PyTorch 使用 TorchText 进行语言翻译

自然语言处理（NLP）技术日新月异，语言翻译作为其中的关键应用之一，正改变着人们跨语言交流的方式。PyTorch 作为深度学习领域备受青睐的框架，携手 TorchText 库，为构建语言翻译模型提供了强大而便捷的工具。即使您是编程新手，也能通过本文循序渐进地掌握利用 PyTorch 和 TorchText 实现语言翻译的全过程，开启您的 NLP 之旅。

一、环境搭建：开启翻译之旅的钥匙

在开始构建语言翻译模型之前，确保您的开发环境已正确配置相关的依赖库，这是保证后续代码顺利运行的基础。以下是搭建环境的步骤：

1. 安装 PyTorch：访问官方网址，根据您的系统配置（如操作系统、CUDA 版本等）获取适合的安装命令。例如，对于 Linux 系统且 CUDA 版本为 11.8 的用户，可以使用以下命令安装 PyTorch：
   • 命令 ：conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia

1. 安装 TorchText：TorchText 是专门用于处理文本数据的 PyTorch 扩展库，它提供了丰富的数据处理工具和预定义的数据集，极大地方便了文本相关任务的开展。安装命令如下：
   • 命令 ：pip install torchtext

1. 安装 Spacy：为了实现高效的文本分词操作，本文推荐使用 Spacy 库，它支持多种语言的分词，并且与 TorchText 配合默契。
   • 命令 ：pip install spacy
   • 接下来，您需要下载对应语言的分词模型，例如英语和德语模型：
     • 下载英语模型：python -m spacy download en
     • 下载德语模型：python -m spacy download de

二、数据准备：翻译模型的基石

数据是构建模型的基石，对于语言翻译任务，我们选择 Multi30k 数据集，该数据集包含了约 30,000 个英语和德语句子对，句子平均长度约为 13 个单词，非常适合作为训练和评估语言翻译模型的数据基础。

（一）数据集加载

TorchText 提供了便捷的数据集加载方式，能够轻松加载 Multi30k 数据集并进行初步处理。以下是加载数据集的代码示例：

from torchtext.datasets import Multi30k


## 加载 Multi30k 数据集
train_data, valid_data, test_data = Multi30k(language_pair=("de", "en"))

（二）字段定义

为了对数据进行进一步处理，如分词、添加起始和结束标记等，我们需要定义字段（Field）。字段定义了如何对文本数据进行预处理，以下是对源语言（德语）和目标语言（英语）分别定义字段的代码：

from torchtext.data import Field


## 定义德语字段（源语言）
SRC = Field(tokenize="spacy", tokenizer_language="de", init_token="<sos>", eos_token="<eos>", lower=True)


## 定义英语字段（目标语言）
TRG = Field(tokenize="spacy", tokenizer_language="en", init_token="<sos>", eos_token="<eos>", lower=True)

（三）词汇表构建

在对数据进行编码和解码之前，我们需要构建词汇表，将文本单词映射到数值索引。这一步骤对于将文本数据转换为模型可处理的数值形式至关重要。以下是构建词汇表的代码：

## 构建德语词汇表
SRC.build_vocab(train_data, min_freq=2)


## 构建英语词汇表
TRG.build_vocab(train_data, min_freq=2)

三、数据迭代器：高效的数据喂入

为了高效地将数据喂入模型进行训练和评估，我们需要使用数据迭代器。TorchText 提供了 BucketIterator，它能够根据序列长度将相似长度的样本划分到一个批次中，从而减少填充操作，提高训练效率。以下是创建数据迭代器的代码示例：

from torchtext.data import BucketIterator


## 设置设备（GPU 或 CPU）
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


## 定义批次大小
BATCH_SIZE = 128


## 创建训练、验证和测试数据迭代器
train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
    (train_data, valid_data, test_data),
    batch_size=BATCH_SIZE,
    device=device
)

四、模型构建：翻译的核心引擎

（一）编码器（Encoder）

编码器的作用是将源语言序列编码为一个固定长度的上下文向量，这个向量包含了源语言序列的语义信息。以下是编码器的代码实现：

import torch.nn as nn


