Skip to content

自注意力机制与多头注意力

推导缩放点积注意力的方差证明、因果掩码与多头并行子空间机制。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是自注意力机制(Self-Attention)与多头注意力(MHA)?

自注意力(Self-Attention) 是大模型读懂上下文联系的核心引擎。句子里的每个词都会生成三个向量:查询 Q(我想找什么信息)、键 K(我身上有什么标签)、值 V(我实际携带的内容);每个词拿自己的 Q 去和全句所有词的 K 算匹配度,再按匹配度加权把对应的 V 汇总回来——比如读到“它很重”时,“它”就会把高权重投给前文的“箱子”。

多头注意力(MHA) 则是同时派出一组(如 32 或 64 个)独立的注意力头并行观察同一句话,有的头专门盯语法主谓、有的盯代词指代、有的盯标点结构,最后把多视角结论拼回一起。

01 问题从何而来:怎么让句子里的每个词按需“找帮手”? ​

读一句话时,人的大脑并不是平均对待每个字的。看到“小明把杯子放在桌上,因为它太烫了”,你的目光会瞬间从“它”跳回“杯子”,而自动忽略“放在”“桌上”。

在早期的循环网络(RNN)里,整句话的历史信息都被硬塞进一个固定长度的小向量里,就像把一整个行李箱的衣服压进一只巴掌大的真空袋——句子一长,关键细节全糊成一团。2014 年 Bahdanau 等人 ↗ 提出加性注意力缓解了翻译对齐问题,但计算需要构造三维广播张量,GPU 算起来非常吃力。

2017 年 Transformer 论文 ↗ 干脆把“注意力”变成序列内部的标配算子——缩放点积自注意力与多头注意力(MHA),直接用矩阵乘法让句子里所有词元互相检索、各取所需。

类比 · 图书馆里的“软性查书”

传统的编程语言字典是“硬匹配”:键名完全一致才返回值,差一个字母就报错。自注意力则像一个极其聪明的软性图书馆检索系统,每个词元同时身兼三职:

  • Query(查询 Q):你手里举着的检索纸条——“我现在缺什么线索?”(比如“它”正在找一个“能发烫的名词”)。
  • Key(键 K):书架上每本书的索引标签——“我属于什么类型?”(比如“杯子”贴着“容器/物体”标签)。
  • Value(值 V):书本里装的真正正文内容——“我能给你的具体语义载荷”。

把你的检索条 Q 和全馆所有标签 K 一一比对相似度,再通过 Softmax 变成加起来等于 100% 的关注比例(例如 85% 看“杯子”、10% 看“桌面”、5% 看其他词),最后按这个比例把各本书的正文 V 打包搬回自己桌上。

核心设问

直接拿 Q 和 K 做点积再过 Softmax 听起来很简单,但为什么非要多除以一个 dk?又为什么不直接算一套大注意力,非要费事拆成几十个“多头”并行去算?

02 核心直觉:为什么要除以 dk,为什么要拆“多头”? ​

这两个看似细节的设计,其实是自注意力能否训得动、学得深的命门。

类比 · 调音台防爆音:为什么要除以 $\sqrt{d_k}$?

想象你往一个杯子里倒 dk 勺随机温度的水(点积 ∑i=1dkqiki 就是把 dk 对随机数相乘再累加)。如果维度 dk=128,累加结果的波动幅度(标准差)会膨胀成原来的 128≈11.3 倍!

Softmax 函数对大数值极其敏感:输入是 [1, 2] 时,输出概率是温和的 [27%, 73%];一旦膨胀 11 倍变成 [11, 22],输出瞬间极端化为 [0.002%, 99.998%]。概率一旦变成非黑即白的 0 和 1,反向传播的梯度就几乎全变成了 0(Softmax 饱和),模型直接学不动。除以 dk 就像给音响加了一级标准衰减,把点积的波动稳稳压回方差为 1 的舒适区。

类比 · 侦探小组分工:为什么要拆成“多头(Multi-Head)”?

如果整层只有一个注意力头,它就像一名分身乏术的单干侦探:看到“它”时,既要确认语法主语、又要追溯指代对象、还要感受整句的语气情感,最后被迫把所有注意力平均摊薄,谁也没看清。

多头注意力直接把高维空间切成 H 个独立的子空间(比如 32 个 128 维小头),相当于组建了一支 32 人的专业侦探团:1 号头专盯主谓搭配,2 号头专追代词指代,3 号头专找前文出现过的代码变量名,4 号头专盯相邻标点。大家各查各的,最后把情报拼在一起经 WO 汇总写回 残差流。

