PSO-SVR超参数调优实战：粒子群搜索、K折交叉验证与对比实验

简介：面向机器学习回归建模学习者与算法实践者，这份资料围绕粒子群优化支持向量回归（PSO-SVR）展开，重点演示用群体智能搜索惩罚因子与核参数，并与常规支持向量回归进行拟合效果对比，适合作为参数寻优、核方法应用与非线性预测实验的参考案例。压缩包共64个文件，约941KB，涵盖Java、Python、C与C++源码，以及MATLAB脚本、编译工具链和说明文档，并附带数据文件与可执行组件，便于跨语言查看实现和直接运行实验。已有220人学习下载。资料内提供粒子群主流程、支持向量回归脚本、libsvm相关组件与使用说明，可帮助读者复现参数寻优过程，观察粒子群优化与网格搜索等传统方式在收敛效率、局部最优和泛化表现上的差异，并据此调整粒子数量、惯性权重等参数，积累调参与排错经验。

1. 参数调不对，SVR 就是个玄学盒子

同一个回归数据集，SVR 的C从 1 改成 1000、gamma从scale改成 0.01，测试集 R² 能从 0.62 掉到 0.31，而中间没有任何报错。做过支持向量机回归的人大概都撞过这堵墙：模型本身没坏，坏的是超参搜索。PSO-SVR 干的事情很直接——用粒子群算法（PSO）在(C, gamma, epsilon)的连续空间里替你找一组像样的组合，再把结果和默认参数的 SVR、网格搜索的 SVR 摆在一起对比，让你看清「调参到底值不值这几个小时」。这套代码适合两类人：一类是手里有一批几百到几万行的回归数据、想快速拿到一个能交付的基线模型；另一类是想把群智能算法真正跑通一遍、而不是只停留在公式推导上的开发者。它不解决数据本身的问题，但能把「参数靠猜」这件事变成一个可复现的搜索过程。

2. 工程骨架与数据流：一份 PSO-SVR 代码应该长什么样

拿到「粒子群优化支持向量机」这个题目，很多人的第一反应是打开一个 notebook，从上往下写两百行，最后连自己都记不清最优参数是从哪一轮冒出来的。这类项目真正的价值不在算法本身，而在工程结构：搜索空间怎么配置、适应度怎么算、最优解怎么落盘、对比实验怎么保证口径一致。下面按我实际拆过的组织方式来。

2.1 目录结构与模块职责

算法项目最容易塌的地方是「训练脚本和实验脚本糊在一起」。一旦你换了份数据，想复现上一版的结果就得靠翻历史记录。我一般会按职责切成五块：搜索器、适应度、模型封装、对比实验、可视化，各管一件事，互相只通过参数和返回值打交道。

pso-svr/ ├── configs/ │ └── search_space.yaml # 搜索上下界、粒子数、迭代代数 ├── data/ │ └── raw/regression.csv # 原始回归数据，特征列 + 目标列 ├── src/ │ ├── pso.py # 粒子群内核，不依赖 sklearn │ ├── fitness.py # 解码超参 + K 折交叉验证打分 │ ├── model.py # SVR 训练/预测/评估的统一封装 │ ├── compare.py # 默认 SVR / GridSearch / PSO-SVR 三方对比 │ └── viz.py # 收敛曲线、预测-真实散点、残差图 ├── outputs/ │ ├── best_params.json # 最优超参，带时间戳 │ ├── metrics.csv # 三组模型的指标明细 │ └── convergence.png ├── run.py # 唯一入口，串起全流程 └── requirements.txt

src/pso.py刻意不 import sklearn，好处是这部分可以单独拿去做函数极值测试，比如用 Sphere、Rastrigin 这类标准函数验证搜索器本身没写错。踩过的坑是：如果一开始就把 PSO 和 SVR 耦合成一个类，后面想换核函数（rbf换poly）就得动搜索器代码，越改越乱。

