Transformer註解及PyTorch實現（下）

摘要： 請先閱讀 Transformer註解及PyTorch實現（上） 目錄 訓練 - 批和掩碼 - 訓練迴圈 - 訓練資料和批處理 - 硬體和訓練進度 -優化器 -正則化 - 標籤平滑 第一個例子 - 資料生成 - 損失計算 - 貪心解...

請先閱讀 ofollow,noindex" target="_blank">Transformer註解及PyTorch實現（上）

目錄

訓練

- 批和掩碼

- 訓練迴圈

- 訓練資料和批處理

- 硬體和訓練進度

-優化器

-正則化

- 標籤平滑

第一個例子

- 資料生成

- 損失計算

- 貪心解碼

真實示例

- 資料載入

- 迭代器

- 多GPU訓練

- 訓練系統附加元件：BPE，搜尋，平均

結果

- 注意力視覺化

結論

訓練

本節介紹模型的訓練方法。

快速穿插介紹訓練標準編碼器解碼器模型需要的一些工具。首先我們定義一個包含源和目標句子的批訓練物件用於訓練，同時構造掩碼。

批和掩碼

1. class Batch:

2.    "Object for holding a batch of data with mask during training."

3.    def __init__(self, src, trg=None, pad=0):

4.        self.src = src

5.        self.src_mask = (src != pad).unsqueeze(-2)

6.        if trg is not None:

7.            self.trg = trg[:, :-1]

8.            self.trg_y = trg[:, 1:]

9.            self.trg_mask = \

10.                self.make_std_mask(self.trg, pad)

11.            self.ntokens = (self.trg_y != pad).data.sum()

13.    @staticmethod

14.    def make_std_mask(tgt, pad):

15.        "Create a mask to hide padding and future words."

16.        tgt_mask = (tgt != pad).unsqueeze(-2)

17.        tgt_mask = tgt_mask & Variable(

18.            subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data))

19.        return tgt_mask

接下來，我們建立一個通用的訓練和得分函式來跟蹤損失。我們傳入一個通用的損失計算函式，它也處理引數更新。

訓練迴圈

def run_epoch(data_iter, model, loss_compute):
   "Standard Training and Logging Function"
   start = time.time()
   total_tokens = 0
   total_loss = 0
   tokens = 0
   for i, batch in enumerate(data_iter):
       out = model.forward(batch.src, batch.trg,
                           batch.src_mask, batch.trg_mask)
       loss = loss_compute(out, batch.trg_y, batch.ntokens)
       total_loss += loss
       total_tokens += batch.ntokens
       tokens += batch.ntokens
       if i % 50 == 1:
           elapsed = time.time() - start
           print("Epoch Step: %d Loss: %f Tokens per Sec: %f" %
                   (i, loss / batch.ntokens, tokens / elapsed))
           start = time.time()
           tokens = 0
   return total_loss / total_tokens

訓練資料和批處理

我們使用標準WMT 2014英語-德語資料集進行了訓練，該資料集包含大約450萬個句子對。 使用位元組對的編碼方法對句子進行編碼，該編碼具有大約37000個詞的共享源-目標詞彙表。 對於英語-法語，我們使用了WMT 2014 英語-法語資料集，該資料集由36M個句子組成，並將詞分成32000個詞片(Word-piece)的詞彙表。

句子對按照近似的序列長度進行批處理。每個訓練批包含一組句子對，包含大約25000個源詞和25000個目標詞。

我們將使用torch text來建立批次。下面更詳細地討論實現過程。 我們在torchtext的一個函式中建立批次，確保填充到最大批訓練長度的大小不超過閾值（如果我們有8個GPU，則閾值為25000）。

global max_src_in_batch, max_tgt_in_batch
def batch_size_fn(new, count, sofar):
   "Keep augmenting batch and calculate total number of tokens + padding."
   global max_src_in_batch, max_tgt_in_batch
   if count == 1:
       max_src_in_batch = 0
       max_tgt_in_batch = 0
   max_src_in_batch = max(max_src_in_batch,  len(new.src))
   max_tgt_in_batch = max(max_tgt_in_batch,  len(new.trg) + 2)
   src_elements = count * max_src_in_batch
   tgt_elements = count * max_tgt_in_batch
   return max(src_elements, tgt_elements)

