---

前言

在前面章节中，我们遇到了图像数据，我们之前的做法是把图像数据进行展平，但是这种方法忽略了像素之间的相关性。

本章介绍的卷积神经网络（convolutional neural network，CNN）是一类强大的、为处理图像数据而设计的神经网络。 基于卷积神经网络架构的模型在计算机视觉领域中已经占主导地位，当今几乎所有的图像识别、目标检测或语义分割相关的学术竞赛和商业应用都以这种方法为基础。

一、图像卷积

1.1 不变性

想象一下，假设我们要从一张图片中找出某个物体，合理的想法是，无论哪种方法找到的这个物体，都应该和物体的位置无关。卷积神经网络正是将空间不变性这一概念系统化。

现在，我们将上述想法总结一下，从而帮助我们设计适合于计算机视觉的神经网络架构。

1. 平移不变性（translation invariance）：不管检测对象出现在图像中的哪个位置，神经网络的前面几层应该对相同的图像区域具有相似的反应，即为“平移不变性”。

2. 局部性（locality）：神经网络的前面几层应该只探索输入图像中的局部区域，而不过度在意图像中相隔较远区域的关系，这就是“局部性”原则。最终，可以聚合这些局部特征，以在整个图像级别进行预测。

1.2 互相关运算

互相关运算就是卷积层的卷积。

计算过程：

输出大小等于(这个我们采用的是步幅为1)：
$$(n_h-k_h+1)\times (n_w-k_w+1).$$
在pytorch中手动计算：

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

def corr2d(X, K):  #@save
    """计算二维互相关运算"""
    h, w = K.shape
    Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (X[i:i + h, j:j + w] * K).sum()
    return Y

X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
corr2d(X, K)

1.3 卷积层

我们手动定义一个卷积层：

class Conv2D(nn.Module):
    def __init__(self, kernel_size):
        super().__init__()
        self.weight = nn.Parameter(torch.rand(kernel_size))
        self.bias = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        return corr2d(x, self.weight) + self.bias

其中corr2d是我们上面写的互相关运算函数。

1.4 互相关和卷积

互相关运算（Cross-correlation）与卷积在数学上非常相似，但在计算机科学中有一些微妙的区别。

在信号处理和机器学习中，卷积和互相关通常用于处理离散信号或图像。它们通过将一个信号（通常称为卷积核或滤波器）应用于另一个信号来生成输出信号。这两种操作可以通过以下方式定义：

卷积运算：卷积运算将卷积核翻转后应用于输入信号，然后计算两个信号之间的点积，得到输出信号。在卷积运算中，卷积核在计算过程中是反转的。

互相关运算：互相关运算与卷积非常类似，但卷积核在计算过程中不会进行反转。互相关运算的计算过程与卷积相同，只是没有进行反转操作。

简单来说，主要区别在于互相关运算中没有对卷积核进行反转操作。这使得互相关运算在一些特定的应用中更加方便，例如模式识别和图像匹配，因为它可以保留输入和卷积核之间的方向关系。

需要注意的是，在实际应用中，术语"卷积"通常被使用得更加广泛，包括了互相关运算。这是因为两者的计算结果在大多数情况下非常接近，且可以通过对卷积核进行翻转操作来实现。因此，"卷积"在实际中被广泛使用来表示这两种操作。
可参考这个

1.5 特征映射和感受野

特征映射和感受野是计算机视觉领域中常用的概念。

特征映射（Feature Map）指的是在卷积神经网络（CNN）中的各个卷积层中生成的特征图。在卷积操作中，通过将滤波器（卷积核）与输入图像进行滑动窗口计算，得到了一系列的特征映射。每个特征映射都对应着输入图像在某种特征上的响应，例如边缘、纹理、颜色等。一般来说，网络的低层特征映射对应着图像的低级特征，而高层特征映射对应着图像的高级语义信息。

感受野（Receptive Field）指的是卷积神经网络中某个特征映射上的每个单元（神经元）对应输入图像的区域大小。感受野的大小取决于网络的结构和层数，较低层的感受野通常较小，只关注输入图像的局部信息，而较高层的感受野较大，能够捕捉到更大范围的上下文信息。感受野的大小直接影响着网络对图像不同尺度物体的感知能力。

