Skip to content

混合精度训练:从 FP16、BF16 到 DeepSeek-V3 细粒度 FP8

解析 FP16/BF16/FP8 格式、主权重、动态损失缩放与 DeepSeek-V3 细粒度分块 FP8 训练。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是混合精度训练(FP16 / BF16 / FP8)?

计算机默认用 32 位浮点数(FP32)存小数,但大模型动辄几百亿参数,全用 FP32 既爆显存又浪费 GPU 的 Tensor Core 算力。混合精度训练 的思路是“粗活细活分开用尺子”:把占绝大部分计算量的矩阵乘法降到更轻快的 FP16、BF16 甚至 FP8(仅 1 字节) 来算,同时把对微小变化敏感的主权重备份和累加器保留在 FP32 里,从而在不掉精度的前提下让训练提速 2–4 倍、显存减半。

01 问题从何而来:为什么不能全用 FP32,也不能全用低精度? ​

在传统科学计算里,每个小数都用 FP32(32 位单精度浮点数) 存储,精度高、动态范围广,几乎不用操心溢出。可放到百亿、千亿参数的大模型训练里,全用 FP32 简直是奢侈到灾难:显存直接翻倍、跨卡带宽直接翻倍,更致命的是现代 GPU(如 NVIDIA H100/H800)的算力极度偏科——BF16 Tensor Core 算力是 FP32 的 16 倍以上,FP8 又比 BF16 再翻一倍!坚持用 FP32,等于买了一辆法拉利却只挂一档在高速上爬行。

那干脆把所有数字全压缩成 16 位甚至 8 位行不行?一试就崩。因为在神经网络里,前向/反向矩阵乘需要极速吞吐但对轻微误差皮糙肉厚;而参数微调更新和长内积累加却对小数点后的微小变化极其敏感。

类比 · 造摩天大楼的“两把尺子”

想象你要盖一座 500 米高的精密摩天大楼:

  • 搬运钢梁、浇筑混凝土(占总工作量 95% 的矩阵乘法),根本不需要拿游标卡尺量到微米,用 BF16 甚至 FP8 的粗刻度尺 飞速推进就行;
  • 可到了记录楼体每天 0.05 毫米的微小沉降校准(每一步的权重更新 w−ηg),如果你还拿一把最小刻度 1 厘米的粗尺子去加减,每次 0.05 毫米的调整都会被直接四舍五入抹成 0——楼就再也调不平了!这就是浮点计算里臭名昭著的 舍入淹没(Swamping)。
核心设问

怎么在“粗尺子跑得飞快”和“细微更新绝不被抹平”之间找到完美分工?从容易炸掉的 FP16,到稳如老狗的 BF16,再到只有 8 个比特、连最大值都只有 448 的 FP8,DeepSeek-V3 究竟是怎么驯服它的?

02 核心直觉与生活类比:动态范围 vs 刻度精度,与分块装袋 ​

要看懂所有浮点格式(详见 线性代数与张量基础)的演进,只需要记住一个物理直觉:比特总数固定时,指数位(E)决定尺子能拉多长(动态范围),尾数位(M)决定尺子刻度有多密(相对精度)。

类比 · FP16 到 BF16:宁可刻度粗一点,也绝不能“量程爆表”

早年的 FP16(1-5-10) 给了 10 位尾数,刻度挺细,但只留了 5 位指数,最大只能表示 65504,最小正数约 6.1×10−5。结果反向传播里动辄出现 10−6 的小梯度直接下溢归零,注意力分数一不小心超了 65504 就炸成 NaN。于是 Mixed Precision Training (2018) ↗ 发明了两件法宝:一是后台常驻一本 FP32 精密总账(Master Weights) 记细微更新;二是搞了个动态损失缩放(Dynamic Loss Scaling)——像拿放大镜把极小的梯度临时放大几万倍躲过下溢,算完再缩小回去。

后来 Google 灵机一动设计了 BF16(1-8-7)(arXiv ↗):从 FP16 的尾数里抠出 3 位补给指数!于是 BF16 拥有和 FP32 一模一样的 8 位指数(最大到 3.39×1038),再也不怕上溢下溢,彻底扔掉了繁琐的 Loss Scaling。大模型对稍微粗糙的 7 位尾数完全扛得住,BF16 一举成为预训练黄金标准。

类比 · FP8 细粒度分块:别让一个“姚明”把全班的身高尺撑坏!

