VGG

2022-07-01

一、VGG网络的背景

AlexNet问世之后，很多学者通过改进AlexNet的网络结构来提高自己的准确率，主要有两个方向：小卷积核和多尺度。

而VGG的作者们则选择了另外一个方向，即加深网络深度。

VGGNet的网络结构简单、规整且高效。VGGNet较为典型的网络结构主要有VGG16和VGG19（两者并没有本质上的区别，只是网络深度不一样）。

二、VGG网络结构

1、各网络结构参数图示

接下来以VGG16为例子来进行讲解

2、输入

（224，224，3）的RGB图像作为输入

3、双层 —— 一层卷积+（一层卷积+最大池化）

这里总共4层。

都是使用卷积核为（3，3）的卷积层，每过一层（不含池化）尺寸不变，每过一层池化尺寸减半。

因此（224，224，3）->（224，224，64）->（112，112，64）->（112，112，128）->（56，56，128）

4、三层 —— 两层卷积+（一层卷积+最大池化）

这里总共9层。

因此（56，56，128）-> （56，56，256）-> （28，28，256）-> （28，28，512）-> （14，14，512）-> （7，7，512）

5、全连接层——分类判决

6、拓展：VGG16_bn —— Batch Normalization

就是在提取特征的每一层多加了BatchNorm2d层。

通常来说，数据标准化预处理对于浅层模型来说就够了（使得输入数据在各个特征的分布相近，往往更容易训练出有效的模型），但对于深层模型来说，训练中模型参数的更新依然很容易造成靠近输出层输出的剧烈变化，这种不稳定性难以让我们训练出有效的深度模型。

因此，批量归一化应运而生。

BatchNorm2d层的作用是：进行批量标准化处理（对于所有的batch中样本的同一个channel的数据元素进行标准化处理，即如果有C个通道，无论batch中有多少个样本，都会在通道维度上进行标准化处理，一共进行C次。），这样能把输入的数限制在一个范围内，把数据重新变为正态分布。
公式：

$\hat{x}=\frac{x-\operatorname{mean}[x]}{\sqrt{\operatorname{Var}[x]+e p s}} * \gamma+\beta$

而上面的可训练参数（拉伸 $\gamma$ 和偏移 $\beta$ )也可以根据学习得到不一样的结果，甚至可以不使用批量归一化（

$\gamma =\sqrt{var(x)+eps}, \beta = mean(x)$

上面所说的是训练时的批量归一化，而在预测时的批量归一化则通常使用移动平均估算整个训练数据集的样本均值和方差，并使用它们得到确定的输出。

（Note：使用批量归一化训练时可以把批量大小设得大一些，从而使批量内样本的均值和方差的计算都较为准确。）

具体结构如下：

三、VGG网络的亮点——连续小卷积核代替大卷积核

采用连续的几个3x3的卷积核代替AlexNet中的较大卷积核（11x11，7x7，5x5）

对于给定的感受野，采用堆积的小卷积核是优于采用大的卷积核，因为多层非线性层（3个33卷积附带3个ReLU，而一个77卷积只附带一个ReLU）可以增加网络深度来保证学习更复杂的模式，而且代价还比较小（参数更少）。

在VGG中，使用了3个3x3卷积核来代替7x7卷积核，使用了2个3x3卷积核来代替5*5卷积核，这样可以在保证具有相同感知野的条件下，提升了网络的深度，在一定程度上提升了神经网络的效果。

替代原因：

如图所示，最上面的那个特征最终是由下面55的特征得到的，这样的效果跟一层55卷积的效果一样。

参数：332<5*5

四、VGG网络的不足

耗费更多计算资源，并且使用了更多的参数（这里不是因为多层3x3卷积），导致更多的内存占用。其中绝大多数的参数都是来自于第一个全连接层。

五、VGG代码实现

这里只展示模型架构。

import torch
import torch.nn as nn
 
