Attention,注意力机制

news2024/11/16 13:26:49

在机器视觉任务中，每一张图片都有重点区域，而非每一个像素对模型理解图片都同等重要。
在自然语言处理任务中，每一段文字都有重点词语，而非每一个字对模型理解语句都同等重要。
如此，在神经网络模型中引入注意力，让模型把握重点，必是能提升模型的理解能力的！

SE模块

SE（Squeeze-and-Excitation：压缩与激活）模块：通过卷积操作将特征图压缩成11C的通道注意力向量，在将该注意力向量作用到之前的特征图。

在这里插入图片描述

import torch.nn as 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)
    
a = torch.randn(1,8,64,64)
SE = SELayer(8)
print(SE(a).shape)

CBAM模块

CBAM（Convolutional Block Attention Module：卷积注意力）模块：首先经过一个通道注意力模块，之后再经过一个空间注意力模块。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

其中通道注意力模块便是一个SE模块；空间注意力模块是将经过通道注意力加权后的特征图与其经卷积操作获得的空间注意力向量进行乘法运算。

import torch
import math
import torch.nn as nn
import torch.nn.functional as F
#基础的卷积模块 由卷积层+BN+激活函数
class BasicConv(nn.Module):
    def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, dilation=1, groups=1, relu=True, bn=True, bias=False):
        super(BasicConv, self).__init__()
        self.out_channels = out_planes
        self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=bias)
        self.bn = nn.BatchNorm2d(out_planes,eps=1e-5, momentum=0.01, affine=True) if bn else None
        self.relu = nn.ReLU() if relu else None

    def forward(self, x):
        x = self.conv(x)
        if self.bn is not None:
            x = self.bn(x)
        if self.relu is not None:
            x = self.relu(x)
        return x
#展平层
class Flatten(nn.Module):
    def forward(self, x):
        return x.view(x.size(0), -1)
