🏠 总目录📚 本教程 混合精度 ← →

AI基础设施 · 06

用了 BF16,为什么某些状态还要留在 FP32?

较低精度可以减少元素存储和搬运,但数值范围、梯度与权重更新有不同风险。原环图只描述一种显式主副本方案。

读完能判断:区分动态范围、权重更新与梯度信息损失,理解一种混合精度方案。

📑 本页目录(点开跳转)

06 · 混合精度

⏱ 30 分钟 | ⭐ 手算舍入与梯度缩放


🎯 一句话

同一批数据改成较低精度后,显存占用降了,训练损失却突然成了 NaN(非数值,例如无效浮点运算产生的结果)。也可能反过来,模型数值正常,训练一步却没变快。混合精度(Mixed Precision)把低精度用于合适的计算或张量,把容易积累误差的步骤留在较高精度。沿用第 3 章的字节和搬运账本,本章再分别查数字装不装得下、会舍入到哪里,以及算子的哪一步用了什么精度。


🔢 一、五种数字格式

同样用 16 位,为什么 FP16 能分开两个很接近的数,BF16 却能存下 FP16 装不下的大数?位数就像固定的预算。符号位决定正负,指数决定乘上哪一档 2 的幂,尾数中实际存储的小数位决定同一档能分多细。

对照

FP32 [符号 1][指数 8][尾数 23] ← 传统标准

TF32 [符号 1][指数 8][尾数 10] ← Ampere 支持的矩阵计算格式,是否启用由框架设置决定

FP16 [符号 1][指数 5][尾数 10] ⚠️ 范围窄

BF16 [符号 1][指数 8][尾数 7] ← 正规指数范围与 FP32 相同,附近的数字间隔更大

FP8 [符号 1][指数 4–5][尾数 2–3] ← 多种 8 位格式,硬件和内核支持须查证

↑ 决定【范围】 ↑ 决定【精度】

格式 最大有限正数 最小正正规值 1 右侧相邻数的间隔
FP32 ~3.4e38 ~1.2e-38 2−23
FP16 65504 ⚠️ ~6e-5 ⚠️ 2−10
BF16 ~3.4e38 ⭐ ~1.2e-38 ⭐ 2−7

先看 1 到 2(不含 2)这一档。指数为 0,乘数 20 就是 1。对这些正规正数,开头的二进制 1 隐含在格式里,不占尾数的小数位。若存 p 个小数位,可用值就是 1 + f / 2p,其中 f 是从 0 到 2p − 1 的整数。f 每增加 1,值就前进一格。因此 FP16 的格距是 1 ÷ 1024,BF16 的格距是 1 ÷ 128。在别的指数档,格距也随那一档的 2 的幂放大或缩小。

同为 16 位,舍入与范围不同
输入FP16BF16
1 + 2−9精确表示舍入为 1
65,536超出有限范围精确表示

先算 1 附近的舍入。1 + 2−9 约等于 1.001953,也是 1 + 2 ÷ 1024,正好落在 FP16 从 1 开始的第 2 格。BF16 的右邻是 1 + 1 ÷ 128,中点是 1 + 1 ÷ 256。输入在中点左边,按最近值舍入为 1。

再算大数能否装下。FP16 最大一档的指数是 15,最大尾数是 1023。上限为 (1 + 1023 ÷ 1024) × 32,768 = 65,504,所以 65,536 超出有限范围。BF16 可以取指数 16,尾数的小数部分为 0,恰好得到 1 × 216 = 65,536。

BF16 的正规指数范围与 FP32 一样宽,最大有限值仍略小,次正规范围和舍入间隔也不同。遇到 FP16 前向溢出时,可以先核对设备、算子是否支持 BF16,再用同一批数据复查误差和速度。若任务更在意数值分辨率,且数值始终在 FP16 合适的范围内,FP16 或局部 FP32 都值得对照。CUDA 浮点格式表


💰 二、为什么快:三个来源

三种收益,分别核算

① 计算:匹配的矩阵内核可以用 Tensor Core
② 搬运:真正缩小的张量少读写一些字节
③ 容量:节省出来的显存有时能放入更大的批次

