BP神经网络MNIST手写数字识别：纯NumPy实现与避坑指南

简介：BP神经网络是机器学习入门的重要模型，手写数字识别则是经典实践任务，适合希望从底层理解深度学习基本原理的Python学习者和计算机视觉初学者。包内提供可直接运行的预测方案与完整训练数据：压缩包共2000个文件，以大量样本图片为主，并包含训练好的权重及偏移量矩阵文件、训练集数据文件、Python脚本、项目配置文件及相关元数据，资源整体约69.36MB；解压后目录层次清晰，模块划分明确，方便按需查阅。已有8756人学习使用，读者既能加载现成模型，输入图片路径后缀快速得到预测结果，也可自行训练模型。尤为适合在IDE中边调试边阅读代码：通过观察前向传播、误差反向传播和参数更新等关键过程，可深入掌握BP算法的实现细节；图片按类别存放，也便于对比不同数字的样本特征。

1. BP神经网络在MNIST手写数字识别上的第一课：最小可复现的Python方案

把 BP 神经网络和 MNIST 手写数字识别放在一起做 Python 实现，几乎是每个入门深度学习的人都会经历的第一道坎。MNIST 是 28×28 像素的灰度手写数字图，BP 神经网络则是把 784 个像素通过两层全连接网络映射到 10 个数字类别上。这个组合看起来简单，但动手写过的人都知道：真正难的不是模型本身，而是数据怎么读、矩阵往哪个方向转置、损失为什么变成 nan、训练集 99% 测试集却只有 90%。这篇文章就是奔着让你亲手跑通这件事去的。我会从网络结构图讲起，给出本地 MNIST 数据的获取和读取方案，再给一份纯 NumPy 手写 BP 的完整源码，最后把最常见的 5 个翻车现场和验证技巧一并讲清楚。适合刚学完 Python 和线性代数、想亲眼看懂反向传播的读者，不适合只想调库跑个结果的人。

2. 先看懂BP神经网络结构图：两次矩阵乘法与三张 shape 表

2.1 三层的BP网络，前向就是在做两次矩阵乘法

MNIST 的每张图是 28×28 像素，按行拉平后得到 784 维向量。BP 神经网络最常见的结构是 784-128-10：输入层 784 个节点，隐藏层 128 个节点，输出层 10 个节点。每一层神经元的计算方式完全一样：拿输入向量乘以权重矩阵，加上偏置，再过一层激活函数。两次矩阵乘法就能完成一次完整的预测。

第一次矩阵乘法发生在输入层到隐藏层。假设一次喂入 m 张图片，输入矩阵 X 的形状是 (m, 784)，权重矩阵 W1 的形状是 (784, 128)，偏置 b1 的形状是 (128,)，那么 z1 = X @ W1 + b1 的形状是 (m, 128)。这里 @ 是 NumPy 里的矩阵乘法。为什么 W1 要设计成 (784, 128) 而不是反过来？因为矩阵乘法的规则是前一个矩阵的列数必须等于后一个矩阵的行数，而结果里每一列对应隐藏层的一个神经元。第 j 个隐藏神经元收到的输入是 X 的 784 个像素各自乘以 W1 第 j 列的 784 个权重再求和，这恰好符合“每个神经元看全图所有像素”的设定。

第二次矩阵乘法发生在隐藏层到输出层。隐藏层输出 a1 的形状是 (m, 128)，权重矩阵 W2 的形状是 (128, 10)，b2 的形状是 (10,)，得到 z2 = a1 @ W2 + b2，形状是 (m, 10)。这 10 个值分别代表这张图属于数字 0 到 9 的“得分”。得分越高，模型越倾向于预测成该数字。为了把得分变成概率，最后一层通常接 softmax：把 10 个得分做指数变换再归一化，让它们的和为 1。这样输出向量的每一个分量就有了清晰的含义——模型认为这张图是数字 i 的概率。

2.2 反向传播的三个核心导数式子

训练的本质是让输出的概率分布贴近真实标签。对单个样本，用交叉熵损失衡量差距：L = -log p_true，其中 p_true 是模型给真实数字的那个概率。真实标签是 3 的图，如果模型输出 p3 = 0.9，损失就是 -log 0.9，很小；如果 p3 = 0.1，损失就很大。对整个 batch，把所有样本的损失取平均，得到最终的损失值。

