深入理解Transformer：注意力机制、模型架构与核心实现

注意力机制

序列模型与根本诉求

• 序列数据 ：按照特定顺序排列且顺序不可打乱的数据，如股票价格、语音信号、文本数据、视频数据等。
• 核心特点：样本与样本之间存在关联性。时间序列中表现为时间点关联，文本数据中表现为字词语义关联。
• 特殊性质：与表格数据不同，序列数据的本质规律和底层逻辑隐藏在样本间关联中，一般的机器学习域深度学习算法无法处理，需要专门序列算法处理。
• 序列算法的根部诉求是建立样本与样本之间的关，并借助这种关联提炼出对序列数据的理解。只有这样序列模型才能对序列数据实现分析、理解和预测。

序列模型：样本关联构建方式

---

• 在机器学习和深度学习领域，存在众多经典且有效的序列模型。这些模型通过不同机制建立样本与样本之间的关联：

1. ARIMA家族算法群（通过历史值加权求和预测未来值）

• 核心逻辑：过去影响未来，未来的值由过去的值加权求和而成，以此构建样本间关联。
• AR模型（自回归模型）
  $$y_t=c+w_1{y}_{t-1}+w_2{y}_{t-2}+\cdots +w_p{y}_{t-p}+{\epsilon }_t$$

2. 循环网络家族

• 核心逻辑：遍历时间点/样本点，将过去时间的信息传递存储在中间变量中，传递给下一个时间点，以此构建样本间关联。
• RNN模型（循环神经网络）[通过中间变量传递历史信息]
  $$h_t=W_{xh}\cdot X_t+W_{hh}\cdot h_{t-1}$$
• LSTM模型（长短期记忆网络）[引入门控机制，但核心仍是加权求和]
  $${\tilde{C}}_t=\tanh (W_{xi}\cdot X_t+W_{hi}\cdot h_{t-1}+b_i)$$

3. 卷积网络家族

• 核心逻辑：通过卷积核扫描实现样本关联，本质仍是矩阵点积的加权求和。
  

---

• 众多的序列架构都在使用加权求和的方式来建立样本与样本之间的关联。 通过对不同时间点或不同样本上点的值进行加权求和，可以轻松构建“上下文的复合表示”，只要尝试使用迭代的方式求解对样本进行加权求和的权重，就可以使算法获取对序列数据的理解。

序列模型的根本诉求

• 核心问题演变：从"如何建立样本关联"转变为"如何合理求解加权权重"。
• 行业共识：所有成功序列架构都采用加权求和方式建立样本关联。
• 关键突破点：Transformer创新性地使用注意力机制作为最佳权重计算方案。

注意力机制的本质

• 注意力机制是一个帮助算法辨别信息重要性的计算流程，它通过计算样本与样本之间相关性来判断每个样本之于一个序列的重要程度，并给这些样本赋予能代表其重要性的权重。

• 注意力机制能够为样本赋予权重的属性，完美匹配序列模型对权重计算的需求。Transformer正是利用注意力机制的这一特点，从而想到利用注意力机制来进行权重的计算。

• 注意力机制实现形式：包含经典注意力机制和自注意力机制两种主要形式。

  • 经典注意力机制：跨序列计算（序列A样本对序列B的重要程度）。典型应用如机器翻译等Seq2Seq任务。
  • 自注意力机制：序列内部计算（序列A样本对自身序列的重要程度）

• Transformer采用的是自注意力机制。

权重计算本质和意义

• 权重计算本质是通过计算样本间相关性来判断每个样本对序列的重要程度，并赋予具体数值权重。与序列模型的契合点：权重计算属性完美匹配序列模型需求，Transformer创新性地利用该特性进行权重计算。

---

• 问题1：为什么要计算序列中样本的重要性？ 计算重要性对于序列理解有什么意义？（计算序列中样本重要性的原因和对于序列理解意义）
• 序列中不同样本对理解序列含义的贡献程度不同，关键样本对理解序列本质逻辑至关重要，而非关键样本影响较小（贡献差异原理）。如：
  • 残缺句1：“尽管今天下了雨，但我因为（）而感到非常开心和兴奋” → 完全无法理解。
  • 残缺句2：“（），但我因为拿到了梦寐以求的工作offer而感到非常开心和兴奋” → 仍可理解核心信息。
• 权重分配机制: 自注意力机制会为"开心"、"兴奋"等关键情感词分配更高权重，因为这些词直接关联句子情感倾向。
• 模型优化价值：识别重要样本可引导算法重点学习，提升模型效率和理解能力。

• 历史发展背景: 从RNN到LSTM再到Transformer，研究者不断尝试克服长序列挑战，注意力机制通过"提效"路径解决了部分问题。

---

• 问题2：样本的重要性如何定义？（样本重要性的定义方法）
• 自注意力机制通过计算一个序列中样本间的相关性来定义重要性，与更多样本高度相关的样本通常对整体序列影响更大（信息枢纽）。（相关性判断标准）案例说明:
  • 原句：“经理在会议上宣布了重大的公司（重组）计划，员工们反应各异，但都对未来充满期待”。被抠除的"重组"一词与"公司"、“计划”、“会议”、“宣布"和"未来"等多个关键词高度相关。该词能回答"公司做了什么？”、“宣布了什么？”、"计划是什么？"等多个核心问题
• 高度相关的样本往往成为信息枢纽，连接并影响序列中的多个其他样本。（信息枢纽）

---

• 问题3：样本的重要性（序列中一个样本与其他样本之间的相关性）是如何计算的？（具体计算方法）
• NLP中，序列数据中的每个样本都会被编码为一个向量，文字数据(batch_size, vocab_size, embedding_dimension)被编码为词向量，时间序列数据(batch_size, time_step, input_dimensions)被编码为时序向量。无论是时间序列数据的时间点之间，还是文字序列的字/词之间，都被编码为向量形式。所以，在序列数据中，样本间的相关性本质上是向量与向量之间的相关性。
• 向量的相关性由两个向量点乘积衡量。
  • 完全同向（0°夹角）：点积最大，完全正相关。
  • 完全反向（180°夹角）：点积最小，完全负相关。
  • 正交（90°/270°夹角）：点积为零，无相关性。
    
• 向量的点积是两个向量相乘的过程。设有两个三维向量 $\mathbf{A}$ 和 $\mathbf{B}$，其点积的具体表达式如下：
  $$\mathbf{A}\cdot {\mathbf{B}}^T=(a_1,a_2,a_3)\cdot \left(\begin{array}{c}{b}_1\\ b_2\\ b_3\end{array}\right)=a_1\cdot b_1+a_2\cdot b_2+a_3\cdot b_3$$
• 从矩阵运算的角度看，点积的相乘结构为 $(1,3)\times (3,1)=(1,1)$，最终结果是一个标量（即单个数值）。

---

• 在NLP领域中，词向量数据或时间序列数据一定是具有多个样本，求解样本与样本两两之间的相关性，经过综合才可以计算出一个样本对整个序列的重要性。同时，样本与样本之间的相关性计算，即向量组之间的相关性计算还会受到向量顺序的影响。换言之，以以A为核心计算A-B相关性和以B为核心计算B-A相关性结果不同，即向量之间的相关性与顺序有关。例："我爱小猫咪"中，以"我"为核心时，"爱"和"小猫咪"都很重要。以"小猫咪"为核心时，"我"的重要性降低。

---

• 在文本分析中，若需评估样本间的语义关联，需计算AB、AA、BA、BB四组相关性（覆盖“跨样本问答”与“自样本问答”场景）。其中：

• 核心词（如“A”）作为「询问」（Question），非核心词（如“B”）作为「应答」（Key）；

• AB 相关性 = A 询问 × B 应答；AA 相关性 = A 自我询问 × 自我应答（同理 BB）。