算力与时间用不同的量。A100 规格给出普通 FP32 的峰值 19.5 TFLOPS、稠密 BF16 Tensor Core 的峰值 312 TFLOPS(每 TFLOPS 表示每秒 1012 次浮点运算)。312 ÷ 19.5 = 16,比较的是两种计算路径的峰值。如果基线已用稠密 TF32 Tensor Core,峰值是 156 TFLOPS,规格比变成 312 ÷ 156 = 2。训练一步还要等读写、其他算子和同步。A100 数据手册

字节变少不等于带宽变小。假设一个逐元素操作读 100 万个元素并写回 100 万个结果,无缓存复用,也没有额外读写。FP32 共 (100 万 + 100 万) × 4 = 800 万字节,若输入和输出都能存为 BF16,则是 400 万字节。若两条路径都能以 1 TB/s(每秒 1012 字节)搬运,按「字节数 ÷ 带宽」分别是 8 μs 和 4 μs。这只是搬运时间的理想估算。若还需把张量转回 FP32、重新分配缓冲区或等待数据,整步未必按这个比例缩短。


⚙️ 三、"混合"精度:哪些用低精度,哪些不能

先固定本例实现:下图采用 FP32 主权重更新、低精度计算副本和 FP32 Adam m/v 的一种常见方案。混合精度的定义是组合多种数值精度;是否另存 master 副本、状态 dtype 与归约/累加精度,要按框架、优化器和算子核对,不能由“用了 BF16”直接推定。

关键信息

看到一种 dtype,先问它指的是哪一处
位置一次矩阵乘的常见例子
算子输入内核拿 BF16 权重和 BF16 激活值做乘法。
内部累加矩阵乘的一个输出要把许多乘积相加。用 FP32 累加可减少小项在求和时被舍掉的风险,但读入时已经舍掉的信息回不来。
输出 dtype累加结果仍可转换成 BF16 输出,因此看到 BF16 输出无法判断中间怎样累加。
跨步保存的状态模型参数、梯度缓冲和 Adam 状态各自有存储精度。由训练配置决定,不能只看前向算子的输入输出。

自动混合精度(Automatic Mixed Precision,AMP)的 autocast 按设备和算子选择执行 dtype。以 PyTorch CUDA 为例,符合条件的矩阵乘可以走较低精度,Softmax、LayerNorm 等符合条件的调用有 FP32 策略。原地调用、指定 dtype=、融合内核等情况要查具体策略。FP32 累加也只是常见选择,某些内核会在中间降低精度。PyTorch AMP 算子表 · PyTorch 数值精度说明

⭐ 为什么本例使用 FP32 主权重副本

因果链

演示:权重 1.0,更新增量 +0.0001(如负梯度产生的上调)
FP16 下:1.0 右侧间隔是 1 ÷ 1024,舍入中点在 1.0 + 1 ÷ 2048
0.0001 小于 1 ÷ 2048,写回 FP16 时 1.0001 舍入为 1.0
所以:
· 用 FP32 保存主权重,更新累加在 FP32 上
· 下图用 BF16 计算副本示意;改用 FP16 也可以保留 FP32 更新路径
用 BF16 计算副本,在 FP32 主权重上累加更新 cast cast to FP32 optimizer.step():更新【在 FP32 上累加】 FP32 主权重 BF16 权重 前向 / 反向计算示例 BF16 梯度
本图是一种显式主副本方案:FP32 主权重转成 BF16 供计算,所得梯度转回 FP32 更新。高精度权重累加可减少小更新被权重舍入吞掉的风险;已在低精度梯度中丢失的信息,不能靠事后转回 FP32 恢复。图示不代表每个 autocast 实现都另存一份持久低精度权重。

🔑 这给出第 3 章所用的一种 "12 字节/参数" 预算: FP32 主权重 4 + Adam 的 m 4 + v 4 = 12。 这里的 12 仅计这三项;若另计 FP32 梯度 4 字节,才得到该假设下的 16。持久低精度权重副本若另占 2 字节,还要另外计入;激活、工作区和分片/卸载也须单独核算。这不是所有 AMP/BF16 训练的固定总量。 本例可减少适用激活/计算张量的字节数;FP32 m/v 本身不因 autocast 自动减半,其他实现需重算预算。


