最小粒子算法

‘壹’ 优化算法笔记（五）粒子群算法（3）

(已合并本篇内容至粒子群算法（1）)

上一节中，我们看到小鸟们聚集到一个较小的范围内后，不会再继续集中。这是怎么回事呢？
猜测：
1.与最大速度限制有关，权重w只是方便动态修改maxV。
2.与C1和C2有关，这两个权重限制了鸟儿的搜索行为。
还是上一节的实验， 。现在我们将maxV的值有5修改为50，即maxV=50，其他参数不变。参数如下

此时得到的最优位值的适应度函数值为0.25571,可以看出与maxV=5相比，结果差了很多而且小鸟们聚集的范围更大了。
现在我们设置maxV=1，再次重复上面的实验，实验结果如下：

这次最终的适应度函数值为，比之前的结果都要好0.00273。从图中我们可以看出，小鸟们在向一个点集中，但是他们飞行的速度比之前慢多了，如果问题更复杂，可能无法等到它们聚集到一个点，迭代就结束了。
为什么maxV会影响鸟群的搜索结果呢？
我们依然以maxV=50为例，不过这次为了看的更加清晰，我们的鸟群只有2只鸟，同时将帧数放慢5倍以便观察。

思路一：限制鸟的最大飞行速率,由于惯性系数W的存在，使得控制最大速率和控制惯性系数的效果是等价的，取其一即可。
方案1：使惯性系数随着迭代次数增加而降低，这里使用的是线性下降的方式，即在第1次迭代，惯性系数W=1,最后一次迭代时，惯性系数W=0，当然，也可以根据自己的意愿取其他值。
实验参数如下：

小鸟们的飞行过程如上图，可以看到效果很好，最后甚至都聚集到了一个点。再看看最终的适应度函数值8.61666413451519E-17，这已经是一个相当精确的值了，说明这是一个可行的方案，但是由于其最后种群过于集中，有陷入局部最优的风险。
方案2：给每只鸟一个随机的惯性系数，那么鸟的飞行轨迹也将不再像之前会出现周期性。每只鸟的惯性系数W为（0,2）中的随机数（保持W的期望为1）。
实验参数如下：

可以看到小鸟们并没有像上一个实验一样聚集于一个点，而是仍在一个较大的范围内进行搜索。其最终的适应度函数为0.01176，比最初的0.25571稍有提升，但并不显着。什么原因造成了这种情况呢？我想可能是由于惯性系数成了期望为1的随机数，那么小鸟的飞行轨迹的期望可能仍然是绕着一个四边形循环，只不过这个四边形相比之前的平行四边形更加复杂，所以其结果也稍有提升，当然对于概率算法，得到这样的结果可能仅仅是因为运气不好
我们看到惯性系数W值减小，小鸟们聚拢到一处的速度明显提升，那么，如果我们去掉惯性系数这个参数会怎么样呢。
方案3：取出惯性系数，即取W=0，小鸟们只向着那两个最优位置飞行。

可以看见鸟群们迅速聚集到了一个点，再看看得到的结果，最终的适应度函数值为2.9086886073362966E-30，明显优于之前的所有操作。
那么问题来了，为什么粒子群算法需要一个惯性速度，它的作用是什么呢？其实很明显，当鸟群迅速集中到了一个点之后它们就丧失了全局的搜索能力，所有的鸟会迅速向着全局最优点飞去，如果当前的全局最优解是一个局部最优点，那么鸟群将会陷入局部最优。所以，惯性系数和惯性速度的作用是给鸟群提供跳出局部最优的可能性，获得这个跳出局部最优能力的代价是它们的收敛速度减慢，且局部的搜索能力较弱（与当前的惯性速度有关）。
为了平衡局部搜索能力和跳出局部最优能力，我们可以人为的干预一下惯性系数W的大小，结合方案1和方案2，我们可以使每只鸟的惯性系数以一个随机周期，周期性下降，若小于0，则重置为初始值。

这样结合了方案1和方案2的惯性系数，也能得到不错的效果，大家可以自己一试。

思路二：改变小鸟们向群体最优飞行和向历史最优飞行的权重。
方案4：让小鸟向全局最优飞行的系数C2线性递减。

小鸟们的飞行过程与之前好像没什么变化，我甚至怀疑我做了假实验。看看最终结果，0.7267249621552874，这是到目前为止的最差结果。看来这不是一个好方案，让全局学习因子C2递减，势必会降低算法的收敛效率，而惯性系数还是那么大，小鸟们依然会围绕历史最优位置打转，毕竟这两个最优位置是有一定关联的。所以让C1线性递减的实验也不必做了，其效果应该与方案4相差不大。
看来只要是惯性系数不变怎么修改C1和C2都不会有太过明显的效果。为什么实验都是参数递减，却没有参数递增的实验呢？
1.惯性系数W必须递减，因为它会影响鸟群的搜索范围。
2.如果C1和C2递增，那么小鸟的惯性速度V势必会跟着递增，这与W递增会产生相同的效果。

