Skip to content

FlashAttention 与 IO 感知注意力算子

剖析 GPU 显存层级、Online Softmax 分块推导与 FlashAttention-2/3 演进。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是 FlashAttention?

很多人以为标准自注意力慢是因为乘法太多,其实真正卡脖子的不是算力,而是 GPU 显存搬运太慢——标准实现要把巨大的 NimesN 注意力分数矩阵反复写回慢速大显存(HBM)再读出来。

FlashAttention 是一种 100% 数学精确、绝不近似 的硬件感知加速算法:它把 Q、K、V 切成刚好塞进 GPU 超高速片上缓存(SRAM)的小块,利用 Online Softmax 技巧在高速缓存里一口气算完最终输出,全程彻底省掉了 NimesN 矩阵的 HBM 读写,既把速度提快 2–4 倍,又把显存从平方级降到线性级。

01 问题从何而来:算得飞快,全耽误在跑腿上 ​

很长一段时间里,大家提到 自注意力机制 慢、显存容易爆,第一反应都是:“因为它要算 N×N 的矩阵,计算量太大了!”于是学界发明了一堆稀疏近似或 线性注意力,拼命砍浮点运算次数(FLOPs),结果一上真机跑,省下来的时间却常常令人失望,模型效果还变差了。

2022 年,Tri Dao 等人提出 FlashAttention(arXiv:2205.14135 ↗),一针见血地戳破了盲区:标准注意力慢,根本不是 GPU 算不过来,而是全卡在“来回搬数据”的路上!

类比 · 大厨的料理台 vs 地下冷库

把一块 NVIDIA GPU 想象成一家顶级米其林厨房:

  • Tensor Core 是刀功出神入化的超级大厨,切菜速度堪比光速;
  • 片上 SRAM 是大厨手边那张极小的料理台,总共只有几十 MB,但伸手就能拿到(带宽高达 19–33 TB/s);
  • HBM 显存 是楼下巨大的冷库,能装 80 GB 食材,但每次上下楼搬运慢了一个数量级(只有 1.5–3.35 TB/s)。

标准 PyTorch 注意力的做法荒唐透顶:大厨先下楼把 Q,K 搬上来,算出整张庞大的 N×N 半成品打分表 S,又专门跑一趟楼下存进冷库;接着再下楼把 S 搬上来做 Softmax 得到 P,再跑一趟楼下存起来;最后第三次下楼搬出 P 和 V 相乘。大厨九成时间都在爬楼梯,真正的炒菜功夫根本没用上!

核心设问

能不能让大厨把食材切成刚好放得进料理台的小块,就在手边一口气完成“打分 → Softmax → 乘 V”,全程绝不把巨大的 N×N 中间表搬回冷库,而且算出来的最终结果和标准注意力在数学上一模一样?

02 核心直觉与生活类比 ​

听起来很简单——分块算不就完了吗?可真正卡住所有人的“拦路虎”是 Softmax:为了防止指数溢出并算出准确分母,你需要知道整行所有 N 个分数的最大值和指数和。如果整行有 65536 个词,料理台一次只能装下 64 个词,还没看到后面几万个词,怎么敢提前把这一块的权重乘到 V 上呢?

类比 · 边读边改账的会计:Online Softmax 的绝妙戏法

想象你要给一万道菜按分数算出加权平均口味,但你手头的小本子一次只能记 100 道菜。你先看完前 100 道菜,发现目前最高分是 80 分,于是顺手以 80 分为基准算出了一个“临时加权结果”,并把当前最高分 80 和总权重 L1 记在页眉,随后就把前 100 道菜的明细全扔了。

看第二批 100 道菜时,突然冒出一道 90 分的新菜王!刚才按 80 分算的旧账是不是白算了、得把前 100 道菜重新翻出来?

完全不用! 因为指数函数有个逆天的性质:ex−90=e80−90⋅ex−80。你只需要把小本子上刚才算好的旧总分和旧结果,整体乘上一个修正系数 e80−90,旧账瞬间就“穿越”成了按 90 分基准算出来的精确结果,再直接加上第二批的新贡献即可!等全部一百批扫完,最后再统一除以最终总权重,答案和一次性摊开一万道菜算出来的一分不差。

