计算智能 | 粒子群算法

一、寻找非线性函数的最大值

这里我们使用python来求解《MATLAB智能算法30个案例分析》种第13章的内容。

我们使用基本粒子群算法寻找非线性函数

f(x)=\frac{sin\sqrt{x^{2}+y^{2}}}{\sqrt{x^{2}+y^{2}}}+e^{\frac{cos2\pi x+2\pi y}{2}}-2.71289

的最大值。

在Python程序中，我们规定粒子数为20，每个粒子的维数为2，算法迭代进化次数为300，学习因子c_{1}=c_{2}=1.49445，个体和速度的最大最小值分别为popmax=2,popmin=-2,Vmax=0.5,Vmin=-0.5。

Python代码如下：

import math
import numpy as np
import random
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=Falseclass PSO:def __init__(self,c1,c2,Vmax,Vmin,popmax,popmin,n,N,m):''':param c1:自我学习因子:param c2:社会学习因子:param Vmax:速度最大值:param Vmin:速度最小值:param popmax:个体最大值:param popmin:个体最小值:param n:粒子的维度:param N:最大迭代步数:param m:种群大小'''self.c1=c1self.c2=c2self.Vmax=Vmaxself.Vmin=Vminself.popmax=popmaxself.popmin=popminself.n=nself.N=Nself.m=mdef function(self,X):''':param X: 粒子的位置:return: 函数值'''f=math.sin(np.sqrt(X[0]**2+X[1]**2))/(np.sqrt(X[0]**2+X[1]**2))+math.exp((math.cos(2*math.pi*X[0])+math.cos(2*math.pi*X[1]))/2)-2.71289return fdef initialpop(self):POP=[]V=[]for i in range(self.m):pop=[random.uniform(self.popmin,self.popmax) for j in range(self.n)]v=[random.uniform(self.Vmin,self.Vmax) for j in range(self.n)]POP.append(pop)V.append(v)return POP,Vdef PSO(self):#产生初始种群POP,V=self.initialpop()#初始化每一个粒子的历史最优解p_i=POP#计算初始种群每个粒子的函数适应值Value=[]for i in range(self.m):value0=self.function(POP[i])Value.append(value0)#初始化种群的历史最优解index_max=np.argmax(Value)    #适应值最大的索引Value_max=Value[index_max]    #最大适应值p_g0=POP[index_max].copy()p_g=[]p_g.append(p_g0)#存储历史最大适应值history=[]history.append(Value_max)#基本粒子群算法for k in range(self.N):#对每个粒子更新速度和位置for i in range(self.m):for j in range(self.n):V[i][j]=V[i][j]+self.c1*(random.uniform(0,1))*(p_i[i][j]-POP[i][j])+self.c2*(random.uniform(0,1))*(p_g[-1][j]-POP[i][j])#界定值的大小if V[i][j]>self.Vmax:V[i][j]=self.Vmaxif V[i][j]<self.Vmin:V[i][j]=self.VminPOP[i][j]=POP[i][j]+0.5*V[i][j]#界定值的大小if POP[i][j]>self.popmax:POP[i][j]=self.popmaxif POP[i][j]<self.popmin:POP[i][j]=self.popmin#对更新后的粒子计算适应度值value=[]for i in range(self.m):value0=self.function(POP[i])value.append(value0)#更新后的最大适应值indexmax=np.argmax(value)valuemax=value[indexmax]#更新并存储历史最大适应值if valuemax>history[-1]:history.append(valuemax)p_g.append(POP[indexmax].copy())else:history.append(history[-1])#更新并存储每个粒子的历史最大适应值和位置for i in range(self.m):if value[i]>Value[i]:p_i[i]=POP[i].copy()Value[i]=value[i]#输出最优解和最优函数值print("函数的最优解：{}\n最优函数值：{}".format(p_g[-1],history[-1]))#绘制函数的优化过程fig=plt.figure(facecolor="snow")plt.plot(range(self.N+1),history,color='plum')plt.title("函数的优化过程")plt.xlabel("代数")plt.ylabel("函数值")plt.grid()plt.show()'''主函数'''
if __name__=="__main__":#最大迭代步数N=300#学习因子c1=1.49445c2=1.49445#种群规模m=20#数据维数n=2#个体和速度的最大最小值popmax=2popmin=-2Vmax=0.5Vmin=-0.5#创建对象pso=PSO(c1,c2, Vmax, Vmin, popmax, popmin, n, N, m)#基本粒子群算法求解pso.PSO()

代码运行结果如下：

因此，函数的最优解为1.0051340460815172，对应的粒子位置为 

\left ( -0.0012701504179166156,-0.0028172028382575515 \right )

PSO算法寻优得到的最优值接近函数实际最优值，说明PSO算法具有较强的函数极值寻优能力。

二、惯性权重\omega的影响

