ResNet论文笔记及代码剖析

最新推荐文章于 2024-05-10 14:09:42 发布

三分明月落

最新推荐文章于 2024-05-10 14:09:42 发布

阅读量843

点赞数 1

本文链接：https://blog.csdn.net/qq_40755643/article/details/88855622

版权

Reference:

https://zhuanlan.zhihu.com/p/56961832

https://zhuanlan.zhihu.com/p/54289848

源码：

https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py

当网络足够深时，仅仅在后面继续堆叠更多层会带来很多问题：

第一个问题就是梯度爆炸 / 消失（vanishing / exploding gradients），这可以通过BN和更好的网络初始化解决；

第二个问题就是退化（degradation）问题，即当网络层数多得饱和了，加更多层进去会导致优化困难、且训练误差和预测误差更大了，注意这里误差更大并不是由过拟合导致的

ResNet特点：

利用残差结构让网络能够更深、收敛速度更快、同时参数相对之前的模型更少、复杂度更低
解决深网络退化（梯度爆炸/消失）这个并不是过拟合引起的、难以训练的问题
适用于多种计算机视觉任务

残差结构：

假设输入为 x，有两层全连接层学习到的映射为H(x) ，也就是说这两层可以渐进（asymptotically）拟合 H(x)。假设 H(x) 与 x 维度相同，那么拟合H(x)与拟合残差函数H(x)-x等价，令残差函数 F(x)=H(x)-x，则原函数变为H(x)=F(x)+x ，于是直接在原网络的基础上加上一个跨层连接，这里的跨层连接也很简单，就是将x 的恒等映射（Identity Mapping）传递过去。

本质也就是不改变目标函数 H(x) ，将网络结构拆成两个分支，一个分支是残差映射 F(x) ，一个分支是恒等映射 x ，于是网络仅需学习残差映射 F(x)即可。

整个残差结构可以形式化定义为y=F(x,{Wi})+x ，这里的 F(x,{Wi}) 指拟合的残差映射，如上图中有两层全连接层，即 F=W2σ(W1x) ，其中σ指ReLU，注意这里为了简洁没有写上bias。当 F与 x 维度相同时，可以直接逐元素相加；但如果不同，就必须给x再加一个线性映射，将其映射到一个与 F 维度相同的向量，此时整个残差结构为y=F(x,{Wi})+Ws.x ，Ws就是一个用于维度匹配的矩阵。，但经过后面的实验发现恒等映射更好,维度匹配直接用1 x 1卷积升维或降维即可，尤其是在bottleneck结构中。

残差结构有效的原因：

自适应深度：网络退化问题就体现了多层网络难以拟合恒等映射这种情况，也就是说H(x)难以拟合x，但使用了残差结构之后，拟合恒等映射变得很容易，直接把网络参数全学习到为0，只留下那个恒等映射的跨层连接即可。于是当网络不需要这么深时，中间的恒等映射就可以多一点，反之就可以少一点。
“差分放大器”：假设最优H(x)更接近恒等映射，那么网络更容易发现除恒等映射之外微小的波动
模型集成：整个ResNet类似于多个网络的集成，原因是删除ResNet的部分网络结点不影响整个网络的性能，但VGGNet会崩溃
缓解梯度消失：针对一个残差结构对输入求导就可以知道，由于跨层连接的存在，总梯度F(x)在对x的导数基础上还会加1

Res50、Res101、Res152采用的是被称为bottleneck的残差结构：

1x1卷积有什么作用：

对通道数进行升维和降维（跨通道信息整合），实现了多个特征图的线性组合，同时保持了原有的特征图大小；
相比于其他尺寸的卷积核，可以极大地降低运算复杂度；
如果使用两个3x3卷积堆叠，只有一个relu，但使用1x1卷积就会有两个relu，引入了更多的非线性映射；
1*1卷积的计算量优势：首先看上图右边的bottleneck结构，对于256维的输入特征，参数数目：1x1x256x64+3x3x64x64+1x1x64x256=69632，如果同样的输入输出维度但不使用1x1卷积，而使用两个3x3卷积的话，参数数目为(3x3x256x256)x2=1179648。简单计算下就知道了，使用了1x1卷积的bottleneck将计算量简化为原有的5.9%，收益超高。

