粒子群優化算法（PSO）python實現（人工智能作業）

本文不對PSO多做解釋，代碼主打通俗，只是最普通的PSO。

因為作業沒有要求保存每一代的position and speed並且沒有要求做自適應的動態慣性因子，所以一切從簡。

 

作業要求：

　　粒子數：100

　　迭代次數：100　　　　// solving的參數

　　x₁ x₂ x₃ 范圍：[0, 15]

　　求解函數：y = 2x₁² - 3x₂² - 4x₁ + 5x₂ + x₃

　　以圖的形式體現全局最優的變化

 

import math
import random
import matplotlib.pyplot as plt

c1 = 2      # 學習因子                          # Learning coefficient
c2 = 2

def fitness(x1,x2,x3):                             #適應度函數                            # Fitness Function
    return math.floor((2*x1**2 - 3*x2**2 - 4*x1 + 5*x2 + x3)*100) / 100

class PSO:
    def __init__(self):
        self.pop_size = 100                         # 粒子群個體數                         # the number of the instance in Particle swarm
        self.dim = 3                                # 變量數                               # the number of variables
        self.omega = 0.4                            # 慣性因子                             # Inertia factor
        self.x_max = 15
        self.x_min = 0
        self.v_max = (self.x_max - self.x_min) * 0.05
        self.v_min = -(self.x_max - self.x_min) * 0.05
        self.position = [[]]                        # 記錄當前粒子位置                      # record the current position of each particle
        self.speed = [[]]                           # 記錄當前粒子速度                      # record the moving speed
        self.best_value = [[]]                      # 記錄全局最優                          # record the global optimal
        self.value = [[]]                           # 記錄當前值                            # record the current fitness and position
    def initial(self):
        for i in range(self.pop_size):
            "第一輪初始化"
            "first round of initialization"
            x = []
            v = []
            for j in range(self.dim):
                "所有math函數只為取兩位小數"
                "all the math.floor() are used for rounding the result up to two decimal places"
                x.append(math.floor(random.uniform(self.x_min,self.x_max) * 100) / 100)
                v.append(math.floor(random.uniform(self.v_min,self.v_max) * 100) / 100)
            self.position.append(x)
            self.speed.append(v)
            #self.value.append((fitness(x[0],x[1],x[2]))
            self.value.append(((fitness(x[0],x[1],x[2])),x[0],x[1],x[2]))
        self.value = self.value[1:]
        # -------------------選擇取最大值/最小值-------------------#
        "choose to get the max or the min value"
        #index = self.value.index(max(self.value))
        index = self.value.index(min(self.value))
        # -------------------選擇取最大值/最小值-------------------#
        self.best_value.append((self.value[index][0],self.position[index][0],self.position[index][1],self.position[index][2]))
        self.best_value = self.best_value[1:]
        self.position = self.position[1:]
        self.speed = self.speed[1:]
        print("the population and fitness after initialization:")
        print("position :",self.position)
        print("value:",self.value)
        print("best value:",self.best_value)
        print("------------------------split line------------------------")
    def solving(self,times):
        for i in range(times):
            #print(self.value)
            # -------------------選擇取最大值/最小值-------------------#
            "choose to get the max or the min value"
            #pbest = self.value[self.value.index(max(self.value))]
            #gbest = self.best_value[self.best_value.index(max(self.best_value))]
            pbest = self.value[self.value.index(min(self.value))]
            gbest = self.best_value[self.best_value.index(min(self.best_value))]
            # -------------------選擇取最大值/最小值-------------------#
            print("pbest:",pbest)
            print("gbest",gbest)
            for j in range(self.pop_size):
                x = []
                v = []
                for k in range(self.dim):
                    v.append(math.floor((self.omega * self.speed[j][k] + c1 * random.uniform(0,1) * (pbest[1+k] - self.position[j][k]) + c2 * random.uniform(0,1) * (gbest[1+k] - self.position[j][k])) * 100) / 100 )
                    x.append(math.floor((self.position[j][k] + self.speed[j][k]) * 100) / 100)
                    "將位置和速度限制在規定范圍內"
                    "restrict the position and the speed"
                    if (v[k] < self.v_min):
                        v[k] = self.v_min
                    if (v[k] > self.v_max):
                        v[k] = self.v_max
                    if(x[k] < self.x_min):
                        x[k] = self.x_min
                    if(x[k] > self.x_max):
                        x[k] = self.x_max
                "數據更新"
                "updating"
                self.position[j] = x
                self.speed[j] =  v
                self.value[j] = (fitness(self.position[j][0],self.position[j][1],self.position[j][2]),self.position[j][0],self.position[j][1],self.position[j][2])
            # -------------------選擇取最大值/最小值-------------------#
            "choose to get the max or the min value"
            #index = self.value.index(max(self.value))
            index = self.value.index(min(self.value))
            # -------------------選擇取最大值/最小值-------------------#
            "獲得全局最優"
            "get the global optimal"
            self.best_value.append((self.value[index][0], self.position[index][0], self.position[index][1],self.position[index][2]))
    def returnbest(self):
        return self.best_value



if __name__ == '__main__':
    demo = PSO()
    demo.initial()
    demo.solving(100)
    result = demo.returnbest()
    for i in result:
        print("value:",i[0],"x1:",i[1],"x2:",i[2],"x3:",i[3])
    X = []
    Y = []
    for i in range(100):
        X.append(i)
        Y.append(result[i][0])
    plt.plot(X, Y)
    plt.show()

 

因為作業要交給日本老師看，所以打了比較詳細的雙語注釋，這里就不對代碼多做解釋了。

如果要更詳細地理解PSO的流程推薦這篇：https://blog.csdn.net/daaikuaichuan/article/details/81382794

本文代碼流程與上面文章所講流程基本相同。

 

博主水平一般，歡迎批評指正。