Skip to content

粒子群优化 PSO ​

方法速览 ​

  • 主要用途 在连续、多峰、不可导或黑箱目标中寻找近似全局最优(本页以最大化为例,最小化只需对目标取负)。
  • 必要输入 目标函数、可行域边界、种群规模(粒子数)、迭代次数、参数 w/c1/c2 与速度上限,以及一个可复现的随机数发生器(固定 seed)。
  • 适用条件 变量为连续、可行域是矩形盒约束(每维一个区间),且允许返回「足够好」的近似解而非严格最优证明。
  • 典型不适用情况 需要严格全局最优证明、目标函数评估极其昂贵,或变量是离散组合(需先设计合适的编码与离散更新规则)。
  • 最低限度的验证方式 用独立网格搜索或枚举给出参考最优,固定 seed 复现,多 seed 统计 gbest 分布,并观察收敛曲线是否停滞。

快速回答 ​

粒子群优化(Particle Swarm Optimization,PSO)是受鸟群、鱼群觅食行为启发的群体智能优化算法。它维护一群「粒子」——每个粒子是一个候选解,携带位置 x 和速度 v。每代用同一条规则更新:

v←wv+c1r1(pbest−x)+c2r2(gbest−x),x←x+v,

即「按惯性继续原方向 + 往自己历史最好 pbest 靠拢 + 往群体历史最好 gbest 靠拢」。w(惯性权重)控制保留多少旧速度,c1、c2 控制向个体记忆与群体记忆靠拢的力度,r1、r2 是 [0,1) 的随机数。

它和模拟退火的关键区别在于跳出局部最优的机制不同:模拟退火靠「以概率接受劣解」翻越山谷,PSO 靠「群体共享记忆 + 惯性飞行」让粒子群越过局部峰。二者都是启发式,返回近似解而非严格全局最优。

从零理解 ​

想象一群人在浓雾中的山地上分头寻找最高点,互相可以喊话。每个人:

  1. 随机站在一个位置(粒子 = 候选解);
  2. 每走一步都记住「自己去过的最高点」——这是个体记忆 pbest;
  3. 大家随时通报「全队目前找到的最高点」——这是群体记忆 gbest;
  4. 下一步往哪走?三个方向的合力:
    • 惯性:继续按原来的速度方向走(保留探索的冲劲);
    • 自我认知:往自己的 pbest 方向走一点;
    • 社会认知:往全队的 gbest 方向走一点。

逐项「翻译」成优化语言:

鸟群觅食优化中的对应
一只鸟的位置一个候选解 x=(x,y)
鸟的飞行速度移动方向与步长 v
这只鸟记忆里食物最多的地方个体历史最优 pbest
全群通报的食物最多的地方群体历史最优 gbest
继续原来的飞行方向惯性项 wv
向自己最好的记忆靠近认知项 c1r1(pbest−x)
向全群最好的记忆靠近社会项 c2r2(gbest−x)

所以 PSO 不是「一只鸟爬山」,而是「一群鸟边飞边共享记忆」,用群体的合力把粒子「拽」向更优区域,同时靠随机与惯性保持探索。

数学原理 ​

符号定义 ​

符号含义
xi=(xi,yi)第 i 个粒子的位置(候选解,本页为二维)
vi=(vix,viy)第 i 个粒子的速度(本步移动方向与步长)
pbesti第 i 个粒子的个体历史最优位置
gbest全体粒子的群体历史最优位置
f(x)目标函数,本页最大化
w惯性权重,0<w<1 常见
c1,c2个体认知 / 社会认知系数,通常 c1=c2≈1.49
r1,r2每维独立抽取的 U(0,1) 随机数
vmax速度分量上限,本页取 0.2(b−a)

更新公式与参数含义 ​

对每一维 d∈{x,y},速度与位置更新为

vd←wvd+c1r1(pbestd−xd)+c2r2(gbestd−xd),xd←xd+vd.

三项的直觉:

  • 惯性项 wvd:保留上一代速度的比例。w 大 → 全局探索强(大步飞行);w 小 → 局部开发强(步子粘、易过早停滞)。常用策略是让 w 随迭代从约 0.9 线性降到约 0.4。
  • 认知项 c1r1(pbestd−xd):把自己「拽」向个人最好点,鼓励个体差异化探索。c1 过大、c2 过小会退化成「各找各的」,难以共享信息。
  • 社会项 c2r2(gbestd−xd):把全群「拽」向群体最好点,加速收敛。c2 过大、c1 过小会让全群过早涌向同一个点,失去多样性。

