解码器层和解码器

目录

1、解码器层和解码器的作用

2、解码器层和解码器的架构

3、解码器层和解码器的代码实现

---

1、解码器层和解码器的作用

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

根据解码器的结果以及上一次预测的结果，对下一次可能出现的值进行特征表示

2、解码器层和解码器的架构

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

3、解码器层和解码器的代码实现

import numpy as np
from torch.autograd import Variable
import copy
from torch import softmax
import math
import torch.nn as nn
import torch
# 构建Embedding类来实现文本嵌入层
class Embeddings(nn.Module):
    def __init__(self,vocab,d_model):
        """
        :param vocab: 词表的大小
        :param d_model: 词嵌入的维度
        """
        super(Embeddings,self).__init__()
        self.lut = nn.Embedding(vocab,d_model)
        self.d_model = d_model
    def forward(self,x):
        """
        :param x: 因为Embedding层是首层，所以代表输入给模型的文本通过词汇映射后的张量
        :return:
        """
        return self.lut(x) * math.sqrt(self.d_model)
class PositionalEncoding(nn.Module):
    def __init__(self,d_model,dropout,max_len=5000):
        """
        :param d_model: 词嵌入的维度
        :param dropout: 随机失活，置0比率
        :param max_len: 每个句子的最大长度，也就是每个句子中单词的最大个数
        """
        super(PositionalEncoding,self).__init__()
        self.dropout = nn.Dropout(p=dropout)
        pe = torch.zeros(max_len,d_model) # 初始化一个位置编码器矩阵，它是一个0矩阵，矩阵的大小是max_len * d_model
        position = torch.arange(0,max_len).unsqueeze(1) # 初始一个绝对位置矩阵 max_len * 1
        div_term = torch.exp(torch.arange(0,d_model,2)*-(math.log(1000.0)/d_model)) # 定义一个变换矩阵，跳跃式的初始化
        # 将前面定义的变换矩阵进行奇数、偶数的分别赋值
        pe[:,0::2] = torch.sin(position*div_term)
        pe[:,1::2] = torch.cos(position*div_term)
        pe = pe.unsqueeze(0)  # 将二维矩阵扩展为三维和embedding的输出（一个三维向量）相加
        self.register_buffer('pe',pe) # 把pe位置编码矩阵注册成模型的buffer，对模型是有帮助的，但是却不是模型结构中的超参数或者参数，不需要随着优化步骤进行更新的增益对象。注册之后我们就可以在模型保存后重加载时，将这个位置编码与模型参数一同加载进来
 
    def forward(self, x):
        """
        :param x: 表示文本序列的词嵌入表示
        :return: 最后使用self.dropout(x)对对象进行“丢弃”操作，并返回结果
        """
        x = x + Variable(self.pe[:, :x.size(1)],requires_grad = False)   # 不需要梯度求导，而且使用切片操作，因为我们默认的max_len为5000，但是很难一个句子有5000个词汇，所以要根据传递过来的实际单词的个数对创建的位置编码矩阵进行切片操作
        return self.dropout(x)
 
def subsequent_mask(size):
    """
    :param size: 生成向后遮掩的掩码张量，参数 size 是掩码张量的最后两个维度大小，它的最后两个维度形成一个方阵
    :return:
    """
    attn_shape = (1,size,size) # 定义掩码张量的形状
    subsequent_mask = np.triu(np.ones(attn_shape),k = 1).astype('uint8') # 定义一个上三角矩阵，元素为1，再使用其中的数据类型变为无符号8位整形
    return torch.from_numpy(1 - subsequent_mask) # 先将numpy 类型转化为 tensor，再做三角的翻转，将位置为 0 的地方变为 1，将位置为 1 的方变为 0
 
