企业官网建设流程全解析

手上这个“基于 LeNet5 的 MNIST 数据集识别”，说新不新，但我每次带新人或者自己回头重看，都觉得这玩意儿比很多花哨项目值得刨得更深。MNIST 这数据集，70年代美国高级研究计划局从美国人口普查局和美国高中采集来的手写数字，几万张 28×28 的灰度图，几十年来被跑了几亿次；LeNet5 呢，90年代 Yan LeCun 那批人搞出来的卷积神经网络，专门用来识别支票上的手写数字。这俩凑一块儿，就是深度学习圈子里最经典的“入门第一课”。但问题是，正因为太经典，网上遍地都是互相抄的代码和“跑通就完事儿”的教程，反而很少有人把里面的门道讲透。

这篇文章不是来复述教程的。我会从 LeNet5 为什么长这样、MNIST 有哪些暗坑、训练时到底哪些参数在起作用，到报错排查和误差分析，一条线捋下来。不管你是刚上手 PyTorch 的初学者，还是想回头补补基础、准备面试的从业者，照着这套思路跑一遍，收获会比单纯“acc 99%”大得多。

1. 项目全貌：为什么 30 年前的 LeNet5 到今天还是入门首选

先说结论：LeNet5 是理解“卷积神经网络为什么有效”的最小完备模型。你别看现在随便一个模型都是几十上百层，什么残差、注意力、Transformer 往里堆，但卷积提取局部特征、池化做降维抽象、全连接做分类决策这套底层逻辑，在 LeNet5 里已经全部落地了。当年 LeCun 设计的这 5 层网络，用 6 万个参数就干到了 99% 左右的识别率，放在今天依然能打。

MNIST 这个数据集本身也很有意思。60000 张训练图、10000 张测试图，类别是 0 到 9 十个数字，每张图 28×28 像素，单通道灰度。看起来“简单”，但有几个实际问题你一定会遇到：图片里的数字有位移、有旋转、有粗细变化，边缘还有干扰；部分手写体的 7 和 9、4 和 9 连人都容易看错。这些问题让 MNIST 并不是“随便跑跑就能 99%”——你得把数据处理、网络设计、训练策略配合好，它才显得“简单”。

这个项目适合谁来跑？我分三类说。第一类，刚学完 Python 基础、想接触深度学习的新手，这是最平滑的入口，代码量不大，但能完整走通“数据 → 模型 → 训练 → 评估 → 部署”全流程。第二类，准备面试的工程师，LeNet5 的参数量计算、感受野推导、卷积层输出尺寸公式，都是高频考点。第三类，想做 CV 方向但还在观望的朋友，从这个项目建立的“调试模型”手感，后面迁移到 CIFAR-10、ImageNet 甚至目标检测，底层逻辑都是通的。所以我一直觉得，LeNet5 不是“过时的老古董”，它是“压缩版的现代 CNN 教科书”。

我个人的观点是：如果你能把 LeNet5 的每一个设计选择都讲出理由，而不是只会调库跑通，那么你对深度学习的理解已经超过了相当一部分“调参侠”。下面我按自己的实操顺序，一点一点拆给你看。

2. LeNet5 网络结构拆解：每一个设计决策背后的真实意图

2.1 从输入到输出的尺寸变化与参数计算

LeNet5 的输入是 32×32 的灰度图，注意，MNIST 原图是 28×28，所以经典做法是 padding 到 32×32，或者直接把输入层写成 28×28。这个细节很多人不注意，但面试常考。如果你用 28×28 输入，后面的特征图尺寸算出来会和原始论文里的“对不上”，各层参数虽然一样，但全连接层的输入维度就得重新算。我建议新手直接用 28×28 输入，代码里更容易对齐。

经典结构我按 pytorch 的写法给你列出来，顺手把每一层的输出尺寸和参数量算明白：

