---
tags: [AI, LLM, 因果注意力]
阶段: 05-Transformer与LLM原理
难度: ★★★
created: 2026-10-18
related: "[[注意力机制与QKV]], [[KV缓存]], [[Transformer架构详解]]"
---

# 因果注意力与多头注意力

## 定义

**因果注意力**（causal attention）是在自注意力中把位置 $t$ 的允许配对集合限制为 $\{1,\dots,t\}$ 的形式，使位置 $t$ 的输出只依赖前缀 $\mathbf{x}_{\le t}$，不依赖任何未来位置。**因果掩码**（causal mask）是实现该限制的加性矩阵 $\mathbf{M}$，满足 $M_{tj}=0$（$j\le t$）与 $M_{tj}=-\infty$（$j>t$）。**多头注意力**（multi-head attention）是并行计算 $h$ 组独立投影的注意力、把 $h$ 个头的输出沿通道维拼接后再做一次线性投影的运算，定义见 [[注意力机制与QKV]] 第 8 节。

本篇符号约定如下，与 [[注意力机制与QKV]] 一致的部分只列形状。

| 符号 | 含义 |
|---|---|
| $B$ | 批量大小 |
| $T$ | 序列长度 |
| $C$ | 模型维度，即 $d_{\text{model}}$；代码用 $C$，复杂度表达式沿用 $d$ |
| $h$ | 注意力头数 |
| $d_h$ | 每头维度，$d_h=C/h$ |
| $\mathbf{X}\in\mathbb{R}^{B\times T\times C}$ | 一层注意力的输入 |
| $x_t$、$\mathbf{x}_t$ | 位置 $t$ 的 token 及其输入向量，$\mathbf{x}_t\in\mathbb{R}^{C}$ |
| $\mathbf{M}\in(\mathbb{R}\cup\{-\infty\})^{T\times T}$ | 因果掩码 |
| $\mathbf{Q},\mathbf{K},\mathbf{V}\in\mathbb{R}^{B\times h\times T\times d_h}$ | 分头后的查询、键、值 |
| $\mathbf{S},\mathbf{A}\in\mathbb{R}^{B\times h\times T\times T}$ | 分头后的打分与权重 |
| $L_{\text{block}}$ | 掩码预分配的最大长度，代码中的 `block_size` |
| $\mathcal{L}$ | 负对数似然损失 |

术语定义：**自回归语言模型**（autoregressive language model）是把序列概率分解为逐位置条件概率乘积的模型；**教师强制**（teacher forcing）指训练时每个位置的输入取真实前缀而非模型自身的输出；**预填充**（prefill）指推理时对整段提示一次性前向；**解码**（decode）指逐个生成新 token 的阶段；**头专门化**（head specialization）指不同注意力头在训练后呈现不同的关注模式。

## 为什么重要

自回归语言模型的目标是建模 $p_\theta(x_1,\dots,x_T)$，标准做法是写成条件概率的乘积并对每个位置做下一 token 预测。这一分解要求预测 $x_t$ 时只能使用 $x_1,\dots,x_{t-1}$；等价地，位置 $t$ 的表示只能读取 $x_1,\dots,x_t$，其中 $x_t$ 是该位置自身的输入 token（生成第 $t+1$ 个 token 时它已经存在），不能读取 $x_{t+1},\dots,x_T$。若注意力不做掩码，第 $t$ 个位置的表示会混入后续 token 的信息，训练损失可以降到接近零：模型只需通过值向量与输出投影把下一个 token 复制到当前位置，不需要学习任何语言规律。这样的模型在训练集上表现完美，在生成时无法使用，因为待预测的 token 尚不存在。

因果掩码同时是训练并行化的前提。有了掩码，一次前向可以对全部 $T$ 个位置同时计算条件分布，反向也只做一次，每层代价为 $O(T^2d)$；若按位置循环，第 $t$ 步需重算前 $t$ 个位置，总代价为 $O(T^3d)$。训练与推理的计算结构差异全部源于这一点：训练时所有位置的输入已知，可以并行；推理时第 $t+1$ 步的输入是第 $t$ 步的输出，只能串行。这一差异直接决定 [[KV缓存]] 的必要性，也决定推理阶段的瓶颈从算力转向显存带宽。

多头的意义在容量与表示分工。单个 softmax 只给出一个归一化分布，需要同时读取多个位置时权重被摊薄；$h$ 个头给出 $h$ 个独立分布，参数量与单头全维相同（$4d^2$），计算量也相同，只增加张量重排的开销。多头的实现细节是工程正确性的高发区：头维与 token 维的顺序、拆分与拼接的互逆性、缩放使用的维度；其中一部分错误（如头维顺序）不会报错，只表现为性能下降，另一部分（如掩码切片）会直接抛出形状错误。

在本库中的位置：本篇承接 [[注意力机制与QKV]] 的缩放点积注意力，给出因果约束的推导与多头的完整实现；[[KV缓存]] 在本篇第 4 节的推理结构上展开；[[Transformer架构详解]] 把本层与残差、LayerNorm、前馈网络组装成完整模型；[[位置编码-正弦与RoPE]] 处理本篇结构对位置不敏感的问题。对应学习目标：懂原理要求证明因果性在整栈中的传递；能复现要求写出可运行的 `CausalSelfAttention` 并核对形状与参数量；会评估要求能判断训练与推理的瓶颈差异。

## 原理与推导

### 1 自回归分解与因果约束

设词表为 $\mathcal{V}$，序列为 $(x_1,\dots,x_T)$，$x_t\in\mathcal{V}$。链式法则给出精确分解

$$
p_\theta(x_1,\dots,x_T)=\prod_{t=1}^{T}p_\theta\big(x_t\mid x_{<t}\big),\qquad x_{<t}=(x_1,\dots,x_{t-1}),
$$

训练目标为最小化负对数似然

$$
\mathcal{L}(\theta)=-\sum_{t=1}^{T}\log p_\theta\big(x_t\mid x_{<t}\big).
$$

该目标对模型结构提出一条约束：记第 $l$ 层第 $t$ 个位置的表示为 $\mathbf{h}_t^{(l)}$，则对任意 $l$ 必须有

$$
\mathbf{h}_t^{(l)}=f_l\big(\mathbf{x}_1,\dots,\mathbf{x}_t\big),
$$

即 $\mathbf{h}_t^{(l)}$ 是前缀的函数。满足该性质的结构称为因果的。下面用归纳法证明：由嵌入、因果注意力、逐位置前馈、残差与 LayerNorm 组成的栈是因果的。

