【模型】Encoder-Decoder模型中Attention机制的引入

🕗 发布于 2024-10-13 04:01 自然语言处理 人工智能 深度学习

在 Encoder-Decoder 模型中引入 Attention 机制，是为了改善基本Seq2Seq模型的性能，特别是当处理长序列时，传统的Encoder-Decoder模型容易面临信息压缩的困难。Attention机制可以帮助模型动态地选择源序列中相关的信息，从而提高翻译等任务的质量。

一、为什么需要Attention机制？

在基本的 Encoder-Decoder 模型中，Encoder将整个源句子的所有信息压缩成一个固定大小的向量（上下文向量），然后Decoder使用这个向量来生成目标序列。这个单一的上下文向量对于较短的句子可能足够，但对于较长的句子，模型可能无法有效捕捉到整个句子中所有重要的信息。这样容易导致信息丢失，尤其是当句子很长时，Decoder在生成目标词时可能无法获取到源句子的细节信息。

二、Attention机制的核心思想

Attention机制的核心思想是：在每个时间步生成目标单词时，Decoder不再依赖于固定的上下文向量，而是能够通过“注意力”权重，动态地从源句子的所有隐状态中选择最相关的部分。这样，Decoder每生成一个目标词时，能够更好地“关注”源句子中与当前生成词最相关的部分。

三、Attention机制的工作流程

在每一步解码时，Attention机制会根据Decoder的当前状态计算出一组权重，表示源句子中各个位置的隐状态对当前解码步骤的重要性。这些权重用于加权源句子的隐状态，以得到一个上下文向量，这个上下文向量会与当前Decoder的隐状态一起用于生成下一个目标词。

Attention的具体步骤如下：

计算注意力权重：
- 对于Decoder的每一步（生成每个目标词时），通过Decoder的当前隐状态和源句子每个时间步的隐状态来计算注意力权重。
- 这些权重表示源句子中每个位置的重要性，可以使用加性Attention或点积Attention来计算。
计算上下文向量：
- 通过将注意力权重与源句子的隐状态进行加权平均，得到一个新的上下文向量。
- 这个上下文向量包含了源句子中当前对Decoder最重要的信息。
解码下一步：
- 将新的上下文向量与当前Decoder的隐状态结合，用于生成当前的目标词。

四、Attention机制的公式

对于每个时间步 t：

计算注意力得分：通常使用Decoder当前的隐状态 ht 和源句子每个位置的隐状态 hs 计算注意力得分，可以通过以下公式计算：

在这里插入图片描述

常见的 score 函数有加性（Bahdanau Attention）和点积（Luong Attention）：

加性Attention：使用一个简单的前馈网络对 ht 和 hs 进行线性变换并加和。
点积Attention：直接计算 ht 和 hs 的点积。

计算注意力权重：对得分 et,s 进行Softmax操作，得到权重：

在这里插入图片描述

这些权重 αt,s 表示源句子中各个位置对当前解码的影响力。

计算上下文向量：使用注意力权重对源句子的隐状态进行加权平均，得到上下文向量 ct：

在这里插入图片描述

生成下一个词：将上下文向量 ct 与Decoder的隐状态 ht 结合，生成下一个词。

五、引入Attention机制的Encoder-Decoder代码实现

以下是一个带有 Attention 机制的 Encoder-Decoder 模型的简化实现，使用 PyTorch 进行构建。

import torch
import torch.nn as nn

# Encoder模型
class Encoder(nn.Module):
    def __init__(self, input_size, embedding_dim, hidden_size):
        super(Encoder, self).__init__()
        self.embedding = nn.Embedding(input_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_size, batch_first=True)

    def forward(self, src):
        embedded = self.embedding(src)  # [batch_size, src_len, embedding_dim]
        outputs, (hidden, cell) = self.lstm(embedded)  # [batch_size, src_len, hidden_size]
        return outputs, hidden, cell

