PyTorch專欄（二十一）：使用Sequence2Sequence網絡和注意力進行翻譯

• 2019 年 11 月 14 日
• 筆記

作者 | News

編輯 | 奇予紀

出品 | 磐創AI團隊出品

使用Sequence2Sequence網絡和注意力進行翻譯：

在這個項目中，我們將講解使用神經網絡將法語翻譯成英語。

[KEY: > input, = target, < output]    > il est en train de peindre un tableau .  = he is painting a picture .  < he is painting a picture .    > pourquoi ne pas essayer ce vin delicieux ?  = why not try that delicious wine ?  < why not try that delicious wine ?    > elle n est pas poete mais romanciere .  = she is not a poet but a novelist .  < she not not a poet but a novelist .    > vous etes trop maigre .  = you re too skinny .  < you re all alone .

…取得了不同程度的成功。

這可以通過序列到序列網絡來實現，其中兩個遞歸神經網絡一起工作以將一個序列轉換成另一個序列。編碼器網絡將輸入序列壓縮成向量，並且解碼器網絡將該向量展開成新的序列。

• 閱讀建議

開始本教程前，你已經安裝好了PyTorch，並熟悉Python語言，理解「張量」的概念：

• https://pytorch.org/ PyTorch 安裝指南
• Deep Learning with PyTorch：A 60 Minute Blitz :PyTorch的基本入門教程 （https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html）
• Learning PyTorch with Examples:得到深層而廣泛的概述 （https://github.com/fendouai/PyTorchDocs/blob/master/ThirdSection/LearningPyTorch.md）
• PyTorch for Former Torch Users Lua Torch:如果你曾是一個Lua張量的使用者 （https://pytorch.org/tutorials/beginner/former_torchies_tutorial.html）

事先學習並了解序列到序列網絡的工作原理對理解這個例子十分有幫助:

• Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation （https://arxiv.org/abs/1406.1078）
• Sequence to Sequence Learning with Neural Networks （https://arxiv.org/abs/1409.3215）
• Neural Machine Translation by Jointly Learning to Align and Translate （https://arxiv.org/abs/1409.0473）
• A Neural Conversational Model （https://arxiv.org/abs/1506.05869）

您還可以找到之前有關Classifying Names with a Character-Level RNN和 Generating Names with a Character-Level RNN的教程，因為這些概念分別與編碼器和解碼器模型非常相似。

Classifying Names with a Character-Level RNN：

https://github.com/fendouai/PyTorchDocs/blob/master/FifthSection/Char%20RNN%20Classification.md

Generating Names with a Character-Level RNN：

https://github.com/fendouai/PyTorchDocs/blob/master/FifthSection/Char%20RNN%20Generation.MD

更多信息，請閱讀介紹這些主題的論文：

• Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation （https://arxiv.org/abs/1406.1078）
• Sequence to Sequence Learning with Neural Networks （https://arxiv.org/abs/1409.3215）
• Neural Machine Translation by Jointly Learning to Align and Translate （https://arxiv.org/abs/1409.0473）
• A Neural Conversational Model （https://arxiv.org/abs/1506.05869）

1.導入必須的包

from __future__ import unicode_literals, print_function, division  from io import open  import unicodedata  import string  import re  import random    import torch  import torch.nn as nn  from torch import optim  import torch.nn.functional as F    device= torch.device("cuda" if torch.cuda.is_available() else "cpu")

2.加載數據文件

該項目的數據是成千上萬的英語到法語的翻譯對的集合。

關於Open Data Stack Exchange的這個問題，開放式翻譯網站 https://tatoeba.org/給出了指導，該網站的下載位於：https://tatoeba.org/eng/downloads

• 更好的是，有人做了額外的拆分工作，將語言對分成單獨的文本文件：https：//www.manythings.org/anki/

英語到法語對因為太大而無法包含在repo中，因此下載到data / eng-fra.txt再繼續進行後續步驟。該文件是以製表符分隔的翻譯對列表：