反向传播就是要计算损失对每个参数的偏导数，然后沿负梯度方向更新参数。有三组公式必须写对：

第一组，输出层误差 δ2。softmax 后面接交叉熵损失时，导数有一个非常简洁的形式：δ2 = p - y_onehot。p 是模型预测的概率分布，y_onehot 是真实标签的 one-hot 编码。这个式子的含义是：如果模型对真实类别给的概率低了，p 和 y 的差就是负数，梯度会把这个概率推上去。

第二组，隐藏层误差 δ1。隐藏层每个神经元的误差来自输出层误差的加权回传：δ1 = (δ2 @ W2.T) * relu'(z1)。W2.T 是把权重矩阵转置，把误差从输出层“分回”隐藏层，逐元素乘以 z1 的导数。如果隐藏层用 ReLU，导数就是 z1 > 0 的位置取 1，否则取 0。ReLU 会把负区间的梯度直接截断，这正是它能缓解梯度消失的原因。

第三组，权重梯度和偏置梯度。拿上一层的输出乘以下一层的误差，再对 batch 取平均：dW2 = a1.T @ δ2 / m，dW1 = X.T @ δ1 / m。这里 X.T 是输入矩阵的转置，目的是让梯度形状和权重矩阵完全一致。偏置梯度简单一些：db2 = δ2 按列求平均，db1 = δ1 按列求平均。

如果把三张 shape 表列出来对比，就能看出每一行代码为什么要转置：

2.3 结构参数怎么定：先选这三组数

输入层 784 和输出层 10 是任务决定的，不能改。隐藏层宽度是第一个要拍板的参数，128 是绝大多数入门例子的默认值。太窄比如 16，模型学不出足够丰富的特征，测试集准确率可能卡在 90% 以下；太宽比如 1024，训练时间成倍上涨，在 MNIST 这种简单任务上收益却很小。隐藏层激活函数选 ReLU 或 sigmoid 都行，ReLU 收敛更快，sigmoid 更贴近 BP 的教科书推导。输出层激活函数必须用 softmax，损失函数必须用交叉熵，这两个搭配起来梯度表达式是简洁的 δ2 = p - y，换成 sigmoid 加均方误差会出现梯度饱和，后面避坑章节详细说。

权重初始化也是一步选型。ReLU 隐藏层推荐 He 初始化：W ~ N(0, sqrt(2 / fan_in))，其中 fan_in 是上一层神经元的数量；sigmoid 隐藏层推荐 Xavier 初始化：W ~ N(0, sqrt(1 / fan_in))。偏置全部初始化为 0。选错了初始化，前几次前向的结果要么无限大要么无限小，反向传播的梯度自然就乱了。

3. 下载并读取MNIST数据：绕开 torchvision 404 的本地方案

3.1 torchvision 下载 MNIST 为什么会 404，手动方案更可控

很多人在第一步加载数据就翻车了。用 torchvision 的 datasets.MNIST 下载 MNIST 时，常会遇到连接超时或者 404 报错，原因是源站证书过期、镜像同步不及时、网络策略等多种因素叠加在一起。我不打算在这里争论谁的责任，只说结论：手动下载 MNIST 原始文件放在本地，比依赖任何框架的自动下载都可靠，而且这个方案完全不依赖 PyTorch，只要 Python 环境里装了 NumPy 就能跑。

MNIST 的原始数据是四个 gz 压缩包，文件名非常固定：

你可以从 MNIST 官网主页找到这四个文件的直链，也可以通过国内镜像或 GitHub 上的 MNIST 镜像仓库下载。下载后建一个 data/mnist 目录，把四个 gz 文件原样放进去，不要去手动解压成二进制文件，因为 Python 的 gzip 模块可以直接读 .gz 压缩流。需要提醒的是，如果从镜像下载，下载完成后核对一下文件大小，确保不是镜像站返回的 404 页面——那是伪装成 gz 文件的 HTML 文本，一读就会报错。

3.2 读图片文件与标签文件：理解 idx 格式的头部

