【精讀】Transformer模型深度解讀

本文作者： AI研習社-譯站

2020-09-25 11:40

導語：希望這段代碼對以后的研究有用。

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

英語原文：The Annotated Transformer

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

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

【精讀】Transformer模型深度解讀

在過去的一年里，《注意力就是你所需要的》中的Transformer被很多人所關注。除了在翻譯質量上產生重大改進外，它還為許多其他NLP任務提供了一個新的架構。這篇論文本身寫得非常清楚，但傳統的觀點是，它的正確實現相當困難。

在這篇文章中，我以逐行實現的形式呈現了論文的 "注釋 "版本。我對原論文中的一些章節進行了重新排序和刪除，并在全文中添加了注釋。這個文檔本身就是一個工作筆記，應該是一個完全可用的實現。總共有400行庫代碼，可以在4個GPU上每秒處理27000個token。

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

請注意，這僅僅是研究人員和感興趣的開發人員的一個起點。這里的代碼主要基于我們的OpenNMT包。(如果有幫助，請自由引用。)對于其他模型的全服務實現，請查看Tensor2Tensor (tensorflow)和Sockeye (mxnet)。

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

預先設置

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

背景資料

減少順序計算的目標也構成了擴展神經GPU、ByteNet和ConvS2S的基礎，它們都使用卷積神經網絡作為基本構件，對所有輸入和輸出位置并行計算隱藏表示。在這些模型中，將兩個任意輸入或輸出位置的信號關聯起來所需的運算次數隨著位置之間的距離而增長，對于ConvS2S來說是線性的，對于ByteNet來說是對數的。這使得學習遠距離位置之間的依賴關系變得更加困難。在Transformer中，這種情況被減少到了一個恒定的操作次數，盡管代價是由于注意力加權位置的平均化而導致有效分辨率的降低，我們用多頭注意力來抵消這種影響。

自注意，有時也被稱為內注意，是一種將單個序列的不同位置聯系起來以計算序列的表示的注意機制。自我注意已被成功地應用于各種任務中，包括閱讀理解、抽象概括、文本內涵和學習任務無關的句子表征。端到端記憶網絡是基于循環注意機制而不是序列對齊的循環，并且已經被證明在簡單語言問題回答和語言建模任務上表現良好。

然而，據我們所知，Transformer是第一個完全依靠自我注意力來計算其輸入和輸出的表征，而不使用序列對齊的RNNs或卷積的轉換模型。

模型結構

大多數競爭性神經序列轉導模型都有一個編碼器-解碼器結構(cite)。在這里，編碼器將輸入的符號表示序列(x1，...,xn)映射為連續表示序列z=(z1，...,zn)。在給定z的情況下，解碼器每次生成一個符號的輸出序列(y1,...,ym)。在每一步中，該模型都是自動遞減的(cite)，在生成下一個符號時，消耗之前生成的符號作為額外的輸入。

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沿用了這種整體架構，編碼器和解碼器都采用堆疊式自關注和點對點的全連接層，分別如圖1的左半部分和右半部分所示。

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

【精讀】Transformer模型深度解讀

編碼器和解碼器堆棧

編碼器

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

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)

我們在兩個子層周圍分別采用殘差連接(cite)，然后進行層歸一化(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

也就是說，每個子層的輸出是LayerNorm(x+Sublayer(x))，其中Sublayer(x)是子層自己實現的函數。我們在每個子層的輸出中應用dropout(引用)，然后再加到子層的輸入中并進行歸一化。

為了方便這些殘差連接，模型中的所有子層以及嵌入層都會產生維度為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)))

每層有兩個子層。第一層是一個多頭自注意機制，第二層是一個簡單的、基于位置的全連接前饋網絡。

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)

除了每個編碼器層中的兩個子層外，解碼器還插入了第三個子層，它在編碼器堆棧的輸出上執行多頭關注。與編碼器類似，我們在每個子層周圍采用殘余連接，然后進行層歸一化。

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)

我們還修改了解碼器堆棧中的自注意力子層，以防止位置對后續位置的關注。這種遮蔽，加上輸出嵌入偏移這一個位置的事實，確保位置ii的預測只能依賴于小于i的這個位置的已知輸出。

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

筆者注：注意力掩碼下方顯示了每個tgt詞（行）被允許看的位置（列）。在訓練過程中，單詞會被屏蔽，以便關注之后的單詞。

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

【精讀】Transformer模型深度解讀

注意事項

注意函數可以描述為將一個查詢和一組鍵值對映射到一個輸出，其中查詢、鍵、值和輸出都是向量。輸出是以值的加權和來計算的，其中分配給每個值的權重是由查詢與對應鍵的兼容性函數計算出來的。我們把我們的特殊注意力稱為 "Scaled Dot-Product注意力"。輸入由維度為dk的查詢和鍵，以及維度為dv的值組成。我們計算查詢與所有鍵的點積，每一個點積除以√dk，然后應用一個softmax函數來獲得值的權重。

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

【精讀】Transformer模型深度解讀

