深度学习d4：机器翻译及相关技术；注意力机制与Seq2seq模型；Transformer

机器翻译

指将一段文本从一种语言自动翻译到另一种语言

1. 读取和预处理数据

   # 将一个序列中所有的词记录在all_tokens中以便之后构造词典，然后在该序列后面添加PAD直到序列
   # 长度变为max_seq_len，然后将序列保存在all_seqs中
   def process_one_seq(seq_tokens, all_tokens, all_seqs, max_seq_len):
       all_tokens.extend(seq_tokens)
       seq_tokens += [EOS] + [PAD] * (max_seq_len - len(seq_tokens) - 1)
       all_seqs.append(seq_tokens)
   # 使用所有的词来构造词典。并将所有序列中的词变换为词索引后构造NDArray实例
   def build_data(all_tokens, all_seqs):
       vocab = text.vocab.Vocabulary(collections.Counter(all_tokens),
                                     reserved_tokens=[PAD, BOS, EOS])
       indices = [vocab.to_indices(seq) for seq in all_seqs]
       return vocab, nd.array(indices)
   

   使用

   def read_data(max_seq_len):
       # in和out分别是input和output的缩写
       in_tokens, out_tokens, in_seqs, out_seqs = [], [], [], []
       #读取法语-英语数据集
       with io.open('../data/fr-en-small.txt') as f: #
           lines = f.readlines()
       for line in lines:
           #法语和英语之间用\t分割的
           in_seq, out_seq = line.rstrip().split('\t') 
           #把法语和英语用空格分隔开
           in_seq_tokens, out_seq_tokens = in_seq.split(' '), out_seq.split(' ')
           if max(len(in_seq_tokens), len(out_seq_tokens)) > max_seq_len - 1:
               continue  # 如果加上EOS后长于max_seq_len，则忽略掉此样本
           #预处理序列
           process_one_seq(in_seq_tokens, in_tokens, in_seqs, max_seq_len)
           process_one_seq(out_seq_tokens, out_tokens, out_seqs, max_seq_len)
       #构造词典
       in_vocab, in_data = build_data(in_tokens, in_seqs)
       out_vocab, out_data = build_data(out_tokens, out_seqs)
       return in_vocab, out_vocab, gdata.ArrayDataset(in_data, out_data)
   

2. 含注意力机制的编码器—解码器

   编码器：
   将输入语言的词索引通过词嵌入层得到词的表征，然后输入到一个多层门控循环单元中。

   class Encoder(nn.Block):
   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)
       #循环神经网络
       self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=drop_prob)
   
   def forward(self, inputs, state):
       # 输入形状是(批量大小, 时间步数)。将输出互换样本维和时间步维
       embedding = self.embedding(inputs).swapaxes(0, 1)
       return self.rnn(embedding, state)
   
   def begin_state(self, *args, **kwargs):
       return self.rnn.begin_state(*args, **kwargs)
   

   注意力机制：

   • Dense的flatten选项
     当输入维度大于2时（即不止行列时），dense会默认把除第一维歪的维度均视作特征维，然后自动转换为行为样本、列为特征的二维矩阵。但若只希望将输入的最后一维作为特征，其他维度不变，那么就把Dense实例的flatten选项设为False。

训练时的模型：

预测时的模型：

两个是不一样的！

注意力机制

由来 ：翻译的过程像是解码器的每一时间步对输入序列中不同时间步的表征或编码信息分配不同的注意力一样。

以循环神经网络为例，注意力机制通过对编码器所有时间步的隐藏状态做加权平均来得到背景变量。解码器在每一时间步调整这些权重，即注意力权重，从而能够在不同时间步分别关注输入序列中的不同部分并编码进相应时间步的背景变量。（因人而异）

记${\mathbf{c}}_{t^{\prime }}$是解码器在时间步$t^{\prime }$的背景变量，那么解码器在该时间步的隐藏状态可以改写为

$${\mathbf{s}}_{t^{\prime }}=g({\mathbf{y}}_{t^{\prime }-1},{\mathbf{c}}_{t^{\prime }},{\mathbf{s}}_{t^{\prime }-1}).$$

难点在于：

1. 计算背景变量

首先，函数 𝑎 根据解码器在时间步1的隐藏状态和编码器在各个时间步的隐藏状态计算softmax运算的输入。softmax运算输出概率分布并对编码器各个时间步的隐藏状态做加权平均，从而得到背景变量。

具体来说，令编码器在时间步$t$的隐藏状态为${\mathbf{h}}_t$，且总时间步数为$T$。那么解码器在时间步$t^{\prime }$的背景变量为所有编码器隐藏状态的加权平均：

$${\mathbf{c}}_{t^{\prime }}=\sum _{t=1}^T{\alpha }_{t^{\prime }t}{\mathbf{h}}_t,$$

其中给定$t^{\prime }$时，权重${\alpha }_{t^{\prime }t}$在$t=1,\dots ,T$的值是一个概率分布。为了得到概率分布，我们可以使用softmax运算:

$${\alpha }_{t^{\prime }t}=\frac{\exp (e_{t^{\prime }t})}{{\sum }_{k=1}^T\exp (e_{t^{\prime }k})},t=1,\dots ,T.$$

现在，我们需要定义如何计算上式中softmax运算的输入$e_{t^{\prime }t}$。由于$e_{t^{\prime }t}$同时取决于解码器的时间步$t^{\prime }$和编码器的时间步$t$，我们不妨以解码器在时间步$t^{\prime }-1$的隐藏状态${\mathbf{s}}_{t^{\prime }-1}$与编码器在时间步$t$的隐藏状态${\mathbf{h}}_t$为输入，并通过函数$a$计算$e_{t^{\prime }t}$：

