机器翻译是指将文本从一种语言自动翻译到另一种语言。本文将从基础开始，逐步介绍如何使用PyTorch构建一个包含注意力机制的机器翻译模型，并通过训练和评估模型，探索提升翻译性能的方法。
一、机器翻译基础
1.1、什么是机器翻译？
机器翻译（Machine Translation, MT）是自然语言处理中的一个重要任务，它通过计算机将文本从一种语言翻译成另一种语言。经典的机器翻译模型包括统计机器翻译（Statistical Machine Translation, SMT）和神经机器翻译（Neural Machine Translation, NMT）。在本教程中，我们将专注于使用神经网络和注意力机制实现神经机器翻译。
1.2、数据预处理
在进行机器翻译之前，需要对数据进行预处理。我们将使用一个小型的法语-英语数据集，并将其转换为适合模型训练的格式。
数据集内容如下：
------------------------------------------
elle est vieille . she is old .
elle est tranquille . she is quiet .
elle a tort . she is wrong .
elle est canadienne . she is canadian .
elle est japonaise . she is japanese .
ils sont russes . they are russian .
ils se disputent . they are arguing .
ils regardent . they are watching .
ils sont acteurs . they are actors .
elles sont crevees . they are exhausted .
il est mon genre ! he is my type !
il a des ennuis . he is in trouble .
c est mon frere . he is my brother .
c est mon oncle . he is my uncle .
il a environ mon age . he is about my age .
elles sont toutes deux bonnes . they are both good .
elle est bonne nageuse . she is a good swimmer .
c est une personne adorable . he is a lovable person .
il fait du velo . he is riding a bicycle .
ils sont de grands amis . they are great friends .
------------------------------------------
1.2.1、读取和处理数据
首先，我们需要定义一些特殊符号，包括“<pad>”用于填充较短的序列，“<bos>”表示序列开始，“<eos>”表示序列结束。这些符号在处理文本数据时非常重要，就像在写信时需要有开头和结尾。
import collections
import io
import torch
import torchtext.vocab as Vocab
import torch.utils.data as Data
# 定义特殊标记
PAD, BOS, EOS = '<pad>', '<bos>', '<eos>'
我们定义了三个特殊标记：
PAD：用于填充较短的序列，使所有序列长度一致。BOS：表示序列的开始。EOS：表示序列的结束。
接下来，我们编写数据预处理函数：
# 数据预处理函数
def process_one_seq(seq_tokens, all_tokens, all_seqs, max_seq_len):
# 将当前序列中的所有词加入总词汇表
all_tokens.extend(seq_tokens)
# 在序列末尾添加EOS标记，并填充PAD标记直到达到最大长度
seq_tokens += [EOS] + [PAD] * (max_seq_len - len(seq_tokens) - 1)
# 将处理后的序列加入总序列列表
all_seqs.append(seq_tokens)
process_one_seq函数处理一个序列，将所有词加入总词汇表，并在序列末尾添加EOS和PAD标记，确保所有序列长度一致。
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)
build_data函数根据所有词创建词汇表，并将所有序列中的词转换为相应的词索引。
def read_data(file_path, max_seq_len):
in_tokens, out_tokens, in_seqs, out_seqs = [], [], [], []
# 读取数据文件
with io.open(file_path, encoding='utf-8') 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
# 处理输入和输出序列
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)
read_data函数读取数据文件中的法语-英语句子对，处理并构建输入和输出的词汇表及索引数据。
# 设置最大序列长度
max_seq_len = 7
# 读取并处理数据集
in_vocab, out_vocab, dataset = read_data('fr-en-small.txt', max_seq_len)
# 打印数据集的第一个样本
print("数据集的第一个样本（输入和输出的词索引序列）:", dataset[0])
结果：数据集的第一个样本（输入和输出的词索引序列）: (tensor([ 5, 4, 45, 3, 2, 0, 0]), tensor([ 8, 4, 27, 3, 2, 0, 0]))
二、构建神经网络模型
在机器翻译任务中，编码器-解码器结构（Encoder-Decoder）是非常常见且有效的模型架构。这种结构通过编码器将输入序列编码为上下文向量，再由解码器根据上下文向量生成输出序列。为了进一步提高翻译质量，我们引入注意力机制，使解码器能够在生成每个词时动态地关注输入序列的不同部分。
2.1、编码器
编码器的任务是将输入序列（如一个法语句子）转换为一个上下文向量，这个向量是输入序列的高维表示。在我们的模型中，编码器由一个嵌入层和多个门控循环单元（GRU）层组成。
代码实现：
# 定义编码器类，继承自nn.Module
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)
# 定义GRU层：处理嵌入后的向量序列，提取特征
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)
# 将嵌入向量序列和初始状态传入GRU层，返回输出和新的状态
return self.rnn(embedding, state)
def begin_state(self):
# 返回GRU的初始状态，初始状态为空即全零
return None------------------------------------------------------------------------------------
1、嵌入层
嵌入层的作用是将离散的词索引转换为连续的向量表示。这些向量表示捕捉了词语的语义信息，使得语义相近的词在向量空间中也相近。例如，“猫”和“狗”在语义上是相似的，它们的向量表示应该也很接近。
2、嵌入层原理
嵌入层的核心思想是通过学习得到词语的向量表示，这些向量可以反映词语之间的语义关系。每个词语对应一个高维空间中的点，向量的维度越高，表示能力越强。词嵌入的学习通常通过在大量文本数据上的训练来完成，使得相似词语的向量距离更近。
举个例子，如果我们想表示“国王”和“王后”，它们的向量在语义上应该很接近，而与“苹果”的向量距离较远。通过这样的向量表示，我们的模型可以更好地理解词语之间的关系，从而提高翻译的准确性。
3、门控循环单元（GRU）
GRU是一种改进的循环神经网络（RNN），能够更好地捕捉序列中的长距离依赖关系。相比传统的RNN，GRU通过门控机制来控制信息流动，使得模型在处理长序列时更有效。
- 输入门：决定当前时间步的输入有多少部分可以传递到隐藏状态。
- 遗忘门：决定前一时间步的隐藏状态有多少部分可以保留下来。
GRU通过这些门控机制，能够有效地解决传统RNN中的梯度消失问题，从而更好地捕捉序列中的长距离依赖。
4、GRU原理
GRU由两个门（更新门和重置门）组成，这些门帮助模型选择性地更新和重置隐藏状态。
- 更新门：控制当前时间步的隐藏状态有多少来自前一时间步的隐藏状态。
- 重置门：控制当前输入有多少影响当前的隐藏状态。
这些门使得GRU能够灵活地记住和遗忘信息，从而更好地处理长序列数据。相比传统RNN，GRU减少了参数数量，训练更高效，同时也能保持较好的性能。
5、动态更新与重置
想象一下，你在阅读一篇长文章，当你阅读每个段落时，你可能会根据段落的内容调整你的理解和记忆。GRU的更新门和重置门就像你的注意力机制，它们帮助模型在处理每个时间步时，选择性地记住重要的信息，忘记不相关的信息。
更新门和重置门的工作原理如下：
- 更新门决定了前一个时间步的隐藏状态对当前时间步的影响程度。如果更新门的值接近1，模型会更多地保留前一时间步的信息；如果更新门的值接近0，模型会更多地依赖当前时间步的输入。
- 重置门决定了当前时间步的输入对当前隐藏状态的影响程度。如果重置门的值接近1，模型会更多地考虑当前输入；如果重置门的值接近0，模型会忽略当前输入的影响。
这种门控机制使得GRU在处理长序列数据时，能够更有效地记住重要信息，从而提高模型的性能和训练效率。
------------------------------------------------------------------------------------
2.2、注意力机制
注意力机制是近年来在序列到序列模型中取得显著成功的技术。它的核心思想是，在生成每个输出词时，模型根据当前的解码器隐藏状态，对输入序列的每个位置分配不同的权重，从而生成一个加权平均的上下文向量。
1、注意力模型
注意力模型通过计算解码器当前时间步的隐藏状态与编码器各时间步隐藏状态的相似度，为每个时间步分配权重。相似度计算通常使用点积、加性注意力或多头注意力。
# 定义注意力模型函数
def 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
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)
# 通过注意力模型计算注意力权重，形状为(时间步数, 批量大小, 1)
e = model(enc_and_dec_states)
# 在时间步维度上对注意力权重做softmax运算，形状仍为(时间步数, 批量大小, 1)
alpha = F.softmax(e, dim=0)
# 返回加权平均后的背景变量，形状为(批量大小, 隐藏单元个数)
return (alpha * enc_states).sum(dim=0)
------------------------------------------------------------------------------------
注意力机制原理
注意力机制通过计算解码器隐藏状态与编码器各时间步隐藏状态的相似度，为每个时间步分配权重。这些权重表示解码器在当前时间步应该关注输入序列的哪个部分。
- 相似度计算：通常使用点积、加性注意力或多头注意力。
- 权重分配：通过softmax函数将相似度转换为概率分布，使权重的和为1。
- 加权平均：将编码器隐藏状态按照权重进行加权平均，生成当前时间步的上下文向量。
动态关注的实现
注意力机制使得模型能够动态地关注输入序列的不同部分，而不是固定地依赖于编码器的最终隐藏状态。这种动态关注使得模型在处理长序列和复杂语言现象时更加有效。
想象你在阅读一篇长文，在每一段的开头你可能需要回忆文章的主题，而在每一段的结尾你会总结这段的核心内容。同样的，在机器翻译中，注意力机制帮助模型在生成每个单词时，动态地关注输入序列的不同部分。例如，当翻译一个复杂的句子时，模型可以根据当前生成的词来调整关注的重点，使得翻译更加准确和流畅。
------------------------------------------------------------------------------------
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层，输入大小为num_hiddens + embed_size
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])
# 将嵌入后的输入和背景向量在特征维度上连接
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------------------------------------------------------------------------------------
解码器的工作原理
解码器的任务是根据编码器的输出和当前的输入，生成目标语言的序列。在每个时间步，解码器通过注意力机制动态地关注编码器输出的不同部分，生成当前时间步的输出。
动态生成输出
在每个时间步，解码器首先通过注意力机制计算上下文向量，然后将当前输入与上下文向量结合，通过GRU生成新的隐藏状态和输出。这样的设计使得解码器能够在生成每个单词时，根据当前的上下文信息做出最合适的选择，从而提高翻译的准确性和流畅度。
------------------------------------------------------------------------------------
三、训练模型
在构建好编码器和解码器后，下一步是训练这个模型。在训练过程中，我们需要定义如何计算损失、更新模型参数，并评估模型的性能。
3.1、计算批量损失
在训练神经网络模型的过程中，计算损失是关键的一步，它帮助我们衡量模型的预测与实际值之间的差异。为了更好地理解这个过程，我们需要了解一些关键概念和底层实现。
1、批量损失计算
在 batch_loss 函数中，我们实现了一个用于计算小批量损失的函数。这个函数的核心思想是通过遍历输入和目标序列，计算每一步的损失，并将其累加。具体来说：
- 初始化编码器的隐藏状态：编码器的初始隐藏状态是全零的，我们通过调用
begin_state函数来实现。 - 前向传播：通过编码器的前向传播，得到编码器的输出和最终隐藏状态。
- 初始化解码器的隐藏状态：解码器的初始隐藏状态直接取自编码器的最终隐藏状态。
- 解码器输入：在最初的时间步，解码器的输入是特殊字符
<bos>，之后的输入为输出序列在上一时间步的词。 - 掩码变量：我们使用掩码变量
mask来忽略掉填充项<pad>对损失计算的影响。初始时，掩码全为1。 - 计算损失：对于每个时间步，我们计算解码器的输出与目标之间的损失，并根据掩码进行加权求和。
- 返回平均损失：最终，我们返回所有时间步的平均损失。
代码实现
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
# 统计非PAD标记的数量
num_not_pad_tokens += mask.sum().item()
# 一旦遇到EOS（序列结束标记），掩码变为0，忽略后续的PAD标记
mask = mask * (y != out_vocab.stoi[EOS]).float()
# 返回平均损失
return l / num_not_pad_tokens
2、深入讲解
------------------------------------------------------------------------------------
强制教学
在训练序列到序列模型时，使用强制教学（Teacher Forcing）是一种常见的策略。它通过在每个时间步使用目标序列作为解码器的输入，而不是使用模型的预测输出。这种方法能够加速训练过程，并提高模型的稳定性。然而，在实际应用中，解码器需要依赖前一步的预测输出，这就引入了训练和推理的不一致性问题。
强制教学的实现：
- 当前时间步的标签作为输入：在每个时间步，我们将目标序列的当前词作为解码器的输入。
- 加速收敛：这种方法能够帮助模型更快地学习到序列间的依赖关系。
- 不一致性问题：虽然强制教学在训练时表现良好，但在实际预测时，模型需要依赖前一步的预测输出，可能会导致性能下降。
------------------------------------------------------------------------------------
掩码机制
在处理变长序列时，使用掩码机制来忽略填充项的影响是非常重要的。填充项通常是为了使批量中的所有序列具有相同长度而添加的。掩码机制通过忽略这些填充项，确保损失计算的准确性。
掩码机制的实现：
- 初始掩码全为1：在最初，掩码全为1，表示所有位置都参与损失计算。
- 遇到EOS后掩码变为0：一旦遇到序列结束标记
<eos>，掩码变为0，忽略后续的填充项。 - 加权求和：在计算损失时，通过掩码进行加权求和，确保只考虑有效的序列部分。
------------------------------------------------------------------------------------
3.2、训练模型
在训练过程中，我们需要同时迭代更新编码器和解码器的参数。我们使用Adam优化器来加速训练，并在每个周期结束时打印平均损失。
1、训练函数
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)
# 定义损失函数，使用交叉熵损失，且不进行自动求和（reduction='none'）
loss = nn.CrossEntropyLoss(reduction='none')
# 创建数据加载器，将数据集分成小批量，支持随机打乱
data_iter = torch.utils.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个周期，打印一次平均损失
if (epoch + 1) % 10 == 0:
print("epoch %d, loss %.3f" % (epoch + 1, l_sum / len(data_iter)))
2、创建模型实例并设置超参数
接下来，我们创建编码器和解码器实例，并设置模型的超参数。然后，开始训练模型。
# 设置模型参数
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、训练过程中的输出
在训练过程中，我们每10个周期打印一次平均损失，以监控训练进展。以下是训练过程中的输出示例：
epoch 10, loss 0.498
epoch 20, loss 0.234
epoch 30, loss 0.150
epoch 40, loss 0.108
epoch 50, loss 0.061
4、深入理解训练过程
在训练神经网络模型的过程中，我们需要不断调整模型参数，以最小化训练数据上的损失。通过梯度下降算法，我们可以计算每个参数对损失的影响，并沿着梯度的反方向调整参数，从而逐步优化模型。
------------------------------------------------------------------------------------
Adam优化器
Adam优化器是一种自适应学习率优化方法，通过计算梯度的一阶和二阶矩估计来动态调整学习率。相比于传统的随机梯度下降（SGD），Adam能够更快地收敛，并且对超参数的选择不那么敏感。
训练数据的随机性
在每个训练周期中，我们将数据集随机打乱，并分成多个小批量进行训练。这种方法能够增加训练的随机性，帮助模型更好地泛化，从而在测试数据上表现得更好。
------------------------------------------------------------------------------------
四、预测不定长的序列
在前面的小节中，我们已经了解了如何构建编码器和解码器，并结合注意力机制来处理序列到序列的翻译任务。接下来，我们将讨论如何使用这些组件来生成不定长的输出序列。特别是，我们将实现一种简单的贪婪搜索方法来生成解码器在每个时间步的输出。
贪婪搜索
贪婪搜索是一种逐步生成序列的方法。在每个时间步中，解码器选择概率最高的单词作为当前时间步的输出，并将其作为下一个时间步的输入。虽然贪婪搜索简单且高效，但它可能会错过全局最优的序列。
1、代码实现
以下是贪婪搜索的具体实现代码。我们将输入序列拆分为单词列表，并通过编码器得到上下文表示。然后，解码器根据当前的上下文和之前的输出生成新的输出，直到生成结束标记 <eos> 或达到最大序列长度。
def translate(encoder, decoder, input_seq, max_seq_len):
# 将输入句子拆分成单词列表
in_tokens = input_seq.split(' ')
# 添加EOS标记，并用PAD标记填充到max_seq_len长度
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)
# 初始化解码器的输入为BOS标记（序列开始）
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())]
# 如果预测到EOS标记，翻译结束
if (pred_token == EOS):
break
else:
output_tokens.append(pred_token) # 添加预测单词到输出序列
dec_input = pred # 将当前预测单词作为下一个时间步的输入
return output_tokens
2、示例测试
我们可以使用上述 translate 函数对一个简单的法语句子进行翻译测试。输入法语句子 “ils regardent.”，期望的翻译结果为 “they are watching.”。
# 定义输入序列
input_seq = 'ils regardent .'
# 调用翻译函数，传入编码器、解码器、输入序列和最大序列长度
translated_tokens = translate(encoder, decoder, input_seq, max_seq_len=10)
# 打印翻译结果
print("翻译结果:", " ".join(translated_tokens))
输出结果如下：
翻译结果: they are watching .3、深入理解
------------------------------------------------------------------------------------
输入序列预处理
在贪婪搜索的实现过程中，我们首先将输入序列拆分为单词列表，并在序列末尾添加结束标记 <eos>。同时，为了保证序列长度一致，我们使用填充标记 <pad> 对序列进行填充。这样可以确保输入序列在经过编码器时具有统一的长度。
解码过程
解码过程是贪婪搜索的核心。在每个时间步，解码器根据当前输入和上下文生成输出。通过选择概率最高的单词作为当前时间步的输出，我们逐步构建完整的翻译结果。
结束条件
解码过程在以下两种情况下结束：
- 生成结束标记
<eos>：表示翻译完成。 - 达到最大序列长度：防止生成过长的序列，保证生成过程的效率。
------------------------------------------------------------------------------------
五、评价翻译结果
经过模型的训练和预测后，我们需要评估模型的翻译效果。这一步对于了解模型的性能至关重要。在机器翻译中，BLEU（Bilingual Evaluation Understudy）分数是常用的评价指标。BLEU 分数通过比较预测序列和参考序列中的 n-gram 来衡量翻译的准确性。
1、BLEU 分数的计算原理
BLEU 分数的计算考虑了模型生成的翻译与参考翻译在 n-gram 层面的匹配情况，并对翻译长度进行惩罚。以下是计算 BLEU 分数的具体步骤：
-
计算 n-gram 精度：比较预测序列和参考序列中的 n-gram 匹配情况。n-gram 是指长度为 n 的子序列。匹配的 n-gram 数量与预测序列中 n-gram 的总数之比即为 n-gram 精度。
-
惩罚短序列：为了避免模型生成的翻译过短，BLEU 分数对短序列进行了惩罚。惩罚项基于预测序列和参考序列的长度比值。
-
综合 n-gram 精度和惩罚项：最终的 BLEU 分数是 n-gram 精度的几何平均数与惩罚项的乘积。
具体的 BLEU 分数计算公式如下：
其中，len_ref 和 len_pred 分别为参考序列和预测序列的长度， 是 n-gram 的精度，N 是最大 n-gram 长度。
2、实现 BLEU 分数计算
我们通过实现一个函数来计算 BLEU 分数。这个函数接受预测序列和参考序列，并返回 BLEU 分数。
import collections
import math
def bleu(pred_tokens, label_tokens, k):
# 获取预测序列和标签序列的长度
len_pred, len_label = len(pred_tokens), len(label_tokens)
# 计算惩罚因子，预测序列长度小于标签序列长度时，该值会小于1
score = math.exp(min(0, 1 - len_label / len_pred))
# 遍历1到k的所有n-gram
for n in range(1, k + 1):
num_matches = 0 # 匹配的n-gram数量
label_subs = collections.defaultdict(int) # 标签n-gram计数器
# 统计标签序列中的n-gram出现次数
for i in range(len_label - n + 1):
label_subs[''.join(label_tokens[i: i + n])] += 1
# 统计预测序列中的n-gram出现次数，并与标签中的n-gram匹配
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
# 计算n-gram匹配率，并更新得分
score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
return score
接下来，我们定义一个辅助函数来打印 BLEU 分数和翻译结果：
def score(input_seq, label_seq, k):
# 使用训练好的编码器和解码器将输入序列翻译成预测序列
pred_tokens = translate(encoder, decoder, input_seq, max_seq_len)
# 将标签序列拆分成单词列表
label_tokens = label_seq.split(' ')
# 计算 BLEU 分数
bleu_score = bleu(pred_tokens, label_tokens, k)
# 打印 BLEU 分数和预测的翻译结果
print('BLEU 得分: %.3f, 预测翻译: %s' % (bleu_score, ' '.join(pred_tokens)))
3、测试翻译结果
我们通过输入一些测试句子来评估模型的翻译效果。例如，输入法语句子“ils regardent.”，期望翻译成英语句子“they are watching.”。
# 定义输入序列
input_seq = 'ils regardent .'
# 调用翻译函数，传入编码器、解码器、输入序列和最大序列长度
translated_tokens = translate(encoder, decoder, input_seq, max_seq_len=10)
# 打印翻译结果
print("翻译结果:", " ".join(translated_tokens))
# 评估 BLEU 分数
score('ils regardent .', 'they are watching .', k=2)
输出结果：
翻译结果: they are watching .
BLEU 得分: 1.000, 预测翻译: they are watching .
通过上述过程，我们可以直观地看到模型的翻译效果，并使用 BLEU 分数进行量化评估。BLEU 分数为 1.000 表示预测翻译与参考翻译完全一致。
score('ils sont canadienne .', 'they are canadian .', k=2)
输出结果：
BLEU 得分: 0.658, 预测翻译: they are actors .
可以看到，在这个例子中，模型没有完全正确地翻译句子，但 BLEU 分数仍然反映了预测翻译与参考翻译的相似度。这种评估方法帮助我们更好地理解和改进机器翻译模型的性能。
通过 BLEU 分数的计算和分析，我们可以更好地了解模型的翻译效果，并针对性地进行优化和改进。这对于提高机器翻译的实际应用效果具有重要意义。
六、小结
------------------------------------------------------------------------------------
在本教程中，我们详细介绍了如何实现一个基于注意力机制的编码器-解码器模型，用于机器翻译任务。从数据预处理、模型构建、训练到评估，我们一步步地展示了完整的实现过程。
首先，我们从基础讲起，通过数据预处理将法语-英语句子对转换为模型可以处理的格式，构建词典并生成输入输出张量。接着，我们深入探讨了编码器和解码器的原理，尤其是注意力机制如何在翻译过程中动态关注输入序列的不同部分。通过编码器，我们将输入序列编码为高维向量表示，通过解码器，我们使用注意力机制生成目标语言的输出序列。
在训练部分，我们实现了批量损失计算函数，并通过多次迭代优化模型参数，提高模型的翻译性能。最后，我们介绍了如何使用 BLEU 分数来评估模型的翻译效果，并通过实际例子展示了翻译结果和评分方法。
本教程不仅展示了代码的实现，更注重原理的讲解和底层知识的发散，使读者不仅能掌握代码的使用，还能深入理解其背后的工作机制。这对于任何希望深入了解机器翻译和深度学习技术的学习者来说，都是非常有价值的。
通过这个系统的介绍，相信你已经对基于注意力机制的机器翻译有了更深入的了解。你可以尝试使用更大的数据集和不同的模型架构来进一步提高翻译效果，探索更广泛的应用场景。希望这篇教程能为你的学习和研究提供帮助。
------------------------------------------------------------------------------------
扫一扫
657
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