惯性权重\omega体现的是粒子继承先前的速度的能力。一个较大的惯性权重有利于全局搜索，而一个较小的惯性权重则更有利于局部搜索。为了更好地平衡算法的全局搜索和局部搜索能力，可以使用线性递减惯性权重：

\omega \left ( k \right )=\omega _{start}-\frac{\omega _{start}-\omega _{end}}{T_{max}}\times k               (1)

 其中，\omega _{start}为初始惯性权重，\omega _{end}为迭代至最大次数时的惯性权重；k为当前迭代次数；T_{max}为最大迭代次数。一般来说，惯性权值\omega _{start}=0.9,\omega _{end}=0.4时算法性能最好。这样，随着迭代的进行，惯性权重由0.9线性递减至0.4，迭代初期较大的惯性权重使算法保持了较强的全局搜索能力，而迭代后期较小的惯性权重有利于算法进行更精确的局部搜索。线性惯性权重只是一种经验做法，常用的惯性权重的选择还包括以下几种：

\omega \left ( k \right )=\omega _{start}-(\omega_{start}-\omega_{end})(\frac{k}{T_{max}})^{2}         (2)

\omega (k)=\omega_{start}-(\omega_{start}-\omega_{end})[\frac{2k}{T_{max}}-(\frac{k}{T_{max}})^{2}]       (3)

\omega(k)=\omega_{end}(\frac{\omega_{start}}{\omega_{end}})^{1/(1+ck/T_{max})}        (4)

 上面4种\omega的动态变化如下图所示：

绘制上图的python代码如下：

import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=Falsewmax=0.9
wmin=0.4
N=300
X=range(N+1)
Y1=[]
Y2=[]
Y3=[]
Y4=[]
for i in range(N+1):y1=wmax-(wmax-wmin)*i/NY1.append(y1)y2=wmax-(wmax-wmin)*(i/N)**2Y2.append(y2)y3=wmax-(wmax-wmin)*(2*i/N-(i/N)**2)Y3.append(y3)y4=wmin*(wmax/wmin)**(1/(1+100*i/N))Y4.append(y4)fig=plt.figure(facecolor="snow")
plt.plot(X,Y1,color="tomato",label="式（1）")
plt.plot(X,Y2,color="violet",label="式（2）")
plt.plot(X,Y3,color="royalblue",label="式（3）")
plt.plot(X,Y4,color="gold",label="式（4）")
plt.grid()
plt.legend()
plt.title("4种惯性权重w的变化")
plt.xlabel("迭代次数")
plt.ylabel("权重值")
plt.show()

接下来，我们设置种群规模为20，进化300代，每个实验设置运行100次，将100次的平均值作为最终结果，在上述的参数设置下，运行5种对\omega取值方法对函数进行求解，并比较所得解的平均值、失效次数和接近最优值的次数，来分析其收敛精度、收敛速度等性能。

python代码如下：

