模块A：Transformer基础与变体 面试题库

本模块涵盖自注意力机制、位置编码、Transformer架构全貌、关键变体（BERT/GPT/T5等）、高效Transformer改进及综合应用与代码实现，共81题。

一、自注意力机制（Self-Attention）——15题

A-1. 【⭐⭐】什么是自注意力机制？它与传统注意力机制的核心区别是什么？

答案：

自注意力机制（Self-Attention），又称内部注意力（Intra-Attention），是Transformer架构的核心组件。其本质特征是Q（Query）、K（Key）、V（Value）三个矩阵都来自于同一个输入序列。

与传统注意力的核心区别：

核心优势：

1. 全局依赖建模：任意两个token之间的依赖路径长度为 $O(1)$，与它们在序列中的距离无关
2. 完全并行化：所有位置的计算可在同一层内同时进行，时间复杂度 $O(1)$（按层计算）
3. 可解释性强：注意力权重矩阵 $A \in \mathbb{R}^{n \times n}$ 直接反映token之间的重要性关系

A-2. 【⭐⭐⭐】请写出Scaled Dot-Product Attention的完整公式推导，并分析每个步骤的维度变化。

答案：

给定输入序列 $X \in \mathbb{R}^{n \times d_{model}}$，其中 $n$ 为序列长度，$d_{model}$ 为模型维度。

Step 1 — 线性投影生成Q、K、V：

$$Q = XW^Q, \quad K = XW^K, \quad V = XW^V$$

其中 $W^Q, W^K \in \mathbb{R}^{d_{model} \times d_k}$，$W^V \in \mathbb{R}^{d_{model} \times d_v}$ 为可学习的投影矩阵。

Step 2 — 计算缩放点积注意力分数：

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

完整维度分析：

按位置展开的完整形式：

对于第 $i$ 个位置的输出：

$$\text{Attention}(Q, K, V)i = \sum{j=1}^{n} \underbrace{\frac{\exp\left(\frac{q_i \cdot k_j}{\sqrt{d_k}}\right)}{\sum_{l=1}^{n}\exp\left(\frac{q_i \cdot k_l}{\sqrt{d_k}}\right)}}{\alpha{ij}} v_j$$

其中 $\alpha_{ij}$ 是第 $i$ 个token对第 $j$ 个token的注意力权重，满足 $\sum_{j=1}^{n} \alpha_{ij} = 1$。

A-3. 【⭐⭐⭐】为什么要除以 $\sqrt{d_k}$？请从数学上证明如果不缩放会发生什么。

答案：

核心原因：防止点积值过大导致softmax梯度消失。

数学推导：

假设 $q_i$ 和 $k_j$ 的每个分量是独立随机变量，均值为0，方差为1。则：

$$q_i \cdot k_j = \sum_{m=1}^{d_k} q_{i,m} \cdot k_{j,m}$$

由中心极限定理：
- $\mathbb{E}[q_i \cdot k_j] = 0$
- $\text{Var}(q_i \cdot k_j) = d_k$

不缩放的后果：

当 $d_k$ 较大时（如64、128），点积的绝对值的标准差为 $\sqrt{d_k}$，会变得很大：

1. Softmax饱和：当输入到softmax的值 $|x| \gg 0$ 时，softmax输出趋近于one-hot分布（某个值为1，其余为0）
2. 梯度消失：softmax在极端值附近的梯度几乎为0，导致反向传播时梯度消失

$$\frac{\partial \text{softmax}(x_i)}{\partial x_j} = \text{softmax}(x_i)(\delta_{ij} - \text{softmax}(x_j))$$

当softmax输出趋近于one-hot时，该梯度矩阵趋近于零矩阵。

缩放后的效果：

$$\text{Var}\left(\frac{q_i \cdot k_j}{\sqrt{d_k}}\right) = \frac{d_k}{d_k} = 1$$

缩放后点积的方差恒为1，与维度 $d_k$ 无关，保证了softmax输入的数值稳定性。

A-4. 【⭐⭐⭐】Multi-Head Attention的完整数学定义是什么？为什么需要多头？多头能否等效为单头大矩阵？

答案：

数学定义：

$$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h)W^O$$

其中每个注意力头：

$$\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) = \text{softmax}\left(\frac{QW_i^Q (KW_i^K)^T}{\sqrt{d_k}}\right)VW_i^V$$

参数维度：
- $W_i^Q, W_i^K \in \mathbb{R}^{d_{model} \times d_k}$
- $W_i^V \in \mathbb{R}^{d_{model} \times d_v}$
- $W^O \in \mathbb{R}^{hd_v \times d_{model}}$

通常设置 $d_k = d_v = d_{model}/h$，例如 $d_{model}=512, h=8$ 时，$d_k=d_v=64$。

为什么需要多头？

1. 多子空间表示：每个头在不同的低维子空间中计算注意力，可以捕捉不同类型的依赖关系——句法关系、语义关系、共指关系等
2. 表达能力增强：类比CNN中的多个滤波器，不同头关注不同的特征模式
3. 集成学习效应：多个头的输出拼接后投影，类似于集成多个注意力函数

关键追问：多头注意力是否可等效为单头大矩阵？

答案：否！ 多头本质上是子空间学习，不是简单的矩阵分解。原因在于：

• 每个头有独立的Q/K/V投影矩阵
• 每个头经过独立的softmax归一化（非线性操作）
• softmax的非线性特性使得多头的表达能力强于单头

若将多头合并为单头大矩阵 $W^{Q’} \in \mathbb{R}^{d_{model} \times hd_k}$，则所有头共享同一个softmax，失去了多子空间独立归一化的能力。

A-5. 【⭐⭐⭐】自注意力的时间/空间复杂度分析？与RNN、CNN的定量对比？

答案：

自注意力复杂度（按序列长度 $n$ 和维度 $d$ 分析）：

与RNN、CNN的定量对比：

关键分析：

• RNN：每步计算简单但串行执行，长距离依赖需要 $O(n)$ 步传播，容易出现梯度消失问题
• CNN：通过空洞卷积（dilated conv）可以增加感受野，但依赖路径仍需 $O(\log n)$ 层，且对长距离依赖的建模能力有限
• Self-Attention：任意两个位置直接交互，依赖路径长度为 $O(1)$（单层内），但代价是 $O(n^2)$ 的复杂度

实际数值感受（设 $d=512$）：

A-6. 【⭐⭐】注意力分数矩阵 $QK^T$ 的对角线元素代表什么？Padding Mask和Causal Mask的原理分别是什么？

答案：

对角线元素的含义：

$QK^T$ 的第 $(i, i)$ 个元素是 $q_i \cdot k_i$，代表第 $i$ 个token自己对自己的注意力分数。在self-attention中，这个位置通常有较高的值，因为token与自身的相似度天然较高。

两种Mask的类型和原理：

1. Padding Mask（填充掩码）：

处理变长序列中的 <PAD> 标记，使模型不关注填充位置。

$$\text{scores}{masked} = \text{scores} + \text{mask}, \quad \text{其中 } \text{mask}{ij} = \begin{cases} 0 & \text{if } j \text{ is valid} \ -\infty & \text{if } j \text{ is padding} \end{cases}$$

在softmax中，$\exp(-\infty) = 0$，因此填充位置不会对输出产生贡献。

2. Look-Ahead Mask / Causal Mask（因果掩码）：

在Decoder的自回归生成中，防止当前位置看到未来的token。

$$\text{mask}_{ij} = \begin{cases} 0 & \text{if } i \geq j \text{ (允许看到当前和之前的位置)} \ -\infty & \text{if } i < j \text{ (屏蔽未来位置)} \end{cases}$$

为什么Decoder必须需要Causal Mask？

训练时所有位置同时计算（并行），但推理时只能看到已生成的token。Causal Mask确保训练和推理行为一致——训练时模拟推理的自回归约束。

A-7. 【⭐⭐⭐⭐⭐】Self-Attention的排列等变性（Permutation Equivariance）是什么？为什么位置编码必须存在？

答案：

定义： 对于任意排列矩阵 $P$，Self-Attention满足：

$$\text{SelfAttn}(PX) = P \cdot \text{SelfAttn}(X)$$

含义： 如果重新排列输入序列的顺序，输出也会以相同的方式重新排列，但每个位置内部的表示内容不变。

推导证明：

令 $X’ = PX$，则：

$$Q’ = PXW^Q = PQ, \quad K’ = PK, \quad V’ = PV$$

$$Q’(K’)^T = PQ(PK)^T = P(QK^T)P^T$$

$$\text{softmax}(Q’(K’)^T)V’ = P \cdot \text{softmax}(QK^T)P^T \cdot PV = P \cdot \text{SelfAttn}(X)$$

为什么位置编码必须存在？

正是因为Self-Attention是排列等变的——如果不加入位置信息：

• 模型完全无法区分序列顺序
• “我爱你” 和 “你爱我” 将被编码为完全相同的语义表示
• 所有位置的信息完全对称，无法处理任何依赖顺序的任务

对比RNN/CNN：
- RNN天然有序列结构，通过时间步隐式编码位置
- CNN通过卷积核的感受野隐式编码局部位置
- Transformer完全并行处理，必须显式注入位置信息

A-8. 【⭐⭐】Self-Attention和Cross-Attention的本质区别是什么？它们各自用在Transformer的哪些位置？

答案：

核心区别：

在Transformer中的位置：

1. Encoder的Multi-Head Self-Attention：Q、K、V都来自输入序列，计算每个token对所有token的注意力（双向）

2. Decoder的Masked Multi-Head Self-Attention：Q、K、V来自目标序列（已生成的部分），用Causal Mask保证自回归特性

3. Decoder的Multi-Head Cross-Attention：Q来自Decoder前一层输出，K/V来自Encoder的最终输出，建立源-目标映射

A-9. 【⭐⭐】为什么说Transformer中的Attention可以看作是一种可学习的全连接层？与标准全连接层的异同？

答案：

相似之处：

Self-Attention的输出可以表示为输入的加权和：

$$\text{Output}i = \sum{j=1}^{n} \alpha_{ij} v_j = \sum_{j=1}^{n} \alpha_{ij} (x_j W^V)$$

这可以看作是以 $\alpha_{ij}$ 为权重、将输入线性组合到输出的操作，类似于全连接层的线性变换。

核心区别：

Attention作为动态滤波器：

$$\text{Output} = A(X) \cdot X W^V$$

其中 $A(X) = \text{softmax}\left(\frac{XW^Q(XW^K)^T}{\sqrt{d_k}}\right)$ 是一个依赖于输入X的动态权重矩阵。这使得Attention能够根据输入内容自适应地调整信息流动路径。

A-10. 【⭐⭐】Attention权重矩阵 $A$ 有哪些可解释性？多头注意力中不同头通常各自关注什么？

答案：

Attention权重的可解释性：

1. 局部聚焦：某些头（尤其是浅层）倾向于关注相邻位置的token，类似于n-gram特征
2. 句法关系：某些头能够捕捉特定的句法关系（如主语-谓语、名词-修饰语）
3. 共指消解：深层的一些头能够连接代词与其指代的名词
4. 分隔符关注：部分头特别关注 [SEP] 或 [CLS] 等特殊token

不同头的分工模式（经验发现）：

注意力可视化分析： 通过绘制注意力热力图（heatmap），可以直观看到：
- 对角线上的高值表示自关注
- 垂直条带可能表示某个token对所有位置的重要性（如 [CLS]）
- 特定位置的横向关注模式揭示语法依赖

A-11. 【⭐⭐⭐⭐⭐】请推导Self-Attention的梯度传播公式。在深层Transformer中，梯度消失/爆炸是如何被控制的？

答案：

Self-Attention的梯度传播：

设注意力输出 $O = AV$，其中 $A = \text{softmax}(S)$，$S = QK^T/\sqrt{d_k}$。

梯度传播链：

$$\frac{\partial \mathcal{L}}{\partial Q} = \frac{1}{\sqrt{d_k}} \cdot \frac{\partial \mathcal{L}}{\partial S} K, \quad \frac{\partial \mathcal{L}}{\partial K} = \frac{1}{\sqrt{d_k}} \cdot \left(\frac{\partial \mathcal{L}}{\partial S}\right)^T Q$$

$$\frac{\partial \mathcal{L}}{\partial V} = A^T \frac{\partial \mathcal{L}}{\partial O}, \quad \frac{\partial \mathcal{L}}{\partial X} = \frac{\partial \mathcal{L}}{\partial Q} (W^Q)^T + \frac{\partial \mathcal{L}}{\partial K} (W^K)^T + \frac{\partial \mathcal{L}}{\partial V} (W^V)^T$$

Softmax的梯度：

$$\frac{\partial A_{ij}}{\partial S_{kl}} = A_{ij}(\delta_{ik}\delta_{jl} - A_{il}\delta_{ik})$$

深层Transformer的梯度控制机制：

1. 残差连接（Residual Connection）：

$$y = x + \text{Module}(x) \Rightarrow \frac{\partial y}{\partial x} = I + \frac{\partial \text{Module}(x)}{\partial x}$$

即使 $\frac{\partial \text{Module}(x)}{\partial x}$ 很小，跳跃连接 $I$ 保证梯度有效传播。

2. Layer Normalization：稳定每层的输出分布，防止梯度爆炸

3. Pre-LN架构：在现代大模型中，LayerNorm放在残差连接之前，进一步确保梯度稳定性

4. 缩放因子 $1/\sqrt{d_k}$：防止注意力分数过大导致softmax梯度消失

A-12. 【⭐⭐⭐⭐⭐】如果将Attention中的softmax替换为其他归一化函数（如ReLU、线性归一化），会对模型产生什么影响？

答案：

使用ReLU替代Softmax：

$$\text{ReLU-Attention}(Q, K, V) = \frac{\text{ReLU}(QK^T)}{\sum_j \text{ReLU}(q_i \cdot k_j)} V$$

影响分析：

1. 稀疏性：ReLU会将负值置零，使得注意力权重更加稀疏——部分token完全不关注其他某些token
2. 无上限约束：正值没有上界（softmax输出上限为1），可能导致注意力分布不均匀
3. 梯度特性：ReLU在正区间的梯度恒为1，在负区间梯度为0，简化了梯度传播

ReLU Attention vs Softmax Attention：

线性Attention（kernel方法）：

$$\text{sim}(q_i, k_j) = \phi(q_i)^T \phi(k_j)$$

通过特征映射 $\phi$ 避免softmax，将复杂度从 $O(n^2)$ 降到 $O(n)$，但牺牲了注意力的精确聚焦能力。

结论：Softmax的指数特性使Attention具有”赢家通吃”的倾向，能够精确聚焦关键位置。非Softmax变体在特定场景下有效，但通常在需要精确检索的任务上表现较差。

A-13. 【⭐⭐】Transformer中Self-Attention的Dropout是如何应用的？为什么要对注意力权重应用Dropout？

答案：

Dropout在Self-Attention中的应用位置：