🩹 四、损失缩放:先放大,后还原

正规下限不是非零下限:IEEE binary16 的最小正正规值为 2−14,最小正次正规值为 2−24。因此不能仅因 1e−7 小于约 6e−5 就断言它一定变成 0;次正规区的相对精度更低,足够小的数仍可能舍入为 0。算子是否支持次正规或采用 flush-to-zero,要核对具体指令/内核/设置,不能当作所有 GPU 的通则。

如果反向传播中有很小的梯度要经过 FP16 路径,可以先放大损失,使这些值在低精度计算时更有机会保留下来。这叫损失缩放(Loss Scaling)。设 L 是原损失,g 是它对某个权重的梯度,S 是本步固定的正缩放因子。把反向传播的入口改成 S × L,由于常数可提出求导,理想情况下梯度变成 S × g。更新前除以 S 还原,因此没有故意改变学习率。低精度计算仍可能舍入,已经丢失的值也无法靠事后放大恢复。

手算放大后,小梯度留下,大梯度可能溢出

先看小梯度。令 g = 2−27。它只有最小正次正规值 2−24 的 1/8,按最近值舍入为 0。先乘演示因子 S = 8192 = 213,得到 213 × 2−27 = 2−14,正好可由 FP16 正规值表示。在较高精度里还原,2−14 ÷ 213 = 2−27。

再看同一轮里的大梯度。若另一处 g = 16,乘同一个 8192 得 131,072。假设这个结果也必须经过 FP16,按最近值转换时溢出为 inf。即使小梯度保住了,单优化器这一轮仍应跳过更新。若后续试到 S = 2048,16 × 2048 = 32,768 可以表示。缩放因子太小则可能重新丢掉小值。

用 Python 3 标准库的 struct 做同一个二进制舍入实验。格式 e 把数转换成 binary16 再读回。Python 的转换会对过大的有限输入报溢出,因此示例将该错误记作 inf,以便展示跳步判断。这里只模拟一次写入,不模拟 GPU 内核或训练过程。

import math
import struct

def as_fp16(value):
    try:
        return struct.unpack("e", struct.pack("e", float(value)))[0]
    except OverflowError:
        return math.copysign(math.inf, value)

small = 2.0 ** -27
scale = 8192
scaled_small = as_fp16(small * scale)
scaled_large = as_fp16(16 * scale)

print("未缩放:", as_fp16(small))
print(f"放大、还原: {scaled_small:.10g}, {scaled_small / scale:.10g}")
print("同组跳过更新:", not math.isfinite(scaled_large))
print("试用更小的因子:", as_fp16(16 * 2048))

输出依次是 0.0、6.103515625e-05, 7.450580597e-09、True、32768.0。第一行和第二行对照出小梯度是否留下,第三行说明本组里另一个梯度非有限,第四行只说明较小因子下这个大值装得下。

PyTorch 训练一步的缩放、裁剪与跳步顺序

autocast 中做前向和计算损失退出 autocast,再用放大的损失反向传播
如需裁剪,先 unscale_ 还原按原单位裁剪
scaler.step:有 inf / NaN 则跳过这个优化器的更新scaler.update:为后续步调整缩放因子

下方是两个独立的 CUDA 分支骨架。使用前需提供放在同一设备上的模型和输入 x、能返回标量损失的前向以及绑定模型参数的 opt。每个训练步开始前应清理上一轮梯度,GradScaler 则在训练循环外初始化一次。不裁剪时,scaler.step(opt) 会先在内部还原梯度;累积多个小批次时,在完整一组梯度累积完以后只还原一次,同组保持相同的缩放因子。出现非有限梯度后通常减小因子,连续若干次正常更新后可以试着增大因子。PyTorch AMP 示例

BF16 因为正规指数范围更宽,常规 BF16 AMP 通常省略这一步缩放。遇到前向已出现 inf 或 NaN,先查产生它的算子、输入和 dtype;调梯度缩放无法修复发生在前向的溢出。

# 🧩 骨架:`model` 来自你自己的代码,这一段只看写法
# FP16:需要 GradScaler
import torch
scaler = torch.amp.GradScaler()
with torch.autocast("cuda", dtype=torch.float16):
    loss = model(x)
