Python优化算法13——飞蛾扑火优化算法(MFO)

科研里面优化算法都用的多,尤其是各种动物园里面的智能仿生优化算法,但是目前都是MATLAB的代码多,python几乎没有什么包,这次把优化算法系列的代码都从底层手写开始。

需要看以前的优化算法文章可以参考:Python优化算法_阡之尘埃的博客-CSDN博客


算法介绍

飞蛾扑火优化算法(Moth-Flame Optimization, MFO)是一种基于自然启发的优化算法,由S. Mirjalili于2015年提出。该算法模拟了飞蛾在夜间围绕光源飞行的行为,这种行为表现为一种螺旋轨迹,类似于飞蛾“扑火”的现象。

基本概念

MFO算法的核心思想是模拟飞蛾围绕光源(火焰)飞行的螺旋路径,其中“飞蛾”代表可能的解,而“火焰”代表当前最优解。通过不断地更新飞蛾的位置来接近火焰,算法能够逐步寻找到全局最优解。

算法流程

  1. 初始化:

  • 随机生成一组初始解,称为飞蛾。

  • 这些解在搜索空间中随机分布。

  1. 适应度评估:

  • 计算每个飞蛾个体的适应度值,根据优化问题的目标函数来评估解的质量。

  1. 排序与选择火焰:

  • 根据适应度值对飞蛾进行排序,选择一部分作为火焰(即当前的优质解)。

  1. 螺旋飞行路径更新:

  • 飞蛾沿着螺旋路径移动接近火焰。螺旋路径由飞蛾和火焰之间的距离以及某个动态参数决定。

  • 这种螺旋飞行确保飞蛾能够探索和开发搜索空间,避免局部最优。

  1. 更新火焰:

  • 在每次迭代中,根据适应度值更新火焰,确保火焰始终代表当前最优解。

  1. 迭代:

  • 重复适应度评估、螺旋路径更新和火焰更新过程,直到达到停止条件,如最大迭代次数或达到满意的解。


优势与应用

MFO算法具有以下优势:

  • 全局搜索能力:通过模拟飞蛾围绕多重火焰的螺旋飞行,MFO有效避免了早熟收敛问题,并有能力在复杂的搜索空间中找到全局最优解。

  • 简单易用:算法结构简单,易于实现,与许多其他优化算法相比,参数设置较少。

由于这些优势,MFO已被应用于各种领域,包括工程优化、功能优化以及机器学习中的参数调优等。与其他优化算法类似,MFO的性能可能会受到具体问题特征和算法参数设置的影响,因此在实际应用中需要针对特定问题进行调整和优化。

原理不多介绍了,直接看代码就好。

代码实现

导入包

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt 
import seaborn as sns
import warnings
import copyplt.rcParams ['font.sans-serif'] ='SimHei'               #显示中文
plt.rcParams ['axes.unicode_minus']=False               #显示负号
warnings.filterwarnings('ignore')
plt.rcParams['font.family'] = 'DejaVu Sans'

只给代码不给使用案例就都是钓鱼的。我这里给出代码,也要给使用案例,先采用一些简单的优化算法常用的测试函数。由于都优化算法需要测试函数,我们先都定义好常见的23个函数:

