NLP基于循环神经网络的机器翻译

一、背景介绍

自然语言处理(NLP)是人工智能领域的一个重要分支，其主要关注于计算机理解和生成人类语言。机器翻译(Machine Translation，MT)是NLP的一个重要应用，它旨在将一种自然语言翻译成另一种自然语言。随着大数据时代的到来，机器翻译技术的发展得到了重要推动。

在过去的几十年里，机器翻译技术经历了多种不同的阶段。初期的机器翻译技术主要基于统计学，如基于词袋模型(Bag of Words)的翻译方法。随着深度学习技术的兴起，机器翻译技术逐渐向后向全连接神经网络(Recurrent Neural Networks, RNN)、循环神经网络(Recurrent Neural Networks, LSTM)和最终的序列到序列模型(Sequence to Sequence, seq2seq)转变。

二、核心概念与联系

机器翻译的主要任务是将一种自然语言的文本翻译成另一种自然语言的文本。机器翻译可以分为 Statistical Machine Translation(统计机器翻译)和 Neural Machine Translation(神经机器翻译)两大类。

统计机器翻译使用统计学方法来建模语言模型，通常使用 n-gram 模型来描述文本的概率分布。这种方法的主要优点是不需要大量的训练数据，但是翻译质量受限于模型的简单性。

神经机器翻译则利用深度学习和神经网络技术，能够生成更高质量的翻译。神经机器翻译的主要组成部分包括：

Encoder：将源语言文本编码为向量表示
Decoder：将目标语言文本解码为向量表示
Attention：帮助翻译器关注源语言文本中的关键信息
神经机器翻译的核心算法是序列到序列(Seq2Seq)模型，它将输入序列映射到输出序列。Seq2Seq模型由编码器和解码器组成，编码器将源语言文本编码为向量，解码器将目标语言文本解码为向量。

三、核心算法原理及代码实现

3.1Seq2Seq模型基础

Seq2Seq模型是一种递归神经网络(RNN)的变种，用于解决序列到序列的映射问题。Seq2Seq模型的主要组成部分包括：

编码器(Encoder)：将源语言文本编码为向量表示
解码器(Decoder)：将目标语言文本解码为向量表示
编码器和解码器都是RNN的变种，可以是LSTM(长短期记忆网络)或GRU(门控递归单元)。

上图描述了使用编码器—解码器将上述英语句子翻译成法语句子的一种方法。在训练数据集中，我们可以在每个句子后附上特殊符号“<eos>”（end of sequence）以表示序列的终止。编码器每个时间步的输入依次为英语句子中的单词、标点和特殊符号“<eos>”。图10.8中使用了编码器在最终时间步的隐藏状态作为输入句子的表征或编码信息。解码器在各个时间步中使用输入句子的编码信息和上个时间步的输出以及隐藏状态作为输入。我们希望解码器在各个时间步能正确依次输出翻译后的法语单词、标点和特殊符号"<eos>"。需要注意的是，解码器在最初时间步的输入用到了一个表示序列开始的特殊符号"<bos>"（beginning of sequence）。

3.1.1编码器

编码器的作用是把一个不定长的输入序列变换成一个定长的背景变量𝑐，并在该背景变量中编码输入序列信息。常用的编码器是循环神经网络。

编码器的具体操作步骤如下：

1. 将源词序列编码为词嵌入向量。词嵌入是预训练好的向量，可以捕捉词汇的语义信息。
2. 将词嵌入向量输入到RNN(LSTM或GRU)网络中，获取隐藏状态向量。
3. 对于每个时间步，更新隐藏状态向量。

整个编码过程可以总结为：在时间步，对输入的特征向量和前一时间步的隐藏状态进行函数运算，得到当前时间步的隐藏状态。然后通过对每个时间步的隐藏状态进行q函数处理，得到最终的背景变量来展示输入序列的全局信息。

3.1.2解码器

解码器的主要任务是将目标语言文本(目标词序列)解码为向量表示。解码器的输入是目标词序列，输出是一个隐藏状态向量。隐藏状态向量捕捉目标词序列的语义信息。

解码器的具体操作步骤如下：