I am cold.    J'ai froid.

注意：從此處（https://download.pytorch.org/tutorial/data.zip）下載數據並將其解壓縮到當前目錄。

與字符級RNN教程中使用的字符編碼類似，我們將語言中的每個單詞表示為one-hot向量或零的巨向量，除了單個字符（在單詞的索引處）。 與語言中可能存在的幾十個字符相比，還有更多的字，因此編碼向量很大。然而，我們投機取巧並修剪數據，每種語言只使用幾千個單詞。

我們將需要每個單詞的唯一索引，以便稍後用作網絡的輸入和目標。為了跟蹤所有這些，我們將使用一個名為Lang的輔助類，它具有word→index（word2index）和index→word（index2word）的字典，以及用於稍後替換稀有單詞的每個單詞word2count的計數。

SOS_token = 0  EOS_token = 1      class Lang:      def __init__(self, name):          self.name = name          self.word2index = {}          self.word2count = {}          self.index2word = {0: "SOS", 1: "EOS"}          self.n_words = 2  # Count SOS and EOS        def addSentence(self, sentence):          for word in sentence.split(' '):              self.addWord(word)        def addWord(self, word):          if word not in self.word2index:              self.word2index[word] = self.n_words              self.word2count[word] = 1              self.index2word[self.n_words] = word              self.n_words += 1          else:              self.word2count[word] += 1

這些文件都是Unicode格式，為了簡化我們將Unicode字符轉換為ASCII，使所有內容都小寫，並去掉大多數標點符號。

# 將Unicode字符串轉換為純ASCII, 感謝https://stackoverflow.com/a/518232/2809427  def unicodeToAscii(s):      return ''.join(          c for c in unicodedata.normalize('NFD', s)          if unicodedata.category(c) != 'Mn'      )    # 小寫，修剪和刪除非字母字符      def normalizeString(s):      s = unicodeToAscii(s.lower().strip())      s = re.sub(r"([.!?])", r" 1", s)      s = re.sub(r"[^a-zA-Z.!?]+", r" ", s)      return s

2.1 讀取數據文件

要讀取數據文件，我們將文件拆分為行，然後將行拆分成對。這些文件都是英語→其他語言，所以如果我們想翻譯其他語言→英語，我添加reverse標誌來反轉對。

def readLangs(lang1, lang2, reverse=False):      print("Reading lines...")        # 讀取文件並分成幾行      lines = open('data/%s-%s.txt' % (lang1, lang2), encoding='utf-8').          read().strip().split('n')        # 將每一行拆分成對並進行標準化      pairs = [[normalizeString(s) for s in l.split('t')] for l in lines]        # 反向對，使Lang實例      if reverse:          pairs = [list(reversed(p)) for p in pairs]          input_lang = Lang(lang2)          output_lang = Lang(lang1)      else:          input_lang = Lang(lang1)          output_lang = Lang(lang2)        return input_lang, output_lang, pairs

由於有很多例句，我們想快速訓練，我們會將數據集修剪成相對簡短的句子。這裡最大長度是10個單詞（包括結束標點符號），我們將過濾到轉換為「我是」或「他是」等形式的句子（考慮先前替換的撇號）。

MAX_LENGTH = 10    eng_prefixes = (      "i am ", "i m ",      "he is", "he s ",      "she is", "she s ",      "you are", "you re ",      "we are", "we re ",      "they are", "they re "  )      def filterPair(p):      return len(p[0].split(' ')) < MAX_LENGTH and           len(p[1].split(' ')) < MAX_LENGTH and           p[1].startswith(eng_prefixes)      def filterPairs(pairs):      return [pair for pair in pairs if filterPair(pair)]

準備數據的完整過程是：

• 讀取文本文件並拆分成行，將行拆分成對
• 規範化文本，按長度和內容進行過濾
• 從成對的句子中製作單詞列表

