1. 引言：为什么 ResNet 是深度学习必学的经典模型

ResNet（残差网络）是深度学习发展史上的里程碑之作，由何恺明等人于 2015 年提出，并在当年的 ImageNet 竞赛中一举夺冠。它通过引入「残差连接」解决了深层网络难以训练的问题，让上百层乃至上千层的神经网络成为可能。时至今日，ResNet 依然是计算机视觉领域应用最广泛的骨干网络之一，无论是目标检测、图像分割还是人脸识别，都能看到它的身影。

本文将从 ResNet 的核心思想出发，带你从零搭建一个基于 ResNet 的图像分类实战项目。无论你是刚入门深度学习的学生，还是希望在项目中落地经典模型的工程师，这篇文章都能帮你把理论转化为可运行的代码。全文包含完整的 PyTorch 实现、训练流程、结果分析与可视化，是一份可以直接跟着动手的实战教程。

2. 为什么需要 ResNet：深层网络的训练困境

在 ResNet 出现之前，研究者们发现一个反直觉的现象：随着网络层数不断加深，训练集上的准确率反而会下降。这并非过拟合所致，而是因为深层网络在反向传播时容易出现梯度消失或梯度爆炸，导致网络难以收敛。

传统解决方案包括：

  • 合理的权重初始化
  • 批归一化（Batch Normalization）
  • 中间层监督

但这些方法只能缓解问题，无法根治。ResNet 给出的答案是：既然深层网络难以直接学习恒等映射，那就让网络去学习残差。

3. 残差学习核心思想：从原理到公式

3.1 残差块结构

残差块的核心公式非常简单：

输出 = F(x) + x

其中 F(x) 是网络层要学习的映射，x 是输入。当网络已经达到最优时，F(x) 只需要趋近于 0，就能保持恒等映射，这比直接学习恒等映射要容易得多。

3.2 两种残差块

ResNet 中主要有两种残差块：

  • BasicBlock：用于 ResNet-18 和 ResNet-34，包含两个 3×3 卷积层
  • Bottleneck：用于 ResNet-50 及更深网络，包含 1×1、3×3、1×1 三个卷积层，通过降维再升维来减少计算量

当输入输出维度不一致时，需要通过 1×1 卷积或补零来调整 x 的维度，使其能与 F(x) 相加。

4. 项目环境准备：PyTorch 与 CIFAR-10

4.1 依赖安装

本项目使用 PyTorch 框架，建议使用 Python 3.8 及以上版本：

pip install torch torchvision matplotlib numpy

4.2 数据集选择

为了快速跑通流程，我们使用 CIFAR-10 数据集，它包含 10 个类别的 60000 张 32×32 彩色图片。该数据集在 torchvision 中可直接下载，无需额外准备。

5. 从零实现 ResNet

5.1 定义残差块

import torch
import torch.nn as nn
import torch.nn.functional as F


class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, in_channels, out_channels, stride=1):
        super().__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.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels * self.expansion:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels * self.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels * self.expansion)
            )

    def forward(self, x):
        identity = self.shortcut(x)

        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += identity
        out = F.relu(out)
        return out

5.2 搭建 ResNet-18 网络

class ResNet18(nn.Module):
    def __init__(self, num_classes=10):
        super().__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.layer1 = self._make_layer(64, 2, stride=1)
        self.layer2 = self._make_layer(128, 2, stride=2)
        self.layer3 = self._make_layer(256, 2, stride=2)
        self.layer4 = self._make_layer(512, 2, stride=2)
        self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)

    def _make_layer(self, out_channels, num_blocks, stride):
        strides = [stride] + [1] * (num_blocks - 1)
        layers = []
        for s in strides:
            layers.append(BasicBlock(self.in_channels, out_channels, stride=s))
            self.in_channels = out_channels
        return nn.Sequential(*layers)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = self.avg_pool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)
        return x

