Transformer模型详解

class PositionalEncoding(nn.Module):
    def __init__(self,d_model,dropout,max_len=60):
        """
        位置编码初始化方法
        :param d_model: 词向量维度。例如：512
        :param dropout: 神经元随机失活概率
        :param max_len: 能够处理的句子最大长度。也就是词的个数
        """

        # 1- 初始化父类
        super().__init__()

        # 2- 创建随机失活层
        self.dropout = nn.Dropout(p=dropout)

        # 3- 定义pe(也就是位置编码张量)
        pe = torch.zeros(size=(max_len,d_model))    # 目前的形状[60,d_model]

        # 4- 定义列向量，用来存储输入句子中词索引信息
        position = torch.arange(0,max_len).unsqueeze(1) # 形状[60,1]

        # 5- 得到pos/分母公式中的，1/分母
        div_term = 1/(10000**(torch.arange(0,d_model,2).float()/d_model))

        # 6- 计算pos/分母的结果
        position_value = position * div_term

        # 7- 调用sin、cos分别计算位置编码值
        pe[:,0::2] = torch.sin(position_value)  # 偶数维度
        pe[:,1::2] = torch.cos(position_value)  # 奇数维度

        # 8- 调整pe的形状变成3维，也就是[60,d_model]->[1,60,d_model]每个批次1条句子，每个句子最多60个词，词向量是d_model
        pe = pe.unsqueeze(0)

        # 9- 将pe的值注册到缓存中，通过它来不断的更新位置编码信息。后面可以直接通过self.pe调用
        self.register_buffer("pe",pe)

    def forward(self,embed):
        """
        位置编码的前向传播：多条句子中所有词的词向量，和位置编码张量进行求和操作，返回结果
        :param embed: 词向量
        :return:
        """

        """
            embed.shape[1]：embed的形状[batch_size,seq_len,d_model]，得到多少个词
            为什么self.pe[:, :embed.shape[1]]？
            如果这条句子中词的个数超过了max_len，那么最多只对前max_len个词的位置编码进行相加
        """
        result = embed + self.pe[:, :embed.shape[1]]
        print(f"对应的位置编码值：{self.pe[:, :embed.shape[1]]}")
        return self.dropout(result)

def use_positional_encoding():
    d_model = 512

    # 实例化词嵌入层类的对象
    my_embed = Embedding(vocab_size=1000,d_model=d_model)

    # 准备数据
    x = torch.tensor([
        # 单词索引
        [100, 2, 421, 600],
        [500, 888, 421, 615]
    ])

    # 输入数据，得到对应的词向量
    word_embed = my_embed(x)
    print(f"词向量的形状：{word_embed.shape}")
    print(f"词向量的值：{word_embed}")

    # 创建位置编码
    my_pe = PositionalEncoding(d_model=d_model,dropout=0.1,max_len=60)

    # 调用位置编码，最终效果是往词向量中加上了位置编码的值
    result = my_pe(word_embed)
    print(f"最终的形状：{result.shape}")
    print(f"最终的值：{result}")

    return result

# 可视化位置编码
def plot_position():
    # 1. 实例化位置编码器.
    my_position = PositionalEncoding(20, dropout=0.1, max_len=100)

    # 2. 生成全0的输入, 观察位置编码的模式.
    # (1, 100, 20) -> 批次大小, 句子长度, 词嵌入维度
    embed = torch.zeros(1, 100, 20)
    y = my_position(embed)

    # 3. 设置图表大小.
    plt.figure(figsize=(20, 15))
    # 绘制位置编码第4到第7列, 100个词的  [4, 5, 6, 7]
    """
        图形的信息解释：
            x轴：词的索引，目前总共有100个词
            y轴：位置编码值
    """
    plt.plot(np.arange(100), y[0, :, 4:8].detach().numpy())
    plt.legend([f'dim {p}' for p in [4, 5, 6, 7]])
    plt.show()

