从零手写BP神经网络：Python实现手写数字识别

先讲一个很常见的现象：很多初学者在学神经网络时，概念能看懂、结构图能看懂，但一到“自己写代码训练模型”这一步就卡住了。网上资料要么偏重数学推导，要么直接丢给你一个封装好的模型，中间缺了“公式如何映射到代码”这一层。这篇文章就是为了解决这个问题。

我会围绕神经网络的核心原理，先解释前向传播、反向传播、梯度下降这些关键概念，再用手写代码的方式实现一个 BP 神经网络，完成一个经典的手写数字识别任务。最后还会补充 scikit-learn 和 PyTorch 两种更工程化的实现方式，以及常见报错和排查思路。

无论你是刚接触机器学习的学生，还是需要在业务里快速验证模型效果的开发者，本文都适合。读完之后，你不仅能看到代码，还能清楚说出每一行代码在做什么、为什么这样做。

1. 背景与核心概念

1.1 什么是神经网络

神经网络是一种受生物神经元结构启发的机器学习模型。它的基本组成单位是“神经元”，每个神经元接收多个输入，对输入进行加权求和，再经过一个“激活函数”产生输出。大量神经元分层连接，就构成了神经网络。

通俗理解：神经网络本质上是一个“带参数的复杂函数”。输入数据经过层层计算，最终得到预测结果。训练过程就是不断调整参数，让预测结果越来越接近真实答案。

专业一点的定义是：神经网络由输入层、若干隐藏层和输出层组成，每层包含若干神经元。相邻层之间通过权重连接，每个神经元还有一个偏置项。模型的表达能力来自“多层非线性变换”，所以深度神经网络才能拟合非常复杂的函数。

1.2 常见神经网络类型

神经网络不是一个单一模型，而是一大家族。初学者经常听到各种名词，这里先梳理一下：

本文聚焦在“BP神经网络 + 分类任务”上，这是理解其他所有神经网络的基础。先把最简单的搞懂，后面学 CNN、RNN、Transformer 会顺畅很多。

1.3 神经网络能解决什么问题

神经网络擅长解决“输入到输出的映射关系很复杂、很难用规则显式描述”的问题。比如：

• 图像分类：给一张图片，判断是猫还是狗。
• 文本分类：给一段评论，判断是正向还是负向。
• 价格预测：根据手机配置参数，预测价格区间。
• 信号识别：根据传感器数据，判断设备状态。

在本文的实战项目中，我们会让神经网络根据手写数字的像素值，识别出这是数字 0 到 9 中的哪一个。

2. 环境准备与版本说明

2.1 环境清单

为了方便读者复现，本文全部代码基于 Python。建议使用以下环境：

• 操作系统：Windows / macOS / Linux 均可
• Python 版本：3.8 及以上
• 核心依赖：NumPy、scikit-learn、Matplotlib
• 可选依赖：PyTorch（用于进阶示例）

版本不需要完全一致，本文代码使用的都是非常稳定的 API。如果你的环境版本偏旧或偏新，通常不影响运行。关键依赖安装命令如下：

pip install numpy scikit-learn matplotlib

如果要用 PyTorch 示例，可参考 PyTorch 官网的安装命令，根据你的 CUDA 版本选择 CPU 或 GPU 版本。本文示例即使只用 CPU 也能运行。

2.2 项目结构

为了便于阅读，本文的实战代码按下面结构组织：

neural-network-practice/ ├── data_prepare.py # 数据加载与预处理 ├── model.py # 神经网络模型定义 ├── train.py # 训练与评估脚本 └── requirements.txt # 依赖清单

当然，你也可以把所有代码写在一个 Jupyter Notebook 或一个 .py 文件里。分文件是为了代码更清晰，实际学习阶段怎么方便怎么来。

2.3 先理解数据：手写数字数据集

本文使用 scikit-learn 内置的 digits 数据集。它包含 1797 张 8x8 的手写数字图片，每张图片对应一个标签 0-9。

