【AI大模型】深入Transformer架构：解码器部分的实现与解析

学习目标

🍀 了解解码器中各个组成部分的作用.

🍀 掌握解码器中各个组成部分的实现过程.

🍔 解码器介绍

解码器部分:

• 由N个解码器层堆叠而成
• 每个解码器层由三个子层连接结构组成
• 第一个子层连接结构包括一个多头自注意力子层和规范化层以及一个残差连接
• 第二个子层连接结构包括一个多头注意力子层和规范化层以及一个残差连接
• 第三个子层连接结构包括一个前馈全连接子层和规范化层以及一个残差连接

• 说明:
• 解码器层中的各个部分，如，多头注意力机制，规范化层，前馈全连接网络，子层连接结构都与编码器中的实现相同. 因此这里可以直接拿来构建解码器层.

🍔 解码器层

2.1 解码器层的作用

• 作为解码器的组成单元, 每个解码器层根据给定的输入向目标方向进行特征提取操作，即解码过程.

2.2 解码器层的代码实现

# 使用DecoderLayer的类实现解码器层
class DecoderLayer(nn.Module):
    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
        """初始化函数的参数有5个, 分别是size，代表词嵌入的维度大小, 同时也代表解码器层的尺寸，
            第二个是self_attn，多头自注意力对象，也就是说这个注意力机制需要Q=K=V， 
            第三个是src_attn，多头注意力对象，这里Q!=K=V， 第四个是前馈全连接层对象，最后就是droupout置0比率.
        """
        super(DecoderLayer, self).__init__()
        # 在初始化函数中， 主要就是将这些输入传到类中
        self.size = size
        self.self_attn = self_attn
        self.src_attn = src_attn
        self.feed_forward = feed_forward
        # 按照结构图使用clones函数克隆三个子层连接对象.
        self.sublayer = clones(SublayerConnection(size, dropout), 3)

    def forward(self, x, memory, source_mask, target_mask):
        """forward函数中的参数有4个，分别是来自上一层的输入x，
           来自编码器层的语义存储变量mermory， 以及源数据掩码张量和目标数据掩码张量.
        """
        # 将memory表示成m方便之后使用
        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)

• 实例化参数:

# 类的实例化参数与解码器层类似, 相比多出了src_attn, 但是和self_attn是同一个类.
head = 8
size = 512
d_model = 512
d_ff = 64
dropout = 0.2
self_attn = src_attn = MultiHeadedAttention(head, d_model, dropout)

# 前馈全连接层也和之前相同 
ff = PositionwiseFeedForward(d_model, d_ff, dropout)

• 输入参数:

# x是来自目标数据的词嵌入表示, 但形式和源数据的词嵌入表示相同, 这里使用per充当.
x = pe_result

# memory是来自编码器的输出
memory = en_result

# 实际中source_mask和target_mask并不相同, 这里为了方便计算使他们都为mask
mask = Variable(torch.zeros(8, 4, 4))
source_mask = target_mask = mask

• 调用:

dl = DecoderLayer(size, self_attn, src_attn, ff, dropout)
dl_result = dl(x, memory, source_mask, target_mask)
print(dl_result)
print(dl_result.shape)

• 输出效果:

tensor([[[ 1.9604e+00,  3.9288e+01, -5.2422e+01,  ...,  2.1041e-01,
          -5.5063e+01,  1.5233e-01],
         [ 1.0135e-01, -3.7779e-01,  6.5491e+01,  ...,  2.8062e+01,
          -3.7780e+01, -3.9577e+01],
         [ 1.9526e+01, -2.5741e+01,  2.6926e-01,  ..., -1.5316e+01,
           1.4543e+00,  2.7714e+00],
         [-2.1528e+01,  2.0141e+01,  2.1999e+01,  ...,  2.2099e+00,
          -1.7267e+01, -1.6687e+01]],

        [[ 6.7259e+00, -2.6918e+01,  1.1807e+01,  ..., -3.6453e+01,
          -2.9231e+01,  1.1288e+01],
         [ 7.7484e+01, -5.0572e-01, -1.3096e+01,  ...,  3.6302e-01,
           1.9907e+01, -1.2160e+00],
         [ 2.6703e+01,  4.4737e+01, -3.1590e+01,  ...,  4.1540e-03,
           5.2587e+00,  5.2382e+00],
         [ 4.7435e+01, -3.7599e-01,  5.0898e+01,  ...,  5.6361e+00,
           3.5891e+01,  1.5697e+01]]], grad_fn=<AddBackward0>)
