文章目錄
- 本文内容
- 将Transformer看成黑盒
- Transformer的推理過程
- Transformer的訓練過程
- Pytorch中的nn.Transformer
- nn.Transformer簡介
- nn.Transformer的構造參數詳解
- Transformer的forward參數詳解
- src和tgt
- src_mask、tgt_mask和memory_mask
- key_padding_mask
- nn.Transformer的使用
- 實戰：使用nn.Transformer實作一個簡單的Copy任務
- 參考資料：
本文内容
Transformer是個相對複雜的模型，可能有些人和我一樣，學了也不會用，或者感覺自己懂了，但又不懂。本文将Transformer看做一個黑盒，然後講解Pytorch中nn.Transformer的使用。
本文包含内容如下：
- Transformer的訓練過程講解
- Transformer的推理過程講解
- Transformer的入參和出參講解
- nn.Transformer的各個參數講解
- nn.Transformer的mask機制詳解
- 實戰：使用nn.Transformer訓練一個copy任務。
開始之前，我們先導入要用到的包：
import math
import random
import torch
import torch.nn as 将Transformer看成黑盒
這是一張經典的Transformer模型圖：
我們現在将其變成黑盒，将其蓋住：
我們現在再來看下Transformer的輸入和輸出：
這裡是一個翻譯任務中transformer的輸入和輸出。transformer的輸入包含兩部分：
- inputs: 原句子對應的tokens，且是完整句子。一般0表示句子開始(
<bos>
<eos>
<pad>
- outputs(shifted right)：上一個階段的輸出。雖然名字叫outputs，但是它是輸入。最開始為0（
<bos>
<bos> 我
Transformer的輸出是一個機率分布。
Transformer的推理過程
這裡先講Transformer的推理過程，因為這個簡單。其實通過上面的講解，你可能已經清楚了。上面是Transformer推理的第一步，緊接着第二步如圖：
Transformer的推理過程就是這樣一遍一遍調用Transformer，直到輸出
<eos>
或達到句子最大長度為止。
通常真正在實戰時，Transformer的Encoder部分隻需要執行一遍就行了，這裡為了簡單起見，就整體重新執行。
Transformer的訓練過程
在Transformer推理時，我們是一個詞一個詞的輸出，但在訓練時這樣做效率太低了，是以我們會将target一次性給到Transformer（當然，你也可以按照推理過程做），如圖所示：
從圖上可以看出，Transformer的訓練過程和推理過程主要有以下幾點異同：
- 源輸入src相同：對于Transformer的inputs部分(src參數)一樣，都是要被翻譯的句子。
- 目标輸入tgt不同：在Transformer推理時，tgt是從
<bos>
<bos> 我
<bos> 我 愛 你 <eos>
<bos> 我 愛 你
<eos>
- 輸出數量變多：在訓練時，transformer會一次輸出多個機率分布。例如上圖，
我
<bos>
愛
<bos> 我
我 愛 你 <eos> <pad> <pad>
<bos>
<bos>
<bos>
tgt_y
當得到transformer的輸出後，我們就可以計算loss了，計算過程如圖：
Pytorch中的nn.Transformer
nn.Transformer簡介
在Pytorch中已經為我們實作了Transformer，我們可以直接拿來用，但nn.Transformer和我們上圖的還是有點差別，具體如圖：
Transformer并沒有實作
Embedding
和
Positional Encoding
和最後的
Linear+Softmax
部分，這裡我簡單對這幾部分進行說明：
- Embedding: 負責将token映射成高維向量。例如将123映射成
[0.34, 0.45, 0.123, ..., 0.33]
nn.Embedding
nn.Embedding
nn.Embedding
- Positional Encoding：位置編碼。用于為token編碼增加位置資訊，例如
I love you
- Linear+Softmax：一個線性層加一個Softmax，用于對nn.Transformer輸出的結果進行token預測。如果把Transformer比作CNN，那麼nn.Transformer實作的就是卷積層，而
Linear+Softmax
這裡我先簡單的示範一下
nn.Transformer
的使用：
# 定義編碼器，詞典大小為10，要把token編碼成128維的向量
embedding = nn.Embedding(10, 128)
# 定義transformer，模型次元為128（也就是詞向量的次元）
transformer = nn.Transformer(d_model=128, batch_first=True) # batch_first一定不要忘記
# 定義源句子，可以想想成是 <bos> 我 愛 吃 肉 和 菜 <eos> <pad> <pad>
src = torch.LongTensor([[0, 3, 4, 5, 6, 7, 8, 1, 2, 2]])
# 定義目标句子，可以想想是 <bos> I like eat meat and vegetables <eos> <pad>
tgt = torch.LongTensor([[0, 3, 4, 5, 6, 7, 8, 1, 2]])
# 将token編碼後送給transformer（這裡暫時不加Positional Encoding）
outputs = transformer(embedding(src), embedding(tgt))
outputs.size() torch.Size([1, 9, 128]) Transformer輸出的Shape和tgt編碼後的Shape一緻。在訓練時，我們會把transformer的所有輸出送給Linear，而在推理時，隻需要将最後一個輸出送給Linear即可，即 outputs[:, -1]
nn.Transformer的構造參數詳解
Transformer構造參數衆多，是以我們還需要将黑盒稍微打開一下：
nn.Transformer主要由兩部分構成：
nn.TransformerEncoder
和
nn.TransformerDecoder
。而
nn.TransformerEncoder
又是由多個
nn.TransformerEncoderLayer
堆疊而成的，圖中的
Nx
就是要堆疊多少層。
nn.TransformerDecoder
同理。
下面是nn.Transformer的構造參數：
- d_model: Encoder和Decoder輸入參數的特征次元。也就是詞向量的次元。預設為512
- nhead: 多頭注意力機制中，head的數量。關于Attention機制，可以參考這篇文章。注意該值并不影響網絡的深度和參數數量。預設值為8。
- num_encoder_layers: TransformerEncoderLayer的數量。該值越大，網絡越深，網絡參數量越多，計算量越大。預設值為6
- num_decoder_layers：TransformerDecoderLayer的數量。該值越大，網絡越深，網絡參數量越多，計算量越大。預設值為6
- dim_feedforward：Feed Forward層（Attention後面的全連接配接網絡）的隐藏層的神經元數量。該值越大，網絡參數量越多，計算量越大。預設值為2048
- dropout：dropout值。預設值為0.1
- activation： Feed Forward層的激活函數。取值可以是string(“relu” or “gelu”)或者一個一進制可調用的函數。預設值是relu
- custom_encoder：自定義Encoder。若你不想用官方實作的TransformerEncoder，你可以自己實作一個。預設值為None
- custom_decoder: 自定義Decoder。若你不想用官方實作的TransformerDecoder，你可以自己實作一個。
- layer_norm_eps:
Add&Norm
- batch_first：batch次元是否是第一個。如果為True，則輸入的shape應為(batch_size, 詞數，詞向量次元)，否則應為(詞數, batch_size, 詞向量次元)。預設為False。這個要特别注意，因為大部分人的習慣都是将batch_size放在最前面，而這個參數的預設值又是False，是以會報錯。
- norm_first– 是否要先執行norm。例如，在圖中的執行順序為
Attention -> Add -> Norm
Norm -> Attention -> Add
Transformer的forward參數詳解
Transformer的forward參數需要詳細解釋，這裡我先将其列出來，進行粗略解釋，然後再逐個進行詳細解釋：
- src: Encoder的輸入。也就是将token進行Embedding并Positional Encoding之後的tensor。必填參數。Shape為(batch_size, 詞數, 詞向量次元)
- tgt: 與src同理，Decoder的輸入。必填參數。Shape為(詞數, 詞向量次元)
- src_mask: 對src進行mask。不常用。Shape為(詞數, 詞數)
- tgt_mask：對tgt進行mask。常用。Shape為(詞數, 詞數)
- memory_mask– 對Encoder的輸出memory進行mask。不常用。Shape為(batch_size, 詞數, 詞數)
- src_key_padding_mask：對src的token進行mask.常用。Shape為(batch_size, 詞數)
- tgt_key_padding_mask：對tgt的token進行mask。常用。Shape為(batch_size, 詞數)
- memory_key_padding_mask：對tgt的token進行mask。不常用。Shape為(batch_size, 詞數)
上面的所有mask都是代表不遮掩，0
代表遮掩。嚴禁用-inf
和True
，雖然看起來它們可以用，但是部分場景下會讓輸出變為False
。另外，src_mask、tgt_mask和memory_mask是不需要傳batch的nan
上面說了和沒說其實差不多，重要的是每個參數的是否常用和其對應的Shape（這裡我預設
batch_first=True
）。 接下來對各個參數進行詳細解釋。
src和tgt
src參數和tgt參數分别為Encoder和Decoder的輸入參數。它們是對token進行編碼後，再經過Positional Encoding之後的結果。
例如：我們一開始的輸入為：
[[0, 3, 4, 5, 6, 7, 8, 1, 2, 2]]
，Shape為(1, 10)，表示batch_size為1, 每句10個詞。
在經過Embedding後，Shape就變成了(1, 10, 128)，表示batch_size為1, 每句10個詞，每個詞被編碼為了128維的向量。
src就是這個(1, 10, 128)的向量。tgt同理
src_mask、tgt_mask和memory_mask
要真正了解mask，需要學習Attention機制，可參考該篇。這裡隻做一個簡要的說明。
在經過Attention層時，會讓每個詞具有上下文關系，也就是每個詞除了自己的資訊外，還包含其他詞的資訊。例如：
蘋果 很 好吃
和
蘋果 手機 很 好玩
，這兩個
蘋果
顯然指的不是同一個意思。但讓
蘋果
這個詞具備了後面
好吃
或
手機
這兩個詞的資訊後，那就可以區分這兩個
蘋果
的含義了。
在Attention中，我們有這麼一個“方陣”，描述着詞與詞之間的關系，例如：
蘋果 很 好吃
蘋果 [[0.5, 0.1, 0.4],
很 [0.1, 0.8, 0.1],
好吃 [0.3, 0.1, 0.6],] 在上述矩陣中，
蘋果
這個詞與自身,
很
和
好吃
三個詞的關系權重就是
[0.5, 0.1, 0.4]
，通過該矩陣，我們就可以得到包含上下文的
蘋果
了，即
但在實際推理時，詞是一個一個輸出的。若
蘋果很好吃
是tgt的話，那麼
蘋果
是不應該包含
很
和
好吃
的上下文資訊的，是以我們希望為：
同理，
很
字可以包含
蘋果
的上下資訊，但不能包含
好吃
，是以為：
那要完成這個事情，那隻需要改變方陣即可：
蘋果 很 好吃
蘋果 [[0.5, 0, 0],
很 [0.1, 0.8, 0],
好吃 [0.3, 0.1, 0.6],] 而這個事情我們就可以使用mask掩碼來完成，即：
蘋果 很 好吃
蘋果 [[ 0, -inf, -inf],
很 [ 0, 0, -inf],
好吃 [ 0, 0, 0]] 其中0表示不遮掩，而
-inf
表示遮掩。（之是以這麼定是因為這個方陣還要過softmax，是以會使
-inf
變為0）。
是以，對于tgt_mask，我們隻需要生成一個斜着覆寫的方陣即可，我們可以利用
nn.Transformer.generate_square_subsequent_mask
來完成，例如：
nn.Transformer.generate_square_subsequent_mask(5) # 這個5指的是tgt的token的數量 tensor([[0., -inf, -inf, -inf, -inf],
[0., 0., -inf, -inf, -inf],
[0., 0., 0., -inf, -inf],
[0., 0., 0., 0., -inf],
[0., 0., 0., 0., 0.]]) 通過上面的分析，src和memory一般是不需要進行mask的，是以不常用。
key_padding_mask
在我們的src和tgt語句中，除了本身的詞外，還包含了三種token:
<bos>
,
<eos>
和
<pad>
。這裡面的
<pad>
隻是為了改變句子長度，友善将不同長度的句子組成batch而進行填充的。該token沒有任何意義，是以在計算Attention時，也不想讓它們參與，是以也要mask。而對于這種mask就需要用到key_padding_mask這個參數了。
例如，我們的src為
[[0, 3, 4, 5, 6, 7, 8, 1, 2, 2]]
，其中2是
<pad>
，是以我們的
src_key_padding_mask
就應為
[[0, 0, 0, 0, 0, 0, 0, 0, -inf, -inf]]
，即将最後兩個2給掩蓋住。
tgt_key_padding_mask
同理。但
memory_key_padding_mask
就沒有必要用了。
在Transformer的源碼中或其他實作中，tgt_mask和tgt_key_padding_mask是合在一起的，例如：
[[0., -inf, -inf, -inf], # tgt_mask
[0., 0., -inf, -inf],
[0., 0., 0., -inf],
[0., 0., 0., 0.]]
+
[[0., 0., 0., -inf]] # tgt_key_padding_mask
=
[[0., -inf, -inf, -inf], # 合并之後的
[0., 0., -inf, -inf],
[0., 0., 0., -inf],
[0., 0., 0., -inf]] nn.Transformer的使用
接下來我們來簡單的使用一下
nn.Transformer
:
首先我們定義src和tgt:
src = torch.LongTensor([
[0, 8, 3, 5, 5, 9, 6, 1, 2, 2, 2],
[0, 6, 6, 8, 9, 1 ,2, 2, 2, 2, 2],
])
tgt = torch.LongTensor([
[0, 8, 3, 5, 5, 9, 6, 1, 2, 2],
[0, 6, 6, 8, 9, 1 ,2, 2, 2, 2],
]) 接下來定義一個輔助函數來生成src_key_padding_mask和tgt_key_padding_mask:
def get_key_padding_mask(tokens):
key_padding_mask = torch.zeros(tokens.size())
key_padding_mask[tokens == 2] = -torch.inf
return key_padding_mask
src_key_padding_mask = get_key_padding_mask(src)
tgt_key_padding_mask = get_key_padding_mask(tgt)
print(tgt_key_padding_mask) tensor([[0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf],
[0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf]]) 然後通過Transformer内容方法生成
tgt_mask
：
tgt_mask = nn.Transformer.generate_square_subsequent_mask(tgt.size(-1))
print(tgt_mask) tensor([[0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],
[0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],
[0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf],
[0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf],
[0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf],
[0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf],
[0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf],
[0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf],
[0., 0., 0., 0., 0., 0., 0., 0., 0., -inf],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]) 之後就可以定義Embedding和Transformer進行調用了：
# 定義編碼器，詞典大小為10，要把token編碼成128維的向量
embedding = nn.Embedding(10, 128)
# 定義transformer，模型次元為128（也就是詞向量的次元）
transformer = nn.Transformer(d_model=128, batch_first=True) # batch_first一定不要忘記
# 将token編碼後送給transformer（這裡暫時不加Positional Encoding）
outputs = transformer(embedding(src), embedding(tgt),
tgt_mask=tgt_mask,
src_key_padding_mask=src_key_padding_mask,
tgt_key_padding_mask=tgt_key_padding_mask)
print(outputs.size()) torch.Size([2, 10, 128]) 實戰：使用nn.Transformer實作一個簡單的Copy任務
任務描述：讓Transformer預測輸入。例如，輸入為
[0, 3, 4, 6, 7, 1, 2, 2]
，則期望的輸出為
[0, 3, 4, 6, 7, 1]
。
首先，我們定義一下句子的最大長度：
max_length=16 定義PositionEncoding類，不需要知道具體什麼意思，直接拿過來用即可。
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)
# 初始化Shape為(max_len, d_model)的PE (positional encoding)
pe = torch.zeros(max_len, d_model)
# 初始化一個tensor [[0, 1, 2, 3, ...]]
position = torch.arange(0, max_len).unsqueeze(1)
# 這裡就是sin和cos括号中的内容，通過e和ln進行了變換
div_term = torch.exp(
torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model)
)
# 計算PE(pos, 2i)
pe[:, 0::2] = torch.sin(position * div_term)
# 計算PE(pos, 2i+1)
pe[:, 1::2] = torch.cos(position * div_term)
# 為了友善計算，在最外面在unsqueeze出一個batch
pe = pe.unsqueeze(0)
# 如果一個參數不參與梯度下降，但又希望儲存model的時候将其儲存下來
# 這個時候就可以用register_buffer
self.register_buffer("pe", pe)
def forward(self, x):
"""
x 為embedding後的inputs，例如(1,7, 128)，batch size為1,7個單詞，單詞次元為128
"""
# 将x和positional encoding相加。
x = x + self.pe[:, : x.size(1)].requires_grad_(False)
return self.dropout(x) 定義我們的Copy模型：
class CopyTaskModel(nn.Module):
def __init__(self, d_model=128):
super(CopyTaskModel, self).__init__()
# 定義詞向量，詞典數為10。我們不預測兩位小數。
self.embedding = nn.Embedding(num_embeddings=10, embedding_dim=128)
# 定義Transformer。超參是我拍腦袋想的
self.transformer = nn.Transformer(d_model=128, num_encoder_layers=2, num_decoder_layers=2, dim_feedforward=512, batch_first=True)
# 定義位置編碼器
self.positional_encoding = PositionalEncoding(d_model, dropout=0)
# 定義最後的線性層，這裡并沒有用Softmax，因為沒必要。
# 因為後面的CrossEntropyLoss中自帶了
self.predictor = nn.Linear(128, 10)
def forward(self, src, tgt):
# 生成mask
tgt_mask = nn.Transformer.generate_square_subsequent_mask(tgt.size()[-1])
src_key_padding_mask = CopyTaskModel.get_key_padding_mask(src)
tgt_key_padding_mask = CopyTaskModel.get_key_padding_mask(tgt)
# 對src和tgt進行編碼
src = self.embedding(src)
tgt = self.embedding(tgt)
# 給src和tgt的token增加位置資訊
src = self.positional_encoding(src)
tgt = self.positional_encoding(tgt)
# 将準備好的資料送給transformer
out = self.transformer(src, tgt,
tgt_mask=tgt_mask,
src_key_padding_mask=src_key_padding_mask,
tgt_key_padding_mask=tgt_key_padding_mask)
"""
這裡直接傳回transformer的結果。因為訓練和推理時的行為不一樣，
是以在該模型外再進行線性層的預測。
"""
return out
@staticmethod
def get_key_padding_mask(tokens):
"""
用于key_padding_mask
"""
key_padding_mask = torch.zeros(tokens.size())
key_padding_mask[tokens == 2] = -torch.inf
return model = CopyTaskModel() 這裡簡單的嘗試下我們定義的模型：
src = torch.LongTensor([[0, 3, 4, 5, 6, 1, 2, 2]])
tgt = torch.LongTensor([[3, 4, 5, 6, 1, 2, 2]])
out = model(src, tgt)
print(out.size())
print(out) torch.Size([1, 7, 128])
tensor([[[ 2.1870e-01, 1.3451e-01, 7.4523e-01, -1.1865e+00, -9.1054e-01,
6.0285e-01, 8.3666e-02, 5.3425e-01, 2.2247e-01, -3.6559e-01,
....
-9.1266e-01, 1.7342e-01, -5.7250e-02, 7.1583e-02, 7.0782e-01,
-3.5137e-01, 5.1000e-01, -4.7047e-01]]],
grad_fn=<NativeLayerNormBackward0>) 沒什麼問題，那就接着定義損失函數和優化器，因為是多分類問題，是以用CrossEntropyLoss:
criteria = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4) 接着再定義一個生成随時資料的工具函數：
def generate_random_batch(batch_size, max_length=16):
src = []
for i in range(batch_size):
# 随機生成句子長度
random_len = random.randint(1, max_length - 2)
# 随機生成句子詞彙，并在開頭和結尾增加<bos>和<eos>
random_nums = [0] + [random.randint(3, 9) for _ in range(random_len)] + [1]
# 如果句子長度不足max_length，進行填充
random_nums = random_nums + [2] * (max_length - random_len - 2)
src.append(random_nums)
src = torch.LongTensor(src)
# tgt不要最後一個token
tgt = src[:, :-1]
# tgt_y不要第一個的token
tgt_y = src[:, 1:]
# 計算tgt_y，即要預測的有效token的數量
n_tokens = (tgt_y != 2).sum()
# 這裡的n_tokens指的是我們要預測的tgt_y中有多少有效的token，後面計算loss要用
return src, tgt, tgt_y, generate_random_batch(batch_size=2, max_length=6) (tensor([[0, 7, 6, 8, 7, 1],
[0, 9, 4, 1, 2, 2]]),
tensor([[0, 7, 6, 8, 7],
[0, 9, 4, 1, 2]]),
tensor([[7, 6, 8, 7, 1],
[9, 4, 1, 2, 2]]),
tensor(8)) 開始進行訓練：
total_loss = 0
for step in range(2000):
# 生成資料
src, tgt, tgt_y, n_tokens = generate_random_batch(batch_size=2, max_length=max_length)
# 清空梯度
optimizer.zero_grad()
# 進行transformer的計算
out = model(src, tgt)
# 将結果送給最後的線性層進行預測
out = model.predictor(out)
"""
計算損失。由于訓練時我們的是對所有的輸出都進行預測，是以需要對out進行reshape一下。
我們的out的Shape為(batch_size, 詞數, 詞典大小)，view之後變為：
(batch_size*詞數, 詞典大小)。
而在這些預測結果中，我們隻需要對非<pad>部分進行，是以需要進行正則化。也就是
除以n_tokens。
"""
loss = criteria(out.contiguous().view(-1, out.size(-1)), tgt_y.contiguous().view(-1)) / n_tokens
# 計算梯度
loss.backward()
# 更新參數
optimizer.step()
total_loss += loss
# 每40次列印一下loss
if step != 0 and step % 40 == 0:
print("Step {}, total_loss: {}".format(step, total_loss))
total_loss = 0 Step 40, total_loss: 3.570814609527588
Step 80, total_loss: 2.4842987060546875
...略
Step 1920, total_loss: 0.4518987536430359
Step 1960, total_loss: 0.37290623784065247 在完成模型訓練後，我們來使用一下我們的模型：
model = model.eval()
# 随便定義一個src
src = torch.LongTensor([[0, 4, 3, 4, 6, 8, 9, 9, 8, 1, 2, 2]])
# tgt從<bos>開始，看看能不能重新輸出src中的值
tgt = torch.LongTensor([[0]]) # 一個一個詞預測，直到預測為<eos>，或者達到句子最大長度
for i in range(max_length):
# 進行transformer計算
out = model(src, tgt)
# 預測結果，因為隻需要看最後一個詞，是以取`out[:, -1]`
predict = model.predictor(out[:, -1])
# 找出最大值的index
y = torch.argmax(predict, dim=1)
# 和之前的預測結果拼接到一起
tgt = torch.concat([tgt, y.unsqueeze(0)], dim=1)
# 如果為<eos>，說明預測結束，跳出循環
if y == 1:
break
print(tgt) tensor([[0, 4, 3, 4, 6, 8, 9, 9, 8, 1]]) 可以看到，我們的模型成功預測了src的輸入。