算法思想

粒子群优化算法灵感来源于鸟群觅食行为，鸟群在寻找食物时会通过互相信息交流来帮助种群更快的寻找到食物。
粒子群优化算法就是秉持这种思想
①：初始化粒子群
②：随即设置每个粒子的位置与速度（可以理解为粒子将要移动的距离）
③：计算每个粒子的适应度值并选出适应度最好的粒子
④：对每个粒子的位置以及速度进行更新
⑤：继续③步骤知道达到终止条件

算法流程图

算法参数设置

pop：population  粒子群规模 #求解函数
dim：dimension  粒子维度大小
low、up：个体上下限
N：惯性权重
Cs：自身认知常数
Cp：社会认知常数
G：generation  最大迭代次数

算法代码详解

导入库

import numpy as np
import matplotlib.pyplot as plt

#中文显示乱码问题解决办法
plt.rcParams['font.sans-serif']=['SimHei']

#‘-’号显示不正常解决办法
plt.rcParams['axes.unicode_minus']=False

定义目标函数

def f(x):
    return np.sum((x-1) ** 2 - np.sin(x**2))   #求解函数

定义算法所用参数

pop_size = 100    # 粒子群的规模
dim = 20    # 问题的维度
low = -10    #定义下限
up = 10   #定义上限
iner = 0.5    # 惯性权重
Cs = 1.5  # 认知常数（粒子本身的经验权重）
Cp = 2.0  # 社会常数（群体经验权重）
G = 100  # 最大迭代次数

速度与位置更新

def refresh_velocity_position(velocity, position, i):   #velocity：粒子群现如今速度  ，position：未更改位置  ，i遍历元素位置
    # 更新速度
    r1 = np.random.rand(dim)    #随机生成0-1的均匀分布的数
    r2 = np.random.rand(dim)    #随机生成0-1的均匀分布的数
    cognitive_velocity = Cs * r1 * (personal_position[i] - position[i])  #计算自身认知部分
    social_velocity = Cp * r2 * (best_position - position[i])    #计算社会认知部分
    velocity[i] = iner * velocity[i] + cognitive_velocity + social_velocity   #对每个粒子的速度进行更新

    # 更新位置
    position[i] = position[i] + velocity[i]   #新位置就等于旧位置加上更新的速度
    
    return velocity, position    #将更新过后的速度以及例子位置返回

边界处理

#进行边界处理
def band_save(position ,low, up):     #position：当前粒子位置（一个个体所在位置）    ，i：遍历元素位置
    position[position > up] = up
    position[position < low] = low
    return position

绘图函数

def drawing(x_values, y_values):
    # 绘制适应度值随迭代次数变化的曲线
    plt.plot(x_values, y_values)
    plt.title('PSO优化算法',size = 18)
    plt.xlabel('迭代数',size = 14)
    plt.ylabel('适应度',size = 14)
    plt.grid(True)
    plt.show()

算法主程序

# 初始化粒子群
position = np.random.uniform(low, up, (pop_size, dim))    #粒子群规模为（100,20）

# 初始化粒子速度
velocity = np.random.uniform(-1, 1, (pop_size, dim))  #初始化各个粒子的速度

#  复制粒子位置
personal_position = np.copy(position)  #复制各个粒子的位置信息

personal_value = np.array([f(ind) for ind in position])   #将求出来的适应值存储为二维数组
best_position = personal_position[np.argmin(personal_value)]  #寻找最小值
best_value = np.min(personal_value)  #找到当前最优适应度

# PSO算法
position_history = []  #创建一个空列表，用来存储最优解
value_history = [] #创建一个空列表，用来存储最佳适应度值

for iteration in range(G):
    for i in range(pop_size):
        
        # 更新速度  更新位置
        re_velocity, re_position = refresh_velocity_position(velocity, position, i)

        # 处理上下限约束
        re_position[i] = band_save(re_position[i], low, up)

        # 计算当前适应度
        current_ = f(re_position[i])     #计算更新位置过后的每个粒子的适应度值

        # 更新个人最佳位置和全局最佳位置
        if current_ < personal_value[i]:
            personal_position[i] = re_position[i]
            personal_value[i] = current_

        if current_ < best_value:
            best_position = re_position[i]
            best_value = current_

    position_history.append(best_position)    #将历史位置最好的粒子信息储存
    value_history.append(best_value)     #将历史适应度最好值进行存储

    # 输出每次迭代的全局最优值
    # print(f"迭代数 {iteration + 1}: 最佳适应度 = {best_value},最佳位置（粒子） = {best_position}\n")

drawing(list(i+1 for i in range(G)), value_history)   #将适应度与迭代次数关系进行绘制