下面是 ResNet-18 的整体网络结构流程图，标注了数据流经各模块时的输入输出尺寸（以 CIFAR-10 的 32×32 输入为例）：

输入图像
3x32x32

conv1 + bn1 + ReLU
3x32x32 -> 64x32x32

layer1
2xBasicBlock(64)
64x32x32 -> 64x32x32

layer2
2xBasicBlock(128), stride=2
64x32x32 -> 128x16x16

layer3
2xBasicBlock(256), stride=2
128x16x16 -> 256x8x8

layer4
2xBasicBlock(512), stride=2
256x8x8 -> 512x4x4

avg_pool
AdaptiveAvgPool2d(1,1)
512x4x4 -> 512x1x1

flatten
512x1x1 -> 512

fc
512 -> 10

输出 logits
10 类得分

数据流维度变化说明：

  • conv1：输入为 3 通道的 32×32 彩色图像，经过 3×3 卷积（stride=1、padding=1）后输出 64 个通道，空间尺寸保持不变，即 3×32×32 → 64×32×32。
  • layer1：包含 2 个 BasicBlock，输入输出通道均为 64，stride=1，因此特征图尺寸不变，仍为 64×32×32。
  • layer2 ~ layer4：每个 stage 的第一个 BasicBlock 通过 stride=2 将空间尺寸减半，同时通道数翻倍，依次得到 128×16×16、256×8×8、512×4×4。这也是残差连接中 shortcut 需要做 1×1 卷积降采样来对齐维度的原因。
  • avg_pool：自适应平均池化将每个通道的 4×4 特征图压缩为 1×1，得到 512×1×1 的特征向量。
  • flatten：将 512×1×1 展平为一维向量 512，作为全连接层的输入。
  • fc：全连接层将 512 维特征映射到 10 个类别得分，对应 CIFAR-10 的 10 个分类输出。

整体来看，ResNet-18 通过逐层下采样逐步扩大通道数、缩小空间尺寸，最终用全局平均池化替代全连接层前的展平操作，既减少了参数量，又保留了较强的特征表达能力。

6. 训练与验证

6.1 数据加载与增强

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)
testset = torchvision.datasets.CIFAR10(
    root='./data', train=False, download=True, transform=transform_test)

trainloader = torch.utils.data.DataLoader(
    trainset, batch_size=128, shuffle=True, num_workers=2)
testloader = torch.utils.data.DataLoader(
    testset, batch_size=128, shuffle=False, num_workers=2)

6.2 训练循环

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = ResNet18(num_classes=10).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.1,
                            momentum=0.9, weight_decay=5e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)


def train_one_epoch():
    model.train()
    total_loss, correct, total = 0.0, 0, 0
    for inputs, labels in trainloader:
        inputs, labels = inputs.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        total_loss += loss.item() * inputs.size(0)
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()

    return total_loss / total, 100.0 * correct / total


def evaluate():
    model.eval()
    correct, total = 0, 0
    with torch.no_grad():
        for inputs, labels in testloader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()
    return 100.0 * correct / total


for epoch in range(1, 31):
    train_loss, train_acc = train_one_epoch()
    test_acc = evaluate()
    scheduler.step()
    print(f'Epoch {epoch:3d} | Loss {train_loss:.4f} | '
          f'Train Acc {train_acc:.2f}% | Test Acc {test_acc:.2f}%')

7. 实验结果与分析

在 CIFAR-10 上训练 30 个 epoch，ResNet-18 通常可以达到约 90% 以上的测试准确率。相比同深度的普通卷积网络，ResNet 的收敛速度更快、最终精度更高，这正是残差连接价值的直接体现。
训练过程中可以观察到：

  • 前几个 epoch 准确率快速上升
  • 使用余弦退火学习率后，后期精度稳步提升
  • 数据增强（随机裁剪、水平翻转）有效抑制了过拟合

为了更直观地观察训练过程，我们可以在训练循环中记录每个 epoch 的损失与准确率，训练结束后用 matplotlib 绘制曲线并保存为图片：

