Python深度学习入门实战：用PyTorch完成MNIST图像分类

1. 学习路线与整体设计思路

1.1 先想清楚：你学深度学习到底卡在哪一步

我一直觉得，深度学习入门这件事，最难的其实不是数学，也不是代码，而是不知道自己该做什么。网上教程一搜一大把，今天看一篇文章讲卷积核，明天刷一个视频说损失函数，后天又有人告诉你得先补线代和概率论。结果就是学了三个星期，命令行还停留在pip install，模型练手项目一个没跑通。

我自己带过不少朋友入坑，也接过不少新手的求助。最后发现一个共性规律：凡是一路顺畅走下来的，靠的不是智商，而是把目标拆成了闭环小项目。比如“用Python写一个能识别手写数字的模型”，你不需要学完所有深度学习理论才能动手，你只需要知道一个最朴素的神经网络大概长什么样、数据是什么格式、训练流程是哪几步，就能跑出一个像样的结果。跑通之后再去补细节，你会发现之前看不懂的理论突然就有画面感了。

所以这篇博文的核心思路就是：以“完成一个可运行的图像分类项目”为锚点，从环境搭建、理论骨架、代码实现到问题排查，逐步推进。这条路我自己走过，也推荐给目标不明确的新人。文章适合有 Python 基础、但不了解深度学习的读者；也适合那些“学了不少概念却从未跑通过模型”的半入门选手。

1.2 拆解标题关键词：Python、深度学习、入门、实战

把标题拆开看，其实每个词都对应着一个核心问题。

Python对应的是工程基础。深度学习框架的日常使用，本质上就是 Python 函数的调用和数据的流转。你不需要写框架的底层实现，但至少要看得懂类、字典、列表操作，以及最基础的文件读写和 numpy 的基本用法。如果这一层不熟，建议先花几天补一补，不然后面调试代码时会很痛苦。

深度学习对应的是模型理论。这里有个常见的误区：新人以为“深度学习=搭神经网络模型”，一上来就要攒各种网络结构。实际上，深度学习作为一种机器学习方法，核心是“数据+模型+损失+优化”这四件事。你只要把这四个关键字串成一条线，再看任何网络结构，都不会慌。

入门意味着目标要设得合理。我见过不少同学第一周就尝试复现大模型或者目标检测项目，然后在一堆环境报错中消磨掉了所有热情。入门阶段，选择任务的标准只有一个：公开数据集容易获取、训练时间短、结果可直观验证。MNIST、CIFAR-10 这类经典数据集就是为此存在的。

实战则是整篇文章的重头。实战不是照着别人的代码敲一遍，而是理解每一步在做什么、为什么要这么写、跑出的结果怎么判断好坏。前面铺垫再多，最终都要落到你能在自己的电脑上，写出一段代码，让模型真正跑起来，输出一个可量化的准确率数字。

1.3 为什么很多人中途放弃：目标倒挂与理论前移

对入门者而言，最常见的失败模式有两种。

第一种叫目标倒挂。什么意思呢？就是一开始把“我要精通深度学习”当目标，于是先去啃《花书》、去刷网课讲义、去背各种网络结构的公式推导。倒不是这些内容没用，但它们是在你已经具备基本实践体感之后才有价值的。没有跑过模型的人看反向传播，就像没开过车的人看发动机原理图，看的时候觉得“原来如此”，转头就忘，真到修车时还是不知道从哪里下手。

第二种叫理论前移。和第一种有点像，但更隐蔽：明明已经在写代码了，还是忍不住想先把每一行背后的数学原理都搞明白再往下走。比如写linear = nn.Linear(784, 128)时，一定要先弄明白权重矩阵的形状怎么算出来的才肯写下一行。结果是一下午卡在一行代码上。我个人的经验是，代码可以先照葫芦画瓢，等整个流程跑通后，再回头逐行解释。那时候你的问题会非常具体，比如“为什么权重初始化是那个分布”，而不是笼统的“什么是反向传播”。

这篇文章的思路正是奔着“避开这两种失败模式”去的——不要求你先成为理论大师，而是带你快速建立一条正确的、可落地的实践路径。

2. 环境准备与工具选型

2.1 框架选择：为什么推荐 PyTorch

深度学习框架的选择，是每个新手都会纠结的问题。我在这里直接给结论：入门阶段，无脑选PyTorch。

原因有三：

