基于Keras的Channel-Spatial Attention Layers的实现

最新推荐文章于 2024-06-07 09:49:46 发布
最新推荐文章于 2024-06-07 09:49:46 发布
阅读量3.5k 收藏 2
点赞数 1
分类专栏： Keras Modules 文章标签： 深度学习 keras python 图像处理 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kouwang9779/article/details/124003376
版权

基于Keras的Channel-Spatial Attention Layers的实现

描述
Attention被应用于医学图像分割领域以提高神经网络对空间特征及通道的关注度，从而提高分割任务的精确程度。本文根据参考文献实现一种Spatial Attention 和Channel Attention融合使用的注意力层。
在这里插入图片描述

代码展示
1.Spatial Attention Layer

class SpatialAttention(Layer):
    def __init__(self,outChan,feature_size_high,feature_size_low,feature_dim_high,mode,**kwargs):
        super(SpatialAttention,self).__init__()
        self.outChan = outChan
        self.feature_size_high = feature_size_high
        self.feature_size_low = feature_size_low
        self.feature_dim_high = feature_dim_high
        self.mode=mode
        if mode=='2D':
            inputs_high = Input(shape=(feature_size_high[0], feature_size_high[1] ,feature_dim_high))
            inputs_low = Input(shape=(feature_size_low[0], feature_size_low[1] ,outChan))
            Fx_ = Conv2D(feature_dim_high, 2, strides=2,padding = 'same')(inputs_low)
            Fy_ = Conv2D(feature_dim_high, 1, padding = 'same')(inputs_high)
            M_Spatial = Conv2D(feature_dim_high, 3, activation='relu',padding = 'same')(Fx_+Fy_)
            M_Spatial = Conv2D(outChan, 1, activation='sigmoid',padding = 'same')(M_Spatial)
            M_Spatial = UpSampling2D(size=(2,2))(M_Spatial)
            M_Spatial = Multiply()([M_Spatial,inputs_low])
        elif mode=='3D':
            inputs_high = Input(shape=(feature_size_high[0], feature_size_high[1] ,feature_size_high[2],feature_dim_high))
            inputs_low = Input(shape=(feature_size_low[0], feature_size_low[1] ,feature_size_low[2],outChan))
            Fx_ = Conv3D(feature_dim_high, (2,2,1), strides=(2,2,1),padding = 'same')(inputs_low)
            Fy_ = Conv3D(feature_dim_high, 1, padding = 'same')(inputs_high)
            M_Spatial = Conv3D(feature_dim_high, (3,3,1), activation='relu',padding = 'same')(Fx_+Fy_)
            M_Spatial = Conv3D(outChan, 1, activation='sigmoid',padding = 'same')(M_Spatial)
            M_Spatial = UpSampling3D(size=(2,2,1))(M_Spatial)
            M_Spatial = Multiply()([M_Spatial,inputs_low])
        self.SpatialAtten = Model(inputs=[inputs_high,inputs_low],outputs=M_Spatial)
        
    def get_config(self):
        config = super().get_config().copy()
        config.update(
            {
                'outChan':self.outChan,
                'feature_size_high':self.feature_size_high,
                'feature_size_low':self.feature_size_low,
                'feature_dim_high':self.feature_dim_high,
                'SpatialAtten':self.SpatialAtten,
                'mode':self.mode
            }
        )
        return config
    
    def call(self,inputs):
        # high level feature:F_y  low level feature:F_x
        Fy,Fx = inputs
        M_Spatial = self.SpatialAtten([Fy,Fx])
        return M_Spatial

2.Channel Attention Layer

