CBAM解析: 卷积块注意模块的介绍

最新推荐文章于 2024-07-24 06:13:17 发布

快撑死的鱼

最新推荐文章于 2024-07-24 06:13:17 发布

阅读量2.6k

点赞数 2

分类专栏： python 文章标签：深度学习神经网络 cnn

本文链接：https://blog.csdn.net/qq_38334677/article/details/127606941

版权

python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

引言

卷积神经网络 (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所示)，以便每个分支可以分别在通道和空间轴中学习 “什么” 和 “在哪里”。因此，我们的模块通过学习强调或抑制信息来有效地帮助网络内的信息流动。

卷积块注意模块

渠道注意力模块

我们通过利用特征的通道间关系来生成通道注意图。由于特征图的每个通道都被视为特征检测器 [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)