第一，调试更友好。PyTorch 是动态计算图，张量在代码执行过程中即时计算，这意味着你可以像调试普通 Python 代码一样，通过print或者断点查看中间结果的 shape 和数值。如果你用过 TensorFlow 1.x 那种先构图再执行的方式，就知道这个特性有多重要了。

第二，社区生态偏向实战。当前学术界和工业界的很多开源项目都是 PyTorch 系，配套工具、教程、预训练模型的丰富程度都很高。跑一个项目卡住了，搜“pytorch + 问题描述”，出来的可参考结果数量远多于其他框架。

第三，语法贴近普通 Python 习惯。nn.Module其实就是一个类，forward就是__call__。你用 Python 写面向对象程序的经验，几乎可以无缝迁移到 PyTorch 模型定义上。

当然这不是说 TensorFlow 或 PaddlePaddle 不行。它们各有优势，比如 TensorFlow 部署生态更完整、某些框架中文文档更充足。但对入门者来说，你需要的不是“生产级部署工具链”，而是“理解深度学习最短路径上的一个顺手工具”。PyTorch 在这一点上做得最扁平。

2.2 环境配置实操：从 Python 到 CUDA

环境配置这一步，我建议按下面的顺序一次走通。你在网上看到许多乱七八糟的报错，绝大多数都是因为环境版本不匹配，而不是代码本身有问题。

首先，安装 Python。这里推荐直接装 3.10 或 3.11，太旧的版本（比如 3.7）会在某些依赖包上遇到“已停止支持”的尴尬，太新的版本（比如 3.13）又可能因为刚发布不久，一些底层库还没适配完。选中间偏新的稳定版本是最省心的策略。

其次，创建虚拟环境。这一步真的别省。我见过太多人把包直接装到全局环境，最后为了项目 A 升级了某个库，项目 B 就挂了。用conda或venv都行，关键是隔离。比如用 conda：

conda create -n dl_env python=3.11 conda activate dl_env

接着，安装 PyTorch。这里要特别留意版本匹配问题。如果你有 NVIDIA 显卡，先查看自己的显卡支持到什么版本的 CUDA，然后到 PyTorch 官网选对应版本安装。命令格式大致类似：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

cu121表示对应的 CUDA 版本。如果不确定显卡情况，或者电脑压根没有独显，可以直接安装 CPU 版本，跑小型项目完全没问题，后续有需要再换 GPU 版。这一步很多人容易卡住，实际上只要记住“先看显卡，再看 CUDA，再到官网选对应命令”就够了。

提示：验证 PyTorch 是否装好的最快方式，是在 Python 环境里执行import torch; print(torch.__version__); print(torch.cuda.is_available())。如果返回 True 且 GPU 设备能显示，说明加速环境OK。返回 False 也没关系，CPU 同样能跑通后续所有代码。

2.3 剩余依赖与数据集说明

除了 PyTorch，我们还需要两个很基础的库：numpy和matplotlib。前者用于数据处理，后者用于可视化训练曲线。安装就是一行命令的事：

pip install numpy matplotlib

关于数据集，文章实战部分选用的是 MNIST 手写数字数据集。它包含 0 到 9 共十类手写数字灰度图，每张图 28x28 像素，训练集六万张、测试集一万张。这个数据集有三个特点特别适合入门：一是足够小，一个 CPU 训练版本几十分钟内就能跑完；二是任务语义清晰，任何人看一眼图片就知道模型在做什么；三是 PyTorch 内置工具可以直接下载和加载，不需要你手动处理文件格式。

后续我也列出了 CIFAR-10 等进阶数据集的思路，但第一遍走通流程时，不建议换更复杂的数据集，原因后面会细说。

3. 核心原理拆解：用生活逻辑理解神经网络

3.1 神经网络到底在做什么

我用一个生活化的例子来解释。

假设你是一个从来没有见过猫的外星人，要通过一堆照片学会分辨“这是猫”还是“不是猫”。你会怎么做？你会先注意到猫有尖耳朵、长胡须、四条腿，然后把“有多尖的耳朵”“有没有胡须”这些打成分数，最后综合所有分数做一个判断：超过某个阈值就认定是猫。

神经网络做的基本上就是这件事。输入一张图片，它提取一些特征（可能是边缘、颜色、纹理，也可能是完全无法用人类语言描述的高级特征），给每个特征一个权重，加加减减，最后过一层“打分”函数判断属于哪个类别。

