粒子群优化算法（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

本文代码流程与上面文章所讲流程基本相同。

 

博主水平一般，欢迎批评指正。