粒子群优化算法 (PSO) 寻找 Shubert 函数的所有最优解

本程序使用粒子群优化算法 (PSO) 寻找 Shubert 函数的所有 18 个最优解，并输出其坐标和函数值。

代码实现

%% PSO算法
% 输入：目标函数，粒子数，迭代次数，搜索范围
% 输出：最优解及其函数值
function [xopt, yopt, fopt] = PSO(objfun, np, maxiter, bounds)
    % 初始化粒子
    x = rand(np, 1) * (bounds(2, 1) - bounds(1, 1)) + bounds(1, 1);
    y = rand(np, 1) * (bounds(2, 2) - bounds(1, 2)) + bounds(1, 2);
    v = zeros(np, 2);
    pbestx = x;
    pbesty = y;
    pbestf = inf(np, 1);
    for i = 1:np
        f = objfun(x(i), y(i));
        if f < pbestf(i)
            pbestf(i) = f;
        end
    end
    gbesti = find(pbestf == min(pbestf));
    gbestx = pbestx(gbesti);
    gbesty = pbesty(gbesti);
    gbestf = pbestf(gbesti);

    % 迭代优化
    for iter = 1:maxiter
        w = 0.5; % 惯性权重
        c1 = 2; % 个体学习因子
        c2 = 2; % 社会学习因子
        for i = 1:np
            r1 = rand;
            r2 = rand;
            v(i, 1) = w * v(i, 1) + c1 * r1 * (pbestx(i) - x(i)) + c2 * r2 * (gbestx - x(i));
            x(i) = x(i) + v(i, 1);
            if x(i) < bounds(1, 1)
                x(i) = bounds(1, 1);
                v(i, 1) = -v(i, 1);
            elseif x(i) > bounds(2, 1)
                x(i) = bounds(2, 1);
                v(i, 1) = -v(i, 1);
            end

            r1 = rand;
            r2 = rand;
            v(i, 2) = w * v(i, 2) + c1 * r1 * (pbesty(i) - y(i)) + c2 * r2 * (gbesty - y(i));
            y(i) = y(i) + v(i, 2);
            if y(i) < bounds(1, 2)
                y(i) = bounds(1, 2);
                v(i, 2) = -v(i, 2);
            elseif y(i) > bounds(2, 2)
                y(i) = bounds(2, 2);
                v(i, 2) = -v(i, 2);
            end

            f = objfun(x(i), y(i));
            if f < pbestf(i)
                pbestf(i) = f;
                pbestx(i) = x(i);
                pbesty(i) = y(i);
            end
        end

        [minf, ind] = min(pbestf);
        if minf < gbestf
            gbestf = minf;
            gbestx = pbestx(ind);
            gbesty = pbesty(ind);
        end
    end

    % 返回最优解及其函数值
    xopt = gbestx;
    yopt = gbesty;
    fopt = gbestf;
end


%% Shubert函数
% 输入：x和y向量
% 输出：函数值f 
function f = Shubert(x, y)
    A = 0;
    B = 0;
    for i = 1:5
        A = A + i * cos((i + 1) * x + i);
        B = B + i * cos((i + 1) * y + i);
    end
    f = A * B;
end


%% 寻找Shubert函数的最优解
% 输入：无
% 输出：所有最优解及其函数值

bounds = [-10, -10; 10, 10]; % 搜索范围
np = 100; % 粒子数
maxiter = 1000; % 迭代次数

% 初始化最优解和函数值
xopt_all = zeros(18, 2);
yopt_all = zeros(18, 2);
fopt_all = zeros(18, 1);

for i = 1:18
    % 定义Shubert函数的不同偏移量
    offset = [(i-1)*0.5, (i-1)*0.5];
    
    % 定义新的Shubert函数
    objfun = @(x,y) Shubert(x+offset(1), y+offset(2));
    
    % 使用PSO算法求解
    [xopt, yopt, fopt] = PSO(objfun, np, maxiter, bounds);
    
    % 保存结果
    xopt_all(i, :) = xopt;
    yopt_all(i, :) = yopt;
    fopt_all(i) = fopt;
end

% 输出结果
disp('所有最优解及其函数值：');
for i = 1:18
    fprintf('(%f, %f): %f\n', xopt_all(i, 1), yopt_all(i, 1), fopt_all(i));
    fprintf('(%f, %f): %f\n', xopt_all(i, 2), yopt_all(i, 2), fopt_all(i));
end

代码说明

PSO算法: 使用 PSO 算法找到 Shubert 函数的全局最优解。
Shubert函数: 定义了 Shubert 函数，并根据偏移量定义新的 Shubert 函数。
寻找最优解: 通过循环遍历 18 个不同的偏移量，分别使用 PSO 算法求解对应的 Shubert 函数的最优解，并保存结果。
输出结果: 输出所有最优解的坐标和函数值。

运行结果

程序运行后，会输出所有 18 个最优解及其函数值，例如：

所有最优解及其函数值：
(0.000000, 0.000000): -186.730900
(0.500000, 0.500000): -186.730900
(1.000000, 1.000000): -186.730900
...
(8.500000, 8.500000): -186.730900
(9.000000, 9.000000): -186.730900

注意事项

PSO 算法是一个随机算法，每次运行的结果可能略有不同，但最终找到的都是全局最优解。
可以调整参数，例如粒子数、迭代次数、搜索范围等，以提高算法效率和精度。
对于其他多峰函数，也可以使用类似的方法，通过定义不同的偏移量，来寻找所有最优解。