MNIST 使用的是 idx 二进制格式，这种格式的头部信息用大端序存储。图片文件的头部固定 16 字节：前 4 字节是魔数 2051，接着 4 字节是图片数量，再 4 字节是行数，最后 4 字节是列数。标签文件的头部只有 8 字节：魔数 2049，然后就是标签数量。之后的数据就是裸的像素或标签值。读文件时用 struct.unpack 解析头部，用 np.frombuffer 把剩余的字节流直接转成 NumPy 数组，速度比逐个像素读取快好几个数量级。

import gzip import numpy as np import struct def read_idx_images(path): """读取 MNIST 图片文件，返回 (num_samples, 784) 的 float32 数组，像素值已归一化到 [0,1]""" with gzip.open(path, 'rb') as f: # 大端序解析 4 个 32 位无符号整数：魔数、图片数、行数、列数 magic, num, rows, cols = struct.unpack('>IIII', f.read(16)) # 剩余字节就是 num*rows*cols 个像素，按 uint8 读入后 reshape data = np.frombuffer(f.read(), dtype=np.uint8).reshape(num, rows * cols) return data.astype(np.float32) / 255.0 def read_idx_labels(path): """读取 MNIST 标签文件，返回 (num_samples,) 的 uint8 数组，取值 0~9""" with gzip.open(path, 'rb') as f: # 标签文件头部只有 8 字节：魔数和数量 magic, num = struct.unpack('>II', f.read(8)) labels = np.frombuffer(f.read(), dtype=np.uint8) return labels

代码的关键点有三处。第一，gzip.open 直接打开 .gz 文件，读到的已经是解压后的字节流，不需要额外调用 gunzip。第二，struct.unpack 后面跟的 '>IIII' 表示按大端序读取四个无符号整数，I 对应 C 语言里的 unsigned int，正好 4 字节。第三，像素数据用 dtype=np.uint8 读入，因为 MNIST 的像素值是 0 到 255 的整数，读成 uint8 可以节省内存，之后在归一化时再转成 float32。标签文件头部只有 8 字节，如果照搬图片文件的 16 字节读法，会把第一张图的标签吞进头部里，导致标签整体错位一位，这是数据读取最常见的翻车点。

3.3 归一化和核对数据形状

数据读进来之后，不要急着训练，先花一分钟核对形状和取值范围。X_train 应该是 (60000, 784)，即 60000 张图每张拉平成 784 维；y_train 应该是 (60000,)，每个元素是 0 到 9 的整数；X_test 和 y_test 分别是 (10000, 784) 和 (10000,)。

X_train = read_idx_images('data/mnist/train-images-idx3-ubyte.gz') y_train = read_idx_labels('data/mnist/train-labels-idx1-ubyte.gz') X_test = read_idx_images('data/mnist/t10k-images-idx3-ubyte.gz') y_test = read_idx_labels('data/mnist/t10k-labels-idx1-ubyte.gz') # 核对形状和数值范围 assert X_train.shape == (60000, 784), f"train images shape error: {X_train.shape}" assert y_train.shape == (60000,), f"train labels shape error: {y_train.shape}" assert X_test.shape == (10000, 784), f"test images shape error: {X_test.shape}" assert y_test.shape == (10000,), f"test labels shape error: {y_test.shape}" assert X_train.min() >= 0.0 and X_train.max() <= 1.0, "pixel should be normalized to [0,1]" print(f"训练集图片 {X_train.shape}, 标签 {y_train.shape}") print(f"测试集图片 {X_test.shape}, 标签 {y_test.shape}")

为什么归一化这么重要？因为 BP 神经网络的权重更新依赖梯度大小，而梯度大小和输入数值直接相关。输入像素如果保持在 0 到 255，z1 = X @ W1 的值很容易到几百甚至上千，ReLU 输出会很大，反向传播的梯度过大导致权重更新步长失控，损失直接飞掉。把像素除以 255 压到 [0,1] 区间，是确保训练稳定最便宜有效的操作，没有之一。这段代码还起到了“后悔药”的作用：如果你后面发现训练结果不对，先回来确认数据范围，能排除一个非常大的嫌疑变量。

