【精讀】Transformer模型深度解讀

本文作者： AI研習(xí)社-譯站

2020-09-25 11:40

導(dǎo)語(yǔ)：希望這段代碼對(duì)以后的研究有用。

字幕組雙語(yǔ)原文：【精讀】Transformer模型深度解讀

英語(yǔ)原文：The Annotated Transformer

翻譯：雷鋒字幕組（Icarus、）

from IPython.display import
Image Image(filename='images/aiayn.png')

【精讀】Transformer模型深度解讀

在過(guò)去的一年里，《注意力就是你所需要的》中的Transformer被很多人所關(guān)注。除了在翻譯質(zhì)量上產(chǎn)生重大改進(jìn)外，它還為許多其他NLP任務(wù)提供了一個(gè)新的架構(gòu)。這篇論文本身寫(xiě)得非常清楚，但傳統(tǒng)的觀點(diǎn)是，它的正確實(shí)現(xiàn)相當(dāng)困難。

在這篇文章中，我以逐行實(shí)現(xiàn)的形式呈現(xiàn)了論文的 "注釋 "版本。我對(duì)原論文中的一些章節(jié)進(jìn)行了重新排序和刪除，并在全文中添加了注釋。這個(gè)文檔本身就是一個(gè)工作筆記，應(yīng)該是一個(gè)完全可用的實(shí)現(xiàn)。總共有400行庫(kù)代碼，可以在4個(gè)GPU上每秒處理27000個(gè)token。

要想跟上，你首先需要安裝PyTorch。完整的筆記本也可以在github或Google Colab上使用免費(fèi)的GPU。

請(qǐng)注意，這僅僅是研究人員和感興趣的開(kāi)發(fā)人員的一個(gè)起點(diǎn)。這里的代碼主要基于我們的OpenNMT包。(如果有幫助，請(qǐng)自由引用。)對(duì)于其他模型的全服務(wù)實(shí)現(xiàn)，請(qǐng)查看Tensor2Tensor (tensorflow)和Sockeye (mxnet)。

Alexander Rush (@harvardnlp 或 srush@seas.harvard.edu)，得到Vincent Nguyen和Guillaume Klein的幫助。

預(yù)先設(shè)置

# !pip install http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl numpy matplotlib spacy torchtext seaborn

import numpy as np import torch import torch.nn as nn import torch.nn.functional as F import math, copy, time from torch.autograd import Variable import matplotlib.pyplot as plt import seaborn
seaborn.set_context(context="talk")
%matplotlib inline

背景資料

減少順序計(jì)算的目標(biāo)也構(gòu)成了擴(kuò)展神經(jīng)GPU、ByteNet和ConvS2S的基礎(chǔ)，它們都使用卷積神經(jīng)網(wǎng)絡(luò)作為基本構(gòu)件，對(duì)所有輸入和輸出位置并行計(jì)算隱藏表示。在這些模型中，將兩個(gè)任意輸入或輸出位置的信號(hào)關(guān)聯(lián)起來(lái)所需的運(yùn)算次數(shù)隨著位置之間的距離而增長(zhǎng)，對(duì)于ConvS2S來(lái)說(shuō)是線性的，對(duì)于ByteNet來(lái)說(shuō)是對(duì)數(shù)的。這使得學(xué)習(xí)遠(yuǎn)距離位置之間的依賴(lài)關(guān)系變得更加困難。在Transformer中，這種情況被減少到了一個(gè)恒定的操作次數(shù)，盡管代價(jià)是由于注意力加權(quán)位置的平均化而導(dǎo)致有效分辨率的降低，我們用多頭注意力來(lái)抵消這種影響。

自注意，有時(shí)也被稱(chēng)為內(nèi)注意，是一種將單個(gè)序列的不同位置聯(lián)系起來(lái)以計(jì)算序列的表示的注意機(jī)制。自我注意已被成功地應(yīng)用于各種任務(wù)中，包括閱讀理解、抽象概括、文本內(nèi)涵和學(xué)習(xí)任務(wù)無(wú)關(guān)的句子表征。端到端記憶網(wǎng)絡(luò)是基于循環(huán)注意機(jī)制而不是序列對(duì)齊的循環(huán)，并且已經(jīng)被證明在簡(jiǎn)單語(yǔ)言問(wèn)題回答和語(yǔ)言建模任務(wù)上表現(xiàn)良好。

然而，據(jù)我們所知，Transformer是第一個(gè)完全依靠自我注意力來(lái)計(jì)算其輸入和輸出的表征，而不使用序列對(duì)齊的RNNs或卷積的轉(zhuǎn)換模型。

模型結(jié)構(gòu)

大多數(shù)競(jìng)爭(zhēng)性神經(jīng)序列轉(zhuǎn)導(dǎo)模型都有一個(gè)編碼器-解碼器結(jié)構(gòu)(cite)。在這里，編碼器將輸入的符號(hào)表示序列(x1，...,xn)映射為連續(xù)表示序列z=(z1，...,zn)。在給定z的情況下，解碼器每次生成一個(gè)符號(hào)的輸出序列(y1,...,ym)。在每一步中，該模型都是自動(dòng)遞減的(cite)，在生成下一個(gè)符號(hào)時(shí)，消耗之前生成的符號(hào)作為額外的輸入。