在實際應用中，我們對一組查詢同時計算關注函數，打包成一個矩陣QQ。鍵和值也一起打包成矩陣KK和VV。我們計算輸出的矩陣為：

【精讀】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

最常用的兩個注意力函數是加法注意力（cite），和點積（乘法）注意力。點積注意力除了縮放因子為1/√dk外，與我們的算法相同。加法注意力使用單層隱藏層的前饋網絡計算兼容性函數。雖然兩者在理論復雜度上相似，但點積注意力在實踐中更快，更節省空間，因為它可以使用高度優化的矩陣乘法代碼來實現。

雖然對于dk的小值，兩種機制的表現相似，但對于dk的大值，加法注意力的表現優于點積注意力，而沒有縮放（引用）。我們懷疑，對于dk的大值，點積的幅度會變大，將softmax函數推到它的梯度極小的區域（為了說明點積為什么會變大，假設qq和kk的分量是均值00、方差11的獨立隨機變量。那么它們的點積q?k=∑dki=1qiki，其均值為00，方差為dk）。

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

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

【精讀】Transformer模型深度解讀

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

【精讀】Transformer模型深度解讀

其中，投影為參數矩陣

【精讀】Transformer模型深度解讀

和

【精讀】Transformer模型深度解讀

在這項工作中，我們采用了h=8h=8個平行的注意層，或者說頭。對于其中的每一個層，我們使用：

【精讀】Transformer模型深度解讀

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

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)

注意力在我們的模型中的應用

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

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

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

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

位置導向的前饋網絡

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

【精讀】Transformer模型深度解讀

雖然不同位置的線性變換是相同的，但它們在層與層之間使用不同的參數。另一種描述方式是內核大小為1的兩個卷積。輸入和輸出的維度為dmodel=512，內層的維度為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

與其他序列轉導模型類似，我們使用學習的嵌入將輸入令牌和輸出令牌轉換為維數dmodel的向量。我們還使用通常的學習線性變換和softmax函數將解碼器輸出轉換為預測的下一個標記概率。在我們的模型中，我們在兩個嵌入層和預softmax線性變換之間共享相同的權重矩陣，類似于（引用）。在嵌入層中，我們將這些權重乘以√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)

位置編碼

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

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

【精讀】Transformer模型深度解讀

其中pos是位置，i是維度。即位置編碼的每個維度對應一個正弦波。波長形成從2π到10000?2π的幾何級數。我們選擇這個函數是因為我們假設它可以讓模型很容易地學會通過相對位置來參加，因為對于任何固定的偏移量k，PEpos+k可以表示為PEpos的線性函數。

此外，我們對編碼器和解碼器堆棧中的嵌入和位置編碼的總和應用了 dropout。對于基礎模型，我們使用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)

下面的位置編碼會根據位置加入一個正弦波。每個維度的波的頻率和偏移量是不同的。

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模型深度解讀

我們還試驗了使用學習的位置嵌入（cite）來代替，并發現這兩個版本產生的結果幾乎是相同的。我們選擇了正弦版本，因為它可能允許模型外推到比訓練過程中遇到的序列長度更長的序列。

完整模型

在這里，我們定義了一個函數，它可以接受超參數并產生一個完整的模型。

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

訓練

本節介紹了我們模型的訓練制度。

筆者注：我們停下來做一個快速的插曲，介紹一些訓練標準編碼器解碼器模型所需的工具。首先，我們定義了一個批處理對象，它保存了用于訓練的src和目標句子，以及構建掩碼。

批量和屏蔽

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

筆者注：接下來我們創建一個通用的訓練和評分函數來跟蹤損失。我們傳遞了一個通用的損失計算函數，它也處理參數更新。

訓練循環

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個tokens。對于英語-法語，我們使用了明顯更大的WMT 2014英法數據集，該數據集由36M句子組成，并將tokens拆分為32000個詞片詞匯。

句子對被按近似序列長度分批在一起。每個訓練批次都包含一組句子對，包含大約25000個源標記和25000個目標標記。

筆者注：我們將使用火炬文本進行批處理。這將在下面詳細討論。在這里，我們在torchtext函數中創建批處理，以確保我們的批處理大小墊到最大batchsize不超過一個閾值（25000，如果我們有8個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)

硬件和時間表

我們在一臺擁有8個NVIDIA P100 GPU的機器上訓練我們的模型。對于我們的基礎模型，使用本文中描述的超參數，每個訓練步驟大約需要0.4秒。我們總共訓練了100,000步或12小時的基礎模型。對于我們的大模型，步長為1.0秒。大模型的訓練時間為30萬步（3.5天）。

優化器

我們使用了Adam優化器（引用），β1=0.9，β2=0.98，?=10^-9。我們根據公式，在訓練過程中改變學習率。

【精讀】Transformer模型深度解讀

這相當于對第一個warmupstepswarmupsteps訓練步數線性增加學習率，此后按步數的倒平方根按比例減少。我們使用warmupsteps=4000。

注意：這部分非常重要。需要用這個設置的模型進行訓練。

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

該模型在不同模型大小和優化超參數下的曲線示例。

# 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模型深度解讀

正規化

標簽平滑化