scaler.scale(loss).backward()
scaler.unscale_(opt)                              # ⭐ 裁剪前必须先还原
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
scaler.step(opt); scaler.update()

# BF16:干净得多 ⭐
with torch.autocast("cuda", dtype=torch.bfloat16):
    loss = model(x)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
opt.step()

先还原再裁剪是因为阈值按原梯度定。以单个梯度 0.5、裁剪上限 1、S = 8192 为例。正确顺序把 4096 还原成 0.5,无需裁剪。若先把 4096 裁成 1 再还原,结果只剩 1 ÷ 8192 ≈ 0.000122,原本合格的更新被错误压小。


⚠️ 五、五个真实的坑

坑 症状 解法
维度没对齐 精度改了但速度没变 核对硬件、库版本和实际内核。FP16 的 8 元素、INT8 的 16 元素对齐是常见效率提示,先比较补齐后的真实开销。
在 autocast 里手动 .half() 类型混乱、报错或静默降速 让 autocast 自己管,别手动转
LayerNorm/Softmax 用低精度累加 loss 抖动、NaN PyTorch CUDA autocast 对符合条件的这些算子有 FP32 策略,须核对版本/调用方式及内核 ✅
梯度裁剪前没 unscale 裁剪失效,训练发散 见上面代码
FP16 训练中期突然 NaN 可能是前向溢出,也可能只在缩放后的反向梯度里出现 先定位第一个非有限值。前向可评估 BF16 或局部 FP32,缩放引发的反向溢出才考虑缩放策略。

💥 一个高频的困惑:"我开了 AMP,为什么没变快?" 以下是原有的四个排查线索。第 ① 项的倍数是对齐提示,是否能走 Tensor Core 以及补齐是否划算,要看实际调用的库和内核。NVIDIA 矩阵乘对齐说明

① 矩阵维度是 8 的倍数吗?(4095 → 4096)
② 模型是不是太小?(小 kernel 的启动开销占主导)
③ 瓶颈是不是根本不在 GPU?(第 4 章的 dataloader 实验)
④ 用 profiler 确认 Tensor Core kernel 真的被调用了

🚀 六、FP8:H100 之后的下一步

以 Transformer Engine 的混合格式配方为例

E4M3:指数 4 位、小数 3 位同一指数档更细,常用于前向激活和权重
E5M2:指数 5 位、小数 2 位表示范围更宽,该配方可用于反向梯度

从 BF16 换成 FP8,只有真正转成 8 位存放的元素从 2 字节降为 1 字节,峰值计算吞吐也要按具体芯片、模式和内核查证。Transformer Engine 的当前/延迟缩放可以为每个张量使用一个缩放因子,也有分块缩放等配方。这里的因子用于把张量数值放入 FP8 的可表示范围,和前一节放大训练损失的做法是两件事。权重、激活、梯度或 KV Cache 选哪一种存储格式,取决于场景、支持的路径和误差实测。Transformer Engine 当前缩放 · 分块缩放


🔗 和站内其他章的关系

相关的地方 这里的位置
第 2 章 Tensor Core 混合精度快的真正原因 ⭐
第 3 章 带宽瓶颈 按实际精度重算要搬的字节
第 3 章 12 字节/参数 FP32 主权重的来源
第 18 章 量化 本章侧重为算子分配精度;第 18 章另算 INT8/INT4 的量化刻度与误差
ML 基础第 11 章 NaN 排查 FP16 溢出是常见原因
《机器学习与深度学习基础》09 优化器与学习率 lr 常在 1e-4 量级 lr × 梯度 可能小于低精度权重的间隔,这是本例选 FP32 更新累加的动机,不是所有实现必存额外 master 的证明 ⭐

