智能优化算法实战：PSO与GA实现及混合策略

1. 智能优化算法概述

在工程优化和计算智能领域，路径规划和传感器覆盖是两类经典但极具挑战性的问题。传统数学方法在面对高维、非线性、多约束的复杂场景时往往捉襟见肘，而智能优化算法因其强大的全局搜索能力和适应性，已成为解决这类问题的利器。

我从事算法开发多年，发现PSO、GA等智能算法在实际应用中存在几个关键痛点：参数敏感、早熟收敛、局部最优陷阱等。本文将分享四种经过实战检验的算法实现，包含标准PSO、改进PSO、遗传算法以及创新的混合算法，所有代码都附带详细注释和调参建议。

2. 标准PSO算法实现与解析

2.1 算法原理剖析

粒子群优化(PSO)算法的核心思想源于鸟群觅食行为的建模。在D维搜索空间中，每个粒子代表一个潜在解，其状态由位置向量x和速度向量v决定。算法通过以下公式更新粒子状态：

code复制v(t+1) = w*v(t) + c1*r1*(pbest-x(t)) + c2*r2*(gbest-x(t))
x(t+1) = x(t) + v(t+1)

其中w是惯性权重，c1、c2为学习因子，r1、r2是[0,1]随机数。pbest记录粒子历史最优位置，gbest记录群体最优位置。

关键点：惯性权重w控制探索能力，较大的w有利于全局搜索，较小的w偏向局部开发。通常取值0.4-0.9

2.2 完整Python实现

python复制import numpy as np

class StandardPSO:
    def __init__(self, obj_func, dim, bounds, num_particles=50, max_iter=100):
        self.obj_func = obj_func  # 目标函数
        self.dim = dim            # 问题维度
        self.bounds = bounds      # 搜索边界 [(min,max)]*dim
        self.num_particles = num_particles
        self.max_iter = max_iter
        
        # 算法参数
        self.w = 0.7     # 惯性权重
        self.c1 = 1.5    # 个体学习因子
        self.c2 = 1.5    # 社会学习因子
        
        # 初始化粒子群
        self.positions = np.random.uniform(
            low=[b[0] for b in bounds],
            high=[b[1] for b in bounds],
            size=(num_particles, dim))
        
        self.velocities = np.random.uniform(
            low=-np.abs(np.array([b[1]-b[0] for b in bounds])),
            high=np.abs(np.array([b[1]-b[0] for b in bounds])),
            size=(num_particles, dim))
        
        self.pbest_positions = self.positions.copy()
        self.pbest_values = np.array([obj_func(p) for p in self.positions])
        self.gbest_position = self.pbest_positions[np.argmin(self.pbest_values)]
        self.gbest_value = np.min(self.pbest_values)
        
    def optimize(self):
        for _ in range(self.max_iter):
            r1 = np.random.rand(self.num_particles, self.dim)
            r2 = np.random.rand(self.num_particles, self.dim)
            
            # 更新速度
            self.velocities = (self.w * self.velocities +
                self.c1 * r1 * (self.pbest_positions - self.positions) +
                self.c2 * r2 * (self.gbest_position - self.positions))
            
            # 更新位置
            self.positions += self.velocities