听起来很简单对不对？但有一个关键细节：神经网络自己决定提取什么特征，并且通过数据调整特征权重。你不需要告诉它“尖耳朵是重要线索”，它自己从海量样本里总结出来。这个过程就叫“学习”——通过不断调整内部的参数，让最终判断的错误越来越少。

3.2 损失函数、反向传播与优化器：训练过程的三大齿轮

理解了“神经网络在做什么”，接下来自然就有一个疑问：参数是怎么自动调整的？

我用一个比喻来拆解。想象你在一个完全黑暗的房间里，要找到最低点。你手里只有一个高度计，每走一步，你能感觉到当前位置的高度是升高了还是降低了。于是你的策略很简单：如果这一步之后高度降低，就继续往这个方向走；如果升高了，就退回去换个方向。反复试，你最终能摸到低点附近。

在这个比喻里，“高度”就是损失值，它衡量模型预测和真实答案之间的差距；“方向”就是梯度；“不断试”的过程就是优化器在起作用。所谓反向传播，就是在计算完损失之后，反着把梯度一层一层传回去，让每一层都知道“该往哪个方向调整自己”。

所以，一次完整的训练循环可以总结为四步：

1. 把一批数据输入模型，得到预测结果。
2. 用损失函数计算预测值与真实标签之间的误差。
3. 反向传播，计算出每个参数的梯度。
4. 优化器根据梯度更新参数，让损失变小。

循环往复。训练的本质就是把这个过程重复成千上万次，直到模型的损失降到一个可以接受的区间。

3.3 常见概念速查：Batch、Epoch、过拟合与学习率

在跑代码之前，有几个高频术语必须先建立直观印象，否则后面看训练日志会一头雾水。

Batch（批次）：训练时不会一次性把所有图片都塞给模型——内存不够，也没必要。通常把数据切成固定大小的小组，比如 32 或 64 张图为一组，一组一组地喂给模型。一个 Batch 的图片数量叫 batch size。

Epoch（轮次）：把所有训练数据从头到尾过一遍，叫一个 epoch。比如训练集六万张图，batch size 是 64，那么一个 epoch 大约有 938 个 batch。训练设定多少个 epoch，模型就要把整个数据集重复看多少遍。

过拟合：模型在训练集上表现很好，一到测试集就拉胯，这种情况最常见。有点像学生把某套题库背得滚瓜烂熟，题目一变就不会了。解决思路有增加数据量、加正则化、简化网络结构、提前停止训练等。入门阶段你需要先能判断“这是过拟合”，再谈解决方案。

学习率：优化器每次更新参数的步子大小。步子太大会震荡甚至发散，损失曲线一上一下；步子太小则收敛极慢。入门阶段用 0.001 作为默认值，后续再根据损失曲线微调，是一个稳妥的做法。

这些概念先别追求公式级理解。等到你代码跑起来了，看到训练日志里的 Loss 从 2.3 降到 0.4，再回过头来看上面这几段，会发现自己什么都不用背就懂了。

4. 从零搭建你的第一个图像分类实战项目

4.1 找到一个最小但完整的任务

这个实战项目，网上类似代码很多，但大部分只是把代码摆出来，没告诉你每一步为什么是长这样的。我这里先把完整流程拆成六步，再给最小可运行代码，最后逐段解读。

我们的任务：用 PyTorch 搭一个小型卷积神经网络，在 MNIST 数据集上完成手写数字分类，预期测试准确率能达到 99% 左右。

为什么是 MNIST 而不是更现代的 CIFAR-10 或 ImageNet？因为入门阶段，网络结构简单、训练时间短、排查问题容易。很多新手见过大世面，第一件事就是想去“屠龙”，但龙没屠到，反而在路上丢了半条命。MNIST 这头新手村史莱姆，恰恰是建立信心的关键。

4.2 完整可运行代码与逐段说明

为了让大家尽快跑起来，我先给出完整版本。你在你创建好的虚拟环境中，把代码保存成train_mnist.py，然后运行python train_mnist.py即可。如果是 CPU 环境，也可以运行，只是训练时间会稍长。

