极限学习机（ELM）

最新推荐文章于 2024-06-09 23:34:55 发布

饕子

最新推荐文章于 2024-06-09 23:34:55 发布

阅读量6.8k

点赞数 12

分类专栏：机器学习文章标签：机器学习深度学习人工智能

本文链接：https://blog.csdn.net/m0_72410588/article/details/130598622

版权

机器学习专栏收录该内容

85 篇文章

订阅专栏

极限学习机（ELM）

1. 引言

在机器学习领域，我们常常需要通过训练数据来学习一个函数模型，以便在未知的数据上进行预测或分类。传统的神经网络模型需要大量的参数调整和迭代优化，学习效率很低。极限学习机（Extreme Learning Machine, ELM）是一种基于随机化的单层前向神经网络，其学习速度快、精度高、易于实现等诸多优点，成为近年来研究热点。

本篇文章将详细介绍极限学习机的原理及应用，并给出相应的代码实现。

2. ELM基本原理

2.1 ELM的结构

ELM主要由三部分组成：

输入层：负责接收输入样本向量X，输出样本特征。
隐含层：包含K个隐含节点，每个隐含节点的输出为一个加权和，即 $z_k = \sum_{i=1}^{n}w_{ik}x_i + b_k$ ，其中 $w_{ik}$ 表示输入层第 $i$ 个神经元到隐含层第 $k$ 个神经元的连接权重， $b_k$ 是偏置项。
输出层：输出层的神经元数等于样本类别数。对于二分类问题，输出层有两个神经元，分别表示正负类别，输出结果为一个向量 $y=(y_1,y_2)^T$ 。

2.2 ELM的学习过程

ELM的核心思想是随机初始化隐含层与输出层之间的连接权重与偏置，从而实现快速训练并得到高精度的模型。

具体地，对于一个训练集 $T={(x_1, y_1),(x_2, y_2),...,(x_n,y_n)}$ ，我们先将输入样本 $X={x_1,x_2,..., x_n}$ 通过某种函数，如sigmoid函数或ReLU函数，映射到高维特征空间，得到新的输入矩阵 $H=[h_{ij}]_{K\times n}$ ，其中 $h_{ij}=g(z_k)$ ， $g(z_k)$ 为隐含层第 $k$ 个神经元的激活函数。

然后，我们随机初始化隐含层与输出层之间的连接权重 $W_{K\times m}$ ，其中 $m$ 为输出层神经元数，即样本类别数。用矩阵表示，输出层的输出 $Y=[y_{i}]_{m\times n}$ 可以表示为：

$\cdot H$

接下来，我们利用最小二乘法（Least Square Method, LSM）来计算输出层与训练数据之间的拟合误差。具体地，对于两个 $n$ 维向量 $y_i$ 和 $t_i$ ，其残差平方和可以表示为：

$E(W)=\frac{1}{2}\sum_{i=1}^{n}||y_i - t_i||^2$

把上式改写成矩阵形式，可得：

$E(W)=\frac{1}{2}||Y-T||_F^2$

其中， $T=[t_{ij}]_{m\times n}$ 表示输出层对应的目标向量。

对于固定的隐含层神经元数 $K$ ，输出层权重 $W$ 可以通过以下公式计算得出：

$W=(H^{T}H)^{-1}H^{T}T$

也就是说，我们只需要求出输入层到隐含层的权重 $W_{K\times n}$ 和隐含层到输出层的权重 $W_{K\times m}$ 即可。这样，ELM的学习过程就完成了。

2.3 ELM的预测过程

在得到模型的权重之后，我们便可以利用新的样本计算输出层的结果。

对于一个未知样本 $x$ ，我们先将其通过激活函数映射到隐含层：

$h_{i}=g(\sum_{j=1}^{n}w_{ij}x_j+b_i)$

然后，将映射后的隐含层的输出与隐含层到输出层的权重相乘，并进行加权和：

$\cdot h$

最终，通过对 $y$ 进行分类处理，即可得出该样本的类别。

3. ELM的应用场景

3.1 ELM在手写数字识别中的应用

手写数字识别是机器学习领域中的一个经典问题，也是ELM的重要应用之一。我们可以使用MNIST数据集进行实验。

以下是Python代码：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.datasets import fetch_openml

# 下载MNIST数据集并划分训练集与测试集
mnist = fetch_openml('mnist_784', version=1)
X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)

# 定义sigmoid激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 定义ReLU激活函数
def relu(x):
    return np.maximum(x, 0)

# 定义ELM分类器
class ELMClassifier:
    def __init__(self, hidden_units, activation='relu'):
        self.hidden_units = hidden_units
        self.activation = activation
        
    def fit(self, X, y):
        # 对于二分类问题，将样本标签转换为{-1, 1}
        self.classes_ = np.unique(y)
        if len(self.classes_) == 2:
            y = np.where(y == self.classes_[0], -1, 1)
        
        # 计算隐含层的权重和偏置
        n_samples, n_features = X.shape
        if self.activation == 'sigmoid':
            H = sigmoid(np.dot(X, self.random_weights(n_features, self.hidden_units)))
        else:
            H = relu(np.dot(X, self.random_weights(n_features, self.hidden_units)))
        H = np.hstack([H, np.ones((n_samples, 1))])
        self.beta = np.dot(np.linalg.inv(np.dot(H.T, H)), np.dot(H.T, y))
        
    def predict(self, X):
        if self.activation == 'sigmoid':
            H = sigmoid(np.dot(X, self.random_weights(X.shape[1], self.hidden_units)))
        else:
            H = relu(np.dot(X, self.random_weights(X.shape[1], self.hidden_units)))
        H = np.hstack([H, np.ones((X.shape[0], 1))])
        y_pred = np.dot(H, self.beta)
        if len(self.classes_) == 2:
            y_pred = np.where(y_pred >= 0, self.classes_[1], self.classes_[0])
        else:
            y_pred = self.classes_[np.argmax(y_pred, axis=1)]
        return y_pred
    
    def random_weights(self, n_input, n_output):
        epsilon = np.sqrt(6) / np.sqrt(n_input + n_output)
        return np.random.randn(n_input, n_output) * epsilon

# 训练并测试ELM分类器
elm = ELMClassifier(hidden_units=256, activation='relu')
elm.fit(X_train, y_train)
y_pred = elm.predict(X_test)
print('Accuracy:', accuracy_score(y_test, y_pred))