PSA极注意力 - tensorflow2代码

已于 2022-11-09 20:31:59 修改
阅读量455 收藏 4
点赞数
分类专栏： Tensorflow2 文章标签： tensorflow 深度学习 keras
于 2022-11-09 20:06:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzl18681269883/article/details/127776730
版权

 论文中有两种，上方的为PSA_P， 下方的为PSA_S。

import tensorflow as tf

def kaiming_init(module, distribution='normal'):
    assert distribution in ['uniform', 'normal']
    if distribution == 'uniform':
        module.kernel_initializer = tf.keras.initializers.he_uniform() # l
    else:
        module.kernel_initializer = tf.keras.initializers.he_normal() # z
    if hasattr(module, 'bias') and module.bias is not None:
        module.kernel_initializer = tf.keras.initializers.constant() # z


class PSA_p(tf.keras.Model):
    def __init__(self, planes, data_format='channels_last'):
        """
        :param planes:  输入的通道数
        :param data_format:  数据格式,默认为 channels_last， 可选 channels_first
        """
        super(PSA_p, self).__init__()
        self.data_format = data_format
        self.planes = planes
        self.out_planes = planes // 2

        self.conv_q_left = tf.keras.layers.Conv2D(filters=1, kernel_size=1, strides=1, padding='valid', use_bias=False)
        self.conv_v_left = tf.keras.layers.Conv2D(filters=self.out_planes, kernel_size=1, strides=1, padding='valid',
                                                  use_bias=False)
        self.conv_up_left = tf.keras.layers.Conv2D(filters=self.planes, kernel_size=1, strides=1, padding='valid',
                                                   use_bias=False)
        self.softmax_left = tf.keras.layers.Activation(activation=tf.keras.activations.softmax)
        self.sigmoid_left = tf.keras.layers.Activation(activation=tf.keras.activations.sigmoid)

        self.conv_q_right = tf.keras.layers.Conv2D(filters=self.out_planes, kernel_size=1, strides=1, padding='valid', use_bias=False)
        self.conv_v_right = tf.keras.layers.Conv2D(filters=self.out_planes, kernel_size=1, strides=1, padding='valid', use_bias=False)
        self.global_pool = tf.keras.layers.GlobalAvgPool2D(keepdims=True)
        self.softmax_right = tf.keras.layers.Activation(activation=tf.keras.activations.softmax)
        self.sigmoid_right = tf.keras.layers.Activation(activation=tf.keras.activations.sigmoid)

        self.reset_parameters() # l

    def reset_parameters(self): # z
        kaiming_init(self.conv_v_right)
        kaiming_init(self.conv_q_right)
        kaiming_init(self.conv_v_left)
        kaiming_init(self.conv_q_left)

    def channel_pool(self, inputs): # z
        if self.data_format == 'channels_first':
            inputs = tf.transpose(inputs, perm=[0, 2, 3, 1])  # (B, C, H, W) -> (B, H, W, C)

        #   (B, H, W, IC) -> (B, H, W, IC/2)
        input_x = self.conv_v_left(inputs)
        B, H, W, C = tf.shape(input_x)
        #   (B, H, W, C) -> (B, H*W, C)
        input_x = tf.reshape(input_x, shape=(B, H * W, C))

        #   (B, H, W, IC) -> (B, H, W, 1)
        context_mask = self.conv_q_left(inputs)
        #   (B, H, W, 1) -> (B, H*W, 1)
        context_mask = tf.reshape(context_mask, shape=(B, H * W, 1))
        #   (B, H*W, 1) -> (B, H*W, 1)
        context_mask = self.softmax_left(context_mask)
        #   (B, C, H*W) 点乘 (B, H*W, 1) -> (B, C, 1)
        context = tf.matmul(a=tf.transpose(input_x, perm=[0, 2, 1]), b=context_mask)
        #   (B, C, 1) -> (B, C, 1, 1)
        context = tf.expand_dims(context, axis=-1)
        #   (B, C, 1, 1) -> (B, 1, 1, C)
        context = tf.transpose(context, perm=[0, 2, 3, 1])
        #   (B, 1, 1, C) -> (B, 1, 1, OC)
        context = self.conv_up_left(context)  # 恢复输入时的通道数
        #   (B, 1, 1, OC) -> (B, 1, 1, OC)
        mask_ch = self.sigmoid_left(context)

        out = inputs * mask_ch
        if self.data_format == 'channels_first':
            #   (B, H, W, C) -> (B, C, H, W)
            out = tf.transpose(out, [0, 3, 1, 2])

        return out

    def spatial_pool(self, inputs):
        if self.data_format == 'channels_first':
            inputs = tf.transpose(inputs, perm=[0, 2, 3, 1])  # (B, C, H, W) -> (B, H, W, C)
        #   (B, H, W, C) -> (B, H, W, C/2)
        g_x = self.conv_q_right(inputs)
        #   (B, H, W, C/2)-> (B, 1, 1, C/2)
        avg_x = self.global_pool(g_x)
        B, H, W, C = tf.shape(avg_x)
        #   (B, 1, 1, C/2) -> (B, 1, C/2)
        avg_x = tf.reshape(tensor=avg_x, shape=(B, H*W, C))

        #   (B, H, W, C) -> (B, H, W, C/2)
        g_v = self.conv_v_right(inputs)
        V_B, V_H, V_W, V_C = tf.shape(g_v)
        #   (B, H, W, C/2) -> (B, H*W, C/2)
        theta_x = tf.reshape(tensor=g_v, shape=(V_B, V_H*V_W, V_C))
        #   (B, 1, C/2) * (B, C/2, H*W) -> (B, 1, H*W)
        context = tf.matmul(avg_x, tf.transpose(a=theta_x, perm=[0, 2, 1]))
        #   (B, 1, H*W) -> (B, 1, H*W)
        context = self.softmax_right(context)   # 虽然论文中的图片，是avg_x先softmax，再点乘，但是代码中却是先点乘，再softmax
        #   (B, 1, H*W) -> (B, 1, H, W)
        context = tf.reshape(context, shape=(V_B, 1, V_H, V_W))
        #   (B, 1, H, W) -> (B, 1, H, W)
        context = self.sigmoid_right(context)
        #   (B, 1, H, W) -> (B, H, W, 1)
        context = tf.transpose(context, [0, 2, 3, 1])

        out = inputs * context
        if self.data_format == 'channels_first':
            out = tf.transpose(out, [0, 3, 1, 2])
        return out

    def call(self, inputs):
        #   空间注意
        context_spatial = self.spatial_pool(inputs)
        #   通道注意
        context_channel = self.channel_pool(inputs)

        out = context_spatial + context_channel
        return out


