python粒子群算法实例

当然，我可以为您提供一个基于Python的粒子群算法的示例。下面是一个简单的实现：

import random

# 定义粒子类
class Particle:
    def __init__(self, dim):
        self.position = [random.uniform(-5, 5) for _ in range(dim)]
        self.velocity = [random.uniform(-1, 1) for _ in range(dim)]
        self.best_position = self.position.copy()
        self.best_fitness = float('inf')

    def update_velocity(self, global_best_position, c1, c2):
        for i in range(len(self.velocity)):
            r1 = random.random()
            r2 = random.random()
            cognitive_component = c1 * r1 * (self.best_position[i] - self.position[i])
            social_component = c2 * r2 * (global_best_position[i] - self.position[i])
            self.velocity[i] += cognitive_component + social_component

    def update_position(self):
        for i in range(len(self.position)):
            self.position[i] += self.velocity[i]
            if self.position[i] < -5:
                self.position[i] = -5
            elif self.position[i] > 5:
                self.position[i] = 5

    def evaluate_fitness(self):
        # 这里的适应度函数可以根据具体问题进行定义
        fitness = sum([x**2 for x in self.position])
        if fitness < self.best_fitness:
            self.best_fitness = fitness
            self.best_position = self.position.copy()

# 定义粒子群类
class ParticleSwarmOptimization:
    def __init__(self, num_particles, dim, max_iter):
        self.num_particles = num_particles
        self.dim = dim
        self.max_iter = max_iter
        self.particles = [Particle(dim) for _ in range(num_particles)]
        self.global_best_position = self.particles[0].position.copy()
        self.global_best_fitness = float('inf')

    def optimize(self):
        for _ in range(self.max_iter):
            for particle in self.particles:
                particle.evaluate_fitness()
                if particle.best_fitness < self.global_best_fitness:
                    self.global_best_fitness = particle.best_fitness
                    self.global_best_position = particle.best_position.copy()

            for particle in self.particles:
                particle.update_velocity(self.global_best_position, 2, 2)
                particle.update_position()

# 调用粒子群算法进行优化
pso = ParticleSwarmOptimization(num_particles=50, dim=10, max_iter=100)
pso.optimize()
print("Optimal solution:", pso.global_best_position)
print("Optimal fitness:", pso.global_best_fitness)

此代码实现了一个简单的粒子群算法，用于求解一个10维优化问题。您可以根据具体问题进行适应度函数的定义，以及调整算法的参数。希望对您有所帮助！