各种注意力机制PyTorch实现

最新推荐文章于 2025-05-12 16:43:29 发布
最新推荐文章于 2025-05-12 16:43:29 发布
阅读量7.8k 收藏 106
点赞数 11
CC 4.0 BY-SA版权
文章标签： pytorch 深度学习 自然语言处理
原文链接：https://blog.youkuaiyun.com/zandaoguang/article/details/117757532
这篇博客汇总了多种注意力机制的PyTorch实现，包括外部注意力、自注意力、简化的自注意力、Squeeze-and-Excitation、Selective Kernel、CBAM、BAM、ECA等。同时，还介绍了RepMLP、MLP-Mixer、ResMLP和gMLP等高效多头自注意力模型。这些实现涵盖了从图像识别到场景理解的多个视觉任务。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

给出了整个系列的PyTorch的代码实现，以及使用方法。

各种注意力机制
Pytorch implementation of “Beyond Self-attention: External Attention using Two Linear Layers for Visual Tasks—arXiv 2020.05.05”

Pytorch implementation of “Attention Is All You Need—NIPS2017”

Pytorch implementation of “Squeeze-and-Excitation Networks—CVPR2018”

Pytorch implementation of “Selective Kernel Networks—CVPR2019”

Pytorch implementation of “CBAM: Convolutional Block Attention Module—ECCV2018”

Pytorch implementation of “BAM: Bottleneck Attention Module—BMCV2018”

Pytorch implementation of “ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks—CVPR2020”

Pytorch implementation of “Dual Attention Network for Scene Segmentation—CVPR2019”

Pytorch implementation of “EPSANet: An Efficient Pyramid Split Attention Block on Convolutional Neural Network—arXiv 2020.05.30”

Pytorch implementation of “ResT: An Efficient Transformer for Visual Recognition—arXiv 2020.05.28”

  1. 外部注意力
    1.1. 论文
    “Beyond Self-attention: External Attention using Two Linear Layers for Visual Tasks”

1.2. 概要

在这里插入图片描述
1.3. 代码

from attention.ExternalAttention import ExternalAttention
import torch
 
input=torch.randn(50,49,512)
ea = ExternalAttention(d_model=512,S=8)
output=ea(input)
print(output.shape)
  1. 自注意力
    2.1. 论文
    “Attention Is All You Need”

1.2. 概要

在这里插入图片描述
1.3. 代码

from attention.SelfAttention import ScaledDotProductAttention
import torch
 
input=torch.randn(50,49,512)
sa = ScaledDotProductAttention(d_model=512, d_k=512, d_v=512, h=8)
output=sa(input,input,input)
print(output.shape)
  1. 简化的自注意力
    3.1. 论文
    None

3.2. 概要

在这里插入图片描述
3.3. 代码

from attention.SimplifiedSelfAttention import SimplifiedScaledDotProductAttention
import torch
 
input=torch.randn(50,49,512)
ssa = SimplifiedScaledDotProductAttention(d_model=512, h=8)
output=ssa(input,input,input)
print(output.shape)
  1. Squeeze-and-Excitation 注意力
    4.1. 论文
    “Squeeze-and-Excitation Networks”

4.2. 概要

在这里插入图片描述
4.3. 代码

from attention.SEAttention import SEAttention
import torch
 
input=torch.randn(50,512,7,7)
se = SEAttention(channel=512,reduction=8)
output=se(input)
print(output.shape)
  1. SK 注意力
    5.1. 论文
    “Selective Kernel Networks”

5.2. 概要

在这里插入图片描述
5.3. 代码

from attention.SKAttention import SKAttention
import torch
 
input=torch.randn(50,512,7,7)
se = SKAttention(channel=512,reduction=8)
output=se(input)
print(output.shape)
  1. CBAM 注意力
    6.1. 论文
    “CBAM: Convolutional Block Attention Module”

6.2. 概要

在这里插入图片描述
在这里插入图片描述
6.3. 代码

from attention.CBAM import CBAMBlock
import torch
 