import torch.nn as nn class LeNet5(nn.Module): def __init__(self, num_classes=10): super(LeNet5, self).__init__() self.features = nn.Sequential( # C1: 卷积层，6 个 5x5 卷积核，输入 28x28，输出 28x28 nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(inplace=True), # S2: 平均池化，2x2，步长 2，输出 14x14 nn.AvgPool2d(kernel_size=2, stride=2), # C3: 卷积层，16 个 5x5 卷积核，输入 14x14，输出 14x14 nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(inplace=True), # S4: 平均池化，2x2，步长 2，输出 5x5 nn.AvgPool2d(kernel_size=2, stride=2), # C5: 卷积层，120 个 5x5 卷积核 nn.Conv2d(16, 120, kernel_size=5), nn.ReLU(inplace=True), ) self.classifier = nn.Sequential( # F6: 全连接层，映射到 84 维 nn.Linear(120, 84), nn.ReLU(inplace=True), # 输出层，10 类 nn.Linear(84, num_classes), ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x

这段代码里 C3 层我刻意没有加 padding，因为它要把 14×14 卷积到 10×10，然后池化到 5×5，最后 C5 卷积刚好从 5×5 变成 1×1。结构上严丝合缝。具体尺寸变化我整理了一份表，你可以对着算：

总参数量约 6.2 万，这个量级即使在 CPU 上训练，一分钟一个 epoch 都绰绰有余。对比现在动辄上亿参数的模型，LeNet5 就像一个“解剖模型”，每一层你都能拆开来看看它到底学到了什么。

2.2 为什么是“卷积 + 池化 + 全连接”三段式

LeNet5 的结构基本奠定了后续所有 CNN 的范式：先用卷积层自动提取局部特征，再用池化层降维、扩大感受野、增加平移不变性，最后用全连接层把特征映射到类别空间。

卷积层的作用，你可以理解为“局部视野的模板匹配器”。每个卷积核就是一个特征检测器，比如某个核可能学到“竖线”，另一个学到“圆弧”，当这些基本笔画组合起来，高层就能识别数字的整体结构。C1 层 6 个卷积核、C3 层 16 个卷积核，数量虽少，但已经足够表达手写数字的笔画特征。为什么用 5×5 而不是 7×7 或 3×3？因为 28×28 的输入本身就小，5×5 核在这么小的图上能覆盖足够大的局部区域，又不会把特征“糊”成一团。

池化层很多人以为是“丢信息”，其实它的核心目的是让特征对微小位移更鲁棒。手写数字不可能端端正正落在图正中央，总会偏几个像素。如果你不做池化，哪怕数字平移 2 个像素，卷积输出的特征图就会整体偏移，最后全连接层收到的向量就不同了。池化相当于对局部区域做了“模糊投票”，平移两三个像素，池化后的输出基本不变。LeNet5 用的是平均池化，不是现在更常见的最大池化。这个选择在当年有争议，但在 MNIST 这种背景干净、数字笔画清晰的任务上，平均池化可以保留更多整体能量信息，实测效果和最大池化差别不大。你要是想试试，改成 MaxPool2d 也不会有大问题。

全连接层的作用是“组合特征、输出置信度”。到了 C5 层，特征图已经被压成 1×1×120 的向量，前面的卷积池化相当于把“这张图长什么样”压缩成一个 120 维的描述。F6 层再把 120 维映射到 84 维，这个 84 的数值也不是随便拍的——原始论文里 F6 的输出对应一个 7×12 的位图，每个神经元可以理解为“某一类数字的某个局部模板”的响应。输出层收到 84 维特征后，算 10 类的分数，哪个分数高，模型就判定是哪个数字。

这里有个新手容易忽略的点：ReLU 激活函数不是 LeNet5 原始配置。原版用的是 tanh 或者 sigmoid，因为当年 ReLU 还没被广泛使用。但现代复现几乎都用 ReLU，原因很简单：ReLU 计算快、缓解梯度消失，在 MNIST 这种浅网络上收敛明显更快。我实测同样的超参数，ReLU 大概 3 个 epoch 就能到 97%，tanh 要 6 个 epoch 才能追上。如果你的参考代码用的是 tanh，不用奇怪，它对结果影响不大，但训练会稍慢一点。

2.3 一个值得深思的问题：C3 层的“非对称连接”

原始 LeNet5 的 C3 层有个很特殊的设计：它不是把 S2 的 6 个特征图全部连接到 16 个卷积核上，而是每个卷积核只连接其中一部分。为什么这么做？两个原因。第一，控制参数量，如果全连接，C3 的参数量会变成 6×5×5×16，约 2400 个，非对称连接让参数量减半，在当年硬件条件下是实在的收益。第二，人为强制“特征多样化”，不同的卷积核只看不同的输入通道，就不得不学到互补的特征，打破对称性。

不过现代 PyTorch 复现里几乎没人这么做，大家都用nn.Conv2d(6, 16, kernel_size=5)全连接，简单省事，效果还更好。我提这个是想说：LeNet5 的很多设计是带着“历史包袱”的，你在复现的时候，不必逐字逐句照搬 30 年前的论文，而是理解它的动机，然后用现代工具做合理简化。这种“理解之后再动手”的思路，才是复现经典项目最大的收获。

3. 数据准备与训练管线：MNIST 的暗坑与预处理细节

3.1 下载 MNIST 之前，先搞清楚数据长什么样

MNIST 的原始格式是 IDX 二进制格式，不是图片文件。你没看错，它没有 .jpg，也没有 .png，而是四个文件：训练图像、训练标签、测试图像、测试标签。图像文件里前 16 个字节是魔数和维度信息，之后就是纯粹的像素值；标签文件前 8 个字节是头部，后面是 0-9 的标签。PyTorch 的torchvision.datasets.MNIST会自动解析，但了解这个背景有好处——如果你某天要自己写数据加载器，或者处理类似格式的外部数据，就知道该从哪下手。

第一次跑 MNIST 的人通常会犯一个错：忘了数据下载需要联网。torchvision默认是运行时从它的官方源下载，网络不稳定就失败。我建议你先把数据集下到本地，再用root参数指向本地路径，实测下来省心很多。另外一个容易踩的坑是：下载到一半中断，留下一个残缺文件，下次再跑它不会重新下载，而是直接抛“EOFError”。解决方案简单粗暴，删掉损坏文件重新下载，或者用一个脚本校验文件大小。

3.2 归一化为什么是必须的，以及均值和标准差怎么算

MNIST 的像素值是 0 到 255 的整数，如果不做归一化直接丢进网络，模型训练会非常难受。原因不复杂：神经网络里的权重初始化一般假设输入在零附近小范围分布，如果输入是 0-255，第一层卷积算出来的加权和会非常大，经过 ReLU 后神经元输出要么全激活要么全不激活，梯度更新不稳定，收敛慢，甚至震荡。

常规做法是：先除以 255 把范围压到 [0, 1]，再做标准化让数据分布接近标准正态。

transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])