def prepareData(lang1, lang2, reverse=False):      input_lang, output_lang, pairs = readLangs(lang1, lang2, reverse)      print("Read %s sentence pairs" % len(pairs))      pairs = filterPairs(pairs)      print("Trimmed to %s sentence pairs" % len(pairs))      print("Counting words...")      for pair in pairs:          input_lang.addSentence(pair[0])          output_lang.addSentence(pair[1])      print("Counted words:")      print(input_lang.name, input_lang.n_words)      print(output_lang.name, output_lang.n_words)      return input_lang, output_lang, pairs      input_lang, output_lang, pairs = prepareData('eng', 'fra', True)  print(random.choice(pairs))

• 輸出結果：

Reading lines...  Read 135842 sentence pairs  Trimmed to 10599 sentence pairs  Counting words...  Counted words:  fra 4345  eng 2803  ['nous nous deshabillons .', 'we re undressing .']

3.Seq2Seq模型

遞歸神經網絡（RNN）是一種對序列進行操作的網絡，它使用自己的輸出作為後續步驟的輸入。

Sequence to Sequence network(seq2seq網絡：https://arxiv.org/abs/1409.3215)或[Encoder Decoder network(https://arxiv.org/pdf/1406.1078v3.pdf)是由稱為編碼器和解碼器的兩個RNN組成的模型。編碼器讀取輸入序列並輸出單個向量，並且解碼器讀取該向量以產生輸出序列。

與使用單個RNN的序列預測不同，其中每個輸入對應於輸出，seq2seq模型使我們從序列長度和順序中解放出來，這使其成為兩種語言之間轉換的理想選擇。

考慮一句「Je ne suis pas le chat noir」→「我不是黑貓」。輸入句子中的大多數單詞在輸出句子中都有直接翻譯，但順序略有不同，例如 「聊天黑色」和「黑貓」。由於「ne / pas」結構，輸入句中還有一個單詞。直接從輸入字序列產生正確的翻譯將是困難的。

使用seq2seq模型，編碼器創建單個向量，在理想情況下，將輸入序列的「含義」編碼為單個向量 – 句子的某些N維空間中的單個點。

3.1 編碼器

seq2seq網絡的編碼器是RNN，它為輸入句子中的每個單詞輸出一些值。對於每個輸入的詞，編碼器輸出向量和隱藏狀態，並將隱藏狀態用於下一個輸入的單詞。

class EncoderRNN(nn.Module):      def __init__(self, input_size, hidden_size):          super(EncoderRNN, self).__init__()          self.hidden_size = hidden_size            self.embedding = nn.Embedding(input_size, hidden_size)          self.gru = nn.GRU(hidden_size, hidden_size)        def forward(self, input, hidden):          embedded = self.embedding(input).view(1, 1, -1)          output = embedded          output, hidden = self.gru(output, hidden)          return output, hidden        def initHidden(self):          return torch.zeros(1, 1, self.hidden_size, device=device)

3.2 解碼器

解碼器是另一個RNN，它接收編碼器輸出向量並輸出一系列字以創建轉換。

簡單的解碼器： 在最簡單的seq2seq解碼器中，我們僅使用編碼器的最後一個輸出。最後一個輸出有時稱為上下文向量，因為它編碼整個序列的上下文。該上下文向量用作解碼器的初始隱藏狀態。

在解碼的每個步驟中，給予解碼器輸入token和隱藏狀態。初始輸入token是開始字符串<SOS>標記，第一個隱藏狀態是上下文向量（編碼器的最後隱藏狀態）。

class DecoderRNN(nn.Module):      def __init__(self, hidden_size, output_size):          super(DecoderRNN, self).__init__()          self.hidden_size = hidden_size            self.embedding = nn.Embedding(output_size, hidden_size)          self.gru = nn.GRU(hidden_size, hidden_size)          self.out = nn.Linear(hidden_size, output_size)          self.softmax = nn.LogSoftmax(dim=1)        def forward(self, input, hidden):          output = self.embedding(input).view(1, 1, -1)          output = F.relu(output)          output, hidden = self.gru(output, hidden)          output = self.softmax(self.out(output[0]))          return output, hidden        def initHidden(self):          return torch.zeros(1, 1, self.hidden_size, device=device)

我鼓勵你訓練和觀察這個模型的結果，但為了節省空間，我們將直接進入主題並引入注意機制。

3.3 注意力機制解碼器

如果僅在編碼器和解碼器之間傳遞上下文向量，則該單個向量承擔編碼整個句子的信息。

注意力允許解碼器網絡針對解碼器自身輸出的每個步驟「聚焦」編碼器輸出的不同部分。首先，我們計算一組注意力權重。這些將乘以編碼器輸出向量以創建加權組合。結果（在代碼中稱為attn_applied）應包含有關輸入序列特定部分的信息，從而幫助解碼器選擇正確的輸出單詞。

使用解碼器的輸入和隱藏狀態作為輸入，使用另一個前饋層attn來計算注意力權重。因為訓練數據中存在所有不同大小的句子，為了實際創建和訓練該層，我們必須選擇它可以應用的最大句子長度（輸入長度，對於編碼器輸出）。最大長度的句子將使用所有注意力權重，而較短的句子將僅使用前幾個。

class AttnDecoderRNN(nn.Module):      def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):          super(AttnDecoderRNN, self).__init__()          self.hidden_size = hidden_size          self.output_size = output_size          self.dropout_p = dropout_p          self.max_length = max_length            self.embedding = nn.Embedding(self.output_size, self.hidden_size)          self.attn = nn.Linear(self.hidden_size * 2, self.max_length)          self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)          self.dropout = nn.Dropout(self.dropout_p)          self.gru = nn.GRU(self.hidden_size, self.hidden_size)          self.out = nn.Linear(self.hidden_size, self.output_size)        def forward(self, input, hidden, encoder_outputs):          embedded = self.embedding(input).view(1, 1, -1)          embedded = self.dropout(embedded)            attn_weights = F.softmax(              self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)          attn_applied = torch.bmm(attn_weights.unsqueeze(0),                                   encoder_outputs.unsqueeze(0))            output = torch.cat((embedded[0], attn_applied[0]), 1)          output = self.attn_combine(output).unsqueeze(0)            output = F.relu(output)          output, hidden = self.gru(output, hidden)            output = F.log_softmax(self.out(output[0]), dim=1)          return output, hidden, attn_weights        def initHidden(self):          return torch.zeros(1, 1, self.hidden_size, device=device)

