Transformer 自注意力机制

举报
yd_292659020 发表于 2026/11/19 00:21:55 2026/11/19
【摘要】 从矩阵乘法到并行计算:彻底拆解 Transformer 自注意力机制本文不讲"注意力是什么",而是拆解它在工程上到底怎么算、为什么这么算、以及哪些细节决定了它能不能跑起来。 1. 问题起点:为什么需要注意力机制在 Transformer 出现之前,序列建模主要靠 RNN/LSTM。RNN 的致命问题有两个:时间步串行:第 t 步的计算依赖第 t-1 步的隐状态,无法在时间维度上并行,训练速...

从矩阵乘法到并行计算:彻底拆解 Transformer 自注意力机制

本文不讲"注意力是什么",而是拆解它在工程上到底怎么算、为什么这么算、以及哪些细节决定了它能不能跑起来。

1. 问题起点:为什么需要注意力机制

在 Transformer 出现之前,序列建模主要靠 RNN/LSTM。RNN 的致命问题有两个:

  1. 时间步串行:第 t 步的计算依赖第 t-1 步的隐状态,无法在时间维度上并行,训练速度被序列长度卡死。
  2. 长距离衰减:梯度沿时间步反向传播时,经过多次激活函数导数连乘,信号指数级衰减。LSTM 用门控缓解了这个问题,但没消除。

注意力机制的思路是:抛弃时间步的递归依赖,让序列中任意两个位置直接交互,计算复杂度从"路径长度"变成"全连接图的一跳"。代价是计算量从 O(n) 变成 O(n²),但换来的是完全可并行——GPU 最擅长批量矩阵乘法。

2. 数学定义:从直觉到公式

2.1 最朴素的注意力

给定一个查询向量 qq 和一组键值对 (k1,v1),(k2,v2),…,(kn,vn)(k_1, v_1), (k_2, v_2), \ldots, (k_n, v_n),注意力的输出是值的加权和:

Attention(q,K,V)=∑i=1nexp⁡(q⋅ki)∑j=1nexp⁡(q⋅kj)vi\text{Attention}(q, K, V) = \sum_{i=1}^{n} \frac{\exp(q \cdot k_i)}{\sum_{j=1}^{n} \exp(q \cdot k_j)} v_i

这就是 softmax 加权求和。q⋅kiq \cdot k_i 是点积,衡量 query 和 key i 的相似度。softmax 把相似度归一化为概率分布,再对 value 加权求和。

2.2 为什么用点积而不是欧氏距离

点积注意力 q⋅kq \cdot k 和加性注意力 tanh⁡(Wqq+Wkk)\tanh(W_q q + W_k k) 都能用。但点积有两个工程优势:

  • 可以写成矩阵乘法:QKTQ K^T 一次 GEMM 搞定,GPU 上走 Tensor Core,速度比逐元素算 tanh⁡\tanh 快一个数量级。
  • 在高维空间中天然区分度更大:两个 512 维向量如果各分量独立同分布,点积的方差是 dd 倍单分量方差,维度越高区分度越强。

但点积有个副作用:维度 dd 越大,q⋅kq \cdot k 的数值越大,softmax 会进入梯度饱和区(最大值对应的概率趋近 1,其余趋近 0,梯度几乎为零)。

2.3 缩放点积注意力

Transformer 的解法是除以 dk\sqrt{d_k}:

Attention(Q,K,V)=softmax(QKTdk)V\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V

为什么是 dk\sqrt{d_k} 而不是 dkd_k?假设 qq 和 kk 的各分量服从均值为 0、方差为 1 的独立分布,则点积 q⋅k=∑i=1dkqikiq \cdot k = \sum_{i=1}^{d_k} q_i k_i 的均值为 0、方差为 dkd_k。除以 dk\sqrt{d_k} 后方差变为 1,把数值拉回标准正态的尺度,softmax 的梯度就不会饱和。

这个缩放因子看似不起眼,但在 dk=64d_k = 64 的模型中,不除它会直接导致训练发散。

3. 多头注意力:为什么要"多头"

单头注意力只有一个 Q,K,VQ, K, V 投影,模型只能学到一种注意力模式。但语言中的依赖关系是多层面的:一个词可能同时关注语法主语、语义角色、指代关系等。

多头注意力的做法是:把 Q,K,VQ, K, V 投影到 hh 个不同的子空间,各自做注意力,再拼接回来:

MultiHead(Q,K,V)=Concat(head1,…,headh)WO\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h) W^O

headi=Attention(QWiQ,KWiK,VWiV)\text{head}_i = \text{Attention}(Q W_i^Q, K W_i^K, V W_i^V)

一个关键工程细节:每个头的维度是 dmodel/hd_{model} / h,不是 dmodeld_{model}。比如 dmodel=512d_{model} = 512,h=8h = 8,每个头的 dk=64d_k = 64。这样多头注意力的总计算量和单头几乎相同,但模型容量更大——用同样的 FLOPS 换来了更丰富的表示。

拼接后的 WOW^O 是一个 dmodel×dmodeld_{model} \times d_{model} 的矩阵,把 hh 个子空间的信息重新混合回原空间。

