高级人工智能之群体智能:粒子群算法

2023-12-25 06:14:51

1.粒子群算法

粒子群优化算法(Particle Swarm Optimization, PSO)是一种基于群体协作和信息共享的优化技术。它由Kennedy和Eberhart于1995年提出,灵感来源于鸟群和鱼群的社会行为。PSO是解决连续空间优化问题的有效方法,特别适合于多峰和高维问题。以下是PSO的基本思想和工作原理:

1.1基本思想

1.灵感来源:PSO受到鸟群觅食行为的启发。在寻找食物的过程中,每只鸟(即“粒子”)不仅依赖于自己的经验来判断方向,还会考虑其他鸟的经验。

2.群体智能:PSO基于群体智能的概念,即群体中的个体通过简单规则和相互合作,展现出复杂的全局行为。

3.信息共享:粒子之间通过共享信息,即每个粒子的历史最优位置和全局最优位置,以指导搜索过程。

1.2工作原理

1.初始化:在搜索空间随机初始化一群粒子。每个粒子有一个位置(代表候选解)和速度。

2.评估:根据目标函数评估每个粒子的位置。

3.个体最优和全局最优

  • 每个粒子都跟踪其遇到的最优位置(个体最优)。
  • 整个粒子群也跟踪所有粒子中遇到的最优位置(全局最优)。

4.速度和位置更新

  • 粒子的速度更新考虑到其当前速度、到个体最优位置的方向和到全局最优位置的方向。
  • 粒子的位置通过当前位置和更新后的速度来确定。

5.迭代:重复评估、更新个体最优、更新全局最优、更新速度和位置的过程,直至满足终止条件(如达到最大迭代次数或找到足够好的解)。

1.3特点

  • 简单高效:PSO算法结构简单,容易实现,计算效率高。
  • 无需梯度信息:与基于梯度的优化方法不同,PSO不需要目标函数的梯度信息,适用于不可导或难以求导的问题。
  • 灵活性:PSO参数(如粒子数、惯性权重、学习因子等)可以根据具体问题调整,增强算法的适应性和鲁棒性。

1.4应用

PSO在多种领域都有应用,如函数优化、神经网络训练、控制系统设计、图像处理等。

1.5限制

  • 局部最优陷阱:PSO可能会陷入局部最优,特别是在处理复杂的多峰优化问题时。
  • 参数调整:算法性能在很大程度上依赖于参数设置,而参数的选择往往缺乏理论指导,需要通过实验来调整。

2 公式化蚁群算法

2.1粒子速度更新规则:

粒子 i i i 在维度 d d d 上的速度 v i d ( t + 1 ) v_{id}(t+1) vid?(t+1)在下一个时间步的更新规则是:

v i d ( t + 1 ) = w ? v i d ( t ) + c 1 ? r 1 i d ( t ) ? ( p i d ( t ) ? x i d ( t ) ) + c 2 ? r 2 i d ( t ) ? ( g d ( t ) ? x i d ( t ) ) v_{id}(t+1) = w \cdot v_{id}(t) + c_1 \cdot r_{1id}(t) \cdot (p_{id}(t) - x_{id}(t)) + c_2 \cdot r_{2id}(t) \cdot (g_{d}(t) - x_{id}(t)) vid?(t+1)=w?vid?(t)+c1??r1id?(t)?(pid?(t)?xid?(t))+c2??r2id?(t)?(gd?(t)?xid?(t))

其中:

  • v i d ( t ) v_{id}(t) vid?(t) 是在时间步 t t t 时粒子 i i i 在维度 d d d 上的速度。
  • w w w 是惯性权重,控制粒子的速度。
  • c 1 c_1 c1? c 2 c_2 c2? 是加速常数,控制粒子向个体最佳位置 p i d ( t ) p_{id}(t) pid?(t) 和全局最佳位置 g d ( t ) g_{d}(t) gd?(t) 移动的程度。
  • r 1 i d ( t ) r_{1id}(t) r1id?(t) r 2 i d ( t ) r_{2id}(t) r2id?(t) 是区间 [0,1] 内的随机数。
  • x i d ( t ) x_{id}(t) xid?(t) 是在时间步 t t t 时粒子 i i i 在维度 d d d 上的位置。

2.2 粒子位置更新规则:

粒子 i i i 在维度 d d d 上的位置 x i d ( t + 1 ) x_{id}(t+1) xid?(t+1)在下一个时间步的更新规则是:

x i d ( t + 1 ) = x i d ( t ) + v i d ( t + 1 ) x_{id}(t+1) = x_{id}(t) + v_{id}(t+1) xid?(t+1)=xid?(t)+vid?(t+1)

其中:

  • x i d ( t ) x_{id}(t) xid?(t) v i d ( t + 1 ) v_{id}(t+1) vid?(t+1) 分别是在时间步 t t t 时粒子 i i i 在维度 d d d 上的位置和新计算出的速度。

通过这些规则,粒子会在解空间中探索,同时考虑到自身历史最佳位置和整个群体的全局最佳位置。

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

class Particle:
    # 粒子类定义
    def __init__(self, bounds):
        self.position = np.random.uniform(bounds[:, 0], bounds[:, 1], size=bounds.shape[0])  # 粒子初始位置
        self.velocity = np.random.uniform(-1, 1, size=bounds.shape[0])  # 粒子初始速度
        self.best_position = np.copy(self.position)  # 粒子最佳位置
        self.best_value = float('inf')  # 粒子的最佳值

class ParticleSwarmOptimizer:
    # 粒子群优化器类定义
    def __init__(self, function, bounds, num_particles, num_iterations, w=0.5, c1=1, c2=1):
        self.function = function  # 优化函数
        self.bounds = bounds  # 搜索空间边界
        self.num_particles = num_particles  # 粒子数
        self.num_iterations = num_iterations  # 迭代次数
        self.w = w  # 惯性权重
        self.c1 = c1  # 个体学习因子
        self.c2 = c2  # 社会学习因子
        self.particles = [Particle(bounds) for _ in range(num_particles)]  # 初始化粒子群
        self.global_best_position = None  # 全局最佳位置
        self.global_best_value = float('inf')  # 全局最佳值

    def optimize(self):
        # 优化过程
        for iteration in range(self.num_iterations):
            for particle in self.particles:
                value = self.function(particle.position)  # 计算当前位置的函数值
                if value < particle.best_value:  # 更新粒子最佳位置
                    particle.best_position = particle.position
                    particle.best_value = value
                if value < self.global_best_value:  # 更新全局最佳位置
                    self.global_best_position = particle.position
                    self.global_best_value = value

            for particle in self.particles:
                # 更新粒子速度和位置
                r1, r2 = np.random.random(size=self.bounds.shape[0]), np.random.random(size=self.bounds.shape[0])
                new_velocity = (self.w * particle.velocity +
                                self.c1 * r1 * (particle.best_position - particle.position) +
                                self.c2 * r2 * (self.global_best_position - particle.position))
                particle.velocity = new_velocity
                particle.position = particle.position + new_velocity
                # 确保粒子不超出边界
                particle.position = np.maximum(particle.position, self.bounds[:, 0])
                particle.position = np.minimum(particle.position, self.bounds[:, 1])

            if iteration % 10 == 0:  # 每10次迭代绘制一次
                self.plot_particles(iteration)

        return self.global_best_position, self.global_best_value

    def plot_particles(self, iteration):
        # 绘制粒子和函数图像
        fig = plt.figure(figsize=(10, 7))
        ax = fig.add_subplot(111, projection='3d')

        # 创建用于绘制函数的网格
        x = np.linspace(self.bounds[0, 0], self.bounds[0, 1], 30)
        y = np.linspace(self.bounds[1, 0], self.bounds[1, 1], 30)
        x, y = np.meshgrid(x, y)
        z = self.function(np.array([x, y, np.zeros_like(x)]))  # 计算函数值

        # 绘制函数图像
        ax.plot_surface(x, y, z, alpha=0.5, cmap='viridis', edgecolor='none')

        # 绘制粒子
        xs, ys, zs = np.array([p.position for p in self.particles]).T
        ax.scatter(xs, ys, zs, color='r')

        ax.set_title(f'Iteration {iteration}')
        ax.set_xlabel('X axis')
        ax.set_ylabel('Y axis')
        ax.set_zlabel('Z axis')
        plt.show()

# 示例:优化的函数
def example_function(x):
    # 三维函数定义
    return np.sin(x[0]) * np.cos(x[1]) + np.sin(x[1]) * np.cos(x[2])

# 定义搜索空间
bounds = np.array([[-10, 10], [-10, 10], [-10, 10]])

# 实例化并运行PSO优化器
pso = ParticleSwarmOptimizer(example_function, bounds, num_particles=30, num_iterations=100)
best_position, best_value = pso.optimize()
print("Best Position:", best_position)
print("Best Value:", best_value)

文章来源:https://blog.csdn.net/weixin_46160781/article/details/135189229
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。