企业官网建设流程全解析

简介：围绕MNIST手写数字识别任务整理的一套可复现实验材料，面向深度学习与机器学习入门读者、课程实验和项目练手场景，重点解决从数据集训练到模型调用之间的衔接问题。压缩包共5个文件，以3个Python脚本和2个H5模型文件为主，前者对应训练与推理流程，后者包含模型参数权重及完整模型，整体约1.39MB，体积轻便，便于本地保存与迁移。已有6131人学习，说明其在入门实践群体中具有一定参考价值。读者可据此了解前馈神经网络在MNIST上的建模思路，对照脚本梳理数据加载、网络搭建、训练保存与加载预测等环节，并利用现成模型快速验证手写数字识别效果；也可作为进一步调参与对比实验的起点，对需要完成课程作业、复现基础实验或搭建演示原型的读者较为友好。

1. 一份能直接加载的权重文件，比十篇教程都实在

很多人第一次接触深度学习，都是从 MNIST 数据集训练手写数字识别模型开始的。但真正的分水岭不在“跑通”，而在“跑完之后能留下什么”。多数教程到print(accuracy)就结束了，你手里只剩一段无法复用的脚本，下次要用还得从头训练。这份资源的思路不一样：它把一个前馈神经网络从数据读取、前向传播、反向传播到权重落盘，做成了一个闭环，最后交付的是一个.npz权重文件加一段不到 30 行的推理代码——拿到新图片，改个路径就能出结果。

它适合两类人。一类是刚学完反向传播公式、想知道“梯度到底怎么落到矩阵乘法上”的开发者，代码里没有框架黑盒，每一层的前向缓存和反向误差都摊开写；另一类是要在边缘设备或老旧环境里塞一个小模型的人，纯 NumPy 实现，几十 KB 的权重，不依赖任何深度学习运行时。接下来按目录结构、数据管线、网络实现、训练闭环、踩坑记录、二次开发六段拆，代码都能直接抄。

2. 项目结构与技术栈：从 raw 数据到权重文件的四层划分

先把目录摊开看。这类项目最怕的就是所有逻辑挤在一个train.py里，改一处牵动全身。合理的组织方式是按“数据 → 模型 → 训练 → 推理”四层切开，每层只暴露一个入口函数，层与层之间靠 ndarray 传递，不传对象、不传路径。

2.1 目录骨架与每个文件的职责边界

mnist-mlp/ ├── data/ │ ├── train-images-idx3-ubyte.gz │ ├── train-labels-idx1-ubyte.gz │ ├── t10k-images-idx3-ubyte.gz │ └── t10k-labels-idx1-ubyte.gz ├── mnist_mlp/ │ ├── __init__.py │ ├── data.py # idx 格式解析 + 归一化 + 批次切分 │ ├── model.py # 参数初始化、前向、反向、保存/加载 │ ├── train.py # 训练循环、学习率调度、验证与落盘 │ └── predict.py # 单张图推理入口 ├── artifacts/ │ └── mnist_mlp.npz # 训练好的权重 ├── requirements.txt └── README.md

这个划分的关键在data.py和model.py的边界。data.py只负责把二进制文件变成(N, 784)的 float32 矩阵和(N,)的 int 标签，不关心模型长什么样；model.py只吃矩阵，不关心数据从哪来。好处是后面想把 MNIST 换成自己的手写数据集，只改data.py一个文件，模型和训练代码一行不动。我见过太多项目把归一化写在train.py的循环里，结果推理时忘了做同样的预处理，精度直接掉到 10%，这种翻车完全可以在结构上避免。

artifacts/单独放权重文件也是刻意的。训练产物和源码分离，.gitignore里排除掉artifacts/之后，仓库干净，权重文件可以单独分发。原始数据放data/而不是每次运行时从网络拉，是为了离线环境能跑——很多内网机器没有外网，下载那一步就卡死了。

2.2 为什么用 NumPy 手写而不是直接上框架

技术选型上，这份代码选了纯 NumPy 实现前馈网络，而不是 PyTorch 或 TensorFlow。这个决定不是“为了教学而教学”，有几个实打实的理由。

