A small project written in college may not be updated in the future.

[introduction]PSO Lab is designed for auxiliary research of particle swarm optimization, verification algorithm, joint algorithm comparison

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Dependencies used by the environment, with * is optional, not required

• MATLAB Live Editor `version: R2016a or above
• *Parallel Computing Toolbox `Not provided, if necessary, please purchase and install it yourself, see official website.
• GUI Layout Toolbox `version 2.3.5 is provided, or higher versions can be installed by yourself

1. Change directory to PSO_Lab
2. Type the following command in the command window and complete the parts that need to be manually installed according to the pop-up window prompts

cd PSO_Lab

run_lab setup

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Current command include setup, help, zip, tar, clear, select.

• setup

Installation environment and related dependencies.

• help

Type the following command in the command window to view the help documentation.

run_lab help

• zip, tar

Compress PSO Lab, the files in these directories in the compressed package will not be preserved:

.\.temp

.\data

.\test

Type the following command in the command window to compress:

run_lab zip

run_lab tar

• clear

Clear Lab's cache (excluding log files), if it contains some running data cache that may not be saved, the user will be prompted whether to delete it.

Type the following command in the command window to Clear Lab's cache:

run_lab clear

• select

Select profiles and modes in the form of pop-up windows, type the following command in the command window to compress:

run_lab select

• syntax

run_lab [config] [mode]

• description

PSO Lab will run in config and mode.

*config composition: full directory of config files(recommend) or relative directory

*mode composition: optimize, par-optimize, search

e.g. Run PSO_Lab\config\benchmark\single\basepso\basepso_primary_unimodal_1_benchmark_config.m by typing the following command in the command window:

run_lab
.\config\benchmark\single\basepso\basepso_primary_unimodal_1_benchmark_config.m
optimize

e.g. or if you know the full directory of config files like

run_lab
E\PSO_Lab\config\benchmark\single\basepso\basepso_primary_unimodal_1_benchmark_config.m
optimize

How to write a configuration file

How to choose mode

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

The configuration file exists in the form of a function file, and the configuration information is passed by returning a structure.

*Parameters with support search in search mode

• fitness function

Specifically, the fitness fucntion here is supposed to be a function handle, which can handle vectors.

e.g.1

function stc = config

...



fit_function_handle = @(x) x(5) + sum(abs(x)) - x(6);



stc.fit_fun = fit_function_handle;



...

end

e.g.2

function stc = config

...



stc.fit_fun = @fit_function;



...

end



function val = fit_function(x)

val = sum(abs(x(1:end - 1) - x(2:end)));

end

It should be noted that the fitness function handle that does not meet the specification will be detected and the program will be interrupted.

*If you need to test the algorithm, you can use the test functions encapsulated in the PSO_Lab\lib\util\math_util library.

It has four test levels:primary, medium, advanced, precision; and the test function types are divided into unimodal and multimodal.

A note on test levels:

1)primary

dimension: 30

scope of the variable: [-100, 100]

test function: alternative

2)medium

dimension: 100

scope of the variable: [-1000, 1000]

test function: alternative

3)advanced

dimension: 1000

scope of the variable: [-10000, 10000]

test function: alternative

4)precision

dimension: 1000

scope of the variable: [9994.88, 10005.12]

test function:

To choose a test level, you can use the following code:

testfun_stc = math_util().test_function("primary");

testfun_stc = math_util().test_function("medium");

testfun_stc = math_util().test_function("advanced");

testfun_stc = math_util().test_function("precision");

A note on function type:

1)unimodal

test function 1: minimum:0

test function 2: minimum:0

test function 3: minimum:0

test function 4: minimum:0

test function 5: minimum:0

test function 6: minimum:0

test function 7: minimum:0

2)multimodal

test function 1: minimum:-12569.5

*There are some problem with the minimum value of this test function.

test function 2: minimum:0

test function 3: minimum:0

test function 4: minimum:0

test function 5: minimum:0

test function 6: minimum:0

*

*

As long as the test level and function type are determined, the variable range and dimension can also be determined.

e.g.Select primary and unimodal test function 1 with dimension 1000

function stc = config

testfun_stc = math_util().test_function("primary");

...

%fitness function

stc.fit_fun = testfun_stc.unimodal().fun1.function;



...

%size [number of dimensions, number of particles]

stc.size = [testfun_stc.varset.dim, 1000];



...

end

*With whose fitness function that needs to be constrained by constraints, add the corresponding constraint code to the corresponding algorithm.

(PSO_Lab\algorithm\... method: checkRestrictions() )

• save data

If you need to save the data after the end of the run, set save to true:

function stc = config

...

stc.save = true;

...

end

• parallel processing

see Parallel Computing

• algorithm

function stc = config

...

stc.algorithm = "BasePSO";

...

end

Algorithms currently available include:

BasePSO

PPSO (Perturbation PSO)

PCPSO (Perturbation-based Cauchy-variation PSO)

ERPSO (Experience Replay PSO)

TSPSO (exTremum disturbed and Simple PSO)

CPSO (Chaos PSO)

*You can also write your own algorithm and save it with a unique file name in the directory: PSO_Lab\algorithm\.

And add the incentive generation code for the algorithm optimizer in the file:PSO_Lab\pso_lab\lab_generate_optimizer.m

see Algorithm coding specification

see Algorithm optimizer coding specification

There are two configuration options for the algorithm in the configuration file:

one algorithm for optimize mode and par-optimize mode

algorithm vector for search mode

• size of the iteration

function stc = config

...

stc.size = [30, 1000];

...

end

The size of this iteration is defined by a 1*2 row vector: [ dimensions, number of particles]

• Maximum number of iterations

function stc = config

...

stc.num_Iter = 1000;

...

end

The final iteration end condition that does not meet other iteration end conditions.

• Print evaluation cycle

function stc = config

...

stc.evalu_times = 100;

...

end

• Exit condition

function stc = config

...

stc.fit_tolerance = 1e-8;

stc.max_tolerance_times = 100;

...

end

The exit condition is not necessary and can be set to an empty array.

• Basic algorithm parameter settings

function stc = config

%dimensions:30

...

stc.idvlLrnFactor = 1.5;

stc.soclLrnFactor = 2.05;

...

stc.w_range = [0.4; 0.9];

...

stc.var_range = repmat([-100, 100], 30, 0);

...

d_var = abs(stc.var_range(:, 1) - stc.var_range(:, 2));

stc.v_range = 0.05 * [-d_var, d_var];

...

end

individual learning factor (default 1.5)

social learning factor (default 2.05)

*In order to adapt to the specific fitness function, the above two parameters can be used to find more suitable parameters

using the search mode before the final determination.

e.g. Determine the best individual learning factor of BasePSO at test level at primary, unimodal test function 1 (social learning factor is 2.05)

@PSO_Lab\config\benchmark\parameter\basepso\idvlLrnFactor

run_lab .\config\benchmark\parameter\basepso\idvlLrnFactor\basepso_primary_unimodal_1_idvlLrnFactor_benchmark_config.m search

Inertia weight range

Specification: 1*2 row vector [min, max].

variable range

Specification: matrix of dimension * 2, the range of the ith dimension is the i-th row of the matrix [min, max].

speed range

The same specification as variable range.

• Specific algorithm parameter configuration

see below:

BasePSO

PPSO (Perturbation PSO)

PCPSO (Perturbation-based Cauchy-variation PSO)

ERPSO (Experience Replay PSO)

TSPSO (exTremum disturbed and Simple PSO)

CPSO (Chaos PSO)

• In order to ensure the adaptability of the environment, the configuration function file is best saved in the directory: PSO_Lab\config

@PSO_Lab\config\benchmark\joint\joint_all_primary_unimodal_1_benchmark_config.m (code for search mode)

%Joint simulation, all algorithms, primary, unimodal test function 1

function stc = joint_all_primary_unimodal_1_benchmark_config

testfun_stc = math_util().test_function("primary");



%Save Data

stc.save = true;



%parallel processing

stc.para_enable = true;

stc.para_num = 4;

%% Basic configuration



%Fitness function

stc.fit_fun = testfun_stc.unimodal().fun1.function;



%Algorithm used

stc.algorithm = [ "BasePSO", "PPSO", "PCPSO", "ERPSO", "TSPSO", "CPSO"];



%size

stc.num_dim = testfun_stc.varset.dim;

stc.num_particle = 1000;



%Maximum Iterations (1000 by default)

stc.num_Iter = 1000;



%Individual factor

stc.idvlLrnFactor = 1.5;

%Social factor

stc.soclLrnFactor = 2.05;



%Inertia weight range [lower bound, upper bound] (default 0.4~0.9)

stc.w_range = [0.4; 0.9];



%Variable range [lower bound, upper bound;...] (dimension * 2)

stc.var_range = testfun_stc.varset.var_range;

%Speed range [lower bound, upper bound;...] (dimension * 2)

d_var = abs(stc.var_range(:, 1) - stc.var_range(:, 2));

stc.v_range = 0.05 * [-d_var, d_var];



%Each evaluation iteration number (100 by default, no need to empty the
evaluation)

stc.evalu_times = 100;



%Exit conditions (minimum fitness change tolerance, the number of times to
reach the minimum fitness tolerance, not used is empty)

stc.fit_tolerance = [];

stc.max_tolerance_times = [];



%% BasePSO

stc.basepso.enable = true;



%% PPSO

stc.ppso.enable = true;



%% PCPSO

stc.pcpso.enable = true;

%Tolerance of fitness for opening Cauchy variation

stc.pcpso.variation_tolerance = inf;



%% TSPSO

stc.tspso.enable = true;



%Individual Stagnation Steps Threshold and Global Stagnation Steps Threshold
(3 and 5 by default)

stc.tspso.idvlStagnantTh = 3;

stc.tspso.soclStagnantTh = 5;



%% ERPSO

stc.erpso.enable = true;



%Experience size

stc.erpso.memory_size = 16384;



%Experience learning factor (default 0.3)

stc.erpso.expLrnFactor = 0.3;



%Experience learning opens tolerance

stc.erpso.exp_tolerance = 1e+5;



%% CPSO

stc.cpso.enable = true;



%Chaotic Iterative Control Parameters

stc.cpso.chaos_mu = 4;



%Length of chaotic sequence

stc.cpso.chaos_length = 500;

end

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Algorithms are stored in the directory: PSO_Lab\algorithm

PSO Lab recommends that all algorithms be a subclass of BasePSO, so that you can just redefine some methods.

Properties of BasePSO:

It is better not to change the dimension of the same property used by inheritance, so as to avoid some unspeakable errors.

classdef BasePSO < handle

...

properties

%-----particle properties------

pst %particle position: dimension * number of particles

v %Particle velocity: dimension * number of particles

fitness %Fitness: 1*Number of particles

w %Inertia weight of each particle: 1*Number of particles

%-----Iterative process record-----

idvlPstBest %Best particle history: dimension * number of particles

idvlFitBest %The best fitness of particle history: 1*number of particles

soclPstBest %Best Collective History: Dimension*1

soclFitBest %Collective historical: best fitness 1*1

idvlFitBestAvgArray %Record the average best fitness of particles

soclFitBestArray %Record the global optimal fitness

%-----iteration parameters-----

num_particles %Number of particles

num_dim %Number of Dimensions/Number of Variables

idvlLrnFactor %individual learning factor

soclLrnFactor %social learning factor

cttFactor %contraction factor

w_range %Inertia weight range (lower bound, upper bound): 2*1

v_range %Speed range (lower bound, upper bound): dimension*2

var_range %Variable range (lower bound, upper bound): dimension*2

evalu_enable %enable evaluation

evalu_times %Iterations per evaluation

num_Iter %The maximum number of iterations

%-----Exit conditions-----

exit_enable %Allow conditional exit

fit_tolerance

max_tolerance_times

fit_fun %fitness function

end

...

end

Methods of BasePSO:

For specific implementation, please refer to the code: PSO_Lab\algorithm\BasePSO

classdef BasePSO < handle

...

%base function

methods

function obj = BasePSO(num_particle, num_dim, idvl, socl, wr, vr, varr,
num_Iter, fit_fun, evalu_times, fit_tolerance, max_tolerance_times)

...

end

%Test the fitness function

function result = test_fitfun(~, fitfun)

...

end

%iterative optimization

function stc = search(obj, disp_stc, tnum)

...

end

end

%Iterative correlation function

methods(Access = protected)

%Calculate fitness

function cal_fitness(obj)

...

end

%Update fitness related parameters

function update_fit(obj)

...

end

%Update particle parameters

function update_particle(obj)

...

end

%Update adaptive parameters

function update_adappara(obj)

...

end

%initialization

function reset(obj)

...

end

%Restrictions

function checkRestrictions(~)

end

%Check exit conditions

function result = check_exit(obj)

...

end

%Packed data

function stc = data_backup(obj)

...

end

end

...

end

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

*Dependency:Parallel Computing Toolbox

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Modify the configuration file to enable parallel processing.

function config

...

stc.para_enable = true;

stc.para_num = 4;



...

end

para_num: the amount of parallel processing, limited by the local computer, recommended 4 or a divisor of 4.

A non-searching configuration, like other configurations in optimize mode, uses multiple threads to run the same configuration to pick acceptable results.

e.g.So configuration ( @PSO_Lab\config\benchmark\single\basepso\basepso_primary_unimodal_1_benchmark_config.m ) can be run in two modes:

%single thread operation(run after disableing Parallel Computing)

run_lab
.\config\benchmark\single\basepso\basepso_primary_unimodal_1_benchmark_config.m
optimize

%multi-threaded operation(run after enableing Parallel Computing)

run_lab
.\config\benchmark\single\basepso\basepso_primary_unimodal_1_benchmark_config.m
par-optimize

Contains search configuration, search configuration can only contain one item.

Currently supported search configurations include:

• Algorithm
• Individual learning factors
• Social Learning Factors
• *Tolerance of fitness for opening Cauchy variation(PCPSO)
• *Individual Stagnation Steps Threshold(TSPSO)
• *Global Stagnation Steps Threshold(TSPSO)
• *Chaotic Iterative Control Parameters(CPSO)
• *Length of chaotic sequence(CPSO)

The item with * is the search configuration of the specific algorithm.

Search specification: represented as a vector.

e.g. (@PSO_Lab\config\benchmark\joint\joint_all_primary_unimodal_1_benchmark_config.m)search configuration for Algorithm, see specific code.

run_lab
.\config\benchmark\joint\joint_all_primary_unimodal_1_benchmark_config.m
search