'''F1函数'''
def F1(X):Results=np.sum(X**2)return Results'''F2函数'''
def F2(X):Results=np.sum(np.abs(X))+np.prod(np.abs(X))return Results'''F3函数'''
def F3(X):dim=X.shape[0]Results=0for i in range(dim):Results=Results+np.sum(X[0:i+1])**2return Results'''F4函数'''
def F4(X):Results=np.max(np.abs(X))return Results'''F5函数'''
def F5(X):dim=X.shape[0]Results=np.sum(100*(X[1:dim]-(X[0:dim-1]**2))**2+(X[0:dim-1]-1)**2)return Results'''F6函数'''
def F6(X):Results=np.sum(np.abs(X+0.5)**2)return Results'''F7函数'''
def F7(X):dim = X.shape[0]Temp = np.arange(1,dim+1,1)Results=np.sum(Temp*(X**4))+np.random.random()return Results'''F8函数'''
def F8(X):Results=np.sum(-X*np.sin(np.sqrt(np.abs(X))))return Results'''F9函数'''
def F9(X):dim=X.shape[0]Results=np.sum(X**2-10*np.cos(2*np.pi*X))+10*dimreturn Results'''F10函数'''
def F10(X):dim=X.shape[0]Results=-20*np.exp(-0.2*np.sqrt(np.sum(X**2)/dim))-np.exp(np.sum(np.cos(2*np.pi*X))/dim)+20+np.exp(1)return Results'''F11函数'''
def F11(X):dim=X.shape[0]Temp=np.arange(1,dim+1,+1)Results=np.sum(X**2)/4000-np.prod(np.cos(X/np.sqrt(Temp)))+1return Results'''F12函数'''
def Ufun(x,a,k,m):Results=k*((x-a)**m)*(x>a)+k*((-x-a)**m)*(x<-a)return Resultsdef F12(X):dim=X.shape[0]Results=(np.pi/dim)*(10*((np.sin(np.pi*(1+(X[0]+1)/4)))**2)+\np.sum((((X[0:dim-1]+1)/4)**2)*(1+10*((np.sin(np.pi*(1+X[1:dim]+1)/4)))**2)+((X[dim-1]+1)/4)**2))+\np.sum(Ufun(X,10,100,4))return Results'''F13函数'''
def Ufun(x,a,k,m):Results=k*((x-a)**m)*(x>a)+k*((-x-a)**m)*(x<-a)return Resultsdef F13(X):dim=X.shape[0]Results=0.1*((np.sin(3*np.pi*X[0]))**2+np.sum((X[0:dim-1]-1)**2*(1+(np.sin(3*np.pi*X[1:dim]))**2))+\((X[dim-1]-1)**2)*(1+(np.sin(2*np.pi*X[dim-1]))**2))+np.sum(Ufun(X,5,100,4))return Results'''F14函数'''
def F14(X):aS=np.array([[-32,-16,0,16,32,-32,-16,0,16,32,-32,-16,0,16,32,-32,-16,0,16,32,-32,-16,0,16,32],\[-32,-32,-32,-32,-32,-16,-16,-16,-16,-16,0,0,0,0,0,16,16,16,16,16,32,32,32,32,32]])bS=np.zeros(25)for i in range(25):bS[i]=np.sum((X-aS[:,i])**6)Temp=np.arange(1,26,1)Results=(1/500+np.sum(1/(Temp+bS)))**(-1)return Results'''F15函数'''
def F15(X):aK=np.array([0.1957,0.1947,0.1735,0.16,0.0844,0.0627,0.0456,0.0342,0.0323,0.0235,0.0246])bK=np.array([0.25,0.5,1,2,4,6,8,10,12,14,16])bK=1/bKResults=np.sum((aK-((X[0]*(bK**2+X[1]*bK))/(bK**2+X[2]*bK+X[3])))**2)return Results'''F16函数'''
def F16(X):Results=4*(X[0]**2)-2.1*(X[0]**4)+(X[0]**6)/3+X[0]*X[1]-4*(X[1]**2)+4*(X[1]**4)return Results'''F17函数'''
def F17(X):Results=(X[1]-(X[0]**2)*5.1/(4*(np.pi**2))+(5/np.pi)*X[0]-6)**2+10*(1-1/(8*np.pi))*np.cos(X[0])+10return Results'''F18函数'''
def F18(X):Results=(1+(X[0]+X[1]+1)**2*(19-14*X[0]+3*(X[0]**2)-14*X[1]+6*X[0]*X[1]+3*X[1]**2))*\(30+(2*X[0]-3*X[1])**2*(18-32*X[0]+12*(X[0]**2)+48*X[1]-36*X[0]*X[1]+27*(X[1]**2)))return Results'''F19函数'''
def F19(X):aH=np.array([[3,10,30],[0.1,10,35],[3,10,30],[0.1,10,35]])cH=np.array([1,1.2,3,3.2])pH=np.array([[0.3689,0.117,0.2673],[0.4699,0.4387,0.747],[0.1091,0.8732,0.5547],[0.03815,0.5743,0.8828]])Results=0for i in range(4):Results=Results-cH[i]*np.exp(-(np.sum(aH[i,:]*((X-pH[i,:]))**2)))return Results'''F20函数'''
def F20(X):aH=np.array([[10,3,17,3.5,1.7,8],[0.05,10,17,0.1,8,14],[3,3.5,1.7,10,17,8],[17,8,0.05,10,0.1,14]])cH=np.array([1,1.2,3,3.2])pH=np.array([[0.1312,0.1696,0.5569,0.0124,0.8283,0.5886],[0.2329,0.4135,0.8307,0.3736,0.1004,0.9991],\[0.2348,0.1415,0.3522,0.2883,0.3047,0.6650],[0.4047,0.8828,0.8732,0.5743,0.1091,0.0381]])Results=0for i in range(4):Results=Results-cH[i]*np.exp(-(np.sum(aH[i,:]*((X-pH[i,:]))**2)))return Results'''F21函数'''
def F21(X):aSH=np.array([[4,4,4,4],[1,1,1,1],[8,8,8,8],[6,6,6,6],[3,7,3,7],\[2,9,2,9],[5,5,3,3],[8,1,8,1],[6,2,6,2],[7,3.6,7,3.6]])cSH=np.array([0.1,0.2,0.2,0.4,0.4,0.6,0.3,0.7,0.5,0.5])Results=0for i in range(5):Results=Results-(np.dot((X-aSH[i,:]),(X-aSH[i,:]).T)+cSH[i])**(-1)return Results'''F22函数'''
def F22(X):aSH=np.array([[4,4,4,4],[1,1,1,1],[8,8,8,8],[6,6,6,6],[3,7,3,7],\[2,9,2,9],[5,5,3,3],[8,1,8,1],[6,2,6,2],[7,3.6,7,3.6]])cSH=np.array([0.1,0.2,0.2,0.4,0.4,0.6,0.3,0.7,0.5,0.5])Results=0for i in range(7):Results=Results-(np.dot((X-aSH[i,:]),(X-aSH[i,:]).T)+cSH[i])**(-1)return Results'''F23函数'''
def F23(X):aSH=np.array([[4,4,4,4],[1,1,1,1],[8,8,8,8],[6,6,6,6],[3,7,3,7],\[2,9,2,9],[5,5,3,3],[8,1,8,1],[6,2,6,2],[7,3.6,7,3.6]])cSH=np.array([0.1,0.2,0.2,0.4,0.4,0.6,0.3,0.7,0.5,0.5])Results=0for i in range(10):Results=Results-(np.dot((X-aSH[i,:]),(X-aSH[i,:]).T)+cSH[i])**(-1)return Results

