粒子群算法源程序
混沌粒子群优化算法C源程序

chaos(ps,psbest,d,xmax,xmin);
}
cout<<"收敛结果是"<<psbest<<endl;
}
#define M 20 //粒子的个数
#define D 500 //迭代次数
#define rmax RAND_MAX
typedef struct particle //粒子的结构(包含n维的位置x,速度v,最优位置p,适应度pbest)
{
double x[N];
if((pts[i].x[j]>xmax[j])||(pts[i].x[j]<xmin[j]))
pts[i].x[j]=(xmax[j]-xmin[j])*(double)rand()/(double)RAND_MAX+xmin[j];
}
if(f(pts[i].x)>pts[i].pbest)
for(int i=0;(i<D)&&(psbest<fmin);i++)
{
update(pts,ps,psbest,k,xmax,xmin,vmax,vmin); //更新粒子群
p=1-1/(1+log(k));
if(p>=((double)rand()/(double)RAND_MAX)) //满足混沌搜索的条件
#include<iostream.h>
#include <math.h>
#include<stdlib.h>
python粒子群算法案例

python粒子群算法案例一、引言粒子群优化(ParticleSwarmOptimization,PSO)是一种基于群体智能的优化算法,广泛应用于各种优化问题。
本案例将介绍如何使用Python实现PSO算法,并通过一个具体案例展示其应用效果。
二、算法原理PSO算法是一种模拟鸟群觅食行为的优化算法,通过模拟鸟群觅食过程中的群体行为,寻找最优解。
在PSO算法中,每个优化问题可以被看作是一个搜索空间中的粒子,每个粒子都有一个当前位置和速度,以及一个最优解(即历史最佳位置)。
通过不断迭代,粒子们会逐渐找到最优解。
三、Python实现以下是一个简单的Python实现PSO算法的代码示例:```pythonimportnumpyasnpclassParticle:def__init__(self,dim,minx,maxx):self.position=np.random.uniform(low=minx,high=maxx,size=dim)self.velocity=np.random.uniform(low=-0.1,high=0.1,size=dim)self.best_position=np.copy(self.position)self.best_score=-1#初始最佳位置没有分数classPSO:def__init__(self,dim,n_particles,minx,maxx,inertia,c1,c2):self.particles=[Particle(dim,minx,maxx)for_inrange(n_particles)]self.global_best_position=np.random.uniform(low=minx,high=maxx,size =dim)self.global_best_score=-1#初始全局最佳位置没有分数self.inertia=inertiaself.c1=c1self.c2=c2defupdate_velocity(self,score):forparticleinself.particles:particle.velocity=self.inertia*particle.velocity+self.c1*np.random. rand(particle.position.size)*(score-particle.best_score)+self.c2*np.random.rand(particle.position.size)*(np. random.rand(particle.position.size)-0.5)returnself.particlesdefupdate_position(self):forparticleinself.particles:particle.position=particle.position+self.update_velocity(particle) ```四、案例应用假设我们有一个函数f(x)=x^2,需要找到最小值点。
粒子群算法源程序

粒子群算法源程序二维粒子群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;。
Python代码实现粒子群算法图文详解

Python代码实现粒⼦群算法图⽂详解⽬录1.引⾔2.算法的具体描述:2.1原理2.2标准粒⼦群算法流程3.代码案例3.1问题3.2绘图3.3计算适应度3.4更新速度3.5更新粒⼦位置3.6主要算法过程结果总结1.引⾔粒⼦群优化算法起源于对鸟群觅⾷活动的分析。
鸟群在觅⾷的时候通常会毫⽆征兆的聚拢,分散,以及改变飞⾏的轨迹,但是在不同个体之间会⼗分默契的保持距离。
所以粒⼦群优化算法模拟鸟类觅⾷的过程,将待求解问题的搜索空间看作是鸟类飞⾏的空间,将每只鸟抽象成⼀个没有质量和⼤⼩的粒⼦,⽤这个粒⼦来表⽰待求解问题的⼀个可⾏解。
所以,寻找最优解的过程就相当于鸟类觅⾷的过程。
粒⼦群算法也是基于种群以及进化的概念,通过个体间的竞争与协作,实现复杂空间最优解的求解。
但是与遗传算法不同的是,他不会对每个个体进⾏“交叉”,“变异”等操作,⽽实以⼀定的规则,更新每个粒⼦的速度以及位置,使得每⼀个粒⼦向⾃⾝历史最佳位置以及全局历史最佳位置进⾏移动,从⽽实现整个种群向着最优的⽅向进化。
2.算法的具体描述:2.1原理在粒⼦群优化算法中,粒⼦之间通过信息共享机制,获得其它粒⼦的发现与飞⾏经历。
粒⼦群算法中的信息共享机制实际上是⼀种合作共⽣的⾏为,在搜索最优解的过程中,每个粒⼦能够对⾃⼰经过的最佳的历史位置进⾏记忆,同时,每个粒⼦的⾏为有会受到群体中其他例⼦的影响,所以在搜索最优解的过程中,粒⼦的⾏为既受其他粒⼦的影响,有受到⾃⾝经验的指导。
粒⼦群优化算法对于鸟群的模拟是按照如下的模式进⾏的:假设⼀群鸟在空中搜索⾷物,所有鸟知道⾃⼰当前距离⾷物有多远(这⾥的远近会⽤⼀个值来衡量,适应度值),那么每只鸟最简单的搜索策略就是寻找距离⽬前距离⾷物最近的鸟的周围空间。
因此,在粒⼦群算法中,每个粒⼦都相当于⼀只鸟,每个粒⼦有⼀个适应度值,还有⼀个速度决定他们的飞⾏的距离与⽅向。
所有的粒⼦追随当前最优的粒⼦在解空间中搜索。
每搜索⼀次,最优的粒⼦会发⽣变化,其他的粒⼦⼜会追随新的最优粒⼦进⾏搜索,如此反复迭代。
粒子群算法 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 %循环结束。
基于粒子群优化 算法的计算卸载源代码

基于粒子群优化算法的计算卸载源代码计算卸载是一种将计算任务从本地设备转移到云端或其他远程计算资源的技术。
通过将计算任务卸载到云端,可以利用云端的强大计算能力和资源来完成计算任务,从而减轻本地设备的计算负担,提高计算效率和性能。
粒子群优化(Particle Swarm Optimization, PSO)算法是一种启发式全局优化算法,它模拟了鸟群或鱼群的社会行为。
在 PSO 算法中,每个粒子代表一个潜在的解,粒子在搜索空间中飞行,并根据自身的经验和群体的经验来调整自己的位置和速度,以寻找最优解。
以下是一个基于 PSO 算法的计算卸载源代码示例,这个示例是一个简单的 PSO 算法实现,用于寻找函数的最优解:```pythonimport random# 目标函数def objective_function(x):return x[0]**2 + x[1]**2# PSO 算法实现def pso(objective_func, lb, ub, dim, n_particles, max_iter):# 初始化粒子的位置和速度particles_pos = [random.uniform(lb, ub) for _ in range(n_particles)]particles_vel = [random.uniform(-0.1, 0.1) for _ in range(n_particles * dim)] # 初始化每个粒子的最佳位置和全局最佳位置personal_best_pos = [particle_pos[i] for i in range(n_particles)]personal_best_val = [objective_func(personal_best_pos[i]) for i in range(n_particles)]global_best_val = min(personal_best_val)global_best_pos = personal_best_pos[personal_best_val.index(global_best_val)]# 惯性权重w = 0.5# 个体经验的学习因子c1 = 2# 社会经验的学习因子c2 = 2for i in range(max_iter):for j in range(n_particles):# 更新速度inertia = w * particles_vel[j]cognitive = c1 * random.random() * (personal_best_pos[j] - particles_pos[j]) social = c2 * random.random() * (global_best_pos - particles_pos[j])particles_vel[j] = inertia + cognitive + social# 更新位置particles_pos[j] += particles_vel[j]# 更新个人最佳位置和全局最佳位置personal_best_val[j] = objective_func(personal_best_pos[j])if personal_best_val[j] < global_best_val:global_best_val = personal_best_val[j]global_best_pos = personal_best_pos[j]return global_best_pos# 示例用法lb = [-10, -10]ub = [10, 10]dim = 2n_particles = 10max_iter = 100best_pos = pso(objective_function, lb, ub, dim, n_particles, max_iter)print("最佳位置:", best_pos)print("最佳解:", objective_function(best_pos))```在这个示例中,我们定义了一个目标函数`objective_function`,它是一个简单的二次函数,代表了计算任务的负载。
6种粒子群算法程序

6种粒子群算法程序程序1当c\\ = c i\ = 2 , c n = c22 = 1.5 , w = 1.2 oa)*主函数源程序(main.m)%------ 基本粒子群算法(particle swarm optimization)%------ 名称:基本粒子群算法%------ 初始格式化clear all; %清除所有变量C1C;%清屏format long; %将数据显示为长整形科学计数%……给定初始条条件............N=40; D=10; T=100; cl1=2;%3初始化群体个数%初始化群体维数%初始化群体最迭代次数%学习因子1c21=2;cl2=1.5;c22=1.5;w=L2; eps=10A(-6);%学习因子2%惯性权重%设置精度(在已知最小值的时候用)%……初始化种群个体(限定位置和速度)x=zeros(N,D);v=zeros(N,D); for i=l:Nfor j=l:Dx(lj)=randn; %随机初始化位置v(ij)=randn; %随机初始化速度end end%……显示群位置............... flgure(l)for j=l:Dif(rem(D,2)>0)subplot((D+l)/2,2J)elsesubplot(D/2,2,j)endplot(x(:,j);b*');grid on xlabelC 粒子■) ylabel(*初始位置J tlnfo=strcat(f第*har(j+48)J 维J;tlnfo=strcat(,M \cha r(floor(j/l 0)+48), char(rem(j,l 0)+48),'维');endtitle(tlnfo)end%-一-显示种群速度figure ⑵for j=l:Dif(rem(D^2)>0) subplot((D+l)/2,2J)elsesubplot(D/2,2J)endplot(x(:,j);b*');gricl on xlabelC 粒子') ylabel(,初始速度J tlnfo=strcatf 第,char(j+48),'维');if(j>9)tlnfo=strcat(* 第“har(floor(j/l())+48)9 char(rem(j,l 0)+48),'维);endtitle(tlnfo)endfigure ⑶%第一个图su bp lot( 1,2,1)%……初始化种群个体(在此限定速度和位置) .........xl=x;vl=v;%……初始化个体最优位置和最优值…pl=xl;pbestl=ones(NJ);for i=l:Npbestl (i)=fitness(x 1 (i,: ),D);end%……初始化全局最优位置和最优值 .........gl=l000*ones(l ,D);gbestl=1000;for i=l:Nlf(pbestl(i)<gbest 1)gl=pl(i,:);gbestl=pbestl(i);endendgbl=ones(l,T);%浸入主循环,按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor J=1:NIf (fltness(xl(J,:),D)<pbestl(J))pl(J,:)=xl(|,:);pbestl (J)=fitness(x 1Q,: ),D);endlf(pbest 1 (])<gbest 1)gl=pl(j,:); gbestl=pbestl(J);endvl(j,:)=w*vl(J,:)+cll*rand*(pl(J,:)-xl(j,:))+c21*rand*(gl-xl(J,:));xl(J,:)=xl(J,:)+vl(j,:);endgbl(i)=gbestl;endplot(gbl)T empSt r=sprl ntf(• c 1 = %g ,c2=%g\cll,c21);title(TempStr);xiabelC迭代次数);ylabelC适应度值J;%第二个图subplot(l,2,2)%••…初始化种群个体(在此限定速度和位置) .........x2=x;v2=v;%••…初始化种群个体最有位置和最优解 .......p2=x2;pbest2=ones(N,l);for i=l:Npbest2(i)=fltness(x2(i,: ),D);end%••…初始化种全局最有位置和最优解……g2=1000*ones(l ,D);gbest2=1000;for i=X:Nif(pbest2(i)<gbest2)g2=p2(i,:);gbest2=pbest2(i);endendgb2=ones(l,T);%……浸入主循环,按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor j=l:Nif (fitness(x2(J,:),D)<pbest2 ⑴)p2(J,:)=x2(j,:); pbest2(j)=fitness(x2(J,:),D);endif(pbest2(J)<gbest2)g2=p2(j,:);gbest2=pbest2(J);endV2(jv)=w*v2(j,:)+cl2*rand*(p2(j,:)-x2(j,:))+c22*rand*(g2-x2(j,:));x2(J,:)=x2(j,:)+v2(j,:);endgb2(i)=gbest2;endplot(gb2)TempStr=sprlntf(t cl= %g ,c2=%g\cl2,c22);title(TempStr);xiabclC迭代次数);ylabelC适应度值J;b)适应度函数%适应度函数(fitness.m)function result=fitness(x,D)sum=0;for i=l:Dsiim=sum+x(i)A2;endresult=sum;程序2当C11 =C2l =2 于C]2 =0,Cj2 = 2,w= 1.2 对比a)%主函数源程序(main.m)% ... 基本粒子群算法(particle swarm optimization)%……名称:基本粒子群算法%……初始格式化clear all; %清除所有变量clc; %清屏format long; %将数据显示为长整形科学计数cl2=0;c22=2;w=1.2; %惯性权重eps=10A(-6); %设置精度(在已知最小值的时候用) %……初始化种群个体(限定位置和速度) .........x=zeros(N,D);v=zeros(N,D);for i=l:Nfor j=l:Dx(lj)=randn; %随机初始化位置v(ij)=randn; %随机初始化速度endend%……显示群位置 ..............figure(l)for j=l:Dif(rem(D,2)>0)subplot((D+1 )/2,2 J)elsesubplot(D/2,2J)endplot(x(:J)/b*t);grid onxlabelC 粒子JylabelC初始位置JtInFo=strcatC 第’,char(j+48),1维f);if(j>9)tlnfo=strcat(f \char(floor(j/10)+48) t char(rem(j,10)+48),'维');endtitle(tlnfo)end%……显示种群速度flgure(2)for j=l:Dif(rem(D,2)>0)subplot((D+l)/2^2J)elsesubplot(D/2,2J)endplot(x(:J)/b*t);grid onxlabelC 粒子JylabelC初始速度Jtlnfo=strcat(v第,char(j+48),'维');if(j>9)tlnfo=strcat(,M t?char(floor(J/10)+48), char(rem(JJ0)+48)/ 维);encltitle(tlnfo)endfigure(3)%第一个图subplot(1^24)%……初始化种群个体(在此限定速度和位置)xl=x;vl=v;%……初始化个体最优位置和最优值…pl=xl;pbestl=ones(N,l);for i=l:Npbestl (i)=fitness(xl(i,:),D);end%……初始化全局最优位置和最优值 .........gl=l000*ones(l Q);gbestl=1000;for i=l:Nif(pbestl(i)<gbestl)gl=pl(i,:); gbestl=pbestl(i); endendgbl=ones(l,T);%••…浸入主循环,按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor J=1:Nif (fitness(xl(J^:),D)<pbestl(J))pl(j,:)=xl(j,:);pbest 1 (J)=fitness(x 1 (J),D);endlf(pbestl (J )<gbest 1)gi=pia,:);gbestl=pbestl(j);endvl(J,:)=w*vl(J5:)+cll*ran(l*(pl(J,:)-xl(j,:))+c21*rand*(gl-xl(j,:));xl(j,:)=xl(J,:)+vl(j,:);endgbl(i)=gbestl;endplot(gbl)TempStr=sprlntf(,cl= %g 5c2=%g\cll,c21);title(TempStr);xlabef迭代次数);ylabelC适应度值J;%第二个图subplot( 1,2,2)%••…初始化种群个体(在此限定速度和位置) .........x2=x;v2=v;%-•…初始化种群个体最有位置和最优解 .......p2=x2;pbest2=ones(N,l);for i=l:Npbest2 ⑴=fltness(x2(i,:),D);end%-•…初始化种全局最有位置和最优解……g2=1000*ones(l Q);gbest2=1000;for i=l:Nif(pbest2(i)<gbest2)g2=p2(i,:); gbest2=pbest2(i);endendgb2=ones(l,T);%……浸入主循环,按照公式依次迭代宜到满足精度或者迭代次数…for i=l:Tfor j=l:Nif (fitness(x2(J,:),D)<pbest2(J))p2(j,:)=x2(j,:); pbest2(j)=fitness(x2(J,:),D);endif(pbest2(J)<gbest2)g2=p2(J,:); gbest2=pbest2(j);endv2Q,:)=w*v2(J,:)+cl2*rand*(p2(j,:)-x2(j,:))+c22*rand*(g2-x2(J,:));x2(J,:)=x2(j,:)+v2(j,:);endgb2(i)=gbest2;endplot(gb2)TempStr=sprlntf(,cl= %g ,c2=%f ,cl2,c22);title(TempStr);xlabef迭代次数);ylabelC适应度值J;b)适应度函数%适应度函数(fitness.ni)function result=fitness(x,D)sum=0;for i=l:Dsiim=sum+x(i)A2;end result=sum;程序3当 5 =c 2\ =2,闪=1.2于“2 = 2,C 22 =0,w = 1.2 对比a) %主函数源程序(main.m)% ... 基本粒子群算法(particle swarm optimization )%……名称:基本粒子群算法%……初始格式化clear all;clc;format long; %……给定初始条条件 ........... N=40;D=10;T=100; cl1=2;c21=2;cl2=2;%,初始化群体个数 %初始化群体维数 %初始化群体最迭代次数 %学习因子1 %学习因子2c22=0;w=L2; eps=10A (-6);%惯性权重 %设置精度(在已知最小值的时候用) %……初始化种群个体(限定位置和速度)x=zeros(N,D); v=zeros(N,D);for i=l:Nfor j=l:Dx(ij)=randn; %随机初始化位置 v(ij)=randn; %随机初始化速度 end end%……显示群位置 ..............flgure(l)for J=1:Dif(rem(D,2)>0)subplot((D+l)/2^2J)elsesubplot(D/2,2J)%清除所有变量 %清屏 %将数据显示为长整形科学计数plot(x(:J)/b*,);grid onxlabelC 粒子JylabelC初始位置Jtlnfo=strcat(f第;char(j+48),维J; if(j>9)tlnfo=strcat(,第;char(floor(j/10)+48), char(rem(ja0)+48);维J;encltitle(tlnfo)end%……显示种群速度flgure(2)for j=l:Dif(rem(D^2)>0)su bplot((D+1 )/2,2 J)elsesubplot(D/2,2J)endplot(x(: J;grid onxlabelC 粒子JylabelC初始速度') tInfo=strcatC 第,charQ+48),1维J; if(j>9)tlnfo=strcat(,第;chai*(floor(j/10)+48), char(rem(J40)+48)/ 维);end title(tlnfo)endflgure(3)%第一个图subplot(l929l)%……初始化种群个体(在此限定速度和位置) .........xl=x;vl=v;%……初始化个体最优位置和最优值…pl=xl;pbestl=ones(NJ);for i=l:Nend%……初始化全局最优位置和最优值 .........gl=l000*ones(l ,D);gbestl=1000;for i=l:Nlf(pbestl(i)<gbest 1)gl=pl(i,:);gbestl=pbestl(i);endendgbl=ones(l,T);%浸入主循环,按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor J=1:NIf (fltness(xl(J,:),D)<pbestl(J))pl(J,:)=xl(|,:);pbestl (J)=fitness(x 1Q,: ),D);endlf(pbest 1 (])<gbest 1)gl=pl(j,:); gbestl=pbestl(J);endvl(j,:)=w*vl(J,:)+cll*rand*(pl(J,:)-xl(j,:))+c21*rand*(gl-xl(J,:));xl(J,:)=xl(J,:)+vl(j,:);endgbl(i)=gbestl;endplot(gbl)T empSt r=sprl ntf(• c 1 = %g ,c2=%g\cll,c21);title(TempStr);xiabelC迭代次数);ylabelC适应度值J;%第二个图subplot(l,2,2)%••…初始化种群个体(在此限定速度和位置) .........x2=x;v2=v;%••…初始化种群个体最有位置和最优解 .......p2=x2;pbest2=ones(N,l);for i=l:Npbest2(i)=fltness(x2(i,: ),D);end%••…初始化种全局最有位置和最优解……g2=1000*ones(l ,D);gbest2=1000;for i=X:Nif(pbest2(i)<gbest2)g2=p2(i,:);gbest2=pbest2(i);endendgb2=ones(l,T);%……浸入主循环,按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor j=l:Nif (fitness(x2(J,:),D)<pbest2 ⑴)p2(J,:)=x2(j,:); pbest2(j)=fitness(x2(J,:),D);endif(pbest2(J)<gbest2)g2=p2(j,:);gbest2=pbest2(J);endv2(J,:)=w*v2(j,:)+cl2*rand*(p2(J,:)-x2(J,:))+c22*rand*(g2-x2(j,:));x2(J,:)=x2(j,:)+v2(j,:);endgb2(i)=gbest2;endplot(gb2)TempStr=sprlntf(f cl= %g ,c2=%g\cl2,c22);title(TempStr);xiabclC迭代次数);ylabelC适应度值J;b)适应度函数%适应度函数(fitness.m)function result=fitness(x,D)sum=0;for i=l:Dsiim=sum+x(i)A2;endresult=sum;程序4对c2, W2分别对其取值Cj =1.1, c2 =2, w, =1.2, w2 =1.5测试函数。
基本粒子群算法

简单的基本粒子群算法#include <stdio.h>#include <stdlib.h>#include <time.h>#include <math.h>#define randf (double)(rand()%10000)/10000 using namespace std;const int dim = 30; // 粒子维数const int num = 100; // 粒子群中粒子的个数. const int c1 = 2; // 学习因子1const int c2 = 2; // 学习因子2const int w = 0.9; // 惯性权重因子double Xmax = 500;double Xmin = -500;double Vmax = 50;double Vmin = -50;double gbest_f; // 全局最优适应值.double gbest[dim]; // 全局最优位置.struct particle // 粒子结构.{double f;double pbest_f;double pbest[dim];double X[dim];double V[dim];} swarm[num]; // 粒子群定义.double fitness(); // 计算粒子适应度.void check(); // 检查粒子的速度和范围是否越界. void initial(); // 粒子群的随机初始化void fly(); // 粒子飞翔.double fitness ( double X[] ){double sum = 0;for ( int i = 0 ; i < dim ; i ++ ){double t = X[i];if ( t < 0 )t *= -1;sum += -1*X[i]*sin(sqrt(t));}return sum;}void check(int index){for ( int i = 0 ; i < dim ; i ++ ){if ( swarm[index].X[i] > Xmax )swarm[index].X[i] = Xmax;if ( swarm[index].X[i] < Xmin )swarm[index].X[i] = Xmin;if ( swarm[index].V[i] > Vmax )swarm[index].V[i] = Vmax;if ( swarm[index].V[i] < Vmin )swarm[index].V[i] = Vmin;}}void initial(){double interval0 = Xmax-Xmin;double interval1 = Vmax-Vmin;for ( int i = 0 ; i < num ; i ++ ){particle * p = &swarm[i];for ( int j = 0 ; j < dim ; j ++ ){p->X[j] = interval0 * randf + Xmin;p->V[j] = interval1 * randf + Vmin;}check(i);p->f = fitness(p->X);p->pbest_f = p->f;for ( int j = 0 ; j < dim ; j ++ )p->pbest[j] = p->X[j];}gbest_f = swarm[0].pbest_f;for ( int j = 0 ; j < dim ; j ++ )gbest[j] = swarm[0].X[j];}void fly (){int i,j;for ( i = 0 ; i < num ; i ++ ){particle * p = &swarm[i];for ( j = 0 ; j < dim ; j ++ ){p->V[j] = w*p->V[j] + c1*randf*( p->pbest[j]- p->X[j]) + c2*randf*(gbest[j]-p->X[j]);p->X[j] = p->V[j] + p->X[j];}check(i);p->f = fitness(p->X);if ( p->f < p->pbest_f ){p->pbest_f = p->f;for ( j = 0 ; j < dim ; j ++ )p->pbest[j] = p->X[j];}if ( p->f < gbest_f ){gbest_f = p->f;for ( j = 0 ; j < dim ; j ++ )gbest[j] = p->X[j];}}}int main() {srand((unsigned)time(NULL));initial();for ( int i = 0 ; i < 50000 ; i ++ )fly();double a = fitness(gbest);printf("%lf",a);return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
二维粒子群matlab源程序%function [pso F] = pso_2D()% FUNCTION PSO --------USE Particle Swarm Optimization Algorithm% 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:一个行向量endpso = gbest; % 最优个体display(gbest);figure;plot(best_record(end,:));% 最优解与代数的进化关系图best=zeros(part_size,max_gen);for i=1:part_size-1best(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返回解的维数10flag=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)); %计算原始种群的适应度%**************************************************** ***********************% 计算适应度%**************************************************** ***********************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);%约束函数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.23 97.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;。