# 使用PyTorch实现掩码。【掌握】
"""
    总结：
        1- 上三角掩码：右上角的值为1，左下角的值为0
        2- 下三角掩码：右上角的值为0，左下角的值为1
        3- 相同的规律：对角线的时候diagonal为0；如果是正数，并且越来越大，那么往右上角移动；反之往左下角移动；diagonal的取值超过范围不会报错
        4- 【掌握】掩码的作用：为了防止解码器端当前时间步偷看后面时间步的数据，你只能看到你前面时间步已经预测出来的数据。核心是防止模型训练效果不好
        5- 【掌握】代码：torch.triu(t,diagonal=0)
"""

import torch
def torch_mask():
    # 创建初始张量
    t = torch.ones(size=(5,5))
    print(f"原始张量：{t}")

    # 进行掩码操作
    # 上三角掩码
    u_0_mask = torch.triu(t,diagonal=0)
    print(f"上三角掩码0：{u_0_mask}")

    u_1_mask = torch.triu(t, diagonal=1)
    print(f"上三角掩码1：{u_1_mask}")

    u__1_mask = torch.triu(t, diagonal=-1)
    print(f"上三角掩码_1：{u__1_mask}")

    u_n_mask = torch.triu(t, diagonal=1000)
    print(f"上三角掩码n：{u_n_mask}")

    print("-"*30)

    # 下三角掩码
    l_0_mask = torch.tril(t, diagonal=0)
    print(f"下三角掩码0：{l_0_mask}")

    l_1_mask = torch.tril(t, diagonal=1)
    print(f"下三角掩码1：{l_1_mask}")

    l__1_mask = torch.tril(t, diagonal=-1)
    print(f"下三角掩码-1：{l__1_mask}")

import numpy as np
def np_mask():
    # 1- 准备数据
    arr = np.ones(shape=(5,5))

    # 2- 上三角掩码
    # k和PyTorch中diagonal参数的作用完全一样
    u_result = np.triu(arr,k=0)
    print(f"上三角掩码0：\n{u_result}")

    u_result = np.triu(arr, k=1)
    print(f"上三角掩码1：\n{u_result}")

    u_result = np.triu(arr, k=-1)
    print(f"上三角掩码-1：\n{u_result}")

    # 3- 下三角掩码
    l_result = 1 - u_result
    print(f"下三角掩码：\n{l_result}")

    l_result = np.tril(arr,k=0)
    print(f"下三角掩码0：\n{l_result}")

    l_result = np.tril(arr, k=1)
    print(f"下三角掩码1：\n{l_result}")

    l_result = np.tril(arr, k=-1)
    print(f"下三角掩码-1：\n{l_result}")

import math
import torch
import torch.nn as nn
from torch import Tensor
from demo01_input import *

def attention(query:Tensor,key:Tensor,value:Tensor,mask:Tensor=None,dropout=None):
    """
    注意力计算方法。能够涵盖如下几种情况：
        1- 编码器端的多头自注意力：query=key=value，mask为None
        2- 解码器端的掩码多头自注意力：query=key=value，mask不为None
        3- 解码器端的多头注意力（交叉注意力）：query和key、value不等，但是key和value相同，mask为None
    :param query: 查询张量，形状：[batch_size每个批次中有多少条句子,seq_len每条句子中有几个词,d_model词向量的维度/隐藏状态维度]
    :param key: 键张量，形状：[batch_size,seq_len,d_model]
    :param value: 值张量，形状：[batch_size,seq_len,d_model]
    :param dropout: 随机失活Dropout层对象
    :param mask: 掩码张量，形状：[batch_size,seq_len,seq_len]
    :return: 专属信息包,权重张量。类型是元组
    """

    # 1- 获得d_k：词向量的维度
    d_k = query.shape[-1]

    # 2- Q和K的转置相乘；再除以根号d_k。得到相似性得分scores
    # K的转置：由  [batch_size,seq_len,d_model]  变成了  [batch_size,d_model,seq_len]
    scores = torch.matmul(query,key.transpose(-2,-1)) / math.sqrt(d_k)

    # 3- 可选：对相似性得分scores进行掩码处理
    if mask is not None:
        # 对需要进行掩码的地方，将值替换成-1e9。注意：不要直接设置为0。需要和softmax结合理解。e的-1e9的结果趋近于0，表示权重趋近于0
        scores = scores.masked_fill(mask==0,value=-1e9)

    # 4- 将相似性转成权重
    weight = torch.softmax(scores,dim=-1)

    # 5- 可选：随机时候，缓解过拟合
    if dropout is not None:
        weight = dropout(weight)

    # 6- 权重和value进行矩阵乘法，得到专属信息包
    C = torch.matmul(weight,value)

    return C,weight

