Python实现鸡群算法

文章目录

源码地址：
鸡群算法之Python实现

算法简介

鸡群算法，缩写为CSO(Chicken Swarm Optimization)，尽管具备所谓仿生学的背景，但实质上是粒子群算法的一个变体。粒子群算法的详细解释见博文：粒子群算法及其Python实现

简单来说，粒子群就是一群粒子，每个粒子都有自己的位置和速度，而且每个粒子都要受到最佳粒子的吸引，除了这两条规则之外，粒子之间完全平等，彼此之间除了位置和速度之外，完全相等。

当然，粒子群算法本身也是有仿生学背景的，据说灵感来自于鸟群觅食，这个当然不重要，无非是一群平等的粒子变成了一群平等的鸟罢了。

而鸡群算法，则是为这些粒子，或者这些鸟，添加了不同的身份特征，使得彼此之间不再等同。

鸡群中至少有三个阶层，分别是公鸡、母鸡和小鸡，每只鸡都有其位置和速度。但区别之处在于，

公鸡最神气，原则上可以随便踱步，只是有的时候注意到其他公鸡的时候，会有抢食的想法，相当于随机抽选一只其他公鸡，对其位置产生影响。
母鸡最憋屈，一方面要接受公鸡的领导，另一方面还要和其他母鸡抢食
小鸡最无忧无虑，跟着母鸡走就是了。

随着位置关系的变化，母鸡和小鸡可能会逐渐遗忘最初的首领，也就是说种群关系可能会发生变化。

Python实现鸡和鸡群

首先，要实现一个鸡类，一只鸡，有两种基本属性，即位置和类别。

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

classChicken: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          # 鸡的编号# 设置自己的首领公鸡defsetCock(self, i):
        self.cock = i

    # 设置自己的监护母鸡defsetHen(self, i):
        self.hen = i

其中

kind

分为三类，分别是公鸡、母鸡和小鸡。其中，每只母鸡都有自己的首领公鸡，每只小鸡都有自己的监护母鸡。

order

为这只鸡在鸡群中的编号，主要在鸡群中得以体现。

鸡群和粒子群有一个很大的区别，后者说到底只有一个群，而鸡群中，每个公鸡都有自己的母鸡和小鸡，相当于一个小群体。但鸡和鸡之间的关系，并不取决于鸡自己，故而需要在鸡群中实现

