CBAM: 卷积块注意模块

摘要：提出了卷积块注意模块 (CBAM)，这是一种用于前馈卷积神经网络的简单而有效的注意模块。给定一个中间特征图，我们的模块依次沿两个独立的维度 (通道和空间) 推断注意力图，然后将注意力图乘以输入特征图以进行自适应特征细化。因为CBAM是一个轻量级的通用模块，所以它可以无缝集成到任何CNN架构中，开销可以忽略不计，并且可以与基础CNN一起端到端训练。

引言

卷积神经网络 (cnn) 因为其丰富的表示能力，显著推动了视觉处理 [1,2，3]。为了提高cnn的性能，最近的研究主要研究了网络的三个重要因素: 深度，宽度和基数

从LeNet体系结构 [4] 到残差式网络 [5,6，7,8] ，网络已经变得更加深入。VGGNet [9] 显示，堆叠具有相同形状的块表现出非常好的性能。遵循同样的思想，ResNet [5] 使用skip connection，堆叠相同的残差块，以构建极其深入的体系结构。GoogLeNet [10] 表明宽度是提高模型性能的另一个重要因素。Zagoruyko和Komodakis [6] 建议增加基于ResNet架构的网络宽度。他们已经表明，在CIFAR基准上，具有增加宽度的28层ResNet可以胜过具有1001层的极深ResNet。Xception [11] 和ResNeXt [7] 提出来增加网络的基数。他们从经验上表明，基数不仅节省了参数的总数，而且比其他两个因素 (深度和宽度) 具有更强的表示能力

除了这些因素之外，我们还研究了架构设计的另一个方面，即注意力。注意的意义已经在以前的文献 [12,13，14,15，16,17] 中进行了广泛的研究。我们的目标是通过使用注意机制来提高表示能力: 关注重要特征并抑制不必要的特征。在本文中，我们提出了一种新的网络模块，称为 “卷积块注意模块”。由于卷积操作通过将交叉通道和空间信息混合在一起来提取信息特征，因此我们采用我们的模块来强调沿这两个主要维度 (通道和空间轴) 的有意义的特征。为了实现这一点，我们顺序地应用通道和空间注意模块 (如图1所示)，以便每个分支可以分别在通道和空间轴中学习 “什么” 和 “在哪里”。因此，我们的模块通过学习强调或抑制信息来有效地帮助网络内的信息流动。

相关工作

网络工程

“网络工程” 一直是最重要的视觉研究之一，因为精心设计的网络可确保在各种应用中显着提高性能。自从大规模的CNN成功实施以来，已经提出了广泛的体系结构 [19]。一种直观而简单的扩展方式是增加神经网络的深度 [9]。Szegedy等人 [10] 引入了使用多分支体系结构的Inception网络，其中每个分支都经过精心定制。简单增加深度由于困难的梯度传播使性能达到饱和，但ResNet [5] 提出了一种简单的跳跃连接来缓解深度网络的优化问题。基于ResNet架构，开发了各种模型，例如WideResNet [6]，Inception-ResNet [8] 和ResNeXt [7]。WideResNet [6] 提出了一种残差网络，具有更多数量的卷积滤波器和减小的深度。PyramidNet [20] 是WideResNet的严格概括，其中网络的宽度逐渐增加。ResNeXt [7] 建议使用分组卷积，并表明增加基数可以提高分类精度。最近，Huang等人 [21] 提出了一种新的体系结构，即DenseNet。它将输入特征与输出特征迭代连接，使每个卷积块能够从所有先前的块接收原始信息。虽然大多数最近的网络工程方法主要针对三个因素深度 [19,9，10,5]，宽度 [10,22，6,8] 和基数 [7,11]，但我们专注于另一个方面，“注意力”，人类视觉系统的好奇方面之一。

注意力机制

Wang等。[27] 提出了使用编码器解码器样式注意模块的残差注意网络。通过完善特征图，网络不仅性能良好，而且对噪声输入也具有鲁棒性。我们不是直接计算3d注意力图，而是分别学习渠道注意力和空间注意力。3D特征图的单独注意力生成过程具有更少的计算和参数开销，因此可以用作已有的基础CNN架构的即插即用模块。

[28] 引入了一个紧凑的模块来利用通道间关系。在他们的挤压和激励模块中，他们使用全局平均池特征来计算信道上的注意力。但是，我们表明这些功能是次优的功能，以推断出良好的渠道注意力，因此我们建议也使用最大池化功能。他们也错过了空间注意力，这在决定 “哪里” 集中在一起起着重要作用。在我们的CBAM中，我们基于有效的体系结构同时利用空间和渠道注意力，并通过经验验证利用两者都优于仅使用渠道注意力 [28]。

同时，BAM [31] 采取了类似的方法，将3D注意力图推断分解为通道和空间。当我们插入每个卷积块时，它们将BAM模块放置在网络的每个瓶颈处

卷积块注意模块

 渠道注意力模块

我们通过利用特征的通道间关系来生成通道注意图。由于特征图的每个通道都被视为特征检测器 [32]，因此通道注意力集中在给定输入图像的 “什么” 有意义。为了有效地计算通道注意力，我们挤压了输入特征图的空间维度。为了聚合空间信息，到目前为止，人们普遍采用平均池化。Zhou等人 [444] 建议使用它来有效地学习目标对象的范围，Hu等人 [28] 在他们的注意力模块中采用它来计算空间统计。我们认为max-pooling还收集了有关独特对象特征的另一个重要线索，以推断出更好的渠道关注。因此，我们同时使用平均池化和最大池化。我们从经验上证实，利用这两个特征极大地提高了网络的表示能力，而不是独立使用每个特征 (见第4.1节)，显示了我们设计选择的有效性。我们在下面描述详细的操作。

