动手学深度学习（李沐）PyTorch 第 7 章 现代卷积神经网络

7.1 深度卷积神经网络（AlexNet）

在计算机视觉中，直接将神经网络与其他机器学习方法进行比较也许不公平。这是因为，卷积神经网络的输入是由原始像素值或是经过简单预处理（例如居中、缩放）的像素值组成的。但在使用传统机器学习方法时，从业者永远不会将原始像素作为输入。在传统机器学习方法中，计算机视觉流水线是由经过人的手工精心设计的特征流水线组成的。对于这些传统方法，大部分的进展都来自于对特征有了更聪明的想法，并且学习到的算法往往归于事后的解释。

虽然上世纪90年代就有了一些神经网络加速卡，但仅靠它们还不足以开发出有大量参数的深层多通道多层卷积神经网络。此外，当时的数据集仍然相对较小。除了这些障碍，训练神经网络的一些关键技巧仍然缺失，包括启发式参数初始化、随机梯度下降的变体、非挤压激活函数和有效的正则化技术。

AlexNet

2012年，AlexNet横空出世。它首次证明了学习到的特征可以超越手工设计的特征。它一举打破了计算机视觉研究的现状。 AlexNet使用了8层卷积神经网络，并以很大的优势赢得了2012年ImageNet图像识别挑战赛。

AlexNet和LeNet的架构非常相似，如 图7.1.2所示。 注意，本书在这里提供的是一个稍微精简版本的AlexNet，去除了当年需要两个小型GPU同时运算的设计特点。

多个卷积层是为了提高网络深度使其能够学习到更复杂的特征，之所以这几个卷积层相同是为了共享参数，减少模型的参数数量，从而降低计算复杂度

dense：稠密层也称做全连接层，就是把特征提取成一维帮助最后分类

1.模型设计

在AlexNet的第一层，卷积窗口的形状是1111。 由于ImageNet中大多数图像的宽和高比MNIST图像的多10倍以上，因此，需要一个更大的卷积窗口来捕获目标。 第二层中的卷积窗口形状被缩减为55，然后是33。 此外，在第一层、第二层和第五层卷积层之后，加入窗口形状为33、步幅为2的最大汇聚层。 而且，AlexNet的卷积通道数目是LeNet的10倍。

在最后一个卷积层后有两个全连接层，分别有4096个输出。 这两个巨大的全连接层拥有将近1GB的模型参数。 由于早期GPU显存有限，原版的AlexNet采用了双数据流设计，使得每个GPU只负责存储和计算模型的一半参数。 幸运的是，现在GPU显存相对充裕，所以现在很少需要跨GPU分解模型（因此，本书的AlexNet模型在这方面与原始论文稍有不同）。

2.激活函数

此外，AlexNet将sigmoid激活函数改为更简单的ReLU激活函数。 一方面，ReLU激活函数的计算更简单，它不需要如sigmoid激活函数那般复杂的求幂运算。 另一方面，当使用不同的参数初始化方法时，ReLU激活函数使训练模型更加容易。 当sigmoid激活函数的输出非常接近于0或1时，这些区域的梯度几乎为0，因此反向传播无法继续更新一些模型参数。 相反，ReLU激活函数在正区间的梯度总是1。 因此，如果模型参数没有正确初始化，sigmoid函数可能在正区间内得到几乎为0的梯度，从而使模型无法得到有效的训练。

3.容量控制和预处理

AlexNet通过暂退法控制全连接层的模型复杂度，而LeNet只使用了权重衰减。 为了进一步扩充数据，AlexNet在训练时增加了大量的图像增强数据，如翻转、裁切和变色。 这使得模型更健壮，更大的样本量有效地减少了过拟合。 在 13.1节中更详细地讨论数据扩增。

import torch
from torch import nn
from d2l import torch as d2l

net = nn.Sequential(
    # 这里使用一个11*11的更大窗口来捕捉对象。
    # 同时，步幅为4，以减少输出的高度和宽度。
    # 另外，输出通道的数目远大于LeNet
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    # 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
    nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    # 使用三个连续的卷积层和较小的卷积窗口。
    # 除了最后的卷积层，输出通道的数量进一步增加。
    # 在前两个卷积层之后，汇聚层不用于减少输入的高度和宽度
    nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Flatten(),
    # 这里，全连接层的输出数量是LeNet中的好几倍。使用dropout层来减轻过拟合
    nn.Linear(6400, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    # 最后是输出层。由于这里使用Fashion-MNIST，所以用类别数为10，而非论文中的1000
    nn.Linear(4096, 10))

我们构造一个高度和宽度都为224的单通道数据，来观察每一层输出的形状。 它与 图7.1.2中的AlexNet架构相匹配。

X = torch.randn(1, 1, 224, 224)
for layer in net:
    X=layer(X)
    print(layer.__class__.__name__,'output shape:\t',X.shape)

读取数据集

尽管原文中AlexNet是在ImageNet上进行训练的，但本书在这里使用的是Fashion-MNIST数据集。因为即使在现代GPU上，训练ImageNet模型，同时使其收敛可能需要数小时或数天的时间。 将AlexNet直接应用于Fashion-MNIST的一个问题是，Fashion-MNIST图像的分辨率（28*28像素）低于ImageNet图像。 为了解决这个问题，我们将它们增加到224*224（通常来讲这不是一个明智的做法，但在这里这样做是为了有效使用AlexNet架构）。 这里需要使用d2l.load_data_fashion_mnist函数中的resize参数执行此调整。

batch_size = 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)