import math
import numpy as np
import random
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False'''基本粒子群算法'''
class PSO:def __init__(self,c1,c2,Vmax,Vmin,popmax,popmin,n,N,m):''':param c1:自我学习因子:param c2:社会学习因子:param Vmax:速度最大值:param Vmin:速度最小值:param popmax:个体最大值:param popmin:个体最小值:param n:粒子的维度:param N:最大迭代步数:param m:种群大小'''self.c1=c1self.c2=c2self.Vmax=Vmaxself.Vmin=Vminself.popmax=popmaxself.popmin=popminself.n=nself.N=Nself.m=mdef function(self,X):''':param X: 粒子的位置:return: 函数值'''f=math.sin(np.sqrt(X[0]**2+X[1]**2))/(np.sqrt(X[0]**2+X[1]**2))+math.exp((math.cos(2*math.pi*X[0])+math.cos(2*math.pi*X[1]))/2)-2.71289return fdef initialpop(self):POP=[]V=[]for i in range(self.m):pop=[random.uniform(self.popmin,self.popmax) for j in range(self.n)]v=[random.uniform(self.Vmin,self.Vmax) for j in range(self.n)]POP.append(pop)V.append(v)return POP,Vdef PSO(self):#产生初始种群POP,V=self.initialpop()#初始化每一个粒子的历史最优解p_i=POP#计算初始种群每个粒子的函数适应值Value=[]for i in range(self.m):value0=self.function(POP[i])Value.append(value0)#初始化种群的历史最优解index_max=np.argmax(Value)    #适应值最大的索引Value_max=Value[index_max]    #最大适应值p_g0=POP[index_max].copy()p_g=[]p_g.append(p_g0)#存储历史最大适应值history=[]history.append(Value_max)#基本粒子群算法for k in range(self.N):#对每个粒子更新速度和位置for i in range(self.m):for j in range(self.n):V[i][j]=V[i][j]+self.c1*(random.uniform(0,1))*(p_i[i][j]-POP[i][j])+self.c2*(random.uniform(0,1))*(p_g[-1][j]-POP[i][j])#界定值的大小if V[i][j]>self.Vmax:V[i][j]=self.Vmaxif V[i][j]<self.Vmin:V[i][j]=self.VminPOP[i][j]=POP[i][j]+0.5*V[i][j]#界定值的大小if POP[i][j]>self.popmax:POP[i][j]=self.popmaxif POP[i][j]<self.popmin:POP[i][j]=self.popmin#对更新后的粒子计算适应度值value=[]for i in range(self.m):value0=self.function(POP[i])value.append(value0)#更新后的最大适应值indexmax=np.argmax(value)valuemax=value[indexmax]#更新并存储历史最大适应值if valuemax>history[-1]:history.append(valuemax)p_g.append(POP[indexmax].copy())else:history.append(history[-1])#更新并存储每个粒子的历史最大适应值和位置for i in range(self.m):if value[i]>Value[i]:p_i[i]=POP[i].copy()Value[i]=value[i]#返回历史最优值列表return history'''标准粒子群算法'''
class PSO_1(PSO):#继承父类PSO并重写def __init__(self,c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,w):''':param c1:自我学习因子:param c2:社会学习因子:param Vmax:速度最大值:param Vmin:速度最小值:param popmax:个体最大值:param popmin:个体最小值:param n:粒子的维度:param N:最大迭代步数:param m:种群大小:param w:惯性权重'''super().__init__(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m)self.w=wdef PSO_1(self):#产生初始种群POP,V=self.initialpop()#初始化每一个粒子的历史最优解p_i=POP#计算初始种群每个粒子的函数适应值Value=[]for i in range(self.m):value0=self.function(POP[i])Value.append(value0)#初始化种群的历史最优解index_max=np.argmax(Value)    #适应值最大的索引Value_max=Value[index_max]    #最大适应值p_g0=POP[index_max].copy()p_g=[]p_g.append(p_g0)#存储历史最大适应值history=[]history.append(Value_max)#标准粒子群算法for k in range(self.N):#对每个粒子更新速度和位置for i in range(self.m):for j in range(self.n):V[i][j]=self.w*V[i][j]+self.c1*(random.uniform(0,1))*(p_i[i][j]-POP[i][j])+self.c2*(random.uniform(0,1))*(p_g[-1][j]-POP[i][j])#界定值的大小if V[i][j]>self.Vmax:V[i][j]=self.Vmaxif V[i][j]<self.Vmin:V[i][j]=self.VminPOP[i][j]=POP[i][j]+0.5*V[i][j]#界定值的大小if POP[i][j]>self.popmax:POP[i][j]=self.popmaxif POP[i][j]<self.popmin:POP[i][j]=self.popmin#对更新后的粒子计算适应度值value=[]for i in range(self.m):value0=self.function(POP[i])value.append(value0)#更新后的最大适应值indexmax=np.argmax(value)valuemax=value[indexmax]#更新并存储历史最大适应值if valuemax>history[-1]:history.append(valuemax)p_g.append(POP[indexmax].copy())else:history.append(history[-1])#更新并存储每个粒子的历史最大适应值和位置for i in range(self.m):if value[i]>Value[i]:p_i[i]=POP[i].copy()Value[i]=value[i]#返回历史最优值列表return history'''采用线性递减惯性权重的标准粒子群算法'''
class PSO_2(PSO):# 继承父类PSO并重写def __init__(self, c1, c2, Vmax, Vmin, popmax, popmin, n, N, m, wmax,wmin):''':param c1:自我学习因子:param c2:社会学习因子:param Vmax:速度最大值:param Vmin:速度最小值:param popmax:个体最大值:param popmin:个体最小值:param n:粒子的维度:param N:最大迭代步数:param m:种群大小:param wmax:惯性权重的最大值:param wmin:惯性权重的最小值'''super().__init__(c1, c2, Vmax, Vmin, popmax, popmin, n, N, m)self.wmax = wmaxself.wmin=wmin#线性递减的惯性权重def LDIW(self,iter):''':param iter: 迭代的次数值:return: 惯性权重值'''w=self.wmax-(self.wmax-self.wmin)*iter/self.Nreturn wdef PSO_2(self):# 产生初始种群POP, V = self.initialpop()# 初始化每一个粒子的历史最优解p_i = POP# 计算初始种群每个粒子的函数适应值Value = []for i in range(self.m):value0 = self.function(POP[i])Value.append(value0)# 初始化种群的历史最优解index_max = np.argmax(Value)  # 适应值最大的索引Value_max = Value[index_max]  # 最大适应值p_g0 = POP[index_max].copy()p_g = []p_g.append(p_g0)# 存储历史最大适应值history = []history.append(Value_max)# 基本粒子群算法for k in range(self.N):#惯性权重w=self.LDIW(k+1)# 对每个粒子更新速度和位置for i in range(self.m):for j in range(self.n):V[i][j] = w * V[i][j] + self.c1 * (random.uniform(0, 1)) * (p_i[i][j] - POP[i][j]) + self.c2 * (random.uniform(0, 1)) * (p_g[-1][j] - POP[i][j])# 界定值的大小if V[i][j] > self.Vmax:V[i][j] = self.Vmaxif V[i][j] < self.Vmin:V[i][j] = self.VminPOP[i][j] = POP[i][j] + 0.5 * V[i][j]# 界定值的大小if POP[i][j] > self.popmax:POP[i][j] = self.popmaxif POP[i][j] < self.popmin:POP[i][j] = self.popmin# 对更新后的粒子计算适应度值value = []for i in range(self.m):value0 = self.function(POP[i])value.append(value0)# 更新后的最大适应值indexmax = np.argmax(value)valuemax = value[indexmax]# 更新并存储历史最大适应值if valuemax > history[-1]:history.append(valuemax)p_g.append(POP[indexmax].copy())else:history.append(history[-1])# 更新并存储每个粒子的历史最大适应值和位置for i in range(self.m):if value[i] > Value[i]:p_i[i] = POP[i].copy()Value[i] = value[i]#返回历史最优值列表return history'''采用式子（13-5）的惯性权重变化的标准粒子群算法'''
class PSO_3(PSO):# 继承父类PSO并重写def __init__(self, c1, c2, Vmax, Vmin, popmax, popmin, n, N, m, wmax, wmin):''':param c1:自我学习因子:param c2:社会学习因子:param Vmax:速度最大值:param Vmin:速度最小值:param popmax:个体最大值:param popmin:个体最小值:param n:粒子的维度:param N:最大迭代步数:param m:种群大小:param wmax:惯性权重的最大值:param wmin:惯性权重的最小值'''super().__init__(c1, c2, Vmax, Vmin, popmax, popmin, n, N, m)self.wmax = wmaxself.wmin = wmin# 线性递减的惯性权重def w3(self, iter):''':param iter: 迭代的次数值:return: 惯性权重值'''w = self.wmax-(self.wmax-self.wmin)*(iter/self.N)**2return wdef PSO_3(self):# 产生初始种群POP, V = self.initialpop()# 初始化每一个粒子的历史最优解p_i = POP# 计算初始种群每个粒子的函数适应值Value = []for i in range(self.m):value0 = self.function(POP[i])Value.append(value0)# 初始化种群的历史最优解index_max = np.argmax(Value)  # 适应值最大的索引Value_max = Value[index_max]  # 最大适应值p_g0 = POP[index_max].copy()p_g = []p_g.append(p_g0)# 存储历史最大适应值history = []history.append(Value_max)# 标准粒子群算法for k in range(self.N):# 惯性权重w = self.w3(k + 1)# 对每个粒子更新速度和位置for i in range(self.m):for j in range(self.n):V[i][j] = w * V[i][j] + self.c1 * (random.uniform(0, 1)) * (p_i[i][j] - POP[i][j]) + self.c2 * (random.uniform(0, 1)) * (p_g[-1][j] - POP[i][j])# 界定值的大小if V[i][j] > self.Vmax:V[i][j] = self.Vmaxif V[i][j] < self.Vmin:V[i][j] = self.VminPOP[i][j] = POP[i][j] + 0.5 * V[i][j]# 界定值的大小if POP[i][j] > self.popmax:POP[i][j] = self.popmaxif POP[i][j] < self.popmin:POP[i][j] = self.popmin# 对更新后的粒子计算适应度值value = []for i in range(self.m):value0 = self.function(POP[i])value.append(value0)# 更新后的最大适应值indexmax = np.argmax(value)valuemax = value[indexmax]# 更新并存储历史最大适应值if valuemax > history[-1]:history.append(valuemax)p_g.append(POP[indexmax].copy())else:history.append(history[-1])# 更新并存储每个粒子的历史最大适应值和位置for i in range(self.m):if value[i] > Value[i]:p_i[i] = POP[i].copy()Value[i] = value[i]#返回历史最优值列表return history'''采用式子（13-6）的惯性权重变化的标准粒子群算法'''
class PSO_4(PSO):# 继承父类PSO并重写def __init__(self, c1, c2, Vmax, Vmin, popmax, popmin, n, N, m, wmax, wmin):''':param c1:自我学习因子:param c2:社会学习因子:param Vmax:速度最大值:param Vmin:速度最小值:param popmax:个体最大值:param popmin:个体最小值:param n:粒子的维度:param N:最大迭代步数:param m:种群大小:param wmax:惯性权重的最大值:param wmin:惯性权重的最小值'''super().__init__(c1, c2, Vmax, Vmin, popmax, popmin, n, N, m)self.wmax = wmaxself.wmin = wmin# 惯性权重def w4(self, iter):''':param iter: 迭代的次数值:return: 惯性权重值'''w = self.wmax+(self.wmax-self.wmin)*(2*iter/self.N-(iter/self.N)**2)return wdef PSO_4(self):# 产生初始种群POP, V = self.initialpop()# 初始化每一个粒子的历史最优解p_i = POP# 计算初始种群每个粒子的函数适应值Value = []for i in range(self.m):value0 = self.function(POP[i])Value.append(value0)# 初始化种群的历史最优解index_max = np.argmax(Value)  # 适应值最大的索引Value_max = Value[index_max]  # 最大适应值p_g0 = POP[index_max].copy()p_g = []p_g.append(p_g0)# 存储历史最大适应值history = []history.append(Value_max)# 基本粒子群算法for k in range(self.N):# 惯性权重w = self.w4(k + 1)# 对每个粒子更新速度和位置for i in range(self.m):for j in range(self.n):V[i][j] = w * V[i][j] + self.c1 * (random.uniform(0, 1)) * (p_i[i][j] - POP[i][j]) + self.c2 * (random.uniform(0, 1)) * (p_g[-1][j] - POP[i][j])# 界定值的大小if V[i][j] > self.Vmax:V[i][j] = self.Vmaxif V[i][j] < self.Vmin:V[i][j] = self.VminPOP[i][j] = POP[i][j] + 0.5 * V[i][j]# 界定值的大小if POP[i][j] > self.popmax:POP[i][j] = self.popmaxif POP[i][j] < self.popmin:POP[i][j] = self.popmin# 对更新后的粒子计算适应度值value = []for i in range(self.m):value0 = self.function(POP[i])value.append(value0)# 更新后的最大适应值indexmax = np.argmax(value)valuemax = value[indexmax]# 更新并存储历史最大适应值if valuemax > history[-1]:history.append(valuemax)p_g.append(POP[indexmax].copy())else:history.append(history[-1])# 更新并存储每个粒子的历史最大适应值和位置for i in range(self.m):if value[i] > Value[i]:p_i[i] = POP[i].copy()Value[i] = value[i]#返回历史最优值列表return history'''采用式子（13-7）的惯性权重变化的标准粒子群算法'''
class PSO_5(PSO):# 继承父类PSO并重写def __init__(self, c1, c2, Vmax, Vmin, popmax, popmin, n, N, m, wmax, wmin,c):''':param c1:自我学习因子:param c2:社会学习因子:param Vmax:速度最大值:param Vmin:速度最小值:param popmax:个体最大值:param popmin:个体最小值:param n:粒子的维度:param N:最大迭代步数:param m:种群大小:param wmax:惯性权重的最大值:param wmin:惯性权重的最小值:param c:惯性权重计算所需常数'''super().__init__(c1, c2, Vmax, Vmin, popmax, popmin, n, N, m)self.wmax = wmaxself.wmin = wminself.c=c# 惯性权重def w5(self, iter):''':param iter: 迭代的次数值:return: 惯性权重值'''w = self.wmin*(self.wmax/self.wmin)**(1/(1+self.c*iter/self.N))return wdef PSO_5(self):# 产生初始种群POP, V = self.initialpop()# 初始化每一个粒子的历史最优解p_i = POP# 计算初始种群每个粒子的函数适应值Value = []for i in range(self.m):value0 = self.function(POP[i])Value.append(value0)# 初始化种群的历史最优解index_max = np.argmax(Value)  # 适应值最大的索引Value_max = Value[index_max]  # 最大适应值p_g0 = POP[index_max].copy()p_g = []p_g.append(p_g0)# 存储历史最大适应值history = []history.append(Value_max)# 标准粒子群算法for k in range(self.N):# 惯性权重w = self.w5(k + 1)# 对每个粒子更新速度和位置for i in range(self.m):for j in range(self.n):V[i][j] = w * V[i][j] + self.c1 * (random.uniform(0, 1)) * (p_i[i][j] - POP[i][j]) + self.c2 * (random.uniform(0, 1)) * (p_g[-1][j] - POP[i][j])# 界定值的大小if V[i][j] > self.Vmax:V[i][j] = self.Vmaxif V[i][j] < self.Vmin:V[i][j] = self.VminPOP[i][j] = POP[i][j] + 0.5 * V[i][j]# 界定值的大小if POP[i][j] > self.popmax:POP[i][j] = self.popmaxif POP[i][j] < self.popmin:POP[i][j] = self.popmin# 对更新后的粒子计算适应度值value = []for i in range(self.m):value0 = self.function(POP[i])value.append(value0)# 更新后的最大适应值indexmax = np.argmax(value)valuemax = value[indexmax]# 更新并存储历史最大适应值if valuemax > history[-1]:history.append(valuemax)p_g.append(POP[indexmax].copy())else:history.append(history[-1])# 更新并存储每个粒子的历史最大适应值和位置for i in range(self.m):if value[i] > Value[i]:p_i[i] = POP[i].copy()Value[i] = value[i]#返回历史最优值列表return history'''主函数'''
if __name__=="__main__":#最大迭代步数N=300#学习因子c1=1.49445c2=1.49445#种群规模m=20#数据维数n=2#个体和速度的最大最小值popmax=2popmin=-2Vmax=0.5Vmin=-0.5#惯性权重的初值和最终值wmax=0.9wmin=0.4pso1=PSO_1(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax)avg_history1=[0 for i in range(N+1)]best1=[]  #每一次迭代得到的最优历史值for i in range(100):history1=pso1.PSO_1()best1.append(history1[-1])avg_history1=[avg_history1[j]+history1[j] for j in range(N+1)]avg_history1=[avg_history1[i]/100 for i in range(N+1)]pso2=PSO_2(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax,wmin)avg_history2=[0 for i in range(N+1)]best2=[]  #每一次迭代得到的最优历史值for i in range(100):history2=pso2.PSO_2()best2.append(history2[-1])avg_history2=[avg_history2[j]+history2[j] for j in range(N+1)]avg_history2=[avg_history2[i]/100 for i in range(N+1)]pso3=PSO_3(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax,wmin)avg_history3=[0 for i in range(N+1)]best3=[]   #每一次迭代得到的最优历史值for i in range(100):history3=pso3.PSO_3()best3.append(history3[-1])avg_history3=[avg_history3[j]+history3[j] for j in range(N+1)]avg_history3=[avg_history3[i]/100 for i in range(N+1)]pso4=PSO_4(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax,wmin)avg_history4=[0 for i in range(N+1)]best4=[]  #每一次迭代得到的最优历史值for i in range(100):history4=pso4.PSO_4()best4.append(history4[-1])avg_history4=[avg_history4[j]+history4[j] for j in range(N+1)]avg_history4=[avg_history4[i]/100 for i in range(N+1)]pso5=PSO_5(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax,wmin,c=100)avg_history5=[0 for i in range(N+1)]best5=[]  #每一次迭代得到的最优历史值for i in range(100):history5=pso5.PSO_5()best5.append(history5[-1])avg_history5=[avg_history5[j]+history5[j] for j in range(N+1)]avg_history5=[avg_history5[i]/100 for i in range(N+1)]#输出各种结果print("恒定惯性权重：")print("求得的最优值：{}".format(max(best1)))print("平均值：{}".format(avg_history1[-1]))m1=0 #陷入次优解次数n1=0 #接近最优解次数for i in range(100):if best1[i]<=0.8477:m1+=1else:n1+=1print("陷入次优解次数：{}".format(m1))print("接近最优解次数：{}".format(n1))print("------------------------------")print("式（1）：")print("求得的最优值：{}".format(max(best2)))print("平均值：{}".format(avg_history2[-1]))m2=0 #陷入次优解次数n2=0 #接近最优解次数for i in range(100):if best2[i]<=0.8477:m2+=1else:n2+=1print("陷入次优解次数：{}".format(m2))print("接近最优解次数：{}".format(n2))print("------------------------------")print("式（2）：")print("求得的最优值：{}".format(max(best3)))print("平均值：{}".format(avg_history3[-1]))m3=0 #陷入次优解次数n3=0 #接近最优解次数for i in range(100):if best3[i]<=0.8477:m3+=1else:n3+=1print("陷入次优解次数：{}".format(m3))print("接近最优解次数：{}".format(n3))print("------------------------------")print("式（3）：")print("求得的最优值：{}".format(max(best4)))print("平均值：{}".format(avg_history4[-1]))m4=0 #陷入次优解次数n4=0 #接近最优解次数for i in range(100):if best4[i]<=0.8477:m4+=1else:n4+=1print("陷入次优解次数：{}".format(m4))print("接近最优解次数：{}".format(n4))print("------------------------------")print("式（4）：")print("求得的最优值：{}".format(max(best5)))print("平均值：{}".format(avg_history5[-1]))m5=0 #陷入次优解次数n5=0 #接近最优解次数for i in range(100):if best5[i]<=0.8477:m5+=1else:n5+=1print("陷入次优解次数：{}".format(m5))print("接近最优解次数：{}".format(n5))#可视化fig=plt.figure(facecolor="snow")plt.plot(range(N+1),avg_history1,color="tomato",label="恒定惯性权重")plt.plot(range(N+1),avg_history2,color="plum",label="式（1）")plt.plot(range(N+1),avg_history3,color="skyblue",label="式（2）")plt.plot(range(N+1),avg_history4,color="lightgreen",label="式（3）")plt.plot(range(N+1),avg_history5,color="orange",label="式（4）")plt.grid()plt.legend()plt.title("不同惯性权重的收敛曲线")plt.xlabel("迭代次数")plt.ylabel("平均值")plt.show()

 程序运行结果如下：

