在 Encoder-Decoder 模型中引入 Attention 机制，是为了改善基本Seq2Seq模型的性能，特别是当处理长序列时，传统的Encoder-Decoder模型容易面临信息压缩的困难。Attention机制可以帮助模型动态地选择源序列中相关的信息，从而提高翻译等任务的质量。
一、为什么需要Attention机制？
在基本的 Encoder-Decoder 模型中，Encoder将整个源句子的所有信息压缩成一个固定大小的向量（上下文向量），然后Decoder使用这个向量来生成目标序列。这个单一的上下文向量对于较短的句子可能足够，但对于较长的句子，模型可能无法有效捕捉到整个句子中所有重要的信息。这样容易导致信息丢失，尤其是当句子很长时，Decoder在生成目标词时可能无法获取到源句子的细节信息。
二、Attention机制的核心思想
Attention机制的核心思想是：在每个时间步生成目标单词时，Decoder不再依赖于固定的上下文向量，而是能够通过“注意力”权重，动态地从源句子的所有隐状态中选择最相关的部分。这样，Decoder每生成一个目标词时，能够更好地“关注”源句子中与当前生成词最相关的部分。
三、Attention机制的工作流程
在每一步解码时，Attention机制会根据Decoder的当前状态计算出一组权重，表示源句子中各个位置的隐状态对当前解码步骤的重要性。这些权重用于加权源句子的隐状态，以得到一个上下文向量，这个上下文向量会与当前Decoder的隐状态一起用于生成下一个目标词。由于它跨越两个序列：源语言序列（编码器输出）作为 Key 和 Value；目标语言序列（解码器的当前状态）作为 Query，因此也叫交叉注意力。
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输出计算注意力权重。
-
Decoder：
- 使用Attention得到的注意力权重对Encoder输出进行加权平均，得到上下文向量。
- 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等模型的出现奠定了基础。