第一是部署体积。一个 784-128-64-10 的四层 MLP，参数量大约 11 万，float32 存下来压缩后不到 400KB。用框架训练出来的模型，哪怕导出成 ONNX，运行时也得带上几百 MB 的依赖。如果目标是把模型塞进一个已有的 C++ 或 Java 服务里做简单分类，NumPy 权重文件可以手工解析，格式就是 zip 包里的几个.npy，读起来毫无门槛。

第二是可调试性。手写反向传播意味着梯度是显式算出来的，哪一层出错，打一行print(grad_norm)就能定位。框架里梯度是自动微分给的，遇到梯度消失或者爆炸，你只能靠猜和试。学习阶段这个东西的价值很高——你得先知道dW = a_prev.T @ dz是怎么来的，后面用框架才有判断力。

第三是依赖极简。requirements.txt里只有numpy和pillow（推理时读图片用）。没有 CUDA 版本冲突，没有 cuDNN 匹配问题，pip install -r requirements.txt在任何 Python 3.8+ 环境里都能一次过。这一点在“帮别人跑起来”的场景下太重要了，我自己被 CUDA 版本坑过不止一次。

2.3 网络结构参数与计算量估算

模型是标准的全连接前馈网络，三层隐藏层：

十万级参数量是个很舒服的规模。单次前向传播是 784×128 + 128×64 + 64×10 ≈ 11 万次乘加，一个 batch 128 张就是 1400 万次浮点运算，普通 CPU 上跑完 60000 张训练集一个 epoch 大概 1 到 2 秒，20 个 epoch 半分钟出头就能收敛到 97% 以上。这个速度意味着你可以放心地做超参搜索，改个学习率重跑一次也就几十秒，不像大模型那样一次实验要等半天。

隐藏层维度选 128 和 64 而不是更宽的 512，是因为 MNIST 本身信息量有限。784 维输入里大量像素是边缘的 0，真正有判别力的特征集中在中间 20×20 的区域。128 维的隐层已经足够编码数字的笔画走向，再宽就是过拟合。实测 256-128 的结构精度提升不到 0.3 个百分点，训练时间却翻倍，性价比不高。当然这是针对这份数据的结论，换成更复杂的手写字符集就得重新调。

3. 数据管线与网络实现：一次前向传播的完整链路

这一章把数据读取和前向/反向传播的代码逐段拆开。两者放一起讲，是因为它们的维度必须严格对齐——data.py输出的(B, 784)和model.py第一层的W1形状(784, 128)是一对强耦合，任何一边改了，另一边必须同步。

3.1 idx 格式解析：绕开框架自己读二进制

MNIST 的原始文件是 idx 格式，本质是“魔数 + 维度信息 + 裸数据”的大端序二进制。很多人习惯用框架自带的datasets.MNIST，但既然选了纯 NumPy 路线，就得自己解析。逻辑不复杂，坑主要在字节序和文件头长度上。

# mnist_mlp/data.py import gzip import numpy as np def load_images(path): """读取 idx3-ubyte 格式的图片文件，返回 (N, 784) 的 float32 矩阵""" with gzip.open(path, 'rb') as f: # 文件头固定 16 字节：magic(4) + 图片数(4) + 行数(4) + 列数(4) header = f.read(16) n = int(np.frombuffer(header[4:8], dtype='>i4')[0]) # 大端序 int32 rows = int(np.frombuffer(header[8:12], dtype='>i4')[0]) cols = int(np.frombuffer(header[12:16], dtype='>i4')[0]) buf = f.read(n * rows * cols) # 一次性 frombuffer 再 reshape，比逐张读快两个数量级 images = np.frombuffer(buf, dtype=np.uint8).reshape(n, rows * cols) return images.astype(np.float32) / 255.0 # 归一化到 [0, 1] def load_labels(path): """读取 idx1-ubyte 格式的标签文件，返回 (N,) 的 uint8 数组""" with gzip.open(path, 'rb') as f: header = f.read(8) # magic(4) + 数量(4) n = int(np.frombuffer(header[4:8], dtype='>i4')[0]) return np.frombuffer(f.read(n), dtype=np.uint8)

