结论先行:注意力机制的本质是一次"软化的加权检索"——每个 token 拿自己的 Query 去和序列里所有 token 的 Key 算匹配度,再按匹配度对 Value 加权求和。理解了 Q、K、V 三个矩阵从哪来、怎么算,Transformer 的核心就通了;多头和掩码只是在这个骨架上加规则。同样要记住的是它的代价:注意力计算量随序列长度平方增长,这一条决定了后面长文本贵、上下文窗口贵的所有故事。

从一次数据库查询说起

后端工程师可以把它类比成一次特殊的表扫描:每行数据(token)都带一个索引字段(Key)和内容字段(Value),你的查询条件(Query)不是精确匹配,而是和每行的 Key 算一个相似度分数,然后按分数加权把所有行的内容捞回来——分数高的行贡献多,分数低的也留一点痕迹。这就是"注意力"这个名字的含义:模型自己学着把注意力放到相关的 token 上。

传统数据库是"命中一条返回一条",注意力是"全表扫一遍,按权重融合"。代价是计算量随序列长度平方增长,这一点决定了后面长文本贵、上下文窗口贵的所有故事。

再补一个和老架构的对比:RNN 是"顺着链条传话",第 100 个 token 想知道第 1 个 token 的内容,信息要经过 99 次中转,越传越淡;注意力让任意两个位置一步直达,任意距离的依赖都是一跳完成。这是 Transformer 能堆得很深、训练能全序列并行的根本原因,也是它能一统 LLM 的原因。

三步算出注意力

对一个长度为 n 的序列,每个 token 的向量先分别乘上三个可学习的投影矩阵 W_Q、W_K、W_V,得到三份向量。同一份原始向量戴上三顶不同的帽子:Q(Query)代表"我想找什么",K(Key)代表"我这里有什么可以被别人找到",V(Value)代表"一旦匹配上,我实际贡献的内容"。然后:

  1. 算相似度:Q 和 K 的转置做矩阵乘法,得到 n×n 的分数矩阵,第 i 行第 j 列表示第 i 个 token 对第 j 个 token 的关注度原始分;
  2. 缩放 + 归一化:分数除以 sqrt(d)(d 是向量维度),再过 softmax 变成每行和为 1 的权重分布;
  3. 加权求和:权重矩阵乘以 V,每个 token 得到一个融合了全序列信息的新向量。

注意这三步里没有任何非线性激活,注意力层的表达力来自"投影 + 加权平均"的堆叠——Transformer 每层里真正引入非线性的地方是注意力之后的 FFN(前馈网络)。这也是为什么模型参数大头在 FFN 而不在注意力投影上。

为什么要除以 sqrt(d)

维度越高,两个随机向量的点积方差越大,大分数进 softmax 后会趋近 one-hot,梯度几乎为零,训练就"冻住"了。粗算一下量级:d=128 时,随机向量点积的标准差在 10 以上,softmax 在这种分数下基本"赢者通吃";除以 sqrt(128)≈11.3,正好把分数拉回 softmax 的敏感区间。这一步纯属数值稳定性设计,没有玄学。

多头与因果掩码

多头注意力:把 Q、K、V 各拆成 h 份,每份独立做一遍上面的三步,结果拼接后再过一个输出投影矩阵。直觉上不同的头学不同的模式——有的头盯语法结构,有的头盯指代关系,有的头只看相邻词。相当于并行的多组检索策略,最后汇总。常见配置是 8 到上百个头,每个头的维度等于模型维度除以头数,单头虽窄,多路并行的总信息量不变。

因果掩码:GPT 这类生成式模型只允许每个 token 看它自己和左边的 token,右边的还没生成、必须遮住。实现上就是把分数矩阵右上三角置成负无穷,softmax 后对应权重为 0。这就是为什么模型生成时是"一个 token 一个 token 往外蹦"——它天然只能看历史。反过来,BERT 这类理解型模型是双向注意力,不加掩码,这是两类模型在架构上的关键区别之一。

代码:手写一个最小注意力

import numpy as np

np.random.seed(0)
seq_len, d = 5, 8
Q = np.random.randn(seq_len, d)
K = np.random.randn(seq_len, d)
V = np.random.randn(seq_len, d)

# 1. 相似度:Q 与 K 的点积
scores = Q @ K.T                                  # (n, n)

