---
tags: [AI, LLM, 注意力]
阶段: 05-Transformer与LLM原理
难度: ★★★
created: 2026-10-18
related: "[[从RNN到注意力机制]], [[因果注意力与多头注意力]], [[Transformer架构详解]]"
---

# 注意力机制与QKV

## 定义

**注意力机制**（attention mechanism）是以查询向量与键向量的相似度为权重、对值向量集合做加权求和，从而为每个查询产生一个输出的运算。**缩放点积注意力**（scaled dot-product attention）是其中取相似度为查询与键的内积除以 $\sqrt{d_k}$、并用 softmax 沿键维度归一化权重的一种具体形式。

本篇符号约定如下。

| 符号 | 含义 |
|---|---|
| $T$ | 序列长度，即查询、键、值的个数 |
| $d$ | 模型维度 $d_{\text{model}}$，输入表示的通道数 |
| $h$ | 注意力头数 |
| $d_k$ | 单个头的查询与键维度，$d_k=d/h$ |
| $d_v$ | 单个头的值维度，通常取 $d_v=d_k$ |
| $\mathbf{X}\in\mathbb{R}^{T\times d}$ | 输入表示，第 $t$ 行为 $\mathbf{x}_t^{\top}$ |
| $\mathbf{W}_Q,\mathbf{W}_K\in\mathbb{R}^{d\times d_k}$ | 查询投影、键投影 |
| $\mathbf{W}_V\in\mathbb{R}^{d\times d_v}$ | 值投影 |
| $\mathbf{W}_O\in\mathbb{R}^{hd_v\times d}$ | 多头输出投影 |
| $\mathbf{Q},\mathbf{K}\in\mathbb{R}^{T\times d_k}$ | 查询矩阵、键矩阵 |
| $\mathbf{V}\in\mathbb{R}^{T\times d_v}$ | 值矩阵 |
| $\mathbf{S}\in\mathbb{R}^{T\times T}$ | 打分矩阵 |
| $s_{tj}$ | 位置 $t$ 对位置 $j$ 的打分 |
| $\mathbf{M}$ | 加性掩码，元素取 $0$ 或 $-\infty$ |
| $\mathbf{A}\in\mathbb{R}^{T\times T}$ | 注意力权重矩阵 |
| $a_{tj}$ | 位置 $t$ 分配给位置 $j$ 的权重 |
| $\mathbf{O}\in\mathbb{R}^{T\times d_v}$ | 输出 |

术语定义：**查询**（query）是发起检索的向量，记 $\mathbf{q}_t\in\mathbb{R}^{d_k}$；**键**（key）是被检索项的索引向量，记 $\mathbf{k}_j\in\mathbb{R}^{d_k}$；**值**（value）是被检索项的内容向量，记 $\mathbf{v}_j\in\mathbb{R}^{d_v}$；**注意力权重**是打分经 softmax 归一化后得到的非负、行和为 1 的系数；**掩码**是加到打分上、用于禁止某些位置配对的矩阵，元素取 $0$ 表示允许、$-\infty$ 表示禁止；**缩放因子** $1/\sqrt{d_k}$ 乘在打分上；**头**（head）是一组独立的 $\mathbf{W}_Q,\mathbf{W}_K,\mathbf{W}_V$ 及其产生的注意力。

## 为什么重要

序列到序列模型必须把源序列的信息传给解码器。循环网络把整个源序列压缩为一个固定维度向量 $\mathbf{c}\in\mathbb{R}^{d}$，解码第 $t$ 步只能访问 $\mathbf{c}$，而 $\mathbf{c}$ 的信息容量与 $d$ 同阶、与源序列长度 $T$ 无关，长度增加时单位 token 可用的维度按 $1/T$ 下降；同时梯度从解码末端回传到源序列首端需经过 $T$ 次矩阵乘与非线性，路径长度随 $T$ 线性增长，长距离依赖的梯度按连乘衰减。注意力把读取路径缩短为常数：位置 $t$ 直接对所有位置做加权求和，任意两个位置之间只隔一次加权聚合。

注意力同时消除了循环结构的串行依赖。给定 $\mathbf{X}$，三次投影与两次矩阵乘法都是批量运算，$T$ 个位置在一次前向中并行完成；循环网络必须执行 $T$ 次串行步骤，每步都是小矩阵乘法，GPU 的并行度受限于单步规模。这一差别使 Transformer 能在长序列上训练，也是 [[Transformer架构详解]] 中整个层可以堆叠到数十层的前提。

若没有注意力而只保留固定向量传递，还会带来参数效率问题：解码器每一步读取同一组参数与同一个向量，无法按内容选择信息来源；注意力用同一组投影参数在不同输入上产生不同权重，位置选择由数据决定而非由参数记忆。

在本库中的位置：本篇是 05 阶段的核心推导篇，[[从RNN到注意力机制]] 给出加性注意力的动机与瓶颈分析，[[因果注意力与多头注意力]] 把本篇的单头、无掩码形式改造为可自回归训练的多头形式，[[位置编码-正弦与RoPE]] 修补本篇结构对位置不敏感的缺陷，[[Transformer架构详解]] 把注意力、前馈网络与残差连接组装成层。对应学习目标三项：懂原理要求完成 $\sqrt{d_k}$ 的方差推导与复杂度分析；能复现要求写出 NumPy 与 PyTorch 两份实现并核对每个中间张量的形状；会评估要求能根据 $T$ 与 $d$ 判断计算瓶颈落在 $2T^2d$ 项还是 $4Td^2$ 项。

## 原理与推导

### 1 检索视角：查询、键、值的语义分工

把注意力理解为一次软检索，需要固定三个对象：键值表是 $T$ 个二元组 $(\mathbf{k}_j,\mathbf{v}_j)$，查询是单个向量 $\mathbf{q}$，检索结果是 $\mathbf{o}$。硬检索要求 $\mathbf{q}$ 与某个键相等，输出对应的值，权重为指示函数 $a_j=\mathbb{1}[\mathbf{q}=\mathbf{k}_j]$。硬检索有两个不可用之处：连续向量之间几乎不存在精确相等；相等判断的梯度恒为零，键与值无法通过梯度下降学习。

软检索用相似度 $s(\mathbf{q},\mathbf{k}_j)$ 替换相等判断，权重取 softmax：

$$
a_j=\frac{\exp\!\big(s(\mathbf{q},\mathbf{k}_j)\big)}{\sum_{l=1}^{T}\exp\!\big(s(\mathbf{q},\mathbf{k}_l)\big)},\qquad
\mathbf{o}=\sum_{j=1}^{T}a_j\,\mathbf{v}_j .
$$

该定义给出三条性质。第一，$a_j\ge 0$ 且 $\sum_{j=1}^{T}a_j=1$，因此 $\mathbf{o}$ 落在 $\{\mathbf{v}_j\}_{j=1}^{T}$ 的凸包内，输出不会超出值向量的取值范围。第二，softmax 对加性常数不变，$s$ 与 $s+c$ 给出相同权重，起作用的只有相似度的相对差异。第三，$s$ 可微时 $\partial a_j/\partial s$ 存在，键、值与打分函数都可训练。