基础情形 $l=0$：$\mathbf{h}_t^{(0)}=\mathbf{e}_{x_t}+\mathbf{p}_t$，其中 $\mathbf{e}_{x_t}$ 是 token 的嵌入向量、$\mathbf{p}_t$ 是位置编码，两者都只涉及位置 $t$，故 $\mathbf{h}_t^{(0)}$ 只用 $x_t$，而 $x_t$ 是前缀 $x_{\le t}$ 的一部分。

归纳步。设第 $l-1$ 层满足因果性，考察第 $l$ 层的四个组成。

- 注意力子层：$\mathbf{o}_t=\sum_{j\le t}a_{tj}\mathbf{v}_j$。其中 $\mathbf{v}_j=\mathbf{h}_j^{(l-1)}\mathbf{W}_V$ 依赖 $x_{\le j}\subseteq x_{\le t}$；打分 $a_{tj}$ 由 $\mathbf{q}_t$ 与 $\mathbf{k}_j$ 决定，二者分别依赖 $x_{\le t}$ 与 $x_{\le j}$；求和下标限制为 $j\le t$。三项合起来使 $\mathbf{o}_t$ 只依赖 $x_{\le t}$。
- 残差：$\mathbf{h}_t^{(l-1)}+\mathbf{o}_t$，两个加项都只依赖 $x_{\le t}$。
- LayerNorm：对单个位置的通道维做归一化，不跨位置混合，保持因果性。
- 前馈网络：对每个位置独立施加同一个 MLP，不跨位置混合，保持因果性。

四项都不引入对 $j>t$ 的依赖，故第 $l$ 层满足因果性，归纳成立。

若无掩码，约束被破坏的方式如下。去掉掩码后 $\mathbf{o}_t=\sum_{j=1}^{T}a_{tj}\mathbf{v}_j$，$\mathbf{h}_t^{(l)}$ 依赖全部 $\mathbf{x}$。若在位置 $t$ 之后接输出层预测 $x_{t+1}$，则预测的输入中已包含 $x_{t+1}$ 的嵌入。优化器可以把整条读取路径（$\mathbf{W}_V$、注意力权重、$\mathbf{W}_O$ 与输出投影）学成近似恒等映射并令 $a_{t,t+1}\to1$，从而直接读出答案，损失趋零而模型不具备任何生成能力。这一现象称为信息泄漏（information leakage），它不是过拟合，而是训练目标与推理条件不一致。

### 2 因果掩码的构造

因果掩码按位置定义

$$
M_{tj}=\begin{cases}0, & j\le t,\\[2pt] -\infty, & j>t.\end{cases}
$$

$T=4$ 时

$$
\mathbf{M}=
\begin{pmatrix}
0 & -\infty & -\infty & -\infty\\
0 & 0 & -\infty & -\infty\\
0 & 0 & 0 & -\infty\\
0 & 0 & 0 & 0
\end{pmatrix}.
$$

实现上有两种等价表示。其一是浮点矩阵，允许位置为 $0$、禁止位置为 $-\infty$ 或充分小的负数（如 $-10^{9}$），直接与打分相加。其二是布尔矩阵，取 $\text{True}$ 表示禁止，再用 `masked_fill` 置为 $-\infty$。布尔版本的存储为每元素 1 字节，浮点版本为 4 或 2 字节，且布尔版本不依赖具体数值，在混合精度下不会出现表示范围问题。

构造方式利用三角矩阵函数：

```python
import numpy as np
import torch

T = 4
mask_float = np.triu(np.full((T, T), -np.inf), k=1)                        # NumPy
mask_bool = torch.triu(torch.ones(T, T, dtype=torch.bool), diagonal=1)     # PyTorch
```

`np.triu(..., k=1)` 保留严格上三角、其余置零，因此传入全 $-\infty$ 矩阵时得到"上三角为 $-\infty$、下三角与对角线为 $0$"的结果。$k=0$ 会把对角线一起置零，得到严格因果掩码，即位置 $t$ 看不到自身，用于逐位置预测任务；语言模型的下一 token 预测需要位置 $t$ 看到自身，故取 $k=1$。

工程上掩码在模块初始化时一次构造并注册为缓冲区，调用形式为 `self.register_buffer("mask", tensor, persistent=False)`。

缓冲区的语义有三条。第一，它随 `module.to(device)`、`module.half()` 一起迁移与转换，使用者不必手动搬运；若每次前向重新构造，必须显式指定 `device` 与 `dtype`，否则会出现设备不一致或精度不一致的错误。第二，它不被优化器更新，也不计算梯度，因为它不是 `nn.Parameter`。第三，`persistent=False` 使它不进入 `state_dict`，保存与加载检查点时不产生冗余键；旧版本模型加载新检查点时也不会因多出键而报错。

掩码的尺寸按最大上下文 $L_{\text{block}}$ 预分配，前向时切片 `mask[:, :, :T, :T]`。这要求 $T\le L_{\text{block}}$，实现中应当显式断言；若 $T>L_{\text{block}}$，切片不会报错而是返回较短的掩码，随后与打分矩阵相加时形状不匹配，或在某些广播布局下静默截断，导致部分位置未被掩码。前一种情况容易发现，后一种不会报错，是长上下文实验中需要重点排查的问题。

### 3 归一化必须在掩码之后

记未掩码的打分为 $s_{tj}$，允许集合为 $\mathcal{A}_t=\{j:j\le t\}$。正确的权重是 softmax 在 $\mathcal{A}_t$ 上的归一化：

$$
a_{tj}=\frac{\exp(s_{tj})}{\sum_{j'\in\mathcal{A}_t}\exp(s_{tj'})},\qquad j\in\mathcal{A}_t,\qquad a_{tj}=0,\quad j\notin\mathcal{A}_t .
$$

前置掩码实现这一点的机制是：$-\infty$ 使禁止位置的指数为 0，且 $0$ 进入分母不改变分母的值，因此分母恰好是 $\sum_{j'\in\mathcal{A}_t}\exp(s_{tj'})$。

后置掩码有两种写法，结果不同。第一种是 softmax 之后置零而不重新归一化：

$$
a^{\text{bad}}_{tj}=a^{0}_{tj}\cdot\mathbb{1}[j\le t],\qquad a^{0}_{tj}=\frac{\exp(s_{tj})}{\sum_{j'=1}^{T}\exp(s_{tj'})}.
$$

