哈尔滨在线制作网站,酒店网站开发需求文档,邮箱地址注册入口,手机制作logo神器一、寻找非线性函数的最大值
这里我们使用python来求解《MATLAB智能算法30个案例分析》种第13章的内容。
我们使用基本粒子群算法寻找非线性函数 的最大值。
在Python程序中#xff0c;我们规定粒子数为20#xff0c;每个粒子的维数为2#xff0c;算法迭代进化次数为300我们规定粒子数为20每个粒子的维数为2算法迭代进化次数为300学习因子个体和速度的最大最小值分别为,。
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.c1c1self.c2c2self.VmaxVmaxself.VminVminself.popmaxpopmaxself.popminpopminself.nnself.NNself.mmdef function(self,X)::param X: 粒子的位置:return: 函数值fmath.sin(np.sqrt(X[0]**2X[1]**2))/(np.sqrt(X[0]**2X[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,Vself.initialpop()#初始化每一个粒子的历史最优解p_iPOP#计算初始种群每个粒子的函数适应值Value[]for i in range(self.m):value0self.function(POP[i])Value.append(value0)#初始化种群的历史最优解index_maxnp.argmax(Value) #适应值最大的索引Value_maxValue[index_max] #最大适应值p_g0POP[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):value0self.function(POP[i])value.append(value0)#更新后的最大适应值indexmaxnp.argmax(value)valuemaxvalue[indexmax]#更新并存储历史最大适应值if valuemaxhistory[-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]))#绘制函数的优化过程figplt.figure(facecolorsnow)plt.plot(range(self.N1),history,colorplum)plt.title(函数的优化过程)plt.xlabel(代数)plt.ylabel(函数值)plt.grid()plt.show()主函数
if __name____main__:#最大迭代步数N300#学习因子c11.49445c21.49445#种群规模m20#数据维数n2#个体和速度的最大最小值popmax2popmin-2Vmax0.5Vmin-0.5#创建对象psoPSO(c1,c2, Vmax, Vmin, popmax, popmin, n, N, m)#基本粒子群算法求解pso.PSO()
代码运行结果如下 因此函数的最优解为1.0051340460815172对应的粒子位置为 PSO算法寻优得到的最优值接近函数实际最优值说明PSO算法具有较强的函数极值寻优能力。
二、惯性权重的影响
惯性权重体现的是粒子继承先前的速度的能力。一个较大的惯性权重有利于全局搜索而一个较小的惯性权重则更有利于局部搜索。为了更好地平衡算法的全局搜索和局部搜索能力可以使用线性递减惯性权重 (1) 其中为初始惯性权重为迭代至最大次数时的惯性权重k为当前迭代次数为最大迭代次数。一般来说惯性权值时算法性能最好。这样随着迭代的进行惯性权重由0.9线性递减至0.4迭代初期较大的惯性权重使算法保持了较强的全局搜索能力而迭代后期较小的惯性权重有利于算法进行更精确的局部搜索。线性惯性权重只是一种经验做法常用的惯性权重的选择还包括以下几种 (2) (3) (4) 上面4种的动态变化如下图所示 绘制上图的python代码如下
import matplotlib.pyplot as plt
plt.rcParams[font.sans-serif][SimHei]
plt.rcParams[axes.unicode_minus]Falsewmax0.9
wmin0.4
N300
Xrange(N1)
Y1[]
Y2[]
Y3[]
Y4[]
for i in range(N1):y1wmax-(wmax-wmin)*i/NY1.append(y1)y2wmax-(wmax-wmin)*(i/N)**2Y2.append(y2)y3wmax-(wmax-wmin)*(2*i/N-(i/N)**2)Y3.append(y3)y4wmin*(wmax/wmin)**(1/(1100*i/N))Y4.append(y4)figplt.figure(facecolorsnow)
plt.plot(X,Y1,colortomato,label式1)
plt.plot(X,Y2,colorviolet,label式2)
plt.plot(X,Y3,colorroyalblue,label式3)
plt.plot(X,Y4,colorgold,label式4)
plt.grid()
plt.legend()
plt.title(4种惯性权重w的变化)
plt.xlabel(迭代次数)
plt.ylabel(权重值)
plt.show()
接下来我们设置种群规模为20进化300代每个实验设置运行100次将100次的平均值作为最终结果在上述的参数设置下运行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]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.c1c1self.c2c2self.VmaxVmaxself.VminVminself.popmaxpopmaxself.popminpopminself.nnself.NNself.mmdef function(self,X)::param X: 粒子的位置:return: 函数值fmath.sin(np.sqrt(X[0]**2X[1]**2))/(np.sqrt(X[0]**2X[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,Vself.initialpop()#初始化每一个粒子的历史最优解p_iPOP#计算初始种群每个粒子的函数适应值Value[]for i in range(self.m):value0self.function(POP[i])Value.append(value0)#初始化种群的历史最优解index_maxnp.argmax(Value) #适应值最大的索引Value_maxValue[index_max] #最大适应值p_g0POP[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):value0self.function(POP[i])value.append(value0)#更新后的最大适应值indexmaxnp.argmax(value)valuemaxvalue[indexmax]#更新并存储历史最大适应值if valuemaxhistory[-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.wwdef PSO_1(self):#产生初始种群POP,Vself.initialpop()#初始化每一个粒子的历史最优解p_iPOP#计算初始种群每个粒子的函数适应值Value[]for i in range(self.m):value0self.function(POP[i])Value.append(value0)#初始化种群的历史最优解index_maxnp.argmax(Value) #适应值最大的索引Value_maxValue[index_max] #最大适应值p_g0POP[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):value0self.function(POP[i])value.append(value0)#更新后的最大适应值indexmaxnp.argmax(value)valuemaxvalue[indexmax]#更新并存储历史最大适应值if valuemaxhistory[-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.wminwmin#线性递减的惯性权重def LDIW(self,iter)::param iter: 迭代的次数值:return: 惯性权重值wself.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):#惯性权重wself.LDIW(k1)# 对每个粒子更新速度和位置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.cc# 惯性权重def w5(self, iter)::param iter: 迭代的次数值:return: 惯性权重值w self.wmin*(self.wmax/self.wmin)**(1/(1self.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__:#最大迭代步数N300#学习因子c11.49445c21.49445#种群规模m20#数据维数n2#个体和速度的最大最小值popmax2popmin-2Vmax0.5Vmin-0.5#惯性权重的初值和最终值wmax0.9wmin0.4pso1PSO_1(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax)avg_history1[0 for i in range(N1)]best1[] #每一次迭代得到的最优历史值for i in range(100):history1pso1.PSO_1()best1.append(history1[-1])avg_history1[avg_history1[j]history1[j] for j in range(N1)]avg_history1[avg_history1[i]/100 for i in range(N1)]pso2PSO_2(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax,wmin)avg_history2[0 for i in range(N1)]best2[] #每一次迭代得到的最优历史值for i in range(100):history2pso2.PSO_2()best2.append(history2[-1])avg_history2[avg_history2[j]history2[j] for j in range(N1)]avg_history2[avg_history2[i]/100 for i in range(N1)]pso3PSO_3(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax,wmin)avg_history3[0 for i in range(N1)]best3[] #每一次迭代得到的最优历史值for i in range(100):history3pso3.PSO_3()best3.append(history3[-1])avg_history3[avg_history3[j]history3[j] for j in range(N1)]avg_history3[avg_history3[i]/100 for i in range(N1)]pso4PSO_4(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax,wmin)avg_history4[0 for i in range(N1)]best4[] #每一次迭代得到的最优历史值for i in range(100):history4pso4.PSO_4()best4.append(history4[-1])avg_history4[avg_history4[j]history4[j] for j in range(N1)]avg_history4[avg_history4[i]/100 for i in range(N1)]pso5PSO_5(c1,c2,Vmax,Vmin,popmax,popmin,n,N,m,wmax,wmin,c100)avg_history5[0 for i in range(N1)]best5[] #每一次迭代得到的最优历史值for i in range(100):history5pso5.PSO_5()best5.append(history5[-1])avg_history5[avg_history5[j]history5[j] for j in range(N1)]avg_history5[avg_history5[i]/100 for i in range(N1)]#输出各种结果print(恒定惯性权重)print(求得的最优值{}.format(max(best1)))print(平均值{}.format(avg_history1[-1]))m10 #陷入次优解次数n10 #接近最优解次数for i in range(100):if best1[i]0.8477:m11else:n11print(陷入次优解次数{}.format(m1))print(接近最优解次数{}.format(n1))print(------------------------------)print(式1)print(求得的最优值{}.format(max(best2)))print(平均值{}.format(avg_history2[-1]))m20 #陷入次优解次数n20 #接近最优解次数for i in range(100):if best2[i]0.8477:m21else:n21print(陷入次优解次数{}.format(m2))print(接近最优解次数{}.format(n2))print(------------------------------)print(式2)print(求得的最优值{}.format(max(best3)))print(平均值{}.format(avg_history3[-1]))m30 #陷入次优解次数n30 #接近最优解次数for i in range(100):if best3[i]0.8477:m31else:n31print(陷入次优解次数{}.format(m3))print(接近最优解次数{}.format(n3))print(------------------------------)print(式3)print(求得的最优值{}.format(max(best4)))print(平均值{}.format(avg_history4[-1]))m40 #陷入次优解次数n40 #接近最优解次数for i in range(100):if best4[i]0.8477:m41else:n41print(陷入次优解次数{}.format(m4))print(接近最优解次数{}.format(n4))print(------------------------------)print(式4)print(求得的最优值{}.format(max(best5)))print(平均值{}.format(avg_history5[-1]))m50 #陷入次优解次数n50 #接近最优解次数for i in range(100):if best5[i]0.8477:m51else:n51print(陷入次优解次数{}.format(m5))print(接近最优解次数{}.format(n5))#可视化figplt.figure(facecolorsnow)plt.plot(range(N1),avg_history1,colortomato,label恒定惯性权重)plt.plot(range(N1),avg_history2,colorplum,label式1)plt.plot(range(N1),avg_history3,colorskyblue,label式2)plt.plot(range(N1),avg_history4,colorlightgreen,label式3)plt.plot(range(N1),avg_history5,colororange,label式4)plt.grid()plt.legend()plt.title(不同惯性权重的收敛曲线)plt.xlabel(迭代次数)plt.ylabel(平均值)plt.show()程序运行结果如下 在本次实验中我们将0.8477及更小的值视为陷入局部最优的解。
从上述程序运行结果种可以看出惯性权重不变的粒子群优化算法虽然具有较快的收敛速度但其后期容易陷入局部最优求解精度低而几种动态变化的算法虽然在算法初期收敛稍慢但在后期局部搜索能力强利于算法跳出局部最优而求得最优解提高了算法的求解精度。
式2中动态变化方法前期变化较慢取值较大维持了算法的全局搜索能力后期变化较快极大地提高了算法的局部寻优能力从而取得了很好的求解结果。
