粒子群优化算法Matlab源程序
(完整word版)基本粒子群算法的原理和matlab程序.doc
基本粒子群算法的原理和matlab 程序作者—— niewei120 (nuaa)一、粒子群算法的基本原理粒子群优化算法源自对鸟群捕食行为的研究,最初由Kennedy 和 Eberhart 提出,是一种通用的启发式搜索技术。
一群鸟在区域中随机搜索食物,所有鸟知道自己当前位置离食物多远,那么搜索的最简单有效的策略就是搜寻目前离食物最近的鸟的周围区域。
PSO 算法利用这种模型得到启示并应用于解决优化问题。
PSO 算法中,每个优化问题的解都是粒子在搜索空间中的位置,所有的粒子都有一个被优化的目标函数所决定的适应值,粒子还有一个速度值决定它们飞翔的方向和距离,然后粒子群就追随当前的最优粒子在解空间中搜索。
PSO 算法首先在给定的解空间中随机初始化粒子群,待优化问题的变量数决定了解空间的维数。
每个粒子有了初始位置与初始速度。
然后通过迭代寻优。
在每一次迭代中,每个粒子通过跟踪两个“极值”来更新自己在解空间中的空间位置与飞翔速度。
第一个极值就是单个粒子本身在迭代过程中找到的最优解粒子,这个粒子叫做个体极值。
另一个极值是种群所有粒子在迭代过程中所找到的最优解粒子,这个粒子是全局极值。
上述的方法叫全局粒子群算法。
如果不用种群所有粒子而只用其中一部分作为该粒子的邻居粒子,那么在所有邻居粒子中的极值就是局部极值,该方法称为局部PSO 算法。
速度、位置的更新方程表示为:每个粒子自身搜索到的历史最优值p i,p i=(p i1 ,p i2 ,....,p iQ ), i=1,2,3,....,n 。
所有粒子搜索到的最优值p g, p g=(p g1 ,p g2,....,p gQ ),注意这里的p g只有一个。
是保持原来速度的系数,所以叫做惯性权重。
是粒子跟踪自己历史最优值的权重系数,它表示粒子自身的认识,所以叫“认知”。
通常设置为 2 。
是粒子跟踪群体最优值的权重系数,它表示粒子对整个群体知识的认识,所以叫做“社会知识”,经常叫做“社会”。
粒子群算法matlab程序
粒子群算法matlab程序粒子群算法(PSO)是一种基于群体智能的求解优化问题的算法。
其通过模拟鸟群等大规模群体行为,实现全局搜索和基于群体协作的局部搜索。
在PSO中,通过一组粒子(每个粒子代表一个解)来搜索问题的解空间,在搜索过程中,粒子的位置表示该解在解空间中的位置,速度表示该解在该方向(即属性)上的变化速率,最终达到全局最优解或局部最优解。
PSO算法有着简单易懂、实现简便、计算速度快以及易于与其他算法结合等优点。
下面我将介绍一下如何使用matlab编写简单的粒子群算法程序。
程序主要分为以下步骤:1.初始化在程序开始之前需要对粒子进行初始化操作,其中需要确定粒子群的大小、每个粒子的位置、速度等初始参数。
2.计算适应值计算每个粒子的适应值,即根据当前位置计算该解的适应值。
适应值可以根据实际问题进行定义,如最小化目标函数或最大化收益等。
3.更新粒子速度和位置这一步是PSO算法的核心步骤,通过改变粒子的速度和位置来找到更优的解。
其核心公式为:v(t+1) = w * v(t) + c1 * rand() * (pbest - x(t)) + c2 * rand() * (gbest - x(t)) x(t+1) = x(t) + v(t+1)其中w是惯性权重,c1、c2是学习因子,pbest是该粒子的历史最优解,gbest 是当前全局最优解。
4.更新pbest和gbest在每次更新位置之后需要更新每个粒子自己的历史最优解以及全局最优解。
5.停止条件判断设定停止条件,如最小适应值误差、迭代次数、最大迭代次数等,如果达到了停止条件,则程序结束,输出全局最优解。
下面是一份简单的PSO算法的matlab代码:function [best_fit, best_x] = pso(func, dim, lb, ub, max_iter, swarm_size, w, c1, c2)%初始化粒子v = zeros(swarm_size, dim);x = repmat(lb, swarm_size, 1) + repmat(ub - lb, swarm_size, 1) .* rand(swarm_size, dim);pbest = x;[best_fit, best_idx] = min(func(x));gbest = x(best_idx,:);%开始迭代for iter = 1 : max_iter%更新速度和位置v = w * v + c1 * rand(swarm_size, dim) .* (pbest - x) + c2 * rand(swarm_size, dim) .* repmat(gbest, swarm_size, 1) - x;x = x + v;%边界处理x = max(x, repmat(lb, swarm_size, 1));x = min(x, repmat(ub, swarm_size, 1));%更新pbest和gbestidx = func(x) < func(pbest);pbest(idx,:) = x(idx,:);[min_fit, min_idx] = min(func(pbest));if min_fit < best_fitbest_fit = min_fit;best_x = pbest(min_idx,:);endendend在使用上述代码时,需要定义适应值函数(func)、解空间维度(dim)、每个维度的上界(ub)与下界(lb)、最大迭代次数(max_iter)、粒子群大小(swarm_size)、惯性权重(w)、学习因子(c1、c2)等参数。
pso算法matlab代码
pso算法matlab代码pso算法是一种优化算法,全称为粒子群优化算法(Particle Swarm Optimization)。
它模拟了鸟群或者鱼群的行为,通过不断地迭代寻找最优解。
在许多优化问题中,pso算法都有着良好的表现,特别是在连续空间的优化问题中。
在matlab中实现pso算法并不复杂,以下是一个简单的例子:```matlabfunction [best_pos, best_val] = pso_algorithm(fitness_func,num_particles, num_iterations, range)% 初始化粒子的位置和速度positions = rand(num_particles, length(range)) .* (range(2) - range(1)) + range(1);velocities = rand(num_particles, length(range)) .* (range(2) - range(1)) + range(1);% 初始化每个粒子的最佳位置和适应度值personal_best_pos = positions;personal_best_val = arrayfun(fitness_func, personal_best_pos);% 初始化全局最佳位置和适应度值[global_best_val, global_best_idx] = min(personal_best_val);global_best_pos = personal_best_pos(global_best_idx, :);% 开始迭代for iter = 1:num_iterations% 更新粒子的速度和位置inertia_weight = 0.9 - iter * (0.5 / num_iterations); % 慢慢减小惯性权重cognitive_weight = 2;social_weight = 2;r1 = rand(num_particles, length(range));r2 = rand(num_particles, length(range));velocities = inertia_weight .* velocities + ...cognitive_weight .* r1 .* (personal_best_pos - positions) + ...social_weight .* r2 .* (global_best_pos - positions);positions = positions + velocities;% 更新每个粒子的最佳位置和适应度值new_vals = arrayfun(fitness_func, positions);update_idx = new_vals < personal_best_val;personal_best_pos(update_idx, :) = positions(update_idx, :);personal_best_val(update_idx) = new_vals(update_idx);% 更新全局最佳位置和适应度值[min_val, min_idx] = min(personal_best_val);if min_val < global_best_valglobal_best_val = min_val;global_best_pos = personal_best_pos(min_idx, :);endendbest_pos = global_best_pos;best_val = global_best_val;end```上面的代码实现了一个简单的pso算法,其中`fitness_func`是待优化的目标函数,`num_particles`是粒子数量,`num_iterations`是迭代次数,`range`是变量的范围。
改进粒子群算法matlab代码
改进粒子群算法matlab代码粒子群算法是一种基于群体智能的优化算法,其主要思想是将优化问题转化为粒子在搜索空间中寻找最优解的过程。
粒子群算法的运作方式是通过定义一群随机粒子,并根据它们在搜索空间中的位置和速度,来引导粒子向着更好的解决方案进行搜索。
以下是改进版粒子群算法的MATLAB代码:%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 粒子群算法-改进版%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 初始化参数和粒子群function [gbest_x, gbest_y] = PSO(num_particles,max_iterations, f, lower_bound, upper_bound)% 定义粒子群基本参数w = 0.7; % 惯性权重c1 = 1.4; % 学习因子1c2 = 1.4; % 学习因子2% 初始化粒子位置和速度particles_position = unifrnd(lower_bound, upper_bound, [num_particles, 2]);particles_velocity = zeros(num_particles, 2);% 初始化个体最优解和全局最优解pbest_position = particles_position;pbest_value = zeros(num_particles, 1);for i = 1:num_particlespbest_value(i) = f(particles_position(i,:));end[global_min_value, global_min_index] = min(pbest_value); gbest_position = particles_position(global_min_index, :);gbest_value = global_min_value;% 迭代优化for iter = 1:max_iterationsfor i = 1:num_particles% 更新粒子速度particles_velocity(i,:) = w *particles_velocity(i,:) ...+ c1 * rand() * (pbest_position(i,:) -particles_position(i,:)) ...+ c2 * rand() * (gbest_position -particles_position(i,:));% 限制粒子速度范围particles_velocity(i,1) = max(particles_velocity(i,1), lower_bound);particles_velocity(i,1) = min(particles_velocity(i,1), upper_bound);particles_velocity(i,2) = max(particles_velocity(i,2), lower_bound);particles_velocity(i,2) = min(particles_velocity(i,2), upper_bound);% 更新粒子位置particles_position(i,:) = particles_position(i,:) + particles_velocity(i,:);% 限制粒子位置范围particles_position(i,1) = max(particles_position(i,1), lower_bound);particles_position(i,1) = min(particles_position(i,1),upper_bound);particles_position(i,2) = max(particles_position(i,2), lower_bound);particles_position(i,2) = min(particles_position(i,2), upper_bound);% 更新个体最优解temp_value = f(particles_position(i,:));if temp_value < pbest_value(i)pbest_value(i) = temp_value;pbest_position(i,:) = particles_position(i,:);endend% 更新全局最优解[temp_min_value, temp_min_index] = min(pbest_value);if temp_min_value < gbest_valuegbest_value = temp_min_value;gbest_position = pbest_position(temp_min_index,:);endend% 返回全局最优解gbest_x = gbest_position(1);gbest_y = gbest_position(2);end其中,num_particles为粒子数目,max_iterations为最大迭代次数,f为目标函数句柄,lower_bound和upper_bound为搜索空间的下界和上界。
粒子群优化算法介绍及matlab程序
粒子群优化算法(1)—粒子群优化算法简介PSO算法就是模拟一群鸟寻找食物的过程,每个鸟就是PSO中的粒子,也就是我们需要求解问题的可能解,这些鸟在寻找食物的过程中,不停改变自己在空中飞行的位置与速度。
大家也可以观察一下,鸟群在寻找食物的过程中,开始鸟群比较分散,逐渐这些鸟就会聚成一群,这个群忽高忽低、忽左忽右,直到最后找到食物。
这个过程我们转化为一个数学问题。
寻找函数y=1-cos(3*x)*exp(-x)的在[0,4]最大值。
该函数的图形如下:当x=0.9350-0.9450,达到最大值y=1.3706。
为了得到该函数的最大值,我们在[0, 4]之间随机的洒一些点,为了演示,我们放置两个点,并且计算这两个点的函数值,同时给这两个点设置在[0, 4]之间的一个速度。
下面这些点就会按照一定的公式更改自己的位置,到达新位置后,再计算这两个点的值,然后再按照一定的公式更新自己的位置。
直到最后在y=1.3706这个点停止自己的更新。
这个过程与粒子群算法作为对照如下:这两个点就是粒子群算法中的粒子。
该函数的最大值就是鸟群中的食物。
计算两个点函数值就是粒子群算法中的适应值,计算用的函数就是粒子群算法中的适应度函数。
更新自己位置的公式就是粒子群算法中的位置速度更新公式。
下面演示一下这个算法运行一次的大概过程:第一次初始化第一次更新位置第二次更新位置第21次更新最后的结果(30次迭代)最后所有的点都集中在最大值的地方。
粒子群优化算法(2)—标准粒子群优化算法在上一节的叙述中,唯一没有给大家介绍的就是函数的这些随机的点(粒子)是如何运动的,只是说按照一定的公式更新。
这个公式就是粒子群算法中的位置速度更新公式。
下面就介绍这个公式是什么。
在上一节中我们求取函数y=1-cos(3*x)*exp(-x)的在[0, 4]最大值。
并在[0,4]之间放置了两个随机的点,这些点的坐标假设为x1=1.5,x2=2.5;这里的点是一个标量,但是我们经常遇到的问题可能是更一般的情况—x 为一个矢量的情况,比如二维z=2*x1+3*x22的情况。
粒子群算法解决VRP代码(matlab)
粒子群算法解决VRP代码(matlab)particle_swarm_optimization.m文件:function PSOforTSP%初始化Alpha=0.25; %个体经验保留概率Beta=0.25; %全局经验保留概率NC_max=100; %最大迭代次数m=80; %微粒数CityNum=14; %问题的规模(城市个数)[dislist,Clist]=tsp(CityNum);NC=1;%迭代计数器R_best=zeros(NC_max,CityNum); %各代最佳路线L_best=inf.*ones(NC_max,1);%各代最佳路线的长度L_ave=zeros(NC_max,1);%各代路线的平均长度%产生微粒的初始位置for i=1:mx(i,:)=randperm(CityNum);L(i)=CalDist(dislist,x(i,:));endp=x; %p为个体最好解pL=L;[L_best(1,1) n_best]=min(L);R_best(1,:)=x(n_best,:);L_ave(1,1)=mean(L);%初始交换序v=ones(CityNum-1,2,m)*(round(rand*(CityNum-1))+1);figure(1);while NC<=NC_max %停止条件之一:达到最大迭代次数for i=1:mxnew(i,:)=changeFun(x(i,:),v(:,:,i));A=changeNum(x(i,:),p(i,:));Arand=randFun(A,Alpha);xnew(i,:)=changeFun(xnew(i,:),Arand);B=changeNum(x(i,:),R_best(NC,:));Brand=randFun(B,Beta);xnew(i,:)=changeFun(xnew(i,:),Brand);v(:,:,i)=changeNum(x(i,:),xnew(i,:));L(i)=CalDist(dislist,xnew(i,:));if L(i)<pl(i)< p="">p(i,:)=xnew(i,:);pL(i)=L(i);endend[L_bestnew n_best]=min(L);R_bestnew=xnew(n_best,:);L_ave(NC+1,1)=mean(L);if L_bestnew<l_best(nc,1)< p="">L_best(NC+1,1)=L_bestnew;R_best(NC+1,:)=R_bestnew;elseL_best(NC+1,1)=L_best(NC,1);R_best(NC+1,:)=R_best(NC,:);endx=xnew;drawTSP10(Clist,R_best(NC,:),L_best(NC,1),NC,0); %pause;NC=NC+1;end%输出结果Pos=find(L_best==min(L_best));Shortest_Route=R_best(Pos(1),:);Shortest_Length=L_best(Pos(1)); figure(2);plot([L_best L_ave]);legend('最短距离','平均距离'); endfunction xnew=changeFun(x,C); changeLen=size(C,1);xnew=x;for i=1:changeLena=xnew(C(i,1));xnew(C(i,1))=xnew(C(i,2));xnew(C(i,2))=a;endendfunction C=changeNum(x,y); CityNum=size(x,2);C=ones(CityNum-1,2);for i=1:CityNum-1pos=find(x==y(i));C(i,:)=[i pos];x=changeFun(x,C(i,:));endendfunction v=randFun(v,w);randLen=size(v,1);for i=1:randLenif rand>wv(i,2)=v(i,1);endendendfunction F=CalDist(dislist,s)%计算回路路径距离DistanV=0;n=size(s,2);for i=1:(n-1)DistanV=DistanV+dislist(s(i),s(i+1));endDistanV=DistanV+dislist(s(n),s(1));F=DistanV;endfunction [DLn,cityn]=tsp(n)city14=[0 0;0.3 0.334;0.08 0.433;0.166 0.456;0.5 0.4439;0.2439 0.1463;0.1207 0.2293;0.2293 0.761;0.6171 0.9414;0.8732 0.6536;0.6878 0.5219;0.8488 0.3609;0.6683 0.2536;0.6195 0.2634];for i=1:14for j=1:14DL14(i,j)=((city14(i,1)-city14(j,1))^2+(city14(i,2)-city14(j,2))^2)^0.5;endendDLn=DL14;cityn=city14;enddrawTSP10.m文件:function m=drawTSP(Clist,BSF,bsf,p,f)CityNum=size(Clist,1);for i=1:CityNum-1plot([Clist(BSF(i),1),Clist(BSF(i+1),1)],[Clist(BSF(i),2),Clist(BSF(i +1),2)],'ms-','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','g');hold on;endaxis([0,1,0,1]);plot([Clist(BSF(CityNum),1),Clist(BSF(1),1)],[Clist(BSF(CityNu m),2),Clist(BSF(1), 2)],'ms-','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','g');title([num2str(CityNum),'城市TSP']);if f==0text(0.1,0.1,['第',int2str(p),' 步',' 最短距离为',num2str(bsf)]);elsetext(0.1,0.1,['最终搜索结果:最短距离',num2str(bsf)]);endhold off;pause(0.05);</l_best(nc,1)<></pl(i)<>。
pso算法matlab程序
pso算法matlab程序PSO(粒子群优化)算法是一种启发式优化算法,用于解决各种优化问题。
在Matlab中实现PSO算法可以通过以下步骤进行:1. 初始化粒子群:首先,定义需要优化的目标函数,然后确定粒子群的规模、搜索空间的范围、最大迭代次数等参数。
在Matlab中可以使用数组或矩阵来表示粒子群的位置和速度。
2. 计算适应度:根据目标函数,计算每个粒子的适应度值,以便评估其在搜索空间中的位置的好坏程度。
3. 更新粒子的速度和位置:根据PSO算法的公式,更新每个粒子的速度和位置。
这个过程涉及到调整粒子的速度和位置,使其朝着适应度更高的方向移动。
4. 更新全局最优解:在整个粒子群中找到最优的粒子,即具有最佳适应度值的粒子,然后更新全局最优解。
5. 循环迭代:重复步骤3和步骤4,直到满足停止迭代的条件(如达到最大迭代次数或达到精度要求)。
在Matlab中,可以使用循环结构和数组操作来实现上述步骤。
以下是一个简单的PSO算法的Matlab程序示例:matlab.% 定义目标函数。
function z = objective_function(x)。
z = x(1)^2 + x(2)^2; % 以x1和x2为变量的目标函数示例(可根据实际情况修改)。
% 初始化粒子群。
n = 30; % 粒子数量。
max_iter = 100; % 最大迭代次数。
c1 = 2; % 学习因子。
c2 = 2; % 学习因子。
w = 0.7; %惯性权重。
x = rand(n, 2); % 随机初始化粒子的位置。
v = rand(n, 2); % 随机初始化粒子的速度。
pbest = x; % 个体最佳位置。
pbest_val = zeros(n, 1); % 个体最佳适应度值。
gbest = zeros(1, 2); % 全局最佳位置。
gbest_val = inf; % 全局最佳适应度值。
% 迭代优化。
for iter = 1:max_iter.for i = 1:n.% 计算适应度。
粒子群算法 matlab源代码
%相关参数的设置UB=600; %函数的上界LB=300; %函数的下界PopSize=40; %种群的大小Dim=10; %微粒的维数c1=2; %学习因子c2=2; %学习因子w_start=0.9;%惯性权重的开始值w_end=0.4;%惯性权重的最后值Vmax=100;%微粒的最大速度MaxIter=1500;%最大迭代次数Iter=0;%初始迭代次数%初始化群和速度X=rand(PopSize,Dim)*(UB-LB)+LB;%微粒位置随机初始化V=rand(PopSize,Dim);%微粒速度随机初始化;%测试函数:Griewank函数ind=repmat(1:Dim,PopSize,1);FX=sum(((X.^2)/4000)')'- prod(cos(X./sqrt(ind))')'+1;%设定当前位置为粒子的最好位置,并记录其最好值PBest=X;FPBest=FX;%找到初始微粒群体的最好微粒[Fgbest,r]=min(FX);CF=Fgbest;%记录当前全局最优值Best=X(r,:);%用于保存最优粒子的位置FBest=Fgbest;%循环while(Iter<=MaxIter)Iter=Iter+1;%更新惯性权重的值;w_now=((w_start-w_end)*(MaxIter-Iter)/MaxIter)+w_end;A=repmat(X(r,:),PopSize,1);%生成随机数R1=rand(PopSize,Dim);R2=rand(PopSize,Dim);%速度更新V=w_now*V+c1*R1.*(PBest-X)+c2*R2.*(A-X);%对进化后速度大于最大速度的微粒进行处理changeRows=V>Vmax;VStep(find(changeRows))=Vmax;%对进化后速度小雨最小速度的微粒进行处理changeRows=V<-Vmax;V(find(changeRows))=-Vmax;%微粒位置进行更新X=X+1.0*V;%重新计算新位置的适应度值ind=repmat(1:Dim,PopSize,1);FX=sum(((X.^2)/4000)')'- prod(cos(X./sqrt(ind))')'+1;%更新每个微粒的最好位置P=FX<FPBest;FPBest(find(P))=FX(find(P));%适应值更换PBest(find(P),:)=X(find(P),:)%粒子位置更换[Fgbest,g]=min(FPBest);%保存最好适应值if Fgbest<CF %如果本次适应值好于上次则保存[fBest,b]=min(FPBest);%最好适应值为fBestBest=PBest(b,:);%最好位置为BestendCF=Fgbest;%保留本次适应值准备与下次比较end %循环结束。
有约束多目标粒子群算法matlab程序
有约束多目标粒子群算法matlab程序【实用版】目录一、多目标粒子群算法的概念和原理二、MATLAB 实现多目标粒子群优化算法的步骤三、多目标粒子群算法在配电网储能选址定容中的应用四、多目标粒子群优化算法的优缺点五、总结与展望正文一、多目标粒子群算法的概念和原理多目标粒子群算法(Multi-objective Particle Swarm Optimization,MOPSO)是一种基于启发式的多目标全局优化算法。
它起源于鸟群觅食的自然现象,通过模拟鸟群中个体的觅食行为,寻找全局最优解。
与传统的单目标粒子群算法不同,MOPSO 需要处理多个目标函数,因此需要在算法中加入目标函数权重的概念,以确定每个目标函数在优化过程中的重要性。
二、MATLAB 实现多目标粒子群优化算法的步骤1.确定优化问题:首先,需要明确优化问题的具体内容,包括目标函数、约束条件和搜索空间等。
2.初始化粒子群:根据搜索空间的大小和目标函数的个数,生成一定数量的粒子,并随机分配它们在搜索空间中的位置和速度。
3.更新粒子速度和位置:根据粒子群算法的更新规则,结合目标函数的梯度和约束条件,更新每个粒子的速度和位置。
4.评估适应度:根据目标函数的值,计算每个粒子的适应度,并选择最优的粒子作为全局最优解。
5.结束条件:当达到预设的最大迭代次数或全局最优解的适应度满足预设的标准时,结束优化过程。
6.输出结果:输出全局最优解及其对应的适应度。
三、多目标粒子群算法在配电网储能选址定容中的应用多目标粒子群算法在配电网储能选址定容问题中具有很好的应用前景。
该问题涉及到多个目标函数,如储能设备的投资成本、运行维护费用、电网的运行安全性等。
MOPSO 可以通过调整目标函数权重,很好地平衡这些目标之间的关系,从而找到最优的储能设备容量和位置。
四、多目标粒子群优化算法的优缺点MOPSO 的优点在于其全局搜索能力,能够处理多个目标函数,并在搜索过程中自动平衡各目标之间的关系。
15基于粒子群算法的连续函数优化通用MATLAB源代码
基于蚁群算法的连续函数优化通用MATLAB源代码此源码是对粒子群算法的一种实现,用于无约束连续函数的优化求解,对于含有约束的情况,可以先使用罚函数等方法,把问题处理成无约束的模型,再使用本源码进行求解。
function [BESTX,BESTY,ALLX,ALLY]= PSOUCP(K,N,LB,UB,WR,CR1,CR2,Alpha,Beta,Gamma)%% 无约束连续函数的粒子群优化算法% GreenSim团队——专业级算法设计&代写程序% 欢迎访问GreenSim团队主页→/greensim%% 此函数实现粒子群算法,用于求解无约束连续函数最小化问题%% 对于最大化问题,请先将其加负号转化为最小化问题%% 输入参数列表% K 最大迭代次数% N 初始粒子群规模(要求为偶数)% LB 决策变量的下界,M×1的向量% UB 决策变量的上界,M×1的向量% WR 粒子群算法控制参数1,惯性系数% CR1 粒子群算法控制参数2,当前最优学习参数% CR2 粒子群算法控制参数3,历史最优学习参数%% 输出参数列表% BESTX K×1细胞结构,每一个元素是M×1向量,记录每一代的最优个体% BESTY K×1矩阵,记录每一代的最优个体的评价函数值% ALLX K×1细胞结构,每一个元素是M×N矩阵,记录全部个体% ALLY K×N矩阵,记录全部个体的评价函数值%% 初始化M=length(LB);%决策变量的个数%种群初始化,每一列是一个样本farm=zeros(M,N);for i=1:Mx=unifrnd(LB(i),UB(i),1,N);farm(i,:)=x;endSumWCR=WR+CR1+CR2;WR=WR/SumWCR;CR1=CR1/SumWCR;CR2=CR2/SumWCR;%输出变量初始化ALLX=cell(K,1);ALLY=zeros(K,N);BESTX=cell(K,1);BESTY=zeros(K,1);k=1;%迭代计数器初始化%% 以下是迭代过程while k<=Knewfarm=zeros(M,2*N);Ser=randperm(N);A=farm(:,Ser(1));B=farm(:,Ser(2));P0=unidrnd(M-1);a=[A(1:P0,:);B((P0+1):end,:)];b=[B(1:P0,:);A((P0+1):end,:)];newfarm(:,2*N-1)=a;newfarm(:,2*N)=b;for i=1:(N-1)A=farm(:,Ser(i));B=farm(:,Ser(i+1));P0=unidrnd(M-1);a=[A(1:P0,:);B((P0+1):end,:)];b=[B(1:P0,:);A((P0+1):end,:)];newfarm(:,2*i-1)=a;newfarm(:,2*i)=b;endnewfarm2=zeros(M,N);for i=1:Mx=unifrnd(LB(i),UB(i),1,N);newfarm2(i,:)=x;endnewfarm3=zeros(M,N);for i=1:Nif Gamma>randAA=farm(:,i);BB=QuantumMutation(AA,LB,UB,Beta);newfarm3(:,i)=BB;endendnewfarm4=farm;if k>=3Pgd=BESTX{k-1};Pid=BESTX{k-2};for i=1:Nnewfarm4(:,i)=WR*farm(:,i)+CR1*Pid+CR2*Pgd;endendFARM=[farm,newfarm,newfarm2,newfarm3,newfarm4];SER=randperm(6*N);FITNESS=zeros(1,6*N);fitness=zeros(1,N);for i=1:(6*N)BETA=FARM(:,i);SE=FIT(BETA);FITNESS(i)=SE;endfor i=1:Nf1=FITNESS(SER(6*i-5));f2=FITNESS(SER(6*i-4));f3=FITNESS(SER(6*i-3));f4=FITNESS(SER(6*i-2));f5=FITNESS(SER(6*i-1));f6=FITNESS(SER(6*i));if f1<=f2&&f1<=f3&&f1<=f4&&f1<=f5&&f1<=f6 farm(:,i)=FARM(:,SER(6*i-5));fitness(:,i)=FITNESS(:,SER(6*i-5));elseif f2<=f1&&f2<=f3&&f2<=f4&&f2<=f5&&f2<=f6 farm(:,i)=FARM(:,SER(6*i-4));fitness(:,i)=FITNESS(:,SER(6*i-4));elseif f3<=f1&&f3<=f2&&f3<=f4&&f3<=f5&&f3<=f6 farm(:,i)=FARM(:,SER(6*i-3));fitness(:,i)=FITNESS(:,SER(6*i-3));elseif f4<=f1&&f4<=f2&&f4<=f3&&f4<=f5&&f4<=f6 farm(:,i)=FARM(:,SER(6*i-2));fitness(:,i)=FITNESS(:,SER(6*i-2));elseif f5<=f1&&f5<=f2&&f5<=f3&&f5<=f4&&f5<=f6 farm(:,i)=FARM(:,SER(6*i-1));fitness(:,i)=FITNESS(:,SER(6*i-1));elsefarm(:,i)=FARM(:,SER(6*i));fitness(:,i)=FITNESS(:,SER(6*i));endendX=farm;Y=fitness;ALLX{k}=X;ALLY(k,:)=Y;minY=min(Y);pos=find(Y==minY);BESTX{k}=X(:,pos(1));BESTY(k)=minY;Alpha=Alpha*1.01;disp(k);k=k+1;end。
基于MATLAB的粒子群优化算法及其应用
到 全 局 最 优 解 0 . 1274936979,函 数 最 大 值 为 19 . (0, 上的特性 89489789733279。图 5 是六峰驼背函数在区间 1) 曲线, 图 6 与图 7 分别是本文算法求解 ( 得到的离线性能 f X) 曲线与在线性能曲线。进化代数为 100。
图7 图5 六峰驼背函数特性曲线
的在线性能曲线 PSO 求解 ( f x)
参考文献:
[1] J Kennedy,R C Eberhart . ParticIe Swarm Optimization. IEEE InternationaI Conference on NeuraI Networks,Perth,AustraIia,1995 . [2] Y Shi,R C Eberhart . A Modified Swarm Optimizer . IEEE InternationaI Conference of EvoIutionary Computation, Anchorage, AIaska,1998 . [3] 陈国良, 王煦法, 庄镇权等 . 遗传算法及其应用 [ M] 人民 . 北京: 邮电出版社,1996 . [4 ] 王凌 . 智能优化算法及其应用 [ M] 清华大学出版社, . 北京: 2001 .
文章编号: (2003) l006 - 9348 l0 - 0068 - 03
1
berhart 博士与 Kennedy 博士发明的一种新的全局优化进化算 法。该算法源于对鸟类捕食行为的模拟
[l]
代找到最优解。在每一次叠代中, 粒子通过跟踪两个 “极值” 来更新自己。一个是粒子本身所找到的最优解, 即个体极值 称之为全局极 pbest。另一个是整个种群目前找到的最优解, 值 gbest。 粒子在找到上述两个极值后, 就根据下面两个公式来更
pso算法matlab代码
pso算法matlab代码粒子群优化算法(Particle Swarm Optimization,PSO)是一种基于群体智能的优化算法,其基本思想是通过模拟鸟群觅食行为来寻找最优解。
以下是一个简单的 MATLAB 代码示例,用于实现 PSO 算法:matlab复制代码% 定义问题参数n_particles = 100; % 粒子数量n_iterations = 100; % 迭代次数n_dimensions = 2; % 问题的维度lb = [-10-10]; % 问题的下界ub = [1010]; % 问题的上界c1 = 2; % 个体学习因子c2 = 2; % 社会学习因子% 初始化粒子群particles = lb + (ub-lb).*rand(n_particles,n_dimensions);velocities = zeros(n_particles, n_dimensions);p_best = particles;g_best = particles(1, :);g_best_fitness = inf;% 主循环for i = 1:n_iterations% 计算每个粒子的适应度值fitness = evaluate(particles); % 更新个体最优解for j = 1:n_particlesif fitness(j) < p_best(j, :)p_best(j, :) = particles(j, :); endend% 更新全局最优解for j = 1:n_particlesif fitness(j) < g_best_fitness g_best_fitness = fitness(j);g_best = particles(j, :);endend% 更新粒子速度和位置for j = 1:n_particlesr1 = rand(); % 个体学习因子随机数r2 = rand(); % 社会学习因子随机数velocities(j, :) = velocities(j, :) +c1*r1*(p_best(j, :) - particles(j, :)) + c2*r2*(g_best - particles(j, :));particles(j, :) = particles(j, :) + velocities(j, :);% 边界条件处理particles(j, :) = max(particles(j, :) , lb);particles(j, :) = min(particles(j, :) , ub);endend% 输出结果disp('全局最优解:');disp(g_best);disp('全局最优解的适应度值:');disp(g_best_fitness);其中,evaluate函数用于计算每个粒子的适应度值,需要根据具体问题进行定义。
PSOELM(粒子群优化极限学习机)MATLAB程序
clear all;clc;close allclear allclc%load pca1load pca2load pca4load pca3%c =566:984%plot(pca2)%plot(x,P11,x,pca11,'r')%plot(x,EP1,'b',x,EP2,'r',x,EP3,'k',x,EP4,'g') %P11=mapminmax(pca1',0,1);%P22=mapminmax(pca2',0,1);%P33=mapminmax(pca3',0,1);%P44=mapminmax(pca4',0,1);%EP1=EWMA(pca1(566:984)',0.2,18)%EP4=EWMA(pca4(772:984)',0.3,16)%EP2=EWMA(pca2(772:984)',0.3,16)%EP3=EWMA(pca3(691:984)',0.3,16)%plot(x,EP1,'b',x,EP2,'r',x,EP3,'k',x,EP4,'g') %P11=mapminmax(EP1,0,1);%P22=mapminmax(EP2,0,1);%P33=mapminmax(EP3,0,1);%P44=mapminmax(EP4,0,1);EP2=smooth(pca2(772:984))';EP4=smooth(pca4(772:984))';Q=zeros(150,64);%V=zeros(965,20);for j=1:64for i=1:150Q(i,j)=EP2(i+j-1);endendP1=Q;P2=(149:-1:0)';PP=[P1,P2];%..................制作测试集....................% M=zeros(150,64);for j=1:64for i=1:150M(i,j)=EP4(i+j-1);endendT1=M;T2=(149:-1:0)';TT=[T1,T2];clearvars -except PP TTX_data=PP;Y_data=TT;%data=load('Lorenz.txt%% 加载数据%x=xlsread('pso_elmdata.xls');%AllSamIn = x(1:29,1:2)';%AllSamOut = x(1:29,3)';%AllTestIn=x(30:36,1:2)';%AllTestOut=x(30:36,3)'; AllSamIn =PP(:,1:64)'; AllSamOut=PP(:,65)';AllTestIn=TT(:,1:64)';AllTestOut=TT(:,65)';%% 训练样本归一化global minAllSamOut;global maxAllSamOut;[AllSamInn,minAllSamIn,maxAllSamIn,AllSamOutn,minAllSamOut,maxAllSamOut] = premnmx(AllSamIn,AllSamOut);TrainSamIn=AllSamInn;TrainSamOut=AllSamOutn;global Ptrain;Ptrain = TrainSamIn;global Ttrain;Ttrain = TrainSamOut;%% 测试样本归一化global minAllTestOut;global maxAllTestOut;[AllTestInn,minAllTestIn,maxAllTestIn,AllTestOutn,minAllTestOut,maxAllTestOut] = premnmx(AllTestIn,AllTestOut);TestIn=AllTestInn;TestOut=AllTestOutn;global Ptest;Ptest = TestIn;global Ttest;Ttest = TestOut;%% 加载网络的初始变量global indim;indim=64;global hiddennum;hiddennum=65;global outdim;outdim=1;%% 加载PSO模型的相关参数vmax=0.7;minerr=0.0001;wmax=1.2;wmin=0.6;cmax=3;cmin=1;global itmax;itmax=150;c1=2;c2=2;for iter=1:itmaxW(iter)=wmax-((wmax-wmin)/itmax)*iter;end%for iter=1:itmax%c2(iter)=cmax-cmin-((cmax-cmin)/itmax/3)*iter;%end%c1=c2;a=-1;b=1;m=-1;n=1;global N;N=200;global D;D=(indim+1)*hiddennum+(hiddennum+1)*outdim;rand('state',sum(100*clock));X=a+(b-a)*rand(N,D,1);V=m+(n-m)*rand(N,D,1);global fvrec;MinFit=[];BestFit=[];%% PSO优化ELM模型过程1fitness=fitcal(X,indim,hiddennum,outdim,D,Ptrain,Ptest,Ttrain,Ttest,minAllSamOut,maxAllSa mOut);fvrec(:,1,1)=fitness(:,1,1);[C,I]=min(fitness(:,1,1));MinFit=[MinFit C];BestFit=[BestFit C];L(:,1,1)=fitness(:,1,1);B(1,1,1)=C;gbest(1,:,1)=X(I,:,1);for p=1:NG(p,:,1)=gbest(1,:,1);endfor i=1:N;pbest(i,:,1)=X(i,:,1);endV(:,:,2)=W(1)*V(:,:,1)+c1*rand*(pbest(:,:,1)-X(:,:,1))+c2*rand*(G(:,:,1)-X(:,:,1));for ni=1:Nfor di=1:Dif V(ni,di,2) > vmaxV(ni,di,2) = vmax;elseif V(ni,di,2) < -vmaxV(ni,di,2) = -vmax;elseV(ni,di,2) = V(ni,di,2);endendendX(:,:,2)=X(:,:,1)+V(:,:,2);for ni=1:Nfor di=1:Dif X(ni,di,2) > 1X(ni,di,2) = 1;elseif V(ni,di,2) < -1X(ni,di,2) = -1;elseX(ni,di,2) = X(ni,di,2);endendend%% PSO优化ELM模型过程2for j=2:itmaxdisp('Iteration and Current Best Fitness')disp(j-1)disp(B(1,1,j-1))fitness=fitcal(X,indim,hiddennum,outdim,D,Ptrain,Ptest,Ttrain,Ttest,minAllSamOut,maxAllSa mOut);fvrec(:,1,j)=fitness(:,1,j);[C,I]=min(fitness(:,1,j));MinFit=[MinFit C];BestFit=[BestFit min(MinFit)];L(:,1,j)=fitness(:,1,j);B(1,1,j)=C;gbest(1,:,j)=X(I,:,j);[C,I]=min(B(1,1,:));if B(1,1,j)<=Cgbest(1,:,j)=gbest(1,:,j);elsegbest(1,:,j)=gbest(1,:,I);endif C<=minerr, break, endif j>=itmax, break, endfor p=1:NG(p,:,j)=gbest(1,:,j);endfor i=1:N;[C,I]=min(L(i,1,:));if L(i,1,j)<=Cpbest(i,:,j)=X(i,:,j);elsepbest(i,:,j)=X(i,:,I);endendV(:,:,j+1)=W(j)*V(:,:,j)+c1*rand*(pbest(:,:,j)-X(:,:,j))+c2*rand*(G(:,:,j)-X(:,:,j));for ni=1:Nfor di=1:Dif V(ni,di,j+1)>vmaxV(ni,di,j+1)=vmax;elseif V(ni,di,j+1)<-vmaxV(ni,di,j+1)=-vmax;elseV(ni,di,j+1)=V(ni,di,j+1);endendendX(:,:,j+1)=X(:,:,j)+V(:,:,j+1);for ni=1:Nfor di=1:Dif X(ni,di,j+1) > 1X(ni,di,j+1) = 1;elseif V(ni,di,j+1) < -1X(ni,di,j+1) = -1;elseX(ni,di,j+1) = X(ni,di,j+1);endendendenddisp('Iteration and Current Best Fitness')disp(j)disp(B(1,1,j))disp('Global Best Fitness and Occurred Iteration')[C,I] = min(B(1,1,:))for t=1:hiddennumx2iw(t,:)=gbest(1,((t-1)*indim+1):t*indim,j);endfor r=1:outdimx2lw(r,:)=gbest(1,(indim*hiddennum+1):(indim*hiddennum+hiddennum),j);endx2b=gbest(1,((indim+1)*hiddennum+1):D,j);x2b1=x2b(1:hiddennum).';x2b2=x2b(hiddennum+1:hiddennum+outdim).';IWbest1=x2iw;IWbest2=x2lw;IBbest1=x2b1;IBbest2=x2b2;T_sim_test = ELMfun2(IWbest1,IBbest1,Ptrain,Ptest,Ttrain,Ttest,hiddennum,IWbest2,IBbest2); testsamout = postmnmx(T_sim_test,minAllTestOut,maxAllTestOut);realtesterr=mse(testsamout-AllTestOut);err1=norm(testsamout-AllTestOut);disp(['优化模型测试样本的仿真误差:',num2str(err1)])N = length(Ttest);R1 = (N*sum(T_sim_test.*Ttest)-sum(T_sim_test)*sum(Ttest))^2/((N*sum((T_sim_test).^2)-(sum(T_sim_test))^2)*(N*sum((Ttest).^2)-(sum(Ttest))^2));%% 不使用PSO优化ELM算法[IW,B,LW,TF,TYPE] = elmtrain2(Ptrain,Ttrain,65,'sig',0);T_sim_test1 = elmpredict(Ptest,IW,B,LW,TF,TYPE);testsamout2 = postmnmx(T_sim_test1,minAllTestOut,maxAllTestOut);realtesterr2=mse(testsamout2-AllTestOut);err2=norm(testsamout2-AllTestOut);R2 = (N*sum(T_sim_test1.*Ttest)-sum(T_sim_test1)*sum(Ttest))^2/((N*sum((T_sim_test1).^2)-(sum(T_sim_test1))^2)*(N*sum((Ttest).^2)-(sum(Ttest))^2));disp(['原始模型测试样本的仿真误差:',num2str(err2)])RMSE1=sqrt(mse(AllTestOut-testsamout2))%plot(1:150,AllTestOut,'r-*',1:150,testsamout2,'b:o');%% 输出参数图% PSO 优化迭代图%% 输出参数图% PSO 优化迭代图figure(1);P0 = plot(1:itmax,BestFit);grid onxlabel('PSO items');ylabel('MSE rate');%string = {'PSO-ELM模型100次迭代误差变化';['决定系数:R^2=' num2str(R1) ' ' ];['模型仿真均方误差:mse=' num2str(realtesterr) ' ']};%title(string)%bestErr=min(BestFit);%fprintf(['PSO-ELM模型:\n决定系数R^2=',num2str(R1),'\n模型仿真均方误差:mse=',num2str(realtesterr),'\n'])%set(P0,'LineWidth',1.5);% PSO与ELM结果比较图figure(2)plot(1:150,AllTestOut,'r-*',1:150,testsamout,'b:o');legend('真实值','PSO-ELM预测值')RMSE2=sqrt(mse(AllTestOut-testsamout))%,1:151,testsamout2,'y--*')%grid on%legend('真实值','PSO-ELM预测值','单纯ELM预测值')%xlabel('样本编号')%ylabel('样本数据分类号')。
粒子群算法matlab代码
一、粒子群主程序psize=20; %粒子个数的设置pd=12; %粒子的维数lz=zeros(psize,pd);for i=1:psize %随机生成粒子群,psize行pd列,pd维。
suiji=rand(1,pd);for j=1:pd/2if suiji(j)<0.5lz(i,j)=fix(unifrnd(0,100))*100;elselz(i,j)=fix(unifrnd(0,100)+1)*100;endendfor j=pd/2+1:1:pdif suiji(j)<0.5lz(i,j)=fix(unifrnd(0,45))/100;elselz(i,j)=fix(unifrnd(0,45)+1)/100;endendlz(i,1:pd/2)=sort(lz(i,1:pd/2));lz(i,pd/2+1:pd)=sort(lz(i,pd/2+1:pd));endlv=lz;goodvalue=lz; %每个粒子自己历史最好值初始化,psize行pd列。
vmax=20; %速度上限c1=2;c2=2; %学习因子w=0.729; %随机因子和惯性因子bestvalue=zeros(1,pd); %全局最好值初始化,1行pd列for j=1:pdbestvalue(1,j)=goodvalue(1,j);endfnew=zeros(1,psize);for j=1:psizefnew(j)=fpso(lz(1,:));endfold=fnew;flagstop=0; %终止标志k=0; %迭代次数记录f0=fpso(bestvalue); %适应值初始化while flagstop==0for i=1:psize %适应值比较,更新各自历史最好值(位置)fnew(i)=fpso(lz(i,:)); %记录每次每个粒子的适应值,便于以后设置终止条件if fnew(i)<fold(i)fold(i)=fnew(i); %fold记录每个粒子的最好历史值goodvalue(i,j)=lz(i,j);endendendfor i=1:psize%每个粒子历史最好值比较,更新全局最好值f1=fold(i);if f1<f0f0=f1;for j=1:pdbestvalue(1,j)=goodvalue(i,j);endendend%*********粒子趋一点终止条件*********%flagstop0=max(abs(fold)); %比较当次的所有粒子的适应值,flagstop1=min(abs(fold)); %若它们之间差别较小,则可以停止。
基于MATLAB的粒子群优化算法程序设计
基于MATLAB的粒子群优化算法程序设计一、概述粒子群优化(Particle Swarm Optimization,PSO)算法是一种基于群体智能的优化搜索技术,它通过模拟鸟群、鱼群等动物群体的社会行为,利用群体中的个体信息共享机制,引导粒子在解空间中搜索最优解。
自1995年由Eberhart博士和Kennedy博士提出以来,PSO 算法因其简单、高效的特点,在函数优化、神经网络训练、模糊系统控制等多个领域得到了广泛的应用。
在MATLAB环境中实现粒子群优化算法,可以充分利用MATLAB强大的数值计算能力和高效的编程环境,实现算法的快速开发和优化。
MATLAB具有简单易用的语法和丰富的函数库,使得开发者能够快速地构建算法模型,进行仿真实验,并对算法性能进行分析和评估。
基于MATLAB的粒子群优化算法程序设计,旨在提供一个完整的算法实现框架,帮助读者理解PSO算法的基本原理和实现细节。
通过该程序设计,读者可以掌握如何在MATLAB中构建粒子群优化算法,如何设置算法参数,如何进行仿真实验,并如何分析和评估算法性能。
该程序设计还可以作为进一步研究和开发粒子群优化算法的基础,为实际应用提供有力的技术支持。
1. 粒子群优化算法(PSO)简介粒子群优化算法(Particle Swarm Optimization, PSO)是一种群体智能优化技术,起源于对鸟群觅食行为的社会心理学模拟。
该算法通过模拟鸟群中的信息共享机制,使得每个个体(粒子)能够在解空间中不断更新自己的位置和速度,从而寻找到问题的最优解。
PSO 算法以其简单、易实现和高效的特点,在函数优化、神经网络训练、模糊系统控制等多个领域得到了广泛应用。
在PSO算法中,每个粒子都代表着问题解空间中的一个候选解,它们根据自己的飞行经验以及群体中最优粒子的飞行经验来调整自己的飞行轨迹。
粒子的位置信息对应着问题的解,而粒子的速度则决定了其搜索解空间的方向和步长。
粒子群算法matlaB程序
end
for k=451:540
qu(k)=1520;
end
for k=541:700
qu(k)=1520+80/100*(k-540);
end
for k=701:800
qu(k)=qu(700);
legend('Expext Line','PID')
xlabel('时间/分')
subplot(2,2,4)
plot(qut(1:end-1)/3,r,'-.')
legend('r(t)')
xlabel('时间/分')
rou(k+1)=rou(k)+alpha*qu(k)-alpha*vf*(rou(k)-rou(k)^2/rou_jam)+alpha*r(k)/lambda;
end
%%
%显示构造的期望密度
figure(1)
subplot(2,2,1)
plot(qut/3,qu)
xlabel('时间/分')
end00)-90/100*(k-800);
end
for k=951:1100
qu(k)=qu(950);
end
for k=1101:1200
qu(k)=qu(950)+120/100*(k-1100);
end
qu(k)=qu(1520)+70/100*(k-1650);
end
for k=1701:1850
智能算法之粒子群优化算法-matlab程序-可运行
c1 = 0.5; % 自我学习因子
c2 = 0.5; % 群体学习因子
for i = 1:d
x = limit(i, 1) + (limit(i, 2) - limit(i, 1)) * rand(N, d);%初始种群的位置
plot(x0, f(x0), 'b-', x, f(x), 'ro');title('状态位置变化')
pause(0.1)
iter = iter+1;
end
figure(3);plot(record);title('收敛过程')
x0 = 0 : 0.01 : 20;
d = 1; % 空间维数
ger = 100; % 最大迭代次数
limit = [0, 20]; % 设置位置参数限制
vlimit = [-1, 1]; % 设置速度限制
end
v = v * w + c1 * rand * (xm - x) + c2 * rand * (repmat(ym, N, 1) - x);% 速度更新
%Hale Waihona Puke 边界速度处理 v(v > vlimit(2)) = vlimit(2);
v(v < vlimit(1)) = vlimit(1);
while iter <= ger
fx = f(x) ; % 个体当前适应度
for i = 1:N
if fxm(i) < fx(i)
fxm(i) = fx(i); % 更新个体历史最佳适应度
带交叉因子的粒子群优化算法matlab源程序
带交叉因子的粒子群优化算法matlab源程序程序源代码:其中PSOGA.m文件,也就是主程序如下%格式标准化clear all;clc;format long;%初始化各个因子c1=1.4962; %学习因子c1c2=1.4962; %学习因子c2w=0.7298; %惯性权重wN=20; %粒子群规模D=6; %搜索空间维数(本程序适合3维及以上,不能求解1, 2维)eps=10^(-6); %满足条件限制的误差(在不知道最小值时候不用设置) MaxDT=500; %粒子群繁殖的代数%初始化粒子的速度和位置,数据结构用矩阵A表示for i=1:Nfor j=1:2*DA(i,j)=rand;endendfor i=1:Nfor j=2*D+1:3*DA(i,j)=A(i,j-2*D);endend%计算各个粒子的适应度for i=1:NA(i,3*D+1)=fitness(A(i,1:D),D);end%对粒子的适应度进行排序B=sortrows(A,3*D+1);%排序后适应度低的前面一半粒子直接进入下一代NextGeneration=zeros(N,3*D+1);for i=1:N/2for j=1:3*D+1NextGeneration(i,j)=B(i,j);endend%后一半粒子进行遗传选择和交叉操作for i=1:N/2for j=1:3*D+1Cross(i,j)=B(i+N/2,j);endend%产生一个随机的交叉位置for i=1:N/4Anumber=randperm(D-1);if Anumber(1)~=1position=Anumber(1);elseposition=Anumber(2);end%交叉进行for j=position:D-1temp=Cross(i,j);Cross(i,j)=Cross(N/2-i+1,j);Cross(N/2-i+1,j)=temp;endend%交叉结束,进行更新for i=1:N/2Cross(i,3*D+1)=fitness(Cross(i,1:D),D);if Cross(i,3*D+1)<B(i+N/2,3*D+1)for j=2*D+1:3*DCross(i,j)=Cross(i,j-2*D);endelsefor j=2*D+1:3*DCross(i,j)=B(i,j);endendend%下面选择最好的粒子N/2个进入下一代Pool=zeros(N,3*D+1);for i=1:N/2for j=1:3*D+1Pool(i,j)=B(i+N/2,j);endendfor i=1+N/2:Nfor j=1:3*D+1Pool(i,j)=Cross(i-N/2,j);endend%POOLX表示排序后的粒子选择池PoolX=sortrows(Pool,3*D+1);for i=1+N/2:Nfor j=1:3*D+1NextGeneration(i,j)=PoolX(i-N/2,j);endendPbest=NextGeneration(i,2*D+1:3*D);for i=2:Nif NextGeneration(i,3*D+1)<fitness(Pbest,D)Pbest=NextGeneration(i,2*D+1:3*D);endend%根据粒子群公式进行迭代(Stander PSO Step)%速度更新for i=1:Nfor j=D+1:2*DA(i,j)=w*NextGeneration(i,j)+c1*rand*(NextGeneration(i, j+D)-NextGeneration(i,j-D))+c2*rand*(Pbest(j-D)-NextGeneration(i,j-D));endend%位置更新for i=1:Nfor j=1:DA(i,j)=NextGeneration(i,j)+A(i,j+D);endA(i,3*D+1)=fitness(A(i,1:D),D);if A(i,3*D+1)<NextGeneration(i,3*D+1)for j=2*D+1:3*DA(i,j)=A(i,j-2*D);endelsefor j=2*D+1:3*DA(i,j)=NextGeneration(i,j-2*D);endendend%下面进入主要循环,循环到最大次数得到最优解和最小值%DDTime=1;for time=1:MaxDTB=sortrows(A,3*D+1);NextGeneration=zeros(N,3*D+1);for i=1:N/2for j=1:3*D+1NextGeneration(i,j)=B(i,j);endend%遗传选择交叉for j=1:3*D+1Cross(i,j)=B(i+N/2,j);endendfor i=1:N/4Anumber=randperm(D-1);if Anumber(1)~=1position=Anumber(1);elseposition=Anumber(2);endfor j=position:D-1temp=Cross(i,j);Cross(i,j)=Cross(N/2-i+1,j);Cross(N/2-i+1,j)=temp;endend%交叉结束,进行更新for i=1:N/2Cross(i,3*D+1)=fitness(Cross(i,1:D),D);if Cross(i,3*D+1)<B(i+N/2,3*D+1)for j=2*D+1:3*DCross(i,j)=Cross(i,j-2*D);endelsefor j=2*D+1:3*DCross(i,j)=B(i,j);endendend%下面选择最好的粒子N/2个进入下一代Pool=zeros(N,3*D+1);for j=1:3*D+1Pool(i,j)=B(i+N/2,j);endendfor i=1+N/2:Nfor j=1:3*D+1Pool(i,j)=Cross(i-N/2,j);endendPoolX=sortrows(Pool,3*D+1);for i=1+N/2:Nfor j=1:3*D+1NextGeneration(i,j)=PoolX(i-N/2,j);endendPbest=NextGeneration(i,2*D+1:3*D);for i=2:Nif NextGeneration(i,3*D+1)<fitness(Pbest,D)Pbest=NextGeneration(i,2*D+1:3*D);endend%根据粒子群公式进行迭代for i=1:Nfor j=D+1:2*DA(i,j)=w*NextGeneration(i,j)+c1*rand*(NextGene ration(i,j+D)-NextGeneration(i,j-D))+c2*rand*(Pbest(j-D)-NextGeneration(i,j-D));endendfor i=1:Nfor j=1:DA(i,j)=NextGeneration(i,j)+A(i,j+D);endA(i,3*D+1)=fitness(A(i,1:D),D);if A(i,3*D+1)<NextGeneration(i,3*D+1)for j=2*D+1:3*DA(i,j)=A(i,j-2*D);endelsefor j=2*D+1:3*DA(i,j)=NextGeneration(i,j-2*D);endendendPg(time)=fitness(Pbest,D);%DDTime=DDTime+1;%if fitness(Pbest,D)<eps%break;%endend%算法结束,得到的结果显示如下:disp('****************************************************') disp('最后得到的最优位置为:')X=Pbest'disp('得到的函数最小值为:')Minimize=fitness(Pbest,D)disp('****************************************************')%绘制进化代数和适应度关系曲线图xx=linspace(1,MaxDT,MaxDT);yy=Pg(xx);plot(xx,yy,'b-')hold ongrid ontitle('带交叉因子的粒子群优化算法进化代数与适应度值关系曲线图') legend('粒子适应度曲线走势')。
【优化求解】基于竞争学习的粒子群优化算法(CLPSO)matlab源码
【优化求解】基于竞争学习的粒⼦群优化算法(CLPSO)matlab源码⼀、粒⼦群算法粒⼦群算法是在1995年由Eberhart博⼠和Kennedy博⼠⼀起提出的,它源于对鸟群捕⾷⾏为的研究。
它的基本核⼼是利⽤群体中的个体对信息的共享从⽽使整个群体的运动在问题求解空间中产⽣从⽆序到有序的演化过程,从⽽获得问题的最优解。
设想这么⼀个场景:⼀群鸟进⾏觅⾷,⽽远处有⼀⽚⽟⽶地,所有的鸟都不知道⽟⽶地到底在哪⾥,但是它们知道⾃⼰当前的位置距离⽟⽶地有多远。
那么找到⽟⽶地的最佳策略,也是最简单有效的策略就是搜寻⽬前距离⽟⽶地最近的鸟群的周围区域。
在PSO中,每个优化问题的解都是搜索空间中的⼀只鸟,称之为"粒⼦",⽽问题的最优解就对应于鸟群中寻找的"⽟⽶地"。
所有的粒⼦都具有⼀个位置向量(粒⼦在解空间的位置)和速度向量(决定下次飞⾏的⽅向和速度),并可以根据⽬标函数来计算当前的所在位置的适应值(fitness value),可以将其理解为距离"⽟⽶地"的距离。
在每次的迭代中,种群中的例⼦除了根据⾃⾝的经验(历史位置)进⾏学习以外,还可以根据种群中最优粒⼦的"经验"来学习,从⽽确定下⼀次迭代时需要如何调整和改变飞⾏的⽅向和速度。
就这样逐步迭代,最终整个种群的例⼦就会逐步趋于最优解。
上⾯的解释可能还⽐较抽象,下⾯通过⼀个简单的例⼦来进⾏说明在⼀个湖中有两个⼈他们之间可以通信,并且可以探测到⾃⼰所在位置的最低点。
初始位置如上图所⽰,由于右边⽐较深,因此左边的⼈会往右边移动⼀下⼩船。
现在左边⽐较深,因此右边的⼈会往左边移动⼀下⼩船⼀直重复该过程,最后两个⼩船会相遇得到⼀个局部的最优解将每个个体表⽰为粒⼦。
每个个体在某⼀时刻的位置表⽰为,x(t),⽅向表⽰为v(t)p(t)为在t时刻x个体的⾃⼰的最优解,g(t)为在t时刻所有个体的最优解,v(t)为个体在t时刻的⽅向,x(t)为个体在t时刻的位置下⼀个位置为上图所⽰由x,p,g共同决定了种群中的粒⼦通过不断地向⾃⾝和种群的历史信息进⾏学习,从⽽可以找到问题的最优解。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
clear all;
clc;
format long;
%------给定初始化条件----------------------------------------------
c1=1.4962; %学习因子1
c2=1.4962; %学习因子2
w=0.7298; %惯性权重
MaxDT=1000; %最大迭代次数
D=10; %搜索空间维数(未知数个数)
N=40; %初始化群体个体数目
eps=10^(-6); %设置精度(在已知最小值时候用)
%------初始化种群的个体(可以在这里限定位置和速度的范围)------------ 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,:),D);
y(i,:)=x(i,:);
end
pg=x(1,:); %Pg为全局最优
for i=2:N
if fitness(x(i,:),D)<fitness(pg,D)
pg=x(i,:);
end
end
%------进入主要循环,按照公式依次迭代,直到满足精度要求------------ for t=1:MaxDT
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,:),D)<p(i)
p(i)=fitness(x(i,:),D);
y(i,:)=x(i,:);
end
if p(i)<fitness(pg,D)
pg=y(i,:);
end
end
Pbest(t)=fitness(pg,D);
end
%------最后给出计算结果
disp('*************************************************************') disp('函数的全局最优位置为:')
Solution=pg'
disp('最后得到的优化极值为:')
Result=fitness(pg,D)
disp('*************************************************************') %------算法结束---DreamSun GL & HF----------------------------------- 适应度函数源程序(fitness.m)
function result=fitness(x,D)
sum=0;
for i=1:D
sum=sum+x(i)^2;
end
result=sum;。