input=torch.randn(50,512,7,7)
kernel_size=input.shape[2]
cbam = CBAMBlock(channel=512,reduction=16,kernel_size=kernel_size)
output=cbam(input)
print(output.shape)
  1. BAM 注意力
    7.1. 论文
    “BAM: Bottleneck Attention Module”

7.2. 概要

在这里插入图片描述
7.3. 代码

from attention.BAM import BAMBlock
import torch
 
input=torch.randn(50,512,7,7)
bam = BAMBlock(channel=512,reduction=16,dia_val=2)
output=bam(input)
print(output.shape)
  1. ECA 注意力
    8.1. 论文
    “ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks”

8.2. 概要

在这里插入图片描述
8.3. Code

from attention.ECAAttention import ECAAttention
import torch
 
input=torch.randn(50,512,7,7)
eca = ECAAttention(kernel_size=3)
output=eca(input)
print(output.shape)
  1. DANet 注意力
    9.1. 论文
    “Dual Attention Network for Scene Segmentation”

9.2. 概要

在这里插入图片描述
9.3. 代码

from attention.DANet import DAModule
import torch
 
if __name__ == '__main__':
    input=torch.randn(50,512,7,7)
    danet=DAModule(d_model=512,kernel_size=3,H=7,W=7)
    print(danet(input).shape)
  1. 金字塔拆分注意力
    10.1. 论文
    “EPSANet: An Efficient Pyramid Split Attention Block on Convolutional Neural Network”

10.2. 概要

在这里插入图片描述
10.3. 代码

from attention.PSA import PSA
import torch
 
if __name__ == '__main__':
    input=torch.randn(50,512,7,7)
    psa = PSA(channel=512,reduction=8)
    output=psa(input)
    print(output.shape)
  1. 高效多头自注意力
    11.1. 论文
    “ResT: An Efficient Transformer for Visual Recognition”

11.2. 概要

在这里插入图片描述
11.3. 代码

from attention.EMSA import EMSA
import torch
from torch import nn
from torch.nn import functional as F
 
if __name__ == '__main__':
    input=torch.randn(50,64,512)
    emsa = EMSA(d_model=512, d_k=512, d_v=512, h=8,H=8,W=8,ratio=2,apply_transform=True)
    output=emsa(input,input,input)
    print(output.shape)

MLP 系列
Pytorch implementation of “RepMLP: Re-parameterizing Convolutions into Fully-connected Layers for Image Recognition—arXiv 2020.05.05”

Pytorch implementation of “MLP-Mixer: An all-MLP Architecture for Vision—arXiv 2020.05.17”

Pytorch implementation of “ResMLP: Feedforward networks for image classification with data-efficient training—arXiv 2020.05.07”

Pytorch implementation of “Pay Attention to MLPs—arXiv 2020.05.17”

  1. RepMLP
    1.1. 论文
    “RepMLP: Re-parameterizing Convolutions into Fully-connected Layers for Image Recognition”

1.2. 概要

在这里插入图片描述
1.3. 代码

from mlp.repmlp import RepMLP
import torch
from torch import nn
 
N=4 #batch size
C=512 #input dim
O=1024 #output dim
H=14 #image height
W=14 #image width
h=7 #patch height
w=7 #patch width
fc1_fc2_reduction=1 #reduction ratio
fc3_groups=8 # groups
repconv_kernels=[1,3,5,7] #kernel list
repmlp=RepMLP(C,O,H,W,h,w,fc1_fc2_reduction,fc3_groups,repconv_kernels=repconv_kernels)
x=torch.randn(N,C,H,W)
repmlp.eval()
for module in repmlp.modules():
    if isinstance(module, nn.BatchNorm2d) or isinstance(module, nn.BatchNorm1d):
        nn.init.uniform_(module.running_mean, 0, 0.1)
        nn.init.uniform_(module.running_var, 0, 0.1)
        nn.init.uniform_(module.weight, 0, 0.1)
        nn.init.uniform_(module.bias, 0, 0.1)
 
#training result
out=repmlp(x)
#inference result
repmlp.switch_to_deploy()
deployout = repmlp(x)
 
print(((deployout-out)**2).sum())
  1. MLP-Mixer
    2.1. 论文
    “MLP-Mixer: An all-MLP Architecture for Vision”

