MNIST 入门实战：从数据流到模型训练与评估（含完整代码与流程图）

关注

原创最新推荐文章于 2026-10-15 12:08:05 发布 770 阅读 AI 写同款· GEO 优化 ›

手写数字数据集MNIST 文章目录一、简介二、下载MNIST数据集训练集和测试集的长度输出图像数据和标记数据的形状显示手写数字图片输出数据集中的第1个样本显示图片一、简介 MNIST是一个非常有名的手写体数字识别数据集(手写数字灰度图像数据集)，在很多资料中，这个数据集都会被用作深度学习的入门样例。 MNIST数据集是由0到9的数字图像构成的。训练图像有6万张，测试图像有1万张。MNIST数据集是NIST数据集的一个子集，它包含了60000张图片作为训练数据，10000张图片作为测试数据。由250个不同的人手写而成。每一张图阅读详情

📺 B站：博主个人介绍

📘 博主书籍-京东购买链接*：Yocto项目实战教程

📘 加博主微信，进技术交流群： jerrydev

MNIST 入门实战：从数据流到模型训练与评估（含完整代码与流程图）

目标：用 MNIST 把深度学习最核心的一条主线走通——数据 → 模型 → 损失 → 反向传播 → 更新参数 → 评估 → 保存/加载 → 推理。读完你会对“训练到底在做什么”“评估到底评估了什么”“.pth 到底是什么”形成清晰、稳定的概念框架，并具备继续突破到更复杂任务（CIFAR、检测、分割、YOLO、Transformer）的基础。

在这里插入图片描述

1. 你已经做到了什么？为什么这条路径很重要

你已经跑通了一个完整的 CNN 分类项目：

数据：MNIST
模型：两层卷积 + 两层全连接（带 Dropout）
训练：CrossEntropyLoss + SGD
评估：test loss + test acc
保存：生成 mnist_cnn.pth

并且得到了非常合理的结果：

test acc ≈ 97%+
test loss 逐步下降

这说明：

数据流（DataLoader）没问题；
模型结构（forward）没问题；
训练闭环（loss → backward → step）成立；
评估逻辑（eval + no_grad + 统计）正确；
参数存档（.pth）可复用。

这条路径是所有 AI 任务的“地基”。以后你换数据集、换模型、换任务，本质上还是这条主线，只是每一段更复杂。

2. 全流程总览：一张逻辑图把它串起来

下面这张“主线流程图”非常建议你记住：

┌──────────────┐
│  数据集 Dataset │  MNIST(train/test)
└──────┬───────┘
       │ transform(ToTensor/Normalize)
       ▼
┌──────────────┐
│ DataLoader     │  batch化、shuffle、并行加载
└──────┬───────┘
       │  (data:[B,1,28,28], target:[B])
       ▼
┌──────────────┐
│  模型 Net      │  forward: [B,1,28,28] → logits[B,10]
└──────┬───────┘
       │
       ▼
┌──────────────┐n│  Loss 函数     │  CrossEntropyLoss(logits, target)
└──────┬───────┘
       │
       ▼
┌──────────────┐
│ backward()    │  自动求梯度: p.grad
└──────┬───────┘
       │
       ▼
┌──────────────┐
│ optimizer.step│  更新参数: θ ← θ - lr * grad
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  评估 Evaluate │  net.eval + no_grad + 指标统计
└──────┬───────┘
       │
       ▼
┌──────────────┐
│ 保存/加载 .pth │  state_dict() / load_state_dict()
└──────────────┘

你可以把它理解为：

Net 是“会计算的结构”；
Loss 把“对不对”变成“可优化的数字”；
Backward 给每个参数算出“该往哪改”；
Optimizer 真正“改参数”；
Evaluate 用测试集验证“改得值不值”。

3. 数据部分：Dataset / Transform / DataLoader 到底做了什么

3.1 MNIST 是什么数据？

MNIST 是手写数字识别数据集：

图片：28×28 灰度图（单通道）
标签：0~9 十个类别
训练集：60000
测试集：10000

在 PyTorch 里，一条样本通常表现为：

image: torch.Tensor，形状 [1,28,28]
label: int，范围 0…9

3.2 为什么 DataLoader 出来是 `[B,1,28,28]`？

你训练时拿到的是一个 batch：

data.shape == [B, 1, 28, 28]
target.shape == [B]

四维的含义非常固定：

维度	含义	MNIST 示例
B	batch_size	32
C	通道数	1（灰度）
H	高度	28
W	宽度	28

只要你看到 [B,C,H,W]，你就知道它是“图片批次输入”。

3.3 transform：ToTensor + Normalize 为什么必做？

你的 transform 典型是：

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

ToTensor()：把图像从 0~255 的像素转换为 0~1 的 float 张量
Normalize(mean, std)：做标准化：

[
x’ = \frac{x - mean}{std}
]

为什么要标准化？

让输入分布更稳定；
梯度更容易优化；
训练更快、收敛更稳定。

你看到 min/max 出现负数，就是 Normalize 生效的直接证据。

3.4 你本地的 data/ 目录意味着什么？

你看到的：