硬體和訓練進度

我們在一臺配備8個NVIDIA P100 GPU的機器上訓練我們的模型。 對於使用本文所述的超引數的基本模型，每個訓練單步大約需要0.4秒。 我們對基礎模型進行了總共100,000步或12小時的訓練。 對於我們的大型模型，每個訓練單步時間為1.0秒。 大型模型通常需要訓練300,000步（3.5天）。

優化器

我們選擇Adam[1]作為優化器，其引數為 、 和 。根據以下公式，我們在訓練過程中改變了學習率： 。在預熱中隨步數線性地增加學習速率，並且此後與步數的反平方根成比例地減小它。我們設定預熱步數為4000。

注意：這部分非常重要，需要這種設定訓練模型。

1. class NoamOpt:

2.    "Optim wrapper that implements rate."

3.    def __init__(self, model_size, factor, warmup, optimizer):

4.        self.optimizer = optimizer

5.        self._step = 0

6.        self.warmup = warmup

7.        self.factor = factor

8.        self.model_size = model_size

9.        self._rate = 0

11.    def step(self):

12.        "Update parameters and rate"

13.        self._step += 1

14.        rate = self.rate()

15.        for p in self.optimizer.param_groups:

16.            p['lr'] = rate

17.        self._rate = rate

18.        self.optimizer.step()

20.    def rate(self, step = None):

21.        "Implement `lrate` above"

22.        if step is None:

23.            step = self._step

24.        return self.factor * \

25.            (self.model_size ** (-0.5) *

26.            min(step ** (-0.5), step * self.warmup ** (-1.5)))

28. def get_std_opt(model):

29.    return NoamOpt(model.src_embed[0].d_model, 2, 4000,

30.            torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))

當前模型在不同模型大小和超引數的情況下的曲線示例。

# Three settings of the lrate hyperparameters.
opts = [NoamOpt(512, 1, 4000, None),
       NoamOpt(512, 1, 8000, None),
       NoamOpt(256, 1, 4000, None)]
plt.plot(np.arange(1, 20000), [[opt.rate(i) for opt in opts] for i in range(1, 20000)])
plt.legend(["512:4000", "512:8000", "256:4000"])
None

正則化

標籤平滑

在訓練期間，我們採用了值 [2]的標籤平滑。 這種做法提高了困惑度，因為模型變得更加不確定，但提高了準確性和BLEU分數。

我們使用KL div loss實現標籤平滑。 相比使用獨熱目標分佈，我們建立一個分佈，其包含正確單詞的置信度和整個詞彙表中分佈的其餘平滑項。

class LabelSmoothing(nn.Module):
    "Implement label smoothing."
    def __init__(self, size, padding_idx, smoothing=0.0):
        super(LabelSmoothing, self).__init__()
        self.criterion = nn.KLDivLoss(size_average=False)
        self.padding_idx = padding_idx
        self.confidence = 1.0 - smoothing
        self.smoothing = smoothing
        self.size = size
        self.true_dist = None
    def forward(self, x, target):
        assert x.size(1) == self.size
        true_dist = x.data.clone()
        true_dist.fill_(self.smoothing / (self.size - 2))
        true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)
        true_dist[:, self.padding_idx] = 0
        mask = torch.nonzero(target.data == self.padding_idx)
        if mask.dim() > 0:
            true_dist.index_fill_(0, mask.squeeze(), 0.0)
        self.true_dist = true_dist
        return self.criterion(x, Variable(true_dist, requires_grad=False))

在這裡，我們可以看到標籤平滑的示例。

1. # Example of label smoothing.

2. crit = LabelSmoothing(5, 0, 0.4)

3. predict = torch.FloatTensor([[0, 0.2, 0.7, 0.1, 0],

4.                             [0, 0.2, 0.7, 0.1, 0],

5.                             [0, 0.2, 0.7, 0.1, 0]])

6. v = crit(Variable(predict.log()),

7.         Variable(torch.LongTensor([2, 1, 0])))

9. # Show the target distributions expected by the system.