def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):
super(EncoderDecoder, self).__init__()
self.encoder = encoder
self.decoder = decoder
self.src_embed = src_embed
self.tgt_embed = tgt_embed
self.generator = generator
def forward(self, src, tgt, src_mask, tgt_mask):
"Take in and process masked src and target sequences."
return self.decode(self.encode(src, src_mask), src_mask,
tgt, tgt_mask)
def encode(self, src, src_mask):
return self.encoder(self.src_embed(src), src_mask)

def decode(self, memory, src_mask, tgt, tgt_mask):
return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)

class Generator(nn.Module):
"Define standard linear + softmax generation step."
def __init__(self, d_model, vocab):
super(Generator, self).__init__()
self.proj = nn.Linear(d_model, vocab)
def forward(self, x):
return F.log_softmax(self.proj(x), dim=-1)

Transformer沿用了這種整體架構(gòu)，編碼器和解碼器都采用堆疊式自關(guān)注和點(diǎn)對(duì)點(diǎn)的全連接層，分別如圖1的左半部分和右半部分所示。

Image(filename='images/ModalNet-21.png')

【精讀】Transformer模型深度解讀

編碼器和解碼器堆棧

編碼器

編碼器是由N=6個(gè)相同的層組成的堆棧。

def clones(module, N):
"Produce N identical layers."
return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])
class Encoder(nn.Module):
"Core encoder is a stack of N layers"
def __init__(self, layer, N):
super(Encoder, self).__init__()
self.layers = clones(layer, N)
self.norm = LayerNorm(layer.size)
def forward(self, x, mask):
"Pass the input (and mask) through each layer in turn."
for layer in self.layers:
x = layer(x, mask)
return self.norm(x)

我們?cè)趦蓚€(gè)子層周?chē)謩e采用殘差連接(cite)，然后進(jìn)行層歸一化(cite)。

class LayerNorm(nn.Module):
"Construct a layernorm module (See citation for details)."
def __init__(self, features, eps=1e-6):
super(LayerNorm, self).__init__()
self.a_2 = nn.Parameter(torch.ones(features))
self.b_2 = nn.Parameter(torch.zeros(features))
self.eps = eps
def forward(self, x):
mean = x.mean(-1, keepdim=True)
std = x.std(-1, keepdim=True)
return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

也就是說(shuō)，每個(gè)子層的輸出是LayerNorm(x+Sublayer(x))，其中Sublayer(x)是子層自己實(shí)現(xiàn)的函數(shù)。我們?cè)诿總€(gè)子層的輸出中應(yīng)用dropout(引用)，然后再加到子層的輸入中并進(jìn)行歸一化。

為了方便這些殘差連接，模型中的所有子層以及嵌入層都會(huì)產(chǎn)生維度為dmodel=512dmodel=512的輸出。

class SublayerConnection(nn.Module):
"""
A residual connection followed by a layer norm.
Note for code simplicity the norm is first as opposed to last.
"""
def __init__(self, size, dropout):
super(SublayerConnection, self).__init__()
self.norm = LayerNorm(size)
self.dropout = nn.Dropout(dropout)
def forward(self, x, sublayer):
"Apply residual connection to any sublayer with the same size."
return x + self.dropout(sublayer(self.norm(x)))

每層有兩個(gè)子層。第一層是一個(gè)多頭自注意機(jī)制，第二層是一個(gè)簡(jiǎn)單的、基于位置的全連接前饋網(wǎng)絡(luò)。

class EncoderLayer(nn.Module):
"Encoder is made up of self-attn and feed forward (defined below)"
def __init__(self, size, self_attn, feed_forward, dropout):
super(EncoderLayer, self).__init__()
self.self_attn = self_attn
self.feed_forward = feed_forward
self.sublayer = clones(SublayerConnection(size, dropout), 2)
self.size = size
def forward(self, x, mask):
"Follow Figure 1 (left) for connections."
x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
return self.sublayer[1](x, self.feed_forward)

解碼器

解碼器也是由N=6層相同的堆棧組成。

class Decoder(nn.Module):
"Generic N layer decoder with masking."
def __init__(self, layer, N):
super(Decoder, self).__init__()
self.layers = clones(layer, N)
self.norm = LayerNorm(layer.size)
def forward(self, x, memory, src_mask, tgt_mask):
for layer in self.layers:
x = layer(x, memory, src_mask, tgt_mask)
return self.norm(x)

除了每個(gè)編碼器層中的兩個(gè)子層外，解碼器還插入了第三個(gè)子層，它在編碼器堆棧的輸出上執(zhí)行多頭關(guān)注。與編碼器類(lèi)似，我們?cè)诿總€(gè)子層周?chē)捎脷堄噙B接，然后進(jìn)行層歸一化。

class DecoderLayer(nn.Module):
"Decoder is made of self-attn, src-attn, and feed forward (defined below)"
def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
super(DecoderLayer, self).__init__()
self.size = size
self.self_attn = self_attn
self.src_attn = src_attn
self.feed_forward = feed_forward
self.sublayer = clones(SublayerConnection(size, dropout), 3)
def forward(self, x, memory, src_mask, tgt_mask):
"Follow Figure 1 (right) for connections."
m = memory
x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))
x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))
return self.sublayer[2](x, self.feed_forward)

