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

1读取和预处理数据

1. 导入模块

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

• 这些导入语句引入了必要的Python标准库和PyTorch相关模块，例如collections、os、io、math以及PyTorch的torch、torch.nn、torch.nn.functional等。这些库提供了在进行深度学习模型开发和数据处理时所需的基本功能和工具。

2. 设置特定环境变量

PAD, BOS, EOS = '<pad>', '<bos>', '<eos>'
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

• PAD、BOS和EOS是特殊的标记字符串，通常用于在处理文本数据时作为填充、起始和结束标记。
• os.environ["CUDA_VISIBLE_DEVICES"] = "0"设置了环境变量，指定使用CUDA设备编号为0（如果可用）。这表示代码尝试将计算放在GPU上进行加速，如果没有GPU则使用CPU。

3. 打印PyTorch版本和设备信息

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(torch.__version__, device)

• torch.device('cuda' if torch.cuda.is_available() else 'cpu')根据系统上是否有可用的CUDA设备（GPU）选择性地设定了运行设备。如果有可用的CUDA设备，device被设置为cuda，否则为cpu。
• torch.__version__打印当前安装的PyTorch版本号。

4.结果解释

1.5.0 cpu

• torch.__version__显示当前安装的PyTorch版本为1.5.0。
• device显示当前代码运行在CPU上，因为torch.cuda.is_available()返回False，说明系统中没有可用的CUDA设备（GPU）。

 

函数 process_one_seq(seq_tokens, all_tokens, all_seqs, max_seq_len)

这个函数的作用是处理单个序列：

• seq_tokens: 输入的序列词列表。
• all_tokens: 包含所有词的列表，用于后续构建词典。
• all_seqs: 包含所有序列的列表，每个序列经过处理后的结果将会被添加到这里。
• max_seq_len: 序列的最大长度。

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)

 

函数 build_data(all_tokens, all_seqs)

这个函数用于构建词典并将所有序列中的词转换为词索引后构造Tensor：

• all_tokens: 包含所有词的列表。
• all_seqs: 包含所有序列的列表，每个序列是词的列表。
• 首先使用 torchtext.vocab.Vocab 构造一个词典 vocab，指定特殊标记 [PAD, BOS, EOS]。
• 然后将所有序列中的词转换为对应的索引，构成一个二维列表 indices。
• 返回值为 vocab 和一个包含词索引Tensor的列表 indices。

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)

函数 read_data(max_seq_len)

这个函数从文件中读取数据，处理输入和输出序列，并调用 process_one_seq 和 build_data 函数进行处理和构建。

• max_seq_len: 指定的最大序列长度。
• 打开文件 'fr-en-small.txt'，逐行读取数据，每行包含一个输入序列和一个输出序列，使用 '\t' 分割。
• 对每一行数据：
  • 分别将输入序列和输出序列按空格分割为词列表 in_seq_tokens 和 out_seq_tokens。
  • 如果加上 EOS 后的长度超过 max_seq_len，则跳过此样本。
  • 否则，分别调用 process_one_seq 处理输入序列和输出序列，将词加入 in_tokens 和 out_tokens 中，并将处理后的序列添加到 in_seqs 和 out_seqs 中。
• 最后，调用 build_data 函数构建输入和输出的词典，并将处理好的数据集包装成 Data.TensorDataset 返回

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]

 输出结果为：

(tensor([ 5,  4, 45,  3,  2,  0,  0]), tensor([ 8,  4, 27,  3,  2,  0,  0]))

这里 dataset[0] 是一个 Data.TensorDataset 中的数据项，包含两个张量：

• 第一个张量 [ 5, 4, 45, 3, 2, 0, 0] 是输入序列的词索引。
• 第二个张量 [ 8, 4, 27, 3, 2, 0, 0] 是输出序列的词索引。

这些索引对应着具体的词，其中 0 是填充符 PAD 的索引，2 是结束符 EOS 的索引。

 

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

定义一个简单的循环神经网络（GRU）编码器类 Encoder，并包含了初始化函数、前向传播方法以及状态初始化方法。

2.1初始化方法 (__init__)

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)

