优化算法——人工蜂群算法(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(doubledouble);//产生区间上的随机数  
  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

相关文章

SpringBoot中HTTP连接池的配置与优化

《SpringBoot中HTTP连接池的配置与优化》这篇文章主要为大家详细介绍了SpringBoot中HTTP连接池的配置与优化的相关知识,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一... 目录一、HTTP连接池的核心价值二、Spring Boot集成方案方案1:Apache HttpCl

使用雪花算法产生id导致前端精度缺失问题解决方案

《使用雪花算法产生id导致前端精度缺失问题解决方案》雪花算法由Twitter提出,设计目的是生成唯一的、递增的ID,下面:本文主要介绍使用雪花算法产生id导致前端精度缺失问题的解决方案,文中通过代... 目录一、问题根源二、解决方案1. 全局配置Jackson序列化规则2. 实体类必须使用Long封装类3.

PyTorch高级特性与性能优化方式

《PyTorch高级特性与性能优化方式》:本文主要介绍PyTorch高级特性与性能优化方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、自动化机制1.自动微分机制2.动态计算图二、性能优化1.内存管理2.GPU加速3.多GPU训练三、分布式训练1.分布式数据

MySQL中like模糊查询的优化方案

《MySQL中like模糊查询的优化方案》在MySQL中,like模糊查询是一种常用的查询方式,但在某些情况下可能会导致性能问题,本文将介绍八种优化MySQL中like模糊查询的方法,需要的朋友可以参... 目录1. 避免以通配符开头的查询2. 使用全文索引(Full-text Index)3. 使用前缀索

C#实现高性能Excel百万数据导出优化实战指南

《C#实现高性能Excel百万数据导出优化实战指南》在日常工作中,Excel数据导出是一个常见的需求,然而,当数据量较大时,性能和内存问题往往会成为限制导出效率的瓶颈,下面我们看看C#如何结合EPPl... 目录一、技术方案核心对比二、各方案选型建议三、性能对比数据四、核心代码实现1. MiniExcel

Springboot实现推荐系统的协同过滤算法

《Springboot实现推荐系统的协同过滤算法》协同过滤算法是一种在推荐系统中广泛使用的算法,用于预测用户对物品(如商品、电影、音乐等)的偏好,从而实现个性化推荐,下面给大家介绍Springboot... 目录前言基本原理 算法分类 计算方法应用场景 代码实现 前言协同过滤算法(Collaborativ

MySQL索引的优化之LIKE模糊查询功能实现

《MySQL索引的优化之LIKE模糊查询功能实现》:本文主要介绍MySQL索引的优化之LIKE模糊查询功能实现,本文通过示例代码给大家介绍的非常详细,感兴趣的朋友一起看看吧... 目录一、前缀匹配优化二、后缀匹配优化三、中间匹配优化四、覆盖索引优化五、减少查询范围六、避免通配符开头七、使用外部搜索引擎八、分

openCV中KNN算法的实现

《openCV中KNN算法的实现》KNN算法是一种简单且常用的分类算法,本文主要介绍了openCV中KNN算法的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的... 目录KNN算法流程使用OpenCV实现KNNOpenCV 是一个开源的跨平台计算机视觉库,它提供了各

Python通过模块化开发优化代码的技巧分享

《Python通过模块化开发优化代码的技巧分享》模块化开发就是把代码拆成一个个“零件”,该封装封装,该拆分拆分,下面小编就来和大家简单聊聊python如何用模块化开发进行代码优化吧... 目录什么是模块化开发如何拆分代码改进版:拆分成模块让模块更强大:使用 __init__.py你一定会遇到的问题模www.

springboot+dubbo实现时间轮算法

《springboot+dubbo实现时间轮算法》时间轮是一种高效利用线程资源进行批量化调度的算法,本文主要介绍了springboot+dubbo实现时间轮算法,文中通过示例代码介绍的非常详细,对大家... 目录前言一、参数说明二、具体实现1、HashedwheelTimer2、createWheel3、n