注意： 通過使用相對位置方法，還有其他形式的注意力可以解決長度限制問題。閱讀[Effective Approaches to Attention-based Neural Machine Translation.] (https://arxiv.org/abs/1508.04025)的「本地注意」。

4.訓練

4.1 準備訓練數據

為了訓練，對於每對翻譯對，我們將需要輸入張量（輸入句子中的單詞的索引）和目標張量（目標句子中的單詞的索引）。在創建這些向量時，我們會將EOS標記附加到兩個序列。

def indexesFromSentence(lang, sentence):      return [lang.word2index[word] for word in sentence.split(' ')]      def tensorFromSentence(lang, sentence):      indexes = indexesFromSentence(lang, sentence)      indexes.append(EOS_token)      return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1)      def tensorsFromPair(pair):      input_tensor = tensorFromSentence(input_lang, pair[0])      target_tensor = tensorFromSentence(output_lang, pair[1])      return (input_tensor, target_tensor)

4.2 訓練模型

為了訓練我們通過編碼器運行的輸入句子，並跟蹤每個輸出和最新的隱藏狀態。然後，解碼器被賦予標記作為其第一輸入，並且編碼器的最後隱藏狀態作為其第一隱藏狀態。

「Teacher Forcing」是將真實目標輸出用作每個下一個輸入的概念，而不是使用解碼器的猜測作為下一個輸入。使用teacher forcing使模型更快地收斂，但是當利用受過訓練的網絡時，它可能表現出不穩定性。