这就是 分块(Tiling)+ Online Softmax(arXiv:1805.02867 ↗)的灵魂:小料理台从头到尾只维护极小的几个累加器,彻底消灭了 O(N2) 的显存炸弹。

训练时的反向传播也同样聪明:常规做法为了算梯度,前向时必须把 N×N 的注意力权重矩阵 P 死死留在显存里;FlashAttention 前向结束只额外存下一条极瘦的 O(N) 统计量 L(每行一个数),反向需要 P 时,在料理台上现场用 Q,K,L 瞬间重算一遍。表面上多算了一点矩阵乘,却省掉了海量爬楼梯(HBM 读写)的时间,总耗时反而大幅缩短!

类比 · 为什么 FlashAttention-2 比初代又快了一倍?

初代 FlashAttention 虽然消灭了来回搬运,但分工方式还有些别扭:它让外循环遍历 K,V 块,内循环遍历 Q 块,并且同一个线程块里的多个小组(Warp)去切分同一个 K 块,算完局部结果后必须凑到共享内存里互相汇合加总,像四位厨师挤在一口锅前轮流勺汤,沟通同步消耗了大量时间。

FlashAttention-2(arXiv:2307.08691 ↗)把循环顺序反过来:外层遍历 Q 块,每个线程块和每个 Warp 各自承包互不重叠的几行 Q,一路顺着 K,V 块独立把自己的那几行结果算到底。大家各炒各的锅、零通信打架,长序列小 Batch 时也能轻松把上百个 SM 全塞满,算力利用率直接翻番!

03 把关键公式读成人话 ​

Online Softmax 最核心的递推公式只有两行(以 FlashAttention-2 延迟归一化形式为例):

minew=max(miold,m~ij),ℓinew=emiold−minewℓiold+ℓ~ijO~inew=diag(emiold−minew)O~iold+P~ijVj

把公式读成直觉:- mi 是截至目前见过的“最高分纪录”,m~ij 是刚端上料理台的这一小块里的局部最高分;两者取大得到新纪录 minew。

  • 修正系数 emiold−minew 永远落在 (0,1] 之间:如果这一块没打破纪录,它就是 e0=1,旧账纹丝不动;如果打破了纪录,它就把旧账 ℓiold 和旧输出 O~iold 按精确比例缩小,对齐到新基准。
  • 最巧妙的是 FlashAttention-2 的“懒人优化”:循环过程里全程不除以 ℓi,等所有 K,V 块全扫描完,在最后一步统一算一次 Oi=O~i/ℓi,省掉了大量昂贵的非矩阵乘除法。

再看论文证明的 HBM 访存复杂度:

HBM IO=Θ(N2d2M)

把公式读成直觉:- 标准注意力每次要搬运 Θ(Nd+N2) 字节;FlashAttention 把它压缩了约 M/d2 倍。

  • 这里的 M 是料理台(SRAM)容量,d 是单头维度。拿典型值 d=64,M≈100 KB 一代,光冷库往返搬运量就直接砍掉了 9 倍以上!料理台越大,省得越狠。

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

FlashAttention 是今天所有主流大模型默认的“心脏起搏器”:

  • 向上严格兼容数学定义:它对 自注意力机制 不做任何近似,输出的数值与标准实现完全等价;由于不需要在 QK⊤ 上加显式 2D 偏置矩阵,它和 旋转位置编码 RoPE 堪称天作之合。
  • 训练阶段撬动超长上下文:它把反向传播的激活显存从 O(N2) 压到 O(N),是 显存优化与重计算 的典范,也让 长上下文训练 和跨卡 序列并行(Ring Attention) 成为现实——Ring Attention 本质上就是把 Online Softmax 分块从单张卡的 SRAM 推广到了几十张卡之间。
  • 推理阶段无缝衔接缓存与压缩:在 Prefill 阶段直接打满 Tensor Core;进入 Decode 阶段时,由于每次查询长度 Nq=1,需要切换成沿 KV 长度切分的 FlashDecoding(Stanford Blog ↗)并与 PagedAttention KV Cache 融为一体;到了 FlashAttention-3 甚至直接结合了块级 FP8 量化。

05 演化对比与避坑备忘 ​

三代 FlashAttention 的演进,其实就是一部越来越懂 GPU 硬件脾气的“榨干史”:

版本核心突破(说人话)典型算力利用率
Standard Attention算一步存一次冷库,显存 O(N2)< 25%(长文直接 OOM)
FlashAttention-1 (arXiv ↗)分块 + Online Softmax + 反向重算,显存降到 O(N)25%–40%(A100)
FlashAttention-2 (arXiv ↗)换外循环遍历 Q、序列维并行、Split-Q 消除 Warp 通信、延迟归一化50%–73%(A100/H100)
FlashAttention-3 (arXiv ↗)Hopper 专属:TMA 异步搬砖 + Softmax/GEMM 乒乓重叠 + 低误差 FP875%–85%(H100 破 1.2 PFLOPS)

实际写代码调用 FlashAttention,有三个经典暗坑要提前绕开:

  1. 别手痒往里面塞稠密 2D attn_mask:FlashAttention 飞快的前提是掩码有规律(因果三角、滑动窗口等),算子可以直接跳过整个上三角块省一半算力。一旦硬塞一张任意形状的 N×N 浮点掩码,不仅瞬间退回 O(N2) 显存,性能也会暴跌。有复杂掩码需求,现代 PyTorch 请直接上编译器生成的 FlexAttention(PyTorch Blog ↗)。
  2. 多样本拼接务必用 varlen 紧凑打包:如果把长短不一的句子用 Padding 补齐成矩形再算,大量算力都白白烧在了无效填充词上。工业训练和推理一律把多条样本头尾相接压平,再传一个 cu_seqlens 边界数组给 flash_attn_varlen_func,彻底消灭无效计算。
  3. 当心“全掩码行”炸出 NaN 和反向微小波动:若左填充或异常跨文档掩码导致某个查询词一个可见的 Key 都没有,局部最大值 mi=−∞,算 exp(-inf - (-inf)) 立刻吐 NaN。另外 FA2 反向默认用 GPU atomicAdd 汇总 dQ,浮点加法顺序略有浮动,若做严格复现实验记得显式打开 deterministic=True。
  4. Decode 阶段别直接傻跑标准 FlashAttention:逐字生成时每次查询只有 Nq=1 个词,而历史 KV 可能长达 64K。如果还按 Q 切分并行,整张显卡只有区区几个线程块在干活,九成核心全在围观!推理引擎此时会自动切到 FlashDecoding(Split-KV),把 64K 的历史 KV 拆成几十段并行算完再归约合并,瞬间把长文吐字速度拉回来。

需要查阅 Online Softmax 完整归纳证明、反向传播 Di 梯度公式、H100 Warp 特化细节与可运行 flash_attention_v2_forward PyTorch 代码?按快捷键 M 或点击顶部 技术 Wiki 即可随时切换。

在标准 Transformer 实现中,自注意力(Self-Attention) 的时间与显存复杂度均随序列长度 N 呈 O(N2) 增长。过去研究者提出了稀疏注意力、线性注意力与状态空间模型 等近似方法试图降低浮点计算量(FLOPs),但往往以牺牲模型表达能力为代价,且实际挂钟速度(Wall-Clock Time)提升有限。FlashAttention(Dao et al., 2022,arXiv:2205.14135 ↗)另辟蹊径,指出标准注意力的真正瓶颈并非算力,而是 GPU 不同存储层级之间的 HBM 读写带宽(Memory IO)。它通过 分块(Tiling)、在线归一化(Online Softmax) 与 反向重计算(Recomputation),在不做任何数值近似的前提下实现了线性 O(N) 显存占用与数倍端到端加速,也是 长上下文建模 与 序列并行(Ring Attention) 的算子基石。

直观理解

把 GPU 想象成一位极速大厨(Tensor Core),他手边有一张极小但拿取飞快的料理台(片上 SRAM),而大仓库(显存 HBM)虽容量巨大但往返搬运极慢。标准注意力每次都要把一整张 N×N 的半成品菜谱搬回仓库存好,再搬出来加调料(Softmax),再搬回仓库;而 FlashAttention 把食材切成刚好能放进料理台的小块,在台面上一次性完成乘加、归一化与加权汇总,只把最终成品端回仓库,省去了绝大多数无效折返跑。

问题动机与演进背景 ​

GPU 存储层级与带宽剪刀差 ​