#通道注意
class ChannelGate(nn.Module):
    def __init__(self, gate_channels, reduction_ratio=16, pool_types=['avg', 'max']):
        super(ChannelGate, self).__init__()
        self.gate_channels = gate_channels
        self.mlp = nn.Sequential(
            Flatten(),
            nn.Linear(gate_channels, gate_channels // reduction_ratio),
            nn.ReLU(),
            nn.Linear(gate_channels // reduction_ratio, gate_channels)
            )
        self.pool_types = pool_types
    def forward(self, x):
        channel_att_sum = None
        for pool_type in self.pool_types:
            if pool_type=='avg':
                avg_pool = F.avg_pool2d( x, (x.size(2), x.size(3)), stride=(x.size(2), x.size(3)))
                channel_att_raw = self.mlp( avg_pool )
            elif pool_type=='max':
                max_pool = F.max_pool2d( x, (x.size(2), x.size(3)), stride=(x.size(2), x.size(3)))
                channel_att_raw = self.mlp( max_pool )
            elif pool_type=='lp':
                lp_pool = F.lp_pool2d( x, 2, (x.size(2), x.size(3)), stride=(x.size(2), x.size(3)))
                channel_att_raw = self.mlp( lp_pool )
            elif pool_type=='lse':
                # LSE pool only
                lse_pool = logsumexp_2d(x)
                channel_att_raw = self.mlp( lse_pool )

            if channel_att_sum is None:
                channel_att_sum = channel_att_raw
            else:
                channel_att_sum = channel_att_sum + channel_att_raw

        scale = F.sigmoid( channel_att_sum ).unsqueeze(2).unsqueeze(3).expand_as(x)
        return x * scale

def logsumexp_2d(tensor):
    tensor_flatten = tensor.view(tensor.size(0), tensor.size(1), -1)
    s, _ = torch.max(tensor_flatten, dim=2, keepdim=True)
    outputs = s + (tensor_flatten - s).exp().sum(dim=2, keepdim=True).log()
    return outputs

class ChannelPool(nn.Module):
    def forward(self, x):
        return torch.cat( (torch.max(x,1)[0].unsqueeze(1), torch.mean(x,1).unsqueeze(1)), dim=1 )
#空间注意力部分
class SpatialGate(nn.Module):
    def __init__(self):
        super(SpatialGate, self).__init__()
        kernel_size = 7
        self.compress = ChannelPool()
        self.spatial = BasicConv(2, 1, kernel_size, stride=1, padding=(kernel_size-1) // 2, relu=False)
    def forward(self, x):
        x_compress = self.compress(x)
        x_out = self.spatial(x_compress)
        scale = F.sigmoid(x_out) # broadcasting
        return x * scale

class CBAM(nn.Module):
    def __init__(self, gate_channels, reduction_ratio=16, pool_types=['avg', 'max'], no_spatial=False):
        super(CBAM, self).__init__()
        self.ChannelGate = ChannelGate(gate_channels, reduction_ratio, pool_types)
        self.no_spatial=no_spatial
        if not no_spatial:
            self.SpatialGate = SpatialGate()
    def forward(self, x):
        x_out = self.ChannelGate(x)
        if not self.no_spatial:
            x_out = self.SpatialGate(x_out)
        return x_out

a = torch.randn(1,8,16,16)
cbam = CBAM(8)
print(cbam(a).shape)

ECA模块

ECA（Effificient Channel Attention：高效通道注意力）模块：其与SE模块唯一的区别就在于：没有将通道注意力向量压缩后再放大的全连接层，而是之间将其与特征图进行加权运算。

在这里插入图片描述

import torch
import torch.nn
from torch.nn.parameter import Parameter

class eca_layer(nn.Module):
    def __init__(self, channel, k_size=3):
        super(eca_layer, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.conv = nn.Conv1d(1, 1, kernel_size=k_size, padding=(k_size - 1) // 2, bias=False) 
        self.sigmoid = nn.Sigmoid()
    def forward(self, x):
        y = self.avg_pool(x)
        y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)
        y = self.sigmoid(y)
        return x * y.expand_as(x)
        

a = torch.randn(1,4,32,32)
eca = eca_layer(8)
print(eca(a).shape)

Non- Local模块

Non-Local（非全局）模块

在这里插入图片描述

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

class NonLocal(nn.Module):
    def __init__(self,in_channels,inter_channels=None,dimension=3,sub_sample=True,bn_layer=True):
        super(NonLocal,self).__init__()
        assert dimension in [1,2,3]
        self.dimension = dimension
        self.sub_sample = sub_sample
        self.in_channels = in_channels
        self.inter_channels = inter_channels
        if self.inter_channels is None:
            self.inter_channels = in_channels // 2
            if self.inter_channels == 0:
                self.inter_channels = 1
        if dimension == 3:
            conv_nd = nn.Conv3d
            max_pool_layer = nn.MaxPool3d(kernel_size=(1,2,2))
            bn = nn.BatchNorm3d
        elif dimension == 2:
            conv_nd = nn.Conv2d
            max_pool_layer = nn.MaxPool2d(kernel_size=(2,2))
            bn = nn.BatchNorm2d
        else:
            conv_nd = nn.Conv1d
            max_pool_layer = nn.MaxPool(kernel_size=(2))
            bn = nn.BatchNorm1d
        self.g = conv_nd(in_channels=self.in_channels,out_channels=self.inter_channels,kernel_size=1,stride=1,padding=0)
        if bn_layer:
            self.W = nn.Sequential(conv_nd(in_channels=self.inter_channels,out_channels=self.in_channels,kernel_size=1,stride=1,padding=0),bn(self.in_channels))
            nn.init.constant_(self.W[1].weight,0)
            nn.init.constant_(self.W[1].bias,0)
        else:
            self.W = conv_nd(in_channels=self.inter_channels,out_channels=self.in_channels,kernel_size=1,stride=1,padding=0)
            nn.init.constant_(self.W[1].weight,0)
            nn.inti.constant_(self.W[1].bias,0)
        self.theta = conv_nd(in_channels=self.in_channels,out_channels=self.inter_channels,kernel_size=1,stride=1,padding=0)
        self.phi = conv_nd(in_channels=self.in_channels,out_channels=self.inter_channels,kernel_size=1,stride=1,padding=0)
        if sub_sample:
            self.g = nn.Sequential(self.g,max_pool_layer)
            self.phi = nn.Sequential(self.phi,max_pool_layer)
    def forward(self,x):
        batch_size = x.size(0)
        g_x = self.g(x).view(batch_size,self.inter_channels,-1)
        g_x = g_x.permute(0,2,1)
        
        theta_x = self.theta(x).view(batch_size,self.inter_channels,-1)
        theta_x = theta_x.permute(0,2,1)
        
        phi_x = self.phi(x).view(batch_size,self.inter_channels,-1)
        
        f = torch.matmul(theta_x,phi_x)
        print(f.shape)
        
        f_div_C = F.softmax(f,dim=-1)
        y = torch.matmul(f_div_C,g_x)
        y = y.permute(0,2,1).contiguous()
        y = y.view(batch_size,self.inter_channels,*x.size()[2:])
        W_y = self.W(y)
        z = W_y + x
        return z
    

a = torch.randn(1,6,6,32,32)
no = NonLocal(6)
print(no(a).shape)

GC模块

GC（Global Context：全局纹理）模块：

在这里插入图片描述

from __future__ import absolute_import
import torch
from torch import nn
from mmcv.cnn import constant_init, kaiming_init
import math

def last_zero_init(m):
    if isinstance(m, nn.Sequential):
        constant_init(m[-1], val=0)
        m[-1].inited = True
    else:
        constant_init(m, val=0)
        m.inited = True
        
class ContextBlock2d(nn.Module):
    def __init__(self, inplanes, planes, pool, fusions):
        super(ContextBlock2d, self).__init__()
        assert pool in ['avg', 'att']
        assert all([f in ['channel_add', 'channel_mul'] for f in fusions])
        assert len(fusions) > 0, 'at least one fusion should be used'
        self.inplanes = inplanes
        self.planes = planes
        self.pool = pool
        self.fusions = fusions
        if 'att' in pool:
            self.conv_mask = nn.Conv2d(inplanes, 1, kernel_size=1)
            self.softmax = nn.Softmax(dim=2)
        else:
            self.avg_pool = nn.AdaptiveAvgPool2d(1)
        if 'channel_add' in fusions:
            self.channel_add_conv = nn.Sequential(
                nn.Conv2d(self.inplanes, self.planes, kernel_size=1),
                nn.LayerNorm([self.planes, 1, 1]),
                nn.ReLU(inplace=True),
                nn.Conv2d(self.planes, self.inplanes, kernel_size=1)
            )
        else:
            self.channel_add_conv = None
        if 'channel_mul' in fusions:
            self.channel_mul_conv = nn.Sequential(
                nn.Conv2d(self.inplanes, self.planes, kernel_size=1),
                nn.LayerNorm([self.planes, 1, 1]),
                nn.ReLU(inplace=True),
                nn.Conv2d(self.planes, self.inplanes, kernel_size=1)
            )
        else:
            self.channel_mul_conv = None
        self.reset_parameters()

    def reset_parameters(self):
        if self.pool == 'att':
            kaiming_init(self.conv_mask, mode='fan_in')
            self.conv_mask.inited = True

        if self.channel_add_conv is not None:
            last_zero_init(self.channel_add_conv)
        if self.channel_mul_conv is not None:
            last_zero_init(self.channel_mul_conv)

    def spatial_pool(self, x):
        batch, channel, height, width = x.size()
        if self.pool == 'att':
            input_x = x
            # [N, C, H * W]
            input_x = input_x.view(batch, channel, height * width)
            # [N, 1, C, H * W]
            input_x = input_x.unsqueeze(1)
            # [N, 1, H, W]
            context_mask = self.conv_mask(x)
            # [N, 1, H * W]
            context_mask = context_mask.view(batch, 1, height * width)
            # [N, 1, H * W]
            context_mask = self.softmax(context_mask)
            # [N, 1, H * W, 1]
            context_mask = context_mask.unsqueeze(3)
            # [N, 1, C, 1]
            # 汇集全文的信息 对应的像素点进行匹配，整个图像的像素点全部相加
            context = torch.matmul(input_x, context_mask)
            # [N, C, 1, 1]
            context = context.view(batch, channel, 1, 1)
        else:
            # [N, C, 1, 1]
            context = self.avg_pool(x)
        return context

    def forward(self, x):
        # [N, C, 1, 1]
        context = self.spatial_pool(x)
        if self.channel_mul_conv is not None:
            # [N, C, 1, 1]
            channel_mul_term = torch.sigmoid(self.channel_mul_conv(context))
            out = x * channel_mul_term
        else:
            out = x
        if self.channel_add_conv is not None:
            # [N, C, 1, 1]
            channel_add_term = self.channel_add_conv(context)
            out = out + channel_add_term
        return out


if __name__ == "__main__":
    inputs = torch.randn(1,16,300,300)
    block = ContextBlock2d(16,4,"att",["channel_add"])
    out = block(inputs)
    print(out.size())

SimAM模块

SimAM模块：受SE模块和CBAM模块启发，SimAM模块直接通过公式计算出CHW的三维注意力矩阵的解析解。

在这里插入图片描述

import torch
import torch.nn as nn

class SimAM_module(torch.nn.Module):
    def __init__(self,channels=None,e_lambda=1e-4):
        super(SimAM_module,self).__init__()
        self.activation = nn.Sigmoid()
        self.e_lambda = e_lambda
    def __repr__(self):
        s = self.__class__.__name__ + '('
        s += ('lambad=%f)'%self.e_lambda)
        return s
    @staticmethod
    def get_module_name():
        return 'simam'
    def forward(self,x):
        b,c,h,w = x.size()
        n = w * h - 1
        x_minus_mu_square = (x - x.mean(dim=[2,3],keepdim=True)).pow(2)
        y = x_minus_mu_square / (4 * (x_minus_mu_square.sum(dim=[2,3],keepdim=True) / n + self.e_lambda)) + 0.5
        return x * self.activation(y)
    
class Bottleneck_SimAM(nn.Module):
    def __init__(self,c1,c2,shortcut=True,g=1,e=0.5):
        super(Bottleneck_SimAM,self).__init__()
        c_ = int(c2*e)
        self.cv1 = Conv(c1,c_,1,1)
        self.cv2 = Conv(c_,c2,3,1,g=g)
        self.add = shortcut and c1 == c2
        self.attention = SimAM_module(channels=c2)
    def forward(self,x):
        return x + self.attention(self.cv2(self.cv1(x))) if self.add else self.cv2(self.cv1(x))
    
a = torch.randn(1,4,32,32)
sim = SimAM_module()
print(sim(a).shape)

CASR模块

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/734810.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

做投票小程序线上投票制作制作图片投票链接如何做投票小程序

做投票小程序线上投票制作制作图片投票链接如何做投票小程序

小程序投票活动如何做？很多企业在运营当中，都会通过投票活动来进行推广，从而达到吸粉、增加用户粘度等效果。而此类投票活动，通过小程序就可以实现，操作简单。 我们现在要以“时尚新态度”为主题进行一次投票活动&…
阅读更多...
WiFi 时钟+本地温度

WiFi 时钟+本地温度

[ WiFi 时钟 ] [ WiFi 天气时钟 ] [ WiFi 时钟本地温度 ] 夏天到了，显示器上放一个时钟，顺便实时测量本地室温，看看空调工作是否正常也算是个实用制作。 用到零件共 4 个： 400孔面包板 （ 大号…
阅读更多...
docker配置nacos

docker配置nacos

1 拉取nacos镜像并启动 docker pull nacos/nacos-server 2 启动nacos命令 docker run -d --name nacos -p 8848:8848 -e PREFER_HOST_MODEhostname -e MODEstandalone nacos/nacos-server 至此，我们已经可以使用nacos服务，UI地址:http://:8848/nacos …
阅读更多...
计算机体系结构基础知识介绍之高级分支预测（二）

计算机体系结构基础知识介绍之高级分支预测（二）

一、标记混合预测器 分支预测的目的是根据历史信息来预测分支指令的跳转方向和目标地址，从而提高流水线的效率。不同的分支预测方法有不同的优缺点，因此有人提出了一种将多种预测方法结合起来的方案，混合预测器。这种方案可以根据不同的分支…
阅读更多...
适合Docker的场景以及不适合的场景

适合Docker的场景以及不适合的场景

文章来自：When to use and when not to use Docker和7 Cases When You Should Not Use Docker，以及互联网网上的一些零散内容。这篇文章只是基于我自己的理解，进行简单的概述。 适合的场景 你的团队不是一成不变的。 当有新的成员加入&#…
阅读更多...
写作技巧：如何让你的文章充满生命力？

写作技巧：如何让你的文章充满生命力？

在写作中，让文章充满生命力是很重要的一点。如果一篇文章缺乏生命力，那么读者很难被吸引，也很难从中获得任何收获。那么，如何让你的文章充满生命力呢？ 以下是几个建议： 1.真实感情：写作的时候要…
阅读更多...
Django_视图中的request对象详解（八）

Django_视图中的request对象详解（八）

目录 Request 属性 方法 QueryDict 源码等资料获取方法 Request 当URLconf文件匹配到用户输入的路径后，会调用对应的view函数，并创建一个包含请求元数据的 HttpRequest 对象 传入该函数的第一个参数，常用request表示。 HttpRequest实…
阅读更多...
为什么要学习使用C++软件常用分析工具？学会这些工具都有哪些好处？

为什么要学习使用C++软件常用分析工具？学会这些工具都有哪些好处？

目录 1、为什么要学习使用C软件常用分析工具？ 2、C常用分析工具有哪些？都能处理哪些具体的问题？ 2.1、SPY 2.2、Dependency Walker 2.3、GDIView 2.4、Process Explorer 2.5、Process Monitor 2.6、调试器Windbg 2.7、反汇编工具IDA…
阅读更多...
Android 13 startActivity报错ActivityNotFoundException

Android 13 startActivity报错ActivityNotFoundException

最近遇到一个问题，就是在google pixel 4（android 13）的手机上startactivity的时候报错activity找不到，其他非13的是好的，这里对问题进行记录： 查阅google官方的文档，有这么一段话， …
阅读更多...
前端mock数据的几种方式

前端mock数据的几种方式

前端mock数据的几种方式 前端在开发具体需求前，后端往往只提供接口文档，对于前端来说，最简单的方式就是把想要的数据写死在代码里进行开发，但这样的坏处就是和后端联调前还需要再把写死的数据从代码里删除，最好的方式…
阅读更多...
开发中易犯错的事务问题

开发中易犯错的事务问题

1.不指定rollbackFor 使用spring的声明式事务（即Transactional注解）时，如果不指定rollbackFor，那么当程序发生Error时，事务将不会回滚！！！显然这将导致数据不一致！ 如下述…
阅读更多...
spring8-getBean（）方法使用

spring8-getBean（）方法使用

；：getBean使用，要传数据，一个是字符串， 就是文件里的UserService 而这里的UserService就是我们配置文件的id：，第一个API 第二个API可以传入一个字节码类型。 如果某一个容器存在多个&#xff…
阅读更多...
windows系统如何部署nacos

windows系统如何部署nacos

1.安装nacos 去nacos github下载nacos最新稳定版本，我用的是nacos-server-2.2.3.zip，下载后解压 2.创建数据库 启动mysql，创建数据库nacos，数据库名字是从conf/application.properties文件获得的 把db这三行取消注释&#xff…
阅读更多...
【Hello mysql】 mysql的约束

【Hello mysql】 mysql的约束

Mysql专栏：Mysql 本篇博客简介：介绍mysql的约束 mysql的约束 表的约束空属性默认值列描述zerofill主键自增长唯一键外键总结 表的约束 为什么要有约束？ 我们在收集一些数据的时候会要求该数据必须存在 比如说像是国家在登记公民信息的时候身…
阅读更多...
实验二 常用网络命令

实验二 常用网络命令

实验目的 了解常用网络命令及其使用方法。通过网络命令了解网络状态，并利用网络命令对网络进行简单的操作。 实验原理 1. 通过 ping 命令检测网络故障 （1）命令格式： ping [-t] [-a] [-n count] [-l size] [-f] [-i TTL] [-v T…
阅读更多...
conic-gradient

conic-gradient

The conic-gradient() CSS function creates an image consisting of a gradient with color transitions rotated around a center point conic-gradient方法创建了一个由围绕中心点旋转渐变组成的图片 background: conic-gradient( red 6deg, orange 6deg 18deg, yellow…
阅读更多...
位图｜布隆过滤器模拟实现｜STL源码剖析系列｜手撕STL

位图｜布隆过滤器模拟实现｜STL源码剖析系列｜手撕STL

今天博主给大家带来位图和布隆过滤器的模拟实现。 前言 那么这里博主先安利一下一些干货满满的专栏啦！ 手撕数据结构https://blog.csdn.net/yu_cblog/category_11490888.html?spm1001.2014.3001.5482这里包含了博主很多的数据结构学习上的总结，每一篇…
阅读更多...
并发编程 - 利用Event Bus模式实现目录文件变化捕捉

并发编程 - 利用Event Bus模式实现目录文件变化捕捉

文章目录 Pre需求CodeDirectoryTargetMonitorFileChangeEventFileChangeListener测试 Pre 并发编程 - Event Bus 设计模式 需求 JDK自1.7版本后提供了WatchService类，该类可以基于事件通知的方式监控文件或者目录的任何变化，文件的改变相当于每一个事件…
阅读更多...
Java继承和多态

Java继承和多态

文章目录 继承继承概念继承的语法 super关键字super和this继承方式多态多态的概念多态实现条件 重写重写和重载的区别 继承 Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，事物之间可能会…
阅读更多...
Linux 内核级通用内存池 —— kmalloc 体系

Linux 内核级通用内存池 —— kmalloc 体系

目录 kmalloc 内存池中都有哪些尺寸的内存块 kmalloc 内存池如何选取合适尺寸的内存块 kmalloc 内存池的整体架构 KMALLOC_RECLAIM 表示需要分配可以被回收的内存，RECLAIM 类型的内存页，不能移动，但是可以直接回收，比如文件缓存页…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023