PyTorch 使用 TorchText 進(jìn)行語言翻譯

2020-09-07 17:25 更新
原文： https://pytorch.org/tutorials/beginner/torchtext_translation_tutorial.html

本教程說明如何使用torchtext的幾個(gè)便捷類來預(yù)處理包含英語和德語句子的著名數(shù)據(jù)集的數(shù)據(jù)，并使用它來訓(xùn)練序列到序列模型，并注意將德語句子翻譯成英語 。

它基于 PyTorch 社區(qū)成員 Ben Trevett 的本教程，并由 Seth Weidman 在 Ben 的允許下創(chuàng)建。

在本教程結(jié)束時(shí)，您將能夠：

    1. Preprocess sentences into a commonly-used format for NLP modeling using the following torchtext convenience classes:


<cite>字段</cite>和
<cite>TranslationDataset</cite>

torchtext具有用于創(chuàng)建數(shù)據(jù)集的實(shí)用程序，可以輕松地對其進(jìn)行迭代，以創(chuàng)建語言翻譯模型。 一個(gè)關(guān)鍵類是字段，它指定應(yīng)該對每個(gè)句子進(jìn)行預(yù)處理的方式，另一個(gè)關(guān)鍵類是 <cite>TranslationDataset</cite> ； torchtext有幾個(gè)這樣的數(shù)據(jù)集； 在本教程中，我們將使用 Multi30k 數(shù)據(jù)集，其中包含約 30,000 個(gè)英語和德語句子(平均長度約為 13 個(gè)單詞）。

注意：本教程中的標(biāo)記化需要 Spacy 我們使用 Spacy，因?yàn)樗鼮橛⒄Z以外的其他語言的標(biāo)記化提供了強(qiáng)大的支持。 torchtext提供了basic_english標(biāo)記器，并支持其他英語標(biāo)記器(例如摩西），但對于語言翻譯(需要多種語言），Spacy 是您的最佳選擇。

要運(yùn)行本教程，請先使用pip或conda安裝spacy。 接下來，下載英語和德語 Spacy 分詞器的原始數(shù)據(jù)：

  1. python -m spacy download en
  2. python -m spacy download de

安裝 Spacy 后，以下代碼將根據(jù)Field中定義的標(biāo)記器，標(biāo)記TranslationDataset中的每個(gè)句子。

  1. from torchtext.datasets import Multi30k
  2. from torchtext.data import Field, BucketIterator
  5. SRC = Field(tokenize = "spacy",
  6.             tokenizer_language="de",
  7.             init_token = '<sos>',
  8.             eos_token = '<eos>',
  9.             lower = True)
  12. TRG = Field(tokenize = "spacy",
  13.             tokenizer_language="en",
  14.             init_token = '<sos>',
  15.             eos_token = '<eos>',
  16.             lower = True)
  19. train_data, valid_data, test_data = Multi30k.splits(exts = ('.de', '.en'),
  20.                                                     fields = (SRC, TRG))

得出：

  1. downloading training.tar.gz
  2. downloading validation.tar.gz
  3. downloading mmt_task1_test2016.tar.gz

現(xiàn)在我們已經(jīng)定義了train_data，我們可以看到torchtext的Field的一個(gè)非常有用的功能：build_vocab方法現(xiàn)在允許我們創(chuàng)建與每種語言相關(guān)的詞匯

  1. SRC.build_vocab(train_data, min_freq = 2)
  2. TRG.build_vocab(train_data, min_freq = 2)

一旦運(yùn)行了這些代碼行，SRC.vocab.stoi將是一個(gè)詞典，其詞匯表中的標(biāo)記作為鍵，而其對應(yīng)的索引作為值； SRC.vocab.itos將是相同的字典，其中的鍵和值被交換。 在本教程中，我們不會(huì)廣泛使用此事實(shí)，但這在您將遇到的其他 NLP 任務(wù)中可能很有用。

BucketIterator

我們將使用的最后torchtext個(gè)特定功能是BucketIterator，它很容易使用，因?yàn)樗?code>TranslationDataset作為第一個(gè)參數(shù)。 具體來說，正如文檔所說：定義一個(gè)迭代器，該迭代器將相似長度的示例批處理在一起。 在為每個(gè)新紀(jì)元生產(chǎn)新鮮改組的批次時(shí)，最大程度地減少所需的填充量。 有關(guān)使用的存儲(chǔ)過程，請參閱池。

  1. import torch
  4. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  7. BATCH_SIZE = 128
  10. train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
  11.     (train_data, valid_data, test_data),
  12.     batch_size = BATCH_SIZE,
  13.     device = device)

