粒子群优化算法（PSO）在我这里一直属于“不用想太多、先跑一把看看”的常用工具。它诞生的灵感很朴素：一群鸟在不知道食物在哪的情况下找食，每只鸟记住自己飞过的最好位置，同时参考群里喊得最响的那只鸟的位置，来回几次就能把整群鸟带到食物附近。落到工程上，这套行为被抽象成一个只依赖“输入一组参数、输出一个分数”的迭代搜索器——你不需要目标函数的导数，不需要它连续可微，甚至不需要知道它的解析形式，只要能算出一个“有多差”的评价，PSO 就能帮你往下推。

它解决的问题很具体：当参数空间是黑箱、非凸、多峰，而且维度在几维到几十维这个区间时，网格搜索会组合爆炸，梯度法无处下手，纯手工试参数又太靠运气，PSO 就是一个实现短、参数少、容易并行、结果还能接受的折中方案。我常用它的场合包括传感器参数标定、控制器参数整定、仿真模型的几个系数反推、机器学习超参数的粗筛、路径与排产这类组合问题的近似求解。这篇文章写给两类人：一类是刚听说 PSO、想把它跑起来看效果的新手；另一类是已经在用、但总觉得结果时好时坏、想搞清楚哪里出了问题的同行。下面这些内容基本来自我自己踩过的坑，公式不会堆太多，重点讲清楚每个参数为什么要那么取、出了问题往哪里看。

1. 工程现场为什么会先想到 PSO

1.1 一次“没有梯度可用”的标定经历

早些年我参与过一个采集系统的参数标定工作，说白了就是五个系数要定下来，评价好坏的方式只有一个：把这五个系数塞进仿真模型里跑一遍，看输出曲线和实测曲线的偏差。这个评价函数有几个让人难受的性质：不可导（内部有阈值判断和查表）、有平台区（某一段参数变化对结果几乎没有影响）、带噪声（实测数据本身有波动）、而且单次评估要花几十毫秒到几百毫秒。五个参数如果每个取十个水平做网格搜索，就是十万次评估，按每次 0.1 秒算要接近三个小时，中间任何一个参数范围估错还得重来。

换成 PSO，30 个粒子跑 150 代，总评估次数四千五百次，十几分钟出结果，而且第一版结果就比手工调了两天的参数好。这件事让我形成了一个判断：选优化算法的第一依据不是“哪个算法先进”，而是“我手上有什么”——有梯度就用梯度法，有解析结构就用凸优化，什么都没有、只有一个能打分的黑箱，那就是 PSO、差分进化、遗传算法这一类的战场。

再往下追问一层，为什么 PSO 在这种场景下效率还行？因为它把“搜索”这件事拆成了两部分信息：个体记忆和群体共享。个体记忆保证它不会把已经找到的好位置丢掉，群体共享保证好消息能快速扩散。这两条加起来，等价于一个不需要导数、带随机扰动的下降方向，代价是它没有收敛性保证，只能靠多次运行和统计来判断结果可不可信。

1.2 PSO、遗传算法、差分进化、贝叶斯优化怎么选

我办公室里经常被问“到底用哪个”，这个问题其实有比较清晰的判断路径，核心看三件事：变量是连续还是离散、评估一次贵不贵、维度有多高。下面这张表是我自己用的选型对照，不是教科书结论，是实践里总结的偏好。

从表里能看出 PSO 的位置：它处在“评估不算太贵、维度不算太高、想要快速拿到一个还不错解”的中间地带。如果评估一次要跑五分钟的有限元仿真，那 PSO 的几千次评估根本不现实，应该转去做代理模型加贝叶斯优化；如果问题是纯离散的车辆路径，那段编码、交叉算子这一套遗传算法的表达力更强。

还有一点常被忽略：PSO 的实现成本极低。一个能用的标准版本不到一百行，调参只需要看着三四个量，这对需要反复改目标函数的探索阶段非常友好。我经常在项目早期用 PSO 快速摸清参数空间的形状，比如哪些参数敏感、最优区域大概在哪、函数是不是多峰的，这些信息比最终那个解更值钱。

