Encoder-Decoder & Attention Mechanisms
前言
本文是一篇NLP实验博客,核心内容是Encoder-Decoder、注意力机制,并将二者应用于机器翻译。文章结尾处分析了模型构建和训练过程中的部分问题,欢迎评论区讨论。
一、机器翻译简介
机器翻译(Machine Translation)指的是将序列从一种语言自动翻译成另一种语言。事实上,这个研究领域可以追溯到数字计算机发明后不久的20世纪40年代,特别是在第二次世界大战中使用计算机破解语言编码。几十年来,在使用神经网络进行端到端学习的兴起之前,统计学方法在这一领域一直占据主导地位。
近年来,随着深度学习的发展,基于神经网络的翻译逐渐兴起,区别于统计机器翻译,其更强调端到端的学习。
二、Encoder-Decoder架构分析
在自然语言处理的很多应用中,输入和输出都可以是不定长序列。以机器翻译为例,输入可以是一段不定长的英语文本序列,输出可以是一段不定长的法语文本序列,例如
英语输入:“They”、“are”、“watching”、“.”
法语输出:“Ils”、“regardent”、“.”
当输入和输出都是不定长序列时,我们可以使用编码器—解码器(encoder-decoder) 或者seq2seq模型 。这两个模型本质上都用到了两个循环神经网络,分别叫做编码器和解码器。编码器用来分析输入序列,解码器用来生成输出序列。
下图描述了使用编码器—解码器将上述英语句子翻译成法语句子的一种方法。在训练数据集中,我们可以在每个句子后附上特殊符号“<eos>”(end of sequence)以表示序列的终止。编码器每个时间步的输入依次为英语句子中的单词、标点和特殊符号“<eos>”。图中使用了编码器在最终时间步的隐藏状态作为输入句子的表征或编码信息。解码器在各个时间步中使用输入句子的编码信息和上个时间步的输出以及隐藏状态作为输入。我们希望解码器在各个时间步能正确依次输出翻译后的法语单词、标点和特殊符号"<eos>"。需要注意的是,解码器在最初时间步的输入用到了一个表示序列开始的特殊符号"<bos>"(beginning of sequence)。
2.1 编码器(Encoder)
编码器的作用是把一个不定长的输入序列变换成一个定长的背景变量
让我们考虑批量大小为1的时序数据样本。假设输入序列是
接下来,编码器通过自定义函数
例如,当选择
以上描述的编码器是一个单向的循环神经网络,每个时间步的隐藏状态只取决于该时间步及之前的输入子序列。我们也可以使用双向循环神经网络构造编码器。在这种情况下,编码器每个时间步的隐藏状态同时取决于该时间步之前和之后的子序列(包括当前时间步的输入),并编码了整个序列的信息。
2.2 解码器(Decoder)
刚刚已经介绍,编码器输出的背景变量
为此,我们可以使用另一个循环神经网络作为解码器。在输出序列的时间步
有了解码器的隐藏状态后,我们可以使用自定义的输出层和softmax运算来计算
2.3 Encoder-Decoder模型的训练
根据最大似然估计,我们可以最大化输出序列基于输入序列的条件概率
并得到该输出序列的损失
在模型训练中,所有输出序列损失的均值通常作为需要最小化的损失函数。在上文所描述的模型预测中,我们需要将解码器在上一个时间步的输出作为当前时间步的输入。与此不同,在训练中我们也可以将标签序列(训练集的真实输出序列)在上一个时间步的标签作为解码器在当前时间步的输入。这叫作强制教学(teacher forcing)。
在本文的拓展部分的Question ② 中,我们也详细的讨论了teacher-forcing和free-running的区别。
2.4 几种常见的解码模式
- 简单Decoder架构
在这种模式下,解码器在每一步生成输出时,只依赖于编码器提供的上下文向量,不使用之前生成的输出作为输入。
该结构实现简单,计算速度快。但由于解码器在每一步生成时没有使用之前生成的输出信息,生成的序列缺乏上下文连贯性。1-简单模式 - 带输出回馈的解码模式
解码器在生成每一步输出时,不仅依赖于编码器提供的上下文向量,还使用之前生成的输出作为输入。利用之前生成的输出信息,生成的序列更具上下文连贯性。2-带输出回馈的解码模式 - 带编码向量的解码模式
解码器在每一步生成时,利用编码器的上下文向量以及时间步t的隐状态,确保了每一步生成都包含全局上下文信息。3-带编码向量的解码模式 - 带注意力的解码模式
在每一步生成时,解码器使用注意力机制,从编码器的所有隐藏状态中选择相关信息。注意力机制动态地计算每个隐藏状态的权重,生成一个上下文向量。
注意力机制可以捕捉输入序列中不同部分的相关性,解决了简单上下文向量无法总结长序列信息的问题,生成的序列更精确且具有上下文相关性。4-带注意力的解码模式
三、注意力机制详解
在上一小节里,解码器在各个时间步依赖相同的背景变量来获取输入序列信息。当编码器为循环神经网络时,背景变量来自它最终时间步的隐藏状态。
现在,让我们再次思考那一节提到的翻译例子:输入为英语序列“They”“are”“watching”“.”,输出为法语序列“Ils”“regardent”“.”。不难想到,解码器在生成输出序列中的每一个词时可能只需利用输入序列某一部分的信息。例如,在输出序列的时间步1,解码器可以主要依赖“They”“are”的信息来生成“Ils”,在时间步2则主要使用来自“watching”的编码信息生成“regardent”,最后在时间步3则直接映射句号“.”。这看上去就像是在解码器的每一时间步对输入序列中不同时间步的表征或编码信息分配不同的注意力一样。这也是注意力机制的由来 。
仍然以循环神经网络为例,注意力机制通过对编码器所有时间步的隐藏状态做加权平均来得到背景变量。解码器在每一时间步调整这些权重,即注意力权重,从而能够在不同时间步分别关注输入序列中的不同部分并编码进相应时间步的背景变量。本节我们将讨论注意力机制是怎么工作的。
在上一节里我们区分了输入序列或编码器的索引
这里的关键是如何计算背景变量
3.1 计算背景变量
我们先描述第一个关键点,即计算背景变量。下图描绘了注意力机制如何为解码器在时间步2计算背景变量。首先,函数
具体来说,令编码器在时间步
其中给定
现在,我们需要定义如何计算上式中softmax运算的输入
这里函数
其中
3.1+ 矢量化计算
我们还可以对注意力机制采用更高效的矢量化计算。广义上,注意力机制的输入包括查询项以及一一对应的键项和值项,其中值项是需要加权平均的一组项。在加权平均中,值项的权重来自查询项以及与该值项对应的键项的计算。
在上面的例子中,查询项为解码器的隐藏状态,键项和值项均为编码器的隐藏状态。
让我们考虑一个常见的简单情形,即编码器和解码器的隐藏单元个数均为
即可算出转置后的背景向量
3.2 更新隐藏状态
现在我们描述第二个关键点,即更新隐藏状态。以门控循环单元为例,在解码器中我们可以对GRU中门控循环单元的设计稍作修改,从而变换上一时间步
其中的重置门、更新门和候选隐藏状态分别为
其中含下标的
四、机器翻译构建实例
4.1 数据读取 & 预处理
我们先定义一些特殊符号。其中“<pad>”(padding)符号用来添加在较短序列后,直到每个序列等长,而“<bos>”和“<eos>”符号分别表示序列的开始和结束。
1
!tar -xf d2lzh_pytorch.tar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import collections
import os
import io
import math
import torch
from torch import nn
import torch.nn.functional as F
import torchtext.vocab as Vocab
import torch.utils.data as Data
import sys
# sys.path.append("..")
import d2lzh_pytorch as d2l
# <pad>用于填充,<bos>表示序列的开始,<eos>表示序列的结束
PAD, BOS, EOS = '<pad>', '<bos>', '<eos>'
# 设置CUDA
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(torch.__version__, device)
1 |
|
为了演示方便,我们在这里使用一个很小的法语—英语数据集。在这个数据集里,每一行是一对法语句子和它对应的英语句子,中间使用'\t'
隔开。在读取数据时,我们在句末附上“<eos>”符号,并可能通过添加“<pad>”符号使每个序列的长度均为max_seq_len
。我们为法语词和英语词分别创建词典。法语词的索引和英语词的索引相互独立。
1 |
|
将序列的最大长度设成7,然后查看读取到的第一个样本。该样本分别包含法语词索引序列和英语词索引序列。
1 |
|
4.2 含注意力机制的编码器—解码器
我们将使用含注意力机制的编码器—解码器来将一段简短的法语翻译成英语。下面介绍模型的实现。
4.2.1 编码器
在编码器中,我们将输入语言的词索引通过词嵌入层得到词的表征,然后输入到一个多层门控循环单元中。PyTorch的nn.GRU
实例在前向计算后也会分别返回输出和最终时间步的多层隐藏状态。其中的输出指的是最后一层的隐藏层在各个时间步的隐藏状态,并不涉及输出层计算。注意力机制将这些输出作为键项和值项。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19class Encoder(nn.Module):
def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
drop_prob=0, **kwargs):
super(Encoder, self).__init__(**kwargs)
# 定义词嵌入层,将词汇表中的词转换为指定维度的词向量
self.embedding = nn.Embedding(vocab_size, embed_size)
# 定义GRU层,输入是词嵌入后的向量,输出是隐藏状态
self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=drop_prob)
def forward(self, inputs, state):
# 输入形状是(批量大小, 时间步数)
# 将输入转换为词嵌入,并交换维度,得到形状为(seq_len, batch, input_size)
embedding = self.embedding(inputs.long()).permute(1, 0, 2)
# 将嵌入向量输入GRU网络,返回所有时间步的隐藏状态和最后一个时间步的隐藏状态
return self.rnn(embedding, state)
def begin_state(self):
# 初始化隐藏状态,GRU会自动处理初始状态为None的情况
return Nonestate
就是一个元素,即隐藏状态;如果使用长短期记忆,state
是一个元组,包含两个元素即隐藏状态和记忆细胞。
1 |
|
4.2.2 注意力机制
将输入连结后通过含单隐藏层的多层感知机变换。其中隐藏层的输入是解码器的隐藏状态与编码器在所有时间步上隐藏状态的一一连结,且使用tanh函数作为激活函数。输出层的输出个数为1。两个Linear
实例均不使用偏差。其中函数attention_size
。
1
2
3
4
5
6
7
8
9
10
11def attention_model(input_size, attention_size):
# 定义一个顺序容器模型
model = nn.Sequential(
# 第一个线性变换层,将输入大小映射到注意力大小,且无偏置
nn.Linear(input_size, attention_size, bias=False),
# Tanh激活函数
nn.Tanh(),
# 第二个线性变换层,将注意力大小映射到单个注意力值,且无偏置
nn.Linear(attention_size, 1, bias=False)
)
return model
1 |
|
在下面的例子中,编码器的时间步数为10,批量大小为4,编码器和解码器的隐藏单元个数均为8。注意力机制返回一个小批量的背景向量,每个背景向量的长度等于编码器的隐藏单元个数。因此输出的形状为(4, 8)。
1 |
|
4.2.3 含注意力机制的解码器
我们直接将编码器在最终时间步的隐藏状态作为解码器的初始隐藏状态。这要求编码器和解码器的循环神经网络使用相同的隐藏层个数和隐藏单元个数。
在解码器的前向计算中,我们先通过刚刚介绍的注意力机制计算得到当前时间步的背景向量。由于解码器的输入来自输出语言的词索引,我们将输入通过词嵌入层得到表征,然后和背景向量在特征维连结。我们将连结后的结果与上一时间步的隐藏状态通过门控循环单元计算出当前时间步的输出与隐藏状态。最后,我们将输出通过全连接层变换为有关各个输出词的预测,形状为(批量大小,
输出词典大小)。 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32class Decoder(nn.Module):
def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
attention_size, drop_prob=0):
super(Decoder, self).__init__()
# 定义词嵌入层,将词汇表中的词转换为指定维度的词向量
self.embedding = nn.Embedding(vocab_size, embed_size)
# 定义注意力模型,输入大小为2*num_hiddens,注意力大小为attention_size
self.attention = attention_model(2 * num_hiddens, attention_size)
# 定义GRU层,输入大小为num_hiddens + embed_size,输出大小为num_hiddens
self.rnn = nn.GRU(num_hiddens + embed_size, num_hiddens,
num_layers, dropout=drop_prob)
# 定义线性层,将GRU的输出转换为词汇表大小的输出
self.out = nn.Linear(num_hiddens, vocab_size)
def forward(self, cur_input, state, enc_states):
"""
cur_input shape: (batch, )
state shape: (num_layers, batch, num_hiddens)
"""
# 使用注意力机制计算背景向量
c = attention_forward(self.attention, enc_states, state[-1])
# 将嵌入后的输入和背景向量在特征维连结, (批量大小, num_hiddens + embed_size)
input_and_c = torch.cat((self.embedding(cur_input), c), dim=1)
# 为输入和背景向量的连结增加时间步维,时间步个数为1
output, state = self.rnn(input_and_c.unsqueeze(0), state)
# 移除时间步维,输出形状为(批量大小, 输出词典大小)
output = self.out(output).squeeze(dim=0)
return output, state
def begin_state(self, enc_state):
# 直接将编码器最终时间步的隐藏状态作为解码器的初始隐藏状态
return enc_state
4.3 训练模型
我们先实现batch_loss
函数计算一个小批量的损失。解码器在最初时间步的输入是特殊字符BOS
。之后,解码器在某时间步的输入为样本输出序列在上一时间步的词,即强制教学。此外,同word2vec的实现一样,我们在这里也使用掩码变量避免填充项对损失函数计算的影响。
1 |
|
1 |
|
1 |
|
4.4 预测不定长序列
这里我们实现最简单的贪婪搜索。1 |
|
1 |
|
4.5 评价翻译结果
评价机器翻译结果通常使用BLEU(Bilingual Evaluation Understudy)[1]。对于模型预测序列中任意的子序列,BLEU考察这个子序列是否出现在标签序列中。
具体来说,设词数为
其中
因为匹配较长子序列比匹配较短子序列更难,BLEU对匹配较长子序列的精度赋予了更大权重。例如,当
下面来实现BLEU的计算。 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19def bleu(pred_tokens, label_tokens, k):
len_pred, len_label = len(pred_tokens), len(label_tokens) # 获取预测序列和标签序列的长度
score = math.exp(min(0, 1 - len_label / len_pred)) # 计算BLEU分数中的长度惩罚因子
for n in range(1, k + 1): # 对每个n-gram进行计算
num_matches, label_subs = 0, collections.defaultdict(int) # 初始化匹配数量和子序列字典
for i in range(len_label - n + 1): # 遍历标签序列中的n-gram
label_subs[''.join(label_tokens[i: i + n])] += 1 # 统计标签序列中n-gram的出现次数
for i in range(len_pred - n + 1): # 遍历预测序列中的n-gram
ngram = ''.join(pred_tokens[i: i + n]) # 获取预测序列中的n-gram
if label_subs[ngram] > 0: # 如果该n-gram在标签序列中出现
num_matches += 1 # 匹配数量加一
label_subs[ngram] -= 1 # 标签序列中的n-gram数量减一
# 计算n-gram的精确度,并更新BLEU分数
score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
return score # 返回BLEU分数1
2
3
4
5
6
7
8def score(input_seq, label_seq, k):
# 翻译输入序列
pred_tokens = translate(encoder, decoder, input_seq, max_seq_len)
# 将标签序列分词
label_tokens = label_seq.split(' ')
# 计算BLEU分数并打印预测结果
print('bleu %.3f, predict: %s' % (bleu(pred_tokens, label_tokens, k),
' '.join(pred_tokens)))1
score('ils regardent .', 'they are watching .', k=2)
1 |
|
五、拓展讨论
5.1 Question ①
如果编码器和解码器的隐藏单元个数不同或层数不同,我们该如何改进解码器的隐藏状态初始化方法?
正常情况下,解码器的隐藏状态初始化通常依赖于编码器的最后隐藏状态。若编码器和解码器的隐藏单元个数或层数不同,则会引发一系列问题:
若编码器和解码器的隐藏单元个数不同,在初始化解码器的隐藏状态时,会遇到维度不匹配的问题,导致解码器的初始状态无法正确初始化。此时,若直接将编码器的隐藏状态用于解码器,可能会丢失部分信息或增加冗余信息,导致训练过程中的梯度更新不稳定,影响模型收敛。
若编码器和解码器的层数不同,同样会造成类似的问题。
以下讨论不同情况下的改进方案:
5.1.1 隐藏单元个数不同
当编码器和解码器的隐藏单元个数不同(即
这样,编码器的输出通过线性变换适配到解码器的隐藏单元维度。
5.1.2 层数不同
如果编码器和解码器的层数不同(
1.选择特定层的隐藏状态:
如果解码器的层数少于编码器(
例如,假设编码器有 3 层(
这里,
2.逐层初始化:
如果解码器的层数多于编码器(
例如,假设编码器有 2 层(
3.拼接和投影:
将编码器所有层的隐藏状态进行拼接,然后通过线性变换投影到解码器的初始隐藏状态维度。
假设编码器有
然后通过线性变换得到解码器的初始隐藏状态:
其中,
通过上述方法,可以一定程度上解决隐藏单元个数不同和层数不同的问题。
5.2 Question ②
在训练中,将强制教学替换为使用解码器在上一时间步的输出作为解码器在当前时间步的输入。结果有什么变化吗?
该问题可以等价为两种训练模式的对比,即 free-running mode 和 teacher-forcing mode。
5.2.1 Teacher-Forcing Mode
在强制教学模式(Teacher-Forcing Mode)中,模型在每个时间步的输入使用的是来自先验时间步长的真实目标序列中的词汇,即直接使用训练数据的标准答案的对应上一项作为下一个state的输入。
这种训练模式的特点在于:
由于每一步的输入都是正确的,模型可以快速学习序列中的正确映射关系。
更快地收敛。
错误不会在网络中传播,避免了由于早期错误导致的后续预测错误。
在训练时,模型总是看到正确的上下文,而在推理时,模型需要使用自己的预测结果作为输入,可能导致性能下降(因为训练和推理时的输入分布不一致)。
5.2.2 Free-Running Mode
在每个时间步的输入使用的是上一个时间步模型自身生成的输出。其特点在于:
训练和推理时使用相同的策略(区别于Teacher-Forcing的特点4),减少了暴露偏差,提高了模型在实际应用中的性能。
由于模型在早期时间步中生成的错误会在后续时间步中传播和累积,模型更难收敛。
综上所述,将Teacher-Forcing Mode替换为Free-Running Mode后,可能会增强模型的鲁棒性,提升测试集上的性能,但会导致训练收敛速度变慢。
5.3 Question ③
为什么不可以将解码器在不同时间步的隐藏状态
连结成查询项矩阵 ,从而同时计算不同时间步的含注意力机制的背景变量 ?
Reason: 解码器的逐步依赖关系
在seq2seq模型中,解码器的隐藏状态
其中
其中
而
由于解码器每一步的隐藏状态
结合上述内容,如果尝试将解码器在不同时间步的隐藏状态连结成查询项矩阵
那么我们会发现我们无法在计算
综上,由于解码器每个时间步的隐藏状态
5.4 Question ④
已知门控循环单元(GRU)中的
gru
函数如下,应如何用它实现本节介绍的解码器?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def gru(inputs, state, params):
# 解包参数
W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params
H, = state # 解包初始隐藏状态
outputs = [] # 用于存储每个时间步的输出
for X in inputs:
# 计算更新门 Z
Z = torch.sigmoid((X @ W_xz) + (H @ W_hz) + b_z)
# 计算重置门 R
R = torch.sigmoid((X @ W_xr) + (H @ W_hr) + b_r)
# 计算候选隐藏状态 H_tilda
H_tilda = torch.tanh((X @ W_xh) + ((R * H) @ W_hh) + b_h)
# 计算新的隐藏状态 H
H = Z * H + (1 - Z) * H_tilda
# 计算输出 Y
Y = H @ W_hq + b_q
outputs.append(Y) # 将输出添加到列表中
# 将所有时间步的输出连接成一个张量,并返回最终隐藏状态
return torch.cat(outputs, dim=0), (H,)
下文尝试在gru函数的基础上,讨论实现本节中解码器的具体步骤:
解码器的实现步骤
初始化:
初始隐藏状态 为零向量。
为输入 添加开始标记 。
初始化模型参数,包括GRU的权重矩阵和偏置。逐步解码: 对于每个解码时间步
:A. 计算背景向量:
根据解码器的当前隐藏状态
和编码器的隐藏状态序列 ,计算背景向量 。B. 计算重置门、更新门和候选隐藏状态:
C. 更新隐藏状态:
D. 输出:
根据当前隐藏状态
生成当前时间步的输出 。返回解码序列:
输出整个解码序列
通过上述步骤,解码器通过GRU单元和注意力机制逐步生成输出序列。