Transformer：Attention 是全部的核心

本章对应课件：《3.2 Transformer》。这是全课程最重要的章节，也是面试八股最密集的一章。下面的知识点全部独立展开，每个都包含：直觉、公式、逐项拆解、矩阵 shape、最小数字例子、交互演示、代码、常见误区、面试问题。

本章末尾还有 7.24 面试题库，把 39 个高频问题（含本章全部考点）逐条列出并给出折叠答案。

7.1 为什么需要 Attention ★

三种方案对比

逐项拆解：Attention 解决的两个核心问题

7.2 Transformer 总体架构（含 Encoder 模块）★

逐项拆解：Encoder 一层做什么

Encoder 的输出：与输入同形状 [B, S, d_model] 的张量，但每个位置都融合了全句信息。原始论文堆叠 N = 6 层，每层结构完全相同但参数不同。

矩阵 shape

Decoder 一层（原始 Transformer）

BERT vs GPT vs 原始 Transformer：

7.3 位置编码（含 embedding 缩放）★

为什么没有顺序

看这个例子：

dog bites man
man bites dog

两句话用词完全相同，意思相反。纯 Attention 是置换等变的（permutation equivariant）：

输入置换 $P$，输出只是跟着置换——模型根本没有「位置」概念。

如何弥补

Sinusoidal 位置编码（原始 Transformer）：

不同维度有不同频率：低频表达粗粒度位置，高频表达细粒度位置。

为什么 embedding 要乘 √d_model

注意：这是原始论文的实现细节；现代 LLM（如 LLaMA）通常在 embedding 后直接接 RMSNorm，用归一化解决尺度问题。

位置编码技术全景

7.4 Self-Attention 是什么 ★

公式

逐项拆解（五个部件，后面逐节展开）

矩阵 shape

复杂度与「翻倍变 4 倍」

7.5 Q、K、V：三个投影 ★

公式

逐项拆解

矩阵 shape（QKV shape flow）

维度怎么「消掉」的：$d_{model}$ 在矩阵乘法中被求和消去，剩下 $d_k$（或 $d_v$）。

最小数字例子

逐行验算：

• 第 1 行：$[1,0]$ → 列 1 = $1\times1 + 0\times1 = 1$；列 2 = $1\times0 + 0\times1 = 0$ → $[1, 0]$
• 第 2 行：$[0,1]$ → 列 1 = $0\times1 + 1\times1 = 1$；列 2 = $0\times0 + 1\times1 = 1$ → $[1, 1]$
• 第 3 行：$[1,1]$ → 列 1 = $1+1 = 2$；列 2 = $0+1 = 1$ → $[2, 1]$

同理：

Wq = nn.Linear(d_model, d_k, bias=False)
Wk = nn.Linear(d_model, d_k, bias=False)
Wv = nn.Linear(d_model, d_v, bias=False)

Q = Wq(x)   # [B, S, d_k]
K = Wk(x)   # [B, S, d_k]
V = Wv(x)   # [B, S, d_v]

7.6 为什么 Q 和 K 要用不同的投影矩阵（不能 X·Xᵀ）★

三个理由

理由 1：打破对称性

如果 $S = XX^\top$：

注意力矩阵恒为对称矩阵，模型无法表达方向性关系。

理由 2：角色分离（Query ≠ Key）

• Query：我在找什么信息（当前 token 的需求）
• Key：我能提供什么信息（每个 token 的标签）

这两个角色语义不同，需要不同的子空间来表达。分开投影后：

模型可以通过 $W_Q W_K^\top$ 学出一个非对称的双线性形式，表达「i 对 j 的关注」。

理由 3：表达力

论文实验表明，学习出来的投影比固定的恒等映射（直接点积）效果好；投影让模型自适应地选择「哪些维度用于匹配」。

数字算例

沿用统一算例。如果直接用 $XX^\top$：

注意它是对称矩阵：$S_{13} = S_{31} = 1$，$S_{23} = S_{32} = 1$。

而用分开投影后得到的 $S = QK^\top$：

关键在于：对称与否由模型自己决定，而不是被数学结构强制。换一组不同的 $W_Q, W_K$，$S$ 就不再对称。

7.7 QKᵀ：匹配打分 ★

公式

逐项拆解

矩阵 shape（为什么是 seq_len × seq_len）

维度怎么「消掉」的：$d_k$ 在点积中被求和消去，剩下 $S \times S$——每个 token 对每个 token 一个分数，所以注意力矩阵的行数和列数都是序列长度。

最小数字例子

逐项验算（注意 $K^\top$ 的列就是 $K$ 的行）：

