PSO-KELM实战：粒子群算法自动优化核极限学习机参数-代码聚汇网

PSO-KELM实战：粒子群算法自动优化核极限学习机参数

江平舟·2026-09-06·阅读 21 GEO检测（免费）

粒子群算法核极限学习机PSO-KELM

|难度：普通|阅读约 30 分钟

分类预测这行，真正的瓶颈往往不在模型结构，而在超参数怎么定。今天聊的PSO-KELM，说白了就是拿粒子群算法（PSO）自动去优化核极限学习机（KELM）的正则化系数和核参数，在不少公开数据集上能把准确率再往上抬几个点，而且不用像网格搜索那样等得人发慌。KELM本身速度极快，PSO又擅长在连续空间里找全局最优，这两者组合起来特别适合那些“数据量中等、特征维数不低、又需要快速迭代模型”的场景。想入门智能优化算法和分类模型融合的同学，这篇文章应该能帮你少走很多弯路。

我自己最开始接触KELM的时候，第一反应是“这不就是ELM套了个核技巧么”，后来跑了几个实验才发现，参数一乱设，效果比普通SVM还差。后来把PSO接进去自动寻优，才算把这套东西的潜力逼出来。这篇博客就把我踩过的坑、验证过的流程、代码结构和调参心得全部摊开讲。

1. 先搞清楚两个主角：PSO和KELM

1.1 从ELM到KELM：核映射解决随机性

极限学习机（ELM）是黄广斌教授提出的一种单隐层前馈神经网络训练方法。它最大的特点就是隐层节点的输入权重和偏置是随机生成的，不需要迭代调整，只需要用最小二乘法求解输出权重。相比BP神经网络要反复反向传播，ELM的训练速度几乎可以快两到三个数量级，而且在很多回归和分类任务上表现都不差。

但ELM有个天然毛病：随机生成的隐层映射会带来不确定性。同一个数据集跑两次，由于随机权重不同，结果可能忽高忽低。而且当隐层节点数设得很大时，矩阵求逆的计算开销也不小，还容易过拟合。KELM的思路就是把ELM中显式的随机特征映射替换成核函数隐式映射，模型不需要再关心隐层节点数是多少，只需要构造一个核矩阵。这样一来，不仅绕开随机性的问题，还提高了非线性拟合能力。

KELM的核心输出表达式是：

[
f(x) = sign\left(\sum_{i=1}^{N} \beta_i K(x, x_i)\right)
]

其中 (K(x, x_i)) 是核函数，比如最常用的RBF核：

[
K(x, x_i) = \exp(-\gamma |x - x_i|^2)
]

输出权重 (\beta) 通过下面这个正则化最小二乘解来求：

[
\beta = \left(\frac{I}{C} + \Omega \right)^{-1} T
]

这里面 (\Omega) 是N×N的核矩阵，N是训练样本数，(T) 是标签矩阵，(C) 是正则化系数。换句话说，KELM把“隐层节点数”这个参数换成了“核函数”和“正则化系数”，更干净，但依然需要人工调。

1.2 粒子群优化（PSO）到底在干什么

PSO是模拟鸟群觅食行为的群智能算法。每个粒子代表解空间里一个候选解，它有两个属性：位置和速度。粒子每次迭代会参考两个最优点更新自己：一个是它自己历史上踩过的最优点（个体最优 (pbest)），另一个是整个种群目前发现的最优点（全局最优 (gbest)）。

速度更新公式是：

[
v_i(t+1) = w v_i(t) + c_1 r_1 (pbest_i - x_i(t)) + c_2 r_2 (gbest - x_i(t))
]

位置更新公式是：

[
x_i(t+1) = x_i(t) + v_i(t+1)
]

其中 (w) 是惯性权重，控制粒子上一步速度对当前的影响；(c_1) 和 (c_2) 是学习因子，分别控制粒子向自身经验和群体经验学习的程度；(r_1)、(r_2) 是在[0,1]之间的随机数。本质上来讲，PSO是在连续多维空间里做“信息共享+随机扰动”，它的优势是不需要目标函数的梯度信息，很多黑盒优化问题都能硬啃。

1.3 为什么偏要用PSO去调KELM的参数

