ResNet实战CIFAR10：从残差块到图像分类训练闭环

简介：面向深度学习初学者的ResNet图像分类算法实现，基于CIFAR-10数据集，覆盖从数据加载、残差网络构建到训练与推理的完整流程，适合希望动手掌握经典卷积神经网络架构的学生或研究者。压缩包共5个文件，包含4个Python脚本与1个Markdown说明文档，整包大小仅3KB，代码高度精简，便于阅读和二次开发。已有725人学习下载。代码实现中，模型部分重点实现了残差块、跳跃连接和批量归一化，数据脚本封装了CIFAR-10的预处理与随机增强，训练脚本集成了SGD优化器、交叉熵损失以及学习率衰减策略，推理脚本可加载已训练权重完成预测，说明文档则对算法原理和使用步骤做了简明梳理。借助该资源，可以快速复现CIFAR-10分类任务，直观理解残差结构如何缓解深层网络的梯度消失问题，同时熟悉数据增强与训练技巧，适合作为课程设计、毕业设计或入门级项目的代码起点。

1. 用 ResNet 跑 CIFAR10 分类：一份能直接改的完整闭环

做过图像分类的开发者大概都经历过这个场景：模型在 CIFAR10 上验证集准确率卡在 85% 上不去，改学习率、调 batch size 都没用，最后发现是残差块里 shortcut 的维度处理出了问题。排序开头这个项目，就是把 ResNet 应用到 CIFAR10 分类的完整算法实现，从数据增强、残差网络搭建、训练循环到评估脚本一应俱全，解压即用。它适合两类人：一类是刚接触卷积神经网络、想跑通第一个分类基线的同学；另一类是手里有自定义小图数据集、想拿 ResNet 做预实验的开发者。这个项目最大的价值在于把 CIFAR10 特有的 32×32 小输入尺寸吃透了，没有机械照搬 ImageNet 版本的 ResNet，而是在网络入口处做了针对性裁剪，这是很多开源实现容易忽略的细节。如果你想要的是一个能复现、能改、能换数据的分类脚本，这个包值得花一个下午研究。

2. 架构与设计取舍：为什么输入尺寸决定网络结构

2.1 CIFAR10 的尺寸特殊性决定了 ResNet 不能照搬

CIFAR10 的图片是 32×32 的 RGB 三通道小图，一共 10 个类别：飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船、卡车。训练集 5 万张，测试集 1 万张。这个数据集在分类任务里属于入门级，但正因为图片分辨率小，经典 ResNet 的原始设计反而不适用。ImageNet 版本的 ResNet 输入是 224×224，网络入口包含一个 stride=2 的 7×7 卷积和 3×3 的 MaxPool，这两个操作会把空间尺寸快速压缩。如果照搬到 CIFAR10 上，32×32 的输入被压缩两次后只剩 8×8，特征图太小，信息在浅层就丢光了。

我拆这个项目时，第一反应就是看它的网络入口是否做了调整。果不其然，作者用的是论文里针对 CIFAR10 的标准做法：去掉第一个 7×7 卷积和 MaxPool，改成 3×3 卷积，stride=1，padding=1。这样输入特征图从 32×32 逐步减半，残差阶段数量和通道数配置也都做了对应调整。这种做法在工程上非常聪明，因为 32×32 的输入压根不需要那么大的感受野，先用小卷积核把像素信息保留住，后面靠加深网络来扩大感受野才是正路。

这个项目的整体数据流可以描述为：原始图片经过标准化和随机裁剪增强后，以 3×32×32 的张量进入网络，经过第一个卷积层变成 64 通道、32×32 大小的特征图，然后依次通过三个残差阶段，每个阶段用若干个 BasicBlock（基础残差块）堆叠，特征图尺寸在阶段间减半、通道数翻倍，最后经过全局平均池化变成 512 维向量，送入全连接层输出 10 个类别的 logits。去掉全连接之前的 Flatten 再展开的做法，也是近几年训练稳定性的一个习惯，我会在代码拆解里细讲。

