自然语言处理之机器翻译

机器翻译是指将一段文本从一种语言自动翻译到另一种语言。因为一段文本序列在不同语言中的长度不一定相同，所以我们使用机器翻译为例来介绍编码器—解码器和注意力机制的应用。

一、数据读取和数据预处理

先定义一些特殊符号。其中“<pad>”（padding）符号用来添加在较短序列后，直到每个序列等长，而“<bos>”和“<eos>”符号分别表示序列的开始和结束。

!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  # 导入d2lzh_pytorch模块

# 定义常量
PAD, BOS, EOS = '<pad>', '<bos>', '<eos>'
os.environ["CUDA_VISIBLE_DEVICES"] = "0"  # 设置可见的GPU设备为0号设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 判断是否有可用的GPU，如果有则使用GPU，否则使用CPU

print(torch.__version__, device)  # 打印PyTorch版本和使用的设备信息

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

process_one_seq 函数

功能：

• 处理单个序列，将其转化为符合要求的格式，并添加到序列列表中。

参数：

• seq_tokens：一个包含序列中所有词的列表。
• all_tokens：一个包含所有序列中所有词的列表（用于构建词典）。
• all_seqs：一个包含所有处理后的序列的列表。
• max_seq_len：序列的最大长度。

具体步骤：

1. 将当前序列中的所有词添加到all_tokens中。
2. 在当前序列的末尾添加结束符EOS。
3. 如果序列长度不足最大长度，则在序列末尾填充PAD，直到长度为max_seq_len。
4. 将处理后的序列添加到all_seqs中。

build_data 函数

功能：

• 使用所有的词构建词典，并将所有序列中的词转换为词索引后构造Tensor。

参数：

• all_tokens：包含所有序列中所有词的列表。
• all_seqs：包含所有处理后的序列的列表。

具体步骤：

1. 使用torchtext.vocab.Vocab创建词典对象vocab，其中collections.Counter(all_tokens)用于统计每个词的频率，specials参数指定特殊符号（如PAD、BOS、EOS）。
2. 将所有序列中的词转换为对应的索引。vocab.stoi（string to index）将词映射到索引。
3. 构造一个包含所有序列索引的Tensor。

# 将一个序列中所有的词记录在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。我们为法语词和英语词分别创建词典。法语词的索引和英语词的索引相互独立。

read_data 函数

功能：

• 读取法语-英语句对数据，将其处理为符合最大序列长度限制的格式，并构建词汇表和索引Tensor。

参数：

• max_seq_len：序列的最大长度，超过该长度的句对将被忽略。

返回值：

• in_vocab：输入序列（法语）的词汇表。
• out_vocab：输出序列（英语）的词汇表。
• Data.TensorDataset：包含处理后的输入和输出序列索引的Tensor数据集。

具体步骤：

1. 初始化存储输入和输出序列及其词汇的列表。
2. 打开文件 fr-en-small.txt 并读取所有行。
3. 遍历每一行，将其分割成输入序列和输出序列。
4. 将输入和输出序列分别按空格分割成单词列表。
5. 如果序列长度加上结束符 EOS 超过最大长度 max_seq_len，则忽略该句对。
6. 处理输入序列和输出序列，将其转换为符合要求的格式。
7. 构建输入和输出的词汇表及其索引Tensor。
8. 返回输入词汇表、输出词汇表和数据集。

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(' ')
        # 如果加上EOS后长于max_seq_len，则忽略掉此样本
        if max(len(in_seq_tokens), len(out_seq_tokens)) > max_seq_len - 1:
            continue
        # 处理输入序列
        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]

结果如下：

二、含注意力机制的编码器—解码器

我们将使用含注意力机制的编码器—解码器来将一段简短的法语翻译成英语。下面我们来介绍模型的实现。

2.1编码器

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

Encoder 类

功能：

• 将输入序列（例如句子的词索引序列）编码为固定长度的隐藏状态序列，以便后续的解码器使用。

初始化方法 __init__：