1. 注意力权重Dropout（Attention Dropout）：对softmax后的注意力权重矩阵 $A$ 应用Dropout
   - 位置：$\text{Dropout}(\text{softmax}(QK^T/\sqrt{d_k}})) \times V$
   - 作用：随机屏蔽某些注意力连接，防止过拟合

2. 残差连接前Dropout（Residual Dropout）：对子层输出应用Dropout后再加到残差上
   - 位置：$x + \text{Dropout}(\text{Sublayer}(x))$

3. 嵌入Dropout（Embedding Dropout）：对Embedding + Positional Encoding的输出应用

对注意力权重应用Dropout的原因：

• 防止共适应：阻止模型过度依赖某些特定的注意力连接
• 增强鲁棒性：使模型学会不依赖单个注意力路径
• 正则化效果：相当于在注意力图上施加随机稀疏性约束

注意：Dropout只在训练时应用，推理时关闭。现代大模型中，由于数据量极大，Dropout率往往设为0（如GPT-3不使用Dropout）。

A-14. 【⭐⭐⭐】Low-Rank Self-Attention（低秩自注意力）是什么？有哪些代表性方法？

答案：

核心思想： 标准Self-Attention中，注意力矩阵 $A = \text{softmax}(QK^T/\sqrt{d_k}) \in \mathbb{R}^{n \times n}$ 是满秩的。低秩方法通过将Attention限制在低秩子空间来降低计算复杂度。

Linformer（代表性方法）：

$$\text{Linformer}(Q, K, V) = \text{softmax}\left(\frac{Q(KE)^T}{\sqrt{d_k}}\right)VF$$

其中 $E, F \in \mathbb{R}^{n \times k}$ 是可学习的投影矩阵，将 $K, V$ 从长度 $n$ 投影到固定长度 $k$。

复杂度从 $O(n^2)$ 降到 $O(n \cdot k)$。

其他低秩方法：

局限性：
- 低秩近似在长序列精确建模上仍有差距
- 投影矩阵 $E, F$ 增加了额外参数量
- 序列长度 $n$ 变化时需要特殊处理

A-15. 【⭐⭐】BERT/GPT/T5三种架构分别使用了哪种类型的Attention？它们的Mask策略有何不同？

答案：

BERT的双向Attention：

BERT使用Transformer Encoder，每个token可以看到序列中所有其他位置的token。预训练时通过MLM（Masked Language Model）随机mask掉部分token，让模型利用双向上下文预测被mask的token。

GPT的单向Attention：

GPT使用Transformer Decoder，每个位置 $i$ 只能看到位置 $\leq i$ 的token。通过Causal Mask实现：

$$\text{Mask}_{ij} = \begin{cases} 0 & i \geq j \ -\infty & i < j \end{cases}$$

T5的混合Attention：

• Encoder层使用标准双向Self-Attention + Padding Mask
• Decoder第一层使用Masked Self-Attention + Causal Mask
• Decoder第二层使用Cross-Attention（Q来自Decoder，K/V来自Encoder）

二、位置编码（Positional Encoding）——10题

A-16. 【⭐⭐】为什么Transformer需要位置编码？没有位置编码会怎样？

答案：

根本原因： Self-Attention是排列等变的（Permutation Equivariant）。即如果打乱输入token的顺序，输出也只会相应重排，每个token的表示内容本身不会改变。

没有位置编码的后果：
- 模型完全无法区分序列顺序
- “我爱你” 和 “你爱我” 将被编码为完全相同的语义表示
- 所有位置的信息完全对称，无法处理任何依赖顺序的任务

对比RNN/CNN：
- RNN：天然有序列结构，通过时间步隐式编码位置
- CNN：通过卷积核的感受野隐式编码局部位置
- Transformer：完全并行处理，必须显式注入位置信息

$$\text{Input} = \text{Token Embedding} + \text{Positional Encoding}$$

A-17. 【⭐⭐】请写出原始Sinusoidal位置编码的完整公式，并分析波长特性。

答案：

对于位置 $pos$（从0开始）和模型维度索引 $i$（从0到 $d_{model}-1$）：

$$PE(pos, 2i) = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right)$$

$$PE(pos, 2i+1) = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right)$$

参数解释：
- $pos$：token在序列中的位置索引（0, 1, 2, …, n-1）
- $i$：维度索引，$i \in [0, d_{model}/2 - 1]$
- $d_{model}$：模型维度（如512、768、1024）
- $10000$：预定义的基数，控制频率范围
- $10000^{2i/d_{model}}$：分母，决定不同维度的波长

等效写法：

$$PE(pos, 2i) = \sin(pos \cdot \omega_i), \quad \omega_i = 10000^{-2i/d_{model}}$$

波长特性分析：

对于第 $i$ 组维度，波长 $\lambda_i$ 满足：

$$\lambda_i = 2\pi \cdot 10000^{2i/d_{model}}$$

• 当 $i=0$ 时：$\lambda_0 = 2\pi \approx 6.28$（最小波长，最高频率）
• 当 $i=d_{model}/2-1$ 时：$\lambda_{max} = 2\pi \cdot 10000 \approx 62832$（最大波长，最低频率）

频率设计意图：

A-18. 【⭐⭐】为什么Sinusoidal编码使用sin/cos成对出现？这种设计如何让模型学到相对位置？

答案：

sin/cos成对使用的核心原因：使模型能够学习相对位置关系。

对于固定偏移量 $k$，$PE(pos+k)$ 可以表示为 $PE(pos)$ 的线性函数：

$$\sin(\omega_i(pos+k)) = \sin(\omega_i pos)\cos(\omega_i k) + \cos(\omega_i pos)\sin(\omega_i k)$$

$$\cos(\omega_i(pos+k)) = \cos(\omega_i pos)\cos(\omega_i k) - \sin(\omega_i pos)\sin(\omega_i k)$$

矩阵形式：

$$\begin{bmatrix} PE(pos+k, 2i) \ PE(pos+k, 2i+1) \end{bmatrix} = \begin{bmatrix} \cos(\omega_i k) & \sin(\omega_i k) \ -\sin(\omega_i k) & \cos(\omega_i k) \end{bmatrix} \begin{bmatrix} PE(pos, 2i) \ PE(pos, 2i+1) \end{bmatrix}$$

这个变换矩阵正是二维旋转矩阵！它表示将位置 $pos$ 的编码向量旋转一个角度 $\omega_i k$ 就得到了位置 $pos+k$ 的编码。

相对位置学习机制：

Attention计算中 $q_i$ 与 $k_j$ 的点积涉及 $PE(i)$ 和 $PE(j)$ 的组合。由于上述线性关系，点积结果天然包含了 $(j-i)$ 的信息，模型只需学习关注特定的频率组合即可推断相对位置关系。

A-19. 【⭐⭐】位置编码与词嵌入相加后，是否会破坏词嵌入的语义信息？为什么这种简单相加是有效的？

答案：

相加方式：

$$X = \text{Embedding}(tokens) + PE(positions)$$

为何不会破坏词嵌入语义：

1. 数值范围匹配：位置编码的值域为 $[-1, 1]$，与经过初始化的词嵌入（通常均值为0，标准差较小，如0.02）量级相当
2. 模型可以学习区分：Transformer后续的线性层和非线性激活具有强大的表示分离能力
3. 类比信号处理：类似于在载波信号上调制信息，后续处理层可以解调出各成分
4. 实验验证：BERT使用可学习的位置编码（与词嵌入相加后一起训练），证明了这种简单相加方式在实践中非常有效

A-20. 【⭐⭐⭐】绝对位置编码与相对位置编码的区别？各有哪些代表性方法和优缺点？

答案：

各方法详细分析：

1. Sinusoidal（绝对）：
- 优点：无需训练；连续可微可外推；蕴含相对位置关系
- 缺点：非自适应，可能不是最优的

2. 可学习位置编码（BERT）：
- 优点：灵活适应数据分布；实现简单
- 缺点：无法外推超过训练长度；可能过拟合训练长度

3. T5相对位置偏置：
- 在注意力分数中添加可学习的相对位置偏置 $b(i-j)$
- 优点：更好建模相对位置关系
- 缺点：额外参数量

4. RoPE（旋转位置编码）：
- 通过旋转矩阵将位置信息融入Q、K向量
- 优点：优秀的外推能力

5. ALiBi：
- 给注意力分数添加与距离成比例的负偏置
- 优点：无需额外参数；外推性好

A-21. 【⭐⭐⭐⭐⭐】RoPE（旋转位置编码）的完整公式推导。为什么它能让注意力分数只依赖于相对位置？

答案：

核心思想： 将位置信息通过旋转矩阵注入到Q和K向量中，使得内积 $q_m^T k_n$ 仅依赖于相对距离 $m-n$。

Step 1 — 将d维向量分为d/2个二维复数对：

$$\bar{q}_n^{(l)} = q_n^{(2l)} + i \cdot q_n^{(2l+1)}, \quad l = 0, 1, \ldots, d/2-1$$

Step 2 — 对每个复数对施加旋转：

$$\tilde{q}_n^{(l)} = \bar{q}_n^{(l)} \cdot e^{in\theta_l}$$

其中 $\theta_l = 10000^{-2l/d}$ 为预定义频率。

Step 3 — 旋转矩阵形式（实数形式）：

对于第 $l$ 对维度 $[2l, 2l+1]$，旋转矩阵为：

$$R_{\Theta,n}^{(l)} = \begin{bmatrix} \cos(n\theta_l) & -\sin(n\theta_l) \ \sin(n\theta_l) & \cos(n\theta_l) \end{bmatrix}$$

完整的旋转矩阵 $R_{\Theta,n} \in \mathbb{R}^{d \times d}$ 是块对角矩阵。

Step 4 — RoPE编码后的Q、K：

$$\tilde{q}n = R{\Theta,n} \cdot q_n, \quad \tilde{k}m = R{\Theta,m} \cdot k_m$$

Step 5 — 关键性质：内积仅依赖相对位置

$$\tilde{q}n^T \tilde{k}_m = q_n^T R{\Theta,n}^T R_{\Theta,m} \, k_m = q_n^T R_{\Theta,m-n} \, k_m$$

核心关键： $R_{\Theta,n}^T R_{\Theta,m} = R_{\Theta,m-n}$（旋转矩阵的正交性）

因此内积结果仅依赖于 $m-n$，实现了真正的相对位置编码。

RoPE的PyTorch实现：

class RoPE(nn.Module):
    """旋转位置编码 (Rotary Position Embedding)"""
    def __init__(self, d_model, max_len=2048, base=10000):
        super().__init__()
        self.d_model = d_model
        inv_freq = 1.0 / (base ** (torch.arange(0, d_model, 2).float() / d_model))
        t = torch.arange(max_len, dtype=torch.float)
        freqs = torch.einsum('i,j->ij', t, inv_freq)
        self.register_buffer('cos_cached', freqs.cos())
        self.register_buffer('sin_cached', freqs.sin())

    def rotate_half(self, x):
        x1, x2 = x.chunk(2, dim=-1)
        return torch.cat([-x2, x1], dim=-1)

    def forward(self, x, seq_len):
        cos = self.cos_cached[:seq_len].unsqueeze(0).unsqueeze(0)
        sin = self.sin_cached[:seq_len].unsqueeze(0).unsqueeze(0)
        cos = torch.cat([cos, cos], dim=-1)
        sin = torch.cat([sin, sin], dim=-1)
        return x * cos + self.rotate_half(x) * sin

A-22. 【⭐⭐】ALiBi（Attention with Linear Biases）的原理是什么？为什么它具有良好的外推能力？

答案：

核心思想： 不给token添加位置嵌入向量，而是直接在注意力分数上添加与距离成线性负相关的偏置。

公式：

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} - b \cdot |i-j|\right)V$$

其中：
- $i, j$ 为token的位置索引
- $|i-j|$ 为token间的绝对距离
- $b$ 为负斜率参数，通常每个头设置不同的值：$b_h = 2^{-\frac{8}{h}}$

特点分析：

1. 无需额外参数：偏置是预定义的，不需要学习
2. 训练更稳定：相比可学习位置编码，ALiBi收敛更快更稳定
3. 外推能力强：线性偏置对训练时未见过的更长序列泛化良好

为什么ALiBi外推能力强？

ALiBi的注意力偏置只依赖于相对距离 $|i-j|$，这个函数形式是固定的、与训练长度无关的。当推理序列超过训练长度时：
- 已有的距离模式（近处关注强、远处关注弱）继续适用
- 新增的远距离只是偏置更负（注意力更弱），这是模型的预期行为

A-23. 【⭐⭐⭐⭐⭐】可学习位置编码与正弦位置编码的对比？为什么BERT选择可学习位置编码，而原始Transformer使用正弦编码？

答案：

核心对比：

BERT选择可学习位置编码的原因：

1. 灵活性：让模型自己学习最优的位置表示，适应具体的预训练数据分布
2. 预训练-微调范式适配：BERT的预训练长度（512）和微调长度通常一致，外推不是主要问题
3. 简化实现：直接用nn.Embedding实现，代码更简单

原始Transformer使用正弦编码的原因：

1. 外推性：正弦编码是连续函数，可以推广到训练时未见过的更长序列
2. 固定且确定：不需要额外的训练参数
3. 相对位置性质：sin/cos成对设计蕴含了相对位置信息

A-24. 【⭐⭐⭐⭐⭐】什么是NTK-aware Position Interpolation？为什么它能帮助RoPE外推到更长的序列？

答案：

问题背景：

RoPE的注意力分数依赖于 $\cos((m-n)\theta_l)$ 和 $\sin((m-n)\theta_l)$。当推理序列长度 $L’$ 超过训练长度 $L$ 时，相对距离 $|m-n|$ 可能达到 $L’$，出现 $\theta_l L’ > 2\pi$ 的高频振荡，模型无法适应。

Position Interpolation（PI）：

将位置索引按比例缩放：

$$m’ = m \cdot \frac{L}{L’}$$

NTK-aware插值（非线性缩放）：

核心洞察：不同频率维度对缩放有不同的敏感度。

• 高频维度（$i$ 小，$\theta_i$ 大）：对缩放敏感，过度缩放会丢失精细位置信息
• 低频维度（$i$ 大，$\theta_i$ 小）：对缩放不敏感，可以承受更大缩放

NTK-aware方法通过调整基数（base）来实现非均匀缩放：

$$\text{new_base} = \text{base} \cdot s^{d/(d-2)}$$

其中 $s = L’/L$ 是缩放比例。这导致高频维度缩放较少，低频维度缩放较多，更好地保留了高频信息。

YaRN的改进：

在NTK-aware基础上增加温度缩放：

$$\text{Attention} = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k} \cdot t}\right)V$$

其中 $t > 1$ 是温度因子。

A-25. 【⭐⭐】位置编码的演进脉络是什么？从Sinusoidal到RoPE到ALiBi，每种方法解决了什么问题？

答案：

演进时间线：

每种方法解决的问题：

