2018CVPR:Non-local Neural Networks（自注意力机制捕获远程依赖）

前言

远程依赖的定义：

• Long-range dependencies make the difference—Comment on “A stochastic model for EEG microstate sequence analysis”
• Long Range Dependence - Cornell University

在阅读Coordination attention时了解到空间位置信息之间的远程依赖关系，经查询了解到ORDNET对短中远程依赖的提取，并对原始的自注意力机制进行了比较，指出原始的自注意力机制捕获的远程依赖特征的不精确性，因此来了解下自注意力机制论文的实现，再继续了解ORDNET会更深刻。
论文下载链接：
2018CVPR:Non-local Neural Networks

Abstract

卷积运算和recurrent运算都是一次处理一个局部邻域的构建块。在本文中，我们将非局部操作表示为一个通用的构建块族，用于捕获远程依赖关系。受计算机视觉中经典非局部均值方法[4]的启发，我们的非局部操作将某个位置的响应计算为所有位置特征的加权和。这种构建块可以插入到许多计算机视觉体系结构中。在视频分类任务上，即使没有任何不必要的附属配件，我们的非局部模型也可以在Kinetics和Charades datasets上与当前的竞争优胜者竞争或超越他们。在静态图像识别中，我们的非局部模型改进了COCO任务集上的目标检测/分割和姿势估计。Code will be made available。

[4]A. Buades, B. Coll, and J.-M. Morel. A non-local algorithm for image denoising. InComputer Vision and Pattern Recognition (CVPR), 2005.1,2,3

1. Introduction

捕获远程依赖在深度神经网络中具有至关重要性。对于序列数据（例如，在语音、语言中），recurrent operations[36,22]是远程依赖建模的主要解决方案。对于图像数据，远程依赖性是由深层的卷积运算形成的大感受野建模的[13,29]。

远古参考文献：
[22]S. Hochreiter and J. Schmidhuber. Long short-term memory.Neural computation, 1997.1
[36]D. E. Rumelhart, G. E. Hintont, and R. J. Williams. Learning representations by back-propagating errors.Nature, 1986.1
[13]K. Fukushima and S. Miyake. Neocognitron: A self-organizing neural network model for a mechanism of visual pattern recognition. InCompetition and cooperation in neural nets. Springer, 1982.1
[29]Y . LeCun, B. Boser, J. S. Denker, D. Henderson, R. E.Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition.Neural computation, 1989.1

卷积运算和recurrent运算都处理局部邻域，无论是在空间还是时间上；因此，只有重复应用这些操作，通过数据逐步传播信号，才能捕获长程依赖关系。重复局部操作有几个限制。

1. 首先，它的计算效率很低。
2. 其次，它会导致需要仔细解决的优化困难[22,20]。
3. 最后，这些挑战使得多跳依赖建模(multihop dependency modeling)变得困难，例如，当信息需要在远程位置之间来回传递时。

在本文中，我们将非局部操作作为一种高效、简单和通用的组件，用于使用深度神经网络捕获远程依赖关系。我们提出的非局部运算是计算机视觉中经典非局部平均运算[4]的推广。直观地说，非局部操作将某个位置的响应计算为输入特征映射中所有位置特征的加权和（图1）。位置集可以是空间、时间或时空，这意味着我们的操作适用于图像、序列和视频问题。

图1：我们网络中的时空非局部操作，用于视频分类。位置$x_i$的响应由所有位置$x_j$特征的加权平均值计算（此处仅显示加权最高的位置）。在这个由我们的模型计算的示例中，请注意它如何将第一帧中的球与最后两帧中的球关联起来。更多示例如图3所示。

使用非局部操作有几个优点：
（a） 与recurrent运算和卷积运算的渐进行为相反，非局部运算通过计算任意两个位置之间的交互直接捕获远程依赖，而不管它们的位置距离如何；
（b） 正如我们在实验中所展示的，非局部操作是有效的，即使只有几层（例如5层），也能达到最佳效果；
（c） 最后，我们的非局部操作保持可变的输入大小，并且可以轻松地与其他操作（例如，我们将使用的卷积）组合。

我们展示了非局部操作在视频分类应用中的有效性。在视频中，空间和时间上的遥远像素之间会发生远距离交互。一个非局部块（我们的基本单元）可以以前馈方式直接捕获这些时空依赖关系。对于一些非局部块，我们称之为非局部神经网络的架构比2D和3D卷积网络[46]（包括膨胀变量（the inflated variant ）[6]）更准确地用于视频分类。此外，非局部神经网络比三维卷积神经网络在计算上更经济。在Kinetics[26]和Charades[42]数据集上介绍了全面的消融研究。只使用RGB且没有任何不必要的附属配件（例如，optical flow，多尺度测试），我们的方法达到的结果比或最优于两个数据集上最新的比赛winners。