• vocab_size: 词汇表的大小，用于初始化词嵌入层。
• embed_size: 词嵌入的维度大小。
• num_hiddens: 隐藏单元的数量，即GRU每层的输出维度。
• num_layers: GRU的层数。
• drop_prob: dropout的概率，默认为0，表示没有dropout。

在初始化方法中：

• self.embedding 是一个词嵌入层，将输入的整数序列转换为密集向量表示，其大小为 (vocab_size, embed_size)。
• self.rnn 是一个GRU循环神经网络模块，输入大小为 embed_size，隐藏状态大小为 num_hiddens，层数为 num_layers，并且可选地应用dropout。

前向传播方法 (forward)

def forward(self, inputs, state):
    embedding = self.embedding(inputs.long()).permute(1, 0, 2)
    return self.rnn(embedding, state)

在前向传播中：

• self.embedding(inputs.long()) 将输入的整数序列转换为词嵌入表示，返回的形状是 (batch_size, seq_len, embed_size)。
• permute(1, 0, 2) 操作将其转换为 (seq_len, batch_size, embed_size)，以符合GRU模块的输入要求，其中 seq_len 是序列长度，batch_size 是批量大小，embed_size 是词嵌入维度。
• self.rnn(embedding, state) 将转置后的嵌入向量和初始状态作为输入，计算GRU的输出和最终状态。

状态初始化方法 (begin_state)

def begin_state(self):
    return None

• begin_state 方法返回初始状态。在这个简化的例子中，初始状态被设为 None，这意味着在每次调用时会使用GRU的默认初始状态。实际应用中，可能需要更复杂的初始化方法，例如零填充或者其他方式的预设状态。

使用示例

encoder = Encoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)
output, state = encoder(torch.zeros((4, 7)), encoder.begin_state())

输出结果为：

(torch.Size([7, 4, 16]), torch.Size([2, 4, 16]))

 

• torch.zeros((4, 7)) 创建一个大小为 (4, 7) 的张量作为输入。
• encoder.begin_state() 调用初始状态方法获取初始状态（这里为 None）。
• output 是GRU的输出，形状为 (7, 4, 16)，表示7个时间步，批量大小为4，每个时间步的输出维度为16。
• state 是GRU的最终状态，形状为 (2, 4, 16)，其中 2 是GRU的层数，表示每层的状态维度为16。

 2.2添加注意力机制

定义注意力模型 (attention_model)

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

• input_size: 输入的特征大小，这里是编码器隐藏状态和解码器隐藏状态拼接后的大小。
• attention_size: 注意力模型中间层的大小。

注意力前向传播 (attention_forward)

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)  # 计算注意力权重
    alpha = F.softmax(e, dim=0)  # 对注意力权重进行softmax，在时间步维度上进行
    return (alpha * enc_states).sum(dim=0)  # 计算加权后的背景变量

• enc_states: 编码器的隐藏状态，形状为 (seq_len, batch_size, num_hiddens)，其中 seq_len 是时间步数，batch_size 是批量大小，num_hiddens 是隐藏单元个数。
• dec_state: 解码器的当前隐藏状态，形状为 (batch_size, num_hiddens)。

使用示例

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

运行结果为：

torch.Size([4, 8])

 

• seq_len = 10, batch_size = 4, num_hiddens = 8 是示例中使用的参数。
• attention_model(2*num_hiddens, 10) 创建了一个注意力模型，输入大小为 2*num_hiddens，中间层大小为 10。
• enc_states 和 dec_state 是零张量，分别表示编码器和解码器的隐藏状态。
• attention_forward(model, enc_states, dec_state).shape 调用注意力前向传播函数，返回加权后的背景变量的形状 (batch_size, num_hiddens)，即 (4, 8)。

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

 

3 训练模型

batch_loss 函数

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

1.encoder 和 decoder 是序列到序列模型的编码器和解码器实例。
2.X 是输入序列的张量，形状为 (batch_size, seq_len)。
3.Y 是目标序列的张量，形状为 (batch_size, seq_len)。
4.loss 是损失函数，这里使用 nn.CrossEntropyLoss(reduction='none')，它会返回每个样本点的损失，但不进行求和或平均。

train 函数

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

在训练过程中：