把他们的参数设置都用字典装起来

Funobject = {'F1': F1,'F2': F2,'F3': F3,'F4': F4,'F5': F5,'F6': F6,'F7': F7,'F8': F8,'F9': F9,'F10': F10,'F11': F11,'F12': F12,'F13': F13,'F14': F14,'F15': F15,'F16': F16,'F17': F17,'F18': F18,'F19': F19,'F20': F20,'F21': F21,'F22': F22,'F23': F23}
Funobject.keys()#维度,搜索区间下界,搜索区间上界,最优值
Fundim={'F1': [30,-100,100],'F2': [30,-10,10],'F3': [30,-100,100],'F4': [30,-10,10],'F5': [30,-30,30],'F6': [30,-100,100],'F7': [30,-1.28,1.28],'F8': [30,-500,500],'F9':[30,-5.12,5.12],'F10': [30,-32,32],'F11': [30,-600,600],'F12': [30,-50,50],'F13': [30,-50,50],'F14': [2,-65,65],'F15':[4,-5,5],'F16': [2,-5,5],'F17':[2,-5,5],'F18': [2,-2,2],'F19': [3,0,1],'F20': [6,0,1],'F21':[4,0,10],'F22': [4,0,10],'F23': [4,0,10]}

Fundim字典里面装的是对应这个函数的 ,维度,搜索区间下界,搜索区间上界。这样写好方便我们去遍历测试所有的函数。