取 $s(\mathbf{q},\mathbf{k})=\mathbf{q}^{\top}\mathbf{k}$ 有三条理由。其一，它是两个向量之间最简单的非平凡双线性函数，不含额外参数；若允许参数，$\mathbf{q}^{\top}\mathbf{W}\mathbf{k}=(\mathbf{W}^{\top}\mathbf{q})^{\top}\mathbf{k}$ 可被对 $\mathbf{q}$ 的线性投影吸收，因此"点积加线性投影"已经覆盖带参数的双线性打分。其二，当 $\|\mathbf{k}\|$ 固定时 $\mathbf{q}^{\top}\mathbf{k}=\|\mathbf{q}\|\|\mathbf{k}\|\cos\theta$ 与夹角余弦单调，相似度的序关系与方向一致；不做归一化时内积同时编码方向与模长，模长较大的键获得更大权重，这一行为由 $\mathbf{W}_K$ 的尺度在训练中调节。其三，全部 $T^2$ 个打分可在一次矩阵乘法 $\mathbf{Q}\mathbf{K}^{\top}$ 中算出，复杂度 $T^2d_k$，硬件利用率高；加性注意力含 $\tanh$ 与逐对相加，无法化为单次批量矩阵乘。

内积不满足度量的公理：$\mathbf{q}^{\top}\mathbf{k}$ 可为负，不满足非负性与三角不等式，$\mathbf{q}^{\top}\mathbf{q}$ 随 $\|\mathbf{q}\|$ 增大而无界。注意力只需要一个与相关性单调的排序量，不需要距离公理。若确实需要距离，可改用 $-\|\mathbf{q}-\mathbf{k}\|^{2}$，它展开为 $-\|\mathbf{q}\|^{2}-\|\mathbf{k}\|^{2}+2\mathbf{q}^{\top}\mathbf{k}$，在 $\|\mathbf{q}\|$ 固定时与内积给出相同排序。

三个角色的语义分工如下。$\mathbf{q}_t$ 由位置 $t$ 的表示经 $\mathbf{W}_Q$ 投影得到，表示该位置为构造自身输出而需要检索的内容；$\mathbf{k}_j$ 由位置 $j$ 的表示经 $\mathbf{W}_K$ 投影得到，是该位置可被检索的索引；$\mathbf{v}_j$ 由位置 $j$ 的表示经 $\mathbf{W}_V$ 投影得到，是该位置实际被读取的内容。三组参数独立，因此同一个 $\mathbf{x}_j$ 可以同时充当键（被其他位置检索）与查询（检索其他位置），两种角色的数值不同。

### 2 三次线性投影：维度与参数量

把单查询形式推广到 $T$ 个查询，得到矩阵形式。输入 $\mathbf{X}\in\mathbb{R}^{T\times d}$ 的第 $t$ 行为 $\mathbf{x}_t^{\top}$，三个投影定义为

$$
\mathbf{Q}=\mathbf{X}\mathbf{W}_Q,\qquad
\mathbf{K}=\mathbf{X}\mathbf{W}_K,\qquad
\mathbf{V}=\mathbf{X}\mathbf{W}_V .
$$

形状链为 $(T\times d)(d\times d_k)\to(T\times d_k)$、$(T\times d)(d\times d_k)\to(T\times d_k)$、$(T\times d)(d\times d_v)\to(T\times d_v)$。逐行写出即 $\mathbf{q}_t^{\top}=\mathbf{x}_t^{\top}\mathbf{W}_Q$，等价于 $\mathbf{q}_t=\mathbf{W}_Q^{\top}\mathbf{x}_t$。批量情形把 $T$ 换成 $(B,T)$，得到 $(B,T,d)(d,d_k)\to(B,T,d_k)$。

参数量：$\mathbf{W}_Q$ 与 $\mathbf{W}_K$ 各 $d\,d_k$ 个，$\mathbf{W}_V$ 有 $d\,d_v$ 个。取 $d_k=d_v=d$ 时三者合计 $3d^{2}$；每个投影加偏置再各加 $d_k$ 或 $d_v$，合计 $3d$。多头情形把 $h$ 个头的投影按输出通道拼接为 $\mathbb{R}^{d\times d}$ 的单一矩阵，参数总量不变，仍为 $3d^{2}$，加输出投影 $\mathbf{W}_O$ 后为 $4d^{2}$，推导见第 8 节。

三组投影必须相互独立。若取 $\mathbf{W}_Q=\mathbf{W}_K=\mathbf{W}$，则打分 $s_{tj}=\mathbf{x}_t^{\top}\mathbf{W}\mathbf{W}^{\top}\mathbf{x}_j$ 关于 $(t,j)$ 对称，$s_{tj}=s_{jt}$，注意力矩阵对称，因果注意力要求 $s_{tj}$ 与 $s_{jt}$ 可以不同，对称打分把"$t$ 对 $j$ 的关注"与"$j$ 对 $t$ 的关注"强制绑定。若取 $\mathbf{W}_V=\mathbf{W}_K$，值空间与键空间共享方向，$\mathbf{v}_j$ 与 $\mathbf{k}_j$ 成比例，值的模长直接进入打分，键与值的角色无法分别调节。

参数量占比可作为规模判断依据。GPT-2 small 配置 $d=768$、$h=12$、$L=12$：每层注意力参数 $4d^{2}=2\,359\,296$，12 层共 $2.83\times10^{7}$，占 1.24 亿总参数的 22.8%；同层前馈网络 $8d^{2}=4\,718\,592$，是注意力的两倍。注意力不是参数主体，而是计算量与显存随 $T$ 增长的部分，见第 6 节。

### 3 缩放点积注意力的完整形式

对 $\mathbf{Q},\mathbf{K},\mathbf{V}$ 定义

$$
\mathbf{S}=\frac{\mathbf{Q}\mathbf{K}^{\top}}{\sqrt{d_k}}\in\mathbb{R}^{T\times T},\qquad
\mathbf{A}=\mathrm{softmax}_{\text{row}}(\mathbf{S}+\mathbf{M})\in\mathbb{R}^{T\times T},\qquad
\mathbf{O}=\mathbf{A}\mathbf{V}\in\mathbb{R}^{T\times d_v},
$$

其中 $\mathrm{softmax}_{\text{row}}$ 表示对每一行独立归一化，$\mathbf{M}$ 为掩码矩阵。展开为标量形式

$$
s_{tj}=\frac{\mathbf{q}_t^{\top}\mathbf{k}_j}{\sqrt{d_k}},\qquad
a_{tj}=\frac{\exp(s_{tj}+M_{tj})}{\sum_{l=1}^{T}\exp(s_{tl}+M_{tl})},\qquad
\mathbf{o}_t=\sum_{j=1}^{T}a_{tj}\mathbf{v}_j .
$$

逐项解释如下。

- $\mathbf{Q}\mathbf{K}^{\top}$ 的第 $(t,j)$ 元素为 $\mathbf{q}_t^{\top}\mathbf{k}_j$，是位置 $t$ 的查询与位置 $j$ 的键的内积；对角线元素为自匹配 $t=j$。矩阵乘法把 $T^2$ 个内积一次算出，每个内积需 $d_k$ 次乘加，总乘加量为 $T^2d_k$。
- $\sqrt{d_k}$ 是 $d_k$ 维内积在单位方差假设下的标准差，除以它使打分的方差为 1，推导见第 4 节。
- $\mathbf{M}$ 为加性掩码，允许的配对为 $0$，禁止的配对为 $-\infty$；加 $0$ 不改变打分，加 $-\infty$ 使该项指数为 0。
- $\mathrm{softmax}$ 沿键维（最后一维）归一化，$\mathbf{A}$ 的每一行为长度 $T$ 的概率向量，全部元素非负、每行和为 1。
- $\mathbf{A}\mathbf{V}$ 的形状链为 $(T\times T)(T\times d_v)\to(T\times d_v)$，第 $t$ 行为 $\sum_{j=1}^{T}a_{tj}\mathbf{v}_j$，即值的加权平均。