在本次实验中，我们将0.8477及更小的值视为陷入局部最优的解。

从上述程序运行结果种可以看出，惯性权重\omega不变的粒子群优化算法虽然具有较快的收敛速度，但其后期容易陷入局部最优，求解精度低；而几种\omega动态变化的算法虽然在算法初期收敛稍慢，但在后期局部搜索能力强，利于算法跳出局部最优而求得最优解，提高了算法的求解精度。

式（2）中\omega动态变化方法，前期\omega变化较慢，取值较大，维持了算法的全局搜索能力；后期\omega变化较快，极大地提高了算法的局部寻优能力，从而取得了很好的求解结果。

 

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

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

相关文章

I/O模型及相似概念

I/O模型及相似概念

I/O I/O&#xff08;输入/输出&#xff09;模型是计算机系统中用于处理输入和输出操作的方法。在计算机程序中&#xff0c;I/O操作通常涉及与外部设备&#xff08;如硬盘、网络、键盘、显示器等&#xff09;的数据交互。不同的I/O模型采用不同的方式来处理这些数据交互&#x…
阅读更多...
一文带你了解Pytest..

一文带你了解Pytest..

在之前的文章里我们已经学习了Python自带测试框架UnitTest&#xff0c;但是UnitTest具有一定的局限性 这篇文章里我们来学习第三方框架pytest&#xff0c;它在保留了UnitTest框架语法的基础上有着更多的优化处理 下面我们将从以下角度来介绍Pytest&#xff1a; Pytest基本介绍…
阅读更多...
GDB Tutorial