• 假设有 2 个样本（A、B），每个样本编码为 4 维特征词向量，可将所有样本的特征向量按行排列成 特征矩阵 $X$（形状：$(2,4)$）。此时：

  • 计算「跨样本相关性」（如 AB）只需执行 $X\cdot X^T$（$X^T$ 为 $X$ 的转置，形状：$(4,2)$）；
  • 矩阵乘法的结果（形状：$(2,2)$）中，对角线元素对应 AA、BB 的自我相关性，非对角线元素对应 AB、BA 的跨样本相关性。

• 通过矩阵乘法，可以将多组相关性计算压缩为一次线性变换，大幅提升大规模文本数据的处理效率。
  
  上述点积结果得到的最终矩阵是：
  $$\left[\begin{array}{cc}{r}_{AA}& r_{AB}\\ r_{BA}& r_{BB}\end{array}\right]$$

• 该乘法规律可推广到任意维度数据：若有 $n$ 个样本，将其特征向量按行排列成矩阵后与自身转置相乘，得到 $n\times n$ 的相关性矩阵——矩阵中每个元素代表对应两个样本间的相关性（对角线为自相关性，非对角线为跨样本相关性）。

• 相关性矩阵的规模仅由样本数量决定，与单个样本的特征维度无关。因此，对任意数据集，只需计算“数据矩阵 × 自身转置”，即可自动获得所有样本两两之间的相关性矩阵。

---

• 在实际应用中不直接使用原始特征矩阵并让其与转置矩阵相乘，因为我们需要的是语义的相关性，所以在NLP总使用注意力机制时，往往会先在原始特征矩阵的基础上乘以一个解读语义的$w$参数矩阵（$w$是神经网络参数，通过迭代优化获得），需通过参数矩阵$w$生成语义化的$Q$和$K$矩阵。

transformer自注意力机制的运行流程

• Transformer 中注意力机制的核心是注意力分数的计算，其公式为：
  $$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$
• Step1:通过词向量得到QK矩阵。

1. 构建 Q 和 K 矩阵： 将原始特征矩阵（如词嵌入）分别通过线性变换得到查询矩阵 $Q$和键矩阵 $K$。二者相乘（$Q{K}^T$）并除以 $\sqrt{d_k}$（$d_k$ 为键向量的维度），得到基础的相关性分数（缩放操作避免梯度问题）。
   $$\begin{gathered} x\times w_Q=Q \\ x\times w_K=K \\ x\times w_V=V \end{gathered}$$
   • 除以 $\sqrt{d_k}$的原因的解释：$Q{K}^T$的过程中，词向量的维度越高，点积相加项越多，最终结果越大。在两个序列的实际相关程度一致的情况下，词向量的高特征维度可能导致巨大的相关性分数，因此需要对其进行标准化，但是标准化程度还需要适度，所以除以 $\sqrt{d_k}$。
2. 引入 V 矩阵： 原始特征还需通过另一线性变换得到值矩阵 $V$。注意力权重（$\text{softmax}$ 归一化后的相关性分数——注意力机制的权重）与 $V$ 相乘，最终构成“上下文相关的复合表示”——即每个 token 的输出是其与其他 token 加权（注意力权重）后的信息聚合。
   • softmax函数将每个单词之间的相关性向量转换成$[0,1]$之间的概率分布，如对AB两个样本，会求出AA、AB、BB、BA四个相关性，经过softmax函数转化，可以实现$P_{AA}+P_{AB}=1$、$P_{BB}+P_{BA}=1$，归一化后令一个样本的相关性总和为1，从而将相关性分数转化成性质上更接近“权重”之间的比例。

---

$$r=\left[\begin{array}{cc}{a}_{11}& a_{12}\\ a_{21}& a_{22}\end{array}\right],V=\left[\begin{array}{ccc}{v}_{11}& v_{12}& v_{13}\\ v_{21}& v_{22}& v_{23}\end{array}\right]$$

$$\begin{array}{rl}Z(Attention)& =\left[\begin{array}{cc}{a}_{11}& a_{12}\\ a_{21}& a_{22}\end{array}\right]\times \left[\begin{array}{ccc}{v}_{11}& v_{12}& v_{13}\\ v_{21}& v_{22}& v_{23}\end{array}\right]\\ & =\left[\begin{array}{ccc}{a}_{11}{v}_{11}+a_{12}{v}_{21}& a_{11}{v}_{12}+a_{12}{v}_{22}& a_{11}{v}_{13}+a_{12}{v}_{23}\\ a_{21}{v}_{11}+a_{22}{v}_{21}& a_{21}{v}_{12}+a_{22}{v}_{22}& a_{21}{v}_{13}+a_{22}{v}_{23}\end{array}\right]\end{array}$$

• 由观察可知，式子$a_{11}{v}_{11}+a_{12}{v}_{21}$对应着原始特征矩阵当中的第一个样本的第一个特征、第二个样本的第一个特征，两个$v$之间的加权求和所建立的联系，正是两个样本之间、两个时间步之间所建立的关联。
• 在计算过程中，$Z$的列脚标与权重无关，因为整个注意力得分矩阵与特征数量并无关联，因此在乘以矩阵$V$的过程中，矩阵$r$其实并不关心一行有几个$v$，它只关心这是哪行的$V$。

---

• 示例：4 词 6 维向量的计算逻辑

假设输入 4 个单词，每个单词编码为 6 维词向量（即原始特征矩阵形状为 $4\times 6$）：

• $Q$ 和 $K$ 由原始特征经不同线性层映射得到（形状仍为 $4\times d_k$，$d_k$ 通常设为 6 或其他值）；

• $V$ 则是原始特征的另一种线性变换结果（形状 $4\times d_v$，$d_v$ 可与 $d_k$ 不同）。
  通过 $Q{K}^T/\sqrt{d_k}$ 计算相关性，再与 $V$ 相乘，最终得到每个 token 融合了全局信息的输出。

• 这种设计让模型能动态关注输入序列中不同部分的重要性，是 Transformer 并行处理长序列的关键。

Multi-Head Attention多头注意力机制

Multi-Head Attention 是在 Self-Attention 的基础上扩展而来。对于输入的 embedding 矩阵：

• Self-Attention 仅使用一组权重矩阵 $W^Q,W^K,W^V$，通过线性变换得到 Query、Keys、Values；
• Multi-Head Attention 则使用多组（如 Transformer 原论文中使用的 8 组）不同的权重矩阵 $W_i^Q,W_i^K,W_i^V$（$i=1,2,\dots ,h$，$h$ 为头数），分别生成多组 Query、Keys、Values。
  
• 每组独立的注意力计算会得到一个输出矩阵 $Z_i$，最后将这些 $Z_i$ 拼接（Concatenate）并经过线性变换得到最终结果。
  

核心步骤公式化表示

设输入 embedding 矩阵为 $X$，则 Multi-Head Attention 的计算流程可表示为：
$$\text{MultiHead}(X)=\text{Concat}(Z_1,Z_2,\dots ,Z_h)W^O$$
其中，每个头的输出 $Z_i$ 由 Self-Attention 计算得到：
$$Z_i=\text{Attention}(X{W}_i^Q,X{W}_i^K,X{W}_i^V)$$
而 Self-Attention 的核心计算（Scaled Dot-Product Attention）为：
$$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$
这里 $d_k$ 是 Keys 的维度，用于缩放点积避免梯度消失。

关键区别总结

特性	Self-Attention	Multi-Head Attention
权重矩阵数量	1 组 $(W^Q,W^K,W^V)$	$h$ 组 $(W_i^Q,W_i^K,W_i^V)$
输出矩阵数量	1 个 $Z$	$h$ 个 $Z_i$
最终输出	直接输出 $Z$	拼接后经 $W^O$ 变换

• 通过多头并行计算，模型能同时关注不同位置的多种语义信息，增强表达能力和泛化性能。

公式中的 $W^O$

设输入 embedding 矩阵为 $X$，则 Multi-Head Attention 的计算流程可表示为：
$$\text{MultiHead}(X)=\text{Concat}(Z_1,Z_2,\dots ,Z_h)W^O$$

• $W^O$ 是输出权重矩阵（Output Weight Matrix）。 它的作用是将所有注意力头计算出的结果进行线性组合，最终生成一个统一的输出。

