13种改进粒子群优化算法 matlab2022 运行结果和耗时对比
前言
阅读粒子群优化算法的文章，发现代码不仅要付费而且还没有运行结果，需要自己手动写代码运行，这里提供下我的运行结果。包含参数结果和耗时对比。
https://www.bilibili.com/read/cv11905136/?spm_id_from=333.999.0.0
% 定义适应度函数
fitness = @(x) x^6 - 3.5*x^4 + 4.3*x^3 + 2*x^2 + 0.8*x + 7;
% 定义初始参数
N = 100; % 初始种群个数
c1 = 2.5;
c2 = 1.6;
w = 0.5; %权重
lamda = 0.5; % 退火参数
M = 100; % 迭代次数
D = 1; % 空间维数
c1max = 3;
c1min = 0.3;
c2max = 2;
c2min = 0.2;
wmax = 0.8;
wmin = 0.3;
mean_max = 5;
mean_min = 0.5;
sigma = 0.5;
Pc = 0.9; % 杂交概率
Sp = 0.2; % 杂交池的大小比例
xmax = 8;
xmin =0.5;
MaxC = 6;
tic
[xm, fv] = PSO(fitness,N,c1,c2,w,M,D); %基于模拟退火的粒子群优化算法
disp(['PSO 最佳结果:', num2str(xm)]);
disp(['PSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['PSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = SimuAPSO(fitness, N, c1, c2, lamda, M, D); %基于模拟退火的粒子群优化算法
disp(['SimuAPSO 最佳结果:', num2str(xm)]);
disp(['SimuAPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['SimuAPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = YSPSO(fitness,N,c1,c2,M,D); %带压缩因子的粒子群优化算法
disp(['YSPSO 最佳结果:', num2str(xm)]);
disp(['YSPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['YSPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = AsyLnCPSO(fitness,N,c1max,c1min,c2max,c2min,w,M,D); %学习因子异步化的粒子群优化算法
disp(['AsyLnCPSO 最佳结果:', num2str(xm)]);
disp(['AsyLnCPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['AsyLnCPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = LinWPSO(fitness,N,c1,c2,wmax,wmin,M,D); %线性递减权重粒子群优化
disp(['LinWPSO 最佳结果:', num2str(xm)]);
disp(['LinWPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['LinWPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = SAPSO(fitness,N,c1,c2,wmax,wmin,M,D); %自适应权重粒子群优化算法
disp(['SAPSO 最佳结果:', num2str(xm)]);
disp(['SAPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['SAPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = RandWPSO(fitness,N,c1,c2,mean_max,mean_min,sigma,M,D); %随机权重粒子群优化算法
disp(['RandWPSO 最佳结果:', num2str(xm)]);
disp(['RandWPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['RandWPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = BreedPSO(fitness,N,c1,c2,w,Pc,Sp,M,D); %基于杂交的粒子群优化算法
disp(['BreedPSO 最佳结果:', num2str(xm)]);
disp(['BreedPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['BreedPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = SecPSO(fitness,N,w,c1,c2,M,D); %二阶粒子群优化算法
disp(['SecPSO 最佳结果:', num2str(xm)]);
disp(['SecPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['SecPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = CLSPSO(fitness,N,c1,c2,w,xmax,xmin,M,MaxC,D); %混沌粒子群优化算法
disp(['CLSPSO 最佳结果:', num2str(xm)]);
disp(['CLSPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['CLSPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = LnCPSO(fitness,N,c1max,c1min,w,M,D); %学习因子同步变化的粒子群优化算法
disp(['LnCPSO 最佳结果:', num2str(xm)]);
disp(['LnCPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['LnCPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = SecVibratPSO(fitness,N,w,c1,c2,M,D); %二阶震荡粒子群优化算法
disp(['SecVibratPSO 最佳结果:', num2str(xm)]);
disp(['SecVibratPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['SecVibratPSO 历时: ' num2str(toc) ' seconds']); %计时结束
tic
[xm, fv] = SelPSO(fitness,N,c1,c2,w,M,D); %基于自然选择的粒子群优化算法
disp(['SelPSO 最佳结果:', num2str(xm)]);
disp(['SelPSO 最佳适应度值: ', num2str(fv)]);
elapsed_time = toc; % 获取结束时间
disp(['SelPSO 历时: ' num2str(toc) ' seconds']); %计时结束
运行测试结果如下：
PSO 最佳结果:-1.8256
PSO 最佳适应度值: -15.8147
PSO 历时: 0.11757 seconds
SimuAPSO 最佳结果:-1.827
SimuAPSO 最佳适应度值: -15.8146
SimuAPSO 历时: 0.024802 seconds
YSPSO 最佳结果:-1.8256
YSPSO 最佳适应度值: -15.8147
YSPSO 历时: 0.016281 seconds
AsyLnCPSO 最佳结果:-1.8256
AsyLnCPSO 最佳适应度值: -15.8147
AsyLnCPSO 历时: 0.017485 seconds
LinWPSO 最佳结果:-1.8256
LinWPSO 最佳适应度值: -15.8147
LinWPSO 历时: 0.01629 seconds
SAPSO 最佳结果:-1.8256
SAPSO 最佳适应度值: -15.8147
SAPSO 历时: 0.020679 seconds
RandWPSO 最佳结果:-1.8212
RandWPSO 最佳适应度值: -15.8133
RandWPSO 历时: 0.015598 seconds
BreedPSO 最佳结果:-1.8256
BreedPSO 最佳适应度值: -15.8147
BreedPSO 历时: 0.26581 seconds
SecPSO 最佳结果:-1.8268
SecPSO 最佳适应度值: -15.8146
SecPSO 历时: 0.014972 seconds
CLSPSO 最佳结果:-1.8261
CLSPSO 最佳适应度值: -15.8147
CLSPSO 历时: 0.033095 seconds
LnCPSO 最佳结果:-1.8256
LnCPSO 最佳适应度值: -15.8147
LnCPSO 历时: 0.015699 seconds
SecVibratPSO 最佳结果:-1.8257
SecVibratPSO 最佳适应度值: -15.8147
SecVibratPSO 历时: 0.017549 seconds
SelPSO 最佳结果:-1.8256
SelPSO 最佳适应度值: -15.8147
SelPSO 历时: 0.017709 seconds
运行上面的代码要把这些算法保存成函数在matlab才能调用，像下图这样：
其中AsyLnCPSO.m
function [xm,fv] = AsyLnCPSO(fitness,N,c1max,c1min,c2max,c2min,w,M,D)
format long;
%------初始化种群的个体------------
for i=1:N
for j=1:D
x(i,j)=randn; %随机初始化位置
v(i,j)=randn; %随机初始化速度
end
end
%------先计算各个粒子的适应度，并初始化Pi和Pg----------------------
for i=1:N
p(i)=fitness(x(i,:));
y(i,:)=x(i,:);
end
pg = x(N,:); %Pg为全局最优
for i=1:(N-1)
if fitness(x(i,:))<fitness(pg)
pg=x(i,:);
end
end
%------进入主要循环，按照公式依次迭代------------
for t=1:M
c1 = c1max - (c1max - c1min)*t/M;
c2 = c2max - (c2max - c2min)*t/M;
for i=1:N
v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
x(i,:)=x(i,:)+v(i,:);
if fitness(x(i,:))<p(i)
p(i)=fitness(x(i,:));
y(i,:)=x(i,:);
end
if p(i)<fitness(pg)
pg=y(i,:);
end
end
Pbest(t)=fitness(pg);
end
xm = pg';
fv = fitness(pg);
BreedPSO.m
function [xm,fv] = BreedPSO(fitness,N,c1,c2,w,Pc,Sp,M,D)
%Pc 杂交概率
%Sp 杂交池的大小比例
format long;
%------初始化种群的个体------------
for i=1:N
for j=1:D
x(i,j)=randn; %随机初始化位置
v(i,j)=randn; %随机初始化速度
end
end
%------先计算各个粒子的适应度，并初始化Pi和Pg----------------------
for i=1:N
p(i)=fitness(x(i,:));
y(i,:)=x(i,:);
end
pg = x(N,:); %Pg为全局最优
for i=1:(N-1)
if fitness(x(i,:))<fitness(pg)
pg=x(i,:);
end
end
%------进入主要循环，按照公式依次迭代------------
for t=1:M
for i=1:N
v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
x(i,:)=x(i,:)+v(i,:);
if fitness(x(i,:))<p(i)
p(i)=fitness(x(i,:));
y(i,:)=x(i,:);
end
if p(i)<fitness(pg)
pg=y(i,:);
end
r1 =rand();
if r1 < Pc
numPool = round(Sp*N);
PoolX = x(1:numPool,:);
PoolVX = v(1:numPool,:);
for i=1:numPool
seed1 = floor(rand()*(numPool-1)) + 1;
seed2 = floor(rand()*(numPool-1)) + 1;
pb = rand();
childx1(i,:) = pb*PoolX(seed1,:) + (1-pb)*PoolX(seed2,:);
childv1(i,:) = (PoolVX(seed1,:) + PoolVX(seed2,:))*norm(PoolVX(seed1,:))/ ...
norm(PoolVX(seed1,:) + PoolVX(seed2,:));
end
x(1:numPool,:) = childx1;
v(1:numPool,:) = childv1;
end
end
end
xm = pg';
fv = fitness(pg);
CLSPSO.m
function [xm,fv] = CLSPSO(fitness,N,c1,c2,w,xmax,xmin,M,MaxC,D)
format long;
%------初始化种群的个体------------
for i=1:N
for j=1:D
x(i,j)=randn; %随机初始化位置
v(i,j)=randn; %随机初始化速度
end
end
%------先计算各个粒子的适应度，并初始化Pi和Pg----------------------
for i=1:N
p(i)=fitness(x(i,:));
y(i,:)=x(i,:);
end
pg = x(N,:); %Pg为全局最优
for i=1:(N-1)
if fitness(x(i,:))<fitness(pg)
pg=x(i,:);
end
end
%------进入主要循环，按照公式依次迭代------------
for t=1:M
for i=1:N
v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
x(i,:)=x(i,:)+v(i,:);
fv(i) = fitness(x(i,:));
end
[sort_fv,index] = sort(fv);
Nbest = floor(N*0.2);
for n=1:Nbest
tmpx = x(index(n),:);
for k=1:MaxC
for dim=1:D
cx(dim) = (tmpx(1,dim) - xmin(dim))/(tmpx(1,dim) - xmax(dim));
cx(dim) = 4*cx(dim)*(1 - cx(dim));
tmpx(1,dim) = tmpx(1,dim) + cx(dim)*(xmax(dim) - xmin(dim));
end
fcs = fitness(tmpx);
if fcs < sort_fv(n)
x(index(n),:) = tmpx;
break;
end
end
x(index(n),:) = tmpx;
end
r = rand();
for s=1:D
xmin(s) = max(xmin(s) , pg(s) - r*(xmax(s) - xmin(s)));
xmax(s) = min(xmax(s) , pg(s) + r*(xmax(s) - xmin(s)));
end
x(1:Nbest, :) = x(index(1:Nbest),:);
for i=(Nbest+1):N
for j=1:D
x(i,j)= xmin(j) + rand*(xmax(j) - xmin(j)); %随机初始化位置
v(i,j)= randn; %随机初始化速度
end
end
Pbest(t)=fitness(pg);
for i=1:N
if fitness(x(i,:))<p(i)
p(i)=fitness(x(i,:));
y(i,:)=x(i,:);
end
if p(i)<fitness(pg)
pg=y(i,:);
end
end
end
xm = pg';
fv = fitness(pg);
LinWPSO.m
function [xm,fv] = LinWPSO(fitness,N,c1,c2,wmax,wmin,M,D)
format long;
%------初始化种群的个体------------
for i=1:N
for j=1:D
x(i,j)=randn; %随机初始化位置
v(i,j)=randn; %随机初始化速度
end
end
%------先计算各个粒子的适应度，初始化Pi和Pg----------------------
for i=1:N
p(i)=fitness(x(i,:));
y(i,:)=x(i,:);
end
pg=x(N,:); %Pg为全局最优
for i=1:(N-1)
if fitness(x(i,:))<fitness(pg)
pg=x(i,:);
end
end
%------进入主要循环，按照公式依次迭代------------
for t=1:M
for i=1:N
w = wmax - (t-1)*(wmax-wmin)/(M-1);
v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
x(i,:)=x(i,:)+v(i,:);
if fitness(x(i,:))<p(i)
p(i)=fitness(x(i,:));
y(i,:)=x(i,:);
end
if p(i)<fitness(pg)
pg=y(i,:);
end
end
Pbest(t)=fitness(pg);
end
xm = pg';
fv = fitness(pg);