视觉注意力机制：csSE-Concurrent Spatial and Channel ‘Squeeze & Excitation’ in Fully Convolutional Networks

最新推荐文章于 2023-08-09 13:56:48 发布
最新推荐文章于 2023-08-09 13:56:48 发布
阅读量1.8k 收藏 21
点赞数 5
分类专栏： 注意力机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CharmsLUO/article/details/110086958
版权

论文连接：paper-Concurrent Spatial and Channel SE in Fully Convolutional Networks
代码下载：github-Concurrent Spatial and Channel SE in Fully Convolutional Networks

文章目录

前言

主要受到squeeze & excitation (SE) block方法的启发，该方法对于一个输入feature map，使用一个全局平均池对其空间依赖性进行分解，来对每一个通道进行逐个学习，生成一个能够表示各个通道重要性的Tensor，这个block有很好的适应性，可以穿插在任何卷积神经网络的模型之中，具有很好的泛用性，并在ILSVRC 2017 classification competition中取得优胜的成绩。作者受到这个方法的启发，提出了两种该方法的变体sSE和scSE，原始的SE方法被作者成为cSE，一共三种block，用于分别研究feature map的通道重要性(cSE)，空间重要性(sSE)与两者结合的重要性(scSE)。
在这里插入图片描述

一、cSE-Spatial Squeeze and Channel Excitation Block

作者将原论文的模块命名为cSE
在这里插入图片描述

原理过程：

1. 首先将feature map通过global average pooling方法从[C, H, W]变为[C, 1, 1]
2. 然后依次使用个C/2x1x1、Cx1x1卷积进行信息的处理，得到C维的向量
3. 然后使用sigmoid函数进行归一化，得到对应的mask
4. 最后通过channel-wise相乘，得到经过信息校准过的feature map

代码实现


import keras.backend as K
from keras.layers import *
from keras.models import Model

# spatial squeeze by mean and channel excitation


