优化算法matlab实现(三十)海底捕食者算法matlab实现

注意:此代码实现的是求目标函数最大值,求最小值可将适应度函数乘以-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_marine_predator\MPA_Unit.m

% 海底捕食者算法个体
classdef MPA_Unit < Unit
   
   properties
       % 猎物位置
       position_prey
   end
   
   methods
       function self = MPA_Unit()
       end
   end

end

文件名:.. \optimization algorithm\algorithm_marine_predator\MPA_Base.m

% 海底捕食者算法
classdef MPA_Base  < Algorithm_Impl
   
   properties
       % 算法名称
       name = 'MPA';
       FADs = 0.2;
   end
   
   % 外部可调用的方法
   methods
       function self = MPA_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 ='MPA';
       end
   end
   
   % 继承重写父类的方法
   methods (Access = protected)
       % 初始化种群
       function init(self)
           init@Algorithm_Impl(self)
           %初始化种群
           for i = 1:self.size
               unit = MPA_Unit();
               % 随机初始化位置:rand(0,1).*(max-min)+min
               unit.position = unifrnd(self.range_min_list,self.range_max_list);
               unit.position_prey = unit.position;
               % 计算适应度值
               unit.value = self.cal_fitfunction(unit.position);
               % 将个体加入群体数组
               self.unit_list = [self.unit_list,unit];
           end
       end
       
       % 每一代的更新
       function update(self,iter)
           update@Algorithm_Impl(self,iter)
           if (iter< self.iter_max/3)
               self.phase1();
           elseif(iter< self.iter_max*2/3)
               self.phase2(iter);
           else
               self.phase3(iter);
           end
           self.update_elite();

           self.update_FADs(iter);
       end
       
       % 阶段一:前1/3
       function phase1(self)
            for i = 1:self.size
                prey_new = zeros(1,self.dim);
                step_size = normrnd(0,1,1,self.dim).*(self.unit_list(i).position - self.unit_list(i).position_prey);
                prey_new = self.unit_list(i).position_prey + unifrnd(0,0.5,1,self.dim).*step_size;
                % 越界检查
                prey_new = self.get_out_bound_value(prey_new);
                % 保存
                self.unit_list(i).position_prey = prey_new;
            end
       end
       
       % 阶段二:1/3-2/3
       function phase2(self,iter)
           cf = self.get_cf(iter);
           for i = 1:self.size
               prey_new = zeros(1,self.dim);
               if i < self.size/2
                   step_size = Levy(self.dim).*(self.unit_list(i).position - self.unit_list(i).position_prey);
                   prey_new = self.unit_list(i).position_prey + unifrnd(0,0.5,1,self.dim).*step_size;
               else
                   step_size = normrnd(0,1,1,self.dim).*(self.unit_list(i).position - self.unit_list(i).position_prey);
                   prey_new = self.unit_list(i).position + 0.5*cf*step_size;
               end
                % 越界检查
                prey_new = self.get_out_bound_value(prey_new);
                % 保存
                self.unit_list(i).position_prey = prey_new;
           end
       end
       
       % 阶段三:2/3-1
       function phase3(self,iter)
           cf = self.get_cf(iter);
           for i = 1:self.size
                step_size = Levy(self.dim).*(self.unit_list(i).position - self.unit_list(i).position_prey);
                prey_new = self.position_best + 0.5*cf*step_size;
                % 越界检查
                prey_new = self.get_out_bound_value(prey_new);
                % 保存
                self.unit_list(i).position_prey = prey_new;
            end
       end
       
       % 更新精英个体
       function update_elite(self)
           for i = 1:self.size
               value = self.cal_fitfunction(self.unit_list(i).position_prey);
               if value > self.unit_list(i).value
                   self.unit_list(i).value = value;
                   self.unit_list(i).position = self.unit_list(i).position_prey;
               end
           end
       end
       
       function update_FADs(self,iter)
           cf = self.get_cf(iter);
           for i = 1:self.size
               prey_new = zeros(1,self.dim);
               % 随机选择两个个体可以相同
               r1 = unidrnd(self.size);
               r2 = unidrnd(self.size);
               
               % 产生一个dim维的0-1整数序列
               U = unidrnd(2,1,self.dim)-1;
               % 产生一个dim维的0-1浮点数序列
               r = unifrnd(0,1,1,self.dim);
               I = r <= self.FADs;
               J = r > self.FADs;
               
               prey_new(I) = self.unit_list(i).position_prey(I) + cf*U(I).*unifrnd(self.range_min_list(I),self.range_max_list(I));
               prey_new(J) = self.unit_list(i).position_prey(J) + (self.FADs*(1-r(J))+r(J)).*(self.unit_list(r1).position_prey(J) - self.unit_list(r2).position_prey(J));
               % 越界检查
               prey_new = self.get_out_bound_value(prey_new);
               % 保存
               self.unit_list(i).position_prey = prey_new;
           end
       end

       function cf = get_cf(self,iter)
           cf = power((1-iter/self.iter_max), 2.0*iter/self.iter_max);
       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 o=Levy(d)
beta=1.5;
sigma=(gamma(1+beta)*sin(pi*beta/2)/(gamma((1+beta)/2)*beta*2^((beta-1)/2)))^(1/beta);
u=randn(1,d)*sigma;v=randn(1,d);step=u./abs(v).^(1/beta);
o=step;
end

文件名:..\optimization algorithm\algorithm_marine_predator\MPA_Impl.m
算法实现,继承于Base,图方便也可不写,直接用MPA_Base,这里为了命名一致。

% 海底捕食者算法实现
classdef MPA_Impl < MPA_Base
  
   % 外部可调用的方法
   methods
       function self = MPA_Impl(dim,size,iter_max,range_min_list,range_max_list)
           % 调用父类构造函数设置参数
            self@MPA_Base(dim,size,iter_max,range_min_list,range_max_list);
       end
   end 
end 

2.测试

测试F1
文件名:..\optimization algorithm\algorithm_marine_predator\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 = MPA_Impl(dim,size,iter_max,range_min_list,range_max_list);
base.is_cal_max = false;
% 确定适应度函数
base.fitfunction = fobj;
% 运行
base.run();
disp(base.cal_fit_num);

%% 绘制图像
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);
% 绘制曲线,由于算法是求最大值,适应度函数为求最小值,故乘了-1,此时去掉-1
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)]);

你可能感兴趣的:(优化算法matlab实现(三十)海底捕食者算法matlab实现)