上面我们通过一些实验及理论分析了粒子群算法的特点及其参数的作用。粒子群作为优化算法中模型最简单的算法，通过修改这几个简单的参数也能够改变算法的优化性能可以说是一个非常优秀的算法。
上述实验中，我们仅分析了单个参数对算法的影响，实际使用时（创新、发明、写论文时）也会同时动态改变多个参数，甚至是参数之间产生关联。
实验中，为了展现实验效果，maxV取值较大，一般取值为搜索空间范围的10%-20%，按上面（-100,100）的范围maxV应该取值为20-40，在此基础上，方案1、方案2效果应该会更好。
粒子群算法是一种概率算法，所以并不能使用一次实验结果来判断算法的性能，我们需要进行多次实验，然后看看这些实验的效果最终来判断，结果必须使用多次实验的统计数据来说明，一般我们都会重复实验30-50次，为了发论文去做实验的小伙伴们不要偷懒哦。
粒子群算法的学习目前告一段落，如果有什么新的发现，后面继续更新哦！
以下指标纯属个人yy,仅供参考

目录
上一篇 优化算法笔记（四）粒子群算法（2）
下一篇 优化算法笔记（六）遗传算法

‘贰’ 粒子群优化算法和多模态优化算法有什么区别

摘 要：，粒子群算法据自己的速度来决定搜索过程，只有最优的粒子把信息给予其他的粒子，整个搜索更新过程是跟随当前最优解的过程，所有的粒子还可以更快的收敛于最优解。由于微粒群算法简单，容易实现，与其它求解约束优化问题的方法相比较，具有一定的优势。实验结果表明，对于无约束的非线性求解，粒子群算法表现出较好的收敛性和健壮性。
关键词：粒子群算法；函数优化；极值寻优
0 引言
非线性方程的求根问题是多年来数学家努力解决的问题之一。长期以来，人们已找出多种用于解决方程求根的方法，例如牛顿法、弦割法、抛物线法等。然而，很多传统的方法仅能运用于相应的小的问题集，推广性相对较差。对于一个现实世界中的优化问题，必须尝试很多不同的方法，甚至要发明相应的新的方法来解决，这显然是不现实的。我们需要另外的方法来克服这样的困难。
粒子群算法是一种现代启发式算法，具有推广性强、鲁棒性高等特点[1]。该算法具有群体智能、内在并行性、迭代格式简单、可快速收敛到最优解所在区域等优点[2]。本文采用粒子群算法，对函数的极值进行寻优计算，实现了对函数的极值求解。
1 粒子群算法
1.1 基本原理
粒子群算法（PSO）是一种基于群体的随机优化技术，它的思想来源于对鸟群捕食行为的研究与模拟。粒子群算法与其它基于群体的进化算法相类似，选用“群体”和“进化”的概念，按照个体的适应度值进行操作，也是一种基于迭代的寻优技术。区别在于，粒子群算法中没有交叉变异等进化算子，而是将每个个体看作搜索空间中的微粒，每个微粒没有重量和体积，但都有自己的位置向量、速度向量和适应度值。所有微粒以一定的速度飞行于搜索空间中，其中的飞行速度是由个体飞行经验和群体的飞行经验动态调整，通过追踪当前搜索到的最优值来寻找全局最优值。
1.2 参数选择
粒子群算法需要修改的参数很少，但对参数的选择却十分敏感。El-Gallad A, El-Hawary M, Sallam A, Kalas A[3]主要对算法中的种群规模、迭代次数和粒子速度的选择方法进行了详细分析，利用统计方法对约束优化问题的求解论证了这 3 个参数对算法性能的影响，并给出了具有一定通用性的3 个参数选择原则[4]。
种群规模：通常根据待优化问题的复杂程度确定。
最大速度：决定粒子在一次迭代中的最大移动距离,通常设定为不超过粒子的范围宽度。
加速常数：加速常数c1和c2通常是由经验值决定的，它代表粒子向pbest和gbest靠拢的加速项的权重。一般取值为：c1=c2=2。
中止条件：达到最大迭代次数或得到最小误差要求，通常要由具体问题确定。
惯性权重：惯性权重能够针对待优化问题调整算法的局部和全局搜索能力。当该值较大时有利于全局搜索，较小时有利于局部搜索。所以通常在算法开始时设置较大的惯性权重，以便扩大搜索范围、加快收敛。而随着迭代次数的增加逐渐减小惯性权重的值，使其进行精确搜索，避免跳过最优解。
1.3 算法步骤
PSO算法步骤如下：
Step1：初始化一个规模为 m 的粒子群，设定初始位置和速度。
初始化过程如下：
（1）设定群体规模m;
（2）对任意的i，s，在[-xmax, xmax]内均匀分布，产生初始位置xis；
（3）对任意的i，s，在[-vmax, vmax]内均匀分布，产生速度vis；
（4）对任意的i，设yi=xi，保存个体。
Step2：计算每个粒子的适应度值。
Step3：对每个粒子的适应度值和得到过的最好位置pis的适应度值进行比较，若相对较好，则将其作为当前的最好位置。
Step4：对每个粒子的适应度值和全局得到过的最好位置pgs的适应度值进行比较，若相对较好，则将其作为当前的全局最好位置。
Step5：分别对粒子的所在位置和速度进行更新。
Step6：如果满足终止条件，则输出最优解；否则，返回Step2。
1.4 粒子群算法函数极值求解
粒子群算法优化是计算机智能领域，除蚁群算法外的另一种基于群体智能的优化算法。粒子群算法是一种群体智能的烟花计算技术。与遗传算法相比，粒子群算法没有遗传算法的选择（Selection）、交叉（Crossover）、变异（Mutation）等操作，而是通过粒子在解空间追随最优的粒子进行搜索。
粒子群算法流程如图所示：

