人工智能 —— 神经网络 —— 极限学习机（ELM）—— 代码示例

只有训练时候的代码：

import numpy as np


class ELM:
    def __init__(self, input_dim, hidden_dim, output_dim, activation='sigmoid'):
        """
        标准极限学习机
        :param input_dim: 输入特征维度
        :param hidden_dim: 隐层节点数
        :param output_dim: 输出维度（分类=类别数，回归=1）
        :param activation: 激活函数 sigmoid / relu
        """
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.activation = activation

        # 随机初始化输入层权重 W 和偏置 b（固定不训练）
        self.W = np.random.uniform(-1, 1, (input_dim, hidden_dim))
        self.b = np.random.uniform(-1, 1, hidden_dim)

        # 输出层权重 β（训练时求解）
        self.beta = None

    def _activate(self, x):
        if self.activation == 'sigmoid':
            return 1.0 / (1.0 + np.exp(-x))
        elif self.activation == 'relu':
            return np.maximum(0, x)
        else:
            raise ValueError('only sigmoid / relu supported')

    def fit(self, X, T):
        """
        训练 ELM
        :param X: shape [n_samples, input_dim]
        :param T: 标签/目标值 [n_samples, output_dim]
        """
        # 隐层输出 H = g(XW + b)
        H = self._activate(X @ self.W + self.b)  # [N, hidden_dim]

        # 闭式解 β = H⁺ T
        self.beta = np.linalg.pinv(H) @ T

    def predict(self, X):
        H = self._activate(X @ self.W + self.b)
        return H @ self.beta


class RELM:
    def __init__(self, input_dim, hidden_dim, output_dim, lam=1e-3, activation='sigmoid'):
        """
        正则化极限学习机（L2正则）
        :param lam: 正则化系数 lambda
        """
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.lam = lam
        self.activation = activation

        self.W = np.random.uniform(-1, 1, (input_dim, hidden_dim))
        self.b = np.random.uniform(-1, 1, hidden_dim)
        self.beta = None

    def _activate(self, x):
        if self.activation == 'sigmoid':
            return 1.0 / (1.0 + np.exp(-x))
        elif self.activation == 'relu':
            return np.maximum(0, x)
        else:
            raise ValueError('only sigmoid / relu supported')

    def fit(self, X, T):
        H = self._activate(X @ self.W + self.b)  # [N, h]

        # 正则化最小二乘
        H_T_H = H.T @ H
        I = np.eye(self.hidden_dim)
        self.beta = np.linalg.inv(H_T_H + self.lam * I) @ H.T @ T

    def predict(self, X):
        H = self._activate(X @ self.W + self.b)
        return H @ self.beta


if __name__ == '__main__':
    # 构造简单正弦回归数据
    N = 200
    X = np.linspace(0, 2 * np.pi, N).reshape(-1, 1)
    y = np.sin(X) + 0.1 * np.random.randn(N, 1)

    # ELM
    elm = ELM(input_dim=1, hidden_dim=50, output_dim=1)
    elm.fit(X, y)
    y_pred_elm = elm.predict(X)

    # RELM（更稳定）
    relm = RELM(input_dim=1, hidden_dim=50, output_dim=1, lam=1e-2)
    relm.fit(X, y)
    y_pred_relm = relm.predict(X)

    print("ELM  MSE:", np.mean((y_pred_elm - y) ** 2))
    print("RELM MSE:", np.mean((y_pred_relm - y) ** 2))

训练的结果：

训练及测试时候的代码：

import numpy as np
import time

# ====================== 1. 之前定义的 ELM 和 RELM 类 ======================
class ELM:
    def __init__(self, input_dim, hidden_dim, output_dim, activation='sigmoid'):
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.activation = activation

        self.W = np.random.uniform(-1, 1, (input_dim, hidden_dim))
        self.b = np.random.uniform(-1, 1, hidden_dim)
        self.beta = None

    def _activate(self, x):
        if self.activation == 'sigmoid':
            return 1.0 / (1.0 + np.exp(-x))
        elif self.activation == 'relu':
            return np.maximum(0, x)
        else:
            raise ValueError('only sigmoid / relu supported')

    def fit(self, X, T):
        H = self._activate(X @ self.W + self.b)
        self.beta = np.linalg.pinv(H) @ T

    def predict(self, X):
        H = self._activate(X @ self.W + self.b)
        return H @ self.beta


class RELM:
    def __init__(self, input_dim, hidden_dim, output_dim, lam=1e-3, activation='sigmoid'):
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.lam = lam
        self.activation = activation

        self.W = np.random.uniform(-1, 1, (input_dim, hidden_dim))
        self.b = np.random.uniform(-1, 1, hidden_dim)
        self.beta = None

    def _activate(self, x):
        if self.activation == 'sigmoid':
            return 1.0 / (1.0 + np.exp(-x))
        elif self.activation == 'relu':
            return np.maximum(0, x)
        else:
            raise ValueError('only sigmoid / relu supported')

    def fit(self, X, T):
        H = self._activate(X @ self.W + self.b)
        H_T_H = H.T @ H
        I = np.eye(self.hidden_dim)
        self.beta = np.linalg.inv(H_T_H + self.lam * I) @ H.T @ T

    def predict(self, X):
        H = self._activate(X @ self.W + self.b)
        return H @ self.beta


# ====================== 2. 生成训练集 & 测试集 ======================
if __name__ == '__main__':
    # 回归任务示例（也可以改成分类）
    np.random.seed(42)

    # 训练数据
    N_train = 2000
    X_train = np.random.rand(N_train, 5) * 2 * np.pi  # 5维输入
    y_train = np.sin(X_train).sum(axis=1, keepdims=True) + 0.1 * np.random.randn(N_train, 1)

    # 测试数据（对应论文里的 testing samples）
    N_test = 481012  # 模拟你论文里的 481,012 测试样本
    X_test = np.random.rand(N_test, 5) * 2 * np.pi
    y_test = np.sin(X_test).sum(axis=1, keepdims=True) + 0.1 * np.random.randn(N_test, 1)

    input_dim = 5
    hidden_dim = 100
    output_dim = 1

    # ====================== ELM 测试 ======================
    print("=" * 60)
    print("                      ELM 测试")
    print("=" * 60)

    start_train = time.time()
    elm = ELM(input_dim, hidden_dim, output_dim)
    elm.fit(X_train, y_train)
    train_time_elm = time.time() - start_train

    start_test = time.time()
    y_pred_elm = elm.predict(X_test)
    test_time_elm = time.time() - start_test

    mse_elm = np.mean((y_pred_elm - y_test) ** 2)
    print(f"训练时间: {train_time_elm:.4f} s")
    print(f"测试时间: {test_time_elm:.4f} s")
    print(f"测试 MSE: {mse_elm:.6f}\n")

    # ====================== RELM 正则化 ELM 测试 ======================
    print("=" * 60)
    print("                    RELM 测试")
    print("=" * 60)

    start_train = time.time()
    relm = RELM(input_dim, hidden_dim, output_dim, lam=1e-2)
    relm.fit(X_train, y_train)
    train_time_relm = time.time() - start_train

    start_test = time.time()
    y_pred_relm = relm.predict(X_test)
    test_time_relm = time.time() - start_test

    mse_relm = np.mean((y_pred_relm - y_test) ** 2)
    print(f"训练时间: {train_time_relm:.4f} s")
    print(f"测试时间: {test_time_relm:.4f} s")
    print(f"测试 MSE: {mse_relm:.6f}")

训练的结果：