到了 FP8(E4M3,最大值只有 448,刻度仅 3 位尾数),麻烦骤然升级。大模型激活里常藏着极少数数值巨大的离群值(Outliers)。如果按传统做法对整张大矩阵共用一个缩放系数(Per-Tensor Scaling),就像拿一根统一的尺子给全班量身高,偏偏班里站着一位 2.26 米的姚明,为了让姚明不爆表,所有人被迫按同一个超大比例缩小,结果其余 99.9% 正常数值全被压成了 0!

更坑的是,Hopper 显卡的 FP8 Tensor Core 硬件内部累加器其实偷工减料了——有效尾数只有约 14 位(远不是完整 FP32 的 23 位),内积加太长就会飘移。

DeepSeek-V3 (2024) ↗ 用两招精准拆弹:

  1. 极细粒度分块装袋:不再全班共用一把尺子,而是把激活按 1×128 小条、权重按 128×128 小方块 各自单独配一把尺子!哪怕某一行冒出离群值,也只影响它自己那个 128 元素小口袋,绝不连累邻居;
  2. 定时倒进真 FP32 大缸:Tensor Core 每次只算长度 128 的短内积(根本来不及飘移),算完立刻提升到 CUDA Core 的真 FP32 寄存器里乘上缩放系数累加!由此首次在 671B 超大模型上跑通了和 BF16 几乎无损的端到端 FP8 预训练。

03 把关键公式读成人话 ​

先看为什么没有 FP32 Master Weights 就会发生“更新消失”——对于尾数宽 M 位的格式,相对舍入精度为 ϵmach=2−M:

wnew=w−ηg(若 |ηg|<12ϵmach|w|,则 wnew≡w)

**把舍入淹没公式读成直觉:**BF16 的 M=7,机器精度 ϵmach≈0.0078(约千分之八)。假设当前权重 w=1.0,而学习率乘以梯度算出的本步微调只有 −0.0002。如果直接在 BF16 上做减法,因为 0.0002 连半个最小刻度 0.0039 都够不到,硬件会直接把它四舍五入扔掉,wnew 纹丝不动!所以必须在 优化器 里维护 FP32 主权重(精度千万分之一)来稳稳攒住每一次微调,每步算完再转一份 BF16/FP8 副本去跑矩阵乘。

再看 DeepSeek-V3 的分块 FP8 反缩放与高精度累加公式:

Cm,n=∑k=1K/128(sm,k(A)⋅sk,n(B))⋅MMAFP8(A^m,k,B^k,n)

把分块 FP8 累加读成直觉:把长达 K 的内积切成 K/128 个短段。每一小段里,压缩后的整数感 FP8 小块 A^,B^ 扔进超快的 Tensor Core 算出局部内积;出来立刻乘回各自口袋的缩放系数 s(A)⋅s(B),并倒进完整 FP32 的总和 Cm,n 里。既吃满了 FP8 Tensor Core 的双倍算力,又完美绕开了硬件 14 位累加器的精度短板。

04 它在模型里怎么工作 & 与上下游的关系 ​

混合精度不是全局一刀切,而是像外科手术一样按算子敏感度精准划分精度领地:

  • 高速低精度区(占 95%+ 算力):Transformer 里所有的巨型线性投影(QKV、O 投影以及 FFN / SwiGLU 上下投影)在前向和 反向传播 的三类 GEMM 中全面采用 BF16 或细粒度 FP8。
  • 高精度保留孤岛(占 <5% 算力但关乎生死):Embedding 层、Output Head、MoE 门控路由、RMSNorm / LayerNorm 以及 FlashAttention 里的在线 Softmax 累加,坚决守在 BF16/FP32,绝不为了省 1% 的算力冒发散风险。
  • 与分布式及推理生态的深度联动:更窄的数据位宽让 ZeRO / FSDP 下的参数广播与 显存优化 中的激活缓存直接瘦身一半;而 FP8 训练中的在线块级缩放思路,也无缝延伸到了部署阶段的 模型量化(如 FP8 / INT4 推理)。

05 演化对比与避坑备忘 ​

浮点格式布局 (S-E-M)最大值相对精度核心特性典型用途
FP321-8-233.4×10381.2×10−7量程广、精度高,最占显存Master Weights、优化器状态、Loss 累加
FP161-5-10655049.8×10−4易上下溢,强依赖 Loss Scaling早期训练、推理加速
BF161-8-73.4×10387.8×10−3与 FP32 同量程,免 Loss Scaling主流 LLM 预训练黄金标准
FP8 (E4M3)1-4-34480.125算力翻倍,需细粒度分块抗离群值DeepSeek-V3 前向/反向全链路 GEMM
FP8 (E5M2)1-5-2573440.25量程宽于 E4M3,刻度更粗传统 Per-Tensor FP8 框架梯度表示