可以像DataLoader``s; below, in the ``train和evaluate函數(shù)一樣調(diào)用這些迭代器，只需使用以下命令即可調(diào)用它們：

  1. for i, batch in enumerate(iterator):

每個(gè)batch然后具有src和trg屬性：

  1. src = batch.src
  2. trg = batch.trg

定義我們的nn.Module和Optimizer

這大部分是從torchtext角度出發(fā)的：構(gòu)建了數(shù)據(jù)集并定義了迭代器，本教程的其余部分僅將模型定義為nn.Module以及Optimizer，然后對其進(jìn)行訓(xùn)練。

具體來說，我們的模型遵循在此處中描述的架構(gòu)(您可以在此處找到更多注釋的版本）。

注意：此模型只是可用于語言翻譯的示例模型； 我們選擇它是因?yàn)樗侨蝿?wù)的標(biāo)準(zhǔn)模型，而不是因?yàn)樗怯糜诜g的推薦模型。 如您所知，目前最先進(jìn)的模型基于“變形金剛”； 您可以在此處看到 PyTorch 的實(shí)現(xiàn) Transformer 層的功能； 特別是，以下模型中使用的“注意”與變壓器模型中存在的多頭自我注意不同。 

  1. import random
  2. from typing import Tuple
  5. import torch.nn as nn
  6. import torch.optim as optim
  7. import torch.nn.functional as F
  8. from torch import Tensor
  11. class Encoder(nn.Module):
  12.     def __init__(self,
  13.                  input_dim: int,
  14.                  emb_dim: int,
  15.                  enc_hid_dim: int,
  16.                  dec_hid_dim: int,
  17.                  dropout: float):
  18.         super().__init__()
  21.         self.input_dim = input_dim
  22.         self.emb_dim = emb_dim
  23.         self.enc_hid_dim = enc_hid_dim
  24.         self.dec_hid_dim = dec_hid_dim
  25.         self.dropout = dropout
  28.         self.embedding = nn.Embedding(input_dim, emb_dim)
  31.         self.rnn = nn.GRU(emb_dim, enc_hid_dim, bidirectional = True)
  34.         self.fc = nn.Linear(enc_hid_dim * 2, dec_hid_dim)
  37.         self.dropout = nn.Dropout(dropout)
  40.     def forward(self,
  41.                 src: Tensor) -> Tuple[Tensor]:
  44.         embedded = self.dropout(self.embedding(src))
  47.         outputs, hidden = self.rnn(embedded)
  50.         hidden = torch.tanh(self.fc(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim = 1)))
  53.         return outputs, hidden
  56. class Attention(nn.Module):
  57.     def __init__(self,
  58.                  enc_hid_dim: int,
  59.                  dec_hid_dim: int,
  60.                  attn_dim: int):
  61.         super().__init__()
  64.         self.enc_hid_dim = enc_hid_dim
  65.         self.dec_hid_dim = dec_hid_dim
  68.         self.attn_in = (enc_hid_dim * 2) + dec_hid_dim
  71.         self.attn = nn.Linear(self.attn_in, attn_dim)
  74.     def forward(self,
  75.                 decoder_hidden: Tensor,
  76.                 encoder_outputs: Tensor) -> Tensor:
  79.         src_len = encoder_outputs.shape[0]
  82.         repeated_decoder_hidden = decoder_hidden.unsqueeze(1).repeat(1, src_len, 1)
  85.         encoder_outputs = encoder_outputs.permute(1, 0, 2)
  88.         energy = torch.tanh(self.attn(torch.cat((
  89.             repeated_decoder_hidden,
  90.             encoder_outputs),
  91.             dim = 2)))
  94.         attention = torch.sum(energy, dim=2)
  97.         return F.softmax(attention, dim=1)
  100. class Decoder(nn.Module):
  101.     def __init__(self,
  102.                  output_dim: int,
  103.                  emb_dim: int,
  104.                  enc_hid_dim: int,
  105.                  dec_hid_dim: int,
  106.                  dropout: int,
  107.                  attention: nn.Module):
  108.         super().__init__()
  111.         self.emb_dim = emb_dim
  112.         self.enc_hid_dim = enc_hid_dim
  113.         self.dec_hid_dim = dec_hid_dim
  114.         self.output_dim = output_dim
  115.         self.dropout = dropout
  116.         self.attention = attention
  119.         self.embedding = nn.Embedding(output_dim, emb_dim)
  122.         self.rnn = nn.GRU((enc_hid_dim * 2) + emb_dim, dec_hid_dim)
  125.         self.out = nn.Linear(self.attention.attn_in + emb_dim, output_dim)
  128.         self.dropout = nn.Dropout(dropout)
  131.     def _weighted_encoder_rep(self,
  132.                               decoder_hidden: Tensor,
  133.                               encoder_outputs: Tensor) -> Tensor:
  136.         a = self.attention(decoder_hidden, encoder_outputs)
  139.         a = a.unsqueeze(1)
  142.         encoder_outputs = encoder_outputs.permute(1, 0, 2)
  145.         weighted_encoder_rep = torch.bmm(a, encoder_outputs)
  148.         weighted_encoder_rep = weighted_encoder_rep.permute(1, 0, 2)
  151.         return weighted_encoder_rep
  154.     def forward(self,
  155.                 input: Tensor,
  156.                 decoder_hidden: Tensor,
  157.                 encoder_outputs: Tensor) -> Tuple[Tensor]:
  160.         input = input.unsqueeze(0)
  163.         embedded = self.dropout(self.embedding(input))
  166.         weighted_encoder_rep = self._weighted_encoder_rep(decoder_hidden,
  167.                                                           encoder_outputs)
  170.         rnn_input = torch.cat((embedded, weighted_encoder_rep), dim = 2)
  173.         output, decoder_hidden = self.rnn(rnn_input, decoder_hidden.unsqueeze(0))
  176.         embedded = embedded.squeeze(0)
  177.         output = output.squeeze(0)
  178.         weighted_encoder_rep = weighted_encoder_rep.squeeze(0)
  181.         output = self.out(torch.cat((output,
  182.                                      weighted_encoder_rep,
  183.                                      embedded), dim = 1))
  186.         return output, decoder_hidden.squeeze(0)
  189. class Seq2Seq(nn.Module):
  190.     def __init__(self,
  191.                  encoder: nn.Module,
  192.                  decoder: nn.Module,
  193.                  device: torch.device):
  194.         super().__init__()
  197.         self.encoder = encoder
  198.         self.decoder = decoder
  199.         self.device = device
  202.     def forward(self,
  203.                 src: Tensor,
  204.                 trg: Tensor,
  205.                 teacher_forcing_ratio: float = 0.5) -> Tensor:
  208.         batch_size = src.shape[1]
  209.         max_len = trg.shape[0]
  210.         trg_vocab_size = self.decoder.output_dim
  213.         outputs = torch.zeros(max_len, batch_size, trg_vocab_size).to(self.device)
  216.         encoder_outputs, hidden = self.encoder(src)
  219.         # first input to the decoder is the <sos> token
  220.         output = trg[0,:]
  223.         for t in range(1, max_len):
  224.             output, hidden = self.decoder(output, hidden, encoder_outputs)
  225.             outputs[t] = output
  226.             teacher_force = random.random() < teacher_forcing_ratio
  227.             top1 = output.max(1)[1]
  228.             output = (trg[t] if teacher_force else top1)
  231.         return outputs
  234. INPUT_DIM = len(SRC.vocab)
  235. OUTPUT_DIM = len(TRG.vocab)
  236. ## ENC_EMB_DIM = 256
  237. ## DEC_EMB_DIM = 256
  238. ## ENC_HID_DIM = 512
  239. ## DEC_HID_DIM = 512
  240. ## ATTN_DIM = 64
  241. ## ENC_DROPOUT = 0.5
  242. ## DEC_DROPOUT = 0.5
  245. ENC_EMB_DIM = 32
  246. DEC_EMB_DIM = 32
  247. ENC_HID_DIM = 64
  248. DEC_HID_DIM = 64
  249. ATTN_DIM = 8
  250. ENC_DROPOUT = 0.5
  251. DEC_DROPOUT = 0.5
  254. enc = Encoder(INPUT_DIM, ENC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, ENC_DROPOUT)
  257. attn = Attention(ENC_HID_DIM, DEC_HID_DIM, ATTN_DIM)
  260. dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, DEC_DROPOUT, attn)
  263. model = Seq2Seq(enc, dec, device).to(device)
  266. def init_weights(m: nn.Module):
  267.     for name, param in m.named_parameters():
  268.         if 'weight' in name:
  269.             nn.init.normal_(param.data, mean=0, std=0.01)
  270.         else:
  271.             nn.init.constant_(param.data, 0)
  274. model.apply(init_weights)
  277. optimizer = optim.Adam(model.parameters())
  280. def count_parameters(model: nn.Module):
  281.     return sum(p.numel() for p in model.parameters() if p.requires_grad)
  284. print(f'The model has {count_parameters(model):,} trainable parameters')

