scratch2modern
第一章 · 训练

1.08 数值精度

这一节数值精度:fp64 到 fp8
结果bf16 混合精度和 fp64 结果一样;宽模型上快几十倍

其实模型参数的精度也有讲究,经常听到量化、混合精度等等的词,实际上它们讨论的都是模型参数的数值精度。我们的项目目前一直在用 fp64,这并不主流,它的精度很高,但相比之下计算速度会更慢,存储占用会更多。

fp64 1每步 2.8 秒 fp32 23每步 124 毫秒 tf32 52每步 56 毫秒 fp16 混合 + loss scaling 71每步 41 毫秒 bf16 混合 71每步 41 毫秒 fp8 82每步 35 毫秒 纯 bf16(去掉主副本) 84每步 34 毫秒 每秒实际做的浮点运算(TFLOPS,万亿次),越高越快;灰字是每一步的时间

把模型加宽到 3072,只测速度。fp64 每一步要 2.8 秒,纯 bf16 只要 34 毫秒,差了 82 倍。

常见的做法是用更小的精度,那都有什么精度呢?先看浮点数是怎么存的。它就像科学计数法 \(6.02 \times 10^{23}\),由三部分组成:

\[x = (-1)^{\text{符号}} \times 2^{\text{指数}} \times 1.\underbrace{b_1 b_2 \cdots b_m}_{\text{尾数,}m\text{ 位}}\]

指数位决定能表示多大、多小的数,也就是范围;尾数位决定有效数字有几位,也就是精度。总位数一定,给指数多一位,尾数就少一位。常见的几种格式:

符号 指数(范围) 尾数(精度) fp64 64 位 = 1 + 11 + 52 fp32 32 位 = 1 + 8 + 23 tf32 19 位 = 1 + 8 + 10 fp16 16 位 = 1 + 5 + 10 bf16 16 位 = 1 + 8 + 7 fp8 E4M3 8 位 = 1 + 4 + 3 fp8 E5M2 8 位 = 1 + 5 + 2
  1. fp64 和 fp32:一个 64 位,一个 32 位。fp32 的有效数字约 7 位,范围到 \(10^{38}\)。
  2. fp16 和 bf16:都是 16 位,取舍正好相反。fp16 尾数多,精度高一点,但最大只能表示 65504,最小的数也不够小;bf16 指数和 fp32 一样是 8 位,范围和 fp32 一样大,代价是有效数字只有 2 位多。
  3. tf32:严格说不是一种存储格式,而是一个硬件开关。数还是按 fp32 存,只是做矩阵乘法时,硬件内部把尾数截到 10 位来算。
  4. fp8:只有 8 位,分两种。E4M3 尾数多一位,精度高一些,最大 448;E5M2 指数多一位,范围大一些,最大 57344。

位数少了,最直接的影响是舍入。尾数只有 \(m\) 位,在 \(x\) 附近能表示的数之间就有间距:

\[\text{相邻两个数的间距} \approx |x| \cdot 2^{-m}\]

bf16 的 \(m = 7\),1 的下一个数是 1.0078,中间的数都表示不了,只能就近取一个。于是一个大数加上一个很小的数,结果可能还是那个大数:

>>> torch.tensor(1.0, dtype=torch.bfloat16) + 0.003
tensor(1., dtype=torch.bfloat16)

这对训练很要命。参数更新就是 p -= lr * update,参数本身在 0.1 左右,bf16 的间距约 0.0005;Adam 每一步的更新大约是学习率乘一个 0.1 左右的数。学习率降到 0.005 以下,很多更新就小于间距的一半,加不上去了,而学习率线性衰减时,后一半的训练都在这个区间。

所以常用的办法是混合精度:不同的数用不同的精度。参数留一份 fp32 的原件,叫主副本,每一步的更新都加在它上面,小的更新不会丢;计算量最大的矩阵乘法,再临时转出一份 16 位的副本来算。PyTorch 里用 autocast 来做这件事,它会自动决定哪些运算用 16 位、哪些留在 fp32:

params = ...  # 参数照常用 fp32 存,这就是主副本

with torch.autocast('cuda', dtype=torch.bfloat16):  # 只有前向放在 autocast 里
    loss = loss_fn(x, y)  # 矩阵乘法自动用 bf16 算,exp、求和这类自动用 fp32
loss.backward()           # 梯度回到 fp32 的参数上
optimizer.step()          # 更新加在 fp32 的主副本上

fp16 还有一个问题:范围太小,小于 \(6\times10^{-8}\) 的数会下溢成 0,而梯度往往很小。loss scaling 的办法是先放大,再缩回去:

\[\mathcal{L} \to S\cdot\mathcal{L} \;\Rightarrow\; g \to S\cdot g, \qquad \text{更新前再除以 } S\]

