Datawhale X 李宏毅苹果书 AI夏令营向李宏毅学深度学习(进阶)Task3笔记

最新推荐文章于 2024-10-06 21:45:11 发布

Hh2767474144

最新推荐文章于 2024-10-06 21:45:11 发布

阅读量1.5k

点赞数 32

文章标签：人工智能深度学习笔记

本文链接：https://blog.csdn.net/Hh2767474144/article/details/141816938

版权

一. 批量归一化

如果误差表面很崎岖，它比较难训练。能不能直接改误差表面的地貌，“把山铲平”，让它变得比较好训练呢？批量归一化（Batch Normalization，BN）就是其中一个“把山铲平”的想法。不要小看优化这个问题，有时候就算误差表面是凸（convex）的，它就是一个碗的形状，都不一定很好训练。如图所示，假设两个参数对损失的斜率差别非常大，在 w1 这个方向上面，斜率变化很小，在 w2 这个方向上面斜率变化很大。

在这个线性的的模型里面，当输入的特征，每一个维度的值，它的范围差距很大的时候，我们就可能产生像这样子的误差表面，就可能产生不同方向，斜率非常不同，坡度非常不同的误差表面所以怎么办呢，有没有可能给特征里面不同的维度，让它有同样的数值的范围。如果我们可以给不同的维度，同样的数值范围的话，那我们可能就可以制造比较好的误差表面，让训练变得比较容易一点其实有很多不同的方法，这些不同的方法往往就合起来统称为特征归一化（feature normalization）。

以下所讲的方法只是特征归一化的一种可能性，即 Z 值归一化（Z-score normalization），也称为标准化（standardization）。它并不是特征归一化的全部，假设 x1 到 xR，是我们所有的训练数据的特征向量。我们把所有训练数据的特征向量，统统都集合起来。向量 x1 里面就x11 代表 x1 的第一个元素，x21 代表 x2 的第一个元素，以此类推。我们把不同笔数据即不同特征向量，同一个维度里面的数值，把它取出来，对于每个维度 i，计算其平均值（mean） mi和标准差（standard deviation）σi。接下来我们就可以做一种归一化。

归一化有个好处，做完归一化以后，这个维度上面的数值就会平均是 0，其方差是 1，所以这一排数值的分布就都会在 0 上下；对每一个维度都做一样的归一化，所有特征不同维度的数值都在 0 上下，可能就可以制造一个比较好的误差表面。所以像这样子的特征归一化方式往往对训练有帮助，它可以让在做梯度下降的时候，损失收敛更快一点，训练更顺利一点。

要考虑深度学习的话，可能需要多次进行归一化

这边就会有一个问题了，因为训练数据非常多，现在一个数据集可能有上百万笔数据，GPU 的显存无法把它整个数据集的数据都加载进去。因此，在实现的时候，我们不会让这一个网络考虑整个训练数据里面的所有样本，而是只会考虑一个批量里面的样本。比如批量设 64，这个网络就是把 64 笔数据读进去，计算这 64 笔数据的 µ,σ，对这 64 笔数据做归一化。因为实际实现的时候，只对一个批量里面的数据做归一化，所以技巧称为批量归一化。一定要有一个够大的批量，才算得出 µ,σ。所以批量归一化适用于批量大小比较大的时候，批量大小如果比较大，也许这个批量大小里面的数据就足以表示整个数据集的分布。这个时候就不需要对整个数据集做特征归一化，而改成只在一个批量上做特征归一化作为近似。

在做批量归一化的时候，如图所示，往往还会做如下操作：

其中，⊙ 代表逐元素的相乘。β, γ 可以想成是网络的参数，需要另外再被学习出来。

以上说的都是训练的部分，测试有时候又称为推断（inference）。在做批量归一化的时候，µ,σ 是用一个批量的数据算出来的。但如果在测试的时候，根本就没有批量，如何算 µ,σ 呢？所以真正的实现上的解法是这个样子的。批量归一化在测试的时候，并不需要做什么特别的处理，PyTorch 已经处理好了。在训练的时候，如果有在做批量归一化，每一个批量计算出来的 µ,σ，都会拿出来算移动平均（moving average）。假设现在有各个批量计算出来的 µ1, µ2, µ3, · · · · · · , µt，则可以计算移动平均

