粒子群優(yōu)化(PSO, particle swarm optimization)?是由Kennedy和Eberhart在1995年提出的一 種群智能優(yōu)化方法。

優(yōu)點：好理解容易實現(xiàn)，適合解決極值問題

缺點：容易過早收斂，容易陷入局部最優(yōu)解，（如果初始點選的不好，可能就會被某個粒子帶偏了= =/）

（Java實現(xiàn)）:

 1 package pso;
 2 
 3 import java.util.Random;
 4 
 5 /**
 6  * 粒子類
 7  * 
 8  * @see dimension
 9  * @author Flyuz
10  */
11 public class Particle {
12     // 維數(shù)
13     public int dimension = 2;
14     // 粒子的位置
15     public double[] X = new double[dimension];
16     // 粒子的速度
17     public double[] V = new double[dimension];
18     // 局部最好位置
19     public double[] pbest = new double[dimension];
20     // 最大速度
21     public double Vmax = 2;
22     // 最大位置
23     public double[] Xmax = { 2, 2 };
24     // 最小位置
25     public double[] Xmin = { -2, -2 };
26     // 適應(yīng)值
27     public double fitness;
28 
29     /**
30      * 根據(jù)當(dāng)前位置計算適應(yīng)值 本例子求式子最大值
31      * 
32      * @return newFitness
33      */
34     public double calculateFitness() {
35 
36         double newFitness = 0;
37         if (X[0] == 0 && X[1] == 0)
38             newFitness = Math.exp((Math.cos(2 * Math.PI * X[0]) + Math.cos(2 * Math.PI * X[1])) / 2) - 2.71289;
39         else
40             newFitness = Math.sin(Math.sqrt(Math.pow(X[0], 2) + Math.pow(X[1], 2)))
41                     / Math.sqrt(Math.pow(X[0], 2) + Math.pow(X[1], 2))
42                     + Math.exp((Math.cos(2 * Math.PI * X[0]) + Math.cos(2 * Math.PI * X[1])) / 2) - 2.71289;
43         return newFitness;
44     }
45 
46     /**
47      * 初始化自己的位置和pbest
48      */
49     public void initialX() {
50         for (int i = 0; i < dimension; i++) {
51             X[i] = new Random().nextDouble() * (Xmax[i] - Xmin[i]) + Xmin[i];
52             pbest[i] = X[i];
53         }
54     }
55 
56     /**
57      * 初始化自己的速度
58      */
59     public void initialV() {
60         for (int i = 0; i < dimension; i++) {
61             V[i] = new Random().nextDouble() * Vmax * 0.5;
62         }
63     }
64 }