得出:

  1. The model has 1,856,685 trainable parameters

注意：特別是在對語言翻譯模型的性能進(jìn)行評分時(shí)，我們必須告訴nn.CrossEntropyLoss函數(shù)忽略僅填充目標(biāo)的索引。

  1. PAD_IDX = TRG.vocab.stoi['<pad>']
  4. criterion = nn.CrossEntropyLoss(ignore_index=PAD_IDX)

最后，我們可以訓(xùn)練和評估該模型：

  1. import math
  2. import time
  5. def train(model: nn.Module,
  6.           iterator: BucketIterator,
  7.           optimizer: optim.Optimizer,
  8.           criterion: nn.Module,
  9.           clip: float):
  12.     model.train()
  15.     epoch_loss = 0
  18.     for _, batch in enumerate(iterator):
  21.         src = batch.src
  22.         trg = batch.trg
  25.         optimizer.zero_grad()
  28.         output = model(src, trg)
  31.         output = output[1:].view(-1, output.shape[-1])
  32.         trg = trg[1:].view(-1)
  35.         loss = criterion(output, trg)
  38.         loss.backward()
  41.         torch.nn.utils.clip_grad_norm_(model.parameters(), clip)
  44.         optimizer.step()
  47.         epoch_loss += loss.item()
  50.     return epoch_loss / len(iterator)
  53. def evaluate(model: nn.Module,
  54.              iterator: BucketIterator,
  55.              criterion: nn.Module):
  58.     model.eval()
  61.     epoch_loss = 0
  64.     with torch.no_grad():
  67.         for _, batch in enumerate(iterator):
  70.             src = batch.src
  71.             trg = batch.trg
  74.             output = model(src, trg, 0) #turn off teacher forcing
  77.             output = output[1:].view(-1, output.shape[-1])
  78.             trg = trg[1:].view(-1)
  81.             loss = criterion(output, trg)
  84.             epoch_loss += loss.item()
  87.     return epoch_loss / len(iterator)
  90. def epoch_time(start_time: int,
  91.                end_time: int):
  92.     elapsed_time = end_time - start_time
  93.     elapsed_mins = int(elapsed_time / 60)
  94.     elapsed_secs = int(elapsed_time - (elapsed_mins * 60))
  95.     return elapsed_mins, elapsed_secs
  98. N_EPOCHS = 10
  99. CLIP = 1
  102. best_valid_loss = float('inf')
  105. for epoch in range(N_EPOCHS):
  108.     start_time = time.time()
  111.     train_loss = train(model, train_iterator, optimizer, criterion, CLIP)
  112.     valid_loss = evaluate(model, valid_iterator, criterion)
  115.     end_time = time.time()
  118.     epoch_mins, epoch_secs = epoch_time(start_time, end_time)
  121.     print(f'Epoch: {epoch+1:02} | Time: {epoch_mins}m {epoch_secs}s')
  122.     print(f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')
  123.     print(f'\t Val. Loss: {valid_loss:.3f} |  Val. PPL: {math.exp(valid_loss):7.3f}')
  126. test_loss = evaluate(model, test_iterator, criterion)
  129. print(f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |')

得出:

  1. Epoch: 01 | Time: 0m 35s
  2.         Train Loss: 5.667 | Train PPL: 289.080
  3.          Val. Loss: 5.201 |  Val. PPL: 181.371
  4. Epoch: 02 | Time: 0m 35s
  5.         Train Loss: 4.968 | Train PPL: 143.728
  6.          Val. Loss: 5.096 |  Val. PPL: 163.375
  7. Epoch: 03 | Time: 0m 35s
  8.         Train Loss: 4.720 | Train PPL: 112.221
  9.          Val. Loss: 4.989 |  Val. PPL: 146.781
  10. Epoch: 04 | Time: 0m 35s
  11.         Train Loss: 4.586 | Train PPL:  98.094
  12.          Val. Loss: 4.841 |  Val. PPL: 126.612
  13. Epoch: 05 | Time: 0m 35s
  14.         Train Loss: 4.430 | Train PPL:  83.897
  15.          Val. Loss: 4.809 |  Val. PPL: 122.637
  16. Epoch: 06 | Time: 0m 35s
  17.         Train Loss: 4.331 | Train PPL:  75.997
  18.          Val. Loss: 4.797 |  Val. PPL: 121.168
  19. Epoch: 07 | Time: 0m 35s
  20.         Train Loss: 4.240 | Train PPL:  69.434
  21.          Val. Loss: 4.694 |  Val. PPL: 109.337
  22. Epoch: 08 | Time: 0m 35s
  23.         Train Loss: 4.116 | Train PPL:  61.326
  24.          Val. Loss: 4.714 |  Val. PPL: 111.452
  25. Epoch: 09 | Time: 0m 35s
  26.         Train Loss: 4.004 | Train PPL:  54.815
  27.          Val. Loss: 4.563 |  Val. PPL:  95.835
  28. Epoch: 10 | Time: 0m 36s
  29.         Train Loss: 3.922 | Train PPL:  50.519
  30.          Val. Loss: 4.452 |  Val. PPL:  85.761
  31. | Test Loss: 4.456 | Test PPL:  86.155 |

下一步

  • 在上查看使用torchtext 的Ben Trevett 其余教程。
  • 敬請關(guān)注使用其他torchtext功能以及nn.Transformer通過下一個(gè)單詞預(yù)測進(jìn)行語言建模的教程！

腳本的總運(yùn)行時(shí)間：(6 分鐘 10.266 秒）

Download Python source code: torchtext_translation_tutorial.py Download Jupyter notebook: torchtext_translation_tutorial.ipynb

由獅身人面像畫廊生成的畫廊


以上內(nèi)容是否對您有幫助：
在線筆記
App下載
App下載

掃描二維碼

下載編程獅App

公眾號
微信公眾號

編程獅公眾號