核心趋势：
1. 从绝对编码到相对编码
2. 从需要学习参数到无需参数
3. 从固定外推到自适应长序列

三、Transformer架构全貌——15题

A-26. 【⭐⭐】请详细描述Transformer Encoder-Decoder的完整结构，并说明每个子层的作用。

答案：

整体架构概览：

Input → [Embedding + Positional Encoding] → Encoder × N → Decoder × N → Linear + Softmax → Output

Encoder层（N=6层，原始论文，每层包含两个子层）：

1. Multi-Head Self-Attention：处理输入序列，每个位置关注所有位置（双向注意力）
   - 输入：$X \in \mathbb{R}^{n \times d_{model}}$
   - 输出：$\text{MultiHead}(X, X, X) \in \mathbb{R}^{n \times d_{model}}$

2. Feed-Forward Network（FFN）：对每个位置独立进行非线性变换
   - 输入：Attention输出
   - 输出：经过升维-激活-降维后的表示

每个子层后有：残差连接 + Layer Normalization

$$\text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) \quad \text{(Post-LN)}$$

Decoder层（N=6层，每层包含三个子层）：

1. Masked Multi-Head Self-Attention：自回归地关注已生成的位置（单向）
   - 使用Causal Mask防止看到未来token

2. Multi-Head Cross-Attention：Q来自Decoder，K/V来自Encoder的最后输出
   - 建立源序列和目标序列之间的映射关系

3. Feed-Forward Network：非线性变换

每个子层后同样有：残差连接 + Layer Normalization

输出层：
- 最后的Decoder输出经过Linear层映射到词表维度
- 再经过Softmax得到下一个token的概率分布

A-27. 【⭐⭐⭐】Feed-Forward Network（FFN）的结构是什么？为什么采用两层线性变换+ReLU？GELU和SwiGLU的改进是什么？

答案：

标准FFN结构定义：

$$\text{FFN}(x) = \max(0, xW_1 + b_1)W_2 + b_2$$

或写作：

$$\text{FFN}(x) = W_2 \cdot \text{ReLU}(W_1 x + b_1) + b_2$$

维度变化：
- 第一层：$d_{model} \rightarrow d_{ff}$（升维，$d_{ff} = 4d_{model} = 2048$）
- ReLU激活
- 第二层：$d_{ff} \rightarrow d_{model}$（降维）

为什么这样设计？

1. 增加非线性表达能力：ReLU引入非线性，使模型能学习更复杂的特征变换
2. 升维再降维的”信息瓶颈”效应：中间维度更大，允许模型在高维空间中做更丰富的特征映射，类似于AutoEncoder的结构
3. 位置级独立处理：FFN对每个位置独立应用（无位置间交互），补充了Attention的跨位置交互能力

现代改进 — GELU：

BERT、T5等使用GELU替代ReLU：

$$\text{GELU}(x) = x \cdot \Phi(x) = x \cdot \frac{1}{2}\left[1 + \text{erf}\left(\frac{x}{\sqrt{2}}\right)\right]$$

近似形式：

$$\text{GELU}(x) \approx 0.5x\left(1 + \tanh\left[\sqrt{\frac{2}{\pi}}\left(x + 0.044715x^3\right)\right]\right)$$

GELU相比ReLU：平滑可微、在负区间有微小梯度（信息保留更好）

现代改进 — SwiGLU（LLaMA等）：

$$\text{SwiGLU}(x) = (\text{SiLU}(xW_{gate}) \odot xW_{up})W_{down}$$

其中 $\text{SiLU}(x) = x \cdot \sigma(x)$（也称Swish激活），$\sigma$ 为sigmoid函数。

为什么SwiGLU性能更好？

1. 门控机制：类似LSTM中的门控，可以自适应地控制信息流
2. 非线性更丰富：Swish激活 + 逐元素乘法引入了更强的非线性
3. 经验验证：Google的PaLM、LLaMA、Mistral等都使用SwiGLU

LLaMA中SwiGLU的参数量调整：

使用SwiGLU时有三组权重矩阵（gate、up、down），为维持参数量不变，中间维度调整为：

$$d_{ff} = \frac{2}{3} \times 4d_{model} = \frac{8}{3}d_{model}$$

A-28. 【⭐⭐⭐】Layer Normalization vs Batch Normalization的详细对比？为什么Transformer选择LayerNorm？

答案：

核心对比：

Transformer选择LayerNorm的原因：

1. 序列长度变化：NLP中序列长度不一（如从几到几千），BatchNorm难以稳定计算统计量
2. 小batch场景：NLP训练常用小batch（如8、16），BatchNorm的统计量不稳定
3. 独立性要求：Transformer中每个位置的计算应保持一定的独立性
4. 训练推理一致性：LayerNorm训练和推理行为完全一致，简化部署

完整公式：

$$\text{LayerNorm}(x) = \gamma \odot \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} + \beta$$

其中：
- $\mu = \frac{1}{d}\sum_{i=1}^{d} x_i$（单样本均值）
- $\sigma^2 = \frac{1}{d}\sum_{i=1}^{d}(x_i - \mu)^2$（单样本方差）
- $\gamma, \beta$ 为可学习的缩放和平移参数

RMSNorm（LLaMA等使用）：

LayerNorm的变体，去掉均值中心化，只使用均方根：

$$\text{RMSNorm}(x) = \frac{x}{\sqrt{\frac{1}{d}\sum_{i=1}^{d}x_i^2 + \epsilon}} \cdot \gamma$$

实验表明RMSNorm在LLM中略优于标准LayerNorm，且计算更简单。

A-29. 【⭐⭐⭐⭐⭐】Pre-LN vs Post-LN的详细对比？为什么现代大模型（GPT、LLaMA）大多使用Pre-LN？

答案：

两种结构的定义：

Post-LN（原始Transformer）：

$$y_l = \text{LayerNorm}(x_l + \text{Module}(x_l))$$

Pre-LN（现代LLM如GPT、LLaMA）：

$$y_l = x_l + \text{Module}(\text{LayerNorm}(x_l))$$

详细对比分析：

现代模型选择Pre-LN的主要原因：

1. 梯度稳定性：Pre-LN在每个子层模块之前进行归一化，使得残差连接可以直接传播梯度，避免了深层网络中的梯度消失问题

$$\frac{\partial y_L}{\partial x_1} = \prod_{l=1}^{L-1} \left(I + \frac{\partial f_l}{\partial x_l}\right) \cdot \text{(well-conditioned terms)}$$

2. 训练效率：Pre-LN可以使用更大的学习率，不需要漫长的warmup阶段
3. 深层模型适配：随着模型层数增加到几十甚至上百层，Post-LN的梯度消失问题越来越严重

Pre-LN的潜在问题：

• “Massive Activations”：由于残差连接绕过了LayerNorm，隐状态的方差可以随深度指数增长，可能导致数值不稳定
• 一些研究提出Peri-LN（同时归一化输入和输出）来缓解这个问题

A-30. 【⭐⭐⭐】残差连接（Residual Connection）的作用与数学原理。在深层Transformer中为什么必不可少？

答案：

作用： 解决深层网络的梯度消失/爆炸问题，确保信息可以直接从浅层传到深层。

数学表达：

$$y = x + \text{Module}(x)$$

梯度分析：

$$\frac{\partial y}{\partial x} = I + \frac{\partial \text{Module}(x)}{\partial x}$$

在反向传播时，梯度会通过两条路径传播：
1. 跳跃连接（$I$）：恒等映射，梯度不衰减
2. 模块路径：正常反向传播

为什么能缓解梯度消失？

假设网络有 $L$ 层，在没有残差连接时，梯度是 $L$ 个Jacobian矩阵的乘积：

$$\frac{\partial y_L}{\partial x} = \prod_{l=1}^{L} J_l$$

每个 $J_l$ 的范数如果小于1，多次乘积后梯度会指数级衰减。

有了残差连接后（简化分析）：

$$x_{l+1} = x_l + f(x_l) \approx x_l \quad \text{(当 } f \text{ 较小时)}$$

网络近似于恒等映射，梯度传播类似于：

$$\frac{\partial y_L}{\partial x} \approx I + \text{(small terms)}$$

即使某些层的梯度很小，跳跃连接也能保证梯度有效传播。

在Transformer中的特殊重要性：

• Transformer通常有几十到上百层
• 每层包含Attention和FFN两个子层，每个子层都有残差连接
• 残差连接使得模型可以安全地堆叠大量层而不出现梯度消失
• 信息可以在不同层级间自由流动

A-31. 【⭐⭐⭐⭐⭐】Transformer Decoder中Cross-Attention的工作原理是什么？为什么在Decoder中需要Cross-Attention而不是只用Self-Attention？

答案：

Cross-Attention的结构：

$$\text{CrossAttn}(Q_{dec}, K_{enc}, V_{enc}) = \text{softmax}\left(\frac{Q_{dec}K_{enc}^T}{\sqrt{d_k}}\right)V_{enc}$$

维度分析：
- $Q_{dec} \in \mathbb{R}^{m \times d}$（$m$ 为目标序列长度）
- $K_{enc}, V_{enc} \in \mathbb{R}^{n \times d}$（$n$ 为源序列长度）
- 注意力分数矩阵：$\mathbb{R}^{m \times n}$
- 输出：$\mathbb{R}^{m \times d}$

Q、K、V的来源：
- Q（Query）：来自Decoder前一层的输出（表示”我想生成什么”）
- K（Key）：来自Encoder的最终输出（表示”源序列各位置的特征”）
- V（Value）：来自Encoder的最终输出（表示”源序列各位置的内容”）

为什么Decoder需要Cross-Attention？

1. 源-目标对齐：每个目标位置的query去匹配所有源位置key，建立翻译/生成中的词语对应关系。例如翻译时，目标语言中”猫”的query应该匹配源语言”cat”的key

2. 信息桥接：将Encoder编码的源语言信息引入Decoder的生成过程。没有Cross-Attention，Decoder只能看到目标序列，无法利用源序列信息

3. 复制机制：Decoder可以通过Cross-Attention直接从源序列中”复制”信息（如CopyNet机制）

Padding Mask在Cross-Attention中的应用：

如果源序列有padding，同样需要mask掉无效位置，防止Decoder关注到填充token。

A-32. 【⭐⭐】Transformer的输入表示由哪几部分组成？BERT的输入表示又有什么特殊之处？

答案：

原始Transformer的输入表示：

$$E_{input} = E_{token} + E_{positional}$$

• $E_{token}$：Token Embedding（词嵌入）
• $E_{positional}$：Positional Encoding（位置编码）

BERT的输入表示（三部分）：

$$E_{input} = E_{token} + E_{segment} + E_{position}$$

• $E_{token}$：Token Embedding
• $E_{segment}$：Segment Embedding（区分句子A和句子B）
• $E_{position}$：Positional Embedding（可学习的位置嵌入）

BERT的特殊Token：

输入示例：

对于句子对分类任务：

[CLS] 今天天气真好 [SEP] 明天会下雨 [SEP]

对应Segment Embedding：

  A   A  A  A  A  A   B  B  B  B  B  B

A-33. 【⭐⭐⭐】Transformer中的Dropout用在哪些地方？现代大模型（如GPT-3）为什么有时不使用Dropout？

答案：

Dropout在Transformer中的应用位置：

1. 嵌入层输出后（Embedding Dropout）：对Embedding + Positional Encoding的结果应用
2. 注意力权重矩阵上（Attention Dropout）：对softmax后的注意力权重应用
3. 残差连接之前（Residual Dropout）：对子层输出应用Dropout后再参与残差相加
4. FFN激活后（Activation Dropout）：对FFN中间层激活输出应用

标准Transformer Dropout率：0.1（10%）

现代大模型不使用Dropout的原因：

1. 数据量极大：大模型训练数据量达到TB甚至PB级别，过拟合不再是主要问题
2. 模型容量仍然不足：相对于海量数据，即使百亿参数模型也可能欠拟合
3. 训练效率：去掉Dropout减少了随机屏蔽的开销
4. 实际观察：实验表明在大规模预训练场景下，Dropout对最终性能无正面贡献

注意：在微调阶段，如果下游数据量较小，有时仍会启用Dropout作为正则化手段。

A-34. 【⭐⭐⭐⭐⭐】Label Smoothing是什么？在Transformer中起什么作用？与温度缩放的关系？

答案：

Label Smoothing的定义：

将hard one-hot标签 $q(k) = \delta_{k,y}$ 替换为平滑后的分布：

$$q’(k) = (1 - \epsilon) \delta_{k,y} + \frac{\epsilon}{K}$$

其中 $\epsilon$ 是平滑参数（通常0.1），$K$ 为类别数（词表大小）。

作用：

1. 防止模型过度自信（over-confident）：避免softmax输出趋近于1（概率过于集中）
2. 正则化效果：相当于在标签上加了噪声，提升模型泛化能力
3. 改善模型校准性：使得预测概率更准确地反映真实置信度

与温度缩放（Temperature Scaling）的关系：

Label Smoothing和温度缩放有相似的”软化”效果：

• Label Smoothing：软化目标分布（ground truth）
• 温度缩放：软化模型输出分布（prediction）

两者都可以防止模型过于自信，但作用在不同对象上。

在注意力中的应用：

除以 $\sqrt{d_k}$ 本身也是一种温度缩放：

$$\frac{QK^T}{\sqrt{d_k}} = QK^T \cdot T^{-1}, \quad T = \sqrt{d_k}$$

$\sqrt{d_k}$ 越大，注意力分布越平滑；$\sqrt{d_k}$ 越小，分布越尖锐（聚焦性更强）。

A-35. 【⭐⭐⭐】Transformer训练中的学习率Warmup策略是什么？为什么需要Warmup？

答案：

Warmup策略公式：

$$lr = \begin{cases} lr_{max} \times \frac{step}{warmup_steps} & \text{if } step < warmup_steps \ lr_{max} \times \min(step^{-0.5}, step \times warmup_steps^{-1.5}) & \text{otherwise} \end{cases}$$

为什么需要Warmup：

1. 早期梯度不稳定：训练初期梯度方差大，大学习率可能导致模型发散（divergence）
2. Adam优化器偏差校正：Adam在初期 $m_t, v_t$ 的估计有偏差（偏向0），小学习率可以补偿这一偏差
3. 稳定注意力：大学习率可能导致注意力分数发散，使得某些位置获得极端权重

典型设置：

现代大模型由于使用Pre-LN架构，梯度更稳定，warmup比例相比原始Transformer有所减少。

A-36. 【⭐⭐⭐⭐⭐】Transformer中的权重初始化策略有哪些？为什么需要特殊的初始化？

答案：

常用的初始化策略：

1. Xavier/Glorot初始化（线性层、嵌入层）：

$$W \sim \mathcal{U}\left(-\sqrt{\frac{6}{d_{in} + d_{out}}}, \sqrt{\frac{6}{d_{in} + d_{out}}}\right)$$

或其正态分布版本：$W \sim \mathcal{N}(0, \sqrt{2/(d_{in} + d_{out})})$