这里还要提一句环境相关的细节：这个方案只需要 Python 3.8+ 和 NumPy，不需要额外安装 PyTorch 或 TensorFlow。如果你连 NumPy 都没有装，用 pip install numpy 一条命令就能解决，装的时候注意核对 pip 是否对应当前 python 解释器，避免出现“装到另一个环境”的混乱。

4. 用NumPy手写BP：前向、反向和梯度更新的落地实现

4.1 初始化：Xavier 和 He 怎么选

准备工作做完，现在开始写模型本身。我用一个 MiniBP 类来组织参数和前向反向逻辑。初始化是最容易马虎的一步，直接决定训练能不能收敛。隐藏层激活函数用 ReLU，权重用 He 初始化，也就是标准差取 sqrt(2 / fan_in)，fan_in 是上一层神经元的个数。如果用 sigmoid 作为隐藏层激活函数，标准差应该改成 sqrt(1 / fan_in)，即 Xavier 初始化，否则 sigmoid 的输出容易在初始化阶段就全部饱和到 0 或 1，梯度一上来就是零。

class MiniBP: def __init__(self, n_in=784, n_hidden=128, n_out=10, lr=0.1): # He 初始化：标准差 sqrt(2 / fan_in)，适合 ReLU 激活 self.W1 = np.random.randn(n_in, n_hidden) * np.sqrt(2.0 / n_in) self.b1 = np.zeros(n_hidden) self.W2 = np.random.randn(n_hidden, n_out) * np.sqrt(2.0 / n_hidden) self.b2 = np.zeros(n_out) self.lr = lr

偏置初始化为零没有风险，因为偏置的梯度是误差的均值，不会出现全部对称的情况。如果想把偏置初始化成随机小数也完全没问题，但在 MNIST 这种任务上没有任何收益。需要注意的是 W1 和 W2 的标准差不一样：W1 的 fan_in 是 784，标准差是 sqrt(2/784) ≈ 0.0505；W2 的 fan_in 是 128，标准差是 sqrt(2/128) ≈ 0.125。隐藏层宽度变小，对应权重的初始范围反而变大，这是为了保证信号在层间传播时方差不衰减。

4.2 前向：ReLU 隐藏层 + softmax 输出层

前向传播把输入从第一层推到最后一层，并把中间变量保存下来，因为反向传播要用到它们。softmax 的实现有一个细节：先对每个输出减去该样本的最大值再做指数运算，防止 exp 溢出。比如某个样本的输出得分是 [1000, 0, 0, ...]，直接算 exp(1000) 会得到 inf，减去最大值后就变成 exp(0)，结果还是 1，数学上等价，数值上安全。

def forward(self, x): # x: (batch_size, 784) self.z1 = x @ self.W1 + self.b1 # (batch_size, 128) self.a1 = np.maximum(0, self.z1) # ReLU 激活 self.z2 = self.a1 @ self.W2 + self.b2 # (batch_size, 10) # softmax，减去最大值保证数值稳定 exp_z2 = np.exp(self.z2 - np.max(self.z2, axis=1, keepdims=True)) self.p = exp_z2 / np.sum(exp_z2, axis=1, keepdims=True) return self.p

代码里 self.a1 在反向传播时会被用到，self.p 是模型对这 batch 所有样本的预测概率分布。求和时用 keepdims=True 保持二维结构，这样 exp_z2 除以的是一个 (batch_size, 1) 的列向量，广播机制会让每一行都正确除以其自身的总和。如果你在这里用 axis=1 但不加 keepdims=True，arr 会变成一维数组，广播时就会出错或者得到完全错误的归一化结果。

这里顺便解释一下为什么输出层必须配 softmax。softmax 把任意实数得分压缩成和为 1 的概率分布，而交叉熵损失在概率值为 1 时取 0，在概率接近 0 时趋向无穷大。两者结合，梯度推导到最后就是 p - y 这样一个线性的简洁形式，反向传播的实现因此非常简单。如果输出层用 sigmoid 而损失用均方误差，梯度会多乘一项 sigmoid 的导数，而 sigmoid 在两端导数趋近于零，训练会变得极慢，甚至看起来像卡住了一样。