1.3 三类别硬上的问题

第一类是超高维。维度上到两三百维以后，PSO 的表现会明显退化，原因是速度和位置的更新在每一维上独立进行，维度一高，“群体共享”这条信息就变得极其嘈杂，粒子很容易在某个方向上冲过头。这类问题要么降维、要么做特征分组，要么换坐标下降的思路。

第二类是单次评估极其昂贵的问题。PSO 的收敛依赖足够的迭代次数，评估预算被压到几十次的时候，它连初始种群的分布都铺不满，还不如直接用拉丁超立方采样加代理模型。

第三类是需要可解释性和可复现审计的场合。PSO 是随机算法，同一份代码换个种子结果就不一样，如果你的结论要写进验收文档，就必须做多次独立运行并报告分布，只报一次“最优值”是没有说服力的。

2. 把速度更新公式拆开看

2.1 三项各自的物理直觉

标准 PSO 的核心只有两行：

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

其中 v 是速度，x 是位置，pbest 是这个粒子历史上到过的最好位置，gbest 是整个群体目前的最好位置，r1、r2 是两个 [0,1] 上均匀分布的随机数，w 是惯性权重，c1、c2 是学习因子。

第一项w * v是惯性项，作用相当于“保持当前运动方向”。它带来的是探索能力——粒子不会因为一次评价变差就立刻掉头，而是继续往前探一段。第二项c1 * r1 * (pbest - x)是认知项，把粒子往自己记忆中的最好位置拉，防止它彻底变成随大流的复制品。第三项c2 * r2 * (gbest - x)是社会项，把粒子往全群最好位置拉，这是信息共享的通道，也是收敛速度的主要来源。

两个随机数不是装饰。它们让每个粒子在同一代里被拉向略微不同的方向，从而维持种群的空间分布。如果你把 r1、r2 固定成常数，会立刻看到粒子排成一条直线冲向同一点，多样性消失得非常快——这是我在早期自己实现时犯过的错，当时以为是参数没调好，查了半天才发现是随机项写成了常数。

一个容易忽略的细节：pbest - x和gbest - x这两个向量的量纲是“位置差”，而w * v的量纲是“每代位移”。在标准形式下两者一致，所以可以直接相加。但一旦你给速度加了额外项、或者对位置做了非线性变换，这个量纲一致性就必须重新检查，否则会出现“速度看着不大、位置却一步跨出搜索空间”的情况。

2.2 惯性权重：最值得动手的一个数

惯性权重 w 是 PSO 里性价比最高的调节旋钮。早期版本取 w = 1，问题是不加衰减时粒子在最优解附近来回震荡，收敛精度差。后来大家普遍的做法是让 w 随迭代线性递减：

w(t) = w_max - (w_max - w_min) * t / T

常用取值是 w_max = 0.9、w_min = 0.4，T 是总迭代代数。这个设计的逻辑很直观：前期 w 大，粒子倾向于保持原方向，全局探索能力强，负责把搜索范围铺开；后期 w 小，惯性被压制，粒子更容易被 pbest 和 gbest 拽住，转入局部精细搜索。这是一条“先广撒网、后收口”的策略。

实践里有几种变体值得一提。非线性递减用w = w_max - (w_max - w_min) * (t/T)^2，前期 w 掉得慢，探索时间更长，适合目标函数特别多峰的情况。自适应 w 则根据当前种群状态来调，比如用种群位置的方差或者适应度的离散程度做反馈：多样性高的时候减小 w 加速收敛，多样性低的时候增大 w 逼它跳出去。这种自适应版本在多峰函数上确实有效，但也引入了新参数，调起来更麻烦，我的建议是先把线性递减用熟，确定问题真的需要再加自适应。

怎么判断 w 取得合不合适？看收敛曲线。如果曲线在前二三十代就压平、最终值离预期差很多，多半是 w 太小或者社会项太强，早熟了；如果曲线一直到最后一代还在上下大幅抖动、没有收口趋势，那是 w 太大或者速度钳制太松，粒子在最优解附近反复横跳。

