pytorch实战5：基于pytorch复现ResNet

最新推荐文章于 2023-03-17 10:35:49 发布

自学小白菜

最新推荐文章于 2023-03-17 10:35:49 发布

阅读量899

点赞数 4

分类专栏： pytorch学习笔记文章标签： pytorch 深度学习 python

本文链接：https://blog.csdn.net/weixin_46676835/article/details/128745885

版权

pytorch学习笔记专栏收录该内容

14 篇文章 38 订阅

订阅专栏

基于pytorch复现ResNet

前言

最近在看经典的卷积网络架构，打算自己尝试复现一下，在此系列文章中，会参考很多文章，有些已经忘记了出处，所以就不贴链接了，希望大家理解。

后期会补上使用数据训练的代码。

完整的代码在最后。

本系列必须的基础

python基础知识、CNN原理知识、pytorch基础知识

本系列的目的

一是帮助自己巩固知识点；

二是自己实现一次，可以发现很多之前的不足；

三是希望可以给大家一个参考。

目录结构

文章目录

- 基于pytorch复现ResNet

1. 残差模型介绍：

标准的结构为：

在这里插入图片描述

稍微修改一下：（引入了1*1卷积层，用于修改通道数）

在这里插入图片描述

2. 各种ResNet介绍：

图片来自网络：

在这里插入图片描述

注意，上面除去18、34外，其余的都是1*1-3*3-1*1的结构，并且第一层都是64个卷积核，第二层不变，第三层扩大四倍。

另外，18、34层的ResNet，第一个block块后的输出和第二个block的输入相同，因此不需要特别处理，但是对于50、101、152层的就需要特别处理，后面可以看代码注释。

3. 模型构建：

参考文献：

官方代码

https://blog.csdn.net/weixin_43940163/article/details/103760294
https://blog.csdn.net/x1027105273/article/details/123466082?spm=1001.2101.3001.6650.12&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-12-123466082-blog-103760294.pc_relevant_recovery_v2&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-12-123466082-blog-103760294.pc_relevant_recovery_v2&utm_relevant_index=13

首先，还是构建block块：

# 创建block块
class My_Res_Block(nn.Module):
    def __init__(self,in_planes,out_planes,stride=1,downsample=None):
        '''
        :param in_planes: 输入通道数
        :param out_planes:  输出通道数
        :param stride:  步长，默认为1
        :param downsample: 是否下采样，主要是为了res+x中两者大小一样，可以正常相加
        '''
        super(My_Res_Block, self).__init__()
        self.model = nn.Sequential(
            # 第一层是1*1卷积层：只改变通道数，不改变大小
            nn.Conv2d(in_planes,out_planes,kernel_size=1,stride=1),
            nn.BatchNorm2d(out_planes),
            nn.ReLU(),
            # 第二层为3*3卷积层，根据上图的介绍，可以看出输入和输出通道数是相同的
            nn.Conv2d(out_planes,out_planes,kernel_size=3,stride=stride,padding=1),
            nn.BatchNorm2d(out_planes),
            nn.ReLU(),
            # 第三层1*1卷积层，输出通道数扩大四倍（上图中由64->256）
            nn.Conv2d(out_planes,out_planes*4,kernel_size=1,stride=1),
            nn.BatchNorm2d(out_planes*4),
            nn.ReLU(),
        )
        self.relu = nn.ReLU()
        self.downsample = downsample

    def forward(self,x):
        res = x
        result = self.model(x)
        # 是否需要下采样来保证res与result可以正常相加
        if self.downsample is not None:
            res = self.downsample(x)
        # 残差相加
        result += res
        # 最后还有一步relu
        result = self.relu(result)
        return result

接着，来实现ResNet模型：