为了证明非局部操作的通用性，我们进一步在COCO数据集上进行了对象检测/分割和姿势估计实验[31]。在强大的Mask R-CNN baseline[18]的基础上，我们的非局部块可以增加所有三项任务的精度，而额外的计算成本很小。结合视频上的证据，这些图像实验表明，非局部操作通常是有用的，可以成为设计深层神经网络的基本构件。

2. Related Work

Non-local image processing. 非局部均值[4]是一种经典的滤波算法，用于计算图像中所有像素的加权平均值。它允许远距离像素在基于patch外观相似性的位置对过滤响应作出贡献。这种非局部滤波思想后来发展为BM3D（block-matching 3D）[9]，它对一组类似但非局部的patch执行滤波。即使与深度神经网络相比，BM3D也是一个可靠的图像去噪baseline[5]。非局部匹配（Non-local matching）也是成功的纹理合成（texture synthesis）[11]、超分辨率（super-resolution ）[15]和修复（inpainting ）[1]算法的本质。
Graphical models. 远程依赖可以通过图形模型建模，如条件随机场（conditional random fields:CRF）[28,27]。在深层神经网络的背景下，可以利用CRF对网络的语义分段预测进行后期处理[8]。CRF的迭代平均场推断可以转化为一个递归网络并进行训练[54,40,7,17,32]。相比之下，我们的方法是计算非局部滤波的简单前馈块。与这些为分割而开发的方法不同，我们的通用组件用于分类和检测。这些方法和我们的方法也与一个更抽象的模型有关，称为图神经网络[39]。

[27]P . Kr¨ahenb¨uhl and V . Koltun. Efficient inference in fully connected crfs with gaussian edge potentials. InNeural Information Processing Systems (NIPS), 2011.2
[28]J. Lafferty, A. McCallum, and F. C. Pereira. Conditional random fields: Probabilistic models for segmenting and labeling sequence data. InInternational Conference on Machine Learning (ICML), 2001.2

Feedforward modeling for sequences. 最近出现了一种使用前馈（即非递归）网络对语音和语言序列建模的趋势[34,52,14]。在这些方法中，长期（long-term）依赖性由非常深的1-D卷积产生的大感受野捕获。这些前馈模型适用于并行实现，并且比广泛使用的递归模型更有效。

Self-attention. 我们的工作与最近的机器翻译的self-attention[47]方法有关。自注意模块通过关注所有位置并在嵌入空间中取其加权平均值来计算序列（例如句子）中某个位置的响应。正如我们将在下一步中讨论的那样，self-attention可以被视为non-local mean的一种形式[4]，从这个意义上说，我们的工作将机器翻译的自注意与适用于计算机视觉中图像和视频问题的更一般的非局部过滤操作联系起来。

[47]A. V aswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones,A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In Neural Information Processing Systems (NIPS),2017.2,3,6

Interaction networks. Interaction Networks(IN)[2,50]最近被提出用于物理系统建模。它们在涉及pairwise交互的对象的图形上进行操作。Hoshen[23]在多智能体预测建模的背景下提出了（VAIN）中更有效的顶点注意。另一个变体，命名为关系网络[38]，在其输入中的所有位置对特征嵌入计算函数。我们的方法也处理所有对，我们将在等式（1）中解释$f(x_i,x_j)$。虽然我们的非局部网络与这些方法相联系，但我们的实验表明，模型的非局部性（与attention/interaction/relation的想法正交）（例如，网络可以关注局部区域）是其经验成功的关键。非局部建模是图像处理的一个长期关键要素（如[11,4]），在最近的计算机视觉神经网络中被大量忽略。

Video classification architectures. 视频分类的自然解决方案是将CNN用于图像和RNN用于序列的成功结合起来[53,10]。 相反，前馈模型是通过时空中的3D卷积（C3D）[25,46]实现的，3D滤波器可以通过“膨胀”[12,6]预先训练的2D滤波器形成。除了对原始视频输入进行端到端建模外，还发现optical flow[43]和trajectories [48,49]也很有帮助。flow和trajectories都是现成的模块，可能会发现长期的非局部依赖性。视频架构的系统比较可在[6]见到。

3. Non-local Neural Networks

我们首先给出非局部操作的一般定义，然后提供几个具体的实例。

3.1. Formulation

根据非局部平均运算[4]，我们将深度神经网络中的一般非局部运算定义为：
$${\mathbf{y}}_i=\frac{1}{C(\mathbf{x})}\sum _{\forall j}f({\mathbf{x}}_i,{\mathbf{x}}_j)g({\mathbf{x}}_j).---(1)$$
此处$i$是要计算其响应的输出位置（在空间、时间或时空中）的索引并且$j$是列出所有可能位置的索引。$\mathbf{x}$是输入信号（图像、序列、视频；通常是它们的特征）然后$\mathbf{y}$是与$\mathbf{x}$大小相同的输出信号。一个pairwise函数$f$在$i$和所有的$j$之间计算一个标量（表示类同之类的关系）。一元函数$g$计算一个在位置$j$的输入信号的表示。响应通过因子$C(\mathbf{x})$标准化。

