PyTorch实战：从零搭建全连接与卷积神经网络识别MNIST

很多想入门深度学习的朋友，都会卡在一个很尴尬的节点：理论看了一堆，知道神经网络有神经元、激活函数、梯度下降，但打开电脑却不知道第一行代码怎么写。今天这篇文章就是来解决这个问题的。我会用PyTorch从零搭建两个最经典的网络——全连接网络和卷积网络，用MNIST手写数字识别作为目标，所有代码都带详细注释，你照着敲一遍，就能真正理解神经网络是怎么跑起来的。

全文不搞复杂的项目结构，不引入大型框架，只教你怎么用最朴素的代码把模型训练起来、跑出结果。适合两类人看：一类是刚学完机器学习基础，想动手写第一个深度学习模型的人；另一类是已经会用PyTorch但想重新梳理全连接与卷积底层逻辑的人。MNIST这个数据集对0基础非常友好，28×28的灰度图片，模型训练几分钟就能看到效果，拿它当入门实验再合适不过。

1. 环境准备与PyTorch核心概念扫盲

1.1 怎么快速搭一个能跑的环境

动手写代码之前，先把环境搞定。我强烈建议直接用Anaconda管理Python环境，这样后面装包、换版本都不容易把系统搞乱。创建环境的命令很简单：

bash复制conda create -n dl python=3.10
conda activate dl
pip install torch torchvision

如果你是NVIDIA显卡用户，建议去PyTorch官网选对应的CUDA版本安装，训练速度会快很多；没有独显或者懒得配的同学也不用慌，CPU版跑MNIST完全够用，后面给出的所有代码在CPU上都能顺利执行，只是训练时间会长一点。我自己第一次跑卷积网络就是在CPU上完成的，一个epoch大约一二十秒，完全可以接受。

装完后跑这么一段代码测试，能正常输出就是环境OK：

python复制import torch
import torchvision

print(torch.__version__)
print(torchvision.__version__)

这里啰嗦一句：PyTorch的版本迭代挺快，有些API在不同版本里会有细微变化。如果你照着文章敲代码报错了，先检查一下版本，多数情况是某些新版本不再支持旧写法，换成当前版本推荐的写法就行。

1.2 tensor和autograd到底是怎么回事

写PyTorch代码之前，有两个核心概念必须先搞清楚：张量（tensor）和自动求导（autograd）。

Tensor可以简单理解成“能放到GPU上运算的多维数组”。它和NumPy的ndarray很像，但多了一个核心能力——它记得自己是怎么算出来的。这句话是理解深度学习代码的关键。训练神经网络本质上是计算损失函数对每个权重参数的梯度，然后沿着梯度的反方向更新参数。如果没有自动求导，你要手动推导每一层权重和偏置的导数公式，那对于稍微深一点的网络简直是地狱难度。

PyTorch的autograd机制帮我们干了这件事：你只管把前向传播写出来，调用loss.backward()，它就会自动把每个参数的梯度算好，存到parameter.grad里面。这就是为什么训练代码里总有那么固定三板斧——梯度清零、反向传播、更新参数。后面详细展开。

我们再看全连接层参数里bias是什么。bias就是偏置，在线性变换y = Wx + b中，它相当于一条直线的截距。如果没有bias，每一层必须严格过原点，会限制网络表达能力；加上bias，神经元能学习到更灵活的输出偏移。在PyTorch里你通常不需要手动管它，nn.Linear(in_features, out_features)默认就会自动创建权重和偏置，初始化策略也是现成的。

2. 数据加载：先让模型看见图片

2.1 用torchvision加载MNIST数据集

MNIST是深度学习界的“Hello World”，它是60000张28×28的手写数字灰度图，包含0到9一共10个类别。torchvision库帮我们封装好了下载和读取逻辑，几行代码就能把数据准备好：

python复制import torch
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision import datasets

# 把像素值从[0, 255]缩放到[0.0, 1.0]区间
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
)

# DataLoader会自动帮我们把数据分成小批次，训练时还可以随机打乱顺序
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)

这里ToTensor()会把PIL图像转成PyTorch张量，像素值也会自动归一化到0到1之间。Normalize((0.1307,), (0.3081,))是MNIST的全局均值和标准差，这一步叫标准化，能让数据分布更接近标准正态分布，训练时梯度更稳定。

2.2 为什么要分批训练、为什么要打乱顺序

你可能会问：60000张图片，为什么不一次性塞给模型，非要分批？两个原因。