class ChannelAttention(Layer):
    def __init__(self,outChan,feature_size_low,feature_size_high,feature_dim_high,mode,**kwargs):
        super(ChannelAttention,self).__init__()
        self.outChan = outChan
        self.feature_size_high = feature_size_high
        self.feature_size_low = feature_size_low
        self.feature_dim_high = feature_dim_high
        self.mode = mode
        if mode=='2D':
            inputs_high = Input(shape=(feature_size_high[0], feature_size_high[1] ,feature_dim_high))
            inputs_low = Input(shape=(feature_size_low[0], feature_size_low[1] ,outChan))
            Fx_ = Conv2D(feature_dim_high, 1, padding = 'same')(inputs_low)
            Fy_ = Conv2D(feature_dim_high, 1, padding = 'same')(inputs_high)
            Fx_avepool = AveragePooling2D(pool_size=(2, 2))(Fx_) # None*16*16*1024
            Fy_avepool = AveragePooling2D(pool_size=(2, 2))(Fy_) # None*8*8*1024
            Nx = tf.cast(K.shape(Fx_avepool)[1]*K.shape(Fx_avepool)[2],dtype=tf.float32)
            Zx = K.sum(Fx_avepool,axis=2)
            Zx = K.sum(Zx,axis=1)/Nx # batchSize*2channels  # None*1024
            Ny = tf.cast(K.shape(Fy_avepool)[1]*K.shape(Fy_avepool)[2],dtype=tf.float32)
            Zy = K.sum(Fy_avepool,axis=2)
            Zy = K.sum(Zy,axis=1)/Ny # batchSize*2channels  # None*1024
            FC1 = Dense(feature_dim_high,activation='relu')(Zx+Zy) # None*1024
            FC2 = Dense(outChan,activation='sigmoid')(FC1) # batchSize*channels # None*512
            FC2 = K.expand_dims(FC2,axis=1)
            FC2 = K.expand_dims(FC2,axis=2) # batchSize*1*1*channels # None*1*1*512
            M_chan = K.repeat_elements(FC2,feature_size_low[0],axis=1)
            M_chan = K.repeat_elements(M_chan,feature_size_low[1],axis=2)
            M_chan = Multiply()([M_chan,inputs_low])
        elif mode=='3D':
            inputs_high = Input(shape=(feature_size_high[0], feature_size_high[1], feature_size_high[2], feature_dim_high))
            inputs_low = Input(shape=(feature_size_low[0], feature_size_low[1], feature_size_low[2], outChan))
            Fx_ = Conv3D(feature_dim_high, 1, padding = 'same')(inputs_low)
            Fy_ = Conv3D(feature_dim_high, 1, padding = 'same')(inputs_high)
            Fx_avepool = AveragePooling3D(pool_size=(2, 2, 1))(Fx_) # None*16*16*1024
            Fy_avepool = AveragePooling3D(pool_size=(2, 2, 1))(Fy_) # None*8*8*1024
            Nx = tf.cast(K.shape(Fx_avepool)[1]*K.shape(Fx_avepool)[2]*K.shape(Fx_avepool)[3],dtype=tf.float32)
            Zx = K.sum(Fx_avepool,axis=3)
            Zx = K.sum(Zx,axis=2)
            Zx = K.sum(Zx,axis=1)/Nx # batchSize*2channels  # None*1024
            Ny = tf.cast(K.shape(Fy_avepool)[1]*K.shape(Fy_avepool)[2]*K.shape(Fy_avepool)[3],dtype=tf.float32)
            Zy = K.sum(Fy_avepool,axis=3)
            Zy = K.sum(Zy,axis=2)
            Zy = K.sum(Zy,axis=1)/Ny # batchSize*2channels  # None*1024
            FC1 = Dense(feature_dim_high,activation='relu')(Zx+Zy) # None*1024
            FC2 = Dense(outChan,activation='sigmoid')(FC1) # batchSize*channels # None*512
            FC2 = K.expand_dims(FC2,axis=1)
            FC2 = K.expand_dims(FC2,axis=2) # batchSize*1*1*channels # None*1*1*512
            FC2 = K.expand_dims(FC2,axis=3)
            M_chan = K.repeat_elements(FC2,feature_size_low[0],axis=1)
            M_chan = K.repeat_elements(M_chan,feature_size_low[1],axis=2)
            M_chan = K.repeat_elements(M_chan,feature_size_low[2],axis=3)
            M_chan = Multiply()([M_chan,inputs_low])
        self.ChanAtten = Model(inputs=[inputs_high,inputs_low],outputs=M_chan)

    def get_config(self):
        config = super().get_config().copy()
        config.update(
            {
                'outChan':self.outChan,
                'feature_size_high':self.feature_size_high,
                'feature_size_low':self.feature_size_low,
                'feature_dim_high':self.feature_dim_high,
                'ChanAtten':self.ChanAtten,
                'mode':self.mode
            }
        )
        return config
    
    def call(self,inputs):
        # high level feature:F_y  low level feature:F_x
        Fy,Fx = inputs
        M_chan = self.ChanAtten([Fy,Fx])
        return M_chan

3.Spatia-lChannel Attention Layer

