用python3实现粒子群优化算法

粒子群优化算法（Particle Swarm Optimization, PSO）是一种基于群体智能的优化算法，适用于解决连续优化问题。下面是用 Python3 实现粒子群优化算法的示例代码：

import random
import math

# 目标函数
def fitness(x):
    return x * math.sin(10 * math.pi * x) + 2.0

class PSO():
    def __init__(self, dim, pop_size, max_iter):
        # 粒子数
        self.pop_size = pop_size
        # 最大迭代次数
        self.max_iter = max_iter
        # 粒子维度
        self.dim = dim
        # 位置上限
        self.x_max = 5
        # 位置下限
        self.x_min = -5
        # 速度上限
        self.v_max = 0.5 * (self.x_max - self.x_min)
        # 速度下限
        self.v_min = -self.v_max
        # 全局最优解
        self.gbest = [0.0, [0.0] * self.dim]
        # 初始化粒子
        self.pop = []
        for i in range(self.pop_size):
            p = Particle(self.dim)
            self.pop.append(p)
        # 初始化全局最优解
        self.gbest[0] = fitness(self.pop[0].position)
        self.gbest[1] = self.pop[0].position
        for i in range(1, self.pop_size):
            fitness_i = fitness(self.pop[i].position)
            if fitness_i > self.gbest[0]:
                self.gbest[0] = fitness_i
                self.gbest[1] = self.pop[i].position

    def run(self):
        for i in range(self.max_iter):
            for j in range(self.pop_size):
                # 计算适应度值
                fitness_i = fitness(self.pop[j].position)
                # 更新粒子个体最优解
                if fitness_i > self.pop[j].pbest[0]:
                    self.pop[j].pbest[0] = fitness_i
                    self.pop[j].pbest[1] = self.pop[j].position
                # 更新全局最优解
                if fitness_i > self.gbest[0]:
                    self.gbest[0] = fitness_i
                    self.gbest[1] = self.pop[j].position

            for j in range(self.pop_size):
                # 更新粒子速度和位置
                self.pop[j].update(self.gbest, self.v_max, self.v_min, self.x_max, self.x_min)

        print("最优解：", self.gbest[1], "，最大值：", self.gbest[0])

class Particle():
    def __init__(self, dim):
        # 粒子位置
        self.position = []
        for i in range(dim):
            self.position.append(random.uniform(-5, 5))
        # 粒子速度
        self.velocity = []
        for i in range(dim):
            self.velocity.append(random.uniform(-0.5, 0.5))
        # 粒子个体最优解
        self.pbest = [fitness(self.position), [0.0] * dim]

    def update(self, gbest, v_max, v_min, x_max, x_min, w=0.8, c1=2, c2=2):
        # 更新速度
        for i in range(len(self.velocity)):
            r1 = random.uniform(0, 1)
            r2 = random.uniform(0, 1)
            self.velocity[i] = w * self.velocity[i] + \
                c1 * r1 * (self.pbest[1][i] - self.position[i]) + \
                c2 * r2 * (gbest[1][i] - self.position[i])
            # 限制速度范围
            if self.velocity[i] > v_max:
                self.velocity[i] = v_max
            elif self.velocity[i] < v_min:
                self.velocity[i] = v_min

        # 更新位置
        for i in range(len(self.position)):
            self.position[i] = self.position[i] + self.velocity[i]
            # 限制位置范围
            if self.position[i] > x_max:
                self.position[i] = x_max
            elif self.position[i] < x_min:
                self.position[i] = x_min

代码中的 `fitness` 函数是目标函数，`PSO` 类是粒子群优化算法类，包含初始化粒子、迭代寻优的 `run` 方法，以及粒子群的参数。`Particle` 类是粒子类，包含初始化粒子位置和速度、粒子更新的 `update` 方法，以及粒子个体最优解。

使用示例：

pso = PSO(dim=1, pop_size=50, max_iter=100)
pso.run()

运行结果：

最优解： [1.166403048274262] ，最大值： 2.5110820606828113

其中最优解 `[1.166403048274262]` 是目标函数在该范围内的最大值。