每张图片被展开成 64 个像素值，所以每条样本是一个 64 维向量。这是一个非常适合入门的多分类任务。

加载数据只需要一行代码：

from sklearn.datasets import load_digits digits = load_digits() X = digits.data # 特征，形状 (1797, 64) y = digits.target # 标签，形状 (1797,)

这里 X 的每一行代表一张图片，每一列代表一个像素位置，像素值范围是 0-16。训练之前我们需要对这个数据进行归一化。

3. 神经网络核心原理拆解

在写代码之前，必须先把原理讲清楚。否则代码只是“抄下来”，换一个场景就不会用了。

3.1 神经元与激活函数

一个神经元做的事情非常简单：把输入向量 x 与权重向量 w 做点积，加上偏置 b，再经过激活函数 f。

用公式表示：

z = w1*x1 + w2*x2 + ... + wn*xn + b a = f(z)

为什么需要激活函数？如果只有线性加权，无论堆多少层，整个网络仍然等价于一个线性模型，无法学习复杂模式。激活函数引入了非线性，让网络有能力拟合复杂函数。

常见的激活函数有三种：

• Sigmoid：输出范围 (0,1)，适合二分类输出层，但容易梯度消失。
• ReLU：输出 max(0,z)，计算简单，隐藏层首选。
• Softmax：把一组实数变成概率分布，适合多分类输出层。

在本文的手写实现中，隐藏层使用 Sigmoid，输出层为了演示反向传播也用 Sigmoid。这是一个适合教学的简化选择。实际工程中通常隐藏层用 ReLU，输出层用 Softmax。

3.2 前向传播

前向传播就是数据从输入层流入，经过隐藏层，最后从输出层产生预测结果的过程。

假设网络结构是 64 -> 32 -> 10，表示输入层 64 个神经元，隐藏层 32 个神经元，输出层 10 个神经元。

每层的计算如下：

z1 = X @ W1 + b1 a1 = sigmoid(z1) z2 = a1 @ W2 + b2 a2 = sigmoid(z2)

其中 X 形状是 (n_samples, 64)，W1 形状是 (64, 32)，W2 形状是 (32, 10)。a2 是最终输出，形状是 (n_samples, 10)，表示每个样本属于 10 个类别的预测得分。

前向传播的代码比较容易理解，难点在后面：如何根据预测结果与真实标签的差距，去更新 W1、b1、W2、b2。

3.3 损失函数

损失函数用来说明“模型预测得有多差”。预测越准，损失越小。

本文使用均方误差（MSE）：

L = (1 / n) * sum((a2 - y_onehot)^2)

其中 y_onehot 是标签的独热编码。比如数字 3 对应的独热编码是 [0,0,0,1,0,0,0,0,0,0]。

损失函数的选择会影响反向传播的公式推导。初学者最容易在这里迷失，所以我后面会用代码配合公式一起解释。

3.4 反向传播与梯度下降

训练神经网络的核心是：计算损失函数对每个参数的梯度，然后沿梯度的反方向更新参数，让损失变小。

梯度下降更新公式：

W = W - learning_rate * dW

其中 learning_rate 是学习率，控制每次更新的步长。学习率太大，模型无法收敛；学习率太小，训练速度很慢。

反向传播就是利用链式法则，从输出层开始，逐层向前计算梯度。下面用本文的简化模型推导三个关键梯度：

输出层误差：

delta2 = (a2 - y_onehot) * a2 * (1 - a2)

这里 (a2 - y_onehot) 来自损失函数对 a2 的导数，a2 * (1 - a2) 来自 Sigmoid 的导数。

隐藏层误差：

delta1 = (delta2 @ W2.T) * a1 * (1 - a1)

权重梯度：

dW2 = a1.T @ delta2 dW1 = X.T @ delta1

偏置梯度：

