MATLAB 实现灰狼优化算法（GWO）

原创于 2025-08-15 02:04:55 发布 · 745 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#matlab #算法

MATLAB 专栏收录该内容

6 篇文章

订阅专栏

灰狼优化算法（GWO）是一种基于灰狼群体狩猎行为的元启发式优化算法，由 Seyedali Mirjalili 等人于 2014 年提出。它模拟了灰狼社会中的领导等级（α, β, δ, ω）和狩猎过程（包围、追捕、攻击）。

MATLAB 实现灰狼优化算法 (GWO)

1. 核心思想：社会等级 (Social Hierarchy)

GWO 模拟了灰狼群体中严格的等级结构，将搜索代理（即“狼”）分为四个等级：

α (Alpha) 狼：群体的领导者，是最优解。在优化问题中，它代表当前找到的最好个体。所有决策（如狩猎、休息地点）最终由 α 决定。
β (Beta) 狼：第二等级，是 α 的“顾问”和“接班人”，协助 α 做出决策，并管理其他低等级狼。在算法中，它代表次优解。
δ (Delta) 狼：第三等级，包括侦察兵、哨兵、老狼、捕猎者等。它们必须服从 α 和 β，但可以支配 ω。在算法中，它代表第三优解。
ω (Omega) 狼：最低等级，数量最多。它们是群体的“服从者”，最后才能享用食物。在算法中，它们代表其余的候选解。

在 GWO 中，算法始终追踪当前最优的三个解（α, β, δ），并利用它们来指导整个种群的搜索方向。

2. 狩猎行为 (Hunting Behavior)

GWO 模拟了灰狼狩猎的三个主要阶段：

包围 (Encircling)：当灰狼发现猎物后，会逐渐包围它。在算法中，这通过数学模型让其他狼的位置向 α, β, δ 的位置靠拢来实现。
追捕 (Hunting)：α, β, δ 引导狩猎过程，其他狼（ω）跟随。狼群会根据领导者的平均位置来更新自身位置。
攻击 (Attacking)：当猎物停止移动时，狼群发起攻击。在算法中，这对应于当控制参数 a 减小到接近 0 时，狼群位置收敛到最优解附近。

3. 数学模型

GWO 的核心是位置更新方程，它模拟了狼群向猎物（最优解）包围的过程。

距离向量 (D)：
D = |C * X_p(t) - X(t)|
- X_p(t)：猎物（或领导狼 α, β, δ）在第 t 代的位置。
- X(t)：当前狼在第 t 代的位置。
- C = 2 * r₂：一个系数向量，r₂ 是 [0, 1] 区间内的随机向量。C 提供随机性，有助于探索搜索空间。
位置更新向量 (A)：
A = 2 * a * r₁ - a
- a：一个从 2 线性减小到 0 的控制参数。a 控制搜索行为：
  - 当 |A| > 1 时，狼倾向于探索（Exploration），远离当前领导者，搜索新区域。
  - 当 |A| < 1 时，狼倾向于开发（Exploitation），向当前领导者靠近，进行局部搜索。
- r₁：[0, 1] 区间内的随机向量。
位置更新方程：
X(t+1) = X_p(t) - A * D
这个方程描述了狼如何根据与猎物的距离和方向来更新自己的位置。
模拟 α, β, δ 的领导作用：
由于算法不知道真正的最优解（猎物），它使用当前找到的三个最好解（α, β, δ）来近似猎物的位置。最终的位置更新是这三个领导者引导结果的平均值：
```
X₁ = X_α - A₁ * |C₁ * X_α - X|
X₂ = X_β - A₂ * |C₂ * X_β - X|
X₃ = X_δ - A₃ * |C₃ * X_δ - X|
X(t+1) = (X₁ + X₂ + X₃) / 3
```

4. 算法流程

初始化：随机生成一群灰狼（搜索代理）的位置。
评估：计算每只狼的目标函数值。
更新领导者：找出当前最优的三只狼，分别记为 α, β, δ。
更新参数：根据当前迭代次数更新控制参数 a。
更新位置：根据 α, β, δ 的位置和公式更新所有其他狼（ω）的位置。
边界检查：确保更新后的位置在搜索空间范围内。
重复：重复步骤 2-6，直到达到最大迭代次数。
输出：返回 α 狼的位置和适应度值作为最优解。

MATLAB 实现代码

function [Best_score, Best_pos, Convergence_curve] = GWO(SearchAgents_no, Max_iter, lb, ub, dim, fobj)
% GWO: Grey Wolf Optimizer
% 搜索代理数量 (SearchAgents_no): 灰狼数量
% 最大迭代次数 (Max_iter): 算法运行的最大代数
% lb: 变量下界 (dim x 1 向量)
% ub: 变量上界 (dim x 1 向量)
% dim: 问题维度
% fobj: 目标函数句柄
% 输出:
% Best_score: 最优解的目标函数值
% Best_pos: 最优解的位置（变量值）
% Convergence_curve: 收敛曲线（每代最优值）

