返回论文笔记资料库
arXiv 2023ICLR 2024语言模型与 Transformer论文笔记

FlashAttention-2

看 GPU 在发呆

原始论文

FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning

论文作者

Tri Dao

发表版本
ICLR 2024会议
arXiv 首次提交
arXiv:2307.08691
引用此论文 · BibTeX

引用信息对应所链接的论文版本,作者为原论文作者。

@misc{transformersflashattention22023,
  title = {{FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning}},
  author = {Tri Dao},
  year = {2023},
  eprint = {2307.08691},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2307.08691}
}
本页内容

FlashAttention 靠着 tiling、online softmax 和 recomputation,成功解决了注意力矩阵反复进出 HBM 的问题。不仅大幅降低内存用量,运算速度也跟着提升了不少。

但是打开 GPU 的工作清单一看,发现不太对劲。

怎么......

这家伙这么闲啊?

定义问题

大家都知道 GPU 里有两层分工。

GPU 里有许多可以同时工作的 Streaming Multiprocessor(SM)。程序把线程组成 thread block,交给 SM 运行;block 内再分成 warp,每组通常有 32 条线程。

简单来说,SM 是工厂,thread block 是工作单,warp 则是实际干活的小组。

第一代 FlashAttention 主要依照 batch size × attention heads 分配工作。以论文中的 A100 为例,GPU 有 108 个 SM,假设 batch size = 1、attention heads = 8,就只有 8 个 thread blocks。

108 座工厂,只发出 8 张订单。

剩下的 100 座呢?就先躺着睡一会儿吧,还能干嘛?

序列越长,还只会让这 8 张工作单越来越厚,却不会增加工厂的开工数量。作者在论文指出,第一代的运算吞吐量只有理论峰值的 25–40%,距离 GPU 的真正实力还差得远。

不仅如此。

首先,GPU 的 Tensor Cores 擅长矩阵乘法,softmax 却需要不少非矩阵乘法(non-matmul)运算。这些运算看似简单,运行效率却远不如矩阵乘法,反而拖慢整体速度。其次,第一代在 block 内让不同 warp 分别处理 K、V 的部分数据,算完又得通过 shared memory 交换结果、同步与合并。

整理一下目前的问题:

SM 之间,工作分得太少;warp 之间,工作又分得不好。

那如果我们就把工作切得更细,让更多 SM 同时运行呢?

偏偏 attention 没这么好拆。softmax 的每一行需要共同的归一化信息;反向传播时,不同区块又可能需要累加到同一份梯度。切得太大,GPU 闲着;切得太碎,大家忙着互相等候。

究竟该怎么切,才能让所有人都有事做,却又不用整天开会?

这就是 FlashAttention-2 要解决的问题。

解决问题

作者把前向工作改从两个地方切,不同 thread block 各管一组 query 行;同一个 block 里,不同 warp 也各管自己的 query 行。这样切完,还得让每行的 softmax 能独立算到底。

沿着行切工作

先认一下表上的三个字母,QQ 是「想找什么」,KK 是拿来比对的线索,VV 是最后要取出的内容。把注意力分数想成一张表,行对应 QQ,列对应 KK,每一格是两者配对的分数。

softmax 沿着行计算,所以同一行的分数要共用分母;不同行却各有自己的分母。作者因此把整组行交给一个 thread block,让它依序读取需要的 K,VK,V 小块,完成这组行的输出。

来看原论文的 Figure 2。左图一种颜色是一组 query 行,也就是一个 worker(thread block)的工作;白色格子因为因果掩码而不用计算。生成文本时,前面的字不能看到未来的字,于是整张表的右上角空了出来。

原论文 Figure 2 局部,arXiv:2307.08691v1 PDF 第 8 页。

第一组 worker 算第一组行,第二组算第二组行;两组都可能读到同一块 K,VK,V,但不用交换 softmax 的中间结果。回到前面 1 个 batch、8 个 head 的例子,每个 head 是一份独立的注意力计算。假设每份的 query 行再切成 16 组,就能从 8 张工作单变成 8×16=1288\times16=128 张。这只是派工示意,实际切几组要看区块大小;重点是序列变长时,工作组数终于也能增加。