data/MNIST/raw/
  train-images-idx3-ubyte
  train-labels-idx1-ubyte
  t10k-images-idx3-ubyte
  t10k-labels-idx1-ubyte

说明：

数据源来自 torchvision.datasets.MNIST(root='data/', download=True, ...)；
评估时使用 train=False 对应 t10k-*（测试集）；
训练时使用 train=True 对应 train-*（训练集）。

4. 模型部分：Net 是“结构”，参数是“记忆”

4.1 你写的 Net 到底是什么？

在 PyTorch 里：

class Net(nn.Module) 定义了网络结构（哪些层、如何连接）；
forward(self, x) 定义了前向计算（输入如何流过这些层）；
模型参数（权重、偏置）被 nn.Conv2d / nn.Linear 等层自动创建。

一句话：

模型 = 结构（Net） + 参数（weights/bias）。

4.2 CNN 为什么有效？卷积、池化、全连接各自负责什么

可以把 CNN 分为两段：

特征提取器：Conv/Pool
分类器：Linear

直觉理解：

Conv：在局部区域找“笔画、边缘、拐角”
Pool：让特征更稳、更省计算
FC：把多个特征组合，输出 10 类得分

4.3 形状追踪：你必须会“追输出形状”

以你常用结构为例：

输入：[B,1,28,28]

conv1(1→8, k=3)：[B,8,26,26]
maxpool(2)：[B,8,13,13]
conv2(8→16, k=3)：[B,16,11,11]
maxpool(2)：[B,16,5,5]
flatten：[B,400]（因为 1655=400）
fc1：[B,40]
fc2：[B,10]（logits）

只要你追得出 400 的来源，你对 CNN 的理解就非常稳。

4.4 logits 是什么？为什么不是直接输出概率？

模型输出 [B,10]，这不是概率，而是 logits（打分）。

预测类别通常是：

pred = logits.argmax(dim=1)  # [B]

训练时用 CrossEntropyLoss(logits, target)，它内部会做 softmax 相关处理，所以你不需要手写 softmax。

5. 训练部分：三件套把“计算结构”变成“会学习的系统”

5.1 训练三件套：loss / backward / optimizer

训练的核心闭环：

forward：模型输出 logits
loss：把“错得程度”变成一个数字
backward：求每个参数的梯度（该往哪改）
step：更新参数（真的改）

最简骨架：

optimizer.zero_grad()
logits = net(data)
loss = criterion(logits, target)
loss.backward()
optimizer.step()

5.2 为什么一定要 zero_grad()

PyTorch 默认会把梯度累加；如果不清零，上一个 batch 的梯度会污染当前 batch。

你可以把它理解为：

每个 batch 都要单独算一次“该怎么改”；
不能把历史梯度一直加下去。

5.3 net.train() 与 net.eval() 的区别（非常关键）

这不是“可有可无”。尤其你用了 Dropout。

net.train()：训练模式，Dropout 生效
net.eval()：评估模式，Dropout 关闭（输出更稳定）

你出现 test acc 比 train acc 高一点，在带 Dropout 的训练里不罕见：训练时更难，评估时更容易。

5.4 为什么 loss 会从 2.3 降下来？

在 10 类分类里，模型完全随机时：

每类概率大约 1/10
交叉熵大约 (\ln(10) ≈ 2.3026)

所以你最开始看到 loss ≈ 2.3 非常合理。

训练后，模型对正确类别给更高分，loss 就下降。

6. 评估部分：你到底评估了什么？关键函数和关键变量

你目前做的基础评估非常正确：

平均 loss（test avg loss）
准确率（test accuracy）

评估的关键点：

6.1 评估数据从哪里来？

评估使用的是 MNIST 测试集：

test_ds = torchvision.datasets.MNIST('data/', train=False, ...)

对应你目录里的：

t10k-images-idx3-ubyte
t10k-labels-idx1-ubyte

6.2 评估为什么要 no_grad()？

评估只需要 forward，不需要 backward。

torch.no_grad() 的价值：

更快
更省显存
更不容易内存爆

6.3 评估最核心的统计逻辑是什么？

logits：net(data)
loss：criterion(logits, target)
pred：logits.argmax(dim=1)
correct：(pred == target).sum()

最终：

avg_loss = total_loss / total_samples
acc = total_correct / total_samples

7. 训练日志该怎么读？你这份结果说明了什么

你的输出：

Epoch 1: train loss=0.6006, train acc=80.70%
          test loss=0.1068, test acc=96.75%
Epoch 2: train loss=0.3271, train acc=89.95%
          test loss=0.0856, test acc=97.34%
Epoch 3: train loss=0.2842, train acc=91.26%
          test loss=0.0718, test acc=97.60%

可以简单做三点结论：

loss 在下降：说明优化器在持续把模型往正确方向推；
acc 在上升：说明预测正确率提升；
test acc 达到 97%+：说明模型已经学到 MNIST 的主特征；

你的模型在 3 个 epoch 已经接近“够用”。如果继续训练可能还会涨，但收益会变小。

8. `mnist_cnn.pth` 到底是什么？怎么理解它的“类型”

8.1 `.pth` 不是模型结构，而是模型参数

你保存的是：