此时行和为 $\sum_{j\le t}a^{0}_{tj}<1$，输出被整体缩小，缩小比例随 $t$ 变化：$t$ 越小，允许的位置越少，被丢弃的质量越多。极端情形 $t=1$ 只剩一个允许位置，输出被缩小到该位置的原始权重。这一偏差不是常数缩放，无法被后续层学到的偏置吸收，因为不同位置的缩放比例不同。

第二种是先置零再除以行和：

$$
a^{\text{post}}_{tj}=\frac{a^{0}_{tj}\cdot\mathbb{1}[j\le t]}{\sum_{j'\le t}a^{0}_{tj'}}
=\frac{\exp(s_{tj})\big/\sum_{l=1}^{T}\exp(s_{tl})}{\sum_{j'\le t}\exp(s_{tj'})\big/\sum_{l=1}^{T}\exp(s_{tl})}
=\frac{\exp(s_{tj})}{\sum_{j'\le t}\exp(s_{tj'})},
$$

与前置掩码逐元素相等。推导中分子分母的公共因子 $\sum_{l=1}^{T}\exp(s_{tl})$ 被约去，因此两种写法在精确算术下等价，实测差值在 float64 舍入量级（例 3）。

两种写法并非完全可互换，差别有三点。其一是中间量：后置写法需要先算出完整的 $T\times T$ softmax，再置零、再求和、再相除，多两次 $T^2$ 规模的逐元素运算与一个临时张量；前置写法把这些并入 softmax 内核。其二是梯度路径：前置写法中被屏蔽位置在计算图中取值为 $-\infty$，其指数恒为 0，反向时该位置不接收梯度；不重新归一化的后置写法中，被屏蔽位置的打分仍出现在分母里，因此仍会收到非零梯度，而它本不应参与归一化，这部分梯度是错误的。其三是数值范围：后置写法先得到一组行和小于 1 的概率，再相除；若某些 $a^{0}_{tj}$ 在低精度下下溢为 0，除法会把相对误差放大。

由此得到准确的表述：约束不是"掩码必须在 softmax 之前"这一实现细节，而是"归一化必须只在允许集合上进行"。前置 $-\infty$ 是最直接、最省中间量、梯度语义最清晰的实现，因此成为标准做法。

### 4 训练时并行与推理时逐 token

训练阶段的输入是完整的 token 序列，形状为 $(B,T)$、元素取值于 $1,\dots,V$。前向一次得到 logits $\in\mathbb{R}^{B\times T\times V}$，与右移一位的目标比较，损失对全部 $T$ 个位置求和。每一层注意力的打分是 $B\times h$ 个 $T\times T$ 矩阵的批量乘法，代价 $O(BThTd_h)=O(BT^2d)$。因果掩码保证第 $t$ 行的计算只读取前 $t$ 列，因此同时计算全部位置不违反因果性。这一并行性依赖教师强制：位置 $t$ 的输入是真实 token $x_t$，与模型在第 $t-1$ 步会输出什么无关，所以全部位置可以同时送入。

推理阶段的条件不同。生成第 $t+1$ 个 token 需要分布 $p_\theta(\cdot\mid x_{\le t})$，而 $x_{t+1}$ 尚未产生，前缀只能由模型自己逐步扩展。于是必须逐 token 前向，第 $t$ 步的输出位置只有一个，但该位置的表示需要读取前 $t$ 个位置的值向量。

不做缓存时，第 $t$ 步要把长度 $t$ 的前缀完整重算一遍，代价 $O(t^2d)$，生成 $T$ 个 token 的总代价为

$$
\sum_{t=1}^{T}O(t^{2}d)=O(T^{3}d),
$$

是训练一次前向的 $T$ 倍。做缓存时，第 $l$ 层的键与值 $\mathbf{k}^{(l)}_{1:t}$、$\mathbf{v}^{(l)}_{1:t}$ 在生成过程中不变，可以保存下来复用，每步只需为新 token 计算 $\mathbf{q},\mathbf{k},\mathbf{v}$ 并追加，代价降为 $O(td)$ 的打分与 $O(d^2)$ 的投影，总代价回到 $O(T^2d)$。缓存的显存公式与实现见 [[KV缓存]]。

两种阶段的计算特征不同。训练阶段每次前向处理 $B\times T$ 个位置，矩阵乘的规模大，受算力限制；推理阶段每步只处理 1 个位置，却要读入全部权重与全部缓存，受显存带宽与内核启动开销限制。同一模型在两种阶段的吞吐差异可达两个数量级，这是 [[模型推理优化]] 中批处理、量化与算子融合的出发点。

因果掩码与缓存的交互需要单独说明。使用缓存时，查询长度为 1（只有新 token），键长度为 $t+1$（缓存加新 token），且全部键都位于查询之前，因果掩码退化为全允许，不需要再施加。若沿用形状 $(T,T)$ 的三角掩码，会与 $(1,t+1)$ 的打分广播，可能掩掉合法位置或触发形状错误；若缓存中的键顺序与位置编码不一致，掩码即使形状正确也会对应错误的位置。正确做法是解码阶段不施加因果掩码，或构造形状 $(1,t+1)$ 的全零掩码，并在实现中区分预填充与解码两条路径。

| 阶段 | 输入 | 注意力打分规模 | 总代价 | 主要瓶颈 |
|---|---|---|---|---|
| 训练 | $(B,T)$ 全部位置 | $B\times h$ 个 $T\times T$ | $O(T^2d)$ 一次 | 算力 |
| 推理，无缓存 | 逐步前缀 | 第 $t$ 步 $t\times t$ | $O(T^3d)$ | 算力 |
| 推理，有缓存 | 新 token 与缓存 | 第 $t$ 步 $1\times(t+1)$ | $O(T^2d)$ 累计 | 显存带宽 |

### 5 多头的维度布局

多头实现的核心是把通道维拆成"头数 × 每头维度"，并在矩阵乘法前后做正确的转置。以 $B=2$、$T=16$、$C=384$、$h=6$ 为例，形状链如下。

