Flash Attention

举报
yd_292659020 发表于 2026/11/14 00:20:02 2026/11/14
【摘要】 Flash Attention:从内存瓶颈到分块计算的注意力加速革命 一、为什么需要 Flash Attention?Transformer 的核心是 Self-Attention,其计算公式为:O=softmax(QKTd)VO = \text{softmax}\left(\frac{QK^T}{\sqrt{d}}\right) VO=softmax(d​QKT​)V其中 Q,K,V∈R...

Flash Attention:从内存瓶颈到分块计算的注意力加速革命

一、为什么需要 Flash Attention?

Transformer 的核心是 Self-Attention,其计算公式为:

O=softmax(QKTd)VO = \text{softmax}\left(\frac{QK^T}{\sqrt{d}}\right) V

其中 Q,K,V∈RN×dQ, K, V \in \mathbb{R}^{N \times d},NN 是序列长度,dd 是头维度。

朴素实现的计算复杂度是 O(N2d)O(N^2 d),这大家都知道。但真正拖慢 GPU 的往往不是 FLOPs,而是内存访问。

1.1 GPU 内存层级回顾

层级 带宽 容量
SRAM(片上共享内存) ~19 TB/s ~192 KB/SM
HBM(显存) ~1.5–2 TB/s 40–80 GB

关键矛盾:计算单元(Tensor Core)的吞吐远大于 HBM 带宽能喂数据的速度。如果每做一步中间计算都要写回 HBM 再读出来,大量时间浪费在搬运数据上。

1.2 朴素 Attention 的内存访问问题

朴素实现分三步:

S = Q @ K.T          # (N, N)  写入 HBM
P = softmax(S)       # (N, N)  读 S,写 P 到 HBM
O = P @ V            # (N, d)  读 P,写 O 到 HBM

中间矩阵 SS 和 PP 的形状是 N×NN \times N。当 N=8192N = 8192 时,单个头的 SS 矩阵占 8192×8192×4B=256MB8192 \times 8192 \times 4\text{B} = 256\text{MB},多头情况下轻松到 GB 级别。

总 HBM 读写量约为 O(N2+Nd)O(N^2 + Nd) 次。N2N^2 项就是瓶颈——计算只读一次 Q,K,VQ, K, V,但中间结果在 HBM 和 SRAM 之间来回搬运了多次。

Flash Attention 的核心思想:能不能不把 N×NN \times N 的中间矩阵写回 HBM,直接在 SRAM 里算完?


二、Flash Attention 的核心算法

2.1 关键障碍:Softmax 的全局性

Softmax 需要对整行求最大值和求和:

softmax(xi)=exi−m∑jexj−m,m=max⁡j(xj)\text{softmax}(x_i) = \frac{e^{x_i - m}}{\sum_j e^{x_j - m}}, \quad m = \max_j(x_j)

这意味着你不能只看一个子块就输出结果——后面块的元素可能改变当前块的最大值,从而改变所有已经算好的指数值。

这就是为什么朴素实现必须把整个 SS 矩阵物化到 HBM:它需要全局信息。

2.2 在线 Softmax(Online Softmax)

Flash Attention 的第一个数学突破是 在线 Softmax:允许你分块计算,并在看到新块时修正之前的结果。

假设把 KK 沿行方向分成 TcT_c 块,每块大小 BcB_c。对 QQ 的第 ii 行:

第一块 K[1]K_{[1]}(下标表示第 1 块的行范围):

m1=rowmax(S[1]),ℓ1=rowsum(eS[1]−m1),O1=eS[1]−m1⋅V[1]m_1 = \text{rowmax}(S_{[1]}), \quad \ell_1 = \text{rowsum}(e^{S_{[1]} - m_1}), \quad O_1 = e^{S_{[1]} - m_1} \cdot V_{[1]}

第二块 K[2]K_{[2]}:

m2=max⁡(m1, rowmax(S[2]))m_2 = \max(m_1,\ \text{rowmax}(S_{[2]}))

