transformer--transformer模型構建和測試

前面幾節進行了各種組件的學習和編碼，本節將組件組成transformer，并對其進行測試?

EncoderDecoder 編碼器解碼器構建

使用EnconderDecoder實現編碼器-解碼器結構

 # 使用EncoderDeconder類實現編碼器和解碼器class EncoderDecoder(nn.Module):def __init__(self, encoder, decoder, sourc_embed, target_embed, generator) -> None:"""encoder: 編碼器對象decoder: 解碼器對象sourc_embed: 源數據嵌入函數target_embed: 目標數據嵌入函數generator: 輸出部分的類別生成器"""super(EncoderDecoder,self).__init__()self.encoder = encoderself.decoder = decoderself.src_embed = sourc_embedself.tgt_embed = target_embedself.generator = generatordef encode(self,source, source_mask):"""source: 源數據source_mask: 源數據的mask"""return self.encoder(self.src_embed(source), source_mask)def decode(self, memory, source_mask, target,target_mask):return self.decoder(self.tgt_embed(target), memory, source_mask,target_mask)def forward(self,source, target, source_mask, target_mask):return self.decode(self.encode(source, source_mask), source_mask,target,target_mask)

測試代碼放在最后，測試結果如下：

ed_result.shape:  torch.Size([2, 4, 512])
ed_result:  tensor([[[ 2.2391, -0.1173, -1.0894,  ...,  0.9693, -0.9286, -0.4191],[ 1.4016,  0.0187, -0.0564,  ...,  0.9323,  0.0403, -0.5115],[ 1.3623,  0.0854, -0.7648,  ...,  0.9763,  0.6179, -0.1512],[ 1.6840, -0.3144, -0.6535,  ...,  0.7420,  0.0729, -0.2303]],[[ 0.8726, -0.1610, -0.0819,  ..., -0.6603,  2.1003, -0.4165],[ 0.5404,  0.8091,  0.8205,  ..., -1.4623,  2.5762, -0.6019],[ 0.9892, -0.3134, -0.4118,  ..., -1.1656,  1.0373, -0.3784],[ 1.3170,  0.3997, -0.3412,  ..., -0.6014,  0.7564, -1.0851]]],grad_fn=<AddBackward0>)

Transformer模型構建

# Tansformer模型的構建過程代碼
def make_model(source_vocab, target_vocab, N=6,d_model=512, d_ff=2048, head=8, dropout=0.1):"""該函數用來構建模型，有7個參數，分別是源數據特征(詞匯)總數，目標數據特征(詞匯)總數，編碼器和解碼器堆疊數，詞向量映射維度，前饋全連接網絡中變換矩陣的維度，多頭注意力結構中的多頭數，以及置零比率dropout"""c = copy.deepcopy#實例化多頭注意力attn = MultiHeadedAttention(head, d_mode)# 實例化前饋全連接層 得到對象ffff = PositionalEncoding(d_mode, dropout)# 實例化位置編碼類，得到對象positionposition = PositionalEncoding(d_mode,dropout)# 根據結構圖，最外層是EncoderDecoder，在EncoderDecoder中，# 分別是編碼器層，解碼器層，源數據Embedding層和位置編碼組成的有序結構# 目標數據Embedding層和位置編碼組成的有序結構，以及類別生成器層。在編碼器層中有attention子層以及前饋全連接子層，# 在解碼器層中有兩個attention子層以及前饋全連接層model  =EncoderDecoder(Encoder(EncoderLayer(d_mode, c(attn), c(ff), dropout),N),Decoder(DecoderLayer(d_mode, c(attn), c(attn),c(ff),dropout),N),nn.Sequential(Embeddings(d_mode,source_vocab), c(position)),nn.Sequential(Embeddings(d_mode, target_vocab), c(position)),Generator(d_mode, target_vocab))# 模型結構完成后，接下來就是初始化模型中的參數，比如線性層中的變換矩陣,這里一但判斷參數的維度大于1，# 則會將其初始化成一個服從均勻分布的矩陣for p in model.parameters():if p.dim()>1:nn.init.xavier_uniform(p)return model

