1. Toy模板网首页
  2. > Toy博客

机器学习的注意力机制学习笔记（三）

9月前 作者：Aresiii 分类：Toy博客 阅读(39) 违法举报

这篇具有很好参考价值的文章主要介绍了机器学习的注意力机制学习笔记（三）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

五）自注意力机制（Self-Attention）

        

        自注意力机制（Self-Attention）是一种用于建模序列数据的注意力机制，最常用于自然语言处理领域中的序列建模任务，如机器翻译和语言生成。

        自注意力机制的核心思想是，通过计算序列中各个位置之间的注意力权重，来动态地为每个位置分配不同的重要性。每个位置都可以同时作为查询（query）、键（key）和值（value）进行计算，以便捕捉到序列中不同位置之间的关联信息。

        自注意力机制在 Transformer 模型等领域中被广泛应用，可以捕捉序列数据中不同位置之间的依赖关系，提供了更全局的建模能力。        

以下是一个使用PyTorch实现自注意力（Self-Attention）的示例代码：

import torch
import torch.nn as nn

class SelfAttention(nn.Module):
    def __init__(self, input_dim, num_heads):
        super(SelfAttention, self).__init__()
        self.input_dim = input_dim
        self.num_heads = num_heads
        self.head_dim = input_dim // num_heads

        self.query_fc = nn.Linear(input_dim, input_dim)
        self.key_fc = nn.Linear(input_dim, input_dim)
        self.value_fc = nn.Linear(input_dim, input_dim)
        self.output_fc = nn.Linear(input_dim, input_dim)

    def forward(self, inputs):
        batch_size, seq_len, _ = inputs.size()

        # 将输入进行线性变换
        query = self.query_fc(inputs)
        key = self.key_fc(inputs)
        value = self.value_fc(inputs)

        # 将线性变换的结果划分为多个头
        query = query.view(batch_size, seq_len, self.num_heads, self.head_dim)
        key = key.view(batch_size, seq_len, self.num_heads, self.head_dim)
        value = value.view(batch_size, seq_len, self.num_heads, self.head_dim)

        # 将头进行维度置换
        query = query.permute(0, 2, 1, 3)
        key = key.permute(0, 2, 1, 3)
        value = value.permute(0, 2, 1, 3)

        # 计算注意力权重
        weights = torch.matmul(query, key.permute(0, 1, 3, 2))
        weights = torch.softmax(weights / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float)), dim=-1)

        # 加权求和
        outputs = torch.matmul(weights, value)

        # 将头维度和序列维度合并
        outputs = outputs.permute(0, 2, 1, 3).contiguous()
        outputs = outputs.view(batch_size, seq_len, self.input_dim)

        # 应用输出线性变换
        outputs = self.output_fc(outputs)

        return outputs, weights

# 示例用法
input_dim = 128
num_heads = 4
seq_len = 10
batch_size = 32

# 创建输入数据
inputs = torch.randn(batch_size, seq_len, input_dim)

# 创建自注意力机制实例
attention = SelfAttention(input_dim, num_heads)

# 前向传播
outputs, weights = attention(inputs)

print("输入数据形状:", inputs.shape)
print("输出数据形状:", outputs.shape)
print("注意力权重形状:", weights.shape)

        在上述代码中，SelfAttention 类表示一个自注意力机制模块。它接受输入数据作为输入，通过对输入进行线性变换和头的划分，计算注意力权重，并将注意力权重应用于输入的加权求和。最后，将多个头的输出进行合并，并通过输出线性变换获得最终的输出。在示例中，输入数据的形状为 (batch_size, seq_len, input_dim) ， input_dim 是输入的特征维度，num_heads 是头的数量。输出数据的形状与输入数据的形状相同，注意力权重形状为(batch_size, num_heads, seq_len, seq_len)。

六）局部注意力机制（Local Attention）   

        局部注意力机制（Local Attention Mechanism）是一种注意力机制的变体，用于在序列数据中建模局部依赖关系，相比于自注意力机制更加节约计算资源。

        在传统的自注意力机制中，每个位置的查询（query）都会与序列中的所有位置的键（key）进行计算相似度，从而获得全局的注意力权重。然而，在某些情况下，全局的注意力计算可能过于昂贵或不必要，特别是当输入序列非常长时。

        局部注意力机制通过限制注意力权重的计算范围，仅在局部窗口内计算注意力权重，从而减少计算开销。

        以下是一个使用 PyTorch 实现局部注意力（Local Attention）的示例代码：

import torch
import torch.nn as nn