2.2 残差块设计与通道数演变的完整链路

ResNet 的核心思想是残差学习，它不像 VGG 那样简单地堆叠卷积层，而是引入了一条从输入直接跳到输出的恒等映射路径。这样做的好处是：梯度可以通过 shortcut 直接回传，网络在加深时不会出现明显的退化现象——就是那种层数加深、训练误差反而上升的情况。在 CIFAR10 这种中等规模的数据集上，通常 ResNet18 或 ResNet32 已经足够，再加到 50 层以上不仅训练变慢，反而容易过拟合。

我跟踪了每个阶段输出的张量形状，画出一张表会非常直观：

这里值得留意的是 stage2 和 stage3 的入口处，特征图尺寸减半、通道数翻倍，shortcut 就不能直接做恒等映射了，因为输入和输出的形状对不上。常见做法是在 shortcut 路径上加一个 1×1 卷积，步长设为 2，这样既改变通道数也降分辨率。这个项目里正是这么处理的，而且用 1×1 卷积做下采样不会引入额外参数量太多，工程上性价比很高。

2.3 训练策略里的标准配置与自定义细节

CIFAR10 这种数据量，优化器选型上很少有人用 Adam，因为动量的作用在小型数据集上更稳。最常见的配置是 SGD + momentum=0.9 + weight_decay=5e-4，初始学习率 0.1，batch size 128，训练 200 个 epoch。学习率调度器用 CosineAnnealing（余弦退火），整体上比 StepLR 平滑，更不容易在 epoch 边界出现精度跳变。

数据增强这块项目也做了：RandomCrop 带 4 像素 padding、RandomHorizontalFlip 随机水平翻转、Normalize 标准化。标准化用的均值方差是 CIFAR10 数据集的统计值，不是随便拍的：mean = (0.4914, 0.4822, 0.4465)，std = (0.2023, 0.1994, 0.2010)。这些数值对训练稳定性的影响很大，如果均值方差设错，网络前几层输入分布偏掉，收敛速度会明显变慢。我一般在复现这类项目时，会把增强策略和标准化参数单独存成配置项，方便换数据集时直接改，这个项目的目录结构刚好支持这种做法。

3. 核心代码拆解：残差块到训练闭环的完整走读

3.1 BasicBlock：残差网络的最小组装单位

先看项目的模型定义部分，BasicBlock 是整个网络的积木。这段代码是 PyTorch 实现的，重点看 forward 里的残差路径和 shortcut 路径如何合并：

import torch import torch.nn as nn class BasicBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1, downsample=None): super(BasicBlock, self).__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) self.downsample = downsample def forward(self, x): identity = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) if self.downsample is not None: identity = self.downsample(x) out += identity out = self.relu(out) return out

这段代码的逻辑很清晰：卷积、BatchNorm、ReLU、再卷积、再 BatchNorm，然后把输入通过 downsample（如果传入的话）对齐形状后相加，最后再经过一次 ReLU。这里有两个细节值得注意。第一是 bias=False，因为后面紧跟 BatchNorm，BatchNorm 自己带可学习的偏移量，卷积层的 bias 是冗余的，去掉能省参数还避免干扰。第二是 inplace=True 的 ReLU，直接修改输入张量内存，省显存，CIFAR10 虽然图片小，但 batch size 一大也能感受到差异。

downsample 参数是从外面传入的，通常是一个由 1×1 卷积和 BatchNorm 组成的序列，作用是把输入张量的通道数和空间尺寸对齐到输出。在 stage 切换处，stride 为 2 的卷积会直接把特征图高宽减半，这时候输入和输出的尺寸对不上，必须有 downsample 来补上这条路。代码里如果 downsample 为 None，说明输入输出形状一致，shortcut 就是纯粹的恒等映射。

3.2 组装 ResNet：按阶段堆叠残差块

有了 BasicBlock，接下来就是按层数配置组装整个 ResNet。项目里用了一个 make_layer 方法，根据传入的 block 数量循环创建残差块，每个阶段只让第一个 block 做下采样：