10. plt.imshow(crit.true_dist)

11. None

如果對給定的選擇非常有信心，標籤平滑實際上會開始懲罰模型。

crit = LabelSmoothing(5, 0, 0.1)
def loss(x):
   d = x + 3 * 1
   predict = torch.FloatTensor([[0, x / d, 1 / d, 1 / d, 1 / d],
                                ])
   #print(predict)
   return crit(Variable(predict.log()),
                Variable(torch.LongTensor([1]))).data[0]
plt.plot(np.arange(1, 100), [loss(x) for x in range(1, 100)])
None

第一個例子

我們可以先嚐試一個簡單的複製任務。 給定來自小詞彙表的隨機輸入符號集，目標是生成那些相同的符號。

資料生成

def data_gen(V, batch, nbatches):
   "Generate random data for a src-tgt copy task."
   for i in range(nbatches):
       data = torch.from_numpy(np.random.randint(1, V, size=(batch, 10)))
       data[:, 0] = 1
       src = Variable(data, requires_grad=False)
       tgt = Variable(data, requires_grad=False)
       yield Batch(src, tgt, 0)

損失計算

class SimpleLossCompute:
    "A simple loss compute and train function."
    def __init__(self, generator, criterion, opt=None):
        self.generator = generator
        self.criterion = criterion
        self.opt = opt
    def __call__(self, x, y, norm):
        x = self.generator(x)
        loss = self.criterion(x.contiguous().view(-1, x.size(-1)), 
                              y.contiguous().view(-1)) / norm
        loss.backward()
        if self.opt is not None:
            self.opt.step()
            self.opt.optimizer.zero_grad()
        return loss.data[0] * norm

貪心解碼

1. # Train the simple copy task.

2. V = 11

3. criterion = LabelSmoothing(size=V, padding_idx=0, smoothing=0.0)

4. model = make_model(V, V, N=2)

5. model_opt = NoamOpt(model.src_embed[0].d_model, 1, 400,

6.        torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))

8. for epoch in range(10):

9.    model.train()

10.    run_epoch(data_gen(V, 30, 20), model,

11.              SimpleLossCompute(model.generator, criterion, model_opt))

12.    model.eval()

13.    print(run_epoch(data_gen(V, 30, 5), model,

14.                    SimpleLossCompute(model.generator, criterion, None)))

Epoch Step: 1 Loss: 3.023465 Tokens per Sec: 403.074173
Epoch Step: 1 Loss: 1.920030 Tokens per Sec: 641.689380
1.9274832487106324
Epoch Step: 1 Loss: 1.940011 Tokens per Sec: 432.003378
Epoch Step: 1 Loss: 1.699767 Tokens per Sec: 641.979665
1.657595729827881
Epoch Step: 1 Loss: 1.860276 Tokens per Sec: 433.320240
Epoch Step: 1 Loss: 1.546011 Tokens per Sec: 640.537198
1.4888023376464843
Epoch Step: 1 Loss: 1.682198 Tokens per Sec: 432.092305
Epoch Step: 1 Loss: 1.313169 Tokens per Sec: 639.441857
1.3485562801361084
Epoch Step: 1 Loss: 1.278768 Tokens per Sec: 433.568756
Epoch Step: 1 Loss: 1.062384 Tokens per Sec: 642.542067
0.9853351473808288
Epoch Step: 1 Loss: 1.269471 Tokens per Sec: 433.388727
Epoch Step: 1 Loss: 0.590709 Tokens per Sec: 642.862135
0.5686767101287842
Epoch Step: 1 Loss: 0.997076 Tokens per Sec: 433.009746
Epoch Step: 1 Loss: 0.343118 Tokens per Sec: 642.288427
0.34273059368133546
Epoch Step: 1 Loss: 0.459483 Tokens per Sec: 434.594030
Epoch Step: 1 Loss: 0.290385 Tokens per Sec: 642.519464
0.2612409472465515
Epoch Step: 1 Loss: 1.031042 Tokens per Sec: 434.557008
Epoch Step: 1 Loss: 0.437069 Tokens per Sec: 643.630322
0.4323212027549744
Epoch Step: 1 Loss: 0.617165 Tokens per Sec: 436.652626
Epoch Step: 1 Loss: 0.258793 Tokens per Sec: 644.372296
0.27331129014492034