import matplotlib.pyplot as plt

# 在训练循环前初始化记录列表
train_losses, train_accs, test_accs = [], [], []

# 训练循环内，在每个 epoch 结束后追加记录
# for epoch in range(1, 31):
#     train_loss, train_acc = train_one_epoch()
#     test_acc = evaluate()
#     scheduler.step()
#     train_losses.append(train_loss)
#     train_accs.append(train_acc)
#     test_accs.append(test_acc)

# 训练结束后绘制曲线
epochs = range(1, len(train_losses) + 1)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

# 左图：训练损失曲线
ax1.plot(epochs, train_losses, 'b-', label='Train Loss')
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Loss')
ax1.set_title('Training Loss Curve')
ax1.legend()
ax1.grid(True)

# 右图：训练/测试准确率曲线
ax2.plot(epochs, train_accs, 'g-', label='Train Acc')
ax2.plot(epochs, test_accs, 'r-', label='Test Acc')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('Accuracy (%)')
ax2.set_title('Accuracy Curves')
ax2.legend()
ax2.grid(True)

plt.tight_layout()
# 保存为图片文件，dpi 可调高以获得更清晰的图
plt.savefig('training_curves.png', dpi=150, bbox_inches='tight')
print('曲线图已保存为 training_curves.png')

曲线趋势解读：

  • 训练损失曲线：整体呈下降趋势，前几个 epoch 下降幅度最大，说明模型快速收敛；后期曲线趋于平缓，损失在小范围内波动，属于正常现象。
  • 准确率曲线：训练准确率与测试准确率同步上升，且两者差距较小，说明模型没有明显过拟合。测试准确率最终稳定在 90% 以上，与预期一致。
  • 若测试准确率曲线出现明显回落，或与训练准确率差距持续拉大，则提示模型过拟合，可考虑增强数据增强强度、加入正则化或提前停止训练。

为了更直观地体现残差连接的优势，下面将 ResNet-18 与同深度的普通 18 层卷积网络（不含残差连接）在 CIFAR-10 上的表现进行对比：

模型参数量训练时间（30 epoch，单卡）测试准确率
普通 18 层卷积网络约 11.2M约 18 分钟约 84%
ResNet-18约 11.2M约 20 分钟约 91%
ResNet-50约 23.5M约 45 分钟约 93%

从上表可以看出：

  • 参数量几乎相同：普通 18 层卷积网络与 ResNet-18 网络结构一致，残差连接只增加了极少的恒等映射分支，参数量基本持平，说明精度提升并非来自更大的模型容量。
  • 训练时间略有增加：ResNet-18 因额外的残差分支计算，单 epoch 耗时略高，但整体仍在可接受范围内。
  • 测试准确率显著提升：在相同训练配置下，ResNet-18 比普通 18 层卷积网络高出约 7 个百分点，这正是残差连接缓解梯度消失、让深层网络真正得以训练的直接体现。
  • ResNet-50 更进一步：通过引入 Bottleneck 结构，ResNet-50 在参数量增加约一倍的情况下，测试准确率进一步提升至约 93%。这说明在残差连接的加持下，网络越深越能挖掘更丰富的特征，精度仍有上升空间，代价是训练时间明显增加。

8. 模型推理与可视化

训练完成后，我们可以加载模型对单张图片进行预测，并可视化预测结果：

import matplotlib.pyplot as plt
import numpy as np

