Transformer 整体结构：

这里 N× 表示进行了 N 次堆叠。每个 Transformer 块都接收一个向量序列 {xi }作为输入，并输出一个等长的向量序列作为输出 {yi }  。

这里的 xi和 yi 分别对应着文本序列中的一个单词的表示。而 yi 是当前 Transformer 块对输入 xi 进一步整合其上下文语义后对应的输出。

在从输入 {xi }到输出 {yi }的语义抽象过程中，主要涉及到如下几个模块：

【3】简介Encoder结构计算流程+Decoder结构计算流程 

1.Add& Norm 层由 Add 和 Normmalize 两部分组成，其计算公式如下：

Decoder block 的第一个 Multi-Head Attention 采用了 Masked 操作，因为在翻译的过程中是顺序翻译的，即翻译完第 i 个单词，才可以翻译第 i+1 个单词。通过 Masked 操作可以防止第 i 个单词知道 i+1 个单词之后的信息。

下面以 "我有一只猫" 翻译成 "I have a cat" 为例，了解一下 Masked 操作。在 Decoder 的时候，是需要根据之前的翻译，求解当前最有可能的翻译，如下图所示。首先根据输入 "<Begin>" 预测出第一个单词为 "I"，然后根据输入 "<Begin> I" 预测下一个单词 "have"。

Decoder 可以在训练的过程中使用 Teacher Forcing 并且并行化训练，即将正确的单词列 (<Begin> I have a cat) 和对应输出 (I have a cat <end>) 传递到 Decoder。那么在预测第 i 个输出时，就要将第 i+1 之后的单词掩盖住，注意 Mask 操作是在 Self-Attention 的 Softmax 之前使用的，下面用 0 1 2 3 4 5 分别表示 "<Begin> I have a cat <end>"。

第一步：是Decoder的输入矩阵和 Mask 矩阵，输入矩阵包含 <Begin> I have a cat" (0, 1, 2, 3, 4) 

五个单词的表示向量，Mask 是一个 5×5 的矩阵。在 Mask 可以发现单词 0 只能使用单词 0 的信息，而单词 1 可以使用单词 0, 1 的信息，即只能使用之前的信息。

第二步：接下来的操作和之前的 Self-Attention 一样，通过输入矩阵X计算得到Q,K,V矩阵。然后计算Q和 Kᐪ 的乘积 QKᐪ 。

第三步：在得到 QKᐪ之后需要进行 Softmax，计算 attention score，在 Softmax 之前需要使用Mask矩阵遮挡住每一个单词之后的信息，遮挡操作如下：--，得到 Mask QKᐪ 之后在 Mask QKᐪ上进行 Softmax，每一行的和都为 1。但是单词 0 在单词 1, 2, 3, 4 上的 attention score 都为 0。

第四步：使用 Mask QKᐪ与矩阵 V相乘，得到输出 Z，则单词 1 的输出向量 ?1 是只包含单词 1 信息的。

第五步：通过上述步骤就可以得到一个 Mask Self-Attention 的输出矩阵 ?? ，然后和 Encoder 类似，通过 Multi-Head Attention 拼接多个输出 ??  然后计算得到第一个 Multi-Head Attention 的输出Z，Z与输入X维度一样。

2.第二个 Multi-Head Attention

Decoder block 第二个 Multi-Head Attention 变化不大，主要的区别在于其中 Self-Attention的 K, V矩阵不是使用 上一个 Decoder block 的输出计算的，而是使用 Encoder 的编码信息矩阵 C 计算的。

根据 Encoder 的输出 C计算得到 K, V，根据上一个 Decoder block 的输出 Z 计算 Q (如果是第一个 

Decoder block 则使用输入矩阵 X 进行计算)，后续的计算方法与之前描述的一致。这样做的好处是在 

Decoder 的时候，每一位单词都可以利用到 Encoder 所有单词的信息 (这些信息无需 Mask)。

3.Softmax 预测输出单词

Decoder block 最后的部分是利用 Softmax 预测下一个单词，在之前的网络层可以得到一个最终的输出 Z，因为 Mask 的存在，使得单词 0 的输出 Z0 只包含单词 0 的信息，如下：