训练AlexNet

现在AlexNet可以开始被训练了。与 6.6节中的LeNet相比，这里的主要变化是使用更小的学习速率训练，这是因为网络更深更广、图像分辨率更高，训练卷积神经网络就更昂贵。

lr, num_epochs = 0.01, 10
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

7.2 使用块的网络（VGG）

与芯片设计中工程师从放置晶体管到逻辑元件再到逻辑块的过程类似，神经网络架构的设计也逐渐变得更加抽象。研究人员开始从单个神经元的角度思考问题，发展到整个层，现在又转向块，重复层的模式。

使用块的想法首先出现在牛津大学的视觉几何组（visual geometry group）的VGG网络中。通过使用循环和子程序，可以很容易地在任何现代深度学习框架的代码中实现这些重复的架构。

VGG块

经典卷积神经网络的基本组成部分是下面的这个序列：

1. 带填充以保持分辨率的卷积层；
2. 非线性激活函数，如ReLU；
3. 汇聚层，如最大汇聚层。

而一个VGG块与之类似，由一系列卷积层组成，后面再加上用于空间下采样的最大汇聚层。在最初的VGG论文中 (Simonyan and Zisserman, 2014)，作者使用了带有33卷积核、填充为1（保持高度和宽度）的卷积层，和带有22汇聚窗口、步幅为2（每个块后的分辨率减半）的最大汇聚层。在下面的代码中，我们定义了一个名为vgg_block的函数来实现一个VGG块。

该函数有三个参数，分别对应于卷积层的数量num_convs、输入通道的数量in_channels 和输出通道的数量out_channels.

import torch
from torch import nn
from d2l import torch as d2l


def vgg_block(num_convs, in_channels, out_channels):
    layers = [] # 用来保存这个 VGG 块中的所有层
    for _ in range(num_convs):
        layers.append(nn.Conv2d(in_channels, out_channels,
                                kernel_size=3, padding=1))
        layers.append(nn.ReLU()) # 用于引入非线性特性
        in_channels = out_channels # 确保下一个卷积层的输入通道数与当前卷积层的输出通道数一致
    layers.append(nn.MaxPool2d(kernel_size=2,stride=2))
    return nn.Sequential(*layers) # 最后将这些层组合成一个 nn.Sequential 模块

VGG网络

与AlexNet、LeNet一样，VGG网络可以分为两部分：第一部分主要由卷积层和汇聚层组成，第二部分由全连接层组成。如 图7.2.1中所示。

VGG神经网络连接 图7.2.1的几个VGG块（在vgg_block函数中定义）。其中有超参数变量conv_arch。该变量指定了每个VGG块里卷积层个数和输出通道数。全连接模块则与AlexNet中的相同。

原始VGG网络有5个卷积块，其中前两个块各有一个卷积层，后三个块各包含两个卷积层。 第一个模块有64个输出通道，每个后续模块将输出通道数量翻倍，直到该数字达到512。由于该网络使用8个卷积层和3个全连接层，因此它通常被称为VGG-11。

conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))

下面的代码实现了VGG-11。可以通过在conv_arch上执行for循环来简单实现。

# VGG网络
def vgg(conv_arch):
    conv_blks = []
    in_channels = 1
    # 卷积层部分
    for (num_convs, out_channels) in conv_arch:
        conv_blks.append(vgg_block(num_convs, in_channels, out_channels))
        in_channels = out_channels

    return nn.Sequential(
        *conv_blks, nn.Flatten(),
        # 全连接层部分
        nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 10))

net = vgg(conv_arch)

接下来，我们将构建一个高度和宽度为224的单通道数据样本，以观察每个层输出的形状。

X = torch.randn(size=(1, 1, 224, 224))
for blk in net:
    X = blk(X)
    print(blk.__class__.__name__,'output shape:\t',X.shape)

正如从代码中所看到的，我们在每个块的高度和宽度减半，最终高度和宽度都为7。最后再展平表示，送入全连接层处理。

训练模型

由于VGG-11比AlexNet计算量更大，因此我们构建了一个通道数较少的网络，足够用于训练Fashion-MNIST数据集。

