生成 遗传算法优化粒子群算法代码

以下是一个简单的遗传算法优化粒子群算法的代码示例（仅供参考）：

import random

# 粒子群算法类
class PSO:
    def __init__(self, particle_count, dimensions, fitness_func, max_iterations=100, c1=2.0, c2=2.0, w=1.0):
        self.particle_count = particle_count
        self.dimensions = dimensions
        self.fitness_func = fitness_func
        self.max_iterations = max_iterations
        self.c1 = c1
        self.c2 = c2
        self.w = w
        self.global_best_position = [0.0] * dimensions
        self.global_best_fitness = float("inf")
        self.particles = []

        # 初始化粒子群
        for i in range(particle_count):
            particle = Particle(dimensions)
            self.particles.append(particle)

    # 运行粒子群算法
    def run(self):
        for i in range(self.max_iterations):
            for particle in self.particles:
                fitness = self.fitness_func(particle.position)
                if fitness < particle.best_fitness:
                    particle.best_fitness = fitness
                    particle.best_position = particle.position
                if fitness < self.global_best_fitness:
                    self.global_best_fitness = fitness
                    self.global_best_position = particle.position

            for particle in self.particles:
                particle.update_velocity(self.global_best_position, self.c1, self.c2, self.w)
                particle.update_position()

# 粒子类
class Particle:
    def __init__(self, dimensions):
        self.position = [random.uniform(-5.0, 5.0) for i in range(dimensions)]
        self.velocity = [0.0] * dimensions
        self.best_position = self.position
        self.best_fitness = float("inf")

    # 更新速度
    def update_velocity(self, global_best_position, c1, c2, w):
        for i in range(len(self.position)):
            r1 = random.random()
            r2 = random.random()
            cognitive_velocity = c1 * r1 * (self.best_position[i] - self.position[i])
            social_velocity = c2 * r2 * (global_best_position[i] - self.position[i])
            self.velocity[i] = w * self.velocity[i] + cognitive_velocity + social_velocity

    # 更新位置
    def update_position(self):
        for i in range(len(self.position)):
            self.position[i] += self.velocity[i]

# 适应度函数
def fitness_func(position):
    # TODO: 计算适应度值
    return fitness_value

# 遗传算法类
class GA:
    def __init__(self, population_size, dimensions, fitness_func, max_generations=100, crossover_rate=0.8, mutation_rate=0.1):
        self.population_size = population_size
        self.dimensions = dimensions
        self.fitness_func = fitness_func
        self.max_generations = max_generations
        self.crossover_rate = crossover_rate
        self.mutation_rate = mutation_rate
        self.population = []
        self.best_individual = None
        self.best_fitness = float("inf")

        # 初始化种群
        for i in range(population_size):
            individual = Individual(dimensions)
            self.population.append(individual)

    # 运行遗传算法
    def run(self):
        for generation in range(self.max_generations):
            # 计算适应度值
            for individual in self.population:
                fitness = self.fitness_func(individual.genes)
                individual.fitness = fitness
                if fitness < self.best_fitness:
                    self.best_fitness = fitness
                    self.best_individual = individual

            # 选择
            new_population = []
            total_fitness = sum([individual.fitness for individual in self.population])
            for i in range(self.population_size):
                roulette_wheel_position = random.uniform(0, total_fitness)
                spin_wheel = 0
                for individual in self.population:
                    spin_wheel += individual.fitness
                    if spin_wheel >= roulette_wheel_position:
                        new_population.append(individual)
                        break

            # 交叉
            for i in range(0, self.population_size - 1, 2):
                if random.random() < self.crossover_rate:
                    crossover_point = random.randint(1, self.dimensions - 2)
                    new_population[i].genes[crossover_point:], new_population[i+1].genes[crossover_point:] = \
                    new_population[i+1].genes[crossover_point:], new_population[i].genes[crossover_point:]

            # 变异
            for individual in new_population:
                for i in range(self.dimensions):
                    if random.random() < self.mutation_rate:
                        individual.genes[i] = random.uniform(-5.0, 5.0)

            self.population = new_population

# 个体类
class Individual:
    def __init__(self, dimensions):
        self.genes = [random.uniform(-5.0, 5.0) for i in range(dimensions)]
        self.fitness = 0

# 运行示例
def main():
    pso = PSO(particle_count=50, dimensions=10, fitness_func=fitness_func)
    pso.run()

    ga = GA(population_size=50, dimensions=10, fitness_func=fitness_func)
    ga.run()

if __name__ == "__main__":
    main()

在上述代码中，PSO 和 GA 分别实现了粒子群算法和遗传算法，并且均包含了相应的粒子/个体类。在主函数中，我们可以分别实例化 PSO 和 GA，并通过调用其 run() 方法来运行算法。请注意，上述代码仅为示例，实际应用中需要根据具体问题进行适当修改。