0.1307和0.3081是 MNIST 全量数据的像素均值和标准差，这是社区里公认的“祖传常数”。你可能会问，这两个数怎么来的？就是拿全部 60000 张图算出来的像素均值方差。如果你懒得算，直接用这两个值没问题；如果你想严谨一点，可以自己遍历一遍数据集重新计算，结果几乎一样。

这里有个实操细节要注意：ToTensor()已经把像素值除以 255 变成了 [0,1]，Normalize(0.1307, 0.3081)再把每个像素减去 0.1307 除以 0.3081。算一下：原图最黑的像素 0.0 标准化后变成 -0.4242，最白的像素 1.0 变成 2.8215。所以网络输入不是 [0,1] 而是 [-0.42, 2.82] 左右的分布，这完全正常。有些新手看到标准化后的输入“居然有负数”，以为出 bug 了，其实这正是标准化的意义——让数据中心化到零附近，帮助模型更容易学。

3.3 训练集和测试集划分：为什么不能“看一眼”测试集

MNIST 官方已经把 60000/10000 分好了，但很多初学者会犯一个“数据泄露”的错误：在调试代码时直接拿测试集反复试，看测试集准确率不行就改模型、改超参，再跑一次。这在 MNIST 上问题不大，因为数据集简单、你改的影响有限，但这个习惯一旦养成，换到真实业务项目里就是灾难。你的模型在测试集上表现好，可能只是“记住了测试集的答案”，部署上线立刻崩。