db2 = np.sum(delta2, axis=0) db1 = np.sum(delta1, axis=0)

这里 @ 表示矩阵乘法，.T 表示转置。如果对公式不熟，不必焦虑，下一章会用完整代码逐行解释。

3.5 为什么需要数据归一化

神经网络对输入数据的尺度很敏感。如果某些特征的数值范围很大（比如 0-1000），某些特征范围很小（比如 0-1），权重更新的速度会不一致，导致训练不稳定、收敛慢。

归一化就是把数据缩放到类似的范围内。常见做法是标准化：

from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test)

注意一个关键细节：只能用训练集的数据去 fit scaler，然后分别 transform 训练集和测试集。如果把测试集也拿去 fit，会造成“数据泄露”，得到偏乐观的评估结果。

4. 完整实战：用 NumPy 手写 BP 神经网络

这一章是全文的核心。我们会从零手写一个两层 BP 神经网络，完成手写数字识别任务。这里不依赖任何深度学习框架，只用 NumPy，这样你能清楚看到每一行代码在做什么。

4.1 创建项目结构与数据准备

首先建立训练脚本。为了简化，这里把数据准备和模型训练放在同一个文件里讲解，你可以按模块拆分。

创建文件 train.py，先写数据加载部分：

# 文件路径：neural-network-practice/train.py import numpy as np from sklearn.datasets import load_digits from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.metrics import accuracy_score # 1. 加载数据 digits = load_digits() X = digits.data y = digits.target # 2. 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42, stratify=y ) # 3. 归一化 scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) print("训练集大小:", X_train_scaled.shape) print("测试集大小:", X_test_scaled.shape)

代码解释：

• train_test_split 将数据划分为 80% 训练、20% 测试。
• random_state=42 固定随机种子，保证每次运行结果一致。
• stratify=y 让训练集和测试集中各类别比例保持一致，对不平衡数据集很有用。
• scaler.fit_transform 先在训练集上计算均值和标准差，再执行标准化。
• 测试集只调用 transform，确保使用训练集的统计量。

4.2 独热编码与激活函数

接下来实现两个辅助函数：独热编码和 Sigmoid 激活函数。

def one_hot_encode(y, num_classes=10): """将标签向量转为独热编码矩阵""" n = len(y) result = np.zeros((n, num_classes)) for i in range(n): result[i, y[i]] = 1 return result def sigmoid(z): """Sigmoid 激活函数""" return 1 / (1 + np.exp(-z)) def sigmoid_derivative(a): """Sigmoid 的导数，输入是 sigmoid 的输出""" return a * (1 - a)

这里解释一个新手常见困惑：sigmoid_derivative 接收的是 sigmoid 的输出 a，而不是输入 z。因为 Sigmoid 函数有一个漂亮的性质：

sigmoid'(z) = sigmoid(z) * (1 - sigmoid(z)) = a * (1 - a)

所以在反向传播时，我们直接用前向传播保存下来的 a 就可以计算导数，不需要保存 z。

4.3 初始化参数

神经网络训练前需要随机初始化权重。初始化方式会影响训练效果。

def initialize_parameters(input_size, hidden_size, output_size): """初始化权重和偏置""" np.random.seed(42) W1 = np.random.randn(input_size, hidden_size) * 0.01 b1 = np.zeros((1, hidden_size)) W2 = np.random.randn(hidden_size, output_size) * 0.01 b2 = np.zeros((1, output_size)) return W1, b1, W2, b2

为什么 W 要乘 0.01？

因为 randn 生成的是标准正态分布随机数，标准差为 1。如果输入维度很大，加权求和 z = X @ W 的方差会随维度增长，数值会很大。数值太大经过 Sigmoid 后容易饱和，梯度接近 0，导致训练停滞。乘以 0.01 可以把初始权重压到比较小的范围，是一个简单有效的初始化策略。

4.4 前向传播