def cse_block(prevlayer, prefix):
	# 1. 首先将feature map通过global average pooling方法从[C, H, W]变为[C, 1, 1]
    mean = Lambda(lambda xin: K.mean(xin, axis=[1, 2]))(prevlayer)  # H W 求均值
    # K.int_shape() Returns the shape of tensor or variable as a tuple of int or None entries
    lin1 = Dense(K.int_shape(prevlayer)[
                 3] // 2, name=prefix + 'cse_lin1', activation='relu')(mean)
    lin2 = Dense(K.int_shape(prevlayer)[
                 3], name=prefix + 'cse_lin2', activation='sigmoid')(lin1)
    x = Multiply()([prevlayer, lin2])
    return x

二、sSE-Channel Squeeze and Spatial Excitation Block

在这里插入图片描述

1.原理过程：

1. 直接对feature map使用1×1×1卷积, 维度由[C, H, W]变为[1, H, W]的特征图
2. 然后使用sigmoid进行激活得到spatial attention map
3. 然后用得到的结果和原来的特征图相乘

2. 代码实现

import keras.backend as K
from keras.layers import *
from keras.models import Model
def sse_block(prevlayer, prefix):
    # Bug? Should be 1 here?
    conv = Conv2D(K.int_shape(prevlayer)[3], (1, 1), padding="same", kernel_initializer="he_normal",
                  activation='sigmoid', strides=(1, 1),
                  name=prefix + "_conv")(prevlayer)
    conv = Multiply(name=prefix + "_mul")([prevlayer, conv])
    return conv

三、scSE-Spatial and Channel Squeeze & Excitation Block

在这里插入图片描述

原理解释

scSE，其实就是将前两者得到的结果相加

代码实现


def csse_block(x, prefix):
    '''
    Implementation of Concurrent Spatial and Channel ‘Squeeze & Excitation’ in Fully Convolutional Networks
    https://arxiv.org/abs/1803.02579

    x = csse_block(x, prefix='csse_block_{}'.format(i))
    '''
    cse = cse_block(x, prefix)
    sse = sse_block(x, prefix)
    x = Add(name=prefix + "_csse_mul")([cse, sse])

    return x

scSEUNet

最后附上将scSE融入U-Net的代码
在这里插入图片描述

import keras.backend as K
from keras.layers import *
from keras.models import Model


# spatial squeeze by mean and channel excitation
def cse_block(prevlayer, prefix):
    mean = Lambda(lambda xin: K.mean(xin, axis=[1, 2]))(prevlayer)  # H W 求均值
    # K.int_shape() Returns the shape of tensor or variable as a tuple of int or None entries
    lin1 = Dense(K.int_shape(prevlayer)[
                 3] // 2, name=prefix + 'cse_lin1', activation='relu')(mean)
    lin2 = Dense(K.int_shape(prevlayer)[
                 3], name=prefix + 'cse_lin2', activation='sigmoid')(lin1)
    x = Multiply()([prevlayer, lin2])
    return x

# channel squeeze and spatial excitation


def sse_block(prevlayer, prefix):
    # Bug? Should be 1 here?
    conv = Conv2D(K.int_shape(prevlayer)[3], (1, 1), padding="same", kernel_initializer="he_normal",
                  activation='sigmoid', strides=(1, 1),
                  name=prefix + "_conv")(prevlayer)
    conv = Multiply(name=prefix + "_mul")([prevlayer, conv])
    return conv

# concurrent spatial and channel squeeze and channel excitation


def csse_block(x, prefix):
    '''
    Implementation of Concurrent Spatial and Channel ‘Squeeze & Excitation’ in Fully Convolutional Networks
    https://arxiv.org/abs/1803.02579

    x = csse_block(x, prefix='csse_block_{}'.format(i))
    '''
    cse = cse_block(x, prefix)
    sse = sse_block(x, prefix)
    x = Add(name=prefix + "_csse_mul")([cse, sse])

    return x


def scSEUnet(nclasses, input_height=224, input_width=224):
    inputs = Input(shape=(input_height, input_width, 3))
    conv1 = Conv2D(16,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(inputs)
    conv1 = BatchNormalization()(conv1)

    conv1 = Conv2D(16,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv1)
    conv1 = BatchNormalization()(conv1)

    pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
    conv2 = Conv2D(32,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(pool1)
    conv2 = BatchNormalization()(conv2)

    conv2 = Conv2D(32,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv2)
    conv2 = BatchNormalization()(conv2)

    pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
    conv3 = Conv2D(64,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(pool2)
    conv3 = BatchNormalization()(conv3)

    conv3 = Conv2D(64,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv3)
    conv3 = BatchNormalization()(conv3)

    pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
    conv4 = Conv2D(128,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(pool3)
    conv4 = BatchNormalization()(conv4)

    conv4 = Conv2D(128,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv4)
    conv4 = BatchNormalization()(conv4)

    pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)

    conv5 = Conv2D(256,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(pool4)
    conv5 = BatchNormalization()(conv5)
    conv5 = Conv2D(256,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv5)
    conv5 = BatchNormalization()(conv5)

    up6 = Conv2D(128,
                 2,
                 activation='relu',
                 padding='same',
                 kernel_initializer='he_normal')(UpSampling2D(size=(2,
                                                                    2))(conv5))
    up6 = BatchNormalization()(up6)

    merge6 = concatenate([conv4, up6], axis=3)
    conv6 = Conv2D(128,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(merge6)
    conv6 = BatchNormalization()(conv6)

    conv6 = Conv2D(128,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv6)
    conv6 = BatchNormalization()(conv6)

    up7 = Conv2D(64,
                 2,
                 activation='relu',
                 padding='same',
                 kernel_initializer='he_normal')(UpSampling2D(size=(2,
                                                                    2))(conv6))
    up7 = BatchNormalization()(up7)

    merge7 = concatenate([conv3, up7], axis=3)
    conv7 = Conv2D(64,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(merge7)
    conv7 = BatchNormalization()(conv7)

    conv7 = Conv2D(64,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv7)
    conv7 = BatchNormalization()(conv7)

    conv7 = csse_block(conv7, prefix="conv7")

    up8 = Conv2D(32,
                 2,
                 activation='relu',
                 padding='same',
                 kernel_initializer='he_normal')(UpSampling2D(size=(2,
                                                                    2))(conv7))
    up8 = BatchNormalization()(up8)

    merge8 = concatenate([conv2, up8], axis=3)
    conv8 = Conv2D(32,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(merge8)
    conv8 = BatchNormalization()(conv8)

    conv8 = Conv2D(32,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv8)
    conv8 = BatchNormalization()(conv8)

    conv8 = csse_block(conv8, prefix="conv8")

    up9 = Conv2D(16,
                 2,
                 activation='relu',
                 padding='same',
                 kernel_initializer='he_normal')(UpSampling2D(size=(2,
                                                                    2))(conv8))
    up9 = BatchNormalization()(up9)

    merge9 = concatenate([conv1, up9], axis=3)
    conv9 = Conv2D(16,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(merge9)
    conv9 = BatchNormalization()(conv9)

    conv9 = Conv2D(16,
                   3,
                   activation='relu',
                   padding='same',
                   kernel_initializer='he_normal')(conv9)
    conv9 = BatchNormalization()(conv9)

    conv9 = csse_block(conv9, prefix="conv9")

    conv10 = Conv2D(nclasses, (3, 3), padding='same')(conv9)
    o = BatchNormalization()(conv10)




    out = Activation('sigmoid')(o)

    model = Model(input=inputs, output=out)


    return model

在这里插入图片描述

Charms@
关注
  • 5
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【论文解读】Concurrent Spatial and Channel `Squeeze & Excitation' in Fully Convolutional Networks
cedi9117的博客
03-06 2764
Paper 这篇论文提出了一种称为scSE（Concurrent Spatial and Channel `Squeeze & Excitation’） block的神经网络，它可以应用在CNN的任意层，用于增强CNN编码空间信息（spatial encoding）能力，提高CNN的图像识别能力。 在Kaggle image segmentation比赛–TGS Salt Ide...
CS-3113：CS 3113-操作系统简介-俄克拉荷马大学
02-04
操作系统是计算机科学中的核心课程，CS-3113，即俄克拉荷马大学的“操作系统简介”，旨在向学生介绍操作系统的基本概念、设计原理和实现技术。这门课程涵盖了操作系统的关键组件，包括进程管理、内存管理、文件系统...
【深度学习】一文读懂CV中的注意力机制
fengdu78的博客
08-04 219
作者丨AdamLau@知乎 来源丨https://zhuanlan.zhihu.com/p/288758894 编辑丨极市平台 转自 | 极市平台导读本文配合相关的论文，讲述了多种CV注意力机制（Non-local Neural Networks、Squeeze-and-Excitation Networks、CBAM、DANet）的概念、特点以及相关实验。CV注意力机制Non-local ~ ...
Concurrent Spatial and Channel ‘Squeeze & Excitation’ in Fully Convolutional Networks(附代码)
得克特
03-30 3879
文章目录摘要介绍方法空间压缩和信道激励（cSE）通道压缩和空间激励空间和通道的压缩和激励模块(scSE) 摘要  全卷积网络为大量应用设置了图像分割的最新技术，F-CNN中的结构创新集中在空间编码或网络连接来帮助梯度流。本文，探索了一种自适应地重新校准特征图的方向，来增加有意义的特征，同时抑制弱的特征。我们从最近提出的squeeze & excitation(SE)模块获得灵感，该模块是用...
2018-15Concurrent Spatial and Channel ‘Squeeze &Excitation’ in Fully Convolutional Networks
weixin_43921949的博客
11-02 424
空间注意力和通道注意力二者的结合
csSEnet注意力网络
feverfew1的博客
04-25 3847
csSEnet注意力网络
「Medical Image Analysis」Notes on Concurrent Spatial and Channel Squeeze & Excitation
小锋子Shawn
01-10 334
QQ Group: 428014259 Sina Weibo：小锋子Shawn Tencent E-mail：403568338@qq.com http://blog.csdn.net/dgyuanshaofeng/article/details/85566885 0 摘要 介绍3种变体：1、squeezing spatially and exciting channel-wise, cSE，挤压...
mastering-c-multithreading-write-robust-concurrent-and-parallel
11-25
mastering-c-multithreading-write-robust-concurrent-and-parallel-applications_compress
Concurrency in .NET: Modern patterns of concurrent and parallel programming
06-13
Concurrency in .NET teaches you how to build concurrent and scalable programs in .NET using the functional paradigm. This intermediate-level guide is aimed at developers, architects, and passionate ...
proj2:CS 535-项目2
04-30
在本项目"proj2: CS 535-项目2"中，我们聚焦于一个针对计算机科学课程CS 535的编程任务，这通常涉及数据库管理或操作系统相关的课程内容。"bufmgr"目录的创建暗示了这个项目的核心是关于缓冲区管理器的设计与实现，...
注意力attention机制在CV中的讲解.pptx
05-18
B站讲解视频的PPT https://www.bilibili.com/video/BV1SA41147uA/
基于resnet+unet的皮肤病变分割
02-25
该工程使用resnet50/101+hypercolumn+scse+unet算法实现对皮肤病变的分割
基于ResNet及特征融合的场景文本检测技术研究
03-12
基于ResNet及特征融合的场景文本检测技术研究，李相相，牛少彰，论文对于之前的学者所提出的CTPN网络模型进行深入的研究，提出了一种改进的场景文本检测网络。首先，使用ResNet代替原网络中的VGG16来
UNET ResNet50网络结构 caffe版本
03-06
UNET ResNet50网络结构 caffe版本，
mulle-concurrent：:antenna_bars:一个无锁且无等待的哈希表（还有一个数组）
02-05
《mulle-concurrent：构建无锁且无等待的哈希表与数组》 在软件开发中，尤其是在多线程环境中，数据结构的选择对于程序性能和并发性至关重要。`mulle-concurrent`是一个专注于并发编程的C语言库，其中的`:antenna_...
注意力机制论文:Concurrent Spatial and Channel SE in Fully Convolutional Networks及其Pytorch实现
mingo_敏
02-26 2385
Concurrent Spatial and Channel ‘Squeeze & Excitation’ in Fully Convolutional Networks PDF: https://arxiv.org/pdf/1803.02579v2.pdf PyTorch代码: https://github.com/shanglianlm0525/PyTorch-Networks PyT...
【深度学习注意力机制系列】—— SCSE注意力机制（附pytorch实现）
最新发布
qq_43456016的博客
08-09 4621
SCSE注意力模块（来自论文[1803.02579] Concurrent Spatial and Channel Squeeze & Excitation in Fully Convolutional Networks (arxiv.org)）。其对SE注意力模块进行了改进，提出了cSE、sSE、scSE三个模块变体，这些模块可以增强有意义的特征，抑制无用特征。今天我们就分别讲解一下这三个注意力模块。cSE模块引入了通道注意力机制，可有效的对通道维度的特征信息进行整合增强，这一点与SE等传统通道注意力机制
注意力机制
weixin_41243988的博客
03-04 1727
注意力机制结构与代码整理
注意力机制(SE, ECA, CBAM, SKNet, scSE, Non-Local, GCNet, ASFF) Pytorch代码
热门推荐
Philo的博客
02-10 3万+
介绍在CNN中的常见的三种注意力机制，并且提供了Pytorch代码 2023.3.2新增SKNet代码，同是修改SkNet在测试时不报错，但是在反向传播中报错的情况。 2023.3.10 新增scSE注意力代码 2023.3.11 新增Non-Local Net代码 2023.3.13 新增GCNet代码 2023.6.7 新增ASFF代码
Duplicate class com.google.common.util.concurrent.ListenableFuture found in modules jetified-guava-24.0-android (com.google.guava:guava:24.0-android) and jetified-listenablefuture-1.0 (com.google.guava:listenablefuture:1.0)
05-24
这个错误是因为在你的项目中，有两个不同版本的 `ListenableFuture` 类同时存在。一个是在 `com.google.guava:guava:24.0-android` 模块中的 `ListenableFuture` 类，另一个是在 `com.google.guava:listenablefuture:1.0` 模块中的 `ListenableFuture` 类。 要解决这个问题，你需要在你的项目中排除其中一个模块的 `ListenableFuture` 类。可以在 `build.gradle` 文件中添加以下代码： ``` dependencies { // ... implementation('com.google.guava:guava:24.0-android') { exclude group: 'com.google.guava', module: 'listenablefuture' } } ``` 这将会排除掉 `guava` 模块中的 `ListenableFuture` 类，只使用 `listenablefuture` 模块中的 `ListenableFuture` 类。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值