粒子群算法的python代码实例

粒子群算法（Particle Swarm Optimization, PSO）是一种启发式优化算法，用于解决优化问题。下面是一个简单的粒子群算法的Python代码实例：

import numpy as np

# 定义目标函数（这里以求解最小值为例）
def objective_function(x):
    return x**2

# 粒子群算法类
class ParticleSwarmOptimization:
    def __init__(self, num_particles, num_dimensions, max_iterations, lower_bound, upper_bound):
        self.num_particles = num_particles  # 粒子数量
        self.num_dimensions = num_dimensions  # 维度数量
        self.max_iterations = max_iterations  # 最大迭代次数
        self.lower_bound = lower_bound  # 变量下界
        self.upper_bound = upper_bound  # 变量上界
        self.particles = np.random.uniform(low=self.lower_bound, high=self.upper_bound,
                                           size=(self.num_particles, self.num_dimensions))  # 初始化粒子位置
        self.velocities = np.zeros_like(self.particles)  # 初始化粒子速度
        self.best_positions = self.particles.copy()  # 最佳位置
        self.best_values = np.zeros(self.num_particles) + np.inf  # 最佳值
        self.global_best_position = None  # 全局最佳位置
        self.global_best_value = np.inf  # 全局最佳值

    # 更新粒子位置和速度
    def update(self):
        for i in range(self.num_particles):
            for j in range(self.num_dimensions):
                r1 = np.random.random()
                r2 = np.random.random()
                # 更新粒子速度
                self.velocities[i][j] = self.velocities[i][j] + 2 * r1 * (self.best_positions[i][j] - self.particles[i][j]) \
                                        + 2 * r2 * (self.global_best_position[j] - self.particles[i][j])
                # 限制粒子速度范围
                self.velocities[i][j] = np.maximum(self.velocities[i][j], self.lower_bound)
                self.velocities[i][j] = np.minimum(self.velocities[i][j], self.upper_bound)
                # 更新粒子位置
                self.particles[i][j] = self.particles[i][j] + self.velocities[i][j]
                # 限制粒子位置范围
                self.particles[i][j] = np.maximum(self.particles[i][j], self.lower_bound)
                self.particles[i][j] = np.minimum(self.particles[i][j], self.upper_bound)

    # 计算适应值
    def evaluate(self):
        for i in range(self.num_particles):
            fitness = objective_function(self.particles[i])
            if fitness < self.best_values[i]:
                self.best_values[i] = fitness
                self.best_positions[i] = self.particles[i]
            if fitness < self.global_best_value:
                self.global_best_value = fitness
                self.global_best_position = self.particles[i]

    # 执行粒子群算法
    def optimize(self):
        for _ in range(self.max_iterations):
            self.update()
            self.evaluate()

# 设置参数并运行粒子群算法
num_particles = 50  # 粒子数量
num_dimensions = 1  # 维度数量
max_iterations = 100  # 最大迭代次数
lower_bound = -10  # 变量下界
upper_bound = 10  # 变量上界

pso = ParticleSwarmOptimization(num_particles, num_dimensions, max_iterations, lower_bound, upper_bound)
pso.optimize()

# 输出结果
print("最优解:", pso.global_best_position)
print("最优值:", pso.global_best_value)

这个代码实例演示了如何使用粒子群算法求解一个简单的一维优化问题。你可以根据自己的需求，修改目标函数和参数设置来解决不同的优化问题。