測試代碼

 
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
import matplotlib.pyplot as plt
import math
import copy 
from inputs import Embeddings,PositionalEncoding
from encoder import  subsequent_mask,attention,clones,MultiHeadedAttention,PositionwiseFeedForward,LayerNorm,SublayerConnection,Encoder,EncoderLayer
# encode 代碼在前面幾節# 解碼器層的類實現
class DecoderLayer(nn.Module):def __init__(self, size, self_attn, src_attn, feed_forward,dropout) -> None:"""size : 詞嵌入維度self_attn:多頭自注意對象，需要Q=K=Vsrc_attn:多頭注意力對象，這里Q!=K=Vfeed_forward: 前饋全連接層對象"""super(DecoderLayer,self).__init__()self.size = sizeself.self_attn = self_attnself.src_attn = src_attnself.feed_forward = feed_forward# 根據論文圖使用clones克隆三個子層對象self.sublayer = clones(SublayerConnection(size,dropout), 3)def forward(self, x, memory, source_mask, target_mask):"""x : 上一層的輸入memory: 來自編碼器層的語義存儲變量source_mask: 源碼數據掩碼張量，針對就是輸入到解碼器的數據target_mask: 目標數據掩碼張量,針對解碼器最后生成的數據，一個一個的推理生成的詞"""m = memory# 將x傳入第一個子層結構，第一個子層結構輸入分別是x和self_attn函數，因為是自注意力機制，所以Q=K=V=x# 最后一個參數是目標數據掩碼張量，這時要對目標數據進行掩碼，因為此時模型可能還沒有生成任何目標數據，# 比如在解碼器準備生成第一個字符或詞匯時，我們其實已經傳入第一個字符以便計算損失# 但是我們不希望在生成第一個字符時模型能利用這個信息，因為我們會將其遮掩，同樣生成第二個字符或詞匯時# 模型只能使用第一個字符或詞匯信息，第二個字符以及以后得信息都不允許被模型使用x = self.sublayer[0](x, lambda x: self.self_attn(x,x,x,target_mask))# 緊接著第一層的輸出進入第二個子層，這個子層是常規的注意力機制，但是q是輸入x；k、v是編碼層輸出memory# 同樣也傳入source_mask， 但是進行源數據遮掩的原因并非是抑制信息泄露，而是遮蔽掉對結果沒有意義的的字符而產生的注意力# 以此提升模型的效果和訓練速度，這樣就完成第二個子層的處理x = self.sublayer[1](x, lambda x: self.src_attn(x,m,m,source_mask))# 最后一個子層就是前饋全連接子層，經過他的處理后就可以返回結果，這就是解碼器層的結構return self.sublayer[2](x,self.feed_forward)# 解碼器
class Decoder(nn.Module):def __init__(self,layer,N) -> None:""" layer: 解碼器層， N：解碼器層的個數"""super(Decoder,self).__init__()self.layers = clones(layer,N)self.norm = LayerNorm(layer.size)def forward(self, x, memory,source_mask, target_mask):# x:目標數據的嵌入表示# memory：編碼器的輸出# source_mask: 源數據的掩碼張量# target_mask: 目標數據的掩碼張量for layer in self.layers:x = layer(x,memory,source_mask,target_mask)return self.norm(x)# 輸出
class Generator(nn.Module):def __init__(self,d_mode, vocab_size) -> None:"""d_mode: 詞嵌入vocab_size： 詞表大小"""super(Generator,self).__init__()self.project = nn.Linear(d_mode, vocab_size)def forward(self, x):return F.log_softmax(self.project(x),dim=-1)# 使用EncoderDeconder類實現編碼器和解碼器class EncoderDecoder(nn.Module):def __init__(self, encoder, decoder, sourc_embed, target_embed, generator) -> None:"""encoder: 編碼器對象decoder: 解碼器對象sourc_embed: 源數據嵌入函數target_embed: 目標數據嵌入函數generator: 輸出部分的類別生成器"""super(EncoderDecoder,self).__init__()self.encoder = encoderself.decoder = decoderself.src_embed = sourc_embedself.tgt_embed = target_embedself.generator = generatordef encode(self,source, source_mask):"""source: 源數據source_mask: 源數據的mask"""return self.encoder(self.src_embed(source), source_mask)def decode(self, memory, source_mask, target,target_mask):return self.decoder(self.tgt_embed(target), memory, source_mask,target_mask)def forward(self,source, target, source_mask, target_mask):return self.decode(self.encode(source, source_mask), source_mask,target,target_mask)# Tansformer模型的構建過程代碼
def make_model(source_vocab, target_vocab, N=6,d_model=512, d_ff=2048, head=8, dropout=0.1):"""該函數用來構建模型，有7個參數，分別是源數據特征(詞匯)總數，目標數據特征(詞匯)總數，編碼器和解碼器堆疊數，詞向量映射維度，前饋全連接網絡中變換矩陣的維度，多頭注意力結構中的多頭數，以及置零比率dropout"""c = copy.deepcopy#實例化多頭注意力attn = MultiHeadedAttention(head, d_mode)# 實例化前饋全連接層 得到對象ffff = PositionalEncoding(d_mode, dropout)# 實例化位置編碼類，得到對象positionposition = PositionalEncoding(d_mode,dropout)# 根據結構圖，最外層是EncoderDecoder，在EncoderDecoder中，# 分別是編碼器層，解碼器層，源數據Embedding層和位置編碼組成的有序結構# 目標數據Embedding層和位置編碼組成的有序結構，以及類別生成器層。在編碼器層中有attention子層以及前饋全連接子層，# 在解碼器層中有兩個attention子層以及前饋全連接層model  =EncoderDecoder(Encoder(EncoderLayer(d_mode, c(attn), c(ff), dropout),N),Decoder(DecoderLayer(d_mode, c(attn), c(attn),c(ff),dropout),N),nn.Sequential(Embeddings(d_mode,source_vocab), c(position)),nn.Sequential(Embeddings(d_mode, target_vocab), c(position)),Generator(d_mode, target_vocab))# 模型結構完成后，接下來就是初始化模型中的參數，比如線性層中的變換矩陣,這里一但判斷參數的維度大于1，# 則會將其初始化成一個服從均勻分布的矩陣for p in model.parameters():if p.dim()>1:nn.init.xavier_uniform(p)return modelif __name__ == "__main__":# 詞嵌入dim = 512vocab  =1000emb = Embeddings(dim,vocab)x = torch.LongTensor([[100,2,321,508],[321,234,456,324]])embr  =emb(x)print("embr.shape = ",embr.shape)# 位置編碼pe = PositionalEncoding(dim,0.1) # 位置向量的維度是20，dropout是0pe_result = pe(embr)print("pe_result.shape = ",pe_result.shape)# 編碼器測試size = 512dropout=0.2head=8d_model=512d_ff = 64c = copy.deepcopyx = pe_resultself_attn = MultiHeadedAttention(head,d_model,dropout)ff = PositionwiseFeedForward(d_model,d_ff,dropout)# 編碼器層不是共享的，因此需要深度拷貝layer= EncoderLayer(size,c(self_attn),c(ff),dropout)N=8mask = torch.zeros(8,4,4)en = Encoder(layer,N)en_result = en(x,mask)print("en_result.shape : ",en_result.shape)print("en_result : ",en_result)# 解碼器層測試size = 512dropout=0.2head=8d_model=512d_ff = 64self_attn = src_attn = MultiHeadedAttention(head,d_model,dropout)ff = PositionwiseFeedForward(d_model,d_ff,dropout)x = pe_resultmask = torch.zeros(8,4,4)source_mask = target_mask = maskmemory = en_resultdl = DecoderLayer(size,self_attn,src_attn,ff,dropout)dl_result = dl(x,memory,source_mask,target_mask)print("dl_result.shape = ", dl_result.shape)print("dl_result = ", dl_result)# 解碼器測試size = 512dropout=0.2head=8d_model=512d_ff = 64memory = en_resultc = copy.deepcopyx = pe_resultself_attn = MultiHeadedAttention(head,d_model,dropout)ff = PositionwiseFeedForward(d_model,d_ff,dropout)# 編碼器層不是共享的，因此需要深度拷貝layer= DecoderLayer(size,c(self_attn),c(self_attn),c(ff),dropout)N=8mask = torch.zeros(8,4,4)source_mask = target_mask = maskde = Decoder(layer,N)de_result = de(x,memory,source_mask, target_mask)print("de_result.shape : ",de_result.shape)print("de_result : ",de_result)# 輸出測試d_model = 512vocab =1000x = de_resultgen = Generator(d_mode=d_model,vocab_size=vocab)gen_result = gen(x)print("gen_result.shape :", gen_result.shape)print("gen_result: ", gen_result)# encoderdeconder 測試vocab_size = 1000d_mode = 512encoder = endecoder= desource_embed = nn.Embedding(vocab_size, d_mode)target_embed = nn.Embedding(vocab_size, d_mode)generator = gensource = target = torch.LongTensor([[100,2,321,508],[321,234,456,324]])source_mask = target_mask = torch.zeros(8,4,4)ed = EncoderDecoder(encoder, decoder, source_embed, target_embed, generator)ed_result = ed(source, target, source_mask, target_mask)print("ed_result.shape: ", ed_result.shape)print("ed_result: ", ed_result)# transformer 測試source_vocab = 11target_vocab = 11N=6# 其他參數使用默認值res = make_model(source_vocab, target_vocab,6)print(res)