class Encoder(nn.Module):
    def __init__(self, input_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout):
        super().__init__()
        self.embedding = nn.Embedding(input_dim, emb_dim)
        self.rnn = nn.GRU(emb_dim, enc_hid_dim, bidirectional=True)
        self.fc = nn.Linear(enc_hid_dim * 2, dec_hid_dim)
        self.dropout = nn.Dropout(dropout)


    def forward(self, src):
        embedded = self.dropout(self.embedding(src))
        outputs, hidden = self.rnn(embedded)
        hidden = torch.tanh(self.fc(torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1)))
        return outputs, hidden

（二）注意力机制（Attention）

注意力机制允许模型在解码过程中动态地关注源语言序列中不同的位置，从而更好地捕捉源语言和目标语言之间的对应关系。以下是注意力机制的代码：

class Attention(nn.Module):
    def __init__(self, enc_hid_dim, dec_hid_dim, attn_dim):
        super().__init__()
        self.enc_hid_dim = enc_hid_dim
        self.dec_hid_dim = dec_hid_dim
        self.attn_in = (enc_hid_dim * 2) + dec_hid_dim
        self.attn = nn.Linear(self.attn_in, attn_dim)


    def forward(self, decoder_hidden, encoder_outputs):
        src_len = encoder_outputs.shape[0]
        repeated_decoder_hidden = decoder_hidden.unsqueeze(1).repeat(1, src_len, 1)
        encoder_outputs = encoder_outputs.permute(1, 0, 2)
        energy = torch.tanh(self.attn(torch.cat((repeated_decoder_hidden, encoder_outputs), dim=2)))
        attention = torch.sum(energy, dim=2)
        return torch.softmax(attention, dim=1)

（三）解码器（Decoder）

解码器根据编码器生成的上下文向量和注意力机制提供的信息，逐步生成目标语言序列。以下是解码器的代码：

class Decoder(nn.Module):
    def __init__(self, output_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout, attention):
        super().__init__()
        self.output_dim = output_dim
        self.attention = attention
        self.embedding = nn.Embedding(output_dim, emb_dim)
        self.rnn = nn.GRU((enc_hid_dim * 2) + emb_dim, dec_hid_dim)
        self.out = nn.Linear(self.attention.attn_in + emb_dim, output_dim)
        self.dropout = nn.Dropout(dropout)


    def _weighted_encoder_rep(self, decoder_hidden, encoder_outputs):
        a = self.attention(decoder_hidden, encoder_outputs)
        a = a.unsqueeze(1)
        encoder_outputs = encoder_outputs.permute(1, 0, 2)
        weighted_encoder_rep = torch.bmm(a, encoder_outputs)
        weighted_encoder_rep = weighted_encoder_rep.permute(1, 0, 2)
        return weighted_encoder_rep


    def forward(self, input, decoder_hidden, encoder_outputs):
        input = input.unsqueeze(0)
        embedded = self.dropout(self.embedding(input))
        weighted_encoder_rep = self._weighted_encoder_rep(decoder_hidden, encoder_outputs)
        rnn_input = torch.cat((embedded, weighted_encoder_rep), dim=2)
        output, decoder_hidden = self.rnn(rnn_input, decoder_hidden.unsqueeze(0))
        embedded = embedded.squeeze(0)
        output = output.squeeze(0)
        weighted_encoder_rep = weighted_encoder_rep.squeeze(0)
        output = self.out(torch.cat((output, weighted_encoder_rep, embedded), dim=1))
        return output, decoder_hidden.squeeze(0)

（四）序列到序列模型（Seq2Seq）

序列到序列模型将编码器和解码器组合在一起，形成完整的翻译模型架构。以下是序列到序列模型的代码：

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder, device):
        super().__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.device = device


    def forward(self, src, trg, teacher_forcing_ratio=0.5):
        batch_size = src.shape[1]
        max_len = trg.shape[0]
        trg_vocab_size = self.decoder.output_dim
        outputs = torch.zeros(max_len, batch_size, trg_vocab_size).to(self.device)
        encoder_outputs, hidden = self.encoder(src)
        output = trg[0, :]
        for t in range(1, max_len):
            output, hidden = self.decoder(output, hidden, encoder_outputs)
            outputs[t] = output
            teacher_force = random.random() < teacher_forcing_ratio
            top1 = output.max(1)[1]
            output = (trg[t] if teacher_force else top1)
        return outputs

五、模型训练与评估：打磨翻译模型的利器

（一）超参数设置