粒子類 算法類 針對缺點，提出了 Multi-start PSO 算法，即每迭代若干次后，都保留歷史優(yōu)粒子，粒子全部初始化，以提高粒子的多樣性，擴大搜索 空間。又提出了一種動態(tài)慣性權(quán)重的粒子群優(yōu)化算法，慣性權(quán)重隨著迭代次數(shù)的增加而降低，在開始階段具有較強的全局搜索能力，而在后期以 較小的慣性權(quán)重能夠收斂到優(yōu)解。?

  1 package pso;
  2 
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 import java.util.Random;
  6 
  7 public class NormalPSO {
  8 
  9     private static double[] gbest;// 全局最優(yōu)位置
 10     private static double gbest_fitness = -0x3f3f3f;// 全局最優(yōu)位置對應(yīng)的fitness
 11     private static int particle_num = 10;// 粒子數(shù)
 12     private static int N = 100;// 迭代次數(shù)
 13     private static int c1, c2 = 2;
 14     private static double w = 1.4;// 慣性因子
 15     private static List<Particle> particles = new ArrayList<Particle>();// 粒子群
 16 
 17     /**
 18      * 初始化所有粒子
 19      */
 20     public static void initialParticles() {
 21         for (int i = 0; i < particle_num; i++) {
 22             Particle particle = new Particle();
 23             particle.initialX();
 24             particle.initialV();
 25             particle.fitness = particle.calculateFitness();
 26             particles.add(particle);
 27         }
 28     }
 29 
 30     /**
 31      * 更新 gbest
 32      */
 33     public static void updateGbest() {
 34         double fitness = -0x3f3f3f;
 35         int index = 0;
 36         for (int i = 0; i < particle_num; i++) {
 37             if (particles.get(i).fitness > fitness) {
 38                 index = i;
 39                 fitness = particles.get(i).fitness;
 40             }
 41         }
 42         if (fitness > gbest_fitness) {
 43             gbest = particles.get(index).pbest.clone();
 44             gbest_fitness = fitness;
 45         }
 46     }
 47 
 48     /**
 49      * 更新每個粒子的速度
 50      */
 51     public static void updateV() {
 52         for (Particle particle : particles) {
 53             for (int i = 0; i < particle.dimension; i++) {
 54                 double v = w * particle.V[i] + c1 * rand() * (particle.pbest[i] - particle.X[i])
 55                         + c2 * rand() * (gbest[i] - particle.X[i]);
 56                 if (v > particle.Vmax)
 57                     v = particle.Vmax * rand();
 58                 else if (v < -particle.Vmax)
 59                     v = -particle.Vmax * rand();
 60                 particle.V[i] = v;// 更新Vi
 61             }
 62         }
 63     }
 64 
 65     /**
 66      * 更新每個粒子的位置和pbest
 67      */
 68     public static void updateX() {
 69         for (Particle particle : particles) {
 70             for (int i = 0; i < particle.dimension; i++) {
 71                 particle.X[i] = particle.X[i] + particle.V[i];
 72                 if (particle.X[i] > particle.Xmax[i])
 73                     particle.X[i] = new Random().nextDouble() * (particle.Xmax[i] - particle.Xmin[i])
 74                             + particle.Xmin[i];
 75                 if (particle.X[i] < particle.Xmin[i])
 76                     particle.X[i] = new Random().nextDouble() * (particle.Xmax[i] - particle.Xmin[i])
 77                             + particle.Xmin[i];
 78             }
 79             double newFitness = particle.calculateFitness();// 新的適應(yīng)值
 80             if (newFitness > particle.fitness) {
 81                 particle.pbest = particle.X.clone();
 82                 particle.fitness = newFitness;
 83             }
 84         }
 85     }
 86 
 87     /**
 88      * 算法主要流程
 89      */
 90     public static void process() {
 91         int n = 0;
 92         initialParticles();
 93         updateGbest();
 94         while (n++ < N) {
 95             /*
 96              * Multi-start PSO 算法，即每迭代若干次后，都保留歷史優(yōu)粒子， 粒子全部初始化，以提高粒子的多樣性，擴大搜索 空間。
 97              */
 98             if (n == N / 2) {
 99                 initialParticles();
100                 updateGbest();
101             }
102             updateV();
103             updateX();
104             updateGbest();
105             w -= 0.01; // 動態(tài)慣性權(quán)重
106             System.out.println(n + ". 當(dāng)前gbest:(" + gbest[0] + "," + gbest[1] + ")  fitness = " + gbest_fitness);
107         }
108     }
109 
110     public static double rand() {
111         return new Random().nextDouble();
112     }
113 
114     public static void main(String[] args) {
115         process();
116     }
117 }

改進后的PSO

改進后，雖然有一定的效果，但是效果不太明顯。

后來又提出許多混合粒子群算法，比如遺傳粒子群（BPSO）、免疫粒子群（IPSO）、混沌粒子群等（CPSO），針對不同的領(lǐng)域，需選用適合的優(yōu)化算法。

?

?

?

轉(zhuǎn)載于:https://www.cnblogs.com/flyuz/p/9210777.html

總結(jié)

以上是生活随笔為你收集整理的普通粒子群算法和优化方法的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。