VGG:把结构变成一块一块
这一课在哪
上一课 AlexNet 的核是 11 → 5 → 3 → 3 → 3, 每层都不一样,代码里就只好一层一行写。
VGG 做了一件很朴素但影响深远的事:把结构抽象成「块」。
什么是「块」
先看经典 CNN 的基本组成,就三样东西:
# | 组件 | 作用 |
|---|---|---|
1 | 带填充的卷积层 | 保持分辨率,换特征 |
2 | 非线性激活(ReLU) | 加非线性 |
3 | 汇聚层 | 降分辨率 |
VGG 块的构造是:把第 1、2 步重复 n 次,然后接一次第 3 步。
一个 VGG 块 = conv 3×3 (padding=1) → ReLU ┐ conv 3×3 (padding=1) → ReLU ├ 重复 n 次 ... ┘ maxpool 2×2 (stride=2) 降分辨率一半「块」这个抽象的价值
AlexNet 每层都不一样,所以你只能一层一层写, 想搭一个更深的网络就得重写一遍。
VGG 之后,结构变成参数化的: 「每个块里几个卷积层、输出多少通道」——两个数字就够了。
改配置就能改网络,不用改代码。
VGG 的三条设计规矩
规矩 | 具体 | 效果 |
|---|---|---|
① 卷积一律 3×3,padding=1 | 核小、补边 | 尺寸不变,只换通道 |
② 池化一律 2×2,stride=2 | 窗口不重叠 | 每个块之后尺寸减半 |
③ 每过一个块,通道翻倍 | 64 → 128 → 256 → 512 | 空间变小的同时变厚 |
这两条让 VGG 的结构可以完全用一张表描述:
段 | 块内卷积层数 | 输出通道 | 输出尺寸 |
|---|---|---|---|
1 | 2 | 64 | 224 |
2 | 2 | 128 | 112 |
3 | 3 | 256 | 56 |
4 | 3 | 512 | 28 |
5 | 3 | 512 | 14 |
后面接三层全连接(4096 → 4096 → 1000)。
为什么非得是 3×3
这是 VGG 最核心的论证。问题是:想看 7×7 那么大一片,怎么凑最省参数?
方案 | 感受野 | 参数量(C→C) | ReLU 次数 |
|---|---|---|---|
一个 7×7 卷积 | 7×7 | 49C² | 1 |
三个 3×3 卷积 | 7×7 | 27C² | 3 |
感受野一样,参数只有 55%(27/49),而且多了两次非线性。
感受野怎么算
def receptive_field(layers): """layers: [(kernel, stride), ...]""" rf, jump = 1, 1 for kernel, stride in layers: rf += (kernel - 1) * jump jump *= stride return rf print(receptive_field([(3, 1)])) # 3 print(receptive_field([(3, 1), (3, 1)])) # 5 print(receptive_field([(3, 1), (3, 1), (3, 1)])) # 7 print(receptive_field([(7, 1)])) # 7为什么每层加 2 而不是加 3
相邻两个 3×3 窗口重叠一格。
第三层的窗口往右挪一格,在原图上只挪了一格—— 所以每加一层感受野 +2,不是 +3。
这就是 层 3×3 的感受野是 的原因。
参数差多少,算一遍
import torch.nn as nn def count(module): return sum(p.numel() for p in module.parameters()) C = 256 one_7x7 = nn.Conv2d(C, C, kernel_size=7, padding=3) three_3x3 = [nn.Conv2d(C, C, kernel_size=3, padding=1) for _ in range(3)] print(count(one_7x7)) # 3,211,520 print(sum(count(l) for l in three_3x3)) # 1,770,2403,211,520 → 1,770,240,省了 45%。 通道数越大,省得越多。
但省参数不是最重要的
真正重要的是多出来的那两次 ReLU。
三个 3×3 叠起来,中间夹两次非线性—— 表达能力比一个 7×7 强得多。
VGG 论文的论证是:这等价于给决策函数加了更多非线性, 让特征更有判别力。
VGG 有多大
import torch.nn as nn def conv_block(in_channels, out_channels): return nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), nn.ReLU(inplace=True), ) CONFIG = [64, 64, "M", 128, 128, "M", 256, 256, 256, "M", 512, 512, 512, "M", 512, 512, 512, "M"] layers, ch = [], 3 for item in CONFIG: if item == "M": layers.append(nn.MaxPool2d(2, 2)) else: layers.append(conv_block(ch, item)) ch = item features = nn.Sequential(*layers) print(sum(p.numel() for p in features.parameters())) # 14,714,688部分 | 参数 | 占比 |
|---|---|---|
13 层卷积 | 14,714,688 | 10.6% |
三层全连接 | 123,642,856 | 89.4% |
合计 | 138,357,544 | 100% |
全连接还是占了大头
VGG16 有 1.38 亿参数,其中 1.24 亿在全连接层。
卷积部分只有 1471 万,是 AlexNet 的 6 倍,但和全连接比还是零头。
这个毛病一直留到第 30 章 NiN 才被解决。
四个变体
配置 | 每段层数 | 卷积层数 | 参数(带 BN) |
|---|---|---|---|
VGG11 | 1,1,2,2,2 | 8 | 132,868,840 |
VGG13 | 2,2,2,2,2 | 10 | 133,053,736 |
VGG16 | 2,2,3,3,3 | 13 | 138,365,992 |
VGG19 | 2,2,4,4,4 | 16 | 143,678,248 |
从 VGG11 到 VGG19,卷积层数翻倍,参数只涨 8%。
这就是「小核堆叠」最大的好处
多出来的层全是 3×3 卷积,而且都在通道数已经到 512 的后面几段。
加深度几乎不花参数。
AlexNet 那种「一层一个大核」的写法做不到这一点。
VGG 的两个毛病
毛病 | 具体 |
|---|---|
① 全连接层还是那么大 | 1.38 亿参数里 1.24 亿在最后三层 |
② 训练吃显存 | 13 层卷积每层都要存激活值用于反向传播 |
第二条是 VGG 被 ResNet 取代的直接原因之一。
这一课留下的三个数
数 | 值 | 含义 |
|---|---|---|
3 层 3×3 | 感受野 7 | = 一个 7×7 |
参数比 | 27 : 49 | 省 45% |
VGG11→19 | 层数翻倍,参数 +8% | 加深度不花参数 |
下一课
规律清楚了。下一课把它跑起来—— VGG 的代码比 AlexNet 短一半,因为它可以用循环生成。