4. 工程实现:从公式到代码的四个坑

4.1 坑一:因果掩码的实现

在自回归生成(GPT 类模型)中,位置 tt 不能看到位置 t+1t+1 及之后的信息。实现方式是在 QKTQ K^T 矩阵上加一个上三角掩码:

# scores: (batch, heads, seq_len, seq_len)
mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1).bool()
scores = scores.masked_fill(mask, float('-inf'))
attn = torch.softmax(scores, dim=-1)

为什么填 −∞-\infty 而不是 0?因为 softmax 是 exp⁡(⋅)\exp(\cdot) 加归一化,exp⁡(−∞)=0\exp(-\infty) = 0,被掩码位置的权重精确为 0。如果填 0,exp⁡(0)=1\exp(0) = 1,掩码位置仍然会分到权重,信息泄露。

4.2 坑二:数值稳定的 softmax

直接算 exp⁡(xi)\exp(x_i) 会溢出。标准做法是减去最大值:

softmax(xi)=exp⁡(xi−max⁡(x))∑jexp⁡(xj−max⁡(x))\text{softmax}(x_i) = \frac{\exp(x_i - \max(x))}{\sum_j \exp(x_j - \max(x))}

数学上完全等价,但数值上所有指数的输入都 ≤0\leq 0,不会溢出。PyTorch 的 torch.softmax 内部就是这么做的,但如果自己手写 kernel(比如 FlashAttention),这一步必须显式处理。

4.3 坑三:padding 掩码与因果掩码的叠加

在批量训练时,序列长度不一,短的用 padding 补齐。padding 位置不应该参与注意力计算。padding 掩码和因果掩码需要叠加:

# causal_mask: (1, 1, seq_len, seq_len) 上三角为 True
# padding_mask: (batch, 1, 1, seq_len) padding 位置为 True
combined_mask = causal_mask | padding_mask
scores = scores.masked_fill(combined_mask, float('-inf'))

注意这里用逻辑或(|)而不是相加——一个位置只要被任一掩码标记就应该被屏蔽。

4.4 坑四:KV Cache 的内存布局

在推理阶段,每生成一个 token,QQ 只有 1 行,但 KK 和 VV 会越来越长。如果每步都重算所有历史 token 的 K,VK, V,计算量是 O(n2)O(n^2)。

KV Cache 的思路是:把历史 token 的 K,VK, V 缓存下来,每步只算新 token 的 k,vk, v 并拼到缓存末尾。这样每步的计算量降为 O(n)O(n)。

但这里有个内存布局陷阱:如果 KV Cache 用 (seq_len, d_k) 的连续内存,每次拼接新 token 需要重新分配和拷贝。高效实现用预分配的 (max_seq_len, d_k) 张量,维护一个 kv_len 指针,新 token 写入对应位置,指针加 1。零拷贝,零分配。

5. FlashAttention:用数学等价换内存带宽

标准注意力的中间矩阵 QKTQ K^T 大小是 O(n2)O(n^2),序列长度 8K 时一个头就要 256MB 的显存。这个中间矩阵要写回 HBM(显存)再读出来做 softmax,再写回去乘 VV——内存读写量是 O(n2)O(n^2),而计算量也是 O(n2)O(n^2),算术强度(计算/访存比)极低,GPU 的计算单元大量空转等数据。

FlashAttention 的核心思想是分块计算(tiling),把 Q,K,VQ, K, V 分成小块,每块小到能放进 SRAM(片上缓存),在片上完成完整的 softmax + 乘法,只把最终结果写回 HBM。

难点在于 softmax 需要全局归一化——分块后每块只看到部分 KK,无法直接算全局 softmax。FlashAttention 用了在线 softmax(online softmax)技巧:

对于分块后的局部最大值 m(i)m^{(i)} 和局部求和 l(i)l^{(i)},全局最大值和求和的递推关系为:

mnew=max⁡(m(i),mold)m_{\text{new}} = \max(m^{(i)}, m_{\text{old}})

lnew=emold−mnewlold+em(i)−mnewl(i)l_{\text{new}} = e^{m_{\text{old}} - m_{\text{new}}} l_{\text{old}} + e^{m^{(i)} - m_{\text{new}}} l^{(i)}

Onew=emold−mnewloldOold+em(i)−mnewl(i)O(i)lnewO_{\text{new}} = \frac{e^{m_{\text{old}} - m_{\text{new}}} l_{\text{old}} O_{\text{old}} + e^{m^{(i)} - m_{\text{new}}} l^{(i)} O^{(i)}}{l_{\text{new}}}

每处理一个 KK 块,就用上述递推更新全局统计量。最终结果与标准注意力数学上完全等价,但中间矩阵 QKTQ K^T 从不落盘 HBM,访存量从 O(n2)O(n^2) 降到 O(n2d/M)O(n^2 d / M)(MM 是 SRAM 大小)。

实测在 A100 上,序列长度 8K 的注意力计算,FlashAttention 比标准实现快 2-4 倍,且显存占用从 O(n2)O(n^2) 降到 O(n)O(n)。