粒子群为由n个粒子组成的种群X = (X1,X2,X3,…Xn).
第i个粒子表示一个D维向量Xi = (X1,X2,X3,…XD)T.
第i个粒子的速度为Vi = (Vi1,Vi2,Vi3,…ViD)T.
个体极值为Pi = (Pi1,Pi2,Pi3,…PiD)T.
全局极值为Pg = (Pg1,Pg2,Pg3,…PgD)T.
速度更新为，式中，c1和c2为其两个学习因子的参数值；r1和r2为其两个随机值。
位置更新为.
2 粒子群算法应用举例
2.1 实验问题
这是一个无约束函数的极值寻优，对于Ackley函数，
.
其中c1=20，e=2. 71289。
2.2 实验步骤
对于Ackley函数图形，选取一个凹峰进行分析，程序运行结果如图所示。

图1 Ackley函数图形
可以看出，选取区间内的Ackley函数图形只有一个极小值点。因此，对于该段函数进行寻优，不会陷入局部最小。采用粒子群算法对该函数进行极值寻优。
首先，进行初始化粒子群，编写的MATLAB代码如下：
% 初始化种群
for i=1:sizepop
x1 = popmin1 (popmax1-popmin1)*rand;
% 产生随机个体
x2 = popmin2 (popmax2-popmin2)*rand;
pop(i,1) = x1; % 保存产生的随机个体
pop(i,2) = x2;
fitness(i) = fun([x1,x2]); % 适应度值
V(i,1) = 0; % 初始化粒子速度
V(i,2) = 0;
end
程序运行后所产生的个体值为：
表1 函数个体值

然后，根据待寻优的目标函数，计算适应度值。待寻优的目标函数为：
function y = fun(x)
y=-20*exp(-0.2*sqrt((x(1)^2x(2)^2)/2))-exp((cos(2*pi*x(1)) cos(2*pi*x(2)))/2) 20 2.71289;
根据每一组个体，通过目标函数，得到的适应度值为：

表2 函数适应度值

搜索个体最优极值，即搜索最小的适应度值，我们可利用MATLAB绘图将所有个体的适应度值绘成plot图查看相对最小值。

图3 函数适应度plot图
从图中可看出，当个体=20时，得到相对最小值，在程序中，将其保存下来。
之后进行迭代寻优，直到满足终止条件。
最后，得到的最优值为：

图4 MATLAB运行得到结果
迭代后得到的运行结果图如下：

图5 迭代曲线图
2.3 实验结果
通过图5中可看出，该函数的寻优是收敛的，最优个体和实际情况较吻合。因此，采用粒子群算法进行函数极值寻优，快速、准确且鲁棒性较好。
3 结论
本文阐述了粒子群算法求解最化问题的过程，实验结果表明了该算法对于无约束问题的可行性。与其它的进化算法相比，粒子群算法容易理解、编码简单、容易实现。但是参数的设置对于该算法的性能却有很大的影响，例如控制收敛，避免早熟等。在未来的工作中，将努力于将其它计算智能算法或其它优化技术应用于粒子群算法中，以进一步提高粒子群算法的性能。

‘叁’ 粒子群算法的参数设置