r1、r2 使每个粒子、每维、每代的移动方向略有随机性——这正是「启发式」的来源,也是需要固定 seed 才能复现的原因。

速度上限 vmax:更新后的每个速度分量都要裁剪到 [−vmax,vmax],防止粒子一步跨过整个搜索域而发散。本页取 vmax=0.2(b−a)(在 [−3,3]2 上为 1.2)。

与模拟退火的直觉对比 ​

维度模拟退火 SA粒子群优化 PSO
灵感来源金属退火(物理)鸟群/鱼群觅食(生物群体)
基本单元一个当前解 + 一个温度 T一群粒子(各自位置 + 速度)
跳出局部最优的机制以概率 exp⁡(Δ/T) 接受劣解群体共享 gbest + 惯性飞行翻越局部峰
关键可调参数t0、α(冷却)w、c1、c2、vmax
并行性单链(可多起点并行)天然并行(种群)
记忆只记一个 running best每个粒子记 pbest + 全局记 gbest

为什么是近似解 ​

PSO 的收敛由「惯性 + 认知 + 社会」三项合力的随机动力学决定,没有任何理论保证一定落到全局最优。它给出的是「迭代预算内找到的最好解」,可能停在局部峰(过早停滞)或还没爬完(迭代上限)。因此结论只能说「近似最优」,并用独立基准与多次运行统计来佐证。

收敛与停滞 ​

  • 收敛:随着粒子向 gbest 聚拢,pbest−x 与 gbest−x 都趋于 0,速度逐渐衰减,粒子「抱团」在某个点附近,gbest 不再刷新。
  • 停滞:若 w 太小、c1/c2 失衡或种群多样性不足,粒子会过早抱团在一个局部峰,之后 gbest 长期无改进——这是 PSO 最典型的失败模式。诊断信号:连续多帧 gbest 不变(本文取「最近 20 帧无改进」)。

边界处理陷阱 ​

速度更新可能把粒子推出可行域,必须显式处理。常见做法有「裁剪到边界并把该维速度置零」(本文实现,防止反复撞墙)或「反弹(速度取反)」。若不做边界处理,粒子会飞出去、目标函数可能在定义域外无意义或发散——这是 PSO 最常见的实现错误,详见「代码实践」的常见错误。

动态实验 ​

粒子群优化演示:最大化 peaks 函数 收敛
-3-1.501.53-3-1.501.53-6-3036f(x, y)(色块为函数值近似)
迭代 0/100gbest.f = 7.0048x = -0.0736y = 1.8541惯性权重 w = 0.72最近改进 97 次迭代
数值参考 ≈ 8.106迭代次数gbest.f

初始化:20 个粒子随机散布在 [−3,3]²,速度在 ±vmax(=1.2)内随机,选出初始群体最优 gbest.f ≈ 7.005。

1 / 101
左图:peaks 函数的热力色块(色块为函数值近似,粒子仍按真实 f 计算),粒子当前位置(圆点)、 速度向量(箭头,线长=速度大小)、个体最优 pbest(小方点)、群体最优 gbest(金色星形);右侧为 gbest.f 收敛曲线的虚线标出本例数值参考 ≈8.106。每帧对应一次迭代。达到目标值阈值 gbest.f ≥ 8.0 时,教学状态显示「收敛」, 最近 20 帧无改进为「停滞」,否则为「达到迭代上限」。粒子群优化是群体智能启发式: 结果是近似解、依赖随机种子,需多次运行统计,不保证严格全局最优。

本演示最大化 MathWorks peaks 函数(f 定义见「代码实践」),x,y∈[−3,3]。本例记录到的最高目标值约 8.1062,位于 (x,y)≈(−0.009,1.581);动画左图用热力色块近似函数值(色块是分块近似,粒子仍按真实 f 计算),右列为 gbest 收敛曲线。每帧对应一次真实迭代。

参数含义:

参数范围默认作用
粒子数10–4020种群规模;越多探索越充分、越慢
w(惯性权重)0.3–0.90.72保留旧速度的比例;越小越粘、越易早停
c1(个体认知)0.5–2.01.49向 pbest 靠拢的力度
c2(社会认知)0.5–2.01.49向 gbest 靠拢的力度
seed42 / 7 / 12342随机种子;同一 seed 轨迹可复现

默认参数(seed 42)实测数值(与 Python 算例逐位一致):