class LocalAttention(nn.Module):
    def __init__(self, input_dim, window_size):
        super(LocalAttention, self).__init__()
        self.input_dim = input_dim
        self.window_size = window_size

        self.query_fc = nn.Linear(input_dim, input_dim)
        self.key_fc = nn.Linear(input_dim, input_dim)
        self.value_fc = nn.Linear(input_dim, input_dim)
        self.output_fc = nn.Linear(input_dim, input_dim)

    def forward(self, query, key, value):
        batch_size, seq_len, _ = query.size()

        # 计算窗口的起始和结束位置
        start = max(0, seq_len - self.window_size)
        end = seq_len

        # 截取窗口内的部分
        query = query[:, start:end, :]
        key = key[:, start:end, :]
        value = value[:, start:end, :]

        # 将输入进行线性变换
        query_proj = self.query_fc(query)
        key_proj = self.key_fc(key)
        value_proj = self.value_fc(value)

        # 计算注意力权重
        weights = torch.matmul(query_proj, key_proj.permute(0, 2, 1))
        weights = torch.softmax(weights, dim=-1)

        # 加权求和
        outputs = torch.matmul(weights, value_proj)

        # 应用输出线性变换
        outputs = self.output_fc(outputs)

        return outputs, weights

# 示例用法
input_dim = 128
window_size = 5
seq_len = 10
batch_size = 32

# 创建输入数据
query = torch.randn(batch_size, seq_len, input_dim)
key = torch.randn(batch_size, seq_len, input_dim)
value = torch.randn(batch_size, seq_len, input_dim)

# 创建局部注意力机制实例
attention = LocalAttention(input_dim, window_size)

# 前向传播
outputs, weights = attention(query, key, value)

print("查询数据形状:", query.shape)
print("键数据形状:", key.shape)
print("值数据形状:", value.shape)
print("输出数据形状:", outputs.shape)
print("注意力权重形状:", weights.shape)

        在上述代码中，LocalAttention 类表示一个局部注意力机制模块。它接受查询（query）、键（key）和值（value）作为输入，并根据窗口大小截取输入的一部分进行处理。然后，通过线性变换计算注意力权重，并将权重应用于值的加权求和。最后，通过输出线性变换获得最终的输出。在示例中，查询、键和值的形状都是(batch_size, seq_len, input_dim)，input_dim 是输入的特征维度，window_size 是窗口的大小。输出数据的形状与输入数据的形状相同，注意力权重的形状为(batch_size, seq_len, seq_len)。

        局部注意力机制通过引入窗口大小的限制，降低了计算复杂度，并且更加关注于局部的上下文信息。这使得它适用于处理长序列时的计算和内存效率问题，并且在一些任务中可能更能捕捉到重要的局部依赖关系。

七）基于内容的注意力机制（Content-based Attention）

        基于内容的注意力机制（Content-Based Attention Mechanism）是一种注意力机制的变体，用于在序列数据中根据内容的相似性来计算注意力权重。

        在传统的自注意力机制中，注意力权重的计算通常是基于查询（query）和键（key）之间的相似度，而与序列数据的内容无关。而基于内容的注意力机制则侧重于利用序列数据的内容信息来计算注意力权重。

        基于内容的注意力机制可以根据输入的内容信息计算注意力权重，突出与当前查询相关的重要部分。

        基于内容的注意力（Content-based Attention）通常与序列到序列（sequence-to-sequence）任务一起使用，例如机器翻译或文本摘要。下面是一个基于内容的注意力的简化示例代码：

import torch
import torch.nn as nn

class ContentBasedAttention(nn.Module):
    def __init__(self):
        super(ContentBasedAttention, self).__init__()

    def forward(self, query, key, value):
        # 计算相似性得分
        similarity = torch.matmul(query, key.transpose(-2, -1))

        # 计算注意力权重
        weights = torch.softmax(similarity, dim=-1)

        # 加权求和
        outputs = torch.matmul(weights, value)

        return outputs, weights

# 示例用法
input_dim = 128
seq_len = 10
batch_size = 32

# 创建输入数据
query = torch.randn(batch_size, seq_len, input_dim)
key = torch.randn(batch_size, seq_len, input_dim)
value = torch.randn(batch_size, seq_len, input_dim)

# 创建基于内容的注意力机制实例
attention = ContentBasedAttention()

# 前向传播
outputs, weights = attention(query, key, value)