configs/search_space.yaml这个文件值得单独说。搜索上下界不该硬编码在 Python 里，原因很实在——不同数据集的gamma合理区间能差两个数量级，特征维度从 5 维到 200 维，gamma的最优值会跟着量级走。把边界外置成配置，换数据集时只改 YAML，不用碰代码逻辑：

# configs/search_space.yaml pso: n_particles: 20 # 粒子数，20~30 是性价比区间 max_iter: 60 # 迭代代数，配合早停用 w: 0.729 # 惯性权重 c1: 1.494 # 个体学习因子 c2: 1.494 # 社会学习因子 v_ratio: 0.2 # 速度上限 = 0.2 * 搜索范围 seed: 42 search_space: C: {low: -1.0, high: 4.0} # log10 空间，即 0.1 ~ 10000 gamma: {low: -4.0, high: 1.0} # log10 空间，即 1e-4 ~ 10 epsilon:{low: -3.0, high: 0.0} # log10 空间，即 0.001 ~ 1

注意这里的low/high是 log10 的指数，不是真实超参值。这一点后面 3.1 会展开——直接在原始尺度上均匀撒粒子，C的采样会严重偏向大值区间，这是很多人第一次写 PSO-SVR 就翻车的地方。

outputs/best_params.json里除了三个超参，我还会顺手记seed、n_particles、max_iter、data_hash和时间戳。别嫌麻烦，两周后你想复现某个 R²=0.87 的结果，靠的就是这几个字段，没有它们就只剩玄学了。

2.2 技术栈与依赖：为什么要自己写 PSO 而不是装包

技术栈很薄：numpy负责粒子矩阵运算，scikit-learn提供SVR、KFold、GridSearchCV、StandardScaler和评估指标，matplotlib画图，pyyaml读配置。就这四个，版本要求也不苛刻，scikit-learn >= 1.0即可，cross_val_score的scoring参数口径在 1.0 之后稳定下来了。

不用pyswarm、scikit-opt这类现成的群智能库，理由有三条，都是实打实的：

第一，pyswarm的接口是pso(func, lb, ub, ...)，它对约束和边界的处理比较固定，而且返回的只有最优解和最优值，拿不到逐代收敛历史。做对比实验时收敛曲线是刚需——你需要向别人证明「PSO 确实在收敛」而不是「跑完就出了一个数」。

第二，这个项目的搜索维度只有 3，粒子数 20，迭代 60 代，总评估次数 1200 次，每次评估是 5 折交叉验证的 SVR 训练。真正的开销在适应度函数里，不在 PSO 本身。自己写 60 行 numpy，性能上完全不是瓶颈，反而能加早停、加停滞判定、加日志。

第三，也是最重要的一点，自己写的搜索器便于二次开发。后面想做「混合搜索」——先用网格粗搜定位区域，再用 PSO 精搜——现成库反而会挡住你。

依赖装好后的最小验证命令：

pip install numpy scikit-learn matplotlib pyyaml python -c "import sklearn; print(sklearn.__version__)"

make_regression可以用来造合成数据快速验证链路通不通，它的n_samples、n_features、noise三个参数足够模拟出不同难度的问题：

from sklearn.datasets import make_regression # n_features 建议 >= 5，noise 控制在 10~30，否则 SVR 之间的差距会被噪声淹没 X, y = make_regression(n_samples=800, n_features=8, noise=15.0, random_state=42)

这里有个经验：noise设得太小（比如 0.1），所有模型 R² 都能到 0.99，PSO 优化带来的差距被抹平，对比实验失去意义；设得太大（比如 60），R² 全部趴在 0.3 附近，看不出谁好谁坏。10 到 30 是能让模型之间拉开身位的区间。

2.3 数据预处理与划分：先把尺子校准再谈优化