最后收好三条实战防翻车清单:

  1. 用 BF16 千万别顺手打开 GradScaler:GradScaler 是专治 FP16 上下溢的拐杖。在 BF16 里开它不仅毫无意义,还会每步额外做一次全卡 Inf/NaN 同步检查,白白拖慢训练吞吐。
  2. 多卡梯度 All-Reduce 别用低精度硬加:在几百张卡的 数据并行 里,如果直接拿 BF16 或 FP8 梯度跨卡连加几百次,微小的舍入误差会滚雪球一样扭曲真实梯度。FSDP 里的 reduce_dtype 务必保持 FP32。
  3. 警惕 FP8 延迟缩放(Delayed Scaling)被突发尖峰打穿:传统方案拿前几步的历史最大值猜当前步缩放系数,一旦某一步突然冒出巨型激活离群值就会瞬间截断爆 Loss。超大规模 FP8 训练应优先采用在线实时细粒度量化(或配合 2 的幂次 E8M0 缩放因子)。

需要查阅完整 IEEE-754 位宽推导、DeepSeek-V3 FP8 前反向架构图以及可验证信噪比优势的 blockwise_fp8_linear PyTorch 代码?按快捷键 M 或点击顶部 技术 Wiki 随时切换。

现代 GPU(如 NVIDIA Hopper H100/H800、Blackwell B200)的算力分布呈现极端的非对称性:BF16 Tensor Core 算力是 FP32 的 16 倍以上,而 FP8 Tensor Core 算力又比 BF16 再翻一倍,同时显存占用与跨卡通信字节数直接减半。混合精度训练(Mixed Precision Training)基于 线性代数与张量基础 中的浮点表示规律,本质上是在 “用低比特格式执行占总算力 95% 以上的矩阵乘法(GEMM)” 与 “在数值敏感环节(如 优化器 状态与 反向传播 梯度累加)保留高精度以防上溢、下溢和舍入淹没” 之间达成精确平衡,其细粒度块级缩放思想也与推理阶段的 模型量化 一脉相承。

直观理解

把神经网络训练想象成建造一座超高精密摩天大楼:搬运砖块与浇筑混凝土(矩阵乘法)不需要游标卡尺,用 BF16 甚至 FP8 的“粗尺子”即可极速推进;但记录楼体每一毫米的微小沉降校准(权重更新与累加),如果也用粗尺子就会把每次微调直接四舍五入抹平。因此必须保留一本 FP32 精密总账(Master Weights),并用动态缩放镜把极小的梯度放大到尺子量程内读取。

问题动机与演进背景 ​

  1. FP16 时代的两大数值梦魇:FP16 仅有 5 位指数,最大可表示正数仅为 65504,最小正规正数约为 6.1×10−5。在反向传播中,深层梯度常常小于 10−5 导致下溢归零(Underflow),激活或注意力分数则容易超过 65504 引发 NaN 上溢(Overflow)。为驯服 FP16,Micikevicius et al. (2018) 确立了 FP32 Master Weights + 动态损失缩放(Dynamic Loss Scaling) 两大支柱。
  2. BF16 成为大模型预训练黄金标准:Google 设计的 BFloat16 牺牲 3 位尾数精度换取了与 FP32 完全一致的 8 位指数(动态范围达 ±3.39×1038)。这一天才取舍彻底消除了上溢与下溢风险,免去了繁琐的 Loss Scaling,使得万亿参数模型的稳定预训练成为可能。
  3. 迈向 FP8 的挑战与 DeepSeek-V3 破局:FP8 只有 8 个比特,无论采用 E4M3(4 位指数、3 位尾数,最大值仅 448)还是 E5M2(5 位指数、2 位尾数,精度粗糙),其动态范围与分辨率都极其狭窄。大语言模型中普遍存在的激活离群值(Activation Outliers) 会瞬间撑爆整张张量的缩放因子(Per-Tensor Scaling),把其余 99.9% 的正常数值压成 0。此外,Hopper 架构 FP8 Tensor Core 硬件内部累加器实际仅提供约 14 位有效尾数(而非完整 23 位 FP32),长内积累加会出现显著漂移。DeepSeek-V3 通过细粒度 Tile/Block-wise 在线量化与高精度 CUDA Core 定时提升累加,首次在 671B 超大规模 MoE 模型上实现了与 BF16 几乎无损(相对损失差低于 0.25%)的端到端 FP8 预训练。

