注意力机制（一）SE模块（Squeeze-and-Excitation Networks）论文总结和代码实现

已于 2024-06-27 11:40:04 修改
阅读量2.8w 收藏 296
点赞数 50
分类专栏： 注意力机制 文章标签： SE模块 注意力机制
于 2023-05-26 01:31:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45981086/article/details/130869929
版权

Squeeze-and-Excitation Networks（压缩和激励网络）

论文地址：Squeeze-and-Excitation Networks

论文中文版：Squeeze-and-Excitation Networks_中文版

代码地址：GitHub - hujie-frank/SENet: Squeeze-and-Excitation Networks

一、论文出发点

为了提高网络的表示能力，许多现有的工作已经显示出增强空间编码的好处。而作者专注于通道，希望能够提出了一种新的架构单元，通过显式地建模出卷积特征通道之间的相互依赖性来提高网络的表示能力。

这里引用“博文：Squeeze-and-Excitation Networks解读”中的总结：核心思想是不同通道的权重应该自适应分配，由网络自己学习出来的，而不是像Inception net一样留下过多人工干预的痕迹。

二、论文的主要工作

1.提出了一种新的架构单元Squeeze-and-Excitation模块，该模块可以显式地建模卷积特征通道之间的相互依赖性来提高网络的表示能力。

2.提出了一种机制，使网络能够执行特征重新校准，通过这种机制可以学习使用全局信息来选择性地强调信息特征并抑制不太有用的特征。

三、Squeeze-and-Excitation模块

3.1 Transformation（Ftr）（转型）