式（1）中的非局部行为是由于在操作中所有位置（$\forall j$） 都考虑到了。作为比较，卷积运算将加权输入相加为一个局部邻域值（$localneighborhood$）（例如，$i-1\le J\le i+1$，在卷积核大小为3的1D情况下）和时间$i$处的recurrent操作通常仅基于当前和最新的时间步长(例如，$j=iorj=i-1$)

非局部操作也不同于全连接（$fc$）层。公式（1）根据不同位置之间的关系计算响应，其中$fc$使用学习的权重。换句话说，与非局部层不同，$x_j$和$x_i$之间的关系不是$fc$中输入数据的函数。此外，等式（1）中的公式支持可变大小的输入，并在输出中保持相应的大小。相反，一个$fc$层需要固定大小的输入/输出，并且会丢失位置关联（例如，从$x_i$到$y_i$在$i$的位置）

非局部操作是一种灵活的构建块，可以很简单地与卷积/递归层一起使用。它可以被添加到深层神经网络的早期部分，而不是最后经常使用的$fc$层。这使我们能够构建一个结合了非局部和局部信息的更丰富的层次结构。

3.2. Instantiations

接下来，我们将介绍几个版本的$f$和$g$。有趣的是，我们将通过实验（表2a）证明我们的非局部模型对这些选择不敏感，这表明一般的非局部行为是观察到的改进的主要原因。

公式1有介绍$f$和$g$的定义，$f$：位置间的类同标量函数，表示两位置间的相关性；$g$：位置输入信号函数，对输入的feature map赋权。

为简单起见，我们仅考虑$g$在线性嵌入的形式：$g({\mathbf{x}}_{\mathbf{j}})=W_g{\mathbf{x}}_j$，其中$W_g$是要学习的权重矩阵。这被实现为，例如，空间中的$1\times 1$卷积或时空中的$1\times 1\times 1$卷积。

接下来我们讨论pairwise函数$f$的选择。

Gaussian. 在non-local mean[4]和bilateral filters [45]之后，$f$的自然选择是高斯函数。在本文中，我们考虑：$$f({\mathbf{x}}_i,{\mathbf{x}}_j)=e^{{\mathbf{x}}_i^T{\mathbf{x}}_j}.---(2)$$
这里${\mathbf{x}}_i^T{\mathbf{x}}_j$是点积相似性。[4,45]中使用的欧几里德距离也适用，但是点积在现代深度学习平台中更易于实现。标准化因子设置为$C(\mathbf{x})={\sum }_{\forall j}f({\mathbf{x}}_i,{\mathbf{x}}_j)$。

Embedded Gaussian. 高斯函数的一个简单扩展是计算嵌入空间中的相似性。在本文中，我们考虑：$$f({\mathbf{x}}_i,{\mathbf{x}}_j)=e^{\theta ({\mathbf{x}}_i{)}^T\varphi ({\mathbf{x}}_j)}.---(3)$$
其中$\theta ({\mathbf{x}}_i)=W_{\theta }{\mathbf{x}}_i$和$\varphi ({\mathbf{x}}_j)=W_{\varphi }{\mathbf{x}}_j$是两个嵌入件。如上所述，我们设置$C(\mathbf{x})={\sum }_{\forall j}f({\mathbf{x}}_i,{\mathbf{x}}_j)$。

我们注意到，最近为机器翻译提出的self-attention module[47]是嵌入式高斯版本中非局部操作的特例。这可以从以下事实中看出：对于给定的$i$，$\frac{1}{C(\mathbf{x})}f({\mathbf{x}}_i,{\mathbf{x}}_j)$，变为沿$j$维度的$softmax$估计。所以我们有$\mathbf{y}=softmax({\mathbf{x}}^T{W}_{\theta }^T{W}_{\varphi }\mathbf{x})g(\mathbf{x})$（基于Embedded Gaussian），这是[47]中的自我注意形式。

[47]A. V aswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones,A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. InNeural Information Processing Systems (NIPS),2017.2,3,6
这篇论文后续会精读

因此，我们的工作通过将这一最新的self-attention model与经典计算机视觉方法non-local means[4]相关联，提供了见解，并将[47]中的sequential self-attention network扩展为计算机视觉中用于图像/视频识别的通用space/spacetime non-local network。

[4]A. Buades, B. Coll, and J.-M. Morel. A non-local algorithm for image denoising. InComputer Vision and Pattern Recognition (CVPR), 2005.1,2,3
这篇论文后续会精读