在卷积神经网络中，通过多个卷积层的堆叠，每一层都可以得到更高级的特征表达，并对应着更大尺度的感受野。这样的设计使得网络能够在不同层次上理解图像的局部细节和全局结构，并逐步提取出更抽象和语义化的特征来完成各种视觉任务。

其中特征图就是特征映射，感受野就是特征图上的每个像素是由上一层输入图像多大范围的像素卷积而来的。

二、填充和步幅

本节我们将介绍填充（padding）和步幅（stride）。假设以下情景： 有时，在应用了连续的卷积之后，我们最终得到的输出远小于输入大小。这是由于卷积核的宽度和高度通常大于1
所导致的。比如，一个240240像素的图像，经过10层55的卷积后，将减少到200*200像素。如此一来，原始图像的边界丢失了许多有用信息。而填充是解决此问题最有效的方法； 有时，我们可能希望大幅降低图像的宽度和高度。例如，如果我们发现原始的输入分辨率十分冗余。步幅则可以在这类情况下提供帮助。

2.1 填充

如上所述，在应用多层卷积时，我们常常丢失边缘像素。 由于我们通常使用小卷积核，因此对于任何单个卷积，我们可能只会丢失几个像素。 但随着我们应用许多连续卷积层，累积丢失的像素数就多了。

我们可在边缘填0，这样的话输出形状就变为：
$$(n_h-k_h+p_h+1)\times (n_w-k_w+p_w+1)。$$
其中， $p_h,p_w$表示填充的高度以及宽度。

而在许多情况下，我们会令$p_h=k_h-1,p_w=k_w-1$这样的话，可以使输入输出的图像大小不变。

通常卷积核的大小为奇数，选择奇数的好处是，保持空间维度的同时，我们可以在顶部和底部填充相同数量的行，在左侧和右侧填充相同数量的列。

比如，在下面的例子中，我们创建一个高度和宽度为3的二维卷积层，并在所有侧边填充1个像素。给定高度和宽度为8的输入，则输出的高度和宽度也是8。

import torch
from torch import nn


# 为了方便起见，我们定义了一个计算卷积层的函数。
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数
def comp_conv2d(conv2d, X):
    # 这里的（1，1）表示批量大小和通道数都是1
    X = X.reshape((1, 1) + X.shape)
    Y = conv2d(X)
    # 省略前两个维度：批量大小和通道
    return Y.reshape(Y.shape[2:])

# 请注意，这里每边都填充了1行或1列，因此总共添加了2行或2列
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
X = torch.rand(size=(8, 8))
comp_conv2d(conv2d, X).shape

当使用nn.Conv2d类定义卷积层时，可以设置以下参数：

• in_channels：输入的通道数，即输入特征图的深度。对于 RGB 彩色图像，通常为 3。对于灰度图像，通常为 1。
• out_channels：输出的通道数，即卷积操作后得到的特征图的深度。可以理解为卷积核的数量，每个卷积核会生成一个输出通道。
• kernel_size：卷积核的大小，可以是一个整数或一个元组，指定卷积核的高度和宽度。例如 kernel_size=3 表示使用 3x3 的卷积核，或者 kernel_size=(3, 3) 表示使用高度和宽度都为 3 的卷积核。

当卷积核的高度和宽度不同时，我们可以填充不同的高度和宽度，使输出和输入具有相同的高度和宽度。在如下示例中，我们使用高度为5，宽度为3的卷积核，高度和宽度两边的填充分别为2和1。

conv2d = nn.Conv2d(1, 1, kernel_size=(5, 3), padding=(2, 1))
comp_conv2d(conv2d, X).shape

2.2 步幅

在计算互相关时，我们默认每次滑动一个元素。 但是，有时候为了高效计算或是缩减采样次数，卷积窗口可以跳过中间位置，每次滑动多个元素。

输出形状公式：

$$\lfloor (n_h-k_h+p_h+s_h)/s_h\rfloor \times \lfloor (n_w-k_w+p_w+s_w)/s_w\rfloor .$$

其中，垂直步幅为$s_h$、水平步幅为$s_w$

三、多输入多输出通道

