scratch2modern
第一章 · 训练

1.09 工程加速

这一节工程加速:减少同步、fused Adam、SDPA、torch.compile、CUDA Graph
结果每步从 3.56 毫秒降到 0.85 毫秒,快 4.2 倍,loss 不变

前面几节改的都是"算什么":优化器、学习率、精度。这一节一点数学都不改,只想利用 PyTorch 现在开箱即用的一些方法来加速。每一项都只要改几行代码,叠在一起,同样的训练快了 4 倍多,loss 不变。

什么都不加 3.56 ms + 减少同步 3.15 ms + fused Adam 2.82 ms + SDPA 2.55 ms + torch.compile 1.58 ms + CUDA Graph 0.85 ms 每一步训练的耗时(毫秒,3 个种子平均),每一行都在上一行的基础上再打开一项

从什么都不加,到全部打开,每一步从 3.56 毫秒降到 0.85 毫秒。

要知道怎么加速,先要知道慢在哪。这要从 CPU 和 GPU 是怎么配合的说起,后面的每一项加速,解决的都是其中某一种慢。

  1. kernel。我们写的每一行 PyTorch 运算,比如 x + y、x.exp()、x @ w,在 GPU 上都是一个 kernel:一个专门做这件事的小程序。GPU 有成千上万个计算单元,一个 kernel 启动以后,让它们同时处理张量里的不同元素。
  2. 启动。GPU 不会自己决定下一步做什么,每个 kernel 都要由 CPU 来启动:Python 执行到这一行,经过 PyTorch 一层层的调度,最后告诉 GPU"用这些参数运行这个 kernel"。每次启动要花几微秒到十几微秒的 CPU 时间。
  3. 异步。CPU 启动 kernel 时,并不等 GPU 算完,而是把指令放进一个队列就立刻返回,接着执行下一行 Python;GPU 从队列里按顺序取出来执行。理想情况是 CPU 在前面不停地发,GPU 在后面不停地算。
  4. 同步。有些操作需要 GPU 的计算结果,比如 loss.item() 要把 GPU 上的数取回来,这时 CPU 必须停下来,等 GPU 把队列里的活干完。

于是一步训练的时间,由更慢的那一边决定:

CPU 启动一个 kernel GPU 执行这个 kernel 小模型:CPU 是瓶颈 CPUGPU GPU 每个 kernel 一下就算完,大部分时间空着,等 CPU 发下一条 大模型:GPU 是瓶颈 CPUGPU CPU 早早把指令发完,GPU 一直有活干;这时减少 CPU 的开销没有用

每个 kernel 的计算量很小时,GPU 一下就算完了,大部分时间在等 CPU 发下一条指令,这时 GPU 再快也没用,要减少的是启动的次数;每个 kernel 的计算量很大时,队列里总有活排着,减少 CPU 的开销就没有用了。

我们的模型属于前者。用 profiler(PyTorch 自带的性能分析工具,能列出一步里启动了哪些 kernel)数一下:不加任何优化时,每一步启动 255 次 kernel,耗时 3.56 毫秒,平均每次约 14 微秒,正好是启动一个 kernel 的典型开销。也就是说,时间几乎全花在 CPU 发指令上。1.04 和 1.08 里,宽度 48 时换更快的 GPU、更短的数字格式都没用,也是这个原因。

所以下面的几项,按它们减少的是什么来看:

  1. 减少同步:CPU 等 GPU 的时间。
  2. fused 优化器、SDPA:kernel 的个数。
  3. torch.compile:kernel 的个数,以及中间结果在显存里的读写。
  4. CUDA Graph:CPU 启动的次数。

代码里一共 6 级,每一级都在前一级的基础上再打开一项:

levels = ['baseline', 'no_sync', 'fused_adam', 'sdpa', 'compile', 'cudagraph']
no_sync     = level >= 1  # 减少 CPU 和 GPU 之间的同步
fused_adam  = level >= 2  # Adam 所有参数的更新合并成一个 kernel
sdpa        = level >= 3  # 注意力用 PyTorch 内置的 scaled_dot_product_attention
use_compile = level >= 4  # torch.compile:把一串小运算融合成少数几个 kernel
cudagraph   = level >= 5  # CUDA Graph:把一整步的 kernel 录下来,之后一次性重放

下面一项一项看。每一项都按"是什么、为什么能快、改了哪几行、我们这里快了多少"来讲。

1减少同步别让 CPU 停下来等

不加优化时,代码里有两处同步:

train_losses.append(loss.item())                     # 每一步都把 loss 取回 CPU:同步
x = torch.stack([data[i:i + block_size] for i in ix])  # 每一步在 CPU 上拼好 batch
return x.to(device), y.to(device)                     # 再从普通内存拷到 GPU:同步
CPU 启动 GPU 执行 CPUGPU loss.item():等 GPU 算完 ↑ GPU 空等 CPU 等的时候没人往队列里放新指令;CPU 拿到结果再发下一条时,又轮到 GPU 等

同步一次,流水线就断一次。改法是能不取回来就不取,非取不可就攒着一起取:

loss_sum = loss_sum + loss.detach()  # loss 留在 GPU 上累加,每 128 步才取回一次

# 训练数据整份放进显存,每步只把 16 个起点传过去,在 GPU 上切出窗口
ix = ix.pin_memory().to(device, non_blocking=True)
offsets = ix[:, None] + torch.arange(block_size, device=device)
return data[offsets], data[offsets + 1]

这里有两个新名词。普通的内存,操作系统随时可能把它挪到别处,GPU 不能直接从里面读,拷贝时要先拷到一块固定不动的中转区,CPU 得等着;锁页内存(pinned memory)就是一开始就固定不动的内存,GPU 可以直接读。non_blocking=True 让拷贝也放进队列,CPU 不等拷完就返回,只有源数据在锁页内存里才真正有效。

效果:快了 13%,代价是训练数据放进显存,多占 48 MB。效果不大的原因就在上面那张图:我们的 GPU 本来就在等 CPU,loss.item() 让 CPU 等 GPU 时,几乎不用等。只有 GPU 是瓶颈时,同步才真正浪费时间,那时 CPU 本可以提前把后面几步的指令都发出去。

2fused 优化器Adam 只用一个 kernel

Adam 更新一个参数要做好几次运算:更新 m、更新 v、修正偏差、除法、减法。每次运算一个 kernel,组织方式有三种:

for 循环 每个参数、每种运算各一个 kernel foreach 同一种运算,所有参数打包成一个 fused 整个更新只有一个 kernel 一个方块是一个 kernel(示意:9 个参数 × 十来种运算)

PyTorch 默认用 foreach。打开 fused 只要一个参数:

optimizer = torch.optim.Adam(params, lr=0.01, betas=(0.85, 0.99), fused=True)

效果:每步的 kernel 从 269 个降到 212 个,少了 57 个,快了 12%。数学完全一样,只是运算的组织方式不同。

3SDPA 和 FlashAttention注意力矩阵不进显存

注意力的公式是:

\[O = \mathrm{softmax}\Big(\frac{QK^\top}{\sqrt{d}}\Big)\,V, \qquad QK^\top \in \mathbb{R}^{T\times T}\]

我们手写的版本一行一个运算:

attn_logits = q @ k.transpose(-2, -1) / head_dim**0.5  # (B, H, T, T)
attn_logits = attn_logits.masked_fill(~causal_mask, float('-inf'))
attn_weights = softmax(attn_logits)
x_attn = attn_weights @ v

问题在中间那个 T×T 的矩阵。每一行都要把它完整地写进显存,下一行再读出来,反向传播时还要存着。上下文 256 时,它有 \(16 \times 4 \times 256 \times 256 \approx 420\) 万个数,而且和 \(T^2\) 成正比,上下文越长越大。

手写注意力 T × T 的注意力分数 显存 整块算出来,写进显存, softmax 再读出来、写回去;反向还要存着 FlashAttention T × T 的注意力分数 片上缓存小但极快 一次只取一小块,在片上算完分数、softmax、乘 v, 算完就丢;T×T 的矩阵从不进显存

FlashAttention(Dao et al. 2022)的想法是不让这个矩阵进显存。GPU 芯片上有一块很小但极快的缓存,把 q、k、v 切成小块,一块一块读进去,在里面算完这一块的分数、softmax、乘 v,再处理下一块。softmax 需要整行的最大值和总和才能归一化,它用一个边算边修正的技巧(online softmax,见最后的"深入")解决。整个注意力一个 kernel,反向时再按需把分数重算一遍,用计算换显存。

PyTorch 把各种注意力的实现统一成了一个函数,SDPA(scaled dot-product attention)。它会根据数据类型、head 维度、硬件,自动挑一个能用的最快实现:

x_attn = F.scaled_dot_product_attention(q, k, v, is_causal=True)

