卷积神经网络六：ResNet

ResNet是2015年的ImageNet竞赛的冠军，由微软研究院的何凯明等人提出。ResNet，残差神经网络是一种通过残差块来构建的神经网络，通过残差模块可以训练152层以上的神经网络。事实上，残差神经网络的出现最终结束了ImageNet竞赛。自从残差网络提出后，后续几乎所有的神经网络都离不开残差，残差神经网络可以轻松训练几百层，甚至是上千层的网络。

残差网络ResNet最初的设计灵感来自于，在不断加深神经网络的时候，会出现一个Degradation，即准确率会先上升然后达到饱和，再增加深度则会导致模型准确率下降。这并不是过拟合的问题，因为不光是验证集上，就算是在训练集上也会出现类似的问题。其实这里面有一部分的原因是因为梯度会出现消失或爆炸，而导致无法训练。

假设一个比较浅的网络达到了饱和的准确率，那么在后面加上几个恒等映射层，误差不会增加，也就是说更深的模型起码不会使得模型效果下降。这里提到的使用恒等映射直接将前一层输出传到后面的思想，就是ResNet的灵感来源。假设输入是x，期望输出是H(x)，如果直接把输入x传到输出作为初始结果，那么此时需要学习的目标就是F(x)=H(x)-x，这就是残差模块。残差映射在现实中往往更容易优化。

这样的话，我们训练的目标其实就转化成了H(x)-x，也就是残差，因为存在着恒等映射，所以梯度几乎就不会消失了（恒等映射的梯度是1）。

ResNet沿⽤了VGG完整的3x3卷积层设计。残差块⾥⾸先有2个有相同输出通道数的3x3卷积层。每个卷积层后接⼀个批量规范化层和ReLU激活函数。然后我们通过跨层数据通路，跳过这2个卷积运算，将输⼊直接加在最后的ReLU激活函数前。这样的设计要求2个卷积层的输出与输⼊形状⼀样，从⽽使它们可以相加。如果想改变通道数，就需要引⼊⼀个额外的卷积层来将输⼊变换成需要的形状后再做相加运算。

下面我们来实现一下残差模块：

import torch
from torch import nn
from torch.nn import functional as F

# 残差块
class Residual(nn.Module):
    def __init__(self, in_channels, out_channels, change_channels=False, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, stride=stride)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
        if change_channels: # 如果通道数改变了话，使用1x1卷积进行改变，否则省略这一步
            self.conv3 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.bn2 = nn.BatchNorm2d(out_channels)

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

残差神经网络和GoogleNet类似，GoogleNet由Inception模块构成，而ResNet由残差卷积模块构成，一个残差卷积模块由多个残差块组成。ResNet使用四个残差卷积模块，每个模块使用若干个同样输出通道数的残差块。第一个模块的通道数同输入通道数一致。由于之前已经通过7x7卷积和池化层减半了输出大小，所以第一个模块无需缩减大小，之后每个残差卷积模块将上一个模块的通道数翻倍，并将长宽大小减半。总体上，残差卷积神经网络ResNet的架构如下图所示：

下面我们定义一下残差卷积模块：

# 残差卷积模块
def resnet_block(in_channels, out_channels, num_residuals, first_block=False):
    resnet_blocks = []
    for i in range(num_residuals):
        # 如果不是第一个残差卷积模块，并且是第一个残差块，那么需要使用1x1卷积使得通道数加倍，并使长宽减半
        if i==0 and not first_block: 
            resnet_blocks.append(Residual(in_channels, out_channels, change_channels=True, stride=2))
        else: # 其余的残差块通道数和长宽都不变
            resnet_blocks.append(Residual(out_channels, out_channels, change_channels=False, stride=1))
    return resnet_blocks

最后，完成的ResNet网络模型代码如下，这里我先选择了和《动手学深度学习》书中一样的ResNet-18：

# 残差卷积神经网络(ResNet-18)
class ResNet(nn.Module):
    def __init__(self, num_classes) -> None:
        super().__init__()
        # 残差卷积模块之前的部分，类似GoogleNet网络Inception模块之前的部分
        b1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )
        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))
        self.features = nn.Sequential(b1, b2, b3, b4, b5, nn.AdaptiveAvgPool2d((1,1)))
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(512, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x
        
if __name__ == '__main__':
    X = torch.rand(size=(1,3,224,224))
    net = ResNet(num_classes=10)
    X = net(X)
    print('output shape:', X.shape)
# 输出：
output shape: torch.Size([1, 10])

可以看到，我们输入一个三通道的大小为224x224的图像，最后输出一行10类的结果，也就是图像属于每一类的概率值，因此输出结果格式是正确的。下面我们在cifar-10数据集上训练看看。

import torchvision.datasets as datasets
from torchvision.transforms.functional import InterpolationMode
transform = transforms.Compose([transforms.Resize((224, 224), interpolation=InterpolationMode.BICUBIC),
                            transforms.ToTensor(),
                            transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.247, 0.2435, 0.2616]) # 此为训练集上的均值与方差
                            ])
train_dataset_cifar = datasets.CIFAR10('./data', train=True, transform=transform, download=True)
test_dataset_cifar = datasets.CIFAR10('./data', train=False, transform=transform, download=True)
train_loader_cifar = torch.utils.data.DataLoader(dataset=train_dataset_cifar, batch_size=24, shuffle=True)
test_loader_cifar = torch.utils.data.DataLoader(dataset=test_dataset_cifar, batch_size=24, shuffle=False)
net = ResNet(num_classes=10)
train(net, train_loader_cifar, test_loader_cifar, lr=0.01, epochs=10)

Epoch 1, Loss: 1.4430, Time 00:04:08
Epoch 2, Loss: 0.7981, Time 00:03:45
Epoch 3, Loss: 0.5703, Time 00:03:46
Epoch 4, Loss: 0.4302, Time 00:03:41
Epoch 5, Loss: 0.3212, Time 00:03:40
Epoch 6, Loss: 0.2398, Time 00:03:41
Epoch 7, Loss: 0.1699, Time 00:03:28
Epoch 8, Loss: 0.1235, Time 00:03:28
Epoch 9, Loss: 0.0963, Time 00:03:28
Epoch 10, Loss: 0.0719, Time 00:03:28
Test Accuracy: 84.52%

可以看到，残差神经网络的效果是非常好的，训练10个epoch后，测试精度就达到了84.52%。