0、 Background

This paper is PSO Improved version , Using local optimal variables lbest It replaces the previous global optimal variable gbest. Although the actual effect has not been improved on a large scale , But it is also a new idea .

Eberhart R, Kennedy J. A new optimizer using particle swarm theory[C]//MHS'95. Proceedings of the sixth international symposium on micro machine and human science. Ieee, 1995: 39-43.

1、lbest PSO

The standard PSO Algorithm and implementation ： standard PSO.

This paper introduces a “ Local “ Version of optimizer , Besides pbest( The best solution of each particle tracking ); also lbest, It is obtained in the local topological neighborhood of particles , Is a local optimal solution . Particles are not directed pbest and gbest（ The best evaluation in the whole group ） Move , But to pbest and “lbest” Defined point movement .

for example , stay K=2 In the model , The particle (i) Values and particles of (i-1) And particles (i+1) Compare , then lbest(i) For the smallest of the three ( When finding the minimum value of a function ), Not the minimum of all particles .

In a sense , Use local neighborhood to update the next location , In this way, the update direction of each particle will not all face the globally optimal position , Improved population diversity , Avoid falling into a local optimal situation .

2、 Algorithm implementation

The standard PSO The algorithm was mentioned in the previous linked blog , It mainly shows lbest PSO The implementation of the .

The algorithm is updated every iteration 20000 Time , Repeat the experiment 100 Time , Then take the average .

function f = Rastrigin(x)
% the Rastrigin function
% xi = [-5.12,5.12]
d = size(x,2);
f = 10*d + sum(x.^2 - 10*cos(2*pi*x),2);
end

clc;clear;clearvars;
%  Random generation 5 Data 
num_initial = 10;
num_vari = 30;
%  Search range 
upper_bound = 5.12;
lower_bound = -5.12;
iter = 20000;
w = 1;
%  Domain size 
k = 2;
%  Random generation 5 Data , And obtain its evaluation value 
sample_x = lhsdesign(num_initial, num_vari).*(upper_bound - lower_bound) + lower_bound.*ones(num_initial, num_vari);
sample_y = Rastrigin(sample_x);
Fmin = zeros(iter, 1);
aver_Fmin = zeros(iter, 1);

for n = 1 : 100
    k1 = 1;
    %  Initialize some parameters 
    pbestx = sample_x;
    pbesty = sample_y;
    %  Current location information presentx
    presentx = lhsdesign(num_initial, num_vari).*(upper_bound - lower_bound) + lower_bound.*ones(num_initial, num_vari);
    vx = sample_x;
    fprintf("n: %.4f\n", n);
    lbest = zeros(num_initial, num_vari);
    for i = 1 : iter
        index = 1;
        r = rand(num_initial, num_vari);
        % pso Update the location of the next step , Here you can set the boundary if it exceeds the search range 
        vx = w.*vx + 2 * r .* (pbestx - presentx) + 2 * r .* (lbest - presentx);
        vx(vx > upper_bound) = upper_bound;
        vx(vx < lower_bound) = lower_bound;
        presentx = presentx + vx;
        presentx(presentx > upper_bound) = upper_bound;
        presentx(presentx < lower_bound) = lower_bound;
        presenty = Rastrigin(presentx);
        %  Update the best location for each individual 
        pbestx(presenty < pbesty, :) = presentx(presenty < pbesty, :);
        pbesty(presenty < pbesty, :) = presenty(presenty < pbesty, :);
        %  Update each individual lbest
        n1 = ceil(k / 2);
        n2 = floor(k / 2);
        %  Process the beginning 
        for i1 = 1 : n1
            [~, ind] = min(pbesty(1 : (1 + k), 1));
            lbest(index, :) = pbestx(ind, :);
            index = index + 1;
        end
        %  Deal with the middle part 
        for i2 = 1 : (num_initial - k)
            [~, ind] = min(pbesty(i2 : (i2 + k), 1));
            lbest(index, :) = pbestx(i2 + ind - 1, :);
            index = index + 1;
        end
        %  Deal with the end 
        for i3 = 1 : n2
            [~, ind] = min(pbesty((num_initial - k) : num_initial, 1));
            lbest(index, :) = pbestx(num_initial - k + ind - 1, :);
            index = index + 1;
        end
        [fmin, ~] = min(pbesty);
        % fprintf("iter %d fmin: %.4f\n", i, fmin);
        Fmin(k1, 1) = fmin;
        k1 = k1 +1;
    end
    aver_Fmin = aver_Fmin + Fmin;
end
aver_Fmin = aver_Fmin ./ 100;
% disp(pbestx(gbest, :));
plot(aver_Fmin);

PSO The experimental results of ：

  lbest PSO When K=2 When the experimental results ：

  lbest PSO When K=5 When the experimental results ：

You can see from the picture above , These three have similar performance , There's only a small difference .lbest PSO(K=5)>PSO>lbest PSO(K=2). Although the actual effect has not improved , But its idea of updating towards the local optimal location may also be worth learning from other algorithms , After all, many of the essence of algorithms are interlinked .