深度学习—— 7 现代卷积神经网络
深度学习—— 7 现代卷积神经网络
可爱可倾7 现代卷积神经网络
7.1 深度卷积神经网络（AlexNet）
从LeNet到AlexNet的变化如下图所示：
图7.1：LeNet（左）和 AlexNet（右）的设计。
- AlexNet比相对较小的LeNet5要深得多。AlexNet由八层组成：五个卷积层、两个全连接隐藏层和一个全连接输出层。
- AlexNet使用ReLU而不是sigmoid作为其激活函数。
- AlexNet的架构与LeNet相似，但使用了更多的卷积层和更多的参数来拟合大规模的ImageNet数据集。
- Dropout、ReLU和预处理是提升计算机视觉任务性能的其他关键步骤。
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))7.2 使用块的网络（VGG）
与AlexNet、LeNet一样，VGG网络可以分为两部分：第一部分主要由卷积层和汇聚层组成，第二部分由全连接层组成。 从AlexNet到VGG，它们本质上都是块设计，如下图所示：
图7.2：VGG块结构
# VGG块(num_convs个卷积层 + 1个用于空间下采样的最大汇聚层)
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)
# 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))
conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512)) # 指定卷积层个数和输出通道数
net = vgg(conv_arch)7.3 网络中的网络（NiN）
在每个像素位置（针对每个高度和宽度）应用一个全连接层，NiN块以一个普通卷积层开始，后面是两个\(1 \times 1\)的卷积层。这两个\(1 \times 1\)卷积层充当带有ReLU激活函数的逐像素全连接层。 第一层的卷积窗口形状通常由用户设置。 随后的卷积窗口形状固定为\(1 \times 1\)。如图所示：
图7.3：对比 VGG 和 NiN 及它们的块之间主要架构差异
- NiN使用由一个卷积层和多个\(1 \times 1\)卷积层组成的块。该块可以在卷积神经网络中使用，以允许更多的每像素非线性。
- NiN去除了容易造成过拟合的全连接层，将它们替换为全局平均汇聚层（即在所有位置上进行求和）。该汇聚层通道数量为所需的输出数量（例如，Fashion-MNIST的输出为10）。
- 移除全连接层可减少过拟合，同时显著减少NiN的参数。
- NiN设计的一个优点是，它显著减少了模型所需参数的数量。然而，在实践中，这种设计有时会增加训练模型的时间。
# NiN块 (1个普通卷积层 + 2个1x1卷积层)
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网络
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())7.4 含并行连结的网络（GoogLeNet）
GoogLeNet吸收了NiN中串联网络的思想，重点是解决了什么样大小的卷积核最合适的问题。本文的一个观点是，有时使用不同大小的卷积核组合是有利的。 Inception块相当于一个有4条路径的子网络。它通过不同窗口形状的卷积层和最大汇聚层来并行抽取信息，并使用\(1 \times 1\)卷积层减少每像素级别上的通道维数从而降低模型复杂度。
最基本的卷积块叫作Inception块，如下图所示：
图7.4：Inception块的结构
- 由四条并行路径组成，前三条路径使用窗口大小为\(1\times 1\)、\(3\times 3\)和\(5\times 5\)的卷积层，来抽取不同空间尺寸下的信息，其中中间两条路径会对输入先做\(1\times 1\)卷积来减少输入通道数，以降低模型复杂度。
- 第四条路径使用\(3\times 3\)最大汇聚层，后接\(1\times 1\)卷积层来改变通道数。
- 这四条路径都使用合适的填充来使输入与输出的高和宽一致。
- 最后我们将每条线路的输出在通道维上连结，并输入接下来的层中去。
# Inception块
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，如下图所示：
图7.5：GoogLeNet网络设计
- Inception块之间的最大汇聚层可降低维度
- 第一个模块类似于AlexNet和LeNet
- Inception块的组合从VGG继承
- 全局平均汇聚层避免了在最后使用全连接层
# GoogLeNet
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))7.5 批量规范化
- 在模型训练过程中，批量规范化利用小批量的均值和标准差，不断调整神经网络的中间输出，使整个神经网络各层的中间输出值更加稳定。
- 批量规范化在全连接层和卷积层的使用略有不同。
- 批量规范化层和暂退层一样，在训练模式和预测模式下计算不同。
7.5.1 原理
原理: 在每次训练迭代中，我们首先规范化输入，即通过减去其均值并除以其标准差，其中两者均基于当前小批量处理。 接下来，我们应用比例系数和比例偏移。 可以用于加速深度网络的收敛速度，同时避免中间层的变化幅度过于剧烈。
用\(\mathbf{x} \in \mathcal{B}\)表示一个来自小批量\(\mathcal{B}\)的输入样本，批量规范化\(\mathrm{BN}\)根据以下等式转换\(\mathbf{x}\):
\[ \mathrm{BN}(\mathbf{x}) = \boldsymbol{\gamma} \odot \frac{\mathbf{x} - \hat{\boldsymbol{\mu}}_\mathcal{B}}{\hat{\boldsymbol{\sigma}}_\mathcal{B}} + \boldsymbol{\beta} \tag{7.1} \]
其中\(\hat{\boldsymbol{\mu}}_\mathcal{B}\)是小批量\(\mathcal{B}\)的均值，\(\hat{\boldsymbol{\sigma}}_\mathcal{B}\)是小批量的标准差。应用标准化后，生成的小批量的平均值为0和单位方差为1。 由于单位方差是一个主观的选择，因此我们通常包含 拉伸参数（scale）\(\boldsymbol{\gamma}\) 和 偏移参数（shift）\(\boldsymbol{\beta}\)，它们的形状与\(\mathbf{x}\)相同。 请注意，\(\boldsymbol{\gamma}\)和\(\boldsymbol{\beta}\)是需要与其他模型参数一起学习的参数。
\[ \begin{split}\begin{aligned} \hat{\boldsymbol{\mu}}_\mathcal{B} &= \frac{1}{|\mathcal{B}|} \sum_{\mathbf{x} \in \mathcal{B}} \mathbf{x},\\ \hat{\boldsymbol{\sigma}}_\mathcal{B}^2 &= \frac{1}{|\mathcal{B}|} \sum_{\mathbf{x} \in \mathcal{B}} (\mathbf{x} - \hat{\boldsymbol{\mu}}_{\mathcal{B}})^2 + \epsilon.\end{aligned}\end{split} \tag{7.2} \]
7.5.2 批量规范化层
批量规范化和其他层之间的一个关键区别是，由于批量规范化在完整的小批量上运行，因此我们不能像以前在引入其他层时那样忽略批量大小
全连接层: 将批量规范化层置于全连接层中的仿射变换和激活函数之间。\(\mathbf{h} = \phi(\mathrm{BN}(\mathbf{W}\mathbf{x} + \mathbf{b}) )\) 卷积层: 在卷积层之后和非线性激活函数之前应用批量规范化。当卷积有多个输出通道时，我们需要对这些通道的“每个”输出执行批量规范化，每个通道都有自己的拉伸（scale）和偏移（shift）参数，这两个参数都是标量。 预测过程中的批量规范化: 一种常用的方法是通过 移动平均估 算整个训练数据集的样本均值和方差，并在预测时使用它们得到确定的输出。
# 使用批量规范化层的 LeNet
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))7.6 残差网络（ResNet）
残差网络的核心思想是：每个附加层都应该更容易地包含原始函数作为其元素之一。在残差块中，输入可通过跨层数据线路更快地向前传播。 残差网络能够解决深度神经网络中的梯度消失问题，允许构建更深的网络。 如图所示：
图7.6：一个正常块（左图）和一个残差块（右图）
如果想改变通道数，就需要引入一个额外的\(1 \times 1\)卷积层来将输入变换成需要的形状后再做相加运算，如下图所示：
图7.7：不包含和包含通道变换的残差块
7.7 稠密连接网络（DenseNet）
- 在跨层连接上，不同于ResNet中将输入与输出相加，稠密连接网络（DenseNet）在通道维上连结输入与输出。
- DenseNet的主要构建模块是稠密块和过渡层。
- 前者定义如何连接输入和输出，而后者则控制通道数量，使其不会太复杂。
可以缓解梯度消失问题和强化特征传播，还可以减少参数数量等。
ResNet（左）与 DenseNet（右）在跨层连接上的主要区别如下图所示：
图7.8：ResNet与DenseNet在跨层连接上的主要区别: 使用相加和使用连结
将ResNet的 \(f(x)=x+g(x)\) (一个简单的线性项和一个复杂的非线性项) 拓展成超过两部分的信息 \(\mathbf{x} \to \left[\mathbf{x},f_1(\mathbf{x}), f_2([\mathbf{x}, f_1(\mathbf{x})]), f_3([\mathbf{x}, f_1(\mathbf{x}), f_2([\mathbf{x}, f_1(\mathbf{x})])]), \ldots\right]\)
最后一层与之前的所有层紧密相连，如图所示：
图7.9：稠密连接
