经典论文-SeNet论文及实践

Squeeze-and-Excitation Networks

• 作者：Jie Hu, Li Shen， Samuel Albanie， Gang Sun, Enhua Wu
• 单位： Chinese Academy of Sciences
• 论文地址： https://arxiv.org/pdf/1709.01507.pdf
• 项目地址：https://github.com/hujie-frank/SENet

摘要

卷积神经网络建立在卷积运算的基础上，通过融合局部感受野内的空间信息和通道信息来提取信息特征。为了提高网络的表示能力，许多现有的工作已经显示出增强空间编码的好处。在这项工作中，我们专注于通道，并提出了一种新颖的架构单元，我们称之为**“Squeeze-and-Excitation”（SE）模块**，通过显式地建模通道之间的相互依赖关系，自适应地重新校准通道式的特征响应。通过将这些块堆叠在一起，证明了可以构建SENet架构，在具有挑战性的数据集中可以进行泛化地非常好。关键的是，发现SE块以微小的计算成本为现有的最先进的深层架构产生了显著的性能改进。SENets是ILSVRC 2017分类提交的基础网络，它赢得了第一名，并将top-5错误率显著减少到$2.251\%$，相对于2016年的获胜成绩取得了$\sim 25\%$的相对改进。

1. 引言

卷积神经网络（CNNs）已被证明是解决各种视觉任务的有效模型[1，2，3，4]。对于每个卷积层，沿着输入通道学习一组滤波器来表达局部空间连接模式。换句话说，期望卷积滤波器通过融合空间信息和信道信息进行信息组合，而受限于局部感受野。通过叠加一系列非线性和下采样交织的卷积层，CNN能够捕获具有全局感受野的分层模式作为强大的图像描述。最近的工作已经证明，网络的性能可以通过显式地嵌入学习机制来改善，这种学习机制有助于捕捉空间相关性而不需要额外的监督。Inception架构推广了一种这样的方法[5，6]，这表明网络可以通过在其模块中嵌入多尺度处理来取得有竞争力的准确度。最近的工作在寻找更好地模型空间依赖[7，8]，结合空间注意力[9]。

本文与这些方法相反，通过引入新的架构单元，称之为“Squeeze-and-Excitation” (SE)模块**，我们研究了架构设计的一个不同方向——通道关系。目标是通过显式地建模卷积特征通道之间的相互依赖性来提高网络的表示能力。为了达到这个目的，提出了一种机制，使网络能够执行特征重新校准，通过这种机制可以学习使用全局信息来选择性地强调信息特征并抑制不太有用的特征。

SE构建块的基本结构如图1所示。对于任何给定的变换${\mathbf{F}}_{tr}:\mathbf{X}\to \mathbf{U}$, $\mathbf{X}\in {\mathbb{R}}^{W’\times H’\times C’},\mathbf{U}\in {\mathbb{R}}^{W\times H\times C}$，(例如卷积或一组卷积)，我们可以构造一个相应的SE块来执行特征重新校准，如下所示。特征$\mathbf{U}$首先通过squeeze操作，该操作跨越空间维度$W\times H$聚合特征映射来产生通道描述符。这个描述符嵌入了通道特征响应的全局分布，使来自网络全局感受野的信息能够被其较低层利用。这之后是一个excitation操作，其中通过基于通道依赖性的自门控机制为每个通道学习特定采样的激活，控制每个通道的激励。然后特征映射$\mathbf{U}$被重新加权以生成SE块的输出，然后可以将其直接输入到随后的层中。

图1. Squeeze-and-Excitation块

SENet可以通过简单地堆叠SE构建块的集合来生成。SE块也可以用作架构中任意深度的原始块的直接替换。然而，虽然构建块的模板是通用的，正如6.4节中展示的那样，但它在不同深度的作用适应于网络的需求。在前面的层中，它学习以类不可知的方式激发信息特征，增强共享的较低层表示的质量。在后面的层中，SE块越来越专业化，并以高度类特定的方式(7.2节)响应不同的输入。因此，SE块进行特征重新校准的好处可以通过整个网络进行累积。

新CNN架构的开发是一项具有挑战性的工程任务，通常涉及许多新的超参数和层配置的选择。相比之下，上面概述的SE块的设计是简单的，并且可以直接与现有的最新架构一起使用，其卷积层可以通过直接用对应的SE层来替换从而进行加强。另外，如第四节所示，SE块在计算上是轻量级的，并且在模型复杂性和计算负担方面仅稍微增加。

为了支持这些声明，我们开发了一些SENets网络，比如SE-ResNet，SE-Inception，SE-ResNeXt和SE-Inception-ResNet，并在ImageNet 2012数据集[10]上对上述SENets进行了广泛的评估。此外，为了证明SE块的一般适用性，还展示了ImageNet之外的结果，表明所提出的方法不受限于特定的数据集或任务。使用SENets，赢得了ILSVRC 2017分类竞赛的第一名。我们表现最好的模型集合在测试集上达到了$2.251\%$的top-5错误率。与前一年的获奖者（$2.991\%$的top-5错误率）相比，获得了$\sim 25\%$的相对改进。我们的模型和相关材料已经提供给研究界。

2. 近期工作

深层架构。 VGGNets[11]和Inception模型[5]证明了深度增加可以获得的好处，明显超过了ILSVRC 2014之前的方法。通过调节每一层输入的分布，批处理归一化(BN)[6]增加了深度网络学习过程的稳定性，并产生了更平滑的优化面[12]。基于这些工作，He等人[13,14]表明，通过重构架构来训练更深层次的网络是有效的，通过使用基于恒等映射的跳跃[13, 14]连接来学习残差函数，高速公路网络[15]引入了一种门控机制来调节沿着捷径连接的信息流，这在深度网络的学习和表征特性方面有了很好的改进。

另一种研究方法探索了调整网络模块化组件功能形式的方法。可以用分组卷积来增加基数（一组变换的大小）[18，19]以学习更丰富的表示。通过多分支卷积[5]、[6]、[20]、[21]可以实现更灵活的算子组合，这可以看作是分组算子的自然扩展。跨通道相关性通常被映射为新的特征组合，或者独立的空间结构[22，23]，或者联合使用标准卷积滤波器[24]和$1\times 1$卷积，然而大部分工作的目标是集中在减少模型和计算复杂度上面。这种方法反映了一个假设，即**通道关系可以被表述为具有局部感受野的实例不可知的函数的组合。**相比之下，我们声称为网络提供一种机制来显式建模通道之间的动态、非线性依赖关系，使用全局信息可以减轻学习过程，并且显著增强网络的表示能力。

算法架构搜索。除了上述的工作，还有一个丰富的研究历史，旨在放弃人工架构设计，而是寻求自动学习网络的结构。这一领域的大部分早期工作都是在神经进化社区中进行的，它利用进化方法[25]，[26]建立了跨网络拓扑进行搜索的方法。虽然进化搜索通常需要计算，但它已经取得了显著的成功，包括为序列模型[27]、[28]找到良好的记忆细胞，以及学习用于图像分类大规模分类[29]、[30]、[31]的复杂架构。为了减少这些方法的计算负担，人们提出了基于拉马克遗传（Lamarckian inheritance）[32]和可微架构搜索[33]的该方法的有效替代方法。通过将架构搜索定义为超参数优化、随机搜索[34]和其他更复杂的基于模型的优化技术[35]，[36]也可以用于解决这个问题。拓扑选择作为可能的设计[37]和直接架构预测[38]的路径，[39]被提出作为附加可行的架构搜索工具。通过强化学习的[40]，[41]，[42]，[43]，[44]的技术已经取得了特别强的结果。SE块可以用作这些搜索算法的原子构建块，并且在并发工作中被证明是非常有效的。

注意力和门机制。注意力可以被解释为一种偏向将可用的计算资源分配到信号[46]、[47]、[48]、[49]、[50]、[51]中信息最丰富的组件上的手段。注意机制已经在许多任务中证明了它们的效用，包括序列学习[52]、[53]、定位和理解图像[9]、[54]、图像字幕[55]、[56]和唇读[57]。在这些应用程序中，它可以作为一个操作符合并在一个或多个层次的抽象，以适应模式之间的层次。一些工作为空间注意力和通道注意力[58]，[59]的联合使用提供了有趣的研究。Wang等人[58]引入了一种基于沙漏模块[8]的强大的trunk-and-mask注意机制，该模块插入到深度残余网络的中间阶段之间。相比之下，本文提出的SE块包含一个轻量级的门控机制，该机制侧重于通过以计算效率高的方式建模信道关系来增强网络的表示能力。

3. Squeeze-and-Excitation块

