人工蜂群算法簡介與程序分析

  目前人工蜂群算法主要分為基於婚配行為與基於釆蜜行為兩大類，本文研究的是基於釆蜜行為的人工蜂群算法。

蜜蜂采蜜

  自然界中的蜜蜂總能在任何環境下以極高的效率找到優質蜜源，且能適應環境的改變。蜜蜂群的采蜜系統由蜜源、雇佣蜂、非雇佣蜂三部分組成，其中一個蜜源的優劣有很多要素，如蜜源花蜜量的大小、離蜂巢距離的遠近、提取的難易程度等；雇佣蜂和特定的蜜源聯系並將蜜源信息以一定概率形式告訴同伴；非雇佣蜂的職責是尋找待開采的蜜源，分為跟隨蜂和偵查蜂兩類，跟隨峰是在蜂巢等待而偵查蜂是探測蜂巢周圍的新蜜源。蜜蜂采蜜時，蜂巢中的一部分蜜蜂作為偵查蜂，不斷並隨機地在蜂巢附近尋找蜜源，如果發現了花蜜量超過某個閾值的蜜源，則此偵査蜂變為雇佣蜂開始釆蜜，采蜜完成后飛回蜂巢跳搖擺舞告知跟隨峰。搖擺舞是蜜蜂之間交流信息的一種基本形式，它傳達了有關蜂巢周圍蜜源的重要信息如蜜源方向及離巢距離等，跟隨峰利用這些信息准確評價蜂巢周圍的蜜源質量。當雇佣蜂跳完搖擺舞之后，就與蜂巢中的一些跟隨蜂一起返回原蜜源采蜜，跟隨蜂數量取決於蜜源質量。以這種方式，蜂群能快速且有效地找到花蜜量最高的蜜源。

 

  蜜蜂采蜜的群體智能就是通過不同角色之間的交流轉換及協作來實現的。具體采蜜過程如圖所示。在最初階段，蜜蜂是以偵查蜂的形式出現，且對蜂巢周闈的蜜源沒有任何了解，由於蜜蜂內在動機和外在的條件不同偵查蜂有兩種選擇：①成為雇佣蜂，開始在蜂巢周圍隨機搜索蜜源，如圖中路線②成為跟隨峰，在觀察完搖擺舞后開始搜索蜜源，如圖中路線。假設發現兩個蜜源和，在發現蜜源后，該偵查蜂變成一只雇佣蜂，雇佣蜂利用其自身屬性記住蜜源的位置，並立刻投入到采蜜中。采蜜完成后蜜蜂帶着滿載花蜜返回蜂巢，將花蜜卸載到卸蜜房，卸載完成后雇佣蜂有三種可能的行為①放棄自己發現的花蜜量不高的蜜源，變成一個不受約束的非雇佣蜂，如圖中的路線；②在

招募區跳搖擺舞，招募一些待在蜂巢中跟隨峰，帶領其再次返回所發現的蜜源如圖中的路線；③不招募其他蜜蜂，繼續回到原來的蜜源采蜜如圖中的路線。在現實生活中並不是所有的蜜蜂一開始就立刻采蜜，另外大多數蜜蜂在一次采蜜完成后都會選擇回到招募區跳搖擺舞來招募更多的蜜蜂去采蜜。

算法模型

人工蜂群算法就是模擬蜜蜂的采蜜過程而提出的一種新型智能優化算法，它也是由食物源、雇佣蜂和非雇佣蜂三部分組成。

食物源：食物源即為蜜源。在任何一個優化問題中，問題的可行解都是以一定形式給出的。在人工蜂群算法中，食物源就是待求優化問題的可行解，是人工蜂群算法中所要處理的基本對象。食物源的優劣即可行解的好壞是用蜜源花蜜量的大小即適應度來評價的。

雇佣蜂：雇佣蜂即為引領蜂與食物源的位置相對應，一個食物源對應一個引領蜂。在人工蜂群算法中，食物源的個數與引領蜂的個數相等；引領蜂的任務是發現食物源信息並以一定的概率與跟隨蜂分享；概率的計算即為人工蜂群算法中的選擇策略，一般是根據適應度值以輪盤賭的方法計算。