1. 维度匹配：每个头 $i$ 的输出 $Z_i$ 的维度与输入 $X$ 的维度是相关的。假设输入 $X$ 的维度是 [seq_len, d_model]，为了并行计算，通常会将其投影到更小的维度。设每个头的维度为 $d_k=d_v=d_{model}/h$。
   • 每个 $Z_i$ 的维度是 [seq_len, d_v]。
   • 将 $h$ 个 $Z_i$ 拼接（Concat）后，矩阵维度变为 [seq_len, h * d_v]，也就是 [seq_len, d_model]。
   • 虽然拼接后的维度与输入 $X$ 相同，但这只是一个简单的堆叠，信息之间没有交互。模型需要一个可学习的参数来决定如何融合这 $h$ 个头所捕获的不同信息。
2. 信息融合：$W^O$ 的作用就是学习如何最优地融合这 $h$ 个头的输出。它允许模型根据任务需求，为不同头学到的特征分配不同的权重，从而提取出最有价值的组合信息。可以把它看作是一个“决策层”，决定在哪个“表示子空间”中学到的信息更重要。

$W^O$ 的维度：

• 输入维度：h * d_v (即 d_model)
• 输出维度：d_model
• 所以 $W^O$ 的维度是 [d_model, d_model]。

---

完整的 Multi-Head Attention 计算流程

假设：

• 输入矩阵：$X$，维度为 [seq_len, d_model]
• 注意力头的数量：$h$
• 每个头的维度：$d_k=d_v=d_{model}/h$

步骤 1: 线性投影
为每个头 $i$ (从 1 到 $h$) 准备一组独立的权重矩阵：

• $W_i^Q\in {\mathbb{R}}^{d_{model}\times d_k}$
• $W_i^K\in {\mathbb{R}}^{d_{model}\times d_k}$
• $W_i^V\in {\mathbb{R}}^{d_{model}\times d_v}$
  用这些权重矩阵对输入 $X$ 进行线性变换，得到每个头自己的 Query, Key, Value：
  $$\begin{gathered} Q_i=X{W}_i^Q \\ {K}_i=X{W}_i^K \\ {V}_i=X{W}_i^V \end{gathered}$$

步骤 2: 并行计算 Scaled Dot-Product Attention
对每个头 $i$，独立地进行注意力计算：

$$Z_i=\text{Attention}(Q_i,K_i,V_i)=\text{softmax}\left(\frac{Q_i{K}_i^T}{\sqrt{d_k}}\right)V_i$$

这里 $Z_i$ 的维度是 [seq_len, d_v]。

步骤 3: 拼接
将所有 $h$ 个头的输出 $Z_1,Z_2,\dots ,Z_h$ 在最后一个维度上拼接起来：

$$\text{Concat}(Z_1,Z_2,\dots ,Z_h)$$

拼接后矩阵的维度是 [seq_len, $h\cdot d_v$]，即 [seq_len, d_model]。

步骤 4: 最终线性变换
将拼接后的结果乘以输出权重矩阵 $W^O$，得到最终的 Multi-Head Attention 输出：

$$\text{MultiHead}(X)=\text{Concat}(Z_1,Z_2,\dots ,Z_h)W^O$$
其中 $W^O\in {\mathbb{R}}^{d_{model}\times d_{model}}$。最终输出的维度是 [seq_len, d_model]，与输入 $X$ 的维度相同，方便进行残差连接。

总结与可视化

整个流程可以概括为下面的公式（这也是《Attention Is All You Need》论文中的原始公式）：
$$\begin{gathered} \text{MultiHead}(Q,K,V)=\text{Concat}({\text{head}}_1,\dots ,{\text{head}}_h)W^O \\ \text{where }{\text{head}}_i=\text{Attention}(Q{W}_i^Q,K{W}_i^K,V{W}_i^V) \end{gathered}$$
可视化流程：

          X (Input)                    X (Input)                    X (Input)|                            |                            ||                            |                            |v                            v                            vLinear Projection (W1Q)      Linear Projection (W2Q)      ...  Linear Projection (WhQ)Linear Projection (W1K)      Linear Projection (W2K)      ...  Linear Projection (WhK)Linear Projection (W1V)      Linear Projection (W2V)      ...  Linear Projection (WhV)|                            |                            |v                            v                            vQ1, K1, V1                  Q2, K2, V2                  ...  Qh, Kh, Vh|                            |                            |v                            v                            vScaled Dot-Product Attention  Scaled Dot-Product Attention  ...  Scaled Dot-Product Attention|                            |                            |v                            v                            vZ1                            Z2                          ...  Zh|                            |                            ||----------------------------|----------------------------||vConcat(Z1, Z2, ..., Zh)|vLinear Projection (WO)|vMultiHead(X) (Final Output)

• 公式 $\text{MultiHead}(X)=\text{Concat}(Z_1,Z_2,\dots ,Z_h)W^O$ 精确地描述了 Multi-Head Attention 机制的最后两个关键步骤：拼接和最终线性变换。而 $W^O$ 正是负责这个最终变换的可学习参数。

Transformer

Transformer模型的地位与发展历程

• Transformer模型自2017年横空出世以来，已成为人工智能领域最具革命性的架构之一，彻底改变了自然语言处理(NLP)的技术格局。这一开创性模型不仅重新定义了NLP领域的标准，更凭借其独特的注意力机制，将人工智能的应用边界拓展至计算视觉、时间序列预测等多个领域。
• 在Transformer诞生之前，深度学习领域面临着诸多挑战，而它的出现为解决歧义处理、多义词理解等难题提供了全新思路。模型的发展历程中，涌现出多个重要变体：2018年推出的GPT-1开创了生成式预训练的先河，而BERT则通过双向编码器设计进一步提升了模型理解能力。随着技术演进，针对长序列处理局限的改进版本如Transformer-XL也应运而生，引入了段级递归等创新机制。
• 近年来，Transformer架构的影响力持续扩大，2025年初中国推出的高性价比大型语言模型DeepSeek-R1就是这一技术路线的最新成果，标志着Transformer模型正朝着更高效、更普及的方向发展。尽管仍面临计算资源需求大等挑战，但Transformer无疑已成为现代AI技术栈中不可或缺的核心组件。

Transformer基本结构

• 要深入理解 Transformer 架构，需要从整体框架、核心组件和工作流程三个层面拆解。Transformer 由 编码器（Encoder） 和 解码器（Decoder） 两部分组成，二者均由多层相同的子层堆叠而成，核心创新在于自注意力机制（Self-Attention） 和并行计算能力，彻底改变了自然语言处理的范式。
• Transformer 通过自注意力机制实现了高效的序列建模，其核心组件（嵌入、位置编码、多头注意力、FFN、残差连接）协同工作，既保留了序列的顺序信息，又具备了强大的并行计算能力。理解 Transformer 的架构，有助于我们深入掌握现代 NLP 模型（如 BERT、GPT）的设计原理，为后续研究奠定基础。

---

Transformer 的核心思想是用注意力机制替代循环/卷积操作，实现高效的序列建模。其架构可分为四大部分：

1. 输入处理：对源序列（Inputs）和目标序列（Outputs）进行嵌入（Embedding）和位置编码（Positional Encoding）；
2. 编码器（Encoder）：负责将源序列转换为上下文表示（Contextual Representation）；
3. 解码器（Decoder）：基于编码器的输出和已生成的前缀序列，自回归生成目标序列；
4. 输出层：将解码器的输出映射为词汇表上的概率分布。

下图是 Transformer 的标准架构（源自原论文《Attention Is All You Need》）：

输入处理：嵌入与位置编码

Transformer 不依赖序列的固有顺序（如 RNN 的时序递推），因此需要显式注入位置信息。