Squeeze-and-Excitation块是一个计算单元，可以为任何给定的变换构建：${\mathbf{F}}_{tr}:\mathbf{X}\to \mathbf{U},\mathbf{X}\in {\mathbb{R}}^{W’\times H’\times C’},\mathbf{U}\in {\mathbb{R}}^{W\times H\times C}$。为了简化说明，在接下来的表示中，将${\mathbf{F}}_{tr}$看作一个标准的卷积算子。$\mathbf{V}=[{\mathbf{v}}_1,{\mathbf{v}}_2,\dots ,{\mathbf{v}}_C]$表示学习到的一组滤波器核，${\mathbf{v}}_c$指的是第$c$个滤波器的参数。然后可以将${\mathbf{F}}_{tr}$的输出写作$\mathbf{U}=[{\mathbf{u}}_1,{\mathbf{u}}_2,\dots ,{\mathbf{u}}_C]$，其中$${\mathbf{u}}_c={\mathbf{v}}_c\ast \mathbf{X}=\sum _{s=1}^{C’}{\mathbf{v}}_c^s\ast {\mathbf{x}}^s.$$这里$\ast$表示卷积，${\mathbf{v}}_c=[{\mathbf{v}}_c^1,{\mathbf{v}}_c^2,\dots ,{\mathbf{v}}_c^{C’}]$，$\mathbf{X}=[{\mathbf{x}}^1,{\mathbf{x}}^2,\dots ,{\mathbf{x}}^{C’}]$（为了简洁表示，忽略偏置项）。这里${\mathbf{v}}_c^s$是$2$D空间核，因此表示${\mathbf{v}}_c$的一个单通道，作用于对应的通道$\mathbf{X}$。由于输出是通过所有通道的和来产生的，所以通道依赖性被隐式地嵌入到${\mathbf{v}}_c$中，但是这些依赖性与滤波器捕获的空间相关性纠缠在一起。目标是确保能够提高网络对信息特征的敏感度，以便后续转换可以利用这些特征，并抑制不太有用的特征。建议通过显式建模通道依赖性来实现这一点，以便在进入下一个转换之前通过两步重新校准滤波器响应，两步为：squeeze和excitation。SE构建块的图如图1所示。

3.1. Squeeze:全局信息嵌入

为了解决利用通道依赖性的问题，首先考虑输出特征中每个通道的信号。每个学习到的滤波器都对局部感受野进行操作，因此变换输出$\mathbf{U}$的每个单元都无法利用该区域之外的上下文信息。在网络较低的层次上其感受野尺寸很小，这个问题变得更严重。

为了缓解这个问题，建议将全局空间信息(Squeeze)压缩到一个信道描述符中。这是通过使用全局平均池化来生成通道级统计数据来实现的。形式上，统计量$X\in R^C$是通过其空间维度$H\times W$收缩U生成的，这样z的第c个元素计算为：

讨论。变换U的输出可以解释为局部描述符的集合，这些描述符的统计数据可以表达整个图像。利用这些信息在之前的特征工程工作[60]，[61]，[62]中很普遍。选择了最简单的聚合技术，即全局平均池，并注意到在这里也可以使用更复杂的策略。

3.2. Excitation:自适应重新校正

为了利用压缩操作中汇聚的信息，接下来通过第二个操作来全面捕获通道依赖性。为了实现这个目标，这个功能必须符合两个标准：第一，它必须是灵活的（特别是它必须能够学习通道之间的非线性交互）；第二，它必须学习一个非互斥的关系，因为我们希望确保多个渠道被允许强调（而不是执行一个热激活）。为了满足这些标准，选择采用一个简单的门机制，并使用sigmoid激活：

其中$\delta$是指ReLU[63]函数，${\mathbf{W}}_1\in {\mathbb{R}}^{\frac{C}{r}\times C}$和${\mathbf{W}}_2\in {\mathbb{R}}^{C\times \frac{C}{r}}$。为了限制模型复杂度和辅助泛化，通过在非线性周围形成两个全连接（FC）层的瓶颈来参数化门机制，即降维层参数为${\mathbf{W}}_1$，降维比例为$r$（我们把它设置为16，这个参数选择在6.1节中讨论），一个ReLU，然后是一个参数为${\mathbf{W}}_2$的升维层。块的最终输出通过重新调节带有激活的变换输出$\mathbf{U}$得到：

其中$\tilde{\mathbf{X}}=[{\tilde{\mathbf{x}}}_1,{\tilde{\mathbf{x}}}_2,\dots ,{\tilde{\mathbf{x}}}_C]$和${\mathbf{F}}_{scale}({\mathbf{u}}_c,s_c)$指的是特征映射${\mathbf{u}}_c\in {\mathbb{R}}^{W\times H}$和标量$s_c$之间的对应通道乘积。

讨论。激励操作符将输入特定的描述符z映射到一组通道权值。在这方面，SE块本质上引入了基于输入的动态条件，这可以看作是通道上的自注意函数，这些通道的关系不局限于卷积滤波器响应的局部接受域。

3.3. 实例：SE-Inception和SE-ResNet

可以通过在每次卷积后的非线性层之后插入，将SE块集成到诸如VGGNet[11]等标准架构中。此外，SE块的灵活性意味着它可以直接应用于标准卷积之外的转换。为了说明这一点，通过将SE块合并到几个更复杂的架构示例中来开发SENets，下面将进行描述。

我们首先考虑Inception网络[5]的SE块的构造。在这里，简单地将转换$F_{tr}$视为一个完整的Inception模块（见图2），通过对体系结构中的每个这样的模块进行更改，得到了一个SE-Inception网络。SE块也可以直接与残差网络一起使用(图3描述了SE-ResNet模块的模式)。在这里，SE块变换$F_{tr}$被视为一个残差的非恒等式分支。Squeeze和Excitation都在与恒等分支求和之前起作用。将SE块与ResNeXt[19]、Inception-ResNet[21]、MebileNet[64]和ShuffleNet[65]集成的进一步变体可以通过以下类似的方案构建。对于SENet体系结构的具体示例，表1给出了SE-ResNet-50和SE-ResNeXt-50的详细描述。

图2。最初的Inception模块架构(左)和SE-Inception模块(右)。

SE块的灵活性特性的一个结果是，有几种可行的方法可以将其集成到这些架构中。因此，为了评估用于将SE块合并到网络体系结构中的集成策略的敏感性，还在6.5节中提供了探索不同块包含的消融设计。

图3。 最初的Residual模块架构(左)和SE-ResNet模块架构(右)。

4. 模型和计算复杂度

为了使所提出的SE块设计具有实际用途，它必须在改进性能和增加模型复杂性之间提供良好的权衡。为了说明与该模块相关的计算负担，我们以ResNet-50和SE-ResNet-50之间的比较为例。

ResNet-50需要在一个224×224像素的输入图像的单次向前传递中使用∼3.86GFLOPs。每个SE块利用压缩阶段的全局平均池化操作和激励阶段中的两个小的全连接层，接下来是不复杂的通道缩放操作， 总的而言，当将还原比r（在第3.2节中介绍）设置为16时，SE-ResNet-50需要∼3.87GFLOPs，相对于原来的ResNet-50增加0.26%。作为这种额外计算负担的交换，SE-ResNet50的精度超过了ResNet-50，而且确实接近于需要∼7.58的深层ResNet-101网络性能（如表2）。

表1。(左)ResNet-50，(中)SE-ResNet-50，(右)具有$32\times 4d$模板的SE-ResNeXt-50。在括号内列出了残差构建块特定参数设置的形状和操作，并且在外部呈现了一个阶段中堆叠块的数量。fc后面的内括号表示SE模块中两个全连接层的输出维度。

表2。ImageNet验证集上的单裁剪图像错误率（％）和复杂度比较。original列是指原始论文中报告的结果。为了进行公平比较，我们重新训练了基准模型，并在re-implementation列中报告分数。SENet列是指已添加SE块后对应的架构。括号内的数字表示与重新实现的基准数据相比的性能改善。†表示该模型已经在验证集的非黑名单子集上进行了评估（在[38]中有更详细的讨论），这可能稍微改善结果。

在实践中，训练的批数据大小为256张图像，ResNet-50的一次前向传播和反向传播花费$190$ ms，而SE-ResNet-50则花费$209$ ms（两个时间都在具有$8$个NVIDIA Titan X GPU的服务器上执行）。我们认为这是一个合理的开销，因为在现有的GPU库中，全局池化和小型内积操作的优化程度较低。此外，由于其对嵌入式设备应用的重要性，还对每个模型的CPU推断时间进行了基准测试：对于$224\times 224$像素的输入图像，ResNet-50花费了$164$ms，相比之下，SE-ResNet-$50$花费了$167$ms 。SE块所需的小的额外计算开销对于其对模型性能的贡献来说是合理的（在第6节中详细讨论）。

接下来，考虑所提出的块引入的附加参数。所有附加参数都包含在门机制的两个全连接层中，构成网络总容量的一小部分。更确切地说，引入的附加参数的数量由下式给出：

$$\frac{2}{r}\sum _{s=1}^S{N}_s\cdot {C_s}^2$$