Softmax 根据输出矩阵的每一行预测下一个单词：

这就是 Decoder block 的定义，与 Encoder 一样，Decoder 是由多个 Decoder block 组合而成。

【★】大模型八股答案基础知识-suc16【202310】：https://zhuanlan.zhihu.com/p/643829565

附简易面试专用版代码如下：

import torch
import torch.nn as nn
import torch.nn.functional as F
import math


class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        self.num_heads = num_heads
        self.d_model = d_model
        assert d_model % self.num_heads == 0
        # Define the dimension of each head or subspace
        self.d_k = d_model // self.num_heads
        # These are still of dimension d_model. They will be split into number of heads 
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        # Outputs of all sub-layers need to be of dimension d_model
        self.W_o = nn.Linear(d_model, d_model)
    
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        batch_size = Q.size(0)
        K_length = K.size(-2)
        # Scaling by d_k so that the soft(arg)max doesn't explode
        QK = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        # Apply the mask
        if mask is not None:
            QK = QK.masked_fill(mask.to(QK.dtype) == 0, float('-inf'))
        # Calculate the attention weights (softmax over the last dimension)
        weights = F.softmax(QK, dim=-1)
        # Apply the self attention to the values
        attention = torch.matmul(weights, V)
        return attention, weights


    def split_heads(self, x, batch_size):
        """
        The original tensor with dimension batch_size * seq_length * d_model is split into num_heads 
        so we now have batch_size * num_heads * seq_length * d_k
        """
        return x.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)

    def forward(self, q, k, v, mask=None):
        batch_size = q.size(0)
        # linear layers
        q = self.W_q(q)
        k = self.W_k(k)
        v = self.W_v(v)
        # split into multiple heads
        q = self.split_heads(q, batch_size)  
        k = self.split_heads(k, batch_size)  
        v = self.split_heads(v, batch_size)  
        # self attention
        scores, weights = self.scaled_dot_product_attention(q, k, v, mask)
        # concatenate heads
        concat = scores.transpose(1,2).contiguous().view(batch_size, -1, self.d_model)
        # final linear layer
        output = self.W_o(concat)
        return output, weights

self.qkv = nn.Linear(d_model, 3 * d_model)
# 在forward方法中
qkv = self.qkv(x)  # (batch_size, seq_len, 3 * d_model)
q, k, v = torch.split(qkv, d_model, dim=-1)  # split into three tensors

【★】大模型面试八股-花甘者浅狐【202307】：https://zhuanlan.zhihu.com/p/643560888

【★】Self-Attention为什么要除以根号d_k【20231026】：https://blog.csdn.net/tailonh/article/details/120544719

【10】Transformer中为什么舍弃BN改用LN?

【10】Transformer为什么要舍弃Batch Normalization改用Layer Normalization呢?

1.NLP中主流就是用LN，实验结果显示Layer Normalization这样做效果更好！

2.Transformer主要用的是Scaled-Dot Self Attention，里边的q,k是做内积的，

LN本质上是L2 Normalzation的简单变体，一般是LN之后再接一个Dense变换，这样||q||,||k||就会一定程度上得到控制，从而使Attention的值在合理范围内，不至于梯度消失/爆炸。如果换成BN，对||q||,

||k||的控制就没那么有效了。

为什么要做归一化：第一，归一化是有好处的，但不足以让归一化成为必选项。第二，以前主流的观点缓解ICS其实并不准确。第三，由于Variance Shift，对深层网络而言，归一化几乎是必选项。

探讨要做什么样的归一化（能在哪些维度做归一化）。对NLP（transformer）而言，对每个token的embedding也是经过叠加其他embedding产生的，所以对embedding进行归一化是必要操作。这就是layer normalization。

任何norm的意义都是为了让使用norm的网络的输入的数据分布变得更好，也就是转换为标准正态分布，数值进入敏感度区间，以减缓梯度消失，从而更容易训练。当然，这也意味着舍弃了除此维度之外其他维度的其他信息。