其中，µ¯ 是 µ 的个平均值，p 是因子，这也是一个常数，这也是一个超参数，也是需要调的那种。在 PyTorch 里面，p 设 0.1。计算滑动平均来更新 µ 的平均值。最后在测试的时候，就不用算批量里面的 µ 跟 σ 了。因为测试的时候，在真正应用上也没有批量，就可以就直接拿µ¯ 跟 σ¯ ，也就是 µ,σ 在训练的时候，得到的移动平均来取代原来的 µ 跟 σ，如下图所示，这就是批量归一化在测试的时候的运作方式。

为什么批量归一化会比较好呢，那在这篇“How Does Batch Normalization Help Optimization?”这篇论文从实验和理论上，至少支持批量归一化可以改变误差表面，让误差表面比较不崎岖这个观点。所以这个观点是有理论的支持，也有实验的佐证的。如果要让网络误差表面变得比较不崎岖，其实不一定要做批量归一化，还有很多其他的方法都可以让误差表面变得不崎岖，这篇论文就试了一些其他的方法，发现跟批量归一化表现也差不多，甚至还稍微好一点，这篇论文的作者也觉得批量归一化是一种偶然的发现，但无论如何，其是一个有用的方法。其实批量归一化不是唯一的归一化，还有很多归一化方法，比如批量重归一化（batchrenormalization）、层归一化（layer normalization）、实例归一化（instance normalization）、组归一化（group normalization）、权重归一化（weight normalization）和谱归一化（spectrum normalization）。

二. 卷积神经网络

卷积神经网络是一种非常典型的网络架构，常用于图像分类等任务,在其他非图像问题上可能会有较大误差。

所谓图像分类，就是给机器一张图像，由机器去判断这张图像里面有什么样的东西——是猫还是狗、是飞机还是汽车。怎么把图像当做模型的输入呢？对于机器，图像可以描述为三维张量（张量可以想成维度大于 2 的矩阵）。一张图像是一个三维的张量，其中一维代表图像的宽，另外一维代表图像的高，还有一维代表图像的通道（channel）的数目。

1. 检测模式不需要整张图像

人在判断一个物体的时候，往往是抓最重要的特征。看到这些特征以后，就会直觉地看到了某种物体。对于机器，也许这是一个有效的判断图像中物体的方法。但假设用神经元来判断某种模式是否出现，也许并不需要每个神经元都去看一张完整的图像，只需要将主要特征提取出来就可以。

2. 感受野

卷积神经网络会设定一个区域，即感受野（receptivefield），每个神经元都只关心自己的感受野里面发生的事情，感受野是由我们自己决定的。

感受野可以有大有小，因为模式有的比较小，有的比较大。有的模式也许在 3 × 3 的范围内就可以被检测出来，有的模式也许要 11 × 11 的范围才能被检测出来。此外，感受野可以只考虑某些通道。目前感受野是 RGB 三个通道都考虑，但也许有些模式只在红色或蓝色的通道会出现，即有的神经元可以只考虑一个通道。之后在讲到网络压缩的时候，会讲到这种网络的架构。感受野不仅可以是正方形的，例如刚才举的例子里面 3 × 3、11 × 11，也可以是长方形的，完全可以根据对问题的理解来设计感受野。但常见的感受野就是3 × 3，2个3 × 3相当于一个5 × 5。（感兴趣的可以了解一下VGG这篇论文，里面讲解了3 × 3感受野的好处）

感受野移动的量称为步幅（stride），超出范围就做填充（padding），填充就是补值，一般使用零填充（zero padding）。

3.同样的模式可能会出现在图像的不同区域

相同的特征可能在不同的图像中处于不同的位置，这个问题需要对于每一个感受野有一个专门的特征检测器。

4.共享参数