其中$r$表示减少比率（我们在所有的实验中将$r$设置为$16$），$S$指的是阶段数量（每个阶段是指在共同的空间维度的特征映射上运行的块的集合），$C_s$表示阶段$s$的输出通道的维度，$N_s$表示重复的块编号。总的来说，SE-ResNet-50在ResNet-50所要求的$\sim$2500万参数之外引入了$\sim$250万附加参数，相对增加了$\sim 10%$的参数总数量。这些附加参数中的大部分来自于网络的最后阶段，其中激励在最大的通道维度上执行。然而，发现SE块相对昂贵的最终阶段可以在性能的边际成本（ImageNet数据集上$<0.1 %$的top-1错误率）上被移除，将相对参数增加减少到$\sim 4%$，这在参数使用是关键考虑的情况下可能证明是有用的。

5. 实现

在本节中，将进行实验来研究SE块在一系列任务、数据集和模型架构中的有效性。

5.1 图像分类

为了评估SE块的影响，我们首先在ImageNet 2012数据集[10]上进行实验，该数据集包括128万张训练图像和50K验证图像，来自1000个不同类别。在训练集上训练网络，并在验证集上报告top-1和top-5的错误率。

每个基线网络架构及其相应的SE对应物都用相同的优化方案进行训练。我们遵循标准实践，使用尺度和长宽比[5]进行数据增强，大小为224×224像素（或299×299为Inception-ResNet-v2[21]和SE-Inception-ResNet-v2），并执行随机水平翻转。每个输入图像通过平均rgb通道进行归一化。所有模型都是在分布式学习系统ROCS上进行训练的，ROCS设计用于处理大型网络的高效并行训练。优化器使用SGD，动量为0.9，批量大小为1024。初始学习率设置为0.6，每30个epochs减少10倍。使用[66]中描述的权重初始化策略，从头开始训练100个epoch。减少比r（在第3.2节中）默认设置为16（另有规定除外）。

在评估模型时，采用中心裁剪，以便从每张图像中裁剪224×224像素。首先对最短边resize到256，之后再从中心裁剪（如果是299x299时，先resize到352像素（Inception-ResNet-v2，SE-Inception-ResNet-v2））。

网络深度。 首先将SE-ResNet与不同深度的ResNet架构进行比较，并在表2中报告结果。我们观察到，SE块在不同的深度上持续提高性能，而计算复杂度的增加非常小，值得注意的是，SE-ResNet-50实现了单裁剪图像$6.62\%$的top-5验证错误率，超过了ResNet-50（$7.48\%$）$0.86\%$，接近更深的ResNet-101网络（$6.52\%$的top-5错误率），且只有ResNet-101一半的计算开销（$3.87$ GFLOPs vs. $7.58$ GFLOPs）。这种模式在更大的深度上重复，SE-ResNet-101（$6.07\%$的top-5错误率）不仅可以媲美，而且超过了更深的ResNet-152网络（$6.34\%$的top-5错误率）。图4分别描绘了SE-ResNets和ResNets的训练和验证曲线。虽然应该注意SE块本身增加了深度，但是它们的计算效率极高，即使在扩展的基础架构的深度达到收益递减的点上也能产生良好的回报。而且，可以看到通过对各种不同深度的训练，性能改进是一致的，这表明SE块引起的改进可以与增加基础架构更多深度结合使用。

图4。在ImageNet上训练基线架构及其SENet对应物。SENets表现出改进的优化特性，并产生一致的性能收益，在整个训练过程中持续。

与现代架构集成。 接下来将研究SE块与另外两种最先进的架构Inception-ResNet-v2[21]和ResNeXt[19]的结合效果。Inception架构将卷积模块构造为分解滤波器的多分支组合，反映了Inception假设，可以独立映射空间相关性和跨通道相关性。相比之下，ResNeXt体架构断言，可以通过聚合稀疏连接（在通道维度中）卷积特征的组合来获得更丰富的表示。两种方法都在模块中引入了先前结构化的相关性。我们构造了这些网络的SENet等价物，SE-Inception-ResNet-v2和SE-ResNeXt（表1给出了SE-ResNeXt-50（$32\times 4d$）的配置）。像前面的实验一样，原始网络和它们对应的SENet网络都使用相同的优化方案。

表2中给出的结果说明在将SE块引入到两种架构中会引起显著的性能改善。尤其是SE-ResNeXt-50的top-5错误率是$5.49\%$，优于于它直接对应的ResNeXt-50（$5.90\%$的top-5错误率）以及更深的ResNeXt-101（$5.57\%$的top-5错误率），这个模型几乎有两倍的参数和计算开销。对于Inception-ResNet-v2的实验，我们猜测可能是裁剪策略的差异导致了其报告结果与我们重新实现的结果之间的差距，因为它们的原始图像大小尚未在[38]中澄清，而我们从相对较大的图像（其中较短边被归一化为352）中裁剪出$299\times 299$大小的区域。SE-Inception-ResNet-v2（$4.79\%$的top-5错误率）比我们重新实现的Inception-ResNet-v2（$5.21\%$的top-5错误率）要低$0.42\%$（相对改进了$8.1\%$）也优于[38]中报告的结果。每个网络的优化曲线如图5所示，说明了在整个训练过程中SE块产生了一致的改进。

我们还通过使用VGG-16 [11]和bn-Inception架构[6]进行实验，来评估SE块在非残差网络上操作时的影响。为了便于从头开始训练VGG-16，我们在每次卷积后都添加了批处理归一化层。我们对VGG-16和SE-VGG-16都使用了相同的训练方案。比较结果见表2。与为残差基线架构报告的结果类似，我们观察到SE块在非残差设置上也带来了性能的改进。

为了深入了解SE块对这些模型优化的影响，图4描述了基线体系结构及其各自对应体系结构运行的训练曲线示例。我们观察到，SE块在整个优化过程中产生了一个稳定的改进。此外，这一趋势在一系列作为基线的网络架构中是相当一致的。

最后，我们通过对BN-Inception架构[14]进行实验来评估SE块在非残差网络上的效果，该架构在较低的模型复杂度下提供了良好的性能。比较结果如表2所示，训练曲线如图6所示，表现出的现象与残差架构中出现的现象一样。尤其是与BN-Inception $7.89\%$的错误率相比，SE-BN-Inception获得了更低$7.14\%$的top-5错误。这些实验表明SE块引起的改进可以与多种架构结合使用。而且，这个结果适用于残差和非残差基础。

移动设置：最后，考虑了移动优化网络类中的两个具有代表性的架构，MobileNet[64]和ShuffleNet[65]。在这些实验中，使用256的小批量数据，以及[65]中那样的数据增强和正则化，使用动量（设置为0.9）的初始学习率，初始学习率为0.1，每次验证损失趋于稳定时，初始学习率降低10倍。整个训练过程需要∼400个epoch（使我们能够重现[65]的基线性能）表3中报告的结果显示，SE块在最小提升计算成本的情况下持续改善性能。

其他数据集。 接下来研究SE块的有利拟合是否适用于ImageNet之外的数据集。我们在CIFAR-10和CIFAR-100数据集[70]上使用几种流行的基线架构和技术(ResNet-110[14]、ResNet-164[14]、WideResNet-16-8[67]、Shake-Shake[68]和Cutout[69])进行实验。这些图像包括50k训练和10k测试32×32像素的RGB图像，分别标记为10个和100个类。将SE块集成到这些网络中遵循了第3.3节中描述的相同方法。每个基线及其SENet对应物都用标准的数据增强策略[24]，[71]进行训练。在训练过程中，图像被随机水平翻转，并在每边进行零填充，然后随机裁剪32×32。平均值和标准差的标准化也被应用。训练超参数的设置（例如，小批量大小、初始学习率、权重衰减）与原始论文提出的建议相匹配。我们在表4中报告了每个基线及其SENet对应的数据在CIFAR-10上的性能，在表5中报告了在CIFAR-100上的性能。我们观察到，在每一次比较中，SENets的性能都优于基线架构，这表明SE块的好处并不局限于ImageNet数据集。

5.2. 场景分类

ImageNet数据集的大部分由单个对象支配的图像组成。为了在更多不同的场景下评估我们提出的模型，我们还在Places365-Challenge数据集[48]上对场景分类进行评估。该数据集包含800万张训练图像和365个类别的36500张验证图像。相对于分类，场景理解的任务可以更好地评估模型泛化和处理抽象的能力，因为它需要捕获更复杂的数据关联以及对更大程度外观变化的鲁棒性。

我们使用ResNet-152作为强大的基线来评估SE块的有效性，并遵循[33]中的评估协议。表4显示了针对给定任务训练ResNet-152模型和SE-ResNet-152的结果。具体而言，SE-ResNet-152（$11.01\%$的top-5错误率）取得了比ResNet-152（$11.61\%$的top-5错误率）更低的验证错误率，证明了SE块可以在不同的数据集上表现良好。这个SENet超过了先前的最先进的模型Places-365-CNN [33]，它在这个任务上有$11.48\%$的top-5错误率。

