ResNet网络构建过程详细分析

最新推荐文章于 2024-05-07 17:19:42 发布

置顶 Joker__Wa

最新推荐文章于 2024-05-07 17:19:42 发布

阅读量2.1k

点赞数 4

分类专栏：计算机视觉文章标签：深度学习 pytorch

本文链接：https://blog.csdn.net/weixin_42469716/article/details/107845165

版权

计算机视觉专栏收录该内容

9 篇文章 1 订阅

订阅专栏

ResNet网络的构建过程

构建ResNet网络是通过ResNet类进行的，ResNet类继承了Pytorch网络的基类：torch.nn.Module，然后重写了 _init_ 方法和 forward 方法，__init__方法用来定义一些参数，forward方法用来定义数据在层之间的流动顺序。

构建ResNet网络时，在函数中一般是调用torchvision.model中的resnet50()/resnet18()/resnet101()等函数完成的，调用resnet50()/resnet18()/resnet101()的源代码如下：

def resnet50(pretrained=False, **kwargs):
    """Constructs a ResNet-50 model.

    Args:
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
    # 在这一句当中调用了ResNet类中的函数，因为此时是构建resnet50，所以在参数第一个为Bottleneck
    # **kwargs是将参数以字典的形式传入 在此例中传入的参数还需要num_classes，则在调用的时候后面应该写num_classes=1000或者别的数字
    if pretrained:
        model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
        # pretrained为true表示加入进入预训练的模型 load_state_dict()函数用于加载参数
    return model


def resnet18(pretrained=False, **kwargs):
    """Constructs a ResNet-18 model.

    Args:
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
    if pretrained:
        model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
    return model


