第Python如何實現(xiàn)雞群算法公雞最神氣，原則上可以隨便踱步，只是有的時候注意到其他公雞的時候，會有搶食的想法，相當于隨機抽選一只其他公雞，對其位置產(chǎn)生影響。

母雞最憋屈，一方面要接受公雞的領導，另一方面還要和其他母雞搶食

小雞最無憂無慮，跟著母雞走就是了。

隨著位置關(guān)系的變化，母雞和小雞可能會逐漸遺忘最初的首領，也就是說種群關(guān)系可能會發(fā)生變化。

Python實現(xiàn)雞和雞群

首先，要實現(xiàn)一個雞類，一只雞，有兩種基本屬性，即位置和類別。

importnumpyasnp

fromrandomimportgauss,random

randint=np.random.randint

uniRand=np.random.uniform

classChicken:

def__init__(self,N,xRange,order=0,kind=0):

#生成(N)維參數(shù)

self.x=uniRand(*xRange,(N,))

self.best=np.inf

self.xBest=np.zeros((N,))

self.kind=kind#雞的類別

self.order=order#雞的編號

#設置自己的首領公雞

defsetCock(self,i):

self.cock=i

#設置自己的監(jiān)護母雞

defsetHen(self,i):

self.hen=i

其中kind分為三類，分別是公雞、母雞和小雞。其中，每只母雞都有自己的首領公雞，每只小雞都有自己的監(jiān)護母雞。

order為這只雞在雞群中的編號，主要在雞群中得以體現(xiàn)。

雞群和粒子群有一個很大的區(qū)別，后者說到底只有一個群，而雞群中，每個公雞都有自己的母雞和小雞，相當于一個小群體。但雞和雞之間的關(guān)系，并不取決于雞自己，故而需要在雞群中實現(xiàn)

randint=np.random.randint

classSwarm:

#cNum雞數(shù)，是三個元素的列表，分別是公雞、母雞和小雞數(shù)

#N參數(shù)維度

def__init__(self,cNum,N,xRange):

self.initCs(cNum,N,xRange)

self.bestCS=deepcopy(self.cs)#最佳雞群

self.best=np.inf#全局最優(yōu)值

self.xBest=np.zeros((N,))#全局最優(yōu)參數(shù)

self.N=N

definitCs(self,cNum,N,xRange,vRange):

self.cs=[]

self.cNum=cNum

self.cocks=np.arange(cNum[0])#公雞編號

self.hens=np.arange(cNum[0],cNum[0]+cNum[1])#母雞編號

self.chicks=np.arange(cNum[0]+cNum[1],np.sum(cNum))#小雞編號

kinds=np.repeat([0,1,2],cNum)

foriinrange(sum(cNum)):

self.cs.append(Chicken(N,xRange,vRange,i,kinds[i]))

ifkinds[i]0:

cock=randint(0,cNum[0])

self.cs[i].setCock(cock)

ifkinds[i]1:

hen=randint(cNum[0],cNum[0]+cNum[1])

self.cs[i].setHen(hen)

其中，initCs是初始化雞群的函數(shù)，其中母雞、小雞的首領公雞，小雞的監(jiān)護母雞，都是隨機生成的。

接下來就是算法的核心環(huán)節(jié)，不同的雞要遵循不同的更新規(guī)則，其中，公雞最瀟灑，其下一步位置只取決于自己，以及另一只隨便挑選的公雞。

公雞

記當前這只公雞的編號是i，隨機挑選的公雞編號是j,j=?i，則第i只公雞位置的更新方法為

xi(t+1)=xi(t)sdot;(1+r)

其中，r是通過正態(tài)分布生成的隨機數(shù)，可表示為1sim;N(0,sigma;2)，其中sigma;2為

其中f一般叫做適應因子，相當于將某只雞塞到待搜解的函數(shù)中得到的值。例如要搜索y=2的最小值，如果當前這只雞的位置1.5，那么f=1.52=2.25。epsilon;是一個防止除零錯誤的小量。

但需要注意，上文中所有的x，表示的并非一個標量，而是一個數(shù)組。

其Python實現(xiàn)為

#寫在Swarm類中

defcockStep(self):

foriinself.cocks:

#第j只公雞

j=np.random.randint(self.cNum[0])

ifj==i:

j=(j+1)%self.cNum[0]

#第i只公雞

ci=self.cs[i]

#第j只公雞

cj=self.cs[self.cocks[j]]

sigma=1ifcj.bestci.bestelsenp.exp(

(cj.best-ci.best)/(np.abs(ci.best)+1e-15))

ci.x*=1+gauss(0,sigma)

母雞

設當前母雞編號為i，這只母雞既要追隨首領公雞，又要和其他母雞搶食。

xi(t+1)=xi(t)+k1r1(xcminus;xi)+k2r2(xjminus;xi)