打印模型層結構：

EncoderDecoder((encoder): Encoder((layers): ModuleList((0): EncoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(1): EncoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(2): EncoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(3): EncoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(4): EncoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(5): EncoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False)))))(norm): LayerNorm())(decoder): Decoder((layers): ModuleList((0): DecoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(src_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(2): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(1): DecoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(src_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(2): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(2): DecoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(src_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(2): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(3): DecoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(src_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(2): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(4): DecoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(src_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(2): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))))(5): DecoderLayer((self_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(src_attn): MultiHeadedAttention((linears): ModuleList((0): Linear(in_features=512, out_features=512, bias=True)(1): Linear(in_features=512, out_features=512, bias=True)(2): Linear(in_features=512, out_features=512, bias=True)(3): Linear(in_features=512, out_features=512, bias=True))(dropout): Dropout(p=0.1, inplace=False))(feed_forward): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False))(sublayer): ModuleList((0): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(1): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False))(2): SublayerConnection((norm): LayerNorm()(dropout): Dropout(p=0.1, inplace=False)))))(norm): LayerNorm())(src_embed): Sequential((0): Embeddings((lut): Embedding(11, 512))(1): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False)))(tgt_embed): Sequential((0): Embeddings((lut): Embedding(11, 512))(1): PositionalEncoding((dropout): Dropout(p=0.1, inplace=False)))(generator): Generator((project): Linear(in_features=512, out_features=11, bias=True))
)