对于一个基于RGB模型的图像来说，其通常具有三个通道，本节将深入研究多输入多输出通道的卷积核。

3.1 多输入通道

对于多输入通道的图像，我们要构造与输入通道数相同数量的卷积核，且每个通道的卷积核分别于图像通道进行卷积运算最后再相加。具体如下：

举例：

import torch
from d2l import torch as d2l

def corr2d_multi_in(X, K):
    # 先遍历“X”和“K”的第0个维度（通道维度），再把它们加在一起
    return sum(d2l.corr2d(x, k) for x, k in zip(X, K))

X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
               [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])

corr2d_multi_in(X, K)

3.2 多输出通道

我们可以为每个输出通道创建一个卷积核张量，这样我们就可以输出多个通道。

def corr2d_multi_in_out(X, K):
    # 迭代“K”的第0个维度，每次都对输入“X”执行互相关运算。
    # 最后将所有结果都叠加在一起
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)

K = torch.stack((K, K + 1, K + 2), 0)
K.shape

torch.Size([3, 2, 2, 2])

corr2d_multi_in_out(X, K)

输出：

tensor([[[ 56.,  72.],
         [104., 120.]],

        [[ 76., 100.],
         [148., 172.]],

        [[ 96., 128.],
         [192., 224.]]])

3.3 1×1卷积层

因为使用了最小窗口，1×1卷积失去了卷积层的特有能力——在高度和宽度维度上，识别相邻元素间相互作用的能力。 其实1×1卷积的唯一计算发生在通道上。

1. 降低计算成本：1乘1卷积核可以减少特征图的通道数，从而减少后续卷积层所需的计算量。这对于在资源受限的设备上进行模型推断十分有用。

2. 增加非线性：在1乘1卷积核之后，可以添加激活函数，提供非线性变换能力。这有助于模型学习更复杂的特征表示。

3. 特征交互与整合：通过使用1乘1卷积核，可以在通道维度上对特征图进行组合和整合。这有助于捕捉不同通道之间的相关性，提高模型的表征能力。

四、汇聚层/池化层

通常我们卷积图像时，每个神经元对其敏感的感受野就越大。

而我们的机器学习任务通常会跟全局图像的问题有关，所以我们最后一层的神经元应该对整个输入的全局敏感。通过逐渐聚合信息，生成越来越粗糙的映射，最终实现学习全局表示的目标，同时将卷积图层的所有优势保留在中间层。

此外，当检测较底层的特征时（如边缘），们通常希望这些特征保持某种程度上的平移不变性。

本节将介绍汇聚（pooling）层，它具有双重目的：降低卷积层对位置的敏感性，同时降低对空间降采样表示的敏感性。

4.1 最大汇聚层与平均汇聚层

与卷积层类似，汇聚层运算符由一个固定形状的窗口组成，该窗口根据其步幅大小在输入的所有区域上滑动，为固定形状窗口（有时称为汇聚窗口）遍历的每个位置计算一个输出。

然而，不同于卷积层中的输入与卷积核之间的互相关计算，汇聚层不包含参数。 相反，池运算是确定性的，我们通常计算汇聚窗口中所有元素的最大值或平均值。这些操作分别称为最大汇聚层（maximum pooling）和平均汇聚层（average pooling）

手动定义一个向量：

X = torch.arange(16, dtype=torch.float32).reshape((1, 1, 4, 4))

tensor([[[[ 0.,  1.,  2.,  3.],
          [ 4.,  5.,  6.,  7.],
          [ 8.,  9., 10., 11.],
          [12., 13., 14., 15.]]]])

4.2 填充和步幅

默认情况下，深度学习框架中的步幅与汇聚窗口的大小相同。 因此，如果我们使用形状为(3, 3)的汇聚窗口，那么默认情况下，我们得到的步幅形状为(3, 3)。

pool2d = nn.MaxPool2d(3)
pool2d(X)


tensor([[[[10.]]]])

当然 也可以手动设定：

pool2d = nn.MaxPool2d((2,3), padding=1, stride=2)
pool2d(X)

4.3 多个通道