我們還修改了解碼器堆棧中的自注意力子層，以防止位置對(duì)后續(xù)位置的關(guān)注。這種遮蔽，加上輸出嵌入偏移這一個(gè)位置的事實(shí)，確保位置ii的預(yù)測(cè)只能依賴(lài)于小于i的這個(gè)位置的已知輸出。

def subsequent_mask(size):
"Mask out subsequent positions."
attn_shape = (1, size, size)
subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')
return torch.from_numpy(subsequent_mask) == 0

筆者注：注意力掩碼下方顯示了每個(gè)tgt詞（行）被允許看的位置（列）。在訓(xùn)練過(guò)程中，單詞會(huì)被屏蔽，以便關(guān)注之后的單詞。

plt.figure(figsize=(5,5))
plt.imshow(subsequent_mask(20)[0])
None

【精讀】Transformer模型深度解讀

注意事項(xiàng)

注意函數(shù)可以描述為將一個(gè)查詢(xún)和一組鍵值對(duì)映射到一個(gè)輸出，其中查詢(xún)、鍵、值和輸出都是向量。輸出是以值的加權(quán)和來(lái)計(jì)算的，其中分配給每個(gè)值的權(quán)重是由查詢(xún)與對(duì)應(yīng)鍵的兼容性函數(shù)計(jì)算出來(lái)的。我們把我們的特殊注意力稱(chēng)為 "Scaled Dot-Product注意力"。輸入由維度為dk的查詢(xún)和鍵，以及維度為dv的值組成。我們計(jì)算查詢(xún)與所有鍵的點(diǎn)積，每一個(gè)點(diǎn)積除以√dk，然后應(yīng)用一個(gè)softmax函數(shù)來(lái)獲得值的權(quán)重。

Image(filename='images/ModalNet-19.png')

【精讀】Transformer模型深度解讀

在實(shí)際應(yīng)用中，我們對(duì)一組查詢(xún)同時(shí)計(jì)算關(guān)注函數(shù)，打包成一個(gè)矩陣QQ。鍵和值也一起打包成矩陣KK和VV。我們計(jì)算輸出的矩陣為：

【精讀】Transformer模型深度解讀

def attention(query, key, value, mask=None, dropout=None):
"Compute 'Scaled Dot Product Attention'"
d_k = query.size(-1)
scores = torch.matmul(query, key.transpose(-2, -1)) \
/ math.sqrt(d_k)
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
p_attn = F.softmax(scores, dim = -1)
if dropout is not None:
p_attn = dropout(p_attn)
return torch.matmul(p_attn, value), p_attn

最常用的兩個(gè)注意力函數(shù)是加法注意力（cite），和點(diǎn)積（乘法）注意力。點(diǎn)積注意力除了縮放因子為1/√dk外，與我們的算法相同。加法注意力使用單層隱藏層的前饋網(wǎng)絡(luò)計(jì)算兼容性函數(shù)。雖然兩者在理論復(fù)雜度上相似，但點(diǎn)積注意力在實(shí)踐中更快，更節(jié)省空間，因?yàn)樗梢允褂酶叨葍?yōu)化的矩陣乘法代碼來(lái)實(shí)現(xiàn)。

雖然對(duì)于dk的小值，兩種機(jī)制的表現(xiàn)相似，但對(duì)于dk的大值，加法注意力的表現(xiàn)優(yōu)于點(diǎn)積注意力，而沒(méi)有縮放（引用）。我們懷疑，對(duì)于dk的大值，點(diǎn)積的幅度會(huì)變大，將softmax函數(shù)推到它的梯度極小的區(qū)域（為了說(shuō)明點(diǎn)積為什么會(huì)變大，假設(shè)qq和kk的分量是均值00、方差11的獨(dú)立隨機(jī)變量。那么它們的點(diǎn)積q?k=∑dki=1qiki，其均值為00，方差為dk）。

為了抵消這種影響，我們將點(diǎn)乘積的比例為1/√dk。

Image(filename='images/ModalNet-20.png')

【精讀】Transformer模型深度解讀

多頭注意使模型能夠共同注意來(lái)自不同位置的不同表征子空間的信息。在單注意頭的情況下，平均化會(huì)抑制這一點(diǎn)。

【精讀】Transformer模型深度解讀

其中，投影為參數(shù)矩陣

【精讀】Transformer模型深度解讀

和

【精讀】Transformer模型深度解讀

在這項(xiàng)工作中，我們采用了h=8h=8個(gè)平行的注意層，或者說(shuō)頭。對(duì)于其中的每一個(gè)層，我們使用：

【精讀】Transformer模型深度解讀

由于每個(gè)頭的維度減少，總的計(jì)算成本與全維度的單頭注意力相似。

