智能计算——粒子群优化算法（PSO）

基本原理

• PSO模拟了自然界鸟群捕食和鱼群捕食的过程。
• 通过群体中的协作寻找到问题的全局最优解。
• 它是1995年由美国学者Eberhart和Kennedy提出的，
• 现在已经广泛应用于各种工程领域的优化问题之中。

基本流程：

代码实现（Java）

在实验作业中我选择了老师课程中选择的函数 ，这个函数具有非常好的性质，单峰，无论是在多少维度的空间都可以在原点处取到最小值0.

import java.util.Arrays;
import java.util.Random;

/**
 * PSO
 */
public class PSO {
    public static int birdsSize = 50;
    public static int batch =100;
    public static int n = 2;
    public static double w = 0.5;
    public static double c1 = 2;
    public static double c2 = 2;
    public static double[] gBest = new double[2];
    public static class Bird{
        public double[] position;
        public double[] velocity;
        public double[] pBest;
        public Bird(double[] position,double[] velocity){
            this.position = position;
            this.velocity = velocity;
            this.pBest = position;
        }
    }
    public static Bird[] birds = new Bird[birdsSize];
    //随机初始化每一个粒子
    public static void initBirds() {
        for (int i = 0; i < birdsSize; i++) {
            double[] position = new double[2];
            double[] velocity = new double[2];
            Random r = new Random();
            position[0] = 20*r.nextDouble()-10;
            position[1] = 20*r.nextDouble()-10;
            velocity[0] = 20*r.nextDouble()-10;
            velocity[1] = 20*r.nextDouble()-10;
            birds[i] = new Bird(position, velocity);
        }
    }
    //评估粒子的函数值,f(x) = x1^2+x2^2
    public static double assess(double[] position) {
        double x,y;
        x = position[0];
        y = position[1];
        return Math.pow(x, 2)+Math.pow(y, 2);
    }
    //寻找全局最优的粒子
    public static void findGBest(boolean first) {
        double min = first? 9999 : assess(gBest);
        for (Bird bird : birds) {
            if(assess(bird.pBest)<min){
                min = assess(bird.pBest);
                gBest[0] = bird.pBest[0];
                gBest[1] = bird.pBest[1];

            }
        }
    }
    //更新每一个粒子
    public static void update(){
        for (Bird bird : birds) {
            double r1 = Math.random();
            double r2 = Math.random();
            for (int i = 0; i < 2; i++) {
                double x = w*bird.velocity[i]+c1*r1*(bird.pBest[i]-bird.position[i])+c2*r2*(gBest[i]-bird.position[i]);
                x = x>10? 10: x;
                x = x<-10? -10: x;
                bird.velocity[i] = x;
                x = bird.position[i] +bird.velocity[i];
                x = x>10? 10: x;
                x = x<-10? -10: x;
                bird.position[i] = x;
            };
            //更新粒子的历史最优位置
            if(assess(bird.pBest)>=assess(bird.position)){
                bird.pBest = bird.position;
            }
            
        }
        //更新全局最优
        findGBest(false);
    }
    public static void main(String[] args) {
        initBirds();
        findGBest(true);
        System.out.println("best position is :"+Arrays.toString(gBest)+"  the value is "+assess(gBest));
        for (int i = 0; i < batch; i++) {
            update();
            System.out.println("best position is :"+Arrays.toString(gBest)+"  the value is "+assess(gBest));
        }

    }
}

算法改进

PSO 算法也存在诸多缺陷。PSO 算法的寻优过程是通过粒子间的相互影响和相互竞争来完成的，其中粒子自身并不存在变异机制，所以导致单个粒子容易被局部极值所影响，容易陷入局部极值且不易跳出。在寻优的初期，算法的收敛速度较快，寻优到后期收敛速度较慢甚至会出现停滞的情况，粒子几乎不再进化，运动轨迹也趋于稳定，此时算法就视为收敛，寻优结束，但是可能算法并没有收敛到全局最优，发生早熟现象。粒子聚集到一起缺乏多样性，导致粒子短时间内无法跳出集聚点。

所以基本的改进思路是：

1. 迭代初期要保证粒子的多样性和收敛速度。
2. 在搜索后期，如果粒子陷入局部最优，要尝试引导跳出局部最优解。

本次作业选取的改进策略：

线性递减惯性权重具有较好的寻优性能，已经被广泛地应用。该算法中的惯性权重融入了反映粒子状态的参数--进化比率。计算进化比率之前，先计算出粒子的进化个数，再求出整个粒子种群的进化比率，然后将其用于惯性权重的更新。根据种群中粒子是否实现了进化计算种群的进化率，然后自适应调整惯性权重。

同理也是通过进化率来自适应调整种群规模，从而实现种群规模的自适应调整。

本文的改进算法来自下面的论文。本人用于课程作业的代码实现。
Title-题名: 几种粒子群优化算法及其应用研究
Author-作者: 高星星
Year-年: 2020
PubTime-发表时间: 2020-05-01
Keyword-关键词: 智能优化算法;粒子群优化;混合算法;路径规划问题;选址问题;旅行商问题
Link-链接:  几种粒子群优化算法及其应用研究 - 中国知网