粒子群算法（PSO）

Posted on

利用群体中的个体对信息的共享使整个群体的运动在问题求解空间中产生从无序到有序的演化过程，从而获得最优解。

粒子群参数设置

1
2
3
4
5
6
7
8
9
int n = 3; // 粒子个数
double[] y;
double[] x;
double[] v;
double c1 = 2;
double c2 = 2;
double pbest[];
double gbest;
double vmax = 0.1; // 速度最大值

适应度函数

定义适应度函数，每个粒子都有自己的适应度(这里求解y=-x2+2x的最大值)

1
2
3
4
5
public void fitnessFunction() {
    for (int i = 0; i < n; i++) {
        y[i] = -1 * x[i] * (x[i] - 2);
    }
}

粒子群初始化

初始化当前个体最优位置，并找到群体最优位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void init() {
    x = new double[n];
    v = new double[n];
    y = new double[n];
    pbest = new double[n];
    x[0] = 0.0;
    x[1] = 2.0;
    x[2]=0.5;
    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("算法开始，起始最优解:" + gbest);
    System.out.print("\n");
}

更新粒子群

更新每个粒子的位置和速度，更新个体极值和群体极值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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];
            // 越界判断，范围限定在[0, 2]
            if (x[j] > 2)
                x[j] = 2;
            if (x[j] < 0)
                x[j] = 0;

        }
        fitnessFunction();
        // 更新个体极值和群体极值
        for (int j = 0; j < n; j++) {
            pbest[j] = Math.max(y[j], pbest[j]);
            if (pbest[j] > gbest)
                gbest = pbest[j];
            System.out.println("粒子n" + j + " :  x = " + x[j] + "    " + " v  = " + v[j]);
        }
        System.out.println("第" + (i + 1) + " 次迭代，全局最优解 gbest = " + gbest);
        System.out.print("\n");
    }
}

主函数

1
2
3
4
5
public static void main(String[] args) {
    AlgorithmPSO ts = new AlgorithmPSO();
    ts.init();
    ts.PSO(100);
}

运算结果

1
2
3
4
粒子n0 :  x = 0.9999999999934679     v  = 2.595715028936614E-12
粒子n1 :  x = 0.9999999999977818     v  = -4.865410319968633E-12
粒子n2 :  x = 1.0000000514230944     v  = 7.147215240458387E-8
第100 次迭代，全局最优解 gbest = 1.0