现代 GPU(如 NVIDIA A100 与 H100)呈现典型的金字塔形存储架构:

  • HBM(High Bandwidth Memory,片外全局显存):容量大(40 GB–80 GB),但带宽相对有限(A100 约 1.5–2.0 TB/s,H100 约 3.35 TB/s)。
  • 片上 SRAM(Shared Memory / Register File):总容量极小(分布在百余个 SM 中,合计仅约 20–50 MB),但片上访存带宽高达 19–33 TB/s,比 HBM 快一个数量级以上。

随着 Tensor Core 算力每代暴涨,算力增速远超 HBM 带宽增速,越来越多的非矩阵乘算子(Softmax、Dropout、Masking、逐元素加法)沦为严重的 Memory-Bound(访存受限) 算子。

标准注意力的 O(N2) IO 瓶颈 ​

给定 Q,K,V∈RN×d,标准 PyTorch 实现按以下分立 Kernel 执行:

  1. 从 HBM 读取 Q,K,计算 S=QK⊤/d∈RN×N,将 S 写回 HBM;
  2. 从 HBM 读取 S,应用因果掩码与 Softmax 得到 P=Softmax(S)∈RN×N,将 P 写回 HBM;
  3. 从 HBM 读取 P 和 V,计算输出 O=PV∈RN×d,将 O 写回 HBM。

该过程不仅在显存中实化(Materialize)了庞大的 N×N 中间矩阵,导致 Θ(N2) 的显存开销,更造成了高达 Θ(Nd+N2) 次 HBM 读写。当 N≫d(如 N=8192,d=128)时,绝大多数运行时间都消耗在向 HBM 反复搬运 S 与 P 上。

核心原理与数学推导 ​

要将整个注意力融合成单一 CUDA Kernel 且不在 HBM 落盘 S 与 P,核心难点在于 Softmax 的行间耦合性:计算任意元素 pij 都依赖于整行 N 个元素的最大值与指数和,而整行 N 可能远超片上 SRAM 容量。

1. Online Softmax 精确数学推导 ​

对于长度为 N 的单行向量 x∈RN,数值稳定的安全 Softmax(Safe Softmax)定义为:

m(x)=maxjxj,ℓ(x)=∑j=1Nexj−m(x),Softmax(x)j=exj−m(x)ℓ(x)

现将向量切分为两块 x=[x(1),x(2)],假设已局部算出各自的最大值与指数和 (m(1),ℓ(1)) 和 (m(2),ℓ(2))。则全局统计量满足严格递推关系:

mnew=max(m(1),m(2))ℓnew=em(1)−mnewℓ(1)+em(2)−mnewℓ(2)

将此递推推广到注意力输出矩阵的分块累加。设当前处理第 i 个 Q 块 Qi∈RBr×d,并依次遍历第 j=1,…,Tc 个键值块 (Kj,Vj)∈RBc×d。在片上计算局部打分块 Sij=QiKj⊤/d∈RBr×Bc 后:

  1. 计算当前块的局部行最大值 m~ij=rowmax(Sij)∈RBr;
  2. 更新运行最大值 minew=max(miold,m~ij);
  3. 计算未归一化局部概率块 P~ij=exp⁡(Sij−minew) 与行和 ℓ~ij=rowsum(P~ij);
  4. 更新运行分母 ℓinew=emiold−minewℓiold+ℓ~ij;
  5. 修正并累加未归一化输出(FlashAttention-2 化简形式):
O~inew=diag(emiold−minew)O~iold+P~ijVj

当全部 Tc 个键值块扫描完毕,仅在循环末尾执行一次最终归一化:

Oi=diag(ℓi(Tc))−1O~i(Tc)

通过数学归纳法易证,上述在线递推得到的 Oi 与一次性在全局计算标准 Softmax 所得结果在实数域上完全恒等,且无需保存任何 N×N 矩阵。

2. 分块尺寸与 HBM IO 复杂度证明 ​

设单 SM 可用 SRAM 容量为 M。为在片上同时容纳 Qi,Kj,Vj,Oi(共 4 个块),选取分块大小 Bc=⌈M4d⌉、Br=min(⌈M4d⌉,d)。

  • 外层遍历 Kj,Vj 块(或 FA2 中外层遍历 Qi 块),整个算法对 Q、O 读写 O(Nd),对 K,V 的每一块需被全部 Tr=⌈N/Br⌉ 个 Q 块各读一次(或反过来),总 HBM 访问量为:
HBM IO=Θ(N2d2M)