从上面的例子我们可以看到应用PSO解决优化问题的过程中有两个重要的步骤: 问题解的编码和适应度函数 不需要像遗传算法一样是二进制编码(或者采用针对实数的遗传操作.例如对于问题 f(x) = x1^2 + x2^2+x3^2 求解, 粒子可以直接编码为 (x1, x2, x3), 而适应度函数就是f(x). 接着我们就可以利用前面的过程去寻优.这个寻优过程是一个叠代过程, 中止条件一般为设置为达到最大循环数或者最小错误
PSO中并没有许多需要调节的参数,下面列出了这些参数以及经验设置
粒子数: 一般取 20 – 40. 其实对于大部分的问题10个粒子已经足够可以取得好的结果, 不过对于比较难的问题或者特定类别的问题, 粒子数可以取到100 或 200
粒子的长度: 这是由优化问题决定, 就是问题解的长度
粒子的范围: 由优化问题决定,每一维可以设定不同的范围
Vmax: 最大速度,决定粒子在一个循环中最大的移动距离,通常设定为粒子的范围宽度,例如上面的例子里,粒子 (x1, x2, x3) x1 属于 [-10, 10], 那么 Vmax 的大小就是 20
学习因子: c1 和 c2 通常等于 2. 不过在文献中也有其他的取值. 但是一般 c1 等于 c2 并且范围在0和4之间
中止条件: 最大循环数以及最小错误要求. 例如, 在上面的神经网络训练例子中, 最小错误可以设定为1个错误分类, 最大循环设定为2000, 这个中止条件由具体的问题确定.
全局PSO和局部PSO: 我们介绍了两种版本的粒子群优化算法: 全局版和局部版. 前者速度快不过有时会陷入局部最优. 后者收敛速度慢一点不过很难陷入局部最优. 在实际应用中, 可以先用全局PSO找到大致的结果,再用局部PSO进行搜索. 代码来自2008年数学建模东北赛区B题， #includestdafx.h#include<math.h>#include<time.h>#include<iostream>#include<fstream>usingnamespacestd;intc1=2;//加速因子intc2=2;//加速因子doublew=1;//惯性权重doubleWmax=1;//最大惯性权重doubleWmin=0.6;//最小惯性权重intKmax=110;//迭代次数intGdsCnt;//物资总数intconstDim=10;//粒子维数intconstPNum=50;//粒子个数intGBIndex=0;//最优粒子索引doublea=0.6;//适应度调整因子doubleb=0.5;//适应度调整因子intXup[Dim];//粒子位置上界数组intXdown[Dim]=;//粒子位置下界数组intValue[Dim];//初始急需度数组intVmax[Dim];//最大速度数组classPARTICLE;//申明粒子节点voidCheck(PARTICLE&,int);//约束函数voidInput(ifstream&);//输入变量voidInitial();//初始化相关变量doubleGetFit(PARTICLE&);//计算适应度voidCalculateFit();//计算适应度voidBirdsFly();//粒子飞翔voidRun(ofstream&,int=2000);//运行函数classPARTICLE//微粒类{public:intX[Dim];//微粒的坐标数组intXBest[Dim];//微粒的最好位置数组intV[Dim];//粒子速度数组doubleFit;//微粒适合度doubleFitBest;//微粒最好位置适合度};PARTICLEParr[PNum];//粒子数组intmain()//主函数{ofstreamoutf(out.txt);ifstreaminf(data.txt);//关联输入文件inf>>GdsCnt;//输入物资总数Input(inf);Initial();Run(outf,100);system(pause);return0;}voidCheck(PARTICLE&p,intcount)//参数:p粒子对象,count物资数量{srand((unsigned)time(NULL));intsum=0;for(inti=0;i<Dim;i++){if(p.X>Xup)p.X=Xup;elseif(p.X<Xdown)p.X=Xdown;if(p.V>Vmax)p.V=Vmax;elseif(p.V<0)p.V=0;sum+=p.X;}while(sum>count){p.X[rand()%Dim]--;sum=0;for(inti=0;i<Dim;i++){if(p.X>Xup)p.X=Xup;elseif(p.X<Xdown)p.X=Xdown;if(p.V>Vmax)p.V=Vmax;elseif(p.V<0)p.V=0;sum+=p.X;}}voidInput(ifstream&inf)//以inf为对象输入数据{for(inti=0;i<Dim;i++)inf>>Xup;for(inti=0;i<Dim;i++)inf>>Value;}voidInitial()//初始化数据{GBIndex=0;srand((unsigned)time(NULL));//初始化随机函数发生器for(inti=0;i<Dim;i++)Vmax=(int)((Xup-Xdown)*0.035);for(inti=0;i{for(intj=0;j<Dim;j++){Parr.X[j]=(int)(rand()/(double)RAND_MAX*(Xup[j]-Xdown[j])-Xdown[j]+0.5);Parr.XBest[j]=Parr.X[j];Parr.V[j]=(int)(rand()/(double)RAND_MAX*(Vmax[j]-Vmax[j]/2));}Parr.Fit=GetFit(Parr);Parr.FitBest=Parr.Fit;if(Parr.Fit>Parr[GBIndex].Fit)GBIndex=i;}}doubleGetFit(PARTICLE&p)//计算对象适应度{doublesum=0;for(inti=0;i<Dim;i++)for(intj=1;j<=p.X;j++)sum+=(1-(j-1)*a/(Xup-b))*Value;returnsum;}voidCalculateFit()//计算数组内各粒子的适应度{for(inti=0;i{Parr.Fit=GetFit(Parr);}}voidBirdsFly()//粒子飞行寻找最优解{srand((unsigned)time(NULL));staticintk=10;w=Wmax-k*(Wmax-Wmin)/Kmax;k++;for(inti=0;i{for(intj=0;j<Dim;j++){Parr.V[j]=(int)(w*Parr.V[j]);Parr.V[j]+=(int)(c1*rand()/(double)RAND_MAX*(Parr.XBest[j]-Parr.X[j]);Parr.V[j]+=c2*rand()/(double)RAND_MAX*(Parr[GBIndex].XBest[j]-Parr.X[j]));}}Check(Parr,GdsCnt);for(intj=0;j<Dim;j++){Parr.X[j]+=Parr.V[j];Check(Parr,GdsCnt);}CalculateFit();for(inti=0;i{if(Parr.Fit>=Parr.FitBest){Parr.FitBest=Parr.Fit;for(intj=0;j<Dim;j++)Parr.XBest[j]=Parr.X[j];}}GBIndex=0;for(inti=0;i{if(Parr.FitBest>Parr[GBIndex].FitBest&&i!=GBIndex)GBIndex=i;}}voidRun(ofstream&outf,intnum)//令粒子以规定次数num飞行{for(inti=0;i<num;i++){BirdsFly();outf<<(i+1)<<ends<for(intj=0;j<Dim;j++)outf<outf<<endl;}cout<<Done!<<endl;}

‘肆’ 粒子群优化算法

姓名：杨晶晶  学号：21011210420  学院：通信工程学院

【嵌牛导读】

传统的多目标优化方法是将多目标问题通过加权求和转化为单目标问题来处理的,而粒子算法主要是解决一些多目标优化问题的（例如机械零件的多目标设计优化）,其优点是容易实现,精度高,收敛速度快。

【嵌牛鼻子】粒子群算法的概念、公式、调参以及与遗传算法的比较。

【嵌牛提问】什么是粒子群算法？它的计算流程是什么？与遗传算法相比呢？

【嵌牛正文】

1. 概念

        粒子群优化算法(PSO：Particle swarm optimization) 是一种进化计算技术（evolutionary computation），源于对鸟群捕食的行为研究。

        粒子群优化算法的基本思想：是通过群体中个体之间的协作和信息共享来寻找最优解。

        PSO的优势：在于简单容易实现并且没有许多参数的调节。目前已被广泛应用于函数优化、神经网络训练、模糊系统控制以及其他遗传算法的应用领域。

2. 算法

2.1 问题抽象

        鸟被抽象为没有质量和体积的微粒(点)，并延伸到N维空间，粒子i在N维空间的位置表示为矢量Xi＝(x1，x2，…，xN)，飞行速度表示为矢量Vi＝(v1，v2，…，vN)。每个粒子都有一个由目标函数决定的适应值(fitness value)，并且知道自己到目前为止发现的最好位置(pbest)和现在的位置Xi。这个可以看作是粒子自己的飞行经验。除此之外，每个粒子还知道到目前为止整个群体中所有粒子发现的最好位置(gbest)(gbest是pbest中的最好值)，这个可以看作是粒子同伴的经验。粒子就是通过自己的经验和同伴中最好的经验来决定下一步的运动。

2.2 更新规则

      PSO初始化为一群随机粒子(随机解)。然后通过迭代找到最优解。在每一次的迭代中，粒子通过跟踪两个“极值”(pbest，gbest)来更新自己。在找到这两个最优值后，粒子通过下面的公式来更新自己的速度和位置。

      公式(1)的第一部分称为【记忆项】，表示上次速度大小和方向的影响；公式(1)的第二部分称为【自身认知项】，是从当前点指向粒子自身最好点的一个矢量，表示粒子的动作来源于自己经验的部分；公式(1)的第三部分称为【群体认知项】，是一个从当前点指向种群最好点的矢量，反映了粒子间的协同合作和知识共享。粒子就是通过自己的经验和同伴中最好的经验来决定下一步的运动。

      以上面两个公式为基础，形成了PSO的标准形式。

      公式(2)和 公式(3)被视为标准PSO算法。

2.3 标准PSO算法流程

    标准PSO算法的流程：

    1）初始化一群微粒(群体规模为N)，包括随机位置和速度；

    2）评价每个微粒的适应度；

    3）对每个微粒，将其适应值与其经过的最好位置pbest作比较，如果较好，则将其作为当前的最好位置pbest；

    4）对每个微粒，将其适应值与其经过的最好位置gbest作比较，如果较好，则将其作为当前的最好位置gbest；

    5）根据公式(2)、(3)调整微粒速度和位置；

    6）未达到结束条件则转第2）步。

        迭代终止条件根据具体问题一般选为最大迭代次数Gk或(和)微粒群迄今为止搜索到的最优位置满足预定最小适应阈值。

      公式(2)和(3)中pbest和gbest分别表示微粒群的局部和全局最优位置。

    当C1＝0时，则粒子没有了认知能力，变为只有社会的模型(social-only)：

被称为全局PSO算法。粒子有扩展搜索空间的能力，具有较快的收敛速度，但由于缺少局部搜索，对于复杂问题

比标准PSO 更易陷入局部最优。

    当C2＝0时，则粒子之间没有社会信息，模型变为只有认知(cognition-only)模型：

      被称为局部PSO算法。由于个体之间没有信息的交流，整个群体相当于多个粒子进行盲目的随机搜索，收敛速度慢，因而得到最优解的可能性小。

2.4 参数分析

        参数：群体规模N，惯性因子 ，学习因子c1和c2，最大速度Vmax，最大迭代次数Gk。

        群体规模N：一般取20～40，对较难或特定类别的问题可以取到100～200。

        最大速度Vmax：决定当前位置与最好位置之间的区域的分辨率(或精度)。如果太快，则粒子有可能越过极小点；如果太慢，则粒子不能在局部极小点之外进行足够的探索，会陷入到局部极值区域内。这种限制可以达到防止计算溢出、决定问题空间搜索的粒度的目的。

        权重因子：包括惯性因子和学习因子c1和c2。使粒子保持着运动惯性，使其具有扩展搜索空间的趋势，有能力探索新的区域。c1和c2代表将每个粒子推向pbest和gbest位置的统计加速项的权值。较低的值允许粒子在被拉回之前可以在目标区域外徘徊，较高的值导致粒子突然地冲向或越过目标区域。

        参数设置：

        1)如果令c1＝c2＝0，粒子将一直以当前速度的飞行，直到边界。很难找到最优解。

        2)如果＝0，则速度只取决于当前位置和历史最好位置，速度本身没有记忆性。假设一个粒子处在全局最好位置，它将保持静止，其他粒子则飞向它的最好位置和全局最好位置的加权中心。粒子将收缩到当前全局最好位置。在加上第一部分后，粒子有扩展搜索空间的趋势，这也使得的作用表现为针对不同的搜索问题，调整算法的全局和局部搜索能力的平衡。较大时，具有较强的全局搜索能力；较小时，具有较强的局部搜索能力。

        3)通常设c1＝c2＝2。Suganthan的实验表明：c1和c2为常数时可以得到较好的解，但不一定必须等于2。Clerc引入收敛因子(constriction factor) K来保证收敛性。

      通常取为4.1,则K＝0.729.实验表明，与使用惯性权重的PSO算法相比，使用收敛因子的PSO有更快的收敛速度。其实只要恰当的选取和c1、c2，两种算法是一样的。因此使用收敛因子的PSO可以看作使用惯性权重PSO的特例。

        恰当的选取算法的参数值可以改善算法的性能。