ratio = 4
small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch]
net = vgg(small_conv_arch)

1. ratio = 4
   这是一个缩放系数，用于减小网络中卷积层的输出通道数。设定 ratio = 4 意味着每个卷积层的输出通道数将被原来值的四分之一。
2. conv_arch 是什么？
   conv_arch 代表卷积神经网络的架构，通常是一个列表，描述了每个卷积块的结构，包括每个卷积层的通道数。
   conv_arch 的典型格式是一个元组列表，其中每个元组包含两个元素：

• 第一个元素是每个卷积块中卷积层的数量。
• 第二个元素是该卷积块的输出通道数（即卷积后的特征图通道数）。
  例如，conv_arch 可能如下所示：
  conv_arch = [(2, 64), (2, 128), (3, 256), (3, 512), (3, 512)]
  这表示：
• 第一层包含 2 个卷积层，输出通道数为 64。
• 第二层包含 2 个卷积层，输出通道数为 128。
• 第三层包含 3 个卷积层，输出通道数为 256。

后面两层分别有 3 个卷积层，输出通道数为 512。

3. small_conv_arch
   small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch]
   这是一种列表推导式，用于生成缩小版的卷积层架构。
   conv_arch 的每个元组被处理，其中：
   pair[0] 表示卷积块中的卷积层数量。
   pair[1] 表示卷积块的输出通道数。
   对每个卷积块的输出通道数 pair[1]，将它除以 ratio，缩小为原来的四分之一：
   pair[1] // ratio 是整数除法，确保结果是整数。
   生成的 small_conv_arch 将具有与 conv_arch 相同的卷积层数量，但每个卷积块的输出通道数被缩小。例如，对于上面的 conv_arch，如果 ratio=4，small_conv_arch 将变成：
   small_conv_arch = [(2, 64 // 4), (2, 128 // 4), (3, 256 // 4), (3, 512 // 4), (3, 512 // 4)]

4. net = vgg(small_conv_arch)
   net = vgg(small_conv_arch)
   这里调用了一个名为 vgg 的函数，并将 small_conv_arch 作为参数传递给它，构建一个基于调整后架构的 VGG 网络。
   假设 vgg 函数能够根据传入的卷积层架构构建一个完整的 VGG 网络，net 将是这个网络的实例。

除了使用略高的学习率外，模型训练过程与 7.1节中的AlexNet类似。

lr, num_epochs, batch_size = 0.05, 10, 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

7.3 网络中的网络（NiN）

LeNet、AlexNet和VGG都有一个共同的设计模式：通过一系列的卷积层与汇聚层来提取空间结构特征；然后通过全连接层对特征的表征进行处理。 AlexNet和VGG对LeNet的改进主要在于如何扩大和加深这两个模块。 或者，可以想象在这个过程的早期使用全连接层。然而，如果使用了全连接层，可能会完全放弃表征的空间结构。 网络中的网络（NiN）提供了一个非常简单的解决方案：在每个像素的通道上分别使用多层感知机 (Lin et al., 2013)

NiN块

1*1卷积代替全连接的意思应该是都是在做加权求和

回想一下，卷积层的输入和输出由四维张量组成，张量的每个轴分别对应样本、通道、高度和宽度。 另外，全连接层的输入和输出通常是分别对应于样本和特征的二维张量。 NiN的想法是在每个像素位置（针对每个高度和宽度）应用一个全连接层。 如果我们将权重连接到每个空间位置，我们可以将其视为1*1卷积层（如 6.4节中所述），或作为在每个像素位置上独立作用的全连接层。 从另一个角度看，即将空间维度中的每个像素视为单个样本，将通道维度视为不同特征（feature）。

图7.3.1说明了VGG和NiN及它们的块之间主要架构差异。 NiN块以一个普通卷积层开始，后面是两个11的卷积层。这两个11卷积层充当带有ReLU激活函数的逐像素全连接层。 第一层的卷积窗口形状通常由用户设置。 随后的卷积窗口形状固定为1*1。

import torch
from torch import nn
from d2l import torch as d2l


def nin_block(in_channels, out_channels, kernel_size, strides, padding):
    return nn.Sequential(
        nn.Conv2d(in_channels, out_channels, kernel_size, strides, padding),
        nn.ReLU(),
        nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU(),
        nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU())

NiN模型

最初的NiN网络是在AlexNet后不久提出的，显然从中得到了一些启示。 NiN使用窗口形状为1111、55和33的卷积层，输出通道数量与AlexNet中的相同。 每个NiN块后有一个最大汇聚层，汇聚窗口形状为33，步幅为2。

NiN和AlexNet之间的一个显著区别是NiN完全取消了全连接层。 相反，NiN使用一个NiN块，其输出通道数等于标签类别的数量。最后放一个全局平均汇聚层（global average pooling layer），生成一个对数几率 （logits）。NiN设计的一个优点是，它显著减少了模型所需参数的数量。然而，在实践中，这种设计有时会增加训练模型的时间。

net = nn.Sequential(
    nin_block(1, 96, kernel_size=11, strides=4, padding=0),
    nn.MaxPool2d(3, stride=2),
    nin_block(96, 256, kernel_size=5, strides=1, padding=2),
    nn.MaxPool2d(3, stride=2),
    nin_block(256, 384, kernel_size=3, strides=1, padding=1),
    nn.MaxPool2d(3, stride=2),
    nn.Dropout(0.5),
    # 标签类别数是10
    nin_block(384, 10, kernel_size=3, strides=1, padding=1),
    nn.AdaptiveAvgPool2d((1, 1)),
    # 将四维的输出转成二维的输出，其形状为(批量大小,10)
    nn.Flatten())

1. nin_block(384, 10, kernel_size=3, strides=1, padding=1)
   这个 nin_block 是卷积操作的一部分，输入通道数为 384，输出通道数为 10。
   卷积层通常会输出四维张量，其形状为 (批量大小, 输出通道数, 高度, 宽度)。因此，这个卷积层的输出形状是 (批量大小, 10, H, W)，其中 H 和 W 是经过卷积和池化后的特征图的高度和宽度。
2. AdaptiveAvgPool2d((1, 1))
   AdaptiveAvgPool2d((1, 1)) 是自适应平均池化操作，它将输入的特征图的空间尺寸 固定 到 1x1。
   因此，经过这个操作后，卷积层的输出形状会变为 (批量大小, 10, 1, 1)，即：

• 批量大小 保持不变。
• 输出通道数 为 10。
• 高度和宽度 被池化成 1x1。

3. Flatten()
   Flatten 操作会将高维张量展平为二维张量。
   在这里，输入到 Flatten 的张量形状是 (批量大小, 10, 1, 1)，而 Flatten 会将除了第一个维度（批量大小）以外的维度全部展平成一个维度。
   因此，Flatten 后的形状会变为：

• 批量大小 保持不变。
• 剩下的维度 10 * 1 * 1 = 10 被展平成一个维度。

结果是 (批量大小, 10)。

我们创建一个数据样本来查看每个块的输出形状。

训练模型

和以前一样，我们使用Fashion-MNIST来训练模型。训练NiN与训练AlexNet、VGG时相似。

lr, num_epochs, batch_size = 0.1, 10, 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

7.4 含并行连结的网络（GoogLeNet）

在2014年的ImageNet图像识别挑战赛中，一个名叫GoogLeNet (Szegedy et al., 2015)的网络架构大放异彩。 GoogLeNet吸收了NiN中串联网络的思想，并在此基础上做了改进。 这篇论文的一个重点是解决了什么样大小的卷积核最合适的问题。 毕竟，以前流行的网络使用小到11，大到1111的卷积核。 本文的一个观点是，有时使用不同大小的卷积核组合是有利的。 本节将介绍一个稍微简化的GoogLeNet版本：我们省略了一些为稳定训练而添加的特殊特性，现在有了更好的训练方法，这些特性不是必要的。

Inception块

在GoogLeNet中，基本的卷积块被称为Inception块（Inception block）。这很可能得名于电影《盗梦空间》（Inception），因为电影中的一句话“我们需要走得更深”（“We need to go deeper”）。

Insection不改变高宽，只改变通道数

白色用来处理通道数，蓝色用来抽取信息（1*1抽取通道信息，其他抽取空间信息）

如 图7.4.1所示，Inception块由四条并行路径组成。 前三条路径使用窗口大小为11、33和55的卷积层，从不同空间大小中提取信息。 中间的两条路径在输入上执行11卷积，以减少通道数，从而降低模型的复杂性。 第四条路径使用33最大汇聚层，然后使用11卷积层来改变通道数。 这四条路径都使用合适的填充来使输入与输出的高和宽一致，最后我们将每条线路的输出在通道维度上连结，并构成Inception块的输出。在Inception块中，通常调整的超参数是每层输出通道数。

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l


class Inception(nn.Module):
    # c1--c4是每条路径的输出通道数
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1，单1x1卷积层
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        # 线路2，1x1卷积层后接3x3卷积层
        self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)
        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
        # 线路3，1x1卷积层后接5x5卷积层
        self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)
        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
        # 线路4，3x3最大汇聚层后接1x1卷积层
        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)

    def forward(self, x):
        p1 = F.relu(self.p1_1(x))
        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
        p4 = F.relu(self.p4_2(self.p4_1(x)))
        # 在通道维度上连结输出
        return torch.cat((p1, p2, p3, p4), dim=1)

