devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ResNet代码复现＋超详细注释（PyTorch）

作者：小小林熬夜学编程 | 2024-05-20 15:06:01

赞

踩

resnet代码复现

关于ResNet的原理和具体细节，可参见上篇解读：经典神经网络论文超详细解读（五）——ResNet（残差网络）学习笔记（翻译＋精读＋代码复现）

接下来我们就来复现一下代码。

源代码比较复杂，感兴趣的同学可以上官网学习： 

https://github.com/pytorch/vision/tree/master/torchvision

本篇是简化版本 

 一、BasicBlock模块

BasicBlock结构图如图所示：

 BasicBlock是基础版本，主要用来构建ResNet18和ResNet34网络，里面只包含两个卷积层，使用了两个 3*3 的卷积，通道数都是64，卷积后接着 BN 和 ReLU。

右边的曲线就是Shortcut Connections，将输入x加到输出。

代码：

  1. '''-------------一、BasicBlock模块-----------------------------'''
  2. # 用于ResNet18和ResNet34基本残差结构块
  3. class BasicBlock(nn.Module):
  4.     def __init__(self, inchannel, outchannel, stride=1):
  5.         super(BasicBlock, self).__init__()
  6.         self.left = nn.Sequential(
  7.             nn.Conv2d(inchannel, outchannel, kernel_size=3, stride=stride, padding=1, bias=False),
  8.             nn.BatchNorm2d(outchannel),
  9.             nn.ReLU(inplace=True), #inplace=True表示进行原地操作，一般默认为False，表示新建一个变量存储操作
  10.             nn.Conv2d(outchannel, outchannel, kernel_size=3, stride=1, padding=1, bias=False),
  11.             nn.BatchNorm2d(outchannel)
  12.         )
  13.         self.shortcut = nn.Sequential()
  14.         #论文中模型架构的虚线部分，需要下采样
  15.         if stride != 1 or inchannel != outchannel:
  16.             self.shortcut = nn.Sequential(
  17.                 nn.Conv2d(inchannel, outchannel, kernel_size=1, stride=stride, bias=False),
  18.                 nn.BatchNorm2d(outchannel)
  19.             )
  20.  
  21.     def forward(self, x):
  22.         out = self.left(x) #这是由于残差块需要保留原始输入
  23.         out += self.shortcut(x)#这是ResNet的核心，在输出上叠加了输入x
  24.         out = F.relu(out)
  25.         return out

二、Bottleneck 模块

Bottleneck结构图如图所示：

Bottleneck主要用在ResNet50及以上的网络结构，与BasicBlock不同的是这里有 3 个卷积，分别为 1*1，3*3，1*1大小的卷积核，分别用于压缩维度、卷积处理、恢复维度。
这里的通道数是变化的，1*1卷积层的作用就是用于改变特征图的通数，使得可以和恒等映射x相叠加，另外这里的1*1卷积层改变维度的很重要的一点是可以降低网络参数量，这也是为什么更深层的网络采用BottleNeck而不是BasicBlock的原因。

注意：这里outchannel / 4是因为Bottleneck层输出通道都是输入的4倍

代码：

  1. '''-------------二、Bottleneck模块-----------------------------'''
  2. # 用于ResNet50及以上的残差结构块
  3. class Bottleneck(nn.Module):
  4.     def __init__(self, inchannel, outchannel, stride=1):
  5.         super(Bottleneck, self).__init__()
  6.         self.left = nn.Sequential(
  7.             nn.Conv2d(inchannel, int(outchannel / 4), kernel_size=1, stride=stride, padding=0, bias=False),
  8.             nn.BatchNorm2d(int(outchannel / 4)),
  9.             nn.ReLU(inplace=True),
  10.             nn.Conv2d(int(outchannel / 4), int(outchannel / 4), kernel_size=3, stride=1, padding=1, bias=False),
  11.             nn.BatchNorm2d(int(outchannel / 4)),
  12.             nn.ReLU(inplace=True),
  13.             nn.Conv2d(int(outchannel / 4), outchannel, kernel_size=1, stride=1, padding=0, bias=False),
  14.             nn.BatchNorm2d(outchannel),
  15.         )
  16.         self.shortcut = nn.Sequential()
  17.         if stride != 1 or inchannel != outchannel:
  18.             self.shortcut = nn.Sequential(
  19.                 nn.Conv2d(inchannel, outchannel, kernel_size=1, stride=stride, bias=False),
  20.                 nn.BatchNorm2d(outchannel)
  21.             )
  22.  
  23.     def forward(self, x):
  24.         out = self.left(x)
  25.         y = self.shortcut(x)
  26.         out += self.shortcut(x)
  27.         out = F.relu(out)
  28.         return out

三、ResNet主体

介绍了上述BasicBlock基础块和BotteNeck结构后，我们就可以搭建ResNet结构了。

