python3实现单目标粒子群算法

2023-08-09 10:38:04 63

本文实例为大家分享了python3单目标粒子群算法的具体代码，供大家参考，具体内容如下

关于PSO的基本知识......就说一下算法流程

1)初始化粒子群；

随机设置各粒子的位置和速度，默认粒子的初始位置为粒子最优位置，并根据所有粒子最优位置，选取群体最优位置。

2)判断是否达到迭代次数；

若没有达到，则跳转到步骤3）。否则，直接输出结果。

3)更新所有粒子的位置和速度；

4)计算各粒子的适应度值。

将粒子当前位置的适应度值与粒子最优位置的适应度值进行比较，决定是否更新粒子最优位置；将所有粒子最优位置的适应度值与群体最优位置的适应度值进行比较，决定是否更新群体最优位置。然后，跳转到步骤2）。

直接扔代码......(PS：1.参数动态调节；2.例子是二维的）

首先，是一些准备工作...

#Importlibs
importnumpyasnp
importrandomasrd
importmatplotlib.pyplotasplt

#Constantdefinition
MIN_POS=[-5,-5]#Minimumpositionoftheparticle
MAX_POS=[5,5]#Maximumpositionoftheparticle
MIN_SPD=[-0.5,-0.5]#Minimumspeedoftheparticle
MAX_SPD=[1,1]#Maximumspeedoftheparticle
C1_MIN=0
C1_MAX=1.5
C2_MIN=0
C2_MAX=1.5
W_MAX=1.4
W_MIN=0

然后是PSO类

#Classdefinition
classPSO():
"""
PSOclass
"""

def__init__(self,iters=100,pcount=50,pdim=2,mode='min'):
"""
PSOinitialization
------------------
"""

self.w=None#Inertiafactor
self.c1=None#Learningfactor
self.c2=None#Learningfactor

self.iters=iters#Numberofiterations
self.pcount=pcount#Numberofparticles
self.pdim=pdim#Particledimension
self.gbpos=np.array([0.0]*pdim)#Groupoptimalposition

self.mode=mode#ThemodeofPSO

self.cur_pos=np.zeros((pcount,pdim))#Currentpositionoftheparticle
self.cur_spd=np.zeros((pcount,pdim))#Currentspeedoftheparticle
self.bpos=np.zeros((pcount,pdim))#Theoptimalpositionoftheparticle

self.trace=[]#Recordthefunctionvalueoftheoptimalsolution


definit_particles(self):
"""
init_particlesfunction
-----------------------
"""

#Generatingparticleswarm
foriinrange(self.pcount):
forjinrange(self.pdim):
self.cur_pos[i,j]=rd.uniform(MIN_POS[j],MAX_POS[j])
self.cur_spd[i,j]=rd.uniform(MIN_SPD[j],MAX_SPD[j])
self.bpos[i,j]=self.cur_pos[i,j]

#Initialgroupoptimalposition
foriinrange(self.pcount):
ifself.mode=='min':
ifself.fitness(self.cur_pos[i])self.fitness(self.gbpos):
gbpos=self.cur_pos[i]

deffitness(self,x):
"""
fitnessfunction
----------------
Parameter:
x:
"""

#Objectivefunction
fitval=5*np.cos(x[0]*x[1])+x[0]*x[1]+x[1]**3#min
#Retyrnvalue
returnfitval

defadaptive(self,t,p,c1,c2,w):
"""
"""

#w=0.95#0.9-1.2
ift==0:
c1=0
c2=0
w=0.95
else:
ifself.mode=='min':
#c1
ifself.fitness(self.cur_pos[p])>self.fitness(self.bpos[p]):
c1=C1_MIN+(t/self.iters)*C1_MAX+np.random.uniform(0,0.1)
elifself.fitness(self.cur_pos[p])<=self.fitness(self.bpos[p]):
c1=c1
#c2
ifself.fitness(self.bpos[p])>self.fitness(self.gbpos):
c2=C2_MIN+(t/self.iters)*C2_MAX+np.random.uniform(0,0.1)
elifself.fitness(self.bpos[p])<=self.fitness(self.gbpos):
c2=c2
#w
#c1=C1_MAX-(C1_MAX-C1_MIN)*(t/self.iters)
#c2=C2_MIN+(C2_MAX-C2_MIN)*(t/self.iters)
w=W_MAX-(W_MAX-W_MIN)*(t/self.iters)
elifself.mode=='max':
pass

returnc1,c2,w

defupdate(self,t):
"""
updatefunction
---------------
Notethat:
1.Updateparticleposition
2.Updateparticlespeed
3.Updateparticleoptimalposition
4.Updategroupoptimalposition
"""

#Part1:Traversetheparticleswarm
foriinrange(self.pcount):

#Dynamicparameters
self.c1,self.c2,self.w=self.adaptive(t,i,self.c1,self.c2,self.w)

#Calculatethespeedafterparticleiteration
#Updateparticlespeed
self.cur_spd[i]=self.w*self.cur_spd[i]\
+self.c1*rd.uniform(0,1)*(self.bpos[i]-self.cur_pos[i])\
+self.c2*rd.uniform(0,1)*(self.gbpos-self.cur_pos[i])
forninrange(self.pdim):
ifself.cur_spd[i,n]>MAX_SPD[n]:
self.cur_spd[i,n]=MAX_SPD[n]
elifself.cur_spd[i,n]MAX_POS[n]:
self.cur_pos[i,n]=MAX_POS[n]
elifself.cur_pos[i,n]self.fitness(self.bpos[k]):
self.bpos[k]=self.cur_pos[k]

#Part3:Updategroupoptimalposition
forkinrange(self.pcount):
ifself.mode=='min':
ifself.fitness(self.bpos[k])self.fitness(self.gbpos):
self.gbpos=self.bpos[k]

defrun(self):
"""
runfunction
-------------
"""

#Initializetheparticleswarm
self.init_particles()

#Iteration
fortinrange(self.iters):
#Updateallparticleinformation
self.update(t)
#
self.trace.append(self.fitness(self.gbpos))

然后是main...

defmain():
"""
mainfunction
"""

foriinrange(1):

pso=PSO(iters=100,pcount=50,pdim=2,mode='min')
pso.run()

#
print('='*40)
print('=Optimalsolution:')
print('=x=',pso.gbpos[0])
print('=y=',pso.gbpos[1])
print('=Functionvalue:')
print('=f(x,y)=',pso.fitness(pso.gbpos))
#print(pso.w)
print('='*40)

#
plt.plot(pso.trace,'r')
title='MIN:'+str(pso.fitness(pso.gbpos))
plt.title(title)
plt.xlabel("Numberofiterations")
plt.ylabel("Functionvalues")
plt.show()
#
input('=Pressanykeytoexit...')
print('='*40)
exit()


if__name__=="__main__":

main()

最后是计算结果，完美结束！！！

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

python3实现单目标粒子群算法

热门推荐

随机推荐