dtype='>i4'里的>表示大端序，这是整个函数最容易写错的地方。idx 格式规定用大端存整数，而 x86 机器是小端，直接用np.int32读出来的n会是个荒唐的数字（比如 60000 会读成 1008382464），然后reshape直接内存溢出。我第一次写这段的时候就是这么翻车的，报错信息还特别晦涩。

/ 255.0这步归一化不能省。原始像素是 0 到 255 的整数，直接喂进网络，第一层加权求和的结果会在几百的量级，ReLU 之后大量神经元饱和，梯度全废。归一化到 [0, 1] 之后输入量级和权重初始化匹配，训练才稳。更讲究的做法是再做一次标准化(x - 0.1307) / 0.3081，这两个数是 MNIST 全集的均值和标准差，能让输入分布接近标准正态，收敛通常快一到两个 epoch。教程里经常省略这步，但你自己复现的时候加上，效果立竿见影。

3.2 参数初始化与前向传播：把缓存留给反向用

网络的类设计要解决一个问题：反向传播需要用到前向时的中间结果（每层的输入激活值、ReLU 的开关状态），这些必须在 forward 时缓存下来。缓存的粒度决定了代码的清晰度，我倾向于把每一层的z（线性输出）和a（激活后输出）都存进一个列表，索引规则定死。

# mnist_mlp/model.py import numpy as np def softmax(z): """数值稳定版 softmax：先减去每行最大值，防止 exp 溢出""" z = z - z.max(axis=1, keepdims=True) e = np.exp(z) return e / e.sum(axis=1, keepdims=True) class MLP: def __init__(self, sizes=(784, 128, 64, 10), seed=42): rng = np.random.default_rng(seed) # 固定随机种子，保证结果可复现 self.sizes = sizes self.params = {} for i in range(1, len(sizes)): fan_in, fan_out = sizes[i - 1], sizes[i] # He 初始化：方差 2/fan_in，专为 ReLU 设计，避免深层激活值衰减 self.params[f'W{i}'] = (rng.standard_normal((fan_in, fan_out)) * np.sqrt(2.0 / fan_in)).astype(np.float32) self.params[f'b{i}'] = np.zeros(fan_out, dtype=np.float32) def forward(self, x): """返回 (输出概率, 缓存)。cache[0] 是输入，cache[i] 是第 i 层的 (z, a)""" cache = [x] a = x n_layers = len(self.sizes) - 1 for i in range(1, n_layers + 1): z = a @ self.params[f'W{i}'] + self.params[f'b{i}'] if i < n_layers: a = np.maximum(z, 0.0) # 隐藏层 ReLU else: a = softmax(z) # 输出层转概率 cache.append((z, a)) return a, cache

rng.standard_normal(...) * np.sqrt(2.0 / fan_in)是 He 初始化。如果图省事用* 0.01之类的小常数，128 维的隐层经过两次矩阵乘法后激活值会衰减到 1e-4 量级，反向传播时梯度同样衰减，训练 20 个 epoch 精度还在 30% 徘徊。反过来用* 1.0又会让初始输出爆炸，softmax 直接饱和成 one-hot，损失卡在 2.3 不动。这两个现象我在早期的实验记录里都留着，改初始化是排查“训练不动”问题的第一顺位。

softmax里减最大值那行是防御性写法。理论上exp(z)里的z不会太大，但训练初期权重随机、输入归一化不完美的时候，z冲到 800 以上完全可能，np.exp(800)就是inf，一路传播成nan，整个训练报废。减去行最大值不改变 softmax 的数学结果，但把指数范围压到了[-inf, 0]，稳如老狗。

3.3 反向传播：交叉熵与 softmax 的梯度合并

反向传播的核心技巧是把 softmax 和交叉熵的导数合并。分开推的话，softmax 的雅可比矩阵是个 10×10 的稠密矩阵，再乘交叉熵的导数，计算量大且容易写错。合并之后结果异常简洁：输出层的误差就是“预测概率减去 one-hot 标签”，除以 batch size 做平均。

