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。

这就是 nn 层 3×3 的感受野是 2n+12n+1 的原因。

参数差多少,算一遍

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,240

3,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 短一半,因为它可以用循环生成。