def use_attention():
    # 1- 输入的数据先经过 词嵌入层 和 位置编码
    posi_embed = use_positional_encoding()

    # 2- 调用注意力计算方法
    # 2.1- 准备query、key、value参数
    query=key=value=posi_embed

    # 2.2- 准备掩码【可选】
    # (2,4,4)值的来源于use_positional_encoding的x。每个批次2条句子，每条句子4个词
    # 形状：[batch_size,seq_len,seq_len]
    mask = torch.triu(torch.ones(size=(2,4,4)))

    # 2.3- 随机失活网络层
    dropout = nn.Dropout(p=0.1)

    # 2.4- 调用
    # 2.4.1- 编码器端：没有掩码的多头自注意力
    encoder_attention_C, encoder_attention_weight = attention(query,key,value,dropout=dropout)
    print(f"编码器C：{encoder_attention_C.shape}-->{encoder_attention_C}")
    print(f"编码器C权重：{encoder_attention_weight.shape}-->{encoder_attention_weight}")

    # 2.4.2- 解码器端：有掩码的多头自注意力
    decoder_attention_C, decoder_attention_weight = attention(query,key,value,dropout=dropout,mask=mask)
    print(f"解码器C：{decoder_attention_C.shape}-->{decoder_attention_C}")
    print(f"解码器C权重：{decoder_attention_weight.shape}-->{decoder_attention_weight}")

def clones(model_obj, nums):
    """
    创建指定个数的相同网络结构对象
    :param model_obj: 网络结构对象
    :param nums: 个数
    :return: 网络结构对象列表
    """
    # 语法 nn.ModuleList([copy.deepcopy(模型对象) for _ in range(深拷贝复制的个数)])
    return nn.ModuleList([copy.deepcopy(model_obj) for _ in range(nums)])