SVR 是基于距离的模型，核函数里直接算样本间的欧氏距离，所以特征尺度的影响是致命的。一个取值范围 0 到 1 的特征，和一个取值范围 0 到 100000 的特征放在一起，后者会完全主导核矩阵。gamma='scale'只是按1/(n_features * X.var())给了个默认值，它救不了量纲差异。

正确顺序只有一个：先切分，再对训练集fit，最后transform测试集。

from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler # 切分在前，防止测试集的均值方差泄露进训练过程 X_tr, X_te, y_tr, y_te = train_test_split( X, y, test_size=0.2, random_state=42 ) scaler = StandardScaler().fit(X_tr) # 只在训练集上 fit X_tr_s = scaler.transform(X_tr) X_te_s = scaler.transform(X_te)

test_size=0.2是常规选择，样本量小于 500 时我会改成 0.25 或者干脆用KFold做外层评估。random_state=42一定要固定，否则每次跑出来的对比表都不一样，没法写进报告。

目标值y要不要标准化？很多人忽略这一点。SVR的epsilon参数定义的是「容忍带宽度」，它的单位和y完全一致。如果你的y量级是 1e4，而epsilon用默认的 0.1，那容忍带几乎为零，模型会拼命拟合每一个点，直接过拟合；反过来y量级是 0.01，epsilon=0.1意味着所有点都落在容忍带里，模型学不到东西。

我的做法是：y也做标准化，训练完再inverse_transform回去。这样epsilon的搜索空间可以稳定在1e-3 ~ 1这个和量纲无关的区间，搜索空间配置一次就能复用到不同数据集上。代价是预测结果要反变换，多两行代码，但省掉了一堆「换个数据集就得重新调搜索边界」的麻烦。

还有一个容易忽略的点：特征里如果有类别列或者缺失值，StandardScaler会直接抛错或者静默传nan。回归数据里缺失值填充用中位数比均值稳，因为 SVR 对异常值本来就敏感，均值填充会把异常值的影响扩散到整列。

3. PSO 内核拆解：粒子在 (C, gamma, epsilon) 三维空间里怎么飞

粒子群的核心就三行公式：速度继承一部分自己的惯性，向自己历史最优靠一点，向全局最优靠一点。但把它落到「优化 SVR 超参」这个具体场景，有三处必须做对：搜索空间的对数变换、适应度函数的交叉验证口径、边界和停滞的处理。这三处错任何一处，跑出来的最优参数都是废的。

3.1 粒子类与速度更新公式落地

先看搜索器的完整实现。注意run()里的顺序：先更新速度、再钳制速度、再更新位置、再处理越界，最后才评估适应度。顺序乱了会出现「粒子飞出去了还在算适应度」的情况。

# src/pso.py import numpy as np class PSO: def __init__(self, fitness, bounds, n_particles=20, max_iter=60, w=0.729, c1=1.494, c2=1.494, v_ratio=0.2, seed=42): self.fitness = fitness # 适应度函数，输入一个粒子位置，返回标量 self.lb = np.array([b[0] for b in bounds], dtype=float) self.ub = np.array([b[1] for b in bounds], dtype=float) self.dim = len(bounds) self.n_particles = n_particles self.max_iter = max_iter self.w, self.c1, self.c2 = w, c1, c2 self.v_max = v_ratio * (self.ub - self.lb) # 速度上限与维度范围挂钩 self.rng = np.random.default_rng(seed) def run(self): # 1) 初始化：位置在上下界内均匀采样，速度取范围的一小段 X = self.rng.uniform(self.lb, self.ub, size=(self.n_particles, self.dim)) V = self.rng.uniform(-self.v_max, self.v_max, size=(self.n_particles, self.dim)) pbest = X.copy() pbest_val = np.array([self.fitness(x) for x in X]) g_idx = int(np.argmin(pbest_val)) gbest, gbest_val = pbest[g_idx].copy(), float(pbest_val[g_idx]) history = [gbest_val] for it in range(self.max_iter): r1 = self.rng.random((self.n_particles, self.dim)) r2 = self.rng.random((self.n_particles, self.dim)) # 2) 速度更新：惯性 + 认知项 + 社会项 V = (self.w * V + self.c1 * r1 * (pbest - X) + self.c2 * r2 * (gbest - X)) V = np.clip(V, -self.v_max, self.v_max) # 速度钳制，防止一步飞出搜索域 # 3) 位置更新 + 越界反弹 X = X + V X = np.where(X < self.lb, self.lb + (self.lb - X), X) X = np.where(X > self.ub, self.ub - (X - self.ub), X) X = np.clip(X, self.lb, self.ub) # 4) 评估并更新个体最优 / 全局最优 vals = np.array([self.fitness(x) for x in X]) better = vals < pbest_val pbest[better] = X[better] pbest_val[better] = vals[better] if pbest_val.min() < gbest_val: g_idx = int(np.argmin(pbest_val)) gbest, gbest_val = pbest[g_idx].copy(), float(pbest_val[g_idx]) history.append(gbest_val) return gbest, gbest_val, history