2.2. 概要

在这里插入图片描述
2.3. 代码

from mlp.mlp_mixer import MlpMixer
import torch
mlp_mixer=MlpMixer(num_classes=1000,num_blocks=10,patch_size=10,tokens_hidden_dim=32,channels_hidden_dim=1024,tokens_mlp_dim=16,channels_mlp_dim=1024)
input=torch.randn(50,3,40,40)
output=mlp_mixer(input)
print(output.shape)
  1. ResMLP
    3.1. 论文
    “ResMLP: Feedforward networks for image classification with data-efficient training”

3.2. 概要

在这里插入图片描述
3.3. 代码

from mlp.resmlp import ResMLP
import torch
 
input=torch.randn(50,3,14,14)
resmlp=ResMLP(dim=128,image_size=14,patch_size=7,class_num=1000)
out=resmlp(input)
print(out.shape) #the last dimention is class_num
  1. gMLP
    4.1. 论文
    “Pay Attention to MLPs”

4.2. 概要
在这里插入图片描述
4.3. 代码

from mlp.g_mlp import gMLP
import torch
 
num_tokens=10000
bs=50
len_sen=49
num_layers=6
input=torch.randint(num_tokens,(bs,len_sen)) #bs,len_sen
gmlp = gMLP(num_tokens=num_tokens,len_sen=len_sen,dim=512,d_ff=1024)
output=gmlp(input)
print(output.shape)

Re-Parameter 系列
Pytorch implementation of “RepVGG: Making VGG-style ConvNets Great Again—CVPR2021”

Pytorch implementation of “ACNet: Strengthening the Kernel Skeletons for Powerful CNN via Asymmetric Convolution Blocks—ICCV2019”

  1. RepVGG
    1.1. 论文
    “RepVGG: Making VGG-style ConvNets Great Again”

1.2. 概要

在这里插入图片描述
1.3. 代码

from rep.repvgg import RepBlock
import torch
 
 
input=torch.randn(50,512,49,49)
repblock=RepBlock(512,512)
repblock.eval()
out=repblock(input)
repblock._switch_to_deploy()
out2=repblock(input)
print('difference between vgg and repvgg')
print(((out2-out)**2).sum())
  1. ACNet
    2.1. 论文
    “ACNet: Strengthening the Kernel Skeletons for Powerful CNN via Asymmetric Convolution Blocks”

2.2. 概要

在这里插入图片描述
2.3. 代码

from rep.acnet import ACNet
import torch
from torch import nn
 