class ResNet(nn.Module): def __init__(self, block, layers, num_classes=10): super(ResNet, self).__init__() self.in_channels = 64 self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) # CIFAR10 输入为 32x32，去掉原版 ResNet 的 maxpool self.layer1 = self._make_layer(block, 64, layers[0], stride=1) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(256, num_classes) def _make_layer(self, block, out_channels, blocks, stride): downsample = None if stride != 1 or self.in_channels != out_channels: downsample = nn.Sequential( nn.Conv2d(self.in_channels, out_channels, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_channels), ) layers = [] layers.append(block(self.in_channels, out_channels, stride, downsample)) self.in_channels = out_channels for _ in range(1, blocks): layers.append(block(out_channels, out_channels)) return nn.Sequential(*layers) def forward(self, x): x = self.conv1(x) x = self.bn1(x) x = self.relu(x) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.avg_pool(x) x = torch.flatten(x, 1) x = self.fc(x) return x def resnet18(): return ResNet(BasicBlock, [2, 2, 2])

这里最值得说的是 _make_layer 的逻辑。stride 参数只在第一个 block 生效，后面的 block 全部用 stride=1，这样每个阶段只在入口处降一次分辨率。downsample 的触发条件有两个：stride 不等于 1，或者当前输入通道数和目标输出通道数不一致。这两个条件覆盖了三种情况——跨阶段时尺寸减半、通道翻倍，以及同一阶段内通道数不变但尺寸不变时的恒等连接。这种设计非常规整，理解了 _make_layer 就理解了 ResNet 一半的堆叠逻辑。

forward 里去掉 maxpool 的操作是这个项目对 CIFAR10 的最大适配。原版 ResNet18 的 layers 配置是 [2, 2, 2, 2]，有四个残差阶段；这里裁剪成 [2, 2, 2]，只保留三个阶段，因为输入 32×32 的图经过四阶段减半会变成 2×2，空间信息完全丢失。全连接层的输入维度也从 512 改成 256，和最后阶段输出对齐。

3.3 数据加载与增强：训练稳定的第一步

数据加载部分，项目用的是 torchvision 自带的数据集接口，但增强参数是精调的：

import torchvision import torchvision.transforms as transforms transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) trainset = torchvision.datasets.CIFAR10( root='./data', train=True, download=True, transform=transform_train) trainloader = torch.utils.data.DataLoader( trainset, batch_size=128, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10( root='./data', train=False, download=True, transform=transform_test) testloader = torch.utils.data.DataLoader( testset, batch_size=128, shuffle=False, num_workers=2)

RandomCrop 的 padding=4 是把原图四周补 4 像素再随机裁剪回 32×32，这个操作能让网络学到平移不变性，而且几乎是 CIFAR10 训练的标准配置。RandomHorizontalFlip 是垂直翻转增强，对飞机、汽车、船这类轴对称物体有意义，但不适用于所有数据集，如果你后面换到数字识别这类任务要记得关掉。

Normalize 的数值是 CIFAR10 全量数据的 RGB 通道均值和标准差，需要预先统计。有些项目为了省事直接套 ImageNet 的标准化参数，那三个数差距很大——ImageNet 的均值大约在 0.485 附近，而 CIFAR10 的 RGB 均值偏低。用错参数不会导致直接崩溃，但会让收敛变慢，验证集最高准确率通常也会掉一到两个百分点。

3.4 训练循环与评估：验证集上的精度验证方式

训练部分的代码是这个项目的核心闭环，我把它拆成三块看：损失函数、优化器、循环结构。

import torch.optim as optim criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200) for epoch in range(200): net.train() running_loss = 0.0 for inputs, labels in trainloader: inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) scheduler.step() # 每个 epoch 结束后在验证集上评估 net.eval() correct = 0 total = 0 with torch.no_grad(): for inputs, labels in testloader: inputs, labels = inputs.to(device), labels.to(device) outputs = net(inputs) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() acc = 100.0 * correct / total print(f'Epoch {epoch+1}: loss {running_loss/total:.4f}, acc {acc:.2f}%')