2.3 学习因子与种群拓扑的选择

c1 和 c2 的经典取值是两个都是 2，这个组合配合收缩因子能保证一定的收敛性质。实际调的时候我更习惯按“前期偏探索、后期偏收敛”的思路给它们做线性变化：c1 从 2.5 降到 0.5，c2 从 0.5 升到 2.5。前期的意思是“多信自己、少信群众”，让粒子各自去不同区域探；后期反过来，“多听群众意见”，加速收口。这个策略在多峰函数上比固定值稳定不少，我对它的评价是：不增加什么实现成本，但能实打实降低早熟概率。

比 c1、c2 更容易被忽略的是拓扑结构，也就是“每个粒子参考谁”。最常见的全局版是所有人都看同一个 gbest，收敛快、信息传播效率高，代价是一旦 gbest 落在局部最优，整个群体会被一起拖进去。另一种是局部版，每个粒子只参考自己邻域内的最优（lbest），比如排成一个环，第 i 个粒子只看第 i-1、i、i+1 号。信息在环上传播得慢，但正因为慢，不同区域的信息不会立刻被覆盖，多样性保持得更好。

我的经验是：单峰或者接近单峰的问题用全局版，收敛快；明显多峰的连续函数用环形拓扑或者冯诺依曼拓扑，虽然迭代次数要多一些，但找到全局最优的概率明显更高。如果问题规模不大、允许跑几十次独立实验，直接两种都试，用结果分布说话，比纠结理论更省时间。

2.4 速度钳制与边界处理

速度钳制这一条我把它放在“必须做、且必须做对”的位置。做法是给每一维速度设一个上限 v_max，通常按搜索范围的比例给：

v_max[j] = v_ratio * (x_max[j] - x_min[j])

v_ratio 我一般取 0.1 到 0.2。比例给太大（比如 0.5 以上），粒子一步就能横跨半个搜索空间，等于在随机采样；给太小，粒子移动能力被限制，收敛慢而且容易困在初始位置附近。

为什么必须钳制？因为不钳制的情况下，一旦某个粒子飞出搜索空间，它的 pbest 会停在越界的位置（或者被截断到边界上），后续的速度项会持续把它往外推，速度越来越大，位置越来越远，最后整个群体被一个错误的 gbest 带着塌缩到边界角落。表现出来就是“所有粒子挤在一起，适应度全都一样，曲线一代就平了”。

位置越界的处理有三种常见做法，各有取舍。截断法最简单，直接把越界分量拉回边界。反弹法把越界分量按对称方式折回来，x = lo + (lo - x)，并且把该维速度取反，好处是粒子还有机会往回走。随机重置法把越界粒子在可行域内重新随机生成，探索性最强但会损失已有信息。我在连续问题上默认用反弹，组合问题上用重置。

注意：截断法最大的隐患是“贴边效应”。粒子被拍在边界上，速度方向仍然朝外，下一代又被拍回来，反复几次适应度完全不变，评估预算就这么白烧了。用截断的话，一定同时把该维速度清零或者取反。

2.5 归一化：量纲不一致会把算法毁掉

这是最容易被跳过、后果最严重的一步。假设你要标定两个参数，一个是增益，范围 0.001 到 0.01；另一个是时间常数，范围 10 到 1000。如果直接在原始量纲上跑 PSO，速度上限只能取一个统一的比例，结果就是增益这一维的更新几乎不动，而时间常数这一维一步跨得巨大。算法实际上变成了单参数搜索，另一半预算全浪费。

正确做法是把所有维度映射到统一的归一化空间，比如 [-1, 1] 或 [0, 1]，在归一化空间里做全部的速度和位置运算，评估时再反变换回去：

def to_norm(x, lo, hi): return (x - lo) / (hi - lo) def to_real(z, lo, hi): return lo + z * (hi - lo)

