注意：此代码实现的是求目标函数最大值，求最小值可将适应度函数乘以-1（框架代码已实现）。
注意：此代码实现的是求目标函数最大值，求最小值可将适应度函数乘以-1（框架代码已实现）。
注意：此代码实现的是求目标函数最大值，求最小值可将适应度函数乘以-1（框架代码已实现）。
1.代码实现
不了解头脑风暴算法可以先看看优化算法笔记（十九）头脑风暴算法
实现代码前需要先完成优化算法matlab实现（二）框架编写中的框架的编写。
| 文件名 | 描述 |
|---|---|
| ..\optimization algorithm\frame\Unit.m | 个体 |
| ..\optimization algorithm\frame\Algorithm_Impl.m | 算法主体 |
以及优化算法matlab实现（四）测试粒子群算法中的测试函数、函数图像的编写。
| 文件名 | 描述 |
|---|---|
| ..\optimization algorithm\frame\Get_Functions_details.m | 测试函数，求值用 |
| ..\optimization algorithm\frame\func_plot.m | 函数图像，画图用 |
头脑风暴算法的个体没有独有属性。
头脑风暴算法个体
文件名：.. \optimization algorithm\algorithm_brain_storm\BSO_Unit.m
% 头脑风暴算法个体
classdef BSO_Unit < Unit
properties
end
methods
function self = BSO_Unit()
end
end
end
头脑风暴算法算法主体
文件名：..\optimization algorithm\algorithm_brain_storm\BSO_Base.m
% 头脑风暴算法
classdef BSO_Base < Algorithm_Impl
properties
% 算法名称
name = 'BSO';
% 聚类数
cluster_num = 5;
p5a = 0.2;
p6b = 0.8;
p6b3 = 0.4;
p6c = 0.5;
k = 20;
% 聚类分组map,key为分组序号，value为个体列表
cluster_map = containers.Map;
% 列表，保存对应的聚类中心
cluster_center_list;
end
% 外部可调用的方法
methods
function self = BSO_Base(dim,size,iter_max,range_min_list,range_max_list)
% 调用父类构造函数
self@Algorithm_Impl(dim,size,iter_max,range_min_list,range_max_list);
self.name ='BSO';
end
end
% 继承重写父类的方法
methods (Access = protected)
% 初始化种群
function init(self)
init@Algorithm_Impl(self)
%初始化种群
for i = 1:self.size
unit = BSO_Unit();
% 随机初始化位置：rand(0,1).*(max-min)+min
unit.position = unifrnd(self.range_min_list,self.range_max_list);
% 计算适应度值
unit.value = self.cal_fitfunction(unit.position);
% 将个体加入群体数组
self.unit_list = [self.unit_list,unit];
end
% 初始化分组
for i = 1:self.cluster_num
self.cluster_map(num2str(i))=[];
end
% 初始化中心
self.cluster_center_list = ones(1,self.cluster_num);
end
% 每一代的更新
function update(self,iter)
update@Algorithm_Impl(self,iter)
self.divide_cluster();
num = 0;
% 每代最多替换一个中心
if (rand<self.p5a)
self.generate_from_center();
num = 1;
end
% 每代只生成size个新个体
while(num<self.size)
self.generate_from_individuals(iter);
num = num + 1;
end
end
% 划分聚类
function divide_cluster(self)
% 初始化分组
for i = 1:self.cluster_num
self.cluster_map(num2str(i))=[];
end
% 初始化中心
self.cluster_center_list = ones(1,self.cluster_num);
% 将种群序列乱序排列
rand_index = randperm(self.size);
% 按照乱序序列对聚类数取模划分聚类
for i = 1:self.size
% 取模的值+1为聚类id
cluster_index = mod(i,self.cluster_num)+1;
self.cluster_map(num2str(cluster_index))=[self.cluster_map(num2str(cluster_index)),rand_index(i)];
end
% 取出每个聚类的聚类中心
for i = 1:self.cluster_num
% 取出该聚类的所有个体id
cluster_id_list = self.cluster_map(num2str(i));
% 遍历取最优的id为聚类中心
self.cluster_center_list(i)=cluster_id_list(1);
for j = 2:length(cluster_id_list(:))
% 如果当前个体的值优于聚类中心的值，则替换
if(self.unit_list(cluster_id_list(j)).value>self.unit_list(self.cluster_center_list(i)).value)
self.cluster_center_list(i) = cluster_id_list(j);
end
end
end
end
% 一定概率替换一个center
function generate_from_center(self)
% 随机选择一个聚类
cluster_id = randperm(self.cluster_num,1);
% 取出聚类中心
cluster_center_id = self.cluster_center_list(cluster_id);
% 随机初始化中心
new_pos = unifrnd(self.range_min_list,self.range_max_list);
new_value = self.cal_fitfunction(new_pos);
self.unit_list(cluster_center_id).position = new_pos;
self.unit_list(cluster_center_id).value = new_value;
end
% 从个人中生成
function generate_from_individuals(self,iter)
if(rand<self.p6b)
% 随机选择一个聚类
cluster_id = randperm(self.cluster_num,1);
if(rand<self.p6b3)
% 选择该聚类的聚类中心
center_id = self.cluster_center_list(cluster_id);
% 加上一个随机数
new_pos = self.generate_add_value(iter,self.unit_list(center_id).position);
new_value = self.cal_fitfunction(new_pos);
if(new_value > self.unit_list(center_id).value)
self.unit_list(center_id).position = new_pos;
self.unit_list(center_id).value = new_value;
end
else
% 选择该聚类的id
cluster_id_list = self.cluster_map(num2str(cluster_id));
% 选择该聚类的随机个体
rand_index = randperm(length(cluster_id_list(:)),1);
rand_id = cluster_id_list(rand_index);
new_pos = self.generate_add_value(iter,self.unit_list(rand_id).position);
new_value = self.cal_fitfunction(new_pos);
if(new_value > self.unit_list(rand_id).value)
self.unit_list(rand_id).position = new_pos;
self.unit_list(rand_id).value = new_value;
end
end
else
% 随机选择两个聚类
cluster_ids = randperm(self.cluster_num,2);
if(rand<self.p6c)
% 合并两个聚类中心
% 选取这两个聚类中心
center_id1 = self.cluster_center_list(cluster_ids(1));
center_id2 = self.cluster_center_list(cluster_ids(2));
% 获得合并后的位置
new_pos = self.generate_combine_unit(self.unit_list(center_id1).position,self.unit_list(center_id2).position);
new_pos = self.generate_add_value(iter,new_pos);
new_value = self.cal_fitfunction(new_pos);
if (new_value > self.unit_list(center_id1).value)
self.unit_list(center_id1).value = new_value;
self.unit_list(center_id1).position = new_pos;
elseif(new_value > self.unit_list(center_id2).value)
self.unit_list(center_id2).value = new_value;
self.unit_list(center_id2).position = new_pos;
end
else
% 合并两个个体
% 选择这两个聚类的随机个体
cluster_id1_list = self.cluster_map(num2str(cluster_ids(1)));
% 随机选择该聚类中的index
rand_index1 = randperm(length(cluster_id1_list(:)),1);
% 该index对应在种群中的id
rand_id1 = cluster_id1_list(rand_index1);
cluster_id2_list = self.cluster_map(num2str(cluster_ids(2)));
rand_index2 = randperm(length(cluster_id2_list(:)),1);
rand_id2 = cluster_id2_list(rand_index2);
% 获得合并后的位置
new_pos = self.generate_combine_unit(self.unit_list(rand_id1).position,self.unit_list(rand_id2).position);
new_pos = self.generate_add_value(iter,new_pos);
new_value = self.cal_fitfunction(new_pos);
if (new_value > self.unit_list(rand_id1).value)
self.unit_list(rand_id1).value = new_value;
self.unit_list(rand_id1).position = new_pos;
elseif(new_value > self.unit_list(rand_id2).value)
self.unit_list(rand_id2).value = new_value;
self.unit_list(rand_id2).position = new_pos;
end
end
end
end
% 合并两个个体思想
function new_pos = generate_combine_unit(self,pos1,pos2)
r = unifrnd(0,1,1,self.dim);
new_pos = pos1.*r+(1-r).*pos2;
new_pos = self.get_out_bound_value(new_pos);
end
% 锦上添花，添加偏移
function new_pos = generate_add_value(self,iter,pos)
new_pos = pos+sigmod((0.5*self.iter_max-iter)/self.k)*unifrnd(0,1,1,self.dim).*normrnd(0,1,1 ,self.dim);
new_pos = self.get_out_bound_value(new_pos);
end
% 获取当前最优个体的id
function best_id=get_best_id(self)
% 求最大值则降序排列
[value,index] = sort([self.unit_list.value],'descend');
best_id = index(1);
end
end
end
function value = sigmod(x)
value = 1./(1+exp(-x));
end
文件名：..\optimization algorithm\algorithm_brain_storm\BSO_Impl.m
算法实现，继承于Base,图方便也可不写，直接用BSO_Base，这里为了命名一致。
% 头脑风暴算法实现
classdef BSO_Impl < BSO_Base
% 外部可调用的方法
methods
function self = BSO_Impl(dim,size,iter_max,range_min_list,range_max_list)
% 调用父类构造函数设置参数
self@BSO_Base(dim,size,iter_max,range_min_list,range_max_list);
end
end
end
2.测试
测试F1
文件名：..\optimization algorithm\algorithm_brain_storm\Test.m
%% 清理之前的数据
% 清除所有数据
clear all;
% 清除窗口输出
clc;
%% 添加框架路径
% 将上级目录中的frame文件夹加入路径
addpath('../frame')
%% 选择测试函数
Function_name='F1';
% [最小值，最大值，维度，测试函数]
[lb,ub,dim,fobj]=Get_Functions_details(Function_name);
%% 算法实例
% 种群数量
size = 50;
% 最大迭代次数
iter_max = 1000;
% 取值范围上界
range_max_list = ones(1,dim)*ub;
% 取值范围下界
range_min_list = ones(1,dim)*lb;
% 实例化头脑风暴算法类
base = BSO_Impl(dim,size,iter_max,range_min_list,range_max_list);
% 告诉算法求不是求最大值
base.is_cal_max = false;
% 确定适应度函数
base.fitfunction =fobj;
% 运行
base.run();
%% 绘制图像
figure('Position',[500 500 660 290])
% Draw search space
subplot(1,2,1);
func_plot(Function_name);
title('Parameter space')
xlabel('x_1');
ylabel('x_2');
zlabel([Function_name,'( x_1 , x_2 )'])
% Draw objective space
subplot(1,2,2);
% 绘制曲线
semilogy(base.value_best_history,'Color','r')
title('Objective space')
xlabel('Iteration');
ylabel('Best score obtained so far');
% 将坐标轴调整为紧凑型
axis tight
% 添加网格
grid on
% 四边都显示刻度
box off
legend(base.name)
display(['The best solution obtained by ',base.name ,' is ', num2str(base.value_best)]);
display(['The best optimal value of the objective funciton found by ',base.name ,' is ', num2str(base.position_best)]);