尽管与[47]有关，但我们发现attentional behavior（由于softmax）在我们研究的应用中并不重要。为了说明这一点，我们接下来将描述non-local operations的两个替代版本。

Dot product. $f$被定义为点积相似性：$$f({\mathbf{x}}_i,{\mathbf{x}}_j)=\theta ({\mathbf{x}}_i{)}^T\varphi ({\mathbf{x}}_j).---(4)$$
这里我们采用嵌入版本的点积。在这种情况，我们设置标准化因子$C(\mathbf{x})=N$，其中$N$是输入$\mathbf{x}$的位置数目，而不是$f$的总数（点积总数），因为它简化了梯度计算（避免了原因子$C(\mathbf{x})$求导）。像这样的标准化是必要的，因为输入可以具有可变的大小。
Dot product和Embedded Gaussian版本之间的主要区别是$softmax$的存在，它起着激活函数的作用。

Dot product 的标准化因子是$N$，Embedded Gaussian. 的标准化因子是$\frac{1}{C(\mathbf{x})}f({\mathbf{x}}_i,{\mathbf{x}}_j)$，实现方式是$softmax$，上面的嵌入式高斯有具体描述。

Concatenation. Concatenation由在用于视觉推理的关系网络[38]的pairwise函数使用。我们还对$f$的Concatenation形式进行了评估：$$f({\mathbf{x}}_i,{\mathbf{x}}_j)=\mathbf{R}\mathbf{e}\mathbf{L}\mathbf{U}({\mathbf{w}}_f^T[\theta ({\mathbf{x}}_i),\varphi ({\mathbf{x}}_j)]).---(5)$$
这里$[\cdot ,\cdot ]$表示concatenation，${\mathbf{w}}_f$是将concatenation向量投影到标量的权重向量。如上所述，我们设置$C(\mathbf{x})=N$。在这种情况，我们在$f$中采用了ReLU[33]。

这里两种变体的标准化因子$C(\mathbf{x})=N$，

以上几个变体展示了我们generic non-local operation的灵活性。我们相信替代版本是可能的，并可能改善结果。

3.3. Non-local Block

我们将等式（1）中的non-local operation包装成一个non-local block，该块可以合并到许多现有架构中。我们将non-local block定义为：$${\mathbf{z}}_i=W_z{\mathbf{y}}_i+{\mathbf{x}}_i,---(6)$$

${\mathbf{y}}_i=\frac{1}{C(\mathbf{x})}{\sum }_{\forall j}f({\mathbf{x}}_i,{\mathbf{x}}_j)g({\mathbf{x}}_j).---(1)$

其中${\mathbf{y}}_i$在等式（1）中给出，"$+{\mathbf{x}}_i$"表示残差连接[20]。残差连接允许我们将新的non-local block插入任何预先训练的模型中，而不会破坏其initial behavior（例如，如果$W_z$被初始化为零）。

以上之所以不会破坏预训练模型的初始化表现是因为残差连接反向传播的特点。

图2中举例说明了一个non-local block。等式（2）、（3）或（4）中的pairwise函数计算可以简单地通过矩阵乘法完成，如图2所示；等式（5）的concatenation版本很简单。

$f({\mathbf{x}}_i,{\mathbf{x}}_j)=e^{{\mathbf{x}}_i^T{\mathbf{x}}_j}.---(2)$
$f({\mathbf{x}}_i,{\mathbf{x}}_j)=e^{\theta ({\mathbf{x}}_i{)}^T\varphi ({\mathbf{x}}_j)}.---(3)$
$f({\mathbf{x}}_i,{\mathbf{x}}_j)=\theta ({\mathbf{x}}_i{)}^T\varphi ({\mathbf{x}}_j).---(4)$
$f({\mathbf{x}}_i,{\mathbf{x}}_j)=\mathbf{R}\mathbf{e}\mathbf{L}\mathbf{U}({\mathbf{w}}_f^T[\theta ({\mathbf{x}}_i),\varphi ({\mathbf{x}}_j)]).---(5)$

图2：一个时空的non-local block 。特征图显示为其张量的shape，例如，1024个通道的$T\times H\times W\times 1024$（如有必要，应进行适当的reshaping）。"$⨂$“表示矩阵乘法，”$⨁$"表示逐元素加法。对每行执行softmax操作。蓝色框表示$1\times 1\times 1$卷积。这里我们展示了embedded Gaussian版本，有512个通道的bottleneck。普通Gaussian版本可以通过去除$\theta$和$\varphi$来实现，然后dot-product版本可以通过将$softmax$替换为$1/N$的缩放比例来实现。

non-local block的pairwise计算在用于高层特征图或子采样特征图时是轻量级的。例如，图2的典型值是$T=4,H=W=14or7$。通过矩阵乘法进行的pairwise计算可与标准网络中的典型卷积层进行比较。我们进一步采用以下实现，使其更加高效。