3. PSO与其它算法的比较

3.1 遗传算法和PSO的比较

  1)共性：

  (1)都属于仿生算法。

  (2)都属于全局优化方法。

  (3)都属于随机搜索算法。

  (4)都隐含并行性。

  (5)根据个体的适配信息进行搜索，因此不受函数约束条件的限制，如连续性、可导性等。

  (6)对高维复杂问题，往往会遇到早熟收敛和收敛 性能差的缺点，都无法保证收敛到最优点。

    2)差异：   

    (1)PSO有记忆，好的解的知识所有粒子都保 存，而GA（Genetic Algorithm），以前的知识随着种群的改变被改变。

    (2)PSO中的粒子仅仅通过当前搜索到最优点进行共享信息，所以很大程度上这是一种单共享项信息机制。而GA中，染色体之间相互共享信息，使得整个种群都向最优区域移动。

    (3)GA的编码技术和遗传操作比较简单，而PSO相对于GA，没有交叉和变异操作，粒子只是通过内部速度进行更新，因此原理更简单、参数更少、实现更容易。

    (4)应用于人工神经网络(ANN)

    GA可以用来研究NN的三个方面：网络连接权重、网络结构、学习算法。优势在于可处理传统方法不能处理的问题，例如不可导的节点传递函数或没有梯度信息。

    GA缺点:在某些问题上性能不是特别好；网络权重的编码和遗传算子的选择有时较麻烦。

    已有利用PSO来进行神经网络训练。研究表明PSO是一种很有潜力的神经网络算法。速度较快且有较好的结果。且没有遗传算法碰到的问题。

