点击上方，选择星标或置顶，不定期资源大放送！

阅读大概需要20分钟

Follow小博主，每天更新前沿干货

【导读】2020年，在各大CV顶会上又出现了许多基于ResNet改进的工作，比如:Res2Net，ResNeSt，IResNet，SCNet等等。为了更好的了解ResNet整个体系脉络的发展，我们特此对ResNet系列重新梳理，并制作了一个ResNet专题，希望能帮助大家对ResNet体系有一个更深的理解。本篇文章我们将主要讲解ResNet、preResNet、ResNext以及它们的代码实现。

ResNet

• 论文链接：https://arxiv.org/abs/1512.03385

• 代码地址：https://github.com/KaimingHe/deep-residual-networks

• pytorch版：https://github.com/Cadene/pretrained-models.pytorch

Motivation 和创新点

深度学习的发展从LeNet到AlexNet，再到VGGNet和GoogLeNet，网络的深度在不断加深，经验表明，网络深度有着至关重要的影响，层数深的网络可以提取出图片的低层、中层和高层特征。但当网络足够深时，仅仅在后面继续堆叠更多层会带来很多问题：第一个问题就是梯度爆炸 / 消失（vanishing / exploding gradients），backprop无法把有效地把梯度更新到前面的网络层，导致前面的层参数无法更新。第二个问题就是退化（degradation）问题，即当网络层数堆叠过多会导致优化困难、且训练误差和预测误差更大了，注意这里误差更大并不是由过拟合导致的。

ResNet旨在解决网络加深后训练难度增大的现象。其提出了residual模块，包含两个3×3卷积和一个shortcut connection。shortcut connection可以有效缓解反向传播时由于深度过深导致的梯度消失现象，这使得网络加深之后性能不会变差。短路连接是深度学习又一重要思想，除计算机视觉外，短路连接也被用到了机器翻译、语音识别/合成领域。此外，具有短路连接的ResNet可以看作是许多不同深度而共享参数的网络的集成，网络数目随层数指数增加。值得注意的是：在此之前已有研究者使用跨层连接对响应和梯度中心化（center）处理；inception结构本质也是跨层连接；highway网络也使用到了跨层连接

ResNet的关键点是：

• 利用残差结构让网络能够更深、收敛速度更快、优化更容易，同时参数相对之前的模型更少、复杂度更低

• ResNet大量使用了批量归一层，而不是Dropout。

• 对于很深的网络(超过50层)，ResNet使用了更高效的瓶颈(bottleneck)结构极大程度上降低了参数计算量。

ResNet的残差结构

为了解决退化问题，我们引入了一个新的深度残差学习block，在这里，对于一个堆积层结构（几层堆积而成）当输入为时，其学习到的特征记为，现在我们希望其可以学习到残差 ，这样其实原始的学习特征是 。之所以这样是因为残差学习相比原始特征直接学习更容易。当残差为0时，此时堆积层仅仅做了恒等映射，至少网络性能不会下降，实际上残差不会为0，这也会使得堆积层在输入特征基础上学习到新的特征，从而拥有更好的性能。

本质也就是不改变目标函数 ，将网络结构拆成两个分支，一个分支是残差映射，一个分支是恒等映射，于是网络仅需学习残差映射即可。对于上述残差单元，我们可以从数学的角度来分析一下，首先上述结构可表示为：

其中和分别表示的是第个残差单元的输入和输出，注意每个残差单元一般包含多层结构。是残差函数，表示学习到的残差，而表示恒等映射，是ReLU激活函数。基于上式，我们求得从浅层到深层的学习特征为：

利用链式规则，可以求得反向过程的梯度：

式子的第一个因子 表示的损失函数到达的梯度，小括号中的1表明短路机制可以无损地传播梯度，而另外一项残差梯度则需要经过带有weights的层，梯度不是直接传递过来的。残差梯度不会那么巧全为-1，而且就算其比较小，有1的存在也不会导致梯度消失。所以残差学习会更容易。要注意上面的推导并不是严格的证明。