几个参数的说法：

w=0.729、c1=c2=1.494这组数来自收缩因子（constriction factor）的经典取值，数学上能保证粒子速度收敛而不是发散。自己随手写w=0.9, c1=c2=2.0也能跑，但后期振荡明显，收敛曲线会来回抖。

n_particles=20对 3 维搜索空间是够的。维度越高粒子数要跟着涨，经验是20 + 5 * dim，但超过 50 收益递减，因为适应度函数里每次都是 5 折 SVR 训练，时间成本是线性的。

v_max我绑定了搜索范围的 20%。设太大粒子容易一步跨过最优区域再弹回来，设太小搜索像蜗牛爬。用比例而不是绝对值，是因为三个维度的范围宽度不一样，C跨 5 个数量级，gamma跨 5 个，epsilon只跨 3 个，统一比例才能让各维度步长协调。

越界处理用了镜像反弹而不是简单clip。clip的问题是把粒子贴在边界上，如果最优解恰好在边界外，一堆粒子会黏在墙角失去多样性。镜像反弹保留了一部分动量，实测收敛稳定性好一些。

3.2 适应度函数：必须用 K 折交叉验证的负 MSE

适应度函数是整个项目的心脏，也是新手最容易偷懒的地方。如果用训练集上的 MSE 当适应度，PSO 会毫不犹豫地把C推到上界、gamma推到上界——训练集误差趋近于 0，测试集直接崩盘。

# src/fitness.py import numpy as np from sklearn.svm import SVR from sklearn.model_selection import KFold, cross_val_score def decode(p): """把 log10 空间的粒子位置解码回真实超参""" C = 10.0 ** p[0] gamma = 10.0 ** p[1] epsilon = 10.0 ** p[2] return C, gamma, epsilon def make_fitness(X, y, cv=5, seed=42): kf = KFold(n_splits=cv, shuffle=True, random_state=seed) def fitness(p): C, gamma, epsilon = decode(p) model = SVR(kernel='rbf', C=C, gamma=gamma, epsilon=epsilon) # neg_mean_squared_error 是负值，取负还原成正的 MSE scores = cross_val_score(model, X, y, cv=kf, scoring='neg_mean_squared_error') return -scores.mean() return fitness

decode里的10.0 ** p就是对数空间变换。p[0]在[-1, 4]之间取值，映射出来的C在0.1到10000之间。如果不做这个变换，直接在[0.1, 10000]上均匀采样，95% 的粒子会落在 500 以上，而真实最优值很可能在 10 附近，搜索效率极低。

KFold(shuffle=True, random_state=seed)这个组合很关键。shuffle=True打乱顺序，避免数据本身有序（比如按时间排序）时每折分布不一致；random_state固定后，每一代粒子评估用的折划分是同一套，适应度之间才有可比性。如果不固定，第 3 代和第 4 代的最优值差异里混进了折划分的随机性，收敛曲线就失真了。