右图为什么又改成按列分工?因为反向传播要算 dQ,dK,dVdQ,dK,dV,也就是传回 Q,K,VQ,K,V 的梯度。一个 K,VK,V 小块会受到许多 query 行影响;让一个 worker 负责一列,就能把这一列的 dK,dVdK,dV 在自己手上累积完。

dQdQ 则会从不同列收到贡献,这些 worker 必须用 atomic add 把数值加回去,确保同时写入时不会互相覆盖。前向各管自己的输出行,反向各管自己的 K,VK,V 梯度。

除法留到最后

一个 worker 接下 query 行后,仍要分批读完 K,VK,V。可是 softmax 的分母,要等整行分数都看过才知道。每来一块,就先把目前的输出除一次,行不行?可以,第一代就是这样做;只是下一块若出现更高的分数,又得重新缩放、再除一次。

我们拿几个数字来示范算算看。

一行分数分成 [3,1][3,1] 和 [4,2][4,2] 两块,对应的 VV 是 [1,0][1,0] 和 [3,2][3,2]。为了避免指数数值太大,我们以目前最高分 mm 为基准;再记住指数的总和 ℓ\ell,以及尚未相除的加权和 UU。

本站依 FlashAttention-2 Algorithm 1 自制:四个分数分两块处理,只有最后一步计算 O = U / ℓ。

看图的第一块。最高分是 33,所以 ℓ1=e3−3+e1−3=1+e−2≈1.1353\ell_1=e^{3-3}+e^{1-3}=1+e^{-2}\approx1.1353;加权和则是 U1=1×1+e−2×0=1U_1=1\times1+e^{-2}\times0=1。第一代此时会先算部分输出 U1/ℓ1≈0.8808U_1/\ell_1\approx0.8808。第二代只把 ℓ1\ell_1 和 U1U_1 留在手上。

第二块冒出更高的分数 44。旧数字原先以 33 为基准,现在要统一改用 44,所以旧的 ℓ1,U1\ell_1,U_1 都乘上 e3−4=e−1e^{3-4}=e^{-1}。新块再加进来,得到 ℓ2=e−1ℓ1+1+e−2≈1.5530\ell_2=e^{-1}\ell_1+1+e^{-2}\approx1.5530,以及 U2=e−1U1+3+2e−2≈3.6386U_2=e^{-1}U_1+3+2e^{-2}\approx3.6386。直到两块都读完,才做一次 O=U2/ℓ2≈2.3429O=U_2/\ell_2\approx2.3429。整行直接做 softmax 加权平均,也是同一个答案。

把这件事写成一般形式,SjS_j 是新读到的一块分数,VjV_j 是对应的 value;撇号表示读完这块后的新状态。

