一、Transformer 解码器
1、Decoder 层实现
解码器层同编码器层一样，需要数据输入后创建Q、K、V向量，通过依据向量之间的关系，构建attention机制，实现decoder layer层的实现。
python
class DecoderLayer(nn.Module):
def __init__(self,size,self_atten,scr_atten,feed_forward,dropout=0.1):
super(DecoderLayer,self).__init__()
"""
其中初始化传入的参数有 self_attne == 多头自注意力机制 Q K V 相等
src_atten == 多头注意力机制 Q ！= K = V 普通的多头注意力机制
feed_forward == 前馈层 == 常规的前馈连接层
"""
self.size = size
self.self_attention = self_atten
self.scr_attention = scr_atten
self.feed_forward = feed_forward
self.sublayers = colon.colones(SublayerConnection(size,dropout),3)
def forward(self,x,memory,src_mask,tgt_mask):
# 传入的四个参数
"""
input == 输入的序列
memory == 编码器的输出张量==
src_mask == 编码器的mask == 在数据处理过程中将没有必要关注的信息进行mask处理
tgt_mask == 解码器的mask == 在解码的过程中将后面的信息进行mask
"""
# 自注意力机制
x = self.sublayers[0](x,lambda x:self.self_attention(x,x,x,tgt_mask))
# 常规注意力机制 Q ！= K = V
x = self.sublayers[1](x,lambda x:self.scr_attention(x,memory,memory,src_mask))
return self.sublayers[2](x,self.feed_forward)2、构建解码器
在解码器中，通过对解码器层的N次重复执行，从而构建解码器。解码器中，输入值为x ,memory，rc_mask,tgt_mask四个向量，通过对解码器层中self.layer进行遍历，对数据向量进行attention计算后，最后对数据进行标准化，进行数据的输出。
python
class Decoder(nn.Module):
def __init__(self,layer,N):
super(Decoder,self).__init__()
"""
# layer == 解码器层 实例化对象
"""
self.layers = colon.colones(layer,N)
self.norm = LayerNorm(layer.size) # 初始化标准化层
def forward(self,x,memory,src_mask,tgt_mask):
# src_mask == 原数据的mask张量
# tgt_mask == 解码器的mask张量
for layer in self.layers:
x = layer(x,memory,src_mask,tgt_mask)
return self.norm(x)3、数据生成器
数据输出层 ,构建数据全连接层，采用softmax激活后进行数据的输出。
python
class Genertor(nn.Module):
def __init__(self,embedding_dim,vocab_size):
super(Genertor,self).__init__()
"""
embedding_dim: 词嵌入的维度
vocab_size: 词表大小
"""
self.embedding_dim = embedding_dim
self.vocab_size = vocab_size
self.linear = nn.Linear(embedding_dim,vocab_size) # 构建线性层
def forward(self,x):
x = self.linear(x)
return F.log_softmax(x,dim=-1)二、Transformer model 类整体构建
python
class EncoderDecoder(nn.Module):
def __init__(self,encoder,decoder,src_embed,tgt_embed,generator):
super(EncoderDecoder,self).__init__()
"""
实现完整的transformer模型
encoder:编码器
decoder:解码器
src_embed:编码器的词向量 ===> 代表源数据的词嵌入函数
tgt_embed:解码器的词向量 ===> 代表输出数据的词嵌入函数 embedding
generator:输出层
"""
self.encoder = encoder
self.decoder = decoder
self.src_embed = src_embed
self.tgt_embed = tgt_embed
self.generator = generator
def forward(self,source,target,source_mask,target_mask):
# source target 没有经过词嵌入的初始输入数据与target数据
# source_mask 原数据的掩码张量
# target_mask 目标数据的掩码张量
return self.decode(self.encode(source,source_mask),source_mask,target,target_mask)
def encode(self,source,source_mask):
# encoder 输入 source(经过词嵌入后的张量) source_mask
return self.encoder(self.src_embed(source),source_mask)
def decode(self,memory,source_mask,target,target_mask):
# memory == 经过编码器编码后的输出张量
# decoder 输入 input memory source_mask target_mask
return self.decoder(self.tgt_embed(target),memory,source_mask,target_mask)
python
def make_model(src_vocab,tgt_vocab,N=6,M=6,d_model=512,d_ff=64,head=8,dropout=0.1):
"""
src_vocab 原数据的词表大小
tgt_vocab 输出数据的词表大小
d_model 表示词嵌入词表的维度
d_ff:表示全连接层隐藏层的维度
"""
c = copy.deepcopy
# 初始化实例对象
self_atten =src_atten = MultiHeadedAttention(head,d_model)
feed_forward = PositionwiseFeedForward(d_model,d_ff,dropout)
# 实例化位置编码器
position = PositionalEncoding(d_model,dropout)
# 实例化 model 模型
"""
编码器中有两个子层 一个atten + feed_forward
解码器中有三个子层 一个self_atten + sec_atten + feed_forward
"""
encoder_layer = Encoder_layer(d_model,self_atten,feed_forward,dropout)
decoder_layer = DecoderLayer(d_model,self_atten,src_atten,feed_forward,dropout)
model = EncoderDecoder(
Encoder(c(encoder_layer),N),
Decoder(c(decoder_layer),M),
nn.Sequential(Embeddings(d_model,src_vocab),c(position)),
nn.Sequential(Embeddings(d_model,tgt_vocab),c(position)),
Genertor(d_model,tgt_vocab)
)
# 对模型中的整个参数进行判断 == 将矩阵中的参数服从均匀分布进行初始化
# 对模型中维度大于1的参数进行初始化
for p in model.parameters():
if p.dim() > 1:
nn.init.xavier_uniform_(p)
return model
if __name__ == "__main__":
result = make_model(10,20)
print(result)