Implementation of Non-local Blocks. 我们将$W_g,W_{\theta }$和$W_{\varphi }$表示的通道数设置为$\mathbf{x}$通道数的一半。这遵循了ResNet[20]的bottleneck设计，并将block的计算量减少了约一半。公式（6）的权重矩阵$W_z$计算了一个在${\mathbf{y}}_i$的逐位置嵌入，将通道数与$\mathbf{x}$的通道数进行匹配。见图2。

${\mathbf{z}}_i=W_z{\mathbf{y}}_i+{\mathbf{x}}_i,---(6)$
[20]K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition (CVPR), 2016.1,4,5

子采样trick可用于进一步减少计算量。我们修改了公式（1）为：${\mathbf{y}}_i=\frac{1}{C(\hat{\mathbf{x}})}{\sum }_{\forall j}f({\mathbf{x}}_i,{\hat{\mathbf{x}}}_j)g({\hat{\mathbf{x}}}_j)$，其中$\hat{\mathbf{x}}$是$\mathbf{x}$的子采样版本（例如 pooling）。我们在空间域中执行此操作，这可以将pairwise计算量减少1/4。这种trick不会改变non-local behavior，只会使计算变得更稀疏。这可以通过在$\varphi$和$g$在图2之后添加max pooling层来实现。

我们将这些有效的修改用于本文研究的所有non-local blocks。

4. Video Classification Models

为了了解non-local网络的行为，我们对视频分类任务进行了全面的消融实验。首先，我们描述了此任务的baseline网络架构，然后将其扩展到3D ConvNet[46,6]和我们建议的non-local网络。

2D ConvNet baseline (C2D). 对3D ConvNets隔离我们的non-local网络的时间效应，我们构建了一个简单的2D baseline体系结构，在该体系结构中，时间维度被简单地处理（即，仅通过pooling）。表1显示了我们在ResNet-50 backbone下的C2D baseline。输入视频片段有32帧，每帧224×224像素。表1中的所有卷积本质上都是2D卷积核，逐帧处理输入（实现为$1\times k\times k$卷积核）。该模型可以直接从ImageNet上预先训练的ResNet权重初始化。ResNet-101的对应部分也是以同样的方式构建的。

唯一包含时域的操作是pooling层。换句话说，这个baseline简单地聚合了时域信息。

Inflated 3D ConvNet (I3D). 如[12,6]所述，通过“膨胀”卷积核，可以将表1中的C2D模型转化为3D卷积模型。例如，2D $k\times k$ 卷积可以膨胀为跨越$t$帧的3D $t\times k\times k$ 卷积核。该卷积核可以从2D模型初始化（在ImageNet上预训练）：$t\times k\times k$卷积核中的每个$t$ planes由预先训练的$k\times k$权重初始化，并按$1/t$重新缩放。如果视频包含一个在时间上重复的静态帧，则此初始化将生成与在静态帧上运行的2D预训练模型相同的结果。

我们研究了两种膨胀情况：我们要么将残差块中的$3\times 3$卷积核膨胀到$3\times 3\times 3$（类似于[6]），要么将残差块中的第一个$1\times 1$卷积核膨胀到$3\times 1\times 1$（类似于[12]）。我们将其表示为$\mathbf{I}3{\mathbf{D}}_{3\times 3\times 3}$和$\mathbf{I}3{\mathbf{D}}_{3\times 1\times 1}$。由于三维卷积是计算密集型的，我们只为每2个残差块膨胀一个卷积核；将更多层膨胀显示出收益递减。我们把$\mathbf{c}\mathbf{o}\mathbf{n}{\mathbf{v}}_1$膨胀到$5\times 7\times 7$。

[6]的作者已经证明，$\mathbf{I}3\mathbf{D}$模型比CNN+LSTM模型更精确。

[6]J. Carreira and A. Zisserman. Quo vadis, action recognition?a new model and the kinetics dataset. InComputer Vision andPattern Recognition (CVPR), 2017.1,2,4,6,7,8
12]C. Feichtenhofer, A. Pinz, and R. Wildes. Spatiotemporal residual networks for video action recognition. InNeural Information Processing Systems (NIPS), 2016.2,4

Non-local network. 我们将non-local blocks插入C2D或I3D，以将它们转换为non-local网络。我们研究添加1、5或10个非局部块；下一节将在上下文中描述实现细节。

图3：由在Kinetics上训练的5-block non-local模型计算的$re{s}_3$中non-local block 的behavior示例。这些示例来自公开的验证视频。箭头的起点表示${\mathbf{x}}_i$，终点表示${\mathbf{x}}_j$。对每个${\mathbf{x}}_i$可视化了20个最高权重的箭头。这4帧来自32帧输入，显示步幅为8帧。这些可视化显示了模型如何找到相关线索来支持其预测。