KELM需要调的主要参数就两个：正则化系数 (C) 和RBF核参数 (\gamma)。虽然参数少，但两者的影响是非线性的，而且互相耦合。用网格搜索的话，假设每个参数试20个值，就是400次训练；数据量稍微大一点，核矩阵求逆每次都做一遍，累计时间并不友好。随机搜索稍微快一点，但稳定性看脸。

PSO每轮只需要评估一定数量粒子的适应度，而且粒子的搜索是朝着历史最优区域靠拢的，通常几十次迭代就能收敛到不错的区间。实际体验中，粒子数设20、迭代30次左右，等于只做600次KELM训练。但和瞎试400个点不一样，PSO能根据历史结果动态调整搜索方向，大部分资源都花在“有希望的区域”里，所以搜索效率反而更高。

还有一点很关键：PSO天然适合连续参数优化，而 (C) 和 (\gamma) 本来就是连续值。用网格搜索只能取你指定的离散值，有可能最佳点在两个网格点之间，PSO则能搜到任意精度。这也是我做对比实验时，PSO-KELM经常比网格搜索KELM精度略高的原因之一。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 整体设计与算法流程

2.1 PSO-KELM的完整架构

整个系统的输入是训练样本 (X) 和标签 (Y)，输出是最优的 (C)、(\gamma) 以及对应的KELM模型。整体流程并不复杂：

初始化PSO种群，每个粒子的位置包含两个维度：([C, \gamma])。
对每个粒子，用当前参数训练KELM模型，在验证集上计算适应度。
更新每个粒子的个体最优和全局最优。
按速度公式和位置公式更新粒子。
判断是否达到最大迭代次数或满足收敛条件。
输出全局最优参数，用全部训练数据重新训练最终KELM模型。

这里面最容易忽略的是“验证集”和“测试集”的区分。很多人直接用训练集的准确率当作适应度，得到的一组参数往往过拟合，泛化能力很差。正确的做法是从训练数据里再切出一部分验证集，用验证集的表现衡量粒子好坏。我习惯按训练：验证 = 7：3或者8：2来切，如果是小样本数据集，再加交叉验证，但那样计算量会翻倍，需要自行权衡。

2.2 适应度函数怎么设计才靠谱

适应度函数是整个PSO-KELM的方向盘。最朴素的做法是用分类准确率：

[
fitness = \frac{correct}{total}
]

但准确率在类别不平衡的时候很容易骗人。比如99个负样本、1个正样本，模型全预测负样本也有99%的准确率，PSO会以为这个参数好得不行，实际根本没学到正样本的特征。所以工业项目里，我更推荐用F1-score、AUC，或者加权准确率作为适应度。如果数据是不平衡的，直接上F1-score往往最稳。

还有一类情况是多分类问题。多分类的F1-score分micro和macro，对不平衡敏感程度不同。我在医学影像分类项目里常用macro F1，它把每个类别的指标单独算再取平均，对稀有类别更公平。PSO寻优时不会关心这个指标怎么算，它只知道分数越高越好，所以我们完全可以根据业务需求换适应度函数，这是这套框架非常灵活的地方。

2.3 参数编码与搜索范围设置

PSO优化的是连续值，所以粒子的位置向量就是一个二维实数向量 (x=[x_1, x_2])，分别对应 (C) 和 (\gamma)。不过 (C) 和 (\gamma) 的数量级经常差得很远，比如 (C) 可能在0.1到1000之间，(\gamma) 可能在0.001到10之间。如果直接在原始空间里搜，粒子容易偏向数值较大的维度。

我常用的做法是在对数空间里搜索。也就是粒子位置存的是 (log_{10}(C)) 和 (log_{10}(\gamma))，在适应度评估时再转换成真实值。这样做有两个好处：第一，搜索空间从宽量程压缩成窄范围，粒子迁移更平滑；第二，对数和人类调参习惯一致，我们一般关注的是10的幂次变化。搜索范围建议：

(C)：(10^{-2}) 到 (10^3)
(\gamma)：(10^{-3}) 到 (10^2)

如果你对数据分布有一定了解，可以把范围进一步缩小。比如使用标准化之后的特征，RBF核的 (\gamma) 基本不会太大，超过100反而容易过拟合。

3. 实操过程与核心环节实现

3.1 数据准备与预处理