缩放因子的位置有两种等价写法。其一是 $\mathbf{Q}\mathbf{K}^{\top}/\sqrt{d_k}$，其二是先把 $\mathbf{Q}$ 缩放为 $\mathbf{Q}/\sqrt{d_k}$ 再做内积，前向结果逐元素相同。两者的差别只在反向：第一种写法使 $\partial\mathcal{L}/\partial\mathbf{Q}$ 与 $\partial\mathcal{L}/\partial\mathbf{K}$ 同乘 $1/\sqrt{d_k}$，第二种写法只对 $\mathbf{Q}$ 的参数施加该常数，$\mathbf{K}$ 一侧的梯度尺度不同。两种写法都正确，但在同一模型中不可同时使用，否则等效缩放因子为 $1/d_k$，方差变为 $1/d_k$，权重分布过于平坦。

### 4 除以 $\sqrt{d_k}$：方差推导与 softmax 饱和

考虑单个打分 $s=\mathbf{q}^{\top}\mathbf{k}=\sum_{i=1}^{d_k}q_i k_i$。假设 $q_i$ 与 $k_i$ 相互独立、均值为 0、方差为 1，即

$$
\mathbb{E}[q_i]=\mathbb{E}[k_i]=0,\qquad \mathrm{Var}(q_i)=\mathrm{Var}(k_i)=1,\qquad q_i\perp k_i .
$$

第一步，求均值。由独立性 $\mathbb{E}[q_ik_i]=\mathbb{E}[q_i]\mathbb{E}[k_i]=0$，故

$$
\mathbb{E}[s]=\sum_{i=1}^{d_k}\mathbb{E}[q_ik_i]=0 .
$$

第二步，求二阶矩。按定义

$$
\mathrm{Var}(s)=\mathbb{E}[s^{2}]-\big(\mathbb{E}[s]\big)^{2}
=\mathbb{E}\Big[\Big(\sum_{i=1}^{d_k}q_ik_i\Big)\Big(\sum_{j=1}^{d_k}q_jk_j\Big)\Big]
=\sum_{i=1}^{d_k}\sum_{j=1}^{d_k}\mathbb{E}[q_ik_iq_jk_j].
$$

把双重和拆为 $i=j$ 与 $i\ne j$ 两部分。当 $i\ne j$ 时，四个随机变量 $q_i,k_i,q_j,k_j$ 相互独立，故

$$
\mathbb{E}[q_ik_iq_jk_j]=\mathbb{E}[q_i]\mathbb{E}[k_i]\mathbb{E}[q_j]\mathbb{E}[k_j]=0 .
$$

当 $i=j$ 时，$q_i$ 与 $k_i$ 独立，故

$$
\mathbb{E}[q_i^{2}k_i^{2}]=\mathbb{E}[q_i^{2}]\,\mathbb{E}[k_i^{2}]
=\big(\mathrm{Var}(q_i)+(\mathbb{E}q_i)^2\big)\big(\mathrm{Var}(k_i)+(\mathbb{E}k_i)^2\big)=1\cdot1=1 .
$$

因此

$$
\mathrm{Var}(s)=\sum_{i=1}^{d_k}1=d_k,\qquad
\mathrm{std}(s)=\sqrt{d_k} .
$$

第三步，缩放。令 $\tilde{s}=s/\sqrt{d_k}$，则

$$
\mathrm{Var}(\tilde{s})=\frac{\mathrm{Var}(s)}{d_k}=\frac{d_k}{d_k}=1 .
$$

结论：$d_k$ 维内积的标准差随 $\sqrt{d_k}$ 增长，除以 $\sqrt{d_k}$ 后与 $d_k$ 无关。若不做缩放，$d_k=64$ 时打分标准差为 8，$d_k=512$ 时为 22.6；模型宽度变化会同时改变 softmax 输入的尺度，学习率与初始化方案无法共用。

第四步，说明尺度为何影响梯度。记 $\mathbf{z}=\mathbf{S}_{t,:}$，$\mathbf{a}=\mathrm{softmax}(\mathbf{z})$，则

$$
\frac{\partial a_i}{\partial z_j}=a_i(\delta_{ij}-a_j),\qquad
\mathbf{J}=\frac{\partial\mathbf{a}}{\partial\mathbf{z}}=\mathrm{diag}(\mathbf{a})-\mathbf{a}\mathbf{a}^{\top} .
$$

当 $\mathbf{a}$ 趋近 one-hot 时 $\mathbf{J}\to\mathbf{0}$：设 $a_m\to1$，则 $\partial a_m/\partial z_j=a_m(\delta_{mj}-a_j)\to0$；其余分量 $a_i\to0$ 使第 $i$ 行整体趋于零。损失对打分的梯度为 $\partial\mathcal{L}/\partial\mathbf{z}=\mathbf{J}^{\top}\,\partial\mathcal{L}/\partial\mathbf{a}$，$\mathbf{J}\to\mathbf{0}$ 意味着 $\mathbf{z}$ 几乎收不到梯度，而 $\mathbf{Q},\mathbf{K}$ 的梯度全部经由 $\mathbf{z}$ 回传，因此键与查询的参数更新停滞。

量化饱和程度。设 $T$ 个打分近似独立、标准差为 $\sigma$。最大值的典型规模为 $\sigma\sqrt{2\ln T}$，其余项在 $\sigma$ 量级，因此除最大项与次大项之外，每一项与最大值之差约为 $\sigma\sqrt{2\ln T}$，其指数权重约为 $\exp(-\sigma\sqrt{2\ln T})$。取 $d_k=64$、$T=1000$，未缩放时 $\sigma=8$，$\sigma\sqrt{2\ln 1000}=8\times3.717\approx29.7$，该量约为 $1.1\times10^{-13}$，在 fp32 下与 0 不可区分。最大权重主要由最大项与次大项的竞争决定：两者差距的典型规模为 $\sigma/\sqrt{2\ln T}\approx2.15$，若差距恰为该值，最大权重为 $1/(1+e^{-2.15})\approx0.90$；差距是随机变量，实测均值为 $0.70$，低于该值。softmax 实现中减去行最大值可避免 $\exp$ 溢出，但非最大项会下溢为精确 0，对应梯度也为精确 0。

数值验证取 $T=1000$、500 组标准正态打分，比较未缩放与缩放后的最大权重均值、以及分数梯度 $\mathbf{J}\mathbf{c}$ 的范数（$\mathbf{c}$ 为标准正态随机方向）：

| $d_k$ | 未缩放最大权重 | 缩放后最大权重 | 未缩放 $\lVert\mathbf{J}\mathbf{c}\rVert$ | 缩放后 $\lVert\mathbf{J}\mathbf{c}\rVert$ |
|---|---|---|---|---|
| 1 | 0.0169 | 0.0169 | 0.0512 | 0.0512 |
| 4 | 0.1104 | 0.0168 | 0.1335 | 0.0513 |
| 16 | 0.4406 | 0.0170 | 0.2566 | 0.0515 |
| 64 | 0.7004 | 0.0163 | 0.2180 | 0.0514 |
| 256 | 0.8476 | 0.0159 | 0.1320 | 0.0510 |

