pytorch实战5：基于pytorch复现ResNet_resnet pytorch实验复现

基于pytorch复现ResNet

前言

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

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

​ 完整的代码在最后。

本系列必须的基础

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

本系列的目的

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

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

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

目录结构

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
1
2

​ 首先，还是构建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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

​ 接着，来实现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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

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
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142