4.3 反向传播：用 delta2 = p - y 这个漂亮式子

反向传播的核心是算出每个参数的梯度，然后用梯度下降更新。输出层的梯度 δ2 = p - y_onehot，隐藏层用 W2.T 把误差回传，再乘以 ReLU 的导数。注意 ReLU 的导数在 z1 > 0 的位置是 1，z1 <= 0 的位置是 0，所以 (self.z1 > 0) 这个布尔数组直接当乘法掩码用。

def backward(self, x, y_onehot): m = x.shape[0] # 输出层误差：softmax + 交叉熵 的梯度恰好是 p - y delta2 = self.p - y_onehot # (batch_size, 10) # 隐藏层误差：输出误差加权回传后乘以 ReLU 导数 delta1 = (delta2 @ self.W2.T) * (self.z1 > 0) # (batch_size, 128) # 计算梯度并取 batch 平均 self.grad_W2 = self.a1.T @ delta2 / m # (128, 10) self.grad_W1 = x.T @ delta1 / m # (784, 128) self.grad_b2 = np.sum(delta2, axis=0) / m # (10,) self.grad_b1 = np.sum(delta1, axis=0) / m # (128,) # 梯度下降更新 self.W2 -= self.lr * self.grad_W2 self.b2 -= self.lr * self.grad_b2 self.W1 -= self.lr * self.grad_W1 self.b1 -= self.lr * self.grad_b1

这一段里的除法是整个实现的精髓。除以 m 是为了对 batch 内所有样本的梯度取平均，避免 batch 大小影响学习率的有效步长。如果你去掉这个除法，batch 越大梯度数值越大，同一个学习率下更新的步长就不一致。权重梯度的形状必须和权重完全一致：grad_W2 是 (128, 10)，W2 也是 (128, 10)。为什么 a1.T @ delta2 能拼出这个形状？a1.T 是 (128, batch_size)，delta2 是 (batch_size, 10)，乘起来自然是 (128, 10)，恰好和 W2 对应。这就是矩阵转置在反向传播中的价值：前向是 A @ B，反向求 B 的梯度就用 A.T 去乘误差。

4.4 先跑通一个 batch 再谈训练

写完前向和反向，不要立刻写训练循环，先拿一小批数据验证代码没有硬伤。这一步能帮你区分“原理没懂”和“代码写错”，省掉后面大量的排查时间。

np.random.seed(42) model = MiniBP(n_in=784, n_hidden=128, n_out=10, lr=0.1) # 取前 200 张图作为一个小 batch x_batch = X_train[:200] y_batch = y_train[:200] y_onehot = np.eye(10)[y_batch] # 把整数标签转成 one-hot # 前向 + 反向各跑一次 p = model.forward(x_batch) model.backward(x_batch, y_onehot) # 检查输出和梯度 assert p.shape == (200, 10), f"输出形状错: {p.shape}" assert np.allclose(p.sum(axis=1), 1.0), "softmax 输出应该每行和为 1" assert model.grad_W1.shape == model.W1.shape, "W1 梯度形状不匹配" assert model.grad_W2.shape == model.W2.shape, "W2 梯度形状不匹配" assert np.all(np.isfinite(model.grad_W1)), "梯度出现 inf 或 nan" print(f"batch 前向通过，loss = {-np.log(p[np.arange(200), y_batch]).mean():.4f}")

这里 np.eye(10)[y_batch] 是生成 one-hot 最简洁的写法：np.eye(10) 生成 10×10 的单位矩阵，用 y_batch 作为行索引取出对应的行。p[np.arange(200), y_batch] 取出每个样本在真实类别上的预测概率，取负对数再平均就是这一批的平均交叉熵。如果这段代码没有任何报错，说明前向传播、反向传播、梯度形状三个环节都是自洽的，接下来写训练循环才有意义。

5. 训练循环必备：学习率、隐藏层宽度与观察窗口的取舍

5.1 训练循环骨架与损失曲线的读法

模型类写好了，训练循环本身其实很简单：把数据切成小块，每块做一次前向和反向，把所有样本遍历完算一个 epoch。关键在于循环里要同时记录训练集和测试集的表现，不要只盯着训练集损失。

