ResNet50模型学习笔记

ResNet的各种网络结构图如下图所示。

ResNet的层级结构

Layer->Block->Stage->Network

Layer是最小的单位，ResNet50代表有50层。

Block由两层或者三层conv层叠加而成，50层以下用左侧的双层block，50层及以上用右侧的三层block，其中右侧的这个block叫做BottleNeck（瓶颈结构）

 数个Block堆叠形成一个Stage，下图中用[ ]框起来的就是一个Stage，一个ResNet中共有4个Stage

ResNet50

输入Input经过Resnet50到输出Output的5个阶段，共经过了50个层，Stage0中的2层（conv7x7、max pooling），Stage1中9层（3x3），Stage2中的12层（3x4），Stage3中的18层（3x6），Stage4中的9层（3x3）。其中Stage0较为简单，可以看作数据的预处理；后面的Stage1、Stage2、Stage3、Stage4都由Bottleneck组成，结构相似。

Stage0

Stage0较为简单，可以看作数据的预处理。（3，473，473）为输入的通道数（channel）、高（height）、宽（width），即（c，h，w）。先假设输入的高和宽相等，所以表示为（c，w，w）

该Stage中第1层包括3个先后操作：

1、CONV

        CONV为卷积（Convolution）的缩写，7x7为卷积核的大小，64为卷积核的数量（即该卷积层输出的通道数），stride 2是卷积核的步长为2

2、BN

        BN是Batch Normalization（批标准化）的缩写，即常说是BN层

3、RELU

        RELU为ReLU激活函数

        self.conv1 = conv3x3(3, 64, stride=2)
        self.bn1 = BatchNorm2d(64)
        self.relu1 = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(64, 64)
        self.bn2 = BatchNorm2d(64)
        self.relu2 = nn.ReLU(inplace=True)
        self.conv3 = conv3x3(64, 128)
        self.bn3 = BatchNorm2d(128)
        self.relu3 = nn.ReLU(inplace=True)

代码中将1个7x7卷积优化为3个3x3的卷积，经过第1个3x3卷积，通道数由3变为64，尺寸应该是（473-3）/2+1=236，即尺寸从473x473变为236x236；经过第2个3x3卷积，通道数为64，尺寸（236-3）/1+1=234，即尺寸从236x236变为234x234；经过第3个3x3卷积，通道数由64变为128，尺寸（234-3）/1+1=232，即尺寸从234x234变为232x232。

        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

该Stage的第2层为maxpool，即最大池化层。kernel为3x3，步长为2。尺寸（232-3+2*1）/2+1=117，即尺寸从232x232变为117x117。池化层不改变通道数。

总体来说，在Stage0中，形状为（3，473，473）的输入经过第1层、第2层得到了形状为（128，117，117）的输出。

Stage1

理解了Stage1的结构之后就同样能理解Stage2、Stage3、Stage4的结构。

Stage1中有3个瓶颈层。

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

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

        return nn.Sequential(*layers)

        self.layer1 = self._make_layer(block, 64, layers[0])

经过Stage1，通道数变为64x4=256，即形状为（128，117，117）的输入经过该Stage得到了形状为（256，117，117）的输出。

        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)

Stage2中有4个瓶颈层。

经过Stage2，通道数变为128x4=512，尺寸变为59x59，即形状为（256，117，117）的输入经过该Stage得到了形状为（512，59，59）的输出。

        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)

Stgae3中有6个瓶颈层。

经过Stage3，通道数变为1024，尺寸变为30x30，即形状为（512，59，59）的输入经过该Stage得到了形状为（1024，30，30）的输出。

        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)

Stage4中有3个瓶颈层

经过Stage4，通道数变为2048，尺寸变为16x16，即形状为（1024，30，30）的输入经过该Stage得到了形状为（2048，16，16）的输出。

        self.avgpool = nn.AvgPool2d(7, stride=1)

经过一个kernel为7x7的mean-pooling，尺寸变为10x10，即形状为（2048，16，16）的输入经过该池化层得到了形状为（2048，10，10）的输出。

  下图是zyyupup画的ResNet18和ResNet50网络结构图，其中输入的形状为（3，224，224），经过ResNet50模块后输出的形状为（2048，1，1），经过一个FC全连接层将2048个通道与num_class连接。