ResNet详解及ResNet18在FashionMinist上代码实现_resnet18论文

论文部分

以前出现的问题及ResNet如何解决

在2015年之前，如果是卷积神经网络的话只顾加深加宽，导致的问题就是梯度消失或者梯度爆炸。那么一个接近办法是初始的权重不要特别大，也不要特别小。包括在中间加入一些BatchNormalization（也就是BN层），是可以训练一些相对较深的网络的。这样是能训练的，但是是说在网络加深的时候，性能是在变差的。如下图所示：

并且这种情况不是过拟合，因为训练集上的误差也变高了。（如果是训练集误差低测试集误差高的话就是过拟合，欠拟合就对应训练集误差高测试集误差高，也就是性能变差了）
按理说如果浅的网络效果好，在此基础上加更多网络效果应该会是更好的，不应该会变差。那么对于一个更深的网络而言，我们完全可以做一个identity mapping，也就是让多出来的更深的网络什么事也不做的话，深层的网络可以保持一个和浅层的网络一样的效果，至少是等于浅层网络的精确度，但实际上去做的时候，发现sgd是做不到的。
而现在的话，我们是显式的去做这么一个identity mapping，从而去保证深的网络效果不会比浅的网络效果差。

具体是这么做的：可以假设原先的浅层网络输出为x，所需的底层映射为H(x)，我们令新加的网络映射为F(x)，那么这里新的网络映射F(x)其实就等于H(x)-x。所以说这里的这么一个块叫做残差块，做的就是学习映射后的数据与真实输入数据的一个残差。这就是Resnet两种基本结构之一 building block，还有一种基础残差块(bottleneck building block)后面会介绍。
所以可以看到和普通的深层卷积神经网络对比的话，其实就是加了旁边一条路（identity mapping）。
那么说这个多加的identity mapping好在哪呢，由于没有多加多余的参数，不会增加模型复杂度，不会增加多余的计算。
所以，关于ResNet论文中主要的一点，就是提出了residual connect。

然后有输入和输出不匹配的时候，残差连接是怎么做的。
1.在输入和输出上分别添0，使得能够匹配维度，然后可以做相加。
2.做投影，卷积上做投影是通过1x1的卷积层，1x1的卷积层特点是：在空间上不做任何事情，主要是在通道维度上改变。这样使得输出通道是输入通道的两倍。（如果是在卷积中，如果输出的通道数变为了两倍，那么输入的高宽都会变为原先的一半，所以我们在使用1x1的卷积的时候，使用步幅为2，这样输出的通道、高和宽都能对应上了）。
没有用dropout，因为没有全连接层，所以这里的话就没用。

具体网络部分

论文中其实主要提出了五种ResNet，可以发现ResNet18和ResNet34使用的基础的残差块都是一样的，也就是在残差块都是在只有两层的基础上。而ResNet50，ResNet101，ResNet152可以发现里面都是残差块为3层的基础上。以ResNet18为例，为什么是18层呢，可以看到一开始有个初始的卷积，也就是conv1，每个网络都会有的，后面四个卷积层，每个里面包含了两个残差块，每个残差块里面均有两个卷积层，最后还有个全局池化，1000维的一个全连接，再经过softmax进行分类。故层数为1+4x2x2+1=18，没有参数的池化就不算层。
ResNet中常用的两个残差块：building block和BottleNeck building block。为什么要有两种残缺块，一种不行吗，从上图中我们可以很明显的看到，在ResNet层数较少的时候，也就是18,34层的时候使用的是building block，而在层数较深的时候使用的是BottleNeck building block，那么这么做的好处是什么呢？原因就在于BottleNeck building block使用的结构不一样，从而在网络较深的时候减少了参数量，上表的最后一行代表的就是模型的一个总参数量FLOPs。从结论上来看，34层的ResNet和50层的ResNet参数量是差不多的。这其实就是50层的ResNet使用的是BottleNeck building block，而34层的ResNet使用的是building block。下面介绍ResNet中间shape的变化，以此来感受使用不同残差模块的一个参数量的变化。