项目值
独立网格搜索(200×200)最优f=8.10434((0.00,1.59),分辨率 0.03)
seed 42 的 gbest 位置x=−0.009317,y=1.581369
seed 42 的 gbest.f8.106214(≈本例高值基准 8.1062)
seed 42 的 stallIterations3

多 seed(42 / 7 / 123)的 gbest.f 分别约 8.106214 / 8.106214 / 8.106214,都接近本例的高值基准(stall 分别为 3 / 14 / 2)。

慢收敛 / 停滞对照(seed 42 实测):

配置gbest.fstallIterations观察
默认 w=0.72≈8.10623快速收敛,最后 3 帧无改进
低惯性 w=0.3≈8.106260第 40 次迭代后 gbest 就不再改进(过早停滞)
弱认知+弱社会 c1=c2=0.5≈8.10620100 次迭代结束时仍在改进(收敛慢,接近「迭代上限」)

注意 peaks 对 PSO 而言较容易:在上述参数范围内三组固定种子的运行都到达同一高值区域(徽章多为「收敛」)。「停滞」「达到迭代上限」两种状态用于诊断更难的问题或更差的参数组合。粒子群优化是群体智能启发式:结果是近似解、依赖随机种子,需多次运行统计,不保证严格全局最优。

代码实践 ​

完整代码 ​

下面的代码与仓库 examples/pso.py 逐字一致,可用 python examples/pso.py 直接运行。脚本用独立网格搜索给出参考最优,复现默认参数与多 seed 的结果,并用 assert 与前端 TS 测试的钉死值交叉核对(不一致即非零退出)。

py
# -*- coding: utf-8 -*-
"""粒子群优化(PSO,最大化)—— MathModel FAQ 可运行算例。

目标函数(搜索域 [−3, 3]²,最大化)为 MathWorks peaks 函数:

    f(x,y) = 3(1−x)²·e^(−x²−(y+1)²) − 10(x/5 − x³ − y⁵)·e^(−x²−y²)
             − (1/3)·e^(−(x+1)²−y²)

这是一个多峰函数:在 [−3,3]² 内高值基准约为 8.1062(位于
(x,y) ≈ (−0.009, 1.581)),以及若干局部极大与一个深谷(约 −6.55)。
粒子群优化的更新公式(每维独立):

    v_d ← w·v_d + c1·r1·(pbest_d − x_d) + c2·r2·(gbest_d − x_d)
    x_d ← x_d + v_d

其中 r1、r2 为每迭代、每维独立抽取的 U(0,1);速度分量裁剪到 [−vmax, vmax],
vmax = 0.2·(b − a);位置越界时裁剪到边界并把该维速度置零。

随机数:mulberry32(seed),与前端 TS 引擎 docs/.vitepress/theme/math/pso.ts
逐位一致(32 位无符号运算,返回 [0,1) 的 IEEE 754 双精度浮点数)。同一 seed
得到逐位相同的轨迹,不同 seed 轨迹不同。参考最优值由独立网格搜索(200×200,
步长 0.03)给出,与 PSO 代码路径无关。

运行方式(本机实测:Python 3.14.8 + numpy 2.5.3 + matplotlib 3.11.2):
    python examples/pso.py

输出:控制台数值表 + docs/public/examples/pso-demo.png(matplotlib contour
等高线为真实函数值;注意与 Web 组件 PsoAnimation.vue 中的「网格色块近似」不同,
后者只是函数值的分块近似,粒子仍按真实 f 计算)。
"""
import math
import sys
from pathlib import Path

import matplotlib
# Agg 保存网页 PNG,无需图形桌面。NumPy 用于地形采样,随机流由下文的生成器提供。
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np

plt.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei']
plt.rcParams['axes.unicode_minus'] = False

ROOT = Path(__file__).resolve().parent.parent
OUT_DIR = ROOT / 'docs' / 'public' / 'examples'

BOUNDS = (-3.0, 3.0)

# 与前端 TS 测试钉死值一致(本机实测 Python 3.14.8;来源见 tests/pso.test.ts
# 与下文独立 200×200 网格搜索)。
SEED42_GBEST_X = -0.009317061786476257
SEED42_GBEST_Y = 1.5813688321287818
SEED42_GBEST_F = 8.106213589428114
SEED42_STALL = 3
GRID_F = 8.10434082784975