保持输入输出的方差大致相同。

2. 正态分布初始化（BERT的嵌入层）：

$$E \sim \mathcal{N}(0, 0.02)$$

3. LayerNorm参数初始化：

$$\gamma \leftarrow 1, \quad \beta \leftarrow 0$$

4. 偏置项初始化：通常初始化为0

为什么需要特殊初始化？

1. 深度网络稳定性：不好的初始化会导致梯度消失或爆炸，尤其当层数增加到几十层时
2. 注意力机制的要求：注意力分数 $QK^T/\sqrt{d_k}$ 的方差需要适中（~1），否则softmax饱和
3. 残差连接的配合：Xavier初始化与残差连接配合良好，确保深层网络的信号传播稳定

Post-LN vs Pre-LN的初始化差异：

• Post-LN（原始Transformer）：对初始化更敏感，需要精心设计
• Pre-LN（现代模型）：更鲁棒，但通常仍使用Xavier初始化

A-37. 【⭐⭐⭐】Beam Search的工作原理是什么？与贪心搜索和采样方法的对比？

答案：

贪心搜索（Greedy Decoding）：

每步选择概率最高的token：

$$y_t = \arg\max_y P(y | y_{1:t-1}, x)$$

• 优点：简单、快速
• 缺点：容易陷入局部最优，生成的文本质量差

Beam Search：

维护 $k$ 个最佳候选序列（beam width=$k$）：

1. 初始：$k$ 个候选都是 [BOS]
2. 每步：对每个候选生成所有可能的下一个token，计算得分
3. 选择得分最高的 $k$ 个保留
4. 重复直到生成 [EOS] 或达到最大长度

得分函数（带长度惩罚）：

$$\text{score}(y) = \frac{1}{|y|^\alpha} \sum_{t=1}^{|y|} \log P(y_t | y_{<t})$$

其中 $\alpha$ 是长度惩罚因子（通常0.6-1.0）。

采样方法（Temperature Sampling）：

$$P(y_t) = \frac{\exp(z_t / T)}{\sum_j \exp(z_j / T)}$$

• $T \to 0$：退化为贪心搜索
• $T = 1$：标准采样
• $T > 1$：分布更均匀，输出更多样化

三种方法对比：

Top-k和Top-p（Nucleus）采样：

• Top-k：只从概率最高的k个token中采样
• Top-p：从累计概率达到p的最小集合中采样（动态调整k值）

A-38. 【⭐⭐⭐】Transformer中的注意力机制与卷积神经网络（CNN）的本质联系是什么？Attention Is All You Need论文中的观点如何理解？

答案：

Attention与CNN的联系：

1. Multi-Head Attention可以模拟卷积：
   - 每个注意力头可以学习关注特定的局部或全局模式
   - 如果某个头只关注固定窗口内的位置，其行为类似于卷积核

2. CNN是特殊形式的Attention：
   - 卷积核的权重是固定的（与输入无关）
   - Attention的权重是动态的（依赖于输入内容）
   - 因此，CNN可以看作是一种内容无关的、稀疏的注意力

3. 感受野的对比：
   - CNN：感受野随层数对数增长 $O(\log_k n)$，需要多层才能看到全局
   - Attention：单层即可达到全局感受野 $O(1)$

“Attention Is All You Need”的深层含义：

1. 表达能力：Self-Attention可以直接建模任意两个token之间的关系，不依赖距离
2. 并行性：所有位置同时计算，充分利用GPU并行能力
3. 长距离依赖：任意两个位置的路径长度为O(1)，优于RNN的O(n)
4. 统一框架：Attention可以替代RNN和CNN的核心功能

注意：这并不意味着Attention在所有场景下都是最优的：
- 对于短序列，RNN可能更高效
- 对于局部特征提取，CNN可能更合适
- Attention的 $O(n^2)$ 复杂度是其在长序列上的主要瓶颈

A-39. 【⭐⭐⭐⭐⭐】请分析Transformer Encoder-only、Decoder-only、Encoder-Decoder三种架构的适用场景和本质区别。

答案：

架构对比：

Encoder-only不适合生成的原因：

BERT在预训练时看到的是双向上下文（被mask的词两边都能看到），而生成任务只能看到左边的已生成文本。训练和推理的不一致导致BERT无法直接自回归生成。

Decoder-only适合生成的原因：

预训练（预测下一个token）和推理（逐token生成）完全一致，不存在不一致问题。

Encoder-Decoder的灵活性：

T5将所有任务统一为text-to-text，通过一个统一的框架处理理解和生成任务。

A-40. 【⭐⭐⭐】Transformer中的Softmax计算是否存在数值稳定性问题？如何解决？

答案：

Softmax的数值稳定性问题：

$$\text{softmax}(x_i) = \frac{e^{x_i}}{\sum_j e^{x_j}}$$

当 $x_i$ 很大时，$e^{x_i}$ 可能导致数值溢出（overflow）。

数值稳定化技巧：

$$\text{softmax}(x_i) = \frac{e^{x_i - c}}{\sum_j e^{x_j - c}}, \quad c = \max_j x_j$$

通过减去最大值 $c$，确保指数运算的最大输入为0（$e^0 = 1$），避免了溢出。

在Transformer Attention中的应用：

$$\text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)$$

除以 $\sqrt{d_k}$ 本身就是数值稳定性措施之一，但通常还需要在实现中使用上述max-trick。

PyTorch实现示例：

def stable_softmax(x, dim=-1):
    # 减去最大值保证数值稳定性
    x_max = torch.max(x, dim=dim, keepdim=True).values
    x_shifted = x - x_max
    exp_x = torch.exp(x_shifted)
    return exp_x / torch.sum(exp_x, dim=dim, keepdim=True)

四、关键变体详解——15题

A-41. 【⭐⭐⭐】BERT的架构和预训练任务详解。MLM和NSP的具体实现和原理是什么？

答案：

BERT架构：
- 仅使用Transformer的Encoder部分
- 双向注意力：每个token可以看到上下文两侧的所有token
- 典型规模：BERT-Base（12层，768维，12头，110M参数）、BERT-Large（24层，1024维，16头，340M参数）

预训练任务1：MLM（Masked Language Model，掩码语言模型）

目标：随机mask输入序列中15%的token，让模型预测这些被mask的token。

具体实现：
- 80%的概率用 [MASK] 替换
- 10%的概率用随机token替换
- 10%的概率保持原token不变

数学形式：

$$\mathcal{L}{MLM} = -\mathbb{E}{x \sim \mathcal{D}} \sum_{i \in \mathcal{M}} \log P(x_i | x_{\backslash \mathcal{M}})$$

其中 $\mathcal{M}$ 是被mask的位置集合。

为什么三种替换策略？ 防止预训练和微调之间的mismatch（微调时没有 [MASK] token）。

预训练任务2：NSP（Next Sentence Prediction，下一句预测）

目标：预测句子B是否是句子A的下一句。
- 正样本：实际相邻的两个句子（50%）
- 负样本：随机配对的两个句子（50%）
- 输入格式：[CLS] A [SEP] B [SEP]

NSP的局限性： RoBERTa等后续工作发现NSP对下游任务几乎没有贡献，可能是因为任务太简单或目标不明确，已被SOP等替代。

A-42. 【⭐⭐⭐】GPT系列的架构特点和训练方式。GPT与BERT的本质区别是什么？

答案：

GPT架构特点：
- 仅使用Transformer的Decoder部分
- 因果注意力（Causal Attention）：每个token只能看到它自己和之前的token
- 自回归生成：逐token生成，每次将新生成的token加入输入继续预测

GPT系列演进：

训练目标（自回归语言模型）：

$$\mathcal{L}{LM} = -\sum{t=1}^{T} \log P(x_t | x_1, x_2, \ldots, x_{t-1})$$

GPT与BERT的本质区别：

为什么GPT适合生成： 预训练和推理方式完全一致（都是自回归），没有BERT的预训练-微调不一致问题。

A-43. 【⭐⭐⭐】T5（Text-to-Text Transfer Transformer）的”统一框架”思想是什么？

答案：

核心思想：将所有NLP任务统一为文本到文本的生成问题。

具体做法：
- 每个任务编码为带有前缀提示（prefix）的文本输入
- 输出也是文本形式

任务示例：

架构：
- 完整的Encoder-Decoder结构
- Encoder使用双向注意力
- Decoder使用因果注意力 + Cross-Attention

预训练任务：Span Corruption（span损坏）

• 随机采样并mask输入中的连续span（平均长度3）
• 用唯一的 <extra_id_0> 等哨兵token替换
• 目标输出是被mask的span序列

示例：
- 输入：Thank you <extra_id_0> me to your party <extra_id_1> week
- 输出：<extra_id_0> for inviting <extra_id_1> last

统一框架的优势：
1. 所有任务共享同一套模型和训练流程
2. 新任务只需设计前缀提示，无需修改模型架构
3. 多任务联合训练天然支持

A-44. 【⭐⭐⭐】RoBERTa相比BERT做了哪些关键改进？为什么这些改进有效？

答案：

RoBERTa（Robustly optimized BERT approach）通过更细致的调优显著提升了BERT性能：

1. 去掉NSP任务
- 发现NSP对性能没有帮助甚至有害
- 仅使用MLM进行预训练

2. 动态掩码（Dynamic Masking）
- BERT在每个epoch使用固定的mask模式
- RoBERTa每次feed数据时动态随机mask，增加数据多样性

3. 更大的batch size
- BERT: batch size 256
- RoBERTa: batch size 8K

4. 更多的训练数据
- BERT: 16GB（BookCorpus + Wikipedia）
- RoBERTa: 160GB（加上CC-News, OpenWebText, Stories）

5. 更长的训练时间
- 从100K steps增加到500K steps

6. 更长的序列
- 512 tokens → 全长度文档级连续训练

7. 文本编码
- 使用Byte-level BPE（BBPE）替代字符级BPE

为什么这些改进有效？

性能提升： 在GLUE基准上相比BERT-Large有约2-3个点的提升。

A-45. 【⭐⭐⭐⭐⭐】ALBERT的参数量减少策略有哪些？每种策略的原理和权衡是什么？

答案：

ALBERT（A Lite BERT）提出了两种主要策略减少参数量：

1. 嵌入参数分解（Factorized Embedding Parameterization）

• BERT的做法：词嵌入维度 $V \times H$（$V$=词表大小，$H$=隐藏层维度）
• ALBERT的做法：先映射到低维 $E$，再映射到高维 $H$
• 第一步：$V \times E$
• 第二步：$E \times H$
• 参数减少比：从 $O(V \times H)$ 降到 $O(V \times E + E \times H)$
• 典型设置：$V=30000, H=4096, E=128$，参数从 ~123M 降到 ~16M

2. 跨层参数共享（Cross-layer Parameter Sharing）

• 所有Transformer层共享同一组注意力参数和FFN参数
• BERT-Large：24层，每层独立参数
• ALBERT-xxlarge：12层（但每层更宽），共享所有层参数
• 参数量从 340M 降到 235M，但层数更多（性能反而更好）

3. SOP（Sentence Order Prediction）替代NSP

• 正样本：连续的两个句子（按正确顺序）
• 负样本：连续的两个句子（交换顺序）
• SOP比NSP更有区分性，因为模型需要真正理解句子间的连贯性

权衡分析：

关键洞察： ALBERT减少了参数量，但前向/反向传播时间不会减少（因为计算量不变）。适合存储受限但计算资源充足的场景。

A-46. 【⭐⭐⭐⭐⭐】DeBERTa的解耦注意力机制（Disentangled Attention）详解。为什么它在SuperGLUE上能超过人类水平？

答案：

核心思想： 将词的内容向量和位置向量分离，用不同的投影矩阵计算内容注意力和位置注意力。

传统做法（BERT）：
- 词嵌入 + 位置嵌入 → 相加后一起计算注意力
- 内容和位置信息在同一个向量中纠缠

DeBERTa的解耦做法：

每个词用两个向量表示：
- $H_c$：内容向量（词本身的语义）
- $H_p$：位置向量（词的位置信息）

注意力分数的计算：

$$A_{ij} = \underbrace{Q_c^i \cdot K_c^j}{\text{内容-内容}(c2c)} + \underbrace{Q_c^i \cdot K_p^{\Delta{ij}}}{\text{内容-位置}(c2p)} + \underbrace{Q_p^{\Delta{ij}} \cdot K_c^j}_{\text{位置-内容}(p2c)}$$

其中 $\Delta_{ij} = j - i$ 为相对位置偏移。

四种交互方式（位置-位置不计算，避免冗余）：
1. 内容查询 × 内容键（c2c）：传统的语义相似度
2. 内容查询 × 相对位置键（c2p）：查询词与位置的关系
3. 相对位置查询 × 内容键（p2c）：位置与键词的关系
4. 位置查询 × 位置键：不计算

Enhanced Mask Decoder（EMD）：

在最后一层Transformer之后、Softmax之前加入绝对位置信息。区别于BERT在输入层加入绝对位置，DeBERTa使得：
- 中间层专注于相对位置建模
- 解码时再利用绝对位置信息

为什么能在SuperGLUE上超过人类？

1. 更精细的位置建模：解耦内容和位置，使得注意力计算更加精确
2. 相对位置的优势：自然处理长距离依赖和不同句子结构
3. EMD的增强效果：在解码阶段引入绝对位置，提升理解精度
4. 更稳定的训练：解耦设计减少了内容和位置的干扰

A-47. 【⭐⭐⭐】ELECTRA的预训练任务是什么？相比BERT为什么更高效？

答案：

核心思想：Replaced Token Detection（替换token检测）

流程：
1. 使用一个小型生成器（Generator，通常是小型MLM）对输入序列中的部分token进行替换
2. 判别器（Discriminator）需要判断每个token是原始的还是被替换的
3. 训练目标类似于二分类：对每个位置的token判断original/replaced

数学形式：

$$\mathcal{L}{ELECTRA} = -\sum{t=1}^{T} [y_t \log D(x_t) + (1-y_t)\log(1 - D(x_t))]$$

其中 $y_t=1$ 表示token $t$ 是原始的，$y_t=0$ 表示是被替换的。

相比BERT的优势：

关键设计：
- 生成器和判别器共享词嵌入层
- 判别器在微调时直接使用，丢弃生成器
- 通常生成器较小（如BERT-small），判别器较大

A-48. 【⭐⭐⭐⭐⭐】GPT-3的上下文学习（In-Context Learning, ICL）能力是什么？为什么大模型具有这种能力？

答案：

上下文学习的定义：

GPT-3可以在不更新任何模型参数的情况下，仅通过在输入上下文（prompt）中提供几个示例（demonstrations），就学会执行新任务。

三种 prompting 方式：

为什么大模型具有ICL能力？（理论假说）

1. 元学习（Meta-Learning）：预训练过程中，模型学会了”如何学习”——从上下文中的示例中提取任务模式和映射关系

