优化算法matlab实现（二十九）秃鹰算法算法matlab实现

矫情吗；* 2023-10-14 15:46 38阅读 0赞

**注意：此代码实现的是求目标函数最大值，求最小值可将适应度函数乘以-1（框架代码已实现）。**

## 1.代码实现 ##

<table> 
 <thead> 
  <tr> 
   <th>文件</th> 
   <th>名描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>..\optimization algorithm\frame\Unit.m</td> 
   <td>个体</td> 
  </tr> 
  <tr> 
   <td>..\optimization algorithm\frame\Algorithm_Impl.m</td> 
   <td>算法主体</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>文件名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>..\optimization algorithm\frame\Get_Functions_details.m</td> 
   <td>测试函数，求值用</td> 
  </tr> 
  <tr> 
   <td>..\optimization algorithm\frame\func_plot.m</td> 
   <td>函数图像，画图用</td> 
  </tr> 
 </tbody> 
</table>

秃鹰算法的个体没有独有属性。  
秃鹰算法个体  
文件名：.. \\optimization algorithm\\algorithm\_bald\_eagle\_search\\BES\_Unit.m

% 秃鹰算法个体
    classdef BES_Unit < Unit
        
        properties
        end
        
        methods
            function self = BES_Unit()
            end
        end
     
    end

秃鹰算法算法主体  
文件名：..\\optimization algorithm\\algorithm\_bald\_eagle\_search\\BES\_Base.m

% 秃鹰算法
    classdef BES_Base  < Algorithm_Impl
        
        properties
            % 算法名称
            name = 'BES';
            c1 = 2;
            c2 = 2;
            alpha = 2;
            a = 10;
            R = 1.5;
    
        end
        
        % 外部可调用的方法
        methods
            function self = BES_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 ='BES';
            end
        end
        
        % 继承重写父类的方法
        methods (Access = protected)
            % 初始化种群
            function init(self)
                init@Algorithm_Impl(self)
                %初始化种群
                for i = 1:self.size
                    unit = BES_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
            end
            
            % 每一代的更新
            function update(self,iter)
                update@Algorithm_Impl(self,iter)
                
                % 选择搜索区域
                self.select_space();
                %搜索
                self.search_in_space();
                %俯冲
                self.swoop();
                
            end
            
            % 选择搜索的区域
            function select_space(self)
                % 计算群体的平均位置
                pos_mean = self.get_mean_pos();
                
                % 遍历每一个个体
                for i = 1:self.size
                    % 计算新位置
                    new_pos = self.position_best + self.alpha*unifrnd(0,1,1,self.dim).*(pos_mean-self.unit_list(i).position);
                    % 越界检查
                    new_pos = self.get_out_bound_value(new_pos);
                    new_value = self.cal_fitfunction(new_pos);
                    % 贪心一下
                    if new_value > self.unit_list(i).value
                         % 更新个体
                         self.unit_list(i).value = new_value;
                         self.unit_list(i).position = new_pos;
                         if new_value > self.value_best
                             % 更新全局最优
                             self.value_best = new_value;
                             self.position_best = new_pos;
                         end
                    end
                end
            end
            
            % 在区域内搜索
            function search_in_space(self)
                % 计算群体的平均位置
                pos_mean = self.get_mean_pos();
                
                % 生成随机theta和r向量，向量长度为总群个数，即一个个体一个值
                theta = self.a*pi*unifrnd(0,1,1,self.size);
                r = theta + self.R*unifrnd(0,1,1,self.size);
                xr = get_xr(theta,r);
                yr = get_yr(theta,r);
                % 获取xr,yr中的最大绝对值
                xr_max = max(abs(xr));
                yr_max = max(abs(yr));
                
                % 遍历每一个个体
                for i = 1:self.size
                    % 第一下一个个体，即最后一个的下一个是第一个
                    if i == self.size
                        next_pos = self.unit_list(1).position;
                    else
                        next_pos = self.unit_list(i+1).position;
                    end
                    
                    % 计算新位置
                    new_pos = self.unit_list(i).position +  xr(i)/xr_max.*(self.unit_list(i).position-pos_mean)+ yr(i)/yr_max.*(self.unit_list(i).position-next_pos) ;
                    % 越界检查
                    new_pos = self.get_out_bound_value(new_pos);
                    new_value = self.cal_fitfunction(new_pos);
                    % 贪心一下
                    if new_value > self.unit_list(i).value
                         % 更新个体
                         self.unit_list(i).value = new_value;
                         self.unit_list(i).position = new_pos;
                         if new_value > self.value_best
                             % 更新全局最优
                             self.value_best = new_value;
                             self.position_best = new_pos;
                         end
                    end
                end
            end
            
            %俯冲
            function swoop(self)
                 % 计算群体的平均位置
                pos_mean = self.get_mean_pos();
                
                % 生成随机theta和r向量，向量长度为总群个数，即一个个体一个值
                theta = self.a*pi*unifrnd(0,1,1,self.size);
                r = theta + self.R*unifrnd(0,1,1,self.size);
                xrl = get_xrl(theta,r);
                yrl = get_yrl(theta,r);
                % 获取xrl,yrl中的最大绝对值
                xrl_max = max(abs(xrl));
                yrl_max = max(abs(yrl));
                
                % 遍历每一个个体
                for i = 1:self.size
                    
                    % 计算新位置
                    new_pos = self.position_best.*unifrnd(0,1,1,self.dim) +  xrl(i)/xrl_max.*(self.unit_list(i).position-self.c1*pos_mean)+ yrl(i)/yrl_max.*(self.unit_list(i).position-self.c2*self.position_best) ;
                    % 越界检查
                    new_pos = self.get_out_bound_value(new_pos);
                    new_value = self.cal_fitfunction(new_pos);
                    % 贪心一下
                    if new_value > self.unit_list(i).value
                         % 更新个体
                         self.unit_list(i).value = new_value;
                         self.unit_list(i).position = new_pos;
                         if new_value > self.value_best
                             % 更新全局最优
                             self.value_best = new_value;
                             self.position_best = new_pos;
                         end
                    end
                end
            end
            
            % 获取种群平均位置
            function pos_mean = get_mean_pos(self)
                pos_mean = zeros(1,self.dim);
                for i=1:self.size
                    pos_mean = pos_mean + self.unit_list(i).position/self.size;
                end
            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 xr = get_xr(theta,r)
    xr = r.*sin(theta);
    end
    
    function yr = get_yr(theta,r)
    yr = r.*cos(theta);
    end
    
    function xrl = get_xrl(theta,r)
    xrl = r.*sinh(theta);
    end
    
    function yrl = get_yrl(theta,r)
    yrl = r.*cosh(theta);
    end

