sklearn.neural_network 是 scikit-learn 庫中的一個模組，提供了建立和訓練神經網路模型的工具。scikit-learn 是一個廣泛使用的 Python 機器學習庫，以其簡潔性和高效性著稱。該庫的設計理念是透過簡潔的介面和高效的實現，使使用者能夠快速構建和應用機器學習模型。neural_network 模組特別實現了多層感知器（MLP），這是一種前饋人工神經網路，適用於各種分類和迴歸任務。該模組的引數化設計允許使用者根據具體需求調整模型結構和訓練過程，從而在處理複雜的非線性問題時獲得更好的效能。透過與 scikit-learn 生態系統中的其他工具（如資料預處理、模型評估和交叉驗證）的無縫整合，使用者可以實現從資料準備到模型訓練再到模型評估的完整工作流。這種高可用性和易用性，使得 sklearn.neural_network 成為機器學習應用中構建神經網路模型的理想選擇，無論是用於學術研究、工業應用還是個人專案。
一、sklearn.neural_network模組
sklearn官方神經網路文件
sklearn.neural_network 是 scikit-learn 庫中的一個模組，提供了建立和訓練神經網路模型的工具。scikit-learn 是一個廣泛使用的 Python 機器學習庫，以其簡潔性和高效性著稱。neural_network 模組包括多層感知器 (MLP) 的實現，這是一種前饋人工神經網路。多層感知器（MLP）是神經網路中的一種基本型別，由一個輸入層、一個或多個隱藏層和一個輸出層組成。每一層的神經元透過權重連線，與上一層的輸出和下一層的輸入相關聯。MLP 透過調整這些權重來學習和預測。
在 neural_network 模組中，主要包含兩個類：MLPClassifier 和 MLPRegressor。MLPClassifier 用於分類任務，而 MLPRegressor 用於迴歸任務。這兩個類都具有高度的可配置性，可以透過引數設定來調整網路的結構和訓練過程。例如，可以透過 hidden_layer_sizes 引數來設定隱藏層的數量和每層的神經元數量；透過 activation 引數來選擇啟用函式，如 ReLU、tanh、logistic 等；透過 solver 引數來選擇最佳化演算法，如 SGD、Adam、LBFGS 等。
除了基本引數配置外，MLPClassifier 和 MLPRegressor 還支援多種訓練和最佳化技巧，例如早停法（early stopping）、正則化（regularization）以及批次歸一化（batch normalization）。這些技巧可以幫助提高模型的泛化能力，防止過擬合，並加速訓練過程。
在實際應用中，neural_network 模組廣泛應用於影像識別、語音識別、自然語言處理等領域。其簡潔的介面和強大的功能，使得使用者可以快速構建和訓練神經網路模型。無論是初學者還是有經驗的研究人員，sklearn.neural_network 都提供了便捷的工具來實現複雜的機器學習任務。
二、 Sklearn.neural_network模組簡述
MLPClassifier 是 scikit-learn 庫中的一個類，專門用於分類任務。它實現了用於監督學習的多層感知器（MLP）演算法，支援二分類和多分類。MLPClassifier 可以透過設定不同的引數來調整模型的結構和訓練過程，例如設定隱藏層的數量和神經元的數量，選擇適當的啟用函式和最佳化演算法。它的高可配置性使得使用者能夠靈活地應用於各種分類問題。MLPRegressor 也是 scikit-learn 庫中的一個類，主要用於迴歸任務。與 MLPClassifier 類似，MLPRegressor 也實現了多層感知器演算法，但設計上側重於預測連續值。它同樣支援對模型結構和訓練過程的高度自定義，可以透過引數設定來最佳化模型效能。MLPRegressor 適用於各種迴歸問題，例如預測房價、股市走勢等連續值資料。總體來說，這兩個類為使用者提供了強大的工具，用於解決不同型別的機器學習任務。
2.1 MLPClassifier 和 MLPRegressor 的關鍵特性
- 隱藏層：可以使用
hidden_layer_sizes引數指定隱藏層的數量和每個隱藏層中的神經元數量。 - 啟用函式：可用的啟用函式包括
'identity'、'logistic'、'tanh'和'relu'。 - 求解器：可以使用不同的最佳化演算法如
'lbfgs'、'sgd'和'adam'來訓練模型。 - 學習率：支援各種學習率排程和策略。
- 正則化：可以使用
alpha引數應用正則化技術以防止過擬合。 - 早停：如果驗證分數停止提高，可以提前停止訓練，這有助於避免過擬合。
2.2 用法示例
以下是如何使用 MLPClassifier 來訓練一個分類任務的神經網路的示例：
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report
# 生成一個合成資料集
X, y = make_classification(n_samples=1000, n_features=20, n_classes=3, random_state=42)
# 將資料集分為訓練集和測試集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 標準化特徵（均值=0，方差=1）
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# 建立並訓練 MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(100,), max_iter=300, activation='relu', solver='adam', random_state=42)
mlp.fit(X_train, y_train)
# 進行預測
y_pred = mlp.predict(X_test)
# 評估模型
print(classification_report(y_test, y_pred))
2.3 引數說明
- hidden_layer_sizes：一個元組，表示隱藏層中神經元的數量。例如，
(100,)表示一個隱藏層，包含 100 個神經元。 - activation：隱藏層的啟用函式。選項有
'identity'、'logistic'、'tanh'、'relu'。 - solver：用於權重最佳化的最佳化器。
'lbfgs'是一種準牛頓法，'sgd'是隨機梯度下降，'adam'是一種基於隨機梯度的最佳化器。 - alpha：L2 懲罰（正則化項）引數。
- batch_size：隨機最佳化器的小批次大小。
- learning_rate：權重更新的學習率排程。選項有
'constant'、'invscaling'、'adaptive'。 - max_iter：最大迭代次數。求解器迭代直到收斂或達到此迭代次數。
- random_state：隨機數生成的種子。
| 屬性導圖 | 方法導圖 |
|---|---|
 |
 |