在训练模型之前，我们需要设置一些超参数，这些超参数将影响模型的训练过程和最终性能。以下是超参数设置的代码：

## 设置超参数
INPUT_DIM = len(SRC.vocab)
OUTPUT_DIM = len(TRG.vocab)
ENC_EMB_DIM = 32
DEC_EMB_DIM = 32
ENC_HID_DIM = 64
DEC_HID_DIM = 64
ATTN_DIM = 8
ENC_DROPOUT = 0.5
DEC_DROPOUT = 0.5

（二）模型初始化与优化器定义

接下来，我们根据超参数初始化编码器、注意力机制、解码器和序列到序列模型，并定义优化器来更新模型参数。以下是相关代码：

## 初始化编码器、注意力机制、解码器和序列到序列模型
enc = Encoder(INPUT_DIM, ENC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, ENC_DROPOUT)
attn = Attention(ENC_HID_DIM, DEC_HID_DIM, ATTN_DIM)
dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, DEC_DROPOUT, attn)
model = Seq2Seq(enc, dec, device).to(device)


## 定义优化器
optimizer = torch.optim.Adam(model.parameters())

（三）损失函数定义

为了评估模型的性能并指导模型训练，我们需要定义损失函数。在语言翻译任务中，通常使用交叉熵损失函数，并忽略填充部分的损失计算。以下是损失函数定义的代码：

## 定义损失函数
PAD_IDX = TRG.vocab.stoi["<pad>"]
criterion = nn.CrossEntropyLoss(ignore_index=PAD_IDX)

（四）训练过程

训练过程是模型学习数据模式并不断提升翻译性能的关键阶段。在每个训练周期（epoch）中，模型会处理整个训练数据集，并根据计算得到的损失更新模型参数。以下是训练函数的代码：

import math
import time


def train(model, iterator, optimizer, criterion, clip):
    model.train()
    epoch_loss = 0
    for _, batch in enumerate(iterator):
        src = batch.src
        trg = batch.trg
        optimizer.zero_grad()
        output = model(src, trg)
        output = output[1:].view(-1, output.shape[-1])
        trg = trg[1:].view(-1)
        loss = criterion(output, trg)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)
        optimizer.step()
        epoch_loss += loss.item()
    return epoch_loss / len(iterator)

（五）评估过程

评估过程用于在验证集或测试集上评估模型的性能，以了解模型在未见过的数据上的表现。以下是评估函数的代码：

def evaluate(model, iterator, criterion):
    model.eval()
    epoch_loss = 0
    with torch.no_grad():
        for _, batch in enumerate(iterator):
            src = batch.src
            trg = batch.trg
            output = model(src, trg, 0)
            output = output[1:].view(-1, output.shape[-1])
            trg = trg[1:].view(-1)
            loss = criterion(output, trg)
            epoch_loss += loss.item()
    return epoch_loss / len(iterator)

（六）训练与评估模型

现在，我们已经定义好了训练和评估函数，接下来就可以开始训练和评估模型了。以下是训练和评估模型的代码：

import math
import time


N_EPOCHS = 10
CLIP = 1


best_valid_loss = float("inf")


for epoch in range(N_EPOCHS):
    start_time = time.time()
    train_loss = train(model, train_iterator, optimizer, criterion, CLIP)
    valid_loss = evaluate(model, valid_iterator, criterion)
    end_time = time.time()
    epoch_mins, epoch_secs = epoch_time(start_time, end_time)
    print(f"Epoch: {epoch + 1:02} | Time: {epoch_mins}m {epoch_secs}s")
    print(f"\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}")
    print(f"\t Val. Loss: {valid_loss:.3f} |  Val. PPL: {math.exp(valid_loss):7.3f}")


test_loss = evaluate(model, test_iterator, criterion)
print(f"| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |")

六、总结与展望

通过本文，您已经学习了如何利用 PyTorch 和 TorchText 构建一个基本的语言翻译模型，从环境搭建、数据准备、模型构建到训练与评估，每一步都至关重要。在实际应用中，您可以根据需求进一步优化模型，如调整超参数、使用更复杂的模型架构（如 Transformer）等，以提升翻译性能。未来，随着深度学习技术的不断发展，语言翻译模型将更加智能和精准，为人们的跨语言交流提供更便捷的支持。编程狮将持续为您提供更多优质的技术教程和资源，助力您的编程学习之旅。