PyTorch入门实战：从全连接到卷积神经网络手写数字识别

1. 从零开始理解神经网络与PyTorch

1.1 神经网络到底在解决什么问题

先说个最直观的感受。很多朋友第一次接触神经网络，被满屏的加减乘除、矩阵求导吓退，觉得这东西高不可攀。其实神经网络解决的核心问题就一句话：从数据中自动学习规律。传统编程是你告诉电脑规则，电脑执行规则；神经网络反过来，你给电脑一堆输入和对应的输出，它自己找规律，找到规律之后拿新数据来验证。

拿手写数字识别来说，传统方式你要写一套复杂的图像处理逻辑，先分割、再提取特征、然后分类，每一步都要人来设计规则。神经网络不干这事，你直接把像素喂进去，告诉它这个是数字5、那个是数字3，它自己把"什么样的像素组合像5"这种规律学出来。

这里要澄清一个常见的误解：神经网络不是什么神秘的黑魔法，它就是一堆带参数的数学函数叠在一起。训练过程本质上是在解一个巨大的优化问题——找到一组参数，让函数的输出尽可能接近我们期望的结果。理解了这一点，后面看代码会通透很多。

1.2 全连接和卷积的定位差异

很多人问：既然神经网络都能学规律，为什么还要分全连接和卷积？答案其实很朴素：不同的数据形态，适合不同的连接方式。

全连接神经网络（Fully Connected Network，简称FC），每一层的每个神经元都和上一层的所有神经元相连。它的优点是结构简单、什么数据都能吃，缺点是参数太多。一张32×32×3的彩色图片，展开成3072维的向量，输入到第一个全连接层只有512个神经元，那这一层就有3072×512约157万个参数。图片稍大一点，全连接直接爆炸。

卷积神经网络（Convolutional Neural Network，简称CNN）则是专门为图像这类带有空间结构的数据设计的。它利用了一个重要的先验知识：图像中的特征具有局部性——一个物体的边缘、纹理往往只影响一个小区域。所以卷积层只让神经元关注局部区域，通过卷积核在图像上滑动提取特征，参数大大减少，同时还能保持空间信息。

如果用大白话给新手打个比方：全连接像是全班同学互相都认识，信息传播全面但社交成本高；卷积更像是熟人圈子，每个人只跟附近的人打交道，效率反而更高。

1.3 为什么选PyTorch作为入门框架

这是新手最纠结的问题之一：TensorFlow、PyTorch、PaddlePaddle到底选哪个？我的看法很直接：零基础入门就选PyTorch。

原因有三条。第一，PyTorch的调试体验极好，它的动态计算图机制让你可以像写普通Python代码一样逐步执行、随时打印中间结果，这对刚接触神经网络、需要反复确认"到底哪一步算错了"的新手来说，是决定性的优势。TensorFlow的静态图模式对新手很不友好，经常出现"代码写了半天，一运行报错不知道错在哪"的情况。

第二，PyTorch的API设计非常符合Python直觉。torch.Tensor就是一个增强版的NumPy数组，如果你学过NumPy，上手PyTorch几乎没有心理负担。而神经网络层的定义，比如nn.Linear、nn.Conv2d，参数含义清晰，文档详实。

第三，学术圈和工业界的生态都在向PyTorch靠拢。HuggingFace的Transformers库、各种最新的模型论文复现代码，绝大部分都是PyTorch写的。你用PyTorch入门，意味着以后看论文代码、跑大模型相关项目，路径会更顺。

2. 环境搭建与PyTorch基础操作

2.1 环境搭建的核心思路与避坑

很多新手一上来就被环境搞崩溃，装完库跑不起来，第一反应是"我是不是不适合学这个"。其实大部分环境问题都是有规律可循的。

PyTorch的安装说白了就是三个要素：Python版本、CUDA版本、PyTorch版本。这三者必须匹配。最容易踩的坑是你电脑的显卡驱动版本很新，但装了旧版PyTorch，它不认识你的CUDA；或者反过来，装了新版PyTorch，但显卡驱动太老。

