人工蜂群算法简介与程序分析

  目前人工蜂群算法主要分为基于婚配行为与基于釆蜜行为两大类，本文研究的是基于釆蜜行为的人工蜂群算法。

蜜蜂采蜜

  自然界中的蜜蜂总能在任何环境下以极高的效率找到优质蜜源，且能适应环境的改变。蜜蜂群的采蜜系统由蜜源、雇佣蜂、非雇佣蜂三部分组成，其中一个蜜源的优劣有很多要素，如蜜源花蜜量的大小、离蜂巢距离的远近、提取的难易程度等；雇佣蜂和特定的蜜源联系并将蜜源信息以一定概率形式告诉同伴；非雇佣蜂的职责是寻找待开采的蜜源，分为跟随蜂和侦查蜂两类，跟随峰是在蜂巢等待而侦查蜂是探测蜂巢周围的新蜜源。蜜蜂采蜜时，蜂巢中的一部分蜜蜂作为侦查蜂，不断并随机地在蜂巢附近寻找蜜源，如果发现了花蜜量超过某个阈值的蜜源，则此侦査蜂变为雇佣蜂开始釆蜜，采蜜完成后飞回蜂巢跳摇摆舞告知跟随峰。摇摆舞是蜜蜂之间交流信息的一种基本形式，它传达了有关蜂巢周围蜜源的重要信息如蜜源方向及离巢距离等，跟随峰利用这些信息准确评价蜂巢周围的蜜源质量。当雇佣蜂跳完摇摆舞之后，就与蜂巢中的一些跟随蜂一起返回原蜜源采蜜，跟随蜂数量取决于蜜源质量。以这种方式，蜂群能快速且有效地找到花蜜量最高的蜜源。

  蜜蜂采蜜的群体智能就是通过不同角色之间的交流转换及协作来实现的。具体采蜜过程如图所示。在最初阶段，蜜蜂是以侦查蜂的形式出现，且对蜂巢周闱的蜜源没有任何了解，由于蜜蜂内在动机和外在的条件不同侦查蜂有两种选择：①成为雇佣蜂，开始在蜂巢周围随机搜索蜜源，如图中路线②成为跟随峰，在观察完摇摆舞后开始搜索蜜源，如图中路线。假设发现两个蜜源和，在发现蜜源后，该侦查蜂变成一只雇佣蜂，雇佣蜂利用其自身属性记住蜜源的位置，并立刻投入到采蜜中。采蜜完成后蜜蜂带着满载花蜜返回蜂巢，将花蜜卸载到卸蜜房，卸载完成后雇佣蜂有三种可能的行为①放弃自己发现的花蜜量不高的蜜源，变成一个不受约束的非雇佣蜂，如图中的路线；②在

招募区跳摇摆舞，招募一些待在蜂巢中跟随峰，带领其再次返回所发现的蜜源如图中的路线；③不招募其他蜜蜂，继续回到原来的蜜源采蜜如图中的路线。在现实生活中并不是所有的蜜蜂一开始就立刻采蜜，另外大多数蜜蜂在一次采蜜完成后都会选择回到招募区跳摇摆舞来招募更多的蜜蜂去采蜜。

算法模型

人工蜂群算法就是模拟蜜蜂的采蜜过程而提出的一种新型智能优化算法，它也是由食物源、雇佣蜂和非雇佣蜂三部分组成。

食物源：食物源即为蜜源。在任何一个优化问题中，问题的可行解都是以一定形式给出的。在人工蜂群算法中，食物源就是待求优化问题的可行解，是人工蜂群算法中所要处理的基本对象。食物源的优劣即可行解的好坏是用蜜源花蜜量的大小即适应度来评价的。

雇佣蜂：雇佣蜂即为引领蜂与食物源的位置相对应，一个食物源对应一个引领蜂。在人工蜂群算法中，食物源的个数与引领蜂的个数相等；引领蜂的任务是发现食物源信息并以一定的概率与跟随蜂分享；概率的计算即为人工蜂群算法中的选择策略，一般是根据适应度值以轮盘赌的方法计算。

非雇佣蜂：非雇佣蜂包括跟随蜂和侦査蜂跟随蜂在蜂巢的招募区内根据引领蜂提供的蜜源信息来选择食物源，而侦查蜂是在蜂巢附近寻找新的食物源。在人工蜂群算法中，跟随蜂依据引领蜂传递的信息，在食物源附近搜索新食物源，并进行贪婪选择。若一个食物源在经过次后仍未被更新，则此引领蜂变成侦査蜂，侦查蜂寻找新的食物源代替原来的食物源。

算法搜索过程  

  人工蜂群算法中将人工蜂群分为引领蜂、跟随蜂和侦查蜂三类，每一次搜索过程中，引领蜂和跟随蜂是先后开采食物源，即寻找最优解，而侦查蜂是观察是否陷入局部最优，若陷入局部最优则随机地搜索其它可能的食物源。每个食物源代表问题一个可能解，食物源的花蜜量对应相应解的质量（适应度值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