• vocab_size：词汇表大小，即输入序列中不同词的数量。
• embed_size：词嵌入的维度大小，即每个词被表示成的向量的长度。
• num_hiddens：GRU隐藏层的单元数，即每个时间步的隐藏状态的大小。
• num_layers：GRU的层数。
• drop_prob：dropout的概率，用于正则化防止过拟合。
• **kwargs：其他可能的参数。

方法：

• forward(inputs, state)：前向传播过程。
  • inputs：输入序列，形状为 (batch_size, seq_len)。
  • state：GRU的初始隐藏状态。
  • embedding：通过嵌入层将输入序列转换为嵌入表示，并调整维度顺序以符合GRU的输入要求（形状为 (seq_len, batch_size, embed_size)）。
  • 返回 GRU 的输出和最终的隐藏状态。
• begin_state()：初始化隐藏状态，这里返回 None，表示 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)

2.2注意力机制

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

attention_model 函数

功能：

• 构建一个简单的注意力机制网络，接受输入特征并输出注意力权重。

参数：

• input_size：输入特征的维度大小。
• attention_size：注意力层的隐层单元数。

返回值：

• 返回一个 PyTorch nn.Sequential 模型，该模型包含两个全连接层和一个非线性激活函数 Tanh。

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

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

attention_forward 函数

功能：

• 计算注意力机制中的背景变量（context vector）。

参数：

• model：注意力模型，用于计算注意力得分。
• enc_states：（时间步数, 批量大小, 隐藏单元个数），编码器的隐藏状态。
• dec_state：（批量大小, 隐藏单元个数），解码器的隐藏状态。

返回值：

• 返回背景变量，形状为（批量大小, 隐藏单元个数）。

详细解释：

1. 解码器状态广播并连接：

   dec_states = dec_state.unsqueeze(dim=0).expand_as(enc_states)
   enc_and_dec_states = torch.cat((enc_states, dec_states), dim=2)
   
   

   • dec_state.unsqueeze(dim=0)：将解码器隐藏状态的形状从 (批量大小, 隐藏单元个数) 扩展到 (1, 批量大小, 隐藏单元个数)。
   • .expand_as(enc_states)：将解码器隐藏状态广播到与编码器隐藏状态相同的形状 (时间步数, 批量大小, 隐藏单元个数)。
   • torch.cat((enc_states, dec_states), dim=2)：在最后一个维度上连接编码器和解码器的隐藏状态，得到形状为 (时间步数, 批量大小, 2 * 隐藏单元个数) 的张量。

2. 计算注意力得分：

   e = model(enc_and_dec_states)  # 形状为(时间步数, 批量大小, 1)
   

   • 使用注意力模型 model 对连接后的张量进行计算，得到注意力得分 e，形状为 (时间步数, 批量大小, 1)。

3. 计算注意力权重：

   alpha = F.softmax(e, dim=0)  # 在时间步维度做softmax运算
   

   • 在时间步维度（即第0维度）上对注意力得分 e 进行 softmax 运算，得到注意力权重 alpha，形状为 (时间步数, 批量大小, 1)。

4. 计算背景变量（context vector）：

   return (alpha * enc_states).sum(dim=0)  # 返回背景变量
   

   • 将注意力权重 alpha 与编码器的隐藏状态 enc_states 相乘，然后在时间步维度（即第0维度）上求和，得到背景变量，形状为 (批量大小, 隐藏单元个数)。

示例：

假设我们有以下参数：

• model 是一个定义好的注意力模型。
• enc_states 是编码器的隐藏状态，形状为 (时间步数, 批量大小, 隐藏单元个数)。
• dec_state 是解码器的隐藏状态，形状为 (批量大小, 隐藏单元个数)。

我们可以调用 attention_forward 函数计算背景变量：

import torch
import torch.nn as nn
import torch.nn.functional as F

# 假设输入的维度
time_steps = 10
batch_size = 4
hidden_size = 256
attention_size = 128

# 随机生成输入数据
enc_states = torch.rand(time_steps, batch_size, hidden_size)
dec_state = torch.rand(batch_size, hidden_size)

# 定义注意力模型
att_model = attention_model(2 * hidden_size, attention_size)