第一是算力限制。全连接网络的输入层如果一次读60000张图，光矩阵就有60000×784个元素，算起来内存吃不消，尤其显卡显存非常金贵，一次装不下。第二是优化效果。深度学习用的优化算法是随机梯度下降（SGD）及其变种，它本身就是一个基于随机采样估计梯度的算法。如果每次用一小批数据计算梯度，可以引入一定的随机性，帮助模型跳出局部最优点。

shuffle=True就是训练前把数据打乱。这很重要，因为原始MNIST数据按标签排列的，如果不打乱，前面几个batch全是“0”，后面全是“1”，模型会在不同批次间疯狂震荡，收敛极慢。打乱以后每个batch都能覆盖不同类别的样本，训练更平稳。

3. 全连接神经网络实战：跑通第一个模型

3.1 网络结构设计思路

全连接网络也叫多层感知机（MLP），是最基础的神经网络结构。每一层的每个神经元，都要和上一层的所有神经元相连，所以叫“全连接”。

拿MNIST来说，一张28×28的图片可以拉直成一个784维的向量。我们把784作为输入层维度，然后经过两个隐藏层，最后输出10个数字的得分。结构如下：

• 输入层：784维（28×28像素拉直）
• 隐藏层1：128个神经元，激活函数用ReLU
• 隐藏层2：64个神经元，激活函数用ReLU
• 输出层：10个神经元，对应数字0到9

为什么隐藏层要设置成128、64？这其实没有绝对标准，是一个经验值。太小的网络拟合能力不够，太大的网络容易过拟合且训练慢。对于MNIST这种简单任务，一两百个神经元的隐藏层足够用了。

3.2 用PyTorch定义全连接网络

我们写一个nn.Module的子类，PyTorch的神经网络都从这里来：

python复制import torch.nn as nn
import torch.nn.functional as F

class FullyConnectedNet(nn.Module):
    def __init__(self):
        super().__init__()
        # 线性层：输入784维，输出128维
        # bias默认为True，即每个神经元自带一个偏置
        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]
        # 用view拉直成[batch_size, 784]
        x = x.view(x.size(0), -1)
        # 隐藏层1：线性变换 + ReLU激活
        x = F.relu(self.fc1(x))
        # 隐藏层2：线性变换 + ReLU激活
        x = F.relu(self.fc2(x))
        # 输出层：输出每个类别的分数，logits
        x = self.fc3(x)
        return x

forward函数定义的是前向传播逻辑，也就是数据从输入到输出的流程。第一行x.view(x.size(0), -1)把人按通道和长宽的4维张量拉成2维矩阵，-1表示自动推断这一维的长度，也就是784。这一步是很多新手容易漏掉的，我见过不少人在全连接层输入维度上报错，99%都是没做这一步。

ReLU激活函数在神经网络里几乎是标配了，它的公式就是max(0, x)，计算极其简单，但效果很好。如果不用激活函数，不管叠加多少层线性层，本质还是线性变换，网络表达能力会大打折扣。ReLU能引入非线性，让网络拟合复杂的函数关系。

3.3 定义损失函数和优化器

网络定义好以后，还要选一个损失函数和一个优化器。分类任务最常用的损失函数是交叉熵损失（CrossEntropyLoss），优化器最简单的选择是随机梯度下降SGD：

python复制import torch.optim as optim

# 实例化网络
model = FullyConnectedNet()

# 交叉熵损失：适合多分类问题
# 它内部会先对输出做softmax，再计算交叉熵
criterion = nn.CrossEntropyLoss()

# 随机梯度下降，学习率设为0.01
# momentum是动量项，能加快收敛并减少震荡
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

这里有个细节值得注意：nn.CrossEntropyLoss()是“logits + softmax + 交叉熵”三合一的封装，所以我们在网络最后一层不用手动加softmax，直接输出原始分数就行。交叉熵损失很擅长处理分类问题，它会对预测错误的类施加更大的惩罚。

学习率lr=0.01是经验值。学习率太大，参数会在最优值附近来回震荡；学习率太小，收敛慢。一般来说0.001到0.01是常见区间，具体可以自己实验。

3.4 训练循环：模型是怎么变聪明的

模型训练的本质就是不断重复这个循环：前向传播算损失，反向传播算梯度，更新参数。代码写出来非常固定：