代入典型参数 d=64,M=100 KB(约 5×104 个 FP16 元素),系数 d2/M≈4096/50000≈0.08,相比标准注意力的 Θ(N2) 减少了约 9 倍以上的 HBM 读写!

3. 反向传播的 IO 感知重计算策略 ​

标准反向传播需要读取前向缓存的 P∈RN×N,既占显存又拖慢 IO。FlashAttention 前向传播结束后,仅向 HBM 写回输出 O∈RN×d 以及每行的对数配分函数(Log-Sum-Exp) Li=mi+log⁡ℓi∈RN,额外显存严格为 O(N)。

在反向传播分块扫描时,算子在片上利用 Qi,Kj 和 Li 直接现场重算局部注意力权重:

Pij=exp⁡(QiKj⊤d−Li)

并借助标量内积 Di=rowsum(dOi⊙Oi)(利用了 ∑kPikdPik=oi⊤doi 的恒等式)在片上直接求得:

dVj+=Pij⊤dOi,dSij=Pij⊙(dOiVj⊤−Di)dQi+=1ddSijKj,dKj+=1ddSij⊤Qi

尽管多执行了一次 QK⊤ 的前向重算(增加了少量 FLOPs),但由于彻底避免了向 HBM 读写 O(N2) 的 S 和 P,反向传播反而显著更快。

4. FlashAttention-2 与 FlashAttention-3 的硬件演进 ​

  • FlashAttention-2(Dao, 2023,arXiv:2307.08691 ↗):针对 FA1 仅能达到理论峰值算力 25%–40% 的问题作出三大改进:
    1. 削减非矩阵乘 FLOPs:取消内循环中每步对 Oi 的 ℓi−1 反复缩放,推迟至内循环末尾一次性除以最终 ℓi;
    2. 序列维度并行与内外循环互换:将外循环改为遍历 Q 块,不同线程块独立处理不同的 Qi,既消除跨块写回 Oi 时的原子锁竞争,又能在长序列、小 Batch 下打满所有 SM;
    3. Warp 分工由 Split-K 改为 Split-Q:同一线程块内的多个 Warp 切分 Qi 行而非切分 Kj,各 Warp 独立累加各自的 Oi 子行,彻底省去 Shared Memory 跨 Warp 归约同步开销,将算力利用率推升至 50%–73%。
  • FlashAttention-3(Shah et al., 2024,arXiv:2407.08608 ↗):专为 NVIDIA Hopper(H100)架构深度定制:
    1. Warp 特化(Warp Specialization)与 TMA 异步搬运:将线程块内的 Warpgroup 划分为 Producer(使用硬件 TMA 引擎异步从 HBM 预取 Kj,Vj 至 SRAM)与 Consumer(专注发射 WGMMA 异步张量核心指令);
    2. GEMM 与 Softmax 乒乓流水(Ping-Pong Scheduling):让第 k 块的非矩阵乘 Softmax(运行在特殊功能单元 SFU)与第 k+1 块的 Tensor Core WGMMA 硬件级重叠执行,隐藏 Softmax 延迟;
    3. 低误差 FP8(E4M3)支持:结合分块 FP8 量化 与随机正交变换(Hadamard Incoherent Processing)分散激活离群值,将 FP8 注意力量化误差压低 2.6 倍,在 H100 上突破 1.2 PFLOPS。

算法架构与数据流图 ​

以下架构图对比了 HBM 与片上 SRAM 之间的分块流式调度逻辑(以 FlashAttention-2 外层遍历 Q 块为例):

图表加载中...

复杂度与横向对比表 ​

算子版本显存复杂度HBM 访存量核心并行维度关键硬件特性典型 H100 FP16/FP8 算力利用率
Standard AttentionO(N2)Θ(Nd+N2)Batch, Heads独立 GEMM + Softmax低于 25%(长序列 OOM)
FlashAttention-1 (2022)O(N)Θ(N2d2/M)Batch, HeadsTiling + Online Softmax + 重计算约 25%–40%(A100)
FlashAttention-2 (2023)O(N)Θ(N2d2/M)Batch, Heads, Seq_QSplit-Q Warp 分工 + 延迟归一化约 50%–73%(A100/H100)
FlashAttention-3 (2024)O(N)Θ(N2d2/M)Batch, Heads, Seq_QHopper TMA + WGMMA + Warp 特化 + FP8约 75%–85%(FP16 达 740+ TFLOPS)