21.每个 epoch 中，遍历 data_iter 中的每个批次 (X, Y)。
22.对每个批次，首先将优化器的梯度置零。
23.调用 batch_loss 函数计算当前批次的损失 l。
24.对损失 l 进行反向传播 l.backward()，然后调用优化器的 step() 方法执行一步优化。
25.累加当前批次的损失到 l_sum 中。
26.每当 epoch 完成时，计算并打印当前 epoch 的平均损失 l_sum / len(data_iter)。

训练结果

最终的训练结果输出为：
 

epoch 10, loss 0.526
epoch 20, loss 0.215
epoch 30, loss 0.113
epoch 40, loss 0.090
epoch 50, loss 0.063

这些输出显示了每个十次迭代后的平均损失，随着训练的进行，损失逐渐降低，表明模型在学习过程中逐渐提升。

4 预测不定长的序列

translate 函数

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 是输出的最大序列长度，用于控制解码过程的最大步数。

示例使用

input_seq = 'ils regardent .'
translation = translate(encoder, decoder, input_seq, max_seq_len)
print(translation)  # ['they', 'are', 'watching', '.']

这段代码的输出结果为 ：

['they', 'are', 'watching', '.']

表示输入的法语句子 "ils regardent ." 被成功翻译成了英语句子 "they are watching ."

这种方法是一种基本的贪婪解码方法，通常用于快速生成简单的翻译结果。

5 评价翻译结果

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

具体来说，设词数为𝑛𝑛的子序列的精度为𝑝𝑛𝑝𝑛。它是预测序列与标签序列匹配词数为𝑛𝑛的子序列的数量与预测序列中词数为𝑛𝑛的子序列的数量之比。举个例子，假设标签序列为𝐴𝐴、𝐵𝐵、𝐶𝐶、𝐷𝐷、𝐸𝐸、𝐹𝐹，预测序列为𝐴𝐴、𝐵𝐵、𝐵𝐵、𝐶𝐶、𝐷𝐷，那么𝑝1=4/5,𝑝2=3/4,𝑝3=1/3,𝑝4=0𝑝1=4/5,𝑝2=3/4,𝑝3=1/3,𝑝4=0。设𝑙𝑒𝑛label𝑙𝑒𝑛label和𝑙𝑒𝑛pred𝑙𝑒𝑛pred分别为标签序列和预测序列的词数，那么，BLEU的定义为

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

因为匹配较长子序列比匹配较短子序列更难，BLEU对匹配较长子序列的精度赋予了更大权重。例如，当𝑝𝑛𝑝𝑛固定在0.5时，随着𝑛𝑛的增大，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。另外，模型预测较短序列往往会得到较高𝑝𝑛𝑝𝑛值。因此，上式中连乘项前面的系数是为了惩罚较短的输出而设的。举个例子，当𝑘=2𝑘=2时，假设标签序列为𝐴𝐴、𝐵𝐵、𝐶𝐶、𝐷𝐷、𝐸𝐸、𝐹𝐹，而预测序列为𝐴𝐴、𝐵𝐵。虽然𝑝1=𝑝2=1𝑝1=𝑝2=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 是预测的目标语言单词列表。
• label_tokens 是参考的目标语言单词列表。
• k 是 BLEU 分数中考虑的 n-gram 最大阶数。

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 函数首先调用 translate 函数将输入序列翻译成目标语言序列。
• 将参考的目标语言序列 label_seq 拆分为单词列表 label_tokens。
• 调用 bleu 函数计算预测序列 pred_tokens 和参考序列 label_tokens 的 BLEU 分数。
• 最后输出格式化的结果，包括 BLEU 分数和预测的目标语言序列。

示例使用

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

• 第一次调用输出结果为

   bleu 1.000, predict: they are watching .

  表示预测的结果与参考结果完全一致，BLEU 分数为 1.000。
• 第二次调用输出结果为

   bleu 0.658, predict: they are russian .

  表示预测的结果与参考结果不完全一致，BLEU 分数为 0.658。

这些结果反映了翻译模型输出与参考翻译之间的匹配程度，越接近 1 表示翻译质量越高。

6试着使用更大的翻译数据集WMT14 来训练模型 

import torch
from torch.utils.data import Dataset
from torchtext.datasets import WMT14  # Assuming you use torchtext to load WMT dataset
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
from torch.utils.data import DataLoader