cv=5是精度和耗时的折中。样本量小于 300 时用 10 折更稳，但耗时翻倍；样本量上万时 3 折就够，因为单折本身已经很大。这里的总开销是n_particles × max_iter × cv次 SVR 训练，20 × 60 × 5 = 6000 次。用make_regression造 800 行 8 维的数据，单次 SVR 训练大概十几毫秒，整套跑完三五分钟，可以接受。

有一个隐藏细节：cross_val_score内部会克隆模型，不会污染传入的model对象，所以每次评估都是干净的新模型，这一点不用担心。

3.3 边界反弹、速度钳制与停滞判定

前面代码里已经有反弹和钳制，这里补一个搜索器层面的停滞判定。粒子群最典型的失败模式是「早熟」：跑到二三十代，20 个粒子的位置几乎重合，gbest_val连续十几代纹丝不动，你以为它在精修，其实它已经死了。

# 在 run() 的迭代循环里插入停滞检测 stagnant, patience = 0, 10 last_best = gbest_val for it in range(self.max_iter): # ... 省略速度、位置、评估部分 ... if last_best - gbest_val < 1e-6: # 改善量小于阈值就算停滞一代 stagnant += 1 else: stagnant, last_best = 0, gbest_val if stagnant >= patience: # 随机重置最差的 30% 粒子，保留最优个体 worst_idx = np.argsort(pbest_val)[-int(0.3 * self.n_particles):] X[worst_idx] = self.rng.uniform( self.lb, self.ub, size=(len(worst_idx), self.dim)) V[worst_idx] = 0.0 stagnant = 0

patience=10的意思是连续 10 代无改善就触发一次重启，重置最差的 30% 粒子。这个比例不能太大，重置一半以上等于把已经积累的搜索信息全扔了；也不能太小，1 到 2 个粒子对整体多样性贡献有限。1e-6这个阈值是针对 MSE 尺度定的，如果你的目标值量级很大（比如 MSE 本身就在 1e8 左右），阈值要相应放大到 1e-2 才有意义。

另一个可选项是惯性权重线性递减，从 0.9 降到 0.4，前期偏探索、后期偏开发：

self.w = 0.9 - 0.5 * (it / self.max_iter)

这招在维度高的时候效果明显，3 维场景下和固定权重的差距不大。我一般先用固定值跑一版当基线，发现收敛曲线抖动厉害再开递减，省得一开始就加复杂度。

4. 对照实验：PSO-SVR 与默认 SVR、网格搜索的三组数字

优化算法的价值只能靠对比体现，单独拿出一个 R²=0.86 说明不了任何问题——默认 SVR 可能也有 0.84。这一章把三个模型放在同一套数据划分、同一个评估函数下跑，指标口径完全一致，这样得出的差距才站得住。

4.1 SVR 训练与预测的统一封装

对比实验最怕口径不一致：一个模型在标准化前切分，另一个在标准化后切分；一个用训练集评估，另一个用测试集评估。所以先把「训练 + 预测 + 打分」封成一个函数，三个模型都走同一条路。

# src/model.py import time import numpy as np from sklearn.svm import SVR from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error def evaluate(name, model, X_tr, y_tr, X_te, y_te): """统一的训练-预测-评估入口，返回指标字典和预测值""" t0 = time.perf_counter() model.fit(X_tr, y_tr) y_pred = model.predict(X_te) elapsed = time.perf_counter() - t0 return { 'model': name, 'R2': r2_score(y_te, y_pred), 'RMSE': mean_squared_error(y_te, y_pred) ** 0.5, 'MAE': mean_absolute_error(y_te, y_pred), 'time_s': round(elapsed, 2), 'y_pred': y_pred, }

R2、RMSE、MAE三个指标一起看是有必要的。R² 衡量解释方差比例，但会随着数据本身的方差变化，跨数据集不可比；RMSE 对异常值敏感，能暴露少数点预测崩掉的情况；MAE 更稳健，反映整体偏差水平。三个指标同时好，模型才算真的稳。