飞蛾扑火优化算法

终于到了算法的主代码阶段了:

import numpy as np
import random
import copydef initialization(pop,ub,lb,dim):''' 种群初始化函数''''''pop:为种群数量dim:每个个体的维度ub:每个维度的变量上边界,维度为[dim,1]lb:为每个维度的变量下边界,维度为[dim,1]X:为输出的种群,维度[pop,dim]'''X = np.zeros([pop,dim]) #声明空间for i in range(pop):for j in range(dim):X[i,j]=(ub[j]-lb[j])*np.random.random()+lb[j] #生成[lb,ub]之间的随机数return Xdef BorderCheck(X,ub,lb,pop,dim):'''边界检查函数''''''dim:为每个个体数据的维度大小X:为输入数据,维度为[pop,dim]ub:为个体数据上边界,维度为[dim,1]lb:为个体数据下边界,维度为[dim,1]pop:为种群数量'''for i in range(pop):for j in range(dim):if X[i,j]>ub[j]:X[i,j] = ub[j]elif X[i,j]<lb[j]:X[i,j] = lb[j]return Xdef CaculateFitness(X,fun):'''计算种群的所有个体的适应度值'''pop = X.shape[0]fitness = np.zeros([pop, 1])for i in range(pop):fitness[i] = fun(X[i, :])return fitnessdef SortFitness(Fit):'''适应度值排序''''''输入为适应度值输出为排序后的适应度值,和索引'''fitness = np.sort(Fit, axis=0)index = np.argsort(Fit, axis=0)return fitness,indexdef SortPosition(X,index):'''根据适应度值对位置进行排序'''Xnew = np.zeros(X.shape)for i in range(X.shape[0]):Xnew[i,:] = X[index[i],:]return Xnewdef MFO(pop, dim, lb, ub, MaxIter, fun):'''飞蛾扑火优化算法''''''输入:pop:为种群数量dim:每个个体的维度ub:为个体上边界信息,维度为[1,dim]lb:为个体下边界信息,维度为[1,dim]fun:为适应度函数接口MaxIter:为最大迭代次数输出:GbestScore:最优解对应的适应度值GbestPositon:最优解Curve:迭代曲线'''r = 2; #参数X = initialization(pop,ub,lb,dim)  # 初始化种群fitness = CaculateFitness(X, fun)  # 计算适应度值fitnessS, sortIndex = SortFitness(fitness)  # 对适应度值排序Xs = SortPosition(X, sortIndex)  # 种群排序后,初始化火焰位置GbestScore = copy.copy(fitnessS[0]) #最优适应度值GbestPositon = np.zeros([1,dim])GbestPositon[0,:] = copy.copy(Xs[0,:])#最优解Curve = np.zeros([MaxIter, 1])for iter in range(MaxIter):print("第"+str(iter)+"次迭代")Flame_no=round(pop-iter*((pop-1)/MaxIter)) #火焰数量更新r = -1 + iter*(-1)/MaxIter # r 线性从-1降到-2#飞蛾扑火行为for i in range(pop):for j in range(dim):if i<= Flame_no:distance_to_flame = np.abs(Xs[i,j] - X[i,j]) #飞蛾与火焰的距离b = 1t = (r - 1)*random.random() + 1          X[i,j] = distance_to_flame*np.exp(b*t)*np.cos(t*2*np.pi) + Xs[i,j] #螺旋飞行else:distance_to_flame = np.abs(Xs[Flame_no,j] - X[i,j]) #飞蛾与火焰的距离b = 1t = (r - 1)*random.random() + 1X[i,j] = distance_to_flame*np.exp(b*t)*np.cos(t*2*np.pi) + Xs[Flame_no,j] #螺旋飞行X = BorderCheck(X, ub, lb, pop, dim)  # 边界检测     fitness = CaculateFitness(X, fun)  # 计算适应度值fitnessS, sortIndex = SortFitness(fitness)  # 对适应度值排序Xs = SortPosition(X, sortIndex)  # 种群排序,作为下一代火焰的位置if fitnessS[0] <= GbestScore:  # 更新全局最优GbestScore = copy.copy(fitnessS[0])GbestPositon[0,:] = copy.copy(Xs[0, :])Curve[iter] = GbestScorereturn GbestScore, GbestPositon, Curve