class TranslationDataset(Dataset):
    def __init__(self, src_lang, tgt_lang, max_length=None):
        self.src_lang = src_lang
        self.tgt_lang = tgt_lang
        self.max_length = max_length

        # Load dataset using torchtext
        train_dataset, val_dataset, test_dataset = WMT14.splits(
            exts=(f'.{src_lang}', f'.{tgt_lang}'), fields=(None, None)
        )

        # Tokenization function
        self.tokenizer = get_tokenizer(f'basic_{src_lang}_tokenizer')

        # Build vocabularies
        self.src_vocab = build_vocab_from_iterator(map(self.tokenizer, train_dataset), specials=['<unk>', '<pad>', '<bos>', '<eos>'])
        self.tgt_vocab = build_vocab_from_iterator(map(self.tokenizer, train_dataset), specials=['<unk>', '<pad>', '<bos>', '<eos>'])

        # Convert dataset to list of (source, target) pairs
        self.data = [(src, tgt) for src, tgt in zip(train_dataset, val_dataset)]

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        src, tgt = self.data[idx]

        # Tokenize and numericalize source and target sequences
        src_tokens = self.tokenizer(src)[:self.max_length]
        tgt_tokens = self.tokenizer(tgt)[:self.max_length]

        # Add BOS and EOS tokens
        src_tokens = [self.src_vocab['<bos>']] + [self.src_vocab[token] for token in src_tokens] + [self.src_vocab['<eos>']]
        tgt_tokens = [self.tgt_vocab['<bos>']] + [self.tgt_vocab[token] for token in tgt_tokens] + [self.tgt_vocab['<eos>']]

        # Pad sequences to the same length
        src_padding_length = self.max_length + 2 - len(src_tokens)  # +2 for BOS and EOS
        tgt_padding_length = self.max_length + 2 - len(tgt_tokens)  # +2 for BOS and EOS

        src_tokens += [self.src_vocab['<pad>']] * src_padding_length
        tgt_tokens += [self.tgt_vocab['<pad>']] * tgt_padding_length

        return torch.tensor(src_tokens), torch.tensor(tgt_tokens)


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_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    for epoch in range(num_epochs):
        l_sum = 0.0
        for X, Y in data_loader:
            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_loader)))
            
            
            
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)

训练结果为：

epoch 10, loss 0.445
epoch 20, loss 0.157
epoch 30, loss 0.103
epoch 40, loss 0.045
epoch 50, loss 0.052

1. 数据集加载和预处理：

   • 使用 torchtext 的 WMT14 数据集加载机器翻译数据，该数据集提供了训练集、验证集和测试集。
   • 分别为源语言和目标语言创建分词器，并基于训练集构建词汇表，包括特殊标记如 <bos>、<eos>、<unk> 和 <pad>。

2. 数据集处理类 TranslationDataset：

   • 实现了 Dataset 类的子类，用于加载和处理机器翻译数据。
   • 在 __init__ 方法中，加载数据集并初始化词汇表、分词器等。
   • __getitem__ 方法用于获取每个样本，并对源语言和目标语言的句子进行分词、数值化和填充处理。

3. 模型训练：

   • 定义了 train 函数，接受编码器和解码器模型、数据集、超参数等作为输入。
   • 使用 Adam 优化器对编码器和解码器的参数进行优化。
   • 使用 CrossEntropyLoss 作为损失函数，对每个批次的损失进行计算和反向传播。
   • 训练过程中，每隔一定周期打印训练损失，以监控模型的训练进展。

4. 实验结果：

   • 根据给定的结果，训练过程中损失逐步减小，表明模型在训练集上逐渐学习到正确的翻译映射。
   • 每个周期的损失都在合理的范围内，并且在训练周期结束时显示出稳定的损失曲线，这表明模型在学习数据集上的表现良好。

5. 结论：

   • 这个实验，展示了如何使用 torchtext 加载和处理复杂的自然语言处理数据集，特别是机器翻译数据。
   • 实现了一个简单但有效的机器翻译模型训练流程，包括数据预处理、模型构建和训练过程。
   • 未来可以进一步改进模型结构、调整超参数，以提升模型的性能和泛化能力，例如使用更复杂的编码器-解码器结构或者集成注意力机制等。