《动手学深度学习》之现代卷积神经网络

旧城等待， 2022-09-12 07:48 184阅读 0赞

### 文章目录 ###

*  深度卷积神经网络（AlexNet）
 *   *  AlexNet
     *   *  模型设计
         *  激活函数
     *  核心网络代码
 *  使用块的网络（VGG）
 *   *  核心网络代码
 *  网络中的网络（NiN）
 *   *  核心网络代码
 *  含并行连结的网络（GoogLeNet）
 *   *  核心网络代码
 *  批量归一化
 *   *  训练深层网
     *  批量归一化层
     *   *  全连接层
         *  卷积层
 *  残差网络（ResNet）
 *   *  函数类
     *  残差块
     *  核心网络代码

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

训练神经网络的一些关键技巧的缺失，包括启发式参数初始化、随机梯度下降的巧妙变体、非挤压激活函数和有效的正则化技术。并且数据集仍然相对较小，不足以开发出有大量参数的深层多通道多层卷积神经网络。

## AlexNet ##

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

*  首先，AlexNet比相对较小的LeNet5要深得多。AlexNet由八层组成：五个卷积层、两个全连接隐藏层和一个全连接输出层。
 *  其次，AlexNet使用ReLU而不是sigmoid作为其激活函数。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16]

### 模型设计 ###

*  在AlexNet的第一层，卷积窗口的形状是  11 × 11 11\\times11 11×11。
 *  第二层中的卷积窗口形状被缩减为  5 × 5 5\\times5 5×5，然后是  3 × 3 3\\times3 3×3。
 *  此外，在第一层、第二层和第五层卷积层之后，加入窗口形状为  3 × 3 3\\times3 3×3、步幅为2的最大汇聚层。
 *  最后一个卷积层后有两个全连接层，分别有4096个输出。

### 激活函数 ###

AlexNet将sigmoid激活函数改为更简单的ReLU激活函数。

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

当sigmoid激活函数的输出非常接近于0或1时，这些区域的梯度几乎为0，因此反向传播无法继续更新一些模型参数。相反，ReLU激活函数在正区间的梯度总是1。  
因此，如果模型参数没有正确初始化，sigmoid函数可能在正区间内得到几乎为0的梯度，从而使模型无法得到有效的训练。

## 核心网络代码 ##

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

# 使用块的网络（VGG） #

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

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

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

VGG 网络可以分为两部分：

*  第一部分主要由卷积层和汇聚层组成
 *  第二部分由全连接层组成

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16 1]

## 核心网络代码 ##

# 定义vgg块
    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-11网络
    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))

# 网络中的网络（NiN） #

LeNet、AlexNet 和 VGG 都有一个共同的设计模式：

*  通过一系列的卷积层与汇聚层来提取空间结构特征；
 *  然后通过全连接层对特征的表征进行处理。

AlexNet 和 VGG 对 LeNet 的改进主要在于如何扩大和加深这两个模块。

*网络中的网络* (**NiN**) 提供了一个非常简单的解决方案：在每个像素的通道上分别使用多层感知机 。

**卷积层**的输入和输出由**四维张量**组成，张量的每个轴分别对应样本、通道、高度和宽度。

**全连接层**的输入和输出通常是分别对应于样本和特征的**二维张量**。

\*\*NiN \*\*的想法是在每个像素位置（针对每个高度和宽度）应用一个全连接层。即将空间维度中的每个像素视为单个样本，将通道维度视为不同特征（feature）。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16 2]

## 核心网络代码 ##

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

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

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16 3]

Inception块由四条并行路径组成。

*  前三条路径使用窗口大小为  1 × 1 1\\times 1 1×1、 3 × 3 3\\times 3 3×3 和  5 × 5 5\\times 5 5×5 的卷积层，从不同空间大小中提取信息。
 *  中间的两条路径在输入上执行  1 × 1 1\\times 1 1×1 卷积，以减少通道数，从而降低模型的复杂性。
 *  第四条路径使用  3 × 3 3\\times 3 3×3 最大汇聚层，然后使用  1 × 1 1\\times 1 1×1 卷积层来改变通道数。

这四条路径都使用合适的填充来使输入与输出的高和宽一致，最后我们将每条线路的输出在通道维度上连结，并构成Inception块的输出。在Inception块中，通常调整的**超参数**是每层输出通道的数量。

**GoogLeNet** 一共使用 9 个Inception块和全局平均汇聚层的堆叠来生成其估计值。Inception块之间的最大汇聚层可降低维度。

第一个模块类似于 AlexNet 和 LeNet，Inception块的栈从VGG继承，全局平均汇聚层避免了在最后使用全连接层。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_17_color_FFFFFF_t_70_g_se_x_16]

## 核心网络代码 ##

class Inception(nn.Module):
        # `c1`--`c4` 是每条路径的输出通道数
        def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
            super(Inception, self).__init__(**kwargs)
            # 线路1，单1 x 1卷积层
            self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
            # 线路2，1 x 1卷积层后接3 x 3卷积层
            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，1 x 1卷积层后接5 x 5卷积层
            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，3 x 3最大汇聚层后接1 x 1卷积层
            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)
    
    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.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))

# 批量归一化 #

## 训练深层网 ##

络

为什么需要批量归一化层呢？