class VGG(nn.Module):
    def __init__(self):
          super().__init__()
 
          self.features = nn.Sequential(
            nn.Conv2d(3,64,(3,3),padding=1),
            nn.ReLU(),
            nn.Conv2d(64,64,(3,3),padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2,2),
            nn.Conv2d(64,128,(3,3),padding=1),
            nn.ReLU(),
            nn.Conv2d(128,128,(3,3),padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2,2),
            nn.Conv2d(128,256,(3,3),padding=1),
            nn.ReLU(),
            nn.Conv2d(256,256,(3,3),padding=1),
            nn.ReLU(),
            nn.Conv2d(256,256,(3,3),padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2,2),
            nn.Conv2d(256,512,(3,3),padding=1),
            nn.ReLU(),
            nn.Conv2d(512,512,(3,3),padding=1),
            nn.ReLU(),
            nn.Conv2d(512,512,(3,3),padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2,2),
            nn.Conv2d(512,512,(3,3),padding=1),
            nn.ReLU(),
            nn.Conv2d(512,512,(3,3),padding=1),
            nn.ReLU(),
            nn.Conv2d(512,512,(3,3),padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2,2)
          )
          self.classifier = nn.Sequential(
            nn.Linear(25088,4096),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(4096,4096),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(4096,1000)
          )
    
    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x

展开全文 >>

LSTM

2022-07-01

LSTM

LSTM(Long Short-Term Memory)是长短期记忆网络，是一种时间递归神经网络，适合于处理和预测时间序列中间隔和延迟相对较长的重要事件。

LSTM是RNN的一种，可以解决RNN短时记忆的不足，当一条序列足够长，那RNN将很难将信息从较早的时间步传送到后面的时间步，而LSTM能学习长期依赖的信息，记住较早时间步的信息，因此可以做到联系上下文。

STM区别于RNN的地方，主要就在于它在算法中加入了一个判断信息有用与否的”处理器”，这个处理器作用的结构被称为cell。

一个cell当中被放置了三扇门，分别叫做输入门、遗忘门和输出门。一个信息进入LSTM的网络当中，可以根据规则来判断是否有用。只有符合算法认证的信息才会留下，不符的信息则通过遗忘门被遗忘。

符号说明：

$x_{t}$ :当前时刻输入信息

$h_{t-1}$ :上一时刻的隐藏状态

$h_{t}$ :传递到下一时刻的隐藏状态

$\sigma$ :sigmoid函数，通过这个函数可以将数据变为0-1范围的数值。

tanh: tanh函数，通过这个函数可以将数据变为[-1,1]范围的数值

LSTM的特点：

lstm比rnn多一个细胞状态（cell state），也有人叫记忆细胞。

下图中的水平黑线表示上一时刻的细胞状态通过三个门的控制及线性运算来决定哪些信息该遗忘丢弃，哪些信息该保留，或者不变，从而生成当前时刻的细胞状态，然后输出到下一时刻，以此来进行记忆的更新。

这只是某个时刻的细胞状态的更新过程，在整个长序列中，每个时刻的细胞状态都对上一时刻的信息选择性的进行遗忘丢弃，或者保留，或者不变，对记忆进行更新，从传送到，因此可以做到长期记忆。

0.什么是门？

LSTM通过门（gate）来控制细胞状态遗忘或添加记忆，门的结构就是一个sigmoid层再点乘上一时刻的细胞状态，下图就是一个门。

sigmoid层输出的值范围在[0, 1]，可以作为门控信号，0点乘任何值还是0，表示过不去，这些记忆就遗忘了，1表示可以通过，记忆就保留下来了。

1. 遗忘门

遗忘门的作用对象是细胞状态 $C_{t-1}$ ，作用是控制细胞状态中的信息进行选择性的遗忘，决定哪部分需要丢弃，哪些需要保留。那么是如何控制细胞状态选择性遗忘记忆的呢，我们结合公式来看:

遗忘门的公式：

权重矩阵 $W_{f}$ 对 $h_{t-1}$ 和 $x_{t}$ 拼接而成的矩阵进行矩阵相乘，再加上偏置 $b_{f}$ ，投入到sigmoid函数中，得到一个与 $C_{t-1}$ 相同维度的矩阵 $f_{t}$ ，比如，得到 $f_{t}$ 为[ 0,0,1,0]，矩阵中每一个值都决定 $C_{t-1}$ 中对应信息的遗忘或保留，0代表彻底丢弃，1代表完全保留。

比如一个语言模型，根据之前的所有词预测下一个词。细胞状态可能已经记住了当前人物的性别，以便下次预测人称代词（他还是她），但当出现一个新人物时，需要将上一个人物的性别忘掉。