• 嵌入层（Embedding）：将离散的 token（如单词、字符）转换为连续的向量表示，维度通常为 d_model（如 512）。例如，“hello” 可能被映射为一个 512 维的向量。
• 位置编码（Positional Encoding）：由于自注意力机制无法区分 token 的顺序（如 “猫吃鱼” 和 “鱼吃猫”），位置编码通过正弦/余弦函数生成与位置相关的向量，与嵌入向量相加后输入模型。公式如下：
  $$\text{PE}(pos,2i)=\sin \left(\frac{pos}{10000^{2i/d_{model}}}\right),\text{PE}(pos,2i+1)=\cos \left(\frac{pos}{10000^{2i/d_{model}}}\right)$$
  其中 pos 是 token 在序列中的位置，i 是维度索引。这种设计保证了模型能感知序列的先后顺序。

推荐深入阅读

• 从“失序”到“有序”：位置编码如何赋予Transformer序列感知力（有关Transformer架构中嵌入和位置编码的理解）
• 从“失序”到“有序”：位置编码如何赋予Transformer序列感知力（有关Transformer架构中嵌入和位置编码的理解）

编码器（Encoder）：提取源序列特征

编码器由 N 个相同的层堆叠而成（原论文中 N=6），每层包含两个子层：

• 多头自注意力（Multi-Head Self-Attention）：捕获序列内各 token 之间的依赖关系；
• 前馈神经网络（Feed-Forward Network, FFN）：对每个 token 的表示进行非线性变换。

每层子层之间通过残差连接（Residual Connection） 和层归一化（Layer Normalization） 连接，即：
$$\text{Sublayer}(x)=\text{LayerNorm}(x+\text{SublayerModule}(x))$$

• 残差连接解决了深度网络的梯度消失问题，层归一化则加速了训练收敛。

• 推荐阅读：Transformer的“隐形支柱”：残差连接

---

• NLP任务中经常会处理长度不同的句子，使用LN(Layer Normalization)可以不考虑其他样本的长度。

进行归一化的好处：

• 减少内部协方差偏移：深度学习训练中，参数更新会改变后续层激活分布，导致训练不稳定。Layer Normalization通过规范化每层输出，减轻该效应以稳定训练。
• 加速训练速度：归一化使梯度更稳定，允许更高学习率，加快模型收敛。
• 减少对初始值的依赖：Layer Normalization让输入数据分布变化更鲁棒，降低模型对参数初始值的敏感性。
• 允许更深网络训练：规范每层激活后，可训练更深网络结构，避免梯度消失或爆炸问题。

多头自注意力（Multi-Head Self-Attention）

自注意力是 Transformer 的核心，它允许每个 token 直接关注序列中所有其他 token，从而高效建模长距离依赖。具体步骤如下：

1. 线性投影：将输入向量 x 转换为三组矩阵：查询（Query, Q）、键（Key, K）、值（Value, V），公式为：
   $$Q=x{W}^Q,K=x{W}^K,V=x{W}^V$$
   其中 W^Q, W^K, W^V 是可学习的参数矩阵。
2. 注意力权重计算：通过缩放点积注意力（Scaled Dot-Product Attention） 计算每个 token 对其他 token 的关注度：
   $$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$
   其中 d_k 是 K 的维度（缩放因子避免 softmax 梯度消失），QK^T 表示查询与键的点积，结果越大表示相关性越强。
3. 多头扩展：将自注意力拆分为 h 个“头”（原论文中 h=8），每个头独立学习不同的注意力模式（如语法、语义），最后将结果拼接并线性变换：
   $$\text{MultiHead}(Q,K,V)=\text{Concat}({\text{head}}_1,...,{\text{head}}_h)W^O$$
   其中 ${\text{head}}_i=\text{Attention}(Q_i,K_i,V_i)$，$W^O$ 是输出投影矩阵。

示例：在句子“我爱北京天安门”中，token“我”通过自注意力可以关注到“爱”“北京”“天安门”，从而理解句子的语义结构。

---

Feed-Forward Network(FFN)

• 在Transformer中，前馈神经网络（FFN）是由线性层组成的深度神经网络结构。它的主要指责是对输入数据进行非线性变换，同时负责产生输出值。

• 自注意力机制大多数是一个线性结构：加权求和是一个线性操作，即便经过丰富的权重变化、由丰富的Q，K，V等矩阵点积的结果，还有softmax函数，但是自注意力机制依旧是一个线性的过程。因此，在加入前馈神经网络之前，transformer本身不具有传统意义上的非线性结构。

• 在Transformer中，FFN 是一个两层的全连接网络，对每个 token 的表示进行独立的非线性变换，公式为：
  $$\text{FFN}(x)=\max (0,x{W}_1+b_1)W_2+b_2$$
  其中 W_1, W_2 是权重矩阵，b_1, b_2 是偏置项。ReLU 激活函数引入非线性，增强模型的表示能力。

• Transformer中的前馈网络，对每个位置进行相同的独立变换，以增强模型能力。这种设计天然适合并行计算，其较宽的结构有助于捕获丰富特征，提供充足的模型容量。

• 以线性层结尾是深度学习的常见做法。Transformer的Encoder自带激活函数，可独立输出，因此可单独用于完成各类任务，无需Decoder部分。如：情感分类、文本分类、命名实体识别、关系抽取、文本生成的预训练。

Layer Normalization和Batch Normalization

Batch Normalization (BN)

• 做什么：在训练时，对一个批次中所有样本的同一神经元（或通道）的输出进行归一化，使其均值为0、方差为1。
• 优点：能显著加速收敛，有效缓解梯度消失/爆炸，对卷积网络效果极佳。
• 缺点：
  • 对批次大小敏感，小批次时效果差，无法用于批次大小为1的场景。
  • 在训练和推理时行为不一致（推理时使用全局统计量）。
  • 不适用于序列模型（如RNN），因为不同时间步的序列长度不一，无法形成稳定批次。

---

Layer Normalization (LN)

• 做什么：对单个样本的所有特征（或一个网络层的所有神经元）进行归一化。
• 优点：
  • 与批次大小无关，解决了BN在小批次和在线学习中的问题。
  • 训练与推理行为一致，逻辑更简单。
  • 天然适用于序列模型（RNN、Transformer），因为它对每个时间步独立归一化。
• 缺点：在某些CNN任务上，效果可能不如BN。

---

特性	Batch Normalization (BN)	Layer Normalization (LN)
归一化维度	批次 (Batch)	特征 (Feature)
计算范围	对同一个批次内，所有样本的同一个特征进行归一化。	对单个样本的所有特征进行归一化。
依赖性	强依赖于批次大小。	不依赖批次大小，适用于单个样本。
适用场景	CNN、大批次训练的前馈网络。	RNN、Transformer、小批次或在线学习场景。

---

• 最初BN是为CNN任务准备的，需要较大的BatchSize来保证统计量的可靠性，并在训练阶段记录全局的$u$和$\sigma$供预测任务使用。LN是独立于batch_size大小，只对单个输入样本的所有特征进行规范化。
• BN 是在“横向”（样本间）做归一化，关注的是同一个特征在不同样本中的分布。
• LN 是在“纵向”（特征间）做归一化，关注的是单个样本内部所有特征的分布。

解码器（Decoder）：生成目标序列

使用完整Transformer结构的任务

• 完整的Transformer结构包括编码器（encoder）和解码器（decoder）部分，通常用于需要将一个序列映射到另外一个序列的任务，一般会在需要高度依赖原始数据信息、尤其是需要语义转义的时候使用，因为Encoder有非常好的语义和数据想信息解析功能，可以帮助架构很好吸收原始数据的信息。如：

1. 机器翻译（Machine Translation）：将源语言的句子翻译为目标语言的句子，如英译汉。
2. 文本摘要（Text Summarization）：将长文本总结为简短的摘要，例如新闻标题总结。
3. 图像字幕生成（Image Captioning）：为给定的图像生成描述性的文字。
4. 文本到语言（text-to-Speech）：将文本转换为语言信号，如将输入文本转换为自然的语言输出。
5. 问答系统（Question Answering）：根据用户问题，给出回答。

适用encoder-only结构的任务

• 只使用decoder结构的模型适合需要生成连续序列任务，当更强调基于原有的信息基础上进行“创新、创造、写作”，而对原有的数据依赖程度不是很高时，通常会选择使用decoder-only结构。

