第10课：VGG与ResNet

📖 本课概述

VGG证明了"更深的网络更好"，ResNet解决了深层网络的训练难题。本课深入分析这两个划时代的架构设计。

📐 一、VGGNet (2014)

1.1 设计哲学

VGG的核心思想：使用更小的3×3卷积核，但堆叠更多层。

1.2 VGG配置

🔗 二、ResNet (2015)

2.1 残差学习

2.2 为什么残差有效？

①梯度可以直接通过shortcut流向浅层②恒等映射是简单解③不会因为加深而变差

2.3 残差块实现

import torch
import torch.nn as nn

# VGG Block
def vgg_block(in_c, out_c, num_convs):
    layers = []
    for _ in range(num_convs):
        layers.extend([nn.Conv2d(in_c, out_c, 3, padding=1), nn.ReLU()])
        in_c = out_c
    layers.append(nn.MaxPool2d(2))
    return nn.Sequential(*layers)

# ResNet残差块
class BasicBlock(nn.Module):
    def __init__(self, in_ch, out_ch, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, stride, 1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_ch)
        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, 1, 1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_ch)
        self.shortcut = nn.Sequential()
        if stride != 1 or in_ch != out_ch:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 1, stride, bias=False),
                nn.BatchNorm2d(out_ch)
            )
    def forward(self, x):
        out = torch.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)  # 残差连接
        return torch.relu(out)

# 对比VGG和ResNet
print("=== VGG Block ===")
vgg = vgg_block(64, 128, 2)
x = torch.randn(1, 64, 32, 32)
print(f"VGG block: {list(x.shape)} → {list(vgg(x).shape)}")
print(f"VGG block参数量: {sum(p.numel() for p in vgg.parameters()):,}")

print("\n=== ResNet BasicBlock ===")
res = BasicBlock(64, 128, stride=2)
x = torch.randn(1, 64, 32, 32)
print(f"ResNet block: {list(x.shape)} → {list(res(x).shape)}")
print(f"ResNet block参数量: {sum(p.numel() for p in res.parameters()):,}")

# 深层网络梯度流对比
print("\n=== 梯度流对比(20层) ===")
# 无残差
torch.manual_seed(42)
layers_plain = []
for i in range(20):
    layers_plain.append(nn.Linear(64, 64))
    layers_plain.append(nn.ReLU())
model_plain = nn.Sequential(*layers_plain)

x = torch.randn(2, 64)
y = model_plain(x).sum()
y.backward()
grads_plain = [l.weight.grad.norm().item() for l in model_plain if isinstance(l, nn.Linear) and l.weight.grad is not None]
print(f"无残差: 首层梯度={grads_plain[0]:.8f}, 末层梯度={grads_plain[-1]:.8f}, 比值={grads_plain[0]/(grads_plain[-1]+1e-10):.2f}")

# 有残差(1D模拟)
torch.manual_seed(42)
class ResLayer1D(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(64, 64)
        self.fc2 = nn.Linear(64, 64)
    def forward(self, x):
        return torch.relu(self.fc2(torch.relu(self.fc1(x))) + x)

res_layers = nn.ModuleList([ResLayer1D() for _ in range(20)])
x = torch.randn(2, 64)
out = x
for layer in res_layers:
    out = layer(out)
out.sum().backward()
res_grads = [l.fc1.weight.grad.norm().item() for l in res_layers if l.fc1.weight.grad is not None]
print(f"有残差: 首层梯度={res_grads[0]:.8f}, 末层梯度={res_grads[-1]:.8f}, 比值={res_grads[0]/(res_grads[-1]+1e-10):.2f}")

🔬 三、ResNet的深远影响

3.1 残差连接的变体

3.2 为什么深层ResNet有效

• 恒等映射假设：如果最优解是恒等映射，残差只需学F(x)=0，比学H(x)=x容易
• 信息高速公路：梯度可以直接通过shortcut流动，不经过非线性变换
• 隐式集成：N个残差块相当于2^N条路径的隐式集成

3.3 现代架构对比

📖 四、延伸阅读

📝 练习

💡 五、ResNet变体与演进

5.1 ResNet家族

5.2 为什么CNN仍然重要

虽然Transformer(ViT)在CV中越来越流行，但CNN仍有优势：

• 平移不变性天然适合图像
• 参数效率更高（小数据集上更好）
• 推理速度更快
• ConvNeXt(2022)证明精心设计的CNN可以媲美ViT

🔬 深度拓展：从理论到实践

核心概念网络

理解本课内容需要将其置于更大的知识网络中。每个核心概念都不是孤立的，它们相互关联、相互支撑：

• 数学基础：线性代数、微积分、概率论是理解所有深度学习算法的根基
• 计算基础：自动微分、GPU并行计算让理论变为现实
• 工程基础：数据处理、模型设计、训练技巧的有机结合
• 领域知识：CV、NLP、语音等领域的先验知识指导模型设计

关键洞察与直觉

建立正确的直觉比记住公式更重要：

与其他课程的关联

本课作为CNN阶段的核心内容，与前后课程紧密关联：

面试常见问题

进阶学习路径

掌握本课内容后，可以通过以下方式继续深入：

• 阅读本课相关的一手论文，理解原始动机和推导
• 复现论文的实验结果，验证自己的理解
• 尝试改进方法，思考为什么现有方法有局限
• 在真实项目或Kaggle竞赛中应用
• 关注该方向的最新进展（arXiv、顶级会议）

📐 补充：知识体系梳理

核心公式速查

将本课涉及的关键公式整理如下，方便回顾和记忆。理解每个公式背后的直觉比死记硬背更重要——试着用自然语言解释每个公式在做什么。

易混淆概念辨析

代码模板

以下是本课核心概念的标准PyTorch实现模板，可以直接用于实际项目：

• 定义模型时，继承nn.Module，实现__init__和forward
• 训练循环：zero_grad → forward → loss → backward → step
• 验证时使用model.eval()和torch.no_grad()
• 保存模型用torch.save(model.state_dict())
• 加载模型用model.load_state_dict(torch.load())