def mulberry32(seed):
    """mulberry32 确定性 PRNG;与前端 TS 实现逐位一致。"""
    state = seed & 0xFFFFFFFF

    def next_float():
        nonlocal state
        state = (state + 0x6D2B79F5) & 0xFFFFFFFF
        # t = Math.imul(a ^ (a >>> 15), 1 | a)
        t = ((state ^ (state >> 15)) & 0xFFFFFFFF) * (state | 1) & 0xFFFFFFFF
        # t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
        u = (t ^ (t >> 7)) & 0xFFFFFFFF
        w = u * (t | 61) & 0xFFFFFFFF
        t = (((t + w) & 0xFFFFFFFF) ^ t) & 0xFFFFFFFF
        # return ((t ^ (t >>> 14)) >>> 0) / 4294967296
        return ((t ^ (t >> 14)) & 0xFFFFFFFF) / 4294967296.0

    return next_float


def peaks(x, y):
    """目标函数(最大化):MathWorks peaks。乘号显式展开,保证与 TS 逐位一致。"""
    x2 = x * x
    y2 = y * y
    y1 = y + 1.0
    x1 = x + 1.0
    omx = 1.0 - x
    return (
        3.0 * omx * omx * math.exp(-x2 - y1 * y1)
        - 10.0 * (x / 5.0 - x * x * x - y * y * y * y * y) * math.exp(-x2 - y2)
        - (1.0 / 3.0) * math.exp(-x1 * x1 - y2)
    )


def run_pso(particles, iterations, w, c1, c2, bounds, seed, objective=peaks):
    """粒子群优化(最大化)。返回 {trajectory, gbest, stall_iterations}。

    trajectory 为 iterations+1 个 {iteration, positions, pbest, gbest} 帧,
    与 TS 引擎逐字段对应。随机数调用顺序(与 TS 完全一致,保证逐位一致):
      初始化:对每个粒子依次抽 4 次 —— x、y、vx、vy。
      每迭代:对每个粒子依次抽 4 次 —— r1x、r2x、r1y、r2y。
    """
    a, b = bounds
    rng = mulberry32(seed)
    # 每坐标最大速度为区间宽度的 20%,限制单步移动距离。
    vmax = 0.2 * (b - a)
    span = b - a

    positions = []  # 每个粒子 [x, y, vx, vy, f]
    pbests = []     # 每个粒子个体最优 [x, y, f]
    for _ in range(particles):
        x = a + rng() * span
        y = a + rng() * span
        vx = (rng() * 2.0 - 1.0) * vmax
        vy = (rng() * 2.0 - 1.0) * vmax
        f = objective(x, y)
        positions.append([x, y, vx, vy, f])
        pbests.append([x, y, f])

    # 扫描初始群体,记录第一次位置更新前的全局最优。
    gbest = [positions[0][0], positions[0][1], positions[0][4]]
    for p in positions:
        if p[4] > gbest[2]:
            gbest = [p[0], p[1], p[4]]

    # 复制当前位置和个体记忆,后续就地更新不会修改已记录的动画帧。
    def snapshot(iteration):
        return {
            'iteration': iteration,
            'positions': [list(p) for p in positions],
            'pbest': [list(b) for b in pbests],
            'gbest': list(gbest),
        }

    trajectory = [snapshot(0)]
    last_improve = 0

    # 网页采用逐粒子更新:某粒子刷新 gbest 后,同代的下一粒子即用新 gbest。
    for iteration in range(1, iterations + 1):
        for i in range(particles):
            p = positions[i]
            pb = pbests[i]

            # 惯性保留原方向,个体和群体项把坐标向相应历史最优点拉动。两轴独立抽样。
            r1x = rng()
            r2x = rng()
            vx = w * p[2] + c1 * r1x * (pb[0] - p[0]) + c2 * r2x * (gbest[0] - p[0])
            vx = min(max(vx, -vmax), vmax)

            r1y = rng()
            r2y = rng()
            vy = w * p[3] + c1 * r1y * (pb[1] - p[1]) + c2 * r2y * (gbest[1] - p[1])
            vy = min(max(vy, -vmax), vmax)

            x = p[0] + vx
            y = p[1] + vy
            # 越界:裁剪到边界并把该维速度置零。
            if x < a:
                x = a
                vx = 0.0
            elif x > b:
                x = b
                vx = 0.0
            if y < a:
                y = a
                vy = 0.0
            elif y > b:
                y = b
                vy = 0.0

            f = objective(x, y)
            p[0] = x
            p[1] = y
            p[2] = vx
            p[3] = vy
            p[4] = f

            # 只在严格提高时更新记忆,last_improve 记群体最近一次提升的迭代号。
            if f > pb[2]:
                pb[0] = x
                pb[1] = y
                pb[2] = f
            if f > gbest[2]:
                gbest = [x, y, f]
                last_improve = iteration

        trajectory.append(snapshot(iteration))

    return {
        'trajectory': trajectory,
        'gbest': {'x': gbest[0], 'y': gbest[1], 'f': gbest[2]},
        'stall_iterations': iterations - last_improve,
    }