核心 PyTorch 参考实现 ​

以下纯 PyTorch 实现完整复现了 FlashAttention-2 分块前向传播与 Online Softmax 递推算法(含因果掩码跳过优化),并验证其数值与标准精确注意力在浮点误差范围内完全等价:

python
import math
import torch
import torch.nn.functional as F


def flash_attention_v2_forward(
    Q: torch.Tensor,          # (B, H, N, D)
    K: torch.Tensor,          # (B, H, N, D)
    V: torch.Tensor,          # (B, H, N, D)
    block_r: int = 32,        # Q 分块大小 B_r
    block_c: int = 32,        # K/V 分块大小 B_c
    causal: bool = True,
):
    """
    教学级 FlashAttention-2 分块前向实现:
    模拟 SRAM 内循环分块计算与 Online Softmax,返回输出 O 及反向所需 log-sum-exp L。
    """
    B, H, N, D = Q.shape
    scale = 1.0 / math.sqrt(D)

    O = torch.zeros_like(Q)                                # (B, H, N, D)
    L = torch.empty((B, H, N), device=Q.device, dtype=torch.float32)

    # 外循环遍历 Q 的分块(在真实 CUDA Kernel 中由不同 Thread Block 并行执行)
    for q_start in range(0, N, block_r):
        q_end = min(q_start + block_r, N)
        q_len = q_end - q_start
        Q_i = Q[:, :, q_start:q_end, :]                    # (B, H, B_r, D)

        # 片上 SRAM 累加器(统一用 FP32 保持累加数值精度)
        O_i = torch.zeros((B, H, q_len, D), device=Q.device, dtype=torch.float32)
        m_i = torch.full((B, H, q_len, 1), float("-inf"), device=Q.device, dtype=torch.float32)
        l_i = torch.zeros((B, H, q_len, 1), device=Q.device, dtype=torch.float32)

        # 因果掩码下,完全位于对角线右侧的 K/V 块可直接跳过(省去约 50% 计算!)
        kv_limit = q_end if causal else N

        for kv_start in range(0, kv_limit, block_c):
            kv_end = min(kv_start + block_c, N)
            K_j = K[:, :, kv_start:kv_end, :]              # (B, H, B_c, D)
            V_j = V[:, :, kv_start:kv_end, :]              # (B, H, B_c, D)

            # 1. 计算局部注意力打分 S_ij: (B, H, B_r, B_c)
            S_ij = torch.matmul(Q_i, K_j.transpose(-1, -2)).float() * scale

            # 仅在跨越对角线的块内施加逐元素因果掩码
            if causal and kv_end > q_start:
                q_idx = torch.arange(q_start, q_end, device=Q.device)[:, None]
                k_idx = torch.arange(kv_start, kv_end, device=Q.device)[None, :]
                S_ij = S_ij.masked_fill(k_idx > q_idx, float("-inf"))

            # 2. Online Softmax 统计量递推更新
            m_ij = S_ij.max(dim=-1, keepdim=True).values   # (B, H, B_r, 1)
            m_new = torch.maximum(m_i, m_ij)               # (B, H, B_r, 1)

            alpha = torch.exp(m_i - m_new)                 # 旧累加器重缩放因子
            P_tilde = torch.exp(S_ij - m_new)              # 局部未归一化权重 (B, H, B_r, B_c)

            l_new = alpha * l_i + P_tilde.sum(dim=-1, keepdim=True)
            # 3. 延迟归一化:仅乘以缩放因子 alpha 并累加 P_tilde @ V_j
            O_i = alpha * O_i + torch.matmul(P_tilde, V_j.float())

            m_i, l_i = m_new, l_new

        # 循环结束一次性执行输出归一化并保存 L_i = m_i + log(l_i)
        O[:, :, q_start:q_end, :] = (O_i / l_i).to(Q.dtype)
        L[:, :, q_start:q_end] = (m_i + torch.log(l_i)).squeeze(-1)

    return O, L


