出乎意料的是，这种退化不是由过度拟合引起的，并且向适当深度的模型添加更多层会导致更高的训练误差，正如 [先前报道] 并通过我们的实验彻底验证的那样。

图 14-1中的图表说明了这种现象，左侧是训练误差，右侧是测试误差。

图 14-1。不同深度网络的训练（由 Kaiming He 等人提供）

正如作者在这里提到的，他们并不是第一个注意到这个奇怪事实的人。但他们是第一个做出非常重要飞跃的人：

还有另一种（大致相同的）方式来考虑这些 ResNet 块。论文是这样描述的：

我们不是希望每几个堆叠层直接拟合所需的底层映射，而是明确让这些层拟合残差映射。形式上，将所需的 基础映射表示为H ( x )，我们让堆叠的非线性层拟合F ( x ) := H( x ) − x的另一个映射。原始映射重铸为F ( x )+ x. 我们假设优化残差映射比优化原始的、未引用的映射更容易。在极端情况下，如果恒等映射是最优的，则将残差推到零比通过一堆非线性层拟合恒等映射更容易。

同样，这是相当难以理解的散文——所以让我们尝试用通俗易懂的英语重述一下！如果给定层的结果是x 并且我们使用的是返回 的 ResNet 块 y = x + block(x)，则我们不要求该块进行预测y；y我们要求它预测和之间的差异x。所以这些块的工作不是预测某些特征，而是最小化x和所需之间的误差y。因此，ResNet 擅长了解什么都不做和通过两个卷积层（具有可训练权重）的块之间的细微差别。这些模型就是这样得名的：它们预测残差（提醒：“残差”是预测减去目标）。

真实身份路径

原始论文实际上并没有gamma在每个块的最后一个 batchnorm 层中使用零作为初始值的技巧；几年后。因此，原始版本的 ResNet 并没有完全开始使用通过 ResNet 块的真实身份路径进行训练，但是尽管如此，具有“导航”跳过连接的能力确实使其训练得更好。添加 batchnorm gammainit 技巧使模型以更高的学习率进行训练。

这是一个简单的 ResNet 块的定义（fastaigamma将最后一个 batchnorm 层的权重初始化为零，因为norm_type=NormType.BatchZero）：

class ResBlock(Module):
    def __init__(self, ni, nf):
        self.convs = nn.Sequential(
            ConvLayer(ni,nf),
            ConvLayer(nf,nf, norm_type=NormType.BatchZero))

    def forward(self, x): return x + self.convs(x)

然而，这有两个问题：它不能处理 1 以外的步幅，并且它需要ni==nf. 停下来仔细想想这是为什么。

问题在于，如果其中一个卷积的步幅为 2，则输出激活的网格大小将是输入每个轴上大小的一半。所以我们不能把它加回xinforward因为x输出激活有不同的维度。如果出现相同的基本问题ni!=nf：输入和输出连接的形状不允许我们将它们加在一起。

要解决此问题，我们需要一种方法来更改形状x以匹配的结果self.convs。可以使用步长为 2 的平均池化层将网格大小减半：也就是说，该层从输入中获取 2×2 块并用它们的平均值替换它们。

可以使用卷积来更改通道数。然而，我们希望这种跳跃连接尽可能接近恒等映射，这意味着要使这种卷积尽可能简单。最简单的卷积是内核大小为 1 的卷积。这意味着内核的大小为ni× nf× 1× 1，因此它只是在每个输入像素的通道上进行点积——它根本不会跨像素进行组合。这种 1x1 卷积在现代 CNN 中被广泛使用，所以花点时间考虑一下它是如何工作的。

1X1的卷积

核大小为 1 的卷积。

这是一个 ResBlock 使用这些技巧来处理跳过连接中的形状变化：

def _conv_block(ni,nf,stride):
    return nn.Sequential(
        ConvLayer(ni, nf, stride=stride),
        ConvLayer(nf, nf, act_cls=None, norm_type=NormType.BatchZero))