input=torch.randn(50,512,49,49)
acnet=ACNet(512,512)
acnet.eval()
out=acnet(input)
acnet._switch_to_deploy()
out2=acnet(input)
print('difference:')
print(((out2-out)**2).sum())
理解神经网络的注意力机制（Attention）及PyTorch 实现
DT程序员的博客
05-16 1520
介绍理解神经网络的注意力机制（Attention）的原理，以及self PyTorch 代码的实现
Selective Kernel Networks（SKNet）解析，附Pytorch实现代码
ITOMG的博客
11-17 1万+
背景： 在神经科学界，视皮层神经元的感受野大小受刺激的调节，即对不同刺激，感受野的大小应该不同。目前很多卷积神经网络的相关工作都只是通过改进网络的空间结构来优化模型，如Inception模块通过引入不同大小的卷积核来获得不同感受野上的信息。或inside-outside网络参考空间上下文信息，等等。但在构建传统CNN时一般在同一层只采用一种卷积核，也就是说对于特定任务...
注意力机制pytorch实现
npc1236的博客
03-21 1842
注意力机制pytorch实现 通道注意力机制 class ChannelAttention(nn.Module): def __init__(self, in_planes, ratio=16): super(ChannelAttention, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.max_pool = nn.AdaptiveMaxPool2d(1)
注意力（Attention）机制详解（附代码）
最新发布
大摆王的博客
05-12 1万+
Attention机制是深度学习中的一种技术，特别是在自然语言处理（NLP）和计算机视觉领域中得到了广泛的应用。它的核心思想是模仿人类的注意力机制，即人类在处理信息时会集中注意力在某些关键部分上，而忽略其他不那么重要的信息。在机器学习模型中，这可以帮助模型更好地捕捉到输入数据中的关键信息。
2019 CVPR 《Selective Kernel Networks》 PyTorch实现
oldsummer
05-04 374
import numpy as np import torch from torch import nn from torch.nn import init from collections import OrderedDict # selective kernel attention # 多个卷积核的通道注意力 # 方法出处 2019 CVPR 《Selective Kernel Networks》 class SKAttention(nn.Module): # 初始化层 def _.
Pytorch 注意力机制解析与代码实现
you 是 mine
11-01 4454
SE注意力模块是一种通道注意力模块，SE模块能对输入特征图进行通道特征加强，且不改变输入特征图的大小。SE模块的S(Squeeze):对输入特征图的空间信息进行压缩SE模块的E(Excitation):学习到的通道注意力信息，与输入特征图进行结合，最终得到具有通道注意力的特征图SE模块的作用是在保留原始特征的基础上，通过学习不同通道之间的关系，提高模型的表现能力。在卷积神经网络中，通过引入SE模块，可以动态地调整不同通道的权重，从而提高模型的表现能力。1、对输入进来的特征层进行全局平均池化。
各种注意力机制pytorch实现以及论文.zip
04-22
各种注意力机制pytorch实现以及论文.zip 大学生课程设计 基于python的课程设计 自己大二写的课程设计
Pytorch 实现注意力机制
01-06
import math import torch import torch.nn as nn import os def file_name_walk(file_dir): for root, dirs, files in os.walk(file_dir): # print(root, root) # 当前目录路径 print(dirs, dirs) # 当前路径下...
使用pytorch框架实现的各种注意力机制代码.zip
02-06
PyTorch是一个强大的深度学习框架，提供了灵活且高效的工具来实现各种注意力机制。 标题"使用PyTorch框架实现的各种注意力机制代码"表明，这个压缩包中包含了一系列用PyTorch编写的注意力机制的实现，这些代码可能...
深度学习中的GAM注意力机制pytorch实现版本
02-23
深度学习中的GAM注意力机制pytorch实现版本
多头自注意力机制Pytorch实现
S10xuexi的博客
02-16 9719
注意力机制广泛存在于现在的深度学习网络结构中，使用得到能够提升模型的学习效果。本文讲使用Pytorch实现多头自注意力模块。 一个典型的自注意力模块由Q、K、V三个矩阵的运算组成，Q、K、V三个矩阵都由原特征矩阵变换而来，所以本质上来说是对自身的运算。 而多头注意力机制则是单头注意力机制的进化版，把每次attention运算分组（头）进行，能够从多个维度提炼特征信息。具体原理可以参看相关的科普文章，下面是Pytorch实现。 import torch.nn as nn class MHSA(nn.Mod
SKnet：Selective Kernel Networks学习笔记+Pytorch代码实现
practical_sharp的博客
03-20 1万+
论文题目：Selective Kernel Networks 发表于 CVPR 2019 论文地址：https://arxiv.org/pdf/1903.06586.pdf 作为一下对比，这里再附上SEnet的结构图： 总结：SK注意力机制和SE注意力机制的不同之处： SE注意力只是在通道上施加MLP学习权重，来体现每个权重之间的重要性差异； SE注意力机制只需要用到一个全局池化和两个全连接层； SK注意力机制是SE注意力机制的升级版，特色之处体现在通过网络自己学习来选择融合不同感受野的特征图信息；
Pytorch图像处理注意力机制SENet CBAM ECA模块解读
qq_43649937的博客
07-26 4787
pytorch python 人工智能注意力机制
gMLP的PyTorch实现与分析
HHzdh的博客
10-17 1975
1、导入相关库函数 import torch from torch import nn from torch.nn import functional as F from torchsummary import summary from tensorboardX import SummaryWriter 2、Spatial Gating Unit模块设计 根据上图的Pseudo-code中的spatial_gating_uint(x)函数，以及文献中的公式(6)，大致思路是：...
PyTorch快餐教程2019 (2) - Multi-Head Attention
lusing的专栏
10-22 1万+
PyTorch快餐教程2019 (2) - Multi-Head Attention 上一节我们为了让一个完整的语言模型跑起来，可能给大家带来的学习负担过重了。没关系，我们这一节开始来还上节没讲清楚的债。 还记得我们上节提到的两个Attention吗？ 上节我们给大家一个印象，现在我们正式开始介绍其原理。 Scaled Dot-Product Attention 首先说Scaled Dot-Pr...
通过Pytorch代码可视化理解卷积神经网络
AI公园
11-11 1124
本文代码地址：https://github.com/AINewHorizon/visualising-cnns机器在理解和识别图像中的特征和对象方面已经达到了99％的准确度。智能手机可以...
Selective Kernel Networks
qq_52302919的博客
02-23 2765
在标准卷积神经网络（CNN）中，每层人工神经元的感受野被设计为相同的大小。神经科学界众所周知，视觉皮层神经元的感受野大小受到刺激的调节，这在构建CNN时很少被考虑。本文在CNN中提出了一种动态选择机制，允许每个神经元根据输入信息的多个尺度自适应调整其感受野大小。设计了一个称为选择性内核（SK）单元的构造块，其中，多个具有不同内核大小的分支使用softmax注意力进行融合，该注意力由这些分支中的信息引导。
pytorch lstm+attention
随笔
12-10 1284
原生： https://www.cnblogs.com/cxq1126/p/13504437.html https://zhuanlan.zhihu.com/p/62486641 https://blog.youkuaiyun.com/qsmx666/article/details/107118550?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1.control&depth_1-utm_source=distrib
pytorch笔记：09)RNN和Transform中的Attention机制
热门推荐
Javis486的专栏
01-11 2万+
原博客是哈佛大学NLP研究组，根据论文“Attention is All You Need” 使用pytorch实现，撰写得非常精彩，强烈推荐。下面是几个笔者阅读时困惑的地方，记录下来以防忘记。 原文中给的一个简单的栗子，给定一个序列，模拟生成同一的序列。 We can begin by trying out a simple copy-task. Given a random set of i...
多头注意力机制pytorch实现
01-03
### 实现多头注意力机制 在神经机器翻译和其他序列建模任务中，多头注意力机制允许模型关注输入的不同部分来改善性能[^1]。下面展示了一个基于PyTorch框架下实现多头注意力机制的方法。 ```python import torch import torch.nn as nn import math class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super(MultiHeadAttention, self).__init__() assert d_model % num_heads == 0, "d_model must be divisible by num_heads" # 定义线性变换层WQ, WK, WV 和WO self.d_k = d_model // num_heads self.num_heads = num_heads self.W_q = nn.Linear(d_model, d_model) self.W_k = nn.Linear(d_model, d_model) self.W_v = nn.Linear(d_model, d_model) self.W_o = nn.Linear(d_model, d_model) def scaled_dot_product_attention(self, Q, K, V, mask=None): attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(K.size(-1)) if mask is not None: attn_scores = attn_scores.masked_fill(mask == 0, -1e9) attn_probs = torch.softmax(attn_scores, dim=-1) output = torch.matmul(attn_probs, V) return output def split_heads(self, x): batch_size, seq_len, _ = x.size() return x.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) def combine_heads(self, x): batch_size, _, seq_len, d_k = x.size() return x.transpose(1, 2).contiguous().view(batch_size, seq_len, self.num_heads * d_k) def forward(self, query, key, value, mask=None): Q = self.split_heads(self.W_q(query)) K = self.split_heads(self.W_k(key)) V = self.split_heads(self.W_v(value)) attn_output = self.scaled_dot_product_attention(Q, K, V, mask=mask) combined_attn_output = self.combine_heads(attn_output) final_output = self.W_o(combined_attn_output) return final_output ``` 此代码片段定义了`MultiHeadAttention`类，该类实现了多头自注意力机制的核心逻辑。通过将查询、键和值向量分割成多个头部并分别计算注意分数，可以捕捉到不同位置之间的关系模式。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值