5种不同层数的ResNet结构图如图所示：

代码： 

ResNet18

  1. '''----------ResNet18----------'''
  2. class ResNet_18(nn.Module):
  3.     def __init__(self, ResidualBlock, num_classes=10):
  4.         super(ResNet_18, self).__init__()
  5.         self.inchannel = 64
  6.         self.conv1 = nn.Sequential(
  7.             nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
  8.             nn.BatchNorm2d(64),
  9.             nn.ReLU(),
  10.         )
  11.         self.layer1 = self.make_layer(ResidualBlock, 64, 2, stride=1)
  12.         self.layer2 = self.make_layer(ResidualBlock, 128, 2, stride=2)
  13.         self.layer3 = self.make_layer(ResidualBlock, 256, 2, stride=2)
  14.         self.layer4 = self.make_layer(ResidualBlock, 512, 2, stride=2)
  15.         self.fc = nn.Linear(512, num_classes)
  16.  
  17.     def make_layer(self, block, channels, num_blocks, stride):
  18.         strides = [stride] + [1] * (num_blocks - 1)  # strides=[1,1]
  19.         layers = []
  20.         for stride in strides:
  21.             layers.append(block(self.inchannel, channels, stride))
  22.             self.inchannel = channels
  23.         return nn.Sequential(*layers)
  24.  
  25.     def forward(self, x):  # 3*32*32
  26.         out = self.conv1(x)  # 64*32*32
  27.         out = self.layer1(out)  # 64*32*32
  28.         out = self.layer2(out)  # 128*16*16
  29.         out = self.layer3(out)  # 256*8*8
  30.         out = self.layer4(out)  # 512*4*4
  31.         out = F.avg_pool2d(out, 4)  # 512*1*1
  32.         out = out.view(out.size(0), -1)  # 512
  33.         out = self.fc(out)
  34.         return out

ResNet34

  1. '''----------ResNet34----------'''
  2. class ResNet_34(nn.Module):
  3.     def __init__(self, ResidualBlock, num_classes=10):
  4.         super(ResNet_34, self).__init__()
  5.         self.inchannel = 64
  6.         self.conv1 = nn.Sequential(
  7.             nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
  8.             nn.BatchNorm2d(64),
  9.             nn.ReLU(),
  10.         )
  11.         self.layer1 = self.make_layer(ResidualBlock, 64, 3, stride=1)
  12.         self.layer2 = self.make_layer(ResidualBlock, 128, 4, stride=2)
  13.         self.layer3 = self.make_layer(ResidualBlock, 256, 6, stride=2)
  14.         self.layer4 = self.make_layer(ResidualBlock, 512, 3, stride=2)
  15.         self.fc = nn.Linear(512, num_classes)
  16.  
  17.     def make_layer(self, block, channels, num_blocks, stride):
  18.         strides = [stride] + [1] * (num_blocks - 1)  # strides=[1,1]
  19.         layers = []
  20.         for stride in strides:
  21.             layers.append(block(self.inchannel, channels, stride))
  22.             self.inchannel = channels
  23.         return nn.Sequential(*layers)
  24.  
  25.     def forward(self, x):  # 3*32*32
  26.         out = self.conv1(x)  # 64*32*32
  27.         out = self.layer1(out)  # 64*32*32
  28.         out = self.layer2(out)  # 128*16*16
  29.         out = self.layer3(out)  # 256*8*8
  30.         out = self.layer4(out)  # 512*4*4
  31.         out = F.avg_pool2d(out, 4)  # 512*1*1
  32.         out = out.view(out.size(0), -1)  # 512
  33.         out = self.fc(out)
  34.         return out
  35.

ResNet50

  1. '''---------ResNet50--------'''
  2. class ResNet_50(nn.Module):
  3.     def __init__(self, ResidualBlock, num_classes=10):
  4.         super(ResNet_50, self).__init__()
  5.         self.inchannel = 64
  6.         self.conv1 = nn.Sequential(
  7.             nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
  8.             nn.BatchNorm2d(64),
  9.             nn.ReLU(),
  10.         )
  11.         self.layer1 = self.make_layer(ResidualBlock, 256, 3, stride=1)
  12.         self.layer2 = self.make_layer(ResidualBlock, 512, 4, stride=2)
  13.         self.layer3 = self.make_layer(ResidualBlock, 1024, 6, stride=2)
  14.         self.layer4 = self.make_layer(ResidualBlock, 2048, 3, stride=2)
  15.         self.fc = nn.Linear(512 * 4, num_classes)
  16.         # **************************
  17.  
  18.     def make_layer(self, block, channels, num_blocks, stride):
  19.         strides = [stride] + [1] * (num_blocks - 1)  # strides=[1,1]
  20.         layers = []
  21.         for stride in strides:
  22.             layers.append(block(self.inchannel, channels, stride))
  23.             self.inchannel = channels
  24.         return nn.Sequential(*layers)
  25.  
  26.     def forward(self, x):  # 3*32*32
  27.         out = self.conv1(x)  # 64*32*32
  28.         out = self.layer1(out)  # 64*32*32
  29.         out = self.layer2(out)  # 128*16*16
  30.         out = self.layer3(out)  # 256*8*8
  31.         out = self.layer4(out)  # 512*4*4
  32.         out = F.avg_pool2d(out, 4)  # 512*1*1
  33.         # print(out.size())
  34.         out = out.view(out.size(0), -1)  # 512
  35.         out = self.fc(out)
  36.         return out