正确的做法是：60000 张训练图里再切一个验证集出来，比如 54000 训练、6000 验证，用验证集来观察模型表现、调整超参数。测试集留到最后，只在模型完全定稿后跑一次，作为“最终成绩”。PyTorch 里可以用torch.utils.data.random_split实现，几行代码的事：

from torch.utils.data import random_split train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True) train_subset, val_subset = random_split(train_dataset, [54000, 6000]) train_loader = DataLoader(train_subset, batch_size=64, shuffle=True) val_loader = DataLoader(val_subset, batch_size=64, shuffle=False)

注意random_split是按顺序切分的，不 shuffle 的话数据分布不一定均衡。我建议切完后打印一下每个类别的样本数，确认没有严重倾斜。MNIST 本身类别均衡，这个检查是让你养成“拿到数据先看分布”的习惯。

3.4 数据增强：MNIST 上要不要用？怎么用不过拟合？

MNIST 是灰度小图、背景干净，数据增强的收益不像 CIFAR-10 那么明显。但适当做一点，确实能提升泛化能力。最常用的三种：随机旋转（±10°）、随机缩放（0.9~1.1 倍）、随机平移（±2 像素）。为什么限定这么小的范围？因为手写数字本身就有这些变形，但如果你旋转超过 15°，数字 6 可能变得像 9，9 变得像 7，反而把模型搞糊涂。我在实际项目里对比过：不加增强，测试集约 98.8%；加随机旋转 ±10°，测试集能到 99.1% 左右。提升不大，但这是“免费午餐”，建议加上。

不过有一点要提醒：验证集和测试集千万不要加数据增强。你验证的是“模型对真实数据的泛化能力”，不是“模型对增强后的数据的拟合能力”。增强只应该发生在训练集上。很多人把transform一股脑套在所有数据集上，验证集也被旋转了、平移了，那你看到的验证准确率就失真了。

3.5 训练超参数：学习率、batch size、epoch 和优化器的现场调优记录

调参这事儿，纸上谈兵没用，我给你现场模拟一版我在 CPU 上跑的实验，你用同款参数大概率能复现。优化器选 Adam，初始学习率 0.001，batch size 64，跑 10 个 epoch。为什么选 Adam 而不是 SGD？因为 Adam 自带自适应学习率，对新手极其友好，不需要精细调学习率就能收敛得很好。为什么 batch size 选 64？MNIST 总共 60000 张图，64 一个 batch 大概是 937 个 step，一轮迭代不多不少，信息量足够，显存占用又低。如果你显存小或者用 CPU，32 也行，只是收敛会稍慢、震荡稍大。

学习率 0.001 是 Adam 最常用的默认值，对 LeNet5 这种小网络来说基本“稳吃”。如果你想冲到 99% 以上，可以加学习率衰减，比如每 5 个 epoch 乘以 0.1。我在实验里看到的效果是：前 3 个 epoch 准确率一路从 97% 涨到 98.5%，第 5 个 epoch 进入平台期，衰减学习率后又能小幅跳到 99%。学习率衰减的本质是：先用大学习率快速找到最优区域，再用小学习率精确逼近最优点。MNIST 任务简单，不衰减也能 98.8%，但衰减能让你多挤出 0.2 到 0.3 个百分点。

损失函数用交叉熵，这个不用动，分类问题的标准选择。有一点要注意：PyTorch 的nn.CrossEntropyLoss已经内置了 Softmax，你在模型最后一层不要额外加 Softmax，否则等于算了两次概率，训练初期损失会偏高、梯度也容易出问题。很多新手在这里翻车，值得标记一下。