class ResBlock(Module):
    def __init__(self, ni, nf, stride=1):
        self.convs = _conv_block(ni,nf,stride)
        self.idconv = noop if ni==nf else ConvLayer(ni, nf, 1, act_cls=None)
        self.pool = noop if stride==1 else nn.AvgPool2d(2, ceil_mode=True)

    def forward(self, x):
        return F.relu(self.convs(x) + self.idconv(self.pool(x)))

请注意，我们在noop这里使用的是函数，它只是简单地返回其输入不变（noop是一个计算机科学术语，代表“无操作”）。在这种情况下，idconv如果 什么都不做，如果ni==nf什么pool也不做stride==1，这就是我们在跳过连接中想要的。

此外，您会看到我们已经从和 act_cls=Nonefrom 的最终卷积中删除了 ReLU ( ) ，并在我们添加跳过连接之后将其移动到。这背后的想法是整个 ResNet 块就像一个层，你希望你的激活在你的层之后。convsidconv

让我们替换我们block的ResBlock并尝试一下：

def block(ni,nf): return ResBlock(ni, nf, stride=2)
learn = get_learner(get_model())

learn.fit_one_cycle(5, 3e-3)

也好不了多少。但这的全部意义在于让我们能够训练更深层次的模型，而我们还没有真正利用它。要创建一个比方说两倍深的模型，我们需要做的就是 连续block用两个ResBlocks 替换 our ：

def block(ni, nf):
    return nn.Sequential(ResBlock(ni, nf, stride=2), ResBlock(nf, nf))

learn = get_learner(get_model())learn.fit_one_cycle(5, 3e-3)

现在我们取得了很好的进展！

TOP5-准确率 

一个度量标准，用于测试我们想要的标签出现在我们模型的前 5 个预测中的频率。它被用在 ImageNet 竞赛中，因为许多图像包含多个对象，或者包含容易混淆甚至可能被错误标记为类似标签的对象。在这些情况下，查看 top-1 准确性可能是不合适的。然而，最近 CNN 变得非常好，top-5 准确率接近 100%，因此一些研究人员现在也将 top-1 准确率用于 ImageNet。

def _resnet_stem(*sizes):
    return [
        ConvLayer(sizes[i], sizes[i+1], 3, stride = 2 if i==0 else 1)
            for i in range(len(sizes)-1)
    ] + [nn.MaxPool2d(kernel_size=3, stride=2, padding=1)]

_resnet_stem(3,32,32,64)