✅ 检查点

  1. 在 1 附近,1 + 2−9 分别写进 FP16、BF16 时会怎样?65,536 又会怎样?
  2. 混合精度的三个性能来源是什么?为什么 A100 的 16 倍规格比不是一步训练的加速比?
  3. 算子输入和输出都是 BF16,内部累加一定是 BF16 吗?
  4. 本例为什么用 FP32 主权重更新?为什么 1.0 加 0.0001 写回 FP16 会丢掉这次更新?
  5. 12 字节/参数计了哪三项?再计 FP32 梯度是多少?
  6. 小梯度 2−27 乘 8192 后变成多少?同一步还有一项梯度 16,经过 FP16 后能否更新?
  7. 梯度是 0.5、裁剪上限是 1 时,为什么放大到 4096 后不能直接裁剪?
  8. 打开 AMP 没变快,如何判断是矩阵内核、数据搬运还是 GPU 在等数据?
  9. Transformer Engine 的混合 FP8 配方怎样选 E4M3 和 E5M2?其他配方必须这么分吗?
👀 答案
  1. 1 + 2−9 正好落在 FP16 的第 2 格,写到 BF16 则舍入为 1。65,536 超过 FP16 的有限范围,BF16 可用指数 16 精确表示。
  2. 匹配的矩阵计算单元、较少的内存读写、可能容纳更大的批次。规格比比较两条路径的峰值,不包括实际执行的算子组合和搬运、等待。
  3. 不一定。低精度输入可以配合 FP32 累加,再转回 BF16 输出,具体取决于内核与框架配置。
  4. 1.0 右侧第一个 FP16 值比它高 1 ÷ 1024,中点只高 1 ÷ 2048 ≈ 0.000488。0.0001 比中点更近 1.0,所以写回 1.0。保留 FP32 更新路径能累积更多这种小变化,是否另存主副本按实现决定。
  5. FP32 主权重、Adam 的一阶和二阶状态各 4 字节,合计 12。加 FP32 梯度是 16;低精度持久副本、激活和工作区仍另计。
  6. 8192 × 2−27 = 2−14,还原后是 2−27。但 16 × 8192 = 131,072 溢出,这一步应跳过该优化器的更新,并把缩放因子调低供后续使用。
  7. 按放大后的 4096 做裁剪,会先削成 1,再还原为 1 ÷ 8192,远小于本应保留的 0.5。
  8. 在同负载下用 profiler 看内核、显存读写和 GPU 空档,再对照矩阵尺寸和对齐、启动开销以及数据供给。改变 batch 或输入形状时分开记录。
  9. 常见混合配方用 E4M3 做前向、E5M2 做反向,分别偏向分辨率和范围。缩放粒度和前后向格式由配方决定。

本节回顾

⚡ 走神救援

先认范围,再认间隔。FP16 在 1 附近的格距更细,BF16 的正规指数范围更宽。选哪种精度,要核对数值表现、内核和实际速度。

分开记输入、累加、输出和保存。FP32 主权重、Adam 状态与低精度计算是可以组合的选择。12 字节/参数只是本例的三项账本,搬运收益也只来自确实少读写的字节。

FP16 梯度太小时,可先缩放损失再反向。有裁剪先还原,检测到非有限梯度跳过更新。BF16 通常省略缩放。若前向已经溢出,回到出问题的算子检查。

本章改变的是数字格式与算子精度。下一节保持同一个结果,继续问:能不能把多个算子融合起来,少搬几次数据?

下一节 👉 07-算子融合与编译.md

条件与依据

FP32 主权重、优化器状态和归约精度依实现选择;本页 12 字节只计 FP32 主权重与 Adam m/v,另计 FP32 梯度才是 16,持久低精度副本和其他张量另算。BF16 的范围较宽,仍会舍入或溢出;FP16 正规下限为 2^−14、最小正次正规值为 2^−24。代码保留常见 FP16 GradScaler 骨架,不能由此认定每条 FP16 运算都 flush,或每个实现都另有持久 master 副本。

进一步核对:PyTorch 2.14 的逐算子策略与 gradient scaling、NumPy 的正规/次正规区分、PTX half add 的次正规与 .ftz 条件。例如该 PTX half add 默认支持次正规,而 .ftz 变体会清零次正规输入/结果;这只说明具体指令条件,不能外推所有内核。本页 Python 算例可在 CPU 上复算二进制舍入。CUDA 训练骨架、真实训练和性能实验需要单独验证。

官方文档

打卡记录保存在你的浏览器里,首页能看到总进度