class MultiHeadAttention(nn.Module):
    def __init__(self,d_model,head,dropout_p=0.1):
        """
        初始化
        :param d_model: 词向量维度/隐藏层隐藏状态向量维度。例如：512
        :param head: 多头的头数。例如：8
        :param dropout_p: 随机失活概率
        """

        # 1- 确定d_model能够被head整除
        assert d_model%head==0

        # 2- 初始化父类
        super().__init__()

        # 3- 设置属性值
        self.d_model = d_model
        self.head = head
        self.head_dim = self.d_model // self.head   # 每个头分别处理的数据维度。例如：64
        self.dropout = nn.Dropout(p=dropout_p)

        # 4- 搭建网络结构
        """
            4个线性层的作用如下：
                第1个线性层：专门用来query进行线性处理，决定“当前词在找什么东西”
                第2个线性层：专门用来key进行线性处理，决定“其他词能够提供什么信息”
                第3个线性层：专门用来value进行线性处理，决定“其他词的信息的重要程度是什么样的”
                第4个线性层：对多头并行处理，并且concat拼接后的张量做最终的线性处理，让数据变得更加平稳
        """
        self.linear_list = clones(nn.Linear(in_features=self.d_model,out_features=self.d_model), 4)

        # 5- 权重张量
        self.weight = None

    def forward(self,query:Tensor,key:Tensor,value:Tensor,mask:Tensor=None):
        """
        前向传播：多头注意力计算
        :param query: 查询张量，形状：[batch_size每个批次中有多少条句子,seq_len每条句子中有几个词,d_model词向量的维度/隐藏状态维度]
        :param key: 键张量，形状：[batch_size,seq_len,d_model]
        :param value: 值张量，形状：[batch_size,seq_len,d_model]
        :param mask: 掩码张量，形状：[head,seq_len,seq_len]。注意第一个维度代表的是头数
        :return:
        """

        # 1- 掩码处理：进行升维，3维变4维
        if mask is not None:
            # 例如：[8,4,4] -> [1,8,4,4]
            # 不管每个批次中有多少条句子，每条句子用的掩码是同一份
            mask = mask.unsqueeze(0)

        # 2- 获得batch_size，也就是批次中句子的条数
        batch_size = query.shape[0]

        # 3- 前3个线性层分别并行对QKV进行处理
        # 方式一：分开版
        # [(Linear,query), (Linear,key), (Linear,value)]
        linear_output_list = []
        model_and_data_list = list(zip(self.linear_list, (query,key,value)))
        for model,data in model_and_data_list:
            """
                1- model(data)：线性变换
                2- reshape：[2,4,512]->[2,4,8,64]
                3- transpose：[2,4,8,64]->[2,8,4,64]
            """
            model_output = model(data)
            reshape_output = model_output.reshape(batch_size,-1,self.head,self.head_dim)
            linear_output_list.append(reshape_output.transpose(1,2))

        new_query, new_key, new_value = linear_output_list

        # 方式二：合并版【理解】
        # new_query, new_key, new_value = [
        #     model(data).reshape(batch_size,-1,self.head,self.head_dim).transpose(1,2)
        #     for model,data in list(zip(self.linear_list, (query,key,value)))
        # ]

        # 4- 多头并行计算注意力
        C,weight = attention(new_query, new_key, new_value,mask=mask,dropout=self.dropout)
        self.weight = weight

        # 5- 对多头处理后的数据进行拼接
        # [2,8,4,64] -> [2,4,8,64] -> [2,4,512]
        result = C.transpose(1,2).reshape(batch_size,-1,self.head*self.head_dim)

        # 6- 调用最后一个线性层对拼接后的数据进行处理，让模型更加稳定
        return self.linear_list[-1](result)

# 前馈网络/前馈全连接层：通过调整张量大小，实现强化信息的过程
class FeedForward(nn.Module):
    def __init__(self,d_model,output_dim,dropout_p=0.1):
        # 1- 初始化父类
        super().__init__()

        # 2- 搭建网络结构
        # 2.1- 第一个线性层：用来对输入的词向量维度进行放大，例如：512->1024
        self.linear_1 = nn.Linear(in_features=d_model,out_features=output_dim)

        # 2.2- 随机失活层
        self.dropout = nn.Dropout(p=dropout_p)

        # 2.3- 第二个线性层：用来对上一个线性层输出的结果进行浓缩，例如：1024->512
        self.linear_2 = nn.Linear(in_features=output_dim, out_features=d_model)

    def forward(self,data):
        # 1- 调用第一个线性层
        data = self.linear_1(data)

        # 2- 调用随机失活
        """
            注意力机制本质是线性计算，如果没有非线性因素，那么整个网络模型比较简单，只能处理线性问题（也就是回归）
            引入relu激活也就是引入了非线性因素；Transformer论文中用的就是relu
        """
        data = self.dropout(torch.relu(data))

        # 3- 调用第二个线性层
        data = self.linear_2(data)

        return data