我的建议是：第一遍学习，不要装CUDA版，直接装CPU版。原因很简单，零基础阶段跑的是MNIST这种小数据集，几张手写数字图片，CPU版PyTorch完全跑得动，训练一个简单全连接网络几秒钟一个epoch，根本不用等。等把代码逻辑吃透了，再回头配GPU环境，那时候你对报错信息的理解能力也上来了，再排查问题会从容很多。

使用conda创建环境可以用下面的命令，我习惯先把Python版本锁死，避免依赖冲突：

bash复制conda create -n pytorch-beginner python=3.10 -y
conda activate pytorch-beginner
pip install torch torchvision torchaudio

如果安装了GPU版，可以先验证一下PyTorch能不能认出显卡：

python复制import torch
print(torch.__version__)
print(torch.cuda.is_available())

torch.cuda.is_available()返回True说明环境OK，返回False也别慌，先用CPU版把代码跑通才是最务实的方案。

2.2 Tensor与autograd：PyTorch的两根支柱

理解了环境，接下来必须搞懂两个最核心的概念：Tensor和autograd。

Tensor翻译过来叫张量，你可以把它理解成"可以自动求导的多维数组"。普通NumPy数组做运算，算完就完了，你不知道结果对某个输入的变化率是多少。但Tensor不同，它在运算过程中会记录操作历史，构建出一张计算图，然后在需要的时候自动计算梯度。

这就是autograd（自动微分）的作用。它是整个神经网络训练的基石。我们训练神经网络，本质上就是用梯度下降法更新参数。而梯度就是损失函数对每个参数的偏导数。如果手写偏导数公式，对于一层两层的网络还行，一旦网络深了，链式法则展开根本不是人算的。PyTorch的autograd帮你把这部分全部自动化了。

一个最简演示：

python复制import torch

# 创建一个需要梯度的张量
x = torch.tensor([2.0], requires_grad=True)
y = x ** 2 + 3 * x + 1

# 反向传播，自动计算梯度
y.backward()

# 查看dy/dx在x=2处的值：2*2 + 3 = 7
print(x.grad)  # tensor([7.])

这个原理值得多看几遍，因为后面所有网络训练都建立在这个机制之上。你定义一个模型，前向传播算出损失，调用loss.backward()，PyTorch会把每个参数的梯度都算好存起来，然后优化器拿这些梯度去更新参数。整个过程，你一行求导代码都不用写。

2.3 数据加载：Dataset与DataLoader

新手学PyTorch往往忽视数据加载这块，直接拿torchvision.datasets.MNIST一键下载就开跑了，这在入门期没问题。但我建议认真理解Dataset和DataLoader这两个类的职责划分，因为后面你接触真实项目，数据不会这么规整。

Dataset定义"如何读取一条数据"，它回答的是：给一个索引，返回样本和标签。DataLoader定义"如何把这些数据组织成批次"，它负责混洗（shuffle）、分批（batch）、并行加载（num_workers）。

这个划分非常优雅。数据集变了，只需重写Dataset；训练策略变了，只需调DataLoader的参数。比如batch_size=32意味着每次从数据集中随机抽取32个样本一起算损失、一起更新参数，而不是一个个样本地更新。batch_size是神经网络训练里最常调的超参数之一。它太小，训练不稳定、耗时；太大，内存吃紧，而且模型收敛可能变差。入门阶段，32和64是比较稳妥的起点。

3. 全连接神经网络代码实战：手写数字识别

3.1 网络结构设计

我见过很多人一上来就追求"深"网络层数越多越好，这其实是个误区。对于MNIST手写数字识别这个任务，一个三层的全连接网络已经能轻松达到97%以上的准确率。网络不是越深越好，而是跟任务的复杂度匹配。

我们要设计的结构是：

