Attention 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

1. 公式：$\text{Attention}(Q,K,V) = \text{softmax}\!\left(\dfrac{QK^\top}{\sqrt{d_k}}\right) V$。
2. 为什么除 √d_k：若 $q_i, k_i \sim \mathcal{N}(0,1)$ 独立，$q\cdot k$ 方差 $= d_k$；除 $\sqrt{d_k}$ 把方差拉回 1，避免 softmax 饱和。
3. Multi-Head：把 $D$ 拆成 $H$ 个 head，每个 head 在不同 subspace 独立做 attention，concat 后 $W_o$ 投影。固定 $D$ 且 $d_k=D/H$ 时，标准 MHA 参数量 $\approx 4D^2$（不随 $H$ 变）；MQA/GQA 下 K/V 投影变小。
4. Self vs Cross：Self 的 Q/K/V 同源；Cross 的 Q 来自 query stream，K/V 来自 context stream（encoder output / image tokens / text embedding）。
5. Causal mask vs Padding mask：前者用下三角阻断未来；后者用 [B,1,1,L_k] 屏蔽 padding 列。
6. 复杂度：$O(B H L^2 d_k)$ 时间，$O(B H L^2)$ score 显存——长序列瓶颈在二次项。
7. 易踩坑：全 masked row → softmax NaN；FP16 下 $QK^\top$ 可能 overflow；attention weight ≠ 因果解释。

§1 Attention 直觉

Attention 的本质是 可学习的检索（learned retrieval）：

• 每个 query（"我现在需要什么信息？"）
• 对所有 key（"每个位置宣称自己能提供什么"）计算相似度
• 用 softmax 归一化得到 权重分布
• 对所有 value（"每个位置实际提供的内容"）做加权求和

对比 RNN：RNN 把过去信息压缩进一个固定大小的 hidden state，长序列必丢信息；attention 在每一步都直接、全局、动态地检索过去所有位置，因此适合长程依赖。

"Q/K/V 是同一个向量经过三个不同投影"——这点要主动说明，因为面试常考新手会以为 Q/K/V 是三份不同输入。

§2 Scaled Dot-Product Attention

2.1　公式

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

形状：

• $Q \in \mathbb{R}^{L_q \times d_k}$, $K \in \mathbb{R}^{L_k \times d_k}$, $V \in \mathbb{R}^{L_k \times d_v}$
• Scores $QK^\top \in \mathbb{R}^{L_q \times L_k}$（每个 query 对所有 key 的相似度）
• Softmax over key 维度：每个 query 行的权重和为 1
• Output $\in \mathbb{R}^{L_q \times d_v}$

2.2　为什么除以 √d_k（必考题，要会推方差）

假设 $q, k \in \mathbb{R}^{d_k}$ 的每个分量独立同分布，$q_i, k_i \sim \mathcal{N}(0,1)$。考虑点积：

$$q \cdot k = \sum_{i=1}^{d_k} q_i k_i$$

由独立性，每项 $q_i k_i$ 均值 $= \mathbb{E}[q_i]\mathbb{E}[k_i] = 0$，方差 $= \mathbb{E}[q_i^2]\mathbb{E}[k_i^2] = 1$。所以：

$$\mathbb{E}[q\cdot k] = 0, \quad \text{Var}[q\cdot k] = d_k$$

当 $d_k$ 大（如 64、128），$q\cdot k$ 的典型量级是 $\sqrt{d_k}$，进入 softmax 后最大 logit 容易抢走绝大部分概率，softmax 进入饱和区，梯度量级显著缩小，训练收敛变慢甚至停滞。除以 $\sqrt{d_k}$ 把方差拉回 1，减轻饱和、改善梯度尺度。

2.3　Mask 与 NaN 陷阱（💣 经典 bug，面试必问）

标准做法：把要屏蔽的位置 score 填成 $-\infty$，softmax 后那些位置概率 = 0。

但有个陷阱：如果某一行所有 key 都被 mask（如 query 0 在 cross-attn 中 context 全 padding；causal + 左 padding；某 query 后无任何合法 token），那一行 score 全是 $-\infty$，softmax 输出：

$$\text{softmax}([-\infty, -\infty, ..., -\infty]) = \text{NaN}$$

因为分子分母都是 $e^{-\infty} = 0$，$0/0 = $ NaN，污染整个 batch 的梯度。

# 检测全 mask 行
all_masked = (~mask).all(dim=-1, keepdim=True)   # [..., L_q, 1]
# 临时给该行放开 (避免 NaN)
safe_mask = mask | all_masked
scores = scores.masked_fill(~safe_mask, float("-inf"))

# Softmax 正常计算
weights = F.softmax(scores, dim=-1)