残差结构为什么有效？

1. 自适应深度：网络退化问题就体现了多层网络难以拟合恒等映射这种情况，也就是说难以拟合，但使用了残差结构之后，拟合恒等映射变得很容易，直接把网络参数全学习到为0，只留下那个恒等映射的跨层连接即可。于是当网络不需要这么深时，中间的恒等映射就可以多一点，反之就可以少一点。（当然网络中出现某些层仅仅拟合恒等映射的可能性很小，但根据下面的第二点也有其用武之地；另外关于为什么多层网络难以拟合恒等映射，这涉及到信号与系统的知识见:https://www.zhihu.com/question/293243905/answer/484708047）

2. 差分放大器：假设最优更接近恒等映射，那么网络更容易发现除恒等映射之外微小的波动

3. 模型集成：整个ResNet类似于多个网络的集成，原因是删除ResNet的部分网络结点不影响整个网络的性能，但VGGNet会崩溃，具体可以看这篇NIPS论文：Residual Networks Behave Like Ensembles of Relatively Shallow Networks

4. 缓解梯度消失：针对一个残差结构对输入求导就可以知道，由于跨层连接的存在，总梯度在对的导数基础上还会加1

下面给出一个直观理解图：

如上图所示，左边来了一辆装满了“梯度”商品的货车，来领商品的客人一般都要排队一个个拿才可以，如果排队的人太多，后面的人就没有了。于是这时候派了一个人走了“快捷通道”，到货车上领了一部分“梯度”，直接送给后面的人，这样后面排队的客人就能拿到更多的“梯度”。

bottleneck(利用1*1卷积)的好处-两种残差单元

我们来计算一下1*1卷积的计算量优势：首先看上图右边的bottleneck结构，对于256维的输入特征，参数数目：1x1x256x64+3x3x64x64+1x1x64x256=69632，如果同样的输入输出维度但不使用1x1卷积，而使用两个3x3卷积的话，参数数目为(3x3x256x256)x2=1179648。简单计算下就知道了，使用了1x1卷积的bottleneck将计算量简化为原有的5.9%，收益超高。

详细见：【基础积累】1x1卷积到底有哪些用处？

ResNet网络设计结构：

基于Pytorch的ResNet代码实现

def conv3x3(in_planes, out_planes, stride=1):"""3x3 convolution with padding"""return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,padding=1, bias=False)class Bottleneck(nn.Module):expansion = 4def __init__(self, inplanes, planes, stride=1, downsample=None):super(Bottleneck, self).__init__()self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)self.bn1 = nn.BatchNorm2d(planes)self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,padding=1, bias=False)self.bn2 = nn.BatchNorm2d(planes)self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)self.bn3 = nn.BatchNorm2d(planes * 4)self.relu = nn.ReLU(inplace=True)self.downsample = downsampleself.stride = stridedef forward(self, x):residual = xout = self.conv1(x)out = self.bn1(out)out = self.relu(out)out = self.conv2(out)out = self.bn2(out)out = self.relu(out)out = self.conv3(out)out = self.bn3(out)if self.downsample is not None:residual = self.downsample(x)out += residualout = self.relu(out)return outclass ResNet(nn.Module):def __init__(self, block, layers, num_classes, grayscale):self.inplanes = 64if grayscale:in_dim = 1else:in_dim = 3super(ResNet, self).__init__()self.conv1 = nn.Conv2d(in_dim, 64, kernel_size=7, stride=2, padding=3,bias=False)self.bn1 = nn.BatchNorm2d(64)self.relu = nn.ReLU(inplace=True)self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)self.layer1 = self._make_layer(block, 64, layers[0])self.layer2 = self._make_layer(block, 128, layers[1], stride=2)self.layer3 = self._make_layer(block, 256, layers[2], stride=2)self.layer4 = self._make_layer(block, 512, layers[3], stride=2)self.avgpool = nn.AvgPool2d(7, stride=1, padding=2)#self.fc = nn.Linear(2048 * block.expansion, num_classes)self.fc = nn.Linear(2048, num_classes)for m in self.modules():if isinstance(m, nn.Conv2d):n = m.kernel_size[0] * m.kernel_size[1] * m.out_channelsm.weight.data.normal_(0, (2. / n)**.5)elif isinstance(m, nn.BatchNorm2d):m.weight.data.fill_(1)m.bias.data.zero_()def _make_layer(self, block, planes, blocks, stride=1):downsample = Noneif stride != 1 or self.inplanes != planes * block.expansion:downsample = nn.Sequential(nn.Conv2d(self.inplanes, planes * block.expansion,kernel_size=1, stride=stride, bias=False),nn.BatchNorm2d(planes * block.expansion),)layers = []layers.append(block(self.inplanes, planes, stride, downsample))self.inplanes = planes * block.expansionfor i in range(1, blocks):layers.append(block(self.inplanes, planes))return nn.Sequential(*layers)def forward(self, x):x = self.conv1(x)x = self.bn1(x)x = self.relu(x)x = self.maxpool(x)x = self.layer1(x)x = self.layer2(x)x = self.layer3(x)x = self.layer4(x)#x = self.avgpool(x)x = x.view(x.size(0), -1)logits = self.fc(x)probas = F.softmax(logits, dim=1)return logits, probasdef resnet101(num_classes, grayscale):"""Constructs a ResNet-101 model."""model = ResNet(block=Bottleneck,layers=[3, 4, 23, 3],num_classes=NUM_CLASSES,grayscale=grayscale)return model