在处理多通道输入数据时，汇聚层在每个输入通道上单独运算，而不是像卷积层一样在通道上对输入进行汇总。 这意味着汇聚层的输出通道数与输入通道数相同。 下面，我们将在通道维度上连结张量X和X + 1，以构建具有2个通道的输入。

X = torch.cat((X, X + 1), 1)
X

tensor([[[[ 0.,  1.,  2.,  3.],
          [ 4.,  5.,  6.,  7.],
          [ 8.,  9., 10., 11.],
          [12., 13., 14., 15.]],

         [[ 1.,  2.,  3.,  4.],
          [ 5.,  6.,  7.,  8.],
          [ 9., 10., 11., 12.],
          [13., 14., 15., 16.]]]])
          
pool2d = nn.MaxPool2d(3, padding=1, stride=2)
pool2d(X)

tensor([[[[ 5.,  7.],
          [13., 15.]],

         [[ 6.,  8.],
          [14., 16.]]]])

五、卷积神经网络（LeNet）

本节将介绍LeNet，它是最早发布的卷积神经网络之一，因其在计算机视觉任务中的高效性能而受到广泛关注。

5.1 LeNet

总体来看，由两部分组成：

• 卷积编码器：由两个卷积层组成
• 全连接层密集块：由三个全连接层组成

架构如下：

pytorch实现：

1. 构造模型：

   import torch
   from torch import nn
   from d2l import torch as d2l
   
   net = nn.Sequential(
       nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),#输入通道数1  输出通道数为6  
       nn.AvgPool2d(kernel_size=2, stride=2),
       nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
       nn.AvgPool2d(kernel_size=2, stride=2),
       nn.Flatten(),
       nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
       nn.Linear(120, 84), nn.Sigmoid(),
       nn.Linear(84, 10))
   

5.2 模型训练

现在我们已经实现了LeNet，让我们看看LeNet在Fashion-MNIST数据集上的表现。

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)

def evaluate_accuracy_gpu(net, data_iter, device=None): #@save
    """使用GPU计算模型在数据集上的精度"""
    if isinstance(net, nn.Module):
        net.eval()  # 设置为评估模式
        if not device:
            device = next(iter(net.parameters())).device
    # 正确预测的数量，总预测的数量
    metric = d2l.Accumulator(2)
    with torch.no_grad():
        for X, y in data_iter:
            if isinstance(X, list):
                # BERT微调所需的（之后将介绍）
                X = [x.to(device) for x in X]
            else:
                X = X.to(device)
            y = y.to(device)
            metric.add(d2l.accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

#@save
def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):
    """用GPU训练模型(在第六章定义)"""
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)
    print('training on', device)
    net.to(device)
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=['train loss', 'train acc', 'test acc'])
    timer, num_batches = d2l.Timer(), len(train_iter)
    for epoch in range(num_epochs):
        # 训练损失之和，训练准确率之和，样本数
        metric = d2l.Accumulator(3)
        net.train()
        for i, (X, y) in enumerate(train_iter):
            timer.start()
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward()
            optimizer.step()
            with torch.no_grad():
                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
            timer.stop()
            train_l = metric[0] / metric[2]
            train_acc = metric[1] / metric[2]
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (train_l, train_acc, None))
        test_acc = evaluate_accuracy_gpu(net, test_iter)
        animator.add(epoch + 1, (None, None, test_acc))
    print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
          f'test acc {test_acc:.3f}')
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
          f'on {str(device)}')

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

六、深度卷积神经网络(AlexNet)

6.1 学习表征

在学习表征领域，传统的机器学习认为图像特征是机械的计算出来的，而现在认为特征也可以被学习。

有趣的是，在网络的最底层，模型学习到了一些类似于传统滤波器的特征抽取器。 图是从AlexNet论文 (Krizhevsky et al., 2012)复制的，描述了底层图像特征。

深度卷积神经网络的突破出现在2012年。突破可归因于两个关键因素：

1. 缺少的成分：数据
2. 缺少的成分：硬件

6.2 AlexNet

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

左图是LeNet架构 右图是AlexNet架构。

AlexNet和LeNet的设计理念非常相似，但也存在显著差异。

• AlexNet比相对较小的LeNet5要深得多。AlexNet由八层组成：五个卷积层、两个全连接隐藏层和一个全连接输出层。