我们的 head 维度是 12,实测它选的是 FlashAttention。效果:每步少了 22 个 kernel,快了 11%,显存从 196 MB 降到 172 MB,注意力矩阵不用存了。

GPU 的存储分几层、各有多快,FlashAttention 的反向怎么算,留到 infra 章细讲。

4torch.compile把小运算融合起来

以 rmsnorm 为例,一行代码:

x * (x.pow(2).mean(dim=-1, keepdim=True) + 1e-5) ** -0.5

不编译时,这是 5 个 kernel:平方、求平均、加、开方取倒数、乘。真正的计算量极小,时间都花在启动和读写显存上。融合(fusion)就是把它们写成 1 个 kernel:读一次输入,在芯片上算完所有步骤,只写一次结果。

不融合:5 个 kernel 平方 求平均 加 ε 开方取倒数 乘 x 显存 每个 kernel 都从显存读输入、再把结果写回显存:启动 5 次,读写 10 次 融合以后:1 个 kernel 平方 → 求平均 → 加 ε → 开方取倒数 → 乘 x,中间结果留在芯片上 显存

torch.compile 会自动找出能融合的运算,只要一行:

batch_loss = torch.compile(batch_loss)

第一次调用时,它分三步把 Python 代码变成新的 kernel:

你的 Python 代码batch_loss(...) TorchDynamo运行时抓出计算图 AOTAutograd提前推出反向的图 Inductor生成融合后的 kernel
  1. TorchDynamo 一边运行 Python 代码,一边把用到的张量运算记录成一张计算图。
  2. AOTAutograd 提前推出反向传播的计算图,前向和反向放在一起优化。
  3. Inductor 找出可以融合的运算,为它们自动生成新的 GPU kernel(用 Triton 写的);矩阵乘法仍然交给 cuBLAS 这类专门的库。

效果:kernel 从 190 个降到 85 个,快了 1.6 倍,是单项最大的加速之一。显存也从 172 MB 降到 99 MB:融合以后,很多中间结果根本不写进显存;有些中间结果在反向时重新算一遍,比存着更划算。代价是编译时间,第一次运行时前 128 步多花了约 2.5 秒,编译结果会缓存下来,之后再跑就快了。

Triton 是什么、怎么自己写一个融合 kernel,留到 infra 章。

5CUDA Graph录下一整步,每步只启动一次

编译以后还剩 85 个 kernel,每一个仍然要 CPU 启动一次。但每一步训练做的事情一模一样:同样的 kernel,同样的顺序,同样的形状。CUDA Graph 的想法是把一整步的所有 kernel 录下来,存成一张图;之后每一步,CPU 只发一条"重放"的指令,GPU 自己按顺序执行里面的所有 kernel。

CPU 启动 GPU 执行 compile 之后:每个 kernel 还要 CPU 启动一次 CPUGPU 一步里 85 个 kernel,就要启动 85 次 CUDA Graph:整步录下来,每步只启动一次 CPUGPU 重放 重放 重放 重放 同样的 kernel,GPU 一个接一个执行,中间不用等 CPU;同样的时间里能跑好几步
batch_loss = torch.compile(batch_loss, mode='reduce-overhead')  # reduce-overhead 会自动用 CUDA Graph
...
torch.compiler.cudagraph_mark_step_begin()  # 每一步开始时告诉它:新的一步开始了

录下来的是"在这些显存地址上做这些运算",所以有三个限制:形状必须固定,换了 batch 大小或序列长度就要重录,所以我们只在训练时用,评估和生成时不用;每一步的新数据要先拷进录制时用的那块显存;录制的这一段里不能有同步。

效果:又快了 1.9 倍。GPU 执行的 kernel 数并没有减少(97 个,比 compile 还多一点),但 CPU 的启动次数从 83 次降到 12 次,这直接说明省下的时间在 CPU 那一侧。

设置和 1.08 一样:bpe1024,宽度 48,上下文 256,batch 16,4096 步,Adam 学习率 0.01 线性衰减,bf16 混合精度。计时只算训练的部分,读时间前先等 GPU 把排队的活干完;每一级看到的 batch 完全一样;每一级跑 3 个种子。

运行结果

先看 kernel。fused Adam、SDPA、compile 都在减少 GPU 执行的 kernel 数;CUDA Graph 的 kernel 数没有减少,减少的是 CPU 启动的次数:

GPU 执行的 kernel 数 什么都不加 269 + 减少同步 273 + fused Adam 212 + SDPA 190 + torch.compile 85 + CUDA Graph 97 CPU 启动的次数 255 261 200 180 83 12