将目标词序列编码为词嵌入向量。
将词嵌入向量与编码器的隐藏状态向量相加，得到新的隐藏状态向量。
将新的隐藏状态向量输入到RNN(LSTM或GRU)网络中，获取隐藏状态向量。
对于每个时间步，更新隐藏状态向量。

根据前一个时间步的预测向量和隐藏状态，结合得到的背景变量,变换为当前时间步的隐藏状态,然后可以结合输出层和softmax得到各个位置的概率分布，从而生成该时间步的元素。

3.1.3注意力机制

Attention机制是Seq2Seq模型的一个变种，可以帮助翻译器关注源语言文本中的关键信息。Attention机制允许解码器在翻译每个目标词时，关注源语言文本中的某个词。

Attention机制的具体操作步骤如下：

计算源语言文本中每个词与目标词的相似度。相似度可以通过内积或其他距离度量计算。
对计算出的相似度进行softmax归一化，得到一个概率分布。
根据概率分布选择源语言文本中的一个词，作为当前目标词的关注词。
将关注词与解码器的隐藏状态向量相加，得到新的隐藏状态向量。

其中是在时间步的隐藏状态，总时间步数为, 是解码器在时间步的隐藏状态。

我们根据最初注意力机制提出的论文中的函数进行计算，它是通过单隐层的多层感知机进行变换得到的：

3.1.4模型训练

根据最大似然估计，我们可以最大化输出序列基于输入序列的条件概率

并得到该输出序列的损失

在模型训练中，所有输出序列损失的均值通常作为需要最小化的损失函数。

3.2代码

3.2.1基础设置

调用基于pytorch框架的d2l库离线安装包进行环境的配置（d2lzh_pytorch.tar）

!tar -xf d2lzh_pytorch.tar

相关库的导入

import 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>'
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

print(torch.__version__, device)

接着定义两个辅助函数对后面读取的数据进行预处理。

# 将一个序列中所有的词记录在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)

# 使用所有的词来构造词典。并将所有序列中的词变换为词索引后构造Tensor
def build_data(all_tokens, all_seqs):
    vocab = Vocab.Vocab(collections.Counter(all_tokens),
                        specials=[PAD, BOS, EOS])
    indices = [[vocab.stoi[w] for w in seq] for seq in all_seqs]
    return vocab, torch.tensor(indices)

为了演示方便，我们在这里使用一个很小的法语—英语数据集。在这个数据集里，每一行是一对法语句子和它对应的英语句子，中间使用'\t'隔开。在读取数据时，我们在句末附上“<eos>”符号，并可能通过添加“<pad>”符号使每个序列的长度均为max_seq_len。我们为法语词和英语词分别创建词典。法语词的索引和英语词的索引相互独立。

def read_data(max_seq_len):
    # in和out分别是input和output的缩写
    in_tokens, out_tokens, in_seqs, out_seqs = [], [], [], []
    with io.open('fr-en-small.txt') as f:
        lines = f.readlines()
    for line in lines:
        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, Data.TensorDataset(in_data, out_data)

将序列的最大长度设成7，然后查看读取到的第一个样本。该样本分别包含法语词索引序列和英语词索引序列。

max_seq_len = 7
in_vocab, out_vocab, dataset = read_data(max_seq_len)
dataset[0]

3.2.2编码器

在编码器中，我们将输入语言的词索引通过词嵌入层得到词的表征，然后输入到一个多层门控循环单元中。PyTorch的nn.GRU实例在前向计算后也会分别返回输出和最终时间步的多层隐藏状态。其中的输出指的是最后一层的隐藏层在各个时间步的隐藏状态，并不涉及输出层计算。注意力机制将这些输出作为键项和值项。

class 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)
        self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=drop_prob)

    def forward(self, inputs, state):
        # 输入形状是(批量大小, 时间步数)。将输出互换样本维和时间步维
        embedding = self.embedding(inputs.long()).permute(1, 0, 2) # (seq_len, batch, input_size)
        return self.rnn(embedding, state)

    def begin_state(self):
        return None