import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader from torchvision import datasets, transforms import matplotlib.pyplot as plt # 1. 数据加载与预处理 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=256, shuffle=False) # 2. 定义神经网络结构 class SimpleCNN(nn.Module): def __init__(self): super(SimpleCNN, self).__init__() self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1) self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1) self.pool = nn.MaxPool2d(2, 2) self.fc1 = nn.Linear(64 * 7 * 7, 128) self.fc2 = nn.Linear(128, 10) self.relu = nn.ReLU() def forward(self, x): x = self.pool(self.relu(self.conv1(x))) x = self.pool(self.relu(self.conv2(x))) x = x.view(x.size(0), -1) x = self.relu(self.fc1(x)) x = self.fc2(x) return x model = SimpleCNN() # 3. 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 4. 训练循环 epochs = 5 loss_history = [] for epoch in range(epochs): running_loss = 0.0 for images, labels in train_loader: optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() avg_loss = running_loss / len(train_loader) loss_history.append(avg_loss) print(f"Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}") # 5. 模型评估 correct = 0 total = 0 model.eval() with torch.no_grad(): for images, labels in test_loader: outputs = model(images) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print(f"Test Accuracy: {100 * correct / total:.2f}%") # 6. 绘制损失曲线 plt.plot(range(1, epochs + 1), loss_history, marker='o') plt.xlabel("Epoch") plt.ylabel("Loss") plt.title("Training Loss Curve") plt.show()

这段代码有一个很好上手的特点：当你把注意力集中在关键几步之后，整个模型可以被压缩成“定义结构—选好损失—循环训练—评估结果”四件事。

信号顺序拆开说一下：

数据部分。transforms.ToTensor()把 PIL 图像转成 Tensor，并将像素值从 0-255 归一化到 0-1。Normalize((0.1307,), (0.3081,))用的是 MNIST 数据集的全局均值和标准差，让数据分布更接近标准正态分布，有助于模型训练。这个均值标准差是官方和实践中常给的固定值，不用自己算。

网络结构部分。SimpleCNN由两层卷积、两层池化、两层全连接构成。卷积层负责提取局部特征（边缘、纹理等），池化层负责压缩特征图尺寸，全连接层负责把特征组合成最终的分类打分。值得注意的一个数字计算：输入是 28x28 的单通道图片，经过第一层卷积和一次池化后变成 14x14，再经过第二层卷积和一次池化后变成 7x7，通道数是 64。因此fc1的输入维度是64 * 7 * 7 = 3136。很多新人看不懂“这个 7*7 哪来的”，其实就是输入尺寸减半两次的结果。

训练循环部分。optimizer.zero_grad()是新手最容易漏掉的一步。PyTorch 默认会累积梯度，如果不手动清零，多个 batch 的梯度就会叠加，参数更新就会乱掉。这个细节等看到训练 Loss 乱七八糟时再回来复习，印象会更深刻。loss.backward()和optimizer.step()分别对应“算梯度”和“更新参数”。

评估部分。注意model.eval()和with torch.no_grad():。前者是切到评估模式，后者是告诉 PyTorch“这里不需要计算梯度”。评估时不需要梯度，这样能省内存和加速，更关键的是避免 dropout 或 batch normalization 等层在训练/评估模式下的行为差异。

4.3 训练结果分析：怎么看 Loss 曲线和准确率

我在 CPU 环境下跑这个代码，5 个 epoch 大约耗时十几分钟。输出大致像这样：

Epoch 1/5, Loss: 0.1821 Epoch 2/5, Loss: 0.0766 Epoch 3/5, Loss: 0.0506 Epoch 4/5, Loss: 0.0381 Epoch 5/5, Loss: 0.0287 Test Accuracy: 98.62%

观察 Loss 曲线，你会发现前两个 epoch 下降很快，后面变慢，这是非常正常的收敛现象。98.62% 的准确率看着已经很不错了，但距离 MNIST 上常见 99%+ 还有一点距离。怎么提高？有几个方向：增加训练轮次、调高 batch size、加数据增强、换更深的网络、或者调学习率。

这里我特别建议一点：不要过早追求 99%，先看看 98% 是怎么跑出来的结论。等你理解了整个训练流程，再往上加分就是水到渠成的事。

如果要用 GPU 训练，只需要把模型和输入数据加上.cuda()：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = model.to(device) # 训练时 images = images.to(device) labels = labels.to(device)

很多框架自带这样的 device 判断代码，你也可以直接采用。

4.4 模型保存与加载：让训练成果可以复用

训练完模型，如果不保存，关掉程序就什么都没了。保存和加载模型有几种方式，我推荐最常用也最少坑的一种——保存完整模型的状态字典：