time_s记录的是纯训练耗时，不包括 PSO 搜索的时间。对比表里我会单独加一列「总耗时（含调参）」，因为默认 SVR 不调参，零成本；网格搜索和 PSO 都要付出搜索代价。不公平的对比没有意义，读者关心的是「多花的这几分钟换来了多少精度」。

4.2 三组实验脚本与指标口径

# src/compare.py import numpy as np from sklearn.svm import SVR from sklearn.model_selection import GridSearchCV from src.pso import PSO from src.fitness import make_fitness, decode from src.model import evaluate def run_all(X_tr, y_tr, X_te, y_te, bounds, pso_cfg): results = [] # 组 1：默认参数 SVR，作为基线 results.append(evaluate( 'SVR-default', SVR(kernel='rbf'), X_tr, y_tr, X_te, y_te)) # 组 2：网格搜索，C 和 gamma 各取 5 个对数刻度，共 25 组 grid = { 'C': np.logspace(-1, 4, 5), 'gamma': np.logspace(-4, 1, 5), } gs = GridSearchCV(SVR(kernel='rbf'), grid, cv=5, scoring='neg_mean_squared_error', n_jobs=-1) results.append(evaluate( 'SVR-grid', gs, X_tr, y_tr, X_te, y_te)) # 组 3：PSO 搜索，适应度与网格搜索同为 5 折 CV 的 MSE fit = make_fitness(X_tr, y_tr, cv=5, seed=42) pso = PSO(fit, bounds, **pso_cfg) gbest, gbest_val, history = pso.run() C, gamma, epsilon = decode(gbest) results.append(evaluate( 'PSO-SVR', SVR(kernel='rbf', C=C, gamma=gamma, epsilon=epsilon), X_tr, y_tr, X_te, y_te)) results[-1].update({'C': C, 'gamma': gamma, 'epsilon': epsilon}) return results, history

n_jobs=-1让网格搜索吃满所有核心，25 组 × 5 折 = 125 次训练，几秒钟就完了。PSO 那边是串行的，因为粒子评估之间虽然独立，但写成并行会让代码复杂度上一个台阶，而 6000 次训练在几分钟内能跑完，暂时不值得优化。

关键的一致性保证：GridSearchCV和make_fitness的cv都是 5，scoring都是neg_mean_squared_error。如果一边用 MSE、一边用 MAE 做搜索准则，最后比测试集指标就没意义了——它们优化的根本不是同一个目标。

一组典型的输出长这样（合成数据，make_regression(800, 8, noise=15)，测试集 160 条）：

这组数字传递的信息比 R² 本身更重要：PSO 相比网格搜索只提升了 0.016 的 R²，代价是 44 倍的搜索时间。所以真正该问的问题不是「PSO 好不好」，而是「你的场景需不需要这最后一点精度」。离线建模、模型上线后要跑几个月的场景，这点提升值得；在线学习、每天重训的场景，网格搜索甚至默认参数就够了。

还有一点要提醒：PSO 搜出来的epsilon=0.062，而网格搜索根本没搜epsilon，用的是默认 0.1。如果把epsilon也加进网格，网格搜索的 R² 大概率能追到 0.855 以上，差距会进一步缩小。对比实验里「谁搜了哪些参数」必须写清楚，否则就是拿调过参的模型打没调参的模型。

4.3 收敛曲线与预测残差图怎么读

出图不是为了让报告好看，是为了验证「搜索过程本身是健康的」。