# 层归一化/规范化层：随着网络模型训练，数据有可能出现极值，导致梯度爆炸或消失，为了让模型训练稳定，通过标准化处理，让数据变的正常
# 也就是要实现y=kx+b，其中x要经过标准化处理（要计算数据的均值mean和标准差std）
class LayerNorm(nn.Module):
    def __init__(self,d_model):
        # 1- 初始化父类
        super().__init__()

        # 2- 线性公式中参数的定义
        """
            为什么k和b要通过nn.Parameter进行定义？
            答：因为nn.Parameter会自动将k和b注册到神经网络模型中，作为可训练的参数。通过反向传播得到k和b。
                如果不写nn.Parameter，那么k和b的值永远固定，不会发生变化。
                对应前面神经网络模型代码中如下两行代码
                optimizer = optim.Adam(params=model.parameters())
                optimizer.step()
        """
        # 2.1- 定义k
        self.k = nn.Parameter(torch.ones(d_model))

        # 2.2- 定义b
        self.b = nn.Parameter(torch.zeros(d_model))

        # 3- 定义小常数：防止分母为0
        self.eps = 1e-6

    def forward(self,data):
        """
        前向传播：输入前面子层处理后的数据，经过层归一化进行【标准化处理】，让模型训练稳定
        要实现y=kx+b，其中x要经过标准化处理（要计算数据的均值mean和标准差std）
        :param data: 前面子层处理后的数据。形状[batch_size,seq_len,d_model]
        :return:
        """

        # 1- 计算均值
        """
            参数解释：
                dim=-1：对最后一个维度计算均值
                keepdim=True：表示计算后，张量的形状保留。举例：[2,4,512]->[2,4,1]
        """
        mean = data.mean(dim=-1,keepdim=True)

        # 2- 计算标准差
        std = data.std(dim=-1, keepdim=True)

        # 3- 实现y=kx+b
        return self.k * (data - mean)/(std+self.eps) + self.b

# 子层连接类
class SubLayerConnection(nn.Module):
    def __init__(self,d_model,dropout_p):
        # 1- 初始化父类
        super().__init__()

        # 2- 创建层归一化
        """
            为什么把LayerNorm创建在__init__中？
            答：因为每个子层的后面都有该层
        """
        self.layer_norm = LayerNorm(d_model)

        # 3- 创建随机失活层
        self.dropout = nn.Dropout(p=dropout_p)

    def forward(self,data,sublayer_obj):
        """
        前向传播：使用你指定的具体子层实例对象【sublayer_obj】对数据【data】进行指定的处理
        :param data: 输入到层中的数据
        :param sublayer_obj: 具体子层实例对象。例如：多头自注意力实例对象、前馈网络实例对象、掩码多头自注意力实例对象、多头注意力实例对象（交叉注意力）
        :return:
        """

        # 具体子层实例对象【sublayer_obj】对数据【data】进行指定的处理
        # 写法一：原始Transformer的实现
        # 子层处理(也就是调用forward) -> 随机失活层 -> 残差连接 -> 层归一化
        # result = self.layer_norm(self.dropout(sublayer_obj(data)) + data)

        # 写法二：目前主流大模型的实现
        # 层归一化 -> 子层处理(也就是调用forward) -> 随机失活层 -> 残差连接
        """
            第一步：层归一化        self.layer_norm(data)
            第二步：子层处理        sublayer_obj(self.layer_norm(data))
            第三步：随机失活层       self.dropout(sublayer_obj(self.layer_norm(data)))
            第四步：残差连接        + data
        """
        result = self.dropout(sublayer_obj(self.layer_norm(data))) + data

        return result

# 子层连接测试
def use_SubLayerConnection():
    # 1- 准备数据：词嵌入层+位置编码
    data = use_positional_encoding()
    d_model = 512

    # 2- 子层连接类的实例对象
    SubLayerConnection_obj = SubLayerConnection(d_model,dropout_p=0.1)

    # 3- 演示子层的组合
    # 3.1- 多头自注意力层 + 残差连接和层归一化
    # 3.1.1- 创建 多头自注意力层 数据处理规则
    # 定义方式一：函数的形式
    def data_handler_fn(data):
        # 创建 多头自注意力层 类的实例对象
        attention_obj = MultiHeadAttention(d_model=d_model,head=8,dropout_p=0.1)
        # 调用forward
        return attention_obj(query=data,key=data,value=data)

    # 3.1.2- 组装得到子层：也就是调用SubLayerConnection它的forward
    multi_head_attention_output = SubLayerConnection_obj(data,data_handler_fn)
    print(f"多头自注意力层输出结果形状：{multi_head_attention_output.shape}")

    # 3.2- 前馈网络层 + 残差连接和层归一化
    # 定义方式二：lambda的形式
    feed_forward_output = SubLayerConnection_obj(
        multi_head_attention_output,
        lambda data:FeedForward(d_model=d_model,output_dim=1024,dropout_p=0.1)(data)
    )
    print(f"前馈网络层输出结果形状：{feed_forward_output.shape}")

