BSO算法介绍及Java实现

头脑风暴过程

头脑风暴法经常被用来解决创新问题。它可以解决很多通常不能由一个人解决的难题。在头脑风暴过程中，一群背景不同的人聚集在一起进行讨论。引导者通常会参与这个过程，但不会直接参与想法的产生。引导者通常应该有足够的引导者经验，但对要解决的问题的了解较少，这样产生的想法就会较少受到来自引导者的认知的影响。头脑风暴的过程是用来产生尽可能多的想法，这样就可以从这些想法中得到解决问题的好办法。

头脑风暴的过程通常包括几轮想法的产生。在每一轮的想法生成中，头脑风暴小组都被要求提出很多想法。在每一轮的想法生成过程结束时，比较好的想法会被挑选出来，作为下一轮创意生成过程中产生想法的线索。在头脑风暴的过程中，还有另外一群人，他们的目的是从每一轮的想法产生过程中挑选出比较好的想法，通过头脑风暴的过程，由人类的集体智慧，往往会产生伟大的解决方案，并且我们的问题通常能够以很高的概率得到解决。

头脑风暴流程建模如下

头脑风暴(BSO)算法简介

受人类创造性解决问题过程——头脑风暴会议的启发， 2011年史玉回老师在第二次群体智能国际会议 (The Second International Conference on Swarm Intelligence(ICSI11)) 中提出一种新的群智能优化算法——头脑风暴优化算法，算法采用聚 类思想搜索局部最优，通过局部最优的比较得到全局最优；采用变异思想增加了算法的多 样性，避免算法陷入局部最优，在这聚与散相辅相承的过程中搜索最优解，思想新颖，适合于解决多峰高维函数问题。

算法流程建模如下

算法步骤描述(流程纯Word手打，转载请注明出处！)：

使用Java实现BSO算法

注：为了演示效果，本示例选择Sphere函数作为适应值函数来评价个体。维度设置为2维，且迭代次数仅仅设定20代。

Sphere函数定义如下：

package BSO_Code;

import java.util.ArrayList;
import java.util.Random;

/**
 * 头脑风暴智能优化算法实现
 * @author xudaxia0610
 */
public class BSO {
   
	
	//个体数量
	public int number_of_individuals;
		
	//聚类个数
	public int number_of_clusters;
	
	//种群
	public ArrayList<Cindividual> population;
	
	//类簇
	public ArrayList<ArrayList<Integer>> cluster;
	
	//质心集合
	public ArrayList<Cindividual> meansList;
	
	//存放类中心所在下标的集合
	public ArrayList<Integer> clusterCenterIndex;
	
	//新解集合
	public ArrayList<Cindividual> nSolutions;
	
	//最优个体
	public Cindividual bestIndividual;
	
	//下面四个为预先决定的概率
	public float p_clustering;
	public float p_generation;
	public float p_oneCluster;
	public float p_twoCluster;
	
	//下面四个为算法执行过程中生成的比例
	public float r_clustering;
	public float r_generation;
	public float r_oneCluster;
	public float r_twoCluster;
	
	//个体的维数
	public int dimension;
	
	// 迭代次数
	public int total_evolve_times;
	
	// 当前迭代的次数
	public int current_evolve_times;
	
	//随机数生成器
	public Random random = new Random();
	
	//参数k，此k非聚类k的个数，而是新个体产生的公式中变异系数中那个控制斜率的K
	public int k;
	
	//交叉生成新个体时,父母的权重比例
	public float weight1;
	public float weight2;
	
	//参数初始化
	public void initParameters() {
   
		
		//解的维数
		dimension = 2;
		//个体数量(种群大小)
		number_of_individuals = 100;
		//聚类个数
		number_of_clusters = 5;
		
		//初始化各个集合
		cluster = new ArrayList<>();
		clusterCenterIndex = new ArrayList<>();
		nSolutions = new ArrayList<>();
		meansList = new ArrayList<>();
		
		//决定是否需要替换一个类中心的概率
		p_clustering = 0.2f;
		//决定新个体产生是由一个还是两个老个体所决定的概率
		p_generation = 0.8f; 
		//决定由一个类中心还是其它普通个体来生成新个体的概率
		p_oneCluster = 0.4f;
		//决定由两个类中心还是其它两个普通个体来生成新个体的概率
		p_twoCluster = 0.5f;
		
		//总迭代次数
		total_evolve_times = 20;
		//当前迭代次数
		current_evolve_times = 0;
		
		//初始化k，变异操作控制斜率的参数
		k = 25;
		
		//初始化权重
		weight1 = 0.5f;
		weight2 = 0.5f;
		
		//初始化最优个体
		bestIndividual = new Cindividual();
		bestIndividual.lChromosome = new ArrayList<>();
		for(int i = 0; i < dimension; i++) {
   
			bestIndividual.lChromosome.add(1.0f);
		}
		//将初始化的最优个体的Object_value设为最大值，因为object_value越小越好
		bestIndividual.objectValue = Float.MAX_VALUE;
	}
	
	//种群初始化
	public void initPopulation() {
   
		population = new ArrayList<>();
		for(int i = 0;i < number_of_individuals;i++) {
   
			//生成一个新个体
			Cindividual t = new Cindividual();
			t.lChromosome = new ArrayList<>();
			//随机初始化这个个体
			initIndividual(t);
			//根据适应值函数评价该个体
			evaluate(t);
			//更新最优个体
			updateBestIndividual(t);
			//将该个体的引用置入种群中
			population.add(t);
		}
	}
	
	//初始化一个个体
	public void initIndividual(Cindividual t) {
   
		for(int i = 0;i < dimension;i++) {
   
			t.lChromosome.add(random.nextFloat() * 200.0f - 100.0f);
		}
	}
	
	//适应值函数评价个体
	public void evaluate(Cindividual t) {
   
		//此处实现的是最简单的Sphere函数(单峰函数)
		t.objectValue = 0.0f;
		float cur = 0.0f;
		for(int i = 0; i < dimension; i++)<