def grid_search(bounds=BOUNDS, divisions=200):
    """独立网格搜索参考最优值(200×200,步长 0.03),与 PSO 代码路径无关。"""
    a, b = bounds
    best = {'x': a, 'y': a, 'f': peaks(a, a)}
    # divisions 为每轴等分数,含两个端点,因此每轴有 divisions+1 个采样位置。
    for i in range(divisions + 1):
        x = a + (b - a) * i / divisions
        for j in range(divisions + 1):
            y = a + (b - a) * j / divisions
            f = peaks(x, y)
            if f > best['f']:
                best = {'x': x, 'y': y, 'f': f}
    return best


def run_default():
    print('== 默认参数(seed 42,20 粒子,100 迭代,w=0.72,c1=c2=1.49)==')
    result = run_pso(20, 100, 0.72, 1.49, 1.49, BOUNDS, 42)
    gbest = result['gbest']
    print(f'  gbest.x = {gbest["x"]:.15f}')
    print(f'  gbest.y = {gbest["y"]:.15f}')
    print(f'  gbest.f = {gbest["f"]:.15f}')
    print(f'  stallIterations = {result["stall_iterations"]}')
    return result


def run_seeds():
    print('== 不同 seed 对比(同一默认参数,轨迹不同)==')
    rows = []
    for seed in (42, 7, 123):
        result = run_pso(20, 100, 0.72, 1.49, 1.49, BOUNDS, seed)
        gbest = result['gbest']
        print(f'  seed={seed}: gbest.x={gbest["x"]:.12f}, gbest.y={gbest["y"]:.12f}, '
              f'gbest.f={gbest["f"]:.12f}, stall={result["stall_iterations"]}')
        rows.append((seed, result))
    return rows


def make_figure(default_result, seed_rows, grid):
    OUT_DIR.mkdir(parents=True, exist_ok=True)
    a, b = BOUNDS
    xs = np.linspace(a, b, 400)
    ys = np.linspace(a, b, 400)
    X, Y = np.meshgrid(xs, ys)
    # Z 第 j 行、第 i 列是 (xs[i],ys[j]) 的目标,与坐标网格逐点对应。
    Z = np.array([[peaks(float(x), float(y)) for x in xs] for y in ys])

    fig, axes = plt.subplots(1, 2, figsize=(12.5, 5.6), dpi=110)

    ax = axes[0]
    cs = ax.contourf(X, Y, Z, levels=24, cmap='viridis')
    ax.contour(X, Y, Z, levels=24, colors='white', linewidths=0.3, alpha=0.5)
    fig.colorbar(cs, ax=ax, label='f(x, y)(真实函数值)')

    # 同一地形叠放初始与最终坐标以及每轮历史最优坐标。
    traj = default_result['trajectory']
    gx = [frame['gbest'][0] for frame in traj]
    gy = [frame['gbest'][1] for frame in traj]
    ax.plot(gx, gy, color='#c0392b', lw=1.6, zorder=4, label='gbest 轨迹')
    init_pos = traj[0]['positions']
    final_pos = traj[-1]['positions']
    ax.scatter([p[0] for p in init_pos], [p[1] for p in init_pos], s=14,
               color='#555555', zorder=3, label='初始粒子')
    ax.scatter([p[0] for p in final_pos], [p[1] for p in final_pos], s=22,
               facecolors='none', edgecolors='#1f8a4c', linewidths=0.8, zorder=4,
               label='最终粒子')
    g = default_result['gbest']
    ax.scatter([g['x']], [g['y']], marker='*', s=260, color='#e0a020', zorder=5,
               label=f"gbest f={g['f']:.3f}")
    ax.scatter([grid['x']], [grid['y']], marker='x', s=70, color='white', zorder=5,
               label=f'网格最优 f={grid["f"]:.3f}')
    ax.set_xlim(a, b)
    ax.set_ylim(a, b)
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_title('peaks 等高线 + 粒子轨迹(seed 42)')
    ax.legend(frameon=False, fontsize=8, loc='upper left')

    ax = axes[1]
    # 右图只改变随机种子,历史最优曲线的水平段代表连续多步未改进。
    for seed, result in seed_rows:
        traj = result['trajectory']
        bests = [frame['gbest'][2] for frame in traj]
        ax.plot(range(len(traj)), bests, lw=1.6, label=f'seed={seed}')
    ax.axhline(grid['f'], color='#b07d2b', lw=1, ls='--',
               label=f'网格最优 {grid["f"]:.4f}')
    ax.set_xlabel('迭代次数')
    ax.set_ylabel('gbest.f(群体最优)')
    ax.set_title('收敛曲线 gbest.f vs 迭代')
    ax.grid(alpha=0.25)
    ax.legend(frameon=False, fontsize=8)

    fig.tight_layout()
    fig.savefig(OUT_DIR / 'pso-demo.png')
    plt.close(fig)
    print(f'== 绘图已保存到 {OUT_DIR / "pso-demo.png"} ==')


