参考链接: 注意力机制

参考链接: 深度学习卷积神经网络重要结构之通道注意力和空间注意力模块

参考链接: 用于卷积神经网络的注意力机制(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> 

通道注意力机制就是学习一个不同通道的加权系数，同时考虑到了所有区域

空间注意力机制就是学习整个画面不同区域的系数，同时考虑到了所有通道
PyTorch实现

哈哈哈，代码是我摘抄出来的…

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 // 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))))
        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)  # 输入两个通道，一个是maxpool 一个是avgpool的
        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)  # 对池化完的数据cat 然后进行卷积
        return self.sigmoid(x)


参考：

https://github.com/luuuyi/CBAM.PyTorch

                    
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建模的是空间位置的重要性，结构如下：
 
 首先将通道本身进行降维，分别获取最大池化和均值池化结果，然后拼接成一个特征图，再使用一个卷积层进行学习。
 
这两种机制，分别学习了通道的重要性和空间的重要性，还可以很容易地嵌入到任何已知的框架中。
 
除此之外，还有很多的注意力机制相关的研究，比如残差注意力机制，多尺度注意力机制，递归注意力机制等。
                

SAM-Model(pytorch版本)


1.一 论文导读
2.二 论文精读
3.三 代码实现
4.四 问题思索


《An Empirical Study of Spatial Attention Mechanisms in Deep Networks》

—空间注意力机制

作者：Xizhou Zhu, Dazhi Cheng,etc.

单位：微软亚研

发表会议及时间：arXiv 2019

论文地址

相关代码
Submission history

From: Jifeng Dai [view email]

[v1] Thu, 11 Apr 2019 17:58:37 UTC (696 KB)
一 论文导读

二 论文精读



Abstract

注意机制已成为深度神经网络中流行的组成部分，但很少有研究探讨不同的影响因素以及从这些因素计算注意力的方法如何影响性能。
为了更好地理解注意力机制，我们提供了一项经验研究，可以消除广义注意力公式中的各种空间注意力元素，包括占主导地位的Transformer注意力以及流行的可变形卷积和动态卷积模块。
在各种应用中进行的研究得出了有关深层网络中空间注意力的重要发现，其中一些与传统理解背道而驰。例如，我们发现Transformer注意中的查询和关键内容比较对于自我注意而言是微不足道的，但对于注意编码器-解码器至关重要。变形卷积与仅关键内容的显着性的适当组合可以实现最佳的自我注意效率-效率折衷。
我们的结果表明，注意力机制的设计存在很大的改进空间。

Attention mechanisms have become a popular component in deep neural networks, yet there has been little examination of how different influencing factors and methods for computing attention from these factors affect performance. Toward a better general understanding of attention mechanisms, we present an empirical study that ablates various spatial attention elements within a generalized attention formulation, encompassing the dominant Transformer attention as well as the prevalent deformable convolution and dynamic convolution modules. Conducted on a variety of applications, the study yields significant findings about spatial attention in deep networks, some of which run counter to conventional understanding. For example, we find that the query and key content comparison in Transformer attention is negligible for self-attention, but vital for encoder-decoder attention. A proper combination of deformable convolution with key content only saliency achieves the best accuracy-efficiency tradeoff in self-attention. Our results suggest that there exists much room for improvement in the design of attention mechanisms.






三 代码实现

四 问题思索