class MultiHeadedAttention(nn.Module):
def __init__(self, h, d_model, dropout=0.1):
"Take in model size and number of heads."
super(MultiHeadedAttention, self).__init__()
assert d_model % h == 0
# We assume d_v always equals d_k
self.d_k = d_model // h
self.h = h
self.linears = clones(nn.Linear(d_model, d_model), 4)
self.attn = None
self.dropout = nn.Dropout(p=dropout)
def forward(self, query, key, value, mask=None):
"Implements Figure 2"
if mask is not None:
# Same mask applied to all h heads.
mask = mask.unsqueeze(1)
nbatches = query.size(0)
# 1) Do all the linear projections in batch from d_model => h x d_k
query, key, value = \
[l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
for l, x in zip(self.linears, (query, key, value))]
# 2) Apply attention on all the projected vectors in batch.
x, self.attn = attention(query, key, value, mask=mask,
dropout=self.dropout)
# 3) "Concat" using a view and apply a final linear.
x = x.transpose(1, 2).contiguous() \
.view(nbatches, -1, self.h * self.d_k)
return self.linears[-1](x)

注意力在我們的模型中的應(yīng)用

Transformer以三種不同的方式使用多頭注意：

1. 在 "編碼器-解碼器關(guān)注 "層中，查詢(xún)來(lái)自前一個(gè)解碼器層，而內(nèi)存鍵和值來(lái)自編碼器的輸出。這使得解碼器中的每個(gè)位置都能在輸入序列的所有位置上進(jìn)行關(guān)注。這模仿了序列到序列模型中典型的編碼器-解碼器的注意機(jī)制，如（引用）。

2. 編碼器包含自注意層。在自注意層中，所有的鍵、值和查詢(xún)都來(lái)自同一個(gè)地方，在這種情況下，就是編碼器中上一層的輸出。編碼器中的每個(gè)位置都可以參加編碼器前一層的所有位置。

3. 同樣，解碼器中的自注意層允許解碼器中的每個(gè)位置都可以參加解碼器中的所有位置，直到并包括該位置。我們需要防止解碼器中的左向信息流，以保持自動(dòng)遞減特性。我們通過(guò)屏蔽（設(shè)置為-∞）softmax的輸入中所有對(duì)應(yīng)非法連接的值，在scaled dot- product attention里面實(shí)現(xiàn)。

位置導(dǎo)向的前饋網(wǎng)絡(luò)

除了注意力子層，我們的編碼器和解碼器中的每個(gè)層都包含一個(gè)完全連接的前饋網(wǎng)絡(luò)，該網(wǎng)絡(luò)分別和相同地應(yīng)用于每個(gè)位置。這包括兩個(gè)線性變換，中間有一個(gè)ReLU激活。

【精讀】Transformer模型深度解讀

雖然不同位置的線性變換是相同的，但它們?cè)趯优c層之間使用不同的參數(shù)。另一種描述方式是內(nèi)核大小為1的兩個(gè)卷積。輸入和輸出的維度為dmodel=512，內(nèi)層的維度為dff=2048。

class PositionwiseFeedForward(nn.Module):
"Implements FFN equation."
def __init__(self, d_model, d_ff, dropout=0.1):
super(PositionwiseFeedForward, self).__init__()
self.w_1 = nn.Linear(d_model, d_ff)
self.w_2 = nn.Linear(d_ff, d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, x):
return self.w_2(self.dropout(F.relu(self.w_1(x))))

嵌入和Softmax

與其他序列轉(zhuǎn)導(dǎo)模型類(lèi)似，我們使用學(xué)習(xí)的嵌入將輸入令牌和輸出令牌轉(zhuǎn)換為維數(shù)dmodel的向量。我們還使用通常的學(xué)習(xí)線性變換和softmax函數(shù)將解碼器輸出轉(zhuǎn)換為預(yù)測(cè)的下一個(gè)標(biāo)記概率。在我們的模型中，我們?cè)趦蓚€(gè)嵌入層和預(yù)softmax線性變換之間共享相同的權(quán)重矩陣，類(lèi)似于（引用）。在嵌入層中，我們將這些權(quán)重乘以√dmodel。

class Embeddings(nn.Module):
def __init__(self, d_model, vocab):
super(Embeddings, self).__init__()
self.lut = nn.Embedding(vocab, d_model)
self.d_model = d_model
def forward(self, x):
return self.lut(x) * math.sqrt(self.d_model)

位置編碼

由于我們的模型不包含遞歸和卷積，為了使模型能夠利用序列的順序，我們必須注入一些關(guān)于序列中標(biāo)記的相對(duì)或絕對(duì)位置的信息。為此，我們?cè)诰幋a器和解碼器堆棧底部的輸入嵌入中加入 "位置編碼"。位置編碼與嵌入的維度dmodel相同，因此兩者可以相加。位置編碼有很多選擇，有學(xué)習(xí)的和固定的（引用）。

在本工作中，我們使用不同頻率的正弦和余弦函數(shù)。

【精讀】Transformer模型深度解讀

其中pos是位置，i是維度。即位置編碼的每個(gè)維度對(duì)應(yīng)一個(gè)正弦波。波長(zhǎng)形成從2π到10000?2π的幾何級(jí)數(shù)。我們選擇這個(gè)函數(shù)是因?yàn)槲覀兗僭O(shè)它可以讓模型很容易地學(xué)會(huì)通過(guò)相對(duì)位置來(lái)參加，因?yàn)閷?duì)于任何固定的偏移量k，PEpos+k可以表示為PEpos的線性函數(shù)。