• 输入层：784个神经元，对应28×28像素的图片展开
• 隐藏层1：128个神经元，激活函数用ReLU
• 隐藏层2：64个神经元，激活函数用ReLU
• 输出层：10个神经元，对应0到9十个类别，最后经过LogSoftmax

这里有个关键问题值得展开：为什么用ReLU而不是Sigmoid？因为Sigmoid函数在输入值很大或很小时梯度会趋近于零，也就是"梯度饱和"，导致深层网络训练不动。ReLU在正区间梯度恒为1，缓解了这个问题，而且计算简单。你会在绝大多数现代网络里看到ReLU，就是这个原因。

3.2 完整代码实现与逐行注释

下面给出完整代码，建议对照注释逐行阅读：

python复制import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 1. 数据预处理
# ToTensor()把PIL图像变成Tensor，像素值从[0,255]缩放到[0,1]
# Normalize()用均值和标准差做标准化，让数据分布更规整，训练更稳定
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 2. 加载数据集
# MNIST是经典的手写数字数据集，60000张训练图片，10000张测试图片
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# DataLoader把数据集打包成批次
# shuffle=True打乱顺序，避免模型学到样本的先后顺序
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

# 3. 定义全连接神经网络
class FCNN(nn.Module):
    def __init__(self):
        super(FCNN, self).__init__()
        # 第一层：784 -> 128
        self.fc1 = nn.Linear(784, 128)
        # 第二层：128 -> 64
        self.fc2 = nn.Linear(128, 64)
        # 第三层：64 -> 10，输出10个类别的得分
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        # 输入x的形状是[batch_size, 1, 28, 28]
        # 需要展平成[batch_size, 784]
        x = x.view(x.size(0), -1)
        # 第一层线性变换后过ReLU激活函数
        x = F.relu(self.fc1(x))
        # 第二层同样
        x = F.relu(self.fc2(x))
        # 第三层不加激活函数，因为后面要用CrossEntropyLoss
        x = self.fc3(x)
        return x

# 4. 初始化模型
model = FCNN()
print(model)

# 5. 定义损失函数和优化器
# CrossEntropyLoss内部已经包含Softmax，所以输出层不需要手动过Softmax
criterion = nn.CrossEntropyLoss()
# Adam是自适应学习率的优化器，新手用它基本不会出大错
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 6. 训练循环
def train(model, train_loader, criterion, optimizer, epoch):
    model.train()  # 切换到训练模式，启用Dropout、BatchNorm等训练行为
    total_loss = 0
    for batch_idx, (data, target) in enumerate(train_loader):
        # 前向传播
        output = model(data)             # 得到预测结果
        loss = criterion(output, target) # 计算损失

        # 反向传播三步曲
        optimizer.zero_grad()  # 梯度清零，否则PyTorch会累加这次梯度到上次
        loss.backward()        # 自动计算所有参数梯度
        optimizer.step()       # 根据梯度更新参数

        total_loss += loss.item()
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)}'
                  f' ({100. * batch_idx / len(train_loader):.0f}%)] Loss: {loss.item():.6f}')
    print(f'Epoch {epoch} 平均损失: {total_loss / len(train_loader):.6f}')

# 7. 测试循环
def test(model, test_loader, criterion):
    model.eval()  # 切换到评估模式
    test_loss = 0
    correct = 0
    # 评估模式下不计算梯度，省内存、加速
    with torch.no_grad():
        for data, target in test_loader:
            output = model(data)
            test_loss += criterion(output, target).item()
            # 取预测得分最高的类别作为预测结果
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader)
    accuracy = 100. * correct / len(test_loader.dataset)
    print(f'测试集损失: {test_loss:.4f}, 准确率: {correct}/{len(test_loader.dataset)}'
          f' ({accuracy:.2f}%)')

# 8. 正式训练
if __name__ == '__main__':
    epochs = 5
    for epoch in range(1, epochs + 1):
        train(model, train_loader, criterion, optimizer, epoch)
        test(model, test_loader, criterion)