好处有三个：速度上限有了统一尺度，c1、c2 的取值也和维度无关；参数之间的敏感度对比更公平；换一个问题时参数配置基本可以直接搬过去。代价是每次评估多两次乘加，可以忽略。

3. 手写一版能直接跑的 PSO

3.1 数据结构与主流程

标准 PSO 的数据结构就五样东西：位置矩阵 X（n 行 d 列，n 是粒子数，d 是维度）、速度矩阵 V、个体最优位置 P、个体最优适应度 fp、全局最优 g 及其适应度 fg。主循环的顺序是：评估当前位置、更新个体最优、更新全局最优、更新速度、更新位置、处理边界、记录历史。

这个顺序有个细节值得说一下：先评估再更新最优，是为了让“当前位置的分数”和“当前最优”对齐；如果你先更新速度位置再评估，那么 gbest 永远是上一代的信息，收敛会慢半拍，在迭代次数有限的时候这个差别能看出来。

下面是我自己常用的实现，包含线性递减惯性权重、速度钳制、反弹边界、早停和评估次数记录。依赖只有 numpy：

import numpy as np def pso_minimize(func, bounds, n_particles=40, n_iter=500, w=(0.9, 0.4), c1=(2.0, 2.0), c2=(2.0, 2.0), v_ratio=0.2, seed=42, patience=80, tol=1e-10, verbose_every=0): """ func: 接收 (n, d) 位置矩阵，返回 (n,) 适应度数组（越小越好） bounds: [(lo, hi), ...]，长度 d """ rng = np.random.default_rng(seed) b = np.asarray(bounds, dtype=float) lo, hi = b[:, 0], b[:, 1] d = lo.size span = hi - lo vmax = v_ratio * span # 初始化：位置均匀撒开，速度取小随机值 X = lo + rng.random((n_particles, d)) * span V = (rng.random((n_particles, d)) - 0.5) * 2.0 * vmax f = np.asarray(func(X), dtype=float) P = X.copy() fp = f.copy() k = int(np.argmin(fp)) g, fg = P[k].copy(), float(fp[k]) history = [fg] stall = 0 n_eval = n_particles for t in range(n_iter): frac = t / max(1, n_iter - 1) w_t = w[0] + (w[1] - w[0]) * frac c1_t = c1[0] + (c1[1] - c1[0]) * frac c2_t = c2[0] + (c2[1] - c2[0]) * frac r1 = rng.random((n_particles, d)) r2 = rng.random((n_particles, d)) V = w_t * V + c1_t * r1 * (P - X) + c2_t * r2 * (g[None, :] - X) V = np.clip(V, -vmax, vmax) X = X + V # 反弹边界 + 速度反向 low_bad = X < lo high_bad = X > hi X = np.where(low_bad, lo + (lo - X), X) X = np.where(high_bad, hi - (X - hi), X) X = np.clip(X, lo, hi) V = np.where(low_bad | high_bad, -V, V) f = np.asarray(func(X), dtype=float) n_eval += n_particles better = f < fp P[better] = X[better] fp[better] = f[better] k = int(np.argmin(fp)) if fp[k] < fg - tol: g, fg = P[k].copy(), float(fp[k]) stall = 0 else: stall += 1 history.append(fg) if verbose_every and (t + 1) % verbose_every == 0: print(f"iter {t + 1:4d} fg = {fg:.6e} w = {w_t:.3f} eval = {n_eval}") if stall >= patience: if verbose_every: print(f"连续 {patience} 代无改善，提前结束于第 {t + 1} 代") break return {"x": g, "f": fg, "history": np.array(history), "n_eval": n_eval}

在十维 Rastrigin 函数上验证一下，这个函数是标准的“多峰陷阱”，全局最优为 0，局部最优密密麻麻：

def rastrigin(X): return np.sum(X ** 2 - 10.0 * np.cos(2 * np.pi * X) + 10.0, axis=1) bounds = [(-5.12, 5.12)] * 10 res = pso_minimize(rastrigin, bounds, n_particles=60, n_iter=1000, patience=150, verbose_every=100) print("best f =", res["f"], "eval =", res["n_eval"])