preResNet

• 论文链接：https://arxiv.org/abs/1603.05027

• 代码地址：https://github.com/KaimingHe/resnet-1k-layers.

论文主要思想和改进点

本文分析了残差模块背后的传播公式，重点是创建一个信息传播的“直接”路径——不仅在残差单元内，而且要通过整个网络。一系列实验表明在使用恒等映射作为跳跃连接和在BN后添加激活函数的方式，前向和后向传播信号可以直接从一个块传播到任何其他块。一系列的消融实验证明了这些恒等映射的重要性。这促使我们提出了一个新的残差单位，它使的训练更容易，并改进了泛化效果。我们把它叫做preResNet，preResNet主要是调整了residual模块中各层的顺序。preResNet比较了ReLU和BN的摆放位置不同，比较两者的效果。相比经典residual模块(a)，(b)将BN共享会更加影响信息的短路传播，使网络更难训练、性能也更差；(c)直接将ReLU移到BN后会使该分支的输出始终非负，使网络表示能力下降；(d)将ReLU提前解决了(e)的非负问题，但ReLU无法享受BN的效果；(e)将ReLU和BN都提前解决了(d)的问题。preResNet的短路连接(e)能更加直接的传递信息，进而取得了比ResNet更好的性能。

基于Pytorch的PreResNet代码