# 创建ResNet模型
class My_ResNet(nn.Module):
    def __init__(self,layers=50,num_classes=1000,in_planes=64):
        '''
        :param layers:  我们ResNet的层数，比如常见的50、101等
        :param num_classes:  最后输出的类别数，就是softmax层的输出数目
        :param in_planes: 我们的block第一个卷积层使用的通道个数
        '''
        super(My_ResNet, self).__init__()
        # 定义一个字典，来存储不同resnet对应的block的个数
        # 在官方实现中，使用另外一个参数来接收，这里参考博客，采用一个字典来接收，都类似
        self.layers_dict = {
            50: [3,4,6,3],
            101: [3,4,23,3],
        }
        self.in_planes = in_planes
        # 最开始的一层，还没有进入block
        # 输入彩色，通道为3；输出为指定的
        self.conv1 = nn.Conv2d(3,self.in_planes,kernel_size=7,stride=2,padding=3)
        self.bn1 = nn.BatchNorm2d(self.in_planes)
        self.relu = nn.ReLU()
        # 根据网络结构要求，大小变为一半
        self.maxPool = nn.MaxPool2d(kernel_size=3,stride=2,padding=1)
        # 进入block层
        self.block1 = self.make_layers(self.layers_dic[layers][0], stride=1, planes=64)
        self.block2 = self.make_layers(self.layers_dic[layers][1], stride=2, planes=128)
        self.block3 = self.make_layers(self.layers_dic[layers][2], stride=2, planes=256)
        self.block4 = self.make_layers(self.layers_dic[layers][1], stride=2, planes=512)
        # 要经历一个平均池化层
        self.avgpool = nn.AvgPool2d(7, stride=1)
        # 最后接上一个全连接输出层
        self.fc = nn.Linear(512 * 4, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_x', nonlinearity='relu')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)


    def _make_layer(self,layers,stride,planes):
        '''
        :param planes: 最开始卷积核使用的通道数
        :param stride: 步长
        :param layers:该层bloack有多少个重复的
        :return:
        '''
        downsample = None
        # 判断是否需要下采样
        if stride != 1 or self.inplanes != planes*4 :
            downsample = nn.Sequential(
                nn.Conv2d(self.in_planes, planes * 4, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * 4),
            )
        layers = []
        # 创建第一个block，第一个参数为输入的通道数，第二个参数为第一个卷积核的通道数
        layers.append(My_Res_Block(self.in_planes, planes, stride, downsample))
        # 输出扩大4倍
        self.in_planes = self.in_planes * 4
        # 对于18，34层的网络，经过第一个残差块后，输出的特征矩阵通道数与第一层的卷积层个数一样
        # 对于50，101，152层的网络，经过第一个残差块后，输出的特征矩阵通道数时第一个卷积层的4倍,因此要将后续残差块的输入特征矩阵通道数调整过来
        for i in range(1, layers):
            # 输入*4，输出变为最初的
            layers.append(My_Res_Block(self.in_planes, planes))
        return nn.Sequential(*layers) # 将列表解码

    def forward(self,x):
        # conv1
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)

        # conv2_x
        x = self.maxPool(x)
        x = self.block1(x)

        # conv3_x
        x = self.block2(x)

        # conv4_x
        x = self.block3(x)

        # conv5_x
        x = self.block4(x)

        # average pool and fc
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)

        return x

4. 总结：

相比于之前实现的网络，ResNet模型还是比较复杂的，因此写起来也是有点困难，外加官方的代码注释不详细，所以参考了很多的文章。有所借鉴。

完整代码：

# author: baiCai
# 导包
import torch
from torch import nn
from torchvision.models import ResNet

# 创建block块
class My_Res_Block(nn.Module):
    def __init__(self,in_planes,out_planes,stride=1,downsample=None):
        '''
        :param in_planes: 输入通道数
        :param out_planes:  输出通道数
        :param stride:  步长，默认为1
        :param downsample: 是否下采样，主要是为了res+x中两者大小一样，可以正常相加
        '''
        super(My_Res_Block, self).__init__()
        self.model = nn.Sequential(
            # 第一层是1*1卷积层：只改变通道数，不改变大小
            nn.Conv2d(in_planes,out_planes,kernel_size=1,stride=1),
            nn.BatchNorm2d(out_planes),
            nn.ReLU(),
            # 第二层为3*3卷积层，根据上图的介绍，可以看出输入和输出通道数是相同的
            nn.Conv2d(out_planes,out_planes,kernel_size=3,stride=stride,padding=1),
            nn.BatchNorm2d(out_planes),
            nn.ReLU(),
            # 第三层1*1卷积层，输出通道数扩大四倍（上图中由64->256）
            nn.Conv2d(out_planes,out_planes*4,kernel_size=1,stride=1),
            nn.BatchNorm2d(out_planes*4),
            nn.ReLU(),
        )
        self.relu = nn.ReLU()
        self.downsample = downsample

    def forward(self,x):
        res = x
        result = self.model(x)
        # 是否需要下采样来保证res与result可以正常相加
        if self.downsample is not None:
            res = self.downsample(x)
        # 残差相加
        result += res
        # 最后还有一步relu
        result = self.relu(result)
        return result
    