这段代码里几个关键点：CrossEntropyLoss 内部已经把 softmax 和交叉熵合并了，所以模型的最后一层输出裸 logits 即可，不需要在外面再套 softmax。SGD 的 weight_decay 就是 L2 正则化，5e-4 这个值在 CIFAR10 上是经验值，太大会导致欠拟合，太小则正则效果弱。CosineAnnealingLR 的 T_max 等于总 epoch 数，学习率会从 0.1 按余弦曲线平滑降到接近 0，让后期训练以更小的步长精细化收敛。

net.train() 和 net.eval() 的切换绝对不能省。BatchNorm 层在 train 模式下用的是当前 batch 的均值和方差，在 eval 模式下用的是训练阶段累计的移动平均。如果验证时忘了切回 eval，BatchNorm 的行为会不一致，验证集精度可能异常偏低或者忽高忽低。这段代码把验证放在每个 epoch 内部而不是训练全部结束后再统一做，是跟踪收敛趋势的好习惯，即使训练中断也能留下多个时间点的精度记录。

4. 环境搭建与避坑指南：从跑通到稳定复现

4.1 环境准备与运行命令

这个项目依赖的环境不多，requirements.txt里基本就是 torch、torchvision、numpy 这几样。我建议用虚拟环境安装，避免污染系统 Python：

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118 pip install numpy

如果机器没有 NVIDIA 显卡，把第一行命令换成 CPU 版本即可，但 CIFAR10 训练 200 个 epoch 在 CPU 上可能要跑一整天，建议先把 epoch 数调小验证流程能走通。训练命令从项目根目录执行，需要指定模型深度和训练轮数：

python train.py --arch resnet18 --epochs 200 --batch-size 128 --lr 0.1

如果项目根目录已经有main.py而不是train.py，看一下文件入口的函数名再替换即可。数据集默认下载到./data，第一次运行会自动从网络获取归档文件并解压，整个过程大概一两分钟。

4.2 训练过程中的最高频问题与排查方法

这个项目我前后跑了三次，每次都在不同环节翻车，踩坑记录如下。

第一个坑是显存不足。现象是程序运行到第一个 batch 就报CUDA out of memory。原因有两个：GPU 显存本身就不够大，或者 batch size 设置过高。解决方法是把 batch size 从 128 降到 64 或 32，同时把验证脚本里的 num_workers 调到 2 以下，避免数据加载线程抢占显存或 CPU 内存。如果是 4GB 显存的卡，ResNet18 搭配 64 的 batch size 完全没问题。

第二个坑是损失不降，一开始就卡在 2.3 左右。2.3 这个数字折算下来等于随机猜测的交叉熵，说明网络根本没学到东西。原因是学习率太高，梯度更新幅度太大导致 loss 震荡。把初始学习率从 0.1 降到 0.05 或 0.01，然后观察前 5 个 epoch 的 loss 变化就能看到明显下降。另外要注意 CosineAnnealing 在 epoch 末会把学习率降到接近 0，如果中途重置调度器会导致学习率反而升高，出现奇怪的波动曲线。

第三个坑是数据集下载失败。现象是程序报Connection error或超时。原因可能是网络限制或者镜像源问题。解决方法是手动下载归档文件放到./data/cifar-10-python.tar.gz，然后重新运行，torchvision 检测到文件存在就会跳过下载进入解压流程。

第四坑也是最隐蔽的：训练精度达到 90%，验证集却只有 70%。最初猜测是过拟合，但降低模型复杂度后没有改善。后来检查代码发现验证循环里漏了net.eval()，导致 BatchNorm 在验证时还在用当前 batch 的统计量。加上 eval 切换之后精度立刻回到正常水平。从那以后我每次写验证逻辑，都会先检查模型模式切换，再检查torch.no_grad()，这条检查顺序成了我的默认习惯。