2. 隐式梯度下降：有理论研究表明，Transformer的注意力机制在前向传播中执行了类似于梯度下降的优化步骤，相当于在推理时进行了”隐式微调”

3. 大规模数据的涌现：当模型参数量和训练数据量超过某个阈值时，ICL能力突然涌现（emergent ability）

4. 模式识别：预训练数据包含了大量不同任务的隐式示例，模型学会了识别和复用这些模式

ICL与微调（Fine-tuning）的区别：

A-49. 【⭐⭐⭐】SpanBERT相比BERT的改进是什么？Span级别的预训练有什么好处？

答案：

SpanBERT的核心改进：

1. Span Masking：
   - BERT随机mask单个token
   - SpanBERT随机mask连续的span（片段）
   - 通过几何分布采样span长度，倾向于mask更短的span

2. Span Boundary Objective（SBO）：
   - 除了预测被mask的token外，还增加了一个任务
   - 用span边界（开头和结尾的token表示）来预测span内部的token
   - 目标是让span的边界表示编码整个span的信息

数学形式：

$$\mathcal{L}{SBO} = -\sum{i \in \mathcal{S}} \log P(x_i | x_{s-1}, x_{e+1}, p_{i-s+1})$$

其中 $\mathcal{S}$ 是被mask的span，$s$ 是span起始位置，$e$ 是结束位置，$p_{i-s+1}$ 是span内的相对位置。

Span级别预训练的好处：

1. 更好地建模span表示：Span Boundary Objective使得span的边界表示包含了span的整体语义
2. 提升span选择任务：如问答（答案通常是一个span）、指代消解
3. 更符合语言学直觉：语义单元通常是词组或短语，而非单个词

性能提升： 在问答（SQuAD）、指代消解等span选择任务上显著提升。

A-50. 【⭐⭐⭐】XLNet的排列语言模型（Permutation Language Model）是什么？与BERT的MLM有何区别？

答案：

BERT MLM的问题：

1. 预训练-微调差异：[MASK] token在微调时不会出现
2. 独立性假设：BERT假设被mask的token之间相互独立，忽略了它们之间的依赖关系

XLNet的排列语言模型：

通过随机排列序列中的token顺序，然后用自回归的方式预测部分位置的token。对于每个位置，模型可以看到的上下文取决于排列中的顺序。

核心思想： 对于序列 $[x_1, x_2, x_3, x_4]$，考虑所有可能的排列（共4! = 24种）。对于排列 $[x_3, x_1, x_4, x_2]$，预测 $x_2$ 时可以看到 $x_3, x_1, x_4$（即上下文中的双侧信息），但预测过程仍然是自回归的。

优化目标：

$$\mathcal{L}{XLNet} = -\mathbb{E}{Z \sim \mathcal{Z}T} \sum{t=1}^{T} \log P(x_{z_t} | x_{z_{<t}})$$

其中 $Z$ 是从所有排列 $\mathcal{Z}_T$ 中采样的一个排列。

与BERT的区别：

Two-Stream Attention：

XLNet需要特殊的Two-Stream Attention机制来同时处理：
- Content Stream：编码token的内容信息
- Query Stream：只包含位置信息，不包含目标token的内容（防止信息泄露）

A-51. 【⭐⭐⭐】ERNIE（百度）的知识增强预训练思想是什么？与BERT有何不同？

答案：

核心思想：将知识图谱中的实体信息融入预训练，增强模型对知识的理解和推理能力。

ERNIE 1.0的改进：

1. 实体级Masking：
   - BERT随机mask单个token
   - ERNIE mask整个实体（如”哈利波特”作为一个整体被mask）
   - 迫使模型学习实体级别的知识

2. 短语级Masking：
   - 随机mask连续的短语（n-gram）
   - 增强短语级别的语义理解

ERNIE 2.0的持续学习框架：

引入多任务持续学习（Continual Learning）：
- 词汇任务（Word-aware）：捕捉词之间的关系
- 结构任务（Structure-aware）：理解句子结构
- 语义任务（Semantic-aware）：理解语义相似度

ERNIE 3.0的统一框架：

• 将自回归网络和自编码网络结合
• 引入知识图谱的显式知识
• 在理解和生成任务上都取得优秀表现

与BERT的核心区别：

A-52. 【⭐⭐⭐⭐⭐】BART（Denoising Autoencoder）的预训练策略是什么？与T5的对比？

答案：

核心思想：通过破坏原文档然后用Seq2Seq模型重建来进行预训练。

破坏策略（Noising Functions）：

预训练目标：

$$\mathcal{L}{BART} = -\sum{t=1}^{T} \log P(x_t | \tilde{x})$$

其中 $\tilde{x}$ 是被破坏的文本，模型需要重建原始文本 $x$。

架构：
- 完整的Encoder-Decoder（与原始Transformer一致）
- Encoder使用双向注意力
- Decoder使用因果注意力 + Cross-Attention

BART与T5的对比：

为什么BART在生成任务上表现好？

BART的预训练目标（重建被破坏文本）与生成任务高度一致，且多种破坏策略增强了模型的鲁棒性。

A-53. 【⭐⭐⭐】GPT-2的多任务零样本学习能力是如何实现的？与后续GPT-3的对比？

答案：

GPT-2的核心发现：

当语言模型足够大（1.5B参数）、训练数据足够多（WebText，40GB）时，模型在没有任何微调的情况下，可以在多个下游任务上取得有竞争力的表现。

实现方式：

1. 任务条件化（Task Conditioning）：将所有任务都视为条件语言建模问题
   - 翻译：English: cat French: chat English: dog French:
   - 问答：Question: What is the capital of France? Answer: Paris Question: ...

2. 大规模预训练：在海量高质量数据上训练，模型隐式学习了各种任务的规律

3. 提示工程（Prompting）：通过精心设计的输入格式引导模型完成特定任务

GPT-2 vs GPT-3：

关键洞察： 模型能力的涌现不是线性的——当参数量和训练数据超过某个阈值后，模型的零样本和少样本能力突然显著提升。

A-54. 【⭐⭐⭐⭐⭐】ChatGPT/GPT-4中的RLHF（Reinforcement Learning from Human Feedback）是什么？它在训练流程中的作用是什么？

答案：

RLHF的三阶段训练流程：

阶段1：预训练（Pre-training）

在大规模语料上训练自回归语言模型，学习通用的语言表示和知识。

阶段2：监督微调（SFT, Supervised Fine-Tuning）

用高质量的（prompt, response）对话数据进行监督学习：

$$\mathcal{L}{SFT} = -\sum{t=1}^{T} \log P(r_t | p, r_{<t})$$

其中 $p$ 是prompt，$r$ 是人类标注的理想回答。

阶段3：RLHF（基于人类反馈的强化学习）

1. 训练奖励模型（Reward Model, RM）：
   - 收集人类偏好数据：对同一问题的多个回答进行排序
   - 训练RM预测人类偏好得分

2. 使用PPO（Proximal Policy Optimization）优化策略：

$$\mathcal{L}{PPO} = \mathbb{E}{x \sim D, y \sim \pi_\theta} [R(x, y)] - \beta \cdot \text{KL}(\pi_\theta | \pi_{SFT})$$

其中：
- $R(x, y)$ 是奖励模型对回答 $y$ 的评分
- $\text{KL}$ 项防止策略偏离SFT模型太远
- $\beta$ 控制KL惩罚的强度

RLHF的作用：

1. 对齐人类偏好：让模型输出符合人类价值观和偏好
2. 减少有害输出：通过奖励模型惩罚有害/不安全的内容
3. 提高有用性：奖励模型偏好有用、详细、准确的回答
4. 遵循指令：让模型更好地理解并遵循用户的指令

A-55. 【⭐⭐⭐】Transformer变体演进的核心趋势是什么？从BERT/GPT到现代大模型的关键转变有哪些？

答案：

演进趋势总结：

关键转变：

为什么Decoder-only成为主流？

1. 预训练-推理一致性：自回归预训练和自回归生成完全一致
2. 扩展性：Decoder-only架构更容易扩展到超大参数量
3. 涌现能力：ICL等能力在Decoder-only大模型中表现最好
4. 工程简单：不需要Encoder-Decoder的复杂交互

五、高效Transformer改进——15题

A-56. 【⭐⭐⭐】Transformer的 $O(n^2)$ 复杂度问题具体体现在哪些方面？对实际应用有什么影响？

答案：

$O(n^2)$ 复杂度的来源：

Self-Attention需要计算 $QK^T \in \mathbb{R}^{n \times n}$，即序列中每对token之间的注意力分数。

三个维度的 $O(n^2)$ 开销：

1. 计算复杂度：矩阵乘法 $QK^T$ 需要 $O(n^2 \cdot d)$ 次操作
2. 内存复杂度：需要存储完整的注意力矩阵 $O(n^2)$
3. IO复杂度：注意力矩阵需要从HBM读写，当 $n$ 很大时成为瓶颈

具体数值感受：

实际影响：
- 训练：长序列训练需要巨大的GPU显存，batch size受限
- 推理：生成长文本时KV-Cache占用线性增长，计算量随序列长度二次增长
- 应用场景限制：无法直接处理长文档（如法律合同、学术论文）、长视频序列、基因组序列等

A-57. 【⭐⭐⭐⭐⭐】Flash Attention的核心原理是什么？为什么能做到”精确注意力”又高效？

答案：

核心思想：IO-Aware Exact Attention

Flash Attention不改变注意力的数学计算结果（exact），而是通过优化内存访问模式来提升速度。

关键问题：标准注意力的内存瓶颈

标准注意力的执行流程：
1. 从HBM加载Q, K → 计算 $S = QK^T$ → 写回HBM（$O(n^2)$）
2. 从HBM加载S → 计算 $P = \text{softmax}(S)$ → 写回HBM（$O(n^2)$）
3. 从HBM加载P, V → 计算 $O = PV$ → 写回HBM

重复读写 $O(n^2)$ 的中间矩阵是主要瓶颈。

Flash Attention的解决方案 — Tiling + Kernel Fusion：

Step 1 — 分块（Tiling）：

将Q、K、V矩阵分块处理：
- Q分块为 $B_r$ 行（如64行一块）
- K、V分块为 $B_c$ 列（如64列一块）

Step 2 — 在线Softmax（Online Softmax）：

不存储完整的注意力矩阵，而是维护running statistics：

对于每个block，维护：
- $m$：当前见过的最大值
- $l$：当前指数和

当处理新的block时，更新统计量：

$$\tilde{m}{new} = \max(m{old}, m_{new})$$

$$\tilde{l}{new} = l{old} \cdot e^{m_{old} - \tilde{m}{new}} + l{new} \cdot e^{m_{new} - \tilde{m}_{new}}$$

Step 3 — Kernel Fusion：

将 $QK^T$、softmax、$PV$ 计算融合为一个GPU kernel，在SRAM中完成。

复杂度对比：

Flash Attention 2的改进：
- 更高效的线程块划分，减少warp之间的空闲
- 减少non-matmul FLOPs，在更多序列长度下达到接近理论的峰值利用率

A-58. 【⭐⭐⭐⭐⭐】Linear Attention的核心思想是什么？与标准注意力的区别和代价是什么？

答案：

核心思想：用核函数（Kernel Feature Map）替代Softmax，将注意力复杂度从 $O(n^2)$ 降到 $O(n)$。

标准注意力：