此外，我們對(duì)編碼器和解碼器堆棧中的嵌入和位置編碼的總和應(yīng)用了 dropout。對(duì)于基礎(chǔ)模型，我們使用Pdrop=0.1的速率。

class PositionalEncoding(nn.Module):
"Implement the PE function."
def __init__(self, d_model, dropout, max_len=5000):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(p=dropout)
# Compute the positional encodings once in log space.
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2) *
-(math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(0)
self.register_buffer('pe', pe)
def forward(self, x):
x = x + Variable(self.pe[:, :x.size(1)],
requires_grad=False)
return self.dropout(x)

下面的位置編碼會(huì)根據(jù)位置加入一個(gè)正弦波。每個(gè)維度的波的頻率和偏移量是不同的。

plt.figure(figsize=(15, 5))
pe = PositionalEncoding(20, 0)
y = pe.forward(Variable(torch.zeros(1, 100, 20)))
plt.plot(np.arange(100), y[0, :, 4:8].data.numpy())
plt.legend(["dim %d"%p for p in [4,5,6,7]])
None

【精讀】Transformer模型深度解讀

我們還試驗(yàn)了使用學(xué)習(xí)的位置嵌入（cite）來(lái)代替，并發(fā)現(xiàn)這兩個(gè)版本產(chǎn)生的結(jié)果幾乎是相同的。我們選擇了正弦版本，因?yàn)樗赡茉试S模型外推到比訓(xùn)練過(guò)程中遇到的序列長(zhǎng)度更長(zhǎng)的序列。

完整模型

在這里，我們定義了一個(gè)函數(shù)，它可以接受超參數(shù)并產(chǎn)生一個(gè)完整的模型。

def make_model(src_vocab, tgt_vocab, N=6,
d_model=512, d_ff=2048, h=8, dropout=0.1):
"Helper: Construct a model from hyperparameters."
c = copy.deepcopy
attn = MultiHeadedAttention(h, d_model)
ff = PositionwiseFeedForward(d_model, d_ff, dropout)
position = PositionalEncoding(d_model, dropout)
model = EncoderDecoder(
Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),
Decoder(DecoderLayer(d_model, c(attn), c(attn),
c(ff), dropout), N),
nn.Sequential(Embeddings(d_model, src_vocab), c(position)),
nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)),
Generator(d_model, tgt_vocab))
# This was important from their code.
# Initialize parameters with Glorot / fan_avg.
for p in model.parameters():
if p.dim() > 1:
nn.init.xavier_uniform(p)
return model

# Small example model.
tmp_model = make_model(10, 10, 2)
None

訓(xùn)練

本節(jié)介紹了我們模型的訓(xùn)練制度。

筆者注：我們停下來(lái)做一個(gè)快速的插曲，介紹一些訓(xùn)練標(biāo)準(zhǔn)編碼器解碼器模型所需的工具。首先，我們定義了一個(gè)批處理對(duì)象，它保存了用于訓(xùn)練的src和目標(biāo)句子，以及構(gòu)建掩碼。

批量和屏蔽

class Batch:
"Object for holding a batch of data with mask during training."
def __init__(self, src, trg=None, pad=0):
self.src = src
self.src_mask = (src != pad).unsqueeze(-2)
if trg is not None:
self.trg = trg[:, :-1]
self.trg_y = trg[:, 1:]
self.trg_mask = \
self.make_std_mask(self.trg, pad)
self.ntokens = (self.trg_y != pad).data.sum()
@staticmethod
def make_std_mask(tgt, pad):
"Create a mask to hide padding and future words."
tgt_mask = (tgt != pad).unsqueeze(-2)
tgt_mask = tgt_mask & Variable(
subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data))
return tgt_mask

筆者注：接下來(lái)我們創(chuàng)建一個(gè)通用的訓(xùn)練和評(píng)分函數(shù)來(lái)跟蹤損失。我們傳遞了一個(gè)通用的損失計(jì)算函數(shù)，它也處理參數(shù)更新。

訓(xùn)練循環(huán)

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

訓(xùn)練數(shù)據(jù)和批處理

我們?cè)跇?biāo)準(zhǔn)的WMT 2014英德數(shù)據(jù)集上進(jìn)行了訓(xùn)練，該數(shù)據(jù)集由大約450萬(wàn)句子對(duì)組成。句子使用字節(jié)對(duì)編碼，其共享的源-目標(biāo)詞匯約為37000個(gè)tokens。對(duì)于英語(yǔ)-法語(yǔ)，我們使用了明顯更大的WMT 2014英法數(shù)據(jù)集，該數(shù)據(jù)集由36M句子組成，并將tokens拆分為32000個(gè)詞片詞匯。

句子對(duì)被按近似序列長(zhǎng)度分批在一起。每個(gè)訓(xùn)練批次都包含一組句子對(duì)，包含大約25000個(gè)源標(biāo)記和25000個(gè)目標(biāo)標(biāo)記。

筆者注：我們將使用火炬文本進(jìn)行批處理。這將在下面詳細(xì)討論。在這里，我們?cè)趖orchtext函數(shù)中創(chuàng)建批處理，以確保我們的批處理大小墊到最大batchsize不超過(guò)一個(gè)閾值（25000，如果我們有8個(gè)gpus）。

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)