‘伍’ 求粒子群算法C#版

static void Main(string[] args)
{
PSO p = new PSO();
p.mains();
System.Console.ReadLine();
}
class PSO
{
const int S = 20; /*试验次数 */
const int G = 2000; /*混合迭代次数*/
const int P = 40; /*个体总数*/
//#define c1 2.0 /*学习因子1*/
//#define c2 2.0 /*学习因子2*/
const int V = 30; /*个体维数*/
const double MAX = 5.12;
const double MIN = -5.12;
double D = MAX; /*蛙跳的最大值*/
int i1, i2, i3, i4;
int try_number = 0;
int try_max = 5;
double R;//0-1之间的随机数,精度为1/10000
double Wmax = 0.9;
double Wmin = 0.4;
double PI = 3.14159265;
double W = 0.9;
double c1 = 2.0;/*学习因子1*/
double c2 = 2.0;/*学习因子2*/
double Vpso = 0.0;
double Tolerance = 0.0000001;//收敛精度
double c3 = 0.03;//扰动幅度
double e = 2.718281828459;//自然对数底数
int sm = 3;
int bz = 0;//扰动因子标志
public class Individal
{
public double[] d = new double[V];
public double fitness;
}
public class psom
{
public double[] sd = new double[V];
} public psom[] pso = new psom[P]; /*记录每个离子各位的更新速度*/
public Individal px; /*全体中最好位置*/
public Individal[] indivial = new Individal[P]; /*全部个体*/
public Individal[] indiviala = new Individal[P]; /*全部个体——备份*/
public Individal tem; public PSO()
{
for (int i = 0; i < P; i++)
{
pso[i] = new psom();
indivial[i] = new Individal();
indiviala[i] = new Individal();
}
}
/*选择测试函数为Sphere*/
/*选择测试函数为Sphere*/
public double fitness(double[] a)
{
int i;
double sum = 0.0;
double sum1 = 0.0;
double s1 = 0.0, h1 = 0.0;
double[] x1 = new double[V + 1];
for (i = 0; i < V; i++) x1[i] = a[i];
for (i = 0; i < V; i++)
for (i = 0; i < V; i++)
sum = sum + (x1[i] * x1[i] - 10 * Math.Cos(2 * PI * x1[i]) + 10); return sum;
} /*对每一个个体初始化*/
public void init()
{
Random ran = new Random();
//R = ran.NextDouble(); int i, j, pmin = 0;
//srand((unsigned)time(NULL));
for (i = 0; i < P; i++)
{
for (j = 0; j < V; j++)
{
R = ran.NextDouble();
indivial[i].d[j] = R * (MAX - MIN) + MIN;
}
indivial[i].fitness = fitness(indivial[i].d);//计算初始适应值
indiviala[i] = indivial[i];//将个体复制给另一个序列
}
for (i = 0; i < P - 1; i++)
{
if (indivial[pmin].fitness > indivial[i + 1].fitness)
pmin = i + 1;//适应值小者最优
}
px = indivial[pmin];//最优者为小
}
/*按照适应度降序对全部个体进行排序和族群划分*/ /*群组内更新*/
public void update()
{
int i, j, k, l, n;
double a;
double b;
W = Wmax - (double)(i2) * (Wmax - Wmin) / (double)(G);
for (i = 0; i < P; i++)
{ for (j = 0; j < V; j++)//更新粒子速度、位置
{//更新速度
pso[i].sd[j] = W * pso[i].sd[j] + c1 * R * (indiviala[i].d[j] - indivial[i].d[j]) + c2 * R * (px.d[j] - indivial[i].d[j]);
if (pso[i].sd[j] > D) pso[i].sd[j] = D; //D 最大速度
if (pso[i].sd[j] < -D) pso[i].sd[j] = -D;
indivial[i].d[j] = indivial[i].d[j] + pso[i].sd[j];//更新位置
}
a = fitness(indivial[i].d);//计算本次迭代的粒子适应值
// printf("old是%.16f",indivial[i].fitness);
indivial[i].fitness = a;
// printf("new是%.16f",indivial[i].fitness);
// getchar();
if (a < indiviala[i].fitness)
{
indiviala[i] = indivial[i];
if (indiviala[i].fitness < px.fitness)
px = indiviala[i];
}//比较粒子与前一次迭代的适应值 寻求最优者
}
}
public void report()
{
int i;
System.Console.WriteLine(px.fitness);

for (i = 0; i < P; i++)
{
// printf("%.16f\n",indivial[i].fitness);
// printf("%.16f\n",indiviala[i].fitness);
}
}
public void mains()
{
// int i1,i2;
//clock_t start, end;
double ave;
//FILE* f = fopen("result(SFLA).txt", "w");
//for(i4=0;i4<G+1;i4+=50)
//{
ave = 0.0;
//start = clock();
for (int i1 = 0; i1 < S; i1++)
{ init();
for (int i2 = 0; i2 < G; i2++)
{
update();
// report();
// getchar();
}
//
//
report();
ave = ave + px.fitness;
}
//end = clock();
ave = ave / S;
System.Console.WriteLine("平均极值为:");
System.Console.WriteLine(ave);
//System.Console.WriteLine("Interval=%.2fseconds\n", (double)(end - start) / ((double)CLOCKS_PER_SEC));
//printf("%d代为平均极值为%.16f\n",i4,ave);
//fprintf(f,"%d代为平均极值为%.16f\n",i4,ave);
// getchar();
//getchar();
}
}