其实优化算法差不多都是这个流程,边界函数,适应度函数排序,然后寻优过程等等。

OPT_algorithms = {'MFO':MFO}
OPT_algorithms.keys()

简单使用

我们选择F5来测试,先看看F5函数三维的情况:

'''F5绘图函数'''
from mpl_toolkits.mplot3d import Axes3Ddef F5Plot():fig = plt.figure(1) #定义figureax = Axes3D(fig) #将figure变为3dx1=np.arange(-30,30,0.5) #定义x1,范围为[-30,30],间隔为0.5x2=np.arange(-30,30,0.5) #定义x2,范围为[-30,30],间隔为0.5X1,X2=np.meshgrid(x1,x2) #生成网格nSize = x1.shape[0]Z=np.zeros([nSize,nSize])for i in range(nSize):for j in range(nSize):X=[X1[i,j],X2[i,j]] #构造F5输入X=np.array(X) #将格式由list转换为arrayZ[i,j]=F5(X)  #计算F5的值#绘制3D曲面# rstride:行之间的跨度  cstride:列之间的跨度# rstride:行之间的跨度  cstride:列之间的跨度# cmap参数可以控制三维曲面的颜色组合ax.plot_surface(X1, X2, Z, rstride = 1, cstride = 1, cmap = plt.get_cmap('rainbow'))ax.contour(X1, X2, Z, zdir='z', offset=0)#绘制等高线ax.set_xlabel('X1')#x轴说明ax.set_ylabel('X2')#y轴说明ax.set_zlabel('Z')#z轴说明ax.set_title('F5_space')plt.show()F5Plot()

然后我们使用优化算法来寻优,自定义好所有的参数:

#设置参数
pop = 30 #种群数量
MaxIter = 200#最大迭代次数
dim = 30 #维度
lb = -100*np.ones([dim, 1]) #下边界
ub = 100*np.ones([dim, 1])#上边界
#选择适应度函数
fobj = F5
#原始算法
GbestScore,GbestPositon,Curve = MFO(pop,dim,lb,ub,MaxIter,fobj) 
#改进算法print('------原始算法结果--------------')
print('最优适应度值:',GbestScore)
print('最优解:',GbestPositon)

其实f5测试函数的最小值是零。所以可以看到这些结果不为零,而且是非常不为0 。。。不符合最优的情况的。所以这个算法真的不咋地。。。

自己使用解决实际问题的时候只需要替换fobj这个目标函数的参数就可以了。

这个函数就如同上面所有的自定义的测试函数一样,你只需要定义输入的x,经过1系列实际问题的计算逻辑,返回的适应度值就可以。

绘制适应度曲线

#绘制适应度曲线
plt.figure(figsize=(6,2.7),dpi=128)
plt.semilogy(Curve,'b-',linewidth=2)
plt.xlabel('Iteration',fontsize='medium')
plt.ylabel("Fitness",fontsize='medium')
plt.grid()
plt.title('MFO',fontsize='large')
plt.legend(['MFO'], loc='upper right')
plt.show()

好家伙,这个训练过程何止是没收敛,简直就是没变化,这个算法是真的很劣质。。。

其实看到这里差不多就可以去把这个优化算法的函数拿去使用了,演示结束了,但是由于我们这里还需要对它的性能做一些测试,我们会把它在所有的测试函数上都跑一遍,这个时间可能是有点久的。


所有函数都测试一下

准备存储评价结果的数据框

functions = list(Funobject.keys())
algorithms = list(OPT_algorithms.keys())
columns = ['Mean', 'Std', 'Best', 'Worth']
index = pd.MultiIndex.from_product([functions, algorithms], names=['function_name', 'Algorithm_name'])
df_eval = pd.DataFrame(index=index, columns=columns)
df_eval.head()