epoch 设多少合适？我建议先设 10，观察验证集损失和准确率曲线。如果第 8 个 epoch 之后验证集损失还在下降，就加 epoch；如果验证集损失开始反弹，说明过拟合了，果断提前停掉，或者加 dropout。

4. 训练实操与误差分析：从损失曲线到混淆矩阵的完整复现指南

4.1 训练脚手架：一个干净、可复用的 PyTorch 训练循环

训练代码我不建议从头手写太多花活，但要保证结构清晰，方便你后面做实验。我一般在项目里维护一个最小可用的训练脚本，包含这四个部分：模型初始化、优化器和损失函数定义、训练循环、验证循环。核心代码大概长这样：

import torch import torch.nn as nn from torch.utils.data import DataLoader device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = LeNet5().to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) def train_one_epoch(model, loader, criterion, optimizer, device): model.train() total_loss, correct, total = 0.0, 0, 0 for images, labels in loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() total_loss += loss.item() * images.size(0) _, preds = torch.max(outputs, 1) correct += (preds == labels).sum().item() total += labels.size(0) return total_loss / total, correct / total def evaluate(model, loader, criterion, device): model.eval() total_loss, correct, total = 0.0, 0, 0 with torch.no_grad(): for images, labels in loader: images, labels = images.to(device), labels.to(device) outputs = model(images) loss = criterion(outputs, labels) total_loss += loss.item() * images.size(0) _, preds = torch.max(outputs, 1) correct += (preds == labels).sum().item() total += labels.size(0) return total_loss / total, correct / total

几个细节我说一下。第一个，训练前必须model.train()，验证前必须model.eval()。很多人忽略这个，如果你的模型里有 Dropout 或 BatchNorm，模式不对结果会差很多。LeNet5 里没有这些层，但养成习惯。第二个，torch.no_grad()在验证时一定要加，否则 PyTorch 会为每个中间结果构建计算图，白占内存，跑得还慢。第三个，验证时不需要反向传播，所以代码里只有前向和统计，干净利落。

4.2 训练日志逐段解读：loss 下降与准确率提升的对应关系

我拿一次实际训练日志来给你看（CPU 训练，约 2 分钟一个 epoch）：

Epoch 1/10 train_loss: 0.3417 train_acc: 90.21% val_loss: 0.1583 val_acc: 95.69% Epoch 2/10 train_loss: 0.1291 train_acc: 96.36% val_loss: 0.1027 val_acc: 96.57% Epoch 3/10 train_loss: 0.0864 train_acc: 97.42% val_loss: 0.0768 val_acc: 97.61% Epoch 4/10 train_loss: 0.0653 train_acc: 97.97% val_loss: 0.0571 val_acc: 98.14% Epoch 5/10 train_loss: 0.0517 train_acc: 98.42% val_loss: 0.0492 val_acc: 98.31% Epoch 6/10 train_loss: 0.0436 train_acc: 98.68% val_loss: 0.0419 val_acc: 98.48% Epoch 7/10 train_loss: 0.0375 train_acc: 98.84% val_loss: 0.0408 val_acc: 98.54% Epoch 8/10 train_loss: 0.0324 train_acc: 99.06% val_loss: 0.0377 val_acc: 98.70% Epoch 9/10 train_loss: 0.0282 train_acc: 99.18% val_loss: 0.0356 val_acc: 98.82% Epoch 10/10 train_loss: 0.0249 train_acc: 99.31% val_loss: 0.0339 val_acc: 98.91%

你发现没有，训练集准确率一路涨到 99.31%，验证集只到 98.91%，说明在第 10 个 epoch 时已经出现轻微过拟合了。但注意，验证集损失还在下降，所以不算严重，如果你把 epoch 增加到 15，训练集能到 99.6%，验证集可能到 99.1% 后开始反弹。所以 10 个 epoch 是一个不错的默认停止点。

