Máquina de aprendizaje extremo Python32 ELM

2024-07-12

imagen

Extreme Learning Machine (ELM) es un algoritmo de aprendizaje simple de red neuronal feedforward (SLFN) de una sola capa. En teoría, los algoritmos de máquina de aprendizaje extremo (ELM) tienden a proporcionar un buen rendimiento (perteneciente a los algoritmos de aprendizaje automático) con velocidades de aprendizaje extremadamente rápidas, y fueron propuestos por Huang et al. La característica principal de ELM es que su velocidad de aprendizaje es muy rápida. En comparación con los métodos tradicionales de descenso de gradiente (como la red neuronal BP), ELM no requiere un proceso iterativo. El principio básico es seleccionar aleatoriamente los pesos y sesgos de la capa oculta y luego aprender los pesos de salida minimizando el error de la capa de salida.

imagen

Los principales pasos del algoritmo ELM.

Inicialice aleatoriamente los pesos y sesgos ingresados en la capa oculta：
- Los pesos y sesgos de las capas ocultas se generan aleatoriamente y permanecen constantes durante el entrenamiento.
Calcule la matriz de salida de la capa oculta (es decir, la salida de la función de activación)：
- Calcule la salida de la capa oculta utilizando una función de activación (como sigmoide, ReLU, etc.).
Calcular el peso de salida：
- Los pesos desde la capa oculta hasta la capa de salida se calculan mediante el método de mínimos cuadrados.

La fórmula matemática de ELM es la siguiente:

Dado un conjunto de datos de entrenamiento, donde,
La fórmula de cálculo de la matriz de salida de la capa oculta es:
- donde es la matriz de entrada, es la entrada de la matriz de peso a la capa oculta, es el vector de polarización y es la función de activación.
La fórmula de cálculo del peso de salida es:
- Entre ellos, se encuentra la inversa generalizada de la matriz de salida de la capa oculta y es la matriz de salida.

Escenarios de aplicación del algoritmo ELM

Procesamiento de conjuntos de datos a gran escala: ELM funciona bien al procesar conjuntos de datos a gran escala porque su velocidad de entrenamiento es muy rápida y es adecuado para escenarios que requieren un entrenamiento rápido de modelos, como clasificación de imágenes a gran escala, procesamiento de lenguaje natural y otras tareas.
Pronóstico de la industria : ELM tiene una amplia gama de aplicaciones en el campo de la predicción industrial, como el control de calidad y la predicción de fallos de equipos en procesos de producción industrial. Puede entrenar rápidamente modelos predictivos y responder rápidamente a datos en tiempo real.
El sector financiero : ELM se puede utilizar para análisis y predicción de datos financieros, como predicción del precio de las acciones, gestión de riesgos, calificación crediticia, etc. Dado que los datos financieros suelen ser de alta dimensión, la rápida velocidad de entrenamiento de ELM es ventajosa para procesar estos datos.
diagnostico medico : En el campo médico, ELM se puede utilizar para tareas como la predicción de enfermedades y el análisis de imágenes médicas. Puede entrenar modelos rápidamente y clasificar o hacer retroceder datos de pacientes, lo que ayuda a los médicos a realizar diagnósticos más rápidos y precisos.
Sistema de control inteligente : ELM se puede utilizar en sistemas de control inteligentes, como hogares inteligentes, sistemas de transporte inteligentes, etc. Al conocer las características y patrones del entorno, ELM puede ayudar al sistema a tomar decisiones inteligentes y mejorar la eficiencia y el rendimiento del sistema.

Python implementa el algoritmo ELM

Usamosmake_moons Conjunto de datos, un conjunto de datos de juguete comúnmente utilizado para tareas de clasificación de aprendizaje automático y aprendizaje profundo. Genera puntos distribuidos en dos formas de media luna que se cruzan, ideal para demostrar los límites de rendimiento y decisión de los algoritmos de clasificación.


import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score
 
# 定义极限学习机（ELM）类
class ELM:
    def __init__(self, n_hidden_units):
        # 初始化隐藏层神经元数量
        self.n_hidden_units = n_hidden_units
 
    def _sigmoid(self, x):
        # 定义Sigmoid激活函数
        return 1 / (1 + np.exp(-x))
 
    def fit(self, X, y):
        # 随机初始化输入权重
        self.input_weights = np.random.randn(X.shape[1], self.n_hidden_units)
        # 随机初始化偏置
        self.biases = np.random.randn(self.n_hidden_units)
        # 计算隐藏层输出矩阵H
        H = self._sigmoid(np.dot(X, self.input_weights) + self.biases)
        # 计算输出权重
        self.output_weights = np.dot(np.linalg.pinv(H), y)
 
    def predict(self, X):
        # 计算隐藏层输出矩阵H
        H = self._sigmoid(np.dot(X, self.input_weights) + self.biases)
        # 返回预测结果
        return np.dot(H, self.output_weights)
 
# 创建数据集并进行预处理
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
# 将标签转换为二维数组（ELM需要二维数组作为标签）
y = y.reshape(-1, 1)
 
# 标准化数据
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
 
# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42)
 
# 训练和比较ELM与MLP
 
# 训练ELM
elm = ELM(n_hidden_units=10)
elm.fit(X_train, y_train)
y_pred_elm = elm.predict(X_test)
# 将预测结果转换为类别标签
y_pred_elm_class = (y_pred_elm > 0.5).astype(int)
# 计算ELM的准确率
accuracy_elm = accuracy_score(y_test, y_pred_elm_class)
 
# 训练MLP
mlp = MLPClassifier(hidden_layer_sizes=(10,), max_iter=1000, random_state=42)
mlp.fit(X_train, y_train.ravel())
# 预测测试集结果
y_pred_mlp = mlp.predict(X_test)
# 计算MLP的准确率
accuracy_mlp = accuracy_score(y_test, y_pred_mlp)
 
# 打印ELM和MLP的准确率
print(f"ELM Accuracy: {accuracy_elm}")
print(f"MLP Accuracy: {accuracy_mlp}")
 
# 可视化结果
def plot_decision_boundary(model, X, y, ax, title):
    # 设置绘图范围
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    # 创建网格
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),
                         np.arange(y_min, y_max, 0.01))
    # 预测网格中的所有点
    Z = model(np.c_[xx.ravel(), yy.ravel()])
    Z = (Z > 0.5).astype(int)
    Z = Z.reshape(xx.shape)
    # 画出决策边界
    ax.contourf(xx, yy, Z, alpha=0.8)
    # 画出数据点
    ax.scatter(X[:, 0], X[:, 1], c=y.ravel(), edgecolors='k', marker='o')
    ax.set_title(title)
 
# 创建图形
fig, axs = plt.subplots(1, 2, figsize=(12, 5))
 
# 画出ELM的决策边界
plot_decision_boundary(lambda x: elm.predict(x), X_test, y_test, axs[0], "ELM Decision Boundary")
# 画出MLP的决策边界
plot_decision_boundary(lambda x: mlp.predict(x), X_test, y_test, axs[1], "MLP Decision Boundary")
 
# 显示图形
plt.show()
 
# 输出：
'''
ELM Accuracy: 0.9666666666666667
MLP Accuracy: 0.9766666666666667
'''

Salida visual:

imagen

El contenido anterior está resumido de Internet. Si es útil, reenvíelo. ¡Hasta la próxima!

Compartir tecnología