5.3 COCO数据集上的目标检测

我们使用COCO数据集[75]进一步评估了SE模块在目标检测任务上的泛化。与之前的工作[19]一样，使用了微型协议，即对80k训练集和35k val子集的并集进行训练模型，并对剩余的5k val子集进行评估。权重由在ImageNet数据集上训练的模型参数初始化。我们使用Faster R-CNN [4]检测框架作为评估我们的模型的基础模型，并遵循[76]中描述的超参数设置（即，使用“2x”学习计划的端到端训练）。我们的目标是评估用SE-ResNet替换对象检测器中的主干体系结构（ResNet）的效果，以便性能上的任何变化都可以归因于更好的表示。表7报告了使用ResNet-50、ResNet-101及其SE对应物作为主干架构的对象检测器的验证集性能。SE-ResNet-50的标准指标比ResNet-50高2.4%（相对提高6.3%），在AP@IoU=0.5上提高3.1%。SE块还有利于更深层次的ResNet-101体系结构，在AP度量上实现了2.0%的改进（5.0%的相对改进）。总之，这组实验证明了SE块的通用性。这种改进可以在广泛的架构、任务和数据集上实现。

5.4 ILSVRC 2017分类竞赛

ILSVRC 2017分类竞赛的结果。 ILSVRC是一个年度计算机视觉竞赛，被证明是图像分类模型发展的沃土。ILSVRC 2017分类任务的训练和验证数据来自ImageNet 2012数据集，而测试集包含额外的未标记的10万张图像。为了竞争的目的，使用top-5错误率度量来对输入条目进行排序。

SENets是我们在挑战中赢得第一名的基础。我们的获胜输入由一小群SENets组成，它们采用标准的多尺度和多裁剪图像融合策略，在测试集上获得了$2.251\%$的top-5错误率。这个结果表示在2016年获胜输入（$2.99\%$的top-5错误率）的基础上相对改进了$\sim 25\%$。我们的高性能网络之一是将SE块与修改后的ResNeXt[19]集成在一起构建的（附录A提供了这些修改的细节）。在表3中我们将提出的架构与最新的模型在ImageNet验证集上进行了比较。我们的模型在每一张图像使用$224\times 224$中间裁剪评估（短边首先归一化到256）取得了$18.68\%$的top-1错误率和$4.47\%$的top-5错误率。为了与以前的模型进行公平的比较，我们也提供了$320\times 320$的中心裁剪图像评估，在top-1($17.28\%$)和top-5($3.79\%$)的错误率度量中获得了最低的错误率。

在这个挑战之后，ImageNet的基准测试已经取得了很大的进一步进展。为了进行比较，我们包括了在表9中我们目前了解到的最好的结果。[79]最近报道了仅使用ImageNet数据的最佳性能。该方法利用强化学习，在训练过程中开发新的数据增强策略，以提高[31]搜索的体系结构的性能。80]使用ResNeXt-101 32×48d体系结构报告了最佳的总体性能。这是通过在大约10亿张弱标记图像上预训练他们的模型，并在ImageNet上进行微调来实现的。更复杂的数据增强[79]和广泛的预训练[80]所带来的改进可能是对我们提出的网络架构变化的补充。

6 消融实验

在本节中，进行了消融实验，以获得更好地理解使用不同的配置对SE块组件的影响。所有的消融实验都在一台机器上（有8个gpu）的ImageNet数据集上进行。使用ResNet-50作为主干架构。我们根据经验发现，在ResNet架构上，消除激励操作中FC层的偏差有助于通道依赖关系的建模，并在接下来的实验中使用这种配置。数据增强策略遵循5.1节中描述的方法。为了研究每个变体的性能上限，学习率被初始化为0.1，并继续训练，直到验证损失平台（总共∼300个epoch），然后将学习速率降低10倍，然后重复这个过程（总共三次）。在训练过程中使用了标签平滑正则化[20]。

6.1 减少比率

公式（5）中引入的减少比率$r$是一个重要的超参数，它允许我们改变模型中SE块的容量和计算成本。为了研究这种关系，我们基于SE-ResNet-50架构进行了一系列不同$r$值的实验。表10中的比较表明，性能并没有随着容量的增加而单调上升。这可能是使SE块能够过度拟合训练集通道依赖性的结果。尤其是我们发现设置$r=16$在精度和复杂度之间取得了很好的平衡，因此我们将这个值用于所有的实验。

6.2 Squeeze压缩操作

我们研究了使用全局平均池化而不是全局最大池化作为选择的挤压算子的重要性（因为这工作得很好，我们没有考虑更复杂的替代方案）。结果见表11。虽然最大池化和平均池化都是有效的，但平均池化的性能稍好一些，这证明了它的选择是挤压操作的基础。然而，我们注意到SE块的性能对于特定的聚合操作符的选择是相当健壮的。

6.3 Excitation 激励操作

接下来，我们评估了激励机制的非线性的选择。我们考虑另外两个选择： ReLU和tanh，并实验用这些替换sigmoid这些非线性函数。结果见表12。我们看到，将sigmoid替换为tanh会略微恶化性能，而使用ReLU会显著恶化，实际上会导致SE-ResNet-50的性能低于ResNet-50基线。 这表明，要使SE块有效，应该仔细构造激励算子是很重要的。

6.4 整体策略

最后，进行了一项消融研究，以评估在将SE块集成到现有架构时，SE块的位置的影响。除了提出的SE设计外，还考虑了三种变量： (1) SE-PRE块，其中SE块被移动到残差单元之前；(2) SE-POST块，其中SE单元在与恒等分支相加之后（ReLU之后）和(3) SE-Identity块，其中SE单元被放置在与剩余单元并行的恒等连接上

这些变体如图5所示，表14报告了每个变体的性能。我们观察到SE-PRE、SE-Identity和提出的SE块的表现都很好， 而SE-POST块会导致性能下降。该实验表明，如果SE单元在分支聚合之前应用，它们的位置是相当稳健的。

在上述实验中，每个SE块都被放置在一个残差单元的结构之外，我们还构造了一个设计的变体，它将SE块移动到残差单元内，并将其直接放置在3×3卷积层之后。由于3×3卷积层具有较少的通道，因此相应的SE块所引入的参数数量也减少了。表15中的比较表明，SE 3×3变量在比标准SE块更少的参数下获得了相当的分类精度。虽然这超出了本工作的范围，但我们预计，通过为特定架构定制SE块的使用，将可以实现进一步的提高效率。

7 SE块的作用

虽然所提出的SE块已被证明可以提高在多个视觉任务上的网络性能，但我们也想了解Squeeze挤压操作的相对重要性，以及excitation激励机制在实践中如何运行。对深度神经网络学习到的表征进行严格的理论分析仍然具有挑战性，因此，我们采用经验的方法来检验SE块所扮演的作用，目的是至少获得对其实际功能的原始理解。

7.1 Squeeze作用

为了评估squeeze挤压操作产生的全局嵌入是否在性能中发挥重要作用，我们实验了SE块的一个变体，它添加了相同数量的参数，但不执行全局平均池化。具体来说，我们去掉了池化操作，并在激励操作符中使用对应的1×1的卷积，即NoSqueeze，其中激励输出保持空间维度作为输入。与SE块相比，这些点积卷积只能作为本地操作符输出的函数重新映射通道。而在实践中，一个深度网络的后一层通常会拥有一个（理论上的）全局感受域，全局嵌入在NoSqueeze变体中不再可以直接通过整个网络访问。将两种模型的精度和计算复杂度与表16中的标准ResNet-50模型进行了比较。可以观察到，使用全局信息对模型的性能有显著的影响，这强调了挤压操作的重要性。此外，与NoSqueeze设计相比，SE块允许以一种计算简洁的方式使用这个全局信息。

7.2 Excitation作用

为了更清楚地了解SE块中Excitation激励算子的函数，在本节中我们研究一个例子从SE-ResNet-50模型中获得的激活，并检查它们在网络中不同深度的不同类别和不同输入图像中的分布。特别是，想了解激励是如何在不同类的图像以及类内的图像之间变化的。