為簡單起見，此程式碼使用貪心解碼來預測翻譯。

1. def greedy_decode(model, src, src_mask, max_len, start_symbol):

2.    memory = model.encode(src, src_mask)

3.    ys = torch.ones(1, 1).fill_(start_symbol).type_as(src.data)

4.    for i in range(max_len-1):

5.        out = model.decode(memory, src_mask,

6.                           Variable(ys),

7.                           Variable(subsequent_mask(ys.size(1))

8.                                    .type_as(src.data)))

9.        prob = model.generator(out[:, -1])

10.        _, next_word = torch.max(prob, dim = 1)

11.        next_word = next_word.data[0]

12.        ys = torch.cat([ys,

13.                        torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=1)

14.    return ys

16. model.eval()

17. src = Variable(torch.LongTensor([[1,2,3,4,5,6,7,8,9,10]]) )

18. src_mask = Variable(torch.ones(1, 1, 10) )

print(greedy_decode(model, src, src_mask, max_len=10, start_symbol=1))
   1     2     3     4     5     6     7     8     9    10
[torch.LongTensor of size 1x10]

真實示例

現在我們通過IWSLT德語-英語翻譯任務介紹一個真實示例。 該任務比上文提及的WMT任務小得多，但它說明了整個系統。 我們還展示瞭如何使用多個GPU處理加速其訓練。

#!pip install torchtext spacy
#!python -m spacy download en
#!python -m spacy download de

資料載入

我們將使用torchtext和spacy載入資料集以進行詞語切分。

# For data loading.
from torchtext import data, datasets
if True:
    import spacy
    spacy_de = spacy.load('de')
    spacy_en = spacy.load('en')
    def tokenize_de(text):
        return [tok.text for tok in spacy_de.tokenizer(text)]
    def tokenize_en(text):
        return [tok.text for tok in spacy_en.tokenizer(text)]
    BOS_WORD = '<s>'
    EOS_WORD = '</s>'
    BLANK_WORD = "<blank>"
    SRC = data.Field(tokenize=tokenize_de, pad_token=BLANK_WORD)
    TGT = data.Field(tokenize=tokenize_en, init_token = BOS_WORD, 
                     eos_token = EOS_WORD, pad_token=BLANK_WORD)
    MAX_LEN = 100
    train, val, test = datasets.IWSLT.splits(
        exts=('.de', '.en'), fields=(SRC, TGT), 
        filter_pred=lambda x: len(vars(x)['src']) <= MAX_LEN and 
            len(vars(x)['trg']) <= MAX_LEN)
    MIN_FREQ = 2
    SRC.build_vocab(train.src, min_freq=MIN_FREQ)
    TGT.build_vocab(train.trg, min_freq=MIN_FREQ)

批訓練對於速度來說很重要。我們希望批次分割非常均勻並且填充最少。 要做到這一點，我們必須修改torchtext預設的批處理函式。 這部分程式碼修補其預設批處理函式，以確保我們搜尋足夠多的句子以構建緊密批處理。

迭代器

1. class MyIterator(data.Iterator):

2.    def create_batches(self):

3.        if self.train:

4.            def pool(d, random_shuffler):

5.                for p in data.batch(d, self.batch_size * 100):

6.                    p_batch = data.batch(

7.                        sorted(p, key=self.sort_key),

8.                        self.batch_size, self.batch_size_fn)

9.                    for b in random_shuffler(list(p_batch)):

10.                        yield b

11.            self.batches = pool(self.data(), self.random_shuffler)

13.        else:

14.            self.batches = []

15.            for b in data.batch(self.data(), self.batch_size,

16.                                          self.batch_size_fn):

17.                self.batches.append(sorted(b, key=self.sort_key))

19. def rebatch(pad_idx, batch):

20.    "Fix order in torchtext to match ours"

21.    src, trg = batch.src.transpose(0, 1), batch.trg.transpose(0, 1)

22.    return Batch(src, trg, pad_idx)

多GPU訓練

最後為了真正地快速訓練，我們將使用多個GPU。 這部分程式碼實現了多GPU字生成。 它不是Transformer特有的，所以我不會詳細介紹。 其思想是將訓練時的單詞生成分成塊，以便在許多不同的GPU上並行處理。 我們使用PyTorch並行原語來做到這一點：

• 複製 - 將模組拆分到不同的GPU上

• 分散 - 將批次拆分到不同的GPU上

• 並行應用 - 在不同GPU上將模組應用於批處理

• 聚集 - 將分散的資料聚集到一個GPU上

• nn.DataParallel - 一個特殊的模組包裝器，在評估之前呼叫它們。

# Skip if not interested in multigpu.
class MultiGPULossCompute:
    "A multi-gpu loss compute and train function."
    def __init__(self, generator, criterion, devices, opt=None, chunk_size=5):
        # Send out to different gpus.
        self.generator = generator
        self.criterion = nn.parallel.replicate(criterion, 
                                               devices=devices)
        self.opt = opt
        self.devices = devices
        self.chunk_size = chunk_size
    def __call__(self, out, targets, normalize):
        total = 0.0
        generator = nn.parallel.replicate(self.generator, 
                                                devices=self.devices)
        out_scatter = nn.parallel.scatter(out, 
                                          target_gpus=self.devices)
        out_grad = [[] for _ in out_scatter]
        targets = nn.parallel.scatter(targets, 
                                      target_gpus=self.devices)
        # Divide generating into chunks.
        chunk_size = self.chunk_size
        for i in range(0, out_scatter[0].size(1), chunk_size):
            # Predict distributions
            out_column = [[Variable(o[:, i:i+chunk_size].data, 
                                    requires_grad=self.opt is not None)] 
                           for o in out_scatter]
            gen = nn.parallel.parallel_apply(generator, out_column)
            # Compute loss. 
            y = [(g.contiguous().view(-1, g.size(-1)), 
                  t[:, i:i+chunk_size].contiguous().view(-1)) 
                 for g, t in zip(gen, targets)]
            loss = nn.parallel.parallel_apply(self.criterion, y)
            # Sum and normalize loss
            l = nn.parallel.gather(loss, 
                                   target_device=self.devices[0])
            l = l.sum()[0] / normalize
            total += l.data[0]
            # Backprop loss to output of transformer
            if self.opt is not None:
                l.backward()
                for j, l in enumerate(loss):
                    out_grad[j].append(out_column[j][0].grad.data.clone())
        # Backprop all loss through transformer.            
        if self.opt is not None:
            out_grad = [Variable(torch.cat(og, dim=1)) for og in out_grad]
            o1 = out
            o2 = nn.parallel.gather(out_grad, 
                                    target_device=self.devices[0])
            o1.backward(gradient=o2)
            self.opt.step()
            self.opt.optimizer.zero_grad()
        return total * normalize

現在我們建立模型，損失函式，優化器，資料迭代器和並行化。

# GPUs to use
devices = [0, 1, 2, 3]
if True:
   pad_idx = TGT.vocab.stoi["<blank>"]
   model = make_model(len(SRC.vocab), len(TGT.vocab), N=6)
   model.cuda()
   criterion = LabelSmoothing(size=len(TGT.vocab), padding_idx=pad_idx, smoothing=0.1)
   criterion.cuda()
   BATCH_SIZE = 12000
   train_iter = MyIterator(train, batch_size=BATCH_SIZE, device=0,
                           repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)),
                           batch_size_fn=batch_size_fn, train=True)
   valid_iter = MyIterator(val, batch_size=BATCH_SIZE, device=0,
                           repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)),
                           batch_size_fn=batch_size_fn, train=False)
   model_par = nn.DataParallel(model, device_ids=devices)
