【精讀】Transformer模型深度解讀

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

英語原文:The Annotated Transformer

翻譯:雷鋒字幕組(Icarus、


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


在過去的一年裡,《注意力就是你所需要的》中的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

目錄

  • Prelims

  • 背景資料

  • 模型結構

        編碼器

        解碼器

        注意事項

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

        編碼器和解碼器堆棧

        位置導向的前饋網絡

        嵌入和Softmax

        位置編碼

        完整模型

  • 訓練

        標籤平滑化

        批量和遮蔽

        訓練迴路

        硬件和時間表

        優化器

        正規化

  • 第一個例子

        合成數據

        損失計算

        greedy解碼

  • 一個現實例子

        加載數據

        迭代器

        多GPU訓練

        訓練系統

        附加組件:BPE、搜索、平均值

  • 結果

        注意力可視化

  • 結論

背景資料

減少順序計算的目標也構成了擴展神經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')


編碼器和解碼器堆棧

編碼器

編碼器是由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


注意事項

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

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


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

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


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

其中,投影為參數矩陣

在這項工作中,我們採用了h=8h=8個平行的注意層,或者說頭。對於其中的每一個層,我們使用 :

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

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激活。

雖然不同位置的線性變換是相同的,但它們在層與層之間使用不同的參數。另一種描述方式是內核大小為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相同,因此兩者可以相加。位置編碼有很多選擇,有學習的和固定的(引用)。

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

其中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


我們還試驗了使用學習的位置嵌入(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。我們根據公式,在訓練過程中改變學習率。

這相當於對第一個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


正規化

標籤平滑化

在訓練過程中,我們採用了價值ϵ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


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

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


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 = ''    
   EOS_WORD = '
'    
   BLANK_WORD = ""    
   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[""]    
   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[""]).unsqueeze(-2)    
   out = greedy_decode(model, src, src_mask,                        
        max_len=60, start_symbol=TGT.vocab.stoi[""])    
    print("Translation:", end="\t")    
    for i in range(1, out.size(1)):        
        sym = TGT.vocab.itos[out[0, i]]        
        if sym == "
": 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 == "": break        
        print(sym, end =" ")    
    print()    
    break


Translation: . In my language , that means , thank you very much .  
Gold: . 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。


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

通過上一節中的附加擴展,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[""]).unsqueeze(-2)
out = greedy_decode(model, src, src_mask,                      
max_len=60, start_symbol=TGT.stoi[""])
print("Translation:", end="\t") trans = " "
for i in range(1, out.size(1)):    
sym = TGT.itos[out[0, i]]    
if sym == "
": break    
trans += sym + " "
print(trans)


ranslation: ▁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

Encoder Layer 4

Encoder Layer 6

Encoder Self Layer 2

Encoder Src Layer 4

Encoder 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}
}



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

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

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


想在手機閱讀更多周邊設備資訊?下載【香港矽谷】Android應用
分享到Facebook
技術平台: Nasthon Systems