# Attention模型
class Attention(nn.Module):
    def __init__(self, hidden_size):
        super(Attention, self).__init__()
        self.attn = nn.Linear(hidden_size * 2, hidden_size)
        self.v = nn.Parameter(torch.rand(hidden_size))

    def forward(self, hidden, encoder_outputs):
        src_len = encoder_outputs.shape[1]
        hidden = hidden.unsqueeze(1).repeat(1, src_len, 1)
        energy = torch.tanh(self.attn(torch.cat((hidden, encoder_outputs), dim=2)))  # [batch_size, src_len, hidden_size]
        energy = torch.sum(self.v * energy, dim=2)  # [batch_size, src_len]
        return torch.softmax(energy, dim=1)  # [batch_size, src_len]

# Decoder模型
class Decoder(nn.Module):
    def __init__(self, output_size, embedding_dim, hidden_size):
        super(Decoder, self).__init__()
        self.embedding = nn.Embedding(output_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim + hidden_size, hidden_size, batch_first=True)
        self.fc_out = nn.Linear(hidden_size * 2, output_size)
        self.attention = Attention(hidden_size)

    def forward(self, input_token, hidden, cell, encoder_outputs):
        input_token = input_token.unsqueeze(1)  # [batch_size, 1]
        embedded = self.embedding(input_token)  # [batch_size, 1, embedding_dim]
        
        # 计算注意力权重
        attn_weights = self.attention(hidden[-1], encoder_outputs)  # [batch_size, src_len]
        
        # 使用注意力权重对encoder输出进行加权平均
        attn_applied = torch.bmm(attn_weights.unsqueeze(1), encoder_outputs)  # [batch_size, 1, hidden_size]

        # 将注意力上下文向量和嵌入层输入拼接
        lstm_input = torch.cat((embedded, attn_applied), dim=2)  # [batch_size, 1, embedding_dim + hidden_size]
        
        # 通过LSTM
        output, (hidden, cell) = self.lstm(lstm_input, (hidden, cell))  # [batch_size, 1, hidden_size]

        # 生成最终输出
        output = torch.cat((output.squeeze(1), attn_applied.squeeze(1)), dim=1)  # [batch_size, hidden_size * 2]
        prediction = self.fc_out(output)  # [batch_size, output_size]

        return prediction, hidden, cell

# Seq2Seq模型
class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder, device):
        super(Seq2Seq, self).__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.device = device

    def forward(self, src, tgt, teacher_forcing_ratio=0.5):
        batch_size = tgt.shape[0]
        target_len = tgt.shape[1]
        target_vocab_size = self.decoder.fc_out.out_features

        outputs = torch.zeros(batch_size, target_len, target_vocab_size).to(self.device)

        encoder_outputs, hidden, cell = self.encoder(src)

        input_token = tgt[:, 0]

        for t in range(1, target_len):
            output, hidden, cell = self.decoder(input_token, hidden, cell, encoder_outputs)
            outputs[:, t, :] = output
            top1 = output.argmax(1)
            input_token = tgt[:, t] if torch.rand(1).item() < teacher_forcing_ratio else top1

        return outputs

代码说明：

Encoder：
- 编码源句子，生成隐状态和输出序列。
- 输出序列会在注意力机制中使用。
Attention：
- Attention 模型根据当前隐状态和Encoder输出计算注意力权重。
- 使用注意力权重对Encoder输出进行加权平均，得到上下文向量。
- 将输入的词向量和上下文向量连接，输入到LSTM中
Decoder：
- Decoder在当前时间步会将当前输入（上一个时间步生成的词）、上一个时间步的隐状态和注意力上下文向量拼接起来，输入到LSTM或GRU中，更新隐状态并生成当前时间步的输出。
Seq2Seq：
- 将Encoder和Decoder结合，逐步生成目标序列。
- 使用了教师强制机制来控制训练时的输入。

Decoder代码详细解释：