$$e_{t^{\prime }t}=a({\mathbf{s}}_{t^{\prime }-1},{\mathbf{h}}_t).$$

这里函数$a$有多种选择，如果两个输入向量长度相同，一个简单的选择是计算它们的内积$a(\mathbf{s},\mathbf{h})={\mathbf{s}}^{\top }\mathbf{h}$。而最早提出注意力机制的论文则将输入连结后通过含单隐藏层的多层感知机变换 [1]：

$$a(\mathbf{s},\mathbf{h})={\mathbf{v}}^{\top }\tanh ({\mathbf{W}}_s\mathbf{s}+{\mathbf{W}}_h\mathbf{h}),$$

其中$\mathbf{v}$、${\mathbf{W}}_s$、${\mathbf{W}}_h$都是可以学习的模型参数。

2. 矢量化计算
   因为矢量化计算更高效。
   考虑一个常见的简单情形，即编码器和解码器的隐藏单元个数均为$h$，且函数$a(\mathbf{s},\mathbf{h})={\mathbf{s}}^{\top }\mathbf{h}$。假设我们希望根据解码器单个隐藏状态${\mathbf{s}}_{t^{\prime }-1}\in {\mathbb{R}}^h$和编码器所有隐藏状态${\mathbf{h}}_t\in {\mathbb{R}}^h,t=1,\dots ,T$来计算背景向量${\mathbf{c}}_{t^{\prime }}\in {\mathbb{R}}^h$。
   我们可以将查询项矩阵$\mathbf{Q}\in {\mathbb{R}}^{1\times h}$设为${\mathbf{s}}_{t^{\prime }-1}^{\top }$，并令键项矩阵$\mathbf{K}\in {\mathbb{R}}^{T\times h}$和值项矩阵$\mathbf{V}\in {\mathbb{R}}^{T\times h}$相同且第$t$行均为${\mathbf{h}}_t^{\top }$。此时，我们只需要通过矢量化计算
   $$\text{softmax}(\mathbf{Q}{\mathbf{K}}^{\top })\mathbf{V}$$
   即可算出转置后的背景向量${\mathbf{c}}_{t^{\prime }}^{\top }$。当查询项矩阵$\mathbf{Q}$的行数为$n$时，上式将得到$n$行的输出矩阵。输出矩阵与查询项矩阵在相同行上一一对应。

3. 更新隐藏状态
   以门控循环单元为例，在解码器中我们可以对门控循环单元的设计稍作修改，从而变换上一时间步$t^{\prime }-1$的输出${\mathbf{y}}_{t^{\prime }-1}$、隐藏状态${\mathbf{s}}_{t^{\prime }-1}$和当前时间步$t^{\prime }$的含注意力机制的背景变量${\mathbf{c}}_{t^{\prime }}$ [1]。解码器在时间步$t^{\prime }$的隐藏状态为
   $${\mathbf{s}}_{t^{\prime }}={\mathbf{z}}_{t^{\prime }}\odot {\mathbf{s}}_{t^{\prime }-1}+(1-{\mathbf{z}}_{t^{\prime }})\odot {\tilde{\mathbf{s}}}_{t^{\prime }},$$
   其中的重置门、更新门和候选隐藏状态分别为
   $$\begin{array}{rl}{\mathbf{r}}_{t^{\prime }}& =\sigma ({\mathbf{W}}_{yr}{\mathbf{y}}_{t^{\prime }-1}+{\mathbf{W}}_{sr}{\mathbf{s}}_{t^{\prime }-1}+{\mathbf{W}}_{cr}{\mathbf{c}}_{t^{\prime }}+{\mathbf{b}}_r),\\ {\mathbf{z}}_{t^{\prime }}& =\sigma ({\mathbf{W}}_{yz}{\mathbf{y}}_{t^{\prime }-1}+{\mathbf{W}}_{sz}{\mathbf{s}}_{t^{\prime }-1}+{\mathbf{W}}_{cz}{\mathbf{c}}_{t^{\prime }}+{\mathbf{b}}_z),\\ {\tilde{\mathbf{s}}}_{t^{\prime }}& =\text{tanh}({\mathbf{W}}_{ys}{\mathbf{y}}_{t^{\prime }-1}+{\mathbf{W}}_{ss}({\mathbf{s}}_{t^{\prime }-1}\odot {\mathbf{r}}_{t^{\prime }})+{\mathbf{W}}_{cs}{\mathbf{c}}_{t^{\prime }}+{\mathbf{b}}_s),\end{array}$$
   其中含下标的$\mathbf{W}$和$\mathbf{b}$分别为门控循环单元的权重参数和偏差参数。

Transform

Transformer模型的架构，与seq2seq模型相似，Transformer同样基于编码器-解码器架构，其区别主要在于以下三点：

Transformer blocks：将seq2seq模型重的循环网络替换为了Transformer Blocks，该模块包含一个多头注意力层（Multi-head Attention Layers）以及两个position-wise feed-forward networks（FFN）。对于解码器来说，另一个多头注意力层被用于接受编码器的隐藏状态。
Add and norm：多头注意力层和前馈网络的输出被送到两个“add and norm”层进行处理，该层包含残差结构以及层归一化。
Position encoding：由于自注意力层并没有区分元素的顺序，所以一个位置编码层被用于向序列元素里添加位置信息。