下面我们来创建一个批量大小为4、时间步数为7的小批量序列输入。设门控循环单元的隐藏层个数为2，隐藏单元个数为16。编码器对该输入执行前向计算后返回的输出形状为(时间步数, 批量大小, 隐藏单元个数)。门控循环单元在最终时间步的多层隐藏状态的形状为(隐藏层个数, 批量大小, 隐藏单元个数)。对于门控循环单元来说，state就是一个元素，即隐藏状态；如果使用长短期记忆，state是一个元组，包含两个元素即隐藏状态和记忆细胞。

encoder = Encoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)
output, state = encoder(torch.zeros((4, 7)), encoder.begin_state())
output.shape, state.shape # GRU的state是h, 而LSTM的是一个元组(h, c)

3.2.3注意力机制

将输入连结后通过含单隐藏层的多层感知机变换。其中隐藏层的输入是解码器的隐藏状态与编码器在所有时间步上隐藏状态的一一连结，且使用tanh函数作为激活函数。输出层的输出个数为1。两个Linear实例均不使用偏差。其中函数𝑎𝑎定义里向量𝑣𝑣的长度是一个超参数，即attention_size。

def attention_model(input_size, attention_size):
    model = nn.Sequential(nn.Linear(input_size, attention_size, bias=False),
                          nn.Tanh(),
                          nn.Linear(attention_size, 1, bias=False))
    return model

注意力机制的输入包括查询项、键项和值项。设编码器和解码器的隐藏单元个数相同。这里的查询项为解码器在上一时间步的隐藏状态，形状为(批量大小, 隐藏单元个数)；键项和值项均为编码器在所有时间步的隐藏状态，形状为(时间步数, 批量大小, 隐藏单元个数)。注意力机制返回当前时间步的背景变量，形状为(批量大小, 隐藏单元个数)。

def attention_forward(model, enc_states, dec_state):
    """
    enc_states: (时间步数, 批量大小, 隐藏单元个数)
    dec_state: (批量大小, 隐藏单元个数)
    """
    # 将解码器隐藏状态广播到和编码器隐藏状态形状相同后进行连结
    dec_states = dec_state.unsqueeze(dim=0).expand_as(enc_states)
    enc_and_dec_states = torch.cat((enc_states, dec_states), dim=2)
    e = model(enc_and_dec_states)  # 形状为(时间步数, 批量大小, 1)
    alpha = F.softmax(e, dim=0)  # 在时间步维度做softmax运算
    return (alpha * enc_states).sum(dim=0)  # 返回背景变量

在下面的例子中，编码器的时间步数为10，批量大小为4，编码器和解码器的隐藏单元个数均为8。注意力机制返回一个小批量的背景向量，每个背景向量的长度等于编码器的隐藏单元个数。因此输出的形状为(4, 8)。

seq_len, batch_size, num_hiddens = 10, 4, 8
model = attention_model(2*num_hiddens, 10) 
enc_states = torch.zeros((seq_len, batch_size, num_hiddens))
dec_state = torch.zeros((batch_size, num_hiddens))
attention_forward(model, enc_states, dec_state).shape

3.2.4含注意力机制的解码器

我们直接将编码器在最终时间步的隐藏状态作为解码器的初始隐藏状态。这要求编码器和解码器的循环神经网络使用相同的隐藏层个数和隐藏单元个数。

在解码器的前向计算中，我们先通过刚刚介绍的注意力机制计算得到当前时间步的背景向量。由于解码器的输入来自输出语言的词索引，我们将输入通过词嵌入层得到表征，然后和背景向量在特征维连结。我们将连结后的结果与上一时间步的隐藏状态通过门控循环单元计算出当前时间步的输出与隐藏状态。最后，我们将输出通过全连接层变换为有关各个输出词的预测，形状为(批量大小, 输出词典大小)。

class 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)
        self.attention = attention_model(2*num_hiddens, attention_size)
        # GRU的输入包含attention输出的c和实际输入, 所以尺寸是 num_hiddens+embed_size
        self.rnn = nn.GRU(num_hiddens + embed_size, num_hiddens, 
                          num_layers, dropout=drop_prob)
        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

3.2.5训练模型

