摘要：遺傳算法回顧核心算子其中代表第個粒子的速度，代表慣性權值和表示學習參數，表示在之間的隨機數代表第個粒子搜索到的歷史最優值代表整個集群搜索到的最優值代表第個粒子的當前位置。

粒子群PSO算法相比遺傳算法實現會簡單一點，核心就是根據算子更新個體歷史最優和全局最優。粒子群用的不多，給我的感覺是收斂很快的一種算法。這種算法較為容易陷入局部最優，若問題具有欺騙性（具有多個假峰，且優化資源集中在其中一個峰上）就不容易找到全局最優。學院有個學長改進PSO發了篇論文，好像是將（全局最優-個體最優）加入到算子當中，這會一定程度上跳出局部最優。

遺傳算法回顧

核心算子：

 v[i] = w * v[i] + c1 * rand() * (pbest[i] - present[i]) + c2 * rand() * (gbest - present[i])
 present[i] = present[i] + v[i]

其中v[i]代表第i個粒子的速度，w代表慣性權值,c1和c2表示學習參數，rand()表示在0-1之間的隨機數,pbest[i]代表第i個粒子搜索到的歷史最優值,gbest代表整個集群搜索到的最優值,present[i]代表第i個粒子的當前位置。

模擬一群鳥尋找食物的過程，每個鳥就是PSO中的粒子，也就是我們需要求解問題的可能解，這些鳥在尋找食物的過程中，會不停改變地自己在空中飛行的位置與速度。改變的方向會根據個體的歷史最優p_best和全局最優g_best來做出改變，也就是上面的核心算子。可以比喻為每只鳥會一定程度上追隨每次迭代中找食物最厲害的那只鳥，這里的找食物最厲害就是能最大可能解出目標函數。

還是解決遺傳算法當中的簡單單目標問題，求解函數f的最大值

max f (x1, x2) = 21.5 + x1·sin(4 pi x1) + x2·sin(20 pi x2)
s. t. -3.0 <= x1 <= 12.1
        4.1 <= x2 <= 5.8

種群初始化：

import random
import numpy as np

pop_size = 100
dec_num = 2    #變量個數
dec_min_val = (-3, 4.1)    #變量約束范圍
dec_max_val = (12.1, 5.8) 
pop_x = np.zeros((pop_size, dec_num))  # 所有粒子的位置
pop_v = np.zeros((pop_size, dec_num))  # 所有粒子的速度
p_best = np.zeros((pop_size, dec_num))  # 個體經歷的最佳位置

def init_population(pop_size, dec_num, dec_min_val, dec_max_val, pop_x, pop_v, p_best):
    for i in range(pop_size):
        for j in range(dec_num):
            pop_x[i][j] = random.uniform(dec_min_val[j], dec_max_val[j])
            pop_v[i][j] = random.uniform(0, 1)
        p_best[i] = pop_x[i]  # p_best存儲個體的歷史最優

迭代更新：

import random
import matplotlib.pyplot as plt
from Initialization import init_population

max_gen = 100
w = 0.4  # 自身權重因子
c1 = 2  # 學習因子
c2 = 2
g_best = np.zeros((1, dec_num))  # 全局最佳個體的位置
popobj = []

def fitness(s):    #個體適應值計算
    x1 = s[0]
    x2 = s[1]
    y = 21.5 + x1 * math.sin(4 * math.pi * x1) + x2 * math.sin(20 * math.pi * x2)
    return y


if __name__ == "__main__":
    init_population(pop_size, dec_num, dec_min_val, dec_max_val, pop_x, pop_v, p_best)
    temp = -1    
    #    ------------更新全局最優-------------
    for i in range(pop_size):   
        fit = fitness(p_best[i])
        if fit > temp:
            g_best = p_best[i]
            temp = fit
    #    ------------迭代優化-------------
    for i in range(max_gen):
        for j in range(pop_size):
            #   ----------------更新個體位置和速度-----------------
            pop_v[j] = w * pop_v[j] + c1 * random.uniform(0, 1) * (p_best[j] - pop_x[j]) + 
                        c2 * random.uniform(0, 1) * (g_best - pop_x[j])
            pop_x[j] = pop_x[j] + pop_v[j]
            for k in range(dec_num):    # 越界保護
                if pop_x[j][k] < dec_min_val[k]:
                    pop_x[j][k] = dec_min_val[k]
                if pop_x[j][k] > dec_max_val[k]:
                    pop_x[j][k] = dec_max_val[k]
            #   -----------------更新p_best和g_best-----------------
            if fitness(pop_x[j]) > fitness(p_best[j]):
                p_best[j] = pop_x[j]
            if fitness(pop_x[j]) > fitness(g_best):
                g_best = pop_x[j]
        popobj.append(fitness(g_best))
        print(fitness(g_best))

    # -------------------畫圖--------------------
    plt.figure(1)
    plt.title("Figure1")
    plt.xlabel("iterators", size=14)
    plt.ylabel("fitness", size=14)
    t = [t for t in range(0, 100)]
    plt.plot(t, popobj, color="b", linewidth=3)
    plt.show()

結果和遺傳算法差不多，但速度是快了，不需要像遺傳算法那樣交叉變異，另一方面粒子群的參數設置有點多。

Github源碼地址：https://github.com/kugua233/P...