*  首先，数据预处理的方式通常会对最终结果产生巨大影响。
 *  第二，对于典型的多层感知机或卷积神经网络。
 *  第三，更深层的网络很复杂，容易过拟合。

**批量归一化**应用于单个可选层（也可以应用到所有层），其原理如下：

在每次训练迭代中，我们首先归一化输入，即通过减去其均值并除以其标准差，其中两者均基于当前小批量处理。接下来，我们应用比例系数和比例偏移。

从形式上来说，用  x ∈ B \\mathbf\{x\} \\in \\mathcal\{B\} x∈B 表示一个来自小批量  B \\mathcal\{B\} B 的输入，批量归一化  B N \\mathrm\{BN\} BN 根据以下表达式转换  x \\mathbf\{x\} x：

B N ( x ) = γ ⊙ x − μ ^ B σ ^ B + β . \\mathrm\{BN\}(\\mathbf\{x\}) = \\boldsymbol\{\\gamma\} \\odot \\frac\{\\mathbf\{x\} - \\hat\{\\boldsymbol\{\\mu\}\}\_\\mathcal\{B\}\}\{\\hat\{\\boldsymbol\{\\sigma\}\}\_\\mathcal\{B\}\} + \\boldsymbol\{\\beta\}. BN(x)=γ⊙σ^Bx−μ^B\+β.  
 μ ^ B \\hat\{\\boldsymbol\{\\mu\}\}\_\\mathcal\{B\} μ^B 是样本均值， σ ^ B \\hat\{\\boldsymbol\{\\sigma\}\}\_\\mathcal\{B\} σ^B 是小批量  B \\mathcal\{B\} B 的样本标准差。*拉伸参数*（scale）  γ \\boldsymbol\{\\gamma\} γ 和 *偏移参数*（shift）  β \\boldsymbol\{\\beta\} β，它们的形状与  x \\mathbf\{x\} x 相同。

计算  μ ^ B \\hat\{\\boldsymbol\{\\mu\}\}\_\\mathcal\{B\} μ^B 和  σ ^ B \{\\hat\{\\boldsymbol\{\\sigma\}\}\_\\mathcal\{B\}\} σ^B，如下所示：

μ ^ B = 1 ∣ B ∣ ∑ x ∈ B x , σ ^ B 2 = 1 ∣ B ∣ ∑ x ∈ B ( x − μ ^ B ) 2 + ϵ . \\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\} μ^Bσ^B2=∣B∣1x∈B∑x,=∣B∣1x∈B∑(x−μ^B)2\+ϵ.

在方差估计值中添加一个小常量  ϵ > 0 \\epsilon > 0 ϵ>0，以确保我们永远不会尝试除以零。

## 批量归一化层 ##

批量归一化在完整的小批次上运行，因此我们不能像以前在引入其他图层时那样忽略批处理的尺寸大小。

### 全连接层 ###

通常，我们将批量归一化层置于全连接层中的仿射变换和激活函数之间。  
设全连接层的输入为 u ，权重参数和偏置参数分别为  W \\mathbf\{W\} W 和  b \\mathbf\{b\} b ，激活函数为  ϕ \\phi ϕ ，批量归一化的运算符为  B N \\mathrm\{BN\} BN 。

h = ϕ ( B N ( W x + b ) ) . \\mathbf\{h\} = \\phi(\\mathrm\{BN\}(\\mathbf\{W\}\\mathbf\{x\} + \\mathbf\{b\}) ). h=ϕ(BN(Wx\+b)).

### 卷积层 ###

对于卷积层，我们可以在卷积层之后和非线性激活函数之前应用批量归一化。

# 残差网络（ResNet） #

## 函数类 ##

![对于非嵌套函数类，较复杂（由较大区域表示）的函数类不能保证更接近“真”函数（  ）。这种现象在嵌套函数类中不会发生。][functionclasses.svg]

对于非嵌套函数类，较复杂（由较大区域表示）的函数类不能保证更接近“真”函数（ f∗ ）。这种现象在嵌套函数类中不会发生。

残差网络的**核心思想**是：每个附加层都应该更容易地包含原始函数作为其元素之一。

## 残差块 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
ResNet 沿用了 VGG 完整的 3×3 卷积层设计。

残差块里首先有 2 个有相同输出通道数的 3×3 卷积层。

每个卷积层后接一个批量归一化层和 ReLU 激活函数。

然后我们通过跨层数据通路，跳过这 2 个卷积运算，将输入直接加在最后的 ReLU 激活函数前。

## 核心网络代码 ##

class Residual(nn.Module):  
        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)
            self.relu = nn.ReLU(inplace=True)
    
        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)
            
    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
        
    net = nn.Sequential(b1, b2, b3, b4, b5,
                        nn.AdaptiveAvgPool2d((1,1)),
                        nn.Flatten(), nn.Linear(512, 10))

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/b4b50977b131493bb9d629a90d2dc8f1.png
[visualgeometry Group]: http://www.robots.ox.ac.uk/~vgg/
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/bec56aa7078d4329a978d706666eb75c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/cd762802692542a2ace74c20696d92b0.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/3cf8eddfe42647199a8dfa9311e3abe2.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_17_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/4932e647f5c74dd48b28cd514951df5a.png
[functionclasses.svg]: /images/20220828/ace4f42b47284c6fb48e0d980b8b5e02.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUXh3MTAxMg_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220828/8f2c14a67d374fcfbb268bf762402b1d.png