ResNet中间shape的变化

下面是介绍中间层的一个feature map变化情况及残差连接是如何做的（以上图中ResNet18为例，3x224x224作为原始输入）：
可以看到相关的卷积层中输出shape的变化：
图像宽为W，高为H，通道数为C；
卷积核尺寸为K，通道数为D，个数为N；
卷积运算步长为S，填充大小为P；
输入和输出量分别以1和2表示。

卷积：
W2 = (W1 - K + 2×P) / S + 1
H2 = (H1 - K + 2×P) / S + 1
C2 = N

1.3x224x224的输入经过一个7x7x64的卷积，由于步幅S为2，W1=224，卷积核尺寸K=7，填充大小P=3，那么计算出W2为112，同理H2也为112，输出的通道数C2等于卷积核的个数N，即C2=N=64。
2.同样是在别的卷积层，只要知道了对应的W，H，S，P，那么对应的输出的W，H就可以知道了，而输出的通道即为卷积核的个数。
关于卷积核的具体细节参数参考何大神的论文，在下面的代码中也有体现，比如padding、dilation和stride。

代码部分

代码实验环境

基于pytorch框架，显卡为RTX 2060。torch版本1.10.0，torchvision版本为0.11.1。

两种基础残差块

1.building block
（也就是在较为浅层的ResNet18和ResNet34中出现的模块）

class ResidualBlock(nn.Module):
    def __init__(self, in_channels):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(in_channels)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(in_channels)

    def forward(self, x):
        residual = self.conv1(x)
        residual = self.bn1(residual)
        residual = self.relu(residual)
        residual = self.conv2(residual)
        residual = self.bn2(residual)     
        out = self.relu(x + residual)
        return out
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.building block
（也就是在较为深层的ResNet50、ResNet101和ResNet152中出现的模块）

class BottleNeck(nn.Module):
    def __init__(self,in_channels):
        super(BottleNeck, self).__init__()
        self.main = nn.Sequential(
            nn.Conv2d(in_channels,64,kernel_size=1,stride=1,padding=0),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            
            nn.Conv2d(64,64,kernel_size=3,stride=1,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),

            nn.Conv2d(63,in_channels,kernel_size=1,stride=1,padding=0),
            nn.BatchNorm2d(in_channels),
        )
        self.shortcut = nn.Sequential()

    def forward(self,x):
        shortcut = self.shortcut(x) 
        residual = self.main(x) 
        out = nn.ReLU(shortcut + residual )
        return out 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

ResNet18在FashionMinist上的整体代码

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader,Dataset
from torchvision import transforms
from d2l import torch as d2l
from torch.nn import functional as F

#数据集
def load_data_fashion_mnist(batch_size,resize):
    trans = []
    if resize:
        trans.append(transforms.Resize(size=resize))
    trans.append(transforms.ToTensor())
    transform = transforms.Compose(trans)
    #准备数据集
    train_data = torchvision.datasets.FashionMNIST(root='./data', train=True, transform=transform,
                                                   download=True)
    test_data = torchvision.datasets.FashionMNIST(root='./data', train=False, transform=transform,
                                                  download=True)
    #加载数据集
    train_dataloader = DataLoader(dataset=train_data,batch_size=batch_size,shuffle=True)
    test_dataloader = DataLoader(dataset=test_data,batch_size=batch_size,shuffle=False)

    return train_dataloader,test_dataloader