None

現在我們訓練模型。 我將稍微使用預熱步驟，但其他一切都使用預設引數。 在具有4個Tesla V100 GPU的AWS p3.8xlarge機器上，每秒執行約27,000個詞，批訓練大小大小為12,000。

訓練系統

#!wget https://s3.amazonaws.com/opennmt-models/iwslt.pt

if False:
   model_opt = NoamOpt(model.src_embed[0].d_model, 1, 2000,
           torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))
   for epoch in range(10):
       model_par.train()
       run_epoch((rebatch(pad_idx, b) for b in train_iter),
                 model_par,
                 MultiGPULossCompute(model.generator, criterion,
                                     devices=devices, opt=model_opt))
       model_par.eval()
       loss = run_epoch((rebatch(pad_idx, b) for b in valid_iter),
                         model_par,
                         MultiGPULossCompute(model.generator, criterion,
                         devices=devices, opt=None))
       print(loss)
else:
   model = torch.load("iwslt.pt")

一旦訓練完成，我們可以解碼模型以產生一組翻譯。 在這裡，我們只需翻譯驗證集中的第一個句子。 此資料集非常小，因此使用貪婪搜尋的翻譯相當準確。

for i, batch in enumerate(valid_iter):
   src = batch.src.transpose(0, 1)[:1]
   src_mask = (src != SRC.vocab.stoi["<blank>"]).unsqueeze(-2)
   out = greedy_decode(model, src, src_mask,
                       max_len=60, start_symbol=TGT.vocab.stoi["<s>"])
   print("Translation:", end="\t")
   for i in range(1, out.size(1)):
       sym = TGT.vocab.itos[out[0, i]]
       if sym == "</s>": break
       print(sym, end =" ")
   print()
   print("Target:", end="\t")
   for i in range(1, batch.trg.size(0)):
       sym = TGT.vocab.itos[batch.trg.data[i, 0]]
       if sym == "</s>": break
       print(sym, end =" ")
   print()
   break