6. 注意力矩阵的稀疏性:从 Dense 到 Sparse

标准注意力让每个位置和所有位置交互,但实际上注意力矩阵往往是稀疏的——大部分位置的注意力权重接近 0。

几种利用稀疏性的方案:

方案 每个位置关注的范围 复杂度 代表模型
全局注意力 所有位置 O(n²) GPT, BERT
滑窗注意力 前后 w 个位置 O(n·w) Longformer
稀疏注意力 固定间隔的若干位置 O(n·√n) Sparse Transformer
膨胀注意力 间隔为 r 的倍数的位置 O(n·d) Longformer
块状注意力 同块内全连 + 块间少量 O(n·√n) Big Bird

这些方案的核心权衡是:用多少全局信息换多少计算节省。纯滑窗模型在长文本上快但容易丢失全局语义,纯全局模型表达力强但跑不动长序列。实践中的混合方案(如 Longformer 的"部分 token 全局 + 其余滑窗")效果最好。

7. 旋转位置编码(RoPE):把位置信息编进注意力

原始 Transformer 用正弦位置编码加在输入上,但这种方式在注意力计算中会被打散——位置信息经过 WQ,WKW^Q, W^K 投影后不再是干净的相对位置关系。

RoPE 的思路更优雅:不把位置编码加在输入上,而是直接编进 qq 和 kk 的旋转中,使得 qm⋅knq_m \cdot k_n 的结果只依赖相对位置 m−nm - n。

具体做法是对 dd 维向量的每两个分量一组,施加角度为 mθim\theta_i 的 2D 旋转:

(q2iq2i+1)→(cos⁡(mθi)−sin⁡(mθi)sin⁡(mθi)cos⁡(mθi))(q2iq2i+1)\begin{pmatrix} q_{2i} \\ q_{2i+1} \end{pmatrix} \to \begin{pmatrix} \cos(m\theta_i) & -\sin(m\theta_i) \\ \sin(m\theta_i) & \cos(m\theta_i) \end{pmatrix} \begin{pmatrix} q_{2i} \\ q_{2i+1} \end{pmatrix}

其中 θi=10000−2i/d\theta_i = 10000^{-2i/d}。两个位置 m,nm, n 的 query-key 点积中,旋转角度的差恰好是 (m−n)θi(m-n)\theta_i,即相对位置。

RoPE 的工程优势:

  • 不引入额外参数:旋转矩阵是确定的,不需要学习。
  • 外推性好:训练时见过的最大位置是 LL,推理时可以超过 LL(配合 NTK-aware 缩放等技术)。
  • 实现简单:复数乘法或等价的实数矩阵乘法,几行代码搞定。
def apply_rope(x, positions, theta=10000.0):
    # x: (..., seq_len, d)
    d = x.shape[-1]
    half = d // 2
    freqs = 1.0 / (theta ** (torch.arange(0, half).float() / half))
    angles = positions[:, None] * freqs[None, :]  # (seq_len, half)
    cos, sin = torch.cos(angles), torch.sin(angles)
    x1, x2 = x[..., ::2], x[..., 1::2]
    x_rot = torch.stack([x1 * cos - x2 * sin, x1 * sin + x2 * cos], dim=-1)
    return x_rot.flatten(-2)

8. 一个容易被忽略的细节:注意力权重的熵

注意力权重的熵 H=−∑ipilog⁡piH = -\sum_i p_i \log p_i 衡量注意力是"集中"还是"分散"。

  • 熵很低:注意力集中在少数几个 token 上,类似于硬注意力。
  • 熵很高:注意力均匀分散,类似于均值池化。

训练初期,注意力权重的熵通常很高(接近均匀分布),因为 Q,KQ, K 还没学好,点积都差不多。随着训练推进,熵逐渐降低,注意力开始聚焦。

但如果熵降得太低(注意力坍缩到单个 token),模型会退化成只看一个位置的局部模型,丢失全局信息。一些工作通过在 softmax 温度上做文章(加一个可学习的温度参数)来控制熵的下降速度。

监控注意力权重的熵分布,是调试 Transformer 模型时一个很有用但很少被提及的手段。

9. 总结:注意力机制的三个本质

回过头来看,自注意力机制的本质可以概括为三点:

  1. 全连接图上的信息路由:每个位置根据 query-key 相似度决定从哪些位置"取"多少信息。这是对序列内关系的一种动态、可学习的建模。

  2. 可并行性换计算量:从 RNN 的 O(n) 串行计算变成 O(n²) 的全并行矩阵乘法。在 GPU 时代,这个交易极其划算——并行带来的吞吐提升远超计算量的增加。

  3. 表示能力的维度扩展:多头机制在不增加计算量的前提下,让模型在不同子空间中学习不同类型的依赖关系。这是用结构设计(而非堆参数)提升模型容量的经典案例。

理解了这三点,再看 GQA(分组查询注意力)、MLA(多头潜在注意力)等新变体,本质上都是在计算量、显存、表示能力这个三角中寻找新的平衡点。

【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。