import torch.nn as nn__all__ = ['preresnet20', 'preresnet32', 'preresnet44','preresnet56', 'preresnet110', 'preresnet1202']def conv3x3(in_planes, out_planes, stride=1):"3x3 convolution with padding"return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,padding=1, bias=False)class BasicBlock(nn.Module):expansion = 1def __init__(self, inplanes, planes, stride=1, downsample=None):super(BasicBlock, self).__init__()self.bn_1 = nn.BatchNorm2d(inplanes)self.relu = nn.ReLU(inplace=True)self.conv_1 = conv3x3(inplanes, planes, stride)self.bn_2 = nn.BatchNorm2d(planes)self.conv_2 = conv3x3(planes, planes)self.downsample = downsampleself.stride = stridedef forward(self, x):residual = xout = self.bn_1(x)out = self.relu(out)out = self.conv_1(out)out = self.bn_2(out)out = self.relu(out)out = self.conv_2(out)if self.downsample is not None:residual = self.downsample(x)out += residualreturn outclass Bottleneck(nn.Module):expansion = 4def __init__(self, inplanes, planes, stride=1, downsample=None):super(Bottleneck, self).__init__()self.bn_1 = nn.BatchNorm2d(inplanes)self.conv_1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)self.bn_2 = nn.BatchNorm2d(planes)self.conv_2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,padding=1, bias=False)self.bn_3 = nn.BatchNorm2d(planes)self.conv_3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)self.relu = nn.ReLU(inplace=True)self.downsample = downsampleself.stride = stridedef forward(self, x):residual = xout = self.bn_1(x)out = self.relu(out)out = self.conv_1(out)out = self.bn_2(out)out = self.relu(out)out = self.conv_2(out)out = self.bn_3(out)out = self.relu(out)out = self.conv_3(out)if self.downsample is not None:residual = self.downsample(x)out += residualreturn outclass PreResNet(nn.Module):def __init__(self, depth, num_classes=1000, block_name='BasicBlock'):super(PreResNet, self).__init__()# Model type specifies number of layers for CIFAR-10 modelif block_name.lower() == 'basicblock':assert (depth - 2) % 6 == 0, "When use basicblock, depth should be 6n+2, e.g. 20, 32, 44, 56, 110, 1202"n = (depth - 2) // 6block = BasicBlockelif block_name.lower() == 'bottleneck':assert (depth - 2) % 9 == 0, "When use bottleneck, depth should be 9n+2 e.g. 20, 29, 47, 56, 110, 1199"n = (depth - 2) // 9block = Bottleneckelse:raise ValueError('block_name shoule be Basicblock or Bottleneck')self.inplanes = 16self.conv_1 = nn.Conv2d(3, 16, kernel_size=3, padding=1,bias=False)self.layer1 = self._make_layer(block, 16, n)self.layer2 = self._make_layer(block, 32, n, stride=2)self.layer3 = self._make_layer(block, 64, n, stride=2)self.bn = nn.BatchNorm2d(64 * block.expansion)self.relu = nn.ReLU(inplace=True)self.avgpool = nn.AvgPool2d(8)self.fc = nn.Linear(64 * block.expansion, num_classes)for m in self.modules():if isinstance(m, nn.Conv2d):nn.init.kaiming_normal_(m.weight.data)elif isinstance(m, nn.BatchNorm2d):m.weight.data.fill_(1)m.bias.data.zero_()def _make_layer(self, block, planes, blocks, stride=1):downsample = Noneif stride != 1 or self.inplanes != planes * block.expansion:downsample = nn.Sequential(nn.Conv2d(self.inplanes, planes * block.expansion,kernel_size=1, stride=stride, bias=False))layers = []layers.append(block(self.inplanes, planes, stride, downsample))self.inplanes = planes * block.expansionfor _ in range(1, blocks):layers.append(block(self.inplanes, planes))return nn.Sequential(*layers)def forward(self, x):x = self.conv_1(x) # 32x32x = self.layer1(x) # 32x32x = self.layer2(x) # 16x16x = self.layer3(x) # 8x8x = self.bn(x)x = self.relu(x)x = self.avgpool(x)x = x.view(x.size(0), -1)x = self.fc(x)return xdef preresnet20(num_classes):return PreResNet(depth=20, num_classes=num_classes)def preresnet32(num_classes):return PreResNet(depth=32, num_classes=num_classes)def preresnet44(num_classes):return PreResNet(depth=44, num_classes=num_classes)def preresnet56(num_classes):return PreResNet(depth=56, num_classes=num_classes)def preresnet110(num_classes):return PreResNet(depth=110, num_classes=num_classes)def preresnet1202(num_classes):return PreResNet(depth=1202, num_classes=num_classes)

ResNeXt

• 论文链接：https://arxiv.org/abs/1611.05431

论文思想和主要改进点