其中，xc為其首領公雞，xj為另一只母雞或者公雞。k1,k2為系數(shù)，其更新邏輯與公雞的k是一樣的，當fi較大時，表示為

代碼實現(xiàn)為

defhenStep(self):

nGuarder=self.cNum[0]+self.cNum[1]-2

foriinself.hens:

guarders=list(self.cocks)+list(self.hens)

c=self.cs[i].cock#首領公雞

guarders.remove(i)

guarders.remove(c)

#隨機生成另一只監(jiān)護雞

j=guarders[np.random.randint(nGuarder)]

ci=self.cs[i]

cj=self.cs[j]

cc=self.cs[c]

k1,k2=random(),random()

ifcc.bestci.best:

k1*=np.exp((ci.best-cc.best)/(np.abs(ci.best)+1e-15))

ifcj.bestci.best:

k2*=np.exp(cj.best-ci.best)

ci.x+=k1*(cc.x-ci.x)+k2*(cj.x-ci.x)

小雞

最后是小雞的更新邏輯，小雞在母雞的周圍找食物，其更新邏輯為

xi(t+1)=xi(t)+r(xh(t)minus;xi(t))

其中，xh為其監(jiān)護母雞，r為隨機數(shù)，算法實現(xiàn)為

defchickStep(self):

foriinself.chicks:

ci=self.cs[i]

ci.x+=2*random()*(self.cs[ci.hen].x-ci.x)

整個雞群

正所謂，算法源于生活而高于生活，自然界里講求輩分，但在雞群算法里，講究的確是實力。如果小雞運氣爆棚，得到了比公雞還厲害的優(yōu)化結(jié)果，那么這只小雞就會進化成公雞。

也就是說，每隔一段時間，雞群里的雞會被重新安排身份，優(yōu)化效果最好的就是頭領公雞，差一點的是監(jiān)護母雞，最差的就只能是小雞了。

defupdate(self):

cn=np.sum(self.cNum)

c1,c2=self.cNum[0],self.cNum[0]+self.cNum[1]

fitness=[self.cs[i].bestforiinrange(cn)]

index=np.argsort(fitness)

self.cocks=index[np.arange(c1)]

self.hens=index[np.arange(c1,c2)]

self.chicks=index[np.arange(c2,cn)]

foriinself.cocks:

self.cs[i].kind=0

foriinself.hens:

self.cs[i].kind=1

foriinself.chicks:

self.cs[i].kind=2

foriinrange(cn):

ifself.cs[i].kind0:

cock=self.cocks[randint(0,c1)]

self.cs[i].setCock(cock)

ifself.cs[i].kind1:

hen=self.hens[randint(c1,c2)]

self.cs[i].setHen(hen)

至此，集群算法的框架算是搭建成功了，接下來就實現(xiàn)最關(guān)鍵的部分，優(yōu)化。

其基本邏輯是，輸入一個待優(yōu)化func，通過將每只雞的位置x帶入到這個函數(shù)中，得到一個判定值，最后通過這個判定值，來不斷更新雞群。

除了這個函數(shù)之外，還需要輸入一些其他參數(shù)，比如整個雞群算法的迭代次數(shù)，以及雞群更新的頻次等等

#func為待優(yōu)化函數(shù)

#N為迭代次數(shù)

#T為雞群更新周期

defoptimize(self,func,N,T,msgT):

forninrange(N):

#計算優(yōu)化參數(shù)

forcinself.cs:

c.best=func(c.x)

#分別更新公雞、母雞和小雞

self.cockStep()

self.henStep()

self.chickStep()

if(n+1)%T==0:

self.update()#每T次更新一次種群

self.printBest(n)

self.printBest(n)

其中，printBest可以將當前最佳結(jié)果打印出來，其形式為

defprintBest(self,n):

fitness=[c.bestforcinself.cs]

best=np.min(fitness)

ind=np.where(fitness==best)[0]

msg=f已經(jīng)迭代{n}次，最佳優(yōu)化結(jié)果為{np.min(fitness)}，參數(shù)為：\n

msg+=,.join([f{x:.6f}forxinself.cs[ind].x])

print(msg)

算法完成之后，當然要找個函數(shù)測試一下，測試函數(shù)為

deftest(xs):

_sum=0.0

foriinrange(len(xs)):

_sum=_sum+np.cos((xs[i]*i)/5)*(i+1)

return_sum

if__name__==__mAIn__:

cNum=[15,20,100]

s=Swarm(cNum,5,(-5,5))

s.optimize(test,20,5)

測試結(jié)果如下

已經(jīng)迭代4次，最佳優(yōu)化結(jié)果為-5.793762423022025，參數(shù)為：

-6.599526,3.117137,5.959538,7.225785,5.204990

已經(jīng)迭代9次，最佳優(yōu)化結(jié)果為-10.61594651972434，參數(shù)為：

-7.003724,-5.589730,0.981409,12.920325,-19.006112

已經(jīng)迭代14