跑完上面这段代码，你会在终端看到每个epoch的损失和测试准确率。正常情况第一个epoch结束准确率就能到95%以上，五轮epoch达到98%左右很正常。如果你看到损失下降到某个值就反弹，大概率是学习率太大、参数在最小值附近震荡，把lr从0.001调小到0.0001就好了。

3.3 零基础最容易忽略的四个细节

第一次跑通代码后，有几个细节值得专门拎出来说，因为它们决定了你后续学习的深度。

第一个是optimizer.zero_grad()。每个batch开始时必须把上一次的梯度清零。PyTorch的autograd机制默认是梯度累加的，不清零的话，梯度会是多轮batch的累加结果，参数更新方向和步长都会错乱。新手最常见的报错"梯度越来越大最终NaN"，十有八九是漏了这一行。

第二个是model.train()和model.eval()的切换。在全连接网络中，这两个模式差别不大，但如果你用了Dropout或BatchNorm，忘记切换会导致严重后果。我在实际项目中见过有人在测试时忘了切到eval模式，Dropout还在随机丢弃神经元，导致预测结果忽高忽低，排查了一天才发现问题。

第三个是data.view(x.size(0), -1)这一步。很多人不理解为什么输入图像要"展平"才能进全连接层。原因很直接：全连接层的权重是固定维度的矩阵，输入必须是一个向量。784维的向量对于这张图片来说就是一个"拉直"的像素列表，空间位置信息被牺牲了。这也是全连接网络在图像任务上不如卷积的原因之一——它看不到像素之间的邻接关系。

第四个是损失函数的选择。代码里用的是CrossEntropyLoss，这个损失函数在PyTorch里做了两件事：先对模型输出做Softmax归一化成概率分布，再计算交叉熵。所以你看代码里第三层线性层的输出没有手动过Softmax。如果你在多分类任务中自己加了Softmax再传给CrossEntropyLoss，反而会导致数值不稳定。这一点新手极其容易弄错。

4. 卷积神经网络代码实战：让模型学会"看"图片

4.1 卷积、池化与全连接如何协作

前面提到全连接网络把图片拉直后直接分类，损失了空间信息。卷积神经网络的做法就聪明得多：先用卷积层提取图像的局部特征，再用池化层压缩特征图尺寸，最后把提取到的"高级特征"接到全连接层做分类。一套组合拳下来，模型的参数占用大幅减少，但对图像的理解反而更深入了。

卷积算子的核心是一个小窗口（比如3×3），它从图像的左上角开始滑动，每滑动一步，窗口内的像素跟卷积核的权重逐位相乘再相加，得到输出特征图上的一个点。这个过程可以理解成用一个模板去图像上"找相似的模式"。一个卷积核负责找一种特征，比如竖直边缘、水平边缘、某个角度的纹理。多个卷积核堆叠在一起，就形成了多种特征探测器的集合。

池化层的典型操作是最大池化，它在一个小窗口内取最大值作为输出。作用是两方面的：一是下采样，把特征图变小，计算量骤降；二是引入一定的平移不变性——目标在图片里稍微挪了几个像素，池化结果变化不大，这对分类任务很有利。

4.2 卷积网络完整实现

下面这套代码结构非常经典，是入门CNN的首选方案：两个卷积块加三个全连接层。我在代码里加了极其详细的注释，新手完全可以对照着逐行理解。