$$\text{Attn}(Q,K,V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

Linear Attention的推导：

1. 将softmax表示为特征映射的内积：

$$\text{sim}(q_i, k_j) = \exp\left(\frac{q_i \cdot k_j}{\sqrt{d_k}}\right) = \phi(q_i)^T \phi(k_j)$$

其中 $\phi$ 是特征映射函数。

2. 注意力输出变为：

$$o_i = \frac{\sum_j \phi(q_i)^T \phi(k_j) v_j}{\sum_j \phi(q_i)^T \phi(k_j)} = \frac{\phi(q_i)^T \sum_j \phi(k_j) v_j^T}{\phi(q_i)^T \sum_j \phi(k_j)}$$

3. 关键分解 — 计算全局统计量：

$$o_i = \frac{\phi(q_i)^T \cdot S}{\phi(q_i)^T \cdot z}$$

其中 $S = \sum_j \phi(k_j) v_j^T \in \mathbb{R}^{d’ \times d}$，$z = \sum_j \phi(k_j) \in \mathbb{R}^{d’}$。

复杂度分析：
- 计算 $S$ 和 $z$：$O(n \cdot d’ \cdot d)$
- 对每个query计算输出：$O(d’ \cdot d)$
- 总计：$O(n \cdot d’ \cdot d)$，与序列长度线性相关！

常用核函数：

Linear Attention的代价：

1. 表达能力弱于softmax注意力：失去了”赢家通吃”的聚焦能力
2. 精确检索能力下降：在需要精确找到特定token的任务上表现较差
3. 因果场景困难：Decoder-only场景下难以实现高效并行训练（需要递归计算）

A-59. 【⭐⭐⭐】Sparse Attention的主要思路是什么？Longformer和BigBird各自的做法？

答案：

核心思想：让注意力矩阵变为稀疏矩阵，只计算重要的注意力对。

Longformer的做法（三种注意力模式结合）：

1. Sliding Window Attention（滑动窗口注意力）：
   - 每个token只关注其左右各 $w$ 个邻居
   - 复杂度 $O(n \cdot w)$

2. Dilated Sliding Attention（空洞滑动注意力）：
   - 在滑动窗口中每隔 $d$ 个token才计算注意力
   - 进一步减少计算

3. Global Attention（全局注意力）：
   - 在特定位置（如 [CLS]）设置全局注意力
   - 这些全局位置可以连接到所有位置，所有位置也可以连接到它们

BigBird的做法（Longformer的扩展）：

结合了三种模式并证明了其是Universal Approximator：

1. Random Attention（随机注意力）：每个token随机关注 $r$ 个其他token
2. Window Attention（窗口注意力）：局部滑动窗口（同Longformer）
3. Global Attention（全局注意力）：部分token关注所有位置，所有位置也关注这些全局token

理论保证： BigBird证明了这种稀疏注意力模式保持了对连续函数的Universal Approximation能力。

复杂度对比：

A-60. 【⭐⭐⭐⭐⭐】什么是KV-Cache？为什么在大模型推理中如此重要？如何估算其内存占用？

答案：

问题背景：

在Decoder的自回归生成中，每步只生成一个新token，但需要计算所有历史token的注意力。注意到：对于已经生成的token，它们的K和V向量是不变的。

KV-Cache的核心思想：

将之前计算好的K和V向量缓存起来，每步只需要计算新token的Q，然后用缓存的K、V一起计算注意力。

标准推理（无Cache）：

$$\text{Step } t: \text{ 计算 } Q_t, K_{1:t}, V_{1:t} \rightarrow \text{Attention}(Q_t, K_{1:t}, V_{1:t})$$

每次需要计算 $K_{1:t}$ 和 $V_{1:t}$，复杂度 $O(t \cdot d^2)$。

使用KV-Cache：

$$\text{Step } t: \text{ 计算 } Q_t, K_t, V_t \rightarrow \text{复用缓存的 } K_{1:t-1}, V_{1:t-1}$$

$$\text{Attention}(Q_t, [K_{1:t-1} \oplus K_t], [V_{1:t-1} \oplus V_t])$$

复杂度改善：
- 每步计算量从 $O(t \cdot d^2)$ 降到 $O(d^2)$（只需新token的Q/K/V投影）
- 但内存消耗线性增长：需要缓存 $K, V \in \mathbb{R}^{t \times d}$

KV-Cache的内存估算公式：

$$\text{KV-Cache大小} = 2 \times b \times t \times d \times L \times \text{sizeof(dtype)}$$

其中：
- $b$ = batch size
- $t$ = 序列长度
- $d$ = 模型维度
- $L$ = 层数
- 2 = K和V两组

示例计算： LLaMA-65B, batch=32, seq_len=2048, d=8192, L=80, FP16

$$= 2 \times 32 \times 2048 \times 8192 \times 80 \times 2 \text{ bytes} \approx 320 \text{ GB}$$

这是巨大的内存开销，是推理batch size受限的主要原因。

A-61. 【⭐⭐⭐⭐⭐】MQA（Multi-Query Attention）和GQA（Grouped-Query Attention）的原理是什么？各自解决了什么问题？

答案：

Multi-Head Attention（MHA）的问题：

标准MHA中，每个头有独立的K、V投影：
- 头数 $h$，每层需要 $h$ 个K和 $h$ 个V
- KV-Cache大小为 $2 \times b \times t \times d \times L$（最大）

MQA（Multi-Query Attention）：

• 核心思想：所有头共享同一套K和V投影矩阵
• 每个头有独立的Q投影，但K、V投影各只有一个
• KV-Cache减少为原来的 $1/h$

$$Q_i = XW_i^Q \text{（每个头独立）}$$
$$K = XW^K \text{（所有头共享）}$$
$$V = XW^V \text{（所有头共享）}$$

缺点： 表达能力下降，可能导致性能损失（因为所有头看到相同的K/V信息）

GQA（Grouped-Query Attention，折中方案）：

• 将头分为 $g$ 组（$g < h$），每组共享一套K/V
• 典型设置：$h=32, g=8$（4个头共享一套K/V）

$$Q_i = XW_i^Q \text{（每个头独立）}$$
$$K_j = XW_j^K, \quad V_j = XW_j^V \text{（每组独立，} j \in [1, g]\text{）}$$

对比总结：

MQA/GQA的PyTorch实现：

class GroupedQueryAttention(nn.Module):
    """GQA: 折中方案，头分组共享K/V"""
    def __init__(self, d_model, n_heads, n_kv_groups=None, dropout=0.1):
        super().__init__()
        # n_kv_groups=None表示MHA, =1表示MQA, =g表示GQA
        self.n_heads = n_heads
        self.n_kv_groups = n_kv_groups or n_heads
        self.d_k = d_model // n_heads

        # Q: 每个头独立
        self.W_Q = nn.Linear(d_model, d_model)
        # K,V: 按组共享
        kv_dim = self.d_k * self.n_kv_groups
        self.W_K = nn.Linear(d_model, kv_dim)
        self.W_V = nn.Linear(d_model, kv_dim)
        self.W_O = nn.Linear(d_model, d_model)

    def forward(self, x, mask=None):
        B, T, _ = x.shape
        Q = self.W_Q(x).view(B, T, self.n_heads, self.d_k)
        K = self.W_K(x).view(B, T, self.n_kv_groups, self.d_k)
        V = self.W_V(x).view(B, T, self.n_kv_groups, self.d_k)

        # 扩展K,V以匹配头的数量
        if self.n_kv_groups < self.n_heads:
            repeats = self.n_heads // self.n_kv_groups
            K = K.repeat_interleave(repeats, dim=2)
            V = V.repeat_interleave(repeats, dim=2)

        # 标准注意力计算
        # ... (transpose, compute scores, apply mask, softmax, output)
        return output

A-62. 【⭐⭐⭐】SwiGLU激活函数为什么在现代大模型中取代了ReLU/GELU？

答案：

SwiGLU结构：

$$\text{SwiGLU}(x) = (\text{SiLU}(xW_{gate}) \odot xW_{up})W_{down}$$

其中 $\text{SiLU}(x) = x \cdot \sigma(x)$（也称Swish激活），$\sigma$ 为sigmoid函数。

等价于门控机制：

$$\text{SwiGLU}(x) = \underbrace{\sigma(xW_{gate})}{\text{门控信号}} \odot \underbrace{(xW{up} \cdot \text{SiLU})}{\text{激活值}} \cdot W{down}$$

为什么性能更好？

1. 门控机制：类似LSTM中的门控，可以自适应地控制信息流——只让重要的信息通过
2. 非线性更丰富：Swish激活 + 逐元素乘法引入了更强的非线性表达能力
3. 平滑性：Swish是平滑激活函数，优于ReLU的硬阈值（dying ReLU问题）
4. 经验验证：Google的PaLM、LLaMA、Mistral等都使用SwiGLU

LLaMA中SwiGLU的实现细节：

$$\text{FFN}_{SwiGLU}(x) = (\text{SiLU}(xW_1) \odot (xW_2))W_3$$

参数量调整：使用SwiGLU时有三组权重矩阵（gate、up、down），为维持参数量不变，中间维度 $d_{ff}$ 需要调整为 $\frac{2}{3} \times 4d = \frac{8}{3}d$（而非原来的 $4d$）。

A-63. 【⭐⭐⭐⭐⭐】Mixture of Experts（MoE）在Transformer中的应用是什么？为什么可以突破稠密模型的参数-计算权衡？

答案：

核心思想： 将FFN层替换为多个”专家”网络，每次只激活部分专家。这样模型参数量可以很大（存储多专家），但计算量只与激活的专家数量成正比。

MoE层结构：

$$y = \sum_{i=1}^{E} g(x)_i \cdot \text{Expert}_i(x)$$

其中：
- $E$ = 专家总数（如64、128）
- $\text{Expert}_i(x)$ = 第 $i$ 个专家（独立的FFN）
- $g(x)$ = 门控网络（Gating Network），决定哪些专家被激活

Top-k门控：

$$g(x) = \text{softmax}(\text{top_k}(W_g \cdot x))$$

只选择得分最高的 $k$ 个专家（通常 $k=1$ 或 $2$），其余设为零。

为什么MoE能突破参数-计算权衡？

MoE模型总参数量远大于稠密模型，但每次前向传播只使用一小部分参数，因此计算量不增加太多。

代表模型：

MoE的挑战：

1. 负载均衡：需要确保所有专家被均匀使用（辅助损失函数）
2. 通信开销：专家可能分布在不同设备上，需要all-to-all通信
3. 微调困难：MoE模型在下游任务上的微调需要特殊技巧
4. 内存占用：即使只激活部分专家，所有专家的参数都需要加载到内存

A-64. 【⭐⭐⭐⭐⭐】DeepSpeed ZeRO系列（ZeRO-1/2/3/Offload）的原理是什么？各自解决了什么问题？

答案：

核心问题：大模型训练的显存瓶颈

训练一个模型需要的显存包括：
- 模型参数（Parameters）
- 梯度（Gradients）
- 优化器状态（Optimizer States）：Adam需要存储一阶和二阶动量（参数量的2倍）
- 激活值（Activations）

对于1B参数的模型用Adam训练：
- 参数：4 GB (FP32)
- 梯度：4 GB (FP32)
- 优化器状态：8 GB (一阶+二阶动量)
- 总计：16 GB（仅模型状态）

ZeRO-1（优化器状态分片）：

将优化器状态分片到多个GPU上，每个GPU只存储一部分：

$$\text{每GPU显存} = \text{Params} + \text{Grads} + \frac{\text{Optimizer States}}{N}$$

ZeRO-2（+ 梯度分片）：

在ZeRO-1基础上，梯度也分片：

$$\text{每GPU显存} = \text{Params} + \frac{\text{Grads} + \text{Optimizer States}}{N}$$

ZeRO-3（+ 参数分片）：

参数、梯度、优化器状态全部分片：

$$\text{每GPU显存} = \frac{\text{Params} + \text{Grads} + \text{Optimizer States}}{N}$$

ZeRO-Offload（CPU/NVMe卸载）：

将优化器状态和计算卸载到CPU内存甚至NVMe SSD上：

$$\text{GPU显存} \approx \text{当前层的参数} + \text{少量激活值}$$

对比：

A-65. 【⭐⭐⭐⭐⭐】Transformer中”涌现能力”（Emergent Abilities）的定义是什么？有哪些典型的涌现能力？规模如何影响涌现？

答案：

涌现能力的定义：

大语言模型在规模（参数量、训练数据量、计算量）超过某个阈值后，突然出现的能力——这些能力在小规模模型中完全不存在，在跨越阈值后突然出现。

典型的涌现能力：

涌现现象的数学理解：

某些能力需要模型的表示空间达到足够高的维度才能”表达”。类似于相变（phase transition）：

$$\text{Performance} = \begin{cases} \text{random} & L < L_c \ f(L) & L \geq L_c \end{cases}$$

其中 $L_c$ 是临界规模。

规模的影响：

涌现能力与以下三个规模因素相关：
1. 模型参数量：参数量越大，表示能力越强
2. 训练数据量：数据量越大，学到的模式越丰富
3. 计算量（FLOPs）：训练步数 × 每步计算量

根据Chinchilla论文，最优 scaling law 要求参数量和数据量等比例增长。

争议：

有研究者认为”涌现”可能只是评估指标的选择效应——使用非线性指标（如准确率）时，连续的性能提升看起来像是突然出现的。使用线性指标（如交叉熵损失）时，能力提升是连续的。

A-66. 【⭐⭐⭐】Gradient Checkpointing（梯度检查点）在Transformer训练中的作用是什么？

答案：

核心问题： 深度Transformer训练中，激活值的内存占用巨大。

对于 $L$ 层的Transformer，前向传播需要存储：
- 每层的输入激活值（用于反向传播计算梯度）
- Attention的中间结果
- LayerNorm的中间结果

总激活值内存 $\propto L \times$ 每层激活大小

Gradient Checkpointing的原理：

不存储所有中间激活值，而是只存储部分层的输出，反向传播时重新计算缺失的激活值。

时间-内存权衡：

实现方式：

from torch.utils.checkpoint import checkpoint

class TransformerLayerWithCheckpoint(nn.Module):
    def forward(self, x, mask=None):
        # 使用checkpoint包装前向计算
        return checkpoint(self._forward_impl, x, mask)

    def _forward_impl(self, x, mask):
        # 标准的Transformer层前向计算
        x = x + self.attn(self.ln1(x), mask)
        x = x + self.ffn(self.ln2(x))
        return x

适用场景：
- GPU显存有限但需要训练更大模型
- 序列长度较长（激活值内存成为瓶颈）
- 可以接受约30%的训练速度损失

A-67. 【⭐⭐⭐⭐⭐】Tensor Parallelism（张量并行）和Pipeline Parallelism（流水线并行）在Transformer训练中的原理是什么？

答案：

数据并行的局限性：

数据并行（每个GPU存储完整模型副本）在模型参数量超过单GPU内存时无法工作。

Tensor Parallelism（张量并行，如Megatron-LM）：

将单个层内的计算分片到多个GPU上。

1. MLP层的张量并行：

$$\text{FFN}(x) = f(xA)B$$

将 $A$ 按列分片，$B$ 按行分片：

$$A = [A_1 | A_2], \quad B = \begin{bmatrix} B_1 \ B_2 \end{bmatrix}$$

$$\text{FFN}(x) = f(xA_1)B_1 + f(xA_2)B_2$$

两个GPU分别计算 $f(xA_1)B_1$ 和 $f(xA_2)B_2$，最后all-reduce求和。

2. Self-Attention层的张量并行：

将多头注意力的头分配到不同GPU上：
- GPU 1：负责头 1 到 $h/2$
- GPU 2：负责头 $h/2+1$ 到 $h$

天然并行，不需要额外通信。

Pipeline Parallelism（流水线并行，如GPipe）：

将模型的不同层分配到不同GPU上：
- GPU 1：层 1-4
- GPU 2：层 5-8
- …

流水线气泡问题：

朴素流水线导致GPU空闲（等待前向/反向传播完成）。解决方法：
- Micro-batching：将一个batch分成多个micro-batch
- 1F1B（One Forward One Backward）：交错前向和反向传播

3D并行（Data + Tensor + Pipeline）：

现代大模型训练通常组合使用三种并行：
- 数据并行：在不同节点间复制
- 张量并行：在同一节点内的GPU间分片
- 流水线并行：在不同节点间分片

A-68. 【⭐⭐⭐】RMSNorm与LayerNorm的详细对比？为什么LLaMA选择RMSNorm？

答案：

RMSNorm（Root Mean Square Layer Normalization）的定义：

$$\text{RMSNorm}(x) = \frac{x}{\sqrt{\frac{1}{d}\sum_{i=1}^{d}x_i^2 + \epsilon}} \cdot \gamma$$

与LayerNorm的对比：

LLaMA选择RMSNorm的原因：

1. 计算更简单：不需要计算均值，减少一次遍历
2. 实验表明效果略好：在大规模语言模型上，RMSNorm与LayerNorm效果相当或略优
3. 梯度传播更直接：没有均值减法的额外梯度项
4. Pre-LN架构下效果足够：在Pre-LN设置中，均值中心化的作用不如Post-LN中重要

关键理解：

在Pre-LN架构中，输入到LayerNorm之前的值已经经过了多层残差连接，其均值通常已经接近0（中心对称分布），因此显式减去均值的收益有限。RMSNorm直接进行缩放归一化，计算更简单高效。

A-69. 【⭐⭐⭐⭐⭐】Chinchilla Scaling Laws的核心发现是什么？它对大模型训练有什么指导意义？

答案：

核心发现：

Chinchilla论文（DeepMind, 2022）发现，当前的大模型普遍训练不足（under-trained）——在固定计算预算下，模型大小和训练token数应该等比例增长，而不是只增加模型大小。

Scaling Laws公式：

对于固定计算预算 $C$（FLOPs），最优的参数量 $N$ 和数据量 $D$ 满足：

$$N_{opt} \propto C^{0.5}, \quad D_{opt} \propto C^{0.5}$$

即：$N_{opt} \approx D_{opt}$（在相同单位下）。

与之前Hoffmann et al.发现的对比：

指导意义：

1. 不要只追求大模型：在计算预算固定时，较小的模型 + 更多的训练数据往往效果更好
2. 数据质量重要：既然需要更多数据，数据的质量和多样性变得更加关键
3. 训练效率：更小的模型训练更快，迭代效率更高
4. 推理成本：小模型推理更快，部署成本更低

计算公式预算：

对于Decoder-only Transformer：

$$C \approx 6 \times N \times D$$

其中 $N$ 为参数量，$D$ 为训练token数。

A-70. 【⭐⭐⭐】PageAttention（vLLM）的核心思想是什么？如何解决KV-Cache的内存碎片问题？

答案：

KV-Cache内存碎片问题的来源：

在批量推理中，每个请求的序列长度不同：
- 预填充阶段（Prefill）：序列长度差异大
- 解码阶段（Decode）：每个请求生成速度不同（有的先完成）

传统KV-Cache分配方式（连续内存块）导致：
- 内部碎片：分配的块比实际需要大
- 外部碎片：释放的块无法被有效利用

PageAttention的核心思想：

借鉴操作系统虚拟内存的分页（Paging）机制：

1. 将KV-Cache划分为固定大小的块（Block，如16个token）
2. 块不需要在物理内存中连续
3. 通过块表（Block Table）记录逻辑位置到物理块的映射

内存组织：

逻辑KV-Cache: [t1, t2, t3, ..., t100]
                  ↓ Block Table映射
物理块:         [BlockA: t1-t16][BlockB: t17-t32]...[BlockF: t97-t100]
                  ↓ 物理内存中可分散存储

优势：

1. 消除内存碎片：固定大小块可以被高效复用
2. 内存共享：同一个prompt的KV-Cache可以在多个请求间共享（如beam search、并行采样）
3. 动态扩展：请求长度增加时只需分配新的块，不需要重新分配连续内存

PagedAttention对推理吞吐的提升：

六、综合应用与代码实现——11题

A-71. 【⭐⭐⭐】请用PyTorch从零实现Scaled Dot-Product Attention，要求支持Mask和Dropout。

答案：

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

class ScaledDotProductAttention(nn.Module):
    """
    缩放点积注意力（Self-Attention核心实现）

    支持功能:
    - 标准的缩放点积注意力
    - Padding Mask和Causal Mask
    - Attention Dropout
    """
    def __init__(self, dropout=0.1):
        super().__init__()
        self.dropout = nn.Dropout(dropout)

    def forward(self, Q, K, V, mask=None):
        """
        参数:
            Q: [batch_size, n_heads, seq_len_q, d_k]
            K: [batch_size, n_heads, seq_len_k, d_k]
            V: [batch_size, n_heads, seq_len_v, d_v]
            mask: [batch_size, 1, seq_len_q, seq_len_k] (可选)
                  mask为0的位置会被屏蔽
        返回:
            output: [batch_size, n_heads, seq_len_q, d_v]
            attn_weights: [batch_size, n_heads, seq_len_q, seq_len_k]
        """
        d_k = Q.size(-1)

        # Step 1: 计算 QK^T / sqrt(d_k)
        # [B, H, L_q, d_k] @ [B, H, d_k, L_k] -> [B, H, L_q, L_k]
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)

        # Step 2: 应用mask（如果提供）
        if mask is not None:
            # 将mask为0的位置填充为极小的值（softmax后接近0）
            scores = scores.masked_fill(mask == 0, -1e9)

        # Step 3: Softmax归一化 + Dropout
        attn_weights = F.softmax(scores, dim=-1)  # 每行和为1
        attn_weights = self.dropout(attn_weights)

        # Step 4: 加权求和V
        # [B, H, L_q, L_k] @ [B, H, L_v, d_v] -> [B, H, L_q, d_v]
        output = torch.matmul(attn_weights, V)

        return output, attn_weights