| 步骤 | 操作 | 形状 |
|---|---|---|
| 输入 | $\mathbf{X}$ | $(2,16,384)$ |
| 合并投影 | `c_attn`，权重 $(384,1152)$ | $(2,16,1152)$ |
| 切分 | `split(384, dim=2)` | 三个 $(2,16,384)$ |
| 拆头 | `view(B,T,h,d_h)` | $(2,16,6,64)$ |
| 换轴 | `transpose(1,2)` | $(2,6,16,64)$ |
| 打分 | $\mathbf{Q}\mathbf{K}^{\top}/\sqrt{d_h}$ | $(2,6,16,16)$ |
| softmax | 沿最后一维 | $(2,6,16,16)$ |
| 加权 | $\mathbf{A}\mathbf{V}$ | $(2,6,16,64)$ |
| 并头 | `transpose(1,2)` | $(2,16,6,64)$ |
| 展平 | `contiguous().view(B,T,C)` | $(2,16,384)$ |
| 输出投影 | `c_proj`，权重 $(384,384)$ | $(2,16,384)$ |

拆分的语义：`view(B,T,h,d_h)` 把最后一维 $C$ 按行优先顺序切成 $h$ 段，第 $i$ 个头占据通道区间 $[i\,d_h,\ (i+1)d_h)$。`transpose(1,2)` 只交换步长，不复制数据，得到的张量在内存中不连续。两次矩阵乘法都作用在最后两维上，PyTorch 与 NumPy 的批量矩阵乘都接受非连续输入，因此这一步不产生复制。真正的复制发生在 `contiguous()`：它把 $(B,h,T,d_h)$ 的布局改写为 $(B,T,h,d_h)$ 的连续布局，随后 `view` 把最后两维合并为 $C$，此时第 $i$ 个头的 $d_h$ 个通道恰好落在输出通道区间 $[i\,d_h,(i+1)d_h)$，与拆分时的顺序一致。

若把 `contiguous()` 换成 `reshape()`，结果相同：`reshape` 在无法返回视图时会隐式复制。若写成 `view()`，非连续张量会使该调用抛出错误。两种写法都对，但显式 `contiguous()` 把复制点暴露在代码中，便于分析显存峰值；隐式复制则可能在性能分析时表现为来源不明的算子。

并头的顺序必须与拆头的顺序互逆。`transpose(1,2)` 是自逆操作，`view(B,T,C)` 是 `view(B,T,h,d_h)` 的逆操作，因此"拆开再合并"恢复原顺序。若中途出现别的重排而没有相应逆操作，头与通道的对应关系被改变。若该改变只是一个固定置换，输出投影 $\mathbf{W}_O$ 的列可以学到补偿，模型仍能训练；若改变把 token 维卷入了头维，则不是置换：不同 token 的通道被分配到同一个头，位置语义被破坏，因果掩码也随之失效，而这一切不会产生任何形状错误。例 4 给出这一错误的数值表现。

### 6 缩放、dropout 与残差

缩放因子为 $1/\sqrt{d_h}$，其中 $d_h=C/h$ 是每头维度，不是 $C$。以 $C=384$、$h=6$ 为例，$\sqrt{d_h}=8$，$\sqrt{C}=19.6$，两者相差 $\sqrt{h}=2.45$ 倍。用错维度的后果是打分尺度过大或过小：用 $\sqrt{C}$ 会过度缩小，等价于把有效温度调高，注意力分布趋于均匀；用 $\sqrt{h}$ 之类更小的常数则会加剧饱和。

缩放只施加一次。两种等价位置是作用在打分上（`att / math.sqrt(d_h)`）或预先作用在查询上（`q / math.sqrt(d_h)` 后再做内积）。同时施加两次会使等效因子变为 $1/d_h$，打分方差变为 $1/d_h$，分布过于平坦；反向时查询与键的梯度尺度也会与预期不符。

dropout 有两处。第一处作用在注意力权重上，位于 softmax 之后、与 $\mathbf{V}$ 相乘之前，原论文基础模型的配置中丢弃率为 $0.1$。它按元素独立地把权重置零，并对保留下来的元素乘以 $1/(1-p)$，使权重的期望不变。训练时行和不再等于 1（被置零的位置质量为 0，保留位置按比例放大），这是正则化的预期行为；推理时关闭 dropout，行和恢复为 1。因此任何以"行和为 1"作为正确性检验的代码都必须在 `eval()` 模式下运行。

第二处作用在子层输出上（残差 dropout），位于输出投影之后、进入残差相加之前。它随机丢弃部分通道，迫使后续层不依赖单一通道。两处 dropout 的随机性不同：前者作用于 $T\times T$ 的权重矩阵，后者作用于 $C$ 维的通道。

dropout 与掩码的交互是安全的，但原因需要说明：注意力 dropout 是乘性缩放，被掩码位置的权重在 softmax 后已精确为 0，乘以任何缩放因子仍为 0，因此 dropout 不会"复活"被屏蔽的位置。若把噪声加在打分上而不是权重上，则被屏蔽位置可能因噪声而重新获得质量，这与标准做法不同。

### 7 多头与多个独立注意力的关系

多头常被描述为"$h$ 个独立的注意力"，这一描述只在部分意义上成立。逐项对照如下。

参数层面：每个头有独立的 $\mathbf{W}_Q^{i},\mathbf{W}_K^{i},\mathbf{W}_V^{i}$，各自 $C\times d_h$，不同头之间不共享参数，这一点与"多个独立注意力"一致。

计算层面：每个头的 softmax 独立进行，第 $i$ 个头的权重分布只由第 $i$ 个头的打分决定，不与其他头交互，这一点也一致。

输出层面：$h$ 个头的输出不是各自独立地进入后续层，而是沿通道拼接后乘同一个 $\mathbf{W}_O$：

$$
\mathbf{y}_t=\sum_{i=1}^{h}\mathbf{W}_O^{i}\Big(\sum_{j\le t}a^{(i)}_{tj}\mathbf{v}^{(i)}_j\Big),
$$

其中 $\mathbf{W}_O^{i}$ 是 $\mathbf{W}_O$ 的第 $i$ 个列块。输出是 $h$ 项之和，每项都经一个稠密矩阵映射，因此各头的贡献在输出端被线性混合，无法分配给某个头单独的语义。

梯度层面：损失不分别作用于各个头。$\partial\mathcal{L}/\partial\mathbf{W}_O$ 汇聚全部头的输出，$\partial\mathcal{L}/\partial\mathbf{W}_Q^{i}$ 只经过第 $i$ 个头，因此参数更新部分解耦、部分耦合。若 $\mathbf{W}_O$ 恰为分块对角且每块为 $\alpha\mathbf{I}$，各头在输出端完全不交互，多头退化为 $h$ 个并行的单头注意力再拼接；训练中 $\mathbf{W}_O$ 稠密，一般不会停在该形式。