反向传播是一连串乘法,loss 放大 \(S\) 倍,所有梯度都跟着放大 \(S\) 倍,原本会变成 0 的小梯度就能存下了;更新之前,在 fp32 里再除回去。\(S\) 也不能太大,否则大的梯度会溢出成 inf,所以一般动态调整。PyTorch 里的工具叫 GradScaler:

scaler = torch.amp.GradScaler('cuda', init_scale=2.0 ** 16, growth_interval=2000)
...
scaler.scale(loss).backward()  # 1. 把 loss 乘以当前的倍数,再反向传播
scaler.step(optimizer)         # 2. 把梯度除回去;如果梯度里有 inf,这一步就不更新
scaler.update()                # 3. 溢出了就把倍数减半,连续 2000 步没溢出就翻倍

bf16 的范围和 fp32 一样大,就不需要这一步,这也是它后来取代 fp16 的原因之一。

到了 fp8,范围窄到放大一个倍数也不够了,得给每个张量单独算一个缩放因子,把它整个挤进 fp8 的范围,用完再乘回去:

\[s = \frac{\max|x|}{448}, \qquad x \approx s \cdot \mathrm{fp8}\Big(\frac{x}{s}\Big)\]
def quantize(x, fmt):
    # 整个张量一个缩放因子:让最大的那个数刚好落在 fp8 的最大值上
    scale = x.abs().max().float().clamp(min=1e-12) / torch.finfo(fmt).max
    return (x / scale).to(fmt), scale

# 矩阵乘法直接吃 fp8,算完再乘回两个缩放因子
y = torch._scaled_mm(xq, wq, scale_a=sx, scale_b=sw, out_dtype=torch.bfloat16)

448 是 E4M3 的最大值。我们的 fp8 只用在 Transformer 层内的 6 个线性层上,前向用 E4M3,反向的梯度用 E5M2,lm_head 和注意力还是 bf16。

从这一节开始,优化器和学习率调度直接用 PyTorch 自带的(torch.optim.Adam、LambdaLR),不再手写。设置和 1.07 一样:bpe1024,宽度 48,上下文 256,batch 16,4096 步,Adam 学习率 0.01 线性衰减。我们比较 8 种设置,分三组(每种一个文件,在 GitHub):

  1. 基线:fp64、fp32、tf32。所有数都用同一种格式,只是位数不同。
  2. 论文的路线:fp16 混合精度加 loss scaling(Micikevicius et al. 2018),然后是现在的标准 bf16 混合精度,再到 fp8(DeepSeek-V3 的简化版)。
  3. 消融:从论文的方案里拿掉一个部件,看它是不是真的必要。纯 bf16 拿掉了 fp32 主副本,参数、梯度、优化器状态全是 bf16;另一个是 fp16 混合精度拿掉 loss scaling。

评估做两次。训练过程中,用训练时的精度评估;训练结束后,再把参数转成 fp64,去掉 autocast 和 fp8,重新评估一次。后者只看训练出来的权重好不好,两者之差就是推理时的精度损失。每种设置跑 3 个种子。

运行结果

转成 fp64 再评估(横线是 3 个种子的范围) 用训练时的精度评估 1.17 1.18 1.19 fp64 1.1757 fp32 1.1756 tf32 1.1753 fp16 混合 + loss scaling 1.1761 bf16 混合 1.1758 fp8 1.1834 纯 bf16(去掉主副本) 1.1841 fp16 混合(去掉 loss scaling) 1.1777 验证集 bpb,越低越好

基线:fp32 和 fp64 的结果一样,但快 2.8 倍(11.8 秒对 33.4 秒),显存也减半(159 MB 对 299 MB)。fp64 的精度远远超出了训练的需要。tf32 和 fp32 也一样,在这个模型上并不更快。

论文的路线:fp16 和 bf16 混合精度都没有损失,和 fp32 的差距在种子波动以内。fp8 差了 0.008,用 fp8 推理时又差了 0.006。从 loss 曲线看,fp8 从训练一开始就比 fp64 高 0.01 以上,一直到最后,fp8 的尾数只有 3 位,前向本身就算不准。

奇怪的是,这一组在我们的模型上都比 fp32 慢:fp16 混合 14.0 秒,bf16 混合 12.5 秒,fp8 21.6 秒。原因又是 1.04 讲过的,我们的模型太小,时间全花在启动 kernel 上,而每多一步处理就要多启动 kernel:loss scaling 每步都要检查梯度有没有溢出,autocast 要在 fp32 和 16 位之间来回转,fp8 每次矩阵乘法前都要求最大值、缩放、转格式。显存也几乎没省,只少了约 7%,因为参数、梯度、Adam 状态都还是 fp32,还要多存一份 16 位副本。