測試Transformer運行

我們將通過一個小的copy任務完成模型的基本測試工作

copy任務介紹:

任務描述:

????????針對數字序列進行學習,學習的最終目標是使輸出與輸入的序列相同.如輸入[1,5,8,9,3],輸出也是[1,5,8,9,3].

任務意義:

copy任務在模型基礎測試中具有重要意義，因為copy操作對于模型來講是一條明顯規律,因此模型能否在短時間內，小數據集中學會它，可以幫助我們斷定模型所有過程是否正常，是否已具備基本學習能力.

使用copy任務進行模型基本測試的四步曲:

第一步: 構建數據集生成器
第二步: 獲得Transformer模型及其優化器和損失函數
第三步: 運行模型進行訓練和評估
第四步: 使用模型進行貪婪解碼

code

from transformer import make_model
import torch
import numpy as npfrom pyitcast.transformer_utils import Batch# 第一步: 構建數據集生成器
def data_generator(V, batch, num_batch):# 該函數用于隨機生成copy任務的數據，它的三個輸入參數是V:隨機生成數字的最大值+1，# batch:每次輸送給模型更新一次參數的數據量，num_batch:-共輸送num_batch次完成一輪for i in range(num_batch):data = torch.from_numpy(np.random.randint(1,V, size=(batch,10),dtype="int64"))data[:,0]=1source = torch.tensor(data,requires_grad=False)target = torch.tensor(data, requires_grad=False)yield Batch(source, target)# 第二步: 獲得Transformer模型及其優化器和損失函數
# 導入優化器工具包get_std_opt，該工具用于獲得標準的針對Transformer模型的優化器
# 該標準優化器基于Adam優化器，使其對序列到序列的任務更有效
from pyitcast.transformer_utils import get_std_opt
# 導入標簽平滑工具包，該工具用于標簽平滑，標簽平滑的作用就是小幅度的改變原有標簽值的值域
# 因為在理論上即使是人工的標注數據也可能并非完全正確，會受到一些外界因素的影響而產生一些微小的偏差
# 因此使用標簽平滑來彌補這種偏差，減少模型對某一條規律的絕對認知，以防止過擬合。通過下面示例了解更清晰
from pyitcast.transformer_utils import LabelSmoothing
# 導入損失計算工具包，該工具能夠使用標簽平滑后的結果進行損失的計算，
# 損失的計算方法可以認為是交叉熵損失函數。
from pyitcast.transformer_utils import SimpleLossCompute# 將生成0-10的整數
V = 11
# 每次喂給模型20個數據進行更新參數
batch = 20
# 連續喂30次完成全部數據的遍歷，也就是一輪
num_batch = 30# 使用make_model構建模型
model = make_model(V,V,N=2)
print(model.src_embed[0])
# 使用get_std_opt獲得模型優化器
model_optimizer = get_std_opt(model)
# 使用labelSmoothing獲得標簽平滑對象
# 使用LabelSmoothing實例化一個crit對象。
# 第一個參數size代表目標數據的詞匯總數，也是模型最后一層得到張量的最后一維大小
# 這里是5說明目標詞匯總數是5個，第二個參數padding_idx表示要將那些tensor中的數字
# 替換成0，一般padding_idx=0表示不進行替換。第三個參數smoothing，表示標簽的平滑程度
# 如原來標簽的表示值為1，則平滑后它的值域變為[1-smoothing，1+smoothing].
criterion = LabelSmoothing(size=V, padding_idx=0, smoothing=0.0)
# 使用SimpleLossCompute獲取到標簽平滑結果的損失計算方法
loss = SimpleLossCompute(model.generator,criterion,model_optimizer)# 第三步: 運行模型進行訓練和評估
from pyitcast.transformer_utils import run_epochdef run(model, loss, epochs=10):for epoch in range(epochs):# 進入訓練模式，所有參數更新model.train()# 訓練時batchsize是20run_epoch(data_generator(V,8,20),model,loss)model.eval()run_epoch(data_generator(V,8,5),model,loss)if __name__ == "__main__":# 將生成0-10的整數V = 11# 每次喂給模型20個數據進行更新參數batch = 20# 連續喂30次完成全部數據的遍歷，也就是一輪num_batch = 30res = data_generator(V,batch, num_batch)run(model, loss)