torch.Size([2, 4, 512])

2.3 解码器层总结

• 学习了解码器层的作用:- 作为解码器的组成单元, 每个解码器层根据给定的输入向目标方向进行特征提取操作，即解码过程.
• 学习并实现了解码器层的类: DecoderLayer- 类的初始化函数的参数有5个, 分别是size，代表词嵌入的维度大小, 同时也代表解码器层的尺寸，第二个是self_attn，多头自注意力对象，也就是说这个注意力机制需要Q=K=V，第三个是src_attn，多头注意力对象，这里Q!=K=V， 第四个是前馈全连接层对象，最后就是droupout置0比率.- forward函数的参数有4个，分别是来自上一层的输入x，来自编码器层的语义存储变量mermory， 以及源数据掩码张量和目标数据掩码张量.- 最终输出了由编码器输入和目标数据一同作用的特征提取结果.

🍔 解码器

3.1 解码器的作用

• 根据编码器的结果以及上一次预测的结果, 对下一次可能出现的'值'进行特征表示.

3.2 解码器的代码分析

# 使用类Decoder来实现解码器
class Decoder(nn.Module):
    def __init__(self, layer, N):
        """初始化函数的参数有两个，第一个就是解码器层layer，第二个是解码器层的个数N."""
        super(Decoder, self).__init__()
        # 首先使用clones方法克隆了N个layer，然后实例化了一个规范化层. 
        # 因为数据走过了所有的解码器层后最后要做规范化处理. 
        self.layers = clones(layer, N)
        self.norm = LayerNorm(layer.size)

    def forward(self, x, memory, source_mask, target_mask):
        """forward函数中的参数有4个，x代表目标数据的嵌入表示，memory是编码器层的输出，
           source_mask, target_mask代表源数据和目标数据的掩码张量"""

        # 然后就是对每个层进行循环，当然这个循环就是变量x通过每一个层的处理，
        # 得出最后的结果，再进行一次规范化返回即可. 
        for layer in self.layers:
            x = layer(x, memory, source_mask, target_mask)
        return self.norm(x)

• 实例化参数:

# 分别是解码器层layer和解码器层的个数N
size = 512
d_model = 512
head = 8
d_ff = 64
dropout = 0.2
c = copy.deepcopy
attn = MultiHeadedAttention(head, d_model)
ff = PositionwiseFeedForward(d_model, d_ff, dropout)
layer = DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout)
N = 8

• 输入参数:

# 输入参数与解码器层的输入参数相同
x = pe_result
memory = en_result
mask = Variable(torch.zeros(8, 4, 4))
source_mask = target_mask = mask

• 调用:

de = Decoder(layer, N)
de_result = de(x, memory, source_mask, target_mask)
print(de_result)
print(de_result.shape)

• 输出效果:

tensor([[[ 0.9898, -0.3216, -1.2439,  ...,  0.7427, -0.0717, -0.0814],
         [-0.7432,  0.6985,  1.5551,  ...,  0.5232, -0.5685,  1.3387],
         [ 0.2149,  0.5274, -1.6414,  ...,  0.7476,  0.5082, -3.0132],
         [ 0.4408,  0.9416,  0.4522,  ..., -0.1506,  1.5591, -0.6453]],

        [[-0.9027,  0.5874,  0.6981,  ...,  2.2899,  0.2933, -0.7508],
         [ 1.2246, -1.0856, -0.2497,  ..., -1.2377,  0.0847, -0.0221],
         [ 3.4012, -0.4181, -2.0968,  ..., -1.5427,  0.1090, -0.3882],
         [-0.1050, -0.5140, -0.6494,  ..., -0.4358, -1.2173,  0.4161]]],
       grad_fn=<AddBackward0>)
torch.Size([2, 4, 512])

3.3 解码器总结

• 学习了解码器的作用:- 根据编码器的结果以及上一次预测的结果, 对下一次可能出现的'值'进行特征表示.
• 学习并实现了解码器的类: Decoder- 类的初始化函数的参数有两个，第一个就是解码器层layer，第二个是解码器层的个数N.- forward函数中的参数有4个，x代表目标数据的嵌入表示，memory是编码器层的输出，src_mask, tgt_mask代表源数据和目标数据的掩码张量.- 输出解码过程的最终特征表示.

💘若能为您的学习之旅添一丝光亮，不胜荣幸💘

🐼期待您的宝贵意见，让我们共同进步共同成长🐼