读法：缩放后最大权重稳定在 $0.016$–$0.017$，约为均匀分布 $1/T=0.001$ 的 17 倍，与 $d_k$ 无关；未缩放时最大权重随 $d_k$ 单调升至 $0.848$。梯度一列呈非单调，原因是 $d_k$ 过小时打分接近均匀、对分数不敏感，$d_k$ 过大时饱和、梯度衰减，两种情形都削弱可学习性；缩放后该量恒定在 $0.051$，这正是缩放的作用：把有效梯度尺度固定在与 $d_k$ 无关的水平。

关于假设的适用范围：推导假设初始化时 $\mathbf{q},\mathbf{k}$ 各分量独立、零均值、单位方差。训练后 $\|\mathbf{q}\|$ 与 $\|\mathbf{k}\|$ 随数据与损失改变，方差不再恰好为 1，缩放也就不再保证单位方差。缩放消除的是方差对 $d_k$ 的依赖，使不同 $d_k$ 的模型可以共用同一学习率与初始化尺度，这是它在工程上的实际作用。输出的尺度不需要额外缩放，因为 $\mathbf{A}$ 的每行和为 1，$\mathbf{o}_t$ 是值的凸组合，其范数被 $\max_j\|\mathbf{v}_j\|$ 控制。

### 5 注意力矩阵、因果性与两种掩码实现

$\mathbf{A}\in\mathbb{R}^{T\times T}$ 称为注意力矩阵，元素非负且每行和为 1，因此每一行是 $T-1$ 维概率单纯形上的一个点。按允许的配对集合分为两类。

非因果（双向）注意力允许 $j\in[1,T]$ 全部配对，$\mathbf{A}$ 稠密，每个位置的输出融合整条序列的信息，用于编码器与 [[BERT与双向编码模型]] 一类模型。因果注意力只允许 $j\le t$，$\mathbf{A}$ 的严格上三角为零，位置 $t$ 的输出只依赖前缀，用于自回归语言模型，动机与训练方式见 [[因果注意力与多头注意力]]。

因果掩码的两个等价定义：

$$
M_{tj}=\begin{cases}0, & j\le t,\\[2pt] -\infty, & j>t,\end{cases}
\qquad\text{或}\qquad
M_{tj}=\begin{cases}0, & j< t,\\[2pt] -\infty, & j\ge t,\end{cases}
$$

后者称为严格因果，用于避免位置 $t$ 通过自身的值向量复制输入，某些逐位置预测任务采用。语言模型采用前者，位置 $t$ 必须能看到自己以预测下一个 token。

实现一，加性浮点掩码：$\mathbf{S}\leftarrow\mathbf{S}+\mathbf{M}$，禁止位置取 $-\infty$ 或充分小的负数（如 $-10^{9}$）。$-\infty$ 加有限数仍为 $-\infty$，$\exp(-\infty)=0$，且该项不进入分母。用 $-10^{9}$ 时 $\exp(-10^{9})$ 在 fp32 下下溢为 0，结果相同，但 $-10^{9}$ 超出 fp16 的可表示范围（约 $\pm6.5\times10^{4}$），在混合精度下应改用 `torch.finfo(dtype).min` 或直接使用布尔掩码。

实现二，布尔掩码：构造布尔矩阵 $\mathbf{B}$，$\mathbf{B}_{tj}=\text{True}$ 表示禁止，再用 `masked_fill` 或 `np.where` 把对应打分置为 $-\infty$。两种实现在数值上等价，区别在于布尔掩码不构造浮点 $-\infty$，在混合精度下更安全，且不依赖掩码值的大小。

掩码必须在 softmax 的归一化之前生效。softmax 的分母遍历整行，若在 softmax 之后把禁止位置置零而不重新归一化，行和变为 $1-\sum_{j>t}a_{tj}<1$，且各位置的缩小比例不同。以例 1 的确定性矩阵实测，错误实现的行和为 $[0.2212,\,0.2295,\,0.9545,\,1.0000]$，第 0 行只剩自匹配项，输出被整体缩小到 22.1%，第 2 行缩小到 95.5%，第 3 行不受影响；缩小比例随位置变化，并会进入后续所有层。若在置零后除以行和重新归一化，精确算术下与前置掩码等价（同一矩阵上实测最大绝对差 $2.78\times10^{-17}$，为 float64 舍入量级），但多一次除法，且在低精度下先产生精确 0 再相除会放大误差。因此正确的做法是让归一化只在允许集合上进行，前置 $-\infty$ 是最直接的实现。

整行全为 $-\infty$ 时 softmax 的分母为 0，结果为 NaN。因果掩码的对角线恒为 $0$，保证每行至少有一个允许位置，因此单独的因果掩码不会产生 NaN；把因果掩码与 padding 掩码相加时，若某行的全部位置都是 padding，仍会得到全 $-\infty$，需要在实现层排除这些行，或保证每行至少保留一个位置。

### 6 计算复杂度与瓶颈

记单个注意力头的计算量。打分矩阵乘法需 $T^2d_k$ 次乘加，softmax 需对 $T^2$ 个元素做指数与求和、约 $4T^2$ 次浮点运算，加权求和 $\mathbf{A}\mathbf{V}$ 需 $T^2d_v$ 次乘加。$h$ 个头合计

$$
C_{\text{attn}}=h\big(T^2d_k+T^2d_v\big)+O(hT^2)=2T^2d+O(hT^2),
$$

最后一步用到 $hd_k=hd_v=d$。投影部分为 $\mathbf{Q},\mathbf{K},\mathbf{V}$ 三次 $(T\times d)(d\times d)$ 与输出投影一次，共

$$
C_{\text{proj}}=4Td^{2}.
$$

单层总计算量

$$
C(T,d)=4Td^{2}+2T^{2}d .
$$

两项之比为 $C_{\text{attn}}/C_{\text{proj}}=T/(2d)$，在 $T=2d$ 时相等。取 $d=768$：

| $T$ | 投影 $4Td^2$ | 注意力 $2T^2d$ | 合计 | 注意力占比 |
|---|---|---|---|---|
| 512 | $1.21\times10^{9}$ | $4.03\times10^{8}$ | $1.61\times10^{9}$ | 25.0% |
| 1024 | $2.42\times10^{9}$ | $1.61\times10^{9}$ | $4.03\times10^{9}$ | 40.0% |
| 2048 | $4.83\times10^{9}$ | $6.44\times10^{9}$ | $1.13\times10^{10}$ | 57.2% |
| 4096 | $9.66\times10^{9}$ | $2.58\times10^{10}$ | $3.54\times10^{10}$ | 72.7% |
| 8192 | $1.93\times10^{10}$ | $1.03\times10^{11}$ | $1.22\times10^{11}$ | 84.2% |

瓶颈分析给出三条结论。第一，$T$ 翻倍时注意力部分变为 4 倍，$d$ 翻倍时投影部分变为 4 倍而注意力只变为 2 倍，因此长上下文的瓶颈在 $T^2$ 项，宽模型的瓶颈在 $4Td^2$ 项；对 $d=768$ 的模型，$T>1536$ 后注意力成为主项。第二，注意力矩阵本身占显存 $B\,h\,T^2$ 个元素，fp32 下 $B=1$、$h=12$、$T=4096$ 时约 $805$ MB，$T=8192$ 时约 $3.22$ GB，这是长上下文训练显存峰值的主要来源之一；FlashAttention 一类实现的改进在于避免把 $T\times T$ 矩阵完整写入显存并按块重算，而不改变算术量 $2T^2d$。第三，注意力对 $T$ 的依赖是二次的，而循环网络对 $T$ 是线性的，注意力的优势在于并行度而非渐近复杂度，序列越长，二次项越需要专门优化。