epochs = 20 batch_size = 128 for epoch in range(epochs): # 每个 epoch 前打乱训练数据，避免固定顺序带来的虚假收敛 idx = np.random.permutation(len(X_train)) X_shuffled, y_shuffled = X_train[idx], y_train[idx] total_loss = 0.0 for i in range(0, len(X_shuffled), batch_size): x_batch = X_shuffled[i:i+batch_size] y_batch = y_shuffled[i:i+batch_size] y_onehot = np.eye(10)[y_batch] p = model.forward(x_batch) # 记录这一批的平均交叉熵，乘 batch 数得到总损失 batch_loss = -np.log(p[np.arange(len(y_batch)), y_batch]).mean() total_loss += batch_loss * len(y_batch) model.backward(x_batch, y_onehot) # 每个 epoch 结束，算一次全量测试集准确率 pred_train = np.argmax(model.forward(X_train[:5000]), axis=1) pred_test = np.argmax(model.forward(X_test), axis=1) acc_train = np.mean(pred_train == y_train[:5000]) acc_test = np.mean(pred_test == y_test) print(f"epoch {epoch+1:02d} | loss {total_loss/len(X_shuffled):.4f} " f"| train acc {acc_train:.4f} | test acc {acc_test:.4f}")

这段代码有四个设计点值得说明。第一，每个 epoch 开头用 np.random.permutation 打乱数据，防止模型学到固定的数据顺序——尤其是 MNIST 的数据本身是按数字排序的，不打乱的话前几个 batch 全是 0 和 1，训练过程会有严重的偏置。第二，测试集准确率在每个 epoch 结束算一次，用 X_test 全量一万张图，实时监控泛化能力；训练集准确率只用前 5000 张估算，省时间，趋势不会看偏。第三，我只在循环里更新了权重，没有加入任何花哨的优化器，SGD 配固定学习率足够让 BP 在 MNIST 上达到 92% 左右。第四，如果你机器不算快，这里全量 60000 张跑 20 个 epoch 在纯 NumPy 下可能要几分钟，属于正常现象，可以用 time 模块记录每个 epoch 的耗时，做到心里有数。

5.2 三个必调参数的参考区间

新手最容易陷入的误区是同时调三个参数，然后不知道是谁起的作用。我一般建议一次只动一个。学习率、隐藏层宽度、epoch 数量是三个最关键的旋钮，每次训练只改一个，其他保持不变，这样损失曲线的变化能直接归因到具体参数上。

学习率是这三个参数里最敏感的一个。0.1 是默认值，大多数情况下能稳定收敛；0.3 在部分随机种子下会出现损失震荡，表现为 loss 曲线不是平稳下降而是毛刺状的上下跳动；大于 1 基本必变 nan。隐藏层宽度 128 已经足够让测试集准确率逼近 95%，换到 256 效果提升可能只有 0.5 个百分点，但训练时间翻倍。epoch 数量可以用“观察训练集准确率和测试集准确率的差距”来定：如果两者都在上升，继续训；如果训练集还在涨而测试集开始持平或下降，说明已经过拟合了，再训下去没有意义。

5.3 先用 2000 张图冒烟测试，再上全量

纯 NumPy 写的 BP 在 CPU 上训练全量 MNIST，20 个 epoch 大约要几分钟到十几分钟，取决于机器性能。调试阶段直接用全量数据，改一次参数就要等一次，效率非常低。我通常的做法是先从全量数据里抽 2000 张训练图和 1000 张测试图，把整个训练循环跑通，等损失曲线正常收敛了，再切回全量数据正式训练。

2000 张图的冒烟测试还有一个额外的好处：它天然等价于一个强正则化环境，模型容量相对数据量偏大，过拟合会非常快地暴露出来。如果你在小数据上训练集准确率能到 100% 而测试集只有 80%，说明模型是能学的，只是数据太少了；如果小数据上训练集准确率也上不去，那就要回头检查数据读取、归一化、初始化这些基础环节，而不是继续调学习率。这个顺序能帮你把“代码有 bug”和“参数没调好”两类问题快速分开，避免在一个错误的方向上浪费大量时间。

