ResNet模型零基础完整学习教程（原理+实战+部署）

大雨淅淅1999

501人浏览 · 2026-06-12 18:09:03

大雨淅淅1999 · 2026-06-12 18:09:03 发布

在这里插入图片描述

一、ResNet核心原理：解决深层网络痛点

1.1 传统CNN的致命缺陷

梯度消失/爆炸：网络层数不断加深时，梯度在反向传播过程中会出现指数级衰减或放大，导致网络浅层参数无法有效更新。
网络退化：实验发现，单纯堆叠网络层数后，深层网络（如56层）的效果反而弱于浅层网络（如20层）。该问题并非过拟合，而是深层网络结构难以优化。

1.2 核心创新：残差学习（Residual Learning）

ResNet 摒弃了传统网络直接学习输入到输出的完整映射 $H (x)$ ，转而学习残差，公式定义：
$F (x) = H (x) - x$
最终网络输出：
$H (x) = F (x) + x$

主分支：由卷积层构成，负责学习残差 $F (x)$ ，完成特征提取。
短路连接（Skip Connection）：无额外计算，直接将原始输入 $x$ 传递到后端。
核心优势
1. 若最优结果为恒等变换（ $H (x) = x$ ），网络只需将残差 $F (x)$ 拟合为0，训练难度大幅降低。
2. 短路连接打通梯度传播通道，梯度可直接回传至网络浅层，从根本上解决梯度消失问题。

二、ResNet网络结构详解

2.1 基础组件：残差块（Residual Block）

ResNet 包含两种标准残差块，分别适配不同深度的网络：

（1）BasicBlock（适用于 ResNet18/34）

结构：2个3×3卷积 + BN + ReLU，搭配短路连接。
特点：结构简单、参数量少、推理速度快，多用于浅层网络。

（2）Bottleneck（适用于 ResNet50/101/152）

结构：1×1卷积（降维）→ 3×3卷积（特征提取）→ 1×1卷积（升维）。
特点：利用1×1卷积压缩通道数，大幅减少深层网络的计算量，是大深度ResNet的核心模块。

2.2 完整网络架构（以 ResNet34 为例）

输入层：标准输入图像尺寸 $224 \times 224 \times 3$ 。
初始卷积模块：7×7卷积（64通道，步长2）→ BN → ReLU → 3×3最大池化（步长2），完成初步下采样与浅层特征提取。
四组残差块
- Layer1：3个BasicBlock，输出64通道，特征图尺寸 $56 \times 56$
- Layer2：4个BasicBlock，输出128通道，步长2下采样，特征图尺寸 $28 \times 28$
- Layer3：6个BasicBlock，输出256通道，步长2下采样，特征图尺寸 $14 \times 14$
- Layer4：3个BasicBlock，输出512通道，步长2下采样，特征图尺寸 $\times 7$
全局平均池化（GAP）：将 $\times 7 \times 512$ 特征图压缩为一维向量，替代传统全连接层，减少参数量。
分类输出层：全连接层 + Softmax，输出分类结果。

2.3 主流版本参数与场景对比

版本	残差块类型	网络层数	参数量	核心特点	适用场景
ResNet18	BasicBlock	18	11.7M	体量最轻、速度最快	轻量图像分类、边缘设备部署
ResNet34	BasicBlock	34	21.8M	精度与速度均衡、易训练	通用分类任务、检测网络骨干
ResNet50	Bottleneck	50	25.6M	精度优秀、工业最常用	全场景通用、项目落地首选
ResNet101	Bottleneck	101	44.5M	精度更高、计算开销大	高精度需求、算法竞赛
ResNet152	Bottleneck	152	60.2M	精度顶尖、算力要求极高	顶级竞赛、科研实验

三、环境搭建（PyTorch 版本）

3.1 依赖库安装命令

打开终端/命令行，执行以下指令安装所需依赖：

# 深度学习核心框架
pip install torch torchvision
# 数据处理、可视化、进度条工具
pip install numpy matplotlib pillow tqdm

3.2 环境验证代码

import torch
import torchvision

# 打印版本与GPU状态
print("PyTorch 版本：", torch.__version__)
print("CUDA 是否可用：", torch.cuda.is_available())

四、实战：ResNet34 图像分类（猫狗二分类 + 迁移学习）

4.1 数据集目录结构

按照如下格式整理数据集，分为训练集和验证集：

dataset/
  train/
    cat/        # 存放所有猫的训练图片
    dog/        # 存放所有狗的训练图片
  val/
    cat/        # 存放所有猫的验证图片
    dog/        # 存放所有狗的验证图片

4.2 数据预处理与数据加载

import torch
from torchvision import transforms, datasets
from torch.utils.data import DataLoader

# 自动选择设备：GPU优先，无GPU则使用CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 训练集数据增强 + 标准化
train_transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.RandomHorizontalFlip(p=0.5),  # 随机水平翻转
    transforms.RandomRotation(15),           # 随机旋转
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

# 验证集仅做标准化，不使用数据增强
val_transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

# 加载数据集
train_dataset = datasets.ImageFolder("./dataset/train", transform=train_transform)
val_dataset = datasets.ImageFolder("./dataset/val", transform=val_transform)

# 构建数据加载器
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=0)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=0)

4.3 模型加载与迁移学习配置

基于 ImageNet 预训练权重做迁移学习，小数据集推荐冻结特征层：

from torchvision import models
import torch.nn as nn

# 加载预训练 ResNet34
model = models.resnet34(pretrained=True)

# 冻结全部特征提取层（小数据集防过拟合）
for param in model.parameters():
    param.requires_grad = False

# 替换最后一层全连接，适配二分类任务
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 2)

# 模型迁移至对应设备
model = model.to(device)

4.4 训练参数配置与训练循环

import torch.optim as optim
from tqdm import tqdm

# 损失函数、优化器、学习率调度器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5)

# 训练超参
epochs = 20
best_acc = 0.0

# 开始训练
for epoch in range(epochs):
    # 切换为训练模式
    model.train()
    train_loss = 0.0
    for images, labels in tqdm(train_loader, desc=f"Epoch {epoch+1}/{epochs}"):
        images, labels = images.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        train_loss += loss.item() * images.size(0)

    # 切换为验证模式，关闭梯度计算
    model.eval()
    val_acc = 0.0
    with torch.no_grad():
        for images, labels in val_loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, preds = torch.max(outputs, 1)
            val_acc += torch.sum(preds == labels.data)

    # 计算平均损失与精度
    train_loss /= len(train_dataset)
    val_acc /= len(val_dataset)

    print(f"训练损失: {train_loss:.4f}, 验证精度: {val_acc:.4f}")
    scheduler.step()

    # 保存最优模型权重
    if val_acc > best_acc:
        best_acc = val_acc
        torch.save(model.state_dict(), "resnet34_best.pth")
        print("已保存当前最优模型！")

4.5 单张图片推理预测

from PIL import Image

def predict_image(img_path):
    # 读取图片并预处理
    img = Image.open(img_path).convert("RGB")
    img = val_transform(img).unsqueeze(0).to(device)
    model.eval()
    # 推理预测
    with torch.no_grad():
        output = model(img)
        _, pred = torch.max(output, 1)
    # 映射分类结果
    return "猫" if pred.item() == 0 else "狗"

# 调用测试
print(predict_image("test.jpg"))