在写PSO-KELM代码之前，数据预处理这一步真的不能省。我最早图省事，直接把原始特征丢进KELM，结果分类准确率原地踏步，后来才发现是特征量纲差异太大，导致核矩阵里的欧氏距离被少数大数值特征主导了。

所以第一步就是对特征做标准化。最常用的是Z-Score标准化：

[
x' = \frac{x - \mu}{\sigma}
]

或者用Min-Max缩放到[0,1]区间。在PSO-KELM场景里，我一般优先选Z-Score，因为它对离群点的容忍度更高，而且能保留特征之间的相关结构。如果特征本身已经是同量纲的，比如像素值，那Min-Max会更方便。

第二件事是标签处理。二分类问题标签建议编码为 (+1) 和 (-1)，因为KELM的符号函数天然输出正负类。多分类问题可以用one-hot编码，输出层每个神经元对应一个类别，取最大值的索引作为预测类别。

3.2 KELM核心代码实现

这一段给一个可运行的Python核心逻辑，基于NumPy实现RBF核KELM。代码不依赖额外深度学习框架，跑起来非常轻量。

python复制import numpy as np

def rbf_kernel(X1, X2, gamma):
    """
    计算RBF核矩阵。
    X1: (n1, d), X2: (n2, d)
    返回: (n1, n2)
    """
    dist_sq = (
        np.sum(X1 ** 2, axis=1, keepdims=True)
        + np.sum(X2 ** 2, axis=1, keepdims=True).T
        - 2.0 * np.dot(X1, X2.T)
    )
    return np.exp(-gamma * dist_sq)

class KELM:
    def __init__(self, C=1.0, gamma=0.1):
        self.C = C
        self.gamma = gamma

    def fit(self, X, Y):
        self.X_train = X.copy()
        N = X.shape[0]
        # 训练核矩阵
        Omega = rbf_kernel(X, X, self.gamma)
        # 加上正则化项后求输出权重
        self.beta = np.linalg.pinv(Omega + np.eye(N) / self.C) @ Y
        return self

    def predict(self, X):
        K_test = rbf_kernel(X, self.X_train, self.gamma)
        Y_pred = K_test @ self.beta
        return np.argmax(Y_pred, axis=1)  # 多分类场景

这个实现里最关键的一步是 np.linalg.pinv，伪逆比直接求逆更稳健，尤其是当核矩阵接近奇异时不会直接崩掉。fit过程只需要一次核矩阵计算和一次伪逆，复杂度主要在第5节的N×N矩阵求逆上。所以当训练样本数超过两万时，KELM训练时间会明显变长，这点在后面工程化部分会提到。

3.3 PSO优化过程的实现框架

PSO部分同样可以用纯NumPy实现。下面的代码展示了二维粒子群的更新骨架，核心是速度和位置的迭代。

python复制class PSO:
    def __init__(self, n_particles=20, n_iter=30, w=0.6, c1=1.8, c2=1.8):
        self.n_particles = n_particles
        self.n_iter = n_iter
        self.w = w
        self.c1 = c1
        self.c2 = c2

    def optimize(self, fitness_func, bounds):
        # bounds: [(low1, high1), (low2, high2)]，对数空间边界
        n_dims = len(bounds)
        # 随机初始化位置和速度
        positions = np.zeros((self.n_particles, n_dims))
        for d in range(n_dims):
            low, high = bounds[d]
            positions[:, d] = np.random.uniform(low, high, self.n_particles)
        velocities = np.zeros_like(positions)

        pbest_pos = positions.copy()
        pbest_score = np.full(self.n_particles, -np.inf)
        gbest_pos = positions[0].copy()
        gbest_score = -np.inf

        for t in range(self.n_iter):
            for i in range(self.n_particles):
                score = fitness_func(positions[i])
                if score > pbest_score[i]:
                    pbest_score[i] = score
                    pbest_pos[i] = positions[i].copy()
                if score > gbest_score:
                    gbest_score = score
                    gbest_pos = positions[i].copy()

            r1 = np.random.random((self.n_particles, n_dims))
            r2 = np.random.random((self.n_particles, n_dims))
            velocities = (
                self.w * velocities
                + self.c1 * r1 * (pbest_pos - positions)
                + self.c2 * r2 * (gbest_pos - positions)
            )
            positions = positions + velocities

            # 越界处理：直接拉回边界
            for d in range(n_dims):
                low, high = bounds[d]
                positions[:, d] = np.clip(positions[:, d], low, high)

        return gbest_pos, gbest_score