索引和列名称都建好了,现在就是一个个跑,把值放进去就行了。

准备存储迭代图的数据框

df_Curve=pd.DataFrame(columns=index)
df_Curve

自定义训练函数

#定义训练函数
def train_fun(fobj_name=None,opt_algo_name=None, pop=30,MaxIter=200,Iter=30,show_fit=False):fundim=Fundim[fobj_name]  ; fobj=Funobject[fobj_name]dim=fundim[0]lb = fundim[1]*np.ones([dim, 1]) ; ub = fundim[2]*np.ones([dim, 1])opt_algo=OPT_algorithms[opt_algo_name]GbestScore_one=np.zeros([Iter])GbestPositon_one=np.zeros([Iter,dim])Curve_one=np.zeros([Iter,MaxIter])for i in range(Iter):GbestScore_one[i],GbestPositon_one[i,:],Curve_oneT =opt_algo(pop,dim,lb,ub,MaxIter,fobj)Curve_one[i,:]=Curve_oneT.Toneal_Mean=np.mean(GbestScore_one) #计算平均适应度值oneal_Std=np.std(GbestScore_one)#计算标准差oneal_Best=np.min(GbestScore_one)#计算最优值oneal_Worst=np.max(GbestScore_one)#计算最差值oneal_MeanCurve=Curve_one.mean(axis=0) #求平均适应度曲线#储存结果df_eval.loc[(fobj_name, opt_algo_name), :] = [oneal_Mean,oneal_Std, oneal_Best,oneal_Worst]df_Curve.loc[:,(fobj_name,opt_algo_name)]=oneal_MeanCurve#df_Curve[df_Curve.columns[(fobj_name,opt_algo_name)]] = oneal_MeanCurveif show_fit:print(f'{fobj_name}函数的{opt_algo_name}算法的平均适应度值是{oneal_Mean},标准差{oneal_Std},最优值{oneal_Best},最差值{oneal_Worst}')

训练测试

#设置参数
pop = 30#种群数量
MaxIter = 100 #代次数
Iter = 30 #运行次数

计算,遍历所有的测试函数

#所有函数,所有算法全部一次性计算
for fobj_name in list(Funobject.keys()):for opt_algo_name in OPT_algorithms.keys():try:train_fun(fobj_name=fobj_name,opt_algo_name=opt_algo_name, pop=pop,MaxIter=MaxIter,Iter=Iter)print(f'{fobj_name}的{opt_algo_name}算法完成')except Exception as e: # 使用 except 来捕获错误print(f'{fobj_name}的{opt_algo_name}算法报错了:{e}') # 打印错误信息

查看计算出来的评价指标


df_eval

由于这里大部分的测试函数最优值都是零,我们可以看到。MFO在很多函数上基本是根本找不到最优值的,这个算法性能真的真的很差。

画出迭代图

colors = ['darkorange', 'limegreen', 'lightpink', 'deeppink', 'red', 'cornflowerblue', 'grey']
markers = ['^', 'D', 'o', '*', 'X', 'p', 's']def plot_log_line(df_plot, fobj_name, step=10, save=False):plt.figure(figsize=(6, 3), dpi=128)for column, color, marker in zip(df_plot.columns, colors, markers):plt.semilogy(df_plot.index[::step], df_plot[column][::step].to_numpy(), color=color, marker=marker, label=column, markersize=4, alpha=0.7)plt.xlabel('Iterations')plt.ylabel('f')plt.legend(loc='best', fontsize=8)if save:plt.savefig(f'./图片/{fobj_name}不同迭代图.png', bbox_inches='tight')plt.show()# 使用示例
# plot_log_line(your_dataframe, 'example_plot')
for fobj_name in df_Curve.columns.get_level_values(0).unique():df1=df_Curve[fobj_name]print(f'{fobj_name}的不同算法效果对比:')plot_log_line(df1,fobj_name,5,False)   #保存图片-True

