今天的 ResNet

这一课在哪

上一课把 ResNet 一块一块搭完了。这一课回答一个问题: 为什么 2015 年的结构,今天还在用?

答案不是「它最强」,而是「它是个稳定的模板」—— 改几个数字就能变大变小,而且残差这个想法被搬到了后面的所有网络里。

五个常见变体

名字

每段块数

块类型

最大通道

参数量

ResNet-18

[2,2,2,2]

Basic

512

11,689,512

ResNet-34

[3,4,6,3]

Basic

512

21,797,672

ResNet-50

[3,4,6,3]

Bottleneck

2048

25,557,032

ResNet-101

[3,4,23,3]

Bottleneck

2048

44,549,160

ResNet-152

[3,8,36,3]

Bottleneck

2048

60,192,808

注意 ResNet-34 和 ResNet-50

两个的块数完全一样:[3,4,6,3]。

但 ResNet-50 的参数量只比 ResNet-34 多 17%, 层数却从 34 涨到 50。

原因是块类型换了:Bottleneck 用三层但通道很窄的卷积。

BasicBlock 与 Bottleneck

BasicBlock:两个 3×3

前面几课一直用的就是这个:

class BasicBlock(nn.Module): """两个 3×3 卷积。输入输出通道相同(或由 stride 改形状)。""" def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, 1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, 1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) if stride != 1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, 1, stride, bias=False), nn.BatchNorm2d(out_channels)) else: self.shortcut = nn.Sequential() def forward(self, x): out = torch.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) return torch.relu(out + self.shortcut(x))

参数:64→64 时是 73,984。

Bottleneck:1×1 → 3×3 → 1×1

第 30 章埋的那个伏笔,在这里收了—— 用 1×1 卷积把通道压窄,做一次 3×3,再用 1×1 升回去。

class Bottleneck(nn.Module): """1×1 降维 → 3×3 → 1×1 升维,输出通道是输入的 expansion 倍。""" def __init__(self, in_channels, out_channels, stride=1, expansion=4): super().__init__() width = out_channels // expansion self.conv1 = nn.Conv2d(in_channels, width, 1, bias=False) self.bn1 = nn.BatchNorm2d(width) self.conv2 = nn.Conv2d(width, width, 3, stride, 1, bias=False) self.bn2 = nn.BatchNorm2d(width) self.conv3 = nn.Conv2d(width, out_channels, 1, bias=False) self.bn3 = nn.BatchNorm2d(out_channels) if stride != 1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, 1, stride, bias=False), nn.BatchNorm2d(out_channels)) else: self.shortcut = nn.Sequential() def forward(self, x): out = torch.relu(self.bn1(self.conv1(x))) out = torch.relu(self.bn2(self.conv2(out))) out = self.bn3(self.conv3(out)) return torch.relu(out + self.shortcut(x))

省了多少参数

算一下把 64 通道处理一遍需要多少参数:

print(count(BasicBlock(64, 64))) # 73,984 print(count(Bottleneck(64, 64))) # 75,008

块

中间通道

输出通道

参数

BasicBlock(64,64)

64

64

73,984

Bottleneck(64,64)

16

256

75,008

同样的参数,输出宽了 4 倍

两个块参数几乎一样(73,984 vs 75,008)。

但 BasicBlock 输出 64 通道,Bottleneck 输出 256 通道。

这就是为什么 ResNet-50 能做 2048 通道, 而 ResNet-34 只能做到 512——Bottleneck 让「宽」变得便宜。

为什么能省

关键在 3×3 那层在窄通道上做:

做法

3×3 那层的参数量

直接 64→64 的 3×3

64×64×9 = 36,864

压到 16 再做 3×3

16×16×9 = 2,304

3×3 卷积的参数量是通道数的平方,把它放在窄通道上, 省下来的钱正好拿去买更宽的通道。

这就是第 30 章那个「瓶颈」

1×1 降维 → 3×3 处理 → 1×1 升维, 中间窄两头宽,像个瓶颈。

第 30 章算过:590,080 → 70,016,省 88%。

ResNet-50 把这一招用在每个块上,一共用了 16 次。

它怎么进了 Transformer

残差块的外壳是 x + subnet(x)。 2017 年的 Transformer 原封不动地用了这个外壳:

# Transformer 的一个编码层(第 38 章详讲) class EncoderLayer(nn.Module): def forward(self, x): x = x + self.attention(self.norm1(x)) # 残差 ① x = x + self.feed_forward(self.norm2(x)) # 残差 ② return x

ResNet

Transformer

子网络是什么

两层 3×3 卷积

注意力 / 前馈网络

外壳

x + F(x)

x + F(x)

归一化

BatchNorm(在块内)

LayerNorm(在块前)

激活

ReLU

GELU / ReLU

外壳一模一样。变的只有子网络和归一化方式。

为什么 Transformer 必须用残差

BERT-base 有 12 层,GPT-3 有 96 层。

没有残差,这些网络在第 10 层左右就训不动了—— 上一课手算过,20 层无残差梯度是 1e-19。

残差不是 ResNet 的专利,是深层网络的通用零件。

今天还在用的三个原因

#

原因

说明

1

结构规整

「每段 N 个块」一句话说清,写代码不用动脑

2

深度可调

18/34/50/101/152,改一个列表就行

3

预训练权重到处都是

下一章迁移学习就靠这个

还有一条不一定写在论文里,但很实际: 它够快。没有 VGG 那种 1.24 亿参数的全连接层, 推理时显存和速度都友好。

这一章到此

回头看这七课走的路:

课

拿到了什么

31.1

知道「更深更差」这个现象,排除了三个错误解释

31.2

从式子上看出「学 0 比学 x 容易」

31.3

手算出 20 层时梯度差 18 个数量级

31.4

三行代码的残差块,可以背

31.5

一块一块搭到 256 通道

31.6

训出真实成绩

31.7

知道它为什么还在用

下一课

习题:手算残差块的梯度、判断形状、画网络、拆掉捷径做对照。