python复制import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 数据预处理和加载，跟全连接网络那部分完全一样
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=1000, shuffle=False)

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 第一个卷积块：1个输入通道（灰度图），32个输出通道，卷积核3x3
        # 经过 Conv2d(1, 32, 3) 后，图片尺寸从 28x28 变成 26x26
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        # 加上padding=1之后，尺寸保持28x28不变，这样设计的好处是特征图尺寸变化可控
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        # 池化层在特征图上做 2x2 的最大值采样，尺寸减半
        self.pool = nn.MaxPool2d(2, 2)

        # 经过两次池化后，图片尺寸从 28x28 -> 14x14 -> 7x7
        # 卷积核数量最终是64，所以全连接层输入维度是 64 * 7 * 7 = 3136
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

        # 添加Dropout层用于防止过拟合
        # 训练时随机丢弃一半神经元，迫使网络学到更鲁棒的特征
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        # 输入x的形状是 [batch_size, 1, 28, 28]
        # 第一个卷积块：卷积 -> 激活 -> 池化
        x = self.pool(F.relu(self.conv1(x)))
        # 此时形状是 [batch_size, 32, 14, 14]
        # 第二个卷积块：卷积 -> 激活 -> 池化
        x = self.pool(F.relu(self.conv2(x)))
        # 此时形状是 [batch_size, 64, 7, 7]

        # 展平成一维向量，准备进入全连接层
        x = x.view(-1, 64 * 7 * 7)

        # 全连接部分
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = CNN()
print(model)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练和测试函数跟全连接网络基本一样，这里直接复用前面的定义
def train(model, train_loader, criterion, optimizer, epoch):
    model.train()
    total_loss = 0
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)}'
                  f' ({100. * batch_idx / len(train_loader):.0f}%)] Loss: {loss.item():.6f}')
    print(f'Epoch {epoch} 平均损失: {total_loss / len(train_loader):.6f}')

def test(model, test_loader):
    model.eval()
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            output = model(data)
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()
    accuracy = 100. * correct / len(test_loader.dataset)
    print(f'测试集准确率: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)')

if __name__ == '__main__':
    epochs = 5
    for epoch in range(1, epochs + 1):
        train(model, train_loader, criterion, optimizer, epoch)
        test(model, test_loader)

这段代码跑完后你会发现，同样的五轮epoch，CNN的测试准确率轻松超过99%，而全连接网络大概在98%左右徘徊。差距看起来不大？那是因为MNIST实在太简单了。换到稍微复杂一点的CIFAR-10数据集（彩色32×32小图），全连接网络基本会在50%-60%之间挣扎，而CNN能到75%以上。这背后就是"空间信息有没有被利用"的差异。

4.3 一个细节必须搞清楚：全连接层输入维度是怎么算的

代码里self.fc1 = nn.Linear(64 * 7 * 7, 128)这一行，很多新手不理解为什么输入维度是3136。我建议你动手算一遍：输入图片是28×28，Conv2d使用padding=1时尺寸不变，第一个MaxPool2d(2, 2)把尺寸减半变14×14，第二个池化再减半变7×7。卷积核数量从1变32再变64，所以最后的特征图是64个通道、每个通道7×7大小。展平就是64×7×7=3136。

实际开发中，我建议你写一段打印形状的代码来验证自己的计算，而不是每次都靠心算：

python复制def test_output_shape(model, input_shape=(1, 1, 28, 28)):
    x = torch.randn(input_shape)
    model.eval()
    with torch.no_grad():
        # 逐层打印中间结果形状
        x = model.conv1(x)
        print('after conv1:', x.shape)
        x = F.relu(x)
        x = model.pool(x)
        print('after pool1:', x.shape)
        x = model.conv2(x)
        print('after conv2:', x.shape)
        x = F.relu(x)
        x = model.pool(x)
        print('after pool2:', x.shape)
        x = x.view(x.size(0), -1)
        print('after flatten:', x.shape)

这个习惯极有价值。我见过太多人在改网络结构时手算维度出错，程序一跑报错"size mismatch"，然后干瞪眼。有了这个调试函数，你的网络层每一层输入输出形状一目了然。

5. 训练过程全解析：损失、优化器与参数调优

5.1 一次训练迭代的内部发生了什么

很多教程讲训练就是"run一下代码看结果"，但如果你想真正掌握神经网络，必须理解每个训练迭代里到底发生了什么。我来拆解一下训练循环的五步。