注意这里 m2m_2 可能比 m1m_1 大。此时之前算的 eS[1]−m1e^{S_{[1]} - m_1} 需要重新归一化到新的最大值:

ℓ2=em1−m2⋅ℓ1+rowsum(eS[2]−m2)\ell_2 = e^{m_1 - m_2} \cdot \ell_1 + \text{rowsum}(e^{S_{[2]} - m_2})

O2=em1−m2⋅O1+eS[2]−m2⋅V[2]O_2 = e^{m_1 - m_2} \cdot O_1 + e^{S_{[2]} - m_2} \cdot V_{[2]}

修正因子 em1−m2e^{m_1 - m_2} 就是把旧结果从以 m1m_1 为基准"平移"到以 m2m_2 为基准。

处理完所有块后:

O=OTcℓTcO = \frac{O_{T_c}}{\ell_{T_c}}

关键点:每处理一个新块,只需要维护三个标量/向量状态——mm(行最大值)、ℓ\ell(行求和)、OO(累积输出),不需要存储任何 N×NN \times N 矩阵。

2.3 分块(Tiling)策略

光有在线 Softmax 还不够,还需要让计算真正在 SRAM 里完成。Flash Attention 采用双层分块:

外层循环:把 Q 分成 T_r 块,每块 B_r 行
  内层循环:把 K, V 分成 T_c 块,每块 B_c 行
    在 SRAM 中计算 B_r × B_c 的子注意力
    用在线 Softmax 增量更新 m, ℓ, O
  写回 O 的 B_r 行到 HBM

分块大小的选择原则:让 Qi,Kj,VjQ_i, K_j, V_j 三个块加上中间的 Br×BcB_r \times B_c 矩阵恰好填满 SRAM。典型值 Br=128, Bc=128B_r = 128,\ B_c = 128(针对 A100 的 192KB 共享内存)。

2.4 完整伪代码

输入: Q, K, V ∈ R^{N×d}, 分块大小 B_r, B_c
输出: O ∈ R^{N×d}

将 Q 分为 T_r = ⌈N/B_r⌉ 块, K/V 分为 T_c = ⌈N/B_c⌉ 块

for i = 1 to T_r:
    将 Q_i 加载到 SRAM
    初始化 O_i = 0, ℓ_i = 0, m_i = -∞

    for j = 1 to T_c:
        将 K_j, V_j 加载到 SRAM

        # 在 SRAM 中计算子块注意力分数
        S_ij = Q_i @ K_j^T / √d          # (B_r, B_c)

        # 在线 Softmax 更新
        m_new = max(m_i, rowmax(S_ij))
        P_ij = exp(S_ij - m_new)          # (B_r, B_c)
        ℓ_new = exp(m_i - m_new) * ℓ_i + rowsum(P_ij)

        # 累积输出(注意修正因子)
        O_i = exp(m_i - m_new) * O_i + P_ij @ V_j

        m_i = m_new
        ℓ_i = ℓ_new

    # 最终归一化
    O_i = O_i / ℓ_i
    将 O_i 写回 HBM

三、为什么快:IO 复杂度分析

3.1 HBM 读写量对比

实现 HBM 读写量
朴素 Attention O(N2d+N2)O(N^2 d + N^2)
Flash Attention O(N2d2/M)O(N^2 d^2 / M)

其中 MM 是 SRAM 大小。

当 M>d2M > d^2 时(几乎总是成立,d=64d=64 时 d2=4096d^2=4096,SRAM 有几十 KB),Flash Attention 的 IO 量是 O(N2)O(N^2) 级别但常数远小于朴素实现,因为省掉了 N×NN \times N 中间矩阵的全部读写。

3.2 实测加速效果

以 GPT-2(序列长度 1024)和 长序列(8K–16K)为例:

  • 短序列(1K):加速约 2×——主要受益于减少 HBM 往返
  • 长序列(16K):加速约 3–4×——N2N^2 项占比更大,收益更显著
  • 内存峰值:从 O(N2)O(N^2) 降到 O(N)O(N),长序列场景下内存节省 10–20×

