torchvision模型库深度解析：预训练模型全攻略
项目地址: https://gitcode.com/gh_mirrors/vi/vision 本文全面解析了torchvision模型库中的预训练模型，涵盖了分类模型（ResNet、VGG、EfficientNet）、检测与分割模型（Faster R-CNN、Mask R-CNN、RetinaNet）、视频与光流模型（R3D、RAFT、MViT）的架构设计、核心原理及实现细节。同时详细介绍了模型权重管理与迁移学习的最佳实践，包括权重枚举系统、迁移学习策略、特征提取技术和实际应用示例，为开发者提供了完整的预训练模型使用指南。
分类模型架构详解（ResNet、VGG、EfficientNet等）
在计算机视觉领域，图像分类是最基础且重要的任务之一。torchvision模型库提供了丰富的预训练分类模型，这些模型在ImageNet数据集上表现出色，为各种视觉任务提供了强大的特征提取能力。本文将深入解析ResNet、VGG和EfficientNet三大经典分类模型的架构设计、核心原理及其在torchvision中的实现。
ResNet：深度残差学习的突破
ResNet（Residual Network）通过引入残差连接解决了深度神经网络训练中的梯度消失问题，使得构建极深的网络成为可能。
核心架构设计
ResNet的核心创新在于残差块（Residual Block）设计，其数学表达为：
$$ y = F(x, {W_i}) + x $$
其中 $F(x, {W_i})$ 是残差映射，$x$ 是恒等映射。
torchvision中的实现
torchvision提供了多种ResNet变体：
| 模型名称 | 层数 | 参数量 | Top-1准确率 | Top-5准确率 |
|---|---|---|---|---|
| ResNet-18 | 18 | 11.7M | 69.8% | 89.1% |
| ResNet-34 | 34 | 21.8M | 73.3% | 91.4% |
| ResNet-50 | 50 | 25.6M | 76.1% | 92.9% |
| ResNet-101 | 101 | 44.5M | 77.4% | 93.6% |
| ResNet-152 | 152 | 60.2M | 78.3% | 94.1% |
import torchvision.models as models
# 加载预训练ResNet-50模型
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
# 查看模型结构
print(model)
残差块实现细节
ResNet使用两种基本的残差块：BasicBlock和Bottleneck。
BasicBlock（用于较浅的网络）：
class BasicBlock(nn.Module):
expansion: int = 1
def __init__(self, inplanes, planes, stride=1, downsample=None):
super().__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = nn.BatchNorm2d(planes)
self.downsample = downsample
self.stride = stride
Bottleneck（用于更深的网络）：
class Bottleneck(nn.Module):
expansion: int = 4
def __init__(self, inplanes, planes, stride=1, downsample=None):
super().__init__()
width = int(planes * (base_width / 64.0)) * groups
self.conv1 = conv1x1(inplanes, width)
self.bn1 = nn.BatchNorm2d(width)
self.conv2 = conv3x3(width, width, stride, groups, dilation)
self.bn2 = nn.BatchNorm2d(width)
self.conv3 = conv1x1(width, planes * self.expansion)
self.bn3 = nn.BatchNorm2d(planes * self.expansion)
VGG：深度卷积网络的经典之作
VGG网络以其简洁统一的架构设计而闻名，全部使用3×3小卷积核和2×2最大池化层。
架构特点
VGG的核心设计理念是使用更小的卷积核（3×3）来替代大的卷积核，通过堆叠多个小卷积核来获得与大卷积核相同的感受野，同时减少参数量。
torchvision中的VGG变体
torchvision支持多种VGG配置：
| 模型变体 | 配置 | 带BN | 参数量 | Top-1准确率 |
|---|---|---|---|---|
| VGG-11 | A | 否 | 132.9M | 69.0% |
| VGG-11 | A | 是 | 132.9M | 70.4% |
| VGG-13 | B | 否 | 133.0M | 69.9% |
| VGG-13 | B | 是 | 133.1M | 71.6% |
| VGG-16 | D | 否 | 138.4M | 71.6% |
| VGG-16 | D | 是 | 138.4M | 73.4% |
| VGG-19 | E | 否 | 143.7M | 72.4% |
| VGG-19 | E | 是 | 143.7M | 74.2% |
架构配置说明
VGG的不同配置通过字母表示：
- A: [64, M, 128, M, 256, 256, M, 512, 512, M, 512, 512, M]
- B: [64, 64, M, 128, 128, M, 256, 256, M, 512, 512, M, 512, 512, M]
- D: [64, 64, M, 128, 128, M, 256, 256, 256, M, 512, 512, 512, M, 512, 512, 512, M]
- E: [64, 64, M, 128, 128, M, 256, 256, 256, 256, M, 512, 512, 512, 512, M, 512, 512, 512, 512, M]
# VGG网络构建函数
def make_layers(cfg, batch_norm=False):
layers = []
in_channels = 3
for v in cfg:
if v == "M": # 最大池化层
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else: # 卷积层
conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
else:
layers += [conv2d, nn.ReLU(inplace=True)]
in_channels = v
return nn.Sequential(*layers)
EfficientNet：模型缩放的艺术
EfficientNet通过复合缩放方法（Compound Scaling）同时优化网络的深度、宽度和分辨率，实现了在准确率和效率之间的最佳平衡。
复合缩放原理
EfficientNet的缩放公式为：
$$ \text{depth}: d = \alpha^\phi $$ $$ \text{width}: w = \beta^\phi $$
$$ \text{resolution}: r = \gamma^\phi $$ $$ \text{约束}: \alpha \cdot \beta^2 \cdot \gamma^2 \approx 2 $$ $$ \alpha \geq 1, \beta \geq 1, \gamma \geq 1 $$
其中 $\phi$ 是用户指定的复合系数，控制模型大小。
MBConv块：移动端倒残差结构
EfficientNet的核心构建块是MBConv（Mobile Inverted Bottleneck Conv）块，包含以下组件：
torchvision中的EfficientNet系列
torchvision支持EfficientNet V1和V2系列：
EfficientNet V1系列： | 模型 | 参数量 | Top-1准确率 | 计算量（FLOPs） | |------|--------|-------------|----------------| | B0 | 5.3M | 77.7% | 0.39B | | B1 | 7.8M | 79.8% | 0.70B | | B2 | 9.2M | 80.6% | 1.0B | | B3 | 12.2M | 82.0% | 1.8B | | B4 | 19.3M | 83.4% | 4.5B | | B5 | 30.4M | 84.3% | 9.9B | | B6 | 43.0M | 84.8% | 19.0B | | B7 | 66.3M | 85.3% | 37.0B |
EfficientNet V2系列： | 模型 | 参数量 | Top-1准确率 | 训练速度提升 | |------|--------|-------------|-------------| | V2-S | 21.5M | 83.9% | 4.1× | | V2-M | 54.1M | 85.1% | 3.3× | | V2-L | 119.5M | 85.7% | 2.6× |
MBConv块实现
class MBConv(nn.Module):
def __init__(self, cnf, stochastic_depth_prob, norm_layer):
super().__init__()
self.use_res_connect = cnf.stride == 1 and cnf.input_channels == cnf.out_channels
layers = []
activation_layer = nn.SiLU
# 扩展阶段
expanded_channels = cnf.adjust_channels(cnf.input_channels, cnf.expand_ratio)
if expanded_channels != cnf.input_channels:
layers.append(Conv2dNormActivation(
cnf.input_channels, expanded_channels,
kernel_size=1, norm_layer=norm_layer,
activation_layer=activation_layer
))
# 深度可分离卷积
layers.append(Conv2dNormActivation(
expanded_channels, expanded_channels,
kernel_size=cnf.kernel, stride=cnf.stride,
groups=expanded_channels, norm_layer=norm_layer,
activation_layer=activation_layer
))
# SE注意力机制
squeeze_channels = max(1, cnf.input_channels // 4)
layers.append(SqueezeExcitation(
expanded_channels, squeeze_channels,
activation=partial(nn.SiLU, inplace=True)
))
# 投影阶段
layers.append(Conv2dNormActivation(
expanded_channels, cnf.out_channels,
kernel_size=1, norm_layer=norm_layer,
activation_layer=None
))
self.block = nn.Sequential(*layers)
self.stochastic_depth = StochasticDepth(stochastic_depth_prob, "row")
模型选择指南
在选择合适的分类模型时，需要考虑多个因素：
性能与效率权衡
具体场景推荐
- 高精度需求：ResNet-152、EfficientNet-B7、VGG-19
- 平衡型应用：ResNet-50、EfficientNet-B3、VGG-16
- 移动端/边缘计算：EfficientNet-B0、EfficientNet-V2-S
- 实时应用：ResNet-18、EfficientNet-B0
- 特征提取：VGG-16（features层）
实际使用示例
import torch
import torchvision.models as models
from torchvision import transforms
# 模型加载函数
def load_classification_model(model_name, pretrained=True):
model_func = getattr(models, model_name)
weights = getattr(models, f"{model_name}_Weights").DEFAULT if pretrained else None
return model_func(weights=weights)
# 图像预处理
def get_transform(model_name):
weights = getattr(models, f"{model_name}_Weights").DEFAULT
return weights.transforms()
# 使用示例
model = load_classification_model('resnet50')
transform = get_transform('resnet50')
通过深入理解这些经典分类模型的架构设计和工作原理，开发者可以更好地选择适合自己应用场景的模型，并在必要时进行微调或架构修改。torchvision提供的这些预训练模型不仅具有优秀的性能表现，还经过了充分的优化和测试，是计算机视觉项目开发的宝贵资源。
检测与分割模型（Faster R-CNN、Mask R-CNN、RetinaNet）
TorchVision提供了业界领先的目标检测和实例分割模型，这些模型在COCO数据集上预训练，可以直接用于推理或作为迁移学习的基础。本节将深入解析Faster R-CNN、Mask R-CNN和RetinaNet三大核心检测模型的技术原理、架构特点和使用方法。
模型架构深度解析
Faster R-CNN：两阶段检测的经典之作
Faster R-CNN是两阶段目标检测算法的里程碑，其核心创新在于Region Proposal Network（RPN）的引入，实现了端到端的训练。
核心组件详解：
- RPN（Region Proposal Network）：在特征图上滑动窗口，为每个位置生成9个不同尺度和长宽比的锚点，预测目标存在概率和边界框偏移量
- RoI Pooling：将不同大小的候选区域统一为固定大小的特征图，便于后续分类和回归
- 多任务损失函数：同时优化分类损失和边界框回归损失
代码示例：加载预训练Faster R-CNN模型
import torch
import torchvision
from torchvision.models.detection import FasterRCNN_ResNet50_FPN_Weights
# 加载预训练模型（COCO数据集）
weights = FasterRCNN_ResNet50_FPN_Weights.DEFAULT
model = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=weights)
model.eval()
# 预处理转换
preprocess = weights.transforms()
# 示例推理
image = torch.rand(3, 800, 1200) # 模拟输入图像
batch = [preprocess(image)]
predictions = model(batch)
# 解析预测结果
boxes = predictions[0]['boxes']
scores = predictions[0]['scores']
labels = predictions[0]['labels']
Mask R-CNN：实例分割的强大框架
Mask R-CNN在Faster R-CNN的基础上增加了掩码预测分支，实现了目标检测和实例分割的统一框架。
flowchart LR
A[输入图像] --> B[Backbone特征提取]
B --> C[RPN区域提议]
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