torch.save(model.state_dict(), "mnist_cnn.pth")

加载时，需要先重新定义模型结构，再把权重加载进去：

model = SimpleCNN() model.load_state_dict(torch.load("mnist_cnn.pth", weights_only=True)) model.eval()

这里有个新手容易犯的错：只保存了模型文件，却忘记网络结构定义。加载模型时如果没有先定义模型类，就会直接报错。所以完整可复用的做法是，把模型定义单独放到一个.py文件中，方便加载时直接导入。

weights_only=True是近几年 PyTorch 版本新增的安全参数，防止加载恶意 pickle 文件，建议加上。model.eval()也别忘了——它确保模型在推理时处于正确的行为模式。

5. 项目进阶方向与更多实战经验

5.1 从 MNIST 到 CIFAR-10：换个数据集，问题翻倍

如果 MNIST 已经跑顺了，下一步顺理成章就是换一个更接近真实场景的数据集。CIFAR-10 是最自然的进阶选择：它包含 10 个类别（飞机、汽车、鸟、猫、鹿、狗、青蛙、马、轮船、卡车），每张图是 32x32 的彩色图片。看起来只是“从灰度变彩色、分辨率涨一点”，但实际训练中会涌现大量 MNIST 上没有的问题：

第一，显存和内存压力变大。彩色图片通道数从 1 变 3，输入数据量直接乘 3。可能在 MNIST 上跑得动的一整套配置，到 CIFAR-10 就内存爆掉或训练慢好几倍。

第二，过拟合更容易出现。CIFAR-10 只有五万张训练图片，相对其复杂度和类别数来说，数据量是不够的。如果继续用 MNIST 上的简单网络结构和训练参数，你会发现自己训练集准确率马上逼近 100%，测试集却停滞在 60% 左右。这时候你就得开始真正理解“数据增强”“正则化”“更深的网络”这些概念，而不再只是听过名词。

第三，预处理更讲究。CIFAR-10 的均值和标准差不是固定的 0.1307 了，需要自己先统计或直接使用官方常用的均值（0.4914, 0.4822, 0.4465）和标准差（0.2470, 0.2435, 0.2616）。

我个人建议的进阶路径是：换到 CIFAR-10，但不要一开始就换网络结构。先用之前的 SimpleCNN 稍作调整跑一遍，记录准确率；然后再做三件事：加数据增强、加入 BatchNorm 层、调学习率策略，看看每个改动对准确率的影响。这样你就完成了从“会跑代码”到“会做实验”的关键跨越。

5.2 迁移学习：站在预训练模型肩膀上

如果不想从零训练又想要更好的效果，可以直接用 PyTorch 内置的预训练模型做迁移学习。比如拿一个在 ImageNet 上预训练过的 ResNet18，替换掉最后的全连接层，让它输出 10 类分类；然后冻结前面的权重、只训练最后一层，或者解冻一部分层做微调。这是实战中最常见、性价比最高的方案。

迁移学习的入门姿势大致是这样：

import torchvision.models as models model = models.resnet18(pretrained=True) model.fc = nn.Linear(model.fc.in_features, 10)

对于 CIFAR-10，因为图片尺寸是 32x32 而 ResNet 默认输入是 224x224，可能需要先调整输入尺寸，或用更小的变体（比如 resnet18 搭配适当缩放）。这不影响原理理解，但你要知道输入尺寸是网络结构的硬约束之一。

迁移学习适合解决“数据量不足又想有不错效果”的场景。入门阶段看一遍流程即可，不必深入太多细节。等自己的训练流程很熟了，再尝试这种“用别人训练好的模型起跑”的玩法，体验会好很多。

5.3 把项目变成可展示的成果

很多人学完深度学习，会有一个共同的困惑：代码跑通了，然后呢？我建议你把项目包装成一个可展示的小成果，这样既巩固知识，也是极好的个人素材。

一个很简单的做法是写一个推理脚本：接受一张本地图片，预处理成模型需要的格式，输出预测类别和置信度。再进一步，可以用 Streamlit 或 Flask 包一个极简 Web 界面，让用户上传一张手写数字图片，页面返回“模型认为这是 7，置信度 99%”。这个完整链路不长，但对“深度学习能做什么”的理解会提升一个台阶，也倒逼你把数据预处理这一环想清楚——因为训练时有框架帮你处理数据，但实际推理时，面对任意一张图，你能不能让它顺利喂进模型，是另一回事。