def main() -> None:
    print('== 环境 ==')
    print(f'  Python {sys.version.split()[0]}')
    print(f'  numpy {np.__version__}, matplotlib {matplotlib.__version__}')
    grid = grid_search()
    print('== 独立网格搜索(200×200,步长 0.03)==')
    print(f'  网格最优 x = {grid["x"]:.15f}')
    print(f'  网格最优 y = {grid["y"]:.15f}')
    print(f'  网格最优 f = {grid["f"]:.15f}')
    print('  (注:peaks 本例高值基准约 8.1062,位于 ≈(−0.009, 1.581),网格分辨率 0.03 只能逼近)')
    default_result = run_default()
    seed_rows = run_seeds()
    make_figure(default_result, seed_rows, grid)

    # —— 与前端 TS 测试钉死值交叉核对(容差 1e-9;stall 为整数应精确相等)——
    print('== 与 TS 测试钉死值交叉核对 ==')
    g = default_result['gbest']
    assert abs(g['x'] - SEED42_GBEST_X) < 1e-9, 'gbest.x 与 TS 钉死值不一致'
    assert abs(g['y'] - SEED42_GBEST_Y) < 1e-9, 'gbest.y 与 TS 钉死值不一致'
    assert abs(g['f'] - SEED42_GBEST_F) < 1e-9, 'gbest.f 与 TS 钉死值不一致'
    assert default_result['stall_iterations'] == SEED42_STALL, 'stallIterations 与 TS 钉死值不一致'
    assert abs(grid['f'] - GRID_F) < 1e-9, '网格最优 f 与 TS 钉死值不一致'
    print('  全部交叉核对通过')
    print('== 全部断言通过 ==')


if __name__ == '__main__':
    main()

运行方式 ​

bash
cd mathmodel-faq
pip install -r examples/requirements.txt   # numpy / matplotlib(本算例仅用这两个)
python examples/pso.py

依赖列表见仓库 examples/requirements.txt(本算例只用 numpy 与 matplotlib)。本机实测环境:Python 3.14.8、numpy 2.5.3、matplotlib 3.11.2。脚本不联网、不用付费 API;任何一条断言失败都会以非零退出码退出。

输出结果(本机实际运行) ​

text
== 环境 ==
  Python 3.14.8
  numpy 2.5.3, matplotlib 3.11.2
== 独立网格搜索(200×200,步长 0.03)==
  网格最优 x = 0.000000000000000
  网格最优 y = 1.590000000000000
  网格最优 f = 8.104340827849750
  (注:peaks 本例高值基准约 8.1062,位于 ≈(−0.009, 1.581),网格分辨率 0.03 只能逼近)
== 默认参数(seed 42,20 粒子,100 迭代,w=0.72,c1=c2=1.49)==
  gbest.x = -0.009317061786476
  gbest.y = 1.581368832128782
  gbest.f = 8.106213589428114
  stallIterations = 3
== 不同 seed 对比(同一默认参数,轨迹不同)==
  seed=42: gbest.x=-0.009317061786, gbest.y=1.581368832129, gbest.f=8.106213589428, stall=3
  seed=7: gbest.x=-0.009317939600, gbest.y=1.581367683280, gbest.f=8.106213589440, stall=14
  seed=123: gbest.x=-0.009317730591, gbest.y=1.581367741332, gbest.f=8.106213589441, stall=2