四、反向传播的精确计算

很多近似 Attention 方法(如 Linformer、Linear Attention)在前向传播中加速,但反向传播需要近似或重新物化中间矩阵,精度有损。

Flash Attention 的一个重要特性是精确(exact)——它不是近似算法,结果与朴素 Attention 在数学上完全一致(浮点误差范围内)。

4.1 反向传播的重计算策略

标准反向传播需要前向的中间矩阵 SS 和 PP 来计算梯度。Flash Attention 没有存这些矩阵,怎么办?

答案:重计算(Recomputation)。

前向传播时只存储 Oi,mi,ℓiO_i, m_i, \ell_i(都是 O(Nd)O(Nd) 级别)。反向传播时,按相同的分块策略重新计算 SijS_{ij} 和 PijP_{ij}。

直觉上重计算会慢一倍,但实际上:

  1. 前向传播本来就是 memory-bound(受限于 HBM 带宽),不是 compute-bound
  2. 重计算的数据已经在 SRAM 分块模式中,IO 模式完全一样
  3. 额外的 FLOPs 对 Tensor Core 来说几乎是"免费"的

实测开销增加约 25–33%,远小于翻倍,换来的是精确梯度和巨大的内存节省。

4.2 梯度公式

给定上游梯度 dOdO,需要计算 dQ,dK,dVdQ, dK, dV:

dV=PT⋅dOdV = P^T \cdot dO

dP=dO⋅VTdP = dO \cdot V^T

dS=P⋅(dP−rowsum(dP⊙P))(softmax 反向)dS = P \cdot (dP - \text{rowsum}(dP \odot P)) \quad \text{(softmax 反向)}

dQ=dS⋅K/d,dK=dST⋅Q/ddQ = dS \cdot K / \sqrt{d}, \quad dK = dS^T \cdot Q / \sqrt{d}

这些都可以用相同的分块策略在 SRAM 中完成,不需要物化 PP 或 SS。


五、Flash Attention v2 的改进

Flash Attention v1(2022)已经很好了,v2(2023)在此基础上做了三个关键优化:

5.1 减少非矩阵乘法运算

v1 中在线 Softmax 的 rescale 操作(乘以 emold−mnewe^{m_{old} - m_{new}})和 rowsum 等非 GEMM 运算占比不小。v2 通过重新排列计算顺序,减少了这些操作:

  • v1:每个内层块迭代做 2 次 rescale(对 OO 和 ℓ\ell)
  • v2:把 rescale 推迟到外层块结束时统一做,内层只做 1 次

5.2 交换循环顺序

v1 的循环结构是 外层遍历 K/V 块,内层遍历 Q 块。这样每个 Q 块需要被多次加载到 SRAM。

v2 改为 外层遍历 Q 块,内层遍历 K/V 块。这样每个 Q 块只加载一次,K/V 块在内层循环中加载——对 QQ 的 HBM 读写减少了 TcT_c 倍。

# v2 的循环结构
for i = 1 to T_r:          # 外层 Q
    for j = 1 to T_c:      # 内层 K, V
        ...

5.3 更好的并行性

v1 在 batch 和 head 维度做并行,序列长维度串行。长序列时 GPU 利用率不足。

v2 增加了序列维度的并行:把 QQ 的块分配到不同的 thread block 上,每个 block 独立处理若干 QQ 行。这使得即使 batch=1、head 数不多时也能充分利用 GPU 上的所有 SM。

综合效果:v2 相比 v1 再快约 2×,相比朴素 Attention 快约 5–7×。


六、工程实现细节

6.1 CUDA Kernel 结构

Flash Attention 的 CUDA 实现中,一个 thread block 处理一个 QQ 块(BrB_r 行):

grid:  (T_r, num_heads, batch_size)
block: (num_threads,)  // 通常 128 或 256 个线程