举例：

小明是一个帅气的男生，小美喜欢…，当处理到‘’小美‘’的时候，需要选择性的忘记前面的’小明’，或者说减小这个词对后面词的作用。

2.输入门

输入门的作用对象也是细胞状态，作用是决定要往细胞状态中存储哪些新的信息，也就是细胞状态选择性的添加哪些新的记忆。那么如何决定添加哪些新的信息呢，输入门分两个部分进行。

第一部分：

构建一个输入门，决定哪些信息被添加到细胞状态中，作为新的记忆。

输入门公式：

与遗忘门公式差不多，输入门通过线性运算得到一个与 $\tilde{C}_{t}$ 相同维度的矩阵 $i_{t}$ ，比如，得到 $i_{t}$ 为 [ 0,0,1,0]，矩阵中每一个值都决定 $\tilde{C}_{t}$ 中对应信息的丢弃或保留，0代表彻底丢弃，1代表完全保留。

第二部分：

构建出一个候选细胞状态 $\tilde{C}_{t}$ ，它保存了 $x_{t}$ 和 $h_{t-1}$ 中的信息，然后与 $i_{t}$ 的值点乘，来决定哪些记忆是有用的，依然 $i_{t}$ 中0代表彻底丢弃，1代表完全保留，这样保留下来的信息作为新的记忆添加给新的细胞状态，所以这里 $\tilde{C}_{t}$ 叫候选细胞状态，它只是一个等候选择的，有用的才会被作为新记忆添加。

候选细胞状态 $\tilde{C}_{t}$ 的公式：

接着上一个例子：

这一步传入了一些信息，比如小美喜欢穿裙子，输入门就是要在这些信息中筛选出来有用的，用来记住新人物的性别，记住小美的性别为女，作为新的记忆添加。

3.更新记忆

新的细胞状态中的记忆由两部分构成。

一部分是，上一时刻的记忆细胞遗忘掉没用的记忆后剩下的旧记忆

另一部分是，输入门中把有用的信息筛选出来当作新的记忆

新的细胞状态的公式：

$f_{t}$ 点乘 $C_{t-1}$ 表示处理后的旧记忆， $i_{t}$ 点乘 $\tilde{C}_{t}$ 表示需要添加的新记忆，加起来就是新的细胞状态。

继续举例：

小明是一个帅气的男生，小美喜欢穿裙子，这一步是要忘记小明性别为男，记住小美性别为女。

4.输出门

输出门的作用是决定最终输出什么，也就是 $h_{t}$ ，这个输出是以新的细胞状态 $C_{t}$ 为基础的，分两部分进行。

第一部分：

依然使用sigmoid层来得到 $o_{t}$ ，比如 $o_{t}$ =[0,0,0,1]，来决定哪部分细胞状态需要被输出，需要的记忆才输出，并不是所有的都输出。

$o_{t}$ 的公式：

第二部分：

把新的细胞状态通过tanh函数处理，将输出值变为[-1. 1]，再点乘 $o_{t}$ ，来控制哪部分需要输出。

$h_{t}$ 的公式：

展开全文 >>

ResNet

2022-05-07

一、提出原因

1、堆叠网络造成的问题

传统的想法是如果我们堆叠很多很多层，或许能让网络变得更好。

然而现实却是：堆叠网络后网络难以收敛，而且梯度爆炸（梯度消失）在一开始就阻碍网络的收敛，让网络难以训练，得到适当的参数。

2、解决深度网络的退化问题

理论上来讲，增加网络的层数，网络可以进行更加复杂的特征提取，可以取得更好的结果。但是实验发现深度网络出现了退化问题，如下图所示（图片来源：Resnet的论文）。网络深度增加时，网络准确度出现饱和，之后甚至还快速下降。而且这种下降不是因为过拟合引起的，而是因为在适当的深度模型上添加更多的层会导致了更高的训练误差，从而使其下降。

二、残差结构

为了解决以上两个问题，残差结构应运而生。

原理图如图所示（图片来源：Resnet的论文）：它的结构很像电路中的短路，因此被称为短路连接（shortcut）。