# 把全 mask 行的输出强制设为 0 (否则会得到均匀分布)
weights = weights.masked_fill(all_masked, 0.0)

nn.MultiheadAttention 的 attn_mask / key_padding_mask：True = mask out（相反！）

面试写代码前先问面试官约定，或主动声明你的约定，否则容易被搞反。

2.4　代码（核心 20 行）

def scaled_dot_product_attention(Q, K, V, mask=None, dropout_p=0.0, training=True):
    d_k = Q.size(-1)
    scores = Q @ K.transpose(-2, -1)                 # [..., L_q, L_k]
    scores = scores / math.sqrt(d_k)                 # ← 关键 scale

    if mask is not None:
        all_masked = (~mask).all(dim=-1, keepdim=True)
        safe_mask = mask | all_masked
        scores = scores.masked_fill(~safe_mask, float("-inf"))
    else:
        all_masked = None

    weights = F.softmax(scores, dim=-1)

    if all_masked is not None:
        weights = weights.masked_fill(all_masked, 0.0)   # NaN 防护

    if dropout_p > 0.0 and training:
        weights = F.dropout(weights, p=dropout_p)

    return weights @ V, weights                       # output, weights

§3 Multi-Head Attention

3.1　公式

$$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_H) W_o$$

$$\text{head}_h = \text{Attention}(Q W_q^{(h)},\; K W_k^{(h)},\; V W_v^{(h)})$$

每个 head 的 $W_q^{(h)}, W_k^{(h)}, W_v^{(h)} \in \mathbb{R}^{D \times d_k}$，$d_k = D/H$。工程上把 H 个 head 的投影矩阵 concat 成一个 $D \times D$ 大矩阵，一次 matmul 跑完所有 head 的投影（GPU 友好）：

Input X [B, L, D]
   │
   │  W_q, W_k, W_v ∈ R^{D×D}   (每个 = concat of H 个 W^{(h)} ∈ R^{D×d_k})
   ↓
Q, K, V [B, L, D]
   │
   │  reshape [B, L, D] → [B, L, H, d_k] → transpose → [B, H, L, d_k]
   ↓
对每个 head 独立做 Scaled-Dot-Product Attention (batched matmul, 并行)
   ↓
heads [B, H, L_q, d_k]
   │
   │  transpose + reshape → [B, L_q, D]   (concat heads)
   ↓
W_o ∈ R^{D×D}    →    Output [B, L_q, D]

3.2　为什么要 multi-head（不是单 head 也行吗？）

• 不同 subspace：每个 head 在自己的 $d_k$ 维子空间里学一种关系模式（语法、共指、远距依赖、局部 n-gram...）
• 表达力：单 head 只能学一种 attention 模式；H 个 head 在 inference 时并行给出 H 种不同的 weighted sum 结果
• 参数效率：$d_k = D/H$ 而不是 $D$，所以参数量不会随 H 线性增加
• 面试常问：head 越多越好吗？不。$d_k = D/H$ 太小（如 $d_k < 16$）会让每个 head 表达力受限；Mistral / LLaMA 用 head_dim ≈ 64-128 是 sweet spot

3.3　参数量与 FLOPs

FLOPs（单次 self-attention forward，$L_q = L_k = L$）：

• QKV projection: $3 \cdot 2 B L D^2 = 6 B L D^2$
• $QK^\top$: $2 B H L^2 d_k = 2 B L^2 D$
• Softmax weight × V: $2 B L^2 D$
• Output projection $W_o$: $2 B L D^2$
• 总计 $\approx 8 B L D^2 + 4 B L^2 D$——前者随 $L$ 线性，后者随 $L$ 平方（长序列瓶颈）

3.4　代码（核心 30 行）

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads, dropout=0.0, bias=False):
        super().__init__()
        assert d_model % num_heads == 0
        self.d_model, self.num_heads, self.d_k = d_model, num_heads, d_model // num_heads

        # 合并 H 个 W^(h) 成一个 [D, D] 矩阵
        self.W_q = nn.Linear(d_model, d_model, bias=bias)
        self.W_k = nn.Linear(d_model, d_model, bias=bias)
        self.W_v = nn.Linear(d_model, d_model, bias=bias)
        self.W_o = nn.Linear(d_model, d_model, bias=bias)
        self.dropout_p = dropout

    def _split(self, x):  # [B, L, D] → [B, H, L, d_k]
        B, L, _ = x.shape
        return x.view(B, L, self.num_heads, self.d_k).transpose(1, 2)

    def _merge(self, x):  # [B, H, L, d_k] → [B, L, D]
        B, _, L, _ = x.shape
        return x.transpose(1, 2).contiguous().view(B, L, self.d_model)

    def forward(self, query, key, value, mask=None):
        Q = self._split(self.W_q(query))
        K = self._split(self.W_k(key))
        V = self._split(self.W_v(value))

        if mask is not None:
            if mask.dim() == 2: mask = mask.unsqueeze(0).unsqueeze(0)   # [1,1,L_q,L_k]
            elif mask.dim() == 3: mask = mask.unsqueeze(1)              # [B,1,L_q,L_k]
            # dim=4: 已对齐

        out, w = scaled_dot_product_attention(Q, K, V, mask=mask, dropout_p=self.dropout_p, training=self.training)
        return self.W_o(self._merge(out)), w