1. 作为特征提取器：将输入序列转换为有意义特征表示，可用于分类、聚类、序列标注等机器学习任务。
2. 生成语义表示：获取输入序列的语义信息，支持语义相似度计算、文本匹配、信息检索等自然语言处理任务。
3. 序列到序列任务的编码器：仅对输入序列编码（如文本摘要、问答系统中将文本转为语义表示），无需生成输出序列。
4. 预训练模型基础：BERT（Bidirectional Encoder Representations from ）等预训练模型基于Transformer Encoder构建，其输出可作为下游任务输入，提供丰富语义信息。

适用decoder-only结构的任务

• 只使用decoder结构（通常被称为自回归模型或生成模型）适用于需要从部分输入生成完整序列的任务，例如：

1. 大语言模型（Language Modeling）：预测给定文本序列中的下一个词或字符（如GPT系列模型用于生成连续文本段落，但并非所有大语言模型都是decoder-only结构）。
2. 文本生成（text Generation）：根据部分输入生成完整文本（如根据开头一句话生成文章/故事，或根据部分诗句生成完整诗歌）。
3. 代码补全（Code Completion）：根据部分输入代码生成完整代码段。
4. 对话生成（Dialogue Generation）：根据对话历史生成下一句回复。
5. 问答系统（Question Answering）：根据上下文回答用户问题，或给定一段文本回答其中具体问题。

---

• 与Encoder不同的是，Decoder结构在不同的任务中承担不同的角色，存在不同的网络架构，不同的训练模式以及不同的数据流，因此我们需要了解不同的任务、才能知道Decoder结构。
  

解码器的输入与强制教学机制

• Decoder的输入与强制教学机制（teacher forcing）：Decoder的输入是滞后1个单位的标签矩阵（shifted right outputs），将真实标签输入给模型，并且让真实标签指导模型的学习和预测，让模型通过正确的标签来学习的流程在Transformer中被称为强制教学机制。
• 标签矩阵首先通过嵌入层（embedding）转换成固定大小的向量。就像 Encoder一样，Decoder 也会对这些嵌入向量添加位置编码，以包含序列中的位置信息。但输入到Decoder层中的sequence_length维度可以与输入到Encoder中的sequence_length维度不一致。
• 对序列来说，滞后是一种常见的操作，滞后是指将原来的序列向未来，向正向顺序的方向挪动，留出空置的行为。

import pandas as pd
df = pd.DataFrame({"值":[0.1543, 0.2731, 0.3626, 0.6732, 0.5123]
})
print("df")
print(df)
print("df.shift(1)")
print(df.shift(1))

df         df.shift(1)值         值
0  0.1543  0     NaN   
1  0.2731  1  0.1543
2  0.3626  2  0.2731
3  0.6732  3  0.3626
4  0.5123  4  0.6732

• 在Transformer当中，一般会为解码器的输入标签添加起始标记"SOS"（start of sequence），并将这个起始标记作为标签序列的第一行，当编码前的序列为[y1, y2, y3, y4]最终构成[“sos”，y1，y2，y3，y4]。
  

起始标记(SOS)的意义：

1. 标记序列的开始：SOS标记用于指示解码器开始生成序列。
2. 初始化解码器：解码阶段，解码器需要一个初始输入开启生成输出序列。SOS标记作为解码器的第一个输入，帮助其启动生成过程。
3. 模型一致性： 通过在每个输出序列的开始添加SOS标记，模型在训练时可以学到序列生成的起点，从而在推理是保持一致的生成过程。
   结束标记(EOS)的意义：
4. 标识序列的结束：EOS标记用于指示生成的序列的结束位置。对于模型在推理阶段停止生成非常重要。
5. 控制生成长度：在没有固定长度的输出序列中，EOS标记告诉模型何时停止生成，而不需要生成固定数量的时间步，使模型可以处理变长序列。
6. 训练终止条件：在训练阶段中，模型学会在适当的时候生成EOS标记，从而正确地结束序列。

• 在Seq2Seq（序列到序列）模型的训练过程中，需针对编码器和解码器的不同需求准备三类数据：

1. 输入与目标序列示例

• 输入序列：x = ["这", "是", "最", "好", "的", "时", "代"]
• 目标序列：y = ["it", "was", "the", "best", "of", "times"]

2. 三类数据的处理规则
   1. 编码器输入：编码器直接使用原始输入序列，不添加任何特殊标记。
   2. 解码器输入标签：为目标序列前添加起始标记（SOS），用于引导解码器开始生成序列。
   3. 解码器损失函数标签：为目标序列末尾添加结束标记（EOS），用于计算模型预测与真实目标的误差。
3. 处理后结果

数据类型	处理后的序列
编码器输入	["这", "是", "最", "好", "的", "时", "代"]
解码器输入标签	["SOS", "it", "was", "the", "best", "of", "times"]
解码器损失函数标签	["it", "was", "the", "best", "of", "times", "EOS"]

import torch
import torch.nn as nn# 假设词汇表大小（包括特殊标记如SOS和EOS）
vocab_size = 10
embedding_dim = 4# 创建嵌入层
embedding_layer = nn.Embedding(vocab_size, embedding_dim)# 假设索引0是SOS，索引1是EOS
SOS_token = 0
EOS_token = 1# 目标序列的索引表示（假设"it","was","the","best","of"对应索引2-6）
target_sequence = [2, 3, 4, 5, 6]# 添加起始标记和结束标记
decoder_input = [SOS_token] + target_sequence          # 解码器输入：[SOS, 2, 3, 4, 5, 6]
decoder_output = target_sequence + [EOS_token]           # 解码器输出（损失计算用）：[2, 3, 4, 5, 6, EOS]# 转换为张量
decoder_input_tensor = torch.tensor(decoder_input)
decoder_output_tensor = torch.tensor(decoder_output)# 嵌入操作
embedded_decoder_input = embedding_layer(decoder_input_tensor)  # 形状：(seq_len, embedding_dim)
embedded_decoder_output = embedding_layer(decoder_output_tensor)  # 形状：(seq_len, embedding_dim)# 打印结果（可选，用于验证）
print("Decoder Input (with SOS):", decoder_input_tensor)
print("Decoder Output (with EOS):", decoder_output_tensor)
print("Embedded Decoder Input:", embedded_decoder_input)
print("Embedded Decoder Output:", embedded_decoder_output)

Decoder Input (with SOS): tensor([0, 2, 3, 4, 5, 6])
Decoder Output (with EOS): tensor([2, 3, 4, 5, 6, 1])
Embedded Decoder Input: tensor([[ 1.3619,  1.2574, -0.6409,  1.9472],[ 1.3066,  0.0681,  2.2982,  1.3738],[ 0.0045,  1.0386, -0.4802, -0.2339],[ 0.1569,  1.6340,  1.3975,  0.7242],[ 1.7515, -1.1312, -0.0494,  0.0058],[ 1.5423, -0.5307, -0.0775,  1.7882]], grad_fn=<EmbeddingBackward0>)
Embedded Decoder Output: tensor([[ 1.3066,  0.0681,  2.2982,  1.3738],[ 0.0045,  1.0386, -0.4802, -0.2339],[ 0.1569,  1.6340,  1.3975,  0.7242],[ 1.7515, -1.1312, -0.0494,  0.0058],[ 1.5423, -0.5307, -0.0775,  1.7882],[-0.5114, -0.5827, -0.5385,  0.3626]], grad_fn=<EmbeddingBackward0>)

---

• 序列模型训练时，可以将部分真实标签当作输入特征。通过将标签与原始特征拼接，模型就能在学习时同时参考两者，做出更准确的决策。时间序列预测中的“带标签的滑窗”就是这种思想的典型应用。
• Transformer将“利用历史标签指导预测”的技巧，从时间序列推广到了任意序列数据（如文本），并应用到了更广泛的Seq2Seq任务中。然而，这两种任务的本质不同：时间序列预测是用序列的“过去”预测“未来”，属于生成式任务；而Seq2Seq任务（如机器翻译）是将一个完整序列转换为另一个，并非预测同一序列的未来部分。因此，时间序列预测更接近生成任务，而非典型的Seq2Seq。
• Encoder-decoder下的seq2seq任务：两个序列大概率不是一张表，而是用一张表去预测另外一张表。
  