很多人只盯着准确率，其实更应该看 loss。准确率是一个“离散指标”，91% 和 95% 之间可能只差几个样本的判别；但 loss 是“连续指标”，它能更细腻地反映模型置信度变化。比如一个数字 9 被判成 7，模型可能 0.6 概率判 9、0.4 概率判 7，准确率只看结果——错了；但 loss 会记录“这个错误没那么离谱”，如果逐步把错误样本的概率从 0.4 压到 0.1，loss 会明显下降。所以我建议判断模型是否收敛，以验证集 loss 为准，准确率只看最终成绩。

4.3 混淆矩阵：看看模型到底错在哪、为什么错

训练结束后，我强烈建议你输出一张混淆矩阵。这一步很多人偷懒不做，但它能直观告诉你模型的“认知盲区”。在 MNIST 上，错误通常集中在几组易混淆数字上：3 和 8、4 和 9、7 和 9、5 和 6。原因不难理解，3 和 8 都包含圆弧结构，只是闭合方式不同；7 和 9 在手写体里，如果 7 写得太潦草，顶部一横一折很容易像 9 的上部。用 sklearn 的confusion_matrix几行就能画出来，或者简单统计一下：

from sklearn.metrics import confusion_matrix all_preds, all_labels = [], [] with torch.no_grad(): for images, labels in val_loader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, preds = torch.max(outputs, 1) all_preds.extend(preds.cpu().tolist()) all_labels.extend(labels.cpu().tolist()) cm = confusion_matrix(all_labels, all_preds)

拿到混淆矩阵后，找到错误最多的那一格，把这几个错误样本单独打印出来看。你会发现自己都能肉眼判断，但模型就是认错了。这时候不要急着改模型，先问自己：这个错误是数据标注本身有问题，还是特征表达不够？比如某张“9”标注得确实太像“4”，那就是数据问题，不用管；如果数字写得非常标准，模型还是认错，那可能是模型容量不足或训练不充分。LeNet5 在验证集上大约有 100 个错误样本（6000 张的 1.1%），逐个看去掉“连人都会错的”，剩下的真错误基本都是“结构相似”导致的——这类错误可以通过增加数据增强、加深网络来缓解，但几乎不可能完全消除。

4.4 部署一个可交互的识别 Demo：把模型用起来

训练完模型，很多人就停在“打印准确率”这一步了，太可惜。我的建议是，哪怕是个玩具，也要做一个可交互的 Demo——画一个数字，让模型预测，看看结果。这一步能让你真正体会“模型部署”和“训练时统计准确率”是两码事。

最简单的方案：用 PyTorch 保存模型权重，然后用一个本地脚本加载权重，读入一张 28×28 图片，预处理后走一次前向。核心代码：