6. 避坑：MNIST+BP 最常见的5个翻车现场

下面这几条是我带人做这个项目时反复出现的坑，每条都是现象、原因、解决三步说清。前四条是纯代码层面的问题，第五条是数据获取层面的问题，建议收藏，后面跑其他 BP 项目也能复用。

6.1 现象：训练没几步，损失变成 nan

loss 打印出来先是 2.3 左右，几个 epoch 之后直接变成 nan，或者第一次前向就报溢出警告。原因几乎总是三个其中之一：学习率太大、输入没有归一化、ReLU 输出在深层累积后数值爆炸。学习率 1.0 以上，权重更新一次就可能跳到极远的区域，z1 变成几百上千，softmax 里 exp 溢出；输入像素如果是 0 到 255 的原始值，z1 的初始范围就非常大，梯度的量级会完全失控。解决分三步：把学习率降到 0.1 以下，确认 X_train 已经除以 255，在 forward 里打印 z1 和 z2 的最大值确认没有超过 100。只要这三处都检查过，nan 基本不会再出现。

6.2 现象：损失卡在 0.2 附近，测试集准确率只有 85%

模型能学，但学得不彻底，损失曲线在下滑到某个位置后平滑地停住，不再继续下降。最常见的原因是输出层用了 sigmoid 加均方误差损失。sigmoid 的导数在输出接近 0 或 1 时趋近于 0，误差越大梯度反而越小，这就是梯度饱和。解决方法是把输出层换成 softmax，损失换成交叉熵，让梯度表达式变成干净的 p - y。如果已经是 softmax 加交叉熵组合，那问题可能出在隐藏层宽度太窄，比如只有 32 个神经元，把 n_hidden 调到 128 或 256，损失会继续下降。这个坑之所以隐蔽，是因为它不报错，只表现为效果不理想，很多人会去调学习率，折腾半天也没用。

6.3 现象：训练集准确率 99%，测试集只有 90%

这就是过拟合的典型症状：模型把训练集中的细节背下来了，但对没见过的测试样本泛化能力不足。BP 在 MNIST 上的过拟合出现得不算早，20 个 epoch 以内主要还是在找特征，但当你把 epoch 数拉到 50 以上，或者隐藏层宽度调到 512 以上，过拟合就会变得明显。解决手段性价比从高到低排列：第一是早停，每轮记录测试集准确率，连续几个 epoch 不再提升就停止训练；第二是做数据增强，对每张训练图随机平移两三个像素或者轻微旋转，相当于免费扩充数据量；第三是给损失函数加 L2 正则，也就是在梯度更新时额外加上权重本身的一个小比例，常见系数是 1e-3 量级。先做前两个，效果不够再加正则。

6.4 现象：所有图片都预测成同一个数字，比如全部预测成 7

模型能前向也能反向，loss 也下降了，但最终预测结果集中在某一个类上。这个现象的原因通常是标签和数据错位，或者 one-hot 编码写错。核对方法非常简单：取第一个 batch，打印前 20 张图的真实标签，再手动把 X_train[0] reshape 成 28×28 用 matplotlib 画出来，看看编号和内容是否一致。另一个高频原因是 np.eye(10)[y] 写成了 np.eye(10)[:, y]，前者生成的是 (batch_size, 10)，后者生成的是 (10, batch_size)，形状对不上就会在广播时悄悄出问题。还有个极少见但很坑的原因：初始化时 W 全部用了 np.zeros，导致同一个隐藏层的所有神经元学到完全相同的特征，模型退化成只有输出层在学。用 np.random.randn 初始化权重可以避免这个问题。

6.5 现象：torchvision 下载 MNIST 一直 404，后文没法继续

这个现象在最近很常见。torchvision 的 datasets.MNIST 在部分网络环境下会从源站拉取数据失败，报 404 或者连接超时，个别时候还会残留坏掉的缓存文件到本地，导致重试仍然失败。解决方法是回到第 3 章的手动下载方案：把四个 gz 文件直接下载到 data/mnist 目录，用 read_idx_images 和 read_idx_labels 自己封装的数据读取函数，完全不依赖 torchvision。如果手动下载后发现文件打开报格式错误，用 ls -l 检查文件大小和预期是否一致，镜像站偶尔会返回 HTML 错误页而不是真正的 gz 文件。这个方案还有一个额外好处——数据处理逻辑完全自己掌握，后续想做平移增强、加噪声、按比例划分验证集，都能直接改，比在框架的 Dataset 封装里四处找钩子省心得多。

