Condivisione della tecnologia

Python32 Extreme Learning Machine ELM

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

immagine

Extreme Learning Machine (ELM) è un semplice algoritmo di apprendimento della rete neurale feedforward (SLFN) a livello singolo. In teoria, gli algoritmi di machine learning estremi (ELM) tendono a fornire buone prestazioni (appartenenti agli algoritmi di machine learning) con velocità di apprendimento estremamente elevate e sono stati proposti da Huang et al. La caratteristica principale di ELM è che la sua velocità di apprendimento è molto rapida rispetto ai tradizionali metodi di discesa del gradiente (come la rete neurale BP), ELM non richiede un processo iterativo. Il principio di base è selezionare in modo casuale i pesi e i bias dello strato nascosto, quindi apprendere i pesi di output minimizzando l'errore dello strato di output.

immagine

immagine

I passaggi principali dell'algoritmo ELM

  1. Inizializza casualmente i pesi e i bias immessi nel livello nascosto：

    • I pesi e i bias degli strati nascosti vengono generati casualmente e rimangono costanti durante l'allenamento.

  2. Calcolare la matrice di output dello strato nascosto (ovvero l'output della funzione di attivazione)：

    • Calcola l'output del livello nascosto utilizzando una funzione di attivazione (come sigmoide, ReLU, ecc.).

  3. Calcolare il peso in uscita：

    • I pesi dallo strato nascosto allo strato di output vengono calcolati con il metodo dei minimi quadrati.

La formula matematica dell'ELM è la seguente:

  • Dato un set di dati di addestramento, dove,

  • La formula di calcolo della matrice di output dello strato nascosto è:

    • dove è la matrice di input, è la matrice dei pesi in input allo strato nascosto, è il vettore di polarizzazione ed è la funzione di attivazione.

  • La formula di calcolo del peso in uscita è:

    • dove è l'inverso generalizzato della matrice di output dello strato nascosto ed è la matrice di output.

Scenari applicativi dell'algoritmo ELM

  1. Elaborazione di set di dati su larga scala: ELM funziona bene durante l'elaborazione di set di dati su larga scala perché la sua velocità di addestramento è molto elevata ed è adatta a scenari che richiedono un addestramento rapido di modelli, come la classificazione di immagini su larga scala, l'elaborazione del linguaggio naturale e altre attività.

  2. Previsioni del settore : ELM ha una vasta gamma di applicazioni nel campo della previsione industriale, come il controllo di qualità e la previsione dei guasti delle apparecchiature nei processi di produzione industriale. Può addestrare rapidamente modelli predittivi e rispondere rapidamente ai dati in tempo reale.

  3. Il settore finanziario : ELM può essere utilizzato per l'analisi e la previsione dei dati finanziari, come la previsione del prezzo delle azioni, la gestione del rischio, il credit scoring, ecc. Poiché i dati finanziari sono generalmente ad alta dimensione, l'elevata velocità di addestramento di ELM è vantaggiosa per l'elaborazione di questi dati.

  4. diagnosi medica : In campo medico, l'ELM può essere utilizzato per attività quali la previsione delle malattie e l'analisi delle immagini mediche. Può addestrare rapidamente modelli e classificare o regredire i dati dei pazienti, aiutando i medici a effettuare diagnosi più rapide e accurate.

  5. Sistema di controllo intelligente : L'ELM può essere utilizzato in sistemi di controllo intelligenti, come case intelligenti, sistemi di trasporto intelligenti, ecc. Apprendendo le caratteristiche e i modelli dell'ambiente, ELM può aiutare il sistema a prendere decisioni intelligenti e migliorare l'efficienza e le prestazioni del sistema.

Python implementa l'algoritmo ELM

Noi usiamomake_moons Set di dati, un set di dati giocattolo comunemente utilizzato per attività di classificazione di machine learning e deep learning. Genera punti distribuiti in due forme a mezzaluna intersecanti, ideali per dimostrare le prestazioni e i limiti decisionali degli algoritmi di classificazione.

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. from sklearn.datasets import make_moons
  4. from sklearn.model_selection import train_test_split
  5. from sklearn.neural_network import MLPClassifier
  6. from sklearn.preprocessing import StandardScaler
  7. from sklearn.metrics import accuracy_score
  8.  
  9. # 定义极限学习机（ELM）类
  10. class ELM:
  11.     def __init__(self, n_hidden_units):
  12.         # 初始化隐藏层神经元数量
  13.         self.n_hidden_units = n_hidden_units
  14.  
  15.     def _sigmoid(self, x):
  16.         # 定义Sigmoid激活函数
  17.         return 1 / (1 + np.exp(-x))
  18.  
  19.     def fit(self, X, y):
  20.         # 随机初始化输入权重
  21.         self.input_weights = np.random.randn(X.shape[1], self.n_hidden_units)
  22.         # 随机初始化偏置
  23.         self.biases = np.random.randn(self.n_hidden_units)
  24.         # 计算隐藏层输出矩阵H
  25.         H = self._sigmoid(np.dot(X, self.input_weights) + self.biases)
  26.         # 计算输出权重
  27.         self.output_weights = np.dot(np.linalg.pinv(H), y)
  28.  
  29.     def predict(self, X):
  30.         # 计算隐藏层输出矩阵H
  31.         H = self._sigmoid(np.dot(X, self.input_weights) + self.biases)
  32.         # 返回预测结果
  33.         return np.dot(H, self.output_weights)
  34.  
  35. # 创建数据集并进行预处理
  36. X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
  37. # 将标签转换为二维数组（ELM需要二维数组作为标签）
  38. y = y.reshape(-1, 1)
  39.  
  40. # 标准化数据
  41. scaler = StandardScaler()
  42. X_scaled = scaler.fit_transform(X)
  43.  
  44. # 拆分训练集和测试集
  45. X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42)
  46.  
  47. # 训练和比较ELM与MLP
  48.  
  49. # 训练ELM
  50. elm = ELM(n_hidden_units=10)
  51. elm.fit(X_train, y_train)
  52. y_pred_elm = elm.predict(X_test)
  53. # 将预测结果转换为类别标签
  54. y_pred_elm_class = (y_pred_elm > 0.5).astype(int)
  55. # 计算ELM的准确率
  56. accuracy_elm = accuracy_score(y_test, y_pred_elm_class)
  57.  
  58. # 训练MLP
  59. mlp = MLPClassifier(hidden_layer_sizes=(10,), max_iter=1000, random_state=42)
  60. mlp.fit(X_train, y_train.ravel())
  61. # 预测测试集结果
  62. y_pred_mlp = mlp.predict(X_test)
  63. # 计算MLP的准确率
  64. accuracy_mlp = accuracy_score(y_test, y_pred_mlp)
  65.  
  66. # 打印ELM和MLP的准确率
  67. print(f"ELM Accuracy: {accuracy_elm}")
  68. print(f"MLP Accuracy: {accuracy_mlp}")
  69.  
  70. # 可视化结果
  71. def plot_decision_boundary(model, X, y, ax, title):
  72.     # 设置绘图范围
  73.     x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
  74.     y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
  75.     # 创建网格
  76.     xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),
  77.                          np.arange(y_min, y_max, 0.01))
  78.     # 预测网格中的所有点
  79.     Z = model(np.c_[xx.ravel(), yy.ravel()])
  80.     Z = (Z > 0.5).astype(int)
  81.     Z = Z.reshape(xx.shape)
  82.     # 画出决策边界
  83.     ax.contourf(xx, yy, Z, alpha=0.8)
  84.     # 画出数据点
  85.     ax.scatter(X[:, 0], X[:, 1], c=y.ravel(), edgecolors='k', marker='o')
  86.     ax.set_title(title)
  87.  
  88. # 创建图形
  89. fig, axs = plt.subplots(1, 2, figsize=(12, 5))
  90.  
  91. # 画出ELM的决策边界
  92. plot_decision_boundary(lambda x: elm.predict(x), X_test, y_test, axs[0], "ELM Decision Boundary")
  93. # 画出MLP的决策边界
  94. plot_decision_boundary(lambda x: mlp.predict(x), X_test, y_test, axs[1], "MLP Decision Boundary")
  95.  
  96. # 显示图形
  97. plt.show()
  98.  
  99. # 输出：
  100. '''
  101. ELM Accuracy: 0.9666666666666667
  102. MLP Accuracy: 0.9766666666666667
  103. '''

Uscita visiva:

immagine

Il contenuto di cui sopra è un riepilogo da Internet. Se è utile, inoltralo. Alla prossima.

Profilo personale

Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro

le mie informazioni di contatto

Posta