第一步，optimizer.zero_grad()，把模型所有参数的梯度清零。前面说过，PyTorch的梯度是累加设计，这一步不清，上一batch的梯度会污染本batch的更新。

第二步，output = model(data)，前向传播。数据从输入层流过每一个中间层，经过一系列线性变换和激活函数，最终到达输出层，产生预测结果。这期间，PyTorch的autograd机制悄悄构建了一张计算图，记录了每个张量是怎么算出来的。

第三步，loss = criterion(output, target)，计算损失。损失函数的作用是量化"模型预测跟真实标签差多少"。交叉熵损失是目前分类任务的标准选择，它衡量的是预测概率分布和真实标签分布之间的差异。

第四步，loss.backward()，反向传播。这是整个训练过程中最关键的一步。PyTorch从损失开始，沿着计算图反方向，用链式法则逐层计算每个参数对损失的梯度。这一步执行完后，每个参数张量的.grad属性里都存好了梯度值。

第五步，optimizer.step()，根据梯度更新参数。优化器拿着每个参数的梯度，按照一定的规则更新参数值。最简单的规则就是weight = weight - lr * gradient，这就是梯度下降。Adam优化器在这个基础上做了更复杂的自适应调整，让每个参数有自己独立的学习率。

五步循环往复，每个batch更新一次。一个epoch跑完全部训练集。

5.2 关键超参数对训练的影响

超参数是你训练前需要手动设定的参数，它们不通过学习获得，但要靠经验调整。我整理了一张表，把入门阶段最关键的四个超参数列出来：

学习率是你最常需要调的参数。如果损失曲线剧烈波动、不下降，先考虑把学习率调小一个数量级。Adam优化器的默认学习率0.001在大多数任务上都表现不错，但并不意味着它万能。越是复杂的网络，越可能需要调小学习率。我个人的经验是：先用小规模数据跑通，再逐步加大训练数据量，同时配合调整学习率。

5.3 欠拟合与过拟合的识别和应对

新手在跑完第一个模型后，最困惑的问题几乎都是：我的模型表现不好，到底是哪里出了问题？这就要引入两个核心概念：欠拟合和过拟合。

欠拟合的意思是模型太弱，没学到训练数据里的规律。表现是训练集准确率和测试集准确率都不高。应对方法是给模型"加难度"：增加层数、增加神经元数量、减少Dropout比例、增加训练轮数。

过拟合的意思是模型把训练数据背下来了，但没学会泛化规律。表现是训练集准确率很高（甚至接近100%），但测试集准确率明显偏低。应对方法有：增加训练数据、增强数据多样性、加大Dropout比例、减小模型规模、引入权重衰减等。

我见过一个很典型的初学者案例。他跑了一个很大的网络在很小的数据集上训练，训练准确率蹭蹭往上涨到了99%，测试准确率卡在60%上不去。他以为继续训练就能提升，结果越练测试准确率越低。这就是标准的过拟合。解决方式也很直接，把模型换小、加Dropout、做数据增强，三管齐下，测试准确率很快回到80%以上。

识别过拟合的一个实用技巧是：打印每个epoch的训练损失和测试损失对比。如果某个epoch之后，训练损失持续下降但测试损失开始上升，恭喜你，过拟合的拐点找到了，模型就应该在那个epoch提前停止训练。

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

6.1 新手的典型报错与解决方案

我在辅导新手的过程中，发现报错高度集中，哪些问题占了九成以上。整理成速查表，希望能让你少走弯路。

这里单独说一下size mismatch，这是新手最常遇到、也最容易排错的。比如你在全连接网络里把第一层设为nn.Linear(784, 128)，但输入图片如果不是28×28，或者你忘了做view展平，数据传入时维度就是错的。最直接的排查方法就是在forward里加print打印形状，我上面提到过那个test_output_shape函数，就是干这个用的。

6.2 训练曲线诊断指南

除了报错，训练过程中的损失曲线也是诊断问题的关键指标。我把几种典型的损失曲线形态和应对策略列出来，这个在真实项目中非常有用。