randint = np.random.randint
classSwarm:# 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

    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)for i inrange(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
   
  
  
   i
  
 
i，随机挑选的公鸡编号是

 
  
   
    j
   
   
    ,
   
   
    j
   
   
    ≠
   
   
    i
   
  
  
   j,j\not=i
  
 
j,j=i，则第

 
  
   
    i
   
  
  
   i
  
 
i只公鸡位置的更新方法为

 
  
   
    
     
      x
     
     
      i
     
    
    
     (
    
    
     t
    
    
     +
    
    
     1
    
    
     )
    
    
     =
    
    
     
      x
     
     
      i
     
    
    
     (
    
    
     t
    
    
     )
    
    
     ⋅
    
    
     (
    
    
     1
    
    
     +
    
    
     r
    
    
     )
    
   
   
     x_i(t+1) = x_i(t)\cdot(1+r) 
   
  
 xi(t+1)=xi(t)⋅(1+r)

其中，

    r
   
  
  
   r
  
 
r是通过正态分布生成的随机数，可表示为

 
  
   
    1
   
   
    ∼
   
   
    N
   
   
    (
   
   
    0
   
   
    ,
   
   
    
     σ
    
    
     2
    
   
   
    )
   
  
  
   1\sim N(0,\sigma^2)
  
 
1∼N(0,σ2)，其中

 
  
   
    
     σ
    
    
     2
    
   
  
  
   \sigma^2
  
 
σ2为

 
  
   
    
     
      σ
     
     
      2
     
    
    
     =
    
    
     
      {
     
     
      
       
        
         
        
       
       
        
         
          
          
           1
          
          
         
        
       
       
        
         
          
           
            f
           
           
            i
           
          
          
           ⩽
          
          
           
            f
           
           
            j
           
          
         
        
       
      
      
       
        
         
        
       
       
        
         
          
          
           
            e
           
           
            
             
              
               f
              
              
               j
              
             
             
              −
             
             
              
               f
              
              
               i
              
             
            
            
             
              ∣
             
             
              
               f
              
              
               i
              
             
             
              ∣
             
             
              +
             
             
              ε
             
            
           
          
         
        
       
       
        
         
          
           
            f
           
           
            i
           
          
          
           >
          
          
           
            f
           
           
            j
           
          
         
        
       
      
     
    
   
   
     \sigma^2=\left\{\begin{aligned} &1\quad&f_i\leqslant f_j\\ &e^\frac{f_j-f_i}{|f_i|+\varepsilon} &f_i > f_j \end{aligned}\right. 
   
  
 σ2=⎩⎨⎧1e∣fi∣+εfj−fifi⩽fjfi>fj

其中

    f
   
  
  
   f
  
 
f一般叫做适应因子，相当于将某只鸡塞到待搜解的函数中得到的值。例如要搜索

 
  
   
    y
   
   
    
     =
    
    
     2
    
   
  
  
   y=^2
  
 
y=2的最小值，如果当前这只鸡的位置是

 
  
   
    1.5
   
  
  
   1.5
  
 
1.5，那么

 
  
   
    f
   
   
    =
   
   
    1.
   
   
    
     5
    
    
     2
    
   
   
    =
   
   
    2.25
   
  
  
   f=1.5^2=2.25
  
 
f=1.52=2.25。

 
  
   
    ε
   
  
  
   \varepsilon
  
 
ε是一个防止除零错误的小量。

但需要注意，上文中所有的

    x
   
  
  
   x
  
 
x，表示的并非一个标量，而是一个数组。

其Python实现为

# 写在Swarm类中defcockStep(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 =1if cj.best > ci.best else np.exp((cj.best-ci.best)/(np.abs(ci.best)+1e-15))
        ci.x *=1+ gauss(0, sigma)

母鸡

设当前母鸡编号为

    i
   
  
  
   i
  
 
i，这只母鸡既要追随首领公鸡，又要和其他母鸡抢食。

 
  
   
    
     
      x
     
     
      i
     
    
    
     (
    
    
     t
    
    
     +
    
    
     1
    
    
     )
    
    
     =
    
    
     
      x
     
     
      i
     
    
    
     (
    
    
     t
    
    
     )
    
    
     +
    
    
     
      k
     
     
      1
     
    
    
     
      r
     
     
      1
     
    
    
     (
    
    
     
      x
     
     
      c
     
    
    
     −
    
    
     
      x
     
     
      i
     
    
    
     )
    
    
     +
    
    
     
      k
     
     
      2
     
    
    
     
      r
     
     
      2
     
    
    
     (
    
    
     
      x
     
     
      j
     
    
    
     −
    
    
     
      x
     
     
      i
     
    
    
     )
    
   
   
     x_i(t+1) = x_i(t)+k_1r_1(x_c-x_i)+k_2r_2(x_j-x_i) 
   
  
 xi(t+1)=xi(t)+k1r1(xc−xi)+k2r2(xj−xi)

其中，

     x
    
    
     c
    
   
  
  
   x_c
  
 
xc为其首领公鸡，

 
  
   
    
     x
    
    
     j
    
   
  
  
   x_j
  
 
xj为另一只母鸡或者公鸡。

 
  
   
    
     k
    
    
     1
    
   
   
    ,
   
   
    
     k
    
    
     2
    
   
  
  
   k_1, k_2
  
 
k1,k2为系数，其更新逻辑与公鸡的

 
  
   
    k
   
  
  
   k
  
 
k是一样的，当

 
  
   
    
     f
    
    
     i
    
   
  
  
   f_i
  
 
fi较大时，表示为

 
  
   
    
     
      k
     
     
      1
     
    
    
     =
    
    
     
      e
     
     
      
       
        
         f
        
        
         i
        
       
       
        −
       
       
        
         f
        
        
         c
        
       
      
      
       
        
         f
        
        
         i
        
       
       
        +
       
       
        ε
       
      
     
    
    
    
     
      k
     
     
      2
     
    
    
     =
    
    
     
      e
     
     
      
       
        f
       
       
        j
       
      
      
       −
      
      
       
        f
       
       
        i
       
      
     
    
   
   
     k_1 = e^\frac{f_i-f_c}{f_i+\varepsilon}\\ k_2 = e^{f_j-f_i} 
   
  
 k1=efi+εfi−fck2=efj−fi

代码实现为

defhenStep(self):
    nGuarder = self.cNum[0]+ self.cNum[1]-2for 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_i(t+1) = x_i(t) + r(x_h(t)-x_i(t)) 
   
  
 xi(t+1)=xi(t)+r(xh(t)−xi(t))

其中，

     x
    
    
     h
    
   
  
  
   x_h
  
 
xh为其监护母鸡，

 
  
   
    r
   
  
  
   r
  
 
r为随机数，算法实现为

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

整个鸡群

正所谓，算法源于生活而高于生活，自然界里讲求辈分，但在鸡群算法里，讲究的确是实力。如果小鸡运气爆棚，得到了比公鸡还厉害的优化结果，那么这只小鸡就会进化成公鸡。

也就是说，每隔一段时间，鸡群里的鸡会被重新安排身份，优化效果最好的就是头领公鸡，差一点的是监护母鸡，最差的就只能是小鸡了。

defupdate(self):
    cn = np.sum(self.cNum)
    c1, c2 = self.cNum[0], self.cNum[0]+self.cNum[1]
    fitness =[self.cs[i].best for i inrange(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 =0for i in self.hens:
        self.cs[i].kind =1for i in self.chicks:
        self.cs[i].kind =2for i inrange(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
   
  
  
   x
  
 
x带入到这个函数中，得到一个判定值，最后通过这个判定值，来不断更新鸡群。

除了这个函数之外，还需要输入一些其他参数，比如整个鸡群算法的迭代次数，以及鸡群更新的频次等等

# func为待优化函数# N为迭代次数# T为鸡群更新周期defoptimize(self, func, N, T, msgT):for n inrange(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

可以将当前最佳结果打印出来，其形式为

defprintBest(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)

测试

算法完成之后，当然要找个函数测试一下，测试函数为

     f
    
    
     (
    
    
     
      x
     
     
      ⃗
     
    
    
     )
    
    
     =
    
    
     
      ∑
     
     
      
       i
      
      
       =
      
      
       0
      
     
    
    
     cos
    
    
     ⁡
    
    
     (
    
    
     
      
       i
      
      
       
        x
       
       
        i
       
      
     
     
      5
     
    
    
     )
    
    
     ∗
    
    
     (
    
    
     i
    
    
     +
    
    
     1
    
    
     )
    
   
   
     f(\vec x)=\sum_{i=0}\cos(\frac{ix_i}{5})*(i+1) 
   
  
 f(x)=i=0∑cos(5ixi)∗(i+1)

deftest(xs):
    _sum =0.0for i inrange(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 算法 CSO

本文转载自: https://blog.csdn.net/m0_37816922/article/details/127942327
版权归原作者 微小冷 所有，如有侵权，请联系我们删除。

Python实现鸡群算法

文章目录

算法简介

Python实现鸡和鸡群

鸡群更新

优化迭代

测试

发表评论

“Python实现鸡群算法”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航