4.1. Implementation Details

Training. 我们的模型是在ImageNet上预先训练的[37]。除非规定，否则我们使用32帧输入片段对模型进行微调。这些片段是通过从原始未删减的视频中随机剪切出64个连续帧，然后每隔一帧删除一帧而形成的。空间大小为224×224像素，从缩放视频中随机裁剪，其较短的一侧以[256，320]像素随机采样，如下[44]。我们在一台8-GPU机器上训练，每个GPU在一个小批量中有8个片段（因此小批量总共有64个片段）。我们总共为400k次迭代训练我们的模型，从学习率0.01开始，每150k次迭代将学习率降低10倍（见图4）。我们使用0.9的动量和0.0001的重量衰减。我们在全局池层之后采用了Dropout[21]，dropout率为0.5。应用BatchNorm（BN）[24]时，我们会对模型进行微调。这与微调Resnet的常见做法形成对比[20]，在这种做法中，BN被冻结。我们发现，在应用中启用BN可以减少过度拟合。

[44]K. Simonyan and A. Zisserman. V ery deep convolutional networks for large-scale image recognition. InInternational Conference on Learning Representations (ICLR), 2015.5

我们采用[19]中的方法初始化non-local blocks中引入的权重层。我们在代表$W_z$的最后$1\times 1\times 1$层之后添加了一个BN层；我们不会将BN添加到non-local blocks中的其他层。此BN层的尺度参数初始化为零，遵循[16]。这确保了整个non-local blocks的初始状态是一致映射，因此可以将其插入任何预先训练的网络中，同时保持其初始behavior。

[19]K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. InInternational Conference on Computer Vision (ICCV), 2015.5
[16]P . Goyal, P . Doll´ar, R. Girshick, P . Noordhuis, L. Wesolowski,A. Kyrola, A. Tulloch, Y . Jia, and K. He. Accurate, large minibatch sgd: Training imagenet in 1 hour.arXiv:1706.02677,2017.5

Inference. 在[44]之后，我们对短边被重新缩放到256的视频执行空间上全卷积推断。对于时域，在我们的实践中，我们从一个未删减的视频中均匀地采样10个片段，并分别计算它们的softmax分数。最后的预测是所有片段的平均softmax分数。

5. Experiments on Video Classification

我们对具有挑战性的Kinetics数据集[26]进行了综合研究。我们还报告了Charades数据集[42]的结果，以显示我们模型的通用性。

5.1. Experiments on Kinetics

Kinetics[26]包含∼246k训练视频和20k验证视频。这是一项涉及400个人类行为类别的分类任务。我们在训练集上训练所有模型，并在验证集上进行测试。

表2：在Kinetics行为分类的消融实验。我们显示了top-1和top-5分类准确率（%）。
（a）不同类型的non-local block：
Gaussian：$f({\mathbf{x}}_i,{\mathbf{x}}_j)=e^{{\mathbf{x}}_i^T{\mathbf{x}}_j}.$，标准化因子为softmax
Gaussian embed：$f({\mathbf{x}}_i,{\mathbf{x}}_j)=e^{\theta ({\mathbf{x}}_i{)}^T\varphi ({\mathbf{x}}_j)}.$，标准化因子为softmax（作者默认使用的版本，便于可视化）
dot product：$f({\mathbf{x}}_i,{\mathbf{x}}_j)=\theta ({\mathbf{x}}_i{)}^T\varphi ({\mathbf{x}}_j).$，标准化因子为N
concatenation：$f({\mathbf{x}}_i,{\mathbf{x}}_j)=\mathbf{R}\mathbf{e}\mathbf{L}\mathbf{U}({\mathbf{w}}_f^T[\theta ({\mathbf{x}}_i),\varphi ({\mathbf{x}}_j)]).$，标准化因子为N
（b）1个non-local block的不同添加位置的增益：$re{s}_i$为Resnet-50的不同block。
（c）1个，5个和10个non-local block添加到ResNet-50和ResNet-101的baseline的增益。
（d）5个non-local block在ResNet-50和ResNet-101两种深度的模型在空间/时间/时空维度分别进行non-local操作的结果。
（e）~（g）的解释略。

图4显示了ResNet-50 C2D baseline的训练过程曲线，对比具有5个块的non-local C2D（更多详细信息见下文）。在整个训练过程中，我们的non-local C2D模型在训练和验证误差方面始终优于C2D baseline。

图1和图3可视化了由我们的模型计算的non-local block behavior的几个示例。我们的人际网络可以学习寻找有意义的关系线索，而不考虑空间和时间的距离。

关于论文其他实验的部分，这里没有给出，有兴趣的可以翻看原论文作者的实验