如果直接跑上面的可能會報錯，報錯的主要原因是?pyitcast主要是針對pytorch 的版本很低，但是好像這個庫也不升級了，所以你如果想要跑通，就需要修改下面兩個地方：

第一個錯誤：'Embeddings' object has no attribute 'd_model'

?從上面可以看到，get_std_opt需要用到嵌入向量的維度，但是沒有這個值，這個時候可以從兩個地方修改，一個是我們embeding的類增加這個屬性即：

第二種方法，直接進入?get_std_opt函數里面，修改這個參數

以上兩個都可以解決問題?

第二個問題：RuntimeError: scatter(): Expected dtype int64 for index

這個屬于數據類型的問題，主要是在生成訓練數據時的問題，如下修改：

這樣就可以正常訓練了?

輸出：

Epoch Step: 1 Loss: 3.169641 Tokens per Sec: 285.952789
Epoch Step: 1 Loss: 2.517479 Tokens per Sec: 351.509888
Epoch Step: 1 Loss: 2.595001 Tokens per Sec: 294.475616
Epoch Step: 1 Loss: 2.108872 Tokens per Sec: 476.050293
Epoch Step: 1 Loss: 2.229053 Tokens per Sec: 387.324188
Epoch Step: 1 Loss: 1.810681 Tokens per Sec: 283.639557
Epoch Step: 1 Loss: 2.047313 Tokens per Sec: 394.773773
Epoch Step: 1 Loss: 1.724596 Tokens per Sec: 415.394714
Epoch Step: 1 Loss: 1.850358 Tokens per Sec: 421.050873
Epoch Step: 1 Loss: 1.668582 Tokens per Sec: 368.275421
Epoch Step: 1 Loss: 2.005047 Tokens per Sec: 424.458466
Epoch Step: 1 Loss: 1.632835 Tokens per Sec: 408.158966
Epoch Step: 1 Loss: 1.698805 Tokens per Sec: 441.689392
Epoch Step: 1 Loss: 1.567691 Tokens per Sec: 392.488251
Epoch Step: 1 Loss: 1.765411 Tokens per Sec: 428.815796
Epoch Step: 1 Loss: 1.492155 Tokens per Sec: 426.288910
Epoch Step: 1 Loss: 1.541114 Tokens per Sec: 411.078918
Epoch Step: 1 Loss: 1.469818 Tokens per Sec: 454.231476
Epoch Step: 1 Loss: 1.677189 Tokens per Sec: 431.382690
Epoch Step: 1 Loss: 1.377327 Tokens per Sec: 433.725250