§4 Self / Cross / Causal / Padding

4.1　Self vs Cross Attention（必考）

4.2　Causal Mask（Decoder / GPT）

下三角矩阵（含对角线）：第 $i$ 行可以看 $j \le i$ 的 key。

def causal_mask(L, device=None):
    return torch.tril(torch.ones(L, L, dtype=torch.bool, device=device))
# L=4 →
# [[T F F F]
#  [T T F F]
#  [T T T F]
#  [T T T T]]

4.3　Padding Mask（变长序列）

每个 sample 有效长度不同，padding token 不应被 attend：

def padding_mask(lengths, max_len=None):
    if max_len is None: max_len = int(lengths.max())
    idx = torch.arange(max_len, device=lengths.device).unsqueeze(0).expand(len(lengths), -1)
    return idx < lengths.unsqueeze(1)    # [B, L]    True=valid, False=padding

# 用法：必须 unsqueeze 成 [B, 1, 1, L_k] 才能 broadcast 到 MHA 内部 [B, H, L_q, L_k]
pmask = padding_mask(lengths).unsqueeze(1).unsqueeze(1)   # [B, 1, 1, L_k]
out, _ = mha(x, x, x, mask=pmask)

§5 复杂度分析

关键点：

• Self-attention 的 $L^2$ 项计算可以接受（GPU 并行），但 $L^2$ 显存（score 矩阵）是真正瓶颈——这是 Flash Attention 攻击的痛点
• LLM inference 时 prefill stage 是 $O(L^2)$；decode stage 用 KV cache 后每步是 $O(L)$（见 §6）
• 当 $L \approx D$ 时，attention 与 FFN 时间相当；当 $L \gg D$ 时，attention 占绝大部分时间

§6 KV Cache + MQA / GQA

6.1　KV Cache（autoregressive inference 关键优化）

问题：GPT 自回归生成时，每生成一个 token，把整个 prefix 重新过 forward——$t$ 步累计 $O(t^2)$ 重复计算。

解：把每层 $K^{(\ell)}, V^{(\ell)}$ 缓存。生成第 $t+1$ 个 token 时：

• 只对新 token 算 $q_{t+1}, k_{t+1}, v_{t+1}$（1 × D 大小）
• 将 $k_{t+1}, v_{t+1}$ append 到 cache
• 新 $q$ 对整个 cache 做 attention（$O(t)$ 不是 $O(t^2)$）

KV cache 显存（per sample）：

$$\text{KV cache} = L_\text{ctx} \cdot n_\text{layers} \cdot \underbrace{2}_{K, V} \cdot H_\text{kv} \cdot d_\text{head} \cdot \text{bytes\_per\_elem}$$

注意：MQA/GQA 下 $H_\text{kv} \ll H$，cache 显著缩减。对 LLaMA-2-70B（GQA, $H_\text{kv}=8$）、$L_\text{ctx}=4096$、80 层、fp16：约 1.25 GB / sample——这就是 LLaMA-2 用 GQA 不用 MHA 的原因（vanilla MHA 会到 10 GB / sample）。

6.2　MQA / GQA（attack KV cache 显存）

核心：多个 Q head 共享一组 K/V。MQA 极端但质量略降；GQA 是折中（如 H=32, G=8），显存 / 带宽降 4 倍，质量基本不掉。

§7 FlashAttention 核心 Trick

问题：标准 attention 需要物化 $L \times L$ 的 score 矩阵，HBM 读写 IO 是瓶颈（不是 FLOPs）。

FlashAttention 思路（IO-aware exact attention，不是近似）：

1. Block Tiling：把 $Q, K, V$ 切成 block，每次只把一个 $Q$ block 和一个 $K, V$ block 加载到 SRAM
2. Online Softmax：边算边维护 running max $m$ 和 running sum $\ell$，避免一次性物化全部 scores
3. Recompute on backward：反向时重算 attention 而不存 $L^2$ scores

效果：