它使用了一种连接方式叫做“shortcut connection”，顾名思义，shortcut就是“抄近道”的意思，下面是这个resnet的网络结构：

对于这整个堆叠结构，当输入x时：

它学习到的特征记为H（x）
因此我们希望他学习到的残差为F（x）= H（x）- x；
那么我们最初学习到的特征就是H（x）= F（x）+ x。

它对每层的输入做一个reference（X）, 学习形成残差函数，而不是学习一些没有reference（X）的函数。这种残差函数更容易优化，能使网络层数大大加深。在上图的残差块中它有二层，如下表达式，
其中σ代表非线性函数ReLU。

在这里插入图片描述

然后通过一个shortcut，和第2个ReLU，获得输出y。

在这里插入图片描述

当需要对输入和输出维数进行变化时（如改变通道数目），可以在shortcut时对x做一个线性变换Ws，如下式。

在这里插入图片描述

这样做的目的是：让经过堆积结构学到的（F（x））和最原始的x进行联合获取特征。

残差学习相比原始特征直接学习更容易。取一个最极端的结果来看，就是F（x）= 0（堆积结构啥也没学到），这里堆积层仅仅做了恒等映射，至少网络性能不会下降，实际上残差不会为0，这也会使得堆积层在输入特征基础上学习到新的特征，从而拥有更好的性能。并且将残差置为零比通过一堆非线性层来拟合恒等映射更容易。

然而实验证明x已经足够了，不需要再搞个维度变换，除非需求是某个特定维度的输出，如是将通道数翻倍，如下图所示：

由上图，我们可以清楚的看到“实线”和“虚线”两种连接方式，实线的Connection部分 (第一个粉色矩形和第三个粉色矩形) 都是执行3x3x64的卷积，他们的channel个数一致，所以采用计算方式：
Y = F(x) + x，虚线的Connection部分 (第一个绿色矩形和第三个绿色矩形) 分别是3x3x64和3x3x128的卷积操作，他们的channel个数不同(64和128)，所以采用计算方式： y=F(x)+Wx 。其中W是卷积操作，用来调整x的channel维度。

残差块的两种结构

这是文章里面的图，我们可以看到一个“弯弯的弧线“这个就是所谓的”shortcut connection“，也是文中提到identity mapping，这张图也诠释了ResNet的真谛，当然大家可以放心，真正在使用的ResNet模块并不是这么单一，文章中就提出了两种方式：

这两种结构分别针对ResNet34（左图）和ResNet50/101/152（右图），一般称整个结构为一个“building block” 。其中右图又称为“bottleneck design”，目的就是为了降低参数的数目，实际中，考虑计算的成本，对残差块做了计算优化，即将两个3x3的卷积层替换为1x1 + 3x3 + 1x1，如右图所示。新结构中的中间3x3的卷积层首先在一个降维1x1卷积层下减少了计算，然后在另一个1x1的卷积层下做了还原，既保持了精度又减少了计算量。第一个1x1的卷积把256维channel降到64维，然后在最后通过1x1卷积恢复，整体上用的参数数目：1x1x256x64 + 3x3x64x64 + 1x1x64x256 = 69632，而不使用bottleneck的话就是两个3x3x256的卷积，参数数目: 3x3x256x256x2 = 1179648，差了16.94倍。

三、Resnet网络结构

1.原理分析

ResNet网络是在VGG19网络的基础上进行修改的，并且通过短路机制加入了残差单元。

设计规则：

（1）对于相同的输出特征图尺寸，层具有相同数量的滤波器

（2）当feature map大小降低一半时，feature map的数量增加一倍【过滤器（可以看作是卷积核的集合）的数量增加一倍】，这保持了网络层的复杂度。然后通过步长为2的卷积层直接执行下采样。

网络结构具体如下图所示（左为VGG-19，中为34个参数层的简单网络，右为34个参数层的残差网络）：

ResNet相比普通网络每两层间增加了短路机制，这就形成了残差学习，其中实线表示快捷连接，虚线表示feature map数量发生了改变。

有两种情况需要考虑：

（1）输入和输出具有相同的维度时（对应实线部分）：

直接使用恒等快捷连接

（2）维度增加（当快捷连接跨越两种尺寸的特征图时，它们执行时步长为2）：

