pso 学习

PSO

介绍：

     粒子群优化算法（PSO)是是Kennedy和Eberhart受人工生命研究结果的启发、通过模拟鸟群觅食过程中的迁徙和群聚行为而提出的一种基于群体智能的全局随机搜索算法，是基于群体智能的全局优化算法，它是将群体中的个体看做是D维空间的没有质量和体积的粒子，并以一定的速度在解空间运动。运动方向为自身历史最佳位置于领域最佳位置，是现对候选解的进化。

粒子属性:位置向量,飞行速度，历史最佳位置，领域最佳位置（即为种群的最佳位置）.

位置更新公式：，

速度更新公式：

算法模拟鸟群觅食。因此位置公式很熟悉的感脚，速度公式则有3部分组成，第一部分为惯性，第二部分为认知，第三部分为社会部分。

参数描述C1，C2为学习因子,R1，R2为【0-1】之间的随机数，P[I][J]为自身最佳位置，P[L][J]为种群最佳位置。

这种设计放映了群体之间的知识共享与向自身历史最佳位置靠近的趋势。。

PSO伪代码：

 

nclear all;nclc;nformat long;n%------给定初始化条件----------------------------------------------nc1=1.4962;             %学习因子1nc2=1.4962;             %学习因子2nw=0.7298;              %惯性权重nMaxDT=1000;            %最大迭代次数nD=10;                  %搜索空间维数（未知数个数）nN=40;                  %初始化群体个体数目neps=10^(-6);           %设置精度(在已知最小值时候用)n %------初始化种群的个体(可以在这里限定位置和速度的范围)------------nfor i=1:Nn    for j=1:Dn        x(i,j)=randn;  %随机初始化位置n        v(i,j)=randn;  %随机初始化速度n    endnendn n

 

 

n%------先计算各个粒子的适应度，并初始化Pi和Pg----------------------nfor i=1:Nn    p(i)=f(x(i,:),D);n    y(i,:)=x(i,:);nEndnpg=x(1,:);       

      %Pg为全局最优nfor i=2:Nn 

   if f(x(i,:),D)<f(pg,D)n      

  pg=x(i,:);n  

  endnEndn%------进入主要循环，按照公式依次迭代，直到满足精度要求-----------

-nfor t=1:MaxDTn    for i=1:Nn     

   v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));n       

x(i,:)=x(i,:)+v(i,:);n    

    if f(x(i,:),D)<p(i)n      

      p(i)=f(x(i,:),D);n         

   y(i,:)=x(i,:);n   

     end

我的代码：

#include<iostream>
#include<windows.h>
#include<ctime>
#include<cstdlib>
using namespace std;
#define c1 1.4926
#define c2 1.4926
#define w 0.729//惯性权重。
#define MAXDT 1500
#define D 10
#define N 40
#define eps 1e-6
#define URAND (rand()/(RAND_MAX+1.0))
#define m_low -100//位置小
#define m_high 100//位置最大值
class L//定义粒子个体
{
public:
L();
     double x[D];//位置坐标
double v[D];//速度坐标
double p[D];//历史最优坐标
double fit_ness;//当前适应值
     double p_fit_ness;//历史最优适应值
double rd(double low,double high);
void fit_ness_count();
void p_best_copy();
 
};
double L::rd(double low,double high)
{
return URAND*(high-low)+low;
}
L::L()
{
int i;
for(i=0;i<D;i++)
{
x[i]=p[i]=rd(m_low,m_high);
}
for(i=0;i<D;i++)
{
v[i]=rd(-100,100);
}
fit_ness_count();
p_fit_ness=fit_ness;
}
void L::fit_ness_count()//计算适应值
{
int i;
double ans=0;
for(i=0;i<D;i++)
{
      ans+=x[i]*x[i];
}
    fit_ness=ans;
 
 
}
void L::p_best_copy()
{
int i;
if(fit_ness<p_fit_ness)
{
for(i=0;i<D;i++)
{
p[i]=x[i];
}
p_fit_ness=fit_ness;
}
 
 
}
class PSO
{
public:
PSO();
L num[N];
L l_best;//全局最优值。
    void g_p_cpy();//全局最优拷贝函数。
void g_p_serch();//搜索PSO最优值。//计算过程
};
 PSO::PSO()
{
l_best=num[0];
g_p_cpy();
}
void PSO::g_p_cpy()
{
int i;
for(i=0;i<N;i++)
{
if(l_best.p_fit_ness>num[i].p_fit_ness)
l_best=num[i];
 
}
}
void PSO::g_p_serch()
{
      int i,j,k;
 for(i=0;i<MAXDT;i++)//进入繁衍代数循环
 {
 for(j=0;j<N;j++)//粒子计算
 {
 for(k=0;k<D;k++)
 {
  num[j].v[k]=w*num[j].v[k]+c1*num[j].rd(0,1)*(num[j].p[k]-num[j].x[k])
  +c2*num[j].rd(0,1)*(l_best.p[k]-num[j].x[k]);
                     if(num[j].v[k]<-100.0)num[j].v[k]=-100;
                     else if(num[j].v[k]>100.0)num[j].v[k]=100.0;                            //边界处理
   num[j].x[k]+=num[j].v[k];      //位置更新
   if(num[j].x[k]>100)num[j].x[k]=100;
   else if(num[j].x[k]<-100)num[j].x[k]=-100;
 }//产生子代。。
 num[j].fit_ness_count();
num[j].p_best_copy();
 
 }
 
 g_p_cpy();
 
 }
 
}
int main()
{
long start=clock();
   PSO pso;  int i;
srand(unsigned(time(0)));
 pso.g_p_serch();
 cout<<pso.l_best.p_fit_ness<<endl;
 cout<<clock()-start<<"ms"<<endl;
 
}