# src/viz.py import matplotlib.pyplot as plt def plot_all(history, y_te, y_pred, out_dir='outputs'): fig, axes = plt.subplots(1, 2, figsize=(11, 4)) # 左图：收敛曲线，纵轴是 5 折 CV 的 MSE axes[0].plot(range(len(history)), history, lw=1.5) axes[0].set_xlabel('iteration') axes[0].set_ylabel('5-fold CV MSE') axes[0].set_title('PSO convergence') # 右图：预测值 vs 真实值，越贴近对角线越好 axes[1].scatter(y_te, y_pred, s=14, alpha=0.7) lo = min(y_te.min(), y_pred.min()) hi = max(y_te.max(), y_pred.max()) axes[1].plot([lo, hi], [lo, hi], 'r--', lw=1) axes[1].set_xlabel('y_true') axes[1].set_ylabel('y_pred') axes[1].set_title('PSO-SVR prediction') fig.tight_layout() fig.savefig(f'{out_dir}/convergence.png', dpi=150)

收敛曲线看三件事。第一，前 10 代有没有明显下降，如果第 1 代就是平的，说明初始粒子全部落在最优点附近，搜索空间设窄了或者数据太简单。第二，中段有没有台阶式下降，台阶说明粒子在跳出局部最优，这是健康信号。第三，末段是否平稳，如果最后 5 代还在大幅波动，说明w太大或者v_max太宽，需要收一收。

散点图看两件事。点是否围绕对角线分布，如果系统性偏在一侧，说明模型有偏差，可能是epsilon太大导致预测被压缩向均值。有没有离群点，少数点偏离很远是正常的，但如果离群点占比超过 5%，要去查原始数据里是不是有异常值没处理——SVR 对这些点非常敏感，它们会拉动整个回归面。

中文标签在 matplotlib 里默认会显示成方块，要么设置plt.rcParams['font.sans-serif']，要么干脆像上面代码一样全用英文标签。做实验图的时候我发现英文标签更省事，也避免了字体文件路径在不同机器上不一致的问题。

5. 排查清单：PSO-SVR 跑不出结果时先看这五处

这套流程跑通一次之后很稳，但第一次跑的人几乎都会在下面五处卡住。每条按「现象、原因、解决」记，照着对号入座基本能定位。

5.1 现象：测试集 R² 是负数，预测值几乎是一条水平线

原因通常是目标值y没做标准化，或者epsilon相对y的量级太大。前面说过，epsilon的单位和y一致，y在 1e4 量级而epsilon用 0.1，容忍带窄到几乎为零，模型在训练集上过拟合；反过来y在 0.01 量级而epsilon=0.1，所有样本都在容忍带内，模型输出恒等于某个常数附近，R² 自然为负。

解决方法是把y做StandardScaler，训练完再反变换。同时在decode之后打印一次实际超参值，确认epsilon落在y标准差的 0.01 到 0.3 倍之间比较合理。

print(f'C={C:.4f} gamma={gamma:.6f} epsilon={epsilon:.4f} y_std={y_tr.std():.4f}')

5.2 现象：PSO 把 C 顶到搜索上界，训练集误差接近 0，测试集一塌糊涂

原因是用训练集 MSE 当适应度，或者交叉验证的折划分写错了（比如把同一个KFold对象传给了不同的数据）。前者让搜索器找到了一条「无脑增大 C」的捷径，后者导致评估结果不可比，搜索方向随机。

解决方法是强制在适应度函数里用cross_val_score，并且每次传同一个带random_state的KFold实例。顺手加一条硬约束：搜索结束后检查C是否等于上界，如果等于，说明搜索边界设窄了或者存在过拟合倾向，把上界放大一个数量级再跑一次。

5.3 现象：每一代的最优值单调不降，但收敛曲线上限被卡住，怎么加迭代都不动

这是典型的早熟收敛。所有粒子在第 30 代左右聚到同一点，速度趋近于零，之后几十代都在原地打转。原因是v_max设得太小、惯性权重太低，或者初始化范围太窄。

解决方法是三选一：把v_max从范围的 0.1 提到 0.2；加 3.3 节那段停滞重启逻辑，连续 10 代无改善就重置最差 30% 的粒子；或者把n_particles从 20 提到 30。我一般先加重启，因为它是自动的，不用重跑调参。