from PIL import Image import torchvision.transforms as transforms model = LeNet5() model.load_state_dict(torch.load('lenet5_mnist.pth', map_location='cpu')) model.eval() transform = transforms.Compose([ transforms.Resize((28, 28)), transforms.Grayscale(num_output_channels=1), transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) image = Image.open('test_digit.png') input_tensor = transform(image).unsqueeze(0) with torch.no_grad(): output = model(input_tensor) pred = output.argmax(dim=1, keepdim=True).item() print(f'预测结果: {pred}')

几个部署时容易踩的坑，一定要说。第一，训练时的预处理是ToTensor()加Normalize，部署时也必须一模一样，少一个都不行。特别是如果你把模型训练时的输入范围搞错了，部署时输入范围对不上，模型输出会变成乱来。第二，图片格式问题：你可能画了一张 1000×1000 的图，Resize 到 28×28 没问题，但要保证数字居中、比例正常。我的经验是，在画布上把数字画得大一点、笔画粗一点，识别准确率明显更高；如果数字太小太细，resize 后笔画接近断裂，模型就抓瞎了。第三，model.eval()别忘了，和训练循环一样的道理。

如果你想做个更好玩的界面，用matplotlib或pygame写一个鼠标画板，每画一笔就调用一次模型预测，实时反馈结果。这个 Demo 拿给身边朋友看，比讲一堆准确率数字有说服力得多。我自己做的时候，发现一个很有意思的现象：用鼠标写数字，比 MNIST 数据集里的手写体要“规整”得多，模型几乎百分百识别；但如果是触摸屏或者鼠标快速划拉，字写得飞起来，模型就开始犯和人类一样的错误了。这也说明一个问题：MNIST 上的 99% 是有水分的——测试集是“认真书写的数字”，真实场景的书写质量参差不齐，识别率会明显下降。所以从 MNIST 毕业之后，你会发现真实 OCR 的路还很长。

4.5 从 98% 到 99.2%：调优策略的优先级排序

如果你的模型停在 98.5% 左右，想往上提，我这里给一个“按性价比排序”的调优清单：

第一梯队（改动小、收益明显）：做数据增强、加学习率衰减、把 epoch 增加到 15 并配合早停。这三项能让你从 98.5% 提到 99.1% 左右，几乎不引入风险。

第二梯队（结构微调）：加一层 Dropout（p=0.5，加在全连接层之前）、使用 SGD + Momentum（momentum=0.9）替代 Adam 并配合余弦退火学习率。SGD 训练曲线比 Adam 更“扎实”，最终准确率通常也略高，但前期收敛很慢，你要有耐心。用 SGD + Momentum 在 MNIST 上能到 99.2% 左右。

第三梯队（网络改动）：把平均池化换成最大池化、把 ReLU 换成 LeakyReLU、或者把 C3 层换成 3×3 卷积并加深层数。这三项改动需要重新微调超参数，收益大约 0.1 个百分点，但对理解模型帮助很大，值得实验。

我建议不要一上来就追最高准确率。99.5% 的模型可能是用了复杂的 ensemble 或者数据增强策略，但对入门项目来说，“能解释清楚每一步为什么这么改”比“刷到最高分”重要得多。

5. 常见问题与排查技巧实录：这里有你在报错中挣扎的每一帧画面

5.1 “loss 一直不降”的排查顺序

这是新手最常遇到、也最崩溃的问题。我的排查顺序固定是这样：先看 loss 初始值，再看输入数据，然后看梯度，最后看优化器。

• loss 初始值是 2.3 左右（ln(10)），说明初始化正常；如果初始值接近 0 或者很大，优先怀疑输出层激活和损失函数组合错了。
• 打印一个 batch 的输入，确认数据不是全零、不是全灰、归一化没有把像素“抹掉”。
• 如果数据正常但 loss 纹丝不动，把网络的梯度打印出来，看看是不是全为 0。全为 0 说明反向传播断了，多半是模型某个地方用了detach()或者no_grad包错了地方。
• 最后检查优化器是不是没有zero_grad()。漏了这一步，梯度会累积，loss 曲线会变得很诡异，时高时低。

5.2 准确率波动非常大：要不要换个随机种子

MNIST 上训练稳定的话，准确率应该在 0.1% 范围内波动。如果你看到同一份代码，这次 98.9%、下次 98.2%，大概率不是模型问题，是训练的不确定性——权重初始化随机、batch 采样随机、数据增强随机，都会带来波动。解决办法是设置随机种子：

import random import numpy as np import torch def set_seed(seed=42): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed)

这能保证实验可复现。但我要多说一句：可复现是手段，不是目的。如果你通过固定随机种子“锁定”了一个高准确率，不代表模型真的更好了，只是运气好。更好的做法是，在多个随机种子下跑 3 次，取平均值作为模型真实水平的估计。

5.3 训练时 CPU 占用率高/内存爆炸怎么处理