三、Python演算法
3.1 神經網路示例1
# 首先我們要匯入科學計算庫，用於一些科學計算
import numpy as np # 為numpy起一個別名，呼叫使用起來會很方便
# 現在匯入神經網路中的一個多分類模型，用於訓練多分類資料
from sklearn.neural_network import MLPClassifier
# 現在匯入sklearn中的用於評測預測結果指標的庫，如混淆矩陣和分類報告
from sklearn.metrics import confusion_matrix,classification_report
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# 載入iris資料集
iris = load_iris()
X_data = iris.data
y_data = iris.target
# 定義資料預處理函式
def preprocess(X,y):
# 對資料的處理我通常會都放入這個函式中，下面將列出部分處理步驟，根據實際情況進行處理
# 資料提取
# 特徵縮放
X_min = np.min(X)
X_max = np.max(X)
X = (X - X_min) / (X_max - X_min)
# 資料初始化
X = np.c_[np.ones(len(X)),X]
y = np.c_[y]
# 資料洗牌
np.random.seed(1)
m = len(X)
o = np.random.permutation(m)
X = X[o]
y = y[o]
# 資料切割
d = int(0.7 * m)
X_train,X_test = np.split(X,[d])
y_train,y_test = np.split(y,[d])
# 資料處理基本完畢，返回處理好的資料
return X_train,X_test,y_train,y_test
# 呼叫資料處理函式，獲得處理好的資料
X_train,X_test,y_train,y_test = preprocess(X_data,y_data)
"""
主要引數：
hidden_layer_sizes: 隱藏層單元數(tuple)，如(100,100,100,50)
activation : 啟用函式，{‘identity’, ‘logistic’, ‘tanh’, ‘relu’}, 預設 ‘relu‘; [f(x) = x, 1/(1+exp(-x)), tanh(x), max(0, x)]
solver : 解決器, {‘lbfgs’, ‘sgd’, ‘adam’}, 預設 ‘adam’; [牛頓法,隨機梯度下降, 自適應momemtum]
alpha : L2正則化引數，float, 可選，預設0.0001
batch_size : 批次，可選, 不適用於’lbfgs’, 預設 ‘auto‘, 此時，batch_size=min(200, n_samples)`
learning_rate : 學習率, {‘constant’, ‘invscaling’, ‘adaptive’}, 預設 ‘constant’, 只適用於梯度下降sgd
learning_rate_init : 學習率初始值, 可選, 預設 0.001, 僅適用於sgd或adam
power_t : 下降指數, 可選, 預設 0.5, 適用於’invscaling’,learning_rate_init/pow(t,power_t), 僅適用於sgd
max_iter : 最大迭代數, 可選, 預設200, 迭代器收斂迭代次數，對於sgd/adam, 代表的是epochs數目，不是下降步數
shuffle : 每次迭代, 是否洗牌, 可選, 預設True,僅適用於sgd或adam
random_state: 預設None; 若int, 隨機數產生器seed, 若RandomStates例項, 隨機數產生器, 若None, np.random
tol : 容忍度, 可選, 預設le-4, 連續兩次迭代loss達不到此值，除非設定成’adaptive’,否則，就停止迭代，
beta_1 : adam指數衰減引數1，可選, 預設0.9
beta_2 : adam指數衰減引數2，可選, 預設0.999
epsilon : adam數值穩定值，可選，預設1e-8
"""
# 首先，建立一個多分類模型物件 類似於Java的類呼叫
# 括號中填寫多個引數，如果不寫，則使用預設值，我們一般要構建隱層結構，除錯正則化引數，設定最大迭代次數
mlp = MLPClassifier(hidden_layer_sizes=(400,100),alpha=0.01,max_iter=300)
# 呼叫fit函式就可以進行模型訓練，一般的呼叫模型函式的訓練方法都是fit()
mlp.fit(X_train,y_train.ravel()) # 這裡y值需要注意，還原成一維陣列
# 模型就這樣訓練好了，而後我們可以呼叫多種函式來獲取訓練好的引數
# 比如獲取準確率
print('訓練集的準確率是：',mlp.score(X_train,y_train))
# 比如輸出當前的代價值
print('訓練集的代價值是：',mlp.loss_)
# 比如輸出每個theta的權重
print('訓練集的權重值是：',mlp.coefs_)
# 混淆矩陣和分類報告是評價預測值和真實值的一種指標
# 混淆矩陣可以直觀的看出分類中正確的個數和分錯的個數，以及將正確的樣本錯誤地分到了哪個類別
matrix_train = confusion_matrix(y_train,mlp.predict(X_train))
print('訓練集的混淆矩陣是：',matrix_train)
# 分類報告中有多個指標用於評價預測的好壞。
'''
TP: 預測為1(Positive)，實際也為1(Truth-預測對了)
TN: 預測為0(Negative)，實際也為0(Truth-預測對了)
FP: 預測為1(Positive)，實際為0(False-預測錯了)
FN: 預測為0(Negative)，實際為1(False-預測錯了)
'''
report_train = classification_report(y_train,mlp.predict(X_train))
print('訓練集的分類報告是：\n', report_train)
3.2 神經網路示例2
import numpy as np
import pandas as pd
from sklearn.neural_network import MLPRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
# 載入加州房價資料集
housing = fetch_california_housing()
feature = housing.data
target = housing.target
xtrain, xtest, ytrain, ytest = train_test_split(feature, target, train_size=0.7, random_state=421)
nn = MLPRegressor(hidden_layer_sizes=(100, 100), activation="identity", shuffle=False, solver="lbfgs", alpha=0.001)
model = nn.fit(xtrain, ytrain)
pre = model.predict(xtest)
print(pre)
print(ytest)
print(model.coefs_)
print(model.n_layers_)
print(model.n_outputs_)
print(model.score(xtest, ytest))
index = 0
for w in model.coefs_:
index += 1
print('第{}層網路層:'.format(index))
print('權重矩陣:', w.shape)
print('係數矩陣：', w)
plt.plot(range(len(pre)), pre, color='red', label='Predicted')
plt.plot(range(len(ytest)), ytest, color='blue', label='Actual')
plt.legend()
plt.show()
3.3 神經網路示例3
| 序號 | x1 | x2 | y | 序號 | x1 | x2 | y |
|---|---|---|---|---|---|---|---|
| 1 | -3 | -2 | 0.6589 | 10 | -0.3 | -0.2 | -0.2875 |
| 2 | -2.7 | -1.8 | 0.2206 | 11 | 0 | -2.22 | 0 |
| 3 | -2.4 | -1.6 | -0.1635 | 12 | 0.3 | 0.2 | 0.3035 |
| 4 | -2.1 | -1.4 | -0.4712 | 13 | 0.6 | 0.4 | 0.5966 |
| 5 | -1.8 | -1.2 | -0.6858 | 14 | 0.9 | 0.6 | 0.8553 |
| 6 | -1.5 | -1 | -0.7975 | 15 | 1.2 | 0.8 | 1.06 |
| 7 | -1.2 | -0.8 | -0.804 | 16 | 1.5 | 1 | 1.1975 |
| 8 | -0.9 | -0.6 | -0.7113 | 17 | 1.8 | 1.2 | 1.2618 |
| 9 | -0.6 | -0.4 | -0.5326 |
import numpy as np
from sklearn.neural_network import MLPRegressor
import matplotlib.pyplot as plt
import networkx as nx
# Data
x1 = np.array([-3, -2.7, -2.4, -2.1, -1.8, -1.5, -1.2, -0.9, -0.6, -0.3, 0, 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
x2 = np.array([-2, -1.8, -1.6, -1.4, -1.2, -1, -0.8, -0.6, -0.4, -0.2, -2.2204, 0.2, 0.4, 0.6, 0.8, 1, 1.2])
y = np.array([0.6589, 0.2206, -0.1635, -0.4712, -0.6858, -0.7975, -0.8040,
-0.7113, -0.5326, -0.2875, 0, 0.3035, 0.5966, 0.8553, 1.0600, 1.1975, 1.2618])
# Prepare input data
inputData = np.vstack((x1, x2)).T # shape (17, 2)
# Initialize the neural network
np.random.seed(88888) # Set random seed for reproducibility
net = MLPRegressor(hidden_layer_sizes=(3,), activation='tanh', solver='lbfgs', max_iter=15000, tol=0.0001, random_state=88888)
# Train the network
net.fit(inputData, y)
# Extract weights and biases
weights = net.coefs_
biases = net.intercepts_
# Create a directed graph
G = nx.DiGraph()
# Add nodes for input, hidden, and output layers
input_nodes = ['x1', 'x2']
hidden_nodes = ['h1', 'h2', 'h3']
output_node = ['y']
# Adding nodes to graph
G.add_nodes_from(input_nodes, layer='input')
G.add_nodes_from(hidden_nodes, layer='hidden')
G.add_nodes_from(output_node, layer='output')
# Connect input layer to hidden layer
for i, input_node in enumerate(input_nodes):
for h, hidden_node in enumerate(hidden_nodes):
weight = weights[0][i][h]
G.add_edge(input_node, hidden_node, weight=f'{weight:.2f}')
# Connect hidden layer to output layer
for h, hidden_node in enumerate(hidden_nodes):
weight = weights[1][h][0]
G.add_edge(hidden_node, output_node[0], weight=f'{weight:.2f}')
# Position the nodes in layers
pos = {'x1': (0, 1), 'x2': (0, -1),
'h1': (1, 2), 'h2': (1, 0), 'h3': (1, -2),
'y': (2, 0)}
# Draw the graph
plt.figure(figsize=(10, 8))
nx.draw(G, pos, with_labels=True, node_size=3000, node_color='lightblue', arrowsize=20, font_size=10, font_weight='bold')
# Draw edge labels (weights)
edge_labels = {(u, v): d['weight'] for u, v, d in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=10)
# Add bias labels to hidden and output nodes
for i, hidden_node in enumerate(hidden_nodes):
bias_label = f'bias: {biases[0][i]:.2f}'
x, y = pos[hidden_node]
plt.text(x, y-0.4, bias_label, fontsize=10, ha='center', bbox=dict(facecolor='white', alpha=0.5))
output_bias_label = f'bias: {biases[1][0]:.2f}'
x, y = pos[output_node[0]]
plt.text(x, y-0.4, output_bias_label, fontsize=10, ha='center', bbox=dict(facecolor='white', alpha=0.5))
plt.title('Neural Network Structure with Weights and Biases')
plt.show()
總結
sklearn.neural_network 模組提供了強大的工具來建立和訓練神經網路，使其適用於分類和迴歸任務。憑藉其靈活性和與 scikit-learn 生態系統的無縫整合，這個模組成為機器學習實踐者的寶貴資源。透過 MLPClassifier 和 MLPRegressor 類，使用者可以方便地實現多層感知器模型，這些模型可以處理複雜的非線性問題。模組支援多種啟用函式和最佳化演算法，並提供正則化和早停等機制來防止過擬合。其引數化設計允許使用者根據具體需求調整模型結構，如設定隱藏層數量、神經元數量和學習率等。此外，透過與其他 scikit-learn 工具（如資料預處理、模型評估和交叉驗證）結合使用，可以實現從資料準備到模型訓練再到模型評估的完整工作流。這種高可用性和易用性，使得 sklearn.neural_network 成為機器學習應用中構建神經網路模型的理想選擇，無論是用於學術研究、工業應用還是個人專案。
參考文獻
- 一個簡單的神經網路例子
- 機器學習之sklearn（一）neural_network調庫實現
- 神經網路——基於sklearn的引數介紹及應用
- Sklearn中的資料處理流程和神經網路導圖學習