粒子群算法python

粒子群算法（Particle Swarm Optimization，PSO）是一种群体智能优化算法，模拟了鸟群捕食的行为。在优化问题中，PSO通过模拟粒子在搜索空间中的移动和信息交流来寻找最优解。

以下是一个简单的粒子群算法的Python实现：

import random

class Particle:
    def __init__(self, x0):
        self.position = []   # 粒子的位置
        self.velocity = []   # 粒子的速度
        self.best_position = []  # 粒子的历史最佳位置
        self.err_best = -1   # 粒子历史最佳误差
        self.err = -1        # 粒子当前误差

        for i in range(0, num_dimensions):
            self.velocity.append(random.uniform(-1, 1))
            self.position.append(x0[i])

    def evaluate(self, costFunc):
        self.err = costFunc(self.position)

        if self.err < self.err_best or self.err_best == -1:
            self.best_position = self.position
            self.err_best = self.err

    def update_velocity(self, best_position_g):
        w = 0.5       # 惯性权重
        c1 = 1        # 个体学习因子
        c2 = 2        # 社会学习因子

        for i in range(0, num_dimensions):
            r1 = random.random()
            r2 = random.random()

            vel_cognitive = c1 * r1 * (self.best_position[i] - self.position[i])
            vel_social = c2 * r2 * (best_position_g[i] - self.position[i])
            self.velocity[i] = w * self.velocity[i] + vel_cognitive + vel_social

    def update_position(self, bounds):
        for i in range(0, num_dimensions):
            self.position[i] = self.position[i] + self.velocity[i]

            if self.position[i] > bounds[i][1]:
                self.position[i] = bounds[i][1]

            if self.position[i] < bounds[i][0]:
                self.position[i] = bounds[i][0]

class PSO:
    def __init__(self, costFunc, x0, bounds, num_particles, maxiter):
        global num_dimensions

        num_dimensions = len(x0)
        err_best_g = -1                    # 全局最佳误差
        best_position_g = []               # 全局最佳位置

        # 初始化粒子群
        swarm = []
        for i in range(0, num_particles):
            swarm.append(Particle(x0))

        # 开始迭代
        i = 0
        while i < maxiter:
            for j in range(0, num_particles):
                swarm[j].evaluate(costFunc)

                if swarm[j].err < err_best_g or err_best_g == -1:
                    best_position_g = list(swarm[j].position)
                    err_best_g = float(swarm[j].err)

            for j in range(0, num_particles):
                swarm[j].update_velocity(best_position_g)
                swarm[j].update_position(bounds)
            i += 1

        print('优化完成：')
        print('全局最佳位置：', best_position_g)
        print('全局最佳误差：', err_best_g)

if __name__ == "__PSO__":
    def costFunc(x):
        return sum([i ** 2 for i in x])

    bounds = [(-10, 10)] * 2
    PSO(costFunc, x0=[0] * 2, bounds=bounds, num_particles=15, maxiter=30)

这个实现是一个简单的PSO算法，可以处理连续型优化问题。你可以修改costFunc函数来适应不同的问题。