那么为什么GoogLeNet这个网络如此有效呢？ 首先我们考虑一下滤波器（filter）的组合，它们可以用各种滤波器尺寸探索图像，这意味着不同大小的滤波器可以有效地识别不同范围的图像细节。 同时，我们可以为不同的滤波器分配不同数量的参数。

GoogLeNet模型

如 图7.4.2所示，GoogLeNet一共使用9个Inception块和全局平均汇聚层的堆叠来生成其估计值。Inception块之间的最大汇聚层可降低维度。 第一个模块类似于AlexNet和LeNet，Inception块的组合从VGG继承，全局平均汇聚层避免了在最后使用全连接层。

现在，我们逐一实现GoogLeNet的每个模块。第一个模块使用64个通道、7*7卷积层。

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1),
                   nn.ReLU(),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),
                   Inception(256, 128, (128, 192), (32, 96), 64),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),
                   Inception(512, 160, (112, 224), (24, 64), 64),
                   Inception(512, 128, (128, 256), (24, 64), 64),
                   Inception(512, 112, (144, 288), (32, 64), 64),
                   Inception(528, 256, (160, 320), (32, 128), 128),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
                   Inception(832, 384, (192, 384), (48, 128), 128),
                   nn.AdaptiveAvgPool2d((1,1)),
                   nn.Flatten())

net = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))

GoogLeNet模型的计算复杂，而且不如VGG那样便于修改通道数。 为了使Fashion-MNIST上的训练短小精悍，我们将输入的高和宽从224降到96，这简化了计算。下面演示各个模块输出的形状变化。

X = torch.rand(size=(1, 1, 96, 96))
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape:\t', X.shape)

训练模型

和以前一样，我们使用Fashion-MNIST数据集来训练我们的模型。在训练之前，我们将图片转换为96*96分辨率。

lr, num_epochs, batch_size = 0.1, 10, 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

7.5 批量归一化

训练深层神经网络是十分困难的，特别是在较短的时间内使他们收敛更加棘手。 本节将介绍批量规范化（batch normalization） (Ioffe and Szegedy, 2015)，这是一种流行且有效的技术，可持续加速深层网络的收敛速度。 再结合在 7.6节中将介绍的残差块，批量规范化使得研究人员能够训练100层以上的网络。

在反向传播过程中，梯度通过链式法则从输出层传递到输入层，由于链式法则的乘积形式，如果每一层的梯度范数小于1，那么经过多层的乘积后，梯度会指数级减小，从而导致梯度消失。

当神经网络特别深的时候，数据在下面，损失函数在上面，backward时是从上往下，上面梯度比较大，越到下面就越容易变小，就导致问题：上面的东西很快就收敛，下面的比较慢

这里的变化指的是不同batch的分布变化，而不是指底层参数变化导致顶层参数变化

batch norm 和 layer norm 的区别简单来说就是对同一个 batch 做平均还是对 同一个 layer 做平均

批量归一化层

对于卷积层，对于每一个像素，都有多个通道，例如100个通道则每一个像素都有一个长为100的向量，可以认为这个向量是这个像素的一个特征。因此，对于输入，每一个像素都是一个样本。在每个批量里，1个像素是1个样本。与像素（样本）对应的通道维，就是特征维

总结：

• 批量归一化可以加速收敛速度，但一般不改变模型精度

从零实现

下面，我们从头开始实现一个具有张量的批量规范化层。

import torch
from torch import nn
from d2l import torch as d2l


def batch_norm(X, gamma, beta, moving_mean, moving_var, eps, momentum):
    # 通过is_grad_enabled来判断当前模式是训练模式还是预测模式
    if not torch.is_grad_enabled():
        # 如果是在预测模式下，直接使用传入的移动平均所得的均值和方差
        X_hat = (X - moving_mean) / torch.sqrt(moving_var + eps)
    else:
        assert len(X.shape) in (2, 4) # 2->全连接层，4->卷积层
        if len(X.shape) == 2:
            # 使用全连接层的情况，计算特征维上的均值和方差
            # 这里2对应全连接层两个维度（batch_size样本数量，每个样本的特征数量）
			
			# 按特征维度 dim=0 计算均值和方差。
            mean = X.mean(dim=0)
            var = ((X - mean) ** 2).mean(dim=0) # 方差
        else:
        	# 4对应卷积4个维度（batch，通道数，长，宽）
            # 使用二维卷积层的情况，计算通道维上（axis=1）的均值和方差。
            # 这里我们需要保持X的形状以便后面可以做广播运算

			# 按通道维度以及空间维度 (0, 2, 3) 计算均值和方差，并保留张量的形状以支持后续的广播操作。
			# 由于是对通道数求平均值，对每一个通道，要把所有的批量、高、宽所有像素用来求均值
            mean = X.mean(dim=(0, 2, 3), keepdim=True)
            var = ((X - mean) ** 2).mean(dim=(0, 2, 3), keepdim=True)
        
        # 训练模式下，用当前的均值和方差做标准化
        X_hat = (X - mean) / torch.sqrt(var + eps)
        # 更新移动平均的均值和方差
        moving_mean = momentum * moving_mean + (1.0 - momentum) * mean
        moving_var = momentum * moving_var + (1.0 - momentum) * var
    Y = gamma * X_hat + beta  # 经过归一化后的张量X_hat进行缩放和移位，其中gamma和beta是可学习的参数
    return Y, moving_mean.data, moving_var.data