class PSA_s(tf.keras.Model):
    def __init__(self, planes, data_format='channels_last'):
        """
        :param planes:  输入的通道数
        :param data_format:  数据格式,默认为 channels_last， 可选 channels_first
        """
        super(PSA_s, self).__init__()
        self.data_format = data_format
        self.planes = planes
        self.out_planes = planes // 2
        ratio = 4

        self.conv_q_left = tf.keras.layers.Conv2D(filters=1, kernel_size=1, strides=1, padding='valid', use_bias=False)
        self.conv_v_left = tf.keras.layers.Conv2D(filters=self.out_planes, kernel_size=1, strides=1, padding='valid',
                                                  use_bias=False)

        self.conv_up_left = tf.keras.Sequential([
            tf.keras.layers.Conv2D(filters=self.out_planes//ratio, kernel_size=1, strides=1, padding='valid'),
            tf.keras.layers.LayerNormalization(),
            tf.keras.layers.Activation(tf.keras.activations.relu),
            tf.keras.layers.Conv2D(filters=self.planes, kernel_size=1, strides=1, padding='valid')
        ])

        self.softmax_left = tf.keras.layers.Activation(activation=tf.keras.activations.softmax)
        self.sigmoid_left = tf.keras.layers.Activation(activation=tf.keras.activations.sigmoid)

        self.conv_q_right = tf.keras.layers.Conv2D(filters=self.out_planes, kernel_size=1, strides=1, padding='valid',
                                                   use_bias=False)
        self.conv_v_right = tf.keras.layers.Conv2D(filters=self.out_planes, kernel_size=1, strides=1, padding='valid',
                                                   use_bias=False)
        self.global_pool = tf.keras.layers.GlobalAvgPool2D(keepdims=True)
        self.softmax_right = tf.keras.layers.Activation(activation=tf.keras.activations.softmax)
        self.sigmoid_right = tf.keras.layers.Activation(activation=tf.keras.activations.sigmoid)

    def reset_parameters(self):
        kaiming_init(self.conv_v_right)
        kaiming_init(self.conv_q_right)
        kaiming_init(self.conv_v_left)
        kaiming_init(self.conv_q_left)

    def channel_pool(self, inputs):
        if self.data_format == 'channels_first':
            inputs = tf.transpose(inputs, perm=[0, 2, 3, 1])  # (B, C, H, W) -> (B, H, W, C)

        #   (B, H, W, IC) -> (B, H, W, IC/2)
        input_x = self.conv_v_left(inputs)
        B, H, W, C = tf.shape(input_x)
        #   (B, H, W, C) -> (B, H*W, C)
        input_x = tf.reshape(input_x, shape=(B, H * W, C))

        #   (B, H, W, IC) -> (B, H, W, 1)
        context_mask = self.conv_q_left(inputs)
        #   (B, H, W, 1) -> (B, H*W, 1)
        context_mask = tf.reshape(context_mask, shape=(B, H * W, 1))
        #   (B, H*W, 1) -> (B, H*W, 1)
        context_mask = self.softmax_left(context_mask)
        #   (B, C, H*W) 点乘 (B, H*W, 1) -> (B, C, 1)
        context = tf.matmul(a=tf.transpose(input_x, perm=[0, 2, 1]), b=context_mask)
        #   (B, C, 1) -> (B, C, 1, 1)
        context = tf.expand_dims(context, axis=-1)
        #   (B, C, 1, 1) -> (B, 1, 1, C)
        context = tf.transpose(context, perm=[0, 2, 3, 1])

        #   (B, 1, 1, C) -> (B, 1, 1, OC)
        context = self.conv_up_left(context)  # 恢复输入时的通道数
        #   (B, 1, 1, OC) -> (B, 1, 1, OC)
        mask_ch = self.sigmoid_left(context)

        out = inputs * mask_ch
        if self.data_format == 'channels_first':
            #   (B, H, W, C) -> (B, C, H, W)
            out = tf.transpose(out, [0, 3, 1, 2])

        return out

    def spatial_pool(self, inputs):
        if self.data_format == 'channels_first':
            inputs = tf.transpose(inputs, perm=[0, 2, 3, 1])  # (B, C, H, W) -> (B, H, W, C)
        #   (B, H, W, C) -> (B, H, W, C/2)
        g_x = self.conv_q_right(inputs)
        #   (B, H, W, C/2)-> (B, 1, 1, C/2)
        avg_x = self.global_pool(g_x)
        B, H, W, C = tf.shape(avg_x)
        #   (B, 1, 1, C/2) -> (B, 1, C/2)
        avg_x = tf.reshape(tensor=avg_x, shape=(B, H * W, C))

        #   (B, H, W, C) -> (B, H, W, C/2)
        g_v = self.conv_v_right(inputs)
        V_B, V_H, V_W, V_C = tf.shape(g_v)
        #   (B, H, W, C/2) -> (B, H*W, C/2)
        theta_x = tf.reshape(tensor=g_v, shape=(V_B, V_H * V_W, V_C))
        #   (B, 1, C/2) * (B, C/2, H*W) -> (B, 1, H*W)
        context = tf.matmul(avg_x, tf.transpose(a=theta_x, perm=[0, 2, 1]))
        #   (B, 1, H*W) -> (B, 1, H*W)
        context = self.softmax_right(context)  # 虽然论文中的图片，是avg_x先softmax，再点乘，但是代码中却是先点乘，再softmax
        #   (B, 1, H*W) -> (B, 1, H, W)
        context = tf.reshape(context, shape=(V_B, 1, V_H, V_W))
        #   (B, 1, H, W) -> (B, 1, H, W)
        context = self.sigmoid_right(context)
        #   (B, 1, H, W) -> (B, H, W, 1)
        context = tf.transpose(context, [0, 2, 3, 1])

        out = inputs * context
        if self.data_format == 'channels_first':
            out = tf.transpose(out, [0, 3, 1, 2])
        return out

    def call(self, inputs):
        #   空间注意
        out = self.spatial_pool(inputs)
        #   通道注意
        out = self.channel_pool(out)

        return out


if __name__ == '__main__':
    a = tf.zeros(shape=(4, 224, 224, 16))
    psa_p = PSA_p(planes=16)(a)
    print("PSA_p output shape = {}".format(tf.shape(psa_p).numpy()))
    psa_s = PSA_s(planes=16)(a)
    print("PSA_s output shape = {}".format(tf.shape(psa_s).numpy()))

早起学习晚上搬砖
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
雷神雷达FMAC组件PSA2电源模块维修-论文
05-21
雷神雷达FMAC组件PSA2电源模块维修
PSA-Introductory-Architecture-Overview.pdf
11-21
PSA-Introductory-Architecture-Overview，是ARM公司发布的PSA安全架构平台的宣传性文档，主要对PSA架构层面做初步概括介绍
深度学习参数初始化（二）Kaiming初始化 含代码
热门推荐
xian0710830114的专栏
07-13 2万+
Xavier初始化在ReLU层表现不好，主要原因是relu层会将负数映射到0，影响整体方差。而且Xavier初始化方法适用的激活函数有限：要求关于0对称；线性。而ReLU激活函数并不满足这些条件，实验也可以验证Xavier初始化确实不适用于ReLU激活函数。所以何恺明在对此做了改进，提出Kaiming初始化，一开始主要应用于计算机视觉、卷积网络。...
KaimingInit论文的译读笔记
墨门
12-25 1854
Keywords: Kaiming KaimingInit 摘要 Rectified activation units (rectifiers)（即：整流激活单元，一般就是ReLU函数，因为在本文中Kaiming还提出了PReLU，所以他这里用的是“rectified activation unit”这个术语）在SOTA的神经网络中至关重要。在本文中，作者从两方面探究了针对图像分类的整流器神经网络。
kaiming_initialization的pytorch实现
开飞机的小毛驴儿
06-10 1286
转载自：https://gist.github.com/jojonki/be1e8af97dfa12c983446391c3640b68，本文只做个人记录学习使用，版权归原作者所有。 # https://github.com/pytorch/examples/blob/master/dcgan/main.py#L95-L102 def weights_init(m): classname = m.__class__.__name__ if classname.find('Conv') !
[十五]深度学习Pytorch-权值初始化(Xavier和Kaiming)
yanzhiwen2的博客
04-06 3580
深度学习Pytorch-权值初始化(Xavier和Kaiming)
kaiming_init 函数
qq_34425255的博客
04-17 203
总的来说,这些导入语句让我们可以在代码中直接使用 PyTorch 的神经网络层以及 MMCV 提供的一些有用的工具函数和模块。这有助于提高开发效率,并且可以利用这些成熟的库提供的功能来构建更加健壮的深度学习模型。这种初始化方法专门针对使用ReLU激活函数的神经网络设计,可以有效地解决深度神经网络在训练初期出现的梯度消失或爆炸的问题。MMCV 库将这种有效的初始化方法封装成了一个易用的函数,极大地方便了深度学习模型的开发和训练。这些导入语句都是很常见的 PyTorch 和 MMCV 库的用法。
PSA（位置太阳算法） - Objective- C_代码_下载
06-09
PSA（位置太阳算法）-Objective-C 该算法应该适用于 -2000 到 6000 ，不确定性为 +/-0.0003 度。 如何使用它？ PSAOCHeader.h考虑到您已将库添加到项目中，并且标头已正确定义，您必须导入文件。 使用PSAOCSPA...
PSA-Unit-1_zbus_psa_
09-29
"PSA-Unit-1.pdf" 文件很可能包含了关于Z Bus和Y Bus的详细理论介绍，以及如何构建和修改这两种模型的具体步骤。学习这部分内容，不仅可以帮助理解电力系统的内部运作机制，还能掌握解决实际工程问题的工具和方法。 ...
matlab代码sqrt-PSA-2D-Mode-Structure-Solver:求解器（MATLAB）来计算2D相敏放大器的模式结构。挤光
05-23
《MATLAB代码sqrt-PSA-2D-Mode-Structure-Solver：解析二维相敏放大器模式结构》 MATLAB是一种强大的编程环境，被广泛应用于数值计算、数据分析和算法开发。在光学工程领域，MATLAB代码常用于解决复杂的光场模拟...
第十七章 MMDetection3D解析系列八_权重初始化(车道线感知)
weixin_44302770的博客
10-17 207
基于 Pytorch 构建模型时，我们通常会选择 nn.Module 作为模型的基类，搭配使用 Pytorch 的初始化模块 torch.nn.init，完成模型的初始化。MMEngine 在此基础上抽象出基础模块（BaseModule）,让我们能够通过传参或配置文件来选择模型的初始化方式。假设我们定义了模型类 ToyNet，它继承自模块基类（BaseModule）。
tensorflow2中tensorflow.keras.layers.Activation函数使用方法
qq_52095705的博客
06-01 2300
简单来说这个函数就是神经网络层的激活函数层。 下面让我们看看这个函数定义： tf.keras.layers.Activation( activation, **kwargs ) 其中参数activation就是用来指定激活函数。可以是两种形式，例如使用rule。示例如下： layer = tf.keras.layers.Activation('relu') output = layer([-3.0, -1.0, 0.0, 2.0]) list(output.numpy()) layer .
空间金字塔池化 spatial_pyramid_pooling
LeeJiangLee的博客
02-21 623
如图所示，空间金字塔池化可以接受任意大小(arbitrary size)的feature maps, 将其分成固定的块（图中分别有4x4, 2x2, 1x1块）取块内的最大值。作为输出值。最后将这三组连接在一起，有固定的输出size：(16+4+1)x256 ...
EPSANet：金字塔切分注意力网络，有效的即插即用炼丹模块【原理讲解及代码！！！】
最新发布
xiaoh_7的博客
04-23 1401
EPSANet是一种创新的深度学习网络，其金字塔切分注意力模块能够高效处理多尺度空间信息，建立长期通道依赖关系。与现有技术相比，EPSANet显著提升了模型性能，同时在计算参数量上实现高效性。该网络即插即用，为计算机视觉任务提供强大解决方案。
霸榜COCO和Cityscapes！南理工&CMU提出极化自注意力，更精细的双重注意力建模结构
极市平台的技术博客
07-15 2179
作者丨小马 编辑丨极市平台 【写在前面】 注意力机制是一个被广泛应用在各种CV任务中的方法。注意力机制根据施加的维度大致可以分为两类：通道注意力和空间注意力。对于通道注意力机制，代表性的工作有SENet[2]、ECANet[3]；对于空间注意力机制，代表性的工作有Self-Attention[4]。随着空间和通道注意力机制的提出，很自然的，结合空间和通道两个维度的双重注意力机制也被提出，代表工作有CBAM[1]，DANet[5]。 基于双重注意力机制，本文针对Pixel-wise regression的任务
2021刷新COCO和Cityscapes | Polarized Self-Attention：极化自注意力机制（keras实现）
u011447962的博客
08-03 3377
Polarized Self-Attention: Towards High-quality Pixel-wise Regression paper:https://arxiv.org/pdf/2107.00782.pdf code:https://github.com/DeLightCMU/PSA def _PSA(x, mode='p'): context_channel = spatial_pool(x, mode) if mode == 'p': con...
简明的 Tensorflow 2 代码示例
lingtianyulong的专栏
06-13 838
通过模型类的方式实现线性模型 y_pred = a * X + b，代码如下： import tensorflow as tf x = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) print(x.shape) y = tf.constant([[10.0], [20.0]]) print(y.shape) class Linear(tf.keras.Model): def __init__(self): super()._
使用torch实现神经网络的一些结构
Abo_luo的博客
06-05 274
使用torch实现神经网络的一些结构前言一、空间池化（自定义）二、残差学习block三、FPN总结 有时间会长期更新，主要是练一练自己的代码 前言 在学习深度学习 用于目标检测领域当中很多时候需要自己去修改代码而不是仅仅Git别人的repository，经过这么长时间来自己几乎都是对着书本或者网上的一些资源来敲代码，因此迫切的想独立的写一些经典的结构，因此这篇文章来了。 一、空间池化（自定义） class spatial_pool(nn.Module): def __init__(self,ke
学习注意力机制【1】
weixin_63016274的博客
03-15 1864
注意力机制学习
psa注意力机制代码
11-09
是使用PyTorch实现的PSA极化自注意力机制的代码： ```python import torch import torch.nn as nn import torch.nn.functional as F class PSA(nn.Module): def __init__(self, in_channels, reduction=8): super(PSA, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.conv1 = nn.Conv2d(in_channels, in_channels // reduction, kernel_size=1, stride=1, padding=0) self.conv2 = nn.Conv2d(in_channels // reduction, in_channels, kernel_size=1, stride=1, padding=0) self.sigmoid = nn.Sigmoid() def forward(self, x): b, c, _, _ = x.size() y = self.avg_pool(x) y = self.conv1(y) y = F.relu(y) y = self.conv2(y) y = self.sigmoid(y) return x * y.expand_as(x) ``` 其中，`in_channels`表示输入的通道数，`reduction`表示压缩比例，即将输入通道数压缩为原来的1/reduction。在`forward`函数中，首先使用自适应平均池化层对输入进行全局平均池化，然后通过两个卷积层和一个Sigmoid函数得到注意力权重，最后将输入和注意力权重相乘得到输出。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

早起学习晚上搬砖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值