函数层面：单个头只能输出一个凸组合，多头输出是 $h$ 个凸组合经不同线性映射后的和。以 $h=2$ 为例，为便于与单头比较，设两个头使用相同的值投影（取 $\mathbf{W}_V^{1}=\mathbf{W}_V^{2}=\mathbf{I}$ 且 $\mathbf{V}=\mathbf{X}$），头 1 的权重集中在位置 $j_1$、头 2 的权重集中在位置 $j_2$，并取 $\mathbf{W}_O^{1}=\mathbf{W}_O^{2}=\mathbf{I}$，则输出为 $\mathbf{v}_{j_1}+\mathbf{v}_{j_2}$。单个头的输出必须形如 $\sum_j a_j\mathbf{v}_j$ 且 $\sum_j a_j=1$，要等于 $\mathbf{v}_{j_1}+\mathbf{v}_{j_2}$ 需要权重之和为 2，一般无解。反过来，取 $h=1$ 时多头公式退化为单头公式，因此多头在同等参数量与计算量下是单头的严格推广。

结论：多头是"参数独立、分布独立、输出混合"的结构。称其为多个独立注意力，只在描述前两项时准确；忽略输出端共享的 $\mathbf{W}_O$，会高估各头的独立性与可解释性。

### 8 头的专门化：经验观察与解释边界

在公开模型上可视化注意力权重，可以观察到若干重复出现的模式。位置模式：部分头系统性地关注前一个 token 或某个固定偏移的过去位置（因果模型中不存在关注未来位置的头）。句法模式：部分头在依存关系两端之间分配较高权重。复制模式：部分头在"$A\,B\ \dots\ A$"出现时把权重从当前的 $A$ 移向先前的 $B$，这一模式与上下文学习中的复制行为相关。稀有 token 模式：部分头集中关注低频 token，可能与信息汇聚有关。

这些观察的解释力有四条边界。

第一，权重不等于贡献。注意力权重只说明读取了哪些位置，不说明读取到的信息对输出起了多大作用。值向量在拼接与投影后可能被后续通道抑制，前馈网络也可以改写该信息。因果证据需要干预实验（替换激活、消融单个头、测量输出变化），仅凭权重图不能得出"该头负责某功能"的结论。

第二，头之间存在冗余。消融单个头通常只造成小幅性能变化，同时移除多个头的影响也常小于线性叠加，说明功能由多组头分担。专门的解释需要说明剩余头如何补偿，而这一点难以从权重图直接读出。

第三，专门化依赖训练数据、初始化与模型规模，跨模型不可直接迁移。同一索引的头在不同模型中呈现不同模式，同一功能在不同模型中可能由不同索引承担，因此"第 $k$ 层第 $i$ 个头是句法头"这类陈述只在特定检查点上成立。

第四，可视化受归一化约束。softmax 使每行和为 1，一行的权重高只说明相对分配，不说明绝对读取强度；不同层的权重尺度不可直接比较，图中颜色深浅也不对应信息量。

因此，关于头专门化的合理表述是：训练后的多头模型中存在可重复观察到的关注模式，这些模式与某些语言现象相关；它们是否构成功能分工，需要消融或干预实验支持，且结论限于被研究的检查点。

## 关键直觉

> [!tip] 机制性表述
> 因果掩码把注意力矩阵的允许集合限制为下三角，使第 $t$ 行只在 $\{1,\dots,t\}$ 上归一化；这一限制在整栈中逐层传递，保证位置 $t$ 的表示是前缀的函数。训练时全部位置同时前向，因为每个位置的输入都是真实 token；推理时只能逐 token 前向，因为下一步的输入依赖上一步的输出，这一结构差异使缓存键与值成为必要。多头在这个框架内并行执行 $h$ 次归一化，每个头在自己的 $d_h$ 维子空间内独立分配权重，输出端经共享的 $\mathbf{W}_O$ 混合。

该表述与严格定义的关系：下三角归一化是定义中的掩码条件；逐层传递依赖第 1 节的归纳证明，其中逐步指出注意力、残差、LayerNorm、前馈都不引入对未来的依赖；输出端混合由第 7 节的分解式给出，它同时说明"独立"只成立于参数与分布两个层面。

## 例子与代码

以下 NumPy 代码在 Python 3.12.14、NumPy 2.3.5 下运行，输出为实际打印结果。PyTorch 代码需 2.0 及以上，本机未安装 PyTorch，形状与参数量按定义推出。

### 例 1：构造因果掩码

```python
import numpy as np

T = 4
mask_float = np.triu(np.full((T, T), -np.inf), k=1)      # 严格上三角为 -inf
mask_bool = np.triu(np.ones((T, T), dtype=bool), k=1)    # True 表示禁止
print(mask_float)
print(mask_bool)
print(mask_bool.sum(1))                                   # 每行被禁止的位置数
```

```text
[[  0. -inf -inf -inf]
 [  0.   0. -inf -inf]
 [  0.   0.   0. -inf]
 [  0.   0.   0.   0.]]
[[False  True  True  True]
 [False False  True  True]
 [False False False  True]
 [False False False False]]
[3 2 1 0]
```

`np.triu` 的第 3 个参数 `k` 指定保留的对角线偏移：`k=1` 保留主对角线以上的元素、把其余位置写为零，因此全 $-\infty$ 输入得到"上三角 $-\infty$、其余 $0$"。`k=0` 会把主对角线一并置零，得到位置 $t$ 看不到自身的严格掩码。`mask_bool.sum(1)` 给出每行的禁止位置数 $[3,2,1,0]$，等于 $T-1-t$，可用于核对行列方向：若误把 `triu` 写成 `tril`，该向量会变成 $[0,1,2,3]$，掩码方向相反，模型将只能看到未来。布尔版本每元素 1 字节，$T=4096$ 时占 16.8 MB，浮点版本占 67 MB，长上下文中前者更省显存。

### 例 2：信息泄漏的检测与量化

构造一条 $T=4$ 的输入，只在最后一个位置加入偏移，观察位置 0 的输出是否改变。若改变，说明位置 0 读取了未来位置。