‘陆’ 粒子群算法

粒子群算法（particle swarm optimization，PSO）是计算智能领域中的一种生物启发式方法，属于群体智能优化算法的一种，常见的群体智能优化算法主要有如下几类：

除了上述几种常见的群体智能算法以外，还有一些并不是广泛应用的群体智能算法，比如萤火虫算法、布谷鸟算法、蝙蝠算法以及磷虾群算法等等。

而其中的粒子群优化算法（PSO）源于对鸟类捕食行为的研究，鸟类捕食时，找到食物最简单有限的策略就是搜寻当前距离食物最近的鸟的周围。

设想这样一个场景：一群鸟在随机的搜索食物。在这个区域里只有一块食物，所有的鸟都不知道食物在哪。但是它们知道自己当前的位置距离食物还有多远。那么找到食物的最优策略是什么？最简单有效的就是搜寻目前离食物最近的鸟的周围区域。

Step1:确定一个粒子的运动状态是利用位置和速度两个参数描述的，因此初始化的也是这两个参数；
Step2:每次搜寻的结果（函数值）即为粒子适应度，然后记录每个粒子的个体历史最优位置和群体的历史最优位置；
Step3:个体历史最优位置和群体的历史最优位置相当于产生了两个力，结合粒子本身的惯性共同影响粒子的运动状态，由此来更新粒子的位置和速度。