前向传播负责完成一次从输入到输出的计算，同时保存中间结果，供反向传播使用。

def forward_propagation(X, W1, b1, W2, b2): """前向传播，返回输出和缓存""" Z1 = np.dot(X, W1) + b1 A1 = sigmoid(Z1) Z2 = np.dot(A1, W2) + b2 A2 = sigmoid(Z2) cache = { "Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2, } return A2, cache

逐行解释：

• np.dot(X, W1) + b1：线性变换，X 形状 (m, 64)，W1 形状 (64, 32)，结果 Z1 形状 (m, 32)。
• A1 = sigmoid(Z1)：对 Z1 中每个元素套上非线性激活。
• np.dot(A1, W2) + b2：隐藏层输出到输出层，A1 形状 (m, 32)，W2 形状 (32, 10)，结果 Z2 形状 (m, 10)。
• A2 = sigmoid(Z2)：最终输出，每个样本对应 10 个类别的得分。

cache 字典保存中间结果。在反向传播中，计算梯度需要用到 A1、A2，所以必须保存下来。

4.5 反向传播

反向传播是 BP 神经网络最核心、也最容易写错的部分。需要严格对照矩阵形状来检查。

def backward_propagation(X, y_onehot, cache, W1, W2): """反向传播，计算梯度""" A1 = cache["A1"] A2 = cache["A2"] m = X.shape[0] # 输出层误差 dZ2 = (A2 - y_onehot) * sigmoid_derivative(A2) dW2 = np.dot(A1.T, dZ2) / m db2 = np.sum(dZ2, axis=0, keepdims=True) / m # 隐藏层误差 dZ1 = np.dot(dZ2, W2.T) * sigmoid_derivative(A1) dW1 = np.dot(X.T, dZ1) / m db1 = np.sum(dZ1, axis=0, keepdims=True) / m gradients = { "dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2, } return gradients

我们对照矩阵形状来验证：

• A2 形状 (m, 10)，y_onehot 形状 (m, 10)，sigmoid_derivative(A2) 形状 (m, 10)，所以 dZ2 形状是 (m, 10)。
• dW2 = A1.T @ dZ2：A1.T 形状 (32, m)，dZ2 形状 (m, 10)，结果形状 (32, 10)，和 W2 一致。
• dZ1 = dZ2 @ W2.T：dZ2 形状 (m, 10)，W2.T 形状 (10, 32)，结果形状 (m, 32)，和 Z1 一致。
• dW1 = X.T @ dZ1：X.T 形状 (64, m)，dZ1 形状 (m, 32)，结果形状 (64, 32)，和 W1 一致。

这里除以 m 是求平均梯度。初学者经常忘掉这个除法，会导致梯度偏大，学习率需要调得很小。

4.6 梯度下降更新参数

得到梯度后，用梯度下降更新参数：

def update_parameters(W1, b1, W2, b2, gradients, learning_rate): """使用梯度下降更新参数""" W1 -= learning_rate * gradients["dW1"] b1 -= learning_rate * gradients["db1"] W2 -= learning_rate * gradients["dW2"] b2 -= learning_rate * gradients["db2"] return W1, b1, W2, b2

这段代码非常直观：参数沿着负梯度方向移动一小步，步长由 learning_rate 控制。

4.7 完整训练循环

把前面的函数组装起来，进行多轮迭代训练：

def compute_loss(A2, y_onehot): """均方误差损失""" m = y_onehot.shape[0] loss = np.sum((A2 - y_onehot) ** 2) / m return loss def train(X_train, y_train, X_test, y_test, hidden_size=32, learning_rate=0.5, epochs=3000): """完整训练流程""" input_size = X_train.shape[1] output_size = 10 # 独热编码 y_train_onehot = one_hot_encode(y_train, output_size) y_test_onehot = one_hot_encode(y_test, output_size) # 初始化参数 W1, b1, W2, b2 = initialize_parameters(input_size, hidden_size, output_size) for epoch in range(epochs): # 前向传播 A2, cache = forward_propagation(X_train, W1, b1, W2, b2) # 计算损失 loss = compute_loss(A2, y_train_onehot) # 反向传播 gradients = backward_propagation(X_train, y_train_onehot, cache, W1, W2) # 更新参数 W1, b1, W2, b2 = update_parameters(W1, b1, W2, b2, gradients, learning_rate) # 每 500 轮打印一次损失 if epoch % 500 == 0: print(f"Epoch {epoch}, Loss: {loss:.4f}") return W1, b1, W2, b2

在训练过程中，打印损失值是一个非常好的习惯。通过观察损失是否在下降，可以快速判断模型是否在正常学习。

4.8 预测与评估

训练完成后，我们需要在新的测试集上评估模型效果：

def predict(X, W1, b1, W2, b2): """预测类别""" A2, _ = forward_propagation(X, W1, b1, W2, b2) return np.argmax(A2, axis=1) # 训练 W1, b1, W2, b2 = train( X_train_scaled, y_train, X_test_scaled, y_test, hidden_size=32, learning_rate=0.5, epochs=3000 ) # 预测 y_train_pred = predict(X_train_scaled, W1, b1, W2, b2) y_test_pred = predict(X_test_scaled, W1, b1, W2, b2) # 评估 train_acc = accuracy_score(y_train, y_train_pred) test_acc = accuracy_score(y_test, y_test_pred) print(f"训练集准确率: {train_acc:.4f}") print(f"测试集准确率: {test_acc:.4f}")

np.argmax(A2, axis=1) 的含义是：对每个样本，取输出向量中得分最高的位置作为预测类别。例如输出 [0.1, 0.05, 0.6, 0.25] 对应 10 个数字的得分，argmax 得到 2，说明模型预测这张图片是数字 2。

这个手写神经网络的准确率通常能达到 95% 以上。虽然和深度学习框架相比不算高，但它完全由你自己实现，每一步都透明可查，这是最好的入门方式。

4.9 可视化训练曲线

为了更直观地观察训练过程，可以用 Matplotlib 绘制损失曲线：

import matplotlib.pyplot as plt loss_history = [] for epoch in range(epochs): A2, cache = forward_propagation(X_train, W1, b1, W2, b2) loss = compute_loss(A2, y_train_onehot) loss_history.append(loss) gradients = backward_propagation(X_train, y_train_onehot, cache, W1, W2) W1, b1, W2, b2 = update_parameters(W1, b1, W2, b2, gradients, learning_rate) plt.plot(range(epochs), loss_history) plt.xlabel("Epoch") plt.ylabel("Loss") plt.title("Training Loss Curve") plt.show()

如果损失曲线平稳下降并逐渐趋平，说明模型训练正常。如果损失震荡剧烈，可能是学习率偏大；如果损失下降缓慢，可能是学习率偏小。

5. 进阶实战：用框架快速实现

手写代码是为了理解原理，工程实践中我们通常使用深度学习框架。下面用一个更高效的 MLPClassifier 和 PyTorch 示例做对比。

5.1 使用 scikit-learn 的 MLPClassifier

scikit-learn 提供了封装好的多层感知机分类器，几行代码就能训练：

from sklearn.neural_network import MLPClassifier mlp = MLPClassifier( hidden_layer_sizes=(32,), activation='relu', solver='adam', max_iter=500, random_state=42 ) mlp.fit(X_train_scaled, y_train) print(f"sklearn 测试集准确率: {mlp.score(X_test_scaled, y_test):.4f}")

这里的参数含义：

• hidden_layer_sizes=(32,)：一个隐藏层，32 个神经元。
• activation='relu'：隐藏层激活函数用 ReLU。
• solver='adam'：优化器用 Adam，一种自适应学习率的梯度下降变体。
• max_iter=500：最大迭代次数。

对比手写实现，MLPClassifier 内置了更多优化策略，比如自动调整学习率、更稳定的初始化方法，所以训练速度更快、效果也更好。初学者可以同时跑手写版和框架版，对比差异。

5.2 使用 PyTorch 实现

PyTorch 是目前最主流的深度学习框架之一。用 PyTorch 实现相同任务，代码结构更接近工程实践：

import torch import torch.nn as nn import torch.optim as optim # 转换为 PyTorch Tensor X_train_t = torch.tensor(X_train_scaled, dtype=torch.float32) y_train_t = torch.tensor(y_train, dtype=torch.long) X_test_t = torch.tensor(X_test_scaled, dtype=torch.float32) y_test_t = torch.tensor(y_test, dtype=torch.long) # 定义模型 model = nn.Sequential( nn.Linear(64, 32), nn.ReLU(), nn.Linear(32, 10), ) # 损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 训练 for epoch in range(300): # 前向传播 outputs = model(X_train_t) loss = criterion(outputs, y_train_t) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 50 == 0: print(f"Epoch {epoch}, Loss: {loss.item():.4f}") # 评估 with torch.no_grad(): test_outputs = model(X_test_t) _, predicted = torch.max(test_outputs, 1) test_acc = (predicted == y_test_t).sum().item() / len(y_test_t) print(f"PyTorch 测试集准确率: {test_acc:.4f}")

代码中有几个和手写版区别明显的地方：

• nn.Linear(64, 32) 自动管理权重和偏置，不需要手动初始化。
• CrossEntropyLoss 内部包含了 Softmax 和交叉熵计算，输出层不需要手动加 Softmax。
• optimizer.zero_grad() 每次清零梯度，因为 PyTorch 默认会累加梯度。
• loss.backward() 自动计算所有参数的梯度。
• optimizer.step() 根据梯度更新参数。
• torch.no_grad() 关闭梯度跟踪，评估阶段不需要计算梯度，可以节省内存。

实际上 PyTorch 的自动求导机制，做的就是我们在第四章手写的反向传播。理解手写版本后，再看这里会自动计算梯度，会更有感触。

5.3 三个版本对比

建议新手按照“手写实现 -> sklearn -> PyTorch”的顺序学习。先知道原理，再使用工具，最后落地到复杂项目。

6. 常见问题与排查思路

神经网络在实操中会遇到各种问题，下面整理几个高频问题，每个都附上排查思路和解决方案。

6.1 Loss 一直不下降怎么办

这是最常见的问题。排查顺序建议如下：

第一步，先检查数据是否归一化。如果输入特征尺度差异大，模型很难学习。这一步最简单，也最容易忽略。

第二步，检查学习率。可以把学习率从 0.5 改成 0.1、0.01 依次尝试。如果损失曲线震荡明显，大概率是学习率过大。

第三步，检查梯度是否计算正确。可以用“数值梯度检查法”：对每个参数加上一个极小量 epsilon，用数值方式近似计算梯度，和反向传播结果对比。如果两者相差很小，说明反向传播实现正确；如果相差很大，说明公式写错了。

6.2 训练时间长怎么办

如果训练集很大，或者模型层数很多，手写的 Python 循环会非常慢。这时建议切换到 PyTorch 或 TensorFlow 等框架，它们底层做了大量矩阵运算优化。

工程上还有一个常用技巧：先用小批量数据试跑，确认代码逻辑没有问题，再扩大到全量数据训练。这样调试效率会高很多。

6.3 准确率上不去

准确率上不去的原因很多，建议按下面的优先级排查：

1. 数据问题：标签是否有错误？数据是否有噪声？
2. 归一化问题：是否对训练集和测试集分别用了正确的统计量？
3. 模型容量：隐藏层神经元数量是否足够？是否增加一个隐藏层？
4. 训练轮数：是否训练次数太少，Loss 还没收敛？
5. 特征工程：原始特征是否过于稀疏？是否可以提取更有意义的特征？

记住一个原则：先确保模型在训练集上能学到东西，再考虑测试集表现。如果训练集准确率都不高，说明模型容量不够或训练方式有问题；如果训练集高但测试集低，则是过拟合问题。

7. 最佳实践与工程建议

理论学习结束后，在实际项目中写神经网络代码，有几个经验特别值得分享。

7.1 固定随机种子

神经网络训练有随机性，每次运行结果可能不一样。为了实验可复现，务必在程序入口固定随机种子：

import numpy as np import random import torch np.random.seed(42) random.seed(42) torch.manual_seed(42)

这样可以让实验结果可复现，方便对比不同参数的效果。

7.2 数据标准化要防止信息泄露

再次强调：scaler 只能用训练集 fit，测试集只能 transform。如果整个数据集一起 fit，测试集信息会“泄露”到训练过程中，导致验证结果偏乐观。这在工程上是非常严重的错误。

7.3 训练/验证/测试三集划分

简单项目只划分训练集和测试集就够了，但正式项目建议划分成三份：

• 训练集：用于更新模型参数。
• 验证集：用于调参和模型选择。
• 测试集：只在最终评估时使用一次。

如果不单独划分验证集，很容易把测试集反复用来调参，导致测试集结果失真。

7.4 日志与可视化

训练时一定要记录关键指标，包括每个 epoch 的损失、准确率、学习率。建议用日志文件保存，不要只打印到控制台。训练完成后画出损失曲线和准确率曲线，能直观判断模型是否收敛。

7.5 模型保存与加载

训练一个好模型需要时间，训练完一定要保存。NumPy 手写模型可以保存为 .npy 文件，PyTorch 模型保存为 .pt 文件：

# NumPy 方式 np.save("W1.npy", W1) np.save("W2.npy", W2) # PyTorch 方式 torch.save(model.state_dict(), "model.pt")

后续推理时直接加载参数，不用重新训练。

7.6 调参顺序

超参数调优不要上来就随机搜索，建议按以下顺序：

1. 先确定学习率：在 0.1、0.01、0.001 中粗筛。
2. 再调整隐藏层大小：从 32、64、128 中逐一尝试。
3. 然后调整网络深度：从 1 个隐藏层开始，逐步增加。
4. 最后做精细调参：在最优附近微调。

每轮只改一个变量，保证实验结果可解释。

8. 总结与后续学习路线

本文从一个完整的“公式到代码”视角，带你实现了 BP 神经网络并完成了手写数字识别任务。你现在应该能说清楚下面几个问题：

• 神经网络的前向传播是如何计算出预测结果的。
• 损失函数如何量化模型好坏。
• 反向传播如何利用链式法则计算梯度。
• 梯度下降如何更新权重和偏置。
• 为什么需要激活函数、归一化、随机种子。

如果你能把第四章的手写代码独立写出来，说明神经网络的基础已经比较扎实了。接下来可以沿着下面的路线继续深入：

• 学习卷积神经网络（CNN）：理解卷积、池化、特征图，适用于图像任务。
• 学习循环神经网络（RNN）与 LSTM：理解序列建模，适用于文本与时间序列。
• 学习 Transformer 与注意力机制：这是现代大语言模型的基础。
• 学习图神经网络（GNN）：适用于社交网络、推荐系统等图结构数据。
• 学习 PyTorch 进阶用法：Dataset、DataLoader、迁移学习、分布式训练。

实际项目中使用神经网络时，优先关注三件事：数据质量、过拟合控制、实验可复现。模型结构反而是相对容易调整的部分。建议你动手把本文的代码完整跑一遍，然后尝试修改隐藏层大小、学习率、激活函数，观察结果变化。亲手调试一次，比看十篇文章都有效。

如果这篇文章对你有帮助，可以先收藏备用，也欢迎留言交流你在跑代码时遇到的问题。