print("查询数据形状:", query.shape)
print("键数据形状:", key.shape)
print("值数据形状:", value.shape)
print("输出数据形状:", outputs.shape)
print("注意力权重形状:", weights.shape)

        在上述代码中，ContentBasedAttention 类表示一个基于内容的注意力机制模块。它接受查询（query）、键（key）和值（value）作为输入，通过计算查询和键之间的相似性得分，然后使用 softmax 函数对得分进行归一化，得到注意力权重。最后，使用注意力权重对值进行加权求和。在示例中，查询、键和值的形状都是(batch_size, seq_len, input_dim)。输出数据的形状与值的形状相同，注意力权重的形状为(batch_size, seq_len, seq_len)。

        基于内容的注意力机制允许模型在计算注意力权重时考虑序列数据的内容相似性，更关注与查询内容相似的位置。这种机制有助于模型更好地理解和处理输入序列中的相关信息，并更好地捕捉到序列中的重要内容。

八）基于位置的注意力机制（Position-based Attention）

        基于位置的注意力机制（Position-Based Attention Mechanism）是一种注意力机制的变体，用于在序列数据中根据位置信息来计算注意力权重。

        在传统的自注意力机制中，注意力权重的计算通常是基于查询（query）和键（key）之间的相似度。而基于位置的注意力机制则侧重于根据位置的远近来计算注意力权重。

        基于位置的注意力机制可以根据序列中不同位置之间的相对位置信息计算注意力权重，捕捉到序列中的位置顺序和依赖关系。

        基于位置的注意力（Position-based Attention）通常与序列任务一起使用，例如自然语言处理中的语言建模或机器翻译。下面是一个基于位置的注意力的简化示例代码：

import torch
import torch.nn as nn

class PositionBasedAttention(nn.Module):
    def __init__(self):
        super(PositionBasedAttention, self).__init__()

    def forward(self, query, key, value):
        # 获取序列长度
        seq_len = query.size(1)

        # 计算位置编码
        position_encoding = torch.arange(seq_len, dtype=torch.float).unsqueeze(0).to(query.device)
        position_encoding = position_encoding.unsqueeze(-1)

        # 计算相似性得分
        similarity = torch.matmul(query + position_encoding, key.transpose(-2, -1))

        # 计算注意力权重
        weights = torch.softmax(similarity, dim=-1)

        # 加权求和
        outputs = torch.matmul(weights, value)

        return outputs, weights

# 示例用法
input_dim = 128
seq_len = 10
batch_size = 32

# 创建输入数据
query = torch.randn(batch_size, seq_len, input_dim)
key = torch.randn(batch_size, seq_len, input_dim)
value = torch.randn(batch_size, seq_len, input_dim)

# 创建基于位置的注意力机制实例
attention = PositionBasedAttention()

# 前向传播
outputs, weights = attention(query, key, value)

print("查询数据形状:", query.shape)
print("键数据形状:", key.shape)
print("值数据形状:", value.shape)
print("输出数据形状:", outputs.shape)
print("注意力权重形状:", weights.shape)

        在上述代码中，PositionBasedAttention 类表示一个基于位置的注意力机制模块。它接受查询（query）、键（key）和值（value）作为输入，并根据序列的位置编码计算相似性得分。然后，使用 softmax 函数对得分进行归一化，得到注意力权重。最后，使用注意力权重对值进行加权求和。在示例中，查询、键和值的形状都是(batch_size, seq_len, input_dim)。输出数据的形状与值的形状相同，注意力权重的形状为(batch_size, seq_len, seq_len)。

        基于位置的注意力机制允许模型根据位置的远近来调整注意力权重，更关注于相对位置较近的位置。这种机制有助于模型更好地理解和捕捉序列中的局部或全局依赖关系，并更好地处理序列数据。在处理长序列或需要考虑位置信息的任务中，基于位置的注意力机制可以提供更好的建模能力。

       文章来源地址https://www.toymoban.com/news/detail-529972.html