== 绘图已保存到 …docs\public\examples\pso-demo.png ==
== 与 TS 测试钉死值交叉核对 ==
  全部交叉核对通过
== 全部断言通过 ==

结果图 ​

粒子群优化:peaks 等高线 + 粒子轨迹(左)与 gbest 收敛曲线(右)

左图为 matplotlib contourf/contour 的真实等高线(函数值的精确表示),与 Web 组件 PsoAnimation.vue 中的「网格色块近似」不同;右图为 gbest.f 随迭代的收敛曲线,虚线是 200×200 网格搜索的参考最优。

关键参数 ​

参数含义本算例取值与效果
w(惯性权重)保留旧速度的比例0.72 快速收敛;降到 0.3 过早停滞
c1(个体认知)向 pbest 靠拢的力度1.49 与 c2 平衡;降到 0.5 收敛变慢
c2(社会认知)向 gbest 靠拢的力度1.49 与 c1 平衡;降到 0.5 收敛变慢
粒子数种群规模默认 20 个粒子、100 次迭代。比较不同随机种子的最优值与停滞情况
vmax速度上限0.2(b−a)=1.2,防止发散
seed随机种子42 / 7 / 123 得到不同轨迹、相同的最优

常见错误 ​

  • 无边界处理:速度更新可能把粒子推出可行域,若不裁剪/反弹,目标函数可能在定义域外无意义或发散。务必显式处理越界(优化算法无法收敛怎么办)。
  • 单次运行当结论:PSO 是随机启发式,单次 gbest 只是随机变量的一个实现。应多 seed 统计分布,并与独立基准(网格搜索/枚举)核对(多次运行得到不同结果怎么办)。
  • 随机不设种子:不固定 seed 时每次轨迹不同、结果不可复现。固定 seed 并记录进报告(代码能够运行,但结果无法复现怎么办)。
  • 参数随意:w 太小过早停滞、c1/c2 失衡失去多样性、vmax 过大发散。应从默认值出发,观察收敛曲线调参。
  • 把近似当最优:PSO 没有全局最优保证,只能说「近似最优」,不要宣称「证明了全局最优」。

专业速查 ​

假设 ​

假设说明
变量连续位置在连续空间内更新;离散问题需先设计编码
可行域为盒约束每维一个区间 [a,b],越界可显式处理
目标可评估每个粒子每代都要计算 f,且评估代价可接受
群体多样性足够初始粒子尽量覆盖搜索域,避免一开始就抱团
随机源可复现用确定性 PRNG(固定 seed)便于复现

参数 ​

参数建议
粒子数10–50 常见;维数越高、问题越难越需要更多
w0.4–0.9;常用线性衰减(0.9 → 0.4)平衡探索与开发
c1,c2常取 c1=c2≈1.49;也可用 c1=c2=2 或 Clerc 收缩系数
vmax取搜索域宽度的一个比例(如 10%–20%),防发散
停止条件固定迭代次数,或 gbest 连续多代无改进(停滞)

复杂度与优缺点 ​

维度内容
时间复杂度O(particles×iterations×每次评估代价)
空间复杂度只存当前种群为 O(particles×d);保留全轨迹为 O(particles×iterations)
优点实现简单、天然并行、几乎不依赖目标光滑性、收敛快
缺点无全局最优保证、易过早停滞、对参数敏感、离散/约束问题需额外处理

指标 ​

指标说明
gbest.f群体历史最优目标值,是最终交付的「解」
gbest.x / gbest.y最优解的位置(本页二维)
stallIterations自最后一次 gbest 改进以来的迭代数,越大越接近停滞
收敛曲线gbest.f vs 迭代,观察是否还在改进
多次运行分布多 seed 的 gbest.f 均值/最差,衡量稳定性

高频问题(FAQ) ​

问题回答
PSO 和模拟退火有什么区别?机制不同:SA 靠接受劣解跳出局部最优,PSO 靠群体记忆 + 惯性飞行;PSO 天然并行
w、c1、c2 怎么选?从 w=0.72、c1=c2=1.49 出发,观察收敛曲线;w 小易停滞,c1/c2 失衡易失多样性
PSO 一定能找到全局最优吗?不能保证;可能过早停滞或迭代不足,只能给近似解
最小化问题怎么用?对目标取负(或把比较符号反过来)
粒子飞出边界怎么办?必须显式处理:裁剪到边界并把速度置零(或反弹)
为什么结果每次不一样?r1,r2 是随机的;固定 seed 才能复现,多 seed 才能评估稳定性