每个 thread block 的执行流程:

  1. 分配 SRAM:Q_tile[B_r][d], K_tile[B_c][d], V_tile[B_c][d], S_tile[B_r][B_c]
  2. 加载 QQ 块到 SRAM(一次性,v2 的优势)
  3. 循环加载 K,VK, V 块,在 SRAM 中完成 GEMM → Softmax → GEMM
  4. 最终 rescale 并写回 OO 块

6.2 Warp 级优化

在 thread block 内部,Flash Attention v2 使用 warp partitioning:

  • 一个 block 有 4–8 个 warp(每个 warp 32 个线程)
  • 把 BrB_r 行分配给不同 warp,每个 warp 负责若干行
  • warp 内用 __shfl_xor_sync 做行内 reduction(求 max、求 sum),避免通过共享内存中转

这种设计让 warp 级的寄存器使用更高效,减少与共享内存的数据交换。

6.3 数值稳定性

在线 Softmax 的修正因子 emold−mnewe^{m_{old} - m_{new}} 在 mnew≫moldm_{new} \gg m_{old} 时趋近于 0,在 mnew=moldm_{new} = m_{old} 时等于 1。由于始终减去当前最大值,指数运算的输入始终 ≤0\leq 0,不会出现 exe^{x} 溢出。这是 Flash Attention 数值稳定性比朴素实现更好的原因之一——朴素实现中如果不做 max subtraction,长序列的注意力分数很容易溢出。


七、实际影响与生态

7.1 对长序列的解锁

Flash Attention 之前,序列长度 4K–8K 已经是实际极限(内存和速度双重瓶颈)。Flash Attention 之后:

  • 训练序列长度 32K–128K 成为常态
  • 上下文窗口 200K(如 GPT-4 Turbo)在工程上变得可行
  • 长文档理解、长代码生成等应用场景被解锁

7.2 框架集成状态

主流框架均已集成:

  • PyTorch 2.0+:F.scaled_dot_product_attention 内部自动调用 Flash Attention
  • Hugging Face Transformers:通过 attn_implementation="flash_attention_2" 启用
  • vLLM / SGLang:推理引擎默认使用,配合 PagedAttention 进一步优化 KV Cache 管理
  • Megatron-LM / DeepSpeed:训练框架的核心注意力实现

7.3 局限性

  1. 因果掩码(Causal Mask):解码时需要下三角掩码,Flash Attention 通过在块级别判断是否完全掩码、部分掩码来处理,有一定复杂度但已解决
  2. 任意稀疏掩码:Flash Attention 针对密集注意力设计,对任意稀疏模式支持有限(Flash Attention 3 和 Sparse Flash Attention 在探索这个方向)
  3. 小序列开销:序列很短时(< 512),分块的开销可能超过收益,框架通常会 fallback 到朴素实现
  4. 硬件依赖:高度依赖 GPU 的 SRAM 大小和 Tensor Core 特性,在其他加速芯片(TPU、NPU)上需要针对性适配

八、总结

Flash Attention 的核心贡献不是新的数学公式,而是一个系统级的洞察:

注意力计算是 memory-bound 的,通过分块让计算在 SRAM 中完成,用在线 Softmax 消除对 N×NN \times N 中间矩阵的依赖,用重计算换取精确的反向传播。

三个关键要素缺一不可:

  1. 在线 Softmax — 数学上允许分块增量计算
  2. 分块 Tiling — 工程上让计算 fit 进 SRAM
  3. 重计算 — 精确反向传播且几乎不增加开销

它改变了人们对 Attention 复杂度的认知:从" O(N2)O(N^2) 计算是瓶颈"到" O(N2)O(N^2) 内存访问才是真正的瓶颈",并用 IO 感知的算法设计解决了这个问题。这个思路对其他 memory-bound 的算子优化同样有启发意义。

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

评论(0)

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

全部回复

上滑加载中

设置昵称

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

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

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