强制教学机制的训练过程

在teacher force中，使用标签需融合特征矩阵与标签矩阵信息后再训练。以示例序列为例：

• 原始序列$x=\text{["这","是","最","好","的","时","代"]}$
• 真实标签$y=\text{["it","was","the","best","of","times"]}$

编码器输出的预测结果为$\hat{y}$，添加初始/结束词、经embedding后的矩阵为 ebd_X 和 ebd_y。

训练流程分步解析
第一步：输入 ebd_X & SOS → 输出时间步1的预测标签，对应真实标签$y[0]$

• Encoder输入：特征矩阵（包含原始序列各词的embedding表示）。
• Decoder输入：标签矩阵的前1个元素（如索引0处的sos，后续逐步加入真实标签前缀）。
• 输出目标：预测序列的第一个词$\hat{y}[0]$，真实标签为$y[0]=\text{"it"}$。
  
  第二步：输入 ebd_X & ebd_y[:1] → 输出$\hat{y}[1]$，对应真实标签$y[1]$
• Decoder输入更新：标签矩阵的前2个元素（含第一步预测的目标词前缀，如sos + 第一个真实标签）。
• 输出目标：预测序列的第二个词$\hat{y}[1]$，真实标签为$y[1]=\text{"was"}$。
  

第三步：输入 ebd_X & ebd_y[:2] → 输出$\hat{y}[2]$，对应真实标签$y[2]$

• Decoder输入更新：标签矩阵的前3个元素（持续加入真实标签前缀）。
• 输出目标：预测序列的第三个词$\hat{y}[2]$，真实标签为$y[2]=\text{"the"}$。
  
  以此类推…

---

通过“序列A（特征矩阵） + 序列B前半段（标签矩阵已生成部分）”预测“序列B后半段”的方式：

• 既避免泄露真实标签（仅用已生成的前半段），又能为下一词预测提供最大程度的准确信息——这是teacher forcing的核心逻辑。
• 训练时借助掩码自注意力+编码器 - 解码器注意力协作，实现并行计算，无需严格时间步顺序，一次性输入后即可获得完整预测序列。

强制教学机制的测试/推理过程

• 在测试和推理时，并不存在真实的标签矩阵，因此需要将上一个时间步预测的结果作为Decoder的输入。

训练流程分步解析
第一步：

• 输入 ebd_X & SOS → 输出时间步为1的预测标签，对应真实标签$y[0]$
• Encoder输入：特征矩阵（包含原始序列各词的embedding表示）。
• Decoder输入：输入Decoder：SOS编码序列。
• 输出目标：预测序列的第一个词$\hat{y}[1]$（对应真实标签为$y[0]=\text{"it"}$）。
  

第二步：输入 ebd_X & yhat[:1] → 输出时间步为2的预测标签，对应真实标签$y[1]$

• Encoder输入：特征矩阵（包含原始序列各词的embedding表示）。

• Decoder输入：输入Decoder：SOS编码序列。

• 输出目标：预测序列的第二个词$\hat{y}[2]$，真实标签为$y[1]=\text{"was"}$。
  
  以此类推…

• 强制教学机制在训练时通过掩码自注意力机制+编码器-解码器注意力层合作的方式实现并行，在推理或测试时是进行循环（逐个字符生成）。所以在实现推理代码时，需要手动写循环完成这个过程，每一步生成一个新词，并将其作为输入添加到序列中，知道生成结束标记“EOS”或达到最大长度为止。（此过程极为耗时）

掩码注意力与前瞻掩码

• 掩码多头自注意力（Masked Multi-Head Self-Attention） 层，用于保证自回归生成（即生成第 t 个 token 时，只能看到前 t-1 个 token）。每层包含三个子层：
• 掩码多头自注意力：防止看到未来 token；
• 编码器-解码器多头注意力：关注编码器的输出；
• 前馈神经网络：同编码器。

1. 掩码多头自注意力（Masked Multi-Head Self-Attention）
   目标序列在训练时会右移一位（如“Bonjour le monde” 变为 <sos> Bonjour le monde <eos>），因此解码器在生成第 t 个 token 时，不能访问后续的 token（如 t+1, t+2,...）。为此，我们在注意力权重的计算中加入掩码（Mask）：
   $$\text{MaskedAttention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}+M\right)V$$
   其中 M 是掩码矩阵，对角线以上的元素（未来位置的值）设为 -∞（softmax 后变为 0），对角线及以下为 0。这样，每个 token 只能关注到自己及之前的 token。这种技术通过将未来未位置的值设置为负无穷大（在softmax操作前），使得这些位置的影响力为零。
   
   
   
   当使用信息Q询问信息K时：

• Q的脚标=K的脚标，Q在询问和自己在同一个位置/同一个时间点的信息。
• Q的脚标>K的脚标，Q在询问在句子前方的/过去的时间点的信息。
• Q的脚标<K的脚标，Q在询问在句子后方的/未来的时间点的信息。
  

---

引入掩码矩阵的意义

• 阻止信息泄露：在解码过程中，为了保持输出的自回归性质（即每个输出仅依赖于先前的输出），模型不能提前访问未来位置的信息。在$Q{K}^T$矩阵中添加负无穷正是为了这一点，将负无穷加到某些位置上，是为了在计算注意力权重时，这些位置的影响被完全忽略。

• 影响softmax函数：在自注意力机制中，注意力权重是通过对$Q{K}^T$应用softmax函数计算得出的。当softmax函数作用于包含负无穷的值时，这些位置的指数值会趋于零，导致它们在计算最终的注意力权重时的贡献也趋于零。因此，这些未来的位置不会对当前或之前的输出产生影响。

• 保持生成顺序性：通过这种方式，Transformer能够按顺序逐个生成输出序列中的元素，每个元素的生成只依赖于之前的元素，从而有效地模拟序列生成任务中的时间顺序性和因果关系。

• 简而言之，将矩阵$Q{K}^T+M$中的上半部分变成负无穷实际上是一种控制措施，用于保证解码器在处理如机器翻译或文本生成等任务时，不会由于未来信息的干扰而产生错误或不自然的输出。这是确保模型生成行为的正确性和效率的关键技术手段。

---

• 使用简单的矩阵表示距离继续往下计算：
  $$\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}+M\right)=\left[\begin{array}{cccc}{a}_{11}& 0& 0& 0\\ a_{21}& a_{22}& 0& 0\\ a_{31}& a_{32}& a_{33}& 0\\ a_{41}& a_{42}& a_{43}& a_{44}\end{array}\right]$$
• 假设V矩阵（矩阵V是从原始标签y生成的embedding矩阵，因此矩阵V的序列方向是从上到下）。上角标为特征维度、下角标为样本序列。这里我们关注的主要是下角标——样本序列。为避免混淆，后续计算省略上角标
  $$\text{V}=\left[\begin{array}{cccc}{v}_1^1& v_1^2& v_1^3& v_1^4\\ v_2^1& v_2^2& v_2^3& v_2^4\\ v_3^1& v_3^2& v_3^3& v_3^4\\ v_4^1& v_4^2& v_4^3& v_4^4\end{array}\right]$$