而在自回归生成模型中,为了防止第 5 个词在训练时偷看第 6 个词的答案,还会叠加一张上三角全是 −∞ 的因果掩码(Causal Mask)——过完指数函数 e−∞=0,未来的词就被彻底“拉上黑帘子”挡住了。

03 把关键公式读成人话 ​

自注意力最著名的核心公式只有短短一行:

Attention(Q,K,V)=softmax(QK⊤dk+M)V

**把公式读成直觉:**按从里到外的顺序读,它就是四步标准动作:

  1. QK⊤:所有词元的“检索条”和“索引标签”两两碰头算匹配分,得到一张 N×N 的全员关联打分表。
  2. /dk:给打分表降温消肿,防止高维点积把分值拉爆导致梯度消失。
  3. +M 再 softmax:用掩码 M 把不该看的未来词(和填充词 <pad>)打成负无穷屏蔽掉,再把每一行归一成总和为 1 的百分比关注权重。
  4. ×V:按刚算出的关注比例,把对应词元的正文载荷 V 加权搬运过来,合成新的上下文表征。

把多头注意力按头拆开写成求和形式,还能看到可解释性研究中最著名的双电路分解(Transformer Circuits, 2021 ↗):

MHA(X)=∑h=1HA(h)X(WV(h)WO(h))

**QK 电路与 OV 电路的分工:**每个头实际上干着两件解耦的事:WQ(h)(WK(h))⊤ 组成 QK 电路,决定“把聚光灯打在谁身上”(算出权重矩阵 A(h));WV(h)WO(h) 组成 OV 电路,决定“把被照亮词元的哪些信息、以什么格式搬运回主干”。

04 它在模型里怎么工作 & 与上下游的关系 ​

在现代 Transformer 块里,自注意力绝不是孤立存在的,它前后左右紧贴着一整套协同优化生态:

  • 位置注入:纯点积本身不认识先后顺序,必须在 Q,K 投影后立即施加 RoPE 旋转位置编码(详见 位置编码演进)。
  • 稳训护栏:在百亿级以上大模型中,常在 RoPE 之前给 Q,K 套上 QK-Norm,从根源上锁死注意力分数上界,防止训练中后期爆发 Loss Spike。
  • 速度与显存突破:标准 MHA 最大的痛点是 O(N2) 复杂度与庞大的历史缓存。工程端用 FlashAttention(Dao, 2023)↗(详见 FlashAttention 词条)分块消除 N2 显存占用,用 KV Cache 避免解码期重复算历史键值;架构端则衍生出压缩 KV 的 MQA / GQA / MLA 以及彻底改写二次复杂度的 Mamba / SSM。

05 演化对比:序列交互机制怎么取舍? ​

同样是做序列信息交互,自注意力与经典及新兴机制的取舍一目了然:

序列交互机制计算复杂度并行训练任意两词路径长文本核心痛点
标准 MHAO(N2d)极强O(1)N2 显存物化 + 庞大 KV Cache
FlashAttentionO(N2d)极强O(1)显存降至 O(N),但超长序列算力仍为二次方
RNN / LSTMO(Nd2)不可并行O(N)训练慢且长距离梯度衰减
SSM / MambaO(NdNs)强(分块扫描)O(1) 隐状态定长状态容量有限,逐字回忆弱于全注意力

一个非常实用的经验法则:当序列长度 N<d 时,线性投影(WQ,WK,WV,WO)占算力大头;一旦上下文跨入 32K~128K(N≫d),两两成对的注意力矩阵计算就会反客为主,成为全网头号性能瓶颈。

06 三个最容易踩的工程坑 ​

  1. 手写 N×N 注意力矩阵极易 OOM:生产训练和推理务必调用 F.scaled_dot_product_attention 或 FlashAttention,千万别在长序列上把 [B, H, N, N] 的分数矩阵真正写进显存;单头维度通常固定选 128,正好贴合 GPU 片上 SRAM 的分块大小。
  2. Softmax 必须升回 FP32,且警惕全掩码行:半精度下指数运算极易溢出或下溢;一旦某一行所有位置都被掩码成 −∞,Softmax 会立刻算出 0 / 0 = NaN 污染整批梯度。
  3. 别把首词元 <bos> 随便剪掉(Attention Sink):Xiao 等人(2024)↗ 发现,Softmax 强制所有权重和为 1,当模型此刻“谁也不想看”时,会把多余注意力全部倾倒在开头的 <bos> 上当“垃圾桶”。做滑窗截断或量化时一旦丢掉首词元,生成质量会瞬间崩塌。