from demo02_component import *

# 编码器层
class EncoderLayer(nn.Module):
    def __init__(self,d_model,multi_head_self_attn,feed_forward,dropout_p=0.1):
        """
        定义编码器层的结构
        :param d_model: 词向量维度
        :param multi_head_self_attn: 多头自注意力类的实例对象
        :param feed_forward: 前馈网络类的实例对象
        :param dropout_p:
        """
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.d_model = d_model
        self.dropout_p = dropout_p
        self.multi_head_self_attn = multi_head_self_attn
        self.feed_forward = feed_forward

        # 3- 创建子层
        # 3.1- 第一个子层：多头自注意力子层
        self.multi_layer = SubLayerConnection(self.d_model,self.dropout_p)

        # 3.2- 第二个子层：前馈网络子层
        self.feed_forward_layer = SubLayerConnection(self.d_model,self.dropout_p)

    def forward(self,data):
        # 1- 数据经过第一个层的处理：多头自注意力子层
        multi_output = self.multi_layer(data, lambda x: self.multi_head_self_attn(query=x, key=x, value=x, mask=None))
        # 2- 数据经过第二个层的处理：前馈网络子层
        encoder_output = self.feed_forward_layer(multi_output, lambda x: self.feed_forward(x))

        return encoder_output

# 编码器
class Encoder(nn.Module):
    def __init__(self, encoder_layer:EncoderLayer, N):
        """
        定义编码器结构。也就是将编码器层重复N层
        :param encoder_layer: 编码器层
        :param N:
        """
        # 1- 初始化父类
        super().__init__()

        # 2- 将编码器层创建N对象
        self.encoder_layer_list = clones(encoder_layer,N)

        # 3- 层归一化
        """
            这东西不是必须的，只是为了缓解经过N层处理后的数据，让数据变得更加平稳。这一层不是必须的
        """
        self.layer_norm = LayerNorm(encoder_layer.d_model)

    def forward(self,data):

        """
            注意：for循环中两个data需要与传递给forward的参数名称完全一致，否则6层网络处理的数据就会断开
        """
        for encoder_layer in self.encoder_layer_list:
            data = encoder_layer(data)

        return self.layer_norm(data)

"""
    解码器层由如下3层组成
        1- 第一层：掩码多头自注意力层
            掩码多头自注意力 + 层归一化 + 残差连接
        2- 第二层：多头注意力层
            多头注意力 + 层归一化 + 残差连接
        3- 第三层：前馈网络层
            前馈网络 + 层归一化 + 残差连接
"""
from demo03_encoder import *
from demo02_component import *

# 解码器层
class DecoderLayer(nn.Module):
    def __init__(self,d_model,mask_multi_head_self_attn,multi_head_attn,feed_forward,dropout_p=0.1):
        """
        定义解码器层的结构
        :param d_model: 词向量维度
        :param mask_multi_head_self_attn: 掩码多头自注意力类的实例对象
        :param multi_head_attn: 多头注意力类的实例对象
        :param feed_forward: 前馈网络类的实例对象
        :param dropout_p:
        """
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.d_model = d_model
        self.dropout_p = dropout_p
        self.mask_multi_head_self_attn = mask_multi_head_self_attn
        self.multi_head_attn = multi_head_attn
        self.feed_forward = feed_forward

        # 3- 创建子层
        # 3.1- 第一个子层：掩码多头自注意力子层
        self.mask_multi_self_layer = SubLayerConnection(self.d_model,self.dropout_p)

        # 3.2- 第二个子层：多头注意力子层
        self.multi_layer = SubLayerConnection(self.d_model, self.dropout_p)

        # 3.3- 第三个子层：前馈网络子层
        self.feed_forward_layer = SubLayerConnection(self.d_model,self.dropout_p)

    def forward(self,data,mask,encoder_output):
        # 1- 数据经过第一个层的处理：掩码多头自注意力子层
        mask_multi_self_output = self.mask_multi_self_layer(data, lambda x: self.mask_multi_head_self_attn(query=x, key=x, value=x, mask=mask))

        # 2- 数据经过第二个层的处理：多头注意力子层
        multi_output = self.multi_layer(mask_multi_self_output, lambda x: self.multi_head_attn(query=x, key=encoder_output, value=encoder_output, mask=None))

        # 3- 数据经过第三个层的处理：前馈网络子层
        decoder_output = self.feed_forward_layer(multi_output, lambda x: self.feed_forward(x))

        return decoder_output

