关键词：
1. 前言
本文使用飞桨（PaddlePaddle）复现卷积神经网络ResNet。本文ResNet复现代码比PaddlePaddle官方内置ResNet代码结构更加清晰，建议参考本文中ResNet复现代码了解ResNet模型搭建流程。
本人全部文章请参见：博客文章导航目录
本文归属于：经典CNN复现系列
前文：GoogLeNet
2. ResNet
2013年，Lei Jimmy Ba和Rich Caurana在Do Deep Nets Really Need to be Deep?一文中分析了深度神经网络，并从理论和实践上证明了更深的卷积神经网络能够达到更高的识别准确率。
将深层网络增加的层变成恒等映射，原浅层网络层权重保持不变，则深层网络可获得与浅层网络相同的性能。即浅层网络的解空间是深层网络解空间的子集，深层网络的解空间中至少存在不差于浅层网络的解。
2015年，ResNet的作者何恺明等人首先发现随着网络叠加更多的层，训练一个相对浅层的网络，在训练集和测试集上均比深层网络表现更好，而且是在训练的各个阶段持续表现的更好，即叠加更多的层后，网络性能出现了快速下降的情况。
训练集上的性能下降，可以排除过拟合，Batch Normalization层的引入也基本解决了Plain Network的梯度消失和梯度爆炸问题。这种神经网络的“退化”现象反映出结构相似的但深度不同模型，其优化难度是不一样的，且难度的增长并不是线性的，越深的模型越难以优化。
神经网络“退化”问题有两种解决思路：一种是调整求解方法，比如更好的初始化、更好的梯度下降算法等；另一种是调整模型结构，让模型更易于优化（改变模型结构实际上是改变了Error Surface的形态）。
ResNet是2015年ImageNet比赛的冠军，其将ImageNet分类Top-5错误率降到了3.57%，这个结果甚至超出了正常人眼识别的精度。ResNet从调整模型结构方面入手，解决神经网络“退化”问题。
将堆叠的几层Layer称之为一个Block，对于某个Block，可以表示的函数为
F
(
x
)
F(x)
F(x)，该Block期望的潜在映射为
H
(
x
)
H(x)
H(x)。ResNet提出与其让
F
(
x
)
F(x)
F(x) 如图一(a)所示直接学习潜在的映射
H
(
x
)
H(x)
H(x)，不如如图一(b)所示去学习残差
H
(
x
)
−
x
H(x)−x
H(x)−x，即将
F
(
x
)
F(x)
F(x)定义为
H
(
x
)
−
x
H(x)−x
H(x)−x。这样处理可使得原本的前向路径变成
F
(
x
)
+
x
F(x)+x
F(x)+x，即用
F
(
x
)
+
x
F(x)+x
F(x)+x来拟合
H
(
x
)
H(x)
H(x)。ResNet作者何凯明等人认为这样处理可使得模型更易于优化，因为相比于将
F
(
x
)
F(x)
F(x)学习成恒等映射，让
F
(
x
)
→
0
F(x)\\rarr0
F(x)→0要更加容易。在网络进行训练时，如果经过某卷积层并不能提升性能（甚至因为网络“退化”而降低性能），那么网络就会倾向于通过更新权重参数使
F
(
x
)
F(x)
F(x)计算结果趋近于0，那么相应层的输出就近似为输入
x
x
x，也就相当于网络计算“跨过了”该层，从而通过这种跨层连接缓解网络退化现象。
2.1 残差块（Residual Block）
残差块是残差网络（ResNet）的基础，多个相似的残差块串联构成ResNet。如图二所示，一个残差块有2条路径
F
(
x
)
F(x)
F(x)和
x
x
x，
F
(
x
)
F(x)
F(x)路径拟合残差，被称为残差路径，
x
x
x路径为恒等映射(Identity Mapping)，被称为Shortcut。输入
x
x
x通过跨层连接，能更快的向前传播数据，或者向后传播梯度。
残差块共分为两种，一种如图二(b)所示包含瓶颈结构(Bottleneck)，Bottleneck主要用于降低计算复杂度，输入数据先经过1x1卷积层减少通道数，再经过3x3卷积层提取特征，最后再经过1x1卷积层恢复通道数。该种结构像一个中间细两头粗的瓶颈，所以被称为Bottleneck。另一种如图二(a)所示没有Bottleneck，被称为Basic Block，Basic Block由2个3×3卷积层构成。Bottleneck Block被用于ResNet50、ResNet101和ResNet152，而Basic Block被用于ResNet18和ResNet34。
Shortcut路径也分为两种，如下图(a)所示，当残差路径输出与输入
x
x
x的通道数量和特征图尺寸均相同时，Shortcut路径将输入
x
x
x原封不动地输出。若残差路径输出与输入
x
x
x的通道数量或特征图尺寸不同时，Shortcut路径使用1x1的卷积对输入
x
x
x进行降采样，使得Shortcut路径输出与残差路径输出的通道数量和特征图尺寸均相同。
2.2 ResNet网络结构
ResNet由多个Bottleneck Block串联而成，其通过“跨层连接”的方式，使网络在无法继续通过增加层数来进一步提升性能时，跳过部分层。这样能够大大缓解深层网络“退化”现象，从而实现成百上千层的网络，大大提升了深度神经网络性能。
从上面的ResNet结构信息图可知，各种层数配置的ResNet网络的“头”和“尾”都是相同的。开头先用一个7×7的卷积层提取输入图片的纹理细节特征，最后接一个全局平均池化（GAP，将特征图降到1×1尺寸）和一个全连接层（对齐输出维度为分类数）。决不同层数配置ResNet的是它们各自包含的残差块的种类的数量。ResNet18和ResNet34中的残差块为Basic Block，ResNet50、ResNet101和ResNet152中的残差块为Bottleneck Block。
3. ResNet模型复现
使用飞桨（PaddlePaddle）复现ResNet，首先定义继承自paddle.nn.Layer的BasicBlock和BottleneckBlock模块，具体代码如下所示：
# -*- coding: utf-8 -*-
# @Time : 2021/8/19 19:11
# @Author : He Ruizhi
# @File : resnet.py
# @Software: PyCharm
import paddle
class BasicBlock(paddle.nn.Layer):
"""
用于resnet18和resnet34的残差块
Args:
input_channels (int): 该残差块输入的通道数
output_channels (int): 该残差块的输出通道数
stride (int): 残差块中第一个卷积层的步长，当步长为2时，输出特征图大小减半
"""
def __init__(self, input_channels, output_channels, stride):
super(BasicBlock, self).__init__()
self.input_channels = input_channels
self.output_channels = output_channels
self.stride = stride
self.conv_bn_block1 = paddle.nn.Sequential(
paddle.nn.Conv2D(in_channels=input_channels, out_channels=output_channels, kernel_size=3,
stride=stride, padding=1, bias_attr=False),
# BatchNorm2D算子对每一个batch数据中各通道分别进行归一化，因此须指定通道数
paddle.nn.BatchNorm2D(output_channels),
paddle.nn.ReLU()
)
self.conv_bn_block2 = paddle.nn.Sequential(
paddle.nn.Conv2D(in_channels=output_channels, out_channels=output_channels, kernel_size=3,
stride=1, padding=1, bias_attr=False),
paddle.nn.BatchNorm2D(output_channels)
)
# 当stride不等于1或者输入残差块的通道数和输出该残差块的通道数不想等时
# 需要对该残差块输入进行变换
if stride != 1 or input_channels != output_channels:
self.down_sample_block = paddle.nn.Sequential(
paddle.nn.Conv2D(in_channels=input_channels, out_channels=output_channels, kernel_size=1,
stride=stride, bias_attr=False),
paddle.nn.BatchNorm2D(output_channels)
)
self.relu_out = paddle.nn.ReLU()
def forward(self, inputs):
x = self.conv_bn_block1(inputs)
x = self.conv_bn_block2(x)
# 如果inputs和x的shape不一致，则调整inputs
if self.stride != 1 or self.input_channels != self.output_channels:
inputs = self.down_sample_block(inputs)
outputs = paddle.add(inputs, x)
outputs = self.relu_out(outputs)
return outputs
class BottleneckBlock(paddle.nn.Layer):
"""
用于resnet50、resnet101和resnet152的残差块
Args:
input_channels (int): 该残差块输入的通道数
output_channels (int): 该残差块的输出通道数
stride (int): 残差块中3x3卷积层的步长，当步长为2时，输出特征图大小减半
"""
def __init__(self, input_channels, output_channels, stride):
super(BottleneckBlock, self).__init__()
self.input_channels = input_channels
self.output_channels = output_channels
self.stride = stride
self.conv_bn_block1 = paddle.nn.Sequential(
paddle.nn.Conv2D(in_channels=input_channels, out_channels=output_channels // 4, kernel_size=1,
stride=1, bias_attr=False),
paddle.nn.BatchNorm2D(output_channels // 4),
paddle.nn.ReLU()
)
self.conv_bn_block2 = paddle.nn.Sequential(
paddle.nn.Conv2D(in_channels=output_channels // 4, out_channels=output_channels // 4, kernel_size=3,
stride=stride, padding=1, bias_attr=False),
paddle.nn.BatchNorm2D(output_channels // 4),
paddle.nn.ReLU()
)
self.conv_bn_block3 = paddle.nn.Sequential(
paddle.nn.Conv2D(in_channels=output_channels // 4, out_channels=output_channels, kernel_size=1,
stride=1, bias_attr=False),
paddle.nn.BatchNorm2D(output_channels)
)
# 如果【输入】和【经过三个conv_bn_block后的输出】的shape不一致
# 添加一个1x1卷积作用到输出数据上，使得【输入】和【经过三个conv_bn_block后的输出】的shape一致
if stride != 1 or input_channels != output_channels:
self.down_sample_block = paddle.nn.Sequential(
paddle.nn.Conv2D(in_channels=input_channels, out_channels=output_channels, kernel_size=1,
stride=stride, bias_attr=False),
paddle.nn.BatchNorm2D(output_channels)
)
self.relu_out = paddle.nn.ReLU()
def forward(self, inputs):
x = self.conv_bn_block1(inputs)
x = self.conv_bn_block2(x)
x = self.conv_bn_block3(x)
# 如果inputs和x的shape不一致，则调整inputs
if self.stride != 1 or self.input_channels != self.output_channels:
inputs = self.down_sample_block(inputs)
outputs = paddle.add(inputs, x)
outputs = self.relu_out(outputs)
return outputs
设置input_channels=64、output_channels=128、stride=2，实例化BasicBlock对象，并使用paddle.summary查看BasicBlock结构：
basic_block = BasicBlock(64, 128, 2)
paddle.summary(basic_block, input_size=(None, 64, 224, 224))
打印BasicBlock结构信息如下：
---------------------------------------------------------------------------
Layer (type) Input Shape Output Shape Param #
===========================================================================
Conv2D-1 [[1, 64, 224, 224]] [1, 128, 112, 112] 73,728
BatchNorm2D-1 [[1, 128, 112, 112]] [1, 128, 112, 112] 512
ReLU-1 [[1, 128, 112, 112]] [1, 128, 112, 112] 0
Conv2D-2 [[1, 128, 112, 112]] [1, 128, 112, 112] 147,456
BatchNorm2D-2 [[1, 128, 112, 112]] [1, 128, 112, 112] 512
Conv2D-3 [[1, 64, 224, 224]] [1, 128, 112, 112] 8,192
BatchNorm2D-3 [[1, 128, 112, 112]] [1, 128, 112, 112] 512
ReLU-2 [[1, 128, 112, 112]] [1, 128, 112, 112] 0
===========================================================================
Total params: 230,912
Trainable params: 229,376
Non-trainable params: 1,536
---------------------------------------------------------------------------
Input size (MB): 12.25
Forward/backward pass size (MB): 98.00
Params size (MB): 0.88
Estimated Total Size (MB): 111.13
---------------------------------------------------------------------------
设置input_channels=64、output_channels=128、stride=2，实例化BottleneckBlock对象，并使用paddle.summary查看BottleneckBlock结构：
bottleneck_block = BottleneckBlock(64, 128, 2)
paddle.summary(bottleneck_block, input_size=(None, 64, 224, 224))
打印BottleneckBlock结构信息如下：
---------------------------------------------------------------------------
Layer (type) Input Shape Output Shape Param #
===========================================================================
Conv2D-1 [[1, 64, 224, 224]] [1, 32, 224, 224] 2,048
BatchNorm2D-1 [[1, 32, 224, 224]] [1, 32, 224, 224] 128
ReLU-1 [[1, 32, 224, 224]] [1, 32, 224, 224] 0
Conv2D-2 [[1, 32, 224, 224]] [1, 32, 112, 112] 9,216
BatchNorm2D-2 [[1, 32, 112, 112]] [1, 32, 112, 112] 128
ReLU-2 [[1, 32, 112, 112]] [1, 32, 112, 112] 0
Conv2D-3 [[1, 32, 112, 112]] [1, 128, 112, 112] 4,096
BatchNorm2D-3 [[1, 128, 112, 112]] [1, 128, 112, 112] 512
Conv2D-4 [[1, 64, 224, 224]] [1, 128, 112, 112] 8,192
BatchNorm2D-4 [[1, 128, 112, 112]] [1, 128, 112, 112] 512
ReLU-3 [[1, 128, 112, 112]] [1, 128, 112, 112] 0
===========================================================================
Total params: 24,832
Trainable params: 23,552
Non-trainable params: 1,280
---------------------------------------------------------------------------
Input size (MB): 12.25
Forward/backward pass size (MB): 107.19
Params size (MB): 0.09
Estimated Total Size (MB): 119.53
---------------------------------------------------------------------------
定义继承自paddle.nn.Layer的ResNet类，在__init__方法中定义各模块，在forward函数中实现网络前向计算流程。具体代码如下：
class ResNet(paddle.nn.Layer):
"""
搭建ResNet
Args:
layers (int): 表明构建的ResNet层数，支持[18, 34, 50, 101, 152]
num_classes (int): 输出类别数
"""
def __init__(self, layers, num_classes=1000):
super(ResNet, self).__init__()
supported_layers = [18, 34, 50, 101, 152]
assert layers in supported_layers, \\
'Supported layers are , but input layer is .'.format(supported_layers, layers)
# 网络所使用的【残差块种类】、每个模块包含的【残差块数量】、各模块的【输出通道数】
layers_config =
18: 'block_type': BasicBlock, 'num_blocks': [2, 2, 2, 2], 'out_channels': [64, 128, 256, 512],
34: 'block_type': BasicBlock, 'num_blocks': [3, 4, 6, 3], 'out_channels': [64, 128, 256, 512],
50: 'block_type': BottleneckBlock, 'num_blocks': [3, 4, 6, 3], 'out_channels': [256, 512, 1024, 2048],
101: 'block_type': BottleneckBlock, 'num_blocks': [3, 4, 23, 3], 'out_channels': [256, 512, 1024, 2048],
152: 'block_type': BottleneckBlock, 'num_blocks': [3, 8, 36, 3], 'out_channels': [256, 512, 1024, 2048]
# ResNet的第一个模块：7x7的步长为2的64通道卷积 + BN + 步长为2的3x3最大池化
self.conv = paddle.nn.Conv2D(in_channels=3, out_channels=64, kernel_size=7, stride=2,
padding=3, bias_attr=False)
self.bn = paddle.nn.BatchNorm2D(64)
self.relu = paddle.nn.ReLU()
self.max_pool = paddle.nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
# 输入各残差块的通道数
input_channels = 64
block_list = []
for i, block_num in enumerate(layers_config[layers]['num_blocks']):
for order in range(block_num):
block_list.append(layers_config[layers]['block_type'](input_channels,
layers_config[layers]['out_channels'][i],
2 if order == 0 and i != 0 else 1))
input_channels = layers_config[layers]['out_channels'][i]
# 将所有残差块打包
self.residual_block = paddle.nn.Sequential(*block_list)
# 全局平均池化
self.avg_pool = paddle.nn.AdaptiveAvgPool2D(output_size=1)
self.flatten = paddle.nn.Flatten()
# 输出层
self.fc = paddle.nn.Linear(in_features=layers_config[layers]['out_channels'][-1], out_features=num_classes)
def forward(self, x):
x = self.conv(x)
x = self.bn(x)
x = self.relu(x)
x = self.max_pool(x)
x = self.residual_block(x)
x = self.avg_pool(x)
x = self.flatten(x)
x = self.fc(x)
return x
设置layers=50实例化ResNet50模型对象，并使用paddle.summary查看ResNet50模型结构信息：
if pytorchcifar10图像分类resnet篇(代码片段)
PytorchCIFAR10图像分类ResNet篇文章目录PytorchCIFAR10图像分类ResNet篇4.定义网络（ResNet）残差结构ResNet18/34的Residual结构ResNet50/101/152的Bottleneck结构ResNet网络结构配置BasicBlockBottleneckBlockResNet5.定义损失函数和优化器6.训练损失函数 查看详情
05-resnet18图像分类(代码片段)
图1Resnet的残差块 图2Resnet18网络架构Cifar10数据集的Resnet10的框架实现（Pytorch）:importtorchfromtorchimportnn#ResNet18_BasicBlock-残差单元classResNet18_BasicBlock(nn.Module):def__init__(self,input_chan 查看详情
paddlepaddle十二生肖分类之模型(resnet)构建(代码片段)
...用paddlepaddle构建一个深度学习模型，这里我们以构建ResNet为例ResNet模型ResNet是2016年由何凯明提出来的，到现在为止我们还是会经常使用到它。我们来看看它的结构在论文中ResNet主要包含了五种结构，ResNet18、ResNet34、R... 查看详情
paddlepaddle十二生肖分类之模型(resnet)构建(代码片段)
...用paddlepaddle构建一个深度学习模型，这里我们以构建ResNet为例ResNet模型ResNet是2016年由何凯明提出来的，到现在为止我们还是会经常使用到它。我们来看看它的结构在论文中ResNet主要包含了五种结构，ResNet18、ResNet34、R... 查看详情
论文泛读resnet：深度残差网络(代码片段)
【论文泛读】ResNet：深度残差网络文章目录【论文泛读】ResNet：深度残差网络摘要Abstract介绍Introduction残差结构的提出残差结构的一些问题深度残差网络实验结果ResNet的探究与先进的模型比较在CIFAR-10进行探究在PASCAL和MSCO... 查看详情
了解resnet网络结构特点，利用resnet完成图像分类(代码片段)
学习目标知道ResNet网络结构的特点能够利用ResNet完成图像分类网络越深，获取的信息就越多，特征也越丰富。但是在实践中，随着网络的加深，优化效果反而越差，测试数据和训练数据的准确率反而降低了。... 查看详情
paddle实现resnet复现(代码片段)
...现3.1导入工具包3.2建立Basicblock3.3建立Bottleneckblock3.4搭建Resnet的主干3.5具象化网络四、查看网络结构五、测试网络是否可以使用一、介绍ResNet（ResidualNeuralNetwork）由微软研究院的KaimingHe等四名华人提出&#x 查看详情
resnet过程(代码片段)
#ResNet因为网络传播的层次太深，后面的很难传播到前面，所以增加了一个短接层，深层次网络可以退化成一个浅层次网络#filter_num卷积核数量#stride步长classBasicBlock(layers.Layer):def__init__(self,filter_num,stride=1):super(BasicBlo... 查看详情
resnet过程(代码片段)
#ResNet因为网络传播的层次太深，后面的很难传播到前面，所以增加了一个短接层，深层次网络可以退化成一个浅层次网络#filter_num卷积核数量#stride步长classBasicBlock(layers.Layer):def__init__(self,filter_num,stride=1):super(BasicBlo... 查看详情
resnet网络详解(代码片段)
ResNetResNet在2015年由微软实验室提出，斩获当年lmageNet竞赛中分类任务第一名，目标检测第一名。获得coco数据集中目标检测第一名，图像分割第一名。ResNet亮点1.超深的网络结构(突破1000层)2.提出residual模块3.使用BatchNorm... 查看详情
paddle实现resnet复现(代码片段)
一、介绍ResNet（ResidualNeuralNetwork）由微软研究院的KaimingHe等四名华人提出，通过使用ResNetUnit成功训练出了152层的神经网络，并在ILSVRC2015比赛中取得冠军，在top5上的错误率为3.57%，同时参数量比VGGNet低，... 查看详情
resnet迁移学习记录(代码片段)
...很完善的网络作为自己的cnn网络层，下面例子为使用Resnet预训练模型来做自己的图片分类：#网络定义classResnet(nn.Module):def__init__(self):super(Resnet,self).__init__()pretr 查看详情
resnet迁移学习记录(代码片段)
...很完善的网络作为自己的cnn网络层，下面例子为使用Resnet预训练模型来做自己的图片分类：#网络定义classResnet(nn.Module):def__init__(self):super(Resnet,self).__init__()pretr 查看详情
从零学习pytorch如何残差网络resnet作为pre-model+代码讲解+残差网络resnet是个啥(代码片段)
看的多个Kaggle上图片分类比赛的代码，发现基本都会选择resnet网络作为前置网络进行训练，那么如何实现这个呢？本文主要分为两个部分第一个部分讲解如何使用PyTorch来实现前置网络的设置，以及参数的下载和导入第二个部分... 查看详情
resnet(代码片段)
...nt("TorchvisionVersion:",torchvision.__version__)__all__=['ResNet50','ResNet101','ResNet152']defConv1(in_planes,places,stride=2):returnnn.Sequential(nn.Conv2d(in_channels=in_planes,out_channels=places,kernel_size=7,stride=stride,padding=3,b... 查看详情
知识蒸馏irg算法实战：使用resnet50蒸馏resnet18(代码片段)
摘要复杂度的检测模型虽然可以取得SOTA的精度，但它们往往难以直接落地应用。模型压缩方法帮助模型在效率和精度之间进行折中。知识蒸馏是模型压缩的一种有效手段，它的核心思想是迫使轻量级的学生模型去学习教... 查看详情
深度学习100例-卷积神经网络（resnet-50）鸟类识别|第8天(代码片段)
...2.可视化数据3.再次检查数据4.配置数据集三、残差网络（ResNet）介绍1.残差网络解决了什么2.ResNet-50介绍四、构建ResNet-50网络模型五、编译六、训练模型七、模型评估八、保存and加载模型九、预测一、前期工作本文将采用ResNet-50... 查看详情
keras深度学习实战——基于resnet模型实现性别分类(代码片段)
Keras深度学习实战——基于ResNet模型实现性别分类0.前言1.ResNet架构简介2.基于预训练的ResNet50模型实现性别分类2.1训练性别分类模型2.2错误分类图像示例相关链接0.前言从VGG16到VGG19，最显著的变化在于网络层数的增加，通... 查看详情