# === 使用示例 ===
if __name__ == "__main__":
    B, H, L, d_k = 2, 8, 10, 64  # batch=2, 8头, 序列长10, 每头64维

    attn = ScaledDotProductAttention(dropout=0.1)
    Q = torch.randn(B, H, L, d_k)
    K = torch.randn(B, H, L, d_k)
    V = torch.randn(B, H, L, d_k)

    # Causal Mask示例
    causal_mask = torch.tril(torch.ones(L, L)).unsqueeze(0).unsqueeze(0)

    output, weights = attn(Q, K, V, mask=causal_mask)
    print(f"Output shape: {output.shape}")       # [2, 8, 10, 64]
    print(f"Weights shape: {weights.shape}")     # [2, 8, 10, 10]
    print(f"Weights sum per row: {weights[0,0,0].sum():.4f}")  # = 1.0

A-72. 【⭐⭐⭐】请用PyTorch实现Multi-Head Attention模块，包括分头、注意力计算和合并。

答案：

class MultiHeadAttention(nn.Module):
    """
    多头注意力模块（完整实现）

    实现流程:
    1. 线性投影生成Q、K、V
    2. 分头（Split Heads）
    3. 缩放点积注意力
    4. 合并头（Combine Heads）
    5. 输出线性投影
    """
    def __init__(self, d_model=512, n_heads=8, dropout=0.1):
        super().__init__()
        assert d_model % n_heads == 0, f"d_model({d_model})必须被n_heads({n_heads})整除"

        self.d_model = d_model
        self.n_heads = n_heads
        self.d_k = d_model // n_heads  # 每个头的维度

        # Q, K, V的线性投影（合并为一个矩阵提高效率）
        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)

        # 输出投影
        self.W_O = nn.Linear(d_model, d_model)

        self.attention = ScaledDotProductAttention(dropout)
        self.dropout = nn.Dropout(dropout)

    def split_heads(self, x):
        """
        分头操作: [batch, seq_len, d_model] -> [batch, n_heads, seq_len, d_k]

        相当于将d_model维度切分为n_heads × d_k
        """
        batch_size, seq_len, d_model = x.size()
        x = x.view(batch_size, seq_len, self.n_heads, self.d_k)
        return x.transpose(1, 2)  # [B, H, L, d_k]

    def combine_heads(self, x):
        """
        合并头操作: [batch, n_heads, seq_len, d_k] -> [batch, seq_len, d_model]
        """
        batch_size, n_heads, seq_len, d_k = x.size()
        x = x.transpose(1, 2).contiguous()  # [B, L, H, d_k]
        return x.view(batch_size, seq_len, self.d_model)  # [B, L, d_model]

    def forward(self, query, key, value, mask=None):
        batch_size = query.size(0)

        # Step 1: 线性投影并分头
        Q = self.split_heads(self.W_Q(query))    # [B, H, L_q, d_k]
        K = self.split_heads(self.W_K(key))      # [B, H, L_k, d_k]
        V = self.split_heads(self.W_V(value))    # [B, H, L_v, d_k]

        # Step 2: 计算缩放点积注意力
        attn_output, attn_weights = self.attention(Q, K, V, mask)
        # attn_output: [B, H, L_q, d_k]

        # Step 3: 合并多头并输出投影
        output = self.W_O(self.combine_heads(attn_output))
        # output: [B, L_q, d_model]

        return output, attn_weights


# === 使用示例 ===
if __name__ == "__main__":
    B, L, d_model = 4, 20, 512
    mha = MultiHeadAttention(d_model=d_model, n_heads=8)

    x = torch.randn(B, L, d_model)
    output, weights = mha(x, x, x)  # Self-Attention
    print(f"Output shape: {output.shape}")     # [4, 20, 512]
    print(f"Weights shape: {weights.shape}")   # [4, 8, 20, 20]

A-73. 【⭐⭐⭐】请用PyTorch实现Sinusoidal位置编码，支持任意序列长度和模型维度。

答案：

class SinusoidalPositionalEncoding(nn.Module):
    """
    原始Transformer的正弦位置编码

    公式:
        PE(pos, 2i) = sin(pos / 10000^(2i/d_model))
        PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))
    """
    def __init__(self, d_model, max_len=5000, dropout=0.1):
        super().__init__()
        self.dropout = nn.Dropout(dropout)
        self.d_model = d_model

        # 预计算位置编码矩阵 [max_len, d_model]
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        # position: [max_len, 1]

        # 计算分母项: 10000^(2i/d_model) = exp(2i * -ln(10000) / d_model)
        div_term = torch.exp(
            torch.arange(0, d_model, 2).float() * 
            (-math.log(10000.0) / d_model)
        )
        # div_term: [d_model/2]

        # 偶数维度用sin，奇数维度用cos
        pe[:, 0::2] = torch.sin(position * div_term)   # 偶数索引
        pe[:, 1::2] = torch.cos(position * div_term)   # 奇数索引

        # 注册为buffer（不参与梯度更新）
        pe = pe.unsqueeze(0)  # [1, max_len, d_model]
        self.register_buffer('pe', pe)

    def forward(self, x):
        """
        x: [batch_size, seq_len, d_model]
        返回: x + position_encoding (带dropout)
        """
        seq_len = x.size(1)
        # 将预计算的位置编码加到输入上
        x = x + self.pe[:, :seq_len, :].to(x.device)
        return self.dropout(x)


# === 使用示例 ===
if __name__ == "__main__":
    d_model = 512
    pe = SinusoidalPositionalEncoding(d_model, max_len=5000)

    x = torch.randn(2, 100, d_model)  # batch=2, seq=100
    output = pe(x)
    print(f"Output shape: {output.shape}")  # [2, 100, 512]

    # 验证位置编码的周期性
    pe_vals = pe.pe[0, :100, :4]  # 前100个位置的前4个维度
    print(f"PE range: [{pe_vals.min():.4f}, {pe_vals.max():.4f}]")

A-74. 【⭐⭐⭐】请用PyTorch实现一个完整的Transformer Encoder层（Pre-LN版本），包含Self-Attention和FFN。

答案：

class TransformerEncoderLayer(nn.Module):
    """
    Transformer Encoder层 (Pre-LN版本)

    结构:
        x -> LayerNorm -> Self-Attention -> Dropout -> +x ->
        LayerNorm -> FFN -> Dropout -> +x -> Output
    """
    def __init__(self, d_model=512, n_heads=8, d_ff=2048, dropout=0.1):
        super().__init__()
        # 子层1: Multi-Head Self-Attention
        self.self_attn = MultiHeadAttention(d_model, n_heads, dropout)

        # 子层2: Feed-Forward Network
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(d_ff, d_model),
            nn.Dropout(dropout)
        )

        # Pre-LN: 在子层输入前进行LayerNorm
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)

        # Dropout
        self.dropout1 = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        """
        x: [batch, seq_len, d_model]
        mask: [batch, 1, seq_len, seq_len] (可选)

        返回: [batch, seq_len, d_model]
        """
        # 子层1: Self-Attention with 残差连接 (Pre-LN)
        x_norm = self.norm1(x)                    # 先归一化
        attn_out, _ = self.self_attn(x_norm, x_norm, x_norm, mask)
        x = x + self.dropout1(attn_out)           # 残差连接

        # 子层2: FFN with 残差连接 (Pre-LN)
        x_norm = self.norm2(x)                    # 先归一化
        ffn_out = self.ffn(x_norm)
        x = x + ffn_out                           # 残差连接

        return x


class TransformerEncoder(nn.Module):
    """
    完整的Transformer Encoder（多层堆叠）
    """
    def __init__(self, num_layers=6, d_model=512, n_heads=8, 
                 d_ff=2048, dropout=0.1):
        super().__init__()
        self.layers = nn.ModuleList([
            TransformerEncoderLayer(d_model, n_heads, d_ff, dropout)
            for _ in range(num_layers)
        ])

    def forward(self, x, mask=None):
        for layer in self.layers:
            x = layer(x, mask)
        return x


# === 使用示例 ===
if __name__ == "__main__":
    B, L, d = 4, 50, 512
    encoder = TransformerEncoder(num_layers=6, d_model=d, n_heads=8)

    x = torch.randn(B, L, d)
    output = encoder(x)
    print(f"Output shape: {output.shape}")  # [4, 50, 512]

A-75. 【⭐⭐⭐】请用PyTorch实现一个完整的Transformer Decoder层（Pre-LN版本），包含Masked Self-Attention、Cross-Attention和FFN。

答案：

class TransformerDecoderLayer(nn.Module):
    """
    Transformer Decoder层 (Pre-LN版本)

    包含三个子层:
    1. Masked Multi-Head Self-Attention
    2. Multi-Head Cross-Attention (Encoder-Decoder Attention)
    3. Feed-Forward Network
    """
    def __init__(self, d_model=512, n_heads=8, d_ff=2048, dropout=0.1):
        super().__init__()
        # 子层1: Masked Self-Attention
        self.masked_self_attn = MultiHeadAttention(d_model, n_heads, dropout)

        # 子层2: Cross-Attention (Q来自Decoder, K/V来自Encoder)
        self.cross_attn = MultiHeadAttention(d_model, n_heads, dropout)

        # 子层3: Feed-Forward Network
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(d_ff, d_model),
            nn.Dropout(dropout)
        )

        # Pre-LN LayerNorm
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.norm3 = nn.LayerNorm(d_model)

        # Dropout
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)

    def forward(self, x, enc_output, tgt_mask=None, src_mask=None):
        """
        参数:
            x: [batch, tgt_len, d_model] (Decoder输入)
            enc_output: [batch, src_len, d_model] (Encoder输出)
            tgt_mask: [batch, 1, tgt_len, tgt_len] (Causal Mask + Padding Mask)
            src_mask: [batch, 1, 1, src_len] (Encoder Padding Mask)

        返回: [batch, tgt_len, d_model]
        """
        # 子层1: Masked Self-Attention
        x_norm = self.norm1(x)
        attn1_out, _ = self.masked_self_attn(x_norm, x_norm, x_norm, tgt_mask)
        x = x + self.dropout1(attn1_out)  # 残差连接

        # 子层2: Cross-Attention (Q来自Decoder, K/V来自Encoder)
        x_norm = self.norm2(x)
        attn2_out, _ = self.cross_attn(x_norm, enc_output, enc_output, src_mask)
        x = x + self.dropout2(attn2_out)  # 残差连接

        # 子层3: FFN
        x_norm = self.norm3(x)
        ffn_out = self.ffn(x_norm)
        x = x + ffn_out  # 残差连接

        return x


class TransformerDecoder(nn.Module):
    """
    完整的Transformer Decoder（多层堆叠）
    """
    def __init__(self, num_layers=6, d_model=512, n_heads=8,
                 d_ff=2048, dropout=0.1):
        super().__init__()
        self.layers = nn.ModuleList([
            TransformerDecoderLayer(d_model, n_heads, d_ff, dropout)
            for _ in range(num_layers)
        ])

    def forward(self, x, enc_output, tgt_mask=None, src_mask=None):
        for layer in self.layers:
            x = layer(x, enc_output, tgt_mask, src_mask)
        return x


# === 使用示例 ===
if __name__ == "__main__":
    B, src_L, tgt_L, d = 4, 60, 40, 512
    decoder = TransformerDecoder(num_layers=6, d_model=d, n_heads=8)

    x = torch.randn(B, tgt_L, d)          # Decoder输入
    enc_out = torch.randn(B, src_L, d)     # Encoder输出

    # 创建Causal Mask
    causal_mask = torch.tril(torch.ones(tgt_L, tgt_L)).unsqueeze(0).unsqueeze(0)

    output = decoder(x, enc_out, tgt_mask=causal_mask)
    print(f"Output shape: {output.shape}")  # [4, 40, 512]