### 7 与 Bahdanau 加性注意力的对比

Bahdanau 注意力为每个解码状态 $\mathbf{s}_t$ 与编码状态 $\mathbf{h}_j$ 计算

$$
e_{tj}=\mathbf{v}_a^{\top}\tanh\!\big(\mathbf{W}_a\mathbf{s}_t+\mathbf{U}_a\mathbf{h}_j\big),\qquad
\alpha_{tj}=\frac{\exp(e_{tj})}{\sum_{l}\exp(e_{tl})},
$$

其中 $\mathbf{W}_a\in\mathbb{R}^{d\times d}$、$\mathbf{U}_a\in\mathbb{R}^{d\times d}$、$\mathbf{v}_a\in\mathbb{R}^{d}$。参数量为 $2d^{2}+d$，与点积注意力的 $2d^2$（$d_k=d$ 时）同阶。

| 对比维度 | 加性注意力（Bahdanau） | 缩放点积注意力 |
|---|---|---|
| 打分函数 | $\mathbf{v}_a^{\top}\tanh(\mathbf{W}_a\mathbf{s}+\mathbf{U}_a\mathbf{h})$ | $\mathbf{q}^{\top}\mathbf{k}/\sqrt{d_k}$ |
| 是否含非线性 | 含 $\tanh$，打分对输入非线性 | 无，打分对 $\mathbf{q},\mathbf{k}$ 双线性 |
| 计算形式 | 逐对计算 $d$ 维变换后投影 | 两次批量矩阵乘法 |
| 复杂度 | $O(T_sT_hd)$，常数含 $\tanh$ 与中间张量 | $O(T_sT_hd)$，常数小 |
| 中间显存 | 若不融合，需 $T_s\times T_h\times d$ | $T_s\times T_h$ |
| 并行性 | 逐对计算，难以映射为单次 GEMM | 全部配对一次 GEMM 完成 |
| 数值行为 | $\tanh$ 有界，打分范围受限 | 方差随 $d_k$ 线性增长，需缩放 |
| 表达能力 | 可表示 $\mathbf{q},\mathbf{k}$ 的非线性交互 | 固定投影后为秩不超过 $d_k$ 的双线性型 |

两条需要精确说明的结论。其一，点积注意力的表达能力并不因缺少非线性而更弱到不可用：$\mathbf{q}^{\top}\mathbf{k}=\mathbf{x}_t^{\top}\mathbf{W}_Q\mathbf{W}_K^{\top}\mathbf{x}_j$ 是输入上的双线性型，其秩不超过 $d_k$，多层堆叠与逐位置前馈可补足非线性；加性注意力的 $\tanh$ 提供逐对非线性，在单层内表达更灵活。其二，Vaswani 等指出，$d_k$ 较小时两种机制效果相近，$d_k$ 较大时未缩放的点积注意力劣于加性注意力，原因正是第 4 节的方差增长；缩放后点积注意力在大 $d_k$ 下不再退化，且计算更省，这是当代模型统一采用点积形式的原因。

### 8 多头注意力

单个 softmax 只产生一个权重分布，输出是单一凸组合。单个分布无法同时给两个位置接近 1 的权重，需要同时读取两个位置时只能折中为各 $0.5$，而单头输出的每个分量都来自这同一个加权和。多头注意力用 $h$ 个独立的打分空间分别产生分布，再把结果拼接。

拆分方式为对每个头 $i\in\{1,\dots,h\}$ 取

$$
\mathbf{W}_Q^{i},\mathbf{W}_K^{i}\in\mathbb{R}^{d\times d_k},\quad
\mathbf{W}_V^{i}\in\mathbb{R}^{d\times d_v},\quad d_k=d_v=\frac{d}{h},
$$

$$
\mathrm{head}_i=\mathrm{Attention}\big(\mathbf{X}\mathbf{W}_Q^{i},\,\mathbf{X}\mathbf{W}_K^{i},\,\mathbf{X}\mathbf{W}_V^{i}\big)\in\mathbb{R}^{T\times d_k},
$$

$$
\mathbf{O}=\big[\mathrm{head}_1;\dots;\mathrm{head}_h\big]\mathbf{W}_O,\qquad
\mathbf{W}_O\in\mathbb{R}^{hd_k\times d}.
$$

其中 $[\cdot;\cdot]$ 表示沿最后一维拼接，形状链为 $(T\times hd_k)=(T\times d)$，再乘 $\mathbf{W}_O$ 得 $(T\times d)$。

参数量：$h$ 个头的 $\mathbf{W}_Q^{i}$ 拼成 $\mathbb{R}^{d\times d}$ 的一个矩阵，共 $d^{2}$；$\mathbf{W}_K$、$\mathbf{W}_V$ 同理，各 $d^{2}$；输出投影 $\mathbf{W}_O$ 为 $d\times d$，$d^{2}$。合计

$$
P_{\text{MHA}}=3d^{2}+d^{2}=4d^{2}.
$$

计算量：每头打分 $T^2d_k$、加权 $T^2d_v$，$h$ 头合计 $2T^2d$；投影合计 $4Td^{2}$，与单头全维（$d_k=d_v=d$）完全相同。因此多头在参数与计算上都不比单头贵，改变的是函数形式：它把输出写成 $h$ 个凸组合经不同线性映射后的和。

多头不等价于单头，论证如下。单头的可达输出集合为

$$
\mathcal{O}_1=\Big\{\sum_{j=1}^{T}a_j\mathbf{v}_j\ \Big|\ \mathbf{a}\in\Delta^{T-1}\Big\},
$$

即值向量集合的凸包。多头的输出为

$$
\mathbf{o}=\sum_{i=1}^{h}\mathbf{W}_O^{i}\sum_{j=1}^{T}a^{(i)}_j\mathbf{v}^{(i)}_j
=\sum_{i=1}^{h}\mathbf{W}_O^{i}\mathbf{u}_i,\qquad \mathbf{u}_i\in\mathrm{conv}\{\mathbf{v}^{(i)}_j\},
$$

是 $h$ 个凸包在 $h$ 个不同线性映射下的像之和；即使取 $\mathbf{W}_O^{i}=\mathbf{I}$，和 $\sum_i\mathbf{u}_i$ 的每行权重总和为 $h$ 而非 1，当 $\{\mathbf{v}_j\}$ 不在原点处退化时该和一般落在单个凸包之外。反之，取 $h=1$ 时多头公式退化为单头形式，故多头在同等参数量下是单头的严格推广。

多头还改变了低秩结构。单头输出 $\mathbf{A}\mathbf{V}$ 的秩不超过 $\min(T,d_v)=d$；多头拼接后的秩不超过 $h\cdot d_k=d$，两者上限相同，但多头的每个头独立归一化，权重矩阵 $\mathbf{A}$ 被分解为 $h$ 个块，每块在自己的 $d_k$ 维子空间内单独饱和，因此同样的总维度下可以表达 $h$ 个互不相同的集中分布。这一性质是 [[因果注意力与多头注意力]] 中讨论头专门化的起点，工程上的头数选择与 KV 显存权衡见 [[分组查询注意力GQA]]。

## 关键直觉