# 计算背景变量
context_vector = attention_forward(att_model, enc_states, dec_state)

print(context_vector.shape)  # 输出的形状应该是 (batch_size, hidden_size)

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

2.3含注意力机制的解码器

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

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

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

 

该 Decoder 类实现了基于注意力机制的解码器，继承自 nn.Module。它主要包括嵌入层、注意力层、GRU 层和输出层。以下是 Decoder 类的详细解释：

__init__ 方法

该方法用于初始化解码器的各个层，包括嵌入层、注意力模型、GRU 层和输出层。

• vocab_size：词汇表的大小。
• embed_size：嵌入层的大小。
• num_hiddens：GRU 隐藏单元的数量。
• num_layers：GRU 层数。
• attention_size：注意力机制中的隐藏单元数。
• drop_prob：dropout 概率，默认为 0。

forward 方法

该方法实现了前向传播过程，主要包括计算注意力背景向量、GRU 前向传播和生成输出。

• cur_input：当前时间步的输入，形状为 (batch,)。
• state：解码器的隐藏状态，形状为 (num_layers, batch, num_hiddens)。
• enc_states：编码器的隐藏状态，形状为 (时间步数, 批量大小, 隐藏单元个数)。

c = attention_forward(self.attention, enc_states, state[-1])

 使用注意力机制计算背景向量 c，形状为 (batch, num_hiddens)。

input_and_c = torch.cat((self.embedding(cur_input), c), dim=1)

将嵌入后的输入和背景向量在特征维度上连接，得到形状为 (batch, num_hiddens + embed_size) 的张量

output, state = self.rnn(input_and_c.unsqueeze(0), state)

将输入和背景向量的连接结果增加一个时间步维度，传入 GRU 层，进行前向传播。得到的 output 形状为 (1, batch, num_hiddens)，state 为更新后的隐藏状态。

output = self.out(output).squeeze(dim=0)

移除时间步维度，输出形状为 (batch, vocab_size)。

begin_state 方法

该方法用于初始化解码器的隐藏状态，直接将编码器的最终时间步的隐藏状态作为解码器的初始隐藏状态。

示例使用

以下是一个使用 Encoder 和 Decoder 的示例，展示了如何构建模型并进行前向传播：

import torch
from torch import nn
import torch.nn.functional as F

# 假设输入的维度
vocab_size = 10000
embed_size = 300
num_hiddens = 256
num_layers = 2
attention_size = 128
batch_size = 4
seq_len = 10

# 创建编码器和解码器
encoder = Encoder(vocab_size, embed_size, num_hiddens, num_layers)
decoder = Decoder(vocab_size, embed_size, num_hiddens, num_layers, attention_size)

# 随机生成输入数据
enc_inputs = torch.randint(0, vocab_size, (batch_size, seq_len))
dec_inputs = torch.randint(0, vocab_size, (batch_size,))

# 编码器前向传播
enc_state = encoder.begin_state()
enc_outputs, enc_state = encoder(enc_inputs, enc_state)

# 解码器前向传播
dec_state = decoder.begin_state(enc_state)
dec_output, dec_state = decoder(dec_inputs, dec_state, enc_outputs)

print(dec_output.shape)  # 输出的形状应该是 (batch_size, vocab_size)

三、训练模型

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

batch_loss 函数

该函数 batch_loss 实现了一个批次的损失计算过程。它将编码器和解码器的输出与实际标签进行比较，计算损失，并在解码过程中应用了掩码以忽略填充项。

函数参数

• encoder：编码器模型。
• decoder：解码器模型。
• X：输入序列，形状为 (batch_size, seq_len)。
• Y：目标序列，形状为 (batch_size, seq_len)。
• loss：损失函数（例如，交叉熵损失）。

• Y.permute(1, 0) 将目标序列的形状从 (batch_size, seq_len) 变为 (seq_len, batch_size) 以便按时间步处理。
• 对每个时间步 y：
  • 解码器前向传播：获取当前时间步的解码输出 dec_output 和新的隐藏状态 dec_state。
  • 计算损失：将当前时间步的损失 l 累加到总损失中。
  • 更新输入：将当前时间步的目标 y 作为下一个时间步的输入（使用强制教学）。
  • 更新计数器：累加非填充项的数量。
  • 更新掩码：一旦遇到 EOS，后续的掩码值都将变为 0。

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

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