硬件和時(shí)間表

我們?cè)谝慌_(tái)擁有8個(gè)NVIDIA P100 GPU的機(jī)器上訓(xùn)練我們的模型。對(duì)于我們的基礎(chǔ)模型，使用本文中描述的超參數(shù)，每個(gè)訓(xùn)練步驟大約需要0.4秒。我們總共訓(xùn)練了100,000步或12小時(shí)的基礎(chǔ)模型。對(duì)于我們的大模型，步長(zhǎng)為1.0秒。大模型的訓(xùn)練時(shí)間為30萬(wàn)步（3.5天）。

優(yōu)化器

我們使用了Adam優(yōu)化器（引用），β1=0.9，β2=0.98，?=10^-9。我們根據(jù)公式，在訓(xùn)練過(guò)程中改變學(xué)習(xí)率。

【精讀】Transformer模型深度解讀

這相當(dāng)于對(duì)第一個(gè)warmupstepswarmupsteps訓(xùn)練步數(shù)線性增加學(xué)習(xí)率，此后按步數(shù)的倒平方根按比例減少。我們使用warmupsteps=4000。

注意：這部分非常重要。需要用這個(gè)設(shè)置的模型進(jìn)行訓(xùn)練。

class NoamOpt:
"Optim wrapper that implements rate."
def __init__(self, model_size, factor, warmup, optimizer):
self.optimizer = optimizer
self._step = 0
self.warmup = warmup
self.factor = factor
self.model_size = model_size
self._rate = 0
def step(self):
"Update parameters and rate"
self._step += 1
rate = self.rate()
for p in self.optimizer.param_groups:
p['lr'] = rate
self._rate = rate
self.optimizer.step()
def rate(self, step = None):
"Implement `lrate` above"
if step is None:
step = self._step
return self.factor * \
(self.model_size ** (-0.5) *
min(step ** (-0.5), step * self.warmup ** (-1.5)))
def get_std_opt(model):
return NoamOpt(model.src_embed[0].d_model, 2, 4000,
torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))

該模型在不同模型大小和優(yōu)化超參數(shù)下的曲線示例。

# 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

【精讀】Transformer模型深度解讀

正規(guī)化

標(biāo)簽平滑化

在訓(xùn)練過(guò)程中，我們采用了價(jià)值?ls=0.1?ls=0.1的標(biāo)簽平滑（引用）。這傷害了迷惑性，因?yàn)槟Ｐ蛯W(xué)會(huì)了更多的不確定，但提高了準(zhǔn)確性和BLEU得分。

筆者注：我們使用KL div loss實(shí)現(xiàn)標(biāo)簽平滑。而不是使用一個(gè)一熱的目標(biāo)分布，我們創(chuàng)建了一個(gè)分布，有信心的正確的單詞和其余的平滑質(zhì)量分布在整個(gè)詞匯。

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

在這里，我們可以看到一個(gè)例子，說(shuō)明質(zhì)量是如何根據(jù)置信度分配給單詞的。

# Example of label smoothing.

crit = LabelSmoothing(5, 0, 0.4) predict = torch.FloatTensor([[0, 0.2, 0.7, 0.1, 0],[0, 0.2, 0.7, 0.1, 0],[0, 0.2, 0.7, 0.1, 0]]) v = crit(Variable(predict.log()),

Variable(torch.LongTensor([2, 1, 0]))) # Show the target distributions expected by the system.

plt.imshow(crit.true_dist) None

【精讀】Transformer模型深度解讀

標(biāo)簽平滑實(shí)際上是開(kāi)始懲罰模型，如果它對(duì)給定的選擇非常自信的話。

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

【精讀】Transformer模型深度解讀

一個(gè)例子

我們可以先嘗試一個(gè)簡(jiǎn)單的復(fù)制任務(wù)。從一個(gè)小詞匯中給定一組隨機(jī)的輸入符號(hào)，目標(biāo)是生成回這些相同的符號(hào)。

綜合數(shù)據(jù)

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)

損失計(jì)算

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

greedy解碼