# 创建ResNet模型
class My_ResNet(nn.Module):
    def __init__(self,layers=50,num_classes=1000,in_planes=64):
        '''
        :param layers:  我们ResNet的层数，比如常见的50、101等
        :param num_classes:  最后输出的类别数，就是softmax层的输出数目
        :param in_planes: 我们的block第一个卷积层使用的通道个数
        '''
        super(My_ResNet, self).__init__()
        # 定义一个字典，来存储不同resnet对应的block的个数
        # 在官方实现中，使用另外一个参数来接收，这里参考博客，采用一个字典来接收，都类似
        self.layers_dict = {
            50: [3,4,6,3],
            101: [3,4,23,3],
        }
        self.in_planes = in_planes
        # 最开始的一层，还没有进入block
        # 输入彩色，通道为3；输出为指定的
        self.conv1 = nn.Conv2d(3,self.in_planes,kernel_size=7,stride=2,padding=3)
        self.bn1 = nn.BatchNorm2d(self.in_planes)
        self.relu = nn.ReLU()
        # 根据网络结构要求，大小变为一半
        self.maxPool = nn.MaxPool2d(kernel_size=3,stride=2,padding=1)
        # 进入block层
        self.block1 = self.make_layers(self.layers_dic[layers][0], stride=1, planes=64)
        self.block2 = self.make_layers(self.layers_dic[layers][1], stride=2, planes=128)
        self.block3 = self.make_layers(self.layers_dic[layers][2], stride=2, planes=256)
        self.block4 = self.make_layers(self.layers_dic[layers][1], stride=2, planes=512)
        # 要经历一个平均池化层
        self.avgpool = nn.AvgPool2d(7, stride=1)
        # 最后接上一个全连接输出层
        self.fc = nn.Linear(512 * 4, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_x', nonlinearity='relu')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)


    def _make_layer(self,layers,stride,planes):
        '''
        :param planes: 最开始卷积核使用的通道数
        :param stride: 步长
        :param layers:该层bloack有多少个重复的
        :return:
        '''
        downsample = None
        # 判断是否需要下采样
        if stride != 1 or self.inplanes != planes*4 :
            downsample = nn.Sequential(
                nn.Conv2d(self.in_planes, planes * 4, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * 4),
            )
        layers = []
        # 创建第一个block，第一个参数为输入的通道数，第二个参数为第一个卷积核的通道数
        layers.append(My_Res_Block(self.in_planes, planes, stride, downsample))
        # 输出扩大4倍
        self.in_planes = self.in_planes * 4
        # 对于18，34层的网络，经过第一个残差块后，输出的特征矩阵通道数与第一层的卷积层个数一样
        # 对于50，101，152层的网络，经过第一个残差块后，输出的特征矩阵通道数时第一个卷积层的4倍,因此要将后续残差块的输入特征矩阵通道数调整过来
        for i in range(1, layers):
            # 输入*4，输出变为最初的
            layers.append(My_Res_Block(self.in_planes, planes))
        return nn.Sequential(*layers) # 将列表解码

    def forward(self,x):
        # conv1
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)

        # conv2_x
        x = self.maxPool(x)
        x = self.block1(x)

        # conv3_x
        x = self.block2(x)

        # conv4_x
        x = self.block3(x)

        # conv5_x
        x = self.block4(x)

        # average pool and fc
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)

        return x
'''
参考文章：
https://blog.csdn.net/x1027105273/article/details/123466082?spm=1001.2101.3001.6650.12&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-12-123466082-blog-103760294.pc_relevant_recovery_v2&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-12-123466082-blog-103760294.pc_relevant_recovery_v2&utm_relevant_index=13
https://blog.csdn.net/weixin_43940163/article/details/103760294
'''