我们先实现batch_loss函数计算一个小批量的损失。解码器在最初时间步的输入是特殊字符BOS。之后，解码器在某时间步的输入为样本输出序列在上一时间步的词，即强制教学。此外，我们在这里也使用掩码变量避免填充项对损失函数计算的影响。

def batch_loss(encoder, decoder, X, Y, loss):
    batch_size = X.shape[0]
    enc_state = encoder.begin_state()
    enc_outputs, enc_state = encoder(X, enc_state)
    # 初始化解码器的隐藏状态
    dec_state = decoder.begin_state(enc_state)
    # 解码器在最初时间步的输入是BOS
    dec_input = torch.tensor([out_vocab.stoi[BOS]] * batch_size)
    # 我们将使用掩码变量mask来忽略掉标签为填充项PAD的损失, 初始全1
    mask, num_not_pad_tokens = torch.ones(batch_size,), 0
    l = torch.tensor([0.0])
    for y in Y.permute(1,0): # Y shape: (batch, seq_len)
        dec_output, dec_state = decoder(dec_input, dec_state, enc_outputs)
        l = l + (mask * loss(dec_output, y)).sum()
        dec_input = y  # 使用强制教学
        num_not_pad_tokens += mask.sum().item()
        # EOS后面全是PAD. 下面一行保证一旦遇到EOS接下来的循环中mask就一直是0
        mask = mask * (y != out_vocab.stoi[EOS]).float()
    return l / num_not_pad_tokens

在训练函数中，我们需要同时迭代编码器和解码器的模型参数。

def train(encoder, decoder, dataset, lr, batch_size, num_epochs):
    # 初始化编码器和解码器的优化器，这里使用Adam优化器，学习率为lr
    enc_optimizer = torch.optim.Adam(encoder.parameters(), lr=lr)
    dec_optimizer = torch.optim.Adam(decoder.parameters(), lr=lr)
     # 定义损失函数为交叉熵损失，reduction='none'意味着不对loss进行任何降维操作
    loss = nn.CrossEntropyLoss(reduction='none')
    # 使用DataLoader创建数据迭代器，用于批量加载数据，batch_size指定每批数据量，shuffle设为True随机打乱数据
    data_iter = Data.DataLoader(dataset, batch_size, shuffle=True)
    for epoch in range(num_epochs):
        l_sum = 0.0
        for X, Y in data_iter:
            # 梯度清零，以清除之前批次的梯度信息，避免梯度累积
            enc_optimizer.zero_grad()
            dec_optimizer.zero_grad()
             # 计算当前批次的损失
            l = batch_loss(encoder, decoder, X, Y, loss)
             # 反向传播计算梯度
            l.backward()
            # 更新编码器和解码器的参数
            enc_optimizer.step()
            dec_optimizer.step()
            # 累加当前批次的损失
            l_sum += l.item()
            # 每10个epoch打印一次当前训练状态
        if (epoch + 1) % 10 == 0:
            print("epoch %d, loss %.3f" % (epoch + 1, l_sum / len(data_iter)))

接下来，创建模型实例并设置超参数。然后，我们就可以训练模型了。

embed_size, num_hiddens, num_layers = 64, 64, 2
attention_size, drop_prob, lr, batch_size, num_epochs = 10, 0.5, 0.01, 2, 50
encoder = Encoder(len(in_vocab), embed_size, num_hiddens, num_layers,
                  drop_prob)
decoder = Decoder(len(out_vocab), embed_size, num_hiddens, num_layers,
                  attention_size, drop_prob)
train(encoder, decoder, dataset, lr, batch_size, num_epochs)

3.2.6预测不定长的序列

束搜索（beam search）是对贪婪搜索的一个改进算法。它有一个束宽（beam size）超参数。我们将它设为𝑘。在时间步1时，选取当前时间步条件概率最大的𝑘个词，分别组成𝑘个候选输出序列的首词。在之后的每个时间步，基于上个时间步的𝑘个候选输出序列，从𝑘个可能的输出序列中选取条件概率最大的𝑘个，作为该时间步的候选输出序列。最终，我们从各个时间步的候选输出序列中筛选出包含特殊符号“<eos>”的序列，并将它们中所有特殊符号“<eos>”后面的子序列舍弃，得到最终候选输出序列的集合。