LeNet5 很小，理论上内存不会爆。如果你内存爆了，多半是 DataLoader 的问题——num_workers设置太高，或者 batch size 太大。CPU 训练时，把num_workers=2就够了，太多反而因为进程切换开销导致更慢。另外检查是不是在验证时忘了torch.no_grad()，我之前说过，忘记它会让 PyTorch 在验证时也构建计算图，内存飙升两三倍，非常容易爆。

5.4 加载本地数据集失败、下载超时怎么办

如果你在公司内网或者网络受限，download=True可能一直报超时错误。此时需要手动下载数据集，放到指定目录。MNIST 数据集的四个文件比较小，总量约 11MB，下载很快。下完之后，把train=False和train=True的数据分别放到raw目录下，注意torchvision对文件名有约定。或者你干脆自己写一个简单的数据加载器，反正 IDX 格式解析不复杂，网上有现成代码可以抄。但这毕竟是个不错的练习——自己解析一个二进制数据集，能让你对“数据从磁盘到 Tensor”的整个过程有更完整的认识。

5.5 一个容易被忽略的问题：模型在 CPU 和 GPU 上的结果不一致

有时候你在 GPU 上训练到 99%，换到 CPU 上跑同一个测试集，结果只有 98.9%。这是因为浮点运算顺序不同，GPU 上的并行计算改变了累加顺序，导致微小差异。这没问题，不用排查。但如果差异超过 1%，那说明你的代码里可能有问题，比如某些层在model.eval()和model.train()下的行为不同，或者用了 Dropout 但没有正确切换模式。

5.6 心得：解决 MNIST 问题的“顿悟时刻”与“功课沉淀”

我在带 A 同学跑这个项目的时候，他卡在“loss 从 0.3 降到 0.1 后就再也不降”的阶段。我们用了很多办法，最后发现是他的DataLoader里shuffle=False，导致每个 epoch 看到的 batch 顺序固定，模型学到的是“顺序模式”而不是“数字特征”。换成shuffle=True后，loss 立刻继续下降。这个案例很经典：当模型卡在局部最优或者损失平台期时，不要急着换模型，先检查数据加载、预处理、训练模式这些“看不见的变量”。

这个经历给我的深刻教训是：复现一个经典项目，重点不是“复现成功”这个结果，而是每一次尝试里你能不能用逻辑推演出“问题出在哪”。MNIST 上所有失败的教训，放到真实业务项目里都是通用的：数据是否有问题？预处理是否一致？训练和验证的模式是否切换？梯度是否正常？这些排查思路，比准确率高几个百分点重要得多。

6. 写在最后的几句实在话

LeNet5 和 MNIST 的组合，我已经不是第一次跑了，但每次重新拿出来做，都还能有新的体会。现在我给大家几条基于实操的建议。

第一，跑通之后一定要改一个变量，比如把卷积核换成 3×3、把池化换成最大池化、把 Adam 换成 SGD，然后观察现象。这是“主动学习”和“被动跟跑”的根本区别。第二，一定要输出混淆矩阵并且挨个看错误样本，这是建立直觉最快的路径——你会知道什么叫“模型把 9 认成 4 是因为结构真的像”。第三，把训练好的模型保存下来，写一个可视化 Demo，让模型“跑”起来。

最后分享一个我实验里验证过的小技巧：如果你想让 LeNet5 在 MNIST 上冲上 99.3%，把全连接层前的特征图方差打印出来看一眼。如果方差太小，说明卷积层学到的特征分布太集中，可以在训练时对特征向量做一个简单的“白化”处理（减均值除标准差），全连接层的收敛会快很多。这个技巧不常用，但能帮你理解“特征分布对分类器的影响”这件事。

这个项目做完，下一步你可以往三个方向走：一是加深网络结构，把手写数字换成 CIFAR-10，体会“经典结构不够用”的瓶颈；二是引入 BatchNorm、Dropout 等现代模块，对比它们对训练稳定性和最终精度的影响；三是尝试用 ONNX 导出模型，部署到手机上跑一下，感受真实场景和理想测试集的差距。无论选哪条路，LeNet5 打下的底子，都会在后面的项目里反复用到。