引入貪婪解碼，并進行了訓練測試

from transformer import make_model
import torch
import numpy as npfrom pyitcast.transformer_utils import Batch# 第一步: 構建數據集生成器
def data_generator(V, batch, num_batch):# 該函數用于隨機生成copy任務的數據，它的三個輸入參數是V:隨機生成數字的最大值+1，# batch:每次輸送給模型更新一次參數的數據量，num_batch:-共輸送num_batch次完成一輪for i in range(num_batch):data = torch.from_numpy(np.random.randint(1,V, size=(batch,10),dtype="int64"))data[:,0]=1source = torch.tensor(data,requires_grad=False)target = torch.tensor(data, requires_grad=False)yield Batch(source, target)# 第二步: 獲得Transformer模型及其優化器和損失函數
# 導入優化器工具包get_std_opt，該工具用于獲得標準的針對Transformer模型的優化器
# 該標準優化器基于Adam優化器，使其對序列到序列的任務更有效
from pyitcast.transformer_utils import get_std_opt
# 導入標簽平滑工具包，該工具用于標簽平滑，標簽平滑的作用就是小幅度的改變原有標簽值的值域
# 因為在理論上即使是人工的標注數據也可能并非完全正確，會受到一些外界因素的影響而產生一些微小的偏差
# 因此使用標簽平滑來彌補這種偏差，減少模型對某一條規律的絕對認知，以防止過擬合。通過下面示例了解更清晰
from pyitcast.transformer_utils import LabelSmoothing
# 導入損失計算工具包，該工具能夠使用標簽平滑后的結果進行損失的計算，
# 損失的計算方法可以認為是交叉熵損失函數。
from pyitcast.transformer_utils import SimpleLossCompute# 將生成0-10的整數
V = 11
# 每次喂給模型20個數據進行更新參數
batch = 20
# 連續喂30次完成全部數據的遍歷，也就是一輪
num_batch = 30# 使用make_model構建模型
model = make_model(V,V,N=2)# 使用get_std_opt獲得模型優化器
model_optimizer = get_std_opt(model)
# 使用labelSmoothing獲得標簽平滑對象
# 使用LabelSmoothing實例化一個crit對象。
# 第一個參數size代表目標數據的詞匯總數，也是模型最后一層得到張量的最后一維大小
# 這里是5說明目標詞匯總數是5個，第二個參數padding_idx表示要將那些tensor中的數字
# 替換成0，一般padding_idx=0表示不進行替換。第三個參數smoothing，表示標簽的平滑程度
# 如原來標簽的表示值為1，則平滑后它的值域變為[1-smoothing，1+smoothing].
criterion = LabelSmoothing(size=V, padding_idx=0, smoothing=0.0)
# 使用SimpleLossCompute獲取到標簽平滑結果的損失計算方法
loss = SimpleLossCompute(model.generator,criterion,model_optimizer)# 第三步: 運行模型進行訓練和評估
from pyitcast.transformer_utils import run_epochdef run(model, loss, epochs=10):for epoch in range(epochs):# 進入訓練模式，所有參數更新model.train()# 訓練時batchsize是20run_epoch(data_generator(V,8,20),model,loss)model.eval()run_epoch(data_generator(V,8,5),model,loss)# 引入貪婪解碼
# 導入貪婪解碼工具包greedy_decode，該工具將對最終結進行貪婪解碼貪婪解碼的方式是每次預測都選擇概率最大的結果作為輸出，
# 它不一定能獲得全局最優性，但卻擁有最高的執行效率。
from pyitcast.transformer_utils import greedy_decode     def run_greedy(model, loss, epochs=10):for epoch in range(epochs):# 進入訓練模式，所有參數更新model.train()# 訓練時batchsize是20run_epoch(data_generator(V,8,20),model,loss)model.eval()run_epoch(data_generator(V,8,5),model,loss)model.eval()# 假定輸入張量source = torch.LongTensor([[1,8,3,4,10,6,7,2,9,5]])# 定義源數據掩碼張量，因為元素都是1，在我們這里1代表不遮掩因此相當于對源數據沒有任何遮掩.source_mask = torch.ones(1,1,10)# 最后將model，src，src_mask，解碼的最大長度限制max_len，默認為10# 以及起始標志數字，默認為1，我們這里使用的也是1result = greedy_decode(model, source, source_mask, max_len=10,start_symbol=1)print(result)if __name__ == "__main__":# # 將生成0-10的整數# V = 11# # 每次喂給模型20個數據進行更新參數# batch = 20# # 連續喂30次完成全部數據的遍歷，也就是一輪# num_batch = 30# res = data_generator(V,batch, num_batch)# run(model, loss)run_greedy(model, loss,50)