## 解码器
class Decoder(nn.Module):
    def __init__(self, decoder_layer:DecoderLayer, N):
        """
        定义解码器结构。也就是将解码器层重复N层
        :param decoder_layer: 解码器层
        :param N:
        """
        # 1- 初始化父类
        super().__init__()

        # 2- 将解码器层创建N对象
        self.decoder_layer_list = clones(decoder_layer,N)

        # 3- 层归一化
        """
            这东西不是必须的，只是为了缓解经过N层处理后的数据，让数据变得更加平稳。这一层不是必须的
        """
        self.layer_norm = LayerNorm(decoder_layer.d_model)

    def forward(self,data, mask, encoder_output):

        """
            注意：for循环中两个data需要与传递给forward的参数名称完全一致，否则6层网络处理的数据就会断开
        """
        for decoder_layer in self.decoder_layer_list:
            data = decoder_layer(data, mask, encoder_output)

        return self.layer_norm(data)

# 测试解码器
# 测试最终的解码器
def use_decoder():
    # 常用参数定义
    d_model = 512
    dropout = 0.1

    # 1- 获得编码器最终结果数据。作为key、value传递给到解码器
    encoder_output = use_encoder()

    # 2- 准备解码器端原始目标值数据
    y = torch.tensor([
        # 例如法语单词索引
        [1, 2, 3, 4],
        [5, 6, 7, 8]
    ])

    # 3- 构建解码器
    # 3.1- 基础组件实例对象创建
    # 解码器端的词嵌入层
    embed = Embedding(vocab_size=1200,d_model=d_model)
    # 解码器端的位置编码
    position_encoding = PositionalEncoding(d_model=d_model,dropout=dropout)
    # 前馈网络子层
    feed_forward = FeedForward(d_model=d_model,output_dim=1024,dropout_p=dropout)
    # 多头注意力子层
    src_attn = MultiHeadAttention(d_model=d_model,head=8,dropout_p=dropout)
    # 掩码多头自注意力子层
    self_attn = MultiHeadAttention(d_model=d_model, head=8, dropout_p=dropout)

    # 3.2- 拼接得到解码器层
    decoder_layer = DecoderLayer(
        d_model=d_model,
        mask_multi_head_self_attn=self_attn,
        multi_head_attn=src_attn,
        feed_forward=feed_forward,
        dropout_p=dropout
    )

    # 3.3- 解码器层堆叠N层，得到解码器
    decoder = Decoder(decoder_layer,6)

    # 4- 处理数据
    # 4.1- 准备掩码
    mask = torch.zeros(size=(8,4,4)) # 掩码多头自注意力子层 的 掩码。# 注意，第一个位置是多头的数量

    # 4.2- 得到词向量+位置编码
    data = embed(y)
    data = position_encoding(data)

    # 4.3- 调用解码器
    decoder_result = decoder(data, mask, encoder_output)

    print(f"解码器最终的结果：{decoder_result.shape}")

"""
    Transformer框架的结构：
        编码器端_输入部分
            词嵌入层
            位置编码

        编码器
            多头自注意力子层：多头自注意力 + 层归一化 + 残差连接
            前馈网络子层：前馈网络 + 层归一化 + 残差连接

        解码器端_输入部分
            词嵌入层
            位置编码

        解码器
            掩码多头自注意力子层：掩码多头自注意力 + 层归一化 + 残差连接
            多头注意力子层（交叉注意力）：多头注意力 + 层归一化 + 残差连接
            前馈网络子层：前馈网络 + 层归一化 + 残差连接

        输出部分
            线性层
            Softmax激活函数

        结果
"""
from demo01_input import *
from demo02_component import *
from demo03_encoder import *
from demo04_decoder import *
from demo05_output import *