> [!tip] 机制性表述
> 注意力是一次可微的软检索：位置 $t$ 用查询 $\mathbf{q}_t$ 与全部键 $\mathbf{k}_j$ 做内积，得到 $T$ 个相对分数，经 softmax 变成和为 1 的权重，再对值做加权平均。输出因此必然落在值向量的凸包内，权重只由分数的相对差异决定。除以 $\sqrt{d_k}$ 把打分的方差固定为 1，使 softmax 既不因 $d_k$ 增大而饱和（梯度趋零），也不因 $d_k$ 减小而近似均匀（无法区分位置）。多头把这个过程并行执行 $h$ 次，得到 $h$ 个不同的权重分布，拼接后经 $\mathbf{W}_O$ 线性混合。

该表述与严格定义的关系：凸包性质来自 softmax 的非负性与行和为 1 的归一化；方差为 1 来自第 4 节的独立同分布假设，只在初始化意义下成立；多头输出的可达集合是凸包线性像之和，比单头更大，但每个头内部仍受同一凸包约束。

## 例子与代码

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

### 例 1：NumPy 缩放点积注意力（含因果掩码）

取 $T=4$、$d_k=2$、$d_v=3$，构造整数矩阵使打分可手算核对。

```python
import numpy as np


def softmax(x, axis=-1):
    x = x - x.max(axis=axis, keepdims=True)      # 减去最大值，防止 exp 溢出
    e = np.exp(x)
    return e / e.sum(axis=axis, keepdims=True)   # 沿指定轴归一化，行和为 1


def scaled_dot_product_attention(Q, K, V, mask=None):
    d_k = Q.shape[-1]
    S = Q @ K.transpose(0, 2, 1) / np.sqrt(d_k)  # (B,T,d_k)(B,d_k,T) -> (B,T,T)
    if mask is not None:
        S = S + mask                             # 加性掩码，禁止位置为 -inf
    A = softmax(S, axis=-1)                      # 沿键维归一化，不是查询维
    return A @ V, A                              # (B,T,T)(B,T,d_v) -> (B,T,d_v)


Q = np.array([[1., 0.], [0., 2.], [1., 1.], [-1., 1.]])
K = np.array([[1., 0.], [0., 1.], [2., 2.], [1., -1.]])
V = np.array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [1., 1., 0.]])

T = Q.shape[0]
causal = np.triu(np.full((T, T), -np.inf), k=1)  # 严格上三角为 -inf
print("mask")
print(causal)

Q1, K1, V1 = Q[None], K[None], V[None]           # 增加批量维，形状 (1,T,d)
O, A = scaled_dot_product_attention(Q1, K1, V1, causal)
print("scores")
print(np.round(Q1 @ K1.transpose(0, 2, 1) / np.sqrt(2), 3))
print("A")
print(np.round(A, 4))
print("row sums", A.sum(-1))
print("O")
print(np.round(O, 4))
print("max masked weight", A[causal[None] == -np.inf].max())
```

```text
mask
[[  0. -inf -inf -inf]
 [  0.   0. -inf -inf]
 [  0.   0.   0. -inf]
 [  0.   0.   0.   0.]]
scores
[[[ 0.707  0.     1.414  0.707]
  [ 0.     1.414  2.828 -1.414]
  [ 0.707  0.707  2.828  0.   ]
  [-0.707  0.707  0.    -1.414]]]
A
[[[1.     0.     0.     0.    ]
  [0.1956 0.8044 0.     0.    ]
  [0.0967 0.0967 0.8066 0.    ]
  [0.131  0.5388 0.2657 0.0646]]]
row sums [[1. 1. 1. 1.]]
O
[[[1.     0.     0.    ]
  [0.1956 0.8044 0.    ]
  [0.0967 0.0967 0.8066]
  [0.1956 0.6034 0.2657]]]
max masked weight 0.0
```

手算核对。第 0 行只允许 $j=0$，权重为 $[1,0,0,0]$，输出等于 $\mathbf{v}_0=[1,0,0]$。第 1 行允许 $j=0,1$，打分为 $[0,\,2/\sqrt{2}=1.414]$，$\exp(0)=1$、$\exp(1.414)=4.113$，归一化得 $[0.1956,\,0.8044]$。第 2 行打分为 $[0.707,0.707,2.828]$，指数为 $[2.028,2.028,16.887]$，和为 $20.943$，权重 $[0.0967,0.0967,0.8066]$，输出 $0.8066\,\mathbf{v}_2+0.1934\,\mathbf{v}_0=[0.0967,0.0967,0.8066]$。第 3 行打分为 $[-0.707,0.707,0,-1.414]$，指数为 $[0.493,2.028,1.000,0.243]$，和为 $3.764$，权重 $[0.1310,0.5388,0.2657,0.0646]$，输出为 $[0.1956,0.6034,0.2657]$，与打印一致。

逐段说明。`K.transpose(0, 2, 1)` 交换最后两维，把 $(1,4,2)$ 变为 $(1,2,4)$，使 $(1,4,2)(1,2,4)\to(1,4,4)$ 得到全部 $(t,j)$ 配对；若写成 `Q @ K`，$(1,4,2)$ 与 $(1,4,2)$ 无法相乘，批量时即使能广播也不是配对关系。`softmax(S, axis=-1)` 沿最后一维（键维）归一化，保证每行和为 1；若取 `axis=-2`，归一化沿查询维进行，每列和为 1，权重语义变为"位置 $j$ 被哪些位置关注"。`causal[None]` 把 $(4,4)$ 广播到 $(1,4,4)$，与打分相加；把掩码加在 softmax 之后会使行和小于 1，对照见下。`A[causal[None] == -np.inf].max()` 取出所有被屏蔽位置的权重，结果为精确 $0.0$，说明 $-\infty$ 经指数后为 0 且未进入分子。去掉 `x - x.max(...)` 一行，当打分较大时 `np.exp` 溢出为 `inf`，归一化得到 `nan`；本例打分最大 2.828，去掉该行仍能运行，因此数值稳定措施在小例子上看不出差别，在 $d_k=64$ 以上的真实模型中必需。

在同一组矩阵上对照掩码的三种位置：

```python
S_full = Q1 @ K1.transpose(0, 2, 1) / np.sqrt(2)     # (1,4,4)，未掩码打分
A_full = softmax(S_full, axis=-1)                    # 先 softmax
A_bad = A_full * (causal[None] == 0)                 # 再置零，未重新归一化
print("bad row sums", np.round(A_bad.sum(-1), 4))
A_renorm = A_bad / A_bad.sum(-1, keepdims=True)      # 置零后重新归一化
A_good = softmax(S_full + causal[None], axis=-1)     # 先掩码再 softmax
print("max diff", np.abs(A_renorm - A_good).max())
```

```text
bad row sums [[0.2212 0.2295 0.9545 1.    ]]
max diff 2.7755575615628914e-17
```

行和等于未掩码时该行前 $t+1$ 个权重之和。第 0 行只剩自匹配项 $a_{00}=0.2212$，输出被缩小到 22.1%；第 2 行缩小到 95.5%；第 3 行没有禁止位置，行和仍为 1。两种正确写法（前置 $-\infty$ 与置零后重新归一化）的最大差为 $2.78\times10^{-17}$，属于 float64 的舍入量级，说明二者在精确算术下等价；错误写法与它们的差异达到 $10^{-1}$ 量级。

### 例 2：方差与饱和的数值验证

以下代码复现第 4 节的两组数字。