消融:拿掉 fp32 主副本,纯 bf16 差了 0.008,主副本是必要的。用 bf16 评估和用 fp64 评估同一组权重,只差 0.0005,所以不是前向算不准,而是训练时出了问题:

+0.000 +0.005 +0.010 0 1024 2048 3072 4096 步数 bf16 混合 纯 bf16 比 fp64 高多少(3 个种子平均)

纯 bf16 和 bf16 混合精度,各自比 fp64 高多少。

前 3000 步,纯 bf16 和 fp64 的差距只有 0.003 以内;最后 1000 步,学习率越来越小,差距拉大到 0.010。这正是前面说的舍入:每一步的更新小于 bf16 的间距,被吃掉了,加不到参数上。有主副本的 bf16 混合精度,一直贴着 0。代价换来的是真正的显存减半,纯 bf16 只要 98 MB,因为所有数都是 16 位了。

拿掉 loss scaling,在我们这里影响不明显。不放大时,矩阵参数的梯度里约 12% 下溢成了 0,放大以后只剩 0.03%;可结果只差 0.0016,两者的种子范围大部分重叠。我们的模型小,梯度规整,下溢掉的只是本来就很小的那部分。

加宽模型,只测速度。宽度 48 的模型太小,精度对速度的影响看不出来。所以另写了一个测速脚本,模型和精度的处理都一样,用随机权重,宽度从 48 一直加到 3072,每个组合只测速度。

0 30 60 90 48 96 192 384 768 1536 3072 模型宽度(对数坐标);纵轴:TFLOPS fp64 1 fp32 23 tf32 52 bf16 混合 71 fp8 82 纯 bf16 84

分成三段。宽度 192 以下,除了 fp64,所有精度都是两三毫秒一步,几乎不随宽度变,时间全花在启动 kernel 上,多启动 kernel 的方案反而更慢。宽度 384 到 768,开始拉开差距,fp32 先跟不上,接着 tf32 和 16 位格式也依次变慢。宽度 1536 以上,各精度都到了自己的上限,大致按"格式越短越快"排好。

fp64 从宽度 192 起就卡在约 1 TFLOPS,这已经是这块卡 fp64 的上限,放到大一点的模型上是不可行的。fp32 卡在约 23,tf32 到 52,只需要一行设置就翻了一倍多。bf16 混合精度 71,纯 bf16 84,后者快 19%,因为 autocast 每次矩阵乘法前都要把 fp32 的参数转成 bf16 副本。fp8 没有达到预期,只比 bf16 混合快 16%,原因放在最后的"深入"里。

fp16 混合精度生成的故事,和 fp64 训练的模型看不出区别:

Lucy was so happy and thanked her helping the ball. She climbed up and started to play with her friends. They all had a great day.

最后补充一点:大模型训练是怎么做的?bf16 混合精度和 fp32 训练效果一样(Kalamkar et al. 2019),是现在大模型训练的标准。fp32 主副本是必要的:Gopher 的附录发现,即使用随机舍入(按距离远近的比例,随机向上或向下取整),bf16 参数也不如保留一份 fp32 主副本。

不一样的地方主要来自规模。大模型的矩阵足够大,低精度直接带来成倍的加速,我们的模型太小,反而更慢。loss scaling 在我们这里可有可无,大模型用 fp16 时,即使有 loss scaling 也经常发散,BLOOM 早期在 fp16 下训练 104B 的模型就遇到了无法恢复的发散,最后改用 bf16 才解决。fp8 在我们这里损失 0.008,DeepSeek-V3 用更细的缩放,在 671B 的模型上验证了 fp8 训练是可行的。

+深入fp8 为什么没有更快

单独测矩阵乘法时,fp8 确实快:4096×4096 的矩阵,fp8 是 255 TFLOPS,bf16 是 105,快 2.4 倍。可放到整个训练里,宽度 3072 时只比 bf16 混合精度快 16%,和纯 bf16 差不多。加速被摊薄了,原因有三个:

  1. 只有 6 个线性层用了 fp8,lm_head 和注意力仍然是 bf16。
  2. 每次量化都要先求最大值、再缩放、再转格式,反向还要为转置再存一份。
  3. 这些步骤各自是一个 kernel,没有和矩阵乘法合并成一个。

精度上,我们用整个张量一个缩放因子,问题出在离群值上:只要张量里有一个特别大的数,缩放因子就被它定下来,其余的数都被压到很小,挤在 fp8 最粗糙的那一段里。DeepSeek-V3 的做法是分块缩放:激活每 1×128 个数一个缩放因子,权重每 128×128 块一个,离群值只影响自己那一小块;再加上提高矩阵乘法里累加的精度,以及和矩阵乘法融合在一起的 kernel。他们在 671B 的模型上,loss 的相对误差小于 0.25%。