非雇佣蜂：非雇佣蜂包括跟隨蜂和偵査蜂跟隨蜂在蜂巢的招募區內根據引領蜂提供的蜜源信息來選擇食物源，而偵查蜂是在蜂巢附近尋找新的食物源。在人工蜂群算法中，跟隨蜂依據引領蜂傳遞的信息，在食物源附近搜索新食物源，並進行貪婪選擇。若一個食物源在經過次后仍未被更新，則此引領蜂變成偵査蜂，偵查蜂尋找新的食物源代替原來的食物源。

算法搜索過程  

  人工蜂群算法中將人工蜂群分為引領蜂、跟隨蜂和偵查蜂三類，每一次搜索過程中，引領蜂和跟隨蜂是先后開采食物源，即尋找最優解，而偵查蜂是觀察是否陷入局部最優，若陷入局部最優則隨機地搜索其它可能的食物源。每個食物源代表問題一個可能解，食物源的花蜜量對應相應解的質量（適應度值fit_i）。

一、人工蜂群算法搜索過程中，首先需要初始化，其中包括確定種群數、最大迭代次數MCN、、控制參數limit和確定搜索空間即解的范圍，在搜索空間中隨機生成初始解x_i(i=1,2,3,……,SN)，SN為食物源個數，每個解x_i是一個D維的向量，D是問題的維數。初始化之后，整個種群將進行引領蜂、跟隨蜂和偵查蜂搜尋過程的重復循環，直到達到最大迭代次數MCN或誤差允許值  ε。

 

二、在搜索過程開始階段，每個引領蜂由式(2-3)產生一個新解即新食物源，

                                                            v_ij=x_ij+Φ_ij(x_ij-x_kj)                    (2-3)

  式中，k∈﹛1,2,...,SN﹜,j∈{1,2,...,D},且k ≠i;Φ_ij為[-1,1]之間的隨機數。計算新解的fit_i並評價它，若新解的fit_i優於舊解，則引領蜂記住新解忘記舊解。反之，它將保留舊解。

三、在所有引領蜂完成搜尋過程之后，引領蜂會在招募區跳搖擺舞把解的信息及信息與跟隨蜂分享。跟隨蜂根據式計算每個解的選擇概率，

                                                               p_i=fit_i/∑_k=1^SNfit_k。            (2-4)

然后在區間[-1,1]內隨機產生一個數，如果解的概率值大於該隨機數，則跟隨蜂由式(2-3)產生一個新解，並檢驗新解的fit_i，若新解的fit_i比之前好，則跟隨蜂將記住新解忘掉舊解；反之，它將保留舊解。

四、在所有跟隨蜂完成搜尋過程之后，如果一個解經過limit次循環仍然沒有被進一步更新，那么就認為此解陷入局部最優，該食物源就會被舍棄。設食物源x_i被舍棄，則此食物源對應的引領蜂轉成一個偵查蜂。偵察蜂由(2-5)式產生一個新的食物源代替它。

                                                                 x_ij=x_minj+rand(0,1)(x_maxj-x_minj)          (2-5)

其中j∈{1,2....,D}。然后返回引領蜂搜索過程，開始重復循環。