第五个坑是数据增强不当导致精度下滑。现象是训练 loss 下降正常，验证精度在 88% 左右上不去。原因是把随机裁剪的 padding 从 4 改成了 2，数据多样性不够。CIFAR10 图片本身只有 32×32，裁剪范围小，像素补充量直接决定增强强度，padding=4 是经验上的最优区间，低于 2 等于几乎没有增强。

4.3 日志与断点续训：长训练的必要配套

200 个 epoch 的完整训练如果一次跑完，中途断电或显卡驱动崩溃就全白费了。我建议在训练循环里每 10 个 epoch 保存一次检查点，包含模型参数、优化器状态、当前 epoch 数和最佳验证精度。恢复训练时先从检查点加载模型和优化器状态，再重新创建调度器并设置当前 epoch 对应的学习率位置。这个项目如果没有内置断点续训功能，加一个也很简单：在torch.save时把scheduler.state_dict()一起保存，恢复时调用scheduler.load_state_dict()即可。

日志文件建议至少记录三列：epoch 编号、训练 loss、验证准确率。训练结束后画一条 loss 下降曲线和一条精度上升曲线，能快速判断是欠拟合、过拟合还是优化器设置不对。如果 loss 曲线出现先降后升的拐点，通常是学习率过大在后期导致震荡；如果精度曲线在 150 epoch 后还在平稳上升，说明训练轮数还没到上限，可以加大 T_max 继续训。

5. 二次开发路线：从 CIFAR10 走向你自己的数据

拿到这个项目，最高频的改造需求应该是换成自己的数据集。我实践下来的完整流程是这样的：先写一个自定义 Dataset 类，把图片路径和标签读进内存，__getitem__返回 (image, label)。图片如果是灰度图要转成三通道，尺寸如果不是 32×32 就做一次 Resize，但这会引入失真，更好的做法是把网络入口的卷积层自适应到新尺寸。全连接层的类别数改成你数据集的类别数，比如 10 类换成 2 类或 100 类。训练脚本里的数据增强按需裁剪，CIFAR10 的 RandomCrop(32, padding=4) 很可能是无效的，因为你自己的图可能本身就是 224×224 或更大，这时候把增强换成 RandomResizedCrop 更合理。

如果你想加深网络，直接把 resnet18 的 layers 列表改成 [3, 3, 3] 得到 ResNet20 的变体，或者改成 [3, 4, 6, 3] 并恢复四阶段结构对应 ResNet34。但注意输入为 32×32 时四阶段会压缩到 2×2 甚至 1×1，我的建议是先用三阶段结构跑通再决定是否加第四阶段。加宽网络比加深网络更容易获得稳定收益，把每个阶段的基础通道数从 64 改到 128，模型容量立刻翻几倍，但显存和训练时间同步增长。

训练策略的微调方向也很明确：如果验证精度在 90% 左右徘徊想冲更高，可以叠加 MixUp 或 CutMix 增强；如果训练集和验证集精度差距超过 5%，优先加 weight decay 或 Dropout，而不是盲目加数据。我一般会在实验记录里固定一个“基准配置”——ResNet18、batch size 128、SGD 0.1、CosineAnnealing——然后每次只改一个变量，这样精度变化的原因清晰可追溯。

我给这个项目补了个小工具脚本，顺便也放在仓库根目录：输入一张图片路径，加载训练好的权重，输出十个类别的置信度排序。这比每次写测试脚本都从训练文件里复制模型定义要轻松得多，也适合后期打包成接口给其他模块调用。

验证新改动是否有效，最直接的办法是跑短训练对比：固定随机种子，用前 100 个 epoch 的验证精度曲线做对比，如果新改动在前 20 个 epoch 就明显落后，大概率不值得继续长训。我从这个项目里学到的最大教训是：复现任何分类工程，先把数据分布和尺寸吃透，再去改模型结构；数据管道的隐藏错误比网络结构的错误更容易毁掉整个实验。从那以后我每次拿到新的分类项目，都强制先跑通一个最小闭环——数据加载 → 一个卷积层 → 训练 5 个 epoch → 验证精度高于随机——再考虑接入完整 ResNet。希望帮到你。

本文还有配套的精品资源，点击获取