粒子群算法通用matlab程序
粒子群_Matlab程序代码
粒子群优化算法(panicle swarm optimization ，PSO)是kennedy 和Eberhart 在研究鸟类和鱼类的群体行为基础上于1995年提出的一种群智能算法，其思想米源予人工生命和演化计算理论，模仿鸟群飞行觅食行为，通过鸟集体协作使群体达到最优。
1.粒子群算法的原理PSO 中，每个优化问题的解看作搜索空间中的一只鸟(即粒子)，所有的粒子都有一个被优化的函数决定的适应值，并且有一个速度决定它们飞翔的方向和速率，粒子们追随当前的最优粒子在解空间中搜索。
算法首先初始化一群随机粒子，然后通过迭代找到最优解。
在每一次迭代中，粒子通过跟踪两个“极值”即个体极值和全局极值来更新自己的速度与位置。
在D 维目标搜索空间中，由种群数为m 的粒子组成粒子群，其中第f 个粒子在第d 维的位置为Xid ，其飞行速度为Vid ，该粒子当前搜索到的最优位置为Pid(goodvalue)和整个粒子群当前的最优位置Pgd(bestvalue)。
每维的速度与位置更新公式如下112(1)()(1)()(1)id id id id id id v v c rand p x c rand g x ω+=⨯+⨯⨯-+⨯⨯-L 11(2)id id id x x v ++=+LW 为惯性权重，C1和C2为学习因子，rand （）——[0,1]范围内变化的随机数。
2.参数介绍与设置（1）ww 是保持粒子运动惯性的参数，能使种群扩展搜索空间，获得较好的求解效果。
较大的w 有利于群体在更大的范围内进行搜索。
而较小的w 能够保证群体收敛到最优位置，所以w 的选择及在迭代中的变化对搜索能力和跳出局优能力具有重要影响。
一般将w 设定为0.8左右。
（1）加速因子c1和c2c1和c2用于调整粒子自身经验和社会经验在其运动中的作用，表示将每个粒子拉向pbest 和gbest 位置的随机加速项的权重，低的值允许粒子在被拉回前可以在目标区域外徘徊, 而高的值则导致粒子突然冲向或越过目标区域。
基本粒子群算法MATLAB编程
v(i,:)=w*v(i,:)+c1*rand*(p(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
x(i,:)=x(i,:)+v(i,:);
if fitness(x(i,:),D)<fitness(p(i,:),D)
p(i,:)=x(i,:);
end
if fitness(p(i,:),D)<fitness(pg,D)
pg=p(i,:);
end
end பைடு நூலகம்
Pbest(t)=fitness(pg,D);
end
%最后给出计算结果
disp('*************************************')
disp('函数的全局最优位置为：')
Solution=pg'
disp('最后得到的优化极值为：')
Result=Pbest(t)
disp('*************************************')
clear all;
%clc;
format long;
%给定初始条件
c1=1.4962;%学习因子1
c2=1.4962;%学习因子2
w=0.7298; %惯性权重
MaxDT=1000;%最大迭代数
D=10;%搜索空间维数
N=40;%初始化群体个体数目
%初始化种群的个体（可以在这里限定位置和速度的范围）
pg=x(1,:);%Pg为全局最优
for i=2:N
粒子群算法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）等参数。
整数空间粒子群算法MATLAB程序
整数空间粒子群算法clear allclcticT =1200; %最大迭代次数PopSize=40; %种群大小c1 =2; %学习因子1c2 = 2; %学习因子2w=0.9; %惯性因子NDim = 60; %空间维数for i=1:PopSizefor j=1:NDim %初始化各粒子初始位置，在有效范围内随机选数x(i,j)=round(rand*20) + 20;endendvmax=zeros(PopSize,NDim);for i=1:PopSizefor j=1:NDim %初始化各粒子最大速度，使粒子不能越出边界vmax(i,j)=10;endendv = vmax.*rand( PopSize,NDim);%计算初始各粒子的适应度值for i = 1:PopSizefvalue(i) = youhualianxuduo(x(i,:));endpbest = x; %记录各粒子的个体极值点位置fpbest = fvalue; %记录初始个体最佳适应度值[fbestval,index] = min(fvalue); % 找出全局极值和相应的序号gbest1=fbestval;g1=x(index,:);%浸入主循环，按照公式依次迭代直到满足迭代次数for i=1:Tfor j=1:PopSizeif(youhualianxuduo(x(j,:))<fpbest(j))pbest(j,:)=x(j,:);fpbest(j)=youhualianxuduo(x(j,:));endif (fpbest(j)<gbest1)g1=pbest(j,:);gbest1=fpbest(j);endfor d=1:NDimif pbest(j,d)>x(j,d)a1=0;elsea1=c1*(pbest(j,d)-x(j,d));endif pbest(j,d)>x(j,d)b1=c1*(pbest(j,d)-x(j,d));elseb1=0;endif g1(d)>x(j,d)a2=0;elsea2=c2*(g1(d)-x(j,d));endif g1(d)>x(j,d)b2=c2*(g1(d)-x(j,d));elseb2=0;endR1=randi([a1,b1],1,1);R2=randi([a2,b2],1,1);v(j,d)=round(w*v(j,d))+R1+R2;end%更新速度Vfor n=1:PopSize %速度v的限定，最大值为10 for k=1:NDimif v(n,k)>10v(n,k)=10;endif v(n,k)<-10v(n,k)=-10;endendendx(j,:)=x(j,:)+v(j,:); %更新位置x% 逸出标志for l=1:PopSize % 阻止逸出for m=1:NDimif x(l,m)<1|x(l,m)>40x(l,m)=round(rand*20+20);endendendendw=0.9-i*0.5/Tgb1(i)=gbest1;endfigure(7)plot(gb1);TempStr=sprintf('c1=%g,c2=%g',c1,c2); title(TempStr);xlabel('迭代次数');ylabel('适应度值');toc。
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源程序%function [pso F] = pso_2D()% FUNCTION PSO --------USE Particle Swarm OptimizationAlgorithm% global present;% close all;clc;clear all;pop_size = 10; % pop_size 种群大小 ///粒子数量 part_size = 2; % part_size 粒子大小 ///粒子的维数 gbest = zeros(1,part_size+1); % gbest 当前搜索到的最小的值 max_gen = 200; % max_gen 最大迭代次数%best=zeros(part_size,pop_size*part_size);%xuanregion=zeros(part_size,2); % 设定搜索空间范围->解空间 region=10*[-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3]; %每一维设定不同范围(称之为解空间，不是可行域空间)rand('state',sum(100*clock)); % 重置随机数发生器状态 %当前种群的信息矩阵，逐代进化的群体 % 当前位置,随机初始化 % 一个10*3的随机的矩阵(初始化所有粒子的所有维数的位置值)，其中最后一列为arr_present = ini_pos(pop_size,part_size);% 初始化当前速度% 一个10*2的随机的矩阵(初始化所有粒子的所有维数的速度值)v=ini_v(pop_size,part_size);%不是当前种群，可看作是一个外部的记忆体，存储每个粒子历史最优值(2维数值):根据适应度更新～%注意:pbest数组10*3 最后一列保存的是适应度pbest = zeros(pop_size,part_size+1); % pbest:粒子以前搜索到的最优值，最后一列包括这些值的适应度% 1*80 保存每代的最优值best_record = zeros(part_size+1,max_gen); % best_record数组:记录每一代的最好的粒子的适应度w_max = 0.9; % w_max权系数最大值w_min = 0.2; % w_min权系数最小值v_max = 2; % 最大速度,为粒子的范围宽度c1 = 2; % 学习因子1c2 = 2; % 学习因子2% ————————————————————————% 计算原始种群的适应度,及初始化% ————————————————————————% 注意:传入的第一个参数是当前的粒子群体，ini_fit函数计算每个粒子的适应度% arr_present(:,end)是最后一列，保存每个粒子的适应值，是这样的～xuan arr_present(:,end)= ini_fit( arr_present, pop_size, part_size );% 数组赋值，初始化每个粒子个体的历史最优值，以后会更新的 pbest = arr_present; % 初始化各个粒子最优值% 找到当前群体中适应度最小的(在最后一列中寻找)，best_value % 改为max，表示关联度最大[best_value best_index] = max(arr_present(:,end)); %初始化全局最优，即适应度为全局最小的值，根据需要也可以选取为最大值% 唯一的全局最优值，是当前代所有粒子中最好的一个 gbest =arr_present(best_index,:);% 因为是多目标，因此这个-----------------% 只是示意性的画出3维的%x=[-3:0.01:3];%y=[-3:0.01:3];%[X,Y]=meshgrid(x,y);%Z1=(-10)*exp((-0.2)*sqrt(X^2+Y^2));%Z2=(abs(X))^0.8+abs(Y)^0.8+5*sin(X^3)+5*sin(Y^3);%z1=@(x,y)(-10)*exp((-0.2)*sqrt(x^2+y^2));%z2=@(x,y)(abs(x))^0.8+abs(y)^0.8+5*sin(x^3)+5*sin(y^3);%ezmeshc(z1);grid on;%ezmeshc(z2);grid on;%开始进化，直到最大代数截至for i=1:max_gen%grid on;%三维图象 %多维图象是画不出来的%ezmesh(z),hold on,grid on;%画出粒子群%plot3(arr_present(:,1),arr_present(:,2),arr_present(:,3),'*'),h old off;%drawnow%flush%pause(0.01);w = w_max-(w_max-w_min)*i/max_gen; % 线形递减权重% 当前进化代数:对于每个粒子进行更新和评价----->>>>>>>for j=1:pop_sizev(j,:) =w.*v(j,:)+c1.*rand.*(pbest(j,1:part_size)-arr_present(j,1:part_size ))...+c2.*rand.*(gbest(1:part_size)-arr_present(j,1:part_size)); % 粒子速度更新 (a)% 判断v的大小，限制v的绝对值小于20———————————————————for k=1:part_sizeif abs(v(j,k))>20rand('state',sum(100*clock));v(j,k)=20*rand();endend%前几列是位置信息arr_present(j,1:part_size) =arr_present(j,1:part_size)+v(j,1:part_size);% 粒子位置更新(b) %最后一列是适应度arr_present(j,end) =fitness(part_size,arr_present(j,1:part_size)); % 适应度更新 (保存至最后一列)% 适应度评价与可行域限制if(arr_present(j,end)>pbest(j,end))&(Region_in(arr_present(j,:),regi on)) % 根据条件更新pbest,如果是最小的值为小于号,相反则为大于号pbest(j,:) = arr_present(j,:); % 更新个体的历史极值endend% 以下更新全局的极值[best best_index] = max(arr_present(:,end)); % 如果是最小的值为min,相反则为maxif best>gbest(end) & ( Region_in(arr_present(best_index,:),region) ) % 如果当前最好的结果比以前的好，则更新最优值gbest,如果是最小的值为小于号,相反则为大于号gbest = arr_present(best_index,:); % 全局的极值end%------------混沌---------------------------------xlhd = gbest(1:part_size);if(1)for p=1:25 %次数%1生成cxl=rand(1,part_size);for j=1:part_sizeif cxl(j)==0cxl(j)=0.1;endif cxl(j)==0.25cxl(j)=0.26;endif cxl(j)==0.5cxl(j)=0.51;endif cxl(j)==0.75cxl(j)=0.76;endif cxl(j)==1cxl(j)=0.9;endend%2映射al=-30;bl=30;rxl=al+(bl-al)*cxl;%3搜索bate = 0.1;xlhd=xlhd+bate*rxl;if fitness(part_size,xlhd)>gbest(end) gbest(1:part_size)=xlhd;gbest(end)=fitness(part_size,xlhd);end%4更新for j=1:part_sizecxl(j)=4*cxl(j)*(1-cxl(j));endendend%-------------混沌-------------------------------- %当前代的最优粒子的适应度(取自)保存best_record(:,i) = gbest; % gbest:一个行向量 end pso = gbest; % 最优个体display(gbest);figure;plot(best_record(end,:));% 最优解与代数的进化关系图best=zeros(part_size,max_gen); for i=1:part_size-1 best(i,:)=best_record(i,:);endpareto1= zeros(1,max_gen);pareto2= zeros(1,max_gen);for i=1:max_genpareto1(i)=f1(part_size, best(:,i) );pareto2(i)=f2(part_size, best(:,i) ); endfigure;i=1:max_gen;%plot(i,pareto1(i),'r*',i,pareto2(i),'g*');plot(pareto1(i),pareto2(i),'r+'); xlabel('f1');ylabel('f2');title('Pareto曲线');%figure;%plot(,f2(best_record),);% movie2avi(F,'pso_2D1.avi','compression','MSVC');%子函数%------------------------------------------------------------------------- %------------------------------------------------------------------------- %返回随机的位置function ini_present=ini_pos(pop_size,part_size)ini_present = 10*3*rand(pop_size,part_size+1); %初始化当前粒子位置,使其随机的分布在工作空间%返回一个随机的矩阵，10*(2+1)，最后一列将用来保存适应度%返回随机的速度function ini_velocity=ini_v(pop_size,part_size)ini_velocity =20*(rand(pop_size,part_size)); %初始化当前粒子速度,使其随机的分布在速度范围内%判断是否处于范围内function flag = Region_in(pos_present,region)[m n]=size(pos_present); % 1*11 n返回解的维数10 flag=1;for j=1:n-1flag = flag & ( pos_present(1,j)>=region(j,1) ) &( pos_present(1,j)<=region(j,2) );end%初始化适应度function arr_fitness = ini_fit(pos_present,pop_size,part_size) for k=1:pop_sizearr_fitness(k,1) =fitness(part_size,pos_present(k,1:part_size)); %计算原始种群的适应度end%***************************************************************************% 计算适应度%***************************************************************************function fit = fitness(n,xp)%需要求极值的函数,本例即peaks函数%y0=[-85.4974,-29.9217]; % 注意:这是基准序列，也就是单个最优的极值y0=[-9.9907,-7.7507];%y0=[-39.6162,-18.4561];% y0=[-86.8312,-29.9217];y1=[f1(n,xp),f2(n,xp)]; % n为粒子维数fit=graydegree(2,y0,y1); % 关联度在某种意义上就是适应度%目标函数1function r=f1(n,x)r=0;for i=1:n-1r=r+(-10)*exp((-0.2)*sqrt(x(i)^2+x(i+1)^2)); end%目标函数2function r=f2(n,x)r=0;for i=1:nr=r+(abs(x(i)))^0.8+5*sin(x(i)^3);end%约束函数1function r=g1(n,x)r=0;for i=1:nr=0;end%约束函数2function r=g2(n,x)r=0;for i=1:nr=0;end% 灰色关联度计算函数 ( 越大相似性越好 )% tn目标函数个数 x0基准序列(一组值) x1贷检(一组值) function gama = graydegree( tn,y0,y1 )gama=0;rou =0.5;kesa= zeros(tn,1);m1= abs(y0(1)-y1(1)) ; m2= abs(y0(1)-y1(1)) ; for i=1:tnif( abs(y0(i)-y1(i))>m2 ) %------------------应该取大于呢还是小于m2= abs(y0(i)-y1(i));endendfor i=1:tnkesa(i) = ( m1+rou*m2)/( abs(y0(i)-y1(i)) +rou*m2 );gama = gama + kesa(i); endgama = gama/tn;% 可行解的判决函数 gn为约束条件的个数(暂时未用) n为解(粒子)的维数function bool = feasible( x,n ) r=0;%for i=1:gnr=max( 0, g1(n,x), g2(n,x) );%判断约束条件%endif(r>0)bool=0; %不可行解elsebool=1; %可行解endPSO粒子群算法解决旅行商问题的MATLAB源码PSO粒子群算法解决旅行商问题的MATLAB源码 %粒子群算法求解旅行商问题% By lReijclose all;clear all;PopSize=500;%种群大小CityNum = 14;%城市数OldBestFitness=0;%旧的最优适应度值Iteration=0;%迭代次数MaxIteration =2000;%最大迭代次数IsStop=0;%程序停止标志Num=0;%取得相同适应度值的迭代次数c1=0.5;%认知系数c2=0.7;%社会学习系数w=0.96-Iteration/MaxIteration;%惯性系数,随迭代次数增加而递减%节点坐标node=[16.47 96.10; 16.47 94.44; 20.09 92.54; 22.39 93.37; 25.2397.24;...22.00 96.05; 20.47 97.02; 17.20 96.29; 16.30 97.38; 14.05 98.12;...16.53 97.38; 21.52 95.59; 19.41 97.13; 20.09 94.55];%初始化各粒子，即产生路径种群Group=ones(CityNum,PopSize);for i=1:PopSizeGroup(:,i)=randperm(CityNum)';endGroup=Arrange(Group);%初始化粒子速度(即交换序)Velocity =zeros(CityNum,PopSize); for i=1:PopSizeVelocity(:,i)=round(rand(1,CityNum)'*CityNum); %round取整end%计算每个城市之间的距离CityBetweenDistance=zeros(CityNum,CityNum); for i=1:CityNumfor j=1:CityNumCityBetweenDistance(i,j)=sqrt((node(i,1)-node(j,1))^2+(node(i,2)-node(j,2))^2);endend%计算每条路径的距离for i=1:PopSizeEachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);endIndivdualBest=Group;%记录各粒子的个体极值点位置,即个体找到的最短路径IndivdualBestFitness=EachPathDis;%记录最佳适应度值,即个体找到的最短路径的长度 [GlobalBestFitness,index]=min(EachPathDis);%找出全局最优值和相应序号%初始随机解figure;subplot(2,2,1);PathPlot(node,CityNum,index,IndivdualBest); title('随机解');%寻优while(IsStop == 0) & (Iteration < MaxIteration)%迭代次数递增Iteration = Iteration +1;%更新全局极值点位置,这里指路径for i=1:PopSizeGlobalBest(:,i) = Group(:,index);end%求pij-xij ,pgj-xij交换序，并以概率c1，c2的保留交换序pij_xij=GenerateChangeNums(Group,IndivdualBest);pij_xij=HoldByOdds(pij_xij,c1);pgj_xij=GenerateChangeNums(Group,GlobalBest);pgj_xij=HoldByOdds(pgj_xij,c2);%以概率w保留上一代交换序Velocity=HoldByOdds(Velocity,w);Group = PathExchange(Group,Velocity); %根据交换序进行路径交换Group = PathExchange(Group,pij_xij);Group = PathExchange(Group,pgj_xij);for i = 1:PopSize % 更新各路径总距离EachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);endIsChange = EachPathDis<IndivdualBestFitness;%更新后的距离优于更新前的，记录序号IndivdualBest(:, find(IsChange)) = Group(:, find(IsChange));%更新个体最佳路径IndivdualBestFitness = IndivdualBestFitness.*( ~IsChange) + EachPathDis.*IsChange;%更新个体最佳路径距离[GlobalBestFitness, index] = min(EachPathDis);%更新全局最佳路径,记录相应的序号if GlobalBestFitness==OldBestFitness %比较更新前和更新后的适应度值;Num=Num+1; %相等时记录加一;elseOldBestFitness=GlobalBestFitness;%不相等时更新适应度值，并记录清零;Num=0;endif Num >= 20 %多次迭代的适应度值相近时程序停止IsStop=1;endBestFitness(Iteration) =GlobalBestFitness;%每一代的最优适应度end%最优解subplot(2,2,2);PathPlot(node,CityNum,index,IndivdualBest);title('优化解');%进化曲线subplot(2,2,3);plot((1:Iteration),BestFitness(1:Iteration));grid on;title('进化曲线');%最小路径值GlobalBestFitnessfunction Group=Arrange(Group)[x y]=size(Group);[NO1,index]=min(Group',[],2); %找到最小值1for i=1:ypop=Group(:,i);temp1=pop([1: index(i)-1]);temp2=pop([index(i): x]);Group(:,i)=[temp2' temp1']';endfunction ChangeNums=GenerateChangeNums(Group,BestVar);[x y]=size(Group);ChangeNums=zeros(x,y);for i=1:ypop=BestVar(:,i);%从BestVar取出一个顺序pop1=Group(:,i);%从粒子群中取出对应的顺序for j=1:x %从BestVar的顺序中取出一个序号NoFromBestVar=pop(j);for k=1:x %从对应的粒子顺序中取出一个序号NoFromGroup=pop1(k);if (NoFromBestVar==NoFromGroup) && (j~=k) %两序号同且不在同一位置ChangeNums(j,i)=k; %交换子pop1(k)=pop1(j);pop1(j)=NoFromGroup;endendendendfunction Hold=HoldByOdds(Hold,Odds) [x,y]=size(Hold);for i=1:xfor j=1:yif rand>OddsHold(i,j)=0;endendendfunction SumDistance=PathDistance(path,CityBetweenDistance)L=length(path); %path为一个循环的节点顺序SumDistance=0;for i=1:L-1SumDistance=SumDistance+CityBetweenDistance(path(i),path(i+1));endSumDistance=SumDistance+CityBetweenDistance(path(1),path(L)); %加上首尾节点的距离function Group=PathExchange(Group,Index)[x y]=size(Group);for i=1:ya=Index(:,i); %取出其中一组交换序pop=Group(:,i); %取出对应的粒子for j=1:x %取出其中一个交换算子作交换if a(j)~=0pop1=pop(j);pop(j)=pop(a(j));pop(a(j))=pop1;endendGroup(:,i)=pop;endfunction PathPlot(node,CityNum,index,EachBest);for i=1:CityNumNowBest(i,:)=node((EachBest(i,index)),:);endNowBest(CityNum+1,:)=NowBest(1,:); plot(node(:,1),node(:,2),'*'); line(NowBest(:,1),NowBest(:,2)); grid on;。
粒子群优化算法介绍及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的情况。
matlab粒子群算法实例
matlab粒子群算法实例
粒子群算法（Particle Swarm Optimization, PSO）是一种基于群体智能的优化算法，常用于解决寻优问题。
在Matlab中，你可以使用以下示例来实现粒子群算法：
matlab.
% 首先，定义适应度函数。
fitnessFunction = @(x) x(1)^2 + x(2)^2; % 这里以一个简单的二元函数 x^2 + y^2 为例。
% 然后，设置粒子群算法的参数。
options =
optimoptions('particleswarm','SwarmSize',100,'HybridFcn',@f mincon);
% 接着，运行粒子群算法。
[x,fval] = particleswarm(fitnessFunction,2,[-10,-
10],[10,10],options);
% 最后，输出结果。
disp('最优解，');
disp(x);
disp('最优值，');
disp(fval);
在这个示例中，首先定义了一个简单的二元适应度函数，然后
使用`optimoptions`函数设置了粒子群算法的参数，包括群体大小
和混合函数。
接着调用`particleswarm`函数来运行粒子群算法，最
后输出最优解和最优值。
当然，这只是一个简单的示例，实际应用中你可能需要根据具
体问题对适应度函数和算法参数进行调整。
希望这个示例能帮到你。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
% 优化函数以m文件的形式放在fitness.m里面，对不同的优化函数只要修改fitness.m 就可
%------基本粒子群优化算法（Particle Swarm Optimization, PSO）-----------
%------初始格式化--------------------------------------------------
clear all;
clc;
format long;
%------给定初始化条件----------------------------------------------
c1=1.4962; %学习因子1
c2=1.4962; %学习因子2
w=0.7298; %惯性权重
MaxDT=1000; %最大迭代次数
D=4; %搜索空间维数（未知数个数）
N=10; %初始化群体个体数目
eps=10^(-6); %设置精度(在已知最小值时候用)
%------初始化种群的个体(可以在这里限定位置和速度的范围)------------
x=0:0.1:1，y=[-.447,1.978,3.11,5.25,5.02,4.66,4.01,4.58,3.45,5.35,9.22]
%------先计算各个粒子的适应度，并初始化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('*************************************************************') %------算法结束--------------------------------------。