scores = Q @ K.transpose(-2, -1)   # [B, S, S]
# transpose(-2, -1)：交换最后两维，即 [B, S, d_k] → [B, d_k, S]

7.8 点乘 vs 加法注意力 ★

公式对比

点乘（Luong，Transformer 采用）：

加性（Bahdanau）：

逐项拆解

复杂度对比

单次打分：点乘 $O(d)$，加性 $O(d^2)$（两个 $d \times d$ 投影）或 $O(d)$（投影到低维后）。但两者都要算 $S^2$ 对，总复杂度分别是 $O(S^2 d)$ 和 $O(S^2 d^2)$——点乘在实际硬件上快得多（大矩阵乘法 + 显存友好）。

7.9 为什么除 √d_k ★

公式

逐项拆解（方差推导）

假设 $q$、$k$ 的每个分量独立、均值 0、方差 1：

每项 $q_i k_i$ 的方差为 1，$d_k$ 项独立相加：

所以除以 $\sqrt{d_k}$ 后，方差回到 1。

矩阵 shape

缩放不改变形状，只改变数值：

最小数字例子

统一算例中 $d_k = 2$，$\sqrt{d_k} \approx 1.414$：

$d_k$ 更大时差异更明显。假设某行分数是 $[3, 2, 1]$：

d_k = Q.size(-1)
scores = Q @ K.transpose(-2, -1) / math.sqrt(d_k)   # 或 scores * (d_k ** -0.5)

7.10 Softmax：对哪个维度做 ★

公式（逐行计算）

关键：对最后一维（dim=-1，即 key 的位置）做，不是对列。

逐项拆解

为什么用 exp？ 保证非负、放大差异、可导。数值稳定技巧：先减去每行最大值再取 exp。

矩阵 shape

最小数字例子

验算第 2 行：$e^{0.707}=2.028$，$e^{0.707}=2.028$，$e^{1.414}=4.113$；总和 $= 8.169$；$2.028/8.169 = 0.248$，$4.113/8.169 = 0.504$ ✅ 每行和 = 1。

怎么读：第 3 行 [0.14, 0.28, 0.58] 表示「token3 把 14% 的注意力给 token1、28% 给 token2、58% 留给自己」。

A = F.softmax(scores, dim=-1)      # 对最后一维（每个 query 的所有 key）归一化

# 手写数值稳定版：
scores = scores - scores.max(dim=-1, keepdim=True).values
e = torch.exp(scores)
A = e / e.sum(dim=-1, keepdim=True)

7.11 为什么最后乘 V 而不是 K ★

为什么不是 K

如果用 $A \cdot K$，输出的语义就变成「按权重混合所有 token 的标签」，而不是「混合所有 token 的内容」——标签是为匹配服务的投影，不是信息本身。

为什么是加权和

• $A_{ij} \ge 0$ 且 $\sum_j A_{ij} = 1$（softmax 保证）
• 所以 output_i 是凸组合（convex combination）——所有 V 的加权平均
• 权重大的 V 贡献大，但所有 V 都被混合（软选择，不是 argmax）

矩阵 shape

$S$ 在加权中被求和消去，输出每个位置仍然是 $d_v$ 维——形状与 V 相同，序列长度不变。

最小数字例子

计算第 1 个 token 的输出：

逐维计算：

• 第 1 维：$0.198\times1 + 0.401\times0 + 0.401\times1 = 0.599$
• 第 2 维：$0.198\times0 + 0.401\times1 + 0.401\times1 = 0.802$

7.12 完整手算：3 token × 2 维的 Attention ★

第 0 步：输入

3 个 token（行），每个 2 维（列）。$d_{model} = d_k = d_v = 2$。

第 1 步：三个投影

逐行验算（以 Q 为例）：第 3 行 $[1,1]$ 乘 $W_Q$ 的第 1 列 $[1,1]$ 得 $1+1=2$，乘第 2 列 $[0,1]$ 得 $0+1=1$ → $[2,1]$。

第 2 步：QKᵀ 打分

全部 9 个元素：

第 3 步：除以 √d_k

$\sqrt{d_k} = \sqrt{2} \approx 1.414$：

第 4 步：逐行 softmax

第 1 行：$e^{[0,\ 0.707,\ 0.707]} = [1,\ 2.028,\ 2.028]$，和 $= 5.056$ → $[0.198,\ 0.401,\ 0.401]$

第 2 行：$e^{[0.707,\ 0.707,\ 1.414]} = [2.028,\ 2.028,\ 4.113]$，和 $= 8.169$ → $[0.248,\ 0.248,\ 0.504]$

