优化算法——人工蜂群算法(ABC)

2024-05-15 21:32
文章标签 算法 优化 abc 人工 蜂群

本文主要是介绍优化算法——人工蜂群算法(ABC)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、人工蜂群算法的介绍

人工蜂群算法(Artificial Bee Colony, ABC)是由Karaboga于2005年提出的一种新颖的基于群智能的全局优化算法，其直观背景来源于蜂群的采蜜行为，蜜蜂根据各自的分工进行不同的活动，并实现蜂群信息的共享和交流，从而找到问题的最优解。人工蜂群算法属于群智能算法的一种。

二、人工蜂群算法的原理

    1、原理

标准的ABC算法通过模拟实际蜜蜂的采蜜机制将人工蜂群分为3类: 采蜜蜂、观察蜂和侦察蜂。整个蜂群的目标是寻找花蜜量最大的蜜源。在标准的ABC算法中，采蜜蜂利用先前的蜜源信息寻找新的蜜源并与观察蜂分享蜜源信息；观察蜂在蜂房中等待并依据采蜜蜂分享的信息寻找新的蜜源；侦查蜂的任务是寻找一个新的有价值的蜜源，它们在蜂房附近随机地寻找蜜源。
假设问题的解空间是维的，采蜜蜂与观察蜂的个数都是，采蜜蜂的个数或观察蜂的个数与蜜源的数量相等。则标准的ABC算法将优化问题的求解过程看成是在维搜索空间中进行搜索。每个蜜源的位置代表问题的一个可能解，蜜源的花蜜量对应于相应的解的适应度。一个采蜜蜂与一个蜜源是相对应的。与第个蜜源相对应的采蜜蜂依据如下公式寻找新的蜜源：

其中，，，是区间上的随机数，。标准的ABC算法将新生成的可能解与原来的解作比较，并采用贪婪选择策略保留较好的解。每一个观察蜂依据概率选择一个蜜源，概率公式为

其中，是可能解的适应值。对于被选择的蜜源，观察蜂根据上面概率公式搜寻新的可能解。当所有的采蜜蜂和观察蜂都搜索完整个搜索空间时，如果一个蜜源的适应值在给定的步骤内(定义为控制参数“limit”) 没有被提高, 则丢弃该蜜源，而与该蜜源相对应的采蜜蜂变成侦查蜂，侦查蜂通过已下公式搜索新的可能解。

其中，是区间上的随机数，和是第维的下界和上界。

    2、流程

  • 初始化；
  • 重复以下过程：
    • 将采蜜蜂与蜜源一一对应，根据上面第一个公式更新蜜源信息，同时确定蜜源的花蜜量；
    • 观察蜂根据采蜜蜂所提供的信息采用一定的选择策略选择蜜源，根据第一个公式更新蜜源信息，同时确定蜜源的花蜜量；
    • 确定侦查蜂，并根据第三个公式寻找新的蜜源；
    • 记忆迄今为止最好的蜜源；
  • 判断终止条件是否成立；

三、人工蜂群算法用于求解函数优化问题

对于函数