残差块的实现：

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):
        identity = 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:
            identity = self.downsample(x)

        out += identity
        out = self.relu(out)

        return out

expansion是残差结构中输出维度是输入维度的多少倍，BasicBlock没有升维，所以expansion = 1
残差结构是在求和之后才经过ReLU层
downsample对残差结构的输入进行升维，直接1 x 1卷积再加上BN即可，后面BasicBlock类和Bottleneck类用得到

class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.conv1 = conv1x1(inplanes, planes)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = conv3x3(planes, planes, stride)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = conv1x1(planes, planes * self.expansion)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        identity = 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:
            identity = self.downsample(x)

        out += identity
        out = self.relu(out)

        return out

expansion = 4，因为Bottleneck中每个残差结构输出维度都是输入维度的4倍

网络结构：

每个网络都包括三个主要部分：输入部分、输出部分和中间卷积部分（中间卷积部分包括如图所示的Stage1到Stage4共计四个stage）。

网络的整体结构：

我们通过调用resnet18( )函数来生成一个具体的model，而resnet18函数则是借助ResNet类来构建网络的。

class ResNet(nn.Module):

    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False):
        super(ResNet, self).__init__()
        self.inplanes = 64
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        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.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512 * block.expansion, num_classes)

    def _make_layer(self, block, planes, blocks, stride=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                conv1x1(self.inplanes, planes * block.expansion, stride),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for _ in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)

        return x

# 生成一个res18网络
def resnet18(pretrained=False, **kwargs):
    model = ResNet(BasicBlock, [3, 4, 23, 3], **kwargs)
    if pretrained:
        model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
    return model

在ResNet类中的forward( )函数规定了网络数据的流向：

（1）数据进入网络后先经过输入部分（conv1, bn1, relu, maxpool）；

（2）然后进入中间卷积部分（layer1, layer2, layer3, layer4，这里的layer对应我们之前所说的stage）；

（3）最后数据经过一个平均池化和全连接层（avgpool, fc）输出得到结果；

具体来说，resnet101和其他res系列网络的差异主要在于layer1~layer4，其他的部件都是相似的。

在残差结构之前，先对原始224 x 224的图片处理，在经过7 x 7的大卷积核、BN、ReLU、最大池化之后得到56 x 56 x 64的feature map
从layer1、layer2、layer3、layer4的定义可以看出，第一个stage不会减小feature map，其余都会在stage的第一层用步长2的3 x 3卷积进行feature map长和宽减半
_make_layer函数中downsample对残差结构的输入进行升维，直接1 x 1卷积再加上BN即可，后面BasicBlock类和Bottleneck类用得到
最后的池化层使用的是自适应平均池化，而非论文中的全局平均池化

输入部分：

所有的ResNet网络输入部分是一个size=7x7, stride=2的大卷积核，以及一个size=3x3, stride=2的最大池化组成，通过这一步，一个224x224的输入图像就会变56x56大小的特征图，极大减少了存储所需大小。

self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

中间卷积部分：

中间卷积部分主要是通过3*3卷积的堆叠来实现信息的提取。上图中的[2, 2, 2, 2]和[3, 4, 23, 3]等则代表了bolck的重复堆叠次数。

输出部分：

通过全局自适应平滑池化，把所有的特征图拉成1*1，对于res18来说，就是1x512x7x7 的输入数据拉成 1x512x1x1，然后接全连接层输出，输出节点个数与预测类别个数一致。

self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)

end

三分明月落

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
ResNet论文笔记及代码剖析

Reference:https://zhuanlan.zhihu.com/p/56961832https://zhuanlan.zhihu.com/p/54289848源码：https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py当网络足够深时，仅仅在后面继续堆叠更多层会带来很多问...
复制链接

扫一扫