% 初始化
Alpha_pos = zeros(1, dim);  % 最优解 (α)
Alpha_score = inf;          % 最优解的目标值

Beta_pos = zeros(1, dim);   % 次优解 (β)
Beta_score = inf;

Delta_pos = zeros(1, dim);  % 第三优解 (δ)
Delta_score = inf;

% 随机初始化灰狼位置
Positions = initialization(SearchAgents_no, dim, lb, ub);

Convergence_curve = zeros(1, Max_iter);

% 主循环
for l = 1:Max_iter
    
    for i = 1:size(Positions, 1)
        
        % 边界检查
        Flag4ub = Positions(i, :) > ub;
        Flag4lb = Positions(i, :) < lb;
        Positions(i, :) = (Positions(i, :) .* (~(Flag4ub + Flag4lb))) + ...
                          ub .* Flag4ub + lb .* Flag4lb;
        
        % 计算目标函数值
        fitness = fobj(Positions(i, :));
        
        % 更新 α, β, δ
        if fitness < Alpha_score
            Alpha_score = fitness;              % 更新 α
            Alpha_pos = Positions(i, :);
        end
        
        if fitness > Alpha_score && fitness < Beta_score
            Beta_score = fitness;               % 更新 β
            Beta_pos = Positions(i, :);
        end
        
        if fitness > Alpha_score && fitness > Beta_score && fitness < Delta_score
            Delta_score = fitness;              % 更新 δ
            Delta_pos = Positions(i, :);
        end
    end
    
    % 计算收敛曲线
    Convergence_curve(l) = Alpha_score;
    
    % 更新系数 a, A, C (随迭代线性减小)
    a = 2 - l * (2 / Max_iter); % a 从 2 线性减小到 0
    
    % 更新每只灰狼的位置
    for i = 1:size(Positions, 1)
        for j = 1:size(Positions, 2)
            
            % 计算 A 和 C 向量
            r1 = rand(); % [0,1] 随机数
            r2 = rand(); % [0,1] 随机数
            
            A1 = 2 * a * r1 - a;
            C1 = 2 * r2;
            
            % 影响 α 狼
            D_alpha = abs(C1 * Alpha_pos(1, j) - Positions(i, j));
            X1 = Alpha_pos(1, j) - A1 * D_alpha;
            
            r1 = rand();
            r2 = rand();
            
            A2 = 2 * a * r1 - a;
            C2 = 2 * r2;
            
            % 影响 β 狼
            D_beta = abs(C2 * Beta_pos(1, j) - Positions(i, j));
            X2 = Beta_pos(1, j) - A2 * D_beta;
            
            r1 = rand();
            r2 = rand();
            
            A3 = 2 * a * r1 - a;
            C3 = 2 * r2;
            
            % 影响 δ 狼
            D_delta = abs(C3 * Delta_pos(1, j) - Positions(i, j));
            X3 = Delta_pos(1, j) - A3 * D_delta;
            
            % 更新位置
            Positions(i, j) = (X1 + X2 + X3) / 3;
            
        end
    end
    
    % 可选：显示当前进度
    % fprintf('Iteration %d: Best Score = %f\n', l, Alpha_score);
end

Best_score = Alpha_score;
Best_pos = Alpha_pos;

end

% 初始化函数
function Positions = initialization(SearchAgents_no, dim, lb, ub)
% 随机初始化搜索代理的位置
Boundary_no = size(ub, 2);
if Boundary_no == 1
    Positions = rand(SearchAgents_no, dim) .* (ub - lb) + lb;
else
    for i = 1:dim
        Positions(:, i) = rand(SearchAgents_no, 1) .* (ub(i) - lb(i)) + lb(i);
    end
end
end

使用示例

下面是一个使用上述 GWO 算法优化一个经典测试函数（如 Sphere 函数）的示例：

% 清除工作区
clear; clc; close all;

% 定义优化问题
dim = 10;                    % 问题维度
lb = -100 * ones(1, dim);    % 下界
ub = 100 * ones(1, dim);     % 上界
fobj = @Sphere;               % 目标函数句柄

% GWO 参数
SearchAgents_no = 30;        % 灰狼数量
Max_iter = 1000;             % 最大迭代次数

% 运行 GWO
[Best_score, Best_pos, Convergence_curve] = GWO(SearchAgents_no, Max_iter, lb, ub, dim, fobj);

% 输出结果
fprintf('最优解位置 (Best Position):\n');
disp(Best_pos);
fprintf('最优目标函数值 (Best Score): %f\n', Best_score);

% 绘制收敛曲线
figure;
semilogy(Convergence_curve, 'LineWidth', 2);
xlabel('迭代次数 (Iteration)');
ylabel('最优目标函数值 (Best Score)');
title('灰狼优化算法 (GWO) 收敛曲线');
grid on;

测试函数示例 (Sphere 函数)

function y = Sphere(x)
% Sphere 函数: 全局最小值在 x=0 处，f(x)=0
y = sum(x.^2);
end