• 矩阵 $\text{MaskedAttention}(Q,K,V)$ 的完整形式为：
  $$\begin{array}{rl}\text{MaskedAttention}(Q,K,V)& =\text{Decoder-Masked-Attention}\times V\\ & =\left[\begin{array}{cccc}{a}_{11}& 0& 0& 0\\ a_{21}& a_{22}& 0& 0\\ a_{31}& a_{32}& a_{33}& 0\\ a_{41}& a_{42}& a_{43}& a_{44}\end{array}\right]\left[\begin{array}{cccc}{v}_1& v_1& \cdots & v_1\\ v_2& v_2& \cdots & v_2\\ v_3& v_3& \cdots & v_3\\ v_4& v_4& \cdots & v_4\end{array}\right]\\ & =\left[\begin{array}{cccc}{a}_{11}{v}_1& a_{11}{v}_1& \cdots & a_{11}{v}_1\\ a_{21}{v}_1+a_{22}{v}_2& a_{21}{v}_1+a_{22}{v}_2& \cdots & a_{21}{v}_1+a_{22}{v}_2\\ a_{31}{v}_1+a_{32}{v}_2+a_{33}{v}_3& a_{31}{v}_1+a_{32}{v}_2+a_{33}{v}_3& \cdots & a_{31}{v}_1+a_{32}{v}_2+a_{33}{v}_3\\ a_{41}{v}_1+a_{42}{v}_2+a_{43}{v}_3+a_{44}{v}_4& a_{41}{v}_1+a_{42}{v}_2+a_{43}{v}_3+a_{44}{v}_4& \cdots & a_{41}{v}_1+a_{42}{v}_2+a_{43}{v}_3+a_{44}{v}_4\end{array}\right]\end{array}$$
• 在$\text{MaskedAttention}(Q,K,V)$矩阵中，$V$上携带的信息的时间点不会超过分数$a$中携带的信息的时间点，权重和句子信息在交互时都只能与“过去”的信息交互，而不能与“未来”信息交互。通过这种方式，最终带掩码的注意力机制实现未来信息的保密。

2. 编码器-解码器多头注意力（Encoder-Decoder Attention）
   该子层的目的是让解码器融合编码器的上下文信息。其 Query 来自解码器前一层的输出，Key 和 Value 来自编码器的输出（即编码器最后一层的输出），公式为：
   $$\text{Attention}(Q_{\text{dec}},K_{\text{enc}},V_{\text{enc}})$$
   例如，在机器翻译任务中，解码器生成“Bonjour”时，会关注编码器对“Hello”的表示，从而确保翻译的准确性。

---

• 前瞻掩码（Look-ahead Masking）与带掩码的注意力机制（Maskd Self-Attention）都是Transformer模型中用来控制信息流的技术，特别是在解码器中。虽然两者都使用掩码来避免未来信息的干扰，它们的应用上存在一些关键的区别，但是实现的目标是完全一致的。

• 前瞻掩码是在Transformer的解码器中应用的，目的是确保在生成序列的每一步时，模型只能访问到当前及之前的位置的信息。这种掩码通常是通过在自注意力层的权重计算过程中使用一个上三角掩码实现的。具体来说，它是在矩阵的上三角部分（不包括对角线）设置为-∞，这防止了每个输出依赖于它之后的输出。它能够确保解码器在生成第i个元素时，不能“看到”第i个元素之后的任何输入，这对于如文本生成这样的自回归任务至关重要，因为模型必须按顺序生成输出。

• 而带掩码的注意力机制（Masked Self-Attention）虽然也是用于控制信息流，但它的应用可以更广泛一些，不限于解码器。在某些情况下，如在处理某些特定任务时，可能需要阻止模型访问某些特定的输入信息。根据任务需求，可以设计各种形式的掩码。例如，在处理带有图像区域的注意力模型时，可能需要掩盖图像的某些部分。这种掩码机制的目的是通用的，可以用于阻止模型在任何类型的注意力计算中访问不应该被访问的信息。

• 没有掩码时的输入数据y （对解码器来说，输入数据是真实标签矩阵）
  $$Y=\left[\begin{array}{cccc}{y}_{11}& y_{12}& y_{13}& y_{14}\\ y_{21}& y_{22}& y_{23}& y_{24}\\ y_{31}& y_{32}& y_{33}& y_{34}\\ y_{41}& y_{42}& y_{43}& y_{44}\end{array}\right]$$

• 在有掩码时，掩码矩阵M
  $$M=\left[\begin{array}{cccc}0& -\infty & -\infty & -\infty \\ 0& 0& -\infty & -\infty \\ 0& 0& 0& -\infty \\ 0& 0& 0& 0\end{array}\right]$$

• 将两个矩阵相加，构成掩码后的矩阵masked y
  $$\text{masked }y=y+M=\left[\begin{array}{cccc}{y}_{11}& -\infty & -\infty & -\infty \\ y_{21}& y_{22}& -\infty & -\infty \\ y_{31}& y_{32}& y_{33}& -\infty \\ y_{41}& y_{42}& y_{43}& y_{44}\end{array}\right]$$

• 在Transformer中，直接使用前瞻掩码会影响的是矩阵$Q$和矩阵$K$的生成。在这种情况下，在$Q{K}^T$矩阵上不再添加掩码矩阵，对于transformer来说，将掩码使用在注意力机制中，或者直接对y进行前瞻掩码都是可以实现目的的手段。

编码器-解码器注意力层

• 编码解码器注意力层（“交叉注意力”层）允许解码器的每个位置访问整个编码器的输出，对于将输入序列的上下文信息整合到输出序列的生成中时必须的。该层的设计是为了确保解码器能欧给予完整的输入序列信息来生成每个输出元素。
• 首先，编码器-解码器注意力层的输入是来自多头注意力机制的输出结果。从Decoder的掩码注意力层中输出的是经过掩码后、每一行只携带特定时间段信息的结果$C_{decoder}$：
  $$\begin{array}{rl}{\text{C}}_{decoder}& =\left[\begin{array}{cccc}{a}_{11}{v}_1& a_{11}{v}_1& \cdots & a_{11}{v}_1\\ a_{21}{v}_1+a_{22}{v}_2& a_{21}{v}_1+a_{22}{v}_2& \cdots & a_{21}{v}_1+a_{22}{v}_2\\ a_{31}{v}_1+a_{32}{v}_2+a_{33}{v}_3& a_{31}{v}_1+a_{32}{v}_2+a_{33}{v}_3& \cdots & a_{31}{v}_1+a_{32}{v}_2+a_{33}{v}_3\\ a_{41}{v}_1+a_{42}{v}_2+a_{43}{v}_3+a_{44}{v}_4& a_{41}{v}_1+a_{42}{v}_2+a_{43}{v}_3+a_{44}{v}_4& \cdots & a_{41}{v}_1+a_{42}{v}_2+a_{43}{v}_3+a_{44}{v}_4\end{array}\right]\end{array}$$
• 使用覆盖的时间点作为脚标(脚标只代表时间维度/序列长度的维度，省略了特征维度上的脚标)，简化为
  $$\begin{array}{rl}{\text{C}}_{decoder}& =\left[\begin{array}{cccc}{c}_1& c_1& \cdots & c_1\\ c_{1\to 2}& c_{1\to 2}& \cdots & c_{1\to 2}\\ c_{1\to 3}& c_{1\to 3}& \cdots & c_{1\to 3}\\ c_{1\to 4}& c_{1\to 4}& \cdots & c_{1\to 4}\end{array}\right]\end{array}$$
• 从Encoder中输出的是没有掩码的注意力机制结果$C_{encoder}$，由于没有掩码，所以Encoder中的注意力分数为
  $$A=\left[\begin{array}{cccc}{a}_{11}& a_{12}& a_{13}& a_{14}\\ a_{21}& a_{22}& a_{23}& a_{24}\\ a_{31}& a_{32}& a_{33}& a_{34}\\ a_{41}& a_{42}& a_{43}& a_{44}\end{array}\right]$$
• 同样，$V$矩阵省略特征维度，使用脚标代表时间点、seq_len的信息，简化的$V$表示为：
  $$V=\left[\begin{array}{cccc}{v}_1& v_1& \cdots & v_1\\ v_2& v_2& \cdots & v_2\\ v_3& c_3& \cdots & c_3\\ v_4& c_4& \cdots & c_4\end{array}\right]$$