#搭建网络
class Residual(nn.Module):
    def __init__(self, input_channels, num_channels, use_1x1conv=False,
                 strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=3,
                               padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3,
                               padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

def resnet_block(input_channels, num_channels, num_residuals,
                 first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(
                Residual(input_channels, num_channels, use_1x1conv=True,
                         strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk

b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

net = nn.Sequential(b1, b2, b3, b4, b5, nn.AdaptiveAvgPool2d((1, 1)),
                    nn.Flatten(), nn.Linear(512, 10))

#Accumulator 实例中创建了 2 个变量，用于分别存储正确预测的数量和预测的总数量
class Accumulator:
    """在`n`个变量上累加。"""
    def __init__(self, n):
        self.data = [0.0] * n

    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]


#GPU训练
def try_gpu(i=0):
    if torch.cuda.device_count() >= 1:
        return torch.device(f'cuda:{i}')
    return torch.device('cpu')


#计算预测正确的数量
def accuracy(y_hat,y):
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

#使用GPU计算模型在数据集上的精度
def evaluate_accuracy_gpu(net,data_iter,device=None):
    if isinstance(net,nn.Module):
        net.eval()   #设置为评估模式
        if not device:
            device = next(iter(net.parameters())).device
    #正确预测的数量，总预测的数量
    metric = Accumulator(2)
    with torch.no_grad():
        for X,y in data_iter:
            if isinstance(X,list):
                X = [x.to(device) for x in X]
            else:
                X = X.to(device)
            y = y.to(device)
            metric.add(accuracy(net(X),y),y.numel())
    return metric[0]/metric[1]

def train(net, train_iter, test_iter, num_epochs, lr, device):
    """用GPU训练模型(在第六章定义)。"""
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)

    net.apply(init_weights)
    print('training on', device)
    net.to(device)
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=['train loss', 'train acc', 'test acc'])
    timer, num_batches = d2l.Timer(), len(train_iter)
    for epoch in range(num_epochs):
        metric = Accumulator(3)
        net.train()
        for i, (X, y) in enumerate(train_iter):
            timer.start()
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward()
            optimizer.step()
            with torch.no_grad():
                metric.add(l * X.shape[0], accuracy(y_hat, y), X.shape[0])
            timer.stop()
            train_l = metric[0] / metric[2]
            train_acc = metric[1] / metric[2]
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (train_l, train_acc, None))
        test_acc = evaluate_accuracy_gpu(net, test_iter)
        animator.add(epoch + 1, (None, None, test_acc))
    print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
          f'test acc {test_acc:.3f}')
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
          f'on {str(device)}')


if __name__ == '__main__':
    batch_size = 256
    lr = 0.05
    num_epochs = 10
    train_iter,test_iter = load_data_fashion_mnist(batch_size=batch_size,resize=96)
    train(net,train_iter=train_iter,test_iter=test_iter,num_epochs=num_epochs,lr=lr,device=try_gpu())
    d2l.plt.show()
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

最后的运行结果：

问题及思考

1.sgd为什么做不到在深层网络的效果比浅层网络好？
自我理解：比如说在20层的网络和34层网络的一个情况下，假设20层的网络效果较好，34层的效果不好。那么后14层依旧是有参数的，由于前20层效果已经较好了，那么这些参数在学习的时候依旧发挥作用，在计算梯度的时候依旧参与其中，那么导致而来的是一个梯度消失，梯度消失导致的效果就是模型训练不动了，因为参数没有变化了或者说变化很小，所以整体导致的效果就是反而没有浅层的网络效果好。
2.为什么ResNet论文当中给出的经典模型层数为18,34,50,101,152，而不是别的层数，以及它的一个残差块堆叠方式为什么是那样的？
自我理解：调参大法好，何大神给出这样的网络想必也是花了不少的时间精力调参 的。

参考

本文参考了如下资料，学习整理而得，但是仍有颇多不足之处，欢迎大家批判指出错误。
视频：李沐：跟我动手学深度学习
论文：HE K, ZHANG X, REN S, et al. Deep Residual Learning for Image Recognition[C]//2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR).2016:770-778. 10.1109/CVPR.2016.90.
博客：https://blog.csdn.net/a_piece_of_ppx/article/details/125960098
博客：https://zhuanlan.zhihu.com/p/549010081
博客：https://blog.csdn.net/qq_42103167/article/details/105056598