def backward(self, cache, y_onehot): """返回各层梯度字典。y_onehot 形状 (B, 10)""" grads = {} n_layers = len(self.sizes) - 1 batch = y_onehot.shape[0] # softmax + 交叉熵合并求导，结果就是 (p - y) / B dz = (cache[-1][1] - y_onehot) / batch for i in range(n_layers, 0, -1): # 第 i 层的输入：i==1 时是原始输入，否则是上一层的激活输出 a_prev = cache[0] if i == 1 else cache[i - 1][1] grads[f'W{i}'] = a_prev.T @ dz # (fan_in, fan_out) grads[f'b{i}'] = dz.sum(axis=0) # 沿 batch 维求和 if i > 1: da = dz @ self.params[f'W{i}'].T # 误差回传到上一层 dz = da * (cache[i - 1][1] > 0).astype(np.float32) # ReLU 导数 return grads

cache[-1][1] - y_onehot这行是整段代码的精华。cache[-1][1]是 softmax 输出的概率分布，y_onehot是目标分布，两者相减就是输出层对z的梯度。初次看到会觉得“这也太简单了”，但推导确实如此，而且这个形式规避了所有数值问题：概率在 [0,1]，标签是 0 或 1，差值永远在 [-1, 1]，不会溢出。

(cache[i-1][1] > 0)是 ReLU 的导数。ReLU 在z > 0时导数为 1，否则为 0，所以这里用布尔数组转 float 直接做乘法。注意判断的是激活输出a而不是z，因为a = max(z, 0)，a > 0和z > 0等价，但用a顺手，也避免了再存一份z。这个细节写错的话（比如写成cache[i-1][0] > 0但其实索引错了），训练不会崩，只是精度上不去，属于典型的“静默失败”，排查起来很费劲。

4. 训练闭环与模型落盘：让权重文件开箱即用

训练这一段，代码本身不长，但决定最终精度的往往不是网络结构，而是这几个超参和调度策略。再往后的重点是落盘格式——权重文件存成什么样，直接决定了别人能不能“直接用”。

4.1 训练循环与带 momentum 的 SGD

优化器选了带动量的 SGD 而不是 Adam。原因很实际：这个网络的规模下，两者最终精度差别不到 0.2 个百分点，但 SGD + momentum 只需要多存一份速度缓冲区，实现十几行，推理端完全不用管优化器状态。Adam 要维护一阶和二阶矩，状态量翻倍，对“交付一个干净权重文件”这个目标没有帮助。

# mnist_mlp/train.py import numpy as np from .data import load_images, load_labels from .model import MLP def iterate_minibatches(x, y, batch_size, rng): """打乱后按 batch 切分，最后不满一个 batch 的也返回""" idx = rng.permutation(len(x)) for start in range(0, len(idx), batch_size): sel = idx[start:start + batch_size] yield x[sel], y[sel] def train(): x_train = load_images('data/train-images-idx3-ubyte.gz') y_train = load_labels('data/train-labels-idx1-ubyte.gz') x_val = load_images('data/t10k-images-idx3-ubyte.gz') y_val = load_labels('data/t10k-labels-idx1-ubyte.gz') model = MLP(sizes=(784, 128, 64, 10), seed=42) velocity = {k: np.zeros_like(v) for k, v in model.params.items()} epochs, batch_size = 20, 128 lr, momentum = 0.1, 0.9 rng = np.random.default_rng(42) best_acc = 0.0 for epoch in range(epochs): # 每 5 个 epoch 学习率减半，后期微调更稳 if epoch > 0 and epoch % 5 == 0: lr *= 0.5 for xb, yb in iterate_minibatches(x_train, y_train, batch_size, rng): y_onehot = np.eye(10, dtype=np.float32)[yb] _, cache = model.forward(xb) grads = model.backward(cache, y_onehot) # momentum 更新：v = 0.9*v - lr*g，参数 += v for k in model.params: velocity[k] = momentum * velocity[k] - lr * grads[k] model.params[k] += velocity[k] # 每个 epoch 结束在验证集上评估，只保留最好的那一版权重 acc = evaluate(model, x_val, y_val) print(f'epoch {epoch + 1:02d} lr={lr:.4f} val_acc={acc:.4f}') if acc > best_acc: best_acc = acc model.save('artifacts/mnist_mlp.npz') print(f'best val acc = {best_acc:.4f}')