# 2. 缩放,防止 softmax 饱和
scores = scores / np.sqrt(d)

# 3. 因果掩码:右上三角置 -inf,禁止偷看未来
mask = np.triu(np.ones((seq_len, seq_len)), k=1)
scores = np.where(mask == 1, -np.inf, scores)

# 4. softmax(减最大值保证数值稳定)
scores = scores - scores.max(axis=-1, keepdims=True)
weights = np.exp(scores) / np.exp(scores).sum(axis=-1, keepdims=True)

# 5. 加权求和 Value
output = weights @ V
print(weights.round(2))  # 每行即一个 token 对全部 token 的注意力分布

跑一遍看 weights:第一行只有第一个位置非零——因果掩码生效的直观证据。

生产代码不要手写这些。下面是同一个计算的"错误写法 vs 正确写法"对比,生产框架里实际用的是内置算子:

# pip install torch
import torch
import torch.nn.functional as F

q = torch.randn(1, 4, 8)   # (batch, seq_len, head_dim)
k = torch.randn(1, 4, 8)
v = torch.randn(1, 4, 8)

# 错误写法:手写注意力,漏缩放或漏掩码都很难被 code review 发现
# scores = q @ k.transpose(-2, -1)          # 没除 sqrt(d):softmax 容易饱和,训练不稳
# weights = torch.softmax(scores, dim=-1)   # 没加因果掩码:生成模型偷看了未来
# out = weights @ v

# 正确写法:框架内置算子,缩放、掩码、内核融合一步到位
out = F.scaled_dot_product_attention(q, k, v, is_causal=True)
print(out.shape)  # torch.Size([1, 4, 8])

scaled_dot_product_attention 会自动选择最高效的底层实现,手写版本不仅容易写错,还一定更慢。

注意力的代价与工程优化

把代价量化一下:n 个 token 的注意力要算 n² 个分数对。上下文从 4K 涨到 128K,序列长度翻 32 倍,注意力计算量翻约 1024 倍。这就是为什么长上下文请求的首字延迟(TTFT)高、长 prompt 按输入 token 收的费用不便宜。第二笔账是 KV Cache:生成阶段每一步都要拿当前 token 和全部历史算注意力,历史的 K、V 必须缓存复用,显存占用随序列长度线性增长(下一篇文章专门算这笔账)。

围绕这两笔账,工程上有两条优化路线。第一条改模型结构,先通过一张表建立直觉:

变体结构KV Cache 占用代表模型
MHA(多头注意力)Q 与 KV 头数相同基准(最大)原始 Transformer、BERT 类
MQA(多查询注意力)Q 多头,KV 全局共享一份约降为 1/头数PaLM 等早期大模型
GQA(分组查询注意力)Q 多头,KV 分组共享介于 MHA 与 MQA 之间Llama 3、Qwen 系列等
MLA(多头潜在注意力)KV 压缩为低秩潜向量大幅压缩DeepSeek-V2/V3

第二条路线是 FlashAttention:不改数学结果,只改计算顺序——利用 GPU 显存分层,让注意力分块在高速缓存里完成,避免把巨大的中间分数矩阵写回显存。效果是同等显存下能处理更长序列、速度明显提升,主流推理框架默认开启。

选模型和推理框架时,这两个维度值得专门确认:KV 头数决定单位显存能开多大并发,是否启用 FlashAttention 级内核决定 prefill 快不快。调 RAG、长对话、prompt cache 时,脑子里有这张"分数矩阵"的图,很多现象立刻解释得通。下一篇讲 token 是什么,先把计费单位搞清楚。

实战场景

一个客服机器人的真实演化:上线时单轮问答,响应一直很快;改成多轮对话后,用户反馈"越聊越卡"。排查发现每轮请求都携带完整历史,第 20 轮时 prompt 已有一万多 token——prefill 的平方代价开始显形,首字延迟明显变长。修复分两步:一是把历史按轮次裁剪并做摘要压缩,控制每次请求的实际长度;二是让 system prompt 与历史排列保持前缀稳定,配合服务端前缀缓存复用已算过的部分(机制见本系列后面的 prompt cache 一文)。整个案例没有换模型,纯靠理解注意力的两笔账把体验救了回来——“越聊越慢"这类问题,几乎都能从这里找到根因。