Translation:    <unk> <unk> . In my language , that means , thank you very much .
Gold:    <unk> <unk> . It means in my language , thank you very much .

附加元件：BPE，搜尋，平均

所以這主要涵蓋了Transformer模型本身。 有四個方面我們沒有明確涵蓋。 我們還實現了所有這些附加功能 OpenNMT-py[3].

1) 位元組對編碼/ 字片(Word-piece)：我們可以使用庫來首先將資料預處理為子字單元。參見Rico Sennrich的subword-nmt實現[4]。這些模型將訓練資料轉換為如下所示：

▁Die ▁Protokoll datei ▁kann ▁ heimlich ▁per ▁E - Mail ▁oder ▁FTP ▁an ▁einen ▁bestimmte n ▁Empfänger ▁gesendet ▁werden .

2) 共享嵌入：當使用具有共享詞彙表的BPE時，我們可以在源/目標/生成器之間共享相同的權重向量，詳細見[5]。 要將其新增到模型，只需執行以下操作：

if False:
   model.src_embed[0].lut.weight = model.tgt_embeddings[0].lut.weight
   model.generator.lut.weight = model.tgt_embed[0].lut.weight

3) 集束搜尋：這裡展開說有點太複雜了。 PyTorch版本的實現可以參考 OpenNMT- py[6]。
4) 模型平均：這篇文章平均最後k個檢查點以建立一個集合效果。 如果我們有一堆模型，我們可以在事後這樣做：

def average(model, models):
   "Average models into model"
   for ps in zip(*[m.params() for m in [model] + models]):
       p[0].copy_(torch.sum(*ps[1:]) / len(ps[1:]))

結果

在WMT 2014英語-德語翻譯任務中，大型Transformer模型（表2中的Transformer（大））優於先前報告的最佳模型（包括整合的模型）超過2.0 BLEU，建立了一個新的最先進BLEU得分為28.4。 該模型的配置列於表3的底部。在8個P100 GPU的機器上，訓練需要需要3.5天。 甚至我們的基礎模型也超過了之前釋出的所有模型和整合，而且只佔培訓成本的一小部分。

在WMT 2014英語-法語翻譯任務中，我們的大型模型獲得了41.0的BLEU分數，優於以前釋出的所有單一模型，不到以前最先進技術培訓成本的1/4 模型。 使用英語到法語訓練的Transformer（大）模型使用dropout概率 = 0.1，而不是0.3。

Image(filename="images/results.png")

我們在這裡編寫的程式碼是基本模型的一個版本。 這裡有系統完整訓練的版本 (Example Models[7]).