核心原理与数学推导 ​

1. IEEE-754 浮点编码与格式数学剖析 ​

任意正规浮点数由 1 位符号位 S、E 位指数位(偏置值 b=2E−1−1)与 M 位尾数位构成,其数值为:

x=(−1)S×2e−b×(1+∑i=1Mmi2−i)

其中指数位宽度 E 决定动态范围(Dynamic Range),尾数位宽度 M 决定相对舍入精度(Machine Epsilon ϵmach=2−M)。当执行权重更新 wnew=w−ηg 时,若 |ηg|<12ϵmach|w|,更新量将在浮点加法对齐阶码时被彻底截断归零(即 Swamping / 舍入淹没现象)。在 BF16 中 ϵmach=2−7≈7.8×10−3,而大模型单步相对更新 |ηg/w| 往往低至 10−4–10−5,因此必须在优化器中维护 FP32 Master Weights(ϵmach≈1.19×10−7)。

2. FP16 动态损失缩放(Dynamic Loss Scaling) ​

为将微小梯度平移进 FP16 的可表示区间,在反向传播前将标量损失乘以放大因子 S(如初始 S=216):

L~=S⋅L⟹g~=∂L~∂w=S⋅g

反向传播结束后,先将低精度梯度转回 FP32 并除以 S 还原真实梯度 g=g~/S,再执行梯度裁剪与权重更新。动态调整策略按如下规则自动试探最大安全倍率:

  • 若本步未检测到任何 Inf 或 NaN,且已连续稳定 N 步(如 N=2000),则翻倍 S←2S;
  • 若检测到 Inf 或 NaN,立即跳过本步参数更新,并将缩放因子减半 S←S/2。

3. FP8 格式双轨制与 DeepSeek-V3 细粒度分块量化 ​

FP8 存在两种互补标准(NVIDIA/ARM/Intel 联合规范):

  • E4M3(4 位指数、3 位尾数,无 Inf,最大值 448):精度更高,适合前向激活与权重。
  • E5M2(5 位指数、2 位尾数,最大值 57344):动态范围更广,传统方案(如 Transformer Engine)将其用于反向梯度。

DeepSeek-V3 发现,只要将缩放粒度缩得足够细,前向激活、权重与反向梯度三者均可全部采用高精度的 E4M3 格式,完全抛弃粗粒度的历史延迟缩放(Delayed Scaling):

  1. 激活按 Tile 分组量化(1×128):沿特征内积维(K 维)每 128 个元素划分为一个 Tile,实时计算局部最大绝对值并在线量化:

    st=maxi∈Tile|xi|448.0,x^i=CastE4M3(xist)
  2. 权重按 Block 分组量化(128×128):在输入维与输出维两个方向均按 128 分块,使权重矩阵的前向传播与转置反向传播共享完全对称的分块缩放因子 sb。

  3. 分块反缩放内积与高精度累加(High-Precision Accumulation): 对于两个分块量化的矩阵 A∈RM×K 与 B∈RK×N,矩阵乘法沿内积维 K 被切分为 K/128 个子块。每个子块在 Hopper FP8 Tensor Core 上执行短内积(长度为 128,远未触发 14 位硬件累加器漂移),随后立刻提升到 CUDA Core 的完整 FP32 寄存器中乘以两个缩放因子并累加:

    Cm,n=∑k=1K/128(sm,k(A)⋅sk,n(B))⋅MMAFP8(A^m,k,B^k,n)⏟长度 128 的 Tensor Core 子块累加

    这种将“缩放因子剥离出内层累加并周期性提升至真 FP32 累加”的设计,以极低的 CUDA Core 辅助开销彻底根治了 Hopper 架构的 FP8 硬件累加精度不足与离群值截断两大顽疾。

算法架构与数据流图 ​

下图展示了 DeepSeek-V3 细粒度分块 FP8 混合精度训练的前向、反向与高精度关键模块隔离数据流:

图表加载中...

复杂度与横向对比 ​