传统的方法通常是靠加深或加宽网络来提升性能，但计算开销也会随之增加。ResNeXt旨在不改变模型复杂度的情况下提升性能。受精简而高效的Inception模块启发，在这篇文章中，我们提出了一个简单的、高度模块化的图像分类网络架构。我们的网络是通过聚合不同的模块构建起来的，它借鉴了Inception的“分割-变换-聚合”策略，却用相同的拓扑结构来组建多分支结构。这种多分支结构的策略衍生出了一个新的维度,我们称之为“基数”，它也是网络结构中除了深度和宽度之外，一个重要的影响因素。作为ResNet的一个高能进化版，ResNeXt在宽度和深度之外，通过引入了“基数 (Cardinality) ”的概念。在网络不加深不加宽的情况下，增加基数便可以提高模型效果和提升准确率，还能减少超参数的数量。

ResNeXt的关键点是：

• 沿用ResNet的短路连接，并且重复堆叠相同的模块组合。

• ResNeXt将ResNet中非跳跃连接的那一分支变为多个分支。

• 多分支分别处理。

• 使用1×1卷积降低计算量。其综合了ResNet和Inception的优点。

• ResNeXt与Inception最本质的差别，其实是Block内每个分支的拓扑结构，Inception为了提高表达能力/结合不同感受野，每个分支使用了不同的拓扑结构。而ResNeXt则使用了同一拓扑的分支，即ResNeXt的分支是同构的！

因为ResNeXt是同构的，因此继承了VGG/ResNet的精神衣钵：维持网络拓扑结构不变。主要体现在两点：

• 特征图大小相同，则涉及的结构超参数相同

• 每当空间分辨率/2（降采样），则卷积核的宽度*2

神经元连接

聚合变换

ResNeXt最终输出模块公式：

此外，ResNeXt巧妙地利用分组卷积进行实现。ResNeXt发现，增加分支数是比加深或加宽更有效地提升网络性能的方式。ResNeXt的命名旨在说明这是下一代(next)的ResNet。

如果一个ResNeXt Block中只有两层conv，前后都可等效成一个大的conv层

上图a的解读：

ResNeXt最核心的地方只存在于被最上最下两层卷积夹着的，中间的部分。

1. 因为第一个分开的conv其实都接受了一样的输入，各分支又有着相同的拓扑结构。类比乘法结合律，这其实就是把一个conv的输出拆开了分掉。（相同输入，不同输出）

2. 而最后一个conv又只对同一个输出负责，因此就可以并起来用一个conv处理。（不同输入，相同输出）

3. 唯一一个输入和输出都不同的，就是中间的3*3conv了。它们的输入，参数，负责的输出都不同，无法合并，因此也相互独立。这才是模型的关键所在。最终模型可以被等效为下图所示的最终形态：

ResNeXt的网络结构设计：

基于Pytorch的ResNeXt代码

