引言：为什么选择 scikit-learn 进行深度学习？
在当今人工智能领域，深度学习已经成为解决复杂问题的核心技术。虽然 TensorFlow 和 PyTorch 是主流的深度学习框架，但 scikit-learn 作为 Python 生态中最受欢迎的机器学习库，也提供了强大的神经网络支持，特别适合初学者入门和快速原型开发。
scikit-learn 的 MLP（多层感知机）模块提供了：
简洁的 API
：与其他 scikit-learn 算法一致的接口
自动化的超参数调优
：内置网格搜索和随机搜索
丰富的预处理工具
：数据标准化、归一化等
完善的评估体系
：交叉验证、多种评估指标
无缝的集成能力
：可以轻松与其他机器学习算法组合使用
1. 环境准备与安装
1.1 基础环境配置
首先，确保你的系统中安装了必要的 Python 包。打开终端或命令行，执行以下命令：
# 安装 scikit-learn 及其依赖
pip install scikit-learn numpy pandas matplotlib seaborn
# 如果需要 GPU 支持（可选，scikit-learn 本身不支持 GPU，但可以配合其他库）
pip install tensorflow-gpu # 用于对比实验
# 安装 Jupyter Notebook（推荐用于交互式开发）
pip install jupyter
1.2 验证安装
创建一个 Python 文件或 Jupyter Notebook，运行以下代码验证安装：
import sklearn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
print(f”scikit-learn version: {sklearn.__version__}”)
print(f”numpy version: {np.__version__}”)
print(f”pandas version: {pd.__version__}”)
# 检查 MLP 模块是否可用
from sklearn.neural_network import MLPClassifier, MLPRegressor
print(“MLP modules imported successfully!”)
2. 理解神经网络基础
2.1 神经网络核心概念
在深入代码之前，我们需要理解几个关键概念：
神经元（Neuron）
：神经网络的基本计算单元，接收输入，进行加权求和，然后通过激活函数产生输出。
层（Layer）
：多个神经元组成的结构，包括：
输入层
：接收原始数据
隐藏层
：进行特征提取和转换
输出层
：产生最终预测结果
激活函数
：引入非线性，使网络能够学习复杂模式。常见激活函数：
ReLU：
f(x) = max(0, x)
Sigmoid：
f(x) = 1/(1 + e^(-x))
Tanh：
f(x) = (e^x – e^(-x))/(e^x + e^(-x))
损失函数
：衡量预测值与真实值的差距，如交叉熵、均方误差等。
2.2 scikit-learn 中的神经网络实现
scikit-learn 提供了两个主要的神经网络类：
MLPClassifier
：用于分类任务
MLPRegressor
：用于回归任务
这两个类都实现了多层感知机（MLP），也称为前馈神经网络。
3. 数据准备与预处理
3.1 加载示例数据集
scikit-learn 内置了许多经典数据集，我们使用鸢尾花（Iris）数据集作为第一个例子：
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# 加载数据
iris = load_iris()
X, y = iris.data, iris.target
print(f”数据集形状: {X.shape}”)
print(f”特征名称: {iris.feature_names}”)
print(f”目标类别: {iris.target_names}”)
print(f”前5行数据:\n{X[:5]}”)
3.2 数据预处理：标准化
神经网络对输入数据的尺度非常敏感，标准化是必不可少的步骤：
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# 标准化：将数据转换为均值为0，标准差为1
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
print(f”训练集原始数据均值: {X_train.mean(axis=0)}”)
print(f”训练集原始数据标准差: {X_train.std(axis=0)}”)
print(f”训练集标准化后均值: {X_train_scaled.mean(axis=0)}”)
print(f”训练集标准化后标准差: {X_train_scaled.std(axis=0)}”)
标准化的重要性
：如果特征尺度差异很大（比如一个特征范围是0-1，另一个是0-10000），梯度下降会变得非常不稳定，导致训练困难。
3.3 数据可视化（可选但推荐）
import seaborn as sns
import pandas as pd
# 创建 DataFrame 用于可视化
df = pd.DataFrame(X, columns=iris.feature_names)
df[‘target’] = y
df[‘species’] = df[‘target’].map({0: ‘setosa’, 1: ‘versicolor’, 2: ‘virginica’})
# 绘制特征分布
plt.figure(figsize=(12, 8))
sns.pairplot(df, hue=’species’, vars=iris.feature_names)
plt.suptitle(‘Iris Dataset Feature Pairplot’, y=1.02)
plt.show()
4. 构建第一个神经网络分类器
4.1 基础模型训练
让我们从一个简单的神经网络开始：
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
# 创建 MLP 分类器
mlp = MLPClassifier(
hidden_layer_sizes=(10,), # 1个隐藏层，10个神经元
activation=’relu’, # 激活函数：ReLU
solver=’adam’, # 优化器：Adam
max_iter=500, # 最大迭代次数
random_state=42, # 随机种子
verbose=True # 显示训练过程
)
# 训练模型
mlp.fit(X_train_scaled, y_train)
# 预测
y_pred = mlp.predict(X_test_scaled)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f”\n测试集准确率: {accuracy:.4f}”)
print(“\n分类报告:”)
print(classification_report(y_test, y_pred, target_names=iris.target_names))
4.2 模型结构分析
# 查看模型结构
print(f”隐藏层结构: {mlp.hidden_layer_sizes}”)
print(f”隐藏层层数: {len(mlp.hidden_layer_sizes)}”)
print(f”每层神经元数量: {mlp.hidden_layer_sizes}”)
# 查看权重和偏置
print(f”\n输入层到第一个隐藏层的权重形状: {mlp.coefs_[0].shape}”)
print(f”第一个隐藏层到输出层的权重形状: {mlp.coefs_[1].shape}”)
print(f”第一个隐藏层的偏置形状: {mlp.intercepts_[0].shape}”)
print(f”输出层的偏置形状: {mlp.intercepts_[1].shape}”)
# 查看训练过程中的损失变化
plt.figure(figsize=(10, 6))
plt.plot(mlp.loss_curve_)
plt.title(‘Training Loss Curve’)
plt.xlabel(‘Iteration’)
plt.ylabel(‘Loss’)
plt.grid(True)
plt.show()
5. 超参数调优：提升模型性能
5.1 网格搜索（Grid Search）
超参数的选择对神经网络性能影响巨大。使用
GridSearchCV
进行系统化的参数搜索：
from sklearn.model_selection import GridSearchCV
# 定义参数网格
param_grid = {
‘hidden_layer_sizes’: [(10,), (50,), (100,), (50, 50), (100, 50)],
‘activation’: [‘relu’, ‘tanh’, ‘logistic’],
‘solver’: [‘adam’, ‘sgd’],
‘alpha’: [0.0001, 0.001, 0.01], # L2 正则化参数
‘learning_rate_init’: [0.001, 0.01, 0.1]
}
# 创建基础模型
mlp = MLPClassifier(max_iter=500, random_state=42)
# 创建网格搜索对象
grid_search = GridSearchCV(
mlp,
param_grid,
cv=3, # 3折交叉验证
scoring=’accuracy’,
n_jobs=-1, # 使用所有CPU核心
verbose=2
)
# 执行网格搜索（注意：这可能需要一些时间）
print(“开始网格搜索…”)
grid_search.fit(X_train_scaled, y_train)
# 输出最佳参数
print(f”\n最佳参数: {grid_search.best_params_}”)
print(f”最佳交叉验证分数: {grid_search.best_score_:.4f}”)
# 使用最佳模型进行测试
best_mlp = grid_search.best_estimator_
y_pred_best = best_mlp.predict(X_test_scaled)
print(f”测试集准确率: {accuracy_score(y_test, y_pred_best):.4f}”)
5.2 随机搜索（Randomized Search）
当参数空间很大时，随机搜索通常比网格搜索更高效：
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform
# 定义参数分布
param_dist = {
‘hidden_layer_sizes’: [(10,), (50,), (100,), (50, 50), (100, 50), (200, 100, 50)],
‘activation’: [‘relu’, ‘tanh’, ‘logistic’],
‘solver’: [‘adam’, ‘sgd’],
‘alpha’: uniform(0.0001, 0.01), # 均匀分布
‘learning_rate_init’: uniform(0.001, 0.1),
‘batch_size’: randint(16, 256) # 批大小
}
# 创建随机搜索对象
random_search = RandomizedSearchCV(
mlp,
param_dist,
n_iter=20, # 尝试20组不同的参数组合
cv=3,
scoring=’accuracy’,
n_jobs=-1,
random_state=42,
verbose=2
)
print(“开始随机搜索…”)
random_search.fit(X_train_scaled, y_train)
print(f”\n最佳参数: {random_search.best_params_}”)
print(f”最佳交叉验证分数: {random_search.best_score_:.4f}”)
6. 回归任务实战
6.1 创建回归数据集
from sklearn.datasets import make_regression
from sklearn.neural_network import MLPRegressor
from sklearn.metrics import mean_squared_error, r2_score
# 创建回归数据集
X_reg, y_reg = make_regression(
n_samples=1000,
n_features=20,
n_informative=15,
noise=50,
random_state=42
)
# 划分数据集
X_reg_train, X_reg_test, y_reg_train, y_reg_test = train_test_split(
X_reg, y_reg, test_size=0.2, random_state=42
)
# 标准化
scaler_reg = StandardScaler()
X_reg_train_scaled = scaler_reg.fit_transform(X_reg_train)
X_reg_test_scaled = scaler_reg.transform(X_reg_test)
print(f”回归数据集形状: {X_reg.shape}”)
print(f”目标值范围: [{y_reg.min():.2f}, {y_reg.max():.2f}]”)
6.2 训练回归模型
# 创建回归模型
mlp_reg = MLPRegressor(
hidden_layer_sizes=(100, 50),
activation=’relu’,
solver=’adam’,
max_iter=1000,
random_state=42,
verbose=True
)
# 训练
mlp_reg.fit(X_reg_train_scaled, y_reg_train)
# 预测
y_reg_pred = mlp_reg.predict(X_reg_test_scaled)
# 评估
mse = mean_squared_error(y_reg_test, y_reg_pred)
r2 = r2_score(y_reg_test, y_reg_pred)
print(f”\n均方误差 (MSE): {mse:.2f}”)
print(f”R² 分数: {r2:.4f}”)
# 可视化预测结果
plt.figure(figsize=(10, 6))
plt.scatter(y_reg_test, y_reg_pred, alpha=0.6)
plt.plot([y_reg_test.min(), y_reg_test.max()], [y_reg_test.min(), y_reg_test.max()], ‘r–‘, lw=2)
plt.xlabel(‘真实值’)
plt.ylabel(‘预测值’)
plt.title(‘回归预测结果’)
plt.grid(True)
plt.show()
7. 实战项目：手写数字识别
7.1 加载和探索数据
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler
# 加载手写数字数据集
digits = load_digits()
X_digits, y_digits = digits.data, digits.target
print(f”数据集形状: {X_digits.shape}”)
print(f”图像尺寸: {digits.images[0].shape}”)
print(f”类别数量: {len(np.unique(y_digits))}”)
print(f”每个类别的样本数: {np.bincount(y_digits)}”)
# 可视化一些样本
fig, axes = plt.subplots(2, 5, figsize=(10, 4))
for i, ax in enumerate(axes.flat):
ax.imshow(digits.images[i], cmap=’gray’)
ax.set_title(f”Label: {y_digits[i]}”)
ax.axis(‘off’)
plt.suptitle(‘Handwritten Digits Examples’)
plt.show()
7.2 数据预处理
# 划分数据集
X_digits_train, X_digits_test, y_digits_train, y_digits_test = train_test_split(
X_digits, y_digits, test_size=0.2, random_state=42, stratify=y_digits
)
# 标准化
scaler_digits = StandardScaler()
X_digits_train_scaled = scaler_digits.fit_transform(X_digits_train)
X_digits_test_scaled = scaler_digits.transform(X_digits_test)
# 查看数据范围
print(f”原始数据范围: [{X_digits.min()}, {X_digits.max()}]”)
print(f”标准化后数据范围: [{X_digits_train_scaled.min():.2f}, {X_digits_train_scaled.max():.2f}]”)
7.3 模型训练与评估
# 创建模型
mlp_digits = MLPClassifier(
hidden_layer_sizes=(100, 50),
activation=’relu’,
solver=’adam’,
max_iter=500,
random_state=42,
verbose=False
)
# 训练
print(“训练手写数字识别模型…”)
mlp_digits.fit(X_digits_train_scaled, y_digits_train)
# 预测
y_digits_pred = mlp_digits.predict(X_digits_test_scaled)
# 评估
accuracy = accuracy_score(y_digits_test, y_digits_pred)
print(f”\n测试集准确率: {accuracy:.4f}”)
# 详细分类报告
print(“\n详细分类报告:”)
print(classification_report(y_digits_test, y_digits_pred))
# 混淆矩阵可视化
cm = confusion_matrix(y_digits_test, y_digits_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt=’d’, cmap=’Blues’,
xticklabels=digits.target_names,
yticklabels=digits.target_names)
plt.title(‘Confusion Matrix – Handwritten Digits’)
plt.xlabel(‘Predicted’)
plt.ylabel(‘Actual’)
plt.show()
7.4 查找错误样本
# 找出预测错误的样本
errors = y_digits_pred != y_digits_test
error_indices = np.where(errors)[0]
print(f”总错误数: {len(error_indices)}”)
print(“\n前5个错误样本:”)
for i, idx in enumerate(error_indices[:5]):
actual = y_digits_test[idx]
predicted = y_digits_pred[idx]
print(f”样本 {idx}: 实际={actual}, 预测={predicted}”)
# 显示错误样本图像
plt.subplot(1, 5, i+1)
plt.imshow(digits.images[digits.data.shape[0] – len(error_indices) + idx], cmap=’gray’)
plt.title(f”真: {actual}\n预: {predicted}”)
plt.axis(‘off’)
plt.show()
8. 高级技巧与最佳实践
8.1 早停（Early Stopping）
防止过拟合的重要技术：
# 使用早停
mlp_early_stop = MLPClassifier(
hidden_layer_sizes=(100, 50),
activation=’relu’,
solver=’adam’,
max_iter=200,
early_stopping=True, # 启用早停
validation_fraction=0.1, # 10%数据用作验证集
n_iter_no_change=10, # 10次迭代无改善就停止
random_state=42,
verbose=True
)
mlp_early_stop.fit(X_digits_train_scaled, y_digits_train)
print(f”实际迭代次数: {mlp_early_stop.n_iter_}”)
print(f”最佳验证分数: {mlp_early_stop.best_validation_score_:.4f}”)
8.2 学习率调度
# 使用自适应学习率（Adam 是默认且推荐的）
mlp_adaptive = MLPClassifier(
hidden_layer_sizes=(100, 50),
activation=’relu’,
solver=’adam’,
learning_rate=’adaptive’, # 当学习停滞时自动降低学习率
max_iter=500,
random_state=42
)
mlp_adaptive.fit(X_digits_train_scaled, y_digits_train)
print(f”适应性学习率模型准确率: {mlp_adaptive.score(X_digits_test_scaled, y_digits_test):.4f}”)
8.3 正则化防止过拟合
# L2 正则化
mlp_l2 = MLPClassifier(
hidden_layer_sizes=(100, 50),
activation=’relu’,
solver=’adam’,
alpha=0.05, # L2 正则化参数，越大越强
max_iter=500,
random_state=42
)
mlp_l2.fit(X_digits_train_scaled, y_digits_train)
print(f”L2 正则化模型准确率: {mlp_l2.score(X_digits_test_scaled, y_digits_test):.4f}”)
# 比较不同 alpha 值
alphas = [0.0001, 0.001, 0.01, 0.05, 0.1]
scores = []
for alpha in alphas:
mlp = MLPClassifier(
hidden_layer_sizes=(100, 50),
activation=’relu’,
solver=’adam’,
alpha=alpha,
max_iter=500,
random_state=42
)
mlp.fit(X_digits_train_scaled, y_digits_train)
scores.append(mlp.score(X_digits_test_scaled, y_digits_test))
plt.figure(figsize=(8, 5))
plt.plot(alphas, scores, marker=’o’)
plt.xscale(‘log’)
plt.xlabel(‘Alpha (L2 正则化参数)’)
plt.ylabel(‘测试集准确率’)
plt.title(‘不同正则化强度下的模型性能’)
plt.grid(True)
plt.show()
8.4 批处理大小优化
# 比较不同批处理大小
batch_sizes = [16, 32, 64, 128, 256]
batch_scores = []
for bs in batch_sizes:
mlp = MLPClassifier(
hidden_layer_sizes=(100, 50),
activation=’relu’,
solver=’adam’,
batch_size=bs,
max_iter=500,
random_state=42
)
mlp.fit(X_digits_train_scaled, y_digits_train)
batch_scores.append(mlp.score(X_digits_test_scaled, y_digits_test))
print(f”Batch size {bs}: 准确率 = {batch_scores[-1]:.4f}”)
plt.figure(figsize=(8, 5))
plt.plot(batch_sizes, batch_scores, marker=’s’)
plt.xlabel(‘Batch Size’)
plt.ylabel(‘测试集准确率’)
plt.title(‘不同批处理大小对性能的影响’)
plt.grid(True)
plt.show()
9. 模型保存与加载
9.1 使用 joblib 保存模型
from joblib import dump, load
# 保存模型和标准化器
dump(mlp_digits, ‘mlp_digits_model.joblib’)
dump(scaler_digits, ‘scaler_digits.joblib’)
print(“模型已保存到文件”)
# 加载模型
loaded_model = load(‘mlp_digits_model.joblib’)
loaded_scaler = load(‘scaler_digits.joblib’)
# 验证加载的模型
test_sample = X_digits_test_scaled[0:1]
prediction = loaded_model.predict(test_sample)
print(f”加载模型的预测结果: {prediction}”)
print(f”原始预测结果: {y_digits_pred[0]}”)
9.2 模型部署示例
# 创建一个简单的预测函数
def predict_digit(image_data, model, scaler):
“””
预测手写数字
Parameters:
———–
image_data : array-like
64维特征向量或8×8图像
model : MLPClassifier
训练好的模型
scaler : StandardScaler
标准化器
Returns:
——–
int: 预测的数字
float: 预测概率
“””
# 确保输入是正确的形状
if image_data.ndim == 1:
image_data = image_data.reshape(1, -1)
# 标准化
image_scaled = scaler.transform(image_data)
# 预测
prediction = model.predict(image_scaled)[0]
probabilities = model.predict_proba(image_scaled)[0]
return prediction, probabilities
# 测试预测函数
sample_idx = 42
sample_image = X_digits_test[sample_idx]
actual_label = y_digits_test[sample_idx]
pred, probs = predict_digit(sample_image, loaded_model, loaded_scaler)
print(f”真实标签: {actual_label}”)
print(f”预测标签: {pred}”)
print(f”预测概率分布: {dict(enumerate(probs))}”)
print(f”置信度: {probs[pred]:.4f}”)
# 可视化
plt.imshow(sample_image.reshape(8, 8), cmap=’gray’)
plt.title(f”真实: {actual_label}, 预测: {pred}”)
plt.axis(‘off’)
plt.show()
10. 与 TensorFlow/PyTorch 的对比
10.1 何时选择 scikit-learn
适合 scikit-learn 的场景：
中小型数据集（< 10万样本）
结构化数据（表格数据）
快速原型开发
需要与其他 scikit-learn 工具集成
计算资源有限（CPU 环境）
不适合 scikit-learn 的场景：
大规模数据集
图像、文本、音频等非结构化数据
需要 GPU 加速
需要复杂的网络架构（CNN、RNN、Transformer）
需要自定义训练循环
10.2 性能对比示例
import time
# scikit-learn 训练时间
start_time = time.time()
mlp_sklearn = MLPClassifier(
hidden_layer_sizes=(100, 50),
activation='relu',
solver='adam',
max_iter=100,
random_state=42
)
mlp_sklearn.fit(X_digits_train_scaled, y_digits_train)
sklearn_time = time.time() - start_time
print(f"scikit-learn 训练时间: {sklearn_time:.2f} 秒")
print(f"scikit-learn 准确率: {mlp_sklearn.score(X_digits_test_scaled, y_digits_test):.4f}")
# 注意：TensorFlow/PyTorch 需要额外安装和配置
# 这里仅作概念性对比，不实际运行
print("\n概念性对比（仅供参考）:")
print("TensorFlow/PyTorch 优势:")
print("- GPU 加速支持")
print("- 更灵活的网络架构")
print("- 更适合大规模数据")
print("- 丰富的预训练模型")
print("\nscikit-learn 优势:")
print("- API 简洁统一")
print("- 自动化程度高")
print("- 与传统 ML 算法无缝集成")
print("- 学习曲线平缓")
11. 常见问题与解决方案
11.1 不收敛问题
# 问题：模型不收敛或收敛缓慢
# 解决方案：
# 1. 调整学习率
mlp = MLPClassifier(
hidden_layer_sizes=(100, 50),
learning_rate_init=0.01, # 尝试不同的值
solver='adam',
max_iter=500,
verbose=True
)
# 2. 增加最大迭代次数
mlp = MLPClassifier(
hidden_layer_sizes=(100, 50),
max_iter=2000, # 增加迭代次数
solver='adam'
)
# 3. 调整网络结构
mlp = MLPClassifier(
hidden_layer_sizes=(50,), # 从简单开始
solver='adam',
max_iter=500
)
# 4. 检查数据标准化
print(f"数据均值: {X_train_scaled.mean(axis=0)}")
print(f"数据标准差: {X_train_scaled.std(axis=0)}")
11.2 过拟合问题
# 问题：训练集准确率高，测试集准确率低
# 解决方案：
# 1. 增加正则化
mlp = MLPClassifier(
hidden_layer_sizes=(200, 100),
alpha=0.1, # 增加 L2 正则化
solver='adam',
max_iter=500
)
# 2. 使用早停
mlp = MLPClassifier(
hidden_layer_sizes=(200, 100),
early_stopping=True,
validation_fraction=0.1,
n_iter_no_change=10,
solver='adam',
max_iter=500
)
# 3. 减少网络复杂度
mlp = MLPClassifier(
hidden_layer_sizes=(50, 25), # 减少层数和神经元
solver='adam',
max_iter=500
)
# 4. 增加训练数据（如果可能）
# 或使用数据增强
11.3 数值不稳定问题
# 问题：出现 NaN 或无穷大值
# 解决方案：
# 1. 检查数据质量
print(f"包含 NaN: {np.isnan(X_train_scaled).any()}")
print(f"包含 Inf: {np.isinf(X_train_scaled).any()}")
print(f"数据范围: [{X_train_scaled.min()}, {X_train_scaled.max()}]")
# 2. 使用梯度裁剪（通过调整参数）
mlp = MLPClassifier(
hidden_layer_sizes=(100, 50),
solver='adam',
max_iter=500,
random_state=42
)
# 3. 调整批处理大小
mlp = MLPClassifier(
hidden_layer_sizes=(100, 50),
batch_size=256, # 增大批大小
solver='adam',
max_iter=500
)
12. 完整项目示例：房价预测
12.1 加载波士顿房价数据集
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
# 加载数据
housing = fetch_california_housing()
X_housing, y_housing = housing.data, housing.target
print(f"数据集形状: {X_housing.shape}")
print(f"特征名称: {housing.feature_names}")
print(f"目标值范围: [{y_housing.min():.2f}, {y_housing.max():.2f}]")
# 划分数据集
X_housing_train, X_housing_test, y_housing_train, y_housing_test = train_test_split(
X_housing, y_housing, test_size=0.2, random_state=42
)
# 标准化
scaler_housing = StandardScaler()
X_housing_train_scaled = scaler_housing.fit_transform(X_housing_train)
X_housing_test_scaled = scaler_housing.transform(X_housing_test)
12.2 训练和优化模型
# 创建基础模型
mlp_housing = MLPRegressor(
hidden_layer_sizes=(100, 50),
activation='relu',
solver='adam',
max_iter=1000,
random_state=42,
verbose=False
)
# 训练
mlp_housing.fit(X_housing_train_scaled, y_housing_train)
# 预测
y_housing_pred = mlp_housing.predict(X_housing_test_scaled)
# 评估
mae = mean_absolute_error(y_housing_test, y_housing_pred)
mse = mean_squared_error(y_housing_test, y_housing_pred)
r2 = r2_score(y_housing_test, y_housing_pred)
print(f"平均绝对误差 (MAE): {mae:.4f}")
print(f"均方误差 (MSE): {mse:.4f}")
print(f"R² 分数: {r2:.4f}")
# 可视化
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.scatter(y_housing_test, y_housing_pred, alpha=0.3)
plt.plot([y_housing_test.min(), y_housing_test.max()],
[y_housing_test.min(), y_housing_test.max()], 'r--', lw=2)
plt.xlabel('真实房价')
plt.ylabel('预测房价')
plt.title('预测 vs 真实')
plt.grid(True)
plt.subplot(1, 2, 2)
residuals = y_housing_test - y_housing_pred
plt.scatter(y_housing_pred, residuals, alpha=0.3)
plt.axhline(y=0, color='r', linestyle='--')
plt.xlabel('预测值')
plt.ylabel('残差')
plt.title('残差分析')
plt.grid(True)
plt.tight_layout()
plt.show()
12.3 特征重要性分析
# 注意：scikit-learn 的 MLP 没有直接的特征重要性
# 但我们可以通过排列重要性来近似
from sklearn.inspection import permutation_importance
# 计算排列重要性
result = permutation_importance(
mlp_housing,
X_housing_test_scaled,
y_housing_test,
n_repeats=10,
random_state=42,
n_jobs=-1
)
# 创建特征重要性 DataFrame
feature_importance = pd.DataFrame({
'feature': housing.feature_names,
'importance': result.importances_mean,
'std': result.importances_std
}).sort_values('importance', ascending=False)
print("\n特征重要性（排列重要性）:")
print(feature_importance)
# 可视化
plt.figure(figsize=(10, 6))
plt.barh(feature_importance['feature'], feature_importance['importance'])
plt.xlabel('重要性')
plt.title('特征重要性分析')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.show()
13. 总结与进阶学习路径
13.1 本教程要点回顾
基础概念
：理解了神经网络的核心组件和工作原理
数据准备
：掌握了标准化、数据划分等预处理技巧
模型构建
：学会了使用 MLPClassifier 和 MLPRegressor
超参数调优
：掌握了网格搜索和随机搜索
实战项目
：完成了手写数字识别和房价预测
高级技巧
：早停、正则化、学习率调度等
问题诊断
：学会了常见问题的解决方案
13.2 性能优化检查清单
在实际项目中，按以下顺序优化：
# 优化检查清单代码模板
def optimize_neural_network(X_train, y_train, X_test, y_test, is_classification=True):
"""
神经网络优化检查清单
"""
results = {}
# 1. 数据标准化检查
print("1. 检查数据标准化...")
if hasattr(X_train, 'mean'):
print(f" 训练集均值: {X_train.mean():.4f}")
print(f" 训练集标准差: {X_train.std():.4f}")
# 2. 基础模型测试
print("\n2. 测试基础模型...")
if is_classification:
model = MLPClassifier(hidden_layer_sizes=(50,), max_iter=500, random_state=42)
else:
model = MLPRegressor(hidden_layer_sizes=(50,), max_iter=500, random_state=42)
model.fit(X_train, y_train)
base_score = model.score(X_test, y_test)
results['base'] = base_score
print(f" 基础分数: {base_score:.4f}")
# 3. 增加网络复杂度
print("\n3. 增加网络复杂度...")
if is_classification:
model = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=500, random_state=42)
else:
model = MLPRegressor(hidden_layer_sizes=(100, 50), max_iter=500, random_state=42)
model.fit(X_train, y_train)
complex_score = model.score(X_test, y_test)
results['complex'] = complex_score
print(f" 复杂模型分数: {complex_score:.4f}")
# 4. 添加正则化
print("\n4. 添加正则化...")
if is_classification:
model = MLPClassifier(hidden_layer_sizes=(100, 50), alpha=0.01, max_iter=500, random_state=42)
else:
model = MLPRegressor(hidden_layer_sizes=(100, 50), alpha=0.01, max_iter=500, random_state=42)
model.fit(X_train, y_train)
reg_score = model.score(X_test, y_test)
results['regularized'] = reg_score
print(f" 正则化模型分数: {reg_score:.4f}")
# 5. 使用早停
print("\n5. 使用早停...")
if is_classification:
model = MLPClassifier(hidden_layer_sizes=(100, 50), early_stopping=True,
validation_fraction=0.1, max_iter=500, random_state=42)
else:
model = MLPRegressor(hidden_layer_sizes=(100, 50), early_stopping=True,
validation_fraction=0.1, max_iter=500, random_state=42)
model.fit(X_train, y_train)
early_score = model.score(X_test, y_test)
results['early_stop'] = early_score
print(f" 早停模型分数: {early_score:.4f}")
print("\n优化结果总结:")
for name, score in results.items():
print(f" {name}: {score:.4f}")
return results
# 使用示例
# results = optimize_neural_network(X_digits_train_scaled, y_digits_train,
# X_digits_test_scaled, y_digits_test,
# is_classification=True)
13.3 进阶学习路径
阶段 1：巩固基础
深入理解梯度下降算法
学习反向传播的数学原理
实现一个简单的神经网络从零开始
阶段 2：扩展应用
尝试更复杂的数据集（如 MNIST）
学习特征工程技巧
探索集成学习与神经网络的结合
阶段 3：转向专业框架
学习 TensorFlow/Keras
学习 PyTorch
理解 CNN、RNN 等专业网络结构
阶段 4：生产部署
模型序列化与版本管理
API 服务化（Flask/FastAPI）
模型监控与持续学习
13.4 推荐资源
官方文档
：scikit-learn.org/stable/modules/neural_networks.html
书籍
：《Python Machine Learning》by Sebastian Raschka
在线课程
：Coursera 的 “Machine Learning” by Andrew Ng
实践平台
：Kaggle 竞赛、UCI 机器学习仓库
14. 完整代码模板库
14.1 快速启动模板
"""
scikit-learn 神经网络快速启动模板
适用于分类任务
"""
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, accuracy_score
import numpy as np
def train_neural_network_classifier(X, y, test_size=0.2, random_state=42):
"""
训练神经网络分类器的完整流程
Parameters:
-----------
X : array-like
特征矩阵
y : array-like
目标向量
test_size : float
测试集比例
random_state : int
随机种子
Returns:
--------
dict: 包含模型、标准化器、评估结果的字典
"""
# 1. 数据划分
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=test_size, random_state=random_state, stratify=y
)
# 2. 标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 3. 定义参数网格
param_grid = {
'hidden_layer_sizes': [(50,), (100,), (50, 50)],
'activation': ['relu', 'tanh'],
'solver': ['adam'],
'alpha': [0.0001, 0.001],
'learning_rate_init': [0.001, 0.01]
}
# 4. 网格搜索
base_model = MLPClassifier(max_iter=500, random_state=random_state)
grid_search = GridSearchCV(
base_model, param_grid, cv=3, scoring='accuracy', n_jobs=-1, verbose=1
)
print("开始超参数优化...")
grid_search.fit(X_train_scaled, y_train)
# 5. 最终评估
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)
# 6. 返回结果
results = {
'model': best_model,
'scaler': scaler,
'best_params': grid_search.best_params_,
'cv_score': grid_search.best_score_,
'test_accuracy': accuracy,
'classification_report': classification_report(y_test, y_pred, output_dict=True)
}
print(f"\n最佳参数: {grid_search.best_params_}")
print(f"交叉验证分数: {grid_search.best_score_:.4f}")
print(f"测试集准确率: {accuracy:.4f}")
return results
# 使用示例
if __name__ == "__main__":
from sklearn.datasets import load_iris
# 加载数据
iris = load_iris()
X, y = iris.data, iris.target
# 训练模型
results = train_neural_network_classifier(X, y)
# 保存模型
from joblib import dump
dump(results['model'], 'best_model.joblib')
dump(results['scaler'], 'scaler.joblib')
print("\n模型已保存!")
14.2 回归任务模板
"""
scikit-learn 神经网络快速启动模板
适用于回归任务
"""
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import train_test_split, RandomizedSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from scipy.stats import uniform
def train_neural_network_regressor(X, y, test_size=0.2, random_state=42):
"""
训练神经网络回归器的完整流程
"""
# 数据划分
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=test_size, random_state=random_state
)
# 标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 参数分布
param_dist = {
'hidden_layer_sizes': [(50,), (100,), (50, 50), (100, 50)],
'activation': ['relu', 'tanh'],
'solver': ['adam'],
'alpha': uniform(0.0001, 0.01),
'learning_rate_init': uniform(0.001, 0.01)
}
# 随机搜索
base_model = MLPRegressor(max_iter=500, random_state=random_state)
random_search = RandomizedSearchCV(
base_model, param_dist, n_iter=10, cv=3,
scoring='neg_mean_squared_error', n_jobs=-1, random_state=random_state
)
print("开始超参数优化...")
random_search.fit(X_train_scaled, y_train)
# 评估
best_model = random_search.best_estimator_
y_pred = best_model.predict(X_test_scaled)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
results = {
'model': best_model,
'scaler': scaler,
'best_params': random_search.best_params_,
'cv_score': -random_search.best_score_,
'test_mse': mse,
'test_r2': r2
}
print(f"\n最佳参数: {random_search.best_params_}")
print(f"交叉验证 MSE: {-random_search.best_score_:.4f}")
print(f"测试集 MSE: {mse:.4f}")
print(f"测试集 R²: {r2:.4f}")
return results
# 使用示例
if __name__ == "__main__":
from sklearn.datasets import make_regression
X, y = make_regression(n_samples=1000, n_features=20, random_state=42)
results = train_neural_network_regressor(X, y)
15. 最佳实践总结
15.1 数据准备最佳实践
始终标准化
：神经网络对输入尺度敏感
处理异常值
：极端值会影响梯度下降
检查缺失值
：scikit-learn 不支持缺失值
平衡数据集
：分类任务中确保各类别比例合理
15.2 模型训练最佳实践
从简单开始
：先用小网络，再逐步增加复杂度
使用早停
：防止过拟合，节省训练时间
监控损失曲线
：判断是否收敛或过拟合
交叉验证
：使用 GridSearchCV 或 RandomizedSearchCV
设置随机种子
：确保结果可复现
15.3 超参数调优优先级
隐藏层结构
：最重要，影响模型容量
正则化参数 (alpha)
：防止过拟合
学习率
：影响收敛速度和稳定性
激活函数
：ReLU 通常是最佳起点
批处理大小
：影响训练稳定性和速度
15.4 性能监控指标
# 完整的评估函数
def comprehensive_evaluation(model, X_test, y_test, task_type='classification'):
"""
综合评估模型性能
"""
from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score,
mean_squared_error, mean_absolute_error, r2_score)
y_pred = model.predict(X_test)
if task_type == 'classification':
metrics = {
'accuracy': accuracy_score(y_test, y_pred),
'precision': precision_score(y_test, y_pred, average='weighted'),
'recall': recall_score(y_test, y_pred, average='weighted'),
'f1': f1_score(y_test, y_pred, average='weighted')
}
else:
metrics = {
'mse': mean_squared_error(y_test, y_pred),
'mae': mean_absolute_error(y_test, y_pred),
'r2': r2_score(y_test, y_pred)
}
return metrics
# 使用示例
# metrics = comprehensive_evaluation(best_model, X_test_scaled, y_test, 'classification')
# print(metrics)
结语
通过本教程，你已经掌握了使用 scikit-learn 构建和优化神经网络的完整技能栈。从数据准备到模型训练，从超参数调优到实战项目，每一步都配有详细的代码示例和最佳实践建议。
记住，深度学习的成功不仅在于选择合适的框架，更在于对数据的理解、特征的工程、超参数的细心调优以及对模型行为的持续监控。scikit-learn 作为入门工具，能帮助你快速建立直觉，为将来使用更复杂的框架打下坚实基础。
关键要点回顾
：
✅ 始终标准化输入数据
✅ 从简单模型开始，逐步增加复杂度
✅ 使用交叉验证和早停防止过拟合
✅ 系统化地调优超参数
✅ 监控损失曲线和评估指标
✅ 保存模型和标准化器以便部署
现在，你可以开始自己的深度学习项目了！祝你在人工智能的旅程中取得成功！