浮点格式总位宽布局 (S-E-M)指数偏置最大正规值最小正规正数机器精度 (ϵ)典型应用场景
FP3232 bit1-8-231273.40×10381.18×10−381.19×10−7Master Weights、优化器状态、Softmax/Loss 累加
TF3219 bit1-8-101273.40×10381.18×10−389.77×10−4Ampere+ GPU 默认替代 FP32 加速矩阵乘
FP1616 bit1-5-10156.55×1046.10×10−59.77×10−4早期混合精度训练(强依赖 Loss Scaling)、推理
BF1616 bit1-8-71273.39×10381.18×10−387.81×10−3主流 LLM 稳定预训练、无需 Loss Scaling
FP8 (E4M3)8 bit1-4-374481.56×10−21.25×10−1FP8 权重与激活(DeepSeek-V3 亦用于梯度)
FP8 (E5M2)8 bit1-5-2155.73×1046.10×10−52.50×10−1传统 Per-Tensor FP8 框架反向梯度表示

核心 PyTorch 参考实现 ​

下面代码模拟了 DeepSeek-V3 风格的 1×128 激活 Tile 量化、128×128 权重 Block 量化以及分块高精度 FP32 累加矩阵乘法,并验证其相较于粗粒度 Per-Tensor 量化的信噪比优势:

python
import torch
import torch.nn.functional as F

FP8_E4M3_MAX = 448.0


def fake_quant_fp8_e4m3(x: torch.Tensor) -> torch.Tensor:
    """在 CPU/通用 GPU 上仿真 FP8 E4M3 量化;若硬件支持 float8_e4m3fn 则直接硬件转换。"""
    clamped = x.clamp(-FP8_E4M3_MAX, FP8_E4M3_MAX)
    if hasattr(torch, "float8_e4m3fn"):
        return clamped.to(torch.float8_e4m3fn).to(torch.float32)
    # 回退仿真:按 3 位尾数 (8 级) 量化
    return torch.round(clamped * 8.0) / 8.0