五、人工蜂群算法的食物源質量一般是越大越好，即適應度值越大越好，而對應於要優化的問題，需要分兩種情況考慮：即最小值問題、最大值問題。設fi是優化問題的目標函數，所以若優化最小值問題時，適應度函數為fi的變形，一般用式(2-6)表示；若優化最大值問題，適應度函數即目標函數。

                                                            fit_i={_{1+abs(fi)     fi>=0}^{1/1+f_i               fi>0                                (2-6)}

 

人工蜂群算法在評價食物源時一般進行貪婪選擇按式(2-7)進行。

                                                          vi={_{xi  fit(xi)<=fit(vi)}^{v_i     fit(vi)>fit(xi)}           (2-7)

 

 

人工蜂群算法就是通過循環搜索，最終找到最優食物源或最優解。

算法步驟

人工蜂群算法具體實現步驟：

步驟1：初始化種群：初始化各個參數，蜂群總數SN、食物源被采集次數即最大迭代次數MCN及控制參數limit，確定問題搜索范圍，並且在搜索范圍內隨機產生初始解x_i(i=1,2,...SN) 。

步驟2：計算並評估每個初始解的適應度。

步驟3：設定循環條件並開始循環

步驟4：引領蜂對解xi按照式（2-3）進行鄰域搜索產生新解（食物源）v_i，並計算其適應度值；

步驟5：按照式(2-7)進行貪婪選擇：如果v_i的適應度值優於xi，則利用vi替換xi，將vi作為當前最好的解，否則保留xi不變；

步驟6：根據式(2-4)計算食物源的概率pi；

步驟7：跟隨蜂依照概率pi選擇解或食物源，按照式(2-3)搜索產生新解（食物源）vi，並計算其適應度。

步驟8：按式(2-7)進行貪婪選擇；如果vi的適應度優於xi，則用vi代替xi，將vi作為當前最好解，否則保留xi不變；

步驟9：判斷是否有要放棄的解。若有，則偵查蜂按式(2-5)隨機產生新解將其替換；

步驟10：記錄到目前為止的最優解；

步驟11：判斷是否滿足循環終止條件，若滿足，循環結束，輸出最優解，否則返回步驟4繼續搜索。

程序分析xi

 程序中的采蜜蜂就是引領蜂也是雇佣蜂，都表達一個含義。

#include<iostream>  
#include<time.h>  
#include<stdlib.h>  
#include<cmath>  
#include<fstream>  
#include<iomanip>  
using namespace std;  
  
const int NP=40;//種群的規模，采蜜蜂+觀察蜂  
const int FoodNumber=NP/2;//食物的數量，為采蜜蜂的數量  
const int limit=20;//限度，超過這個限度沒有更新采蜜蜂變成偵查蜂  
const int maxCycle=10000;//停止條件  
  
/*****函數的特定參數*****/  
const int D=2;//函數的參數個數  
const double lb=-100;//函數的下界   
const double ub=100;//函數的上界  
  
double result[maxCycle]={0};  
  
/*****種群的定義****/  
struct BeeGroup  
{  
    double code[D];//函數的維數  
    double trueFit;//記錄真實的最小值  
    double fitness;  
    double rfitness;//相對適應值比例  
    int trail;//表示實驗的次數，用於與limit作比較  
}Bee[FoodNumber];  
  
BeeGroup NectarSource[FoodNumber];//蜜源，注意：一切的修改都是針對蜜源而言的  
BeeGroup EmployedBee[FoodNumber];//采蜜蜂  
BeeGroup OnLooker[FoodNumber];//觀察蜂  
BeeGroup BestSource;//記錄最好蜜源  
  
/*****函數的聲明*****/  
double random(double, double);//產生區間上的隨機數  
void initilize();//初始化參數  
double calculationTruefit(BeeGroup);//計算真實的函數值  
double calculationFitness(double);//計算適應值  
void CalculateProbabilities();//計算輪盤賭的概率  
void evalueSource();//評價蜜源  
void sendEmployedBees();  
void sendOnlookerBees();  
void sendScoutBees();  
void MemorizeBestSource();  
  
  
/*******主函數*******/  
int main()  
{  
    ofstream output;  //輸出定義
    output.open("dataABC.txt");  
  
    srand((unsigned)time(NULL));  //根據時間產生隨機種子
    initilize();//初始化  
    MemorizeBestSource();//保存最好的蜜源  
          
    //主要的循環  
    int gen=0;  
    while(gen<maxCycle)  
    {  
        sendEmployedBees();  
              
        CalculateProbabilities();  
              
        sendOnlookerBees();  
              
        MemorizeBestSource();  
              
        sendScoutBees();  
              
        MemorizeBestSource();  
  
        output<<setprecision(30)<<BestSource.trueFit<<endl;  //輸出30個有效數字
              
        gen++;  
    }  
      
    output.close();  
    cout<<"運行結束!!"<<endl;  
    return 0;  
}  
  
/*****函數的實現****/  
double random(double start, double end)//隨機產生區間內的隨機數  
{     
    return start+(end-start)*rand()/(RAND_MAX + 1.0);  
}  
  
void initilize()//初始化參數  
{  
    int i,j;  
    for (i=0;i<FoodNumber;i++)  
    {  
        for (j=0;j<D;j++)  
        {  
            NectarSource[i].code[j]=random(lb,ub);  
            EmployedBee[i].code[j]=NectarSource[i].code[j];  
            OnLooker[i].code[j]=NectarSource[i].code[j];  
            BestSource.code[j]=NectarSource[0].code[j];  
        }  
        /****蜜源的初始化*****/  
        NectarSource[i].trueFit=calculationTruefit(NectarSource[i]);  
        NectarSource[i].fitness=calculationFitness(NectarSource[i].trueFit);  
        NectarSource[i].rfitness=0;  
        NectarSource[i].trail=0;  
        /****采蜜蜂的初始化*****/  
        EmployedBee[i].trueFit=NectarSource[i].trueFit;  
        EmployedBee[i].fitness=NectarSource[i].fitness;  
        EmployedBee[i].rfitness=NectarSource[i].rfitness;  
        EmployedBee[i].trail=NectarSource[i].trail;  
        /****觀察蜂的初始化****/  
        OnLooker[i].trueFit=NectarSource[i].trueFit;  
        OnLooker[i].fitness=NectarSource[i].fitness;  
        OnLooker[i].rfitness=NectarSource[i].rfitness;  
        OnLooker[i].trail=NectarSource[i].trail;  
    }  
    /*****最優蜜源的初始化*****/  
    BestSource.trueFit=NectarSource[0].trueFit;  
    BestSource.fitness=NectarSource[0].fitness;  
    BestSource.rfitness=NectarSource[0].rfitness;  
    BestSource.trail=NectarSource[0].trail;  
}  
  
double calculationTruefit(BeeGroup bee)//計算真實的函數值  
{  
    double truefit=0;  
    /******測試函數1******/  
    truefit=0.5+(sin(sqrt(bee.code[0]*bee.code[0]+bee.code[1]*bee.code[1]))*sin(sqrt(bee.code[0]*bee.code[0]+bee.code[1]*bee.code[1]))-0.5)  
        /((1+0.001*(bee.code[0]*bee.code[0]+bee.code[1]*bee.code[1]))*(1+0.001*(bee.code[0]*bee.code[0]+bee.code[1]*bee.code[1])));  
  
    return truefit;  
}  
  
double calculationFitness(double truefit)//計算適應值  
{  
    double fitnessResult=0;  
    if (truefit>=0)  
    {  
        fitnessResult=1/(truefit+1);  
    }else  
    {  
        fitnessResult=1+abs(truefit);  
    }  
    return fitnessResult;  
}  
  
void sendEmployedBees()//修改采蜜蜂的函數  
{  
    int i,j,k;  
    int param2change;//需要改變的維數  
    double Rij;//[-1,1]之間的隨機數  
    for (i=0;i<FoodNumber;i++)  
    {  
          
        param2change=(int)random(0,D);//隨機選取需要改變的維數  
  
        /******選取不等於i的k********/  
        while (1)  
        {  
            k=(int)random(0,FoodNumber);  
            if (k!=i)  
            {  
                break;  
            }  
        }  
  
        for (j=0;j<D;j++)  
        {  
            EmployedBee[i].code[j]=NectarSource[i].code[j];  //在之前初始化對EmployedBee進行初始化了，程序之后有對蜜源改變在此對EmployedBee進行更新
        }  
  
        /*******采蜜蜂去更新信息*******/  
        Rij=random(-1,1);  
        EmployedBee[i].code[param2change]=NectarSource[i].code[param2change]+Rij*(NectarSource[i].code[param2change]-NectarSource[k].code[param2change]);  //根據公式(2-3)
        /*******判斷是否越界********/  
        if (EmployedBee[i].code[param2change]>ub)  
        {  
            EmployedBee[i].code[param2change]=ub;  
        }  
        if (EmployedBee[i].code[param2change]<lb)  
        {  
            EmployedBee[i].code[param2change]=lb;  
        }  
        EmployedBee[i].trueFit=calculationTruefit(EmployedBee[i]);  
        EmployedBee[i].fitness=calculationFitness(EmployedBee[i].trueFit);  
  
        /******貪婪選擇策略*******/  
        if (EmployedBee[i].trueFit<NectarSource[i].trueFit)  
        {  
            for (j=0;j<D;j++)  
            {  
                NectarSource[i].code[j]=EmployedBee[i].code[j];  
            }  
            NectarSource[i].trail=0;  
            NectarSource[i].trueFit=EmployedBee[i].trueFit;  
            NectarSource[i].fitness=EmployedBee[i].fitness;  
        }else  
        {  
            NectarSource[i].trail++;  
        }  
    }  
}  
  
void CalculateProbabilities()//計算輪盤賭的選擇概率  (計算的適應度比例)與后面 sendOnlookerBees中的選擇R_choosed進行比較
{  
    int i;  
    double maxfit;  
    maxfit=NectarSource[0].fitness;  
    for (i=1;i<FoodNumber;i++)  
    {  
        if (NectarSource[i].fitness>maxfit)  
            maxfit=NectarSource[i].fitness;  
    }  
      
    for (i=0;i<FoodNumber;i++)  
    {  
        NectarSource[i].rfitness=(0.9*(NectarSource[i].fitness/maxfit))+0.1;  
    }  
}  
  
void sendOnlookerBees()//采蜜蜂與觀察蜂交流信息，觀察蜂更改信息  
{  
    int i,j,t,k;  
    double R_choosed;//被選中的概率  
    int param2change;//需要被改變的維數  
    double Rij;//[-1,1]之間的隨機數  
    i=0;  
    t=0;  //是否超出食物源個數
    while(t<FoodNumber)  
    {  
          
        R_choosed=random(0,1);  
        if(R_choosed<NectarSource[i].rfitness)//根據被選擇的概率選擇  （算法搜索過程三的實現）
        {          
            t++;  
            param2change=(int)random(0,D);  
              
            /******選取不等於i的k********/  
            while (1)  
            {  
                k=(int)random(0,FoodNumber);  
                if (k!=i)  
                {  
                    break;  
                }  
            }  
  
            for(j=0;j<D;j++)  
            {  
                OnLooker[i].code[j]=NectarSource[i].code[j];  
            }  
              
            /****更新******/  
            Rij=random(-1,1);  
            OnLooker[i].code[param2change]=NectarSource[i].code[param2change]+Rij*(NectarSource[i].code[param2change]-NectarSource[k].code[param2change]);  
              
            /*******判斷是否越界*******/  
            if (OnLooker[i].code[param2change]<lb)  
            {  
                OnLooker[i].code[param2change]=lb;  
            }  
            if (OnLooker[i].code[param2change]>ub)  
            {     
                OnLooker[i].code[param2change]=ub;  
            }  
            OnLooker[i].trueFit=calculationTruefit(OnLooker[i]);  
            OnLooker[i].fitness=calculationFitness(OnLooker[i].trueFit);  
              
            /****貪婪選擇策略******/  
            if (OnLooker[i].trueFit<NectarSource[i].trueFit)  
            {  
                for (j=0;j<D;j++)  
                {  
                    NectarSource[i].code[j]=OnLooker[i].code[j];  
                }  
                NectarSource[i].trail=0;  
                NectarSource[i].trueFit=OnLooker[i].trueFit;  
                NectarSource[i].fitness=OnLooker[i].fitness;  
            }else  
            {  
                NectarSource[i].trail++;  
            }  
        }   
        i++;  
        if (i==FoodNumber)  
        {  
            i=0;  
        }  
    }  
}  
  
  
/*******只有一只偵查蜂（主程序進行一次循環該函數就判斷一次偵查蜂是否出現）（如果有兩個及以上超過limit限制，該函數能將他們都找到嗎？在循環結束之前）**********/  
void sendScoutBees()//判斷是否有偵查蜂的出現，有則重新生成蜜源  
{  
    int maxtrialindex,i,j;  
    double R;//[0,1]之間的隨機數  
    maxtrialindex=0;  
    for (i=1;i<FoodNumber;i++)  
    {  
        if (NectarSource[i].trail>NectarSource[maxtrialindex].trail)  
        {  
            maxtrialindex=i;  
        }  
    }  
    if(NectarSource[maxtrialindex].trail>=limit)  
    {  
        /*******重新初始化*********/  
        for (j=0;j<D;j++)  
        {  
            R=random(0,1);  
            NectarSource[maxtrialindex].code[j]=lb+R*(ub-lb);  //此處蜜源進行更新（這就是為什么在初始化引領蜂和偵查蜂之后，還要在相應的函數地方再初始化一次）
        }  
        NectarSource[maxtrialindex].trail=0;  
        NectarSource[maxtrialindex].trueFit=calculationTruefit(NectarSource[maxtrialindex]);  
        NectarSource[maxtrialindex].fitness=calculationFitness(NectarSource[maxtrialindex].trueFit);  
    }  
}  
  
void MemorizeBestSource()//保存最優的蜜源  
{  
    int i,j;  
    for (i=1;i<FoodNumber;i++)  
    {  
        if (NectarSource[i].trueFit<BestSource.trueFit)  
        {  
            for (j=0;j<D;j++)  
            {  
                BestSource.code[j]=NectarSource[i].code[j];  
            }  
            BestSource.trueFit=NectarSource[i].trueFit;  
        }  
    }  
}

 

 另附實驗生成數據資料以及算法源碼以供參考  https://pan.baidu.com/s/1iIPfQUSpJHp7_pjJ1SSBEg

 

 請大家斧正

2019-08-17  10:22:31