其中。
代码：
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. #include<iostream>  
  2. #include<time.h>  
  3. #include<stdlib.h>  
  4. #include<cmath>  
  5. #include<fstream>  
  6. #include<iomanip>  
  7. using namespace std;  
  8.   
  9. const int NP=40;//种群的规模，采蜜蜂+观察蜂  
  10. const int FoodNumber=NP/2;//食物的数量，为采蜜蜂的数量  
  11. const int limit=20;//限度，超过这个限度没有更新采蜜蜂变成侦查蜂  
  12. const int maxCycle=10000;//停止条件  
  13.   
  14. /*****函数的特定参数*****/  
  15. const int D=2;//函数的参数个数  
  16. const double lb=-100;//函数的下界   
  17. const double ub=100;//函数的上界  
  18.   
  19. double result[maxCycle]={0};  
  20.   
  21. /*****种群的定义****/  
  22. struct BeeGroup  
  23. {  
  24.     double code[D];//函数的维数  
  25.     double trueFit;//记录真实的最小值  
  26.     double fitness;  
  27.     double rfitness;//相对适应值比例  
  28.     int trail;//表示实验的次数，用于与limit作比较  
  29. }Bee[FoodNumber];  
  30.   
  31. BeeGroup NectarSource[FoodNumber];//蜜源，注意：一切的修改都是针对蜜源而言的  
  32. BeeGroup EmployedBee[FoodNumber];//采蜜蜂  
  33. BeeGroup OnLooker[FoodNumber];//观察蜂  
  34. BeeGroup BestSource;//记录最好蜜源  
  35.   
  36. /*****函数的声明*****/  
  37. double random(double, double);//产生区间上的随机数  
  38. void initilize();//初始化参数  
  39. double calculationTruefit(BeeGroup);//计算真实的函数值  
  40. double calculationFitness(double);//计算适应值  
  41. void CalculateProbabilities();//计算轮盘赌的概率  
  42. void evalueSource();//评价蜜源  
  43. void sendEmployedBees();  
  44. void sendOnlookerBees();  
  45. void sendScoutBees();  
  46. void MemorizeBestSource();  
  47.   
  48.   
  49. /*******主函数*******/  
  50. int main()  
  51. {  
  52.     ofstream output;  
  53.     output.open(”dataABC.txt”);  
  54.   
  55.     srand((unsigned)time(NULL));  
  56.     initilize();//初始化  
  57.     MemorizeBestSource();//保存最好的蜜源  
  58.           
  59.     //主要的循环  
  60.     int gen=0;  
  61.     while(gen<maxCycle)  
  62.     {  
  63.         sendEmployedBees();  
  64.               
  65.         CalculateProbabilities();  
  66.               
  67.         sendOnlookerBees();  
  68.               
  69.         MemorizeBestSource();  
  70.               
  71.         sendScoutBees();  
  72.               
  73.         MemorizeBestSource();  
  74.   
  75.         output<<setprecision(30)<<BestSource.trueFit<<endl;  
  76.               
  77.         gen++;  
  78.     }  
  79.       
  80.     output.close();  
  81.     cout<<”运行结束!!”<<endl;  
  82.     return 0;  
  83. }  
  84.   
  85. /*****函数的实现****/  
  86. double random(double start, double end)//随机产生区间内的随机数  
  87. {     
  88.     return start+(end-start)*rand()/(RAND_MAX + 1.0);  
  89. }  
  90.   
  91. void initilize()//初始化参数  
  92. {  
  93.     int i,j;  
  94.     for (i=0;i<FoodNumber;i++)  
  95.     {  
  96.         for (j=0;j<D;j++)  
  97.         {  
  98.             NectarSource[i].code[j]=random(lb,ub);  
  99.             EmployedBee[i].code[j]=NectarSource[i].code[j];  
  100.             OnLooker[i].code[j]=NectarSource[i].code[j];  
  101.             BestSource.code[j]=NectarSource[0].code[j];  
  102.         }  
  103.         /****蜜源的初始化*****/  
  104.         NectarSource[i].trueFit=calculationTruefit(NectarSource[i]);  
  105.         NectarSource[i].fitness=calculationFitness(NectarSource[i].trueFit);  
  106.         NectarSource[i].rfitness=0;  
  107.         NectarSource[i].trail=0;  
  108.         /****采蜜蜂的初始化*****/  
  109.         EmployedBee[i].trueFit=NectarSource[i].trueFit;  
  110.         EmployedBee[i].fitness=NectarSource[i].fitness;  
  111.         EmployedBee[i].rfitness=NectarSource[i].rfitness;  
  112.         EmployedBee[i].trail=NectarSource[i].trail;  
  113.         /****观察蜂的初始化****/  
  114.         OnLooker[i].trueFit=NectarSource[i].trueFit;  
  115.         OnLooker[i].fitness=NectarSource[i].fitness;  
  116.         OnLooker[i].rfitness=NectarSource[i].rfitness;  
  117.         OnLooker[i].trail=NectarSource[i].trail;  
  118.     }  
  119.     /*****最优蜜源的初始化*****/  
  120.     BestSource.trueFit=NectarSource[0].trueFit;  
  121.     BestSource.fitness=NectarSource[0].fitness;  
  122.     BestSource.rfitness=NectarSource[0].rfitness;  
  123.     BestSource.trail=NectarSource[0].trail;  
  124. }  
  125.   
  126. double calculationTruefit(BeeGroup bee)//计算真实的函数值  
  127. {  
  128.     double truefit=0;  
  129.     /******测试函数1******/  
  130.     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)  
  131.         /((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])));  
  132.   
  133.     return truefit;  
  134. }  
  135.   
  136. double calculationFitness(double truefit)//计算适应值  
  137. {  
  138.     double fitnessResult=0;  
  139.     if (truefit>=0)  
  140.     {  
  141.         fitnessResult=1/(truefit+1);  
  142.     }else  
  143.     {  
  144.         fitnessResult=1+abs(truefit);  
  145.     }  
  146.     return fitnessResult;  
  147. }  
  148.   
  149. void sendEmployedBees()//修改采蜜蜂的函数  
  150. {  
  151.     int i,j,k;  
  152.     int param2change;//需要改变的维数  
  153.     double Rij;//[-1,1]之间的随机数  
  154.     for (i=0;i<FoodNumber;i++)  
  155.     {  
  156.           
  157.         param2change=(int)random(0,D);//随机选取需要改变的维数  
  158.   
  159.         /******选取不等于i的k********/  
  160.         while (1)  
  161.         {  
  162.             k=(int)random(0,FoodNumber);  
  163.             if (k!=i)  
  164.             {  
  165.                 break;  
  166.             }  
  167.         }  
  168.   
  169.         for (j=0;j<D;j++)  
  170.         {  
  171.             EmployedBee[i].code[j]=NectarSource[i].code[j];  
  172.         }  
  173.   
  174.         /*******采蜜蜂去更新信息*******/  
  175.         Rij=random(-1,1);  
  176.         EmployedBee[i].code[param2change]=NectarSource[i].code[param2change]+Rij*(NectarSource[i].code[param2change]-NectarSource[k].code[param2change]);  
  177.         /*******判断是否越界********/  
  178.         if (EmployedBee[i].code[param2change]>ub)  
  179.         {  
  180.             EmployedBee[i].code[param2change]=ub;  
  181.         }  
  182.         if (EmployedBee[i].code[param2change]<lb)  
  183.         {  
  184.             EmployedBee[i].code[param2change]=lb;  
  185.         }  
  186.         EmployedBee[i].trueFit=calculationTruefit(EmployedBee[i]);  
  187.         EmployedBee[i].fitness=calculationFitness(EmployedBee[i].trueFit);  
  188.   
  189.         /******贪婪选择策略*******/  
  190.         if (EmployedBee[i].trueFit<NectarSource[i].trueFit)  
  191.         {  
  192.             for (j=0;j<D;j++)  
  193.             {  
  194.                 NectarSource[i].code[j]=EmployedBee[i].code[j];  
  195.             }  
  196.             NectarSource[i].trail=0;  
  197.             NectarSource[i].trueFit=EmployedBee[i].trueFit;  
  198.             NectarSource[i].fitness=EmployedBee[i].fitness;  
  199.         }else  
  200.         {  
  201.             NectarSource[i].trail++;  
  202.         }  
  203.     }  
  204. }  
  205.   
  206. void CalculateProbabilities()//计算轮盘赌的选择概率  
  207. {  
  208.     int i;  
  209.     double maxfit;  
  210.     maxfit=NectarSource[0].fitness;  
  211.     for (i=1;i<FoodNumber;i++)  
  212.     {  
  213.         if (NectarSource[i].fitness>maxfit)  
  214.             maxfit=NectarSource[i].fitness;  
  215.     }  
  216.       
  217.     for (i=0;i<FoodNumber;i++)  
  218.     {  
  219.         NectarSource[i].rfitness=(0.9*(NectarSource[i].fitness/maxfit))+0.1;  
  220.     }  
  221. }  
  222.   
  223. void sendOnlookerBees()//采蜜蜂与观察蜂交流信息，观察蜂更改信息  
  224. {  
  225.     int i,j,t,k;  
  226.     double R_choosed;//被选中的概率  
  227.     int param2change;//需要被改变的维数  
  228.     double Rij;//[-1,1]之间的随机数  
  229.     i=0;  
  230.     t=0;  
  231.     while(t<FoodNumber)  
  232.     {  
  233.           
  234.         R_choosed=random(0,1);  
  235.         if(R_choosed<NectarSource[i].rfitness)//根据被选择的概率选择  
  236.         {          
  237.             t++;  
  238.             param2change=(int)random(0,D);  
  239.               
  240.             /******选取不等于i的k********/  
  241.             while (1)  
  242.             {  
  243.                 k=(int)random(0,FoodNumber);  
  244.                 if (k!=i)  
  245.                 {  
  246.                     break;  
  247.                 }  
  248.             }  
  249.   
  250.             for(j=0;j<D;j++)  
  251.             {  
  252.                 OnLooker[i].code[j]=NectarSource[i].code[j];  
  253.             }  
  254.               
  255.             /****更新******/  
  256.             Rij=random(-1,1);  
  257.             OnLooker[i].code[param2change]=NectarSource[i].code[param2change]+Rij*(NectarSource[i].code[param2change]-NectarSource[k].code[param2change]);  
  258.               
  259.             /*******判断是否越界*******/  
  260.             if (OnLooker[i].code[param2change]<lb)  
  261.             {  
  262.                 OnLooker[i].code[param2change]=lb;  
  263.             }  
  264.             if (OnLooker[i].code[param2change]>ub)  
  265.             {     
  266.                 OnLooker[i].code[param2change]=ub;  
  267.             }  
  268.             OnLooker[i].trueFit=calculationTruefit(OnLooker[i]);  
  269.             OnLooker[i].fitness=calculationFitness(OnLooker[i].trueFit);  
  270.               
  271.             /****贪婪选择策略******/  
  272.             if (OnLooker[i].trueFit<NectarSource[i].trueFit)  
  273.             {  
  274.                 for (j=0;j<D;j++)  
  275.                 {  
  276.                     NectarSource[i].code[j]=OnLooker[i].code[j];  
  277.                 }  
  278.                 NectarSource[i].trail=0;  
  279.                 NectarSource[i].trueFit=OnLooker[i].trueFit;  
  280.                 NectarSource[i].fitness=OnLooker[i].fitness;  
  281.             }else  
  282.             {  
  283.                 NectarSource[i].trail++;  
  284.             }  
  285.         }   
  286.         i++;  
  287.         if (i==FoodNumber)  
  288.         {  
  289.             i=0;  
  290.         }  
  291.     }  
  292. }  
  293.   
  294.   
  295. /*******只有一只侦查蜂**********/  
  296. void sendScoutBees()//判断是否有侦查蜂的出现，有则重新生成蜜源  
  297. {  
  298.     int maxtrialindex,i,j;  
  299.     double R;//[0,1]之间的随机数  
  300.     maxtrialindex=0;  
  301.     for (i=1;i<FoodNumber;i++)  
  302.     {  
  303.         if (NectarSource[i].trail>NectarSource[maxtrialindex].trail)  
  304.         {  
  305.             maxtrialindex=i;  
  306.         }  
  307.     }  
  308.     if(NectarSource[maxtrialindex].trail>=limit)  
  309.     {  
  310.         /*******重新初始化*********/  
  311.         for (j=0;j<D;j++)  
  312.         {  
  313.             R=random(0,1);  
  314.             NectarSource[maxtrialindex].code[j]=lb+R*(ub-lb);  
  315.         }  
  316.         NectarSource[maxtrialindex].trail=0;  
  317.         NectarSource[maxtrialindex].trueFit=calculationTruefit(NectarSource[maxtrialindex]);  
  318.         NectarSource[maxtrialindex].fitness=calculationFitness(NectarSource[maxtrialindex].trueFit);  
  319.     }  
  320. }  
  321.   
  322. void MemorizeBestSource()//保存最优的蜜源  
  323. {  
  324.     int i,j;  
  325.     for (i=1;i<FoodNumber;i++)  
  326.     {  
  327.         if (NectarSource[i].trueFit<BestSource.trueFit)  
  328.         {  
  329.             for (j=0;j<D;j++)  
  330.             {  
  331.                 BestSource.code[j]=NectarSource[i].code[j];  
  332.             }  
  333.             BestSource.trueFit=NectarSource[i].trueFit;  
  334.         }  
  335.     }  
  336. }  