①快捷连接仍然执行恒等映射，额外填充零输入以增加维度。这样就不会引入额外的参数。

②用下面公式的投影快捷连接用于匹配维度（由1×1卷积完成）

Resnet网络结构的更多细节如下图所示：

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4ODA3Njg4,size_16,color_FFFFFF,t_70

2、结构分析

Resnet结构分层为：Layer–Block–Stage–Network

（1）Layer是最小的结构，ResNet-18就代表网络有18层。

（2）Block是由两层或者三层conv层堆叠形成的。一般来说，50层以下用下图左侧的双层block，50层以上用下图右侧的三层block，其中右侧的这个block叫做BottleNeck（瓶颈结构）。

（3）stage 是由数个Block堆叠形成的。如下图黄圈圈（3个Block组成）所示：

（4）以Resnet-50为例，如上图，该网络是由stage之前的两层（conv7x7, maxpooling）和4个stage（共48层）组成的。

3、代码分析（内含分析和注释）

（1）网络总括

class ResNet(nn.Module):
    def __init__(self,block, layers, num_class=1000, norm_layer=None):
        super(ResNet, self).__init__()
        if norm_layer is None:
            norm_layer = nn.BatchNorm2d
        self._norm_layer = norm_layer
 
        self.inplanes = 64
 
        #对应第一层conv1
        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride = 2, padding = 3, bias=False)#7*7卷积
        self.bn1 = norm_layer(self.inplanes)#正态分布（归一化操作）
 
        self.relu = nn.ReLU(inplace=True)#激活
 
        #对应第二层
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2)#3*3最大池化池化
 
        # stages部分，分别第1，2，3，4个stage
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
 
        #对应最后一层
        self.gap = nn.AdaptiveAvgPool2d((1,1))#平均池化
 
        self.linear = nn.Linear(512*block.expansion, num_class)#线性
 
        for m in self.modules():
        	#isinstance()函数来判断一个对象是否是一个已知的类型，类似 type()，其实就是没有正态分布的话咱就kaiming均匀分布。
            if isinstance(m, nn.Conv2d): 
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
				#kaiming均匀分布
            elif isinstance(m, nn.BatchNorm2d):#是正态分布
                nn.init.constant_(m.weight, 1)
			#torch.nn.init.constant(tensor, val)，用val的值填充输入的张量或变量，即变成全1分布
                nn.init.constant_(m.bias, 0)#偏置变为0
    def forward(self,x):
 
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.maxpool(out)
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = self.gap(out)
        out = nn.Flatten(out)#推平
        out = self.linear(out)
 
        return out

（2）内含函数（将多个block拼接成一个stage）

def _make_layer(self, block, planes, blocks, stride = 1):
 
    #将多个block拼接成一个stage，实现block之间的衔接；block指前面定义的BottleNeck或BasicBlock;planes指进行变换的通道数;blocks指这个stage中block的数目;stride：filter在原图上扫描时，需要跳跃的格数
 
        norm_layer = self._norm_layer
        downsample = None
        if stride !=1 or self.inplanes != block.expansion *planes:
        #形状不匹配的两种情况:(1)通道数目不匹配，（2）stride导致的feature map的尺寸不匹配
        
            downsample= nn.Sequential(
            conv1x1(self.inplanes, block.expansion *planes, stride = stride),
            norm_layer(block.expansion *planes)
                                )
# self.inplanes是block的输入通道数，planes是做3x3卷积的空间的通道数，expansion是残差结构中输出维度是输入维度的多少倍，同一个stage内，第一个block，inplanes=planes， 输出为planes*block.expansion
        # 第二个block开始，该block的inplanes等于上一层的输出的通道数planes*block.expansion（类似于卷积后的结果进入下一个卷积时，前一个卷积得到的output的输出为下一个卷积的input）
 
        layers = []
        layers.append(block(self.inplanes, blocks[0], stride=stride, downsample=downsample, norm_layer=norm_layer))
        #在一个stage中，只对stage中的第一个block中使用下采样(stride!=1)，其他的block都不影响feature map的维度的
        self.inplanes = planes * self.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, blocks[0], stride=stride, norm_layer=norm_layer))#这里就没有downsample了
 
        return nn.Sequential(*layers)# 变量名前加星号表示Unpack解包

展开全文 >>