再看 loss。6 级的种子范围全部重叠,加速没有改变训练结果:

1.172 1.176 1.180 什么都不加 1.1758 + 减少同步 1.1758 + fused Adam 1.1753 + SDPA 1.1756 + torch.compile 1.1754 + CUDA Graph 1.1776 验证集 bpb(点是 3 个种子平均,横线是范围)

减少同步和不加优化的结果一模一样,因为算的东西完全相同,只是 CPU 什么时候去取 loss 不同。其他几级有微小差别,因为融合、FlashAttention 改变了浮点运算的顺序,舍入误差不同,都在种子的波动以内。

速度上一共快了 4.2 倍,大头在 compile 和 CUDA Graph,两项合计约 3 倍。CUDA Graph 的速度波动最大(0.75 到 0.98 毫秒):每步不到 1 毫秒,又完全受 CPU 限制,机器上其他进程占用 CPU 时,影响就很明显。

最后补充一点:放到大模型上,这些加速还有用吗?我们把模型加宽,从 48 一直到 1536,只测速度:

宽度 483.5 → 0.8 ms,快 4.5 倍 无 同步 fused SDPA compile Graph 宽度 1923.3 → 0.8 ms,快 4.0 倍 无 同步 fused SDPA compile Graph 宽度 7684.0 → 2.4 ms,快 1.7 倍 无 同步 fused SDPA compile Graph 宽度 153610.6 → 9.0 ms,快 1.2 倍 无 同步 fused SDPA compile Graph 每步耗时,每个宽度单独一个纵轴;从左到右依次多打开一项

宽度 192 以下,不加优化时每步都是 3.3 毫秒左右,几乎不随宽度变,仍然卡在 CPU 启动 kernel 上,全部打开以后快 4 倍以上。宽度 768 时,GPU 的计算开始变得重要,CUDA Graph 已经没有帮助,compile 的融合还有用。宽度 1536 时,时间主要花在矩阵乘法上,GPU 成了瓶颈,只剩 compile 的融合(少读写显存)还能快 18%,全部加起来只快 1.2 倍。这正是开头那张时间线图的两种情况:小模型慢在 CPU 启动 kernel,大模型慢在 GPU 计算本身。

大模型训练里,这几项几乎都是标配:nanoGPT 用了 bf16 混合精度、torch.compile、FlashAttention、fused AdamW、锁页内存加非阻塞拷贝,基本就是这一节的全部内容。它们代价很小,又不改变数学。但大模型的速度主要不靠它们,而是靠更高效的矩阵乘法 kernel、多卡之间的通信和各种并行方式。这些留到 infra 章再讲。

+深入online softmax;一个测量的坑;词表补齐

online softmax。softmax 要先知道整行的最大值 \(m\)(减掉它防止 \(e^x\) 溢出)和总和 \(\ell\),才能归一化。FlashAttention 一次只看到一块分数 \(s_j\),于是维护三个量:目前见过的最大值 \(m\)、按这个最大值算的总和 \(\ell\)、还没归一化的输出 \(o\)。每读进一块:

\[m_{\text{新}} = \max\big(m,\ \max_j s_j\big)\]
\[\ell_{\text{新}} = \ell\, e^{m - m_{\text{新}}} + \sum_j e^{s_j - m_{\text{新}}}, \qquad o_{\text{新}} = o\, e^{m - m_{\text{新}}} + \sum_j e^{s_j - m_{\text{新}}}\, v_j\]

最大值变了,之前算的部分都乘上 \(e^{m - m_{\text{新}}}\) 修正一下。所有块处理完以后:

\[\text{输出} = o / \ell\]

结果和先算整行再 softmax 完全一样,只是浮点运算的顺序不同。

一个测量的坑。最初测速脚本每测完一级,就马上用 profiler 数一次 kernel。结果 profiler 运行过一次以后,同一个进程里之后的每一步都一直慢约 20%(同一个 SDPA,2.54 毫秒变成 3.05 毫秒)。改成先测完所有速度、最后再数 kernel 以后,结果才对上。测速度时,profiler 不能和计时放在同一个进程的同一段里。

词表补齐。GPU 的 Tensor Core 按固定大小的小块做矩阵乘法,维度不是它的整数倍时,边角就要用更慢的方式处理。GPT-2 的词表有 50257 个 token,nanoGPT 把它补到 50304(64 的倍数),多出来的永远用不到,但矩阵乘法更快了。我们的词表是 1024,本来就是 64 的倍数,所以不用做。