1.09 工程加速
前面几节改的都是"算什么":优化器、学习率、精度。这一节一点数学都不改,只想利用 PyTorch 现在开箱即用的一些方法来加速。每一项都只要改几行代码,叠在一起,同样的训练快了 4 倍多,loss 不变。
从什么都不加,到全部打开,每一步从 3.56 毫秒降到 0.85 毫秒。
要知道怎么加速,先要知道慢在哪。这要从 CPU 和 GPU 是怎么配合的说起,后面的每一项加速,解决的都是其中某一种慢。
- kernel。我们写的每一行 PyTorch 运算,比如
x + y、x.exp()、x @ w,在 GPU 上都是一个 kernel:一个专门做这件事的小程序。GPU 有成千上万个计算单元,一个 kernel 启动以后,让它们同时处理张量里的不同元素。 - 启动。GPU 不会自己决定下一步做什么,每个 kernel 都要由 CPU 来启动:Python 执行到这一行,经过 PyTorch 一层层的调度,最后告诉 GPU"用这些参数运行这个 kernel"。每次启动要花几微秒到十几微秒的 CPU 时间。
- 异步。CPU 启动 kernel 时,并不等 GPU 算完,而是把指令放进一个队列就立刻返回,接着执行下一行 Python;GPU 从队列里按顺序取出来执行。理想情况是 CPU 在前面不停地发,GPU 在后面不停地算。
- 同步。有些操作需要 GPU 的计算结果,比如
loss.item()要把 GPU 上的数取回来,这时 CPU 必须停下来,等 GPU 把队列里的活干完。
于是一步训练的时间,由更慢的那一边决定:
每个 kernel 的计算量很小时,GPU 一下就算完了,大部分时间在等 CPU 发下一条指令,这时 GPU 再快也没用,要减少的是启动的次数;每个 kernel 的计算量很大时,队列里总有活排着,减少 CPU 的开销就没有用了。
我们的模型属于前者。用 profiler(PyTorch 自带的性能分析工具,能列出一步里启动了哪些 kernel)数一下:不加任何优化时,每一步启动 255 次 kernel,耗时 3.56 毫秒,平均每次约 14 微秒,正好是启动一个 kernel 的典型开销。也就是说,时间几乎全花在 CPU 发指令上。1.04 和 1.08 里,宽度 48 时换更快的 GPU、更短的数字格式都没用,也是这个原因。
所以下面的几项,按它们减少的是什么来看:
- 减少同步:CPU 等 GPU 的时间。
- fused 优化器、SDPA:kernel 的个数。
- torch.compile:kernel 的个数,以及中间结果在显存里的读写。
- 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:同步
同步一次,流水线就断一次。改法是能不取回来就不取,非取不可就攒着一起取:
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,组织方式有三种:
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注意力矩阵不进显存
注意力的公式是:
我们手写的版本一行一个运算:
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\) 成正比,上下文越长越大。
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:读一次输入,在芯片上算完所有步骤,只写一次结果。
torch.compile 会自动找出能融合的运算,只要一行:
batch_loss = torch.compile(batch_loss)
第一次调用时,它分三步把 Python 代码变成新的 kernel:
- TorchDynamo 一边运行 Python 代码,一边把用到的张量运算记录成一张计算图。
- AOTAutograd 提前推出反向传播的计算图,前向和反向放在一起优化。
- 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。
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 启动的次数:
再看 loss。6 级的种子范围全部重叠,加速没有改变训练结果:
减少同步和不加优化的结果一模一样,因为算的东西完全相同,只是 CPU 什么时候去取 loss 不同。其他几级有微小差别,因为融合、FlashAttention 改变了浮点运算的顺序,舍入误差不同,都在种子的波动以内。
速度上一共快了 4.2 倍,大头在 compile 和 CUDA Graph,两项合计约 3 倍。CUDA Graph 的速度波动最大(0.75 到 0.98 毫秒):每步不到 1 毫秒,又完全受 CPU 限制,机器上其他进程占用 CPU 时,影响就很明显。
最后补充一点:放到大模型上,这些加速还有用吗?我们把模型加宽,从 48 一直到 1536,只测速度:
宽度 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\)。每读进一块:
最大值变了,之前算的部分都乘上 \(e^{m - m_{\text{新}}}\) 修正一下。所有块处理完以后:
结果和先算整行再 softmax 完全一样,只是浮点运算的顺序不同。
一个测量的坑。最初测速脚本每测完一级,就马上用 profiler 数一次 kernel。结果 profiler 运行过一次以后,同一个进程里之后的每一步都一直慢约 20%(同一个 SDPA,2.54 毫秒变成 3.05 毫秒)。改成先测完所有速度、最后再数 kernel 以后,结果才对上。测速度时,profiler 不能和计时放在同一个进程的同一段里。
词表补齐。GPU 的 Tensor Core 按固定大小的小块做矩阵乘法,维度不是它的整数倍时,边角就要用更慢的方式处理。GPT-2 的词表有 50257 个 token,nanoGPT 把它补到 50304(64 的倍数),多出来的永远用不到,但矩阵乘法更快了。我们的词表是 1024,本来就是 64 的倍数,所以不用做。