def quantize_activation_tile_1x128(x: torch.Tensor, block_size: int = 128) -> tuple[torch.Tensor, torch.Tensor]:
    """激活沿 K 维按 1 x 128 切分做在线 Tile-wise 量化。"""
    M, K = x.shape
    assert K % block_size == 0
    x_blocks = x.view(M, K // block_size, block_size)                     # [M, K//128, 128]
    amax = x_blocks.abs().amax(dim=-1, keepdim=True).clamp(min=1e-12)     # [M, K//128, 1]
    scales = amax / FP8_E4M3_MAX                                          # [M, K//128, 1]
    x_q = fake_quant_fp8_e4m3(x_blocks / scales)                          # [M, K//128, 128]
    return x_q, scales.squeeze(-1)                                        # scales: [M, K//128]


def quantize_weight_block_128x128(w: torch.Tensor, block_size: int = 128) -> tuple[torch.Tensor, torch.Tensor]:
    """权重 w [N, K] 按 128 x 128 网格做 Block-wise 量化。"""
    N, K = w.shape
    assert N % block_size == 0 and K % block_size == 0
    w_blocks = w.view(N // block_size, block_size, K // block_size, block_size)
    amax = w_blocks.abs().amax(dim=(1, 3), keepdim=True).clamp(min=1e-12)
    scales = amax / FP8_E4M3_MAX                                          # [N//128, 1, K//128, 1]
    w_q = fake_quant_fp8_e4m3(w_blocks / scales)
    return w_q, scales.squeeze(1).squeeze(-1)                             # scales: [N//128, K//128]


def blockwise_fp8_linear(x: torch.Tensor, w: torch.Tensor, block_size: int = 128) -> torch.Tensor:
    """分块 FP8 子矩阵乘 + 周期性 FP32 反缩放累加:模拟 DeepSeek-V3 GEMM 精度行为。"""
    M, K = x.shape
    N, _ = w.shape
    num_k_blocks = K // block_size
    num_n_blocks = N // block_size

    x_q, x_scales = quantize_activation_tile_1x128(x, block_size)         # [M, Kb, 128], [M, Kb]
    w_q, w_scales = quantize_weight_block_128x128(w, block_size)          # [Nb, 128, Kb, 128], [Nb, Kb]

    # 在 FP32 累加器上逐 K-block 累加反缩放后的子矩阵乘结果
    out = torch.zeros(M, N, dtype=torch.float32, device=x.device)
    for kb in range(num_k_blocks):
        xk = x_q[:, kb, :]                                                # [M, 128]
        sx = x_scales[:, kb : kb + 1]                                     # [M, 1]
        for nb in range(num_n_blocks):
            wk = w_q[nb, :, kb, :]                                        # [128, 128]
            sw = w_scales[nb, kb]                                         # 标量
            # 子块短内积 (长度 128) 后立即乘以尺度因子累加至 FP32
            partial = (xk @ wk.T) * (sx * sw)                             # [M, 128]
            out[:, nb * block_size : (nb + 1) * block_size] += partial
    return out


if __name__ == "__main__":
    torch.manual_seed(7)
    M, K, N = 32, 512, 256
    # 构造带有极端离群值 (Outlier = 150.0) 的真实 LLM 风格激活张量
    x = torch.randn(M, K)
    x[:, 13] *= 80.0
    w = torch.randn(N, K) * 0.02

    ref = x @ w.T
    # 对比 1:粗粒度 Per-Tensor FP8
    sx_all = x.abs().max() / FP8_E4M3_MAX
    sw_all = w.abs().max() / FP8_E4M3_MAX
    out_tensor = (fake_quant_fp8_e4m3(x / sx_all) @ fake_quant_fp8_e4m3(w / sw_all).T) * (sx_all * sw_all)
    # 对比 2:DeepSeek-V3 细粒度 Tile/Block-wise FP8
    out_block = blockwise_fp8_linear(x, w, block_size=128)

    err_tensor = (out_tensor - ref).norm() / ref.norm()
    err_block = (out_block - ref).norm() / ref.norm()
    print(f"Per-Tensor FP8 相对误差: {err_tensor:.4%} | Block-wise FP8 相对误差: {err_block:.4%}")

工程实践与常见陷阱 ​

工程实践

  1. 对数值敏感算子坚决保留高精度:即便采用全链路 FP8 训练,DeepSeek-V3 仍明确将 Embedding 层、Output Head、MoE 门控路由、RMSNorm / LayerNorm 以及 FlashAttention 核心计算保留在 BF16/FP32,因为这些模块计算量占比极小,却对数值舍入极其敏感。
  2. 2 的幂次缩放因子(Power-of-Two Scaling):DeepSeek-V3 后续优化及 Blackwell MXFP8 规范倾向于将缩放因子向上取整为 2 的整数次幂 2k(E8M0 格式)。这样反缩放仅涉及指数位加减,彻底消除了尾数二次舍入误差并显著简化硬件电路。
  3. BF16 下的随机舍入(Stochastic Rounding):如果在极致省显存场景下(配合 训练显存全景优化)必须用低精度存储部分优化器状态或梯度累积,启用随机舍入(按小数残差概率向上/向下取整)可使舍入误差在数学期望上严格无偏,有效缓解 Swamping 问题。

常见陷阱

  1. 在 BF16 下误开 GradScaler:PyTorch 的 torch.amp.GradScaler 专为 FP16 动态范围不足设计。在 BF16 训练中开启 GradScaler 不仅毫无必要,还会增加多余的 Inf/NaN 全卡同步开销,拖慢吞吐量。
  2. FP8 延迟缩放(Delayed Scaling)遭遇突发离群值:传统 Transformer Engine 的 Delayed Scaling 依赖过去若干步的历史最大绝对值预测当前步的缩放因子。一旦当前步突然涌现激活尖峰,就会发生大面积饱和截断并引发 Loss Spike;因此超大规模训练正全面转向在线实时细粒度量化(Online Fine-grained Quantization)。
  3. 忽视低精度归约(All-Reduce)误差:在多卡 数据并行 下,若直接对 BF16/FP8 梯度跨数百张 GPU 做 All-Reduce 求和,大量小数累加会产生严重的顺序相关精度丢失。工程上梯度 All-Reduce 必须至少在 FP32(或高精度 BF16 分层规约) 缓冲区中执行。

延伸阅读与参考论文 ​

  • Micikevicius, P., et al. (2018). Mixed Precision Training. ICLR 2018. (arXiv:1710.03740 ↗)
  • Kalamkar, D., et al. (2019). A Study of BFLOAT16 for Deep Learning Training. Intel. (arXiv:1905.12322 ↗)
  • Micikevicius, P., et al. (2022). FP8 Formats for Deep Learning. NVIDIA / Arm / Intel. (arXiv:2209.05433 ↗)
  • Peng, H., et al. (2023). FP8-LM: Training FP8 Large Language Models. Microsoft. (arXiv:2310.18313 ↗)
  • DeepSeek-AI (2024). DeepSeek-V3 Technical Report (Section 3.3: FP8 Mixed Precision Training). (arXiv:2412.19437 ↗)