1个non-local block加在$re{s}_3$的增益：

7. Conclusion

我们提出了一类新的神经网络，它通过non-local操作捕获远程依赖关系。我们的non-local block可以与任何现有架构相结合。我们展示了非局部建模在视频分类、目标检测和分割以及姿态估计任务中的重要性。在所有任务中，简单地添加非局部块可以提供对baseline的可靠改进。我们希望non-local层将成为未来网络架构的重要组成部分。

个人总结

non-local block的网络结构

图2：一个时空的non-local block 。特征图显示为其张量的shape，例如，1024个通道的$T\times H\times W\times 1024$（如有必要，应进行适当的reshaping）。"$⨂$“表示矩阵乘法，”$⨁$"表示逐元素加法。对每行执行softmax操作。蓝色框表示$1\times 1\times 1$卷积，有512个通道的bottleneck。

论文的non-local block默认使用Embed Gaussian版本
$$\mathbf{y}=softmax({\mathbf{x}}^T{W}_{\theta }^T{W}_{\varphi }\mathbf{x})g(\mathbf{x})$$
这里$softmax=\frac{exp({\mathbf{x}}_i)}{{\sum }_{j}exp({\mathbf{x}}_j)}$（${\mathbf{x}}_i$对应${\mathbf{x}}^T$，${\mathbf{x}}_j$对应$\mathbf{x}$）
$$\mathbf{z}=W_z\mathbf{y}+\mathbf{x}$$
，这里作者指出这里softmax的不必要性，并且将标准化因子改成$\frac{1}{N}$进行了实验验证softmax的作用确实不必要，之所以采用Embed Gaussian模型去实验是因为softmax将输出归一在[0,1]之间，方便可视化。

论文作者采用了sub-sample来降低计算量
修改了公式为：${\mathbf{y}}_i=\frac{1}{C(\hat{\mathbf{x}})}{\sum }_{\forall j}f({\mathbf{x}}_i,{\hat{\mathbf{x}}}_j)g({\hat{\mathbf{x}}}_j)$，其中$\hat{\mathbf{x}}$是$\mathbf{x}$的子采样版本（例如 pooling）。我们在空间域中执行此操作，这可以将pairwise计算量减少1/4。这种trick不会改变non-local behavior，只会使计算变得更稀疏。这可以通过在$\varphi$和$g$在图2之后添加max pooling层来实现。

本人专注于2D目标检测，因此解读源码时，在对公式$\mathbf{y}=softmax({\mathbf{x}}^T{W}_{\theta }^T{W}_{\varphi }\mathbf{x})g(\mathbf{x})$的实现部分解读时，网络在对${\mathbf{x}}^T{W}_{\theta }^T{W}_{\varphi }\mathbf{x}$进行矩阵乘法时，运行的是三维矩阵间的乘法（这里暂时不考虑代码实现中添加的batch维度），关于多维矩阵乘法的理解可以参考【全面理解多维矩阵运算】多维（三维四维）矩阵向量运算-超强可视化

其实这里的依赖就是像素点间的通道关联性度量，将像素点间通道特征聚合。这里会产生非常大的计算量，为了减少计算量，作者提出的$\theta ,\varphi ,g$操作将通道数降了一半，又在$\theta ,\varphi ,g$层后添加了pooling层降低feature map尺寸，后续又CCNet和GCNet等论文针对这几个弊端提出了改进，可能后续的ORDNet也有提到（我还没读完）。

接着$softmax({\mathbf{x}}^T{W}_{\theta }^T{W}_{\varphi }\mathbf{x})$与$g(\mathbf{x})$将得到的注意力$softmax({\mathbf{x}}^T{W}_{\theta }^T{W}_{\varphi }\mathbf{x})$与经过$g(\mathbf{x})$后的特征映射进行赋权，此时注意力机制已经完成。
计算出$\mathbf{y}$后，接着进行$\mathbf{z}=W_z\mathbf{y}$，$W_z$就是一个1X1卷积以与$\mathbf{x}$进行通道数匹配完成残差连接得到$\mathbf{z}=W_z\mathbf{y}+\mathbf{x}$，到这里non local block的任务就算完成了。

pytorch源码（参考）

网络结构简单，源码也易于看懂，这里没有进行注释。

# -*- coding: utf-8 -*-
"""
@Author  :   zhwzhong
@License :   (C) Copyright 2013-2018, hit
@Contact :   zhwzhong.hit@gmail.com
@Software:   PyCharm
@File    :   nlrn.py
@Time    :   2019/5/5 16:27
@Desc    :
"""
import torch
from torch import nn
from torch.nn import functional as F