附注：本文系转载文章
出处：http://blog.csdn.net/google19890102/article/details/26164653

这篇关于优化算法——人工蜂群算法(ABC)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/992970。

相关文章

Vue3 的 shallowRef 和 shallowReactive：优化性能

Vue3 的 shallowRef 和 shallowReactive：优化性能

大家对 Vue3 的 ref 和 reactive 都很熟悉，那么对 shallowRef 和 shallowReactive 是否了解呢？ 在编程和数据结构中，“shallow”（浅层）通常指对数据结构的最外层进行操作，而不递归地处理其内部或嵌套的数据。这种处理方式关注的是数据结构的第一层属性或元素，而忽略更深层次的嵌套内容。 1. 浅层与深层的对比 1.1 浅层（Shallow） 定义
阅读更多...
不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
HDFS—存储优化（纠删码）

HDFS—存储优化（纠删码）

纠删码原理 HDFS 默认情况下，一个文件有3个副本，这样提高了数据的可靠性，但也带来了2倍的冗余开销。 Hadoop3.x 引入了纠删码，采用计算的方式，可以节省约50％左右的存储空间。 此种方式节约了空间，但是会增加 cpu 的计算。 纠删码策略是给具体一个路径设置。所有往此路径下存储的文件，都会执行此策略。 默认只开启对 RS-6-3-1024k
阅读更多...
康拓展开（hash算法中会用到）