注意torch.cat((X, Y), dim=0) 把这两个元素合并在一起，且在第0维合并，也就是按行合并，即堆起来；但是mean = X.mean(dim=0)不是对每行求均值，而是对每列求均值，与sum相似：axis等于几相当于把第几维给消去。这里axis=0，相当于把【5，4】的“5”给消去，剩下的就是“4”

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape

axis=0，对行，但是这个按行并不是指按行的方向来说，而是从行的角度来说，这里一共有5行，所以就是把五行加起来，所以最后就剩下四列了，这种情况下我们计算时不会考虑有几列，只是自然而然的剩下了四列

我们可以基于形状为 (2, 5, 4) 的张量 X 来分别讨论 mean(dim=0)、mean(dim=1) 和 mean(dim=2) 的结果。

假设的张量 X：

X = [
  [  # 第 1 个块 (5x4 矩阵)
    [a1, b1, c1, d1],
    [a2, b2, c2, d2],
    [a3, b3, c3, d3],
    [a4, b4, c4, d4],
    [a5, b5, c5, d5]
  ],
  [  # 第 2 个块 (5x4 矩阵)
    [e1, f1, g1, h1],
    [e2, f2, g2, h2],
    [e3, f3, g3, h3],
    [e4, f4, g4, h4],
    [e5, f5, g5, h5]
  ]
]

这个张量的形状为 (2, 5, 4)，表示有 2 个 5×4 的矩阵块。

1. mean(dim=0) 的结果
   当我们对 dim=0 进行均值计算时，我们会对第 0 维（块的维度）进行均值计算，意思是将 两个块的对应行的值进行均值操作。这样对 每个位置（行和特征） 进行平均，结果将是一个 5x4 的矩阵（即形状为 (5, 4)）。

具体计算如下：

mean(dim=0) = [
  [  # 每个位置对应两个块的值进行均值
    (a1 + e1) / 2, (b1 + f1) / 2, (c1 + g1) / 2, (d1 + h1) / 2
  ],
  [
    (a2 + e2) / 2, (b2 + f2) / 2, (c2 + g2) / 2, (d2 + h2) / 2
  ],
  [
    (a3 + e3) / 2, (b3 + f3) / 2, (c3 + g3) / 2, (d3 + h3) / 2
  ],
  [
    (a4 + e4) / 2, (b4 + f4) / 2, (c4 + g4) / 2, (d4 + h4) / 2
  ],
  [
    (a5 + e5) / 2, (b5 + f5) / 2, (c5 + g5) / 2, (d5 + h5) / 2
  ]
]

结果的形状为 (5, 4)，即沿着第 0 维度（两个块之间）进行均值计算。

2. mean(dim=1) 的结果
   当我们对 dim=1 进行均值计算时，我们会对每个块内的 5 行进行均值操作，意味着对每个块的 5 行条目 进行均值，结果将是一个 2x4 的矩阵（即形状为 (2, 4)）。

具体计算如下：

mean(dim=1) = [
  [  # 对第 1 个块的每列计算均值
    (a1 + a2 + a3 + a4 + a5) / 5, 
    (b1 + b2 + b3 + b4 + b5) / 5, 
    (c1 + c2 + c3 + c4 + c5) / 5, 
    (d1 + d2 + d3 + d4 + d5) / 5
  ],
  [  # 对第 2 个块的每列计算均值
    (e1 + e2 + e3 + e4 + e5) / 5, 
    (f1 + f2 + f3 + f4 + f5) / 5, 
    (g1 + g2 + g3 + g4 + g5) / 5, 
    (h1 + h2 + h3 + h4 + h5) / 5
  ]
]

结果的形状为 (2, 4)，即每个块内的 5 行被均值计算成 1 行。

3. mean(dim=2) 的结果
   当我们对 dim=2 进行均值计算时，表示对每个块的 每行的 4 个特征值 进行均值计算，结果将是一个 2x5 的矩阵（即形状为 (2, 5)）。

具体计算如下：