实测下来，这套配置在十维 Rastrigin 上通常能跑到个位数到 1e-2 量级的适应度，如果一次跑到 20 以上，要么是种子不巧，要么是粒子数太少，别急着加迭代次数，先把 n_particles 从 60 提到 100 试试。

3.2 参数取值模板与评估预算倒推

参数怎么给这个问题，我给的建议是“先按预算倒推，再按表现微调”。PSO 的总评估次数约等于粒子数乘以代数（早停会少一些），所以顺序应该是：先确定我能接受多少次评估，再定粒子数和代数的组合。

其他参数：w 从 0.9 线性降到 0.4；c1 从 2.5 降到 0.5、c2 从 0.5 升到 2.5（或者干脆都取 2）；v_ratio 取 0.15 到 0.2；早停 patience 取总代数的 15% 到 20%。

这些数字不是定理，是起点。有一个反直觉的地方：粒子数对结果的影响通常比代数更大。种群太小（比如 10 个）时，局部最优一旦被 gbest 占据，整个群体很快就被拉过去，你加再多代也救不回来；而种群够大时，即使代数少一点，也更有可能在某个粒子身上碰到好的盆地区域。预算有限的时候，我倾向于多给种群、少给代数。

3.3 如何判断结果不是假收敛

单次运行的最优值没有任何统计意义，这一点怎么强调都不过分。我固定做四件事：

第一，画收敛曲线，纵轴用对数坐标。线性坐标下早期的大幅下降会把后期细节全压平，看不出算法到底是在改进还是在原地打转。

第二，用同一个配置跑至少 20 次不同种子，统计最好值、中位数、最差值、标准差。工程上报“最好值 0.012、中位数 0.035、最差 0.4”和只报“0.012”，可信度差一个量级，前者告诉你这个结果有多大概率能复现。

第三，和随机搜索做对比。随机搜索的基线很好算：在同一个搜索空间里均匀采样相同次数，取最好的那个。如果 PSO 跑出来的结果和随机搜索差不多，那说明算法根本没起作用，问题多半出在参数范围设错、目标函数太嘈杂或者归一化没做。

第四，用已知答案的函数验证代码本身。这一步被跳过的人特别多，我见过不止一次“PSO 效果很差”最后发现是目标函数写错了符号。跑一遍球函数（Sphere），最优应该是 0 且在原点；跑一遍 Rosenbrock，看能不能逼近 (1,1,...,1)。代码没问题，再去怀疑算法。

3.4 一次“假收敛”的现场诊断

有个排产场景，二十来个决策变量，PSO 跑到第 15 代曲线就平了，最终结果比人工排的还差 8%。第一反应是参数不够好，调了半天 w 和 c2 没变化。于是把每一代所有粒子的位置打出来看，发现所有粒子在第 12 代左右已经挤到了几乎同一个点上，位置方差降到 1e-6 量级——这就是彻底塌缩。

顺着往回查，原因有两个叠加在一起：一是 v_ratio 给到了 0.5，粒子一步能飞半个空间，早期就撞到了边界，反弹之后全被推回同一个角落；二是目标函数的量纲差异很大，一个变量范围是 0 到 1，另一个是 0 到 5000，没做归一化，第二维的更新完全主导了速度。改成 v_ratio = 0.15、全维归一化到 [0,1] 之后，第 40 代才收敛，结果比人工排的好 6%。

这个案例我想说明的是：收敛曲线“太平”和“太抖”都指向具体的实现问题，先看种群多样性指标（位置的标准差），再看速度分布，最后才去调参数。顺序反了就是在黑箱里瞎摸。

4. 工程落地的几个硬骨头

4.1 约束条件怎么处理才不别扭

现实问题基本都带约束：参数有上下限、总资源有上限、某些组合不允许出现。处理方式主要有三类，效果差别很大。