文件名：..\\optimization algorithm\\algorithm\_bald\_eagle\_search\\BES\_Impl.m  
算法实现，继承于Base,图方便也可不写，直接用BES\_Base，这里为了命名一致。

% 秃鹰算法实现
    classdef BES_Impl < BES_Base
       
        % 外部可调用的方法
        methods
            function self = BES_Impl(dim,size,iter_max,range_min_list,range_max_list)
                % 调用父类构造函数设置参数
                 self@BES_Base(dim,size,iter_max,range_min_list,range_max_list);
            end
        end 
    end

## 2.测试 ##

测试F1  
文件名：..\\optimization algorithm\\algorithm\_bald\_eagle\_search\\Test.m

%% 清理之前的数据
    % 清除所有数据
    clear all;
    % 清除窗口输出
    clc;
    
    %% 添加目录
    % 将上级目录中的frame文件夹加入路径
    addpath('../frame')
    
    
    %% 选择测试函数
    Function_name='F1';
    %[最小值，最大值，维度，测试函数]
    [lb,ub,dim,fobj]=Get_Functions_details(Function_name);
    
    %% 算法实例
    % 种群数量
    size = 50;
    % 最大迭代次数
    iter_max = 300;
    % 取值范围上界
    range_max_list = ones(1,dim).*ub;
    % 取值范围下界
    range_min_list = ones(1,dim).*lb;
    
    % 实例化秃鹰算法类
    base = BES_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)]);

![9d3f0e223e624161bde8a9eda8268aae.webp][]

[9d3f0e223e624161bde8a9eda8268aae.webp]: https://img-blog.csdnimg.cn/9d3f0e223e624161bde8a9eda8268aae.webp