# 创建Transformer框架类
class MyTransformer(nn.Module):
    def __init__(self, en_embde_pos, encoder, de_embde_pos, decoder, output):
        """
        将前面开发的各个部分组织得到完整的Transformer框架
        :param en_embde_pos: 编码器端_输入部分 实例对象
        :param encoder: 编码器 实例对象
        :param de_embde_pos: 解码器端_输入部分 实例对象
        :param decoder: 解码器 实例对象
        :param output: 输出部分 实例对象
        """
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.en_embde_pos = en_embde_pos
        self.encoder = encoder
        self.de_embde_pos = de_embde_pos
        self.decoder = decoder
        self.output = output

    def forward(self,en_input,de_input,mask):
        """
        Transformer前向传播
        :param en_input: 输入到编码器端的词索引数据
        :param de_input: 输入到解码器端的词索引数据
        :param mask: 解码器使用的掩码
        :return:
        """

        # 1- 编码器端_输入部分：词嵌入层、位置编码
        encoder_data = self.en_embde_pos(en_input)

        # 2- 编码器
        encoder_data = self.encoder(encoder_data)

        # 3- 解码器端_输入部分：词嵌入层、位置编码
        decoder_data = self.de_embde_pos(de_input)

        # 4- 解码器
        decoder_data = self.decoder(
            data=decoder_data,
            mask=mask,
            encoder_output=encoder_data
        )

        # 5- 输出部分
        return self.output(decoder_data)

# 调用Transformer框架
def get_mytransformer():
    # 常用变量
    d_model = 512
    dropout = 0.1
    de_vocab_size = 4345

    # ---------------- 编码器部分 ----------------
    # 词嵌入层
    en_ebd = Embedding(vocab_size=1000, d_model=d_model)
    # 位置编码
    en_pos = PositionalEncoding(d_model=d_model, dropout=dropout, max_len=60)
    # 多头自注意力
    en_multi_self_attn = MultiHeadAttention(d_model=d_model, head=8, dropout_p=dropout)
    # 前馈网络
    en_ff = FeedForward(d_model=d_model, output_dim=1024, dropout_p=dropout)
    # 组装得到编码器层
    encoder_layer = EncoderLayer(
        d_model=d_model,
        multi_head_self_attn=en_multi_self_attn,
        feed_forward=en_ff,
        dropout_p=dropout
    )
    # 得到编码器
    encoder = Encoder(encoder_layer=encoder_layer, N=6)

    # ---------------- 解码器部分 ----------------
    # 词嵌入层
    de_ebd = Embedding(vocab_size=de_vocab_size, d_model=d_model)
    # 位置编码
    de_pos = PositionalEncoding(d_model=d_model, dropout=dropout, max_len=60)
    # 掩码多头自注意力
    de_multi_self_attn = MultiHeadAttention(d_model=d_model, head=8, dropout_p=dropout)
    # 多头注意力
    de_multi_attn = MultiHeadAttention(d_model=d_model, head=8, dropout_p=dropout)
    # 前馈网络
    de_ff = FeedForward(d_model=d_model, output_dim=1024, dropout_p=dropout)
    # 组装得到编码器层
    decoder_layer = DecoderLayer(
        d_model=d_model,
        mask_multi_head_self_attn=de_multi_self_attn,
        multi_head_attn=de_multi_attn,
        feed_forward=de_ff,
        dropout_p=dropout
    )
    # 得到编码器
    decoder = Decoder(decoder_layer=decoder_layer, N=6)

    # ---------------- 输出部分 ----------------
    output = Output(d_model=d_model, vocab_size=de_vocab_size)

    # ---------------- 组装得到Transformer框架 ----------------
    my_transformer = MyTransformer(
        en_embde_pos=nn.Sequential(en_ebd, en_pos),  # 表示 词先经过词嵌入层的处理，然后再经过位置编码的处理。注意：位置不能乱
        encoder=encoder,
        de_embde_pos=nn.Sequential(de_ebd, de_pos),
        decoder=decoder,
        output=output
    )
    print(f"框架结构信息：{my_transformer}")
    return my_transformer