m′=max⁡(m,max⁡Sj),ℓ′=em−m′ℓ+∑eSj−m′,U′=em−m′U+eSj−m′Vj.\begin{aligned} m'&=\max(m,\max S_j),\\ \ell'&=e^{m-m'}\ell+\sum e^{S_j-m'},\\ U'&=e^{m-m'}U+e^{S_j-m'}V_j. \end{aligned}

式子前半的 em−m′e^{m-m'},就是图中那次 e−1e^{-1},用来把旧分母和旧加权和换到同一个基准。后半在 ℓ′\ell' 中加进新分数的指数,在 U′U' 中加进对应 VjV_j 的加权和。

一般情况的 VjV_j 是一组向量,所以 UU 也是向量;图上用单一数值,方便我们手算。每组 query 行都能这样维护自己的 m,ℓ,Um,\ell,U,读完才输出 O=U/ℓO=U/\ell。

反向传播要重算注意力权重,作者只替每行保存一个归一化数字 L=m+log⁡ℓL=m+\log\ell。因为 eL=emℓe^L=e^m\ell,某个分数 SijS_{ij} 的权重就能写成 Pij=eSij−LiP_{ij}=e^{S_{ij}-L_i}。这仍要重算分数,却不用留下整张权重表,也不用分开保存 mm 与 ℓ\ell。

少除几次,对 GPU 有什么帮助?

作者在论文中列出 A100 的理论吞吐量,FP16/BF16 矩阵乘法是 312 TFLOPs/s,一般 FP32 运算是 19.5 TFLOPs/s。因此,只要我们尽量减少后者,把时间留给 Tensor Cores 擅长的矩阵乘法,就能达到提速的效果。

warp 也要重新排

前面增加 thread block,让更多 SM 有工作;现在打开其中一个 block,看里面的 warp。原论文 Figure 3 用橙色虚线标出分给不同 warp 的数据,蓝色虚线则表示各组 warp 都能取用。

原论文 Figure 3 局部,arXiv:2307.08691v1 PDF 第 9 页。

先看左边。四组 warp 都看同一组 QQ,但各拿一部分 K,VK,V。算完后,每组手里只有同一批输出行的一部分。想交出完整答案,得把这些部分结果放进 shared memory,等大家算完,再读出来合并;论文称作 split-K。

右边把方向反过来,K,VK,V 让各组 warp 取用,QQ 切成四份。第一组 warp 产生自己的输出行,第二组产生下一组。既然输出行各有主人,前向就不必为了拼同一行而开那场 shared memory 协调会。反向仍有梯度依赖,需要部分同步。

到这里,两层分工接起来了。一个 head 的不同 query 行派往更多 block;进了 block,再把行分给不同 warp。每行内部的 softmax 则只在最后相除。

讨论

先看注意力本身

原论文的 Figure 4(a) 比较 A100 80GB SXM4 上的注意力前向加反向,设置是没有因果掩码、每个 head 宽度为 64。横轴是序列长度;纵轴 TFLOPs/s 是按论文的运算量公式换算的吞吐量,同一设置下愈高代表跑得愈快。橙色是第一代,紫色是第二代。

原论文 Figure 4(a) 局部,arXiv:2307.08691v1 PDF 第 10 页。

先读 8k 这组,第一代 110、第二代 175 TFLOPs/s,相差约 175/110≈1.59175/110\approx1.59 倍。到 16k,两者是 110 与 176,差距仍在。PyTorch 在最右边标了 OOM,表示那组设置内存不足。

作者在这张图固定每次测试的总 token 数为 16k,所以序列愈长,batch 就愈小,这点和开场有关。8k 时 batch 为 2;16k 时 batch 为 1。

在这张图的 32 个 head 设置下,第一代到了 16k 只有 1×32=321\times32=32 组按 batch 与 head 派出的工作,面对 A100 的 108 个 SM。沿 query 行再分 block,正好补上这种情况缺少的并行任务。

再看整场训练

注意力这一层快了,整个模型呢?原论文 Table 1 用 8 张 A100 训练 GPT 类模型,比较没有 FlashAttention、第一代和第二代。表中的 1.3B、2.7B 是模型参数量;2k、8k 是一次能看的 token 长度。每张 GPU 的 TFLOPs/s 愈高,代表同一行设置下的训练吞吐量愈高。

原论文 Table 1 局部,arXiv:2307.08691v1 PDF 第 12 页。

先沿着 1.3B 的两行横着读。2k 上下文时,第一代 189、第二代 196 TFLOPs/s,提升约 4%;换成 8k,则从 170 到 220,提升约 29%。2.7B 的 8k 也从 175 到 225,约多 29%;同一行不用 FlashAttention 时只有 80,因此第二代相对它约快 2.8 倍。

在这张表里,短上下文的改进有限,长上下文的训练则拿到更明显的收益。这与前面沿序列增加工作组数的理由相符。

最后,表中最高的 225 TFLOPs/s,被作者换算成 72% model FLOPs utilization。这不是说 108 个 SM 恰好有 72% 在上班。表格的 TFLOPs/s 是按模型运算量公式与耗时换算的;该公式沿用当时文献惯例,计算因果注意力时没有扣掉掩码略去的约半张分数表,它能用来比较表中同条件的训练速度。

结论

第一代 FlashAttention 解决了数据搬太多的问题,第二代则开始研究工作怎么分配。

它沿着 query 的序列维度派出更多 thread blocks,让更多 SM 同时开工;重新安排 warp 的工作,减少彼此交换数据的麻烦;再调整 online softmax 的计算顺序,省下部分非矩阵乘法运算。

这套设计后来也走进 PyTorch SDPA 与 Hugging Face 的加速选项。不过,密集 attention 的计算量仍随序列长度呈平方增长,而且 A100 上的最佳分工,到了 H100、B200 未必还是最佳解。

最后,所有人都在忙,就代表整条产线没有浪费时间吗?

下一篇继续,换 H100 上场。