Python怎么實現雞群算法

本文小編為大家詳細介紹“Python怎么實現雞群算法”，內容詳細，步驟清晰，細節處理妥當，希望這篇“Python怎么實現雞群算法”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學習新知識吧。

算法簡介

雞群算法，縮寫為CSO(Chicken Swarm Optimization)，盡管具備所謂仿生學的背景，但實質上是粒子群算法的一個變體。

簡單來說，粒子群就是一群粒子，每個粒子都有自己的位置和速度，而且每個粒子都要受到最佳粒子的吸引，除了這兩條規則之外，粒子之間完全平等，彼此之間除了位置和速度之外，完全相等。

當然，粒子群算法本身也是有仿生學背景的，據說靈感來自于鳥群覓食，這個當然不重要，無非是一群平等的粒子變成了一群平等的鳥罷了。

而雞群算法，則是為這些粒子，或者這些鳥，添加了不同的身份特征，使得彼此之間不再等同。

雞群中至少有三個階層，分別是公雞、母雞和小雞，每只雞都有其位置和速度。但區別之處在于，

• 公雞最神氣，原則上可以隨便踱步，只是有的時候注意到其他公雞的時候，會有搶食的想法，相當于隨機抽選一只其他公雞，對其位置產生影響。

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

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

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

Python實現雞和雞群

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

import numpy as np
from random import gauss, random
randint = np.random.randint
uniRand = np.random.uniform

class Chicken:
    def __init__(self, N, xRange, order=0, kind=0):
        # 生成(N)維參數
        self.x = uniRand(*xRange, (N,))
        self.best = np.inf
        self.xBest = np.zeros((N,))
        self.kind = kind            # 雞的類別
        self.order = order          # 雞的編號
    
    # 設置自己的首領公雞
    def setCock(self, i):
        self.cock = i

    # 設置自己的監護母雞
    def setHen(self, i):
        self.hen = i

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

order為這只雞在雞群中的編號，主要在雞群中得以體現。

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

randint = np.random.randint
class Swarm:
    # cNum 雞數，是三個元素的列表，分別是公雞、母雞和小雞數
    # N參數維度
    def __init__(self, cNum, N, xRange):
        self.initCs(cNum, N, xRange)
        self.bestCS = deepcopy(self.cs)     #最佳雞群
        self.best = np.inf  #全局最優值
        self.xBest = np.zeros((N,)) #全局最優參數
        self.N = N

    def initCs(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)
        for i in range(sum(cNum)):
            self.cs.append(Chicken(N,xRange, vRange, i, kinds[i]))
            if kinds[i] > 0:
                cock = randint(0, cNum[0])
                self.cs[i].setCock(cock)
            if kinds[i] > 1:
                hen = randint(cNum[0], cNum[0]+cNum[1])
                self.cs[i].setHen(hen)

其中，initCs是初始化雞群的函數，其中母雞、小雞的首領公雞，小雞的監護母雞，都是隨機生成的。

雞群更新

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

公雞

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

x_i(t+1)=x_i(t)⋅(1+r)

其中，r是通過正態分布生成的隨機數，可表示為1∼N(0,σ²)，其中σ²為

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

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

其Python實現為

# 寫在Swarm類中
def cockStep(self):
    for i in self.cocks:
        # 第j只公雞
        j = np.random.randint(self.cNum[0])
        if j==i:
            j = (j+1) % self.cNum[0]
        # 第i只公雞
        ci = self.cs[i]
        # 第j只公雞
        cj = self.cs[self.cocks[j]]
        sigma = 1 if cj.best > ci.best else np.exp(
            (cj.best-ci.best)/(np.abs(ci.best)+1e-15))
        ci.x *= 1 + gauss(0, sigma)

母雞

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

x_i(t+1)=x_i(t)+k₁r₁(x_c−x_i)+k₂r₂(x_j−x_i)

其中，x_c為其首領公雞，x_j為另一只母雞或者公雞。k₁,k₂為系數，其更新邏輯與公雞的k是一樣的，當f_i較大時，表示為

代碼實現為

def henStep(self):
    nGuarder = self.cNum[0] + self.cNum[1] - 2
    for i in self.hens:
        guarders = list(self.cocks) + list(self.hens)
        c = self.cs[i].cock     #首領公雞
        guarders.remove(i)
        guarders.remove(c)
        # 隨機生成另一只監護雞
        j = guarders[np.random.randint(nGuarder)]
        ci = self.cs[i]
        cj = self.cs[j]
        cc = self.cs[c]
        k1, k2 = random(), random()
        if cc.best > ci.best:
            k1 *= np.exp((ci.best-cc.best)/(np.abs(ci.best)+1e-15))
        if cj.best < ci.best:
            k2 *=  np.exp(cj.best-ci.best)
        ci.x += k1*(cc.x-ci.x)+k2*(cj.x-ci.x)

小雞

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

x_i(t+1)=x_i(t)+r(x_h(t)−x_i(t))

其中，x_h為其監護母雞，r為隨機數，算法實現為

def chickStep(self):
    for i in self.chicks:
        ci = self.cs[i]
        ci.x += 2*random()*(self.cs[ci.hen].x-ci.x)

整個雞群

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

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

def update(self):
    cn = np.sum(self.cNum)
    c1, c2 = self.cNum[0], self.cNum[0]+self.cNum[1]
    fitness = [self.cs[i].best for i in range(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)]
    for i in self.cocks:
        self.cs[i].kind = 0
    for i in self.hens:
        self.cs[i].kind = 1
    for i in self.chicks:
        self.cs[i].kind = 2
    for i in range(cn):
        if self.cs[i].kind > 0:
            cock = self.cocks[randint(0, c1)]
            self.cs[i].setCock(cock)
        if self.cs[i].kind > 1:
            hen = self.hens[randint(c1,c2)]
            self.cs[i].setHen(hen)

優化迭代

至此，集群算法的框架算是搭建成功了，接下來就實現最關鍵的部分，優化。

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

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

# func為待優化函數
# N為迭代次數
# T為雞群更新周期
def optimize(self, func, N, T, msgT):
    for n in range(N):
        # 計算優化參數
        for c in self.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可以將當前最佳結果打印出來，其形式為

def printBest(self,n):
    fitness = [c.best for c in self.cs]
    best = np.min(fitness)
    ind = np.where(fitness==best)[0]
    msg = f"已經迭代{n}次，最佳優化結果為{np.min(fitness)}，參數為：\n"
    msg += ", ".join([f"{x:.6f}" for x in self.cs[ind].x])
    print(msg)

測試

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

def test(xs):
    _sum = 0.0
    for i in range(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)

測試結果如下

已經迭代4次，最佳優化結果為-5.793762423022024，參數為：
-6.599526, 3.117137, 5.959538, 7.225785, 5.204990
已經迭代9次，最佳優化結果為-10.61594651972434，參數為：
-7.003724, -5.589730, 0.981409, 12.920325, -19.006112
已經迭代14次，最佳優化結果為-9.143596747975293，參數為：
5.388234, -3.714421, -5.254391, -5.216215, -6.079223
已經迭代19次，最佳優化結果為-11.097888385616995，參數為：
-9.156244, -5.914600, -5.960154, 4.550833, 4.127889
已經迭代19次，最佳優化結果為-11.097888385616995，參數為：
-9.156244, -5.914600, -5.960154, 4.550833, 4.127889

讀到這里，這篇“Python怎么實現雞群算法”文章已經介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領會，如果想了解更多相關內容的文章，歡迎關注億速云行業資訊頻道。