机器学习的注意力机制学习笔记（二）-Toy模板网

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

二）内积注意力机制

内积注意力机制（Dot Product Attention Mechanism）是一种计算注意力权重的方法，常用于自注意力机制中。

在内积注意力机制中，注意力权重的计算基于查询（query）和键（key）之间的内积（点积）。这种方法的计算简单高效，常用于序列建模任务，如机器翻译和语言生成。

以下是一个使用 PyTorch 实现内积注意力（Dot Product Attention）的示例代码：

import torch
import torch.nn as nn

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

    def forward(self, query, key, value):
        # 计算注意力权重
        weights = torch.matmul(query, key.transpose(-2, -1))
        weights = torch.softmax(weights, 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 = DotProductAttention()

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

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

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

输出结果：

查询数据形状: torch.Size([32, 10, 128])
键数据形状: torch.Size([32, 10, 128])
值数据形状: torch.Size([32, 10, 128])
输出数据形状: torch.Size([32, 10, 128])
注意力权重形状: torch.Size([32, 10, 10])

需要注意的是，这只是一个简单的内积注意力的示例代码，实际应用中可能需要根据具体任务和模型的需求进行适当的修改和扩展。

内积注意力机制通过点积操作直接计算查询和键之间的相似度，从而得到注意力权重。这种方法简单高效，不需要额外的参数和映射操作，可以更好地捕捉到序列中的相关信息。然而，对于维度较高的查询和键，内积可能会导致数值不稳定的问题，因此通常会进行缩放或其他处理来稳定计算。

三）加性注意力机制

加性注意力机制（Additive Attention Mechanism）是一种计算注意力权重的方法，常用于序列建模任务中。

在加性注意力机制中，注意力权重的计算通过对查询（query）和键（key）进行线性变换后的加和来实现。这种方法可以捕捉到查询和键之间的复杂关系，并允许模型在注意力计算过程中学习权重的非线性关系。

以下是一个使用 PyTorch 实现加性注意力（Additive Attention）的示例代码：

import torch
import torch.nn as nn

class AdditiveAttention(nn.Module):
    def __init__(self, query_dim, key_dim, hidden_dim):
        super(AdditiveAttention, self).__init__()
        self.query_dim = query_dim
        self.key_dim = key_dim
        self.hidden_dim = hidden_dim
        self.query_fc = nn.Linear(query_dim, hidden_dim)
        self.key_fc = nn.Linear(key_dim, hidden_dim)
        self.energy_fc = nn.Linear(hidden_dim, 1)

    def forward(self, query, key, value):
        # 将查询和键映射到隐藏空间
        mapped_query = self.query_fc(query)
        mapped_key = self.key_fc(key)

        # 计算能量分数
        energy = torch.tanh(mapped_query + mapped_key)
        energy = self.energy_fc(energy)

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

        # 加权求和
        outputs = torch.matmul(weights.transpose(-1, -2), value)

        return outputs, weights

# 示例用法
query_dim = 128
key_dim = 128
hidden_dim = 64
seq_len = 10
batch_size = 32

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

# 创建加性注意力机制实例
attention = AdditiveAttention(query_dim, key_dim, hidden_dim)

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

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

在上述代码中，AdditiveAttention 类表示一个加性注意力机制模块。它接受查询（query）、键（key）和值（value）作为输入，通过使用全连接层将查询和键映射到隐藏空间，然后计算能量分数，并通过softmax函数对能量进行归一化得到注意力权重。最后，使用注意力权重对值进行加权求和。在示例中，查询、键和值的形状都是 (batch_size, seq_len, dim)，隐藏空间维度为 hidden_dim 。输出数据的形状与值的形状相同，注意力权重的形状为(batch_size, seq_len, 1) 。

输出结果：

查询数据形状: torch.Size([32, 10, 128])
键数据形状: torch.Size([32, 10, 128])
值数据形状: torch.Size([32, 10, 128])
输出数据形状: torch.Size([32, 10, 128])
注意力权重形状: torch.Size([32, 10, 1])

需要注意的是，这只是一个简单的加性注意力的示例代码，实际应用中可能需要根据具体任务和模型的需求进行适当的修改和扩展。

加性注意力机制通过引入线性变换和非线性激活函数，能够学习到更复杂的注意力权重计算规则，以更好地捕捉查询和键之间的关系。这种方法在一些序列建模任务中可以提供更好的表达能力和建模能力。然而，加性注意力机制通常需要更多的参数和计算开销，因此在处理大规模数据时可能会受到限制。

四）多头注意力机制

多头注意力机制（Multi-Head Attention Mechanism）是一种扩展自注意力机制（Self-Attention Mechanism）的注意力机制，用于增强模型的表达能力和建模能力。

在多头注意力机制中，模型通过并行地进行多个注意力头的计算，从而可以捕捉到不同注意力子空间中的特征和关系。每个注意力头独立地学习自己的查询（query）、键（key）和值（value）的线性变换，以及计算注意力权重和上下文向量的过程。

以下是一个使用 PyTorch 实现多头注意力（Multi-head Attention）的示例代码：

import torch
import torch.nn as nn

class MultiheadAttention(nn.Module):
    def __init__(self, input_dim, num_heads):
        super(MultiheadAttention, 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, query, key, value):
        batch_size, seq_len, _ = query.size()

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

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

        # 将头进行维度置换
        query_proj = query_proj.permute(0, 2, 1, 3)
        key_proj = key_proj.permute(0, 2, 1, 3)
        value_proj = value_proj.permute(0, 2, 1, 3)

        # 计算注意力权重
        weights = torch.matmul(query_proj, key_proj.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_proj)

        # 将头维度和序列维度合并
        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

# 创建输入数据
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 = MultiheadAttention(input_dim, num_heads)

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

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

在上述代码中，MultiheadAttention 类表示一个多头注意力机制模块。它接受查询（query）、键（key）和值（value）作为输入，通过对输入进行线性变换和头的划分，计算注意力权重，并将注意力权重应用于值进行加权求和。

最后，将多个头的输出进行合并，并通过输出线性变换获得最终的输出。在示例中，查询、键和值的形状都是 (batch_size, seq_len, input_dim) ，input_dim 是输入的特征维度，num_heads 是头的数量。输出数据的形状与输入数据的形状相同，注意力权重的形状为 (batch_size, num_heads, seq_len, seq_len) 。

输出结果：

查询数据形状: torch.Size([32, 10, 128])
键数据形状: torch.Size([32, 10, 128])
值数据形状: torch.Size([32, 10, 128])
输出数据形状: torch.Size([32, 10, 128])
注意力权重形状: torch.Size([32, 4, 10, 10])

需要注意的是，这只是一个简单的多头注意力的示例代码，实际应用中可能需要根据具体任务和模型的需求进行适当的修改和扩展。多头注意力机制被广泛应用于 Transformer 模型等领域，可以提高模型对序列数据的表达能力和泛化能力。

多头注意力机制通过并行地进行多个注意力头的计算，使得模型能够同时关注不同的关系和特征，从而提升了模型的表达能力和建模能力。每个注意力头可以捕捉到不同的上下文信息，提供了更丰富和多样化的表示。这种机制在许多自然语言处理任务中取得了显著的效果改善，如机器翻译、文本分类等。文章来源地址https://www.toymoban.com/news/detail-532255.html

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