if __name__ == "__main__":
    torch.manual_seed(0)
    B, H, N, D = 2, 4, 128, 64
    Q = torch.randn(B, H, N, D)
    K = torch.randn(B, H, N, D)
    V = torch.randn(B, H, N, D)

    out_flash, lse = flash_attention_v2_forward(Q, K, V, block_r=32, block_c=32, causal=True)
    out_ref = F.scaled_dot_product_attention(Q, K, V, is_causal=True)

    max_diff = (out_flash - out_ref).abs().max().item()
    print(f"Max absolute diff vs PyTorch SDPA: {max_diff:.2e}")
    assert torch.allclose(out_flash, out_ref, atol=1e-5)

工程实践与常见陷阱 ​

工程实践

  1. Decode 阶段需切换至 FlashDecoding(Split-KV):在自回归推理的 Decode 阶段,查询长度 Nq=1,而 KV Cache 长度 Nkv 可能高达 32K 甚至 128K。此时按 Q 序列并行只能启动极少线程块,大量 SM 闲置。FlashDecoding 在 Nkv 维度再做并行切分(Split-KV),各线程块并行算完局部注意力与 LSE 后,再由一个轻量归约 Kernel 利用 Online Softmax 公式合并结果,可将长序列解码提速数倍。
  2. 头维度 dh 对齐与可变长打包(Varlen):FlashAttention 的 CUDA 模板对 dh∈{64,128,256} 做过极致寄存器优化;在训练与推理批处理中,应使用 flash_attn_varlen_func 配合累积序列长度 cu_seqlens 将不等长样本紧凑拼接(Sequence Packing),彻底避免 Padding Token 浪费算力。
  3. 利用因果块稀疏跳过与滑动窗口:对于因果注意力,内循环可直接跳过全部满足 kv_start >= q_end 的上三角块,自然获得接近 2× 的理论加速;对于 Sliding Window Attention(如 Mistral)也只需收缩内循环上下界即可零额外开销支持。

常见陷阱

  1. 反向传播的非确定性(Non-Determinism):FlashAttention-2 反向算子在将不同键值块贡献的梯度累加至 dQ 时,默认使用 GPU atomicAdd 操作,浮点数加法的结合律差异会导致相同输入在多次运行间产生微小梯度波动。若需严格可复现训练,需显式开启 deterministic=True(会带来轻微性能回退)。
  2. 自定义任意 2D 注意力掩码的性能退化:FlashAttention 的高速依赖于因果、滑动窗口、ALiBi 等结构化掩码的解析计算。若强行传入稠密的 N×N 浮点 attn_mask,不仅会重新引回 O(N2) 显存占用,还会打破 IO 优势。现代框架(如 PyTorch FlexAttention)通过编译自定义 score_mod 与 mask_mod 块稀疏函数,兼顾了灵活性与 FlashAttention 级性能。
  3. 全掩码行导致 NaN:如果某一行在所有键值位置上均被掩码为 −∞(常见于左填充或异常跨文档掩码),会导致 mi=−∞,进而 exp(-inf - (-inf)) 产生 NaN。工程上必须在构造 cu_seqlens 或自定义掩码时确保每个有效查询至少可见一个键。

延伸阅读与参考论文 ​

  • Milakov, M., & Gimelshein, N. (2018). Online normalizer calculation for softmax. arXiv:1805.02867 ↗(提出数值稳定的 Online Softmax 单遍归约算法)
  • Dao, T., Fu, D. Y., Ermon, S., Rudra, A., & Ré, C. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS 2022. arXiv:2205.14135 ↗(FlashAttention 奠基论文)
  • Dao, T. (2023). FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning. ICLR 2024. arXiv:2307.08691 ↗(序列维度并行与 Split-Q Warp 分工优化)
  • Dao, T., Haziza, D., Massa, F., & Sizov, G. (2023). Flash-Decoding for Long-Context Inference. Stanford CRFM Blog ↗(针对 Nq=1 解码阶段的 Split-KV 并行化)
  • Shah, J., Bikshandi, G., Zhang, Y., Thakkar, V., Ramani, P., & Dao, T. (2024). FlashAttention-3: Fast and Accurate Attention with Asynchrony and Low-precision. NeurIPS 2024. arXiv:2407.08608 ↗(Hopper 异步 TMA/WGMMA 流水线与低误差 FP8 融合算子)
  • Dong, J., et al. (2024). FlexAttention: A Programming Model for Generating Optimized Attention Kernels. PyTorch Blog ↗(基于编译器生成的高性能可编程注意力框架)