def resnet101(pretrained=False, **kwargs):
    """Constructs a ResNet-101 model.

    Args:
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
    if pretrained:
        model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
    return model

在上面调用resnet50()等函数构造网络的时候，如果要调用预训练的模型，使用load_state_dict(model_zoo.load_url(model_urls[‘resnet50’]))进行调用，model_zoo.load_url()的函数代码如下：

import torch.nn as nn
import torch.utils.model_zoo as model_zoo

# 默认的resnet网络，已预训练
model_urls = {
    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
}

在上面调用resnet50()等函数的过程中调用ResNet()以及Bottleneck()以及BasicBlock()类在下面会进行详细的讲解

nn.Conv2d(in_channels,out_channels,kernel_size,stride=1,padding=0,dilation=1,groups=1,bias=true) 函数参数的讲解，in_channels表示输入的维度，out_channels表示输出维度，Kernel_size表示卷积核大小，stride表示步长大小，padding表示填充多少个0，dilation表示kernel的间距，groups表示卷积核的个数，bias表示是否加偏移量
torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)
torch.nn.Linear(in_features,out_features,bias=True)

class ResNet(nn.Module):

    def __init__(self, block, layers, num_classes=1000):
        # 参数block对应的就是残差结构，层数不同，传入的block也不同，比如说ResNet18/34传入的就是BasicBlock所对应的残差结构，而ResNet50/101/152传入的就是Bottleneck所对应的残差结构
        # layers对应的是一个残差结构的数目，是以列表的形式存储，比如对于ResNet50而言就是[3,4,6,3]
        self.inplanes = 64
        # 定义输入特征矩阵的channel，channel定义为64是因为经过maxpool之后channel就会变为64
        super(ResNet, self).__init__()
        
        # ResNet18、ResNet34、ResNet50、ResNet101等都是先经过由7*7的卷积核、out_channel为64，stride为2的卷积层构成
        # 输入的图片都是3通道的，所以Conv2d的第一个参数为3
        # 在进入ResNet网络之前，图片的大小为224*224，这里设置padding为3是为了令output_size为112*112，即满足下述公式：
        # output_size = (input_size - kernel + 2*padding)/stride + 1
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        # inplace等于true，表示对上层传下来的tensor直接修改，这样能够节省运算内存
        # 这里使用BatchNorm2d()而不使用BathNorm1d()的原因：BatchNorm2d 是处理 4D 数据的，BathNorm1d()处理的是2D和3D的数据 而在ResNet类中传递的数据为4D的数据，对应的维度为[batchsize,channel,Height,Weight] 所以使用BatchNorm2d
        self.relu = nn.ReLU(inplace=True)
        # 经过Kernel_size=3 stride=2,padding=1的最大池化之后，output_size为
        # (input_size - kernel + 2*padding)/stride + 1 = (112-3+2)/2+1 = 56
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        
        self.layer1 = self._make_layer(block, 64, layers[0])
        # _make_layer函数中的第一个参数block为Bottleneck或者BasicBlock对应的残差结构，使用Bottleneck还是BasicBlock根据ResNet多少层决定
        # layer1对应的是conv2_x中的一系列残差块，残差块的多少由layers[0]决定
        # layer1不设值stride的原因是因为layer1经过maxpool之后宽和高已经和输出相同了，不需要在进行宽和高的变化了，所以使用默认的stride=1
        # conv2_x的结构是通过_make_layer函数完成的
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        # layer2对应的是conv3_x中的一系列残差块，残差块的多少由layers[1]决定
        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.AvgPool2d(7, stride=1)
        # 表示平均池化下采用 第一个参数表示kernel_size 因为经过经过平均池化之后要输出1*1的，所以卷积核大小为7 stride为1
        self.fc = nn.Linear(512 * block.expansion, num_classes)
        # fc表示的是全连接层 对于ResNet18/34而言，最后一层输出维度为512，对于ResNet50/101/152而言，最后一层输出维度为2048，所以要使用512*block.expansion，全连接层的输出为num_classes
        
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                # 判断该层是否是Conv2d，如果当前遍历的层是Conv2d，则执行下面的两条语句
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
            elif isinstance(m, nn.BatchNorm2d):
                # 这里应该是初始化BN算法中的γ,β ,分别初始化为1和0
                m.weight.data.fill_(1)
                m.bias.data.zero_()
        # 上述的循环是卷积层的初始化操作
                
    def _make_layer(self, block, planes, blocks, stride=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            # 这里这个判断的意义在于：不管是ResNet18/34还是ResNet50/101/152，他们的conv3_1 conv4_1 conv5_1 都需要进行下采样，即第一个残差块的shortcut虚线连接，并且conv3_1 conv4_1 conv5_1的另一个意义就是进行宽和高的变化，所以这几个都是stride=2。但是ResNet18/34和ResNet50/101/152的有一个地方不同，对于conv2_1而言，ResNet18/34不需要进行维度和宽高的变化(因为已经经过了maxpool)，所以ResNet18/34不需要执行这个判断里面的语句，但是ResNet50/101/152的conv2_1则不一样，ResNet50/101/152不需要进行宽高的变化，但是需要进行维度的变化，所以conv2_1的stride=1，但是self.inplanes != planes * block.expansion，所以还是要执行判断下的语句
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                # shortcut虚线连接对于ResNet50/101/152而言需要进行维度的变化，对应的block.expansion为4，对于ResNet18/34而言不需要进行维度的变化，对应的block.expansion为1，stride对应的是宽和高的变化
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        # 这个对应的是conv2_1 conv3_1 conv4_1 conv5_1，在这些残差块中都需要shortcut虚线连接(除了ResNet18/34的conv2_1，ResNet18/34的conv2_1对应的downsample为none)，所以要传入downsample和stride
        self.inplanes = planes * block.expansion
        # 在每一个大块的第一个残差结构执行完毕之后，维度已经发生了变化(ResNet18/34未发生变化 ResNet50/101/152已经变化了)，所以在没一大块的后面的几个残差块的输入channel都变成了 planes*block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes))
            # 除去每一大块的第一个残差块，其他的残差块输入的channel都是self.inplanes(经过expansion变化之后的)，但是后面的残差块的第一个卷积层的卷积核仍然是planes

        return nn.Sequential(*layers)
        # 通过非关键字参数传入，nn.Sequential将上面定义的一系列层结构组合在一起并返回

    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 是一个tensor类型 对应 C*H*W 所以size(0)对应的为channel -1表示电脑自动计算 C*H*W / x.size(0) 在这里的含义就是将x各个维度的值平摊为一维的(因为avgpool完成之后 H和W都会变为1了)
        x = self.fc(x)

        return x

ResNet50/101/152网络的构建所需类的讲解

在这里插入图片描述

上图表示的是ResNet50/101/152残差块的部分结构，用于和下面的源码进行对比分析

class Bottleneck(nn.Module):
    expansion = 4
    # 对于ResNet50而言，每一个残差块中最后一个卷积核都会扩大四倍，比如conv2_x中前两个是64 channel，而最后一个卷积层是 256 channel，所以在Bottleneck中的expansion为4

    def __init__(self, inplanes, planes, stride=1, downsample=None):
    # downsample对应的是ResNet网络结构中的虚线连接 比如说 ResNet50中的conv2_x到conv3_x的过渡，在shortcut分支需要使用虚线连接，从而将 56*56*64 的输入特征矩阵转变为 28*28*512 的输出特征矩阵
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        # 上面的conv1表示每一个残差块的第一个卷积层，从上面的图片可以看出第一个卷积层的卷积核为1*1 且步长为1 所以在这里使用默认步长，且使用padding为0即可(因为卷积核为1，不需要进行padding的设置)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
                               padding=1, bias=False)
        # conv2表示每一个残差块的第二个卷积层，从上面图片的右图可以看出第二个卷积层的卷积核为3*3 并且stride=2，所以在这里设置stride等于2，但是这里设置stride=stride的原因是：stride等于2这是针对每一个大块中的第一个残差块，因为一个残差块需要进行特征矩阵的变化(在这里特指宽和高的变化)，所以需要设置为2，但是从上面图片的左图可以看出，其余的第二层卷积层只需要stride=1即可
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
        # 这里对应的是每一个残差块的第三个卷积层，和第一个卷积层不同的地方在于，第三个卷积层的卷积核的个数相比较第一个卷积层而言扩大了4倍，所以使用planes*4
        self.bn3 = nn.BatchNorm2d(planes * 4)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        # forward函数表示数据在层之间的传递顺序
        residual = x
        # 这里residual=x对应的残差块中的shortcut分支，对于大部分的shortcut分支来说，直接输入和输出相连即可（对应的shortcut实线连接），而对于conv3_1 conv4_1对应的shortcut对原特征矩阵进行改变，所以才有了后面的if self.downsample is not None判断
        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)
        # 这里对应的shortcut中的虚线分支，即将原始的输入特征矩阵进行相应的改变，从而使其满足主分支和shortcut分支的输出特征矩阵的shape相同

        out += residual
        # 这里表示的是在ReLU激活函数之前的相加过程 相加完之后的结果再进行ReLU激活
        out = self.relu(out)

        return out

ResNet18/34网络的构建所需类的讲解

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u6YoWuOs-1596705524223)(C:\Users\云之遥\AppData\Roaming\Typora\typora-user-images\image-20200805190446204.png)]$

上图表示的是ResNet18/34残差块的部分结构，用于和下面的源码进行对比分析

class BasicBlock(nn.Module):
    expansion = 1
    # 这里的expansion和Bottleneck类中的expansion不同，是因为对于ResNet18/34而言，每一个残差块中的channel都是恒定的，比如ResNet34中的conv2_x都是64个channel，而对于ResNet50而言，conv2_x中前两个是64 channel，而最后一个卷积层是 256 channel，所以在Bottleneck中的expansion为4

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        # downsample对应的是ResNet网络结构中的虚线连接 比如说 ResNet34中的conv2_x到conv3_x的过渡，在shortcut分支需要使用虚线连接，从而将 56*56*64 的输入特征矩阵转变为 28*28*128 的输出特征矩阵
        super(BasicBlock, self).__init__()
        self.conv1 = conv3x3(inplanes, planes, stride)
        # 在BasicBlock中都是使用的conv3*3，是因为对于ResNet18/34而言，所有的残差块中的卷积层都是使用的kernel_size为3的卷积核
        # inplanes是输入的channel planes是输出的channel stride对应步长 conv3x3函数的padding默认为1 因为这里要求padding要为1 bias这里也要求为false 因为BN不需要bias
        # 这里的stride在每一个大块的第一个残差块需要设置stride等于2，因为要进行特征矩阵的变化，比如说conv3_1 conv4_1都需要设置stride=2，但是对除去每一大块中的第一个残差块之外，其余的都应该设置为stride=1
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        # inplace=true 表示对上层传下来的tensor直接修改，这样能够节省运算内存
        self.conv2 = conv3x3(planes, planes)
        # 这里和上面的conv3x3的不同在于没有了stride参数 因为第一个conv3x3可能位于每一个大的残差块的开头，比如conv3_1 conv4_1，这个时候需要stride等于2来调整输出特征矩阵的宽和高 而在之后的卷积层stride等于1即可，所以后面都是使用的默认的1
        self.bn2 = nn.BatchNorm2d(planes)
        self.downsample = downsample
        # 定义下采样的方法
        self.stride = stride

    def forward(self, x):
        # forward函数表示数据在层之间的传递顺序
        residual = x
        # 这里residual=x对应的残差块中的shortcut分支，对于大部分的shortcut分支来说，直接输入和输出相连即可（对应的shortcut实线连接），而对于conv3_1 conv4_1对应的shortcut对原特征矩阵进行改变，所以才有了后面的if self.downsample is not None判断
        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)
        # 这里对应的shortcut中的虚线分支，即将原始的输入特征矩阵进行相应的改变，从而使其满足主分支和shortcut分支的输出特征矩阵的shape相同

        out += residual
        # 这里表示的是在ReLU激活函数之前的相加过程 相加完之后的结果再进行ReLU激活
        out = self.relu(out)

        return out

Joker__Wa

关注

4
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
ResNet网络构建过程详细分析

ResNet网络的构建过程构建ResNet网络是通过ResNet类进行的，ResNet类继承了Pytorch网络的基类：torch.nn.Module，然后重写了 _init_ 方法和 forward 方法，__init__方法用来定义一些参数，forward方法用来定义数据在层之间的流动顺序。构建ResNet网络时，在函数中一般是调用torchvision.model中的resnet50()/resnet18()/resnet101()等函数完成的，调用resnet50()/resnet1.
复制链接

扫一扫