损失稳步下降，最终平稳，这是最理想的形态，说明模型在正常学习。如果准确率不够高，可以考虑增加模型容量或训练更长。

损失急剧下降后反弹，通常是学习率过大，参数越过最优点在震荡。解决办法是把学习率调小，或者使用学习率调度器（scheduler）在训练过程中动态降低学习率。

损失几乎不下降，可能是模型容量太小，或者学习率设得太小。先确认代码跑通没问题，再尝试加大学习率一个数量级看看曲线是否有变化。

损失出现NaN，这是最头疼的问题。常因梯度爆炸或数据异常。第一步把学习率调小十倍，第二步检查输入数据中是否有缺失值或异常值。如果用了自定义数据集，把数据打印出来看看是不是有NaN混进去了。

如果使用GPU训练时遇到"CUDA out of memory"，除了调小batch_size外，还有一个实用技巧：在测试循环里加with torch.no_grad():，这个上下文管理器让PyTorch不构建计算图，节约大量显存。不要小看这个细节，很多人的显存溢出问题就出在这里。

6.3 一个综合案例：模型准确率卡住不动怎么办

最后分享一个我实际遇到的案例，比较有代表性。有朋友跑卷积网络，训练到第三轮后准确率就卡在91%不动，不管怎么加大epoch数都没用。他怀疑是模型结构有问题，来问我。

我让他先确认三件事：一是数据预处理是否正确，图片标准化了吗；二是数据集有没有类别不均衡的问题；三是学习率是不是太低导致模型陷入局部最优。

他检查后发现，数据标准化没做对——Normalize的参数填的是自己随便写的值，而不是MNIST数据集的真实均值和标准差。这就是一个隐藏很深的坑，因为代码不会报错，但模型的表现就是上不去。把标准化参数改成正确的(0.1307,)和(0.3081,)，准确率很快就突破到98%以上。

从这个案例得到的教训是：模型表现不理想，先查数据，再调模型，最后才调超参数。这个排查顺序能帮你少走很多弯路。数据有问题是最终常见的"隐形杀手"，任何模型结构修改都救不回来。

7. 项目扩展与后续学习方向

代码跑通、流程走通之后，你可以在这个基础上做很多扩展，这些扩展的难度梯度设计得很好，适合稳步提升。

最直接的是把模型换到彩色图片数据集，比如CIFAR-10。这一步需要改动的点很明确：输入通道从1变成3，图片尺寸从28×28变成32×32。你会在这一步真正体会到为什么全连接网络在稍微复杂的数据上寸步难行，而CNN却能游刃有余。

往上一点，可以尝试自己实现数据增强。PyTorch的torchvision.transforms里有RandomHorizontalFlip、RandomCrop、ColorJitter这些工具，合理的增强策略往往能让模型的表现提升一到两个百分点，而且几乎不增加训练成本。

再往后，可以学习残差连接（ResNet的核心思想）、BatchNorm、学习率调度器这些进阶知识。你会发现，它们都是针对某一个具体问题提出的解决方案——残差连接解决深层网络难以训练的问题，BatchNorm解决内部协变量偏移的问题，学习率调度器让训练后期参数更新更精细。理解了"问题→方案"的对应关系，深度学习的学习曲线会变得非常陡峭。

关于后续学习路线，我建议按照"经典结构复现→论文代码阅读→自己动手设计"的节奏走。用两周时间把LeNet、AlexNet、VGG、ResNet这些经典结构的PyTorch实现都跑一遍，不用每篇论文都精读，但代码必须亲手敲。这个阶段积累的代码直觉，会在你后续写任何模型时都派上用场。

最后，把所有代码都放进一个带版本管理的项目里，用git记录每一次修改。我当时入门最大的遗憾就是代码越改越乱，最后想回到某个能运行的版本都做不到。从现在开始养成标记版本的习惯，后面会感谢自己。