resnet50网络搭建

优游涵泳斋

已于 2024-07-15 16:29:47 修改

阅读量87

点赞数 1

文章标签：深度学习 pytorch 人工智能

于 2024-07-15 15:54:24 首次发布

本文链接：https://blog.csdn.net/weixin_48433993/article/details/140439495

版权

Resnet详解：从原理到结构_resnet block-CSDN博客

图1

1.resnet的网络结构如图所示

它分成两个基本模块，一个是basic block，另一个是bottle neck模块，一般层数较低的用basicblock搭建，层数较深的用bottle neck模块，resnet50用的是bottleneck搭建的，两个模块的网络结构如图下

图2

为什么有多余的一个边，通俗讲就是为了可以搭建更深的网络，采用F(X)+X求它的梯度比F(X)的梯度更不容易导致梯度下降。另一种说法是当这一层的卷积权重不那么重要的时候就可以直接连接下一部分，也就是那条多的线，而忽略掉卷积权重这一部分。

2.代码搭建

首先导入相应的包

import torch.nn as nn
import math

加载权重文件

model_urls = {
    'resnet50': 'model/faster_rcnn/resnet50-19c8e357.pth',
    # 'resnet101': 'https://s3.amazonaws.com/pytorch/models/resnet101-5d3b4d8f.pth',
}

定义卷积，也可以不定义，直接用nn.Conv2d也行

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

定义basicblock，代码对照图2

class BasicBlock(nn.Module):
    expansion = 1
    # expansion=1代表输出与输出通道数大小一样，而bottleneck通常大于1
    # 如果是bottleneck则需要加downsample下采样
    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, stride)
        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

可以输出一下看看

basic_block = BasicBlock(64,64,1)
print(basic_block)

输入64，输出64，是按照图二的输入输出来写的

打印结果：

之后定义bottleneck，也是按照图2对应

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, stride=stride, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        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 * 4, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * 4)
        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

输出一下

Bottle_neck = Bottleneck(256,64,1)
print(Bottle_neck)

这里输入通道输出通道大小看第一层的输入输出

输入是256，输出是64

结果与图2的网络结构是一致的

下一步搭建resnet通用结构，这部分看图1

首先初始化，根据图2一共有四层，这里面有初始化权重，定义每一层的函数包含多少个block

 def __init__(self, block, layers, num_classes=1000):

       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, ceil_mode=True)
       self.layer1 = self._make_layer(block, 64, layers[0])
       self.layer2 = self._make_layer(block, 128, layers[1])
       self.layer3 = self._make_layer(block, 256, layers[2])
       self.layer4 = self._make_layer(block, 512, layers[3])

       # 7是卷积核大小,因为这里最后一层的输出大小是7*7,
       self.avgpool = nn.AvgPool2d(7)
       # nn.Linear(in_features, out_features)
       self.fc = nn.Linear(512 * block.expansion, num_classes)
       # 初始化权重包括卷积核权重和偏执,遍历模型每一部分
       # 判断m是否是卷积层nn.conv2d,初始化为均值是0,标准差为math.sqrt(2. / n)的正态分布
       # 如果是nn.BatchNorm2d则把权重初始化为1,偏差为0
       for m in self.modules():
           if isinstance(m, nn.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):
               m.weight.data.fill_(1)
               m.bias.data.zero_()
    # 动态创建多个卷积层或者残差块
    # planes是输出通道跟图像对应
    # 这里比较绕但是还是可以理解,layers是[a, b, c ,d]四个数组,每一个代表一个层数,resnet50中[3, 4, 6, 3],
    # layers中的每个元素对应blocks的数值
    def _make_layer(self, block, planes, blocks, stride=1):
        downsample = None
        # 如果步长不等于1,或者输入通道数不等于输出通道数乘以扩张系数block.expansion,
        # 则需要添加一个下采样层来调整数据的维度,以便能够顺利的进行残差连接
        # 这里创建一个下采样层, 通常是一个1*1卷积, 用来调整数据的通道数(planes * block.expansion)
        # 和可能的空间维度(通过stride参数),以便与残差路径的输出匹配
        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),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        # block是自己设置的basicblock或者bottleneck,将block添加到layers中
        # blocks是自己设置的有多少个块,也就是有多少个basicblock或者bottleneck
        #  block.expansion在basicblock中的expansion是1,在bottleneck中的expansion是4
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inpanes, planes))
        # nn.Sequential(*layers)包含layers的顺序模型,按照顺序排列的
        return nn.Sequential(*layers)
    # x.view(x.size(0), -1),将二维张量重塑为一个一维张量,数量相同,也就是拉伸.

定义前向传播

    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

试一下打印

resnet18 = ResNet(BasicBlock, [2, 2, 2, 2])
print(resnet18)

打印

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=True)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AvgPool2d(kernel_size=7, stride=7, padding=0)
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)

这一步很重要，这里第一个模块（conv2d(inplanes,planes)）,之后通过 self.inplanes = planes * block.expansion变成了conv2d(planes,planes)

 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))

优游涵泳斋

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
resnet50网络搭建

它分成两个基本模块，一个是basic block，另一个是bottle neck模块，一般层数较低的用basicblock搭建，层数较深的用bottle neck模块，resnet50用的是bottleneck搭建的，两个模块的网络结构如图下。为什么有多余的一个边，通俗讲就是为了可以搭建更深的网络，采用F(X)+X求它的梯度比F(X)的梯度更不容易导致梯度下降。另一种说法是当这一层的卷积权重不那么重要的时候就可以直接连接下一部分，也就是那条多的线，而忽略掉卷积权重这一部分。结果与图2的网络结构是一致的。
复制链接

扫一扫