第 3 行：$e^{[0.707,\ 1.414,\ 2.121]} = [2.028,\ 4.113,\ 8.343]$，和 $= 14.484$ → $[0.140,\ 0.284,\ 0.576]$

第 5 步：乘 V 得到输出

output₁：

output₂：

output₃：

输出形状与输入 $X$ 相同（都是 3×2）——Attention 不改变序列长度，也不改变（当 $d_v = d_{model}$ 时）特征维度。

7.13 公式 ↔ 代码逐行对应 ★

逐行对应表

完整实现（逐行注释）

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

class SelfAttention(nn.Module):
    def __init__(self, d_model, d_k):
        super().__init__()
        # 三套独立投影：W_Q, W_K, W_V
        self.Wq = nn.Linear(d_model, d_k, bias=False)   # 对应 Q = XW_Q
        self.Wk = nn.Linear(d_model, d_k, bias=False)   # 对应 K = XW_K
        self.Wv = nn.Linear(d_model, d_k, bias=False)   # 对应 V = XW_V

    def forward(self, x, causal=False):                  # x: [B, S, d_model]
        Q = self.Wq(x)                                   # [B, S, d_k]
        K = self.Wk(x)                                   # [B, S, d_k]
        V = self.Wv(x)                                   # [B, S, d_v]

        d_k = Q.size(-1)                                 # 缩放因子
        scores = Q @ K.transpose(-2, -1)                 # QKᵀ  → [B, S, S]
        scores = scores / math.sqrt(d_k)                 # 除以 √d_k

        if causal:                                       # 可选：因果掩码
            mask = torch.triu(torch.ones(scores.shape[-2:], device=x.device), 1).bool()
            scores = scores.masked_fill(mask, float("-inf"))   # 未来位置 = -∞

        A = F.softmax(scores, dim=-1)                    # 逐行 softmax → [B, S, S]
        return A @ V                                     # 加权求和 → [B, S, d_v]

对照手算例子验证代码

用 7.12 的数字跑一遍上面的代码（$B=1, S=3, d_k=2$），你会得到：

Q = [[1,0],[1,1],[2,1]]
K = [[0,1],[1,0],[1,1]]
V = [[1,0],[0,1],[1,1]]
scores（缩放后）= [[0,0.707,0.707],[0.707,0.707,1.414],[0.707,1.414,2.121]]
A = [[0.198,0.401,0.401],[0.248,0.248,0.504],[0.140,0.284,0.576]]
out = [[0.599,0.802],[0.752,0.752],[0.716,0.860]]

与手算结果完全一致 ✅——数学和代码是同一件事。

7.14 Multi-Head Attention ★

公式

逐项拆解

矩阵 shape（每个 head 的维度如何变化）

为什么不是「简单把 Attention 做很多遍」

关键：每个头有独立的可学习参数，所以会自发分化——有的头关注局部语法，有的关注指代，有的关注句首。

为什么每个 head 要降维

最小数字例子

设 $d_{model} = 4$，$h = 2$，则每个头的 $d_k = d_v = 2$。假设某个 token 两个头的输出分别是：

拼接：

再乘 $W_O$（$[4,4]$，这里取单位阵示意）得到该 token 的最终输出 $[0.6, 0.8, 0.2, 0.5]$。

mha = nn.MultiheadAttention(embed_dim=512, num_heads=8, batch_first=True)
x = torch.randn(2, 10, 512)          # [B=2, S=10, d=512]
out, attn = mha(x, x, x)             # self-attention
print(out.shape)                     # [2, 10, 512]
print(attn.shape)                    # [2, 10, 10]（各头平均后的权重）

7.15 复杂度与工程延伸 ★

三个瓶颈与对应技术

逐项拆解

KV Cache（推理）：自回归生成时缓存历史 K/V，新 token 不再重算历史投影与完整前向（K/V 投影的重复量从 $O(n^2)$ 降到 $O(n)$）。注意：注意力分数仍需与新 Query 对全部历史 K 计算，随上下文线性增长——KV Cache 省的是「重算历史」，不是注意力本身（第 10 章有完整说明）。

GQA（显存）：多个 Query head 共享一组 K/V head（如 32 Q 配 8 KV），KV Cache 直接降到 1/4。

FlashAttention（IO）：GPU 的瓶颈往往不是算力而是显存读写（HBM↔SRAM）。FlashAttention 把 Q/K/V 分块载入片上 SRAM，用「在线 softmax」逐步累积结果，从不把完整的 S×S 矩阵写回显存。结果：同样 $O(S^2)$ 复杂度，但显存占用从 $O(S^2)$ 降到 $O(S)$，速度大幅提升，且是精确计算不是近似。

7.16 Padding Mask：在 Attention 里怎么遮 PAD ★

