惯性权重改进粒子群算法仿真程序

惯性权重改进粒子群算法是一种优化算法，它通过模拟粒子在搜索空间内的运动来寻找最优解。其中，惯性权重是控制粒子群运动的重要参数，它决定了粒子在搜索空间内的探索能力和收敛速度。

为了改进惯性权重的效果，我们可以使用以下的算法步骤：

1. 初始化粒子群的位置和速度。

2. 根据适应度函数计算每个粒子的适应度值。

3. 记录全局最优解和每个粒子的最优解。

4. 更新粒子的速度和位置，其中包括两部分：惯性权重和加速度。

5. 重复步骤2-4，直到满足停止条件。

6. 输出最优解。

在惯性权重改进的粒子群算法中，惯性权重的值是动态调整的，其值随着迭代次数的增加而变化。一般来说，初始时惯性权重较大，可以帮助粒子快速探索搜索空间；而随着迭代次数的增加，惯性权重逐渐减小，可以帮助粒子更精确地搜索局部最优解。

以下是一个简单的惯性权重改进粒子群算法的仿真程序，供参考：

import random

# 定义适应度函数，这里以 Rosenbrock 函数为例
def fitness_func(x, y):
    return (1 - x) ** 2 + 100 * (y - x ** 2) ** 2

class Particle:
    def __init__(self):
        self.position = [random.uniform(-5, 5), random.uniform(-5, 5)]
        self.velocity = [random.uniform(-1, 1), random.uniform(-1, 1)]
        self.best_position = self.position
        self.best_fitness = fitness_func(self.position[0], self.position[1])
        
    def update_velocity(self, global_best_position, w, c1, c2):
        r1 = random.random()
        r2 = random.random()
        new_velocity = []
        for i in range(2):
            v = w * self.velocity[i] + c1 * r1 * (self.best_position[i] - self.position[i]) + c2 * r2 * (global_best_position[i] - self.position[i])
            new_velocity.append(v)
        self.velocity = new_velocity
        
    def update_position(self):
        new_position = []
        for i in range(2):
            x = self.position[i] + self.velocity[i]
            x = max(min(x, 5), -5)  # 限制搜索范围在 [-5, 5] 内
            new_position.append(x)
        self.position = new_position
        fitness = fitness_func(self.position[0], self.position[1])
        if fitness < self.best_fitness:
            self.best_fitness = fitness
            self.best_position = self.position
            
class PSO:
    def __init__(self, n_particles, w_init, w_final, c1, c2, max_iter):
        self.n_particles = n_particles
        self.w_init = w_init
        self.w_final = w_final
        self.c1 = c1
        self.c2 = c2
        self.max_iter = max_iter
        self.particles = [Particle() for i in range(n_particles)]
        self.global_best_position = None
        self.global_best_fitness = float('inf')
        
    def update_global_best(self):
        for particle in self.particles:
            if particle.best_fitness < self.global_best_fitness:
                self.global_best_fitness = particle.best_fitness
                self.global_best_position = particle.best_position
                
    def update_w(self, iter):
        return self.w_init - (self.w_init - self.w_final) * iter / self.max_iter
    
    def run(self):
        for iter in range(self.max_iter):
            w = self.update_w(iter)
            for particle in self.particles:
                particle.update_velocity(self.global_best_position, w, self.c1, self.c2)
                particle.update_position()
            self.update_global_best()
            print('Iteration:', iter, 'Global best fitness:', self.global_best_fitness)
        print('Optimal solution:', self.global_best_position)
        
pso = PSO(n_particles=20, w_init=0.9, w_final=0.4, c1=2, c2=2, max_iter=100)
pso.run()

这个程序通过模拟20个粒子在二维搜索空间内的运动来寻找 Rosenbrock 函数的最优解。在程序中，我们使用了动态惯性权重的方法来改进粒子群算法，其中 w_init 和 w_final 分别表示初始惯性权重和最终惯性权重，max_iter 表示最大迭代次数。程序输出了每次迭代后的全局最优解和最优解的适应度值，以及最终的最优解。