您可以觀察teacher forcing網絡的輸出，這些網絡使用連貫的語法閱讀，但遠離正確的翻譯 – 直覺上它已經學會表示輸出語法，並且一旦老師告訴它前幾個單詞就可以「提取」意義，但是它沒有正確地學習如何從翻譯中創建句子。

由於PyTorch的 autograd 為我們提供了自由，我們可以隨意選擇使用teacher forcing或不使用簡單的if語句。將teacher_forcing_ratio調高以使用更多。

teacher_forcing_ratio = 0.5      def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=MAX_LENGTH):      encoder_hidden = encoder.initHidden()        encoder_optimizer.zero_grad()      decoder_optimizer.zero_grad()        input_length = input_tensor.size(0)      target_length = target_tensor.size(0)        encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)        loss = 0        for ei in range(input_length):          encoder_output, encoder_hidden = encoder(              input_tensor[ei], encoder_hidden)          encoder_outputs[ei] = encoder_output[0, 0]        decoder_input = torch.tensor([[SOS_token]], device=device)        decoder_hidden = encoder_hidden        use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False        if use_teacher_forcing:          # Teacher forcing: Feed the target as the next input          for di in range(target_length):              decoder_output, decoder_hidden, decoder_attention = decoder(                  decoder_input, decoder_hidden, encoder_outputs)              loss += criterion(decoder_output, target_tensor[di])              decoder_input = target_tensor[di]  # Teacher forcing        else:          # Without teacher forcing: use its own predictions as the next input          for di in range(target_length):              decoder_output, decoder_hidden, decoder_attention = decoder(                  decoder_input, decoder_hidden, encoder_outputs)              topv, topi = decoder_output.topk(1)              decoder_input = topi.squeeze().detach()  # detach from history as input                loss += criterion(decoder_output, target_tensor[di])              if decoder_input.item() == EOS_token:                  break        loss.backward()        encoder_optimizer.step()      decoder_optimizer.step()        return loss.item() / target_length

輔助函數

這是一個輔助函數，用於打印經過的時間和估計的剩餘時間給定當前時間和進度％。

import time  import math      def asMinutes(s):      m = math.floor(s / 60)      s -= m * 60      return '%dm %ds' % (m, s)      def timeSince(since, percent):      now = time.time()      s = now - since      es = s / (percent)      rs = es - s      return '%s (- %s)' % (asMinutes(s), asMinutes(rs))

整個訓練過程如下：

• 啟動計時器
• 初始化優化器和標準
• 創建一組訓練對
• 啟動空損數組進行繪圖

然後我們調用train，偶爾打印進度（例子的百分比，到目前為止的時間，估計的時間）和平均損失。

def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):      start = time.time()      plot_losses = []      print_loss_total = 0  # Reset every print_every      plot_loss_total = 0  # Reset every plot_every        encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)      decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)      training_pairs = [tensorsFromPair(random.choice(pairs))                        for i in range(n_iters)]      criterion = nn.NLLLoss()        for iter in range(1, n_iters + 1):          training_pair = training_pairs[iter - 1]          input_tensor = training_pair[0]          target_tensor = training_pair[1]            loss = train(input_tensor, target_tensor, encoder,                       decoder, encoder_optimizer, decoder_optimizer, criterion)          print_loss_total += loss          plot_loss_total += loss            if iter % print_every == 0:              print_loss_avg = print_loss_total / print_every              print_loss_total = 0              print('%s (%d %d%%) %.4f' % (timeSince(start, iter / n_iters),                                           iter, iter / n_iters * 100, print_loss_avg))            if iter % plot_every == 0:              plot_loss_avg = plot_loss_total / plot_every              plot_losses.append(plot_loss_avg)              plot_loss_total = 0        showPlot(plot_losses)