康拓展开（hash算法中会用到）

康拓展开是一个全排列到一个自然数的双射（也就是某个全排列与某个自然数一一对应） 公式： X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。（a[i]在不同应用中的含义不同）； 典型应用： 计算当前排列在所有由小到大全排列中的顺序，也就是说求当前排列是第
阅读更多...
使用opencv优化图片（画面变清晰）

使用opencv优化图片（画面变清晰）

文章目录 需求影响照片清晰度的因素 实现降噪测试代码 锐化空间锐化Unsharp Masking频率域锐化对比测试 对比度增强常用算法对比测试 需求 对图像进行优化，使其看起来更清晰，同时保持尺寸不变，通常涉及到图像处理技术如锐化、降噪、对比度增强等 影响照片清晰度的因素 影响照片清晰度的因素有很多，主要可以从以下几个方面来分析 1. 拍摄设备 相机传感器：相机传
阅读更多...
csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

这是一道扩展欧几里得算法的简单应用题，这题是在湖南多校训练赛中队友ac的一道题，在比赛之后请教了队友，然后自己把它a掉 这也是自己独自做扩展欧几里得算法的题目 题意：把题意转变下就变成了：求d1*x - d2*y = f2 - f1的解,很明显用exgcd来解 下面介绍一下exgcd的一些知识点：求ax + by = c的解 一、首先求ax + by = gcd(a,b)的解 这个
阅读更多...
综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动，这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升：减少抖动，提高图像的清晰度和细节表现力，使得监控画面更加真实可信。 - 细节增强：在低光条件下，抖
阅读更多...
【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...
poj 3974 and hdu 3068 最长回文串的O（n）解法(Manacher算法)

poj 3974 and hdu 3068 最长回文串的O（n）解法(Manacher算法)

求一段字符串中的最长回文串。 因为数据量比较大，用原来的O（n^2）会爆。 小白上的O(n^2)解法代码：TLE啦~ #include<stdio.h>#include<string.h>const int Maxn = 1000000;char s[Maxn];int main(){char e[] = {"END"};while(scanf("%s", s) != EO
阅读更多...
MySQL高性能优化规范

MySQL高性能优化规范

前言：      笔者最近上班途中突然想丰富下自己的数据库优化技能。于是在查阅了多篇文章后，总结出了这篇！ 数据库命令规范 所有数据库对象名称必须使用小写字母并用下划线分割 所有数据库对象名称禁止使用mysql保留关键字（如果表名中包含关键字查询时，需要将其用单引号括起来） 数据库对象的命名要能做到见名识意，并且最后不要超过32个字符 临时库表必须以tmp_为前缀并以日期为后缀，备份
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2