函数参数

• encoder: 编码器模型实例。
• decoder: 解码器模型实例。
• dataset: 训练数据集，通常是一个 torch.utils.data.Dataset 对象。
• lr: Adam 优化器的学习率。
• batch_size: 每个小批量中的样本数量。
• num_epochs: 训练的总轮数。

def train(encoder, decoder, dataset, lr, batch_size, num_epochs):
    enc_optimizer = torch.optim.Adam(encoder.parameters(), lr=lr)
    dec_optimizer = torch.optim.Adam(decoder.parameters(), lr=lr)

    loss = nn.CrossEntropyLoss(reduction='none')
    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()
        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)

结果如下：

四、预测不定长的序列

这里我们实现最简单的贪婪搜索。

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)
    enc_input = torch.tensor([[in_vocab.stoi[tk] for tk in in_tokens]]) # batch=1
    enc_state = encoder.begin_state()
    enc_output, enc_state = encoder(enc_input, enc_state)
    dec_input = torch.tensor([out_vocab.stoi[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())]
        if pred_token == EOS:  # 当任一时间步搜索出EOS时，输出序列即完成
            break
        else:
            output_tokens.append(pred_token)
            dec_input = pred
    return output_tokens

函数参数

• encoder: 训练好的编码器模型实例。
• decoder: 训练好的解码器模型实例。
• input_seq: 输入的源语言序列，作为字符串。
• max_seq_len: 最大的输出序列长度，用于限制翻译的最大长度。

函数过程

1. 输入序列处理:

   将输入序列 input_seq 按空格分割成单词，并在末尾添加结束符 EOS 和填充符 PAD，以确保序列长度达到 max_seq_len。

2. 输入序列索引化:

   使用输入词汇表 in_vocab 将单词序列转换为对应的索引，并构造成一个 Tensor，其中 batch=1 表示一次翻译一个句子。

3. 编码器编码:

   使用编码器 encoder 对输入序列进行编码，得到编码器的输出 enc_output 和最终状态 enc_state。

4. 解码器初始化:

   将解码器的初始输入设置为开始符号 BOS 对应的索引，并使用编码器的最终状态初始化解码器的隐藏状态。

5. 解码过程:

   迭代解码过程，直到达到 max_seq_len 或预测到结束符 EOS。解码器根据当前输入和隐藏状态生成输出 dec_output。选择输出概率最高的预测 token。如果预测到了结束符 EOS，则停止解码。否则，将预测的 token 添加到输出 token 列表中，并将其作为下一个时间步的输入。

6. 返回结果:

   返回生成的输出 token 列表。

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

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

五、评价翻译结果

计算 BLEU（Bilingual Evaluation Understudy）评分的函数。BLEU 是一种用于评估机器翻译质量的指标，它通过比较预测的翻译与参考（标签）翻译之间的 n-gram 重叠来评估翻译的准确性。

具体来说，设词数为𝑛n的子序列的精度为𝑝𝑛pn。它是预测序列与标签序列匹配词数为𝑛n的子序列的数量与预测序列中词数为𝑛n的子序列的数量之比。举个例子，假设标签序列为𝐴A、𝐵B、𝐶C、𝐷D、𝐸E、𝐹F，预测序列为𝐴A、𝐵B、𝐵B、𝐶C、𝐷D，那么𝑝1=4/5,𝑝2=3/4,𝑝3=1/3,𝑝4=0p1=4/5,p2=3/4,p3=1/3,p4=0。设𝑙𝑒𝑛labellenlabel和𝑙𝑒𝑛predlenpred分别为标签序列和预测序列的词数，那么，BLEU的定义为

其中𝑘k是我们希望匹配的子序列的最大词数。可以看到当预测序列和标签序列完全一致时，BLEU为1。

因为匹配较长子序列比匹配较短子序列更难，BLEU对匹配较长子序列的精度赋予了更大权重。例如，当𝑝𝑛pn固定在0.5时，随着𝑛n的增大，0.51/2≈0.7,0.51/4≈0.84,0.51/8≈0.92,0.51/16≈0.960.51/2≈0.7,0.51/4≈0.84,0.51/8≈0.92,0.51/16≈0.96。另外，模型预测较短序列往往会得到较高𝑝𝑛pn值。因此，上式中连乘项前面的系数是为了惩罚较短的输出而设的。举个例子，当𝑘=2k=2时，假设标签序列为𝐴A、𝐵B、𝐶C、𝐷D、𝐸E、𝐹F，而预测序列为𝐴A、𝐵B。虽然𝑝1=𝑝2=1p1=p2=1，但惩罚系数exp(1−6/2)≈0.14exp⁡(1−6/2)≈0.14，因此BLEU也接近0.14。

下面来实现BLEU的计算。

def 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))
    for n in range(1, k + 1):
        num_matches, label_subs = 0, collections.defaultdict(int)
        for i in range(len_label - n + 1):
            label_subs[''.join(label_tokens[i: i + n])] += 1
        for i in range(len_pred - n + 1):
            if label_subs[''.join(pred_tokens[i: i + n])] > 0:
                num_matches += 1
                label_subs[''.join(pred_tokens[i: i + n])] -= 1
        score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
    return score

