粒子群算法

一、一个形象的比喻　

　　粒子群算法可以用鸟类在一个空间内随机觅食为例，所有的鸟都不知道食物具体在哪里，但是他们知道大概距离多远，最简单有效的方法就是搜寻目前离食物最近的鸟的周围区域。

    所以，粒子群算法就是把鸟看成一个个粒子，并且他们拥有位置和速度这两个属性，然后根据自身已经找到的离食物最近的解和参考整个共享于整个集群中找到的最近的解去改变自己的飞行方向，最后我们会发现，整个集群大致向同一个地方聚集。而这个地方是离食物最近的区域，条件好的话就会找到食物。这就是粒子群算法，很好理解。

二、算法历史

　　粒子群优化算法(PSO)是一种进化计算技术(evolutionary computation)，1995 年由Eberhart 博士和kennedy 博士提出，源于对鸟群捕食的行为研究 。该算法最初是受到飞鸟集群活动的规律性启发，进而利用群体智能建立的一个简化模型。粒子群算法在对动物集群活动行为观察基础上，利用群体中的个体对信息的共享使整个群体的运动在问题求解空间中产生从无序到有序的演化过程，从而获得最优解。

三、算法流程

For each particle

 　　Initialize particle

END

Do

　　For each particle

　　　　Calculate fitness value

　　　　If the fitness value is better than the best fitness value (pBest) in history

　　　　　　set current value as the new pBest

　　End

　　Choose the particle with the best fitness value of all the particles as the gBest

　　For each particle

　　　　Calculate particle velocity according equation (a)

　　　　Update particle position according equation (b)

　　End

While maximum iterations or minimum error criteria is not attained

流程图：

四、算法一个简单的代码

[java] view plaincopyprint?
<span style="font-family:Microsoft YaHei">/*** 
 *  计算y=-x(x-1)的最大值 
 *  取值范围x--[-2,2] 
 * @author BreezeDust 
 * 
 */  
public class PSOTest {  
    int n=2; //粒子个数，这里为了方便演示，我们只取两个，观察其运动方向  
    double[] y;  
    double[] x;  
    double[] v;  
    double c1=2;  
    double c2=2;  
    double pbest[];  
    double gbest;  
    double vmax=0.1;  
    public void fitnessFunction(){//适应函数  
        for(int i=0;i<n;i++){  
            y[i]=-1*x[i]*(x[i]-2);  
        }  
    }  
    public void init(){ //初始化  
        x=new double[n];  
        v=new double[n];  
        y=new double[n];  
        pbest=new double[n];  
        /*** 
         * 本来是应该随机产生的，为了方便演示，我这里手动随机落两个点，分别落在最大值两边 
         */  
        x[0]=-0.5;  
        x[1]=2.6;  
        v[0]=0.01;  
        v[1]=0.02;  
        fitnessFunction();  
        //初始化当前个体极值，并找到群体极值  
        for(int i=0;i<n;i++){  
            pbest[i]=y[i];  
            if(y[i]>gbest) gbest=y[i];  
        }  
        System.out.println("start gbest:"+gbest);  
    }  
    public double getMAX(double a,double b){  
        return a>b?a:b;  
    }  
    //粒子群算法  
    public void PSO(int max){  
        for(int i=0;i<max;i++){  
            double w=0.4;  
            for(int j=0;j<n;j++){  
                //更新位置和速度  
                v[j]=w*v[j]+c1*Math.random()*(pbest[j]-x[j])+c2*Math.random()*(gbest-x[j]);  
                if(v[j]>vmax) v[j]=vmax;  
                x[j]+=v[j];  
                //越界判断  
                if(x[j]>2) x[j]=2;  
                if(x[j]<-2) x[j]=-2;  
                  
            }  
            fitnessFunction();  
            //更新个体极值和群体极值  
            for(int j=0;j<n;j++){  
                pbest[j]=getMAX(y[j],pbest[j]);  
                if(pbest[j]>gbest) gbest=pbest[j];  
                System.out.println(x[j]+"  "+v[j]);  
            }  
            System.out.println("======"+(i+1)+"======gbest:"+gbest);  
        }  
          
          
    }  
    public static void main(String[] args){  
        PSOTest ts=new PSOTest();  
        ts.init();  
        ts.PSO(100);  
    }  
  
      
  
}</span>

 参考文献：http://blog.csdn.net/breezedust/article/details/12378519