[ConvLayer(
   (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
   (1): BatchNorm2d(32, eps=1e-05, momentum=0.1)
   (2): ReLU()
 ), ConvLayer(
   (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
   (1): BatchNorm2d(32, eps=1e-05, momentum=0.1)
   (2): ReLU()
 ), ConvLayer(
   (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
   (1): BatchNorm2d(64, eps=1e-05, momentum=0.1)
   (2): ReLU()
 ), MaxPool2d(kernel_size=3, stride=2, padding=1, ceil_mode=False)]

茎

CNN 的前几层。通常，主干与 CNN 的主体具有不同的结构。

我们使用普通卷积层而不是 ResNet 块的原因是基于对所有深度卷积神经网络的重要认识：绝大多数计算发生在早期层中。因此，我们应该尽可能保持早期层的快速和简单。

要了解为什么在早期层中会发生如此多的计算，请考虑对 128 像素输入图像进行的第一个卷积。如果它是步幅为 1 的卷积，它会将内核应用于 128×128 像素中的每一个像素。这是很多工作！然而，在后面的层中，网格大小可能小到 4×4 甚至 2×2，因此要执行的内核应用程序要少得多。

另一方面，第一层卷积只有 3 个输入特征和 32 个输出特征。由于它是一个 3×3 内核，因此权重中有 3×32×3×3 = 864 个参数。但是最后一个卷积将有 256 个输入特征和 512 个输出特征，产生 1,179,648 个权重！所以第一层包含绝大多数计算，但最后一层包含绝大多数参数。

ResNet 块比普通卷积块需要更多的计算，因为（在 stride-2 的情况下）ResNet 块具有三个卷积和一个池化层。这就是为什么我们想要简单的卷积来开始我们的 ResNet。

我们现在准备展示现代 ResNet 的实现，其中包含“技巧包”。它使用四组 ResNet 块，分别有 64、128、256，然后是 512 个过滤器。每个组都以一个 stride-2 块开始，除了第一个，因为它就在MaxPooling一层之后：

class ResNet(nn.Sequential):
    def __init__(self, n_out, layers, expansion=1):
        stem = _resnet_stem(3,32,32,64)
        self.block_szs = [64, 64, 128, 256, 512]
        for i in range(1,5): self.block_szs[i] *= expansion
        blocks = [self._make_layer(*o) for o in enumerate(layers)]
        super().__init__(*stem, *blocks,
                         nn.AdaptiveAvgPool2d(1), Flatten(),
                         nn.Linear(self.block_szs[-1], n_out))

    def _make_layer(self, idx, n_layers):
        stride = 1 if idx==0 else 2
        ch_in,ch_out = self.block_szs[idx:idx+2]
        return nn.Sequential(*[
            ResBlock(ch_in if i==0 else ch_out, ch_out, stride if i==0 else 1)
            for i in range(n_layers)
        ])

该_make_layer功能只是用来创建一系列 n_layers块。第一个是从ch_in到ch_out 与指示的stride，所有其他都是步幅为 1 的块与ch_out到ch_out张量。一旦定义了块，我们的模型就是纯顺序的，这就是为什么我们将它定义为 nn.Sequential. （暂时忽略expansion参数；我们将在下一节中讨论它。现在，它是1，所以它什么都不做。）

为什么这有用？1×1 卷积要快得多，所以即使这看起来是一个更复杂的设计，这个块的执行速度也比我们看到的第一个 ResNet 块快。这让我们可以使用更多的过滤器：正如我们在插图中看到的，进出过滤器的数量高出四倍（256 而不是 64）。1×1 convs 减少然后恢复通道数量（因此称为bottleneck）。总体影响是我们可以在相同的时间内使用更多的过滤器。

让我们尝试用ResBlock这个瓶颈设计替换我们的：

def _conv_block(ni,nf,stride):
    return nn.Sequential(
        ConvLayer(ni, nf//4, 1),
        ConvLayer(nf//4, nf//4, stride=stride),
        ConvLayer(nf//4, nf, 1, act_cls=None, norm_type=NormType.BatchZero))

我们将使用它来创建一个组大小为(3,4,6,3). 我们现在需要传入4的expansion参数ResNet，因为我们需要以少四倍的通道开始，以多四倍的通道结束。

像这样的更深层网络在仅训练 5 个时期时通常不会显示出改进，因此我们这次将其增加到 20 个时期以充分利用我们更大的模型。为了真正获得好的结果，让我们也使用更大的图像：

dls = get_data(URLs.IMAGENETTE_320, presize=320, resize=224)

我们不需要做任何事情来解释更大的 224 像素图像；多亏了我们的全卷积网络，它才能正常工作。这也是我们能够在本书前面进行渐进式调整大小的原因——我们使用的模型是完全卷积的，因此我们甚至能够微调使用不同大小训练的模型。我们现在可以训练我们的模型并查看效果：

rn = ResNet(dls.c, [3,4,6,3], 4)

learn = get_learner(rn)learn.fit_one_cycle(20, 3e-3)

我们现在取得了不错的成绩！尝试添加 Mixup，然后在你去吃午饭的时候训练它一百个 epoch。您将拥有一个非常准确的图像分类器，从头开始训练。