7. 准确率之外：验证模型是否真的学会了数字

7.1 把错误样本画出来看

测试集准确率达到 95% 之后，大部分人会认为任务完成了。但准确率只是一个数字，它掩盖了模型犯错的模式。把错误样本可视化，你才能知道模型是“不会”还是“粗心”。我用下面的代码找出测试集前 2000 张图里所有预测错的样本，打印前八个：

import matplotlib.pyplot as plt pred = np.argmax(model.forward(X_test[:2000]), axis=1) wrong_idx = np.where(pred != y_test[:2000])[0] print(f"前 2000 张测试图错分了 {len(wrong_idx)} 张") for i in wrong_idx[:8]: plt.imshow(X_test[i].reshape(28, 28), cmap='gray') plt.title(f"真实: {y_test[i]}, 预测: {pred[i]}") plt.show()

观察这些错误样本，你会发现一个规律：4 和 9、3 和 8、7 和 2 这三对数字的混淆占了绝大多数。这完全合理，因为这些数字的手写体在局部结构上高度相似，而 BP 用的是全局像素加权和，缺乏局部模式识别能力。这让你对模型的能力边界有一个直观认识，比记住一个准确率数字重要得多。更进一步，你可以打印一张混淆矩阵，看看模型把哪个类误判成哪个类的次数最多，这比随机翻错误样本更有统计意义。

7.2 测试模型的泛化边界

原始测试集只能说明模型在“干净数据”上的表现，真实场景中的手写数字会有位移、旋转、粗细变化。你可以做一个简单的鲁棒性测试：把测试集每张图随机向左或向右平移两个像素，看看准确率掉多少。

def shift_images(images, dx, dy): """把 (n, 784) 的图片按 dx, dy 平移，边缘填 0""" imgs = images.reshape(-1, 28, 28) shifted = np.roll(np.roll(imgs, dx, axis=2), dy, axis=1) # 把边缘卷绕的部分清零，模拟真位移而不是环形移动 if dx > 0: shifted[:, :, :dx] = 0 elif dx < 0: shifted[:, :, dx:] = 0 if dy > 0: shifted[:, :dy, :] = 0 elif dy < 0: shifted[:, dy:, :] = 0 return shifted.reshape(-1, 784) X_shifted = shift_images(X_test[:2000], dx=2, dy=-1) pred_shifted = np.argmax(model.forward(X_shifted), axis=1) print(f"平移后准确率: {np.mean(pred_shifted == y_test[:2000]):.4f}")

你会看到，原始准确率 95% 的模型，在平移两个像素之后可能掉到 80% 以下。这说明 BP 对位置信息极其敏感，它学到的并不是“数字的形状”，而是“数字出现在固定位置时的像素组合”。这其实从结构上解释了为什么后来的 CNN 要引入卷积和池化——它们天然对局部平移有容忍度。如果你想把 BP 的准确率进一步提升，可以把这个思想反过来用在训练上：在训练阶段对图片做随机平移，让模型看到更多位置变化，测试时的准确率就能回升几个点。这个“测试时做攻击、训练时做增强”的组合，是我做所有图像模型都会走的一步。

做了这么多年数字识别实验，我最大的一个感受是：模型在训练集上的表现是最会说谎的指标，错误样本不会说谎。你可以调参让训练损失降到任意小，但那些错误样本会诚实地告诉你模型的能力边界在哪里。养成“每训完一个模型就画错误样本”这个习惯，能让你在后续做更复杂的任务时省掉大量盲目调参的时间。希望这篇文章能帮你把 BP 神经网络这第一课走扎实，把数据、结构、实现和验证这几个环节串成一个闭环，之后再去碰 CNN、RNN 或者 Transformer，你都不会再觉得“深度学习”这四个字是玄学。希望帮到你。

本文还有配套的精品资源，点击获取