精华内容
参与话题
问答
  • 人工蜂群算法

    万次阅读 2018-06-24 15:12:42
    一、人工蜂群算法的介绍 人工蜂群算法(Artificial Bee Colony, ABC)是由Karaboga于2005年提出的一种新颖的基于群智能的全局优化算法,其直观背景来源于蜂群的采蜜行为,蜜蜂根据各自的分工进行不同的活动,并实现...

    一、人工蜂群算法的介绍

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

    二、人工蜂群算法的原理

        1、原理

            标准的ABC算法通过模拟实际蜜蜂的采蜜机制将人工蜂群分为3类: 采蜜蜂、观察蜂和侦察蜂。整个蜂群的目标是寻找花蜜量最大的蜜源。在标准的ABC算法中,采蜜蜂利用先前的蜜源信息寻找新的蜜源并与观察蜂分享蜜源信息;观察蜂在蜂房中等待并依据采蜜蜂分享的信息寻找新的蜜源;侦查蜂的任务是寻找一个新的有价值的蜜源,它们在蜂房附近随机地寻找蜜源。


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

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

     对于函数

    其中

    代码:

    #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;
    			
    		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];
    		}
    
    		/*******采蜜蜂去更新信息*******/
    		Rij=random(-1,1);
    		EmployedBee[i].code[param2change]=NectarSource[i].code[param2change]+Rij*(NectarSource[i].code[param2change]-NectarSource[k].code[param2change]);
    		/*******判断是否越界********/
    		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()//计算轮盘赌的选择概率
    {
    	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;
    		}
    	}
    }
    
    
    /*******只有一只侦查蜂**********/
    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;
    		}
    	}
    }

    展开全文
  • 基于人工蜂群算法的区块链投资组合优化Journal of Computational and Applied Mathematics,Volume 385, 2021.作者:Yulin Deng, Hongfeng Xu, Jie Wu摘要:为了提高资产证券化的安全性并降低投资风险,本文研究了...
    基于人工蜂群算法的区块链投资组合优化Journal of Computational and Applied Mathematics,Volume 385, 2021.作者Yulin Deng, Hongfeng Xu, Jie Wu摘要:为了提高资产证券化的安全性并降低投资风险,本文研究了资产证券化降低风险的方法。首先,利用多种方法来衡量投资的风险和回报,并介绍了几种投资组合方法。其次,资产证券化过程中,存在关于欺诈风险、基础资产和不对称风险的问题。采用区块链技术可以降低这些风险的可能性,提高投资安全性。最后,将人工蜂群(ABC)算法应用于区块链投资组合的优化。由于传统的ABC算法只能解决单目标优化的问题,因此构建了一个外部种群对其进行改进。结果表明,改进的人工蜂群(ABC)算法可以同时优化投资组合中的多个特征,减少投资者的决策误差,提高投资收益与风险之间的平衡。同时,对算法进行评估,发现其准确性和实用性都有一定程度的提高。本文证明了ABC算法可以解决投资组合优化问题,提高资产证券化的安全性,并在一定程度上保证了投资收益与风险的平衡。

    Optimization of blockchain investment portfolio under artificial bee colony algorithm

    Abstract: To improve the security of asset securitization and reduce investment risk, the risk reduction methods of asset securitization are investigated. First, the risk and return of investment are measured using multiple methods, and several portfolio methods are introduced. Second, there are problems of fraud risk, underlying assets, and asymmetry risk when assets are being transformed into securitization. The blockchain technology is used to reduce the probability of these risks and improve investment security. Finally, the artificial bee colony (ABC) algorithm is applied to the optimization of the blockchain investment portfolio. Since the traditional ABC algorithm can only solve the problem of single-objective optimization, an external population is constructed to improve it. The results show that the improved ABC algorithm can simultaneously optimize multiple features in the investment portfolio, reduce the error of investors when making decisions, and improve the balance between investment returns and risks. At the same time, after the algorithm is evaluated, it is found that the accuracy and practicality have been improved to a certain extent. Also, it is proved that the ABC algorithm can solve the problem of portfolio optimization, improve the security of asset securitization, and ensure the balance of investment return and risk to a certain extent.

    翻译:黄子怡bf4f07bd-0120-eb11-8da9-e4434bdf6706.jpeg

    CAFR区块链应用研究

    长按点关注哦~

    c84f07bd-0120-eb11-8da9-e4434bdf6706.jpeg▼▼
    展开全文
  • 基于反向学习的人工蜂群算法 基于反向学习的人工蜂群算法 基于反向学习的人工蜂群算法 基于反向学习的人工蜂群算法基于反向学习的人工蜂群算法基于反向学习的人工蜂群算法
  • 基于人工蜂群的BP神经网络 人工蜂群算法的反向传播神经网络。 基于人工蜂群算法的反向传播神经网络,通过大量尝试提出对神经网络误差调整参数进行优化的方法 BP神经网络 基于人工蜂群的BP神经网络
  • 利用随机过程理论, 对人工蜂群算法收敛性进行理论分析, 给出人工蜂群算法的一些数学定义和蜜源位置 的一步转移概率, 建立人工蜂群算法的Markov 链模型, 分析此Markov 链的一些性质, 论证了人工蜂群状态序列是有...
  • 人工蜂群算法是模仿蜜蜂行为提出的一种优化方法,是集群智能思想的一个具体应用,它的主要特点是不需要了解问题的特殊信息,只需要对问题进行优劣的比较,通过各人工蜂个体的局部寻优行为,最终在群体中使全局最优值...
  • 人工蜂群算法求解VRPSPD问题研究 ,潘冬,高庆萱,针对同时取人工蜂群算法求解VRPSPD问题研究送货车辆路径规划问题,对算法中邻域搜索策略进行研究,提出一种改进的人工蜂群算法。通
  • 人工蜂群算法MATLAB代码,利用人工蜂群算法求解函数优化问题;包括雇佣蜂操作、观察蜂操作、侦查蜂操作,智能优化算法
  • 针对电网故障诊断中的0-1规划问题,从代数和几何角度优化了人工蜂群算法。仿真结果表明,人工蜂群算法具有可行性和合理性,并且综合性能显著优于传统的遗传算法;在两种人工蜂群算法中,基于几何思想的人工蜂群算法具有更...
  • 期刊:Computational Intelligence and Neuroscience论文题目: Transition Control Mechanism for Artificial Bee Colony (ABC) Algorithm(人工蜂群算法的过渡控制机制)作者:Selcuk Aslan,土耳其奥都古兹·玛伊斯...

    期刊: Computational Intelligence and Neuroscience

    论文题目: Transition Control Mechanism for Artificial Bee Colony (ABC) Algorithm(人工蜂群算法的过渡控制机制)

    作者:Selcuk Aslan,土耳其奥都古兹·玛伊斯大学(Ondokuz Mayıs University)计算机工程系

    出版日期:2019年4月

    人工蜂群算法(ABC)是模拟真实蜜蜂复杂的搜索和觅食行为来解决生活中一些多维和多模的优化问题。他是新型智能优化算法,也是集群智能思想的具体应用,其应用前景广阔。

    a84d46877ab1b97d9f05208228242d3e.png

    *图源于作者论文; 被雇佣蜜蜂的不同行为。

    近期,Hindawi旗下期刊Computational Intelligence and Neuroscience近期发表了一篇题为A Transition Control Mechanism for Artificial Bee Colony (ABC) Algorithm的论文。在该研究中,研究人员通过添加一种新的控制机制,改进了人工蜂群算法的搜索能力。在这种新控制机制下,研究人员以控制向舞蹈区过渡的被雇佣蜂为对象,对其决策过程进行了建模。

    19960eadde2fe36a246943b78af567d3.gif 点击阅读原文,查看论文原文

    cf4f435d55a95b798359d175031d7b34.png由查尔斯沃思集团(Charlesworth Group)统筹翻译。

    fcf414e3bbc8857749303865eaf80459.png

    展开全文
  • 人工蜂群算法.txt

    2020-04-14 20:28:38
    人工蜂群算法(Artificial Bee Colony Algorithm, 简称ABC算法)是一个由蜂群行为启发的算法,在2005年由Karaboga小组为优化代数问题而提出。
  • 针对人工蜂群算法收敛速度慢、局部搜索能力差等缺点,提出一种新的改进人工蜂群算法.新算法依据蜜源适应值进行排序,将排序结果作为权值,构造一个虚拟蜜源,即加权中心.若加权中心优于当前最优解,则取代当前最优解,以便...
  • 主要介绍了python如何实现人工蜂群算法,帮助大家更好的利用python进行数据分析,感兴趣的朋友可以了解下
  • 人工蜂群算法 Artificial Bee Colony ABC ? 人工蜂群算法是模仿蜜蜂行为提出的一种优化方法是集 群智能思想的一个具体应用 ? 主要特点是不需要了解问题的特殊信息只需要对问题进 行优劣的比较通过各人工蜂个体的局部...
  • 为了克服人工蜂群算法在处理复杂性问题时收敛速度慢、收敛精度不高、易早熟等缺陷, 在原始人工蜂群算法的基础上引入信息熵. 信息熵本身是不确定性的一种度量, 由信息熵的值来度量人工蜂群算法中跟随蜂选择的不确定性...
  • 优化算法——人工蜂群算法(ABC)

    万次阅读 多人点赞 2014-05-18 21:06:38
    一、人工蜂群算法的介绍 人工蜂群算法(Artificial Bee Colony, ABC)是由Karaboga于2005年提出的一种新颖的基于群智能的全局优化算法,其直观背景来源于蜂群的采蜜行为,蜜蜂根据各自的分工进行不同的活动,并实现...

    一、人工蜂群算法的介绍

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

    二、人工蜂群算法的原理

        1、原理

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

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

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

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

        2、流程

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

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

        对于函数

    其中
    代码:
    #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;
    			
    		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];
    		}
    
    		/*******采蜜蜂去更新信息*******/
    		Rij=random(-1,1);
    		EmployedBee[i].code[param2change]=NectarSource[i].code[param2change]+Rij*(NectarSource[i].code[param2change]-NectarSource[k].code[param2change]);
    		/*******判断是否越界********/
    		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()//计算轮盘赌的选择概率
    {
    	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;
    		}
    	}
    }
    
    
    /*******只有一只侦查蜂**********/
    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;
    		}
    	}
    }
    

    收敛曲线:


    展开全文
  • 人工蜂群算法中有三类蜂群,在寻找蜜源过程中相互转化,最终寻得最优解。
  • 人工蜂群算法.pptx

    2020-02-21 09:20:51
    人工蜂群算法 Artificial Bee ColonyABC ;蜂群算法简介;一 蜜蜂采蜜机理;二 ABC算法原理;1.蜜源初始化;2. 新蜜源的更新搜索公式;3. 观察蜂选择雇佣蜂的概率;4. 侦察蜂的产生;三 控制参数;基本ABC算法的流程为 1: ...
  • 针对人工蜂群算法存在的计算精度不高、收敛速度较慢的缺点,提出一种多搜索策略协同进化的人工蜂群算法.所提出的算法在引领蜂和跟随蜂进行邻域搜索时,动态调整搜索的维数以提高搜索效率,并结合人工蜂群算法不同搜索...

空空如也

1 2 3 4 5 ... 16
收藏数 318
精华内容 127
关键字:

人工蜂群算法