python复制def train_one_epoch(model, train_loader, criterion, optimizer):
    model.train()  # 切换到训练模式
    total_loss = 0

    for images, labels in train_loader:
        # images: [64, 1, 28, 28]，labels: [64]
        # 第一步：梯度清零，否则PyTorch会累积上一个batch的梯度
        optimizer.zero_grad()

        # 第二步：前向传播，得到预测输出
        outputs = model(images)

        # 第三步：计算损失
        loss = criterion(outputs, labels)

        # 第四步：反向传播，计算每个参数的梯度
        loss.backward()

        # 第五步：根据梯度更新参数
        optimizer.step()

        total_loss += loss.item()

    return total_loss / len(train_loader)

我重点解释一下optimizer.zero_grad()的作用。PyTorch默认是梯度累加的，也就是说你每调用一次loss.backward()，梯度会累加到参数的.grad属性上。如果不手动清零，下一个batch的梯度会和上一个batch叠加，参数更新方向就完全错了。这是新手最常见的问题之一，很多不收敛、loss乱跳的现象都是这个原因。

另外注意model.train()这个调用。PyTorch里有些层（比如Dropout、BatchNorm）在训练和评估时行为不同，train()和eval()就是用来切换这两种状态。对于纯全连接网络影响不大，但养成这个习惯很重要。

我们跑完一个epoch，再把测试集上跑一遍看看效果：

python复制def evaluate(model, test_loader):
    model.eval()  # 切换到评估模式
    correct = 0
    total = 0

    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()

    return correct / total

torch.no_grad()告诉PyTorch在这个上下文里不需要构建计算图，能省下一大块内存。torch.max(outputs, 1)返回每一行最大值的数值和索引，索引就是模型预测的类别。

训练几个epoch以后，全连接网络在MNIST上的准确率会达到97%以上。这个成绩用最朴素的网络结构就能达到，说明MNIST本身相对简单，也说明全连接网络已经具备相当不错的拟合能力。

4. 卷积神经网络实战：从特征出发

4.1 为什么全连接已经有了97%，还要学卷积

这个问题我当年也问过自己。既然全连接模型能跑到97%的准确率，理论上已经算不错了，为什么还要折腾卷积？

因为全连接网络有个很大的问题：结构上与图像信息不匹配。一张图片上有一定的空间结构，相邻像素关系紧密，离得远的像素通常没什么关联。全连接层把所有像素一视同仁地拉直，让每个输出神经元都要看全部784个输入，参数量会爆炸。对于更复杂的任务（比如CIFAR-10就比MNIST难得多），全连接需要极大的隐藏层才能拟合，但训练会变得又慢又容易过拟合。

卷积神经网络（CNN）就是为此设计的。它用卷积核在图像上滑动，每个卷积核只关注一个小局部区域，然后把提取到的特征层层组合。这带来两个好处：一是大幅减少参数数量，二是不需要手动设计特征，网络自己就能学会提取边缘、纹理、形状等特征，从低层到高层逐层组合出语义信息。

4.2 卷积网络结构拆解

我们搭一个经典的简单CNN，结构如下：

• 卷积层1：输入通道1，输出通道32，卷积核5×5
• ReLU激活 + 2×2最大池化
• 卷积层2：输入通道32，输出通道64，卷积核5×5
• ReLU激活 + 2×2最大池化
• 展平
• 全连接层：输入3136，输出128
• ReLU激活
• 输出层：10

有几个概念需要展开讲。

卷积核大小：5×5表示卷积核覆盖5×5像素区域。这个数字是超参数，太小的感受野可能看不到足够信息，太大的计算量大，3×3或5×5都是常见选择。

通道数：第一层的输出通道是32，你可以把每个通道理解成一种特征检测器，比如一个通道负责检测横向边缘，一个通道负责检测纵向边缘。第二层的64个通道则基于第一层的输出进一步组合出更复杂的模式。

最大池化：作用是降采样，把2×2区域里的最大值取出来。直观理解是保留这个区域内最强烈的特征，同时把特征图尺寸缩小一半。这样既能减少计算量，又能在一定程度上增加平移不变性。

padding：最大池化之后特征图从28×28变到14×14，再经过一次卷积、一次池化后变成7×7。我在卷积层里没有加padding，所以第一次卷积后特征图是24×24而不是28×28。这个尺寸变化可以通过公式推导：输出尺寸 = (输入尺寸 - 核尺寸 + 2×padding) / 步长 + 1。若后接池化核大小为2、步长2，输出再减半。

4.3 用PyTorch实现卷积网络

来看完整代码：