想查阅严格的方差恒为 1 数学证明、完整复杂度表以及支持 KV Cache 增量解码的 MultiHeadSelfAttention 代码?按快捷键 M 或点击顶部 技术 Wiki 随时切换。

缩放点积注意力(Scaled Dot-Product Attention) 与多头注意力(Multi-Head Attention, MHA) 是 Transformer 得以捕捉全局语义依赖的核心引擎。不同于固定权重的卷积核或串行推进的循环隐状态,自注意力允许序列中的每个词元根据当前上下文动态计算与其余所有词元的关联权重,从而实现内容寻址(Content-Based Addressing)与信息聚合;在现代大模型中,它常与 RoPE 旋转位置编码、GQA/MLA 压缩架构 以及 FlashAttention 协同工作。

直观理解

可以将注意力机制类比为一个 “软性哈希字典查询” 过程:每个词元同时扮演三种角色——Query(查询) 代表“我现在需要什么信息”,Key(键) 代表“我能提供什么类型的信息索引”,Value(值) 代表“我实际携带的内容载荷”。通过计算 Query 与所有 Key 的匹配度并用 Softmax 归一化为概率权重,模型便能按需加权提取所有相关词元的 Value。

问题动机与演进背景 ​

早期神经机器翻译中,Bahdanau 等人(2014)提出了加性注意力(Additive Attention),通过一个小前馈网络计算源端隐状态与目标端隐状态的对齐分数:score(q,k)=v⊤tanh⁡(Wqq+Wkk)。然而,加性注意力需要构造三维广播张量,难以直接转化为硬件高度优化的 GEMM(通用矩阵乘法)。

Luong 等人(2015)进一步推广了乘性/点积注意力(Dot-Product Attention)。到了 2017 年,Transformer 将这一机制完全“自化”(Self-Attention,即 Q,K,V 均源自同一序列的线性投影),并引入两项决定性设计:

  1. 1dk 缩放因子:解决高维向量点积方差膨胀导致的 Softmax 梯度消失问题。
  2. 多头并行投影(MHA):解决单一注意力分布过度平滑、无法同时关注语法结构、指代消解与长程语义等不同维度特征的问题。

核心原理与数学推导 ​

Scaled Dot-Product Attention 与缩放因子方差证明 ​

给定输入序列特征矩阵 X∈RN×d,通过三组投影矩阵 WQ,WK∈Rd×dk 与 WV∈Rd×dv 得到查询、键、值矩阵 Q=XWQ、K=XWK、V=XWV。缩放点积注意力定义为:

Attention(Q,K,V)=softmax(QK⊤dk+M)V

其中 M∈RN×N 为掩码矩阵(Mask)。

为什么必须除以 dk?(严格方差证明)

假设查询向量 q∈Rdk 与键向量 k∈Rdk 的各个分量相互独立,且均满足零均值、单位方差分布:

E[qi]=E[ki]=0,Var(qi)=Var(ki)=1,∀i∈{1,…,dk}

考虑未缩放点积 z=q⊤k=∑i=1dkqiki,其期望与方差为:

E[z]=∑i=1dkE[qi]E[ki]=0Var(z)=∑i=1dkVar(qiki)=∑i=1dk(E[qi2]E[ki2]−(E[qi]E[ki])2)=∑i=1dk(1⋅1−0)=dk

可见点积的标准差随维度以 dk 增长。当 dk 较大(如 64 或 128)时,注意力分数 z 会出现极大正值或极小负值。回顾 Softmax 对其输入 z 的雅可比矩阵:

∂pi∂zj=pi(δij−pj),pi=ezi∑mezm

一旦 z 方差过大,分布 p 会急剧坍缩为近似 One-Hot 向量(最大项 pi∗→1,其余 pj→0),导致雅可比矩阵几乎处处为零,反向传播陷入梯度消失(Softmax Saturation)。将点积除以 dk 后:

Var(q⊤kdk)=1dkVar(q⊤k)=1

由此保证了任意头维度下注意力得分方差恒为常数级别,稳定维持 Softmax 的有效梯度区。

因果掩码(Causal Mask) ​

在自回归语言模型中,位置 i 预测下一词元时严禁窥探未来位置 j>i 的信息。这通过在 Softmax 前叠加严格上三角负无穷掩码实现:

Mij={0,i≥j−∞,i<j

经过指数运算后,e−∞=0,确保注意力权重矩阵 A=softmax(QK⊤dk+M) 成为下三角行随机矩阵(每行非负且和为 1)。在批次内包含变长样本时,还需将填充词元(Padding Token,如 <pad>)对应列置为 −∞。

多头注意力(Multi-Head Attention, MHA) ​

若仅使用单组注意力权重,模型在同一层对所有特征通道只能采用同一套加权组合。MHA 将 d 维特征空间切分为 H 个独立的子空间(通常取 dk=dv=dh=d/H),并行执行 H 次缩放点积注意力:

headh=Attention(XWQ(h),XWK(h),XWV(h)),WQ(h),WK(h),WV(h)∈Rd×dh

随后将所有头的输出在特征维度拼接,并通过输出投影矩阵 WO∈Rd×d 跨头融合信息:

MHA(X)=Concat(head1,…,headH)WO

从代数角度看,令 WO=[WO(1);…;WO(H)] 按行分块,上式等价于各独立注意力头对残差流的加性贡献之和:

MHA(X)=∑h=1HheadhWO(h)=∑h=1HA(h)X(WV(h)WO(h))

其中 WQ(h)(WK(h))⊤ 构成QK 电路(决定“关注谁”),而 WV(h)WO(h) 构成OV 电路(决定“搬运什么信息”),这种视角成为可解释性研究的核心基石。

算法架构与数据流图 ​

图表加载中...

复杂度与横向对比表 ​

设序列长度为 N,隐藏维度为 d,头数为 H,卷积核宽为 k:

序列交互机制单层计算复杂度单层顺序操作步数任意两词元最大路径长度显存占用(标准实现)
Self-Attention (MHA)O(N2d+Nd2)O(1)O(1)O(HN2+Nd)
FlashAttention (MHA)O(N2d+Nd2)O(1)O(1)O(Nd)(无 N2 显存物化)
Recurrent (RNN/LSTM)O(Nd2)O(N)O(N)O(Nd)
Convolutional (1D-CNN)O(kNd2)O(1)O(logk⁡N) 或 O(N/k)O(Nd)
Linear Attention / SSMO(Nd2)O(1)(并行扫描)O(1)(隐状态压缩)O(Nd)

关键观察:当 N<d 时,线性投影项 O(Nd2) 主导算力;当 N≫d(如长文本 128K 场景),成对相似度项 O(N2d) 与标准实现下的 O(HN2) 显存占用成为核心瓶颈。

核心 PyTorch 参考实现 ​

以下代码手动实现了多头因果自注意力(含缩放点积、掩码与 KV Cache 推理接口),并与数值稳定的 Softmax 计算细节对齐:

python
import math
from typing import Optional, Tuple
import torch
import torch.nn as nn
import torch.nn.functional as F


class MultiHeadSelfAttention(nn.Module):
    def __init__(self, d_model: int, n_heads: int, dropout: float = 0.0):
        super().__init__()
        assert d_model % n_heads == 0, "d_model 必须能被 n_heads 整除"
        self.d_model = d_model
        self.n_heads = n_heads
        self.d_head = d_model // n_heads
        self.scale = 1.0 / math.sqrt(self.d_head)

        self.w_q = nn.Linear(d_model, d_model, bias=False)
        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.attn_dropout = nn.Dropout(dropout)

    def forward(
        self,
        x: torch.Tensor,
        kv_cache: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
        is_causal: bool = True,
    ) -> Tuple[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
        # x: [B, N_q, d_model]
        B, N_q, _ = x.shape

        # 1. 线性投影并拆分为多头: [B, H, N_q, d_head]
        q = self.w_q(x).view(B, N_q, self.n_heads, self.d_head).transpose(1, 2)
        k = self.w_k(x).view(B, N_q, self.n_heads, self.d_head).transpose(1, 2)
        v = self.w_v(x).view(B, N_q, self.n_heads, self.d_head).transpose(1, 2)

        # 2. 若处于自回归解码阶段,沿序列维度拼接历史 KV Cache
        if kv_cache is not None:
            k_prev, v_prev = kv_cache
            k = torch.cat([k_prev, k], dim=2)  # [B, H, N_kv, d_head]
            v = torch.cat([v_prev, v], dim=2)  # [B, H, N_kv, d_head]
        new_cache = (k, v)
        N_kv = k.size(2)

        # 3. 缩放点积计算注意力 logits: [B, H, N_q, N_kv]
        scores = torch.matmul(q, k.transpose(-2, -1)) * self.scale

        # 4. 构造因果掩码(支持预填充 N_q == N_kv 与增量解码 N_q < N_kv)
        if is_causal and N_q > 1:
            mask = torch.triu(
                torch.ones(N_q, N_kv, device=x.device, dtype=torch.bool),
                diagonal=N_kv - N_q + 1,
            )
            scores = scores.masked_fill(mask, float("-inf"))

        # 5. 在 FP32 下执行 Softmax 防止 BF16/FP16 下溢或精度损失
        attn_weights = F.softmax(scores, dim=-1, dtype=torch.float32).to(q.dtype)
        attn_weights = self.attn_dropout(attn_weights)

        # 6. 加权聚合 Value 并拼接多头: [B, N_q, d_model]
        out = torch.matmul(attn_weights, v)  # [B, H, N_q, d_head]
        out = out.transpose(1, 2).contiguous().view(B, N_q, self.d_model)
        return self.w_o(out), new_cache


if __name__ == "__main__":
    mha = MultiHeadSelfAttention(d_model=512, n_heads=8)
    # 模拟 Prefill 阶段 (N=16) 与 Decode 阶段 (N=1)
    x_prefill = torch.randn(2, 16, 512)
    y_prefill, cache = mha(x_prefill)
    x_decode = torch.randn(2, 1, 512)
    y_decode, cache = mha(x_decode, kv_cache=cache)
    print("Prefill out:", y_prefill.shape, "Decode out:", y_decode.shape)
    print("Cached K shape:", cache[0].shape)  # [2, 8, 17, 64]

工程实践与常见陷阱 ​

工程实践

  1. 单头维度 dh 的黄金选择:现代 LLM(如 LLaMA-3、Qwen2.5、GPT-3)普遍将 dh 固定为 128(小模型可取 64)。dh=128 恰好匹配 FlashAttention 在 Ampere/Hopper 架构上的共享内存(SRAM)Tile 大小,且比 dh=64 拥有更强的单头语义容量。
  2. 融合 QKV 线性投影:将独立的 w_q、w_k、w_v 合并为单个矩阵 w_qkv 进行一次大 GEMM,再通过 chunk 或 split 拆分,能显著减少 CUDA Kernel 启动开销并提升矩阵计算密度。
  3. 强制使用融合算子:在生产训练与推理中,切勿手写 torch.matmul 物化 [B,H,N,N] 的注意力矩阵,而应调用 F.scaled_dot_product_attention 或 FlashAttention 算子,以免 OOM 并获得 2×∼4× 的速度提升。

常见陷阱

  1. 低精度 Softmax 数值溢出与 NaN:当一整行掩码全为 −∞(例如某些极端 Padding 样本或错误构造的稀疏掩码)时,Softmax 会产生 0 / 0 = NaN。混合精度训练中务必将 Softmax 提升至 FP32 计算,并在自定义掩码时确保每行至少有一个有效非掩码位置。
  2. Attention Sink(注意力汇聚)现象:由于 Softmax 强制所有权重之和为 1,当当前词元无需关注任何语义上下文时,模型会将多余的注意力概率倾倒在序列首个词元(如 <bos>)上,导致首词元激活值异常巨大。这在量化和滑窗注意力设计中必须特殊保留。
  3. Attention Logits 爆炸(Entropy Collapse):训练后期部分头的 Q,K 范数持续增大,导致注意力分数绝对值飙升、分布过度尖锐并触发 Loss Spike。主流解法包括引入 QK-Norm 或 Logit Soft-Capping(如 Gemma-2 使用 t⋅tanh⁡(z/t));而在推理端则需结合 KV Cache 避免历史键值重算。

延伸阅读与参考论文 ​

  • 注意力起源:Bahdanau et al., Neural Machine Translation by Jointly Learning to Align and Translate, ICLR 2015 (arXiv:1409.0473 ↗).
  • Transformer 与 MHA 奠基:Vaswani et al., Attention Is All You Need, NeurIPS 2017 (arXiv:1706.03762 ↗).
  • 注意力电路可解释性:Elhage et al., A Mathematical Framework for Transformer Circuits, Transformer Circuits Thread ↗, 2021.
  • Attention Sink 现象剖析:Xiao et al., Efficient Streaming Language Models with Attention Sinks, ICLR 2024 (arXiv:2309.17453 ↗).
  • IO 感知注意力加速:Dao et al., FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning, ICLR 2024 (arXiv:2307.08691 ↗).