class ChannelSpatialAttention(Layer):
    def __init__(self,outChan,feature_size_low,feature_size_high,feature_dim_high,mode,**kwargs):
        super(ChannelSpatialAttention,self).__init__()
        self.outChan = outChan
        self.feature_size_low = feature_size_low
        self.feature_size_high = feature_size_high
        self.feature_dim_high = feature_dim_high
        self.mode = mode
        self.ChannelAttention = ChannelAttention(outChan=outChan,feature_size_low=feature_size_low,feature_size_high=feature_size_high,feature_dim_high=feature_dim_high,mode=mode)
        self.SpatialAttention = SpatialAttention(outChan=outChan,feature_size_low=feature_size_low,feature_size_high=feature_size_high,feature_dim_high=feature_dim_high,mode=mode)

    def get_config(self):
        config = super().get_config().copy()
        config.update(
            {
                'outChan':self.outChan,
                'feature_size_low':self.feature_size_low,
                'feature_size_high':self.feature_size_high,
                'feature_dim_high':self.feature_dim_high,
                'ChannelAttention':self.ChannelAttention,
                'SpatialAttention':self.SpatialAttention,
                'mode':self.mode
            }
        )
        return config
    
    def call(self,inputs):
        # high level feature:F_y  low level feature:F_x
        Fy,Fx = inputs
        M_Chan = self.ChannelAttention([Fy,Fx])
        M_Spatial = self.SpatialAttention([Fy,M_Chan])
        return M_Spatial

References

https://doi.org/10.1016/j.knosys.2021.106754