我们首先通过使用平均pooling和max-pooling操作来聚合特征图的空间信息，生成两个不同的空间上下文描述符，分别表示平均pooling特征和max-pooling特征。然后将两个描述符转发到共享网络，以生成我们的频道注意力图。共享网络由具有一个隐藏层的多层感知器 (MLP) 组成。为了减少参数开销，隐藏激活大小设置为RC/r × 1，其中r是缩减比。在将共享网络应用于每个描述符之后，我们使用元素求和来合并输出特征向量。简而言之，渠道关注度计算为:

import torch
import torch.nn as nn

class ChannelAttentionModule(nn.Module):
    def __init__(self, channel, ratio=16):
        super(ChannelAttentionModule, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)

        self.shared_MLP = nn.Sequential(
            nn.Conv2d(channel, channel // ratio, 1, bias=False),
            nn.ReLU(),
            nn.Conv2d(channel // ratio, channel, 1, bias=False)
        )
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avgout = self.shared_MLP(self.avg_pool(x))
        maxout = self.shared_MLP(self.max_pool(x))
        return self.sigmoid(avgout + maxout)

if __name__=='__main__':
    model=ChannelAttentionModule(64)
    input=torch.randn(1,64,64,64)
    output=model(input)
    print(output.shape)

空间注意力模块。

我们利用特征的空间间关系生成空间注意图。与渠道注意力不同，空间注意力集中在 “哪里” 是信息部分，与渠道注意力互补。为了计算空间注意力，我们首先沿通道轴应用平均池化和最大池化操作，并将它们连接起来以生成有效的特征描述符。沿通道轴应用池化操作被证明可以有效地突出显示信息区域 [34]。在级联特征描述符上，我们应用卷积层以生成空间注意图，该图编码要强调或抑制的位置。我们在下面描述详细的操作 

我们通过使用两个池化操作来聚合特征图的通道信息，生成两个2D图。每个表示通道上的平均池特征和最大池特征。然后将它们通过标准的卷积层连接和卷积，生成我们的2D空间注意力图。简而言之，空间注意力计算为

import torch
import torch.nn as nn

class SpatialAttentionModule(nn.Module):
    def __init__(self):
        super(SpatialAttentionModule, self).__init__()
        self.conv2d = nn.Conv2d(in_channels=2, out_channels=1, kernel_size=7, stride=1, padding=3)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avgout = torch.mean(x, dim=1, keepdim=True)
        maxout, _ = torch.max(x, dim=1, keepdim=True)
        out = torch.cat([avgout, maxout], dim=1)
        out = self.sigmoid(self.conv2d(out))
        return out

if __name__=='__main__':
    model=SpatialAttentionModule()
    input=torch.randn(1,64,64,64)
    output=model(input)
    print(output.shape)

注意模块的布置

给定输入图像，两个注意模块 (通道和空间) 计算互补注意，分别关注 “什么” 和 “哪里”。考虑到这一点，可以以并行或顺序的方式放置两个模块。我们发现顺序排列比平行排列给出更好的结果。对于顺序过程的安排，我们的实验结果表明，通道一阶略好于空间一阶。

import torch
import torch.nn as nn
import torchvision


class ChannelAttentionModule(nn.Module):
    def __init__(self, channel, ratio=16):
        super(ChannelAttentionModule, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)

        self.shared_MLP = nn.Sequential(
            nn.Conv2d(channel, channel // ratio, 1, bias=False),
            nn.ReLU(),
            nn.Conv2d(channel // ratio, channel, 1, bias=False)
        )
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avgout = self.shared_MLP(self.avg_pool(x))
       
        maxout = self.shared_MLP(self.max_pool(x))
        return self.sigmoid(avgout + maxout)


class SpatialAttentionModule(nn.Module):
    def __init__(self):
        super(SpatialAttentionModule, self).__init__()
        self.conv2d = nn.Conv2d(in_channels=2, out_channels=1, kernel_size=7, stride=1, padding=3)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avgout = torch.mean(x, dim=1, keepdim=True)
        maxout, _ = torch.max(x, dim=1, keepdim=True)
        out = torch.cat([avgout, maxout], dim=1)
        out = self.sigmoid(self.conv2d(out))
        return out


class CBAM(nn.Module):
    def __init__(self, channel):
        super(CBAM, self).__init__()
        self.channel_attention = ChannelAttentionModule(channel)
        self.spatial_attention = SpatialAttentionModule()

    def forward(self, x):
        out = self.channel_attention(x) * x
        out = self.spatial_attention(out) * out
        return out


class ResBlock_CBAM(nn.Module):
    def __init__(self,in_places, places, stride=1,downsampling=False, expansion = 4):
        super(ResBlock_CBAM,self).__init__()
        self.expansion = expansion
        self.downsampling = downsampling

        self.bottleneck = nn.Sequential(
            nn.Conv2d(in_channels=in_places,out_channels=places,kernel_size=1,stride=1, bias=False),
            nn.BatchNorm2d(places),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=places, out_channels=places, kernel_size=3, stride=stride, padding=1, bias=False),
            nn.BatchNorm2d(places),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=places, out_channels=places*self.expansion, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(places*self.expansion),
        )
        self.cbam = CBAM(channel=places*self.expansion)

        if self.downsampling:
            self.downsample = nn.Sequential(
                nn.Conv2d(in_channels=in_places, out_channels=places*self.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(places*self.expansion)
            )
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        residual = x
        out = self.bottleneck(x)
        print(x.shape)
        out = self.cbam(out)
        if self.downsampling:
            residual = self.downsample(x)

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


model = ResBlock_CBAM(in_places=16, places=4)
print(model)

input = torch.randn(1, 16, 64, 64)
out = model(input)
print(out.shape)