attn_weights = self.attention(hidden[-1], encoder_outputs):
- hidden[-1] 是Decoder当前时间步的最后一层隐状态（对于多层LSTM来说）。encoder_outputs 是Encoder所有时间步的输出。
- 调用 self.attention 计算当前时间步的注意力权重。
attn_applied = torch.bmm(attn_weights.unsqueeze(1), encoder_outputs):
- attn_weights 是注意力权重，形状为 [batch_size, src_len]。
- unsqueeze(1) 将其变为 [batch_size, 1, src_len]，然后与 encoder_outputs（形状为 [batch_size, src_len, hidden_size]）进行批量矩阵乘法（torch.bmm）。
- 这样得到的结果 attn_applied 是加权后的上下文向量，形状为 [batch_size, 1, hidden_size]，表示根据注意力权重加权后的源句子信息。
torch.cat((embedded, attn_applied), dim=2):
- 将Decoder的当前输入（嵌入表示）和上下文向量拼接在一起，输入到LSTM中。

六、总结：

Attention机制的引入，允许Decoder在生成每个目标词时，能够动态地根据源句子的不同部分调整注意力，使得模型能够处理更长的序列，并提高生成结果的准确性。Attention机制在机器翻译等任务中取得了显著的效果，并且为之后的Transformer等模型的出现奠定了基础。

原文地址：https://blog.csdn.net/a13545564067/article/details/142883866

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：vue从0开始的项目搭建(含环境配置)
下一篇：Python入门：如何在Python中优雅地书写多行字符串！

QML tableView设置role为index的问题
好了，开始运行，表格显示无问题。但点击时，奇怪的现象发生了，点击第一行时无选中效果，点击第二行时第一行选中，点击第三行时第二行选中，依此类推。并且通过tableview的currentRow 获取到的
阅读更多2024-10-13
XMOJ3065 旅游线路
10分钟没啥思路就去看题解了，结果发现很蠢。
阅读更多2024-10-13
【实时计算 Flink】检查点和快照超时的诊断方法与调优策略
本文为您介绍检查点和快照超时的诊断方法和调优策略。Flink的核心机制依赖于Chandy-Lamport算法，以确保数据的一致性和可靠性。：此阶段的关键在于Barrier的对齐和同步资源的维护。Bar
阅读更多2024-10-13
《RabbitMQ篇》交换机基本概览
接受RabbitMQ中的交换机的概念及其分类
阅读更多2024-10-13
mysql学习教程，从入门到精通，SQL 约束（Constraints）（41）
在数据库设计中，约束（Constraints）用于确保数据的准确性和完整性。它们通过限制可以插入到数据库表中的数据类型来防止无效数据。SQL 中有几种常见的约束类型，包括主键约束（Primary Ke
阅读更多2024-10-13
云直播的基本概念
用户需要在域名服务商处，配置一条 CNAME 记录，记录生效后，域名解析的工作就正式转向腾讯云云直播，该域名所有的请求都将转向腾讯云直播的边缘节点。指推流过程中，直播触发事件通知，腾讯云按照配置模板信
阅读更多2024-10-13
java生成离职证明,各种申请模板并上传pdf
4.数据流上传到sftp服务器上就ok了。3.将html模板,转为数据流。
阅读更多2024-10-13
本地windows文件上传到远程阿里云windows server方法
将本地windows系统下开发的软件快速上传到远程阿里云windows server的方法
阅读更多2024-10-13
基于落差法实现自动测流的java方法
关注到文章中求解系数部分有2种假设如下：1.落差系数使用试错法得出 2.落差系数使用回归曲线进行拟合。某天下午在上班摸鱼的小邓突然接到新任务，如下参考论文进行java的编码实现。z+c 和落差系数B
阅读更多2024-10-13
java 基础
1. equals vs hashCode在 Java 中，如果你重写了 equals 方法，就必须重写 hashCode 方法。这是因为这两个方法在某些数据结构（如 HashMap、HashSet
阅读更多2024-10-13

【模型】Encoder-Decoder模型中Attention机制的引入

一、为什么需要Attention机制？

二、Attention机制的核心思想

三、Attention机制的工作流程

四、Attention机制的公式

五、引入Attention机制的Encoder-Decoder代码实现

代码说明：

Decoder代码详细解释：

六、总结：

相关文章