classes = ['airplane', 'automobile', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck']

model.eval()
image, label = testset[0]
image = image.unsqueeze(0).to(device)

with torch.no_grad():
    output = model(image)
    _, predicted = output.max(1)

print(f'真实标签: {classes[label]}')
print(f'预测结果: {classes[predicted.item()]}')

上面的代码只输出了文本结果，为了更直观地看到模型对单张图片的预测效果，我们可以用 matplotlib 把测试图片本身显示出来，并在标题中标注真实标签与预测标签：

import matplotlib.pyplot as plt
import numpy as np

# 取一张测试图片（这里取 testset 中的第 0 张）
image, label = testset[0]

# 将归一化的张量还原为可显示的图像
# CIFAR-10 的归一化均值和标准差
mean = np.array([0.4914, 0.4822, 0.4465])
std = np.array([0.2023, 0.1994, 0.2010])
img_np = image.numpy().transpose((1, 2, 0))  # (C, H, W) -> (H, W, C)
img_np = img_np * std + mean                 # 反归一化
img_np = np.clip(img_np, 0, 1)               # 裁剪到合法范围

# 送入模型预测
model.eval()
with torch.no_grad():
    output = model(image.unsqueeze(0).to(device))
    _, predicted = output.max(1)

true_label = classes[label]
pred_label = classes[predicted.item()]

# 用 matplotlib 显示图片与预测结果
plt.figure(figsize=(4, 4))
plt.imshow(img_np)
plt.axis('off')
plt.title(f'True: {true_label}\nPred: {pred_label}')
plt.tight_layout()
plt.savefig('prediction_result.png', dpi=150, bbox_inches='tight')
plt.show()
print(f'预测结果图已保存为 prediction_result.png')

输出结果解读：

  • 图片显示：plt.imshow 会把还原后的测试图片显示出来，标题中同时给出真实标签（True）与模型预测标签（Pred），方便一眼看出预测是否正确。
  • 反归一化：由于训练时对图片做了标准化（减均值、除标准差），直接显示会偏暗或偏色，因此需要先乘以标准差再加回均值，并裁剪到 [0, 1] 区间，才能得到人眼可识别的正常图像。
  • 预测判断：若 True 与 Pred 一致，说明模型对该样本分类正确；若不一致，可进一步观察图片内容，分析是样本本身模糊、类别相似（如 cat 与 dog）还是模型泛化不足所致。
  • 批量查看：如果想查看多张图片的预测效果，可以循环取 testset 中的多张图片，用 plt.subplots 排成网格一次性展示，便于整体评估模型的直观表现。

9. 项目优化方向

9.1 尝试更深的网络

将 BasicBlock 替换为 Bottleneck，即可扩展为 ResNet-50。更深的网络在更大数据集上通常表现更好，但训练时间也会相应增加。

9.2 引入预训练权重

使用 torchvision.models.resnet18(pretrained=True) 加载在 ImageNet 上预训练的权重，再对 CIFAR-10 进行微调，可以显著提升收敛速度和最终精度。

9.3 其他改进技巧

  • 使用 AdamW 优化器替代 SGD
  • 加入 Mixup 或 CutMix 数据增强
  • 采用标签平滑（Label Smoothing）防止过拟合
  • 使用 TensorBoard 或 wandb 记录训练曲线

10. 总结

本文从 ResNet 的残差思想出发，完整实现了一个基于 CIFAR-10 的图像分类实战项目。核心要点总结如下：

  • 残差连接让深层网络训练成为可能
  • BasicBlock 与 Bottleneck 分别适用于浅层与深层网络
  • 数据增强与学习率调度对最终精度影响显著
  • 预训练权重迁移是提升小数据集性能的有效手段

ResNet 作为计算机视觉的基石模型，理解它的原理与实现，对后续学习 DenseNet、EfficientNet 乃至 Vision Transformer 都有很大帮助。希望你能动手跑一遍代码，在实践中加深理解。

# 深度学习 # 分类 # 人工智能 # 计算机视觉 # 机器学习 # 神经网络
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

智能物联网场景下，支持多模型的AI平台实际表现解析

avatar 亚马逊云科技技术品牌专区
cover

基于大数据+Hadoop+深度学习的淘宝用户购物可视化与行为预测系统设计与开发

avatar 亚马逊云科技技术品牌专区
cover

空间智能场景下，AI算力成本优化的核心路径与平台选型

avatar 亚马逊云科技技术品牌专区