我见过很多同学拿这种方法作为自己进入机器学习领域的第一个正式项目，既不像玩具，门槛也不算高，非常推荐试一试。

6. 常见问题与排查技巧实录

6.1 环境与安装类问题速查表

到这里，我把操作中真正高频踩坑的问题整理成表，好查找：

6.2 训练过程中的报错与排查思路

训练时最常见的报错之一是维度不匹配。比如：

RuntimeError: mat1 and mat2 shapes cannot be multiplied

这种错误大概率是nn.Linear的输入维度没算对。排查思路是检查特征图经过卷积和池化后的尺寸。我的习惯是：遇到这种问题，先打印x.shape。在forward函数里临时加一行print(x.shape)，就能定位是哪一层输出了预期外的尺寸。找到之后，要么调整nn.Linear的输入维度，要么调整网络结构。

另一个高频问题是损失变成 NaN。原因可能是学习率过大、数据里有异常值、或者权重初始化不当。简单图像分类任务里，最常见的是学习率问题。先将学习率降到 0.0001 试试；如果还不行，检查数据预处理，确认输入不是全零或全满的极端值。

还有新手特有的一道坎：明明训练 Loss 降着降着突然跳高，最后准确率也一般。这时候除了想到学习率震荡，还有一个容易被忽略的坑——忘记optimizer.zero_grad()。梯度一直在累积，参数更新步长就乱了。遇到 Loss 曲线像心电图一样上下乱窜，先查这一行。

6.3 我踩过的坑：几个值得你避开的弯路

第一个坑是太早使用复杂网络结构。我当年入门时，MNIST 只跑通一次就直接上了 ResNet，结果训练时间暴增，代码还各种报错，连是不是代码问题都难以判断。后来退回简单的三层 CNN，几分钟跑一个实验，反而很快把流程吃透了。复杂结构在引路人阶段毫无必要，它只会让排查问题的成本线性上升。

第二个坑是在全局环境里装包。有一段时间我在两个 Python 项目之间反复切换，一个需要旧版 numpy，另一个需要新版，冲突到怀疑人生。后来老老实实用虚拟环境隔离，半分钟切换一次，再也没为依赖问题头疼过。这一条希望你能在开头就做好。

第三个坑是不记录实验结果。训练完一个模型，准确率 98.6%，改了 batch size 后变成 98.9%，这中间到底是哪一步带来的提升？如果不记录，你会完全凭感觉，相当于白做实验。我现在每跑一次实验，都会用 Markdown 或表格简单记下：日期、模型结构、batch size、学习率、epochs、最终准确率。这一点看起来琐碎，但长期收益极大。

6.4 提升训练效率的三个小习惯

最后分享几个让日常实践更顺手的习惯。

第一，固定随机种子。深度学习涉及大量随机初始化，不固定种子的话，每次运行结果可能略有差异。这对复现实验和排查问题是致命的。在代码开头加几行：

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

第二，用 TensorBoard 或简单的 matplotlib 保存训练曲线。我之前只会盯着终端输出的 Loss 数字，感觉不直观。后来养成把每个 epoch 的 Loss 绘制成曲线的习惯，一眼就能看出是收敛正常、过拟合还是发散。观察训练曲线是深度学习中最常用的判断手段，没有之一。

第三，从小数据集开始调试。在完整跑 60000 张图之前，可以先只取 100 张图、 2 个 epoch 跑一遍全流程。这样代码的问题能在两分钟内暴露，而不是等你泡了半小时咖啡回来才发现第二行就报错。这个习惯在我切换网络结构或改数据处理逻辑时特别有用。

写在最后的经验体会

如果让我总结这段学习旅程里最重要的东西，我的答案不是神经网络结构，也不是某个调参技巧，而是“尽快制造一个完整的正反馈”。我在实战中发现，只要有一次“我写的代码真的从数据里学出了规律”的体验，后面所有枯燥的补课和调试都会有动力。相比之下，一开始就陷入理论和公式的泥潭，很容易把自己架在半空中，上不去也下不来。

所以我的建议始终是：先跑通一个最简项目，再往回补数学和原理。MNIST 虽然简单，但它作为第一个闭环项目的地位目前还没有被取代。等你有过几次亲手训练模型的经历，再回头看那些当初看不懂的概念，会发现它们全都变得清晰可辨了——这个过程本身就是深度学习入门最值得体验的部分。