輸出部分結果：

Epoch Step: 1 Loss: 0.428033 Tokens per Sec: 389.530670
Epoch Step: 1 Loss: 0.317753 Tokens per Sec: 399.060852
Epoch Step: 1 Loss: 0.192723 Tokens per Sec: 387.384308
Epoch Step: 1 Loss: 0.257650 Tokens per Sec: 379.354736
Epoch Step: 1 Loss: 0.487521 Tokens per Sec: 410.506714
Epoch Step: 1 Loss: 0.136969 Tokens per Sec: 388.222687
Epoch Step: 1 Loss: 0.119838 Tokens per Sec: 375.405731
Epoch Step: 1 Loss: 0.250391 Tokens per Sec: 408.776367
Epoch Step: 1 Loss: 0.376862 Tokens per Sec: 419.787231
Epoch Step: 1 Loss: 0.163561 Tokens per Sec: 393.896088
Epoch Step: 1 Loss: 0.303041 Tokens per Sec: 395.884857
Epoch Step: 1 Loss: 0.126261 Tokens per Sec: 386.709167
Epoch Step: 1 Loss: 0.237891 Tokens per Sec: 376.114075
Epoch Step: 1 Loss: 0.139017 Tokens per Sec: 405.207336
Epoch Step: 1 Loss: 0.414842 Tokens per Sec: 389.219666
Epoch Step: 1 Loss: 0.207141 Tokens per Sec: 392.840820
tensor([[ 1,  8,  3,  4, 10,  6,  7,  2,  9,  5]])

從上面的代碼可以看出測試輸入的是?source = torch.LongTensor([[1,8,3,4,10,6,7,2,9,5]])

推理出來的結果是完全正確的，因為我把epoch設置為50了，如果是10就會有錯誤的情況，大家可以嘗試