Interactive Learning / attention-mechanisms / Flash MHA 交互讲解
Flash Multi-Head Attention · 交互式深度讲解
从内存层级讲到 online softmax 推导,再到完整 tiling 算法的逐步演示。
基础概念 — 为什么需要 Flash Attention?
要理解 Flash Attention 之前,必须先看清两件事:
① GPU 的内存层级是非对称的(快的地方很小,大的地方很慢),
② 标准 attention 把绝大部分时间花在了"搬数据"上而不是"算数据"上。
这两件事拼起来,就是 Flash Attention 的全部动机。
GPU 内存层级 · 点击各层看细节
关键直觉:SRAM 的带宽是 HBM 的约 10 倍。也就是说,数据放在 SRAM 上计算的速度,比"把它从 HBM 搬过来"快一个数量级。
SRAM (片上共享内存)
每个 SM (Streaming Multiprocessor) 各有一份。L1 缓存 + 共享内存。
容量 ~20 MB
带宽 ~19 TB/s
延迟 ~1 周期
L2 缓存
整个 GPU 共享。介于 SRAM 和 HBM 之间的中间层。
容量 ~50 MB
带宽 ~7 TB/s
延迟 ~200 周期
HBM (显存)
你平时说的"24G 显存"就是这里。模型权重、KV cache、激活值都住在这。
容量 40-80 GB
带宽 ~2 TB/s
延迟 ~400 周期
类比
HBM 是你家书房(书很多,但每次取书都要走过去)。SRAM 是你手边的书桌(放不下几本但伸手就够到)。问题是:很多算法都在"反复跑去书房拿同一本书"。
标准 Attention 的内存灾难
计算 O = softmax(QKᵀ)V 时,标准实现会把 整个 n×n 的 S 矩阵和 P 矩阵写到 HBM 再读回来。当 n=128k 时,这是几十 GB 的数据在最慢的那条路上来回搬运。
🐢 标准 Attention · 内存操作
R从 HBM 读 Q, K (n×d each)
∗计算 S = Q·Kᵀ (n×n)
W把 S 写回 HBM (n² 个数!)
R再从 HBM 读 S
∗计算 P = softmax(S)
W把 P 写回 HBM (n² 个数!)
R再读 P 和 V
∗计算 O = P·V
W把 O 写回 HBM
—HBM 读写量 (个数)
—计算量 (FLOPs)
⚡ Flash Attention · 内存操作
R每次只读一个 Q tile (B_r×d)
R每次只读一个 K, V tile (B_c×d)
∗在 SRAM 中算 S_ij (B_r×B_c)
∗在 SRAM 中更新 m, ℓ, O 累积量
∗循环所有 K/V tile (S 永远不出 SRAM)
W最后才把 O 写回 HBM (一次)
—HBM 读写量 (个数)
—计算量 (FLOPs)
核心洞察
标准 Attention 的 HBM 操作量是 O(n²)(要写整个 S 和 P)。
Flash Attention 的 HBM 操作量是 O(n²·d / SRAM 大小),比标准少一个 d 因子左右——也就是 d=64 时大约快 10×。
计算量两者完全相同(同样的 O(n²d) FLOPs),但 attention 是 memory-bound,所以省 IO 就直接等于省时间。
FlashAttention 的两个核心招式
- Tiling(分块)—把整个矩阵切成小块,每次只搬一块到 SRAM,让 Sij、Pij 这些中间产物只活在 SRAM 里、不写回 HBM。
- Online Softmax(在线 softmax)—softmax 要除以整行总和,本来需要"看完整行才能算";online softmax 让我们能"边走边记",下一节我们来推导这件事到底怎么做到的。
公式推导 — Online Softmax 的数学
softmax 本来要求"看完整行才能算"(因为分母是全部 exp 的和)。这一节我们一步步推导:
如何在只看到部分数据的情况下,正确地把已经算的部分"修正"成最终答案。
最后会证明:online 算法的结果 和标准 softmax 完全相等,不是近似。
2.1 标准 softmax 与数值稳定版本
softmax 的定义很简单:
softmax(x)i = exp(xi) / Σj exp(xj)
但 ex 在 x 稍大时就会溢出:x=100 时 ex ≈ 1043,float32 装不下。标准做法是先减去最大值 m = max(x):
softmax(x)i = exp(xi − m) / Σj exp(xj − m)
数学上完全等价(分子分母同乘 e−m),但所有指数项都 ≤ 1,永不溢出。
2.2 分块带来的问题:不知道全局 max
稳定 softmax 需要 全局的 max。但 Flash Attention 一次只看一个 tile——看到第一个 tile 时根本不知道后面 tile 里有没有更大的值。
怎么办?答案是:先用当前已看到的 max 算一个"临时版本",等下一个 tile 带来更大的 max 时,把之前算的部分按比例 修正。
2.3 Online Softmax 的核心更新公式
假设我们把整行 x 切成两段:x = [x(1), x(2)]。我们想要算 softmax(x),但 只能一段一段处理。
第 1 步:处理 x⁽¹⁾,得到局部统计量
m₁ = max(x⁽¹⁾)
ℓ₁ = Σ exp(x⁽¹⁾ − m₁)
现在我们手上有 局部 的 max 和 softmax 分母。如果不再有数据,softmax = exp(x⁽¹⁾ − m₁) / ℓ₁ 就是最终答案。
第 2 步:x⁽²⁾ 来了,看看新的全局 max
m₂ = max(m₁, max(x⁽²⁾)) # 新的全局 max
如果 m₂ > m₁,旧的 ℓ₁ 就"不对了"——它是按 m₁ 算的,但现在 max 变成了 m₂。我们要修正它。
第 3 步:修正旧的 ℓ₁ + 加入新的贡献
ℓ₂ = exp(m₁ − m₂) · ℓ₁ + Σ exp(x⁽²⁾ − m₂)
↑ 这就是"修正因子"
推导:原来 ℓ₁ = Σ exp(x⁽¹⁾ − m₁);想要的是 Σ exp(x⁽¹⁾ − m₂) = Σ exp(x⁽¹⁾ − m₁) · exp(m₁ − m₂) = ℓ₁ · exp(m₁ − m₂)。
因为 m₂ ≥ m₁,exp(m₁−m₂) ≤ 1,旧的贡献被"压扁"。
关键洞察
每次 max 变大,所有"用旧 max 算出来的累积值"都必须乘 exp(m_old − m_new)。
这个因子 ≤ 1,相当于把旧的贡献"按比例缩小",让它和新数据用同一个 max 对齐。
2.4 交互演示 · 看 online softmax 一步步收敛到标准答案
在线 softmax 增量计算
3
数据流(虚线=未见,实线=已见,闪烁=当前处理)
| 步骤 |
当前 max (m) |
当前分母 (ℓ) |
修正因子 |
新贡献 Σexp |
2.5 把 V 也加进来:完整的在线 attention
到目前为止我们只算了 softmax。但 attention 还要乘 V:O = softmax(S) · V。
好消息是,同一套修正机制原样适用。
完整在线 attention 更新(一次处理一个 K/V tile j)
# 1. 当前 tile 的局部统计
Sij = Qi · KjT # shape: B_r × B_c
m̃j = rowmax(Sij) # 当前 tile 每行的 max
P̃ij = exp(Sij − m̃j) # 未归一化概率
# 2. 用新的局部 max 更新全局 m
mnew = max(mold, m̃j)
# 3. 修正因子(每行一个标量)
α = exp(mold − mnew) # 旧累积量的缩放
β = exp(m̃j − mnew) # 当前 tile 的缩放
# 4. 同步更新 ℓ 和 O
ℓnew = α · ℓold + β · rowsum(P̃ij)
Onew = α · Oold + β · P̃ij · Vj
# 5. 最后一个 tile 处理完之后
O = O / ℓ # 唯一的归一化
为什么这是精确而非近似
每次更新都保持一个不变量:
当前的 (m, ℓ, O) 等于"如果这就是全部数据" 时标准 softmax-attention 应该得到的结果。
最后一个 tile 处理完时,"全部数据"就真的是全部了,所以 O/ℓ 就是标准答案。误差为 0。
▸ 一段简洁的代数证明(可选展开)
设全部数据为 x = [x⁽¹⁾, x⁽²⁾],标准答案:
oi = exp(xi − m*) / ℓ* where m* = max(x), ℓ* = Σ exp(x − m*)
在线算法处理完两块后:
m = max(m₁, m₂') = m* (m₂' = max(x⁽²⁾))
ℓ = exp(m₁−m) · Σ exp(x⁽¹⁾−m₁) + exp(m₂'−m) · Σ exp(x⁽²⁾−m₂')
= Σ exp(x⁽¹⁾−m) + Σ exp(x⁽²⁾−m)
= ℓ*
最后一步是因为 exp(a−b)·exp(b−c) = exp(a−c)。同样的代数对 O 也成立。QED.
实际例子 — 完整算法分步演示
现在我们用一个具体的小例子(n=8, d=4, tile=4×4)跑完整个 Flash Attention。
每一步都能看到 SRAM 里到底装了什么、m/ℓ/O 怎么变、HBM 计数器怎么涨。
用 ← → 翻页,或者点下面的小方块跳到任意步骤。
0 / 0
内存层级 · 实时状态
SRAM · 快但小(内部数据从不写回 HBM)~19 TB/s
多头扩展 — Flash MHA
"Flash MHA" 里的 MHA = Multi-Head Attention。多头是怎么和 Flash 协作的?
答案出奇地简单:每个 head 独立跑一遍 Flash Attention,并行执行,没有任何特殊处理。
所以理解了单头 Flash Attention,就理解了 Flash MHA 的 99%。
4.1 MHA 的本质:H 个独立的 attention
多头注意力把 dmodel 维 token 切成 H 份,每份 d = dmodel/H 维,
每份各算一遍 attention,最后把 H 个 d 维输出拼回 dmodel 维。
d_model = H · d (e.g. 4096 = 32 · 128)
每个 head 有独立的 Q, K, V 权重矩阵,所以它们看到的是不同的 query/key/value 投影。
各 head 之间没有任何数据依赖,是 embarrassingly parallel。
4.2 Flash 视角下的并行
GPU 上的并行有三个层级,Flash Attention 同时利用三层:
- Batch 维 · Head 维并行—每个 (batch_i, head_j) 配对分一个 thread block(CUDA 里就是一个 SM 上的一个并行单元)。这两维之间完全独立。
- Q 行 tile 维并行(FlashAttention-2 引入)—同一个 head 内,不同的 Q tile 之间也没有依赖(外层循环是 Q tile)。
- K/V tile 维顺序—内层循环必须顺序,因为 m/ℓ/O 是串行累积的。FlashAttention-3 用了一些技巧把这部分也异步起来。
交互演示 · 多头并行
8
128
4.3 容易混淆的点
⚠
"Flash MHA" ≠ "Multi-Query Attention (MQA)" / "Grouped-Query Attention (GQA)"。
Flash 是怎么算的优化(内存层级 + tiling),MHA/MQA/GQA 是算什么的结构选择(K/V head 怎么共享)。
Flash 可以用在 MHA, MQA, GQA 任何一种结构上——它们正交。
⚠
FlashAttention 的"块大小 B_r, B_c"和"多头的 head 数 H"是两码事。
B_r/B_c 是序列维上的分块(一次看几个 token),H 是 hidden 维上的分块(同一个 token 算几遍)。
一句话总结
Flash MHA = "每个 (batch, head) 独立跑一个 Flash Attention kernel,H 个 kernel 在 GPU 上同时跑"。
多头不增加 Flash 算法本身的复杂度,只是增加了并行单元数。