计算智能 | 粒子群算法

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

这里我们使用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，一经查实，立即删除！

相关文章

一文带你了解Pytest..

一文带你了解Pytest..

在之前的文章里我们已经学习了Python自带测试框架UnitTest&#xff0c;但是UnitTest具有一定的局限性 这篇文章里我们来学习第三方框架pytest&#xff0c;它在保留了UnitTest框架语法的基础上有着更多的优化处理 下面我们将从以下角度来介绍Pytest&#xff1a; Pytest基本介绍…
阅读更多...
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;今天看到的是后端直接返回一个字符串&#…
阅读更多...
如何搭建企业管理系统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] …
阅读更多...
STL技术概述与入门

STL技术概述与入门

STL技术概述与入门 STL介绍STL六大组件初识容器算法迭代器1. vector存放内置数据类型2. Vector存放自定义数据类型3. Vector容器的嵌套 ✨ 总结 参考博文1&#xff1a;STL技术——STL概述和入门 参考博文2&#xff1a;&#xff1c;C&#xff1e;初识STL —— 标准模板库 STL介…
阅读更多...
SpringBoot配置mysql加密之Druid方式

SpringBoot配置mysql加密之Druid方式

一、导入Druid依赖 <dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.22</version> </dependency>二、生成密文 方式1. 找到存放druid jar包的目录 1-1、在目录…
阅读更多...
【Proteus仿真】【Arduino单片机】电子称重秤

【Proteus仿真】【Arduino单片机】电子称重秤

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真Arduino单片机控制器&#xff0c;使LCD1602液晶&#xff0c;矩阵按键、蜂鸣器、HX711称重模块等。 主要功能&#xff1a; 系统运行后&#xff0c;LCD1602显示HX711称重模块检测重量…
阅读更多...
人工智能与自动驾驶：智能出行时代的未来之路

人工智能与自动驾驶：智能出行时代的未来之路

一、前言 首先&#xff0c;我们先来说下什么是人工智能&#xff0c;人工智能&#xff08;Artificial Intelligence&#xff0c;简称AI&#xff09;是一门研究如何使计算机系统能够模拟、仿真人类智能的技术和科学领域。它涉及构建智能代理&#xff0c;使其能够感知环境、理解和…
阅读更多...
怎么检测DC-DC电源模块稳定性？电源测试系统测试有什么优势？

怎么检测DC-DC电源模块稳定性？电源测试系统测试有什么优势？

DC-DC电源模块稳定性测试 稳定性是衡量DC电源模块的重要指标&#xff0c;电源模块的稳定性直接影响着电源产品和设备的工作稳定性。DC-DC电源模块的稳定性&#xff0c;可以通过检测输出电压、输出电流、负载、波形、效率等参数来评估。 1. 静态测试方法 静态测试是通过直流电压…
阅读更多...
【DataSophon】大数据服务组件之Flink升级

【DataSophon】大数据服务组件之Flink升级

&#x1f984; 个人主页——&#x1f390;开着拖拉机回家_Linux,大数据运维-CSDN博客 &#x1f390;✨&#x1f341; &#x1fa81;&#x1f341;&#x1fa81;&#x1f341;&#x1fa81;&#x1f341;&#x1fa81;&#x1f341; &#x1fa81;&#x1f341;&#x1fa81;&am…
阅读更多...
性能测试QPS+TPS+事务基础知识分析

性能测试QPS+TPS+事务基础知识分析

事务 就是用户某一步或几步操作的集合。不过&#xff0c;我们要保证它有一个完整意义。比如用户对某一个页面的一次请求&#xff0c;用户对某系统的一次登录&#xff0c;淘宝用户对商品的一次确认支付过程。这些我们都可以看作一个事务。那么如何衡量服务器对事务的处理能力。…
阅读更多...
部署智能合约以及 javascript 调用合约函数（Web3项目二实战之三）

部署智能合约以及 javascript 调用合约函数（Web3项目二实战之三）

在上一篇 智能合约是Web3项目的核心要务（Web3项目二实战之二） ，我们已然为项目编写了智能合约，在攥写完智能合约后，该项目将完成了一大部分，剩下无非就是用户界面交互的内容。 然而，在码完了智能合约代码后，起着承前启后关键性的便是，前端界面与智能合约的交互。 智能…
阅读更多...
ansible远程操作主机功能（1）

ansible远程操作主机功能（1）

自动化运维&#xff08;playbook剧本yaml&#xff09; 是基于Python开发的配置管理和应用部署工具。自动化运维中&#xff0c;现在是异军突起。 Ansible能批量配置&#xff0c;部署&#xff0c;管理上千台主机&#xff0c;类似于Xshell的一键输入的工具&#xff0c;不需要每次…
阅读更多...
【IOS开发】传感器 SensorKit

【IOS开发】传感器 SensorKit

资源 官方文档 https://developer.apple.com/search/?qmotion%20graph&typeDocumentation SensorKit 使应用程序能够访问选定的原始数据或系统从传感器处理的指标。 步骤信息加速度计或旋转速率数据用户手腕上手表的配置物理环境中的环境光有关用户日常通勤或旅行的详细…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023