在訓練過程中，我們采用了價值?ls=0.1?ls=0.1的標簽平滑（引用）。這傷害了迷惑性，因為模型學會了更多的不確定，但提高了準確性和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))

在這里，我們可以看到一個例子，說明質量是如何根據置信度分配給單詞的。

# 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模型深度解讀

標簽平滑實際上是開始懲罰模型，如果它對給定的選擇非常自信的話。

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模型深度解讀

一個例子

我們可以先嘗試一個簡單的復制任務。從一個小詞匯中給定一組隨機的輸入符號，目標是生成回這些相同的符號。

綜合數據

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

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

這個代碼為了簡單起見，使用貪婪的解碼來預測翻譯。

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]

一個真實的例子

筆者注：現在我們考慮使用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 批量進行一些改進。這段代碼修補了他們的默認批處理，以確保我們搜索到的句子足夠多，從而找到緊湊的批處理。

迭代器

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訓練

筆者注：最后為了真正針對快速訓練，我們將使用多gpu。這段代碼實現了多gpu詞的生成。它不是專門針對transformer的，所以我不會說得太詳細。我們的想法是在訓練時將單詞生成分割成塊，在許多不同的gpus上并行處理。我們使用 pytorch 并行基元來實現這一目的。

replicate - 將模塊分割到不同的gpus上。
scatter - 分割批次到不同的gpus上。
parallel_apply - 將模塊應用到不同的gpus上的批次。
gather - 把分散的數據拉回到一個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

現在我們創建我們的模型、準則、優化器、數據迭代器和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

現在我們訓練模型。我會稍微玩一下熱身步驟，但其他一切都使用默認參數。在一個有4個特斯拉V100的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、搜索、平均

筆者注：所以這主要是涵蓋了變壓器模型本身。有四個方面我們沒有明確地覆蓋。我們還在OpenNMT-py中實現了所有這些附加功能。

1. BPE/字片。我們可以使用一個庫先把數據預處理成子字單元。參見Rico Sennrich的subword- nmt實現。這些模型會將訓練數據轉化成這樣的樣子。

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

2. 共享嵌入。當使用共享詞匯的BPE時，我們可以在源/目標/生成器之間共享相同的權重向量。詳情請參見（引文）。要將此添加到模型中，只需這樣做。

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. 光束搜索:這有點太復雜了，這里就不多說了。參見OpenNMT- py中的pytorch實現。

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（big）在表2中）比之前報道的最佳模型（包括合集）的表現要好2.0 BLEU以上，建立了新的最先進的BLEU得分28.4。該模型的配置列在表3的底行。訓練在8個P100 GPU上花了3.5天。即使我們的基礎模型也超越了所有之前發布的模型和合集，而訓練成本只是任何競爭模型的一小部分。

在WMT 2014英譯法任務上，我們的大模型實現了41.0的BLEU得分，超越了之前發布的所有單體模型，而訓練成本不到之前最先進模型的1/4。為英譯法訓練的Transformer（大）模型使用的輟學率Pdrop=0.1，而不是0.3。

【精讀】Transformer模型深度解讀

我們在這里寫的代碼是基礎模型的一個版本。這里有這個系統的完全訓練版本（示例模型）。

通過上一節中的附加擴展，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)

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

注意力的可視化

即使是用greedy解碼，翻譯出來的效果也很不錯。我們可以進一步將其可視化，看看在注意力的每一層發生了什么。

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模型深度解讀

結論

筆者注：希望這段代碼對以后的研究有用。如果你有任何問題，請聯系我們。如果你覺得這段代碼有幫助，也可以看看我們其他的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}
}

雷鋒字幕組是一個由AI愛好者組成的翻譯團隊，匯聚五五多位志愿者的力量，分享最新的海外AI資訊，交流關于人工智能技術領域的行業轉變與技術創新的見解。

團隊成員有大數據專家，算法工程師，圖像處理工程師，產品經理，產品運營，IT咨詢人，在校師生；志愿者們來自IBM，AVL，Adobe，阿里，百度等知名企業，北大，清華，港大，中科院，南卡羅萊納大學，早稻田大學等海內外高校研究所。

如果，你也是位熱愛分享的AI愛好者。歡迎與雷鋒字幕組一起，學習新知，分享成長。

【精讀】Transformer模型深度解讀

雷峰網版權文章，未經授權禁止轉載。詳情見轉載須知。

0人收藏

AI研習社-譯站

知情人士

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

掃描關注作者微信

發私信

當月熱門文章

【精讀】Transformer模型深度解讀

預先設置

目錄

Prelims

背景資料

模型結構

訓練

第一個例子

一個現實例子

結果

結論

背景資料

模型結構

編碼器和解碼器堆棧

解碼器

注意力在我們的模型中的應用

位置導向的前饋網絡

嵌入和Softmax

位置編碼

完整模型

訓練

批量和屏蔽

訓練循環

訓練數據和批處理

硬件和時間表

優化器

正規化

一個例子

綜合數據

損失計算

greedy解碼

一個真實的例子

數據加載

迭代器

多CPU訓練

訓練系統

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

結果

注意力的可視化

結論