到了这里，关于机器学习的注意力机制学习笔记（三）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 深度学习CV方向学习笔记5 —— 通道注意力机制

    深度学习CV方向学习笔记5 —— 通道注意力机制

    目录 1 问题：MobileNet 中的注意力机制 2 SE 通道注意力机制 2.1 SE 通道注意力机制的定义与作用 2.2 SE过程： Squeeze + Excitation + Scale 3 其他通道注意力机制 4 参考链接 问题描述： MobileNet 中使用了通道注意力机制，是如何实现的？CNN中还有哪些 Attention? 2.1 SE 通道注意力机制的定义

    2024年02月08日
    浏览(46)
  • 计算机视觉注意力机制小盘一波 （学习笔记）

    计算机视觉注意力机制小盘一波 （学习笔记）

    将注意力的阶段大改分成了4个阶段 1.将深度神经网络与注意力机制相结合，代表性方法为RAM ⒉.明确预测判别性输入特征，代表性方法为STN 3.隐性且自适应地预测潜在的关键特征，代表方法为SENet 4.自注意力机制 在深度神经网络中，每个卷积层通常包含多个通道， 每个通道对

    2024年02月08日
    浏览(44)
  • 学习笔记1——常用的注意力机制（即插即用）

    学习笔记1——常用的注意力机制（即插即用）

    在目标检测网络里加注意力机制已经是很常见的了，顾名思义，注意力机制是指在全局图像中获得重点关注的目标，常用的注意力机制有SE、CA、ECA、CBAM、GAM、NAM等。 1、SE模块 论文：https://arxiv.org/pdf/1709.01507.pdf 参考：CV领域常用的注意力机制模块（SE、CBAM）_学学没完的博客

    2024年02月06日
    浏览(47)
  • NLP 学习笔记十-simple RNN+attention（注意力机制）

    NLP 学习笔记十-simple RNN+attention（注意力机制）

    感兴趣的伙伴，看这个笔记，最好从头开始看哈，而且我的笔记，其实不面向零基础，最好有过一些实践经历的来看最好。 紧接上一回，我们谈到seq2seq模型解决用于机器翻译的问题。其中seq其实是采用lstm作为自己的基础记忆网络实现的，当然也可以用RNN实现实现seq2seq模型。

    2024年02月09日
    浏览(62)

  • 机器学习笔记 - 什么是图注意力网络？

            顾名思义，图注意力网络是图神经网络和注意力层的组合。要理解图注意力网络，我们首先需要了解什么是注意力层和图神经网络。首先，我们将看一下对图神经网络和注意力层的基本理解，然后我们将重点介绍两者的结合。让我们看一下图神经网络。       

    2023年04月09日
    浏览(38)
  • 机器学习笔记 - 在 Vision Transformer 中可视化注意力

    机器学习笔记 - 在 Vision Transformer 中可视化注意力

            2022 年， 视觉变换器 (ViT) 成为 卷积神经网络 (CNN) 的有力竞争对手，后者现已成为计算机视觉领域的 最先进技术，并广泛应用于许多图像识别应用中。 在计算效率和准确性方面，ViT 模型超过了当前最先进的 (CNN) 几乎 四倍 。         视觉转换器模型的性能由

    2024年02月13日
    浏览(39)
  • 深度学习笔记之Seq2seq(三)注意力机制的执行过程

    深度学习笔记之Seq2seq(三)注意力机制的执行过程

    上一节介绍了 Seq2seq text{Seq2seq} Seq2seq 中注意力机制 ( Attention ) (text{Attention}) ( Attention ) 的动机，并介绍了 权重系数、 Score text{Score} Score 函数 。本节将完整介绍 注意力机制 在 Seq2seq text{Seq2seq} Seq2seq 中的执行过程。 经典 Seq2seq text{Seq2seq} Seq2seq 模型中 Context text{Context} Co

    2024年02月08日
    浏览(52)
  • 【深度学习注意力机制系列】—— ECANet注意力机制（附pytorch实现）

    【深度学习注意力机制系列】—— ECANet注意力机制（附pytorch实现）

    ECANet（Efficient Channel Attention Network） 是一种 用于图像处理任务的神经网络架构，它在保持高效性的同时，有效地捕捉图像中的通道间关系，从而提升了特征表示的能力 。ECANet通过引入通道注意力机制，以及在卷积层中嵌入该机制，取得了优越的性能。本文将对ECANet的核心思

    2024年02月13日
    浏览(50)
  • 【深度学习注意力机制系列】—— SENet注意力机制（附pytorch实现）

    【深度学习注意力机制系列】—— SENet注意力机制（附pytorch实现）

    深度学习中的注意力机制（Attention Mechanism）是一种模仿人类视觉和认知系统的方法，它允许神经网络在处理输入数据时集中注意力于相关的部分。通过引入注意力机制，神经网络能够自动地学习并选择性地关注输入中的重要信息，提高模型的性能和泛化能力。 卷积神经网络

    2024年02月14日
    浏览(40)
  • 【深度学习注意力机制系列】—— SCSE注意力机制（附pytorch实现）

    【深度学习注意力机制系列】—— SCSE注意力机制（附pytorch实现）

    SCSE注意力模块 （来自论文[1803.02579] Concurrent Spatial and Channel Squeeze Excitation in Fully Convolutional Networks (arxiv.org)）。其对SE注意力模块进行了改进，提出了 cSE、sSE、scSE 三个模块变体，这些模块可以 增强有意义的特征，抑制无用特征 。今天我们就分别讲解一下这三个注意力模块。

    2024年02月13日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包