用PSO包装KELM的时候，适应度函数可以写成闭包的形式，这样不用把训练数据到处传来传去。每次粒子评估，要做的事情就是：把 ([C, \gamma]) 从对数空间还原，然后训练KELM，再在验证集上算F1-score。

python复制def build_fitness(X_train, Y_train, X_val, Y_val):
    def fitness(position):
        C = 10 ** position[0]
        gamma = 10 ** position[1]
        model = KELM(C=C, gamma=gamma)
        model.fit(X_train, Y_train)
        pred = model.predict(X_val)
        return f1_score(Y_val, pred, average='macro')
    return fitness

注意这里每次适应度评估都要重新训练一次KELM，数据量大时比较吃CPU。这种场景下可以考虑并行评估粒子，或者先用小批量训练初筛，再对候选参数精调，能省不少时间。

3.4 参数配置与调参经验

PSO自身的参数不能乱设。惯性权重 (w) 过大，粒子容易飞出搜素空间，收敛慢；过小则容易早熟，陷入局部最优。我一般把 (w) 设为0.6到0.7之间，这是很多论文里比较认可的经验区间。学习因子 (c_1) 和 (c_2) 通常取1.5到2.0，且两者差值不要太大，保持个人经验和群体经验的平衡。

粒子数和迭代次数的搭配也值得说。粒子数太多，每次适应度评估数量大，计算量暴涨；粒子数太少，又不足以覆盖搜索空间。常规任务我用20到30个粒子，迭代20到40轮。如果特征维数高或者数据复杂，可以把粒子数加到40，但迭代次数不建议超过50，因为PSO收敛很快，后期提升非常有限。

还有一个容易踩坑的地方是速度限制。如果你没有给粒子速度设上限，可能出现某个粒子一下子飞出十万八千里，然后整个种群被一个异常值带偏。虽然边界clip能限制位置，但速度过大依然会导致粒子长时间在边界附近来回震荡。我的做法是把速度按搜索空间的10%到20%做clip，比如搜索范围长度是5，那么速度范围就限制在[-1, 1]左右。

4. 实验验证与效果分析

4.1 在基准数据集上做对比

为了验证PSO-KELM的效果，我在几个经典数据集上做了对比实验，包括UCI的Iris、Wine、Breast Cancer Wisconsin，以及一个模拟的二分类不平衡数据集。切分方式统一用70%训练、15%验证、15%测试，特征做Z-Score标准化。

对比对象包括普通ELM、随机搜索调参的KELM、网格搜索调参的KELM、PSO-KELM，以及作为参照的SVM（RBF核，用网格搜索调参）。每组实验跑10次取平均准确率。

从实验结果来看，PSO-KELM在Iris和Wine这种样本量较小的数据集上，和网格搜索KELM打成平手，但搜索耗时只有网格搜索的1/5左右。在Breast Cancer数据集上，PSO-KELM的测试准确率比随机搜索高约1.2%，比ELM高约2.8%。在模拟不平衡数据上，用F1-score作为适应度的PSO-KELM明显优于用准确率优化的版本，这说明适应度函数的选择比想象中更重要。

4.2 收敛曲线与搜索过程解读

观察PSO的收敛曲线，可以发现一个常见现象：前5到10轮适应度上升非常快，粒子迅速从随机位置跳到较优区域；10轮之后再提升就很缓慢，基本是在局部区域做精细搜索。因此如果你的项目时间紧，设15轮迭代可能就够用了，再多轮次的收益并不高。

另一个值得关注的是全局最优参数的稳定性。同一批数据如果跑多次PSO，每次得到的 (C) 和 (\gamma) 可能不完全相同，但最终的测试精度差异通常很小。这并不可怕，因为KELM对参数有一定鲁棒性，不同参数组合可能落在同一个“性能平台”上。如果你发现多次运行PSO得到的精度波动很大，首先怀疑是不是验证集太小或数据划分不均衡。

4.3 相比传统方法的实际提升