几个参数的选择值得说清楚。batch_size=128是精度和速度的平衡点，64 太小导致梯度噪声大、收敛慢，256 以上在这个数据集上每个 epoch 的更新次数不够，20 个 epoch 走不完必要的迭代步数。lr=0.1配合 momentum 0.9 是经典组合，初始阶段损失下降很快；到第 10 个 epoch 左右精度增长明显放缓，这时候把学习率减半，能让模型在局部最优附近再往下探一截。

best_acc那套逻辑是必须的。训练集精度会一直涨，但验证集精度到 15 个 epoch 之后往往开始横盘甚至微跌，说明在过拟合。如果无脑保存最后一个 epoch 的权重，交付出去的模型比最优版本差 0.3 到 0.5 个百分点。保存最优版本这个习惯，我从这个项目开始就一直保持，后面做任何训练任务都强制走一遍。

4.2 权重序列化：npz 格式与加载时的类方法

权重存成np.savez_compressed生成的.npz文件。这个格式本质是个 zip 包，里面每个数组存成一个.npy，可以用unzip -l直接查看里面有哪些文件，也可以用np.load读成字典。相比 pickle 或 joblib，它的优势是跨语言可解析——Java 或 C++ 端想读，解压后按 npy 格式规范解析就行，不依赖 Python 运行时。

def save(self, path): """把参数字典原样存成 npz，键名即参数名""" np.savez_compressed(path, **self.params) @classmethod def load(cls, path): """从 npz 恢复模型，不需要知道原始结构也能读""" obj = cls.__new__(cls) # 跳过 __init__，避免重新随机初始化 obj.params = {k: v for k, v in np.load(path).items()} # 从权重形状反推网络结构，保证 sizes 与实际参数一致 n_layers = len(obj.params) // 2 obj.sizes = [obj.params['W1'].shape[0]] + \ [obj.params[f'W{i}'].shape[1] for i in range(1, n_layers + 1)] return obj

cls.__new__(cls)这个写法是刻意的。如果直接cls()，构造函数会跑一遍随机初始化，生成一堆用不上的参数，虽然马上被覆盖，但在大模型上这步会白白占用内存。跳过后直接从文件填params，干净利落。

obj.sizes从权重形状反推这一步，是为了让加载逻辑对结构变化免疫。如果哪天你把隐层从 128 改成 256 重新训练，只要权重文件是新的，加载代码一行不用改。我见过反过来的设计——load里硬编码sizes=(784,128,64,10)，结果换了模型结构就报维度不匹配，还得回头改代码。

4.3 单张图片推理：预处理必须和训练时一模一样

推理脚本是整套代码里最容易被轻视的部分。训练时数据是现成的(N, 784)矩阵，推理时你得自己把一张 PNG 变成同样的形状和数值范围，任何一步不一致，精度都会断崖式下跌。

# mnist_mlp/predict.py import numpy as np from PIL import Image from .model import MLP def preprocess(image_path): """把任意尺寸的手写数字图片转成模型输入 (1, 784)""" img = Image.open(image_path).convert('L') # 转灰度，丢弃色彩通道 img = img.resize((28, 28), Image.BILINEAR) # 统一到 28x28 arr = np.asarray(img, dtype=np.float32) / 255.0 # MNIST 是白字黑底；如果你的图是黑字白底，必须反相 if arr.mean() > 0.5: arr = 1.0 - arr return arr.reshape(1, 784) def predict(image_path, weight_path='artifacts/mnist_mlp.npz'): model = MLP.load(weight_path) x = preprocess(image_path) probs, _ = model.forward(x) pred = int(probs.argmax(axis=1)[0]) conf = float(probs.max()) return pred, conf if __name__ == '__main__': import sys digit, conf = predict(sys.argv[1]) print(f'预测结果: {digit} 置信度: {conf:.4f}')