xtphysics
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
通道注意力机制_即插即用，Triplet Attention机制让Channel和Spatial交互更加丰富（附开源代码）...
weixin_39858245的博客
11-25 1436
↑ 点击蓝字关注极市平台作者丨ChaucerG来源丨AI人工智能初学者编辑丨极市平台极市导读本文介绍了一种新的注意力机制——Triplet Attention，它通过使用Triplet Branch结构捕获跨维度交互来计算注意力权重，是一个即插即用、简单高效的注意力模块。>>加入极市CV技术交流群，走在计算机视觉的最前沿论文下载地址和代码开源地址：https://gith...
在Keras中自定义Attention层
qq_41669355的博客
11-16 2916
具体的公式随处可见，就不展开了讨论了，在build中定义了WQ,WK,WV三个可训练的权值矩阵（batch_size,len,embedding_size），通过对input相乘后将WQ与WK的转置矩阵相乘（（batch_size,len,embedding_size）（batch_size,embedding_size,len）=（batch_size,len,len）），并对该结果进行softmax运算，再对WV进行扩维，扩维至（batch_size,len,len,embedding_size），扩维
理解 tf.keras.layers.Attention
Tak-Wah Blog
05-07 1万+
官方链接：https://tensorflow.google.cn/versions/r2.1/api_docs/python/tf/keras/layers/Attention 语法： tf.keras.layers.Attention( use_scale=False, **kwargs ) Inputs arequerytensor of shape[batch_...
CNN with Attention---channal and spatial attention
weixin_42560055的博客
12-23 2042
CNN with Attention 主要分为两种，一种是spatial attention, 另外一种是channel attention。 CNN每一层都会输出一个C x H x W的特征图，C就是通道，代表卷积核的数量，亦为特征的数量，H 和W就是原始图片经过压缩后的图，spatial attention就是对于所有的通道，在二维平面上，对H x W尺寸的图学习到一个权重，对每个像素都会学习...
探索Keras中的注意力层：实现与应用
最新发布
gitblog_00097的博客
06-07 336
探索Keras中的注意力层：实现与应用 项目地址:https://gitcode.com/thushv89/attention_keras 在深度学习领域，尤其是在自然语言处理（NLP）任务中，注意力机制（Attention Mechanism）已经成为一种革命性的技术。它允许模型在处理序列数据时更加关注关键部分，而不仅仅是全局或平均表示。今天，我们将深入研究一个名为Keras Attention...
CBAM: Convolutional Block Attention Module—— channel attention + spatial attention
yzy的博客
07-31 5300
影响卷积神经网络的几大因素： Depth: VGG, ResNet Width: GoogLeNet Cardinality: Xception, ResNeXt Attention：channel attention, spatial attention Attention在人类感知系统中扮演了重要角色，人类视觉系统的一大重要性质是人类并不是试图一次处理完整个场景，与此相反，为了更好地捕捉...
在 Keras 中为循环神经网络添加自定义注意层
Together_CZ的博客
09-17 1035
本教程分为三个部分；为时间序列预测准备一个简单的数据集如何使用通过 SimpleRNN 构建的网络进行时间序列预测向 SimpleRNN 网络添加自定义注意力层在 Keras 中，通过继承 Layer 类很容易创建一个实现注意力的自定义层。Keras 指南列出了通过子类化创建新层的清晰步骤。我们将在此处使用这些指南。与单个层对应的所有权重和偏差都由该类封装。我们需要编写 __init__ 方法并覆盖以下方法：build()：一旦知道输入的大小，Keras 指南建议在此方法中添加权重。
基于Keras的attention实战
08-21
该代码为基于Keras的attention实战，环境配置： Wn10+CPU i7-6700 、Pycharm 2018、 python 3.6 、、numpy 1.14.5 、Keras 2.0.2 Matplotlib 2.2.2 经过小编亲自调试，可以使用，适合初学者从代码的角度了解attention机制。
keras-self-attention:处理顺序数据的注意力机制，考虑每个时间戳的上下文
05-31
安装pip install keras-self-attention用法基本的默认情况下，注意力层使用附加注意力并在计算相关性时考虑整个上下文。 以下代码创建了一个注意力层，它遵循第一部分中的方程（ attention_activation是e_{t, t'}的...
Self-Attention-Keras：自我关注与文本分类
02-03
本仓库基于自关注机制实现文本分类。 依赖 Python 3.5 凯拉斯 数据集 IMDB影评高度分类数据集，来自IMDB的25,000条影评，被标记为正面/纵向两种评价。影评已被预先为词下标构成的序列。方便起见，单词的下标基于它...
基于Keras实现的Faster-R-CNN安全帽检测模型源码
03-25
项目概述：本项目是一个基于Keras框架实现的Faster R-CNN安全帽检测模型，主要用于识别图像中的安全帽穿戴情况。项目代码开源，托管于GitHub（https://github.com/DataXujing/Faster-R-CNN-Keras）。 技术细节： - ...
cnn-bilstm-attention-time-series-prediction_keras-master
06-02
cnn-bilstm-attention-time-series-prediction_keras-mastercnn-bilstm-attention-time-series-prediction_keras-mastercnn-bilstm-attention-time-series-prediction_keras-mastercnn-bilstm-attention-time-series...
keras-grad-cam：带有keras的Grad-CAM的实现
02-04
在Keras中实现Grad-CAM 梯度类激活图是用于深度学习网络的可视化技术。 参见论文： : 该论文的作者实现了火炬实施： ： 该代码假定Tensorflow尺寸顺序，并默认在keras.applications中使用VGG16网络（网络权重将在...
基于Keras Faster-rcnn对kitti数据集进行目标识别
11-09
在这个项目中，我们将基于Keras这一高度灵活的深度学习库来实现Faster R-CNN，并在Kitti数据集上进行训练，以识别pedestrian和car两类目标。 Kitti数据集是自动驾驶和计算机视觉研究中的一个基准数据集，包含大量的...
keras-attention-mechanism-master_2_attention_keras_kerasgan_GaN_
05-11
本项目"keras-attention-mechanism-master_2_attention_keras_kerasgan_GAN_"是关于使用Keras实现GAN网络的代码库，特别是涉及到注意力机制（Attention Mechanism）和KerasGAN。 注意力机制在深度学习中是一个重要...
keras实现注意力机制
haosen
06-22 3957
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 self.
keras attention机制
重剑无锋博客
05-18 1031
class Attention(tf.keras.layers.Layer): """ Multi-Head Convolutional Self Attention Layer """ def __init__(self, dk, dv, num_heads, filter_size): super().__init__() self.dk = dk self.dv = dv self.num_heads .
注意力之spatial attention
热门推荐
weixin_42764932的博客
01-06 1万+
spatial attention channel attention是对通道加权，spatial attention是对spatial加权 Parameter-Free Spatial Attention Network for Person Re-Identification feature map 对通道求和获得H*W矩阵，然后reshape, softmax, reshape获得注意力矩阵。 CBAM: Convolutional Block Attention Module 既有channel
基于keras搭建的交叉注意力机制python代码
06-01
该代码实现了一个基于Keras的交叉注意力机制模型，包括Squeeze and Excitation block（压缩和激发块）、Spatial Attention block（空间注意块）和Cross Attention block（交叉注意块）。其中，Squeeze and ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值