我们首先考虑不同类的激励分布。具体来说，我们从ImageNet数据集中抽取了四种显示语义和外观多样性的类，即goldfifish, pug, plane 和 cliff (（这些类的示例图像显示在附录中）。然后，从验证集中为每个类抽取50个样本，并计算每个阶段最后一个SE块（紧接降采样之前）50个均匀采样通道的平均激活，并在图中绘制它们在图6的分布。作为参考，还绘制了所有1000个类的平均激活的分布。

我们对excitation激励操作的作用进行了以下三个观察。首先，不同类之间的分布在网络的早期层中非常相似，例如SE_2_3。这表明，在早期阶段，不同的类很可能会共享重要的特征通道，第二个观察结果是，在更大的深度上，每个通道的值变得更具体的类，因为不同的类对特征的鉴别值表现出不同的偏好，例如SE_4_6和SE_5_1。这些观察结果与之前的工作[81]，[82]的发现一致，即早期的层特征通常更普遍（例如，在分类任务的上下文中类不可知），而后来的层特征表现出更高水平的特异性[83]。

接下来，我们在网络的最后阶段观察到一个有些不同的现象。SE_5_2表现出一种有趣的饱和状态的趋势，其中大多数激活都接近于饱和状态。在所有激活的值都为1时，SE块简化为恒等运算符。在SE_5_3的网络末端（在分类器之前是全局池化），在不同的类上出现了类似的模式，在规模上有适度的变化（可以通过分类器进行调整）。这表明，SE_5_2和SE _5_3在提供网络重新校准方面不如以前的块重要。这一发现与第4节的实证调查结果一致，该结果表明，通过去除最后一阶段的SE块，额外的参数计数可以显著减少，而只有边际性能损失。

最后，我们在图7中展示了两个样本类（goldfish和plane）在同一类内的图像实例的激活量的平均值和标准差。我们观察到一个与类间可视化一致的趋势，这表明SE块的动态行为随着类和类内的实例而变化。特别是在网络的后一层，在单个类中有相当大的表示多样性，网络学习利用特征重新校准来提高其鉴别性能[84]。总之，SE块产生特定于实例的响应。它的功能是支持体系结构中不同层的模型日益特定于类的需求。

8. 结论

在本文中，我们提出了SE块，这是一个新颖的架构单元，旨在通过使网络能够执行动态的通道级特征重新校准来提高网络的表示能力。广泛的实验表明了SENet的有效性，它在多个数据集和任务上实现了最先进的性能。此外，SE块还揭示了以前的架构无法充分建模通道级的特性依赖关系。我们希望这种见解可以被证明对其他需要强鉴别特征的任务有用。最后，SE块产生的特征重要性值可能用于其他任务，如模型压缩的网络剪枝。

APPENDIX: DETAILS OF SENET-154

SENet-154是通过将SE块合并到64×4d ResNeXt-152的修改版本中来构建的。原ResNeXt-101 [19]采用ResNet-152 [13]的块叠加策略。与该模型的设计和训练（除了SE块的使用之外）的进一步区别如下：

• （a）对于每个瓶颈构建块，首先$1\times 1$卷积通道的数量减半，以性能下降最小的方式降低网络的计算成本
• （b）第一个$7\times 7$卷积层被三个连续的$3\times 3$卷积层所取代
• （c）步长为2的$1\times 1$卷积的下采样投影被替换步长为2的$3\times 3$卷积以保留信息
• （d）在分类器层之前插入一个dropout层（丢弃比为0.2）以防止过拟合
• （e）训练期间使用标签平滑正则化（如[40]中所介绍的）
• （f）在最后几个训练迭代周期，所有BN层的参数都被冻结，以确保训练和测试之间的一致性
• （g）使用8个服务器（64个GPU）并行执行训练，以实现大批量数据大小（2048），初始学习率为1.0

References

• [1] A. Krizhevsky, I. Sutskever, and G. E. Hinton, “ImageNet classififi-cation with deep convolutional neural networks,” in Conference on Neural Information Processing Systems, 2012.

• [2] A. Toshev and C. Szegedy, “DeepPose: Human pose estimation via deep neural networks,” in CVPR, 2014.

• [3] J. Long, E. Shelhamer, and T. Darrell, “Fully convolutional networks for semantic segmentation,” in CVPR, 2015.

• [4] S. Ren, K. He, R. Girshick, and J. Sun, “Faster R-CNN: Towards real-time object detection with region proposal networks,” in Conference on Neural Information Processing Systems, 2015.

• [5] C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich, “Going deeper with convolutions,” in CVPR, 2015.

• [6] S. Ioffe and C. Szegedy, “Batch normalization: Accelerating deep network training by reducing internal covariate shift,” in ICML, 2015.

• [7] S. Bell, C. L. Zitnick, K. Bala, and R. Girshick, “Inside-outside net: Detecting objects in context with skip pooling and recurrent neural networks,” in CVPR, 2016.

• [8] A. Newell, K. Yang, and J. Deng, “Stacked hourglass networks for human pose estimation,” in ECCV, 2016.

• [9] M. Jaderberg, K. Simonyan, A. Zisserman, and K. Kavukcuoglu, “Spatial transformer networks,” in Conference on Neural Information Processing Systems, 2015.

• [10] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. C. Berg, and L. Fei-Fei, “ImageNet large scale visual recognition challenge,” International Journal of Computer Vision, 2015.

• [11] K. Simonyan and A. Zisserman, “Very deep convolutional networks for large-scale image recognition,” in ICLR, 2015.

• [12] S. Santurkar, D. Tsipras, A. Ilyas, and A. Madry, “How does batch normalization help optimization? (no, it is not about internal covariate shift),” in Conference on Neural Information Processing Systems, 2018.

• [13] K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in CVPR, 2016.

• [14] K. He, X. Zhang, S. Ren, and J. Sun, “Identity mappings in deep residual networks,” in ECCV, 2016.

• [15] R. K. Srivastava, K. Greff, and J. Schmidhuber, “Training very deep networks,” in Conference on Neural Information Processing Systems, 2015.

• [16] Y. Chen, J. Li, H. Xiao, X. Jin, S. Yan, and J. Feng, “Dual path networks,” in Conference on Neural Information Processing Systems, 2017.

• [17] G. Huang, Z. Liu, K. Q. Weinberger, and L. Maaten, “Densely connected convolutional networks,” in CVPR, 2017.

• [18] Y. Ioannou, D. Robertson, R. Cipolla, and A. Criminisi, “Deep roots: Improving CNN effificiency with hierarchical fifilter groups,” in CVPR, 2017.

• [19] S. Xie, R. Girshick, P. Dollar, Z. Tu, and K. He, “Aggregated residual transformations for deep neural networks,” in CVPR, 2017.

• [20] C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna, “Rethinking the inception architecture for computer vision,” in CVPR, 2016.

• [21] C. Szegedy, S. Ioffe, V. Vanhoucke, and A. Alemi, “Inceptionv4, inception-resnet and the impact of residual connections on learning,” in AAAI Conference on Artifificial Intelligence, 2016.

• [22] M. Jaderberg, A. Vedaldi, and A. Zisserman, “Speeding up convolutional neural networks with low rank expansions,” in BMVC, 2014.

• [23] F. Chollet, “Xception: Deep learning with depthwise separable convolutions,” in CVPR, 2017.

• [24] M. Lin, Q. Chen, and S. Yan, “Network in network,” in ICLR, 2014.

• [25] G. F. Miller, P. M. Todd, and S. U. Hegde, “Designing neural networks using genetic algorithms.” in ICGA, 1989.

• [26] K. O. Stanley and R. Miikkulainen, “Evolving neural networks through augmenting topologies,” Evolutionary computation, 2002.

• [27] J. Bayer, D. Wierstra, J. Togelius, and J. Schmidhuber, “Evolving memory cell structures for sequence learning,” in ICANN, 2009.

• [28] R. Jozefowicz, W. Zaremba, and I. Sutskever, “An empirical exploration of recurrent network architectures,” in ICML, 2015.

• [29] L. Xie and A. L. Yuille, “Genetic CNN,” in ICCV, 2017.

• [30] E. Real, S. Moore, A. Selle, S. Saxena, Y. L. Suematsu, J. Tan, Q. Le, and A. Kurakin, “Large-scale evolution of image classififiers,” in ICML, 2017.

• [31] E. Real, A. Aggarwal, Y. Huang, and Q. V. Le, “Regularized evolution for image classififier architecture search,” arXiv preprint arXiv:1802.01548, 2018.

• [32] T. Elsken, J. H. Metzen, and F. Hutter, “Effificient multi-objective neural architecture search via lamarckian evolution,” arXiv preprint arXiv:1804.09081, 2018.

• [33] H. Liu, K. Simonyan, and Y. Yang, “DARTS: Differentiable architecture search,” arXiv preprint arXiv:1806.09055, 2018.

• [34] J. Bergstra and Y. Bengio, “Random search for hyper-parameter optimization,” JMLR, 2012.

• [35] C. Liu, B. Zoph, J. Shlens, W. Hua, L.-J. Li, L. Fei-Fei, A. Yuille, J. Huang, and K. Murphy, “Progressive neural architecture search,” in ECCV, 2018.

• [36] R. Negrinho and G. Gordon, “Deeparchitect: Automatically designing and training deep architectures,” arXiv preprint arXiv:1704.08792, 2017.

• [37] S. Saxena and J. Verbeek, “Convolutional neural fabrics,” in Conference on Neural Information Processing Systems, 2016.

• [38] A. Brock, T. Lim, J. M. Ritchie, and N. Weston, “SMASH: one-shot model architecture search through hypernetworks,” in ICLR, 2018.

• [39] B. Baker, O. Gupta, R. Raskar, and N. Naik, “Accelerating neural architecture search using performance prediction,” in ICLR Workshop, 2018.

• [40] B. Baker, O. Gupta, N. Naik, and R. Raskar, “Designing neural network architectures using reinforcement learning,” in ICLR, 2017.

• [41] B. Zoph and Q. V. Le, “Neural architecture search with reinforcement learning,” in ICLR, 2017.

• [42] B. Zoph, V. Vasudevan, J. Shlens, and Q. V. Le, “Learning transferable architectures for scalable image recognition,” in CVPR, 2018.

• [43] H. Liu, K. Simonyan, O. Vinyals, C. Fernando, and K. Kavukcuoglu, “Hierarchical representations for effificient architecture search,” in ICLR, 2018.

• [44] H. Pham, M. Y. Guan, B. Zoph, Q. V. Le, and J. Dean, “Effificient neural architecture search via parameter sharing,” in ICML, 2018.

• [45] M. Tan, B. Chen, R. Pang, V. Vasudevan, and Q. V. Le, “Mnasnet: Platform-aware neural architecture search for mobile,” arXiv preprint arXiv:1807.11626, 2018.

• [46] B. A. Olshausen, C. H. Anderson, and D. C. V. Essen, “A neurobiological model of visual attention and invariant pattern recognition based on dynamic routing of information,” Journal of Neuroscience, 1993.

• [47] L. Itti, C. Koch, and E. Niebur, “A model of saliency-based visual attention for rapid scene analysis,” IEEE Transactions on Pattern Analysis and Machine Intelligence, 1998.

• [48] L. Itti and C. Koch, “Computational modelling of visual attention“, Nature reviews neuroscience, 2001.

• [49] H. Larochelle and G. E. Hinton, “Learning to combine foveal glimpses with a third-order boltzmann machine,” in Conference on Neural Information Processing Systems, 2010.

• [50] V. Mnih, N. Heess, A. Graves, and K. Kavukcuoglu, “Recurrent models of visual attention,” in Conference on Neural Information Processing Systems, 2014.

• [51] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” in Conference on Neural Information Processing Systems, 2017.

• [52] T. Bluche, “Joint line segmentation and transcription for end-to end handwritten paragraph recognition,” in Conference on Neural Information Processing Systems, 2016.

• [53] A. Miech, I. Laptev, and J. Sivic, “Learnable pooling with context gating for video classifification,” arXiv:1706.06905, 2017.

• [54] C. Cao, X. Liu, Y. Yang, Y. Yu, J. Wang, Z. Wang, Y. Huang, L. Wang, C. Huang, W. Xu, D. Ramanan, and T. S. Huang, “Look and think twice: Capturing top-down visual attention with feedback convolutional neural networks,” in ICCV, 2015.

• [55] K. Xu, J. Ba, R. Kiros, K. Cho, A. Courville, R. Salakhudinov, R. Zemel, and Y. Bengio, “Show, attend and tell: Neural image caption generation with visual attention,” in ICML, 2015.

• [56] L. Chen, H. Zhang, J. Xiao, L. Nie, J. Shao, W. Liu, and T. Chua, “SCA-CNN: Spatial and channel-wise attention in convolutional networks for image captioning,” in CVPR, 2017.

• [57] J. S. Chung, A. Senior, O. Vinyals, and A. Zisserman, “Lip reading sentences in the wild,” in CVPR, 2017.

• [58] F. Wang, M. Jiang, C. Qian, S. Yang, C. Li, H. Zhang, X. Wang, and X. Tang, “Residual attention network for image classifification,” in CVPR, 2017.

• [59] S. Woo, J. Park, J.-Y. Lee, and I. S. Kweon, “CBAM: Convolutional block attention module,” in ECCV, 2018.

• [60] J. Yang, K. Yu, Y. Gong, and T. Huang, “Linear spatial pyramid matching using sparse coding for image classifification,” in CVPR, 2009.

• [61] J. Sanchez, F. Perronnin, T. Mensink, and J. Verbeek, “Image classifification with the fifisher vector: Theory and practice,” International Journal of Computer Vision, 2013.

• [62] L. Shen, G. Sun, Q. Huang, S. Wang, Z. Lin, and E. Wu, “Multilevel discriminative dictionary learning with application to large scale image classifification,” IEEE TIP, 2015.

• [63] V. Nair and G. E. Hinton, “Rectifified linear units improve restricted boltzmann machines,” in ICML, 2010.

• [64] A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, and H. Adam, “MobileNets: Effificient convolutional neural networks for mobile vision applications," arXiv:1704.04861, 2017.

• [65] X. Zhang, X. Zhou, M. Lin, and J. Sun, “ShufflfleNet: An extremely effificient convolutional neural network for mobile devices,” in CVPR, 2018.

• [66] K. He, X. Zhang, S. Ren, and J. Sun, “Delving deep into rectififiers: Surpassing human-level performance on ImageNet classifification,” in ICCV, 2015.

• [67] S. Zagoruyko and N. Komodakis, “Wide residual networks,” in BMVC, 2016.

• [68] X. Gastaldi, “Shake-shake regularization,” arXiv preprint arXiv:1705.07485, 2017.

• [69] T. DeVries and G. W. Taylor, “Improved regularization of convolutional neural networks with cutout,” arXiv preprint arXiv:1708.04552, 2017.

• [70] A. Krizhevsky and G. Hinton, “Learning multiple layers of features from tiny images,” Citeseer, Tech. Rep., 2009.

• [71] G. Huang, Y. Sun, Z. Liu, D. Sedra, and K. Q. Weinberger, “Deep networks with stochastic depth,” in ECCV, 2016.

• [72] L. Shen, Z. Lin, G. Sun, and J. Hu, “Places401 and places365 models,” https://github.com/lishen-shirley/Places2-CNNs, 2016.

• [73] B. Zhou, A. Lapedriza, A. Khosla, A. Oliva, and A. Torralba, “Places: A 10 million image database for scene recognition,” IEEE Transactions on Pattern Analysis and Machine Intelligence, 2017.

• [74] L. Shen, Z. Lin, and Q. Huang, “Relay backpropagation for effective learning of deep convolutional neural networks,” in ECCV, 2016.

• [75] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollar, and C. L. Zitnick, “Microsoft COCO: Common objects in context,” in ECCV, 2014.

• [76] R. Girshick, I. Radosavovic, G. Gkioxari, P. Dollar, and K. He, “Detectron,” https://github.com/facebookresearch/detectron, 2018.

• [77] D. Han, J. Kim, and J. Kim, “Deep pyramidal residual networks,” in CVPR, 2017.

• [78] X. Zhang, Z. Li, C. C. Loy, and D. Lin, “Polynet: A pursuit of structural diversity in very deep networks,” in CVPR, 2017.

• [79] E. D. Cubuk, B. Zoph, D. Mane, V. Vasudevan, and Q. V. Le, “Autoaugment: Learning augmentation policies from data,” arXiv preprint arXiv:1805.09501, 2018.

• [80] D. Mahajan, R. Girshick, V. Ramanathan, K. He, M. Paluri, Y. Li, A. Bharambe, and L. van der Maaten, “Exploring the limits of weakly supervised pretraining,” in ECCV, 2018.

• [81] H. Lee, R. Grosse, R. Ranganath, and A. Y. Ng, “Convolutional deep belief networks for scalable unsupervised learning of hierarchical representations,” in ICML, 2009.

• [82] J. Yosinski, J. Clune, Y. Bengio, and H. Lipson, “How transferable are features in deep neural networks?” in Conference on Neural Information Processing Systems, 2014.

• [83] A. S. Morcos, D. G. Barrett, N. C. Rabinowitz, and M. Botvinick, “On the importance of single directions for generalization,” in ICLR, 2018.

• [84] J. Hu, L. Shen, S. Albanie, G. Sun, and A. Vedaldi, “Gather-excite: Exploiting feature context in convolutional neural networks,” in Conference on Neural Information Processing Systems, 2018.

实现

基于torch1.8 实现SeResNet50

## 导入相关的包
import os
import sys
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt

import torch
import torch.nn as nn
import torch.nn.init as init
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import torchvision
from torchvision import transforms
from torchvision import datasets
from torchvision.models import ResNet
from torch.hub import load_state_dict_from_url

# 设置运行环境
os.environ['CUDA_VISIABLE_DIVICES'] = '0'   # GPU
# os.environ['CUDA_VISIABLE_DIVICES'] = ''  # CPU


# 设置超参数
batch_size = 128
lr = 1e-4
num_works = 8
epochs = 100

image_size = 224

data_transform = transforms.Compose(
    [transforms.Resize(image_size), transforms.ToTensor()]
)

## 准备相关数据
# load_data
train_data = datasets.CIFAR10(root='./', train=True, download=True, transform=data_transform)
test_data = datasets.CIFAR10(root='./', train=False, download=True, transform=data_transform)

# data loader
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=num_works, drop_last=True)
test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=num_works, drop_last=False)