python复制class ConvNet(nn.Module):
    def __init__(self):
        super().__init__()
        # 卷积层1：1个输入通道（灰度图），32个输出通道，卷积核5x5
        self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
        # 卷积层2：32个输入通道，64个输出通道，卷积核5x5
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
        # 池化层：2x2窗口，步长为2，共用同一个池化操作
        self.pool = nn.MaxPool2d(2, 2)
        # 全连接层：输入3136维，输出128维
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        # 输出层：128维 -> 10类
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        # 输入: [batch_size, 1, 28, 28]
        # 第一次卷积: [batch_size, 32, 24, 24]，relu后不变
        x = F.relu(self.conv1(x))
        # 第一次池化: [batch_size, 32, 12, 12]
        x = self.pool(x)
        # 第二次卷积: [batch_size, 64, 8, 8]
        x = F.relu(self.conv2(x))
        # 第二次池化: [batch_size, 64, 4, 4]
        x = self.pool(x)
        # 展平: [batch_size, 64*4*4]
        x = x.view(-1, 64 * 4 * 4)
        # 全连接层
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

我第一次看网络尺寸计算时也绕了很久弯路，这里我展开算一遍给你看。

输入是28×28，第一层卷积核5×5，步长默认1，padding默认0，所以输出尺寸：(28 - 5) / 1 + 1 = 24，即24×24。经过最大池化后减半，变成12×12。第二层卷积再减4，变成8×8，池化后变4×4。所以最后展平前的特征图是64通道、4×4大小，展平成64×4×4 = 1024维。

等一下，我在4.2节写的展平维度是3136，代码注释写的是1024。这里要统一。用上面的公式算，无padding 5×5卷积会在28→24，池化→12，再卷积→8，池化→4，最终64×4×4=1024。但是如果第一层加padding=2，28→28，池化→14，第二层加padding=2，14→14，池化→7，最终64×7×7=3136。两种都常见。我为了展示两种写法，正文结构描述和代码可能不一致，那就统一用padding=2的版本，更好记，特征图尺寸不缩小：28→（padding=2保持28）→池化14→（padding=2保持14）→池化7。这样展平就是64×7×7=3136。

调整后代码：