```python
import numpy as np

def softmax(x, axis=-1):
    x = x - x.max(axis=axis, keepdims=True)
    e = np.exp(x)
    return e / e.sum(axis=axis, keepdims=True)

def attention(X, Wq, Wk, Wv, mask=None):
    Q, K, V = X @ Wq, X @ Wk, X @ Wv
    S = Q @ K.transpose(0, 2, 1) / np.sqrt(Q.shape[-1])
    if mask is not None:
        S = S + mask
    return softmax(S, -1) @ V

rng = np.random.default_rng(7)
B, T, C, d = 1, 4, 6, 6
X = rng.standard_normal((B, T, C))
Wq, Wk, Wv = (rng.standard_normal((C, d)) for _ in range(3))
causal = np.triu(np.full((T, T), -np.inf), k=1)[None]     # 广播到 (B,T,T)

X2 = X.copy()
X2[0, 3, :] += 5.0                                        # 只改最后一个位置

for name, mask in [("无掩码", None), ("因果掩码", causal)]:
    o1 = attention(X, Wq, Wk, Wv, mask)
    o2 = attention(X2, Wq, Wk, Wv, mask)
    print("%s：位置 0 变化 %.4f，位置 3 变化 %.4f"
          % (name, np.abs(o1[0, 0] - o2[0, 0]).max(),
             np.abs(o1[0, 3] - o2[0, 3]).max()))
```

```text
无掩码：位置 0 变化 2.8155，位置 3 变化 18.0133
因果掩码：位置 0 变化 0.0000，位置 3 变化 18.0133
```

无掩码时修改位置 3 使位置 0 的输出改变 2.8155，泄漏被直接观测到；加因果掩码后该变化为精确 0。位置 3 在两种实现下的变化相同，因为位置 3 的允许集合在两种情形下都是全体位置，被改动的 token 本来就在它的读取范围内。这一对照说明掩码的作用范围：它只切断"从未来读现在"的边，不改变每个位置对自身与前缀的读取。

该测试可作为一种单元检验：随机初始化一层注意力，扰动位置 $t$ 的输入，检查所有 $t'<t$ 的输出是否保持不变（差值应为 0）。若差值非零，掩码方向、掩码应用位置或维度顺序至少有一处错误。

### 例 3：四种掩码实现的数值对照

```python
import numpy as np

def softmax(x, axis=-1):
    x = x - x.max(axis=axis, keepdims=True)
    e = np.exp(x)
    return e / e.sum(axis=axis, keepdims=True)

rng = np.random.default_rng(11)
T = 6
S = rng.standard_normal((T, T))                            # 未掩码打分
causal = np.triu(np.full((T, T), -np.inf), k=1)

A_ref = softmax(S + causal, -1)                            # 前置 -inf
A_nine = softmax(S + np.where(np.isinf(causal), -1e9, 0.), -1)   # 前置 -1e9
A_post = softmax(S, -1) * (causal == 0)                    # 后置置零
A_post = A_post / A_post.sum(-1, keepdims=True)            # 后置置零并重归一化
A_bad = softmax(S, -1) * (causal == 0)                     # 后置置零，不重归一化

print("前置 -inf 行和", A_ref.sum(-1))
print("前置 -1e9 与 -inf 的最大差", np.abs(A_nine - A_ref).max())
print("后置重归一化与前置的最大差", np.abs(A_post - A_ref).max())
print("后置不重归一化的行和", np.round(A_bad.sum(-1), 4))
```

```text
前置 -inf 行和 [1. 1. 1. 1. 1. 1.]
前置 -1e9 与 -inf 的最大差 0.0
后置重归一化与前置的最大差 1.1102230246251565e-16
后置不重归一化的行和 [0.1008 0.2541 0.4297 0.6357 0.6271 1.    ]
```

前三行印证第 3 节：$-10^{9}$ 与 $-\infty$ 在 fp32 下给出逐元素相同的结果，因为 $\exp(-10^{9})$ 下溢为 0；后置重归一化与前置的差为 $1.11\times10^{-16}$，属于 float64 舍入。最后一行给出错误实现的偏差：第 0 行只剩 $10.1\%$ 的质量，第 4 行剩 $62.7\%$，第 5 行未受影响。缩小比例随位置单调变化（除随机波动），与"允许位置越少、丢弃质量越多"一致。这类偏差会被后续层逐层放大，且无法通过偏置或缩放吸收，因为每一行的缩放系数不同。

### 例 4：头维顺序错误的表现

用 $h=2$、$d_h=4$、$C=8$ 的输入演示两种拆分。三个 token 的通道值都取 $1,\dots,8$，正确拆分下头 0 应始终拿到通道 $1$–$4$。

```python
import numpy as np

C, h = 8, 2
d_h = C // h
x = np.arange(1., C + 1.)[None, None, :].repeat(3, axis=1)   # (1,3,8)，三个 token 相同

right = x.reshape(1, 3, h, d_h).transpose(0, 2, 1, 3)         # 正确：(1,h,3,d_h)
wrong = x.reshape(1, h, 3, d_h)                               # 错误：把 T 折进 h
print("正确 头0\n", right[0, 0])
print("正确 头1\n", right[0, 1])
print("错误 头0\n", wrong[0, 0])
```

```text
正确 头0
 [[1. 2. 3. 4.]
 [1. 2. 3. 4.]
 [1. 2. 3. 4.]]
正确 头1
 [[5. 6. 7. 8.]
 [5. 6. 7. 8.]
 [5. 6. 7. 8.]]
错误 头0
 [[1. 2. 3. 4.]
 [5. 6. 7. 8.]
 [1. 2. 3. 4.]]
```

正确拆分下，头 0 的三个 token 都取通道 $1$–$4$，头 1 都取 $5$–$8$，头内的 token 维保持独立。错误写法 `reshape(1,h,3,d_h)` 把 $T\times C$ 的元素按行优先顺序连续切分，于是头 0 的第 0 行拿到 token 0 的通道 $1$–$4$，第 1 行拿到 token 1 的通道 $5$–$8$，第 2 行拿到 token 2 的通道 $1$–$4$：头内混合了不同 token 的不同通道，位置与通道的对应关系被破坏。这种错误不会引发任何形状异常，注意力仍然能算出一个 $T\times T$ 矩阵，只是每一行的含义与设计不符；在因果模型中，它还会让位置 $t$ 的查询携带其他位置的通道，破坏因果性。

### 例 5：从零实现 CausalSelfAttention

以下代码需 PyTorch 2.0 及以上，结构与 nanoGPT 的 `CausalSelfAttention` 一致。

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