• AlexNet使用ReLU而不是sigmoid作为其激活函数。

下面的内容将深入研究AlexNet的细节。

6.2.1 模型设计

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

6.2.2 激活函数

此外，AlexNet将sigmoid激活函数改为更简单的ReLU激活函数。
优点：

1. ReLU激活函数的计算更简单，它不需要如sigmoid激活函数那般复杂的求幂运算。
2. 当使用不同的参数初始化方法时，ReLU激活函数使训练模型更加容易。

6.2.3 容量控制和预处理

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

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))

6.2.4 读取数据集

由于AlexNet的输入图像时224×224，所以为了能够在Fashion-MNIST数据集上使用，我们缩放数据集。

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

6.2.5 训练AlexNet

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

6.3 小结

• AlexNet的架构与LeNet相似，但使用了更多的卷积层和更多的参数来拟合大规模的ImageNet数据集。

• 今天，AlexNet已经被更有效的架构所超越，但它是从浅层网络到深层网络的关键一步。

• 尽管AlexNet的代码只比LeNet多出几行，但学术界花了很多年才接受深度学习这一概念，并应用其出色的实验结果。这也是由于缺乏有效的计算工具。

• Dropout、ReLU和预处理是提升计算机视觉任务性能的其他关键步骤。

七、使用块的网络（VGG）

虽然AlexNet证明深层神经网络卓有成效，但它没有提供一个通用的模板来指导后续的研究人员设计新的网络。 在下面，我们将介绍一些常用于设计深层神经网络的启发式概念。

7.1 VGG块

经典的CNN的基本组成部分是这样的：

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

VGG块与之类似，下面我们定义一个VGG块：

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


def vgg_block(num_convs, in_channels, out_channels):
    layers = []
    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)

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

7.2 VGG网络

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

对于每个VGG块，有超参数变量conv_arch控制,该变量指定了每个VGG块的卷积层与输出通道数。

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

超参数变量为：

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

构建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)

7.3 训练模型

为了简便期间，我们在VGG-11上构建一个通道数较少的网络。

ratio = 4
small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch]  #通道数减为四分之一
net = vgg(small_conv_arch)

设置超参数并训练

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())

八、网络中的网络(NIN)

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

8.1 NiN块

NiN的想法是在每个像素位置（针对每个高度和宽度）应用一个全连接层。 如果我们将权重连接到每个空间位置，我们可以将其视为1×1卷积层，或作为在每个像素位置上独立作用的全连接层。 从另一个角度看，即将空间维度中的每个像素视为单个样本，将通道维度视为不同特征（feature）。

NiN块以一个普通卷积层开始，后面是两个1×1的卷积层。这两个1×1卷积层充当带有ReLU激活函数的逐像素全连接层。 第一层的卷积窗口形状通常由用户设置。 随后的卷积窗口形状固定为。

定义NIN块：

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())

8.2 NiN模型

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())

8.3 训练模型

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())

九、含并行连结的网络（GoogLeNet）

GoogLeNet吸收了NiN中串联网络的思想，并在此基础上做了改进，解决了什么样大小的卷积核最合适的问题。

9.1 Inception块

在GoogLeNet中，基本的卷积块被称为Inception块（Inception block）。

实现代码：

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)

9.2 GoogLeNet模型

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

• 第一个模块使用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))
  

• 第二个模块使用两个卷积层：第一个卷积层是64个通道、1×1卷积层；第二个卷积层使用将通道数量增加三倍的3×3卷积层。 这对应于Inception块中的第二条路径。

  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))
  

• 第三个模块串联两个完整的Inception块。

  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))
  

• 第四模块更加复杂， 它串联了5个Inception块。

  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))
  

• 第五模块包含两个Inception块。

  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))
  

9.3 训练模型

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())

十、批量归一化

随着神经网络的层数越多，出现了很多问题，比如：

• 损失出现在最后，后面的层训练较快
• 数据再最底部
  • 底部的层训练较慢
  • 底部层一变换，所有都得跟着变
  • 最后的哪些层需要重新学习多次
  • 导致收敛变慢