# show a picture
image, label = next(iter(train_loader))
print(image.shape, label.shape)
plt.imshow(image[0][0], cmap='gray')


# build basic model
class SELayer(nn.Module):
    def __init__(self, channel, reduction=16):
        super(SELayer, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel, bias=False),
            nn.Sigmoid()
        )

    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y.expand_as(x)
    
    
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)


# 基于se的残差块
class SEBasicBlock(nn.Module):
    expansion = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
                 base_width=64, dilation=1, norm_layer=None,
                 *, reduction=16):
        super(SEBasicBlock, self).__init__()
        self.conv1 = conv3x3(inplanes, planes, stride)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(planes, planes, 1)
        self.bn2 = nn.BatchNorm2d(planes)
        self.se = SELayer(planes, reduction)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.se(out)

        if self.downsample is not None:
            residual = self.downsample(x)

        out += residual
        out = self.relu(out)

        return out
    
    
    
class SEBottleneck(nn.Module):
    expansion = 4

    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
                 base_width=64, dilation=1, norm_layer=None,
                 *, reduction=16):
        super(SEBottleneck, 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.se = SELayer(planes * 4, reduction)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        residual = x

        out = 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)
        out = self.se(out)

        if self.downsample is not None:
            residual = self.downsample(x)

        out += residual
        out = self.relu(out)

        return out
    