結果繪圖函數

繪圖使用 matplotlib 庫完成，使用在訓練時保存的plot_losses的損失值數組。

import matplotlib.pyplot as plt  plt.switch_backend('agg')  import matplotlib.ticker as ticker  import numpy as np      def showPlot(points):      plt.figure()      fig, ax = plt.subplots()      # this locator puts ticks at regular intervals      loc = ticker.MultipleLocator(base=0.2)      ax.yaxis.set_major_locator(loc)      plt.plot(points)

評價函數

評估與訓練大致相同，但沒有目標，因此我們只需將解碼器的預測反饋給每個步驟。每次它預測一個單詞時我們都會將它添加到輸出字符串中，如果它預測了EOS標記，我們就會停在那裡。我們還存儲解碼器的注意力輸出以供稍後顯示。

def evaluate(encoder, decoder, sentence, max_length=MAX_LENGTH):      with torch.no_grad():          input_tensor = tensorFromSentence(input_lang, sentence)          input_length = input_tensor.size()[0]          encoder_hidden = encoder.initHidden()            encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)            for ei in range(input_length):              encoder_output, encoder_hidden = encoder(input_tensor[ei],                                                       encoder_hidden)              encoder_outputs[ei] += encoder_output[0, 0]            decoder_input = torch.tensor([[SOS_token]], device=device)  # SOS            decoder_hidden = encoder_hidden            decoded_words = []          decoder_attentions = torch.zeros(max_length, max_length)            for di in range(max_length):              decoder_output, decoder_hidden, decoder_attention = decoder(                  decoder_input, decoder_hidden, encoder_outputs)              decoder_attentions[di] = decoder_attention.data              topv, topi = decoder_output.data.topk(1)              if topi.item() == EOS_token:                  decoded_words.append('<EOS>')                  break              else:                  decoded_words.append(output_lang.index2word[topi.item()])                decoder_input = topi.squeeze().detach()            return decoded_words, decoder_attentions[:di + 1]

我們可以從訓練集中評估隨機句子並打印輸入、目標和輸出以做出一些直觀質量判斷：

def evaluateRandomly(encoder, decoder, n=10):      for i in range(n):          pair = random.choice(pairs)          print('>', pair[0])          print('=', pair[1])          output_words, attentions = evaluate(encoder, decoder, pair[0])          output_sentence = ' '.join(output_words)          print('<', output_sentence)          print('')

5.訓練和評價

有了所有這些輔助函數（它看起來像是額外的工作，但它使得運行多個實驗更容易）我們實際上可以初始化網絡並開始訓練。

請記住，輸入句子被嚴格過濾。對於這個小數據集，我們可以使用256個隱藏節點和單個GRU層的相對較小的網絡。在MacBook CPU上大約40分鐘後，我們將得到一些合理的結果。

注意： 如果你運行這個筆記，你可以訓練、中斷內核、評估，並在以後繼續訓練。注釋掉編碼器和解碼器初始化的行並再次運行trainIters。

hidden_size = 256  encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)  attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1).to(device)    trainIters(encoder1, attn_decoder1, 75000, print_every=5000)

• 輸出結果：

1m 53s (- 26m 24s) (5000 6%) 2.8558  3m 42s (- 24m 3s) (10000 13%) 2.2832  5m 31s (- 22m 6s) (15000 20%) 1.9841  7m 19s (- 20m 8s) (20000 26%) 1.7271  9m 7s (- 18m 15s) (25000 33%) 1.5487  10m 54s (- 16m 21s) (30000 40%) 1.3461  12m 41s (- 14m 30s) (35000 46%) 1.2251  14m 30s (- 12m 41s) (40000 53%) 1.0956  16m 16s (- 10m 51s) (45000 60%) 1.0126  18m 5s (- 9m 2s) (50000 66%) 0.9212  19m 52s (- 7m 13s) (55000 73%) 0.7952  21m 41s (- 5m 25s) (60000 80%) 0.7481  23m 29s (- 3m 36s) (65000 86%) 0.6882  25m 17s (- 1m 48s) (70000 93%) 0.6190  27m 6s (- 0m 0s) (75000 100%) 0.5745