mean(dim=2) = [
  [  # 对第 1 个块的每行计算均值
    (a1 + b1 + c1 + d1) / 4,  # 第 1 行的均值
    (a2 + b2 + c2 + d2) / 4,  # 第 2 行的均值
    (a3 + b3 + c3 + d3) / 4,  # 第 3 行的均值
    (a4 + b4 + c4 + d4) / 4,  # 第 4 行的均值
    (a5 + b5 + c5 + d5) / 4   # 第 5 行的均值
  ],
  [  # 对第 2 个块的每行计算均值
    (e1 + f1 + g1 + h1) / 4,  # 第 1 行的均值
    (e2 + f2 + g2 + h2) / 4,  # 第 2 行的均值
    (e3 + f3 + g3 + h3) / 4,  # 第 3 行的均值
    (e4 + f4 + g4 + h4) / 4,  # 第 4 行的均值
    (e5 + f5 + g5 + h5) / 4   # 第 5 行的均值
  ]
]

结果的形状为 (2, 5)，即每行的 4 个特征被均值成 1 个值。

触发广播机制的情形1.tensor维度相等。 2.tensor维度不等且其中一个维度为1。 3.tensor维度不等且其中一个维度不存在。这里mean的维度为1，故即使维度不一样也可以触发广播机制

我们现在可以创建一个正确的BatchNorm层。 这个层将保持适当的参数：拉伸gamma和偏移beta,这两个参数将在训练过程中更新。 此外，我们的层将保存均值和方差的移动平均值，以便在模型预测期间随后使用。

撇开算法细节，注意我们实现层的基础设计模式。 通常情况下，我们用一个单独的函数定义其数学原理，比如说batch_norm。 然后，我们将此功能集成到一个自定义层中，其代码主要处理数据移动到训练设备（如GPU）、分配和初始化任何必需的变量、跟踪移动平均线（此处为均值和方差）等问题。 为了方便起见，我们并不担心在这里自动推断输入形状，因此我们需要指定整个特征的数量。 不用担心，深度学习框架中的批量规范化API将为我们解决上述问题，我们稍后将展示这一点。

class BatchNorm(nn.Module):
    # num_features：完全连接层的输出数量或卷积层的输出通道数。
    # num_dims：2表示完全连接层，4表示卷积层
    def __init__(self, num_features, num_dims):
        super().__init__()
        if num_dims == 2:
            shape = (1, num_features)
        else:
            shape = (1, num_features, 1, 1)
        # 参与求梯度和迭代的拉伸和偏移参数，分别初始化成1和0
        self.gamma = nn.Parameter(torch.ones(shape))
        self.beta = nn.Parameter(torch.zeros(shape))
        # 非模型参数的变量初始化为0和1
        self.moving_mean = torch.zeros(shape)
        self.moving_var = torch.ones(shape)

    def forward(self, X):
    	# 由于moving_mean和moving_var没有使用nn.Parameter
        # 如果X不在内存上，将moving_mean和moving_var复制到X所在显存上
        if self.moving_mean.device != X.device:
            self.moving_mean = self.moving_mean.to(X.device)
            self.moving_var = self.moving_var.to(X.device)
        # 保存更新过的moving_mean和moving_var
        Y, self.moving_mean, self.moving_var = batch_norm(
            X, self.gamma, self.beta, self.moving_mean,
            self.moving_var, eps=1e-5, momentum=0.9)
        return Y

eps:伊普西隆

这里不随机的原因是如果随机出来比较特别的数就没办法按正常迭代了

使用批量规范化层的 LeNet

为了更好理解如何应用BatchNorm，下面我们将其应用于LeNet模型（ 6.6节）。 回想一下，批量规范化是在卷积层或全连接层之后、相应的激活函数之前应用的。注意最后的输出层 nn.Linear(84, 10) 后就不加任何东西了

net = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5), BatchNorm(6, num_dims=4), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), BatchNorm(16, num_dims=4), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(),
    nn.Linear(16*4*4, 120), BatchNorm(120, num_dims=2), nn.Sigmoid(),
    nn.Linear(120, 84), BatchNorm(84, num_dims=2), nn.Sigmoid(),
    nn.Linear(84, 10))

和以前一样，我们将在Fashion-MNIST数据集上训练网络。 这个代码与我们第一次训练LeNet（ 6.6节）时几乎完全相同，主要区别在于学习率大得多。

lr, num_epochs, batch_size = 1.0, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

之前的：

不是跑得更快，是收敛更快，同样跑10个epoch，加了更多操作肯定是变慢了的。变快是指收敛所需的迭代步数变少了，但每次迭代计算量更大了，所以从时间上来讲跑得慢了

LeNet使用BatchNorm后只是加快收敛，并不会提高精度。收敛变快指的是原本10轮精度只有现在的六七轮的效果

让我们来看看从第一个批量规范化层中学到的拉伸参数gamma和偏移参数beta。

net[1].gamma.reshape((-1,)), net[1].beta.reshape((-1,))

reshape((-1,)) 是对张量进行重塑（reshape）操作，将其展平成 一维张量，即将其转换为一个扁平化的向量。