这里可以打印它在每一个测试函数上的迭代图,可以自己具体仔细观察。。。当然观察后这个算法是真的好垃圾。。。 也不知道是代码问题还是啥,完全不如我前面的SMA, SSA,CS等其他的优化算法。


后面还有更多的优化算法,等我有空都写完。其实文章最核心的还是优化算法的函数那一块儿,别的代码都是用来测试它的性能的

当然需要本次案例的全部代码文件的还是可以参考:飞蛾扑火优化算法

创作不易,看官觉得写得还不错的话点个关注和赞吧,本人会持续更新python数据分析领域的代码文章~(需要定制类似的代码可私信)

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/408595.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

用4种不同视角理解矩阵乘法

目录 1. 背景 2. 线性方程组视角&#xff08;向量点积视角&#xff09; 3. 列向量观点视角 4. 向量变换视角&#xff08;矩阵函数&#xff09; 5. 坐标变换视角 1. 背景 矩阵诞生于线性方程组的求解&#xff0c;最基本的运算方法来自于高斯消元法&#xff0c;所以矩阵整个…

Linux 离线安装docker和docker-compose

前言 公司有 docker 和 docker-compose 离线包安装部署的需求&#xff0c;本文应运而生撰写时间&#xff1a;2024-06-07&#xff08;初稿&#xff09; 1 应用版本 docker&#xff1a;20.10.7, build f0df350docker-compose&#xff1a;1.25.1 2 物料准备 服务器账号/密码d…

[数据集][目标检测]电力场景输电线防震锤检测数据集VOC+YOLO格式2721张2类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;2721 标注数量(xml文件个数)&#xff1a;2721 标注数量(txt文件个数)&#xff1a;2721 标注…

《javaEE篇》--线程池

线程池是什么 线程的诞生是因为进程创建和销毁的成本太大&#xff0c;但是也是相对而言&#xff0c;如果频繁的创建和销毁线程那么这个成本就不能忽略了。 一般有两种方法来进一步提高效率&#xff0c;一种是协程(这里不多做讨论),另一种就是线程池 假如说有一个学校食堂窗口…

智能控制,高效节能。ZLG致远电子能源智慧管理解决方案

面对楼宇及建筑群能源管理与设备控制的复杂需求&#xff0c;ZLG致远电子推出了一套能源智慧管理解决方案。该方案集设备管理、任务调度和数据可视化于一体&#xff0c;不仅实现数据的实时监控与分析&#xff0c;还助力系统节能降耗。 ZLG致远电子能源智慧管理解决方案 在ZLG致…

ShareSDK 企业微信

本篇文档主要讲解如何使用企业微信并进行分享和授权。 创建应用 登录企业微信并通过企业认证。选择应用管理 > 应用 >创建应用。编辑应用信息。配置授权登录信息。 以下为创建过程示例&#xff0c;图中信息仅为示例&#xff0c;创建时请按照真实信息填写&#xff0c;否…

如何查看ubuntu版本

在当前的技术环境中&#xff0c;了解操作系统的具体版本对于用户来说至关重要。这不仅能确保软件兼容性&#xff0c;还有助于进行系统管理和故障排查。对于使用Ubuntu系统的用户来说&#xff0c;有几种不同的方法可以查看当前系统的版本。下面将详细介绍如何查看您的Ubuntu系统…

Spring Boot(快速上手)

Spring Boot 零、环境配置 1. 创建项目 2. 热部署 添加依赖&#xff1a; <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><optional>true</optional> </dependency&…

polarctf靶场[WEB]cookie欺骗、upload、签到

[web]cookie欺骗 考点&#xff1a;cookie值 工具&#xff1a;Burp Suite抓包 根据题目提示&#xff0c;cookie欺骗&#xff0c;所以要在cookie值寻找关键 进入网页之后&#xff0c;说只有admin用户才能得到flag&#xff0c;而我们此时只属于普通访客 我们查看cookie值&…

「Python程序设计」基本数据类型:字符串

