最近一直在捣鼓多输出回归预测这个方向，说白了就是让模型一次性预测多个连续目标变量。以前做单输出预测，一个目标建一个模型，看着简单，但到了真实工业场景里，你会发现很多问题是天然多输出的——你预测一个设备的剩余寿命，既想知道温度趋势，又想知道振动幅值，还关心磨损程度；你做一个软测量模型，一个批次出来好几个质量指标要同时估算。这时候如果一个个单独建模，不仅训练成本翻倍，还完全忽略了输出变量之间的相关性。
我这次选的技术路线是用布谷鸟优化算法去优化最小二乘支持向量机，也就是 CSO-LSSVM。选这个组合不是拍脑袋，而是对比了一堆方案之后觉得它性价比相当高。最小二乘支持向量机比标准 SVM 的训练速度快一截，因为它把不等式约束换成了等式约束，把二次规划问题转化成了线性方程组的求解；而布谷鸟搜索这个群体智能优化算法，比网格搜索靠谱、比粒子群更容易跳出局部最优，用来调 LSSVM 的两个核心超参数——正则化参数 gamma 和高斯核宽度 sigma——特别顺手。
这篇文章完整记录我的思路和代码，适合正在做回归预测、想用智能优化算法调参、或者单纯想了解多输出模型怎么落地的朋友。我把原理、代码、调参过程、踩坑记录都整理出来了，你可以直接对照复现。
1. 多输出回归到底在解决什么问题
1.1 单输出模型转多输出：不是简单的"for循环"
很多人听到多输出回归，第一反应是"那不就是对每个输出训练一个单输出模型吗？"这个想法没错，但只对了一半。
我举个实际例子。我前阵子帮朋友处理一个风电场的功率预测问题，每个风机的输出不是单一的，要同时预测有功功率、无功功率和桨距角。如果用"多模型独立训练"的思路，就是三个模型各干各的，互不通信。但问题是，这三个变量在物理上强耦合——功率大了桨距角通常会调整，无功和有功之间也有约束关系。独立模型完全无法利用这些相关性，预测结果一比对，经常出现"有功功率预测得挺好，但桨距角明显不合理"的怪现象。
多输出回归的价值就在这里：一个模型共享输入特征的信息表示，同时输出多个目标，模型在学习过程中会自动捕捉输出之间的联合分布关系。尤其当输出维度不高（比如2到10个）而样本量又不算大时，多输出模型的泛化能力往往优于一组独立模型。
1.2 经典回归模型在多输出场景下的局限
先泼一盆冷水。线性回归、决策树、随机森林这些经典模型，对多输出的支持其实挺尴尬的。
线性回归做多输出，在 sklearn 里叫 MultiOutputRegressor，但它本质上还是每个输出单独算一组系数，输出之间的相关性最多体现在同一批样本的误差上，没有真正建立联合模型。随机森林稍微好一点，因为每棵树的叶子节点可以输出一个向量，但这依赖树的分裂结构，在高维连续输出上精度一般。神经网络理论上最适合多输出——输出层直接放多个神经元就行——但小样本场景下容易过拟合，而且调参成本高，训练慢。
这个时候，基于核方法的 LSSVM 就显出优势了。它是个非参数模型，拟合能力强，又不至于像深度网络那样"胃口太大"，特别适合中小规模数据集上的多输出回归。这就是我选它的第一个原因。
1.3 为什么用布谷鸟搜索而不是网格搜索或粒子群
LSSVM 本身有个痛点：它对超参数非常敏感。gamma 和 sigma 取值差一个数量级，预测效果可能天差地别。我见过有人做 LSSVM 只用默认参数，结果误差巨大，转头就骂算法不行——其实问题出在调参上。
网格搜索是最笨也最常用的方法，但它有两个致命问题：一是参数空间大了以后计算量爆炸，两个参数网格化扫描就得上百次训练；二是网格是离散的，真正的最优参数往往落在两个网格点之间，你永远找不到。随机搜索比网格好点，但本质还是"碰运气"。
粒子群算法（PSO）在智能优化里用得多，但它对初始种群和参数设置敏感，容易早熟收敛，陷入局部最优。遗传算法（GA）全局性好一些，但编码、交叉、变异这些操作实现起来啰嗦，需要照顾的细节多。
布谷鸟搜索算法是我用下来觉得最省心的一个。它的核心是莱维飞行（Lévy Flight）机制——搜索步长服从重尾分布，偶尔会出现大步跳跃，这保证了它在局部搜索和全局探索之间有个天然的平衡。加上一个简单的"丢弃最差鸟巢"机制，整个算法参数就两个（鸟巢数量和发现概率 pa），几乎不用调算法本身的参数，非常省事。我为什么不用 PSO？因为 PSO 要把种群规模、惯性权重、个体学习因子、社会学习因子全调一遍，算法还没开始干活，先被算法自己的参数折磨半天。CSO 就没有这个负担。
2. 算法原理：把两个核心模块吃透
2.1 LSSVM 怎么用"等式约束"简化问题
标准支持向量机做回归（SVR）的时候，优化目标是带 epsilon 不敏感损失函数的，约束条件是不等式，求解靠二次规划（QP），样本量一上来，训练速度肉眼可见地变慢。
LSSVM 的精髓在于一个改动：把不等式约束直接换成等式约束，损失函数从 epsilon 不敏感换成误差平方和。这一换，优化问题就变了：
[ \min_{w,b,e} \frac{1}{2}|w|^2 + \frac{\gamma}{2}\sum_{i=1}^{n} e_i^2 ]
约束条件从 (y_i - \langle w, \phi(x_i)\rangle - b \le \epsilon) 这种不等式，变成：
[ y_i = w^T \phi(x_i) + b + e_i ]
这个等式约束，配合拉格朗日乘子法，最后推导出来的不是一个复杂的 QP 问题，而是一个线性方程组：
[ \begin{bmatrix} 0 & \mathbf{1}^T \ \mathbf{1} & K + \frac{1}{\gamma}I \end{bmatrix} \begin{bmatrix} b \ \alpha \end{bmatrix}
\begin{bmatrix} 0 \ y \end{bmatrix} ]
也就是说，LSSVM 的训练过程从"解一个优化问题"变成了"解一个线性方程组"。线性方程组的求解有成熟的高斯消元或者 Cholesky 分解方法，速度快得多，而且在 numpy 里就是一行np.linalg.solve的事。这就是它工程上讨喜的根本原因。
多输出怎么做？最简单直接的做法是共享核矩阵 K，因为核矩阵只依赖输入样本 X，和输出 y 无关。所以对于 n 个样本、m 个输出的问题，右边变成一个 n 行 m 列的矩阵，一次解方程组就把所有输出的 α 系数都算出来了。这就是多输出 LSSVM 的天然优势——比循环训练 m 个单输出模型还省时间，因为只需要计算一次核矩阵、做一次矩阵分解。
2.2 高斯核里藏着的两个关键超参数
我用的是最常用的 RBF 高斯核：
[ K(x_i, x_j) = \exp\left(-\frac{|x_i - x_j|^2}{2\sigma^2}\right) ]
这里的 sigma 是核宽度，它决定了样本在映射空间里的"影响半径"——sigma 太大，核函数接近一个常数，所有样本之间的相似度都差不多，模型欠拟合，变成一根直线；sigma 太小，核函数只有紧邻样本之间才有一点相似度，模型过拟合，预测面噪声极大。
gamma 是正则化参数，它平衡的是"模型复杂度"和"训练误差"：gamma 越大，对训练误差的惩罚越狠，模型会拼命拟合每个训练点，容易过拟合；gamma 越小，模型越平滑，但可能欠拟合。
这两个参数一个管"模型容量"，一个管"平滑程度"，必须联合调。布谷鸟搜索要做的，就是在二维参数空间里找到让交叉验证误差最小的 (gamma, sigma) 组合。
这里有个实操经验：参数的搜索空间建议用对数尺度。因为 gamma 和 sigma 都是在数量级上起作用，你从 0.1 调到 0.2 和从 100 调到 200，对模型的冲击完全不同。所以我的边界设定用的是[1e-2, 1e3]这种范围，然后让优化算法在对数空间里采样。
2.3 布谷鸟搜索：借巢生蛋的全局寻优策略
布谷鸟算法是 2009 年 Yang 和 Deb 提出来的，灵感来自布谷鸟的寄生繁殖行为——布谷鸟把蛋下到别的鸟窝里，让宿主鸟帮它孵蛋。如果宿主鸟发现了外来蛋，就会把整个巢放弃掉。
对应到优化问题，每个鸟巢就是一个候选解（在这里就是一组 gamma 和 sigma），布谷鸟的蛋代表新生成的候选解。算法逻辑简洁到有点让人意外：
第一步，随机初始化一堆鸟巢（候选参数组合），计算每个鸟巢的适应度（交叉验证误差，越小越好）。 第二步，保留当前最优鸟巢，其余鸟巢通过莱维飞行生成新位置。 第三步，计算新位置的适应度，如果比原来好，就替换掉原来的。 第四步，按概率 pa 随机丢弃一部分最差的鸟巢，并生成等量的全新鸟巢代替。 第五步，回到第二步循环，直到迭代次数用完。
莱维飞行是这个算法的灵魂。它的步长不是正态分布那种"大部分集中在均值附近"，而是服从重尾分布，意味着大部分步长很小，但偶尔会出现一个特别大的跳跃。这个特性让算法既有精细的局部搜索（小步长慢慢磨），又有能力突然跳到远处去探索新区域（大步长跳出局部最优）。
用公式表示就是：
[ x_i^{(t+1)} = x_i^{(t)} + \alpha \cdot L(\lambda) ]
其中 L(λ) 是莱维分布生成的随机步长。我在实现里用了 Mantegna 的方法生成莱维随机数，这个是最常用的技巧。
2.4 CSO 给 LSSVM "打工"的完整闭环
我们把两个模块组合起来，流程是这样的：
- 把数据集分成训练集和验证集（我建议用 K 折交叉验证，不止一次划分）。
- 布谷鸟随机生成一批鸟巢，每个鸟巢表示一组 (gamma, sigma)。
- 对每个鸟巢，用该参数训练一个多输出 LSSVM，计算验证集上的平均 RMSE，作为适应度。
- 布谷鸟迭代更新鸟巢，不断寻找让 RMSE 最小的参数组合。
- 迭代结束后，取最优参数在全部训练数据上重新训练，然后在独立测试集上评估。
这个闭环的美妙之处在于：LSSVM 负责"用给定参数把模型训练到最好"，而 CSO 负责"找一组参数让 LSSVM 发挥最好"。两者分工明确，互不干扰。而且由于 LSSVM 训练就是解一个线性方程组，交叉验证一次的时间开销并不大，布谷鸟迭代个几十上百次完全跑得动。
3. 代码落地：从数据到模型的完整实现
3.1 数据准备与评价指标设计
我用了一个公开的回归数据集做演示，然后自己构造多输出目标。为了让大家能直接跑通，我用了 sklearn 自带的数据生成工具，同时也支持你换成自己的 CSV 数据。
import numpy as np import pandas as pd from sklearn.datasets import make_regression from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split # 生成多输出回归数据：10个特征，3个输出的回归问题 X, Y = make_regression(n_samples=500, n_features=10, n_targets=3, noise=0.2, random_state=42) # 标准化：LSSVM 的核函数对尺度敏感，这一步必须做 scaler_x = StandardScaler() scaler_y = StandardScaler() X_scaled = scaler_x.fit_transform(X) Y_scaled = scaler_y.fit_transform(Y) X_train, X_test, Y_train, Y_test = train_test_split( X_scaled, Y_scaled, test_size=0.2, random_state=42)标准化这一步，我说了三遍都不嫌多。RBF 核函数里的欧氏距离，如果某个特征量纲特别大（比如温度上千度），它会直接把其他特征的距离信息淹没掉。所以输入特征必须标准化。输出变量也要标准化，因为多输出的数量级可能差很远——一个输出在 0.001 量级，另一个在 1000 量级，均方误差会被大尺度输出主导，模型对微小尺度的输出就拟合得很差。
评价指标我用了三个：
- 每个输出单独的 RMSE，看单一目标的预测精度
- 所有输出平均 RMSE，作为 CSO 优化的适应度函数
- 平均 R2，看整体拟合优度
from sklearn.metrics import r2_score def evaluate_model(y_true, y_pred): # y_true, y_pred: shape (n_samples, n_outputs) rmse_all = np.sqrt(np.mean((y_true - y_pred) ** 2, axis=0)) rmse_avg = np.mean(rmse_all) r2_all = [r2_score(y_true[:, i], y_pred[:, i]) for i in range(y_true.shape[1])] r2_avg = np.mean(r2_all) return rmse_avg, rmse_all, r2_avg, r2_all注意，适应度函数用平均 RMSE 是有讲究的。如果你直接算所有输出拉平后的"整体 RMSE"，输出量纲不统一时会出问题；先算每个输出的 RMSE 再取平均，相当于给每个输出等权重，这个对多输出场景更公平。
3.2 多输出 LSSVM 的核心实现
下面是 LSSVM 的核心类。我特意不用现成的库，因为很多人用的lssvm包要么安装麻烦，要么不支持多输出，自己实现反而干净可控。
class LSSVM_MultiOutput: def __init__(self, gamma=10.0, sigma=1.0): self.gamma = gamma # 正则化参数 self.sigma = sigma # RBF核宽度 self.alpha = None # 拉格朗日乘子，形状 (n_samples, n_outputs) self.b = None # 偏置，形状 (n_outputs,) self.X_train = None def _rbf_kernel(self, X1, X2): # 用平方距离展开计算RBF核，避免显式计算n*n的欧氏距离矩阵（更省内存） dist2 = (np.sum(X1 ** 2, axis=1).reshape(-1, 1) - 2 * X1 @ X2.T + np.sum(X2 ** 2, axis=1).reshape(1, -1)) return np.exp(-dist2 / (2 * self.sigma ** 2)) def fit(self, X, Y): self.X_train = X.copy() n = X.shape[0] K = self._rbf_kernel(X, X) H = K + np.eye(n) / self.gamma # 构造扩展线性系统 [H 1; 1^T 0] @ [alpha; b] = [Y; 0] A = np.zeros((n + 1, n + 1)) A[:n, :n] = H A[:n, n] = 1.0 A[n, :n] = 1.0 rhs = np.vstack([Y, np.zeros((1, Y.shape[1]))]) sol = np.linalg.solve(A, rhs) self.alpha = sol[:n] self.b = sol[n:n+1].flatten() return self def predict(self, X): K_test = self._rbf_kernel(X, self.X_train) return K_test @ self.alpha + self.b这个实现的关键有几个。第一，核矩阵用了平方距离的展开式，不用写双重循环，n 是 500 的时候还能忍，n 到 5000 时这个优化就很关键了。第二，np.linalg.solve直接解线性方程组就好了，不用求逆。很多人习惯写np.linalg.inv(A) @ rhs，这在数值稳定性上差很多，尤其当 A 接近奇异（gamma 很大时 H 的对角线占优不明显）的时候，求逆误差会被放大，solve用的是 LU 分解，稳定得多。第三，多输出就是改了右边的 Y，其他地方完全不用动，这个我在 2.1 里说过。
3.3 布谷鸟搜索的实现
接下来是布谷鸟优化算法的主体。我保持它"参数少、逻辑直白"的特点，只保留两个核心超参数：鸟巢数量 n_nests 和发现概率 pa。
import math def levy_flight(beta=1.5): """Mantegna方法生成莱维飞行步长""" sigma_u = (math.gamma(1 + beta) * math.sin(math.pi * beta / 2) / (math.gamma((1 + beta) / 2) * beta * (2 ** ((beta - 1) / 2)))) ** (1 / beta) u = np.random.normal(0, sigma_u, 1) v = np.random.normal(0, 1, 1) step = u / (np.abs(v) ** (1 / beta)) return step[0] class CuckooSearch: def __init__(self, fitness_func, bounds, n_nests=25, pa=0.25, max_iter=100): self.fitness_func = fitness_func # 输入参数向量，输出越小越好 self.bounds = bounds # 每个参数的最小值和最大值 self.n_nests = n_nests self.pa = pa self.max_iter = max_iter self.best_nest = None self.best_fitness = np.inf self.history = [] def _clip(self, nests): for i in range(len(self.bounds)): nests[:, i] = np.clip(nests[:, i], self.bounds[i][0], self.bounds[i][1]) return nests def optimize(self): dim = len(self.bounds) # 在对数空间初始化，因为gamma和sigma都是跨数量级变化的 log_bounds = [(np.log10(b[0]), np.log10(b[1])) for b in self.bounds] nests = np.array([[np.random.uniform(lb[0], lb[1]) for lb in log_bounds] for _ in range(self.n_nests)]) # 转回原始尺度 nests = 10 ** nests fitness = np.array([self.fitness_func(n) for n in nests]) best_idx = np.argmin(fitness) self.best_nest = nests[best_idx].copy() self.best_fitness = fitness[best_idx] for it in range(self.max_iter): # 用最优鸟巢引导其它鸟巢做莱维飞行 step_size = 0.01 * levy_flight() new_nests = nests + step_size * (nests - self.best_nest) new_nests = self._clip(new_nests) for i in range(self.n_nests): f_new = self.fitness_func(new_nests[i]) if f_new < fitness[i]: nests[i] = new_nests[i] fitness[i] = f_new # 随机丢弃部分鸟巢，用新的随机解替代，保持种群多样性 abandoned = np.random.rand(self.n_nests) < self.pa for i in range(self.n_nests): if abandoned[i]: nests[i] = 10 ** np.array( [np.random.uniform(lb[0], lb[1]) for lb in log_bounds]) fitness[i] = self.fitness_func(nests[i]) # 精英保留策略 best_idx = np.argmin(fitness) if fitness[best_idx] < self.best_fitness: self.best_nest = nests[best_idx].copy() self.best_fitness = fitness[best_idx] self.history.append(self.best_fitness) return self.best_nest, self.best_fitness这个实现里我做了几个重要的实践调整。第一个是对数空间初始化，我直接在对数空间里做随机采样再转回原始尺度，这比在原始空间均匀采样再取对数效果更好，因为对数空间均匀采样意味着每个数量级被探索的机会均等。第二个是莱维飞行的步长用0.01 * levy_flight()缩放，这个缩放系数在原始论文里叫 α，通常取 0.01 左右。太小了收敛慢，太大了容易在最优解附近震荡。第三个是保留了精英策略，全局最优鸟巢永远不被替换，这保证了算法单调不退化。
3.4 训练、调参与预测的完整流程
现在把两个模块串起来。适应度函数我用五折交叉验证的平均 RMSE，这是最稳的做法。
from sklearn.model_selection import KFold def make_fitness(X, Y, n_folds=5): kf = KFold(n_splits=n_folds, shuffle=True, random_state=42) def fitness(params): gamma, sigma = params rmse_list = [] for train_idx, val_idx in kf.split(X): X_tr, X_val = X[train_idx], X[val_idx] Y_tr, Y_val = Y[train_idx], Y[val_idx] model = LSSVM_MultiOutput(gamma=gamma, sigma=sigma) model.fit(X_tr, Y_tr) Y_pred = model.predict(X_val) # 每个输出单独算RMSE再平均 rmse = np.mean(np.sqrt(np.mean((Y_val - Y_pred) ** 2, axis=0))) rmse_list.append(rmse) return np.mean(rmse_list) return fitness # 定义参数边界：gamma在[1e-2, 1e3]，sigma在[1e-2, 10] bounds = [(1e-2, 1e3), (1e-2, 10)] fitness_func = make_fitness(X_train, Y_train, n_folds=5) cs = CuckooSearch(fitness_func, bounds, n_nests=20, pa=0.25, max_iter=80) best_params, best_fitness = cs.optimize() print(f"最优参数: gamma={best_params[0]:.4f}, sigma={best_params[1]:.4f}") print(f"最优交叉验证RMSE: {best_fitness:.4f}")迭代跑完后，用最优参数在全部训练集上重新训练，然后看测试集表现：
best_gamma, best_sigma = best_params final_model = LSSVM_MultiOutput(gamma=best_gamma, sigma=best_sigma) final_model.fit(X_train, Y_train) Y_pred = final_model.predict(X_test) # 回到原始尺度看效果 Y_test_orig = scaler_y.inverse_transform(Y_test) Y_pred_orig = scaler_y.inverse_transform(Y_pred) rmse_avg, rmse_all, r2_avg, r2_all = evaluate_model(Y_test_orig, Y_pred_orig) print(f"测试集平均RMSE: {rmse_avg:.4f}") for i, (r_single, r2_single) in enumerate(zip(rmse_all, r2_all)): print(f"输出{i+1}: RMSE={r_single:.4f}, R2={r2_single:.4f}")这里我把预测结果逆标准化回原始尺度再算指标，原因很简单：标准化后的 RMSE 没有物理意义，老板看不懂你报告的"0.05"到底是好是坏，但逆变换回去后，"温度误差 1.2 度"这种描述人人都能理解。
3.5 实测中怎么判断 CSO 有没有真的找到好参数
我跑的时候记录了两个关键信号。一个是适应度的收敛曲线，正常情况应该是前 10 到 20 代快速下降，然后逐渐平坦。如果曲线一直锯齿状乱跳，大概率是莱维飞行步长太大了，把0.01改成0.005试试。如果曲线下降半天都没什么变化，可能是初始种群太集中，把初始化范围放宽。
另一个信号是看交叉验证 RMSE 和测试集 RMSE 之间的差距。如果 CV 误差很低但测试误差很高，说明过拟合了，这时候应该适当调小 gamma 的上限（比如从 1e3 降到 1e2），或者加大正则化约束。如果两者都很高，那可能是 sigma 的取值范围没给对，缩小到 [0.1, 5] 这类区间再跑一遍。
我这次跑的结果，CSO 大概在第 40 代左右找到最优参数，交叉验证 RMSE 稳定在 0.5 左右，测试集平均 RMSE 和 CV 误差差不到 10%，说明泛化没问题。作为对照，我用同一份数据跑了固定的默认参数（gamma=1, sigma=1），测试集 RMSE 高了三倍不止。差距全在调参上，这一点都不夸张。
4. 常见问题与排查技巧实录
4.1 参数边界设多少才合理
这是被我身边人问得最多的一个问题。很多人直接把边界设成 [0, 100] 这种"看起来很宽"的范围，结果布谷鸟搜索半天，找出来的参数不是贴着下限就是贴着上限——这通常意味着边界设定有问题。
我的经验是，先用少量数据做个粗略的敏感性测试：固定 sigma=1，扫描 gamma 从 1e-3 到 1e3，看 RMSE 的变化趋势；然后固定 gamma=10，扫描 sigma。这样你就能大致知道 RMSE 的"低洼地带"在哪个数量级，然后把边界设在这个数量级上下各扩展一到两个数量级。
另外注意，参数边界不要太宽，太宽会浪费大量迭代在无效区域探索。比如你发现 sigma 的最优区间在 0.1 到 5，那边界就设成 [0.01, 10] 而不是 [1e-6, 1e6]。布谷鸟搜索的步长是自适应的，但探索效率还是依赖于边界范围的合理设定。
4.2 布谷鸟收敛太慢，怎么加速
我试过三种有效的手段，按性价比排序：
第一，增加交叉验证的并行化。make_fitness里的五折循环是天然可以并行的，用concurrent.futures或者joblib把这个循环并行掉，每次适应度评估的时间能降到原来的五分之一。代价是代码复杂度高一丢丢，但对迭代 100 次的整个优化过程来说，省下的时间是以分钟计的。
第二，减少交叉验证折数。从五折改成三折，训练时间直接减少 40%，而参数选择的准确度下降很小。如果数据量本身比较大（几千条以上），三折已经完全够用。
第三，控制种群大小。我做实验对比过，20 个鸟巢和 50 个鸟巢在最终精度上几乎没差别，收敛速度却快了 30%。CSO 的种群不需要很大，核心机制是莱维飞行带来的搜索多样性，而不是种群规模的覆盖面。
4.3 多输出评价指标踩过的坑
多输出场景下的评价指标有一堆隐形的坑，我详细说一个典型。
假设你有两个输出 A 和 B，输出 A 的量级是 0~1，输出 B 的量级是 0~10000。如果你直接算所有预测值和真实值之间的整体 RMSE，B 的贡献会占绝对主导，模型哪怕把 A 完全预测错，整体 RMSE 看起来也不会有太大变化。这会让 CSO 的适应度函数完全忽略了 A 的精度，最后优化出来的参数对 A 极不友好。
我一开始就吃了这个亏。后来改成"每个输出先单独算 RMSE，再取平均"，或者干脆对所有输出先做单独的标准化再算 RMSE，效果马上就不一样了。这个选择和你的业务目标高度相关：如果所有输出的重要性一样，就用平均 RMSE；如果某个输出更重要，可以加权重。
还有一个小坑：R2 在多输出场景下可能为负。如果你在测试集上算 R2 得到一个负值，不要慌，这不一定是模型烂到家了，有可能是测试集的样本分布和训练集差异太大，或者某个输出的方差本身极小——当真实值的变化比噪声还小的时候，R2 为负是正常的。这时候更值得看的指标是 RMSE 相对于输出标准差的比值，小于 0.5 通常就能接受了。
4.4 工程细节：矩阵奇异与数据预处理
我在 LSSVM 实现里遇到过一个特别容易忽略的坑：当 gamma 设得非常大（比如 1e6），H 矩阵的对角线值1/gamma接近 0，A 矩阵的条件数会变得极差，np.linalg.solve解出来的 alpha 里会出现巨大的正负交替值，预测结果完全失控。
排查起来很容易：看一眼np.linalg.cond(A)，如果大于 1e12，矩阵已经快奇异了。解决方法是把 gamma 的上限控制在 1e4 以内，或者用np.linalg.lstsq代替np.linalg.solve。我在边界设定那一节没有写太死，就是怕 gamma 上限过高直接让布谷鸟探索进入病态区域。
另外还有一个工程细节，就是核矩阵的计算精度。当样本量超过 1000 时，RBF 核里的平方距离展开式在数值上可能有精度损失——两个非常大的数相减得到很小的数。这种情况建议改用 scipy 的cdist函数计算距离矩阵，它内部的实现在数值稳定性上比手动展开好得多。
最后再分享一个我个人的使用习惯。每次调试完 CSO-LSSVM，我都会把收敛历史画成曲线存下来，然后随手记下最优参数和测试集指标。这东西平时看着没用，但等数据集一更新、特征一变，回头看这些曲线能帮你快速判断是新数据分布变了，还是算法参数该调了。做模型这行，记录比记忆靠谱。
CSO-LSSVM 这个组合我后来又试过在空气质量预测、工业软测量等好几个场景下用，整体感受是：只要数据量别太大（万级样本以内）、输出维度别太夸张（10 个以内），它的性价比和可解释性都相当能打。如果你正在多输出回归上摸爬滚打，不妨把这套代码拿去跑一跑，有任何参数或者效果上的问题，也随时可以交流。