GDB Tutorial

背景&#xff1a; 最近在重新学习操作系统&#xff0c;顺带重学一下C语言&#xff0c;GDB是C语言进行调试的工具&#xff0c;也就重新学一下GDB&#xff0c;本文没有什么创新只是记录所学内容&#xff0c;供以后翻阅和查询。 一、首先需要安装一系列软件 apt-get install bui…
阅读更多...
按摩师（空间优化的动态规划算法）

按摩师（空间优化的动态规划算法）

一个有名的按摩师会收到源源不断的预约请求&#xff0c;每个预约都可以选择接或不接。在每次预约服务之间要有休息时间&#xff0c;因此她不能接受相邻的预约。给定一个预约请求序列&#xff0c;替按摩师找到最优的预约集合&#xff08;总预约时间最长&#xff09;&#xff0c;…
阅读更多...
Typora+Picgo（正常） 却上传图片失败问题解决思路和办法

Typora+Picgo（正常） 却上传图片失败问题解决思路和办法

报错信息 在typora中粘贴图片时报错&#xff0c;显示上传图片失败&#xff0c;有点奇怪&#xff0c;而我确定我的picgo正常且通过了测试&#xff0c;那我们就去看日志&#xff0c;跟踪排查问题在哪里 我的picgo日志文件路径在 D:\user\username\Application Data\picgo\picg…
阅读更多...
Linux下Netty实现高性能UDP服务