公式

逐项拆解

数字算例

序列 [CLS] my dog [SEP] PAD PAD（S=6）：

mask = [1, 1, 1, 1, 0, 0]

某行原始分数 [2, 1, 3, 2, 4, 5]：

• 不加 mask：softmax 后 PAD 位置（第 5、6 个）分别拿到约 21%、57% 的注意力——错误！模型会「关注空白」。
• 加 mask 后：[2, 1, 3, 2, −∞, −∞] → softmax 只在真实 token 上分配权重，行和仍为 1。

与 Causal Mask 的区别

两者可以同时使用（GPT 的 batch 推理既有 padding 又需要 causal）。

# 方式一：masked_fill（True 的位置被填 -inf）
scores = scores.masked_fill(pad_mask[:, None, :] == 0, float("-inf"))

# 方式二：HuggingFace 的 attention_mask 约定（1 = 保留，0 = 遮住）
# model(input_ids, attention_mask=mask) 内部自动处理

# 注意：PyTorch nn.MultiheadAttention 的 attn_mask 约定是 True = 遮住（-inf）

7.17 Causal Mask ★

公式

为什么填 −∞（而不是 0 或其他）

矩阵 shape

最小数字例子（三步变化）

① 缩放后的分数：

② 加 mask 后（上三角变 $-\infty$）：

③ softmax 后：

验算第 2 行：$e^{0.707} = 2.028$，$e^{0.707} = 2.028$，未来是 0；归一化得 $[0.5, 0.5, 0]$ ✅

含义：token 1 只能看自己（权重 1.0），token 2 只能看 token1/2，token 3 可以看全部三个。

Decoder 自注意力 vs Encoder 自注意力

S = 4
mask = torch.triu(torch.ones(S, S), diagonal=1).bool()   # 上三角（不含对角线）
scores = scores.masked_fill(mask, float("-inf"))
attn = torch.softmax(scores, dim=-1)

# 内置写法：
# F.scaled_dot_product_attention(q, k, v, is_causal=True)
# nn.MultiheadAttention(..., is_causal=True)

7.18 Cross-Attention ★

公式

逐项拆解

注意：分数矩阵不再是方阵——行数是 Decoder 长度，列数是 Encoder 长度。

矩阵 shape

数字算例（seq2seq 翻译）

Encoder 输入 I love you，Decoder 正在生成 我 爱 你：

生成「爱」时，权重集中在 love（0.90）——这就是模型学到的词对齐。输出 = $0.05 V_I + 0.90 V_{love} + 0.05 V_{you}$。

seq2seq 里的 Attention 是怎么来的

在 Transformer 之前，seq2seq 用 RNN 做编码器和解码器，问题是「编码器把整句压成一个固定向量」，长句信息丢失。Bahdanau 等人提出：让解码器每生成一个词时，回头查看编码器的所有位置并加权取信息——这就是最早的 Attention。Transformer 把它推广成多头、可并行的 Cross-Attention。

cross_attn = nn.MultiheadAttention(embed_dim=512, num_heads=8, batch_first=True)

dec = torch.randn(2, 5, 512)    # Decoder 状态 [B, S_dec, d]
enc = torch.randn(2, 9, 512)    # Encoder 输出 [B, S_enc, d]

out, attn = cross_attn(query=dec, key=enc, value=enc)
print(out.shape)                # [2, 5, 512] —— 长度跟随 Decoder
print(attn.shape)               # [2, 5, 9]   —— 非方阵

7.19 残差连接（含 mask 泄露问题）★

公式

逐项拆解

数字算例

假设每层的「子层梯度因子」是 0.7：

无残差时 24 层后梯度几乎为 0；有残差时始终有 1 打底——这就是「梯度高速公路」。

解码端残差会不会泄露被 mask 的未来信息？（面试高频）

7.20 LayerNorm（为什么不用 BatchNorm）★

公式

逐项拆解

数字算例（x = [1, 2, 3, 4]）

为什么 Transformer 用 LN 不用 BN

BatchNorm 及优缺点（面试常问）

做法：对一个 batch 内同一特征做标准化：$\hat x = \frac{x - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}$，再乘 γ 加 β。

LayerNorm 在 Transformer 的位置

Post-Norm（原始）：x → Attention → Add → Norm
Pre-Norm（现代）：x → Norm → Attention → Add

Pre-Norm 的残差路径无归一化，梯度更容易传回浅层（见第 10 章）。

ln = nn.LayerNorm(normalized_shape=512)   # 对最后一维做归一化
x = torch.randn(2, 10, 512)               # [B, S, d]
y = ln(x)                                 # 形状不变