函数参数

• pred_tokens: 预测的 token 序列。
• label_tokens: 参考的标签 token 序列。
• k: BLEU 评分中考虑的最大 n-gram 的值。

函数过程

1. 长度惩罚:

   首先，计算长度惩罚项，即将预测序列长度与标签序列长度的比值的负对数指数

2. n-gram 匹配计算:

   对于每个 n-gram（从 1 到 k），计算预测序列中的 n-gram 与标签序列中的 n-gram 的匹配数量。使用 collections.defaultdict(int) 来计算标签中每个 n-gram 的出现次数。对于预测序列中的每个 n-gram，如果在标签中存在相同的 n-gram，则增加匹配数量，并减少标签中的计数，以确保每个 n-gram 只匹配一次。

3. BLEU 分数计算:

   对于每个 n-gram，计算匹配数量与预测序列中该 n-gram 总数的比率，并将结果乘以一个权重系数，以惩罚更高的 n-gram。最后，将每个 n-gram 的得分相乘，得到最终的 BLEU 分数。

4. 返回结果:

   返回计算得到的 BLEU 分数。

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

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)))

如果预测正确则分数就为1

score('ils regardent .', 'they are watching .', k=2)

score('ils sont canadienne .', 'they are canadian .', k=2)

六、总结

编码器-解码器和注意力机制应用于机器翻译

机器翻译是一种典型的序列到序列（Sequence-to-Sequence, Seq2Seq）任务。通过编码器-解码器结构和注意力机制，我们可以实现更有效的机器翻译模型。

编码器-解码器（Encoder-Decoder）结构和注意力机制（Attention Mechanism）在机器翻译（Machine Translation）领域得到了广泛的应用。BLEU（Bilingual Evaluation Understudy）是一种评价机器翻译结果的指标，用于衡量翻译质量。

编码器-解码器结构是一种序列到序列（Sequence to Sequence）的模型，通常使用循环神经网络（RNN）或长短时记忆网络（LSTM）实现。编码器将源语言句子编码成一个固定长度的向量，解码器则将这个向量解码成目标语言句子。这种结构可以捕捉长距离依赖关系，但存在信息丢失的问题。

为了解决这个问题，注意力机制被引入到编码器-解码器结构中。注意力机制允许解码器在生成目标语言单词时，关注源语言句子中的不同部分。这样，解码器可以根据上下文信息选择关注源语言句子中的哪些部分，从而提高翻译质量。

BLEU是一种自动评价机器翻译结果的指标，通过比较翻译结果与人工翻译的多个参考译文之间的相似度来衡量翻译质量。BLEU分数越高，表示翻译结果与参考译文越接近，翻译质量越好。