简明实现

除了使用我们刚刚定义的BatchNorm，我们也可以直接使用深度学习框架中定义的BatchNorm。 该代码看起来几乎与我们上面的代码相同。

net = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5), nn.BatchNorm2d(6), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.BatchNorm2d(16), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(),
    nn.Linear(256, 120), nn.BatchNorm1d(120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.BatchNorm1d(84), nn.Sigmoid(),
    nn.Linear(84, 10))

下面，我们使用相同超参数来训练模型。 请注意，通常高级API变体运行速度快得多，因为它的代码已编译为C++或CUDA，而我们的自定义代码由Python实现。

这个api调包时，不需要前面自己实现的dimension参数，而是直接变成了两个接口，1d和2d

d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

7.6 残差网络（ResNet）

随着我们设计越来越深的网络，深刻理解“新添加的层如何提升神经网络的性能” 变得至关重要。更重要的是设计网络的能力，在这种网络中，添加层会使网络更具表现力， 为了取得质的突破，我们需要一些数学基础知识。

因此，ResNet想的办法就是加更多的层不让模型精度变差，通常是变好的

残差块

ResNet块

ResNet可以认为和VGG很像，有两种ResNet-block。第一种是高宽减半的block，利用1*1卷积层，步幅为2，结果是高宽减半，然后还要使通道数增加

ResNet沿用了VGG完整的3*3卷积层设计。 残差块里首先有2个有相同输出通道数的33卷积层。 每个卷积层后接一个批量规范化层和ReLU激活函数。 然后我们通过跨层数据通路，跳过这2个卷积运算，将输入直接加在最后的ReLU激活函数前。 这样的设计要求2个卷积层的输出与输入形状一样，从而使它们可以相加。 如果想改变通道数，就需要引入一个额外的11卷积层来将输入变换成需要的形状后再做相加运算。 残差块的实现如下：

Residual剩余的

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l


class Residual(nn.Module):  #@save
    def __init__(self, input_channels, num_channels,
                 use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,
                               kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,
                               kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)

如 图7.6.3所示，此代码生成两种类型的网络： 一种是当use_1x1conv=False时，应用ReLU非线性函数之前，将输入添加到输出。 另一种是当use_1x1conv=True时，添加通过1*1卷积调整通道和分辨率。

下面我们来查看输入和输出形状一致的情况。

blk = Residual(3,3)
X = torch.rand(4, 3, 6, 6)
Y = blk(X)
Y.shape

我们也可以在增加输出通道数的同时，减半输出的高和宽。

blk = Residual(3,6, use_1x1conv=True, strides=2)
blk(X).shape

ResNet架构

ResNet的前两层跟之前介绍的GoogLeNet中的一样： 在输出通道数为64、步幅为2的77卷积层后，接步幅为2的33的最大汇聚层。 不同之处在于ResNet每个卷积层后增加了批量规范化层。

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

GoogLeNet在后面接了4个由Inception块组成的模块。 ResNet则使用4个由残差块组成的模块，每个模块使用若干个同样输出通道数的残差块。 第一个模块的通道数同输入通道数一致。 由于之前已经使用了步幅为2的最大汇聚层，所以无须减小高和宽。 之后的每个模块在第一个残差块里将上一个模块的通道数翻倍，并将高和宽减半。

下面我们来实现这个模块。注意，我们对第一个模块做了特别处理。

def resnet_block(input_channels, num_channels, num_residuals,
                 first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels,
                                use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk

接着在ResNet加入所有残差块，这里每个模块使用2个残差块。

b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

最后，与GoogLeNet一样，在ResNet中加入全局平均汇聚层，以及全连接层输出。

net = nn.Sequential(b1, b2, b3, b4, b5,
                    nn.AdaptiveAvgPool2d((1,1)),
                    nn.Flatten(), nn.Linear(512, 10))

每个模块有4个卷积层（不包括恒等映射的11卷积层）。加上第一个77卷积层和最后一个全连接层，共有18层。 因此，这种模型通常被称为ResNet-18。 通过配置不同的通道数和模块里的残差块数可以得到不同的ResNet模型，例如更深的含152层的ResNet-152。 虽然ResNet的主体架构跟GoogLeNet类似，但ResNet架构更简单，修改也更方便。这些因素都导致了ResNet迅速被广泛使用。 图7.6.4描述了完整的ResNet-18。

在训练ResNet之前，让我们观察一下ResNet中不同模块的输入形状是如何变化的。 在之前所有架构中，分辨率降低，通道数量增加，直到全局平均汇聚层聚集所有特征。

X = torch.rand(size=(1, 1, 224, 224))
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape:\t', X.shape)

训练模型

同之前一样，我们在Fashion-MNIST数据集上训练ResNet。

lr, num_epochs, batch_size = 0.05, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())