罚函数法最通用，把违反量做成惩罚项加进目标函数：F = f + M * sum(max(0, g_i)^2)。难点在 M 怎么取。M 太小，最优解会停在不可行区域；M 太大，可行域边缘变成一堵墙，粒子一撞就被弹回，搜索退化成在可行域内部瞎转。我的经验值是先估一下目标函数和违反量的量级，让 M 使得“单位违反量”的惩罚等于目标函数典型变化的 10 到 100 倍。更好的做法是自适应：随着迭代进行逐渐增大 M，前期允许适度越界以保持探索，后期收紧逼回可行域。

Deb 提出的可行性优先规则在工程上更稳：比较两个解时，可行解永远优于不可行解；两个都可行就比目标函数；两个都不可行就比违反量大小。这条规则的好处是不需要给 M 找一个精确的数量级，缺点是它改变了适应度的语义，个体最优和全局最优的更新逻辑要跟着改。我在约束比较硬的问题上倾向用这一套。

第三类是修复策略，也就是把不可行解“拉回”可行域。参数越界就截断，总量超限就按比例缩放，排产里任务冲突就交换顺序。修复的好处是评估永远发生在可行域内，坏处是修复算子本身可能破坏粒子已经积累的搜索信息，而且写起来最费劲。我的取舍是：连续参数用罚函数或者可行性优先，离散组合问题用修复和随机键编码。

4.2 离散与组合问题：随机键编码

标准 PSO 是为连续空间设计的，直接拿来做排列问题会很别扭。常用的一种转换是随机键编码：粒子仍然在连续空间里飞，位置向量本身没有业务含义，把它排序之后取序号，得到的排列就是合法解。

def decode_permutation(position): """position: 长度 n 的实数向量 -> 0..n-1 的排列""" return np.argsort(position, kind="stable")

这个技巧的妙处在于把“离散约束”从算法内部挪到了解码环节，粒子照样可以加减速度、照样能保持种群结构，而输出永远是合法的排列。缺点是搜索空间到解空间是多对一的映射，不同的位置向量可能解码出同一个排列，收敛时的有效多样性会比看起来低。实践上配合较小的 v_ratio 和适中的种群规模，效果一般够用。

对于 0-1 变量，常见做法是用 sigmoid 把速度映射成概率，再按概率采样。这条路的坑在于概率很容易饱和到接近 0 或 1，粒子一旦定形就不再变化，最后所有粒子给出同一个 0-1 串。缓解办法是给概率设一个下限（比如 0.05），或者定期对部分粒子做随机翻转。

4.3 评估预算紧张时的三板斧

第一是向量化。把整个种群的位置矩阵一次性传给目标函数，用 numpy 的广播把评估写成批量运算，比 for 循环逐个算通常快一个数量级。上面那份实现就是按批量接口设计的，如果你的目标函数只能接收单点，写个包装把批量拆开，也比在 PSO 里逐粒子调用要好维护。

第二是并行。粒子之间的评估互相独立，天然适合多进程。要注意两点：随机种子必须在主进程生成好再分发，否则子进程会拿到相同的种子；单次评估很轻（毫秒级）的时候，进程间通信的开销会吃掉收益，这种时候老老实实串行反而更快。

第三是早停和预算控制。早停的判据我用两条：连续 patience 代 gbest 没有超过 tol 的改善，或者改善量小于1e-6 * abs(fg)。另外记录实际评估次数，一旦超预算立刻中断，返回当前最优。这比事后发现跑了一晚上要体面得多。

如果评估真的很贵（比如每次几十秒），那就别在 PSO 上硬顶了，先采二三十个点建一个 RBF 或者 Kriging 代理模型，在代理模型上跑 PSO 找候选点，再把候选点拿去真评估，这是代理优化（surrogate optimization）的基本套路，评估预算能压到原来的几十分之一。

4.4 高维与多峰的几种改造

标准 PSO 在多峰问题上失败的方式很一致：所有粒子被同一个 gbest 吸走。针对这个，几种改造按实现成本从低到高排：

