Transformer--Decoder

一、Transformer 解码器

编码器详见上篇文章

1、Decoder 层实现

解码器层同编码器层一样，需要数据输入后创建Q、K、V向量，通过依据向量之间的关系，构建attention机制，实现decoder layer层的实现。

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计算后，最后对数据进行标准化，进行数据的输出。

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激活后进行数据的输出。

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 类整体构建

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)

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)