• 由于$C_{encoder}=A\times V$，最终结果矩阵$C_{encoder}$：
  $$C_{encoder}=\left[\begin{array}{cccc}{a}_{11}\cdot v_1+a_{12}\cdot v_2+a_{13}{v}_3+a_{14}{v}_4& a_{11}\cdot v_1+a_{12}\cdot v_2+a_{13}{v}_3+a_{14}{v}_4& \cdots & a_{11}\cdot v_1+a_{12}\cdot v_2+a_{13}{v}_3+a_{14}{v}_4\\ a_{21}\cdot v_1+a_{22}\cdot v_2+a_{23}{v}_3+a_{24}{v}_4& a_{21}\cdot v_1+a_{22}\cdot v_2+a_{23}{v}_3+a_{24}{v}_4& \cdots & a_{21}\cdot v_1+a_{22}\cdot v_2+a_{23}{v}_3+a_{24}{v}_4\\ a_{31}\cdot v_1+a_{32}\cdot v_2+a_{33}{v}_3+a_{34}{v}_4& a_{31}\cdot v_1+a_{32}\cdot v_2+a_{33}{v}_3+a_{34}{v}_4& \cdots & a_{31}\cdot v_1+a_{32}\cdot v_2+a_{33}{v}_3+a_{34}{v}_4\\ a_{41}\cdot v_1+a_{42}\cdot v_2+a_{43}{v}_3+a_{44}{v}_4& a_{41}\cdot v_1+a_{42}\cdot v_2+a_{43}{v}_3+a_{44}{v}_4& \cdots & a_{41}\cdot v_1+a_{42}\cdot v_2+a_{43}{v}_3+a_{44}{v}_4\end{array}\right]$$
• 同样，使用覆盖的时间点作为脚标(为了方便观看，同样省略了特征维度上的脚标)，则有：
  $$C_{encoder}=\left[\begin{array}{cccc}{c}_{1\to 4}& c_{1\to 4}& \cdots & c_{1\to 4}\\ c_{1\to 4}& c_{1\to 4}& \cdots & c_{1\to 4}\\ c_{1\to 4}& c_{1\to 4}& \cdots & c_{1\to 4}\\ c_{1\to 4}& c_{1\to 4}& \cdots & c_{1\to 4}\end{array}\right]$$
• 虽然4列C虽然覆盖的时间维度一致，但却属于不同的特征维度。

---

• 此时，$C_{encoder}$ 携带的是特征矩阵$X$的信息，$C_{encoder}$ 中的每个元素都携带了全部时间步上的信息。$C_{decoder}$ 携带的是真实标签的信息，$C_{decoder}$ 中的元素则是每一行代表一段时间的信息，随着行数的增加这段时间窗口越来越长。编码器 - 解码器注意力层负责整合这两部分信息。
• 具体来说，编码器解码器输出的结果结合的方式是——将解码器中的标签信息 $C_{decoder}$ 作为 Q 矩阵，将编码器中输出的特征信息 $C_{encoder}$ 作为 K 和 V 矩阵，使用每行 Q 与全部的 K、V 相乘，来执行一种特殊的注意力机制，公式如下
  $$\begin{array}{rl}Contex{t}_1& =\sum _{i}Attention(Q_1,K_i)\times V_i\\ Contex{t}_2& =\sum _{i}Attention(Q_2,K_i)\times V_i\\ Contex{t}_3& =\sum _{i}Attention(Q_3,K_i)\times V_i\\ & \cdots \end{array}$$
• 在这个公式中，Q与K转置相乘的地方不再是点积，而是按全新的加和规则相乘相加。转换成矩阵则有$C_{decoder}(Q)$的第一行乘以$C_{encoder}$($K^T$)的第一列，加上$C_{decoder}(Q)$的第一行乘以$C_{encoder}$($K^T$)的第二列，加上$C_{decoder}(Q)$的第一行乘以$C_{encoder}$($K^T$)的第三列……直到所有的列都被乘完为止。

$$\begin{gathered} Contex{t}_1=\left[\begin{array}{cccc}{c}_1& c_1& \cdots & c_1\\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \end{array}\right]\cdot \left[\begin{array}{cccc}{c}_{1\to 4}& \cdots & \cdots \cdots & \\ c_{1\to 4}& \cdots & \cdots \cdots & \\ c_{1\to 4}& \cdots & \cdots & \cdots \\ c_{1\to 4}& \cdots & \cdots & \cdots \end{array}\right] \\ + \\ \left[\begin{array}{cccc}{c}_1& c_1& \cdots & c_1\\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \end{array}\right]\cdot \left[\begin{array}{cccc}\cdots & c_{1\to 4}& \cdots & \cdots \\ \cdots & c_{1\to 4}& \cdots & \cdots \\ \cdots & c_{1\to 4}& \cdots & \cdots \\ \cdots & c_{1\to 4}& \cdots & \cdots \end{array}\right] \\ + \\ \left[\begin{array}{cccc}{c}_1& c_1& \cdots & c_1\\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \end{array}\right]\cdot \left[\begin{array}{cccc}\cdots & \cdots & \cdots & c_{1\to 4}\\ \cdots & \cdots & \cdots & c_{1\to 4}\\ \cdots & \cdots & \cdots & c_{1\to 4}\\ \cdots & \cdots & \cdots & c_{1\to 4}\end{array}\right] \end{gathered}$$

• 以上公式是标签中的第一个时间步与特征中的所有时间步产生关联。
  $$\begin{gathered} Contex{t}_1=\left[\begin{array}{cccc}\cdots & \cdots & \cdots & \cdots \\ c_{1\to 2}& c_{1\to 2}& \cdots & c_{1\to 2}\\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \end{array}\right]\cdot \left[\begin{array}{cccc}{c}_{1\to 4}& \cdots & \cdots \cdots & \\ c_{1\to 4}& \cdots & \cdots \cdots & \\ c_{1\to 4}& \cdots & \cdots & \cdots \\ c_{1\to 4}& \cdots & \cdots & \cdots \end{array}\right] \\ + \\ \left[\begin{array}{cccc}\cdots & \cdots & \cdots & \cdots \\ c_{1\to 2}& c_{1\to 2}& \cdots & c_{1\to 2}\\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \end{array}\right]\cdot \left[\begin{array}{cccc}\cdots & c_{1\to 4}& \cdots & \cdots \\ \cdots & c_{1\to 4}& \cdots & \cdots \\ \cdots & c_{1\to 4}& \cdots & \cdots \\ \cdots & c_{1\to 4}& \cdots & \cdots \end{array}\right] \\ + \\ \left[\begin{array}{cccc}\cdots & \cdots & \cdots & \cdots \\ c_{1\to 2}& c_{1\to 2}& \cdots & c_{1\to 2}\\ \cdots & \cdots & \cdots & \cdots \\ \cdots & \cdots & \cdots & \cdots \end{array}\right]\cdot \left[\begin{array}{cccc}\cdots & \cdots & \cdots & c_{1\to 4}\\ \cdots & \cdots & \cdots & c_{1\to 4}\\ \cdots & \cdots & \cdots & c_{1\to 4}\\ \cdots & \cdots & \cdots & c_{1\to 4}\end{array}\right] \end{gathered}$$
• 标签中的第一个和第二个时间步与特征中的所有时间步产生关联。
• 以此类推，知道形成新的注意力机制矩阵，后续进入softmax，并于$V$相乘也类似。

输出层：概率分布生成

解码器的最终输出经过两层变换得到目标序列的概率分布：

1. 线性层（Linear）：将解码器的输出（维度 d_model）映射到词汇表大小（维度 vocab_size）；
2. Softmax 层：将线性层的输出转换为概率分布，选择概率最高的 token 作为当前步的输出。

总结

• Transformer模型在自然语言处理等序列任务中表现卓越，源于其创新设计与高效信息处理能力。自注意力机制可灵活捕捉长距离依赖，避免梯度消失与计算低效；编码器层逐层提取聚合信息，解码器层结合自回归构建输出序列，支撑翻译、文本生成等任务。编码器 - 解码器注意力机制是理解输入输出关联的关键，使模型适用于传统NLP及图像处理等多模态任务，展现灵活性。Transformer的出现标志着深度学习处理序列数据的重大进步，未来基于其的创新应用将推动人工智能边界拓展。