import torch.nn as nn
import torch.nn.functional as F__all__ = ['resnext29_8x64d', 'resnext29_16x64d']class Bottleneck(nn.Module):def __init__(self,in_channels,out_channels,stride,cardinality,base_width,expansion):super(Bottleneck, self).__init__()width_ratio = out_channels / (expansion * 64.)D = cardinality * int(base_width * width_ratio)self.relu = nn.ReLU(inplace=True)self.conv_reduce = nn.Conv2d(in_channels, D, kernel_size=1, stride=1, padding=0, bias=False)self.bn_reduce = nn.BatchNorm2d(D)self.conv_conv = nn.Conv2d(D,D,kernel_size=3,stride=stride,padding=1,groups=cardinality,bias=False)self.bn = nn.BatchNorm2d(D)self.conv_expand = nn.Conv2d(D, out_channels, kernel_size=1, stride=1, padding=0, bias=False)self.bn_expand = nn.BatchNorm2d(out_channels)self.shortcut = nn.Sequential()if in_channels != out_channels:self.shortcut.add_module('shortcut_conv',nn.Conv2d(in_channels,out_channels,kernel_size=1,stride=stride,padding=0,bias=False))self.shortcut.add_module('shortcut_bn', nn.BatchNorm2d(out_channels))def forward(self, x):out = self.conv_reduce.forward(x)out = self.relu(self.bn_reduce.forward(out))out = self.conv_conv.forward(out)out = self.relu(self.bn.forward(out))out = self.conv_expand.forward(out)out = self.bn_expand.forward(out)residual = self.shortcut.forward(x)return self.relu(residual + out)class ResNeXt(nn.Module):"""ResNext optimized for the Cifar dataset, as specified inhttps://arxiv.org/pdf/1611.05431.pdf"""def __init__(self,cardinality,depth,num_classes,base_width,expansion=4):""" ConstructorArgs:cardinality: number of convolution groups.depth: number of layers.num_classes: number of classesbase_width: base number of channels in each group.expansion: factor to adjust the channel dimensionality"""super(ResNeXt, self).__init__()self.cardinality = cardinalityself.depth = depthself.block_depth = (self.depth - 2) // 9self.base_width = base_widthself.expansion = expansionself.num_classes = num_classesself.output_size = 64self.stages = [64, 64 * self.expansion, 128 *self.expansion, 256 * self.expansion]self.conv_1_3x3 = nn.Conv2d(3, 64, 3, 1, 1, bias=False)self.bn_1 = nn.BatchNorm2d(64)self.stage_1 = self.block('stage_1', self.stages[0], self.stages[1], 1)self.stage_2 = self.block('stage_2', self.stages[1], self.stages[2], 2)self.stage_3 = self.block('stage_3', self.stages[2], self.stages[3], 2)self.fc = nn.Linear(self.stages[3], num_classes)for m in self.modules():if isinstance(m, nn.Conv2d):nn.init.kaiming_normal_(m.weight.data)elif isinstance(m, nn.BatchNorm2d):m.weight.data.fill_(1)m.bias.data.zero_()def block(self, name, in_channels, out_channels, pool_stride=2):block = nn.Sequential()for bottleneck in range(self.block_depth):name_ = '%s_bottleneck_%d' % (name, bottleneck)if bottleneck == 0:block.add_module(name_,Bottleneck(in_channels,out_channels,pool_stride,self.cardinality,self.base_width,self.expansion))else:block.add_module(name_,Bottleneck(out_channels,out_channels,1,self.cardinality,self.base_width,self.expansion))return blockdef forward(self, x):x = self.conv_1_3x3.forward(x)x = F.relu(self.bn_1.forward(x), inplace=True)x = self.stage_1.forward(x)x = self.stage_2.forward(x)x = self.stage_3.forward(x)x = F.avg_pool2d(x, 8, 1)x = x.view(-1, self.stages[3])return self.fc(x)def resnext29_8x64d(num_classes):return ResNeXt(cardinality=8,depth=29,num_classes=num_classes,base_width=64)def resnext29_16x64d(num_classes):return ResNeXt(cardinality=16,depth=29,num_classes=num_classes,base_width=64)

参考链接

1. https://zhuanlan.zhihu.com/p/54289848

2. https://zhuanlan.zhihu.com/p/28124810

3. https://zhuanlan.zhihu.com/p/31727402

4. https://zhuanlan.zhihu.com/p/56961832

5. https://zhuanlan.zhihu.com/p/54072011

6. https://github.com/BIGBALLON/CIFAR-ZOO

7. https://zhuanlan.zhihu.com/p/78019001

重磅！DLer-计算机视觉交流群已成立！

欢迎各位Cver加入计算机视觉微信交流大群，本群旨在交流图像分类、目标检测、点云/语义分割、目标跟踪、机器视觉、GAN、超分辨率、人脸检测与识别、动作行为/时空/光流/姿态/运动、模型压缩/量化/剪枝、NAS、迁移学习、人体姿态估计等内容。更有真实项目需求对接、求职内推、算法竞赛、干货资讯汇总、行业技术交流等，欢迎加群交流学习！

进群请备注：研究方向+学校/公司+昵称（如图像分类+上交+小明）

广告商、博主请绕道！

???? 长按识别添加，邀请您进群！