混合局部搜索（memetic）这一条我特别推荐：PSO 负责全局定位，等它收敛之后，从 gbest 出发跑一次坐标轮换或者简单的模式搜索做精修。连续参数标定里，这一步经常能把精度再提高一到两个数量级，因为 PSO 在最优解附近是靠随机项慢慢逼近的，而局部搜索是有方向的。

5. 踩坑实录与排查速查表

5.1 故障现象与根因对照

这张表覆盖了我遇到过的绝大多数情况，实际排查时从头往下看，最快的两个检查是“跑一遍球函数”和“打印位置的标准差”，前者排除代码 bug，后者判断是否塌缩。

5.2 我固定的七步排查动作

遇到 PSO 表现不对，我按这个顺序走，通常在前三步就能定位：

1. 用 Sphere 和 Rosenbrock 各跑一次，确认算法实现本身没问题。
2. 打印第一代所有粒子的适应度分布，看有没有大量相同值（说明初始化有问题或评价函数有多值平台）。
3. 打印每代位置矩阵的标准差，看多样性衰减速度，第几代塌缩一目了然。
4. 固定种子跑三次，结果完全一致才说明没有隐藏的全局状态或者未初始化变量。
5. 做单参数灵敏度扫描：对 gbest 的每一维分别扰动，看目标函数变化是否合理，这一步能抓出“某一维根本没在起作用”的问题。
6. 用随机搜索在同样预算下跑一遍，对比基线。
7. 把实际评估次数和预算对一遍，确认早停和预算控制是否生效。

第三步那个多样性曲线特别有用，它比收敛曲线更早暴露问题。正常状态下位置标准差应该在中前期缓慢下降，如果在十代内直接掉到接近零，那就一定是速度或者边界出问题了。

5.3 几条不写在教材里的经验

第一条，PSO 背锅的次数远多于它真正该背的。我被“这个算法不行”骗过好几次，最后都是评价函数有 bug——符号反了、少乘了一个量、单位没换算、缓存没清导致读到旧值。所以现在的流程是：先把目标函数放到网格搜索上跑一遍，确认它给出的“好参数”符合常识，再上 PSO。

第二条，别追求“高级变体”。线性递减 w 加 c1、c2 各自线性变化、v_ratio = 0.2，这套朴素配置能覆盖八成以上的连续优化问题。自适应参数、混沌扰动、量子行为这些变体确实在某些函数上有优势，但每加一个机制就多一组参数要调，调试成本翻倍。我的原则是：朴素版跑不出可接受结果，先怀疑问题和评价函数，确认问题需要了再上变体。

第三条，评估预算要先算清楚再动手。粒子数乘以代数是总评估次数，乘以单次耗时就是总时间。我见过有人用 200 个粒子跑 5000 代，单次评估 0.2 秒，算了三天，最后发现第一代的结果就已经接近最优了。把预算和前几代的收敛速度对齐，往往能省掉 90% 的时间。

第四条，目标函数带噪声时，调参数没用，改评估方式才有用。噪声幅度如果和目标函数在最优附近的改进量同一个量级，PSO 会一直“以为找到了更好的解”，实际上是在拟合噪声。处理办法是每次评估重复采样取均值，或者用移动平均平滑历史最优，前者费预算，后者省事但会引入滞后。

第五条，别用 PSO 解本来有解析解的问题。线性回归、凸二次规划、最小二乘，这些有闭式解或者成熟求解器的问题，用 PSO 纯属给自己找不痛快——精度差、速度慢、还解释不清楚。判断标准很简单：如果能写出梯度，就先考虑梯度法；如果问题是凸的，就找凸优化工具；两者都不满足，再考虑群体智能这一套。

最后分享一个我自己常用的小习惯：每次跑 PSO，我都会把搜索范围设得比“我认为合理”的范围宽 30% 到 50%。如果最优解落在设定的边界上，几乎可以肯定真实最优在边界外面，这时候扩大范围重跑，比在原地调参数有用得多。这个信号极其容易观察，却经常被忽略——最优解贴着边界，本身就是算法在告诉你范围设错了。