def attention(query, key, value, mask=None, dropout=None):
    """
    :param query: 三个张量输入
    :param key: 三个张量输入
    :param value: 三个张量输入
    :param mask: 掩码张量
    :param dropout: 传入的 dropout 实例化对象
    :return:
    """
    d_model = query.size(-1)  # 得到词嵌入的维度，取 query 的最后一维大小
    scores = torch.matmul(query,key.transpose(-2,-1)) / math.sqrt(d_model)     # 按照注意力公式，将 query 和 key 的转置相乘，这里是将 key 的最后两个维度进行转置，再除以缩放系数，得到注意力得分张量 scores
    # query(2,8,4,64) key.transpose(-2,-1) (2,8,64,4) 进行矩阵乘法为 （2,8,4,4）
    if mask is not None:
        scores = torch.masked_fill(scores,mask == 0,-1e9)  # 使用 tensor 的 mask_fill 方法，将掩码张量和 scores 张量中每一个位置进行一一比较，如果掩码张量处为 0 ,则使用 -1e9 替换
        # scores = scores.masked_fill(mask == 0,-1e9)
    p_attn = softmax(scores, dim = -1) # 对 scores 的最后一维进行 softmax 操作，使用 F.softmax 方法，第一个参数是 softmax 对象，第二个参数是最后一个维度，得到注意力矩阵
    print('scores.shape ',scores.shape)
    if dropout is not None:
        p_attn = dropout(p_attn)
    return torch.matmul(p_attn,value),p_attn  # 返回注意力表示
 
class MultiHeadAttention(nn.Module):
    def __init__(self, head, embedding_dim , dropout=0.1):
        """
        :param head: 代表几个头的参数
        :param embedding_dim: 词向量维度
        :param dropout: 置零比率
        """
        super(MultiHeadAttention, self).__init__()
        assert embedding_dim % head == 0     # 确认一下多头的数量可以整除词嵌入的维度 embedding_dim
        self.d_k = embedding_dim // head  # 每个头获得词向量的维度
        self.head = head
        self.linears = nn.ModuleList([copy.deepcopy(nn.Linear(embedding_dim, embedding_dim)) for _ in range(4)])   # 深层拷贝4个线性层，每一个层都是独立的，保证内存地址是独立的，分别是 Q、K、V以及最终的输出线性层
        self.attn = None   # 初始化注意力张量
        self.dropout = nn.Dropout(p=dropout)
    def forward(self, query, key, value, mask=None):
        """
        :param query: 查询query [batch size, sentence length, d_model]
        :param key: 待查询key [batch size, sentence length, d_model]
        :param value: 待查询value [batch size, sentence length, d_model]
        :param mask: 计算相似度得分时的掩码（设置哪些输入不计算到score中）[batch size, 1, sentence length]
        :return:
        """
        if mask is not None:
            mask = mask.unsqueeze(1) # 将掩码张量进行维度扩充，代表多头中的第 n 个头
        batch_size = query.size(0)
        query, key, value = [l(x).view(batch_size, -1, self.head, self.d_k).transpose(1, 2) for l, x in zip(self.linears, (query, key, value))]  # 将1、2维度进行调换，目的是让句子长度维度和词向量维度靠近，这样注意力机制才能找到词义与句子之间的关系
        # 将每个头传递到注意力层
        x, self.attn = attention(query, key, value, mask=mask, dropout=self.dropout)
        # 得到每个头的计算结果是 4 维的张量，需要形状的转换
        # 前面已经将1,2两个维度进行转置了，所以这里要重新转置回来
        # 前面已经经历了transpose，所以要使用contiguous()方法，不然无法使用 view 方法
        x = x.transpose(1, 2).contiguous() \
            .view(batch_size, -1, self.head * self.d_k)
        return self.linears[-1](x)  # 在最后一个线性层中进行处理，得到最终的多头注意力结构输出
 
class LayerNormalization(nn.Module):
    def __init__(self, features, eps=1e-6):
        """
        :param features: 词嵌入的维度
        :param eps: 出现在规范化公式的分母中，防止分母为0
        """
        super(LayerNormalization, self).__init__()
        # a 系数的默认值为1，模型的参数
        self.a = nn.Parameter(torch.ones(features))
        # b 系统的初始值为0，模型的参数
        self.b = nn.Parameter(torch.zeros(features))
        # 把 eps 传递到类中
        self.eps = eps
 
    def forward(self, x):
        # 在最后一个维度上求 均值，并且输出维度保持不变
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.a * (x - mean) / (std + self.eps) + self.b
 