Linux下Netty实现高性能UDP服务

前言 近期笔者基于Netty接收UDP报文进行业务数据统计的功能&#xff0c;因为Netty默认情况下处理UDP收包只能由一个线程负责&#xff0c;无法像TCP协议那种基于主从reactor模型实现多线程监听端口&#xff0c;所以笔者查阅网上资料查看是否有什么方式可以接收UDP收包的性能瓶颈…
阅读更多...
如何实现公网访问本地内网搭建的WBO白板远程协作办公【内网穿透】

如何实现公网访问本地内网搭建的WBO白板远程协作办公【内网穿透】

最近&#xff0c;我发现了一个超级强大的人工智能学习网站。它以通俗易懂的方式呈现复杂的概念&#xff0c;而且内容风趣幽默。我觉得它对大家可能会有所帮助&#xff0c;所以我在此分享。点击这里跳转到网站。 文章目录 前言1. 部署WBO白板2. 本地访问WBO白板3. Linux 安装cp…
阅读更多...
Python的代码c语言可以用吗,python代码大全和用法

Python的代码c语言可以用吗,python代码大全和用法

本篇文章给大家谈谈Python的代码c语言可以用吗&#xff0c;以及python代码大全和用法&#xff0c;希望对各位有所帮助&#xff0c;不要忘了收藏本站喔。 深度学习的图片等比resize后&#xff0c;再把图片反向resize回来&#xff0c;验证通过 import cv2 import numpy as npdef …
阅读更多...
python识别增强静脉清晰度 opencv-python图像处理案例