class CausalSelfAttention(nn.Module):
    def __init__(self, d_model=384, n_head=6, block_size=256, dropout=0.1):
        super().__init__()
        assert d_model % n_head == 0, "d_model 必须被头数整除"
        self.d_model = d_model
        self.n_head = n_head
        self.d_head = d_model // n_head
        self.block_size = block_size
        self.c_attn = nn.Linear(d_model, 3 * d_model, bias=False)   # Q,K,V 合并投影
        self.c_proj = nn.Linear(d_model, d_model, bias=False)       # 输出投影
        self.attn_dropout = nn.Dropout(dropout)                     # 作用于权重
        self.resid_dropout = nn.Dropout(dropout)                    # 作用于子层输出
        mask = torch.tril(torch.ones(block_size, block_size, dtype=torch.bool))
        self.register_buffer("mask", mask.view(1, 1, block_size, block_size),
                             persistent=False)

    def forward(self, x):
        B, T, C = x.shape
        assert T <= self.block_size, "序列长度超过 block_size"
        qkv = self.c_attn(x)                        # (B,T,3C)
        q, k, v = qkv.split(C, dim=2)               # 三个 (B,T,C)
        q = q.view(B, T, self.n_head, self.d_head).transpose(1, 2)
        k = k.view(B, T, self.n_head, self.d_head).transpose(1, 2)
        v = v.view(B, T, self.n_head, self.d_head).transpose(1, 2)
        att = (q @ k.transpose(-2, -1)) / math.sqrt(self.d_head)     # (B,h,T,T)
        att = att.masked_fill(~self.mask[:, :, :T, :T], float("-inf"))
        att = F.softmax(att, dim=-1)                # 沿键维归一化
        att = self.attn_dropout(att)
        y = att @ v                                 # (B,h,T,d_head)
        y = y.transpose(1, 2).contiguous().view(B, T, C)
        return self.resid_dropout(self.c_proj(y))


torch.manual_seed(0)
m = CausalSelfAttention(d_model=384, n_head=6, block_size=256)
x = torch.randn(2, 16, 384)
y = m(x)
print(y.shape)                                   # torch.Size([2, 16, 384])
print(sum(p.numel() for p in m.parameters()))    # 589824
print(m.mask.shape, m.mask.dtype)                # torch.Size([1, 1, 256, 256]) torch.bool
print("mask" in m.state_dict())                  # False
```

预期输出为形状 $(2,16,384)$、参数量 $589824$、掩码形状 $(1,1,256,256)$ 与类型 `torch.bool`、以及掩码不在 `state_dict` 中的 `False`。

逐段说明。`c_attn` 用一次 $(C,3C)$ 的矩阵乘同时算出 $\mathbf{Q},\mathbf{K},\mathbf{V}$，相比三个独立的 $(C,C)$ 投影，矩阵乘的调用次数从 3 降为 1，在 GPU 上少两次内核启动与两次读入 $\mathbf{X}$；参数量相同，都是 $3C^2$。`split(C, dim=2)` 沿通道维三等分，得到的三块依次对应 $\mathbf{Q},\mathbf{K},\mathbf{V}$，顺序必须与 `c_attn` 权重初始化时的排列一致，交换任意两块会使查询去匹配值、键去承载内容。

`view(B,T,h,d_head).transpose(1,2)` 是拆头，规则见第 5 节。`q @ k.transpose(-2,-1)` 在最后两维上转置，得到 $(B,h,T,T)$；若用 `.T`，四维张量全部维都会反转。`/ math.sqrt(self.d_head)` 用 $d_h=64$ 而非 $C=384$，两者相差 $\sqrt{6}\approx2.45$ 倍。

`~self.mask[:, :, :T, :T]` 把"True 表示允许"取反为"True 表示禁止"，与 `masked_fill` 的语义对齐。若省略取反，`masked_fill` 会把下三角（允许位置）全部置为 $-\infty$、上三角保持原值，结果是每个位置只能看到未来，训练损失几乎不下降，而代码不会报错。若把切片写成 `self.mask[:, :, :T]`，得到的是 $(1,1,T,L_{\text{block}})$，与打分的 $(B,h,T,T)$ 无法广播（仅当 $T=L_{\text{block}}$ 时形状恰好相同），会抛出形状错误；这类错误容易被发现，更难发现的是第 4 条易错点所列的拆分顺序错误。

`F.softmax(att, dim=-1)` 沿键维归一化。`attn_dropout` 放在 softmax 之后、`@ v` 之前。`y.transpose(1,2).contiguous().view(B,T,C)` 三步缺一不可：缺 `transpose` 则头维与 token 维错配；缺 `contiguous` 则 `view` 抛出步长错误；`view` 的第三个参数必须是 $C$ 而不是 $h$ 或 $d_h$。最后 `c_proj` 把拼接结果映射回模型维度，`resid_dropout` 在返回前施加，残差相加由调用方完成。

参数量核对：$\mathbf{W}_{\text{attn}}\in\mathbb{R}^{384\times1152}$ 有 $442\,368$ 个，$\mathbf{W}_{\text{proj}}\in\mathbb{R}^{384\times384}$ 有 $147\,456$ 个，合计 $589\,824=4\times384^{2}$。掩码缓冲区不计入参数量，也不在 `state_dict` 中，因为 `persistent=False`；若去掉该参数，检查点会多出 $(1,1,256,256)$ 的布尔张量，加载到没有该缓冲区的模型时会报缺失键。

### 例 6：nn.MultiheadAttention 的掩码接口

```python
import torch
import torch.nn as nn

mha = nn.MultiheadAttention(embed_dim=384, num_heads=6, dropout=0.1, batch_first=True)
mha.eval()                                       # 关闭 dropout，两次调用才可比
x = torch.randn(2, 16, 384)

causal_bool = torch.triu(torch.ones(16, 16, dtype=torch.bool), diagonal=1)
additive = torch.zeros(16, 16).masked_fill(causal_bool, float("-inf"))

out_f, _ = mha(x, x, x, attn_mask=additive, need_weights=False)
out_c, _ = mha(x, x, x, is_causal=True, need_weights=False)
out_w, w = mha(x, x, x, attn_mask=additive, need_weights=True,
               average_attn_weights=False)