位置和速度的初始化即在位置和速度限制内随机生成一个N x d 的矩阵，而对于速度则不用考虑约束，一般直接在0~1内随机生成一个50x1的数据矩阵。

此处的位置约束也可以理解为位置限制，而速度限制是保证粒子步长不超限制的，一般设置速度限制为[-1,1]。

粒子群的另一个特点就是记录每个个体的历史最优和种群的历史最优，因此而二者对应的最优位置和最优值也需要初始化。其中每个个体的历史最优位置可以先初始化为当前位置,而种群的历史最优位置则可初始化为原点。对于最优值，如果求最大值则初始化为负无穷，相反地初始化为正无穷。

每次搜寻都需要将当前的适应度和最优解同历史的记录值进行对比，如果超过历史最优值，则更新个体和种群的历史最优位置和最优解。

速度和位置更新是粒子群算法的核心，其原理表达式和更新方式：

每次更新完速度和位置都需要考虑速度和位置的限制，需要将其限制在规定范围内，此处仅举出一个常规方法，即将超约束的数据约束到边界（当位置或者速度超出初始化限制时，将其拉回靠近的边界处）。当然，你不用担心他会停住不动，因为每个粒子还有惯性和其他两个参数的影响。

粒子群算法求平方和函数最小值，由于没有特意指定函数自变量量纲，不进行数据归一化。

‘柒’ 粒子群优化算法

         粒子群算法 的思想源于对鸟/鱼群捕食行为的研究，模拟鸟集群飞行觅食的行为，鸟之间通过集体的协作使群体达到最优目的，是一种基于Swarm Intelligence的优化方法。它没有遗传算法的“交叉”(Crossover) 和“变异”(Mutation) 操作，它通过追随当前搜索到的最优值来寻找全局最优。粒子群算法与其他现代优化方法相比的一个明显特色就是所 需要调整的参数很少、简单易行 ，收敛速度快，已成为现代优化方法领域研究的热点。

         设想这样一个场景：一群鸟在随机搜索食物。已知在这块区域里只有一块食物；所有的鸟都不知道食物在哪里；但它们能感受到当前的位置离食物还有多远。那么找到食物的最优策略是什么呢？

        1. 搜寻目前离食物最近的鸟的周围区域

        2. 根据自己飞行的经验判断食物的所在。

        PSO正是从这种模型中得到了启发，PSO的基础是 信息的社会共享

        每个寻优的问题解都被想象成一只鸟，称为“粒子”。所有粒子都在一个D维空间进行搜索。

        所有的粒子都由一个fitness function 确定适应值以判断目前的位置好坏。

        每一个粒子必须赋予记忆功能，能记住所搜寻到的最佳位置。

        每一个粒子还有一个速度以决定飞行的距离和方向。这个速度根据它本身的飞行经验以及同伴的飞行经验进行动态调整。

        粒子速度更新公式包含三部分： 第一部分为“惯性部分”，即对粒子先前速度的记忆；第二部分为“自我认知”部分，可理解为粒子i当前位置与自己最好位置之间的距离；第三部分为“社会经验”部分，表示粒子间的信息共享与合作，可理解为粒子i当前位置与群体最好位置之间的距离。

        第1步   在初始化范围内，对粒子群进行随机初始化，包括随机位置和速度

        第2步   根据fitness function，计算每个粒子的适应值

        第3步   对每个粒子，将其当前适应值与其个体历史最佳位置（pbest）对应的适应值作比较，如果当前的适应值更高，则用当前位置更新粒子个体的历史最优位置pbest

        第4步   对每个粒子，将其当前适应值与全局最佳位置（gbest）对应的适应值作比较，如果当前的适应值更高，则用当前位置更新粒子群体的历史最优位置gbest

        第5步   更新粒子的速度和位置

        第6步   若未达到终止条件，则转第2步

        【通常算法达到最大迭代次数或者最佳适应度值得增量小于某个给定的阈值时算法停止】

粒子群算法流程图如下：

以Ras函数（Rastrigin's Function）为目标函数，求其在x1,x2∈[-5,5]上的最小值。这个函数对模拟退火、进化计算等算法具有很强的欺骗性，因为它有非常多的局部最小值点和局部最大值点，很容易使算法陷入局部最优，而不能得到全局最优解。如下图所示，该函数只在(0,0)处存在全局最小值0。