if arr.mean() > 0.5: arr = 1.0 - arr这行是整个推理脚本的救命稻草。MNIST 训练集全是黑底白字，而你自己用手机拍或者截图得到的数字图，绝大多数是白底黑字。不反相的话，模型看到的是一张“背景全是 1”的图，输出会稳定地偏向某个固定数字，而且置信度还不低，属于最难查的一类 bug。

resize用BILINEAR而不是NEAREST，是因为最近邻插值在缩小图像时会产生锯齿，笔画断裂，模型对这种高频噪声很敏感。双线性插值做了加权平均，边缘更平滑，更接近 MNIST 原始数据经过抗锯齿采样的样子。另外如果原始图片留白太多，数字只占中间一小块，最好先做一次裁剪把数字的包围盒切出来再缩放，否则有效信息会被压缩得很小。

5. 避坑排查：训练不收敛、精度上不去、模型加载报错

这一章记录的是实打实踩过的坑。每一条都按“现象 → 原因 → 解决”写，能省掉你几个小时的盲目试错。

5.1 训练阶段的典型故障

现象一：损失从第一个 epoch 就卡在 2.3026 附近不动，精度稳定在 10% 左右。

这个 2.3026 是ln(10)，也就是均匀随机猜十选一的交叉熵。损失停在这个值意味着模型的输出恒为 0.1 的均匀分布，完全没学到东西。原因几乎总是初始化或学习率的问题：权重初始化过小（比如乘了 0.01），导致各层激活值趋近于零，梯度也跟着趋近于零，参数几乎不更新；或者学习率设成了 1e-5 这种量级，每次更新幅度比浮点精度还小。解决办法是先打印np.abs(grads['W1']).mean()，如果数值在 1e-8 以下，说明梯度已经消失，换成 He 初始化并确认学习率在 0.01 到 0.1 区间。

现象二：训练集精度能到 99%，验证集卡在 96% 上不去，且两者差距逐 epoch 拉大。

典型的过拟合。10 万参数对 6 万张图，理论上不算夸张，但如果训练 40 个 epoch 以上，模型会把训练集的噪声也记下来。判断方法是看损失曲线：训练损失持续下降，验证损失在某个 epoch 后开始上升，那个拐点就是应该停的地方。解决手段有三个方向，按代价从低到高是：减少 epoch 数（最简单，配合保存最优权重即可）、加 Dropout（在隐层后随机置零 20% 的神经元，训练时生效、推理时关闭）、加 L2 正则（在梯度里加上lambda * W）。这个项目选了第一种，因为目标是交付一个轻量基线，复杂化收益不大。

现象三：训练几轮后损失突然变成 nan，后续全部失效。

几乎都是 softmax 溢出。前面提过np.exp在大输入下的问题，但如果已经减了最大值还出 nan，就得查数据本身——某张图片加载时字节错位，像素值被解析成了 1000 以上的数，归一化后仍然异常。排查方式是在 dataloader 里加一句断言assert x.max() <= 1.0 and x.min() >= 0.0，跑一遍训练，如果不触发就说明数据干净。另一个隐蔽原因是学习率过大导致参数爆炸，梯度更新后权重冲到 1e10，这时候把学习率除以 10 再跑就能确认。

现象四：同一份代码，两次运行结果差好几个百分点。

没有固定随机种子。权重初始化和 batch 打乱都用了随机数，不固定的话每次初始化落点不同，最终精度自然有波动。这个网络的波动幅度实测在 0.2 到 0.5 个百分点之间。解决办法是把np.random.default_rng(42)作为参数传进所有需要随机的地方，包括初始化和每个 epoch 的 shuffle。注意别用全局的np.random.seed()，那样在多线程或多次调用时行为不可控，显式传 rng 对象才是可靠做法。

5.2 推理与部署阶段的坑

现象五：加载权重文件后调用 forward，报matmul维度不匹配。

