传统粒子群与改进粒子群对比代码

以下是传统粒子群算法和改进粒子群算法的Python实现代码对比：

# 传统粒子群算法
import random

class Particle:
    def __init__(self, dim, x_max, x_min, v_max, v_min):
        self.position = [random.uniform(x_min, x_max) for _ in range(dim)]
        self.velocity = [random.uniform(v_min, v_max) for _ in range(dim)]
        self.best_position = self.position.copy()
        self.best_fitness = float('inf')

    def update_position(self):
        for i in range(len(self.position)):
            self.position[i] += self.velocity[i]

    def update_velocity(self, w, c1, c2, global_best_position):
        for i in range(len(self.velocity)):
            r1 = random.uniform(0, 1)
            r2 = random.uniform(0, 1)
            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] = w * self.velocity[i] + cognitive_component + social_component

    def evaluate_fitness(self, fitness_func):
        fitness = fitness_func(self.position)
        if fitness < self.best_fitness:
            self.best_fitness = fitness
            self.best_position = self.position.copy()

class PSO:
    def __init__(self, dim, population_size, x_max, x_min, v_max, v_min, w, c1, c2, max_iter, fitness_func):
        self.dim = dim
        self.population_size = population_size
        self.x_max = x_max
        self.x_min = x_min
        self.v_max = v_max
        self.v_min = v_min
        self.w = w
        self.c1 = c1
        self.c2 = c2
        self.max_iter = max_iter
        self.fitness_func = fitness_func
        self.population = [Particle(dim, x_max, x_min, v_max, v_min) for _ in range(population_size)]
        self.global_best_position = self.population[0].position.copy()
        self.global_best_fitness = float('inf')

    def update_global_best(self):
        for particle in self.population:
            if particle.best_fitness < self.global_best_fitness:
                self.global_best_fitness = particle.best_fitness
                self.global_best_position = particle.best_position.copy()

    def optimize(self):
        for i in range(self.max_iter):
            for particle in self.population:
                particle.update_velocity(self.w, self.c1, self.c2, self.global_best_position)
                particle.update_position()
                particle.evaluate_fitness(self.fitness_func)
                self.update_global_best()
            print('Iteration {}: Best Fitness: {}'.format(i, self.global_best_fitness))


# 改进粒子群算法（基于自适应权重和多策略融合的粒子群算法）
import random
import numpy as np

class Particle:
    def __init__(self, dim, x_max, x_min, v_max, v_min):
        self.position = [random.uniform(x_min, x_max) for _ in range(dim)]
        self.velocity = [random.uniform(v_min, v_max) for _ in range(dim)]
        self.best_position = self.position.copy()
        self.best_fitness = float('inf')
        self.local_best_position = self.position.copy()
        self.local_best_fitness = float('inf')
        self.weights = np.array([random.uniform(0, 1) for _ in range(dim)])
        self.strategy = random.choice(['explore', 'exploit'])

    def update_position(self):
        for i in range(len(self.position)):
            self.position[i] += self.velocity[i]

    def update_velocity(self, w, c1, c2, global_best_position):
        global_weights = np.array([1 / len(global_best_position) for _ in range(len(global_best_position))])
        local_weights = np.array([1 / len(self.local_best_position) for _ in range(len(self.local_best_position))])
        if self.strategy == 'explore':
            self.weights = global_weights
        else:
            self.weights = local_weights
        for i in range(len(self.velocity)):
            r1 = random.uniform(0, 1)
            r2 = random.uniform(0, 1)
            cognitive_component = c1 * r1 * (self.best_position[i] - self.position[i])
            social_component = c2 * r2 * (global_best_position[i] - self.position[i])
            adaptive_weight = self.weights[i] * (1 - w) + w
            self.velocity[i] = adaptive_weight * (cognitive_component + social_component)

    def evaluate_fitness(self, fitness_func):
        fitness = fitness_func(self.position)
        if fitness < self.best_fitness:
            self.best_fitness = fitness
            self.best_position = self.position.copy()
        if fitness < self.local_best_fitness:
            self.local_best_fitness = fitness
            self.local_best_position = self.position.copy()

class APSO:
    def __init__(self, dim, population_size, x_max, x_min, v_max, v_min, w_max, w_min, c1, c2, max_iter, fitness_func):
        self.dim = dim
        self.population_size = population_size
        self.x_max = x_max
        self.x_min = x_min
        self.v_max = v_max
        self.v_min = v_min
        self.w_max = w_max
        self.w_min = w_min
        self.c1 = c1
        self.c2 = c2
        self.max_iter = max_iter
        self.fitness_func = fitness_func
        self.population = [Particle(dim, x_max, x_min, v_max, v_min) for _ in range(population_size)]
        self.global_best_position = self.population[0].position.copy()
        self.global_best_fitness = float('inf')

    def update_global_best(self):
        for particle in self.population:
            if particle.best_fitness < self.global_best_fitness:
                self.global_best_fitness = particle.best_fitness
                self.global_best_position = particle.best_position.copy()

    def select_strategy(self):
        explore_prob = 1 - (self.global_best_fitness - self.local_best_fitness) / self.global_best_fitness
        if random.random() < explore_prob:
            return 'explore'
        else:
            return 'exploit'

    def update_local_best(self):
        for particle in self.population:
            if particle.local_best_fitness < self.global_best_fitness:
                self.local_best_fitness = particle.local_best_fitness
                self.local_best_position = particle.local_best_position.copy()

    def optimize(self):
        for i in range(self.max_iter):
            self.local_best_fitness = float('inf')
            self.local_best_position = self.global_best_position.copy()
            for particle in self.population:
                particle.strategy = self.select_strategy()
                particle.update_velocity(self.w_max - (self.w_max - self.w_min) * i / self.max_iter, self.c1, self.c2, self.global_best_position)
                particle.update_position()
                particle.evaluate_fitness(self.fitness_func)
                self.update_global_best()
            self.update_local_best()
            print('Iteration {}: Best Fitness: {}'.format(i, self.global_best_fitness))

可以看出，改进粒子群算法增加了自适应权重和多策略融合的机制，使得粒子群算法更加灵活和高效。