通過上一節中的附加擴充套件，OpenNMT-py複製在EN-DE WMT上達到26.9。 在這裡，我已將這些引數載入到我們的重新實現中。

!wget https://s3.amazonaws.com/opennmt-models/en-de-model.pt

model, SRC, TGT = torch.load("en-de-model.pt")

model.eval()
sent = "▁The ▁log ▁file ▁can ▁be ▁sent ▁secret ly ▁with ▁email ▁or ▁FTP ▁to ▁a ▁specified ▁receiver".split()
src = torch.LongTensor([[SRC.stoi[w] for w in sent]])
src = Variable(src)
src_mask = (src != SRC.stoi["<blank>"]).unsqueeze(-2)
out = greedy_decode(model, src, src_mask,
                   max_len=60, start_symbol=TGT.stoi["<s>"])
print("Translation:", end="\t")
trans = "<s> "
for i in range(1, out.size(1)):
   sym = TGT.itos[out[0, i]]
   if sym == "</s>": break
   trans += sym + " "
print(trans)

Translation:    <s> ▁Die ▁Protokoll datei ▁kann ▁ heimlich ▁per ▁E - Mail ▁oder ▁FTP ▁an ▁einen ▁bestimmte n ▁Empfänger ▁gesendet ▁werden .

注意力視覺化

即使使用貪婪的解碼器，翻譯看起來也不錯。 我們可以進一步想象它，看看每一層注意力發生了什麼。

tgt_sent = trans.split()
def draw(data, x, y, ax):
    seaborn.heatmap(data, 
                    xticklabels=x, square=True, yticklabels=y, vmin=0.0, vmax=1.0, 
                    cbar=False, ax=ax)
for layer in range(1, 6, 2):
    fig, axs = plt.subplots(1,4, figsize=(20, 10))
    print("Encoder Layer", layer+1)
    for h in range(4):
        draw(model.encoder.layers[layer].self_attn.attn[0, h].data, 
            sent, sent if h ==0 else [], ax=axs[h])
    plt.show()
for layer in range(1, 6, 2):
    fig, axs = plt.subplots(1,4, figsize=(20, 10))
    print("Decoder Self Layer", layer+1)
    for h in range(4):
        draw(model.decoder.layers[layer].self_attn.attn[0, h].data[:len(tgt_sent), :len(tgt_sent)], 
            tgt_sent, tgt_sent if h ==0 else [], ax=axs[h])
    plt.show()
    print("Decoder Src Layer", layer+1)
    fig, axs = plt.subplots(1,4, figsize=(20, 10))
    for h in range(4):
        draw(model.decoder.layers[layer].self_attn.attn[0, h].data[:len(tgt_sent), :len(sent)], 
            sent, tgt_sent if h ==0 else [], ax=axs[h])
    plt.show()

Encoder Layer 2

Encoder Layer 4

Encoder Layer 6

Decoder Self Layer 2

Decoder Src Layer 2

Decoder Self Layer 4

Decoder Src Layer 4

Decoder Self Layer 6

Decoder Src Layer 6

結論

希望這段程式碼對未來的研究很有用。 如果您有任何問題，請與我們聯絡。 如果您發現此程式碼有用，請檢視我們的其他OpenNMT工具。

@inproceedings{opennmt,
 author    = {Guillaume Klein and
              Yoon Kim and
              Yuntian Deng and
              Jean Senellart and
              Alexander M. Rush},
 title     = {OpenNMT: Open-Source Toolkit for Neural Machine Translation},
 booktitle = {Proc. ACL},
 year      = {2017},
 url       = {https://doi.org/10.18653/v1/P17-4012},
 doi       = {10.18653/v1/P17-4012}
}

Cheers，srush

參考連結

[1] https://arxiv.org/abs/1412.6980

[2] https://arxiv.org/abs/1512.00567

[3] https://github.com/opennmt/opennmt-py

[4] https://github.com/rsennrich/subword-nmt

[5] https://arxiv.org/abs/1608.05859

[6] https://github.com/OpenNMT/OpenNMT-py/blob/master/onmt/translate/Beam.py

[7] http://opennmt.net/Models-py/