​在python的程序设计过程中&#xff0c;字符串是需要经常处理的变量类型。字符串在程序中的存储方式&#xff0c;类似于一维数组&#xff0c;每个字符占据数组中的一个单元格。 字符串可以存储字符类型的变量&#xff0c;即使是数字类型&#xff0c;也可以通过字符串来进行存…

vue3+vite配置环境变量实现开发、测试、生产的区分

文章目录 一、为什么需要区分 (dev)、测试 (test) 和生产 (prod) 环境二、vue3的项目如何通过配置方式区分不同的环境1、创建不同环境的.env文件2、在不同的.env文件中配置相应的环境变量1&#xff09;.env.develoment2&#xff09;.env.test3&#xff09;.env.production 3、在…

Git之git stash高级用法(五十)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 新书发布&#xff1a;《Android系统多媒体进阶实战》&#x1f680; 优质专栏&#xff1a; Audio工程师进阶系列…

Tomcat 部署与优化

目录 tomcat 简介 tomcat 构件 1. Web 容器 2. Servlet 容器 3.Jsp容器 tomcat 核心组件 Connector Container Service 子容器 总结 tomcat 部署 tomcat请求过程 tomcat部署 tomcat 优化 tomcat配置文件参数优化 JVM优化 tomcat 简介 提到Tomcat 就想到 java&a…

RISC-V vector(1) --- vector的引入与register说明

Vector相较于SIMD的优势 这两种实现方案&#xff0c;都是为了实现数据级并行性&#xff08;存在大量的数据可供程序同时计算&#xff09;&#xff1b; SIMD&#xff08;Single Instruction Multiple Data&#xff09; SIMD是将数据宽度和操作类型&#xff0c;都放在了指令中&a…

http应用层协议

一、万维网 用来存放各种资源的网络。 1、如何在万维网中表示一个资源 ? url ——统一资源定位符&#xff1b; 形式&#xff1a; <协议>://<主机>:<端口>/<路径>&#xff1b; <主机>:<端口>/<路径> //表示了资源所在的…

这个TOP 100 AI应用榜单,包含了所有你需要的使用场景(一)

大家好&#xff0c;我是木易&#xff0c;一个持续关注AI领域的互联网技术产品经理&#xff0c;国内Top2本科&#xff0c;美国Top10 CS研究生&#xff0c;MBA。我坚信AI是普通人变强的“外挂”&#xff0c;专注于分享AI全维度知识&#xff0c;包括但不限于AI科普&#xff0c;AI工…

【Unity3D小技巧】Unity3D中实现FPS数值显示功能实现

推荐阅读 CSDN主页GitHub开源地址Unity3D插件分享简书地址QQ群&#xff1a;398291828 大家好&#xff0c;我是佛系工程师☆恬静的小魔龙☆&#xff0c;不定时更新Unity开发技巧&#xff0c;觉得有用记得一键三连哦。 一、前言 很简单也很使用的小技巧&#xff0c;就是在Unity…

【系统分析师】-综合知识-计算机系统基础

1、流水线的吞吐率是指流水线在单位时间里所完成的任务数或输出的结果数。设某流水线有 5 段&#xff0c;有 1 段的时间为 2ns &#xff0c;另外 4 段的每段时间为 1ns&#xff0c;利用此流水线完成 100 个任务的吞吐率约为&#xff08;16&#xff09;个/s 。 2、矢量图像通过使…

[NeurIPS 2024] Self-Refine: Iterative Refinement with Self-Feedback

Contents TL;DRReferences TL;DR 通过让 LLM 生成 feedback 不断 refine 自身的回答&#xff0c;可以提升回答效果&#xff0c;但也会带来不可忽视的推理开销 References Madaan, Aman, et al. “Self-refine: Iterative refinement with self-feedback.” Advances in Neura…

广州网站制作seo优化技巧

随着互联网的迅速发展&#xff0c;越来越多的企业意识到网站对于品牌推广和销售的重要性。而在众多网站中&#xff0c;如何让自己的站点脱颖而出&#xff0c;是每个网站管理员和SEO从业者必须面对的挑战。特别是对于广州这样一个经济繁荣、竞争激烈的城市&#xff0c;网站制作和…