在图像处理上，则可以让不同感受野的神经元共享参数，也就是做参数共享（parameter sharing），如下图所示。所谓参数共享就是两个神经元的权重完全是一样的。

因为输入不一样的关系，所以就算是两个神经元共用参数，它们的输出也不会是一样的。所以这是第 2 个简化，让一些神经元可以共享参数，共享的方式完全可以自己决定。接下来将介绍图像识别方面，常见的共享方法是如何设定的。

如图 4.15 所示，每个感受野都有一组神经元在负责守备，比如 64 个神经元，它们彼此之间可以共享参数。图 4.16 中使用一样的颜色代表这两个神经元共享一样的参数，所以每个感受野都只有一组参数，就是上面感受野的第 1 个神经元会跟下面感受野的第 1 个神经元共用参数，上面感受野的第 2 个神经元跟下面感受野的第 2 个神经元共用参数 · · · · · · 所以每个感受野都只有一组参数而已，这些参数称为滤波器（filter）。这是第 2 个简化的方法。

5. 与其他概念联系

根据模型的灵活性可以分成以下关系：

6. 下采样不影响模式检测

下采样就是在对数据做汇聚。汇聚有很多不同的版本，以最大汇聚（max pooling）为例。最大汇聚在每一组里面选一个代表，选的代表就是最大的一个。除了最大汇聚，还有平均汇聚（mean pooling），平均汇聚是取每一组的平均值。

做完卷积以后，往往后面还会搭配汇聚。汇聚就是把图像变小。做完卷积以后会得到一张图像，这张图像里面有很多的通道。做完汇聚以后，这张图像的通道不变。

一般架构就是卷积加汇聚，汇聚是可有可无的，很多人可能会选择不用汇聚。如下图所示，如果做完几次卷积和汇聚以后，把汇聚的输出做扁平化（flatten），再把这个向量丢进全连接层里面，最终还要过个 softmax 来得到图像识别的结果。这就是一个经典的图像识别的网络，里面有卷积、汇聚和扁平化，最后再通过几个全连接层或 softmax 来得到图像识别的结果。

三. 实践任务进阶

采用VGG16模型进行优化，其模型如下

from torch import nn

class Vgg16_net(nn.Module):
    def __init__(self):
        super(Vgg16_net, self).__init__()


        self.layer1=nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,stride=1,padding=1), #(32-3+2)/1+1=32   32*32*64
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=64,out_channels=64,kernel_size=3,stride=1,padding=1), #(32-3+2)/1+1=32    32*32*64
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(kernel_size=2,stride=2)   #(32-2)/2+1=16         16*16*64
        )


        self.layer2=nn.Sequential(
            nn.Conv2d(in_channels=64,out_channels=128,kernel_size=3,stride=1,padding=1),  #(16-3+2)/1+1=16  16*16*128
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=128,out_channels=128,kernel_size=3,stride=1,padding=1), #(16-3+2)/1+1=16   16*16*128
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)    #(16-2)/2+1=8     8*8*128
        )

        self.layer3=nn.Sequential(
            nn.Conv2d(in_channels=128,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),


            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)     #(8-2)/2+1=4      4*4*256
        )

        self.layer4=nn.Sequential(
            nn.Conv2d(in_channels=256,out_channels=512,kernel_size=3,stride=1,padding=1),  #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)    #(4-2)/2+1=2     2*2*512
        )

        self.layer5=nn.Sequential(
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(2-3+2)/1+1=2    2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),  #(2-3+2)/1+1=2     2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),  #(2-3+2)/1+1=2      2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)   #(2-2)/2+1=1      1*1*512
        )


        self.conv=nn.Sequential(
            self.layer1,
            self.layer2,
            self.layer3,
            self.layer4,
            self.layer5
        )

        self.fc=nn.Sequential(
            nn.Linear(512,512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),

            nn.Linear(512,256),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),

            nn.Linear(256,10)
        )


    def forward(self,x):
        x=self.conv(x)
        x = x.view(-1, 512)
        x=self.fc(x)
        return x