python识别增强静脉清晰度 opencv-python图像处理案例

一.任务说明 用python实现静脉清晰度提升。 二.代码实现 import cv2 import numpy as npdef enhance_blood_vessels(image):# 调整图像对比度和亮度enhanced_image cv2.convertScaleAbs(image, alpha0.5, beta40)# 应用CLAHE&#xff08;对比度受限的自适应直方图均衡化&…
阅读更多...
Java序列化、反序列化-为什么要使用序列化？Serializable接口的作用？

Java序列化、反序列化-为什么要使用序列化？Serializable接口的作用？

什么是序列化和反序列化&#xff1f; 把对象转换成字节序列把字节序列恢复成对象 结合OSI七层协议模型&#xff0c;序列化和反序列化是在那一层做的&#xff1f; 在OSI七层模型中&#xff0c;序列化工作的层级是表示层。这一层的主要功能包括把应用层的对象转换成一段连续的二进…
阅读更多...
vue中用v-html根据后端返回结果设置样式

vue中用v-html根据后端返回结果设置样式

一、问题 1》今日遇到一个需求&#xff0c;是一个表格列返回状态status&#xff0c;并拥有多种不同颜色。 2》平日里见到的基本都是返回01234......前端用插槽放进去&#xff0c;根据数字去判断显示字段以及设置不同样式&#xff0c;今天看到的是后端直接返回一个字符串&#…
阅读更多...
面试经典150题(27-28)