```python
import numpy as np

rng = np.random.default_rng(0)
d_k, n = 64, 200000
q = rng.standard_normal((n, d_k))        # 零均值单位方差
k = rng.standard_normal((n, d_k))
s = (q * k).sum(-1)                      # 逐样本内积
print("var(s) = %.3f, theory = %d" % (s.var(), d_k))
print("std(s) = %.3f, theory = %.3f" % (s.std(), np.sqrt(d_k)))
print("var(s/sqrt(d_k)) = %.4f" % (s / np.sqrt(d_k)).var())


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


T = 1000
c = rng.standard_normal((500, T))                      # 固定随机方向，用于测分数梯度
print("d_k  maxw  scaled  |Jc|  scaled")
for d_k in [1, 4, 16, 64, 256]:
    Z = rng.standard_normal((500, T)) * np.sqrt(d_k)   # 模拟未缩放打分
    A_raw = softmax(Z)
    A_scaled = softmax(Z / np.sqrt(d_k))
    Jc = A_raw * (c - (A_raw * c).sum(-1, keepdims=True))        # J c = a*(c - a·c)
    Jc_s = A_scaled * (c - (A_scaled * c).sum(-1, keepdims=True))
    print("%4d %.4f %.4f %.4f %.4f" % (
        d_k, A_raw.max(1).mean(), A_scaled.max(1).mean(),
        np.linalg.norm(Jc, axis=-1).mean(), np.linalg.norm(Jc_s, axis=-1).mean()))
```

```text
var(s) = 63.767, theory = 64
std(s) = 7.985, theory = 8.000
var(s/sqrt(d_k)) = 0.9964
d_k  maxw  scaled  |Jc|  scaled
   1 0.0169 0.0169 0.0512 0.0512
   4 0.1104 0.0168 0.1335 0.0513
  16 0.4406 0.0170 0.2566 0.0515
  64 0.7004 0.0163 0.2180 0.0514
 256 0.8476 0.0159 0.1320 0.0510
```

第一段验证 $\mathbf{q}^{\top}\mathbf{k}$ 的方差为 $d_k$：20 万个样本的样本方差为 $63.767$，与 $64$ 相差 $0.4\%$，标准差 $7.985$ 与 $\sqrt{64}=8$ 一致；缩放后方差为 $0.9964$，抽样误差量级为 $1/\sqrt{n}=0.0022$，故与 $1$ 相符。第二段验证饱和与梯度：$d_k$ 从 1 增至 256，未缩放的最大权重从 $0.0169$ 升至 $0.8476$，缩放后稳定在 $0.0159$–$0.0170$；未缩放的分数梯度范数先升后降（$0.0512\to0.2566\to0.1320$），缩放的始终为 $0.051$。`Z` 的构造直接使用 $\sqrt{d_k}$ 倍的标准正态，等价于第 4 节假设下未缩放打分的分布；若改用真实的 $\mathbf{q},\mathbf{k}$ 投影，方差还取决于权重初始化尺度，但对 $d_k$ 的依赖关系不变。`Jc` 一行利用 $\mathbf{J}\mathbf{c}=\mathbf{a}\odot(\mathbf{c}-(\mathbf{a}^{\top}\mathbf{c})\mathbf{1})$，避免显式构造 $T\times T$ 的雅可比矩阵。

### 例 3：PyTorch 多头注意力（含拆分与拼接）

需 PyTorch 2.0 及以上。代码中 `view` 与 `transpose` 的顺序是多头实现的核心。

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


class MultiHeadAttention(nn.Module):
    def __init__(self, d_model=512, num_heads=8, dropout=0.0):
        super().__init__()
        assert d_model % num_heads == 0, "d_model 必须被头数整除"
        self.d_model = d_model
        self.h = num_heads
        self.d_k = d_model // num_heads
        self.W_q = nn.Linear(d_model, d_model, bias=False)   # d^2 参数
        self.W_k = nn.Linear(d_model, d_model, bias=False)
        self.W_v = nn.Linear(d_model, d_model, bias=False)
        self.W_o = nn.Linear(d_model, d_model, bias=False)   # 拼接后的输出投影
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        B, T, _ = x.shape
        q = self.W_q(x).view(B, T, self.h, self.d_k).transpose(1, 2)
        k = self.W_k(x).view(B, T, self.h, self.d_k).transpose(1, 2)
        v = self.W_v(x).view(B, T, self.h, self.d_k).transpose(1, 2)
        scores = q @ k.transpose(-2, -1) / math.sqrt(self.d_k)  # (B,h,T,T)
        if mask is not None:
            scores = scores.masked_fill(mask, float("-inf"))    # True 表示禁止
        attn = self.dropout(torch.softmax(scores, dim=-1))
        out = attn @ v                                          # (B,h,T,d_k)
        out = out.transpose(1, 2).contiguous().view(B, T, self.d_model)
        return self.W_o(out), attn