5.4 现象：结果每次都不一样，R² 在 0.82 到 0.87 之间飘

原因是随机性没有完全固定。PSO里的rng固定了，但train_test_split没固定，或者KFold的shuffle用了默认的random_state=None。

解决方法是把三层随机源全部锁死：数据切分random_state=42，KFold(random_state=42, shuffle=True)，PSO(seed=42)。锁完之后同一份数据跑十次结果完全一致，这时候才能确认「指标变化是模型改动带来的」而不是随机波动。反过来说，如果你想评估模型的稳定性，应该主动跑 5 个不同的seed，看 R² 的均值和标准差，标准差超过 0.02 就说明模型对数据划分太敏感，泛化能力存疑。

5.5 现象：脚本跑了一晚上还没结束，CPU 只有一个核在转

算一下开销就明白了：n_particles × max_iter × cv次 SVR 训练。如果粒子数设了 50、迭代 200 代、交叉验证 10 折，那就是 10 万次训练，单次几十毫秒，十几个小时很正常。很多人一上手就把参数往大了设，觉得「搜得越久越准」。

解决方法分两步。第一步，先用小配置试跑：n_particles=10, max_iter=20, cv=3，两分钟内出结果，确认整条链路没问题再放大。第二步，样本量超过 5000 时，cv降到 3，n_particles控制在 20，因为大样本下单次 SVR 训练本身就慢，靠增加粒子数收益不大。真要并行，用joblib把一代内的粒子评估并行化，改造成本不高：

from joblib import Parallel, delayed vals = np.array(Parallel(n_jobs=-1)( delayed(self.fitness)(x) for x in X))

注意n_jobs=-1和 sklearn 内部的并行可能打架，实测时把 sklearn 的n_jobs置为 1，避免线程超订。

6. 二次开发：把这套搜索器接到自己的数据上

换数据集时，需要动的只有三处：数据加载、搜索边界、评估口径。数据加载部分把make_regression换成pd.read_csv，然后按列名拆出X和y，类别特征要么做独热编码，要么直接删掉——SVR 吃不了字符串。搜索边界按 2.1 节说的改成 YAML 驱动，先看一眼y的标准差，epsilon的上界取标准差的 0.5 倍左右，下界取 0.001，C和gamma先在默认区间跑，观察最优值落在哪个位置，再按需缩放边界。

评估口径这部分，我建议加一层外层交叉验证，而不是只切一次 80/20。样本量小于 1000 时，单次切分的测试集指标波动能到 ±0.05，你会误以为模型改进了。用RepeatedKFold(n_splits=5, n_repeats=3)包一层，报出 R² 的均值和标准差，结论才稳。

一个具体技巧：把 PSO 的搜索结果当作网格搜索的起始点，做「粗网格 + 精 PSO」的混合。先用小网格定位C和gamma的大致区间，再以该区间为中心、缩小上下界跑 PSO，粒子数和迭代都能砍一半，总耗时反而下降。我用这个组合在几个数据集上试过，最终精度和全程大范围 PSO 基本持平，时间省了六成左右。

验证改造是否成功的方法很朴素：固定seed，同一份数据连跑三次，三次的best_params.json应该完全一致；换一份数据后，PSO 的最优 MSE 不应该高于网格搜索的最优 MSE——如果高了，说明 PSO 的搜索空间没覆盖到网格的最优点，边界需要放宽。

血泪经验是：改任何一处之后，先把n_particles和max_iter压到最小（比如 5 和 5）跑一遍，确认能端到端出结果，再放大参数。有一次我直接上 50 粒子 200 代，跑了四十分钟报了个 shape 不匹配的错，回头一查是特征列顺序在transform前后对不上。从那以后我每次改完代码都先用最小配置走一遍，确认链路通了再谈精度。希望这套结构能帮你少花几个晚上在调参和排错之间来回横跳。

本文还有配套的精品资源，点击获取