# Train the simple copy task.
V = 11 criterion = LabelSmoothing(size=V, padding_idx=0, smoothing=0.0)
model = make_model(V, V, N=2)
model_opt = NoamOpt(model.src_embed[0].d_model, 1, 400,
torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))
for epoch in range(10):
model.train()
run_epoch(data_gen(V, 30, 20), model,
SimpleLossCompute(model.generator, criterion, model_opt))
model.eval()
print(run_epoch(data_gen(V, 30, 5), model,
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

這個(gè)代碼為了簡(jiǎn)單起見(jiàn)，使用貪婪的解碼來(lái)預(yù)測(cè)翻譯。

def greedy_decode(model, src, src_mask, max_len, start_symbol):
memory = model.encode(src, src_mask)
ys = torch.ones(1, 1).fill_(start_symbol).type_as(src.data)
for i in range(max_len-1):
out = model.decode(memory, src_mask,
Variable(ys),
Variable(subsequent_mask(ys.size(1))
.type_as(src.data)))
prob = model.generator(out[:, -1])
_, next_word = torch.max(prob, dim = 1)
next_word = next_word.data[0]
ys = torch.cat([ys,
torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=1)
return ys
model.eval() src = Variable(torch.LongTensor([[1,2,3,4,5,6,7,8,9,10]]) )
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]

一個(gè)真實(shí)的例子

筆者注：現(xiàn)在我們考慮使用IWSLT德英翻譯任務(wù)的一個(gè)真實(shí)世界的例子。這個(gè)任務(wù)比論文中考慮的WMT任務(wù)小得多，但它說(shuō)明了整個(gè)系統(tǒng)。我們還展示了如何使用多GPU處理來(lái)使其真正快速。

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

數(shù)據(jù)加載

筆者注：我們將使用 torchtext 和 spacy 加載數(shù)據(jù)集進(jìn)行標(biāo)記化。

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

批量對(duì)速度有很大的影響。我們希望有非常均勻的批次，絕對(duì)最小的填充。要做到這一點(diǎn)，我們必須對(duì)默認(rèn)的 torchtext 批量進(jìn)行一些改進(jìn)。這段代碼修補(bǔ)了他們的默認(rèn)批處理，以確保我們搜索到的句子足夠多，從而找到緊湊的批處理。

迭代器

class MyIterator(data.Iterator):
def create_batches(self):
if self.train:
def pool(d, random_shuffler):
for p in data.batch(d, self.batch_size * 100):
p_batch = data.batch(
sorted(p, key=self.sort_key),
self.batch_size, self.batch_size_fn)
for b in random_shuffler(list(p_batch)):
yield b
self.batches = pool(self.data(), self.random_shuffler)
else:
self.batches = []
for b in data.batch(self.data(), self.batch_size,
self.batch_size_fn):
self.batches.append(sorted(b, key=self.sort_key))
def rebatch(pad_idx, batch):
"Fix order in torchtext to match ours"
src, trg = batch.src.transpose(0, 1), batch.trg.transpose(0, 1)
return Batch(src, trg, pad_idx)

多CPU訓(xùn)練

筆者注：最后為了真正針對(duì)快速訓(xùn)練，我們將使用多gpu。這段代碼實(shí)現(xiàn)了多gpu詞的生成。它不是專(zhuān)門(mén)針對(duì)transformer的，所以我不會(huì)說(shuō)得太詳細(xì)。我們的想法是在訓(xùn)練時(shí)將單詞生成分割成塊，在許多不同的gpus上并行處理。我們使用 pytorch 并行基元來(lái)實(shí)現(xiàn)這一目的。

replicate - 將模塊分割到不同的gpus上。
scatter - 分割批次到不同的gpus上。
parallel_apply - 將模塊應(yīng)用到不同的gpus上的批次。
gather - 把分散的數(shù)據(jù)拉回到一個(gè)gpu上。
nn.DataParallel - 一個(gè)特殊的模塊包裝器，在評(píng)估前調(diào)用這些

# 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

現(xiàn)在我們創(chuàng)建我們的模型、準(zhǔn)則、優(yōu)化器、數(shù)據(jù)迭代器和paralelization。

# 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

現(xiàn)在我們訓(xùn)練模型。我會(huì)稍微玩一下熱身步驟，但其他一切都使用默認(rèn)參數(shù)。在一個(gè)有4個(gè)特斯拉V100的AWS p3.8xlarge上，這以每秒約27,000個(gè)代幣的速度運(yùn)行，批次大小為12,000個(gè)。

訓(xùn)練系統(tǒng)

#!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")

筆者注：一旦訓(xùn)練好了，我們就可以對(duì)模型進(jìn)行解碼，產(chǎn)生一組翻譯。這里我們只需翻譯驗(yàn)證集中的第一句話。這個(gè)數(shù)據(jù)集相當(dāng)小，所以通過(guò)貪婪搜索的翻譯是相當(dāng)準(zhǔn)確的。

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、搜索、平均

筆者注：所以這主要是涵蓋了變壓器模型本身。有四個(gè)方面我們沒(méi)有明確地覆蓋。我們還在OpenNMT-py中實(shí)現(xiàn)了所有這些附加功能。

1. BPE/字片。我們可以使用一個(gè)庫(kù)先把數(shù)據(jù)預(yù)處理成子字單元。參見(jiàn)Rico Sennrich的subword- nmt實(shí)現(xiàn)。這些模型會(huì)將訓(xùn)練數(shù)據(jù)轉(zhuǎn)化成這樣的樣子。

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

2. 共享嵌入。當(dāng)使用共享詞匯的BPE時(shí)，我們可以在源/目標(biāo)/生成器之間共享相同的權(quán)重向量。詳情請(qǐng)參見(jiàn)（引文）。要將此添加到模型中，只需這樣做。

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. 光束搜索:這有點(diǎn)太復(fù)雜了，這里就不多說(shuō)了。參見(jiàn)OpenNMT- py中的pytorch實(shí)現(xiàn)。

4. 模型平均化:本文對(duì)最后的k個(gè)檢查點(diǎn)進(jìn)行平均，以產(chǎn)生集合效應(yīng)。如果我們有一堆模型，我們可以事后再做。

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

結(jié)果

在WMT 2014英譯德任務(wù)上，大變壓器模型（Transformer（big）在表2中）比之前報(bào)道的最佳模型（包括合集）的表現(xiàn)要好2.0 BLEU以上，建立了新的最先進(jìn)的BLEU得分28.4。該模型的配置列在表3的底行。訓(xùn)練在8個(gè)P100 GPU上花了3.5天。即使我們的基礎(chǔ)模型也超越了所有之前發(fā)布的模型和合集，而訓(xùn)練成本只是任何競(jìng)爭(zhēng)模型的一小部分。

在WMT 2014英譯法任務(wù)上，我們的大模型實(shí)現(xiàn)了41.0的BLEU得分，超越了之前發(fā)布的所有單體模型，而訓(xùn)練成本不到之前最先進(jìn)模型的1/4。為英譯法訓(xùn)練的Transformer（大）模型使用的輟學(xué)率Pdrop=0.1，而不是0.3。

【精讀】Transformer模型深度解讀

我們?cè)谶@里寫(xiě)的代碼是基礎(chǔ)模型的一個(gè)版本。這里有這個(gè)系統(tǒng)的完全訓(xùn)練版本（示例模型）。

通過(guò)上一節(jié)中的附加擴(kuò)展，OpenNMT-py復(fù)制在EN-DE WMT上達(dá)到了26.9。在這里，我已經(jīng)把這些參數(shù)加載到我們的重新實(shí)施中。

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

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

注意力的可視化

即使是用greedy解碼，翻譯出來(lái)的效果也很不錯(cuò)。我們可以進(jìn)一步將其可視化，看看在注意力的每一層發(fā)生了什么。

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

【精讀】Transformer模型深度解讀

Encoder Layer 4

【精讀】Transformer模型深度解讀

Encoder Layer 6

【精讀】Transformer模型深度解讀

Encoder Self Layer 2

【精讀】Transformer模型深度解讀

Encoder Src Layer 4

【精讀】Transformer模型深度解讀

Encoder Self Layer 6

【精讀】Transformer模型深度解讀

Decoder Src Layer 6

【精讀】Transformer模型深度解讀

結(jié)論

筆者注：希望這段代碼對(duì)以后的研究有用。如果你有任何問(wèn)題，請(qǐng)聯(lián)系我們。如果你覺(jué)得這段代碼有幫助，也可以看看我們其他的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}
}

