精华内容
下载资源
问答
  • 2021-09-28 15:34:30

    CBAM(Convolutional Block Attention Module)一种轻量的注意力模块,可以在空间和通道上进行注意力机制,沿着通道和空间两个维度推断出注意力权重系数,然后再与feature map相乘,CBAM的结构如下:在这里插入图片描述
    包含两个模块:通道注意力模块和空间注意力模块,两个注意力模块采用串联的方式。

    1.通道注意力模块

    在这里插入图片描述

    通道注意力是关注哪个通道上的特征是有意义的,输入feature map是H x W x C,先分别进行一个全局平均池化和全局最大池化得到两个1 x 1 x C的feature map , 然后将这两个feature map分别送入两层的全连接神经网络,对于这两个feature map,这个两层的全连接神经网络是共享参数的,然后,再将得到的两个feature map相加,然后再通过Sigmoid函数得到0~1之间的权重系数,然后权重系数再与输入feature map相乘,得到最终输出feature map。

    2. 空间注意力模块

    通道注意力输出之后,再引入空间注意力模块,关注空间中哪部分的特征有意义,
    在这里插入图片描述
    输入feature map为 H x W x C,分别进行一个通道维度的最大池化和平均池化得到两个H x W x 1的feature map,然后将这两个feature map在通道维度拼接起来,现在feature map H x W x 2,然后再经过一个卷积层,降为1个通道,卷积核采用7x7,同时保持H W 不变,输出feature map为H x W x 1,然后再通过Sigmoid函数生成空间权重系数,然后再与输入feature map相乘得到最终feature map。

    关于通道注意力模块和空间注意力模块组合方式,作者通过实验证明先通道注意力模块再空间注意力模块的方式效果会更好。

    3.code

    class channelAttention(nn.Module):
        def __init__(self , in_planes , ration = 16):
            super(channelAttention, self).__init__()
    
            '''
            AdaptiveAvgPool2d():自适应平均池化
                                不需要自己设置kernelsize stride等
                                只需给出输出尺寸即可
            '''
    
            self.avg_pool = nn.AdaptiveAvgPool2d(1) # 通道数不变,H*W变为1*1
            self.max_pool = nn.AdaptiveMaxPool2d(1) #
    
            self.fc1 = nn.Conv2d(in_planes , in_planes // 16 , 1 , bias = False)
            self.relu1 = nn.ReLU()
            self.fc2 = nn.Conv2d(in_planes//16 , in_planes ,1, bias = False)
    
            self.sigmoid = nn.Sigmoid()
    
        def forward(self , x):
            avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
            #print(avg_out.shape)
            #两层神经网络共享
            max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
            print(avg_out.shape)
            print(max_out.shape)
            out = avg_out + max_out
            print(out.shape)
            return self.sigmoid(out)
    ''''
    空间注意力模块
            先分别进行一个通道维度的最大池化和平均池化得到两个H x W x 1,
            然后两个描述拼接在一起,然后经过一个7*7的卷积层,激活函数为sigmoid,得到权重Ms
    
    '''
    class spatialAttention(nn.Module):
        def __init__(self , kernel_size = 7):
            super(spatialAttention, self).__init__()
            assert kernel_size in (3 , 7 ), " kernel size must be 3 or 7"
            padding = 3 if kernel_size == 7 else 1
            # avg 和 max 两个描述,叠加 共两个通道。
            self.conv1 = nn.Conv2d(2 , 1 , kernel_size , padding = padding , bias = False)#保持卷积前后H、W不变
            self.sigmoid = nn.Sigmoid()
        def forward(self , x):
            # egg:input: 1 , 3 * 2 * 2  avg_out :
            avg_out = torch.mean(x , dim = 1 , keepdim = True)#通道维度的平均池化
            # 注意 torch.max(x ,dim = 1) 返回最大值和所在索引,是两个值  keepdim = True 保持维度不变(求max的这个维度变为1),不然这个维度没有了
            max_out ,_ = torch.max(x , dim =1 ,keepdim=True)#通道维度的最大池化
            print(avg_out.shape)
            print(max_out.shape)
            x = torch.cat([avg_out , max_out] , dim =1)
            print(x.shape)
            x = self.conv1(x)
            return self.sigmoid(x)
    
    更多相关内容
  • 空间注意力机制和通道注意力机制详解

    万次阅读 多人点赞 2021-04-13 16:27:37
    Attention机制在近几年来在图像,自然语言处理等领域中都取得了重要的突破,被证明有益于提高模型的性能。 Attention机制本身也是符合人脑和人眼的感知机制,这次我们主要以计算机视觉领域为例,讲述Attention机制...

    Attention机制在近几年来在图像,自然语言处理等领域中都取得了重要的突破,被证明有益于提高模型的性能。

    Attention机制本身也是符合人脑和人眼的感知机制,这次我们主要以计算机视觉领域为例,讲述Attention机制的原理,应用以及模型的发展

    何为Attention机制?

    所谓Attention机制,便是聚焦于局部信息的机制,比如,图像中的某一个图像区域。随着任务的变化,注意力区域往往会发生变化。
    在这里插入图片描述
    面对上面这样的一张图,如果你只是从整体来看,只看到了很多人头,但是你拉近一个一个仔细看就了不得了,都是天才科学家。

    图中除了人脸之外的信息其实都是无用的,也做不了什么任务,Attention机制便是要找到这些最有用的信息,可以想到,最简单的场景就是从照片中检测人脸了。

    基于Attention的显著目标检测

    和注意力机制相伴而生的一个任务便是显著目标检测,即salient object detection。它的输入是一张图,输出是一张概率图,概率越大的地方,代表是图像中重要目标的概率越大,即人眼关注的重点,一个典型的显著图如下:
    在这里插入图片描述
    右图就是左图的显著图,在头部位置概率最大,另外腿部,尾巴也有较大概率,这就是图中真正有用的信息。

    显著目标检测需要一个数据集,而这样的数据集的收集便是通过追踪多个实验者的眼球在一定时间内的注意力方向进行平均得到,典型的步骤如下:
    (1) 让被测试者观察图。

    (2) 用eye tracker记录眼睛的注意力位置。

    (3) 对所有测试者的注意力位置使用高斯滤波进行综合。

    (4) 结果以0~1的概率进行记录。

    于是就能得到下面这样的图,第二行是眼球追踪结果,第三行就是显著目标概率图。

    在这里插入图片描述
    上面讲述的都是空间上的注意力机制,即关注的是不同空间位置,而在CNN结构中,还有不同的特征通道,因此不同特征通道也有类似的原理 ,下面一起讲述。

    Attention模型架构

    注意力机制的本质就是定位到感兴趣的信息,抑制无用信息,结果通常都是以概率图或者概率特征向量的形式展示,从原理上来说,主要分为空间注意力模型,通道注意力模型,空间和通道混合注意力模型三种,这里不区分soft和hard attention。

    1.空间注意力模型(spatial attention)

    不是图像中所有的区域对任务的贡献都是同样重要的,只有任务相关的区域才是需要关心的,比如分类任务的主体,空间注意力模型就是寻找网络中最重要的部位进行处理。

    我们在这里给大家介绍两个具有代表性的模型,第一个就是Google DeepMind提出的STN网络(Spatial Transformer Network[1]),它通过学习输入的形变,从而完成适合任务的预处理操作,是一种基于空间的Attention模型,网络结构如下:

    在这里插入图片描述
    这里的Localization Net用于生成仿射变换系数,输入是C×H×W维的图像,输出是一个空间变换系数,它的大小根据要学习的变换类型而定,如果是仿射变换,则是一个6维向量。

    这样的一个网络要完成的效果如下图:
    在这里插入图片描述
    即定位到目标的位置,然后进行旋转等操作,使得输入样本更加容易学习。这是一种一步调整的解决方案,当然还有很多迭代调整的方案,感兴趣可以去有三知识星球星球中阅读。

    相比于Spatial Transformer Networks 一步完成目标的定位和仿射变换调整,Dynamic Capacity Networks[2]则采用了两个子网络,分别是低性能的子网络(coarse model)和高性能的子网络(fine model)。

    • 低性能的子网络(coarse model)用于对全图进行处理,定位感兴趣区域,如下图中的操作fc。
    • 高性能的子网络(fine model)则对感兴趣区域进行精细化处理,如下图的操作ff。
    • 两者共同使用,可以获得更低的计算代价和更高的精度。
      在这里插入图片描述
      由于在大部分情况下我们感兴趣的区域只是图像中的一小部分,因此空间注意力的本质就是定位目标并进行一些变换或者获取权重。
    2 通道注意力机制

    对于输入2维图像的CNN来说,一个维度是图像的尺度空间,即长宽,另一个维度就是通道,因此基于通道的Attention也是很常用的机制。

    SENet(Sequeeze and Excitation Net)[3]是2017届ImageNet分类比赛的冠军网络,本质上是一个基于通道的Attention模型,它通过建模各个特征通道的重要程度,然后针对不同的任务增强或者抑制不同的通道,原理图如下。

    在这里插入图片描述
    在正常的卷积操作后分出了一个旁路分支,首先进行Squeeze操作(即图中Fsq(·)),它将空间维度进行特征压缩,即每个二维的特征图变成一个实数,相当于具有全局感受野的池化操作,特征通道数不变。

    然后是Excitation操作(即图中的Fex(·)),它通过参数w为每个特征通道生成权重,w被学习用来显式地建模特征通道间的相关性。在文章中,使用了一个2层bottleneck结构(先降维再升维)的全连接层+Sigmoid函数来实现。

    得到了每一个特征通道的权重之后,就将该权重应用于原来的每个特征通道,基于特定的任务,就可以学习到不同通道的重要性。

    将其机制应用于若干基准模型,在增加少量计算量的情况下,获得了更明显的性能提升。作为一种通用的设计思想,它可以被用于任何现有网络,具有较强的实践意义。而后SKNet[4]等方法将这样的通道加权的思想和Inception中的多分支网络结构进行结合,也实现了性能的提升。

    通道注意力机制的本质,在于建模了各个特征之间的重要性,对于不同的任务可以根据输入进行特征分配,简单而有效。

    3 空间和通道注意力机制的融合

    前述的Dynamic Capacity Network是从空间维度进行Attention,SENet是从通道维度进行Attention,自然也可以同时使用空间Attention和通道Attention机制

    CBAM(Convolutional Block Attention Module)[5]是其中的代表性网络,结构如下:
    在这里插入图片描述
    通道方向的Attention建模的是特征的重要性,结构如下:

    在这里插入图片描述
    同时使用最大pooling和均值pooling算法,然后经过几个MLP层获得变换结果,最后分别应用于两个通道,使用sigmoid函数得到通道的attention结果。

    空间方向的Attention建模的是空间位置的重要性,结构如下:
    在这里插入图片描述
    首先将通道本身进行降维,分别获取最大池化和均值池化结果,然后拼接成一个特征图,再使用一个卷积层进行学习。

    这两种机制,分别学习了通道的重要性和空间的重要性,还可以很容易地嵌入到任何已知的框架中。

    除此之外,还有很多的注意力机制相关的研究,比如残差注意力机制,多尺度注意力机制,递归注意力机制等。

    展开全文
  • 公众号关注 “Python遇见机器学习” 设为“星标”,第一时间知晓最新干货~ 作者丨pprp 来源丨GiantPandaCV 导读: CBAM模块由于其使用的广泛性以及易于集成得到很多应用。 目前CV领域中的Attention机制也是在20 19年

    原文参考:https://blog.csdn.net/weixin_39890708/article/details/111363969
    https://blog.csdn.net/xiewenrui1996/article/details/105760359

    公众号关注 “Python遇见机器学习”

    设为“星标”,第一时间知晓最新干货~

    作者丨pprp 来源丨GiantPandaCV 导读: CBAM模块由于其使用的广泛性以及易于集成得到很多应用。 目前CV领域中的Attention机制也是在20 19年论文中非常火。 这篇CBAM虽然是在2018年提出的,但是其影响力比较深远,在很多领域都用到了该模块。

    1. 什么是注意力机制?

    注意力机制(Attention Mechanism)是机器学习中的一种数据处理方法,广泛应用在自然语言处理、图像识别及语音识别等各种不同类型的机器学习任务中。通俗来讲:注意力机制就是希望网络能够自动学出来图片或者文字序列中的需要注意的地方。比如人眼在看一幅画的时候,不会将注意力平等地分配给画中的所有像素,而是将更多注意力分配给人们关注的地方。 从实现的角度来讲:注意力机制通过神经网络的操作生成一个掩码mask, mask上的值一个打分,评价当前需要关注的点的评分。注意力机制可以分为:
    通道注意力机制:对通道生成掩码mask,进行打分,代表是senet, Channel Attention Module
    空间注意力机制:对空间进行掩码的生成,进行打分,代表是Spatial Attention Module
    混合域注意力机制:同时对通道注意力和空间注意力进行评价打分,代表的有BAM, CBAM

    2. CBAM模块的实现

    CBAM全称是Convolutional Block Attention Module, 是在ECCV2018上发表的注意力机制代表作之一。本人在打比赛的时候遇见过有人使用过该模块取得了第一名的好成绩,证明了其有效性。在该论文中,作者研究了网络架构中的注意力,注意力不仅要告诉我们重点关注哪里,还要提高关注点的表示。目标是通过使用注意机制来增加表现力,关注重要特征并抑制不必要的特征。为了强调空间和通道这两个维度上的有意义特征,作者依次应用 通道和空间注意模块,来分别在通道和空间维度上学习关注什么、在哪里关注。此外,通过了解要强调或抑制的信息也有助于网络内的信息流动。主要网络架构也很简单,一个是通道注意力模块,另一个是空间注意力模块,CBAM就是先后集成了通道注意力模块和空间注意力模块。

    2.1 通道注意力机制

    在这里插入图片描述

    通道注意力机制按照上图进行实现:

    class ChannelAttention(nn.Module):
        def __init__(self, in_planes, rotio=16):
            super(ChannelAttention, self).__init__()
            self.avg_pool = nn.AdaptiveAvgPool2d(1)
            self.max_pool = nn.AdaptiveMaxPool2d(1)
            self.sharedMLP = nn.Sequential(
                nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False), nn.ReLU(),
                nn.Conv2d(in_planes // rotio, in_planes, 1, bias=False))
            self.sigmoid = nn.Sigmoid()
        def forward(self, x):
            avgout = self.sharedMLP(self.avg_pool(x))
            maxout = self.sharedMLP(self.max_pool(x))
            return self.sigmoid(avgout + maxout)
    

    核心的部分Shared MLP使用了11卷积完成的,进行信息的提取。需要注意的是,其中的bias需要人工设置为False。

    2.2 空间注意力机制

    在这里插入图片描述
    注意力机制按照上图进行实现:

    class SpatialAttention(nn.Module):
        def __init__(self, kernel_size=7):
            super(SpatialAttention, self).__init__()
            assert kernel_size in (3,7), "kernel size must be 3 or 7"
            padding = 3 if kernel_size == 7 else 1
            self.conv = nn.Conv2d(2,1,kernel_size, padding=padding, bias=False)
            self.sigmoid = nn.Sigmoid()
        def forward(self, x):
            avgout = torch.mean(x, dim=1, keepdim=True)
            maxout, _ = torch.max(x, dim=1, keepdim=True)
            x = torch.cat([avgout, maxout], dim=1)
            x = self.conv(x)
            return self.sigmoid(x)
    

    这个部分实现也很简单,分别从通道维度进行求平均和求最大,合并得到一个通道数为2的卷积层,然后通过一个卷积,得到了一个通道数为1的spatial attention。

    2.3 Convolutional bottleneck attention module

    在这里插入图片描述

    class BasicBlock(nn.Module):
        expansion = 1
        def __init__(self, inplanes, planes, stride=1, downsample=None):
            super(BasicBlock, self).__init__()
            self.conv1 = conv3x3(inplanes, planes, stride)
            self.bn1 = nn.BatchNorm2d(planes)
            self.relu = nn.ReLU(inplace=True)
            self.conv2 = conv3x3(planes, planes)
            self.bn2 = nn.BatchNorm2d(planes)
            self.ca = ChannelAttention(planes)
            self.sa = SpatialAttention()
            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.ca(out) * out  # 广播机制
            out = self.sa(out) * out  # 广播机制
            if self.downsample is not None:
                residual = self.downsample(x)
            out += residual
            out = self.relu(out)
            return out
    

    最后的使用一个类进行两个模块的集成,得到的通道注意力和空间注意力以后,使用广播机制对原有的feature map进行信息提炼,最终得到提炼后的feature map。以上代码以ResNet中的模块作为对象,实际运用可以单独将以下模块融合到网络中:

    class cbam(nn.Module):
       def __init__(self, planes):
            self.ca = ChannelAttention(planes)# planes是feature map的通道个数
            self.sa = SpatialAttention()
         def forward(self, x):
            x = self.ca(out) * x  # 广播机制
            x = self.sa(out) * x  # 广播机制
    

    3. 在什么情况下可以使用?

    提出CBAM的作者主要对分类网络和目标检测网络进行了实验,证明了CBAM模块确实是有效的。以ResNet为例,论文中提供了改造的示意图,如下图所示:
    在这里插入图片描述
    也就是在ResNet中的每个block中添加了CBAM模块,训练数据来自benchmark ImageNet-1K。检测使用的是Faster R-CNN, Backbone选择的ResNet34,ResNet50, WideResNet18, ResNeXt50等,还跟SE等进行了对比。 消融实验:消融实验一般是控制变量,最能看出模型变好起作用的部分在那里。分为三个部分:
    如何更有效地计算channel attention?
    在这里插入图片描述
    可以看出来,使用avgpool和maxpool可以更好的降低错误率,大概有1-2%的提升,这个组合就是dual pooling,能提供更加精细的信息,有利于提升模型的表现。
    如何更有效地计算spatial attention?
    在这里插入图片描述
    这里的空间注意力机制参数也是有avg, max组成,另外还有一个卷积的参数kernel_size(k), 通过以上实验,可以看出,当前使用通道的平均和通道的最大化,并且设置kernel size=7是最好的。
    如何组织这两个部分?
    在这里插入图片描述
    可以看出,这里与SENet中的SE模块也进行了比较,这里使用CBAM也是超出了SE的表现。除此以外,还进行了顺序和并行的测试,发现,先channel attention然后spatial attention效果最好,所以也是最终的CBAM模块的组成。在MSCOCO数据及使用了ResNet50,ResNet101为backbone, Faster RCNN为检测器的模型进行目标检测,如下图所示:
    在这里插入图片描述
    在VOC2007数据集中采用了StairNet进行了测试,如下图所示:
    在这里插入图片描述
    官方貌似没有提供目标检测部分的代码,CBAM的作用在于对信息进行精细化分配和处理,所以猜测是在backbone的分类器之前添加的CBAM模块,欢迎有研究的小伙伴留言。

    4. 参考

    CBAM arxiv link:
    https://arxiv.org/pdf/1807.06521.pdf

    核心代码:https://github.com/pprp/SimpleCVReproduction/blob/master/attention/CBAM/cbam.py
    ————————————————
    版权声明:本文为CSDN博主「weixin_39890708」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/weixin_39890708/article/details/111363969

    展开全文
  • 参考链接: 深度学习卷积神经网络重要结构之通道注意力和空间注意力模块 参考链接: 用于卷积神经网络的注意力机制(Attention)----CBAM: Convolutional Block Attention Module 参考链接: link 参考链接: link 参考...

    参考链接: 注意力机制
    参考链接: 深度学习卷积神经网络重要结构之通道注意力和空间注意力模块
    参考链接: 用于卷积神经网络的注意力机制(Attention)----CBAM: Convolutional Block Attention Module
    参考链接: moskomule/senet.pytorch
    参考链接: Squeeze-and-Excitation Networks
    参考链接: CBAM: Convolutional Block Attention Module

    空间注意力机制:
    在这里插入图片描述
    代码实验展示:

    import torch
    from torch import nn
    
    class SpatialAttention(nn.Module):
        def __init__(self, kernel_size=7):
            super(SpatialAttention, self).__init__()
    
            assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
            padding = 3 if kernel_size == 7 else 1
    
            self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)  # 7,3     3,1
            self.sigmoid = nn.Sigmoid()
    
        def forward(self, x):
            avg_out = torch.mean(x, dim=1, keepdim=True)
            max_out, _ = torch.max(x, dim=1, keepdim=True)
            x = torch.cat([avg_out, max_out], dim=1)
            x = self.conv1(x)
            return self.sigmoid(x)
    
    if __name__ == '__main__':
        SA = SpatialAttention(7)
        data_in = torch.randn(8,32,300,300)
        data_out = SA(data_in)
        print(data_in.shape)  # torch.Size([8, 32, 300, 300])
        print(data_out.shape)  # torch.Size([8, 1, 300, 300])
    
    

    控制台结果输出展示:

    Windows PowerShell
    版权所有 (C) Microsoft Corporation。保留所有权利。
    
    尝试新的跨平台 PowerShell https://aka.ms/pscore6
    
    加载个人及系统配置文件用了 1003 毫秒。
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM>  & 'D:\Anaconda3\python.exe' 'c:\Users\chenxuqi\.vscode\extensions\ms-python.python-2021.1.502429796\pythonFiles\lib\python\debugpy\launcher' '55088' '--' 'c:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM\ 
    空间注意力机制.py'
    torch.Size([8, 32, 300, 300])
    torch.Size([8, 1, 300, 300])
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM> conda activate base
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM> 
    

    通道注意力机制:

    在这里插入图片描述代码实验展示:

    import torch
    from torch import nn
    
    class ChannelAttention(nn.Module):
    	def __init__(self, in_planes, ratio=16):
    		super(ChannelAttention, self).__init__()
    		self.avg_pool = nn.AdaptiveAvgPool2d(1)
    		self.max_pool = nn.AdaptiveMaxPool2d(1)
    
    		self.fc1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
    		self.relu1 = nn.ReLU()
    		self.fc2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
    		self.sigmoid = nn.Sigmoid()
    
    	def forward(self, x):
    		avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
    		max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
    		out = avg_out + max_out
    		return self.sigmoid(out)
    
    
    if __name__ == '__main__':
        CA = ChannelAttention(32)
        data_in = torch.randn(8,32,300,300)
        data_out = CA(data_in)
        print(data_in.shape)  # torch.Size([8, 32, 300, 300])
        print(data_out.shape)  # torch.Size([8, 32, 1, 1])
    
    

    控制台结果输出展示:

    Windows PowerShell
    版权所有 (C) Microsoft Corporation。保留所有权利。
    
    尝试新的跨平台 PowerShell https://aka.ms/pscore6
    
    加载个人及系统配置文件用了 882 毫秒。
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM> conda activate base
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM>  & 'D:\Anaconda3\python.exe' 'c:\Users\chenxuqi\.vscode\extensions\ms-python.python-2021.1.502429796\pythonFiles\lib\python\debugpy\launcher' '55339' '--' 'c:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM\ 
    通道注意力机制.py'
    torch.Size([8, 32, 300, 300])
    torch.Size([8, 32, 1, 1])
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM>
    

    CBAM注意力机制:
    在这里插入图片描述
    代码实验展示:

    import torch
    from torch import nn
    
    class ChannelAttention(nn.Module):
        def __init__(self, in_planes, ratio=16):
            super(ChannelAttention, self).__init__()
            self.avg_pool = nn.AdaptiveAvgPool2d(1)
            self.max_pool = nn.AdaptiveMaxPool2d(1)
    
            self.fc1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
            self.relu1 = nn.ReLU()
            self.fc2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
            self.sigmoid = nn.Sigmoid()
    
        def forward(self, x):
            avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
            max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
            out = avg_out + max_out
            return self.sigmoid(out)
    
    
    class SpatialAttention(nn.Module):
        def __init__(self, kernel_size=7):
            super(SpatialAttention, self).__init__()
    
            assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
            padding = 3 if kernel_size == 7 else 1
    
            self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)  # 7,3     3,1
            self.sigmoid = nn.Sigmoid()
    
        def forward(self, x):
            avg_out = torch.mean(x, dim=1, keepdim=True)
            max_out, _ = torch.max(x, dim=1, keepdim=True)
            x = torch.cat([avg_out, max_out], dim=1)
            x = self.conv1(x)
            return self.sigmoid(x)
    
    class CBAM(nn.Module):
        def __init__(self, in_planes, ratio=16, kernel_size=7):
            super(CBAM, self).__init__()
            self.ca = ChannelAttention(in_planes, ratio)
            self.sa = SpatialAttention(kernel_size)
            
        def forward(self, x):
            out = x * self.ca(x)
            result = out * self.sa(out)
            return result
    
    
    if __name__ == '__main__':
        print('testing ChannelAttention'.center(100,'-'))
        torch.manual_seed(seed=20200910)
        CA = ChannelAttention(32)
        data_in = torch.randn(8,32,300,300)
        data_out = CA(data_in)
        print(data_in.shape)  # torch.Size([8, 32, 300, 300])
        print(data_out.shape)  # torch.Size([8, 32, 1, 1])
    
    
    
    
    if __name__ == '__main__':
        print('testing SpatialAttention'.center(100,'-'))
        torch.manual_seed(seed=20200910)
        SA = SpatialAttention(7)
        data_in = torch.randn(8,32,300,300)
        data_out = SA(data_in)
        print(data_in.shape)  # torch.Size([8, 32, 300, 300])
        print(data_out.shape)  # torch.Size([8, 1, 300, 300])
    
    
    
    if __name__ == '__main__':
        print('testing CBAM'.center(100,'-'))
        torch.manual_seed(seed=20200910)
        cbam = CBAM(32, 16, 7)
        data_in = torch.randn(8,32,300,300)
        data_out = cbam(data_in)
        print(data_in.shape)  # torch.Size([8, 32, 300, 300])
        print(data_out.shape)  # torch.Size([8, 1, 300, 300])
    

    控制台结果输出展示:

    Windows PowerShell
    版权所有 (C) Microsoft Corporation。保留所有权利。
    
    尝试新的跨平台 PowerShell https://aka.ms/pscore6
    
    加载个人及系统配置文件用了 1029 毫秒。
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM>  & 'D:\Anaconda3\python.exe' 'c:\Users\chenxuqi\.vscode\extensions\ms-python.python-2021.1.502429796\pythonFiles\lib\python\debugpy\launcher' '55659' '--' 'c:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM\cbam注意力机制.py'
    --------------------------------------testing ChannelAttention--------------------------------------
    torch.Size([8, 32, 300, 300])
    torch.Size([8, 32, 1, 1])
    --------------------------------------testing SpatialAttention--------------------------------------
    torch.Size([8, 32, 300, 300])
    torch.Size([8, 1, 300, 300])
    --------------------------------------------testing CBAM--------------------------------------------
    torch.Size([8, 32, 300, 300])
    torch.Size([8, 32, 300, 300])
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM> conda activate base
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM> 
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM> 
    (base) PS C:\Users\chenxuqi\Desktop\News4cxq\测试注意力机制CBAM> 
    

    SE注意力机制:

    在这里插入图片描述
    代码实验展示:

    from torch import nn
    import torch
    
    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)
            # return x * y
    
    
    if __name__ == '__main__':
        torch.manual_seed(seed=20200910)
        data_in = torch.randn(8,32,300,300)
        SE = SELayer(32) 
        data_out = SE(data_in)
        print(data_in.shape)  # torch.Size([8, 32, 300, 300])
        print(data_out.shape)  # torch.Size([8, 32, 300, 300])
        
        
        
        
        
        
        
    

    控制台输出结果展示:

    Windows PowerShell
    版权所有 (C) Microsoft Corporation。保留所有权利。
    
    尝试新的跨平台 PowerShell https://aka.ms/pscore6
    
    加载个人及系统配置文件用了 979 毫秒。
    (base) PS F:\Iris_SSD_small\senet.pytorch-master>  & 'D:\Anaconda3\envs\pytorch_1.7.1_cu102\python.exe' 'c:\Users\chenxuqi\.vscode\extensions\ms-python.python-2021.1.502429796\pythonFiles\lib\python\debugpy\launcher' '54904' '--' 'f:\Iris_SSD_small\senet.pytorch-master\senet\se_module.py'
    torch.Size([8, 32, 300, 300])
    torch.Size([8, 32, 300, 300])
    (base) PS F:\Iris_SSD_small\senet.pytorch-master> conda activate pytorch_1.7.1_cu102
    (pytorch_1.7.1_cu102) PS F:\Iris_SSD_small\senet.pytorch-master> 
    
    展开全文
  • 目录基本概念配置实现源码分析训练效果小结 在上一篇《【YOLOv4探讨 之七】利用... 基本概念 空间注意力机制使用SAM模块,在Darknet中,新添加的sam_layer层就是用于SAM模块,该层在darknet.h中的定义为sam. 其原理
  • 30种常见注意力机制论文、解读、使用方法、实现代码整理(Attention)
  • SAM(空间注意力机制

    万次阅读 2020-05-12 19:16:02
    四 问题思索 《An Empirical Study of Spatial Attention Mechanisms in Deep Networks》 —空间注意力机制 作者:Xizhou Zhu, Dazhi Cheng,etc. 单位:微软亚研 发表会议及时间:arXiv 2019 论文地址 相关代码 ...
  • PyTorch 通道/空间注意力机制

    千次阅读 2020-09-22 22:12:46
    空间注意力机制就是学习整个画面不同区域的系数,同时考虑到了所有通道 class ChannelAttention(nn.Module): def __init__(self, in_planes, ratio=16): super(ChannelAttention, self).__init__() self.avg_...
  • 由于紧凑型CNN的参数空间冗余度较低,与现有的注意力机制相比,紧凑型CNN的理想注意力机制应该具有更有效、更高效地捕捉全局相关性(融合语义和空间信息)的能力。 论文主要思想 论文提出了一种新的用于紧凑型cnn的...
  • Twins 提出的空间可分离自注意力机制 (SSSA) 空间可分离自注意力使用局部-全局注意力交替(LSA-GSA)的机制,可以大幅降低计算成本,复杂度从输入的平方 O(H2W2d) 降为线性 O(mnHWd),通过将分组计算的注意力进行...
  • 基于角度敏感的空间注意力机制的轻量型旋转目标检测器.docx
  • U-Net网络模型(简单改进版) 这一段时间做项目用到了U-Net网络模型...***下采样的过程中加入了通道注意力和空间注意力(大概就是这样)*** 代码跑出来后,效果比原来的U-Net大概提升了一个点左右,证明是有效的。 ...
  • 文章目录一、空间注意力机制简介二、空间注意力与pytorch代码三、使用案例 一、空间注意力机制简介 空间注意力的示意图如下: 长条的是通道注意力机制,而平面则是空间注意力机制,可以发现:通道注意力在意的是每个...
  • 为什么需要视觉注意力计算机视觉(computervision)中的注意力机制(attention)的基本思想就是想让系统学会注意力——能够忽略无关信息而关注重点信息。为什么要忽略无关信息呢?注意力分类与基本概念神经网络中的...
  • 本文提出了一种基于双路细化注意力机制的图像描述模型,该模型同时使用了空间注意力机制与通道注意力机制,并且使用了细化图像特征的模块,对图像特征进行进一步细化处理,过滤掉图像中的冗余与不相关的特征....
  • 针对现有基于注意力机制的多模态学习,对文字上下文之间的自我联系和图像目标区域的空间位置关系进行了深入研究。在分析现有注意力网络的基础上,提出使用自注意力模块(self-attention,SA)和空间推理注意力模块...
  • Attention注意力机制介绍

    千次阅读 2020-12-20 14:43:58
    什么是Attention机制Attention机制通俗的讲...根据应用场景的不同,Attention分为空间注意力和时间注意力,前者用于图像处理,后者用于自然语言处理。本文主要介绍Attention机制在Seq2seq中的应用。为什么要用Attent...
  • 注意力机制attention和Transformer

    千次阅读 2020-09-30 19:59:56
    文章目录一,注意力机制二,自注意力(self-attention)三,软注意力机制1,空域注意力2,通道注意力机制3,混合域模型4,Non-Local5,位置注意力机制四,强注意力机制 一,注意力机制 attention 机制可以认为是一种...
  • 注意力机制attention图解

    千次阅读 2022-04-11 10:32:01
    注意力机制核心观点就是让RNN每一步都监视一个更大的信息集合并从中挑选信息。例如:如果你使用RNN去为一个图像生成注释,它会从图像中挑选一部分去预测输出的单词。接下来在讲解attention之前,我们会先聊聊Seq2Seq...
  • 【python】注意力机制代码

    万次阅读 多人点赞 2021-06-08 17:48:52
    梳理目前主流的注意力机制代码,目前以pytorch为例。 说明: 特征图维度的组织形式为:(batch,channel,height,width) 1. 正文 1.1 SEBlock 2017 考虑通道间的注意力之间的关系,在通道上加入注意力机制 论文:...
  • 首先是结构:CBAM不仅包含senet的channel注意力机制也包含spatial注意力模块 两个attention模块都是使用sigmoid来缩放到[0,1]之间。 更详细的结构:也就是说channel和spatial的注意力机制都用了两个不同的pool。...
  • keras实现注意力机制

    千次阅读 2021-06-22 00:02:43
    class Attention_layer(Layer): def __init__(self, W_regularizer=None, b_regularizer=None, W_constraint=None, b_constraint=None, bias=True, **kwargs): self.supports_masking = True ...
  • 在了解了基于通道的注意力机制SE-NET之后,发现CBAM对于upsample造成的图像损失有一定的弥补作用,这让改进网络结构有了一定的思路。 Abstract 我们提出了卷积块注意模块(CBAM),一种简单而有效的前馈卷积神经网络...
  • 注意力机制详解

    千次阅读 2019-10-18 23:55:55
    Attention机制在近几年来在图像,自然语言处理等领域中都取得了重要的突破,被证明有益于提高模型的性能。...1.1 什么是注意力机制? 所谓Attention机制,便是聚焦于局部信息的机制,比如图像中的某一个图像区...
  • 提出了Attention-YOLO算法,该算法借鉴了基于项的注意力机制,将通道注意力及空间注意力机制加入特征提取网络之中,使用经过筛选加权的特征向量来替换原有的特征向量进行残差融合,同时添加二阶项来减少融合过程中的...
  • 图像中的注意力机制 Pytorch实现

    千次阅读 2022-04-06 21:11:11
    图像中的注意力机制 Pytorch实现
  • 我们的注意力模型会关注feature map的通道和空间,之后模型输出的attention maps会与输入的特征图相乘。这个模型既轻量又通用,可以被加入到任何CNN中,并且可以一起与网络进行端到端的训练。 简介 最近的研究...
  • Attention机制理解笔记声明Attention分类(主要SA和CA)spitial attentionchannel attentionSA + CA(spitial attention+channel attention)加强SA+CA理解空间注意力机制和通道注意力机制解释attention机制Attention...
  • keras, TensorFlow中加入注意力机制

    千次阅读 多人点赞 2019-12-25 11:03:40
    在里面添加通道注意力机制和空间注意力机制 所需库 from keras.layers import GlobalAveragePooling2D, GlobalMaxPooling2D, Reshape, Dense, multiply, Permute, Concatenate, Conv2D, Add, Activation, Lambda ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 118,910
精华内容 47,564
关键字:

空间注意力机制

友情链接: Packet.zip