• 避免 materialize 完整 $L \times L$ 的 scores / probs 矩阵到 HBM
• 论文给出的 HBM IO 复杂度约 $O(L^2 d^2 / M + Ld)$，对比标准 attention 的 $O(L^2 + Ld)$ HBM traffic——当 $L$ 大、$M$（SRAM）合适时 IO 减少显著
• 显存峰值从 $O(L^2)$ 降到 $O(L)$（不存中间 scores）
• 典型速度提升 2-4 倍（取决于 sequence length & GPU 架构）
• 数学上完全等价（exact attention，不是 sparse / linear approximation）

§8 Position Encoding (RoPE / ALiBi / Absolute)

8.1　Attention Sink（高级题）

训练好的 LLM 在 decode 时，注意力会异常集中在前 1-4 个 token（特别是 [BOS] / 第一个 token），即使内容无关。这种现象叫 attention sink。常见直觉解释：softmax 强制权重和为 1，当一个 query 实际不想 attend 任何 key 时，需要一个"垃圾位"来吸收概率质量；又因为 early tokens 对所有后续 token 都可见，训练中容易自然形成全局 sink。StreamingLLM (Xiao et al., ICLR 2024) 利用这个现象做长序列推理（保留 attention sink + 滑动窗口）。

§9 Attention in Diffusion（generative 方向必问）

对 diffusion 背景的候选人，几乎必问 attention 在生成模型里的用法。

9.1　Latent Diffusion (Stable Diffusion) 里的 Cross-Attention

Image latent (z_t)  [B, C, H, W]
   │
   │  flatten to tokens [B, HW, D]
   ↓
Self-Attention (Q=K=V from image)
   ↓
Cross-Attention:
    Q = image tokens [B, HW, D]
    K, V = text embedding [B, L_text, D]    ← 文本条件
   ↓
FFN → next layer

关键点：

• Text-to-image conditioning 通过 cross-attention 实现：image tokens 是 query，text embedding 是 key/value
• Classifier-Free Guidance (CFG)：两次 forward（with text / without text）做差值。$\epsilon$-pred 时：$\epsilon_\text{CFG} = \epsilon_\text{uncond} + s (\epsilon_\text{cond} - \epsilon_\text{uncond})$；v-pred / x0-pred 时换成对应预测量，线性 guidance 形式类似
• SD / SDXL 的 U-Net 在多个 spatial resolution 的 transformer block 里都有 self-attn 与 cross-attn 交替
• DiT (Diffusion Transformer) 把 U-Net 换成 pure Transformer，conditioning 通过 AdaLN / cross-attn / token-concat 等方式

9.2　Attention 在 video diffusion

• Spatial attention：每帧内部（image patches 之间）
• Temporal attention：跨帧（同位置在不同时间步之间）
• Spatiotemporal / full attention：所有 frame × all positions——最昂贵，长视频不可行
• Long video 的 attention 是开放问题（$L \sim 10^4$-$10^5$ token），常见路线：因式化（空间 + 时间交替）、sparse window、hierarchical pooling、chunked attention

§10 25 高频面试题

codex (gpt-5.5 xhigh) 作为顶级 lab 面试官视角列的，按难度分 3 档。每题点开看答案要点 + 易踩坑。

L1必会题（任何 ML 工程岗都会问）

L2进阶题（research-oriented 岗位）

L3高级变体（顶级 lab / diffusion 方向）

§A 附录：完整 from-scratch 代码骨架

参考 from-scratch 实现包含：

• scaled_dot_product_attention()—— 含 NaN 防护
• MultiHeadAttention—— 标准 MHA，支持 4 种 mask 形状
• SelfAttention / CrossAttention—— thin wrapper，调用语义清晰
• causal_mask() / padding_mask() / combine_masks()
• 9 个 sanity check（self / causal / padding / cross / wrappers / nn.MHA 对齐 / NaN防护 / d_model%H / return_weights=False）

实跑 sanity check 输出（PyTorch 2.x，单机 GPU）：

[a] self-attn  out=(2, 5, 16) weights=(2, 4, 5, 5)  weights row-sum=1 ✓
[b] causal mask: upper triangle ~ 0  ✓
[c] padding mask: pad-key columns ~ 0 in sample-1  ✓
[d] cross-attn out=(2, 7, 16) weights=(2, 4, 7, 5)  ✓
[e] SelfAttention(causal) ✓   CrossAttention(context-pad) ✓
[f] vs nn.MultiheadAttention:  |Δout|=0.00e+00  |Δweights|=0.00e+00  ✓
[g] all-masked row: no NaN, weights row = 0  ✓
[h] d_model not divisible by num_heads -> ValueError  ✓
[i] return_weights=False -> weights is None  ✓

代码经独立 reviewer 静态检查 + PyTorch 实跑 sanity check，与 nn.MultiheadAttention diff = 0。