在最终候选输出序列的集合中，我们取以下分数最高的序列作为输出序列：

def translate(encoder, decoder, input_seq, max_seq_len):
    in_tokens = input_seq.split(' ')# 将输入序列按空格分割成单词列表
    in_tokens += [EOS] + [PAD] * (max_seq_len - len(in_tokens) - 1)# 在输入序列末尾添加结束符EOS，然后用PAD符号填充至最大序列长度
    enc_input = torch.tensor([[in_vocab.stoi[tk] for tk in in_tokens]]) # batch=1# 将单词转换为索引，并构造为适合模型输入的张量形状 (batch=1, sequence_length)
    enc_state = encoder.begin_state()# 初始化编码器的状态
    enc_output, enc_state = encoder(enc_input, enc_state)# 通过编码器处理输入序列，得到编码输出enc_output和最终状态enc_state
    dec_input = torch.tensor([out_vocab.stoi[BOS]])# 初始化解码器的输入为目标词表的开始符BOS的索引，并构建初始解码状态基于编码器的最终状态
    dec_state = decoder.begin_state(enc_state)
    output_tokens = []# 用于保存输出序列的单词列表
    # 用于保存输出序列的单词列表
    for _ in range(max_seq_len):
        dec_output, dec_state = decoder(dec_input, dec_state, enc_output)# 解码器一步解码，得到输出和更新后的解码状态
        # 选择概率最高的词作为预测词
        pred = dec_output.argmax(dim=1)
        pred_token = out_vocab.itos[int(pred.item())]# 索引转回单词
        # 如果预测词为EOS，则停止生成；否则，将词添加到输出序列并更新解码器输入
        if pred_token == EOS:  
            break
        else:
            output_tokens.append(pred_token)
            dec_input = pred# 下一时间步的输入为当前预测词
    return output_tokens

简单测试一下模型。输入法语句子“ils regardent.”，翻译后的英语句子应该是“they are watching.”。

input_seq = 'ils regardent .'
translate(encoder, decoder, input_seq, max_seq_len)

3.2.7评价翻译结果

评价机器翻译结果通常使用BLEU（Bilingual Evaluation Understudy）[1]。对于模型预测序列中任意的子序列，BLEU考察这个子序列是否出现在标签序列中。

def bleu(pred_tokens, label_tokens, k):
    # 计算预测序列和参考标签序列的长度
    len_pred, len_label = len(pred_tokens), len(label_tokens)
    # 初始化BLEU分数，首先计算长度惩罚因子，避免过短的预测序列获得过高分数
    score = math.exp(min(0, 1 - len_label / len_pred))
    # 对于1到k的每个n-gram大小
    for n in range(1, k + 1):
        # 初始化匹配的数量和一个字典来存储参考标签中的n-gram计数
        num_matches, label_subs = 0, collections.defaultdict(int)
        # 遍历参考标签中的所有n-gram并计数 
        for i in range(len_label - n + 1):
            label_subs[''.join(label_tokens[i: i + n])] += 1
            # 遍历预测序列中的所有n-gram
        for i in range(len_pred - n + 1):
            # 如果预测的n-gram在参考标签的n-gram中出现过，则增加匹配数量并减少该n-gram的剩余计数
            if label_subs[''.join(pred_tokens[i: i + n])] > 0:
                num_matches += 1
                label_subs[''.join(pred_tokens[i: i + n])] -= 1
                # 更新BLEU分数，将当前n-gram大小的精确匹配率应用长度惩罚后乘入总分
        # 使用0.5的幂确保对较长的n-gram给予更多权重
        score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
    return score

接下来，定义一个辅助打印函数

def score(input_seq, label_seq, k):
    pred_tokens = translate(encoder, decoder, input_seq, max_seq_len)
    label_tokens = label_seq.split(' ')
    print('bleu %.3f, predict: %s' % (bleu(pred_tokens, label_tokens, k),
                                      ' '.join(pred_tokens)))
score('ils regardent .', 'they are watching .', k=2)
score('ils sont canadienne .', 'they are canadian .', k=2)

预测正确则分数为1。