class _NonLocalBlockND(nn.Module):
    def __init__(self, in_channels, gamma=0, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
        super(_NonLocalBlockND, self).__init__()

        assert dimension in [1, 2, 3]

        self.gamma = nn.Parameter(torch.ones(1)) * gamma

        self.dimension = dimension
        self.sub_sample = sub_sample

        self.in_channels = in_channels
        self.inter_channels = inter_channels

        if self.inter_channels is None:
            self.inter_channels = in_channels // 2
            if self.inter_channels == 0:
                self.inter_channels = 1

        if dimension == 3:
            conv_nd = nn.Conv3d
            max_pool_layer = nn.MaxPool3d(kernel_size=(1, 2, 2))
            bn = nn.BatchNorm3d
        elif dimension == 2:
            conv_nd = nn.Conv2d
            max_pool_layer = nn.MaxPool2d(kernel_size=(2, 2))
            bn = nn.BatchNorm2d
        else:
            conv_nd = nn.Conv1d
            max_pool_layer = nn.MaxPool1d(kernel_size=(2))
            bn = nn.BatchNorm1d

        self.g = conv_nd(in_channels=self.in_channels, out_channels=self.inter_channels,
                         kernel_size=1, stride=1, padding=0)

        if bn_layer:
            self.W = nn.Sequential(
                conv_nd(in_channels=self.inter_channels, out_channels=self.in_channels,
                        kernel_size=1, stride=1, padding=0),
                bn(self.in_channels)
            )
            # 参数数量与 channel 有关
            nn.init.constant_(self.W[1].weight, 0)
            nn.init.constant_(self.W[1].bias, 0)
        else:
            self.W = conv_nd(in_channels=self.inter_channels, out_channels=self.in_channels,
                             kernel_size=1, stride=1, padding=0)
            nn.init.constant_(self.W.weight, 0)
            nn.init.constant_(self.W.bias, 0)

        self.theta = conv_nd(in_channels=self.in_channels, out_channels=self.inter_channels,
                             kernel_size=1, stride=1, padding=0)
        self.phi = conv_nd(in_channels=self.in_channels, out_channels=self.inter_channels,
                           kernel_size=1, stride=1, padding=0)

        if sub_sample:
            self.g = nn.Sequential(self.g, max_pool_layer)
            self.phi = nn.Sequential(self.phi, max_pool_layer)

    def forward(self, x):
        """
        :param x: (b, c, t, h, w)
        :return:
        """

        batch_size = x.size(0)

        g_x = self.g(x).view(batch_size, self.inter_channels, -1)
        g_x = g_x.permute(0, 2, 1)

        theta_x = self.theta(x).view(batch_size, self.inter_channels, -1)
        theta_x = theta_x.permute(0, 2, 1)

        phi_x = self.phi(x).view(batch_size, self.inter_channels, -1)
        f = torch.matmul(theta_x, phi_x)
        f_div_C = F.softmax(f, dim=-1)

        y = torch.matmul(f_div_C, g_x)
        y = y.permute(0, 2, 1).contiguous()
        y = y.view(batch_size, self.inter_channels, *x.size()[2:])
        W_y = self.W(y)
        z = self.gamma * W_y + x

        return z


class NONLocalBlock1D(_NonLocalBlockND):
    def __init__(self, in_channels, inter_channels=None, sub_sample=True, bn_layer=True):
        super(NONLocalBlock1D, self).__init__(in_channels,
                                              inter_channels=inter_channels,
                                              dimension=1, sub_sample=sub_sample,
                                              bn_layer=bn_layer)


class NONLocalBlock2D(_NonLocalBlockND):
    def __init__(self, in_channels, inter_channels=None, sub_sample=True, bn_layer=True):
        super(NONLocalBlock2D, self).__init__(in_channels,
                                              inter_channels=inter_channels,
                                              dimension=2, sub_sample=sub_sample,
                                              bn_layer=bn_layer)


class NONLocalBlock3D(_NonLocalBlockND):
    def __init__(self, in_channels, inter_channels=None, sub_sample=True, bn_layer=True):
        super(NONLocalBlock3D, self).__init__(in_channels,
                                              inter_channels=inter_channels,
                                              dimension=3, sub_sample=sub_sample,
                                              bn_layer=bn_layer)

if __name__ == '__main__':
    import torch

    for (sub_sample, bn_layer) in [(True, True), (False, False), (True, False), (False, True)]:
        img = torch.zeros(2, 3, 20)
        net = NONLocalBlock1D(3, sub_sample=sub_sample, bn_layer=bn_layer)
        out = net(img)
        print(out.size())

        img = torch.zeros(2, 3, 20, 20)
        net = NONLocalBlock2D(3, sub_sample=sub_sample, bn_layer=bn_layer)
        out = net(img)
        print(out.size())

        img = torch.randn(2, 3, 8, 20, 20)
        net = NONLocalBlock3D(3, sub_sample=sub_sample, bn_layer=bn_layer)
        out = net(img)
        print(out.size())