pytorch 实现transformer
生活随笔
收集整理的這篇文章主要介紹了
pytorch 实现transformer
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
transformer理論部分見機器學習筆記：Transformer_劉文巾的博客-CSDN博客
1 導入庫
import math import torch import numpy as np import torch.nn as nn import torch.optim as optim import torch.utils.data as Data2?數據集處理
?S: decoder輸入的起始符號
?E: decoder輸出的終止符號
?P: 出現不等長的sequence的時候，用來補長
3?transformer的參數
# Transformer Parameters d_model = 512 #每一個詞的 word embedding 用多少維表示 #（包括positional encoding應該用多少維表示，因為這兩個要維度相加，應該是一樣的維度）d_ff = 2048 # FeedForward dimension #forward線性層變成多少維 #(d_model->d_ff->d_model)d_k = d_v = 64 # dimension of K(=Q), V #K，Q，V矩陣的維度 #K和Q一定是一樣的，因為要K乘Q的轉置 #V不一定,這里我們認為是一樣的''' 換一種說法，就是我在進行self-attention的時候， 從input（加了位置編碼之后的input）線性變換之后的三個向量 K，Q，V的維度 '''n_layers = 6 #encoder和decoder各有多少層n_heads = 8 #multi-head attention有幾個頭4?數據預處理
將encoder_input、decoder_input和decoder_output進行id化
def make_data(sentences):enc_inputs, dec_inputs, dec_outputs = [], [], []for i in range(len(sentences)):#對于輸入的每一句話enc_input = [src_vocab[n] for n in sentences[i][0].split()]# 每一次生成這一行sentence中encoder_input對應的id編碼for _ in range(src_len-len(enc_input)):enc_input.append(0)#encoder_input 補長dec_input = [tgt_vocab[n] for n in sentences[i][1].split()]# 每一次生成這一行sentence中decoder_input對應的id編碼for _ in range(tgt_len-len(dec_input)):dec_input.append(0)#decoder_input補長dec_output = [tgt_vocab[n] for n in sentences[i][2].split()]# 每一次生成這一行sentence中decoder_output對應的id編碼for _ in range(tgt_len-len(dec_output)):dec_output.append(0)#decoder_output補長#分別對encoder-input、decoder-input、decoder-output進行處理，分別放到一個list里面enc_inputs.extend(enc_input)dec_inputs.extend(dec_input)dec_outputs.extend(dec_output)return torch.LongTensor(enc_inputs), torch.LongTensor(dec_inputs), torch.LongTensor(dec_outputs) #一定要是LongTensorenc_inputs, dec_inputs, dec_outputs = make_data(sentences)print(enc_inputs,'\n', dec_inputs,'\n', dec_outputs) ''' tensor([[1, 2, 3, 4, 0],[1, 2, 3, 5, 0]]) tensor([[6, 1, 2, 3, 4, 8],[6, 1, 2, 3, 5, 8]]) tensor([[1, 2, 3, 4, 8, 7],[1, 2, 3, 5, 8, 7]]) '''5 構建dataloader
要使用pytorch的dataloader，有以下兩種構造方法
? ? 第一種方法——構造MyDataSet類，我們需要自己實現__len__方法和__getitem__方法
? ? 第二種方法 使用TensorDateset
具體可見?pytorch筆記：Dataloader_劉文巾的博客-CSDN博客
5.1 MyDataSet
class MyDataSet(Data.Dataset):def __init__(self, enc_inputs, dec_inputs, dec_outputs):super(MyDataSet, self).__init__()self.enc_inputs = enc_inputsself.dec_inputs = dec_inputsself.dec_outputs = dec_outputsdef __len__(self):return self.enc_inputs.shape[0]#有幾個sentencedef __getitem__(self, idx):return self.enc_inputs[idx], self.dec_inputs[idx], self.dec_outputs[idx]#根據索引找encoder_input,decoder_input,decoder_outputloader = Data.DataLoader(MyDataSet(enc_inputs, dec_inputs, dec_outputs), batch_size=2, shuffle=True)for step,(b_e_i,b_d_i,b_d_o) in enumerate(loader):print(b_e_i,'\n',b_d_i,'\n',b_d_o) ''' tensor([[1, 2, 3, 4, 0],[1, 2, 3, 5, 0]]) tensor([[6, 1, 2, 3, 4, 8],[6, 1, 2, 3, 5, 8]]) tensor([[1, 2, 3, 4, 8, 7],[1, 2, 3, 5, 8, 7]]) '''5.2 TensorDataset
torch_dataset=Data.TensorDataset(enc_inputs, dec_inputs, dec_outputs)loader2=Data.DataLoader(dataset=torch_dataset,batch_size=2,shuffle=True)for step,(b_e_i,b_d_i,b_d_o) in enumerate(loader2):print(b_e_i,'\n',b_d_i,'\n',b_d_o) ''' tensor([[1, 2, 3, 5, 0],[1, 2, 3, 4, 0]]) tensor([[6, 1, 2, 3, 5, 8],[6, 1, 2, 3, 4, 8]]) tensor([[1, 2, 3, 5, 8, 7],[1, 2, 3, 4, 8, 7]]) '''6 Transformer結構 （總體）
我改變一下順序，先看一下總體的Transformer框架
class Transformer(nn.Module):def __init__(self):super(Transformer, self).__init__()self.encoder = Encoder().cuda()self.decoder = Decoder().cuda()self.projection = nn.Linear(d_model, tgt_vocab_size, bias=False).cuda() #對decoder的輸出轉換維度， #從隱藏層維數->輸出詞典大小（選取概率最大的那一個，作為我們的預測結果）def forward(self, enc_inputs, dec_inputs):''' enc_inputs維度：[batch_size, src_len] 對encoder-input，我一個batch中有batch_size個sequence，一個sequence有src_len個字dec_inputs: [batch_size, tgt_len] 對decoder-input，我一個batch中有batch_size個sequence，一個sequence有tgt_len個字'''enc_outputs, enc_self_attns = self.encoder(enc_inputs) # enc_outputs: [batch_size, src_len, d_model]， # d_model是每一個字的word embedding長度"""enc_self_attns: [n_layers, batch_size, n_heads, src_len, src_len] 注意力矩陣，對encoder和decoder，每一層，每一句話，每一個頭，每兩個字之間都有一個權重系數， 這些權重系數組成了注意力矩陣 之后的dec_self_attns同理，當然decoder還有一個decoder-encoder的注意力矩陣"""dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(dec_inputs, enc_inputs, enc_outputs) # dec_outpus: [batch_size, tgt_len, d_model], #dec_self_attns: [n_layers, batch_size, n_heads, tgt_len, tgt_len], #dec_enc_attn: [n_layers, batch_size, tgt_len, src_len]dec_logits = self.projection(dec_outputs) #將輸出的維度，從 [batch_size, tgt_len, d_model]變成[batch_size, tgt_len, tgt_vocab_size] # dec_logits: [batch_size, tgt_len, tgt_vocab_size]return dec_logits.view(-1, dec_logits.size(-1)), enc_self_attns, dec_self_attns, dec_enc_attns ''' dec_logits view了之后的維度是 [batch_size * tgt_len, tgt_vocab_size]，可以理解為， 一個長句子，這個句子有 batch_size*tgt_len 個單詞. 每個單詞用 tgt_vocab_size 維表示，表示這個單詞為目標語言各個單詞的概率，取概率最大者為這個單詞的翻譯 '''#Transformer 主要就是調用 Encoder 和 Decoder。最后返回7 Encoder 結構
7.1 Encoder結構整體
nn.Embedding原理可見?pytorch 筆記： torch.nn.Embedding_劉文巾的博客-CSDN博客
class Encoder(nn.Module):def __init__(self):super(Encoder, self).__init__()self.src_emb = nn.Embedding(src_vocab_size, d_model) #對encoder的輸入的每個單詞進行詞向量計算（src_vocab_size個詞，每個詞d_model的維度)self.pos_emb = PositionalEncoding(d_model)#計算位置向量self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])#將6個EncoderLayer組成一個moduledef forward(self, enc_inputs):'''enc_inputs: [batch_size, src_len]'''enc_outputs = self.src_emb(enc_inputs) #對每個單詞進行詞向量計算#enc_outputs [batch_size, src_len, d_model]enc_outputs = self.pos_emb(enc_outputs.transpose(0, 1)).transpose(0, 1) #添加位置編碼# enc_outputs [batch_size, src_len, d_model]enc_self_attn_mask = get_attn_pad_mask(enc_inputs, enc_inputs) # enc_self_attn: [batch_size, src_len, src_len]#計算得到encoder-attention的pad martixenc_self_attns = []#創建一個列表，保存接下來要返回的字-字attention的值，不參與任何計算，供可視化用for layer in self.layers:# enc_outputs: [batch_size, src_len, d_model]# enc_self_attn: [batch_size, n_heads, src_len, src_len]enc_outputs, enc_self_attn = layer(enc_outputs, enc_self_attn_mask)enc_self_attns.append(enc_self_attn)#再傳進來就不用positional decoding#記錄下每一次的attentionreturn enc_outputs, enc_self_attns#使用 nn.ModuleList() 里面的參數是列表，列表里面存了 n_layers 個 Encoder Layer#由于我們控制好了 Encoder Layer 的輸入和輸出維度相同，所以可以直接用個 for 循環以嵌套的方式， #將上一次 Encoder Layer 的輸出作為下一次 Encoder Layer 的輸入7.2?positional encoding
buffer和parameter部分可見pytorch筆記 pytorch模型中的parameter與buffer_劉文巾的博客-CSDN博客
class PositionalEncoding(nn.Module):def __init__(self, d_model, dropout=0.1, max_len=5000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(p=dropout)#max_len （一個sequence的最大長度）pe = torch.zeros(max_len, d_model) #pe [max_len,d_model]position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) #position [max_len，1]div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) div_term:[d_model/2] #e^(-i*log10000/d_model)=10000^(-i/d_model) #d_model為embedding_dimension#兩個相乘的維度為[max_len,d_model/2] pe[:, 0::2] = torch.sin(position * div_term)pe[:, 1::2] = torch.cos(position * div_term) #計算position encoding #pe的維度為[max_len,d_model],每一行的奇數偶數分別取sin和cos(position * div_term)里面的值pe = pe.unsqueeze(0).transpose(0, 1) #維度變成(max_len,1,d_model)， #所以直接用pe=pe.unsqueeze(1)也可以self.register_buffer('pe', pe) #放入buffer中，參數不會訓練 #因為無論是encoder還是decoder，他每一個字的維度都是d_model #同時他們的位置編碼原理是一樣的 #所以一個sequence中所需要加上的positional encoding是一樣的。 #所以只需要存一個pe就可以了 #同時pe是固定的參數，不需要訓練 #后續代碼中，如果要使用位置編碼，只需要self.pe即可，因為pe已經注冊在buffer里面了def forward(self, x):'''x: [seq_len, batch_size, d_model]'''x = x + self.pe[:x.size(0), :,:] #選取和x一樣維度的seq_length，將pe加到x上return self.dropout(x)7.3?get-attention-pad-mask
#由于在 Encoder 和 Decoder 中都需要進行 mask 操作， #因此就無法確定這個函數的參數中 seq_len 的值， #如果是在 Encoder 中調用的，seq_len 就等于 src_len #如果是在 Decoder 中調用的，seq_len 就有可能等于 src_len， #也有可能等于 tgt_len（因為 Decoder 有兩個attention模塊，兩次 mask） #src_len 是在encoder-decoder中的mask #tgt_len是decoder中的maskdef get_attn_pad_mask(seq_q, seq_k): #對于seq_q中的每一個元素，它都會和seq_k中的每一個元素有著一個相關聯系數，這個系數組成一個矩陣： #但是因為pad的存在，pad的這些地方是不參與我們attention的計算的 #那么就是我們這里要返回的東西就是輔助得到哪些位是需要pad的 #pad的位置標記上True'''seq_q: [batch_size, seq_len]seq_k: [batch_size, seq_len]seq_len could be src_len or it could be tgt_lenseq_len in seq_q and seq_len in seq_k maybe not equal'''batch_size, len_q = seq_q.size()batch_size, len_k = seq_k.size()pad_attn_mask = seq_k.data.eq(0).unsqueeze(1) #擴展一個維度，因為attention_matrix是三維的 # pad_attn_mask [batch_size, 1, len_k] #seq_q:[[1,2,3,4,0],[1,2,4,5,0]] ->pad_attn_mask [[F,F,F,F,T],[F,F,F,F,T]]#通過seq_k.data.eq(0),判斷哪些位是pad（pad的編碼為0） #舉個例子，輸入為 seq_data = [1, 2, 3, 4, 0]，seq_data.data.eq(0) #就會返回 [False, False, False, False, True]return pad_attn_mask.expand(batch_size, len_q, len_k) #對于每一個batch_size對應的一行，都擴充為len_q行 # [batch_size, len_q, len_k]''' seq_q=torch.Tensor([[1,2,3,4,0],[1,2,4,5,0]] ) print(seq_q.data.eq(0).unsqueeze(1)) print(seq_q.data.eq(0).unsqueeze(1).expand(2,5,5) ) '''解釋一下這里expand之后矩陣的意思，以及為什么每一行是一樣的
| ? | 1 | am | Chinese | padding |
| 我 | FALSE | FALSE | FALSE | TRUE |
| 是 | FALSE | FALSE | FALSE | TRUE |
| 中 | FALSE | FALSE | FALSE | TRUE |
| 國 | FALSE | FALSE | FALSE | TRUE |
| 人 | FALSE | FALSE | FALSE | TRUE |
假設我們用英文翻譯中文。那么我們預測每一個中文字的時候，需要每個英文單詞的權重。
這個權重就是之后attention matrix每一個元素里面的東西。
所以矩陣的大小是(len_q,len_k)
而我們這個函數做的是輔助attention matrix，知道哪些位是需要padding的，哪些是不需要的。所以維度需要和attention matrix一致。
7.4 Encoder Layer（整體）
class EncoderLayer(nn.Module):def __init__(self):super(EncoderLayer, self).__init__()self.enc_self_attn = MultiHeadAttention() #多頭注意力機制self.pos_ffn = PoswiseFeedForwardNet() #提取特征def forward(self, enc_inputs, enc_self_attn_mask):'''enc_inputs: [batch_size, src_len, d_model]enc_self_attn_mask: [batch_size, src_len, src_len]'''enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask) # enc_outputs: [batch_size, src_len, d_model], #attn: [batch_size, n_heads, src_len, src_len] 每一個頭一個注意力矩陣# enc_inputs to same Q,K,V # enc_inputs乘以WQ，WK，WV生成QKV矩陣 ''' 為什么傳三個？ 因為這里傳的是一樣的 但在decoder-encoder的mulit-head里面 我們需要的decoder input ,encoder output, encoder output 所以為了使用方便，我們在定義enc_self_atten函數的時候就定義的是有三個形參的 '''enc_outputs = self.pos_ffn(enc_outputs) # enc_outputs: [batch_size, src_len, d_model] #輸入和輸出的維度是一樣的return enc_outputs, attn #將上述組件拼起來，就是一個完整的 Encoder Layer7.4.1?Multihead attention
class MultiHeadAttention(nn.Module):def __init__(self):super(MultiHeadAttention, self).__init__()self.W_Q = nn.Linear(d_model, d_k * n_heads, bias=False)self.W_K = nn.Linear(d_model, d_k * n_heads, bias=False)self.W_V = nn.Linear(d_model, d_v * n_heads, bias=False) #三個矩陣，分別對輸入進行三次線性變化self.fc = nn.Linear(n_heads * d_v, d_model, bias=False)#變換維度def forward(self, input_Q, input_K, input_V, attn_mask):'''input_Q: [batch_size, len_q, d_model]input_K: [batch_size, len_k, d_model]input_V: [batch_size, len_v(=len_k), d_model]attn_mask: [batch_size, seq_len, seq_len]'''residual, batch_size = input_Q, input_Q.size(0)Q = self.W_Q(input_Q).view(batch_size, -1, n_heads, d_k).transpose(1,2) K = self.W_K(input_K).view(batch_size, -1, n_heads, d_k).transpose(1,2) V = self.W_V(input_V).view(batch_size, -1, n_heads, d_v).transpose(1,2) #生成Q，K，V矩陣''' input_Q： [batch_size, len_q, d_model] (W)-> [batch_size, len_q,d_k * n_heads] (view)->[batch_size, len_q,n_heads,d_k] (transpose)-> [batch_size,n_heads, len_q,d_k ] '''attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1) ''' attn_mask: [batch_size, seq_len, seq_len] (unsqueeze)->[batch_size, 1, seq_len, seq_len] (repeat)->[batch_size, n_heads, seq_len, seq_len] '''context, attn = ScaledDotProductAttention()(Q, K, V, attn_mask) # context: [batch_size, n_heads, len_q, d_v], #attn: [batch_size, n_heads, len_q, len_k]context = context.transpose(1, 2).reshape(batch_size, -1, n_heads * d_v) # context: [batch_size, len_q, n_heads * d_v]output = self.fc(context) # [batch_size, len_q, d_model]return nn.LayerNorm(d_model).cuda()(output + residual), attn #Add & Norm ''' 完整代碼中一定會有三處地方調用 MultiHeadAttention()，Encoder Layer 調用一次， 傳入的 input_Q、input_K、input_V 全部都是 enc_inputs； Decoder Layer 中兩次調用，第一次都是decoder_inputs；第二次是兩個encoder_outputs和一個decoder——input '''7.4.2?Scaled-Dot-Product-Attention
class ScaledDotProductAttention(nn.Module):def __init__(self):super(ScaledDotProductAttention, self).__init__()def forward(self, Q, K, V, attn_mask):'''Q: [batch_size, n_heads, len_q, d_k]K: [batch_size, n_heads, len_k, d_k]V: [batch_size, n_heads, len_v(=len_k), d_v]attn_mask: [batch_size, n_heads, seq_len, seq_len]'''scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k) # scores : [batch_size, n_heads, len_q, len_k]scores.masked_fill_(attn_mask, -1e9) #attn_mask所有為True的部分（即有pad的部分），scores填充為負無窮，也就是這個位置的值對于softmax沒有影響attn = nn.Softmax(dim=-1)(scores) #attn： [batch_size, n_heads, len_q, len_k] #對每一行進行softmaxcontext = torch.matmul(attn, V) # [batch_size, n_heads, len_q, d_v]return context, attn ''' 這里要做的是，通過 Q 和 K 計算出 scores，然后將 scores 和 V 相乘，得到每個單詞的 context vector第一步是將 Q 和 K 的轉置相乘沒什么好說的，相乘之后得到的 scores 還不能立刻進行 softmax， 需要和 attn_mask 相加，把一些需要屏蔽的信息屏蔽掉， attn_mask 是一個僅由 True 和 False 組成的 tensor，并且一定會保證 attn_mask 和 scores 的維度四個值相同（不然無法做對應位置相加）mask 完了之后，就可以對 scores 進行 softmax 了。然后再與 V 相乘，得到 context '''7.4.3?PoswiseFeedForwardNet
用來提取特征的
class PoswiseFeedForwardNet(nn.Module):def __init__(self):super(PoswiseFeedForwardNet, self).__init__()self.fc = nn.Sequential(nn.Linear(d_model, d_ff, bias=False),nn.ReLU(),nn.Linear(d_ff, d_model, bias=False))def forward(self, inputs):'''inputs: [batch_size, seq_len, d_model]'''residual = inputsoutput = self.fc(inputs)return nn.LayerNorm(d_model).cuda()(output + residual) # [batch_size, seq_len, d_model]#也有殘差連接和layer normalization#這段代碼非常簡單，就是做兩次線性變換，殘差連接后再跟一個 Layer Norm8?decoder結構
8.1 decoder 結構（整體）
class Decoder(nn.Module):def __init__(self):super(Decoder, self).__init__()self.tgt_emb = nn.Embedding(tgt_vocab_size, d_model)self.pos_emb = PositionalEncoding(d_model)self.layers = nn.ModuleList([DecoderLayer() for _ in range(n_layers)])def forward(self, dec_inputs, enc_inputs, enc_outputs):''' dec_inputs: [batch_size, tgt_len] enc_intpus: [batch_size, src_len] enc_outputs: [batsh_size, src_len, d_model] 經過六次encoder之后得到的東西'''dec_outputs = self.tgt_emb(dec_inputs) # [batch_size, tgt_len, d_model] #同樣地，對decoder_layer進行詞向量的生成dec_outputs = self.pos_emb(dec_outputs.transpose(0, 1)).transpose(0, 1).cuda() #計算他的位置向量 # [batch_size, tgt_len, d_model]dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs).cuda() # [batch_size, tgt_len, tgt_len] #decoder的multi-head attention的mask（padding部分為True，其他為False）dec_self_attn_subsequence_mask = get_attn_subsequence_mask(dec_inputs).cuda() # [batch_size, tgt_len, tgt_len] #當前時刻我是看不到未來時刻的東西的，要把之后的部門mask掉（ #看不到的部分為True，看得到的部分為Falsedec_self_attn_mask = torch.gt((dec_self_attn_pad_mask + dec_self_attn_subsequence_mask), 0).cuda() # [batch_size, tgt_len, tgt_len]#布爾+int false 0 true 1，gt 大于 True #這樣把dec_self_attn_pad_mask和dec_self_attn_subsequence_mask里面為True的部分都剔除掉了 #也就是說，結果是所有需要被mask掉位置為True，不需要被mask掉的為Falsedec_enc_attn_mask = get_attn_pad_mask(dec_inputs, enc_inputs) # [batc_size, tgt_len, src_len] #在decoder的第二個attention里面使用dec_self_attns, dec_enc_attns = [], [] #decoder的兩個attention模塊for layer in self.layers:# dec_outputs: [batch_size, tgt_len, d_model], #dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len], #dec_enc_attn: [batch_size, h_heads, tgt_len, src_len]dec_outputs, dec_self_attn, dec_enc_attn = \layer(dec_outputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask)dec_self_attns.append(dec_self_attn)dec_enc_attns.append(dec_enc_attn)return dec_outputs, dec_self_attns, dec_enc_attns8.2 DecoderLayer
class DecoderLayer(nn.Module):def __init__(self):super(DecoderLayer, self).__init__()self.dec_self_attn = MultiHeadAttention()self.dec_enc_attn = MultiHeadAttention()self.pos_ffn = PoswiseFeedForwardNet()def forward(self, dec_inputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask):''' dec_inputs: [batch_size, tgt_len, d_model] enc_outputs: [batch_size, src_len, d_model] dec_self_attn_mask: [batch_size, tgt_len, tgt_len] dec_enc_attn_mask: [batch_size, tgt_len, src_len]'''dec_outputs, dec_self_attn = self.dec_self_attn(dec_inputs, dec_inputs, dec_inputs, dec_self_attn_mask) # dec_outputs: [batch_size, tgt_len, d_model], #dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len] #先是decoder的self-attentiondec_outputs, dec_enc_attn = self.dec_enc_attn(dec_outputs, enc_outputs, enc_outputs, dec_enc_attn_mask) # dec_outputs: [batch_size, tgt_len, d_model] # dec_enc_attn: [batch_size, h_heads, tgt_len, src_len] #再是encoder-decoder attention部分dec_outputs = self.pos_ffn(dec_outputs) # [batch_size, tgt_len, d_model] #特征提取return dec_outputs, dec_self_attn, dec_enc_attn #在 Decoder Layer 中會調用兩次 MultiHeadAttention，第一次是計算 Decoder Input 的 self-attention，得到輸出 dec_outputs。 #然后將 dec_outputs 作為生成 Q 的元素，enc_outputs 作為生成 K 和 V 的元素，再調用一次8.2.1?get_attn_subsequence_mask
def get_attn_subsequence_mask(seq): #Subsequence Mask 只有 Decoder的self-attention會用到，主要作用是屏蔽未來時刻單詞的信息。'''seq: [batch_size, tgt_len] '''attn_shape = [seq.size(0), seq.size(1), seq.size(1)] #[batch_size, tgt_len, tgt_len]subsequence_mask = np.triu(np.ones(attn_shape), k=1) # Upper triangular matrix #首先通過 np.ones() 生成一個全 1 的方陣 #然后通過 np.triu() 生成一個上三角矩陣（對角線元素及其左下方全為0）subsequence_mask = torch.from_numpy(subsequence_mask).byte()#轉化成byte類型的tensorreturn subsequence_mask # [batch_size, tgt_len, tgt_len]''' s=torch.Tensor([[1,1,1],[3,5,1]]) get_attn_subsequence_mask(s)tensor([[[0, 1, 1],[0, 0, 1],[0, 0, 0]],[[0, 1, 1],[0, 0, 1],[0, 0, 0]]], dtype=torch.uint8) '''9 定義模型，損失函數和優化函數
model = Transformer().cuda() criterion = nn.CrossEntropyLoss(ignore_index=0) optimizer = optim.SGD(model.parameters(), lr=1e-3, momentum=0.99)10?進行訓練
for epoch in range(30):for enc_inputs, dec_inputs, dec_outputs in loader:'''enc_inputs: [batch_size, src_len]dec_inputs: [batch_size, tgt_len]dec_outputs: [batch_size, tgt_len]'''enc_inputs, dec_inputs, dec_outputs = enc_inputs.cuda(), dec_inputs.cuda(), dec_outputs.cuda()outputs, enc_self_attns, dec_self_attns, dec_enc_attns = model(enc_inputs, dec_inputs) # outputs: [batch_size * tgt_len, tgt_vocab_size] loss = criterion(outputs, dec_outputs.view(-1))print('Epoch:', '%04d' % (epoch + 1), 'loss =', '{:.6f}'.format(loss))optimizer.zero_grad()loss.backward()optimizer.step()''' Epoch: 0001 loss = 2.399018 Epoch: 0002 loss = 2.190828 Epoch: 0003 loss = 2.072805 Epoch: 0004 loss = 1.816573 Epoch: 0005 loss = 1.629891 Epoch: 0006 loss = 1.342404 Epoch: 0007 loss = 1.120496 Epoch: 0008 loss = 0.945255 Epoch: 0009 loss = 0.765375 Epoch: 0010 loss = 0.597852 Epoch: 0011 loss = 0.504108 Epoch: 0012 loss = 0.368425 Epoch: 0013 loss = 0.273608 Epoch: 0014 loss = 0.239933 Epoch: 0015 loss = 0.187699 Epoch: 0016 loss = 0.161942 Epoch: 0017 loss = 0.151922 Epoch: 0018 loss = 0.103952 Epoch: 0019 loss = 0.072388 Epoch: 0020 loss = 0.080190 Epoch: 0021 loss = 0.070481 Epoch: 0022 loss = 0.054710 Epoch: 0023 loss = 0.053659 Epoch: 0024 loss = 0.047746 Epoch: 0025 loss = 0.029473 Epoch: 0026 loss = 0.039323 Epoch: 0027 loss = 0.036756 Epoch: 0028 loss = 0.014491 Epoch: 0029 loss = 0.020453 Epoch: 0030 loss = 0.024998 '''11 測試結果
enc_inputs, dec_inputs,dec_outputs = next(iter(loader))predict, e_attn, d1_attn, d2_attn = model(enc_inputs[0].view(1, -1).cuda(), dec_inputs[0].view(1, -1).cuda())predict = predict.data.max(1, keepdim=True)[1]print(enc_inputs[0], '->', [idx2word[n.item()] for n in predict.squeeze()]) #tensor([1, 2, 3, 5, 0]) -> ['i', 'want', 'a', 'coke', '.', 'E']''' e_attn的形狀[6,8,5,5] 六層 8頭 5*5 d1_attn的形狀[6,8,6,6] 六層 8頭 6*6（decoder自己的attention） d2_attn的形狀[6,8,6,5] 六層 8頭 6*5'''12 可視化attention
我們以encoder 最后一層的attention為例：
x=e_attn[-1].view(8,5,5) import seaborn import matplotlib.pyplot as plt for i in range(8):plt.title('head'+str(i))seaborn.heatmap(x[i].data.cpu(),cmap='Blues')plt.show()13 整體代碼
#導入庫 import math import torch import numpy as np import torch.nn as nn import torch.optim as optim import torch.utils.data as Data#***********************************************# #數據集處理 # S: Symbol that shows starting of decoding input # E: Symbol that shows endng of decoding output # P: Symbol that will fill in blank sequence if current batch data size is short than time steps sentences = [# enc_input dec_input dec_output['ich mochte ein bier', 'S i want a beer .', 'i want a beer . E'],['ich mochte ein cola', 'S i want a coke .', 'i want a coke . E'] ] #encoder input和decoder input就不用說了，分別是transformer中encoder和decoder的輸入 #decoder output就是我們理論上需要輸出的東西（ground truth）（預測的句子和這個進行比對，算loss） #這里的輸入數據集只是兩對英德句子，每個字的索引（vocab）也是手動編碼上去的 src_vocab = {'P' : 0, 'ich' : 1, 'mochte' : 2, 'ein' : 3, 'bier' : 4, 'cola' : 5} # Padding Should be Zero #每一個batch里面的句子長度是一樣的，那么不足的部分就需要補Padding src_vocab_size = len(src_vocab)tgt_vocab = {'P' : 0, 'i' : 1, 'want' : 2, 'a' : 3, 'beer' : 4, 'coke' : 5, 'S' : 6, 'E' : 7, '.' : 8} idx2word = {i: w for i, w in enumerate(tgt_vocab)}tgt_vocab_size = len(tgt_vocab)#***********************************************# #參數定義4 src_len = 5 # enc_input max sequence length #encoder 輸入的句子的長度（不足的部分補padding） tgt_len = 6 # dec_input(=dec_output) max sequence length #decoder輸出的目標句子的長度（算上起始符S和終止符E之后）#***********************************************# #transformer的參數 # Transformer Parameters d_model = 512 #每一個詞的 word embedding 用多少位表示 #（包括positional encoding應該用多少位表示，因為這兩個要維度相加，應該是一樣的維度） d_ff = 2048 # FeedForward dimension #forward線性層變成多少位(d_model->d_ff->d_model) d_k = d_v = 64 # dimension of K(=Q), V #K，Q，V矩陣的維度（K和Q一定是一樣的，因為要K乘Q的轉置），V不一定 ''' 換一種說法，就是我在進行self-attention的時候， 從input（當然是加了位置編碼之后的input）線性變換之后的三個向量 K，Q，V的維度 ''' n_layers = 6 #encoder和decoder各有多少層 n_heads = 8 #multi-head attention有幾個頭 #***********************************************##數據預處理 # 將encoder_input、decoder_input和decoder_output進行id化def make_data(sentences):enc_inputs, dec_inputs, dec_outputs = [], [], []for i in range(len(sentences)):#對于輸入的每一句話enc_input = [src_vocab[n] for n in sentences[i][0].split()]# 每一次生成這一行sentence中encoder_input對應的id編碼for _ in range(src_len-len(enc_input)):enc_input.append(0)dec_input = [tgt_vocab[n] for n in sentences[i][1].split()]# 每一次生成這一行sentence中decoder_input對應的id編碼for _ in range(tgt_len-len(dec_input)):dec_input.append(0)dec_output = [tgt_vocab[n] for n in sentences[i][2].split()]# 每一次生成這一行sentence中decoder_output對應的id編碼for _ in range(tgt_len-len(dec_output)):dec_output.append(0)#分別對encoder-input、decoder-input、decoder-output進行處理，分別放到一個list里面enc_inputs.append(enc_input)dec_inputs.append(dec_input)dec_outputs.append(dec_output)return torch.LongTensor(enc_inputs), torch.LongTensor(dec_inputs), torch.LongTensor(dec_outputs)enc_inputs, dec_inputs, dec_outputs = make_data(sentences) #***********************************************#class MyDataSet(Data.Dataset):def __init__(self, enc_inputs, dec_inputs, dec_outputs):super(MyDataSet, self).__init__()self.enc_inputs = enc_inputsself.dec_inputs = dec_inputsself.dec_outputs = dec_outputsdef __len__(self):return self.enc_inputs.shape[0]#有幾個sentencedef __getitem__(self, idx):return self.enc_inputs[idx], self.dec_inputs[idx], self.dec_outputs[idx]#根據索引找encoder_input,decoder_input,decoder_outputloader = Data.DataLoader(MyDataSet(enc_inputs, dec_inputs, dec_outputs), batch_size=2, shuffle=True)#***********************************************# class PositionalEncoding(nn.Module):def __init__(self, d_model, dropout=0.1, max_len=5000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(p=dropout)#max_length_（一個sequence的最大長度）pe = torch.zeros(max_len, d_model)#pe [max_len,d_model]position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)#position [max_len，1]div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))#div_term:[d_model/2]#e^(-i*log10000/d_model)=10000^(-i/d_model)#d_model為embedding_dimension#兩個相乘的維度為[max_len,d_model/2] pe[:, 0::2] = torch.sin(position * div_term)pe[:, 1::2] = torch.cos(position * div_term)#計算position encoding#pe的維度為[max_len,d_model],每一行的奇數偶數分別取sin和cos(position * div_term)里面的值pe = pe.unsqueeze(0).transpose(0, 1)#維度變成(max_len,1,d_model)#所以直接用pe=pe.unsqueeze(1)也可以self.register_buffer('pe', pe)#放入buffer中，參數不會訓練def forward(self, x):'''x: [seq_len, batch_size, d_model]'''x = x + self.pe[:x.size(0), :,:]#選取和x一樣維度的seq_length，將pe加到x上return self.dropout(x) #***********************************************# #由于在 Encoder 和 Decoder 中都需要進行 mask 操作， #因此就無法確定這個函數的參數中 seq_len 的值， #如果是在 Encoder 中調用的，seq_len 就等于 src_len #如果是在 Decoder 中調用的，seq_len 就有可能等于 src_len， #也有可能等于 tgt_len（因為 Decoder 有兩次 mask） #src_len 是在encoder-decoder中的mask #tgt_len是decdoer maskdef get_attn_pad_mask(seq_q, seq_k):#對于seq_q中的每一個元素，它都會和seq_k中的每一個元素有著一個相關聯系數，這個系數組成一個矩陣：#但是因為pad的存在，pad的這些地方是不參與我們attention的計算的，那么就是我們這里要返回的東西就是輔助得到哪些位是pad'''seq_q: [batch_size, seq_len]seq_k: [batch_size, seq_len]seq_len could be src_len or it could be tgt_lenseq_len in seq_q and seq_len in seq_k maybe not equal'''#pad的位置標記上Truebatch_size, len_q = seq_q.size()batch_size, len_k = seq_k.size()#seq_q:[[1,2,3,4,0],[1,2,4,5,0]] ->pad_attn_mask [[F,F,F,F,T],[F,F,F,F,T]]#擴展一個維度，因為word embedding是三維的pad_attn_mask = seq_k.data.eq(0).unsqueeze(1) # pad_attn_mask [batch_size, 1, len_k], False is masked#通過seq_k.data.eq(0),判斷哪些位是pad（pad的編碼為0）#舉個例子，輸入為 seq_data = [1, 2, 3, 4, 0]，seq_data.data.eq(0) 就會返回 [False, False, False, False, True]return pad_attn_mask.expand(batch_size, len_q, len_k) #對于每一個batch_size對應的一行，都擴充為len_q行# [batch_size, len_q, len_k] #***********************************************# def get_attn_subsequence_mask(seq): #Subsequence Mask 只有 Decoder的self-attention會用到，主要作用是屏蔽未來時刻單詞的信息。'''seq: [batch_size, tgt_len]'''attn_shape = [seq.size(0), seq.size(1), seq.size(1)]#[batch_size, tgt_len, tgt_len]subsequence_mask = np.triu(np.ones(attn_shape), k=1) # Upper triangular matrix#首先通過 np.ones() 生成一個全 1 的方陣，然后通過 np.triu() 生成一個上三角矩陣（對角線元素及其左下方全為0）subsequence_mask = torch.from_numpy(subsequence_mask).byte()#轉化成byte類型的tensorreturn subsequence_mask # [batch_size, tgt_len, tgt_len] #***********************************************# class ScaledDotProductAttention(nn.Module):def __init__(self):super(ScaledDotProductAttention, self).__init__()def forward(self, Q, K, V, attn_mask):'''Q: [batch_size, n_heads, len_q, d_k]K: [batch_size, n_heads, len_k, d_k]V: [batch_size, n_heads, len_v(=len_k), d_v]attn_mask: [batch_size, n_heads, seq_len, seq_len]'''scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k) # scores : [batch_size, n_heads, len_q, len_k]scores.masked_fill_(attn_mask, -1e9) #attn_mask所有為True的部分（即有pad的部分），scores填充為負無窮，也就是這個位置的值對于softmax沒有影響attn = nn.Softmax(dim=-1)(scores) #attn： [batch_size, n_heads, len_q, len_k]#對每一行進行softmaxcontext = torch.matmul(attn, V) # [batch_size, n_heads, len_q, d_v]return context, attn ''' 這里要做的是，通過 Q 和 K 計算出 scores，然后將 scores 和 V 相乘，得到每個單詞的 context vector第一步是將 Q 和 K 的轉置相乘沒什么好說的，相乘之后得到的 scores 還不能立刻進行 softmax， 需要和 attn_mask 相加，把一些需要屏蔽的信息屏蔽掉， attn_mask 是一個僅由 True 和 False 組成的 tensor，并且一定會保證 attn_mask 和 scores 的維度四個值相同（不然無法做對應位置相加）mask 完了之后，就可以對 scores 進行 softmax 了。然后再與 V 相乘，得到 context ''' #***********************************************# class MultiHeadAttention(nn.Module):def __init__(self):super(MultiHeadAttention, self).__init__()self.W_Q = nn.Linear(d_model, d_k * n_heads, bias=False)self.W_K = nn.Linear(d_model, d_k * n_heads, bias=False)self.W_V = nn.Linear(d_model, d_v * n_heads, bias=False)#三個矩陣，分別對輸入進行三次線性變化self.fc = nn.Linear(n_heads * d_v, d_model, bias=False)#變換維度def forward(self, input_Q, input_K, input_V, attn_mask):'''input_Q: [batch_size, len_q, d_model]input_K: [batch_size, len_k, d_model]input_V: [batch_size, len_v(=len_k), d_model]attn_mask: [batch_size, seq_len, seq_len]'''residual, batch_size = input_Q, input_Q.size(0)# [batch_size, len_q, d_model]#(W)-> [batch_size, len_q,d_k * n_heads]#(view)->[batch_size, len_q,n_heads,d_k]#(transpose)-> [batch_size,n_heads, len_q,d_k ]Q = self.W_Q(input_Q).view(batch_size, -1, n_heads, d_k).transpose(1,2) K = self.W_K(input_K).view(batch_size, -1, n_heads, d_k).transpose(1,2) V = self.W_V(input_V).view(batch_size, -1, n_heads, d_v).transpose(1,2) #生成Q，K，V矩陣attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1) # attn_mask : [batch_size, n_heads, seq_len, seq_len]context, attn = ScaledDotProductAttention()(Q, K, V, attn_mask)# context: [batch_size, n_heads, len_q, d_v],#attn: [batch_size, n_heads, len_q, len_k]context = context.transpose(1, 2).reshape(batch_size, -1, n_heads * d_v) # context: [batch_size, len_q, n_heads * d_v]output = self.fc(context) # [batch_size, len_q, d_model]return nn.LayerNorm(d_model).cuda()(output + residual), attn ''' 完整代碼中一定會有三處地方調用 MultiHeadAttention()，Encoder Layer 調用一次， 傳入的 input_Q、input_K、input_V 全部都是 enc_inputs； Decoder Layer 中兩次調用，第一次都是decoder_inputs；第二次是兩個encoder_outputs和一個decoder——input ''' #***********************************************# class PoswiseFeedForwardNet(nn.Module):def __init__(self):super(PoswiseFeedForwardNet, self).__init__()self.fc = nn.Sequential(nn.Linear(d_model, d_ff, bias=False),nn.ReLU(),nn.Linear(d_ff, d_model, bias=False))def forward(self, inputs):'''inputs: [batch_size, seq_len, d_model]'''residual = inputsoutput = self.fc(inputs)return nn.LayerNorm(d_model).cuda()(output + residual) # [batch_size, seq_len, d_model]#也有殘差連接和layer normalization#這段代碼非常簡單，就是做兩次線性變換，殘差連接后再跟一個 Layer Norm #***********************************************# class EncoderLayer(nn.Module):def __init__(self):super(EncoderLayer, self).__init__()self.enc_self_attn = MultiHeadAttention()#多頭注意力機制self.pos_ffn = PoswiseFeedForwardNet()#提取特征def forward(self, enc_inputs, enc_self_attn_mask):'''enc_inputs: [batch_size, src_len, d_model]enc_self_attn_mask: [batch_size, src_len, src_len]'''# enc_outputs: [batch_size, src_len, d_model], #attn: [batch_size, n_heads, src_len, src_len] 每一個投一個注意力矩陣enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask) # enc_inputs to same Q,K,V#乘以WQ，WK，WV生成QKV矩陣（為什么傳三個？因為這里傳的是一樣的#但在decoder-encoder的mulit-head里面，我們需要的decoder input encoder output encoder output#所以為了使用方便，我們在定義enc_self_atten函數的時候就定義的使有三個形參的enc_outputs = self.pos_ffn(enc_outputs) # enc_outputs: [batch_size, src_len, d_model]#輸入和輸出的維度是一樣的return enc_outputs, attn #將上述組件拼起來，就是一個完整的 Encoder Layer #***********************************************# class DecoderLayer(nn.Module):def __init__(self):super(DecoderLayer, self).__init__()self.dec_self_attn = MultiHeadAttention()self.dec_enc_attn = MultiHeadAttention()self.pos_ffn = PoswiseFeedForwardNet()def forward(self, dec_inputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask):'''dec_inputs: [batch_size, tgt_len, d_model]enc_outputs: [batch_size, src_len, d_model]dec_self_attn_mask: [batch_size, tgt_len, tgt_len]dec_enc_attn_mask: [batch_size, tgt_len, src_len]'''# dec_outputs: [batch_size, tgt_len, d_model], dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len]dec_outputs, dec_self_attn = self.dec_self_attn(dec_inputs, dec_inputs, dec_inputs, dec_self_attn_mask)# dec_outputs: [batch_size, tgt_len, d_model], dec_enc_attn: [batch_size, h_heads, tgt_len, src_len]#先是decoder的self-attentiondec_outputs, dec_enc_attn = self.dec_enc_attn(dec_outputs, enc_outputs, enc_outputs, dec_enc_attn_mask)#再是encoder-decoder attention部分dec_outputs = self.pos_ffn(dec_outputs) # [batch_size, tgt_len, d_model]#特征提取return dec_outputs, dec_self_attn, dec_enc_attn #在 Decoder Layer 中會調用兩次 MultiHeadAttention，第一次是計算 Decoder Input 的 self-attention，得到輸出 dec_outputs。 #然后將 dec_outputs 作為生成 Q 的元素，enc_outputs 作為生成 K 和 V 的元素，再調用一次 MultiHeadAttention，得到的是 Encoder 和 Decoder Layer 之間的 context vector。最后將 dec_outptus 做一次維度變換，然后返回 #***********************************************# class Encoder(nn.Module):def __init__(self):super(Encoder, self).__init__()self.src_emb = nn.Embedding(src_vocab_size, d_model)#對encoder的輸入的每個單詞進行詞向量計算詞向量/字向量（src——vocab_size個詞，每個詞d_model的維度)self.pos_emb = PositionalEncoding(d_model)#計算位置向量self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])#將6個EncoderLayer組成一個moduledef forward(self, enc_inputs):'''enc_inputs: [batch_size, src_len]'''enc_outputs = self.src_emb(enc_inputs) #對每個單詞進行詞向量計算#enc_outputs [batch_size, src_len, d_model]enc_outputs = self.pos_emb(enc_outputs.transpose(0, 1)).transpose(0, 1) #添加位置編碼# enc_outputs [batch_size, src_len, d_model]enc_self_attn_mask = get_attn_pad_mask(enc_inputs, enc_inputs) # enc_self_attn: [batch_size, src_len, src_len]#計算得到encoder-attention的pad martixenc_self_attns = []#創建一個列表，保存接下來要返回的字-字attention的值，不參與任何計算，供可視化用for layer in self.layers:# enc_outputs: [batch_size, src_len, d_model]# enc_self_attn: [batch_size, n_heads, src_len, src_len]enc_outputs, enc_self_attn = layer(enc_outputs, enc_self_attn_mask)enc_self_attns.append(enc_self_attn)#再傳進來就不用positional decoding#記錄下每一次的attentionreturn enc_outputs, enc_self_attns#使用 nn.ModuleList() 里面的參數是列表，列表里面存了 n_layers 個 Encoder Layer#由于我們控制好了 Encoder Layer 的輸入和輸出維度相同，所以可以直接用個 for 循環以嵌套的方式， #將上一次 Encoder Layer 的輸出作為下一次 Encoder Layer 的輸入#***********************************************# class Decoder(nn.Module):def __init__(self):super(Decoder, self).__init__()self.tgt_emb = nn.Embedding(tgt_vocab_size, d_model)self.pos_emb = PositionalEncoding(d_model)self.layers = nn.ModuleList([DecoderLayer() for _ in range(n_layers)])def forward(self, dec_inputs, enc_inputs, enc_outputs):'''dec_inputs: [batch_size, tgt_len]enc_intpus: [batch_size, src_len]enc_outputs: [batsh_size, src_len, d_model] 經過六次encoder之后得到的東西'''dec_outputs = self.tgt_emb(dec_inputs) # [batch_size, tgt_len, d_model]#同樣地，對decoder_layer進行詞向量的生成dec_outputs = self.pos_emb(dec_outputs.transpose(0, 1)).transpose(0, 1).cuda() #計算他的位置向量# [batch_size, tgt_len, d_model]dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs).cuda() # [batch_size, tgt_len, tgt_len]dec_self_attn_subsequence_mask = get_attn_subsequence_mask(dec_inputs).cuda() # [batch_size, tgt_len, tgt_len]#當前時刻我是看不到未來時刻的東西的dec_self_attn_mask = torch.gt((dec_self_attn_pad_mask + dec_self_attn_subsequence_mask), 0).cuda() # [batch_size, tgt_len, tgt_len]#布爾+int false 0 true 1，gt 大于 True#這樣把dec_self_attn_pad_mask和dec_self_attn_subsequence_mask里面為True的部分都剔除掉了#也就是說，即屏蔽掉了pad也屏蔽掉了maskdec_enc_attn_mask = get_attn_pad_mask(dec_inputs, enc_inputs) # [batc_size, tgt_len, src_len]#在decoder的第二個attention里面使用dec_self_attns, dec_enc_attns = [], []for layer in self.layers:# dec_outputs: [batch_size, tgt_len, d_model], #dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len], #dec_enc_attn: [batch_size, h_heads, tgt_len, src_len]dec_outputs, dec_self_attn, dec_enc_attn = \layer(dec_outputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask)dec_self_attns.append(dec_self_attn)dec_enc_attns.append(dec_enc_attn)return dec_outputs, dec_self_attns, dec_enc_attns #***********************************************# class Transformer(nn.Module):def __init__(self):super(Transformer, self).__init__()self.encoder = Encoder().cuda()self.decoder = Decoder().cuda()self.projection = nn.Linear(d_model, tgt_vocab_size, bias=False).cuda()#對decoder的輸出轉換維度，#從隱藏層維數->英語單詞詞典大小（選取概率最大的那一個，作為我們的預測結果）def forward(self, enc_inputs, dec_inputs):'''enc_inputs維度：[batch_size, src_len] 對encoder-input，我一個batch中有幾個sequence，一個sequence有幾個字dec_inputs: [batch_size, tgt_len] 對decoder-input，我一個batch中有幾個sequence，一個sequence有幾個字'''# enc_outputs: [batch_size, src_len, d_model]，# d_model是每一個字的word embedding長度"""enc_self_attns: [n_layers, batch_size, n_heads, src_len, src_len]注意力矩陣，對encoder和decoder，每一層，每一句話，每一個頭，每兩個字之間都有一個權重系數，這些權重系數組成了注意力矩陣(之后的dec_self_attns同理，當然decoder還有一個decoder-encoder的矩陣)"""enc_outputs, enc_self_attns = self.encoder(enc_inputs)# dec_outpus: [batch_size, tgt_len, d_model],#dec_self_attns: [n_layers, batch_size, n_heads, tgt_len, tgt_len], #dec_enc_attn: [n_layers, batch_size, tgt_len, src_len]dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(dec_inputs, enc_inputs, enc_outputs)dec_logits = self.projection(dec_outputs) #將輸出的維度，從 [batch_size, tgt_len, d_model]變成[batch_size, tgt_len, tgt_vocab_size]# dec_logits: [batch_size, tgt_len, tgt_vocab_size]return dec_logits.view(-1, dec_logits.size(-1)), enc_self_attns, dec_self_attns, dec_enc_attns #dec_logits 的維度是 [batch_size * tgt_len, tgt_vocab_size]，可以理解為， #一個句子，這個句子有 batch_size*tgt_len 個單詞，每個單詞有 tgt_vocab_size 種情況，取概率最大者#Transformer 主要就是調用 Encoder 和 Decoder。最后返回 #***********************************************# model = Transformer().cuda() criterion = nn.CrossEntropyLoss(ignore_index=0) optimizer = optim.SGD(model.parameters(), lr=1e-3, momentum=0.99) #***********************************************# for epoch in range(30):for enc_inputs, dec_inputs, dec_outputs in loader:'''enc_inputs: [batch_size, src_len]dec_inputs: [batch_size, tgt_len]dec_outputs: [batch_size, tgt_len]'''enc_inputs, dec_inputs, dec_outputs = enc_inputs.cuda(), dec_inputs.cuda(), dec_outputs.cuda()# outputs: [batch_size * tgt_len, tgt_vocab_size]outputs, enc_self_attns, dec_self_attns, dec_enc_attns = model(enc_inputs, dec_inputs)loss = criterion(outputs, dec_outputs.view(-1))print('Epoch:', '%04d' % (epoch + 1), 'loss =', '{:.6f}'.format(loss))optimizer.zero_grad()loss.backward()optimizer.step()enc_inputs, dec_inputs,dec_outputs = next(iter(loader)) predict, e_attn, d1_attn, d2_attn = model(enc_inputs[0].view(1, -1).cuda(), dec_inputs[0].view(1, -1).cuda()) predict = predict.data.max(1, keepdim=True)[1] print(enc_inputs[0], '->', [idx2word[n.item()] for n in predict.squeeze()])?
總結
以上是生活随笔為你收集整理的pytorch 实现transformer的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 文巾解题 16. 最接近的三数之和
- 下一篇： 文巾解题 67. 二进制求和