我们可以在学习底部层的时候避免变换顶部层吗？具体我们可以采用批量归一化的方法来进行解决。

批量运算公式：
$$\mathrm{BN}(\mathbf{x})=\mathbf{\gamma }\odot \frac{\mathbf{x}-{\hat{\mathbf{\mu }}}_{\mathcal{B}}}{{\hat{\mathbf{\sigma }}}_{\mathcal{B}}}+\mathbf{\beta }.$$

其中，${\hat{\mathbf{\mu }}}_{\mathcal{B}}$是小批量$\mathcal{B}$的样本均值，${\hat{\mathbf{\sigma }}}_{\mathcal{B}}$是小批量$\mathcal{B}$的样本标准差。 应用标准化后，生成的小批量的平均值为0和单位方差为1。 由于单位方差（与其他一些魔法数）是一个主观的选择，因此我们通常包含 拉伸参数（scale）$\mathbf{\gamma }$和偏移参数（shift）$\mathbf{\beta }$，它们的形状与$\mathbf{x}$相同。 请注意，$\mathbf{\gamma }$和$\mathbf{\beta }$是需要与其他模型参数一起学习的参数。

均值以及方差的计算：

$$\begin{array}{r}\begin{array}{rl}{\hat{\mathbf{\mu }}}_{\mathcal{B}}& =\frac{1}{|\mathcal{B}|}\sum _{\mathbf{x}\in \mathcal{B}}\mathbf{x},\\ {\hat{\mathbf{\sigma }}}_{\mathcal{B}}^2& =\frac{1}{|\mathcal{B}|}\sum _{\mathbf{x}\in \mathcal{B}}(\mathbf{x}-{\hat{\mathbf{\mu }}}_{\mathcal{B}}{)}^2+ϵ.\end{array}\end{array}$$

10.1 批量规范化层

10.1.1 全连接层

对于全连接层的批量化公式为：

$$\mathbf{h}=\varphi (\mathrm{BN}(\mathbf{Wx}+\mathbf{b})).$$

其中，BN表示批量归一化运算。

10.1.2 卷积层

对于卷积层，我们可以在卷积层之后和非线性激活函数之前进行批量规范化。
当卷积有多个输出通道时，我们需要对这些通道的 “每个” 输出执行批量规范化，每个通道都有自己的拉伸（scale）和偏移（shift）参数，这两个参数都是标量。

10.1.3 预测过程中的批量规范化

预测过程中的批量规范化与训练过程中的批量规范化略有不同。在预测阶段，没有训练数据的小批量可供使用，因此无法计算小批量的均值和方差。为了解决这个问题，通常会使用在训练过程中计算得到的均值和方差的移动平均值来进行规范化。

具体而言，在训练过程中，每个批次的均值和方差会被计算，并用于对当前批次的数据进行规范化。然后，这些均值和方差会持续地进行指数移动平均，以得到整个训练集上的均值和方差的近似值。在预测过程中，使用这些近似的均值和方差对输入数据进行规范化，以保持模型的性能和稳定性。

总结起来，预测过程中的批量规范化使用在训练过程中计算得到的移动平均均值和方差来对输入数据进行规范化，以保持模型的性能和稳定性。这样可以使得在预测阶段获得与训练阶段相似的性能。

10.2 从零实现

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

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)
        if len(X.shape) == 2:
            # 使用全连接层的情况，计算特征维上的均值和方差
            mean = X.mean(dim=0)
            var = ((X - mean) ** 2).mean(dim=0)
        else:
            # 使用二维卷积层的情况，计算通道维上（axis=1）的均值和方差。
            # 这里我们需要保持X的形状以便后面可以做广播运算
            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  # 缩放和移位
    return Y, moving_mean.data, moving_var.data

构建归一化层：

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):
        # 如果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

10.3 使用批量规范化层的LeNet

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时几乎完全相同，主要区别在于学习率大得多。

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.4 简明实现

除了使用我们刚刚定义的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实现。

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

十一、残差网络（ResNet）

着我们设计越来越深的网络，深刻理解“新添加的层如何提升神经网络的性能”变得至关重要。

11.1 残差块

结构如图：

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

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)

11.2 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))

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

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))

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

结构图：

11.3 训练模型

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())