双语言实验 ​

沿用上面 peaks 的有界最大化问题。这组程序用 12 个粒子运行 60 次更新,固定初始位置、随机系数生成规则和初始速度(全零),只比较惯性权重 w=0.72 与 0.3。每代粒子都读取上一代的同一个群体最优位置,移动完成后统一更新记忆。上方网页演示与原 Python 完整算例采用粒子顺次更新。比较轨迹时要对齐更新时序和随机数流。

从位置差理解群体收缩 ​

如果粒子正好位于它的个人最优点,认知项为零。这包括初始时刻,所以第一轮都只受社会项作用。只要它与群体历史最佳点还有距离,社会项就会拉动它。上一轮留下的速度通过 w 影响后面的方向和幅度。用粒子质心 x¯(t) 和平均距离定义一个观察量

Rt=1N∑i=1N‖xi(t)−x¯(t)‖2.

Rt 小表示粒子聚拢,对目标值的判断还要看历史记录。左图显示初始、最终粒子位置和群体最优路径,右图的实线是历史最佳目标值,虚线是粒子半径。若一个速度分量会导致越界,程序把该坐标裁剪到边界,并将该分量清零。

运行原理实现 ​

下载 Python 源码 · 下载 MATLAB 源码

  • Python 环境安装 python -m pip install numpy matplotlib 后,在下载目录运行 python mmf_pso.py。
  • MATLAB 在下载目录运行 result = mmf_pso(),使用基础 MATLAB 的 peaks、yyaxis 和隐式扩展,建议 R2016b 或更新版本,无需工具箱。

固定两个粒子的初始位置、速度与两轮随机系数,逐步使用惯性、个体最优和全局最优三项。最佳位置记忆到达 2,目标值为 0,粒子的最终位置与历史最好点可以不同。

最简版依赖 Python:NumPy。MATLAB:基础功能,无需额外工具箱。

在源码所在目录运行 python mmf_min_pso.py

py
import json
import numpy as np

x = np.array([0., 4.])
velocity = np.array([1., 0.])
personal = x.copy()
objective = lambda values: (values - 2) ** 2
global_best = personal[np.argmin(objective(personal))]
history = [float(global_best)]
# 两轮同步更新;用约定的 r1、r2 演示速度公式,便于手算与复核。
for r1, r2 in [(.5, .5), (.5, .5)]:
    velocity = .5 * velocity + r1 * (personal - x) + r2 * (global_best - x)
    x = x + velocity
    better = objective(x) < objective(personal)
    personal[better] = x[better]
    global_best = personal[np.argmin(objective(personal))]
    history.append(float(global_best))
best_value = float(objective(global_best))
assert np.allclose(history, [0, 2, 2]) and best_value == 0
result = {"best_positions": history, "final_positions": x.tolist(), "best_value": best_value}
print("LAB_RESULT " + json.dumps(result, ensure_ascii=False))
下载当前源码

两种语言都用同一整数递推产生均匀系数。Python 按行重排数组,MATLAB 在列优先的 reshape 后转置,得到相同的“每粒子一行、每坐标一列”。Python 用 np.clip 限制速度和位置,MATLAB 用 min(max(...))。比较初始目标、历史最佳曲线、最终半径和越界分量计数。有限网格参考值约 8.104341,两个连续搜索最终都达到约 8.106214。连续搜索超过有限网格采样值是正常现象。接近峰顶时,若几个值在浮点精度内相近,末位坐标可能略有差异。MATLAB 的生产接口 particleswarm 需要 Global Optimization Toolbox,调用时最小化 −f 可对应本页最大化问题,默认群体邻域、参数和停止条件会改变轨迹。 MathWorks peaks · MathWorks particleswarm

参数练习 ​

看两个权重的第一步是否相同。到第 60 步时,对比它们的历史最佳值与半径。能否仅凭粒子非常聚拢,就判断它找到了全局最优?

参考答案

两组第一步相同,因为此时惯性速度是零。权重 0.3 的群体后期更紧,最终半径约为 3×10−9,而 0.72 的结果约为 4.9×10−3,两条历史最佳曲线都达到了约 8.106214。半径说的是位置分散程度,必须结合目标值和独立参照来读。要进一步比较稳定性,可以再换若干相同的种子,并记录多少次到达同一高值区。

关联文章 ​

MathModel FAQ · 数学建模知识库