ReseNet简介

ResNet的应用比较广泛，为了方便以后的学习，对ResNet网络结构做了进一步了解，ResNet的种类有好几种，此处简要介绍ResNet-18的代码。

论文地址：

1512.03385.pdf (arxiv.org)https://arxiv.org/pdf/1512.03385.pdf

ResNet

ResNet（Residual Neural Network）由微软研究院的Kaiming He等四名华人提出，通过使用ResNet Unit成功训练出了152层的神经网络，并在ILSVRC2015比赛中取得冠军，在top5上的错误率为3.57%，同时参数量比VGGNet低，效果非常突出。ResNet的结构可以极快的加速神经网络的训练，模型的准确率也有比较大的提升。同时ResNet的推广性非常好，甚至可以直接用到InceptionNet网络中。

    ResNet的主要思想是在网络中增加了直连通道，即Highway Network的思想。此前的网络结构是性能输入做一个非线性变换，而Highway Network则允许保留之前网络层的一定比例的输出。ResNet的思想和Highway Network的思想也非常类似，允许原始输入信息直接传到后面的层中，如下图所示：

这样的话这一层的神经网络可以不用学习整个的输出，而是学习上一个网络输出的残差，因此ResNet又叫做残差网络。

创新的点在于：

提出残差学习的思想。传统的卷积网络或者全连接网络在信息传递的时候或多或少会存在信息丢失，损耗等问题，同时还有导致梯度消失或者梯度爆炸，导致很深的网络无法训练。ResNet在一定程度上解决了这个问题，通过直接将输入信息绕道传到输出，保护信息的完整性，整个网络只需要学习输入、输出差别的那一部分，简化学习目标和难度。VGGNet和ResNet的对比如下图所示。ResNet最大的区别在于有很多的旁路将输入直接连接到后面的层，这种结构也被称为shortcut或者skip connections。

在ResNet网络结构中会用到两种残差模块，一种是以两个3*3的卷积网络串接在一起作为一个残差模块，另外一种是1*1、3*3、1*1的3个卷积网络串接在一起作为一个残差模块，他们如下图所示。

ResNet有不同的网络层数，比较常用的是50-layer，101-layer，152-layer。他们都是由上述的残差模块堆叠在一起实现的。

 ResNet-18的Pytorch代码如下：

函数定义如下：

def resnet18(pretrained=False, **kwargs):
    """构建一个ResNet-18模型

    参数:
        pretrained (bool): 若为True则返回在ImageNet上预训练的模型
    """
    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
    if pretrained:
        model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
    return model

使用其他的ResNet模型时，使用对应的名字的函数就行，函数返回的是一个ResNet类型的实例，这个类定义了resnet网络的结构，ResNet类的结构如下：

class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False):
        """定义ResNet网络的结构
        
        参数：
            block (BasicBlock / Bottleneck): 残差块类型
            layers (list): 每一个stage的残差块的数目，长度为4
            num_classes (int): 类别数目
            zero_init_residual (bool): 若为True则将每个残差块的最后一个BN层初始化为零，
                这样残差分支从零开始每一个残差分支，每一个残差块表现的就像一个恒等映射，根据
                https://arxiv.org/abs/1706.02677这可以将模型的性能提升0.2~0.3%
        """
        super(ResNet, self).__init__()
        # __init__
    def _make_layer(self, block, planes, blocks, stride=1):
        # _make_layer function
    def forward(self, x):
        # forward function

注意上面的ResNet类的代码中的block参数，这个参数定义了残差块的结构，分为两种：

1. BasicBlock：resnet-18和resnet-34的残差块结构；
2. Bottleneck：resnet-50，resnet-101和resnet-152的残差块结构；

 这里仅关注resnet-18因此我们只关注BasicBlock类，这个类的结构如下：

def conv3x3(in_planes, out_planes, stride=1):
    """3x3 convolution with padding"""
    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                     padding=1, bias=False)


def conv1x1(in_planes, out_planes, stride=1):
    """1x1 convolution"""
    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)


class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        """定义BasicBlock残差块类
        
        参数：
            inplanes (int): 输入的Feature Map的通道数
            planes (int): 第一个卷积层输出的Feature Map的通道数
            stride (int, optional): 第一个卷积层的步长
            downsample (nn.Sequential, optional): 旁路下采样的操作
        注意：
            残差块输出的Feature Map的通道数是planes*expansion
        """
        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

BasicBlock定义的网络结构如下所示： 

 ResNet类：

class ResNet(nn.Module):

    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False):
         """定义ResNet网络的结构
        
        参数：
            block (BasicBlock / Bottleneck): 残差块类型
            layers (list): 每一个stage的残差块的数目，长度为4
            num_classes (int): 类别数目
            zero_init_residual (bool): 若为True则将每个残差块的最后一个BN层初始化为零，
                这样残差分支从零开始每一个残差分支，每一个残差块表现的就像一个恒等映射，根据
                https://arxiv.org/abs/1706.02677这可以将模型的性能提升0.2~0.3%
        """
        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)
        
        # Stage1 ~ Stage4
        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))  # GAP
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        # 网络参数初始化
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
        if zero_init_residual:
            for m in self.modules():
                if isinstance(m, Bottleneck):
                    nn.init.constant_(m.bn3.weight, 0)
                elif isinstance(m, BasicBlock):
                    nn.init.constant_(m.bn2.weight, 0)
    
    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

 ResNet类定义的网络结构如下图所示：

 _make_layer方法

ResNet类中还有一个方法是_make_layer在这个方法中，定义了ResNet网络的一个Stage的结构，代码如下：

def _make_layer(self, block, planes, blocks, stride=1):
    """定义ResNet的一个Stage的结构
    
    参数：
        block (BasicBlock / Bottleneck): 残差块结构
        plane (int): 残差块中第一个卷积层的输出通道数
        bloacks (int): 当前Stage中的残差块的数目
        stride (int): 残差块中第一个卷积层的步长
    """
    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)

首先是为第一个残差块定义downsample结构，当残差块的输入和输出的尺寸不一致或者通道数不一致的时候就会需要下采样结构，下采样结构由一个1x1卷积层和一个BatchNorm层组成。之后定义了b l o c k s blocksblocks个残差块（在ResNet-18中每一个Stage均有两个残差块），只有第一个残差块需要下采样层。

在ResNet中，Stage1中输入通道数和输出通道数相同，并且使用的是stride为1的卷积，因此在Stage1中不需要有下采样层，其余Stage中钧需要有下采样层。

ResNet-50的结构略有差别，但整体思乡并无太大差别，感兴趣的可自行查看Pytorch中的源码。