class PositionFeedForward(nn.Module):
    def __init__(self, d_model, d_ff, dropout=0.1):
        """
        :param d_model: 输入维度，词嵌入的维度
        :param d_ff: 第一个的输出连接第二个的输入
        :param dropout: 置零比率
        """
        super(PositionFeedForward, self).__init__()
        self.linear1 = nn.Linear(d_model, d_ff)
        self.linear2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(p = dropout)
    def forward(self, x):
        return self.linear2(self.dropout(torch.relu(self.linear1(x))))
 
class SublayerConnection(nn.Module):
    def __init__(self, size, dropout=0.1):
        super(SublayerConnection,self).__init__()
        # 实例化了一个 LN 对象
        self.norm = LayerNormalization(size)
        self.dropout = nn.Dropout(p = dropout)
    def forward(self,x,sublayer):
        """
        :param x: 接受上一个层或者子层的输入作为第一个参数
        :param sublayer: 该子层连接中的子层函数胡作为第二个参数
        :return:
        """
        "首先对输出进行规范化，然后将结果交给子层处理，之后对子层进行 dropout处理" \
        "随机失活一些神经元，来防止过拟合，最后还有一个add操作" \
        "因此存在跳跃连接，所以是将输入x与dropout后的子层输出结果相加作为最终的子层连接输出"
        return x + self.dropout(sublayer(self.norm(x)))
 
class EncoderLayer(nn.Module):
    def __init__(self, size, self_attn, feed_forward, dropout):
        """
        :param size: 词嵌入的维度
        :param self_attn: 传入多头自注意力子层实例化对象，并且是自注意力机制
        :param feed_forward: 前馈全连接层实例化对象
        :param dropout: 置零比率
        """
        super(EncoderLayer,self).__init__()
        self.self_attn = self_attn
        self.feed_forward = feed_forward
        self.sublayer = nn.ModuleList([copy.deepcopy(SublayerConnection(size,dropout)) for _ in range(2)])
        self.size = size
    def forward(self, x, mask):
        """
        :param x: 上一层的输出
        :param mask: 掩码张量
        :return:
        """
        "首先通过第一个子层连接结构，其中包含多头自注意力子层"
        "然后通过第二个子层连接结构，其中包含前馈全连接子层，最后返回结果"
        x = self.sublayer[0](x,lambda x:self.self_attn(x,x,x,mask))
        return self.sublayer[1](x,self.feed_forward)
class Encoder(nn.Module):
    def __init__(self, layer, N):
        """
        :param layer: 编码器层
        :param N: 编码器的个数
        """
        super(Encoder,self).__init__()
        self.layers = nn.ModuleList([copy.deepcopy(layer) for _ in range(N)])
        "初始化一个规范化层，用于最后的输出"
        self.norm = LayerNormalization(layer.size)
        # print('layer.size',layer.size) 512
    def forward(self, x, mask):
        for layer in self.layers:
            x = layer(x,mask)
        return self.norm(x)