print(out_f.shape, w.shape)                      # torch.Size([2, 16, 384]) torch.Size([2, 6, 16, 16])
print(torch.allclose(out_f, out_c, atol=1e-6))   # True
```

接口差异有四点。第一，`batch_first=True` 使输入为 $(B,T,E)$；默认 `False` 时输入为 $(T,B,E)$，与本文其余部分的约定相反，混用会导致把批量与序列长度对调。第二，浮点 `attn_mask` 在 softmax 之前加到注意力权重上，语义与本文的加性掩码一致，形状可以是 $(T,T)$ 或 $(B\,h,T,T)$。第三，`is_causal=True` 使用内置的因果路径，等价于传入尺寸正确的三角掩码；它与 `attn_mask` 不能同时使用，同时传入会在部分版本中报错。第四，`need_weights=True` 会关闭融合的高效路径；`average_attn_weights=True`（默认）对头求平均，只返回 $(B,T,T)$，要看单头权重必须显式设为 `False`。

`attn_mask` 同时接受布尔与浮点两种张量。布尔版本的取值语义与 `key_padding_mask` 相反（后者以 `True` 表示忽略该位置），且历史上经过调整；混用时最稳妥的检验是构造一个只有单个允许位置的 $2\times2$ 掩码，检查另一列的权重是否恰为 0。这类检验比查阅文档更快，也不受版本差异影响。

## 易错点

> [!warning] 以下六条均可在形状、行和或单测中直接检验。
> 1. 掩码形状与广播错误：$(T,T)$ 的掩码要与 $(B,h,T,T)$ 的打分相加，必须先扩为 $(1,1,T,T)$；若写成 $(B,T,T)$，广播会把它视为 $(1,B,T,T)$，只有当 $T=h$ 时才静默通过，此时掩码的第二维被当作头维解释，含义已经错位，其余情形直接报错。检验方法：打印 `att` 与 `mask` 的形状，确认掩码的维数不大于打分且可从右侧对齐。
> 2. 掩码取值语义反转：`masked_fill` 把 `True` 位置置为 $-\infty$，而 `torch.tril` 构造的掩码中 `True` 表示允许，两者语义相反，必须取反。写反后模型只能看到未来，损失几乎不降，但形状与运行都不报错。
> 3. 缓存与掩码的交互错误：解码阶段查询长度为 1、键长度为 $t+1$，全部键都在查询之前，不应再施加 $(T,T)$ 的三角掩码；沿用训练时掩码会掩掉合法位置或触发形状不匹配。正确做法是把预填充与解码分成两条路径，解码路径不加因果掩码。
> 4. 头维顺序错误：拆分必须写成 `view(B,T,h,d_h).transpose(1,2)`；写成 `view(B,h,T,d_h)` 会把 token 维折进头维，位置与通道错配，且不产生任何形状错误。检验方法：用三个 token 取相同通道值的输入，检查每个头的输出是否只含固定的通道区间（例 4）。
> 5. 缩放维度或次数错误：应为 $1/\sqrt{d_h}$，$d_h=C/h$；用 $\sqrt{C}$ 会过度缩小，对查询与打分同时缩放则等效因子为 $1/d_h$。检验方法：初始化时打印打分的标准差，应在 1 附近。
> 6. 训练与推理路径不一致：训练时施加 dropout 与因果掩码，推理时若忘记 `model.eval()`，dropout 仍生效，权重行和随机且输出不可复现；若解码路径误加掩码，可能整行为 $-\infty$，softmax 分母为 0，产生 NaN 并沿残差传播污染全部参数。

## 关联笔记

- 前置 [[注意力机制与QKV]]：该篇给出缩放点积注意力、$\sqrt{d_k}$ 的方差推导与多头定义；本篇在其上加入因果约束，并展开多头的维度布局与实现细节。
- 后续 [[KV缓存]]：本篇第 4 节指出推理逐 token 的结构与缓存必要性，该篇给出显存公式、预填充与解码的代价分解及实现。
- 后续 [[Transformer架构详解]]：本层的输出经残差相加与 LayerNorm 后进入前馈网络，该篇给出整层的组装顺序与参数量核算。
- 对照 [[BERT与双向编码模型]]：双向注意力不施加因果掩码，训练目标为掩码语言建模，与本篇的自回归目标形成对照；两者的注意力计算形式相同，差别在允许集合与损失。
- 后续 [[Llama-2架构复盘]]：该篇的注意力层由 RMSNorm、RoPE、因果掩码与 GQA 组合，本篇的 `CausalSelfAttention` 是去掉 RoPE 与 GQA 后的基础形式。

## 达标检测

- [ ] 用归纳法证明"嵌入 + 因果注意力 + 残差 + LayerNorm + 前馈"组成的栈是因果的，并指出哪一步会因去掉掩码而失效。
- [ ] 写出 $T=5$ 的因果掩码矩阵，说明 `np.triu(..., k=1)` 与 `k=0` 的区别，并给出每行允许位置数。
- [ ] 证明后置置零并重归一化与前置 $-\infty$ 逐元素相等，并说明不重归一化时行和为何随位置变化。
- [ ] 运行例 2，报告无掩码与有掩码时位置 0 的输出变化，并解释位置 3 的变化为何相同。
- [ ] 写出 `CausalSelfAttention` 的完整代码，打印 $(B,h,T,d_h)$、参数量与掩码形状，并说明去掉 `~`、`contiguous()`、`transpose(1,2)` 三者各自的后果。
- [ ] 说明 `nn.MultiheadAttention` 的 `attn_mask`、`key_padding_mask`、`is_causal` 三者的语义差异，并给出一个检验布尔掩码方向的单测。
- [ ] 用两个头的具体例子说明多头输出不在单个凸包内，并指出这一结论依赖 $\mathbf{W}_O$ 的哪条性质。

## 参考来源

- Vaswani et al., "Attention Is All You Need", arXiv:1706.03762, 第 3.2.3 节 —— 对应本篇第 2 节的因果掩码定义与第 1 节信息泄漏的动机；第 3.2.2 节对应第 5 节与第 7 节的多头拆分与拼接；第 5.4 节对应第 6 节的残差 dropout。
- Karpathy, nanoGPT 仓库与 "Let's build GPT" 讲义 —— 对应例 5 的 `CausalSelfAttention` 结构：合并 QKV 投影、`register_buffer` 的三角掩码、`masked_fill` 取反、注意力权重 dropout 与输出投影的顺序。
- d2l.ai《动手学深度学习》「注意力机制与 Transformer」一章 —— 对应第 3 节的 masked softmax 与第 4 节的训练并行、推理串行对比。
- Raschka, *Build a Large Language Model (From Scratch)*, 2024, 第 3 章 —— 对应第 5 节的形状链推导、第 6 节的缩放与 dropout 位置，以及例 5 的参数量核对。
- PyTorch 官方文档 `torch.nn.MultiheadAttention` —— 对应例 6 的 `batch_first`、`attn_mask`、`key_padding_mask`、`is_causal` 参数语义与 `average_attn_weights` 的返回形状。