原因是np.load返回的数组默认是只读的，且某些情况下数据类型和训练时不一致，更常见的是权重文件的层数与sizes对不上。先print({k: v.shape for k, v in np.load(path).items()})，把形状打出来，和sizes逐层核对。如果形状对但报错，检查是否误用了MLP()构造再手动赋值params，那样sizes还是默认值，前向循环的层数和params里的键数量不匹配。用MLP.load()类方法就没这个问题，因为它从权重反推了sizes。

现象六：预测单张图片时置信度很高，但结果全是错的。

预处理不一致。最常见的是忘了反相（白底黑字没转成黑底白字），其次是没做/255.0归一化，或者 resize 用了最近邻导致笔画断裂。排查顺序是：先把预处理后的arr存成 PNG 看一眼，人眼能认出来是那个数字，模型大概率也能；如果人眼都认不出，说明裁剪或缩放有问题。我在调试阶段习惯在preprocess里加一个可选的debug=True参数，把中间结果 dump 出来，比对着代码猜快得多。

现象七：批量预测时速度奇慢，一张图要几百毫秒。

每次都重新MLP.load()权重文件。np.load会读磁盘、解压、解析 zip，这个开销对小文件也有几毫秒，如果放在循环里，整体就被拖垮了。正确做法是模型只加载一次，循环只做preprocess和forward。如果要做成服务，把模型对象放在模块级变量或者在服务启动时初始化一次，请求处理函数里直接复用。另外批量预测时可以把多张图拼成一个(B, 784)矩阵一次前向，比逐张循环快好几倍，矩阵乘法的并行效率就体现出来了。

6. 二次开发：从 97% 往上抠的那几个百分点

拿到这份代码之后，如果只是跑通看个 97.5% 的精度，价值有限。真正有意思的是在它基础上做增量实验，因为训练一次只要几十秒，试错成本极低。下面几条改造路线按投入产出比排序，每条都给了验证方式。

第一条是数据增强，性价比最高。MNIST 是手写数字，天然具有平移和轻微旋转不变性，但训练集里的样本位置相对固定。用scipy.ndimage.shift对每张图做 ±2 像素的随机平移，训练集直接扩到 5 倍，精度通常能到 98.3% 以上。代码改动很小，在iterate_minibatches里对xb做变换即可。注意验证集不能增强，否则指标就失去意义了。验证方法是固定随机种子跑三次，看三次的最优验证精度方差是否收窄，收窄说明泛化更稳。

第二条是给隐层加 BatchNorm 思路的替代——每层输入做标准化。手写完整 BN 的反向传播比较费事，简单版的替代是在每层线性输出后减均值除标准差，再过一个可学习的缩放平移。这个改动能让学习率敢开到 0.3 而不发散，收敛 epoch 数从 20 降到 12 左右。验证方式是画学习率与最终精度的曲线，如果曲线在高学习率区间不再出现断崖下跌，说明标准化起作用了。

第三条是换损失函数做对比实验。交叉熵和合页损失（SVM 用的那个）在 MNIST 上的精度差距不大，但训练动态不同——合页损失前期下降慢，后期更稳定。这类对比不是为了提高精度，而是为了理解不同损失对梯度分布的影响。做法是写一个loss_fn和loss_grad_fn的可插拔接口，训练循环里按名字调用。这个改造把backward里那行(p - y) / B抽出来，代码结构会更干净。

最后的建议是别急着上卷积。很多人跑通 MLP 后第一反应是换 CNN，精度确实能到 99.2%，但代价是代码量翻三倍，还得处理池化层的反向传播。如果目的是学习，把 MLP 的每个环节吃透比堆结构有用得多；如果目的是部署，MLP 的体积和推理速度在边缘设备上反而有优势。

从那以后我每次交付模型文件，都会强制走一遍“清空缓存目录、从零加载、跑 100 张测试图”的流程，确认交付物真的是自包含的——这个习惯是被一次“权重文件里漏了最后一层的 bias”坑出来的，当时本地有缓存所以一切正常，换台机器就崩。希望帮到你。

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