A-76. 【⭐⭐⭐⭐⭐】请用PyTorch实现一个完整的Transformer模型（Encoder-Decoder），包含Embedding、Positional Encoding、Mask生成和输出层。

答案：

class Transformer(nn.Module):
    """
    完整Transformer模型 (Encoder-Decoder架构)

    适用于: 机器翻译、文本摘要等Seq2Seq任务
    """
    def __init__(
        self,
        src_vocab_size,           # 源语言词表大小
        tgt_vocab_size,           # 目标语言词表大小
        d_model=512,
        n_heads=8,
        n_encoder_layers=6,
        n_decoder_layers=6,
        d_ff=2048,
        max_len=512,
        dropout=0.1,
        pad_idx=0                 # <PAD> token的索引
    ):
        super().__init__()
        self.d_model = d_model
        self.pad_idx = pad_idx

        # ========== 嵌入层 ==========
        self.src_embedding = nn.Embedding(src_vocab_size, d_model)
        self.tgt_embedding = nn.Embedding(tgt_vocab_size, d_model)

        # 缩放embedding（原始Transformer论文建议）
        self.scale = math.sqrt(d_model)

        # ========== 位置编码 ==========
        self.pos_encoding = SinusoidalPositionalEncoding(d_model, max_len, dropout)

        # ========== Encoder ==========
        self.encoder = TransformerEncoder(
            n_encoder_layers, d_model, n_heads, d_ff, dropout
        )

        # ========== Decoder ==========
        self.decoder = TransformerDecoder(
            n_decoder_layers, d_model, n_heads, d_ff, dropout
        )

        # ========== 输出层 ==========
        self.output_layer = nn.Linear(d_model, tgt_vocab_size)

        # ========== 参数初始化 ==========
        self._init_parameters()

    def _init_parameters(self):
        """Xavier初始化"""
        for p in self.parameters():
            if p.dim() > 1:
                nn.init.xavier_uniform_(p)

    def make_src_mask(self, src):
        """
        为源序列生成Padding Mask
        src: [batch, src_len]
        返回: [batch, 1, 1, src_len]
        """
        return (src != self.pad_idx).unsqueeze(1).unsqueeze(2)

    def make_tgt_mask(self, tgt):
        """
        为目标序列生成Padding Mask + Causal Mask
        tgt: [batch, tgt_len]
        返回: [batch, 1, tgt_len, tgt_len]
        """
        # Padding Mask: [batch, 1, 1, tgt_len]
        tgt_pad_mask = (tgt != self.pad_idx).unsqueeze(1).unsqueeze(3)

        # Causal Mask: [1, 1, tgt_len, tgt_len]
        seq_len = tgt.size(1)
        causal_mask = torch.tril(
            torch.ones(seq_len, seq_len, device=tgt.device)
        ).bool().unsqueeze(0).unsqueeze(0)

        # 合并两个mask
        return tgt_pad_mask & causal_mask

    def encode(self, src, src_mask=None):
        """
        编码源序列
        src: [batch, src_len]
        返回: [batch, src_len, d_model]
        """
        x = self.src_embedding(src) * self.scale
        x = self.pos_encoding(x)
        return self.encoder(x, src_mask)

    def decode(self, tgt, enc_output, src_mask=None, tgt_mask=None):
        """
        解码目标序列
        tgt: [batch, tgt_len]
        enc_output: [batch, src_len, d_model]
        返回: [batch, tgt_len, d_model]
        """
        x = self.tgt_embedding(tgt) * self.scale
        x = self.pos_encoding(x)
        return self.decoder(x, enc_output, tgt_mask, src_mask)

    def forward(self, src, tgt):
        """
        完整的前向传播
        src: [batch, src_len]
        tgt: [batch, tgt_len]
        返回: [batch, tgt_len, tgt_vocab_size]
        """
        src_mask = self.make_src_mask(src)
        tgt_mask = self.make_tgt_mask(tgt)

        enc_output = self.encode(src, src_mask)
        dec_output = self.decode(tgt, enc_output, src_mask, tgt_mask)

        return self.output_layer(dec_output)


# === 使用示例 ===
if __name__ == "__main__":
    SRC_VOCAB = 10000  # 源语言词表
    TGT_VOCAB = 10000  # 目标语言词表

    model = Transformer(
        src_vocab_size=SRC_VOCAB,
        tgt_vocab_size=TGT_VOCAB,
        d_model=512,
        n_heads=8,
        n_encoder_layers=6,
        n_decoder_layers=6,
        d_ff=2048,
        max_len=512,
        dropout=0.1
    )

    # 模拟输入
    src = torch.randint(0, SRC_VOCAB, (4, 30))  # batch=4, src_len=30
    tgt = torch.randint(0, TGT_VOCAB, (4, 25))  # batch=4, tgt_len=25

    output = model(src, tgt)
    print(f"Output shape: {output.shape}")  # [4, 25, 10000]

    # 统计参数量
    total_params = sum(p.numel() for p in model.parameters())
    print(f"Total parameters: {total_params / 1e6:.2f}M")

A-77. 【⭐⭐⭐⭐⭐】请实现一个GPT风格的Decoder-only模型，支持自回归生成（逐token生成）。

答案：

class GPTDecoderOnly(nn.Module):
    """
    GPT风格的Decoder-only模型

    特点:
    - 仅使用Decoder（无Encoder）
    - Causal Self-Attention（只能看到之前的token）
    - 自回归生成
    """
    def __init__(
        self,
        vocab_size,
        d_model=768,
        n_heads=12,
        n_layers=12,
        d_ff=3072,
        max_len=1024,
        dropout=0.1,
        pad_idx=0
    ):
        super().__init__()
        self.d_model = d_model
        self.max_len = max_len
        self.pad_idx = pad_idx

        # Token嵌入
        self.token_embedding = nn.Embedding(vocab_size, d_model)
        # 可学习位置编码（GPT风格）
        self.pos_embedding = nn.Embedding(max_len, d_model)

        # Decoder层堆叠
        self.layers = nn.ModuleList([
            TransformerDecoderLayer(d_model, n_heads, d_ff, dropout)
            for _ in range(n_layers)
        ])

        self.norm = nn.LayerNorm(d_model)
        self.output = nn.Linear(d_model, vocab_size, bias=False)

        # Dropout
        self.dropout = nn.Dropout(dropout)

        self._init_parameters()

    def _init_parameters(self):
        for p in self.parameters():
            if p.dim() > 1:
                nn.init.xavier_uniform_(p)

    def make_causal_mask(self, seq_len, device):
        """生成Causal Mask"""
        return torch.tril(torch.ones(seq_len, seq_len, device=device)).bool()

    def forward(self, x):
        """
        训练时的前向传播
        x: [batch, seq_len]
        返回: [batch, seq_len, vocab_size]
        """
        B, T = x.shape
        assert T <= self.max_len, f"序列长度{T}超过最大长度{self.max_len}"

        # Token嵌入 + 位置编码
        positions = torch.arange(T, device=x.device).unsqueeze(0)
        x = self.dropout(
            self.token_embedding(x) + self.pos_embedding(positions)
        )

        # Causal Mask
        causal_mask = self.make_causal_mask(T, x.device).unsqueeze(0).unsqueeze(0)

        # 通过所有Decoder层
        # Decoder-only: self-attention的Q,K,V都来自自身
        # 不需要cross-attention，所以enc_output设为None
        enc_dummy = torch.zeros(B, 1, self.d_model, device=x.device)
        for layer in self.layers:
            # 简化：不使用cross-attention
            x_norm = layer.norm1(x)
            attn_out, _ = layer.masked_self_attn(x_norm, x_norm, x_norm, causal_mask)
            x = x + layer.dropout1(attn_out)
            x_norm = layer.norm2(x)
            x = x + layer.ffn(x_norm)

        x = self.norm(x)
        return self.output(x)

    @torch.no_grad()
    def generate(self, prompt, max_new_tokens=50, temperature=1.0, top_k=None):
        """
        自回归生成
        prompt: [batch, prompt_len] 的token索引
        返回: 生成的完整序列
        """
        self.eval()
        generated = prompt.clone()

        for _ in range(max_new_tokens):
            # 只使用最近的max_len个token
            input_ids = generated[:, -self.max_len:]

            # 前向传播
            logits = self.forward(input_ids)

            # 取最后一个位置的logits
            next_token_logits = logits[:, -1, :] / temperature

            # Top-k采样
            if top_k is not None:
                v, _ = torch.topk(next_token_logits, top_k)
                next_token_logits[next_token_logits < v[:, [-1]]] = -float('inf')

            # 采样下一个token
            probs = F.softmax(next_token_logits, dim=-1)
            next_token = torch.multinomial(probs, num_samples=1)

            generated = torch.cat([generated, next_token], dim=1)

        return generated


# === 使用示例 ===
if __name__ == "__main__":
    VOCAB_SIZE = 50000
    model = GPTDecoderOnly(
        vocab_size=VOCAB_SIZE,
        d_model=768,
        n_heads=12,
        n_layers=12,
        d_ff=3072,
        max_len=512
    )

    # 训练模式
    x = torch.randint(0, VOCAB_SIZE, (2, 100))
    logits = model(x)
    print(f"Logits shape: {logits.shape}")  # [2, 100, 50000]

    # 生成模式
    prompt = torch.randint(0, VOCAB_SIZE, (1, 10))
    generated = model.generate(prompt, max_new_tokens=20, temperature=0.8, top_k=50)
    print(f"Generated shape: {generated.shape}")  # [1, 30]

A-78. 【⭐⭐⭐⭐⭐】请实现带有KV-Cache优化的自回归生成，用于加速大模型推理。

答案：

class KVCacheAttention(nn.Module):
    """
    支持KV-Cache的多头注意力模块
    """
    def __init__(self, d_model=512, n_heads=8, dropout=0.1):
        super().__init__()
        assert d_model % n_heads == 0
        self.d_model = d_model
        self.n_heads = n_heads
        self.d_k = d_model // n_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)
        self.W_O = nn.Linear(d_model, d_model)

        self.dropout = nn.Dropout(dropout)
        self.scale = math.sqrt(self.d_k)

    def forward(self, x, kv_cache=None, use_cache=False):
        """
        支持KV-Cache的前向传播

        参数:
            x: [batch, seq_len, d_model]
               - 首次调用时seq_len = prompt_len
               - 后续调用时seq_len = 1（只传入新的token）
            kv_cache: dict或None, 包含'k'和'v'的缓存
            use_cache: 是否使用并返回KV-Cache

        返回:
            output: [batch, seq_len, d_model]
            new_kv_cache: 更新后的KV-Cache（如果use_cache=True）
        """
        B, T, _ = x.shape

        # 线性投影
        Q = self.W_Q(x).view(B, T, self.n_heads, self.d_k).transpose(1, 2)
        K_new = self.W_K(x).view(B, T, self.n_heads, self.d_k).transpose(1, 2)
        V_new = self.W_V(x).view(B, T, self.n_heads, self.d_k).transpose(1, 2)

        # KV-Cache逻辑
        if kv_cache is not None:
            # 拼接缓存的K,V
            K = torch.cat([kv_cache['k'], K_new], dim=2)  # [B, H, cache_len+T, d_k]
            V = torch.cat([kv_cache['v'], V_new], dim=2)
        else:
            K, V = K_new, V_new

        # 计算注意力
        scores = torch.matmul(Q, K.transpose(-2, -1)) / self.scale
        attn = F.softmax(scores, dim=-1)
        attn = self.dropout(attn)

        out = torch.matmul(attn, V)  # [B, H, T, d_k]
        out = out.transpose(1, 2).contiguous().view(B, T, self.d_model)
        output = self.W_O(out)

        if use_cache:
            new_cache = {'k': K, 'v': V}
            return output, new_cache
        return output


class DecoderWithKVCache(nn.Module):
    """
    使用KV-Cache加速的Decoder模型
    """
    def __init__(self, vocab_size, d_model=512, n_heads=8, n_layers=6, 
                 max_len=2048, dropout=0.1):
        super().__init__()
        self.token_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb = nn.Embedding(max_len, d_model)

        self.layers = nn.ModuleList([
            nn.ModuleDict({
                'attn': KVCacheAttention(d_model, n_heads, dropout),
                'ln1': nn.LayerNorm(d_model),
                'ffn': nn.Sequential(
                    nn.Linear(d_model, 4 * d_model),
                    nn.GELU(),
                    nn.Linear(4 * d_model, d_model),
                ),
                'ln2': nn.LayerNorm(d_model),
            }) for _ in range(n_layers)
        ])

        self.norm = nn.LayerNorm(d_model)
        self.output = nn.Linear(d_model, vocab_size)

    @torch.no_grad()
    def generate(self, prompt, max_new_tokens=50, temperature=1.0):
        """
        使用KV-Cache的自回归生成
        """
        self.eval()
        device = prompt.device
        generated = prompt.clone()

        # 初始化每层的KV-Cache
        past_key_values = [None] * len(self.layers)

        for i in range(prompt.size(1) + max_new_tokens):
            # 只输入最新的token（首次输入整个prompt）
            if i < prompt.size(1):
                input_ids = generated[:, :i+1]
            else:
                input_ids = generated[:, -1:]

            B, T = input_ids.shape
            pos = torch.arange(i+1-T, i+1, device=device).unsqueeze(0)
            x = self.token_emb(input_ids) + self.pos_emb(pos)

            # 通过各层，使用KV-Cache
            for layer_idx, layer in enumerate(self.layers):
                # Self-Attention with KV-Cache
                x_norm = layer['ln1'](x)
                attn_out, past_key_values[layer_idx] = layer['attn'](
                    x_norm, 
                    kv_cache=past_key_values[layer_idx],
                    use_cache=True
                )
                x = x[:, -attn_out.size(1):] + attn_out

                # FFN
                x = x + layer['ffn'](layer['ln2'](x))

            x = self.norm(x)

            # 只在生成新token时计算输出
            if i >= prompt.size(1) - 1:
                logits = self.output(x[:, -1:, :])
                next_token_logits = logits[:, -1, :] / temperature
                probs = F.softmax(next_token_logits, dim=-1)
                next_token = torch.multinomial(probs, num_samples=1)
                generated = torch.cat([generated, next_token], dim=1)

                if generated.size(1) >= prompt.size(1) + max_new_tokens:
                    break

        return generated


# === 性能对比 ===
if __name__ == "__main__":
    model = DecoderWithKVCache(vocab_size=50000, d_model=512, n_layers=6)
    prompt = torch.randint(0, 50000, (1, 50))

    import time
    start = time.time()
    output = model.generate(prompt, max_new_tokens=30, temperature=0.9)
    elapsed = time.time() - start

    print(f"Generated: {output.shape}")
    print(f"Time: {elapsed:.2f}s")
    print(f"Tokens/sec: {30/elapsed:.1f}")