def se_resnet50(num_classes=1_000, pretrained=False):
    """Constructs a ResNet-50 model.
    Args:
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    model = ResNet(SEBottleneck, [3, 4, 6, 3], num_classes=num_classes)
    model.avgpool = nn.AdaptiveAvgPool2d(1)
    if pretrained:
        model.load_state_dict(load_state_dict_from_url(
            "https://github.com/moskomule/senet.pytorch/releases/download/archive/seresnet50-60a8950a85b2b.pkl"))
    return model


## 超参数，优化器 loss选择并训练
model = se_resnet50().cuda()  # gpu
# model = se_resnet50()  # cpu
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=lr)

# Summary 模型保存，log曲线
from torch.utils.tensorboard import SummaryWriter

writer1 = SummaryWriter('./runs/loss')
writer2 = SummaryWriter('./runs/acc')


def train(epoch):
    model.train()
    train_loss = 0
    for data, label in train_loader:
        data, label = data.cuda(), label.cuda()
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()
        train_loss += loss.item() * data.size(0)
    train_loss = train_loss / len(train_loader.dataset)
    writer1.add_scalar('loss', train_loss, epoch)
    print('Epoch: {} \tTraining Loss: {:.6f}'.format(epoch, train_loss))

    
def val(epoch):
    model.eval()
    val_loss = 0
    gt_labels = []
    pred_labels = []
    with torch.no_grad():
        for data, label in test_loader:
            data, label = data.cuda(), label.cuda()
            output = model(data)
            preds = torch.argmax(output, 1)
            gt_labels.append(label.cpu().data.numpy())
            pred_labels.append(preds.cpu().data.numpy())
            loss = criterion(output, label)
            val_loss += loss.item() * data.size(0)
    # 计算验证集的平均损失
    val_loss = val_loss /len(test_loader.dataset)
    writer1.add_scalar('loss', val_loss, epoch)
    gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(pred_labels)
    # 计算准确率
    acc = np.sum(gt_labels ==pred_labels)/len(pred_labels)
    writer2.add_scalar('acc', acc, epoch)
    print('Epoch: {} \tValidation Loss: {:.6f}, Accuracy: {:6f}'.format(epoch, val_loss, acc))
    
for epoch in range(1, epochs):
    train(epoch)
    val(epoch)

Epoch: 1 	Training Loss: 0.006197
Epoch: 1 	Validation Loss: 1.216656, Accuracy: 0.812400
Epoch: 2 	Training Loss: 0.009846
Epoch: 2 	Validation Loss: 1.194462, Accuracy: 0.811500
Epoch: 3 	Training Loss: 0.012974
Epoch: 3 	Validation Loss: 1.261616, Accuracy: 0.801700
Epoch: 4 	Training Loss: 0.007324
Epoch: 4 	Validation Loss: 1.098541, Accuracy: 0.825700
Epoch: 5 	Training Loss: 0.007421
Epoch: 5 	Validation Loss: 1.131869, Accuracy: 0.817000
Epoch: 6 	Training Loss: 0.012053
Epoch: 6 	Validation Loss: 1.285318, Accuracy: 0.801200
Epoch: 7 	Training Loss: 0.008391
Epoch: 7 	Validation Loss: 1.105770, Accuracy: 0.824800
Epoch: 8 	Training Loss: 0.007407
Epoch: 8 	Validation Loss: 1.101353, Accuracy: 0.822000
Epoch: 9 	Training Loss: 0.017247
Epoch: 9 	Validation Loss: 1.120953, Accuracy: 0.815800
Epoch: 10 	Training Loss: 0.007326
Epoch: 10 	Validation Loss: 1.078075, Accuracy: 0.820900
Epoch: 11 	Training Loss: 0.005727
Epoch: 11 	Validation Loss: 1.115142, Accuracy: 0.824700
Epoch: 12 	Training Loss: 0.003235
Epoch: 12 	Validation Loss: 1.071482, Accuracy: 0.825300
Epoch: 13 	Training Loss: 0.002914
Epoch: 13 	Validation Loss: 1.380002, Accuracy: 0.794300
Epoch: 14 	Training Loss: 0.026956
Epoch: 14 	Validation Loss: 1.142319, Accuracy: 0.813600
Epoch: 15 	Training Loss: 0.007456
Epoch: 15 	Validation Loss: 1.053252, Accuracy: 0.831700
Epoch: 16 	Training Loss: 0.001648
Epoch: 16 	Validation Loss: 1.020194, Accuracy: 0.835900
Epoch: 17 	Training Loss: 0.001522
Epoch: 17 	Validation Loss: 1.027686, Accuracy: 0.832400
Epoch: 18 	Training Loss: 0.008243
Epoch: 18 	Validation Loss: 1.396998, Accuracy: 0.790400
Epoch: 19 	Training Loss: 0.019509
Epoch: 19 	Validation Loss: 1.281632, Accuracy: 0.802900
Epoch: 20 	Training Loss: 0.010239
Epoch: 20 	Validation Loss: 1.027465, Accuracy: 0.829000
Epoch: 21 	Training Loss: 0.005435
Epoch: 21 	Validation Loss: 1.113640, Accuracy: 0.816100
Epoch: 22 	Training Loss: 0.006981
Epoch: 22 	Validation Loss: 1.124926, Accuracy: 0.820200
Epoch: 23 	Training Loss: 0.005138
Epoch: 23 	Validation Loss: 1.070682, Accuracy: 0.828400
Epoch: 24 	Training Loss: 0.008008
Epoch: 24 	Validation Loss: 1.188039, Accuracy: 0.814500
Epoch: 25 	Training Loss: 0.012424
Epoch: 25 	Validation Loss: 1.169044, Accuracy: 0.815600
Epoch: 26 	Training Loss: 0.006919
Epoch: 26 	Validation Loss: 1.090215, Accuracy: 0.823900
Epoch: 27 	Training Loss: 0.004939
Epoch: 27 	Validation Loss: 1.098545, Accuracy: 0.824500
Epoch: 28 	Training Loss: 0.004092
Epoch: 28 	Validation Loss: 1.070245, Accuracy: 0.825700
Epoch: 29 	Training Loss: 0.005777
Epoch: 29 	Validation Loss: 1.254185, Accuracy: 0.801200
Epoch: 30 	Training Loss: 0.014821
Epoch: 30 	Validation Loss: 1.106400, Accuracy: 0.823600
Epoch: 31 	Training Loss: 0.010393
Epoch: 31 	Validation Loss: 1.127024, Accuracy: 0.822100
Epoch: 32 	Training Loss: 0.007448
Epoch: 32 	Validation Loss: 1.089350, Accuracy: 0.821300
Epoch: 33 	Training Loss: 0.004222
Epoch: 33 	Validation Loss: 1.070658, Accuracy: 0.830900
Epoch: 34 	Training Loss: 0.003194
Epoch: 34 	Validation Loss: 1.116960, Accuracy: 0.820600
Epoch: 35 	Training Loss: 0.005828
Epoch: 35 	Validation Loss: 1.194685, Accuracy: 0.818100
Epoch: 36 	Training Loss: 0.015829
Epoch: 36 	Validation Loss: 1.113171, Accuracy: 0.822000
Epoch: 37 	Training Loss: 0.006209
Epoch: 37 	Validation Loss: 1.112627, Accuracy: 0.823200
Epoch: 38 	Training Loss: 0.003732
Epoch: 38 	Validation Loss: 1.148167, Accuracy: 0.826000
Epoch: 39 	Training Loss: 0.006753
Epoch: 39 	Validation Loss: 1.163127, Accuracy: 0.818800
Epoch: 40 	Training Loss: 0.009212
Epoch: 40 	Validation Loss: 1.059855, Accuracy: 0.831200
Epoch: 41 	Training Loss: 0.001818
Epoch: 41 	Validation Loss: 1.081294, Accuracy: 0.835300
Epoch: 42 	Training Loss: 0.004566
Epoch: 42 	Validation Loss: 1.164896, Accuracy: 0.823200
Epoch: 43 	Training Loss: 0.015835
Epoch: 43 	Validation Loss: 1.162611, Accuracy: 0.820800
Epoch: 44 	Training Loss: 0.004936
Epoch: 44 	Validation Loss: 1.094652, Accuracy: 0.827900
Epoch: 45 	Training Loss: 0.004041
Epoch: 45 	Validation Loss: 1.145985, Accuracy: 0.816900
Epoch: 46 	Training Loss: 0.005705
Epoch: 46 	Validation Loss: 1.178761, Accuracy: 0.827500
Epoch: 47 	Training Loss: 0.006816
Epoch: 47 	Validation Loss: 1.117509, Accuracy: 0.830300
Epoch: 48 	Training Loss: 0.006704
Epoch: 48 	Validation Loss: 1.123136, Accuracy: 0.827300
Epoch: 49 	Training Loss: 0.005876
Epoch: 49 	Validation Loss: 1.162662, Accuracy: 0.821500
Epoch: 50 	Training Loss: 0.008731
Epoch: 50 	Validation Loss: 1.167454, Accuracy: 0.825300
Epoch: 51 	Training Loss: 0.008613
Epoch: 51 	Validation Loss: 1.294547, Accuracy: 0.808000
Epoch: 52 	Training Loss: 0.006725
Epoch: 52 	Validation Loss: 1.116650, Accuracy: 0.833800
Epoch: 53 	Training Loss: 0.005218
Epoch: 53 	Validation Loss: 1.108299, Accuracy: 0.830100
Epoch: 54 	Training Loss: 0.005740
Epoch: 54 	Validation Loss: 1.067041, Accuracy: 0.832700
Epoch: 55 	Training Loss: 0.005275
Epoch: 55 	Validation Loss: 1.205709, Accuracy: 0.822000
Epoch: 56 	Training Loss: 0.007252
Epoch: 56 	Validation Loss: 1.168793, Accuracy: 0.827100
Epoch: 57 	Training Loss: 0.007940
Epoch: 57 	Validation Loss: 1.068549, Accuracy: 0.834900
Epoch: 58 	Training Loss: 0.003175
Epoch: 58 	Validation Loss: 1.166235, Accuracy: 0.823600
Epoch: 59 	Training Loss: 0.002775
Epoch: 59 	Validation Loss: 1.157118, Accuracy: 0.831500
Epoch: 60 	Training Loss: 0.011233
Epoch: 60 	Validation Loss: 1.136464, Accuracy: 0.826700
Epoch: 61 	Training Loss: 0.008459
Epoch: 61 	Validation Loss: 1.183527, Accuracy: 0.823000
Epoch: 62 	Training Loss: 0.004816
Epoch: 62 	Validation Loss: 1.143768, Accuracy: 0.834400
Epoch: 63 	Training Loss: 0.005402
Epoch: 63 	Validation Loss: 1.132395, Accuracy: 0.829600
Epoch: 64 	Training Loss: 0.005939
Epoch: 64 	Validation Loss: 1.088398, Accuracy: 0.832800
Epoch: 65 	Training Loss: 0.006679
Epoch: 65 	Validation Loss: 1.130293, Accuracy: 0.829900
Epoch: 66 	Training Loss: 0.006953
Epoch: 66 	Validation Loss: 1.178849, Accuracy: 0.824400
Epoch: 67 	Training Loss: 0.004669
Epoch: 67 	Validation Loss: 1.104968, Accuracy: 0.830900
Epoch: 68 	Training Loss: 0.002345
Epoch: 68 	Validation Loss: 1.093381, Accuracy: 0.836600
Epoch: 69 	Training Loss: 0.007551
Epoch: 69 	Validation Loss: 1.189730, Accuracy: 0.827500
Epoch: 70 	Training Loss: 0.010745
Epoch: 70 	Validation Loss: 1.153572, Accuracy: 0.832900
Epoch: 71 	Training Loss: 0.005294
Epoch: 71 	Validation Loss: 1.079362, Accuracy: 0.838200
Epoch: 72 	Training Loss: 0.001344
Epoch: 72 	Validation Loss: 1.043825, Accuracy: 0.844000
Epoch: 73 	Training Loss: 0.001564
Epoch: 73 	Validation Loss: 1.144649, Accuracy: 0.833000
Epoch: 74 	Training Loss: 0.013637
Epoch: 74 	Validation Loss: 1.089317, Accuracy: 0.832600
Epoch: 75 	Training Loss: 0.008307
Epoch: 75 	Validation Loss: 1.248292, Accuracy: 0.820200
Epoch: 76 	Training Loss: 0.003438
Epoch: 76 	Validation Loss: 1.066194, Accuracy: 0.841300
Epoch: 77 	Training Loss: 0.001628
Epoch: 77 	Validation Loss: 1.160034, Accuracy: 0.832100
Epoch: 78 	Training Loss: 0.006852
Epoch: 78 	Validation Loss: 1.083493, Accuracy: 0.835400
Epoch: 79 	Training Loss: 0.003457
Epoch: 79 	Validation Loss: 1.134959, Accuracy: 0.833200
Epoch: 80 	Training Loss: 0.005477
Epoch: 80 	Validation Loss: 1.117704, Accuracy: 0.836200
Epoch: 81 	Training Loss: 0.004470
Epoch: 81 	Validation Loss: 1.195279, Accuracy: 0.830000
Epoch: 82 	Training Loss: 0.003692
Epoch: 82 	Validation Loss: 1.085580, Accuracy: 0.842500
Epoch: 83 	Training Loss: 0.010547
Epoch: 83 	Validation Loss: 1.129026, Accuracy: 0.833000
Epoch: 84 	Training Loss: 0.006752
Epoch: 84 	Validation Loss: 1.068371, Accuracy: 0.841700
Epoch: 85 	Training Loss: 0.005572
Epoch: 85 	Validation Loss: 1.096544, Accuracy: 0.832700
Epoch: 86 	Training Loss: 0.004139
Epoch: 86 	Validation Loss: 1.029078, Accuracy: 0.845200
Epoch: 87 	Training Loss: 0.002595
Epoch: 87 	Validation Loss: 1.080700, Accuracy: 0.833700
Epoch: 88 	Training Loss: 0.005427
Epoch: 88 	Validation Loss: 1.214780, Accuracy: 0.823000
Epoch: 89 	Training Loss: 0.008483
Epoch: 89 	Validation Loss: 1.080743, Accuracy: 0.837000
Epoch: 90 	Training Loss: 0.004502
Epoch: 90 	Validation Loss: 1.131596, Accuracy: 0.831400
Epoch: 91 	Training Loss: 0.003841
Epoch: 91 	Validation Loss: 1.107346, Accuracy: 0.836400
Epoch: 92 	Training Loss: 0.006907
Epoch: 92 	Validation Loss: 1.214701, Accuracy: 0.822600
Epoch: 93 	Training Loss: 0.008277
Epoch: 93 	Validation Loss: 1.157797, Accuracy: 0.833600
Epoch: 94 	Training Loss: 0.003175
Epoch: 94 	Validation Loss: 1.069129, Accuracy: 0.839900
Epoch: 95 	Training Loss: 0.001216
Epoch: 95 	Validation Loss: 1.072251, Accuracy: 0.842800
Epoch: 96 	Training Loss: 0.003600
Epoch: 96 	Validation Loss: 1.520384, Accuracy: 0.795500
Epoch: 97 	Training Loss: 0.012480
Epoch: 97 	Validation Loss: 1.129360, Accuracy: 0.836400
Epoch: 98 	Training Loss: 0.004314
Epoch: 98 	Validation Loss: 1.214102, Accuracy: 0.823500
Epoch: 99 	Training Loss: 0.004418
Epoch: 99 	Validation Loss: 1.134002, Accuracy: 0.839200

参考

• https://github.com/pytorch/vision/blob/e2573a71c093bd5f8fe5a312cc642cd80a54f719/torchvision/models/resnet.py
• https://zhuanlan.zhihu.com/p/474790387
• https://blog.csdn.net/qq_42754919/article/details/106468510
• https://github.com/moskomule/senet.pytorch/blob/8cb2669fec6fa344481726f9199aa611f08c3fbd/senet/se_module.py
• https://blog.csdn.net/uncle_ll/article/details/124279623
• https://discuss.pytorch.org/t/resnet-bottleneck-layers-groups-width-per-group/69088