雷鋒字幕組是一個(gè)由AI愛(ài)好者組成的翻譯團(tuán)隊(duì)，匯聚五五多位志愿者的力量，分享最新的海外AI資訊，交流關(guān)于人工智能技術(shù)領(lǐng)域的行業(yè)轉(zhuǎn)變與技術(shù)創(chuàng)新的見(jiàn)解。

團(tuán)隊(duì)成員有大數(shù)據(jù)專(zhuān)家，算法工程師，圖像處理工程師，產(chǎn)品經(jīng)理，產(chǎn)品運(yùn)營(yíng)，IT咨詢(xún)?nèi)耍谛熒恢驹刚邆儊?lái)自IBM，AVL，Adobe，阿里，百度等知名企業(yè)，北大，清華，港大，中科院，南卡羅萊納大學(xué)，早稻田大學(xué)等海內(nèi)外高校研究所。

如果，你也是位熱愛(ài)分享的AI愛(ài)好者。歡迎與雷鋒字幕組一起，學(xué)習(xí)新知，分享成長(zhǎng)。

【精讀】Transformer模型深度解讀

雷峰網(wǎng)版權(quán)文章，未經(jīng)授權(quán)禁止轉(zhuǎn)載。詳情見(jiàn)轉(zhuǎn)載須知。

0人收藏

相關(guān)文章

AI研習(xí)社-譯站

知情人士

AI研習(xí)社(yanxishe.com)譯站頻道，傳播前沿人工智能知識(shí)，讓語(yǔ)言不再成為學(xué)習(xí)知識(shí)的門(mén)檻。（原雷鋒字幕組）

掃描關(guān)注作者微信

發(fā)私信

當(dāng)月熱門(mén)文章

【精讀】Transformer模型深度解讀

預(yù)先設(shè)置

目錄

Prelims

背景資料

模型結(jié)構(gòu)

訓(xùn)練

第一個(gè)例子

一個(gè)現(xiàn)實(shí)例子

結(jié)果

結(jié)論

背景資料

模型結(jié)構(gòu)

編碼器和解碼器堆棧

解碼器

注意力在我們的模型中的應(yīng)用

位置導(dǎo)向的前饋網(wǎng)絡(luò)

嵌入和Softmax

位置編碼

完整模型

訓(xùn)練

批量和屏蔽

訓(xùn)練循環(huán)

訓(xùn)練數(shù)據(jù)和批處理

硬件和時(shí)間表

優(yōu)化器

正規(guī)化

一個(gè)例子

綜合數(shù)據(jù)

損失計(jì)算

greedy解碼

一個(gè)真實(shí)的例子

數(shù)據(jù)加載

迭代器

多CPU訓(xùn)練

訓(xùn)練系統(tǒng)

附加組件：BPE、搜索、平均

結(jié)果

注意力的可視化

結(jié)論