很多初学者会问，PSO-KELM真的比SVM强吗？我的回答是：不一定，但值得一试。SVM在小样本非线性分类上非常能打，但SVM有自身的超参数，也需要调。PSO-KELM的优势在于训练速度快，尤其当样本量在几千这个量级时，一次KELM训练只要零点几秒，PSO在几十轮内能尝试几百种参数组合。SVM在大样本下训练时间会显著上升，而KELM的核矩阵求逆在中等样本量下依然可控。

另外，KELM是“核方法+正则化最小二乘”框架，理论上和LS-SVM、RVM都有千丝万缕的联系。但在工程实现上，KELM的代码要简洁很多，做矩阵运算时能更容易利用GPU或者NumPy加速。所以如果你的目标是“快速搭一个可解释、性能不差的分类器”，PSO-KELM确实是一手好牌。

5. 常见问题与避坑指南

5.1 核矩阵太大导致内存爆炸

KELM需要存储N×N的核矩阵，样本数到几万时，这个矩阵就是天文数字。1万样本的float64矩阵大约是800MB，2万就超过3GB，个人电脑基本扛不住。解决办法包括：

对训练样本做下采样，比如先聚类再挑选代表点。
使用近似核方法，比如Nyström采样。
将样本分批训练，但要注意KELM不是增量算法，分批后需要额外的融合策略。

我实际项目里遇到最多的场景是样本量一两万，这时候用单机16GB内存还勉强能跑，但如果超过三万，就建议考虑降维或者换其他算法了。

5.2 参数搜索范围设置不当

搜索范围设得太窄，可能找不到最优参数；设得太宽，PSO会在无意义的区域浪费大量计算。比如有人把 (\gamma) 范围定到 (10^{-6}) 到 (10^6)，结果大部分粒子都扎堆在两端边界附近，效果反而不好。

我的建议是先跑一次宽范围的快速PSO，比如粒子数10、迭代10轮，观察最优参数落在哪个数量级。然后再把范围缩窄到最优值附近一个数量级内，进行二次精细搜索。这种“粗搜+细搜”的两阶段策略，既稳又快。

5.3 验证集和测试集切分不规范

这是最容易被忽视的问题。有些人做参数优化时，直接把测试集也拿进去算适应度，相当于“偷看答案”，最后报告的准确率虚高，换到新数据上立刻露馅。正确的做法是参数寻优过程中测试集全程不动，只有最终评估时才准碰。

如果是小样本数据集，可以尝试嵌套交叉验证，外层交叉验证估计泛化误差，内层交叉验证选参数。但嵌套交叉验证的计算量非常大，和PSO搭配时要注意总的训练次数，避免等到天荒地老。

5.4 类别不平衡场景下的适应度陷阱

我前面提过，类别不平衡时用准确率会失效。这里再提醒一点：F1-score也有macro和micro之分。micro F1计算的是全局TP、FP、FN，对多数类别更敏感；macro F1则对每个类别等权平均，更关注少数类。具体选哪个要看业务需求，如果少数类的识别本身就是重点，就选macro F1。

更极端的情况下，可以用带权重的评价指标，但那需要和业务方确认清楚，不要自己拍脑袋定。

5.5 如何进一步扩展PSO-KELM

这套框架的扩展空间很大。除了二分类和多分类，KELM可以改造成回归模型，只需要把输出层的符号函数换成恒等映射，PSO的适应度函数换成均方误差或者MAE。PSO部分也可以换成其他优化器，比如灰狼优化、鲸鱼优化、麻雀搜索等，本质思路都是“用元启发式算法解决超参数搜索问题”。

另外，核函数不止RBF一种。多项式核、Sigmoid核、拉普拉斯核都可以试试，甚至可以同时优化多个核的混合权重，让核矩阵变成多个核矩阵的线性组合。这种情况下PSO的搜索维度扩展到3维以上，粒子搜索仍然有效，但需要更大种群和更多迭代次数。

我在实际使用中的体会是：PSO-KELM不是一个“万能算法”，而是一套“快速试错框架”。它把调参的机械劳动交给优化器，把一个分类任务的超参数搜索时间从几小时压缩到几分钟，让研发人员能把精力花在特征工程和业务理解上。如果看这篇文章的你对智能化调参感兴趣，建议先拿一个公开数据集跑通代码，再把适应度函数换成自己业务关心的指标，你会发现这套组合拳比想象中更实用。