F_{tr}：X\rightarrow U，经过F_{tr}特征图X变为特征图U。F_{tr}可以看作一个标准的卷积算子。公式定义如下：

                                                       U_{c}=V_{c}*X=\sum_{s=1}^{C'}V_{c}^{s}*X^{s}

其中，X∈R^(H′×W′×C′)为输入特征图U∈R^(H×W×C)：输出特征图，V：表示学习到的一组滤波器核，Vc：指的是第c个滤波器的参数，​V_{c}^{s}表示一个2D的空间核，*表示卷积操作。

该卷积算子公式表示，输入特征图X的每一层都经过一个2D空间核的卷积最终得到C个输出的feature map，组成特征图U。

3.2 Squeeze（全局信息嵌入）

​

Fsq就是使用通道的全局平均池化。

原文中为了解决利用通道依赖性的问题，选择将全局空间信息压缩到一个信道描述符中，即使用通道的全局平均池化，将包含全局信息的W×H×C 的特征图直接压缩成一个1×1×C的特征向量Z，C个feature map的通道特征都被压缩成了一个数值，这样使得生成的通道级统计数据Z就包含了上下文信息，缓解了通道依赖性的问题。定义如下：

其中，Zc为Z的第c个元素。

3.3 Excitation（自适应重新校正）

目的：为了利用压缩操作中汇聚的信息，我们接下来通过Excitation操作来全面捕获通道依赖性。
实现方法：
为了实现这个目标，这个功能必须符合两个标准：
第一，它必须是灵活的 （它必须能够学习通道之间的非线性交互）
第二，它必须学习一个非互斥的关系，因为独热激活相反，这里允许强调多个通道。
为了满足这些标准，作者采用了两层全连接构成的门机制，第一个全连接层把C个通道压缩成了C/r个通道来降低计算量，再通过一个RELU非线性激活层，第二个全连接层将通道数恢复回为C个通道，再通过Sigmoid激活得到权重s，最后得到的这个s的维度是1×1×C，它是用来刻画特征图U中C个feature map的权重。r是指压缩的比例。

为什么这里要有两个FC，并且通道先缩小，再放大？

因为一个全连接层无法同时应用relu和sigmoid两个非线性函数，但是两者又缺一不可。为了减少参数，所以设置了r比率。

3.4 Scale（重新加权）

目的：最后是Scale操作，将前面得到的注意力权重加权到每个通道的特征上。

实现方法：特征图U中的每个feature map乘以对应的权重，得到SE模块的最终输出\widetilde{X}。

四、模型：SE-Inception和SE-ResNet

通过将一个整体的Inception模块看作SE模块中F_{tr}，为Inception网络构建SE模块。

同理， 将一个整体的Residual模块看作SE模块中F_{tr}，为ResNet网络构建SE模块。

五、实验

六、结论

本文提出的SE模块，这是一种新颖的架构单元，旨在通过使网络能够执行动态通道特征重新校准来提高网络的表示能力。大量实验证明了SENets的有效性，其在多个数据集上取得了最先进的性能。

七、源码分析

将SEblock嵌入ResNet的残差模块中。

7.1 SE模块

'''-------------一、SE模块-----------------------------'''
#全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid
class SE_Block(nn.Module):
    def __init__(self, inchannel, ratio=16):
        super(SE_Block, self).__init__()
        # 全局平均池化(Fsq操作)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        # 两个全连接层(Fex操作)
        self.fc = nn.Sequential(
            nn.Linear(inchannel, inchannel // ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(inchannel // ratio, inchannel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )

    def forward(self, x):
            # 读取批数据图片数量及通道数
            b, c, h, w = x.size()
            # Fsq操作：经池化后输出b*c的矩阵
            y = self.gap(x).view(b, c)
            # Fex操作：经全连接层输出（b，c，1，1）矩阵
            y = self.fc(y).view(b, c, 1, 1)
            # Fscale操作：将得到的权重乘以原来的特征图x
            return x * y.expand_as(x)

7.2 SE-ResNet完整代码

不同版本的ResNet各层主要是由BasicBlock模块（18-layer、34-layer）或Bottleneck模块（50-layer、101-layer、152-layer）构成的。

添加SE模块位置：在BasicBlock模块或Bottleneck模块尾部添加，但是要注意放在shortcut之前。

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchsummary import summary

'''-------------SE模块-----------------------------'''
#全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid
class SE_Block(nn.Module):
    def __init__(self, inchannel, ratio=16):
        super(SE_Block, self).__init__()
        # 全局平均池化(Fsq操作)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        # 两个全连接层(Fex操作)
        self.fc = nn.Sequential(
            nn.Linear(inchannel, inchannel // ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(inchannel // ratio, inchannel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )

    def forward(self, x):
            # 读取批数据图片数量及通道数
            b, c, h, w = x.size()
            # Fsq操作：经池化后输出b*c的矩阵
            y = self.gap(x).view(b, c)
            # Fex操作：经全连接层输出（b，c，1，1）矩阵
            y = self.fc(y).view(b, c, 1, 1)
            # Fscale操作：将得到的权重乘以原来的特征图x
            return x * y.expand_as(x)

'''-------------（18-layer、34-layer）BasicBlock模块-----------------------------'''
# residual block 结构
class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, inchannel, outchannel, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(inchannel, outchannel, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(outchannel)
        self.conv2 = nn.Conv2d(outchannel, outchannel, kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(outchannel)
        # SE_Block放在BN之后，shortcut之前
        self.SE = SE_Block(outchannel)

        self.shortcut = nn.Sequential()
        if stride != 1 or inchannel != self.expansion*outchannel:
            self.shortcut = nn.Sequential(
                nn.Conv2d(inchannel, self.expansion*outchannel,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*outchannel)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        SE_out = self.SE(out)
        out = out * SE_out
        out += self.shortcut(x)
        out = F.relu(out)
        return out

'''-------------（50-layer、101-layer、152-layer）Bottleneck模块-----------------------------'''
# residual block 结构
class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, inchannel, outchannel, stride=1):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inchannel, outchannel, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(outchannel)
        self.conv2 = nn.Conv2d(outchannel, outchannel, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(outchannel)
        self.conv3 = nn.Conv2d(outchannel, self.expansion*outchannel,
                               kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(self.expansion*outchannel)
        # SE_Block放在BN之后，shortcut之前
        self.SE = SE_Block(self.expansion*outchannel)

        self.shortcut = nn.Sequential()
        if stride != 1 or inchannel != self.expansion*outchannel:
            self.shortcut = nn.Sequential(
                nn.Conv2d(inchannel, self.expansion*outchannel,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*outchannel)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = F.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        SE_out = self.SE(out)
        out = out * SE_out
        out += self.shortcut(x)
        out = F.relu(out)
        return out

'''-------------搭建SE_ResNet结构-----------------------------'''
class SE_ResNet(nn.Module):
    def __init__(self, block, num_blocks, num_classes=10):
        super(SE_ResNet, self).__init__()
        self.in_planes = 64

        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,
                               stride=1, padding=1, bias=False)                  # conv1
        self.bn1 = nn.BatchNorm2d(64)
        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)       # conv2_x
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)      # conv3_x
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)      # conv4_x
        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)      # conv5_x
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.linear = nn.Linear(512 * block.expansion, num_classes)

    def _make_layer(self, block, planes, num_blocks, stride):
        strides = [stride] + [1]*(num_blocks-1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_planes, planes, stride))
            self.in_planes = planes * block.expansion
        return nn.Sequential(*layers)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        out = self.linear(x)
        return out


def SE_ResNet18():
    return SE_ResNet(BasicBlock, [2, 2, 2, 2])


def SE_ResNet34():
    return SE_ResNet(BasicBlock, [3, 4, 6, 3])


def SE_ResNet50():
    return SE_ResNet(Bottleneck, [3, 4, 6, 3])


def SE_ResNet101():
    return SE_ResNet(Bottleneck, [3, 4, 23, 3])


def SE_ResNet152():
    return SE_ResNet(Bottleneck, [3, 8, 36, 3])


'''
if __name__ == '__main__':
    model = SE_ResNet50()
    print(model)
    input = torch.randn(1, 3, 224, 224)
    out = model(input)
    print(out.shape)
# test()
'''
if __name__ == '__main__':
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    net = SE_ResNet50().to(device)
    # 打印网络结构和参数
    summary(net, (3, 224, 224))

向岸看
关注
  • 50
    点赞
  • 踩
  • 296
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
SE 注意力模块 原理分析与代码实现
黎国溥
09-24 1万+
本文介绍SE注意力模块，它是在SENet中提出的，SENet是ImageNet 2017的冠军模型；SE模块常常被用于CV模型中，能较有效提取模型精度，所以给大家介绍一下它的原理，设计思路，代码实现，如何应用在模型中。后面还会介绍其它注意力模型：SK-Nets、CBAM、DANet、ECA-Net、CA等注意力模块。
Squeeze-and-Excitation Networks
chenaxin的博客
04-07 1万+
摘要 卷积神经网络建立在卷积运算的基础上，通过融合局部感受野内的空间信息和通道信息来提取信息特征。为了提高网络的表示能力，许多现有的工作已经显示出增强空间编码的好处。在这项工作中，我们专注于通道，并提出了一种新颖的架构单元，我们称之为“Squeeze-and-Excitation”（SE）块，通过显式地建模通道之间的相互依赖关系，自适应地重新校准通道式的特征响应。通过将这些块堆叠在一起，我们证明了我们可以构建SENet架构，在具有挑战性的数据集中可以进行泛化地非常好。关键的是，我们发现SE块以微小的计算成本
SE、CBAM、ECA 、CA注意力机制
m0_50127633的博客
10-04 5999
之后对平均池化和最大池化的结果，利用共享的全连接层进行处理，我们会对处理后的两个结果进行相加，然后取一个sigmoid，此时我们获得了输入特征层每一个通道的权值（0-1之间）。假设输入进来的特征层的形状为[C, H, W]，在经过宽方向的平均池化后，获得的特征层shape为[C, H, 1]，此时我们将特征映射到了高维度上；用更专业的名词就是跨通道交互的覆盖率。SE注意力机制只考虑了通道维度上的注意力，无法捕捉空间维度上的注意力，适用于通道数较多的场景，但对于通道数较少的情况可能不如其他注意力机制。
SE 注意力模块
热门推荐
IT__learning的博客
08-02 1万+
一、SE 模块的结构 SE 模块主要包含 Squeeze 和 Excitation 两部分。W，H 表示特征图宽，高。C 表示通道数，输入特征图大小为 W×H×C。 1、压缩（Squeeze） 第一步是压缩（Squeeze）操作，如下图所示： 这个操作就是一个全局平均池化（global average pooling）。经过压缩操作后特征图被压缩为1×1×C向量。 2、激励（Excitation） 接下来就是激励（Excitation）操作，如下图所示： 由两个全连接层组成，其中SERatio是
【学习】SE注意力，SEresnet代码实现。
最新发布
qq_46110320的博客
05-20 212
SE是一个通道注意力机制。这里的代码是只提取出了resnet的后三层。
Squeeze-and-Excitation Networks 论文思维导图
04-07
该资源给出了论文 Squeeze-and-Excitation Networks 整体的思维导图情况，可以更方便的加深对论文的理解与应用，所使用的软件是 XMind zen.
SE通道注意力机制模块
m0_62919535的博客
01-23 2128
SE（Squeeze-and-Excitation）模块是一种引入通道注意力机制的方法，旨在让神经网络更加关注对当前任务重要的特征。首先是Squeeze操作，通过聚合跨空间维度(H × W)的特征映射来产生通道描述符，怎么理解呢？假设有一个输入的特征映射，它的维度是H × W × C，对于每个通道，执行全局平均池化操作，具体来说，对于第i个通道，计算该通道上所有空间位置的平均值。通过学习，全连接层得到的通道权重经过一个Sigmoid激活函数，将其范围限制在0到1之间。ResNet与SE-ResNet分类性能
SE （Squeeze Excitation）模块
zfjBIT的专栏
10-27 1万+
SE模块
注意力机制——Squeeze-and-Excitation Networks（SENet）
weixin_50752408的博客
03-16 2189
2.Excitation操作：根据Squeeze操作得到的通道重要性系数，对每个通道的特征图进行加权，即通过一个全连接层对重要性系数进行学习，得到一个权重向量，然后将该向量应用到原始的特征图上。1.Squeeze操作：将每个通道的特征图压缩成一个数值，即全局平均池化（global average pooling），可以理解为对每个通道进行特征提取，得到该通道的重要性系数。是一种通道注意力模型，通过对每个通道进行权重调整，增强对于重要通道的关注度，从而提高了模型的表现力。表示输入特征图的通道数，
SE-Net:Squeeze-and-Excitation Networks论文详解
weixin_47166887的博客
10-27 5688
注意力机制的文章之------通道注意力 SE-Net:Squeeze-and-Excitation Networks论文详解 论文链接：https://arxiv.org/pdf/1709.01507.pdf Github代码：https://github.com/hujie-frank/SENet 注意力机制最早用于自然语言处理(NLP),后来在计算机视觉(CV)也得到广泛的应用，之后注意力机制便被引入来进行视觉信息处理。注意力机制的核心思想就是能够从大量的信息中筛选出重要的信息。注意力机制可以分为通道
【新手小白向-自我感觉只有基础的高数和线代知识】-SE（Squeeze and Excitation）模块的原理理解与解释-以别人的文章为主加上自己的理解
时间漂流者-梧桐的博客
04-06 1838
基础薄弱的我，阅读SE模块原理解释等文章后的学习笔记。内容以阅读的文章正文部分为主，辅有我自己的注释。
Recurrent Squeeze-and-Excitation Context Aggregation Net for Single Image
09-28
"Squeeze-and-Excitation"（SE）模块是由Hu等人提出的，其核心思想是通过自适应地调整通道之间的权重，使网络能更好地关注重要特征，而忽略不那么重要的信息。在RESCAN模型中，SE模块被引入到循环结构中，增强了模型...
注意力机制-在resnet18中嵌入视觉注意力机制-优质项目.zip
02-24
1. 通道注意力：如SEBlock（Squeeze-and-Excitation Block），它先全局平均池化（Global Average Pooling）来获取整个特征图的通道统计信息，然后通过全连接层（Fully Connected Layers）生成通道权重，最后乘以原始...
各种图像注意力模块的实现.zip
01-12
1. **SE（Squeeze-and-Excitation）注意力模块**：由Huang等人在2017年的论文《Squeeze-and-Excitation Networks》中提出。SE模块通过全局池化获取通道间的信息，并用此来重新调整每个通道的权重，从而使网络能更好...
【Attention(9)】【CNN-attention机制】Squeeze-and-Excitation Networks（SENet）通过压缩与激励实现特征强化，最简单最易实现的SE模块
Hali_Botebie的博客
04-27 916
Squeeze-and-Excitation Networks（SENet）是由自动驾驶公司Momenta在2017年公布的一种全新的图像识别结构，它通过对特征通道间的相关性进行建模，把重要的特征进行强化来提升准确率。这个结构是2017 ILSVR竞赛的冠军，top5的错误率达到了2.251%，比2016年的第一名还要低25%，可谓提升巨大。这么大的提升是怎么来的呢？今天就来介绍下这个冠军背后的原理细节。 一、结构和原理 图1是SENet的Block单元，图中的Ftr是传统的卷积结构，X和U是Ftr的输入
SE注意力模块学习笔记《Squeeze-and-Excitation Networks》
985小菜鸡
03-26 1405
卷积神经网络建立在卷积运算的基础上，通过在局部感受野内融合空间信息和通道信息来提取信息特征。为了提高网络的表示能力，最近的几种方法显示了增强空间编码的好处。作者专注于通道关系，并提出了一种新的架构单元，称之为“挤压-激励”(SE)块，该单元通过明确建模通道之间的相互依赖性自适应地重新校准通道级别(channel-wise )的特征响应。作者证明，通过将这些块堆叠在一起所构建的 SENet 架构，在具有挑战性的数据集上泛化得非常好。
SENet结构解读
zhw864680355的博客
04-07 5588
原文：https://zhuanlan.zhihu.com/p/65459972 一、前言 在深度学习领域，CNN分类网络的发展对其它计算机视觉任务如目标检测和语义分割都起到至关重要的作用，因为检测和分割模型通常是构建在CNN分类网络（称为backbone）之上。提到CNN分类网络，我们所熟知的是VGG，ResNet，Inception，DenseNet等模型，它们的效果已经被充分验证，而且被...
❀论文篇❀注意力机制SE论文的理解
weixin_44649780的博客
06-03 2992
注意力机制SE的通俗理解！❤❤❤
squeeze-and-excitation networks
03-17
Squeeze-and-excitation networks (SE-Net) 是一种深度神经网络架构，它通过调整每个通道的权重来提高网络的注意力。这种方法通过缩放和激活的过程来提高网络的性能。SE-Net在计算机视觉领域有着广泛的应用，如图像分类和物体检测。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

向岸看

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值