evaluateRandomly(encoder1, attn_decoder1)

• 輸出結果：

> je pars en vacances pour quelques jours .  = i m taking a couple of days off .  < i m taking a couple of days off . <EOS>    > je ne me panique pas .  = i m not panicking .  < i m not panicking . <EOS>    > je recherche un assistant .  = i am looking for an assistant .  < i m looking a call . <EOS>    > je suis loin de chez moi .  = i m a long way from home .  < i m a little friend . <EOS>    > vous etes en retard .  = you re very late .  < you are late . <EOS>    > j ai soif .  = i am thirsty .  < i m thirsty . <EOS>    > je suis fou de vous .  = i m crazy about you .  < i m crazy about you . <EOS>    > vous etes vilain .  = you are naughty .  < you are naughty . <EOS>    > il est vieux et laid .  = he s old and ugly .  < he s old and ugly . <EOS>    > je suis terrifiee .  = i m terrified .  < i m touched . <EOS>

6.可視化注意力

注意力機制的一個有用特性是其高度可解釋的輸出。因為它用於對輸入序列的特定編碼器輸出進行加權，所以我們可以想像在每個時間步長看網絡最關注的位置。

您可以簡單地運行plt.matshow（attention）以將注意力輸出顯示為矩陣，其中列是輸入步驟，行是輸出步驟：

output_words, attentions = evaluate(      encoder1, attn_decoder1, "je suis trop froid .")  plt.matshow(attentions.numpy())

為了獲得更好的觀看體驗，我們將額外添加軸和標籤：

def showAttention(input_sentence, output_words, attentions):      # 用colorbar設置圖      fig = plt.figure()      ax = fig.add_subplot(111)      cax = ax.matshow(attentions.numpy(), cmap='bone')      fig.colorbar(cax)        # 設置坐標      ax.set_xticklabels([''] + input_sentence.split(' ') +                         ['<EOS>'], rotation=90)      ax.set_yticklabels([''] + output_words)        # 在每個刻度處顯示標籤      ax.xaxis.set_major_locator(ticker.MultipleLocator(1))      ax.yaxis.set_major_locator(ticker.MultipleLocator(1))        plt.show()      def evaluateAndShowAttention(input_sentence):      output_words, attentions = evaluate(          encoder1, attn_decoder1, input_sentence)      print('input =', input_sentence)      print('output =', ' '.join(output_words))      showAttention(input_sentence, output_words, attentions)      evaluateAndShowAttention("elle a cinq ans de moins que moi .")    evaluateAndShowAttention("elle est trop petit .")    evaluateAndShowAttention("je ne crains pas de mourir .")    evaluateAndShowAttention("c est un jeune directeur plein de talent .")

• 輸出結果：

input = elle a cinq ans de moins que moi .  output = she is two years younger than me . <EOS>  input = elle est trop petit .  output = she s too trusting . <EOS>  input = je ne crains pas de mourir .  output = i m not afraid of dying . <EOS>  input = c est un jeune directeur plein de talent .  output = he s a fast person . <EOS>

7.練習

• 嘗試使用其他數據集：   * 另一種語言對   * 人→機器（例如IOT命令）   * 聊天→回復   * 問題→答案
• 用預先訓練過的字嵌入（例如word2vec或GloVe）替換嵌入
• 嘗試使用更多圖層，更多隱藏單元和更多句子。比較訓練時間和結果。
• 如果你使用翻譯文件，其中對有兩個相同的短語（I am test t I am tes），你可以使用它作為自動編碼器。試試這個：   * 訓練為自動編碼器   * 僅保存編碼器網絡   * 從那裡訓練一個新的解碼器進行翻譯