python复制class ConvNet(nn.Module):
    def __init__(self):
        super().__init__()
        # 卷积层1：1通道 -> 32通道，5x5卷积，padding=2保持尺寸不变
        self.conv1 = nn.Conv2d(1, 32, kernel_size=5, padding=2)
        # 卷积层2：32通道 -> 64通道，5x5卷积，padding=2保持尺寸不变
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5, padding=2)
        # 最大池化：2x2窗口，步长2，尺寸减半
        self.pool = nn.MaxPool2d(2, 2)
        # 全连接层：输入3136维
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        # 输入: [batch_size, 1, 28, 28]
        # conv1+relu: [batch_size, 32, 28, 28]
        x = F.relu(self.conv1(x))
        # pool: [batch_size, 32, 14, 14]
        x = self.pool(x)
        # conv2+relu: [batch_size, 64, 14, 14]
        x = F.relu(self.conv2(x))
        # pool: [batch_size, 64, 7, 7]
        x = self.pool(x)
        # 展平: [batch_size, 3136]
        x = x.view(-1, 64 * 7 * 7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

padding=2的版本理解起来更省心：每次卷积后宽高不变，只有池化把尺寸减半。这样就不需要记复杂的尺寸公式了，你只需要关心池化做了几次、最终长宽是多少。训练时打印x.shape是最直观的调试方法，我后面还会强调。

这个CNN在MNIST上的表现比全连接更好，通常准确率能到99%左右。区别看起来只有2个百分点，但意义在于：CNN仅仅用了全连接网络大约三分之一的参数量，就取得了更好效果。参数的效率来自卷积的权值共享——同一卷积核在图像不同位置复用它学到的特征。

4.4 训练脚本和全连接几乎一致

CNN的训练代码和全连接网络没有本质区别，因为PyTorch把网络内部的差异都封装起来了。我们只需要把model替换成ConvNet()实例：

python复制model = ConvNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

num_epochs = 5
for epoch in range(num_epochs):
    avg_loss = train_one_epoch(model, train_loader, criterion, optimizer)
    accuracy = evaluate(model, test_loader)
    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {avg_loss:.4f}, Accuracy: {accuracy:.4f}')

这里我把优化器换成了Adam，学习率设为0.001。Adam是自适应学习率算法，对学习率没那么敏感，训练过程也更平稳，非常适合快速验证想法。很多论文里的基线实验都用Adam，它对0基础玩家很友好，不用花太多时间调学习率。SGD配合momentum则往往能在充分调参后达到更高的精度上限，属于进阶玩法。

5. 训练评估与调试技巧

5.1 怎么看loss曲线和accuracy

训练的时候不要只看最终准确率，过程中就要盯住loss变化。如果loss一直下降，说明模型在正常学习；如果loss震荡剧烈，可能是学习率太大；如果loss迟迟不降，可能是网络结构有问题或者梯度消失。

我自己的习惯是每个epoch都打印训练集平均loss和测试集准确率。loss下降而准确率不升，说明模型在训练集上已经拟合但泛化不行，就要考虑过拟合；loss和准确率一起停滞，换个学习率或者加深网络试试。

注意一点：测试集准确率和训练集loss不是同一个数据分布上算的，两者不会直接可比。如果你想看训练集上的准确率，可以在训练完一个epoch后单独在训练集上跑一次evaluate。

5.2 保存和加载模型

训练完模型，你肯定想把它保存下来，以后直接用。PyTorch推荐只保存状态字典（state_dict），也就是权重和偏置参数：

python复制# 保存模型参数
torch.save(model.state_dict(), 'mnist_cnn.pth')

# 使用模型时加载参数
model = ConvNet()
model.load_state_dict(torch.load('mnist_cnn.pth', weights_only=True))
model.eval()

weights_only=True是较新版本PyTorch的推荐做法，它只允许加载纯张量数据，避免加载恶意pickle文件带来的安全风险。如果你用的老版本不支持这个参数，忽略即可。

如果之前是在GPU上训练的模型，想拿到CPU上加载，需要加一句map_location='cpu'。这也是很常见的坑。

5.3 用tensor.shape调试：我调试的最多手段

我个人调试网络最常用的一招，就是在forward里一行一行打印x.shape。真的，PyTorch报错70%都在维度不匹配上，打印出每个中间张量的形状，一眼就能看出问题在哪。

比如你写了model(x)，报错说mat1 and mat2 shapes cannot be multiplied，意思是矩阵乘法的两个维度对不上。这时候你打印一下展平后的x.shape，和全连接层in_features一对上，问题就清楚了。

维度报错时不要瞎猜，就用打印形状定位。这个习惯帮我节省了大量排查时间。

6. 常见报错与排错思路

6.1 新手最高频的报错速查表

6.2 我的独门调试顺序

面对模型不收敛、结果异常这类问题，我通常按这个顺序排查：

先看数据。用Python打印一批训练图像，确认预处理后像素值范围是否正常，标签是否有错位，有没有把random shuffle忘了。数据出问题，后面全白搭。

再看损失。训练前几个batch的loss应该是相对较高的数值，然后逐步下降。如果第一个batch的loss就非常低，很可能是标签错了或者模型有问题。如果loss完全没变化，检查是不是把.grad忘了清空，或者梯度被torch.no_grad()包住了。

再看网络输出。在forward函数的每个关键节点打印x.shape和数值范围。如果数值出现NaN，多半是学习率太大导致梯度爆炸；如果数值全为0，可能是ReLU之后神经元全部死亡。

最后再考虑调整超参数。不要一上来就瞎调学习率。先确认数据和前向传播没问题，再动优化器参数。我见过太多人模型写错了，却在那里调了一个下午学习率。

7. 一点个人的体会

写到这里，我觉得有必要说几句实操层面的感受。

全连接和卷积这两个网络，是深度学习一切复杂结构的基石。你现在看起来它们只是两个几十行的类，但理解了它们的输入输出、维度流转、训练闭环，后面再看ResNet、Transformer、各种注意力机制，会顺畅很多。因为所有复杂模型的骨架都没有脱离“定义网络结构”、“前向传播”、“算损失反向传播”、“更新参数”这个框架，变化的主要是网络内部连接方式。

MNIST这个任务本身已经快被玩烂了，但它作为入门实验实在太合适——数据简单、训练快、容易调试。我第一次在这个数据集上跑出99%准确率时，那种“模型真的学到东西了”的感觉，会带来很强的正反馈。这种正反馈对初学者来说比任何理论都重要。

你有兴趣的话，可以拿这个框架顺手做几件事：把MNIST换成Fashion-MNIST试试，你会发现任务变难了；把CNN的卷积层改成三层，看看准确率还能不能提升；或者往CNN里加一点数据增强，比如随机翻转、随机裁剪，感受一下它对泛化能力的改善。这些扩展实验十几分钟就能跑一轮，但对于理解网络结构、过拟合、数据增强这些概念，作用非常大。