import copy
import torch.nn as nn
class DecoderLayer(nn.Module):
    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
        """
        :param size: 代表词嵌入的维度，同时也代表解码器层的尺寸
        :param self_attn: 多头自注意力对象 Q = K = V
        :param src_attn:  多头自注意力对象，Q! = K = V
        :param feed_forward: 前馈全链连接层
        :param dropout: 置零比率
        """
        super(DecoderLayer,self).__init__()
        self.size = size
        self.self_attn = self_attn
        self.src_attn = src_attn
        self.feed_forward = feed_forward
        self.sublayer = nn.ModuleList([copy.deepcopy(SublayerConnection(size,dropout))for _ in range(3)])
    def forward(self, x, memory, source_mask, target_mask):
        """
        :param x: 来自上一层的输入x
        :param memory: 来自编码器层的语义存储变量 mermory
        :param source_mask: 源数据掩码张量
        :param target_mask: 目标数据掩码张量
        :return:
        """
        "将x传入第一个子层结构，输入分别是x 和 self_attn函数，因为是自注意力机制，所以Q、K、V相等 "
        "最后一个数据是目标数据的掩码张量，这时要对目标数据进行遮掩，因为这个时候模型还没有生成任何的目标数据"
        "比如在解码器生成第一个字符或者词汇的时候，我们其实已经传入进来了滴哟个字符以便计算损失，但是我们不希望在生成第一个字符时模型能利用这个信息，同样在生成第二个字符或者词汇时，模型只能使用第一个字符或者词汇信息，第二个词汇以及以后的信息都不被模型允许使用"
        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.self_attn(x,memory,memory,source_mask))
        "全连接子层，返回结果"
        return self.sublayer[2](x,self.feed_forward)
class Decoder(nn.Module):
    def __init__(self, layer, N):
        """
        :param layer: 编码器层
        :param N: 编码器的个数
        """
        super(Decoder,self).__init__()
        self.layers = nn.ModuleList([copy.deepcopy(layer) for _ in range(N)])
        "初始化一个规范化层，用于最后的输出"
        self.norm = LayerNormalization(layer.size)
        # print('layer.size',layer.size) 512
    def forward(self, x, memory, source_mask, target_mask):
        for layer in self.layers:
            x = layer(x, memory, source_mask, target_mask)
        return self.norm(x)

# 实例化参数
N = 8
size = d_model = 512
head = 8
source_mask = target_mask = mask = torch.zeros(2,4,4)
d_ff = 62
dropout = 0.2
max_len = 60  # 句子最大长度
#-----------------------------------------词嵌入层
# 输入 x 是 Embedding层输出的张量，形状为 2 * 4 * 512
x = Variable(torch.LongTensor([[100,2,42,508],[491,998,1,221]]))
emb = Embeddings(1000,512)   # 嵌入层
embr = emb(x)
#-----------------------------------------位置编码
pe = PositionalEncoding(d_model, dropout,max_len)
pe_result = pe(embr)
x = pe_result
#-----------------------------------------多头注意力
self_attn = src_attn =  MultiHeadAttention(head,d_model)
#-----------------------------------------FFN
ff = PositionFeedForward(d_model, d_ff, dropout)
#-----------------------------------------编码器层
layer = EncoderLayer(size, copy.deepcopy(self_attn), copy.deepcopy(ff),dropout)
#-----------------------------------------编码器
en = Encoder(layer, N)
en_result = en(x,mask)
memory = en_result
#-----------------------------------------解码器层
layer = DecoderLayer(d_model, copy.deepcopy(self_attn), copy.deepcopy(src_attn), copy.deepcopy(ff), dropout)
#-----------------------------------------编码器
de = Decoder(layer, N)
de_result = de(x, memory, source_mask, target_mask)
print(de_result)
print(de_result.shape)

tensor([[[-2.6716, -1.4034, -0.0345,  ...,  0.0774, -0.0210, -1.0268],
         [ 0.9154, -0.0816,  0.9004,  ...,  2.4049,  0.6053,  0.0746],
         [-2.1708,  1.4642, -0.0542,  ..., -0.3622, -2.9757,  0.6427],
         [-0.3369, -1.8594, -0.7430,  ..., -0.0699,  0.9597, -1.1720]],

        [[ 2.8194, -0.0856, -0.7291,  ...,  0.3985, -1.6122,  0.2269],
         [ 1.2411,  0.9427, -1.0782,  ..., -1.5396, -0.0680,  1.7228],
         [-0.1725,  1.5356,  0.1297,  ...,  0.4093, -1.5300,  0.1120],
         [-0.2468, -1.1276,  0.7052,  ...,  0.7486, -0.8290,  0.8279]]],
       grad_fn=)
torch.Size([2, 4, 512])