torch.manual_seed(0)
mha = MultiHeadAttention(d_model=512, num_heads=8)
x = torch.randn(2, 5, 512)
causal = torch.triu(torch.ones(5, 5, dtype=torch.bool), diagonal=1)
y, a = mha(x, mask=causal)
print(y.shape)                                    # torch.Size([2, 5, 512])
print(a.shape)                                    # torch.Size([2, 8, 5, 5])
print(a.sum(-1)[0, 0])                            # tensor([1., 1., 1., 1., 1.])
print(sum(p.numel() for p in mha.parameters()))   # 1048576
```

预期输出为 `torch.Size([2, 5, 512])`、`torch.Size([2, 8, 5, 5])`、每行和为 1 的向量、参数量 `1048576`。

逐行说明与删除后果。`view(B, T, self.h, self.d_k)` 把最后一维 $d=512$ 切成 $8$ 个连续块，每块 64 维，头 $i$ 占据通道区间 $[64i,\,64i+64)$；随后 `transpose(1, 2)` 把 $(B,T,h,d_k)$ 变为 $(B,h,T,d_k)$，只交换步长、不复制数据。若省略 `transpose` 而直接写 `view(B, self.h, T, self.d_k)`，则 token 维被折进头维，头 0 会拿到位置 0 与位置 1 的部分通道，位置与头的对应关系被破坏，因果掩码也随之失效。`k.transpose(-2, -1)` 在最后两维上转置，是批量内积的标准写法；若用 `.T`，四维张量的所有维都会被反转，得到 $(d_k,T,h,B)$。`/ math.sqrt(self.d_k)` 用每头维度 64 而非模型维度 512，两者相差 $\sqrt{8}\approx2.83$ 倍。`masked_fill(mask, float("-inf"))` 中布尔掩码 `True` 表示禁止，与例 1 的加性掩码语义相反，混用会导致全掩码或完全不掩码。`attn @ v` 后必须 `transpose(1, 2)` 回到 $(B,T,h,d_k)$，再 `contiguous().view(B,T,d)` 把 $h$ 个块按 $0,\dots,h-1$ 的顺序拼回；`view` 要求连续内存，省略 `contiguous()` 会抛出步长错误，说明前面的 `transpose` 产生了非连续张量，也说明拼接顺序依赖这一步的实现。最后 `W_o` 把 $d$ 维映射回 $d$ 维，参数量 $d^2$；去掉它则各头输出直接拼接，头之间无法线性混合，等价于把 $\mathbf{W}_O$ 固定为单位矩阵。

参数量核对：四个 `nn.Linear(d,d,bias=False)` 各 $d^2=262\,144$ 个参数，合计 $4d^2=1\,048\,576$，与打印一致。若加偏置，每个投影多 $d$ 个，合计 $4d$。

### 例 4：常见配置的参数量与计算量核对

| 配置 | $d$ | $h$ | $d_k$ | 单层注意力参数 $4d^2$ | 单层 $T=1024$ 注意力 FLOPs $2T^2d$ |
|---|---|---|---|---|---|
| 小模型 | 384 | 6 | 64 | 589 824 | $8.05\times10^{8}$ |
| GPT-2 small | 768 | 12 | 64 | 2 359 296 | $1.61\times10^{9}$ |
| GPT-2 medium | 1024 | 16 | 64 | 4 194 304 | $2.15\times10^{9}$ |
| 7B 级 | 4096 | 32 | 128 | 67 108 864 | $8.59\times10^{9}$ |

计算方式：$4d^2$ 与 $2T^2d$ 直接代入。$d=384$ 时 $4\times147\,456=589\,824$，$2\times1024^2\times384=8.05\times10^{8}$。$d=4096$ 时单层注意力参数 $6.71\times10^{7}$，32 层共 $2.15\times10^{9}$，与 7B 模型的总参数量同阶，说明大模型中注意力参数与 FFN 参数共同构成主体，而 $2T^2d$ 一项随 $T$ 平方增长。

## 易错点

> [!warning] 以下六条均可在代码或形状推导中直接检验。
> 1. 打分写成 $\mathbf{Q}\mathbf{K}$ 或忘记转置最后两维：正确形式为 $\mathbf{Q}\mathbf{K}^{\top}$，形状 $(T,d_k)(d_k,T)\to(T,T)$。批量时用 `k.transpose(-2,-1)`，不可用 `.T`，后者会反转全部维度。检验方法：打印打分矩阵形状，应为 $(B,h,T,T)$。
> 2. 掩码加在 softmax 之后且不重新归一化：行和变为 $1-\sum_{j>t}a_{tj}$，例 1 的确定性矩阵上实测为 $[0.2212,0.2295,0.9545,1.0000]$，位置越靠前输出被缩小得越多。检验方法：`A.sum(-1)` 应逐行等于 1。
> 3. 缩放遗漏或除错维度：应除以 $\sqrt{d_k}$（每头维度），不是 $\sqrt{d}$（模型维度）；$d=512,h=8$ 时两者相差 2.83 倍。同时缩放 $\mathbf{Q}$ 与打分两次会使等效因子为 $1/d_k$，权重过于平坦。检验方法：初始化时打印打分的标准差，应接近 1。
> 4. softmax 沿错误维度归一化：`dim=-1` 是键维，`dim=-2` 是查询维；后者使每列和为 1，权重语义变为"位置 $j$ 被哪些位置关注"。此时因果掩码仍能屏蔽配对，但输出不再是值的凸组合，尺度也不受控。检验方法：检查 `A.sum(-1)` 而非 `A.sum(-2)`。
> 5. 多头拆分与拼接顺序不一致：拆分必须是 `view(B,T,h,d_k).transpose(1,2)`，拼接必须是 `transpose(1,2).contiguous().view(B,T,h*d_k)`，两者互为逆变换。若拆分写成 `view(B,h,T,d_k)`，token 维被折进头维，头与位置错配，且不报错、只表现为性能下降。
> 6. 掩码导致整行 $-\infty$：softmax 分母为 0，结果为 NaN，且 NaN 会经残差传播到全部参数。因果掩码的对角线恒为 0 可避免此问题；叠加 padding 掩码时必须保证每行至少保留一个允许位置，或在实现中把全掩码行的权重置为均匀分布。

## 关联笔记

- 前置 [[从RNN到注意力机制]]：该篇从 seq2seq 的固定向量瓶颈与 Bahdanau 加性注意力出发，给出注意力要解决的问题；本篇第 7 节把两种打分函数放在同一张对比表中。
- 前置 [[预备知识-token与嵌入]]：注意力在嵌入序列 $\mathbf{X}\in\mathbb{R}^{T\times d}$ 上做三次投影，本篇的形状约定与 $d=d_{\text{model}}$ 的记法沿用该篇。
- 后续 [[因果注意力与多头注意力]]：把本篇的无掩码单头形式改造为因果掩码加多头，给出 `CausalSelfAttention` 的完整实现、训练并行与推理逐 token 的差异。
- 后续 [[位置编码-正弦与RoPE]]：本篇的打分只依赖内容，对位置置换等变；该篇证明这一性质并给出位置信息的注入方式。
- 后续 [[Transformer架构详解]]：注意力作为子层与残差、LayerNorm、前馈网络组合，该篇给出层的完整结构与参数量核算。

## 达标检测

- [ ] 写出 $\mathbf{Q},\mathbf{K},\mathbf{V},\mathbf{S},\mathbf{A},\mathbf{O}$ 的形状链，并计算 $d=768$、$h=12$ 时单层注意力参数量与 12 层占总参数的百分比，误差不超过 0.5 个百分点。
- [ ] 在不查资料的情况下推出 $\mathrm{Var}(\mathbf{q}^{\top}\mathbf{k})=d_k$，逐项说明独立性、零均值、单位方差三条假设分别用在哪一步。
- [ ] 用 softmax 的雅可比 $\mathbf{J}=\mathrm{diag}(\mathbf{a})-\mathbf{a}\mathbf{a}^{\top}$ 证明 $\mathbf{a}\to$ one-hot 时 $\mathbf{J}\to\mathbf{0}$，并说明为何 $\mathbf{Q},\mathbf{K}$ 的梯度随之消失。
- [ ] 手算例 1 中第 2 行的打分、指数、权重与输出，与打印结果逐位核对，并说明第 0 行为何恰为 one-hot。
- [ ] 运行例 1 的代码，报告被屏蔽位置权重的最大值与四行的行和；再把掩码改到 softmax 之后，报告行和的变化并解释偏差来源。
- [ ] 实现例 3 的多头注意力，打印 $(B,h,T,d_k)$、注意力矩阵与参数量，并说明去掉 `transpose(1,2)`、`contiguous()`、`W_o` 三者各自的后果。
- [ ] 取 $d=768$，判断 $T=512$ 与 $T=4096$ 时计算瓶颈分别落在 $4Td^2$ 项还是 $2T^2d$ 项，给出两项的数值与占比。

## 参考来源

- Vaswani et al., "Attention Is All You Need", arXiv:1706.03762, 第 3.2 节 —— 对应本篇第 3 节的缩放点积公式、第 3.2.1 节关于 $d_k$ 增大时点积注意力劣于加性注意力的结论与缩放动机、第 3.2.2 节的多头定义。
- d2l.ai《动手学深度学习》「注意力机制与 Transformer」一章 —— 对应本篇第 1 节的打分函数视角（加性、点积与缩放点积）、第 5 节的 masked softmax 与掩码位置。
- Stanford CS224n 关于 Self-Attention 与 Transformer 的讲义 —— 对应本篇第 1 节的 QKV 检索视角与第 8 节的多头拆分动机。
- Karpathy, nanoGPT 仓库与 "Let's build GPT" 讲义 —— 对应第 2 节把 $\mathbf{Q},\mathbf{K},\mathbf{V}$ 合并为单次投影的实现结构、第 5 节的因果掩码 buffer 与例 3 的拆分拼接写法。
- Raschka, *Build a Large Language Model (From Scratch)*, 2024, 第 3 章 —— 对应第 8 节多头注意力的形状变换逐步推导与第 2 节的参数量核对方法。
- PyTorch 官方文档 `torch.nn.MultiheadAttention` 与 `torch.nn.functional.scaled_dot_product_attention` —— 对应 `attn_mask` 的布尔与浮点两种语义、批量维约定与例 3 的模块接口。