torch.save(net.state_dict(), 'mnist_cnn.pth')

state_dict() 是一个“参数字典”：键是参数名，值是张量
.pth 只是常用后缀名，表示 PyTorch 的保存文件

一句话：

mnist_cnn.pth 保存的是 你训练得到的“记忆”（权重/偏置）。

8.2 为什么必须同时有 Net 才能用 `.pth`

.pth 本身不包含 forward 的代码逻辑。

可用模型 = Net() + load_state_dict(mnist_cnn.pth)。

8.3 你可以用一行看它内部是什么

import torch
sd = torch.load('mnist_cnn.pth', map_location='cpu')
print(type(sd))
print(list(sd.keys())[:10])

你会看到：它是 dict，里面有 conv1.weight、fc2.bias 等键。

9. 一份“初学者最推荐”的工程组织方式

你现在的结构已经很健康：

jerry_mnist/
  create_model.py   # 模型结构
  get_data.py       # 数据准备（可选）
  train_model.py    # 训练 + 评估 + 保存
  eval_basic.py     # （建议新增）单独评估
  mnist_cnn.pth     # 训练结果参数
  data/             # MNIST 数据缓存

推荐原则：

模型结构独立文件（便于复用）
训练脚本只管训练
评估脚本只管评估
推理脚本只管推理

这样你后面做 CIFAR10、做猫狗分类、做 YOLO，都可以复用思路。

10. 代码模板：最简训练脚本（带注释）

下面是一份“看一眼就懂”的训练框架（与你现在的逻辑一致）：

# train_model.py（结构示意）

# 1) 准备 DataLoader（train_loader / test_loader）
# 2) 创建模型 net = Net().to(device)
# 3) 定义 loss + optimizer
# 4) 循环 epoch：
#    4.1 net.train()
#    4.2 对 train_loader：zero_grad → forward → loss → backward → step
#    4.3 net.eval() + no_grad()
#    4.4 对 test_loader：forward → 统计 loss/acc
# 5) 保存参数 torch.save(net.state_dict(), 'mnist_cnn.pth')

你要掌握的是“骨架”，以后换任何任务都能套进去。

11. 评估进阶：从两个指标走向“知道错在哪”

你现在评估了 loss/acc，这已经是基础合格。

接下来想提高理解和实战能力，建议加三种评估：

混淆矩阵：看哪些数字互相混淆
每类准确率：哪个类最弱
错误样本可视化：错的样本长什么样

这三件事会让你从“知道结果不错”升级到“知道怎么继续提升”。

12. 从 MNIST 走向更大突破：下一步练什么最有效

当你把 MNIST 这一套跑稳后，推荐你按这个顺序升级：

12.1 升级数据：CIFAR-10

32×32 彩色图（3 通道）
更贴近真实视觉任务
你会遇到：数据增强、过拟合、模型更深

12.2 升级模型：更规范的 CNN（BatchNorm、更多层）

加 BatchNorm 稳定训练
更深的网络、残差结构（ResNet）

12.3 升级任务：目标检测（YOLO）

输入输出不再是 10 类得分
变为：框位置 + 类别 + 置信度

但注意：无论怎么升级，“主线流程图”依旧成立。

13. 关键知识点清单（建议你定期扫一遍）

数据

Dataset / DataLoader
[B,C,H,W] 含义
transform：ToTensor / Normalize

模型

nn.Module / forward
Conv / Pool / Flatten / Linear
logits 与 argmax

训练

criterion（CrossEntropyLoss）
optimizer（SGD/Adam）
zero_grad → forward → loss → backward → step
train() vs eval()

评估

no_grad()
avg loss / accuracy
错误分析（混淆矩阵、错例）

保存

state_dict() / load_state_dict()
.pth 是参数存档，不是结构

14. 你目前这份项目的一句话“专业总结”

你已经完成了一个可复用的 PyTorch 图像分类最小工程：

使用 torchvision.datasets.MNIST 构建训练/测试数据流；
使用自定义 CNN（两层卷积 + 两层全连接 + Dropout）进行分类；
使用 CrossEntropyLoss + SGD 完成训练闭环并达到 97%+ 测试准确率；
使用 state_dict() 将训练得到的参数保存为 mnist_cnn.pth，可在任意环境中通过 load_state_dict() 复现推理效果。

15. 附：你可以直接复制的“推理脚本”骨架（可选）

如果你想快速验证 .pth 的价值：

# predict_one_batch.py
import torch
import torchvision
from torch.utils.data import DataLoader
from torchvision import transforms

from create_model import Net

device = 'cuda' if torch.cuda.is_available() else 'cpu'

# 1) load model
net = Net().to(device)
net.load_state_dict(torch.load('mnist_cnn.pth', map_location=device))
net.eval()

# 2) test loader
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

test_ds = torchvision.datasets.MNIST('data/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_ds, batch_size=32, shuffle=True)

data, target = next(iter(test_loader))
data = data.to(device)

with torch.no_grad():
    logits = net(data)
    pred = logits.argmax(dim=1).cpu()

print('pred[:10]  =', pred[:10].tolist())
print('target[:10]=', target[:10].tolist())