【文献阅读及pytorch实践】ResNet:Deep Residual Learning for Image Recognition

第一部分.文献阅读

首先,作者抛出了一个问题:

学习更好的网络就像堆叠更多的层那么简单吗?

回答这个问题的一个很大的障碍就是众所周知的梯度消失/梯度爆炸,它从一开始就阻止了收敛。现在这个问题主要是通过初始归一化和中间层归一化来解决,可以使数十层的网络收敛。

但是当更深的网络可以收敛的时候,存在一个退化的问题:

当网络深度逐渐增加时,精度达到饱和,然后开始退化(目前还不是很懂这个问题的本质原因)

这种退化不是过拟合的原因。

针对这种退化的原因,作者想出了一个构造更深模型的方法:

在浅层网络的基础上构造恒等映射层

这种构造方式不会使深层网络比浅层网络有更大的训练误差。
【文献阅读及pytorch实践】ResNet:Deep Residual Learning for Image Recognition_第1张图片
让网络学习H(x)-x而不是学习H(x)

这种方式的优势在于:

一个极端的情况,假设当前精度已饱和,进行恒等映射是最优的,那么将残差学习为0比堆叠一堆层去学习恒等映射要容易

恒等映射既不增加额外的参数,也不增加运算复杂度。

作者发现:

1.深度残差网络很容易去优化,但是与之对应的“朴素”网络(仅堆叠层)在深度增加的时候有更高的训练误差
2.深度残差网络可以简单的从大幅增加的网络深度中获取更高的精度,比之前的网络都好

【文献阅读及pytorch实践】ResNet:Deep Residual Learning for Image Recognition_第2张图片
残差块定义如下:
在这里插入图片描述
但是上式只能用于F和x可以直接相加的情况(维度相同),还有一个更普适的式子:
在这里插入图片描述
Ws可以用来对x进行线性变换从而匹配维度。
恒等映射(式1)足以解决问题,并且是最经济的,Ws仅在匹配维度时会使用。

【文献阅读及pytorch实践】ResNet:Deep Residual Learning for Image Recognition_第3张图片
F的形式是灵活的,本实验中采用的是2层和3层的,更多层也可以;但如果是1层的,就类似于线性变换层。

【文献阅读及pytorch实践】ResNet:Deep Residual Learning for Image Recognition_第4张图片
在输入和输出具有相同维度的时候,shortcut可以直接使用(图中实线部分);
当维度增加时,有两种情况(图中虚线部分):

1.依旧为恒等映射,额外的维度用0补充,此方法不引入额外的参数;
2.通过1*1卷积来匹配维度;

当shortcut跨越两种不同尺寸的feature map时,步长设为2。

具体实验细节如下:

训练:

输入为224*224的图片,从图片和他的镜像中随机采样,并且每个像素减去均值;
使用标准颜色增强;
每次卷积后都做一次BN;
batch size设为256;
lr从0.1开始,当错误率停滞时,lr/10,最终训练了600000轮;
weight decay=10,momentum=0.9,不使用dropout;

测试:

使用10-crop测试(详见AlexNet)

第二部分.pytorch实践

这里主要看了pytorch官方实现残差快的代码,简单易懂。
【文献阅读及pytorch实践】ResNet:Deep Residual Learning for Image Recognition_第5张图片
第一种残差块如上图所示,基础版,由两个3 * 3的卷积组成。

class BasicBlock(nn.Module):
    expansion = 1
 
    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        self.conv1 = conv3x3(inplanes, planes, stride)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(planes, planes)
        self.bn2 = nn.BatchNorm2d(planes)
        self.downsample = downsample
        self.stride = stride
 
    def forward(self, x):
        residual = x
 
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
 
        out = self.conv2(out)
        out = self.bn2(out)
 
        if self.downsample is not None:
            residual = self.downsample(x)
 
        out += residual
        out = self.relu(out)
 
        return out
expansion是残差结构中输出维度是输入维度的多少倍,BasicBlock没有升维,所以expansion = 1
残差结构是在求和之后才经过ReLU层

【文献阅读及pytorch实践】ResNet:Deep Residual Learning for Image Recognition_第6张图片
与基础版的不同之处只在于这里是三个卷积,分别是1x1,3x3,1x1,分别用来压缩维度,卷积处理,恢复维度,接着就是网络主体了。

class Bottleneck(nn.Module):
    expansion = 4
 
    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
                               padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride
 
    def forward(self, x):
        residual = x
 
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
 
        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)
 
        out = self.conv3(out)
        out = self.bn3(out)
 
        if self.downsample is not None:
            residual = self.downsample(x)
 
        out += residual
        out = self.relu(out)
 
        return out
inplane是输入的通道数,plane是输出的通道数,在basic中expansion是1,此时完全忽略expansion这个东西,输出的通道数就是plane,然而bottleneck就是不走寻常路,它的任务就是要对通道数进行压缩,再放大,于是,plane不再代表输出的通道数,而是block内部压缩后的通道数,输出通道数变为plane * expansion。

你可能感兴趣的:(文献阅读)