面试经典150题(27-28)

leetcode 150道题 计划花两个月时候刷完&#xff0c;今天&#xff08;第十三天&#xff09;完成了2道(27-28)150&#xff1a; 今天这两道是真的汗流浃背&#xff01;&#xff01;&#xff01; 27.&#xff08;209. 长度最小的子数组&#xff09;题目描述&#xff1a; 给定一…
阅读更多...
SpringBoot3 Web开发新特性(Problemdetails、函数式Web)

SpringBoot3 Web开发新特性(Problemdetails、函数式Web)

目录 1. Problemdetails2. 函数式Web2.1 场景2.2 主要逻辑2.3 核心对象2.4 示例程序 1. Problemdetails 错误信息返回新格式 package org.springframework.boot.autoconfigure.web.servlet; ......省略部分...... public class WebMvcAutoConfiguration {......省略部分.....…
阅读更多...
Leetcode 2967. Minimum Cost to Make Array Equalindromic

Leetcode 2967. Minimum Cost to Make Array Equalindromic

Leetcode 2967. Minimum Cost to Make Array Equalindromic 1. 解题思路2. 代码实现 题目链接&#xff1a;2967. Minimum Cost to Make Array Equalindromic 1. 解题思路 这一题其实我的思路有点笨&#xff0c;多少有点暴力求解的意思。 显然&#xff0c;如果我们给出全部的…
阅读更多...
PCL 点云半径查找

PCL 点云半径查找

目录 一、 算法概述二、代码实现三、测试示例一、 算法概述 适用：根据已知点坐标，在点云中搜索其指定半径范围内的所有点云。 二、代码实现 #include <iostream> #include <vector> #include <
阅读更多...
如何搭建企业管理系统Odoo并远程访问管理界面【内网穿透】

如何搭建企业管理系统Odoo并远程访问管理界面【内网穿透】

文章目录 前言1. 下载安装Odoo&#xff1a;2. 实现公网访问Odoo本地系统&#xff1a;3. 固定域名访问Odoo本地系统 前言 Odoo是全球流行的开源企业管理套件&#xff0c;是一个一站式全功能ERP及电商平台。 开源性质&#xff1a;Odoo是一个开源的ERP软件&#xff0c;这意味着企…
阅读更多...
【贪心算法】【中位贪心】LeetCode:100123.执行操作使频率分数最大

【贪心算法】【中位贪心】LeetCode:100123.执行操作使频率分数最大

涉及知识点 双指针 C算法&#xff1a;前缀和、前缀乘积、前缀异或的原理、源码及测试用例 包括课程视频 贪心算法 题目 给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。 你可以对数组执行 至多 k 次操作&#xff1a; 从数组中选择一个下标 i &#xff0c;将 nums[i] …
阅读更多...
【云原生之Docker实战】Docker环境下部署群晖DSM系统（详细教程）

【云原生之Docker实战】Docker环境下部署群晖DSM系统（详细教程）

【云原生之Docker实战】Docker环境下部署群晖DSM系统（详细教程） 一、Virtual DSM介绍2.1 Virtual DSM特点二、本地环境介绍2.1 本地环境规划2.2 本次实践介绍三、本地环境检查3.1 检查Docker服务状态3.2 检查Docker版本3.3 检查docker compose 版本四、环境准备工作4.1 检查c…
阅读更多...
STL技术概述与入门

STL技术概述与入门

STL技术概述与入门 STL介绍STL六大组件初识容器算法迭代器1. vector存放内置数据类型2. Vector存放自定义数据类型3. Vector容器的嵌套 ✨ 总结 参考博文1&#xff1a;STL技术——STL概述和入门 参考博文2&#xff1a;&#xff1c;C&#xff1e;初识STL —— 标准模板库 STL介…
阅读更多...
Android开发中pcm格式的音频转换为wav格式之二

Android开发中pcm格式的音频转换为wav格式之二

上篇Android开发中pcm格式的音频转换为wav格式的工具类-CSDN博客文章讲解了pcm格式的音频转换为wav格式&#xff0c;这篇文章主要讲解怎么使用&#xff1a; 我们先来说明一下怎么播放一个wav文件 /*** 播放一个wav文件*/public static void playWav(String filePath){File wav…
阅读更多...
最新文章

Copyright @ 2022~2023