四、完整代码

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  4.  
  5.  
  6. '''-------------一、BasicBlock模块-----------------------------'''
  7. # 用于ResNet18和ResNet34基本残差结构块
  8. class BasicBlock(nn.Module):
  9.     def __init__(self, inchannel, outchannel, stride=1):
  10.         super(BasicBlock, self).__init__()
  11.         self.left = nn.Sequential(
  12.             nn.Conv2d(inchannel, outchannel, kernel_size=3, stride=stride, padding=1, bias=False),
  13.             nn.BatchNorm2d(outchannel),
  14.             nn.ReLU(inplace=True), #inplace=True表示进行原地操作，一般默认为False，表示新建一个变量存储操作
  15.             nn.Conv2d(outchannel, outchannel, kernel_size=3, stride=1, padding=1, bias=False),
  16.             nn.BatchNorm2d(outchannel)
  17.         )
  18.         self.shortcut = nn.Sequential()
  19.         #论文中模型架构的虚线部分，需要下采样
  20.         if stride != 1 or inchannel != outchannel:
  21.             self.shortcut = nn.Sequential(
  22.                 nn.Conv2d(inchannel, outchannel, kernel_size=1, stride=stride, bias=False),
  23.                 nn.BatchNorm2d(outchannel)
  24.             )
  25.  
  26.     def forward(self, x):
  27.         out = self.left(x) #这是由于残差块需要保留原始输入
  28.         out += self.shortcut(x)#这是ResNet的核心，在输出上叠加了输入x
  29.         out = F.relu(out)
  30.         return out
  31.  
  32.  
  33. '''-------------二、Bottleneck模块-----------------------------'''
  34. # 用于ResNet50及以上的残差结构块
  35. class Bottleneck(nn.Module):
  36.     def __init__(self, inchannel, outchannel, stride=1):
  37.         super(Bottleneck, self).__init__()
  38.         self.left = nn.Sequential(
  39.             nn.Conv2d(inchannel, int(outchannel / 4), kernel_size=1, stride=stride, padding=0, bias=False),
  40.             nn.BatchNorm2d(int(outchannel / 4)),
  41.             nn.ReLU(inplace=True),
  42.             nn.Conv2d(int(outchannel / 4), int(outchannel / 4), kernel_size=3, stride=1, padding=1, bias=False),
  43.             nn.BatchNorm2d(int(outchannel / 4)),
  44.             nn.ReLU(inplace=True),
  45.             nn.Conv2d(int(outchannel / 4), outchannel, kernel_size=1, stride=1, padding=0, bias=False),
  46.             nn.BatchNorm2d(outchannel),
  47.         )
  48.         self.shortcut = nn.Sequential()
  49.         if stride != 1 or inchannel != outchannel:
  50.             self.shortcut = nn.Sequential(
  51.                 nn.Conv2d(inchannel, outchannel, kernel_size=1, stride=stride, bias=False),
  52.                 nn.BatchNorm2d(outchannel)
  53.             )
  54.  
  55.     def forward(self, x):
  56.         out = self.left(x)
  57.         y = self.shortcut(x)
  58.         out += self.shortcut(x)
  59.         out = F.relu(out)
  60.         return out
  61.  
  62. '''-------------ResNet18---------------'''
  63. class ResNet_18(nn.Module):
  64.     def __init__(self, ResidualBlock, num_classes=10):
  65.         super(ResNet_18, self).__init__()
  66.         self.inchannel = 64
  67.         self.conv1 = nn.Sequential(
  68.             nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
  69.             nn.BatchNorm2d(64),
  70.             nn.ReLU(),
  71.         )
  72.         self.layer1 = self.make_layer(ResidualBlock, 64, 2, stride=1)
  73.         self.layer2 = self.make_layer(ResidualBlock, 128, 2, stride=2)
  74.         self.layer3 = self.make_layer(ResidualBlock, 256, 2, stride=2)
  75.         self.layer4 = self.make_layer(ResidualBlock, 512, 2, stride=2)
  76.         self.fc = nn.Linear(512, num_classes)
  77.  
  78.     def make_layer(self, block, channels, num_blocks, stride):
  79.         strides = [stride] + [1] * (num_blocks - 1)  # strides=[1,1]
  80.         layers = []
  81.         for stride in strides:
  82.             layers.append(block(self.inchannel, channels, stride))
  83.             self.inchannel = channels
  84.         return nn.Sequential(*layers)
  85.  
  86.     def forward(self, x):  # 3*32*32
  87.         out = self.conv1(x)  # 64*32*32
  88.         out = self.layer1(out)  # 64*32*32
  89.         out = self.layer2(out)  # 128*16*16
  90.         out = self.layer3(out)  # 256*8*8
  91.         out = self.layer4(out)  # 512*4*4
  92.         out = F.avg_pool2d(out, 4)  # 512*1*1
  93.         out = out.view(out.size(0), -1)  # 512
  94.         out = self.fc(out)
  95.         return out
  96.  
  97. '''-------------ResNet34---------------'''
  98. class ResNet_34(nn.Module):
  99.     def __init__(self, ResidualBlock, num_classes=10):
  100.         super(ResNet_34, self).__init__()
  101.         self.inchannel = 64
  102.         self.conv1 = nn.Sequential(
  103.             nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
  104.             nn.BatchNorm2d(64),
  105.             nn.ReLU(),
  106.         )
  107.         self.layer1 = self.make_layer(ResidualBlock, 64, 3, stride=1)
  108.         self.layer2 = self.make_layer(ResidualBlock, 128, 4, stride=2)
  109.         self.layer3 = self.make_layer(ResidualBlock, 256, 6, stride=2)
  110.         self.layer4 = self.make_layer(ResidualBlock, 512, 3, stride=2)
  111.         self.fc = nn.Linear(512, num_classes)
  112.  
  113.     def make_layer(self, block, channels, num_blocks, stride):
  114.         strides = [stride] + [1] * (num_blocks - 1)  # strides=[1,1]
  115.         layers = []
  116.         for stride in strides:
  117.             layers.append(block(self.inchannel, channels, stride))
  118.             self.inchannel = channels
  119.         return nn.Sequential(*layers)
  120.  
  121.     def forward(self, x):  # 3*32*32
  122.         out = self.conv1(x)  # 64*32*32
  123.         out = self.layer1(out)  # 64*32*32
  124.         out = self.layer2(out)  # 128*16*16
  125.         out = self.layer3(out)  # 256*8*8
  126.         out = self.layer4(out)  # 512*4*4
  127.         out = F.avg_pool2d(out, 4)  # 512*1*1
  128.         out = out.view(out.size(0), -1)  # 512
  129.         out = self.fc(out)
  130.         return out
  131.  
  132. '''-------------ResNet50---------------'''
  133. class ResNet_50(nn.Module):
  134.     def __init__(self, ResidualBlock, num_classes=10):
  135.         super(ResNet_50, self).__init__()
  136.         self.inchannel = 64
  137.         self.conv1 = nn.Sequential(
  138.             nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
  139.             nn.BatchNorm2d(64),
  140.             nn.ReLU(),
  141.         )
  142.         self.layer1 = self.make_layer(ResidualBlock, 256, 3, stride=1)
  143.         self.layer2 = self.make_layer(ResidualBlock, 512, 4, stride=2)
  144.         self.layer3 = self.make_layer(ResidualBlock, 1024, 6, stride=2)
  145.         self.layer4 = self.make_layer(ResidualBlock, 2048, 3, stride=2)
  146.         self.fc = nn.Linear(512 * 4, num_classes)
  147.         # **************************
  148.  
  149.     def make_layer(self, block, channels, num_blocks, stride):
  150.         strides = [stride] + [1] * (num_blocks - 1)  # strides=[1,1]
  151.         layers = []
  152.         for stride in strides:
  153.             layers.append(block(self.inchannel, channels, stride))
  154.             self.inchannel = channels
  155.         return nn.Sequential(*layers)
  156.  
  157.     def forward(self, x):  # 3*32*32
  158.         out = self.conv1(x)  # 64*32*32
  159.         out = self.layer1(out)  # 64*32*32
  160.         out = self.layer2(out)  # 128*16*16
  161.         out = self.layer3(out)  # 256*8*8
  162.         out = self.layer4(out)  # 512*4*4
  163.         out = F.avg_pool2d(out, 4)  # 512*1*1
  164.         # print(out.size())
  165.         out = out.view(out.size(0), -1)  # 512
  166.         out = self.fc(out)
  167.         return out
  168.  
  169.  
  170. def ResNet18():
  171.     return ResNet_18(BasicBlock)
  172.  
  173.  
  174. def ResNet34():
  175.     return ResNet_34(BasicBlock)
  176.  
  177.  
  178. def ResNet50():
  179.     return ResNet_50(Bottleneck)

本篇到这里就结束啦，有什么问题，欢迎大家留言讨论~

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/598144
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号