起因:H20 上 FP64 只有 1 TFLOPS,但计算要的是双精度#
写这篇笔记的直接原因是一块 H20。业务里有一块对数值精度敏感的计算,需要接近 FP64 的结果,但 H20 的 FP64 算力只有 1 TFLOPS。对照同一张卡的其他规格,这个数字有多别扭很直观:FP32 是 44 TFLOPS,FP16/BF16 Tensor Core 是 148 TFLOPS,FP8 是 296 TFLOPS,FP64 只有 1——不到 FP32 的四十分之一,而满血的 H100 上 FP64 是 34 TFLOPS。
在 H20 上老老实实用 FP64,等于把一张 GPU 当慢速 CPU 用;直接降到 FP32,长链求和这类计算又会把舍入误差攒起来,精度不够。
出路只有一条:用 FP32 甚至更低精度跑算力,把双精度的准确性用数值算法补回来。第一件搬出来的工具是 Kahan 补偿求和:乘加还是 FP32,用一个额外的补偿变量把每次被舍掉的低尾数追回来,长链求和的误差界从 \( O(N \cdot \epsilon) \) 压到 \( O(\epsilon) \),在求和这类场景里能顶到接近 FP64 的结果。
把 Kahan 用上之后,马上冒出一串新问题:乘法怎么办,Tensor Core 的 FP32 累加器够不够保险;如果继续往 BF16 降精度,哪些环节必须守住 FP32;以及更根本的,一次舍入只有 \( 10^{-7} \) 量级的相对影响,凭什么会被放大到肉眼可见。
这篇笔记想理清的就是这条链路:误差从哪来、以多快的速度传播、在系统的哪一层被放大或者被吸收。顺着往下走,最后落到三个判断上:
- 数学上等价的两条计算路径,在浮点里不一定等价,差别常常来自括号的结合顺序。
- 精度是可以分配的预算,不是越高越好的信仰。Tensor Core 的吞吐、显存和带宽都在为它定价。
- 数值稳定性不只是算法问题。归约树长什么样、kernel 怎么融合、跨机通信走什么拓扑,都会改变误差的传播路径。
误差有多大:ULP 与那张不均匀的网格#
误差要谈传播,先得能把它量出来。“FP32 大概有 7 位有效数字"这句话我用了很多年,配 dtype 的时候够用,但它说的是相对精度,不是一个固定的绝对误差。同一个格式,在 1.0 附近和 \( 10^8 \) 附近,能分辨的最小步长差了好几个数量级。
实数轴是连续的,可以在任意两点之间插入无穷多个点;计算机寄存器的位数是有限的,32 个 bit 无论如何组合,最多只能表达 \( 2^{32} \approx 4.29 \times 10^9 \) 个离散数值。
在之前关于 从 IEEE 754 到 BF16 的讨论中,我梳理过 IEEE 754 的位布局:1 位符号位(Sign)、\( E \) 位指数位(Exponent)与 \( M \) 位尾数位(Mantissa)。
浮点数的值由以下形式给出:
$$ v = (-1)^s \times 2^{e - \text{bias}} \times \left(1 + \sum_{i=1}^M b_i 2^{-i}\right) $$这种指数与尾数分离的设计,决定了浮点数在实数轴上的分布是极不均匀的:靠近 0 的区域分布极密,离 0 越远分布越稀疏。
刻画这种离散性的量叫 ULP(Unit in the Last Place,最后一位单元),也就是某个数值附近相邻两个可表示浮点数之间的实际间距。尾数位数为 \( p \) 的二进制浮点数,在 \( x \) 处的 ULP 大致为:
$$ \text{ULP}(x) \approx 2^{\lfloor \log_2 |x| \rfloor - p + 1} $$在 FP32 下(尾数有效位 24 位,含隐藏位 1),当 \( x = 1.0 \) 时,\( \text{ULP}(1.0) = 2^{-23} \approx 1.19 \times 10^{-7} \)。但当 \( x = 10^8 \) 时,量级落在 \( [2^{26}, 2^{27}) \),间距变成 \( 2^{26 - 23} = 2^3 = 8 \)。
这个差距用几行代码就能量出来:
1import numpy as np
2
3a = np.float32(1.0)
4b = np.float32(1e8)
5c = np.float32(-1e8)
6
7print((a + b) + c) # 输出 0.0
8print(a + (b + c)) # 输出 1.0在 \( 10^8 \) 附近,FP32 所能分辨的最小步进是 8。把 \( 1.0 \) 加到 \( 10^8 \) 上,真实的数学结果 \( 10^8 + 1 \) 距离 \( 10^8 \) 只有 1,小于半个网格间距(4),按照 IEEE 754 的默认最近舍入规则(Round to Nearest, Ties to Even)直接被舍弃,结果仍然是 \( 10^8 \),再减去 \( 10^8 \) 就得到 0;而先把 \( 10^8 \) 和 \( -10^8 \) 相加,两个数精确抵消,那个 1.0 就留了下来。
因此,浮点数加法在物理上不满足结合律:
$$ (a + b) + c \neq a + (b + c) $$每一次浮点算术运算(\( +、-、\times、\div \)),在硬件底层都对应着一次对离散网格点的舍入(Rounding)。只要涉及有限精度,代数公式就必须接受舍入误差的约束。
三个容易混用的词#
排查发散的时候,Conditioning、Stability、Catastrophic Cancellation 这三个词经常被混着用,我自己也混过一段时间。它们描述的其实是三个不同层次的属性。
1. Numerical Conditioning(问题的病态性)#
Conditioning 衡量的是数学问题本身对输入扰动的敏感程度,与具体的计算实现无关。
数学上用条件数(Condition Number)\( \kappa \) 来刻画。对于单变量可微函数 \( f(x) \),相对条件数定义为:
$$ \kappa = \left| \frac{x f'(x)}{f(x)} \right| $$如果 \( \kappa \) 很小,说明输入有微小的相对误差时,输出的相对变化也很小,这个问题就是良态的(Well-conditioned);如果 \( \kappa \gg 1 \),即使微小的输入扰动也会引发输出剧烈震荡,这个问题就是病态的(Ill-conditioned)。
在机器学习中,经典的病态问题是高维线性回归或协方差矩阵求逆时遇到的接近奇异的矩阵(Singular Matrix)。当矩阵的条件数高达 \( 10^8 \) 时,哪怕使用理论上完美的数学算法,输入数据里微不足道的量化噪声也会被放大 \( 10^8 \) 倍。
换用 FP64 并不会让病态问题变好。高精度只能稍微推迟误差爆炸的阈值,病态是问题自身的数学属性。要让条件数降下来,只能改问题定义——比如引入权重衰减(Ridge 正则化)、添加对角抖动项(Jitter / \( \epsilon I \))。
2. Numerical Stability(算法的稳定性)#
与 Conditioning 关注"问题本身"不同,Numerical Stability 衡量的是具体的计算算法在有限精度实现时,是否额外引入或放大了舍入误差。
一个数学问题可能是 Well-conditioned 的,但如果算法实现不当,依然可能得到荒谬的垃圾输出。反之,一个数值稳定的算法保证:在整个计算流程中,每一次操作所引入的舍入误差都不会以指数级或超线性方式恶化,其最终误差界能够被有效控制。
简而言之:Conditioning 是问题属性,Stability 是算法属性。
3. Catastrophic Cancellation(灾难性消去)#
灾难性消去是导致数值不稳定的最常见元凶:当两个大小极为接近的大数相减时,高位的有效数字相互抵消,导致结果中的有效精度大幅丢失。
来看一个经典的数值分析例子:
$$ f(x) = \sqrt{x + 1} - \sqrt{x} $$当 \( x \) 很大(例如 \( x = 10^8 \))时,这个函数本身很平滑,问题也是良态的:随着 \( x \) 增大,\( f(x) \) 单调趋近于 0。它的条件数约为 0.5。
但在 FP32 下直接计算,第一步就出问题:\( 10^8 + 1 \) 会先被舍入成 \( 10^8 \)。退一步说,就算把两个平方根当作精确输入,\( \sqrt{10^8 + 1} \approx 10000.00005 \) 与 \( \sqrt{10^8} = 10000 \) 在 10000 附近(ULP 约为 \( 9.8 \times 10^{-4} \))也会落到同一个浮点数上。两者相减得到 0,而真实结果大约是 \( 5 \times 10^{-5} \)。
两个操作数的有效前缀几乎完全一样,甚至在 FP32 里干脆就是同一个数。在 24 位有效二进制位(约 7 位十进制精度)的约束下,高位在减法中直接归零,剩下的低位几乎全是被舍入噪声污染的尾巴。
然而,我们只需要做一步初中代数有理化:
$$ f(x) = \frac{(\sqrt{x + 1} - \sqrt{x})(\sqrt{x + 1} + \sqrt{x})}{\sqrt{x + 1} + \sqrt{x}} = \frac{1}{\sqrt{x + 1} + \sqrt{x}} $$改写后的公式在数学上与原式完全等价,但数值上减法变成了加法:两个同量级的数相加不会抵消高位,随后的除法也不会放大相对误差。在 FP32 下,这个改写后的公式能够稳定输出结果。
这里有一个容易被忽略的点:灾难性消去并不意味着浮点减法指令本身产生了巨大舍入误差。
相反,IEEE 754 的硬件减法是极其精确的。著名的 Sterbenz 引理 证明:如果两个正浮点数 \( x \) 和 \( y \) 满足 \( \frac{y}{2} \le x \le 2y \),那么在 IEEE 754 浮点体系下,计算 \( x - y \) 的结果是完全没有舍入误差的(即数学值完全可以被浮点数精确表示)。
灾难性消去的真正元凶,是操作数在此前计算步骤中已经积累的微小误差,在相减之后变成了相对误差的主导部分。当有效的高位数字被全部切除后,残留在低位的误差被无情地推到了台前。
稳定算法的设计范式#
上面这些例子有个共同点:数学上等价的两条路径,落到浮点里的表现可能差很远。真正写算子时,能从数学上动的手脚大致有三类。
1. 控制数值范围:Softmax 与对数域计算#
深度学习模型中充满指数函数 \( e^x \)。指数函数的致命缺陷是增长极快:在 FP16 下,最大可表示正数为 65504,只要输入 \( x \gt \ln(65504) \approx 11.09 \),\( e^x \) 就会直接溢出为 +Inf;而一旦出现 Inf,随后的除法就会变成 Inf / Inf = NaN。
解决这个问题的常规做法,是利用 Softmax 的平移不变性(Shift Invariance):
$$ \operatorname{softmax}(x)_i = \frac{e^{x_i}}{\sum_j e^{x_j}} = \frac{e^{x_i - c}}{\sum_j e^{x_j - c}} $$只要令 \( c = \max_j x_j \),所有新的输入都满足:
$$ x_i - c \le 0 \implies e^{x_i - c} \in (0, 1] $$所有指数项都不会超过 1.0,上溢(Overflow)就被挡住了。
但这里有一个常被忽略的工程细节:减去最大值解决的是 Overflow,并没有解决 Underflow。
对于那些远小于最大值的输入(如 \( x_i - c \lt -88 \) 在 FP32 下),\( e^{x_i - c} \) 依然会下溢到 0.0。然而在概率分布归一化的场景下,极小项下溢到 0 是良性的——它代表该项的注意力权重趋近于 0,并不会污染分母的主导和,更不会产生破坏训练的 NaN。
同理,计算交叉熵损失(Cross-Entropy Loss)时,如果先做 p = softmax(x),再算 loss = -log(p),某项一旦下溢成 0,log(0) 就会直接产生 -Inf。成熟框架统一使用 LogSumExp(LSE) 在对数域计算:
这样中间的极值不会直接进入 log,动态范围的问题被挡在了外面。
2. 避免灾难性消去:方差计算与 Welford 算法#
LayerNorm、BatchNorm、RMSNorm 是现代大模型的基础组件,它们的核心计算都涉及统计量——特别是方差。
很多教材里给出的方差定义公式是:
$$ \operatorname{Var}(X) = \mathbb{E}[X^2] - (\mathbb{E}[X])^2 $$这个单遍扫描(One-pass)公式在工程上非常诱人:只需要在遍历数据时同时累加 \( \sum x_i \) 和 \( \sum x_i^2 \),遍历结束一步就能算出方差。
但在有限精度下,这个公式会出问题。假设输入张量的均值很大而方差很小(例如一组特征值全分布在 \( [1000.1, 1000.2] \) 之间):
- \( \mathbb{E}[X^2] \approx 10^6 \)
- \( (\mathbb{E}[X])^2 \approx 10^6 \)
这是典型的两接近大数相减。在 FP16 甚至 FP32 下,由于大数舍入误差,算出来的相减结果完全可能是一个微小的负数!而在 LayerNorm 中,随后的操作是 \( \frac{1}{\sqrt{\operatorname{Var} + \epsilon}} \)。对负数开根号,整个前向传播瞬间全盘 NaN。
标准的工业级解法是 Two-pass Variance:
- 第一遍扫描:计算中心化均值 \( \mu = \frac{1}{N} \sum x_i \)。
- 第二遍扫描:计算离均差平方和 \( \operatorname{Var}(X) = \frac{1}{N} \sum (x_i - \mu)^2 \)。
由于每个 \( (x_i - \mu) \) 已经是微小残差,平方和每一项恒非负,从根源上消灭了两个大数相减的消去路径。
更进一步,显存受限或者需要流式处理时,我会换成 Welford 增量算法。它在线维护均值和平方和差值:
$$ \mu_k = \mu_{k-1} + \frac{x_k - \mu_{k-1}}{k} $$$$ M_k = M_{k-1} + (x_k - \mu_{k-1})(x_k - \mu_k) $$其中 \( \operatorname{Var}_k = \frac{M_k}{k} \)。它不仅实现了单遍扫描(避免多次读取内存),而且整个递推过程始终在处理残差,数值上更稳。
3. 控制累积误差:从 Kahan 到树状规约#
深度学习充满了规约(Reduction)操作:向量内积、矩阵乘累加、Loss 求和。当向量长度 \( N \) 从数千膨胀到数百万时,累加顺序的影响就藏不住了。
不同求和算法的误差演化机制有着质的差异:
| 算法 | 核心思想 | 误差界(Error Bound) | 并行友好度 |
|---|---|---|---|
| Naive 顺序求和 | 从头到尾简单累加:s += x[i] | \( O(N \cdot \epsilon) \) | 极差(严格串行依赖) |
| Kahan 补偿求和 | 用额外变量追踪并补偿被舍弃的低位尾数 | \( O(\epsilon) \) | 差(依赖时序,GPU 改造复杂度高) |
| Pairwise 折半求和 | 递归二分分治,两两配对相加 | \( O(\log N \cdot \epsilon) \) | 优(天然适合树状展开) |
| GPU Tree Reduction | 利用硬件 Warp Shuffle 进行层次树状归约 | \( O(\log N \cdot \epsilon) \) | 极高(CUDA 原生硬件映射) |
在 Naive 求和中,当累加和逐渐增大时,其 ULP 也在同步扩张。后续小数字加进来时,低位信息持续丢失,误差随 \( N \) 线性堆积。
Kahan 补偿求和就是开头说的那件工具。它给求和配一个补偿变量 \( c \),专门记录每一步被舍掉的低位,并在下一步加回来:
1s = np.float32(0.0)
2c = np.float32(0.0)
3for x in xs:
4 y = x - c # 先把上一轮丢失的低位补回来
5 t = s + y
6 c = (t - s) - y # 记录这一轮又被舍掉的部分
7 s = t用 FP32 跑这个循环,长链求和的相对误差界接近 \( O(\epsilon) \),基本与 \( N \) 无关。这也是它在 H20 上能顶替 FP64 求和的原因:花 FP32 的算力,拿到接近双精度的累加结果。对精度要求再高一步,还有用两个 FP32 拼出约 48 位有效精度的 double-single(float-float)模拟,仍不及 FP64 的 53 位,但配合算法改造往往够用。
需要注意两点:Kahan 求和并不保证不同输入顺序得到相同结果;而且它有严格的时序依赖,在 GPU 上需要先局部求和再层级合并,实现起来比看起来麻烦。
GPU 的硬件体系天然契合 Tree Reduction。在 CUDA 编程中,无论是 Block 内部利用 __shfl_down_sync 做的 Warp-level Reduction,还是 Shared Memory 上的折半规约,其计算拓扑在数学上都等价于一棵高度为 \( \lceil \log_2 N \rceil \) 的二叉平衡树。
这种拓扑结构既照顾了 GPU 的并行吞吐,也在数值上把最大舍入传播深度从 \( N \) 降到 \( \log_2 N \)。
精度工程:精度是一种系统资源#
在传统科学计算中,研究者常常追求尽可能高的数值精度(FP64 甚至是高精度任意浮点库)。但在现代机器学习系统中,精度是一种系统资源。H20 就是把这件事推到极端的例子:FP64 1 TFLOPS、FP32 44 TFLOPS、BF16 148 TFLOPS,硬件直接用算力给不同精度标了价。
降低计算精度,能够直接换来成倍提升的 Tensor Core 计算吞吐、减少近半的显存占用,并大幅缓解 HBM 访存带宽瓶颈;而保留高精度,则能守住关键环节不崩。所以我的做法不是全盘追高,而是按计算图分段配置:该省的地方省,该保的地方保。
FP32、FP16 与 BF16 的物理取舍#
在 IEEE 754 到 BF16 这篇笔记 中,我对比过底层位布局。这里用一张精简的对照表回顾它们在数值特性上的差异:
| 格式 | 总位数 | 指数位 (Exponent) | 尾数位 (Mantissa) | 动态范围 (Dynamic Range) | 有效十进制精度 |
|---|---|---|---|---|---|
| FP32 | 32 | 8 | 23 | \( \approx 10^{\pm 38} \) | 约 7 位 |
| FP16 | 16 | 5 | 10 | \( [-65504, 65504] \) (\( \approx 10^{\pm 4.8} \)) | 约 3~4 位 |
| BF16 | 16 | 8 | 7 | \( \approx 10^{\pm 38} \) | 约 2 位 |
这张表揭示了浮点格式在固定 16-bit 预算下的残酷权衡:Precision vs Dynamic Range。
- BF16 选择了极大的动态范围:它直接完整保留了 FP32 的 8 位指数,因此它的上溢与下溢边界与 FP32 完全一致。代价是尾数被砍到仅剩 7 位,相对精度只有约 \( 2^{-7} \approx 0.8\% \)。
- FP16 选择了稍好的相对精度:保留了 10 位尾数,但指数只分到 5 位,导致最大值被限制在 65504,最小非零正规数仅为 \( 2^{-14} \approx 6.1 \times 10^{-5} \)。
混合精度训练的分级法则#
在 从 AMP 到 Mixed Precision 中,我整理过现代训练系统里的精度分工:
| 计算环节 | 推荐计算精度 | 核心动机与工程权衡 |
|---|---|---|
| GEMM 输入张量 | FP16 / BF16 | 充分激活 Tensor Core 极高计算吞吐,减半权重与激活显存 |
| GEMM 累加器(Accumulator) | FP32 | 矩阵乘法点积涉及成千上万次累加,必须用 FP32 抑制误差爆炸 |
| LayerNorm / RMSNorm 统计量 | FP32 | 均值、方差平方和及倒数开方对精度极其敏感,避免溢出与消去 |
| 梯度累加(Gradient Accumulation) | 通常 FP32 | 跨 micro-batch 梯度求和涉及小数值持续叠加,防止被 ULP 吞噬 |
| 优化器状态与 Master Weights | 必须 FP32 | 权重微调更新步长极小,必须保留 FP32 消除截断滞后 |
有几个细节容易想当然,值得单独拎出来说:
为什么 BF16 通常不需要 Loss Scaling,而 FP16 必须依赖?#
在神经网络的反向传播过程中,大量的梯度值都分布在 \( 10^{-5} \sim 10^{-8} \) 甚至更小的区间内。
在 FP16 下,最小正规数只有 \( 6.1 \times 10^{-5} \)。比它更小的梯度不会立刻变成 0:FP16 还有一段次正规数(Subnormal)可以一直落到 \( 2^{-24} \approx 6 \times 10^{-8} \),但这一段里有效位数从 10 位一路掉到 1 位,精度所剩无几;再往下才被舍入成 0。梯度里相当大的比例正好落在这个区间,更新量要么被磨得严重失真,要么直接归零,反向传播的效果就废了。
为了解决 FP16 的动态范围问题,必须引入 Loss Scaling:在反向传播前,将 Loss 人为乘以一个放大系数(如 1024 或 32768),使整个反向梯度的分布整体向右平移进入 FP16 的安全动态范围;在反向传播完毕、更新权重前,再将梯度除以该缩放系数。这需要维护动态跳步(Dynamic Loss Scaler),一旦中间出现任何溢出就放弃本步更新。
而 BF16 的指数范围与 FP32 完全相同,最小正规数远达 \( 10^{-38} \)。神经网络反向梯度的数值基本不会因为动态范围不足而下溢,所以 BF16 训练通常不需要 Loss Scaling 这一层动态调节。
FP32 Accumulation 的能力边界#
Tensor Core 允许输入为 BF16,而内部矩阵乘累加使用 FP32 寄存器(gemm_accum_type = FP32)。
一个容易产生的错觉是:既然累加器是 FP32,那精度是不是就没有损失?
并非如此。FP32 Accumulation 无法恢复输入被 cast 为 BF16 时已经丢失的尾数信息。如果你的原始数据在从 FP32 强制截断为 BF16 时砍掉了后 16 位尾数,这些信息在进入乘法逻辑的一瞬间就已经物理蒸发了。FP32 Accumulation 的唯一作用,是保证在随后的几千次乘积累加过程中,不再引入新的低精度累积舍入误差。
为什么需要 FP32 Master Weights?#
大模型训练时,学习率 \( \eta \) 通常在 \( 10^{-4} \sim 10^{-5} \) 级别,而梯度可能在 \( 10^{-3} \) 左右。参数的单步更新量 \( \Delta w = -\eta \cdot g \) 往往只有 \( 10^{-7} \sim 10^{-8} \)。
如果直接将更新量加在 BF16 的模型权重上:以 \( w \approx 1 \) 为例,BF16 的 ULP 是 \( 2^{-7} \approx 0.0078 \)。一个 \( 10^{-7} \) 量级的更新量试图加到一个 ULP 为 \( 0.0078 \) 的数上,下场和前面 \( 10^8 + 1 \) 那个例子是同一个——更新量被完全舍掉,参数原地不动。
因此,优化器内部必须始终维护一份全精度的 FP32 Master Weights。权重更新在 FP32 上精确累积,只有在前向传播开始前,才转换成(cast 为)BF16 载入 Tensor Core。
需要特别区分的是:PyTorch AMP 的 Autocast 并不负责维护 Master Weights。Autocast 只负责前向算子维度的黑白名单动态类型转换;而 Master Weights 是优化器(如 Apex FusedAdam 或 PyTorch 原生 AdamW 的内部实现)与分布式框架(如 FSDP2 的权重 sharding 逻辑)所承担的显存与精度管理职责。
当数值稳定性遇上系统实现#
在单机单核时代,数值算法的优化主要局限在公式变形与误差分析。但在现代 GPU 与分布式集群环境下,数值稳定性与存储层级(Memory Hierarchy)、计算图融合(Kernel Fusion)以及通信拓扑(AllReduce Topology)深度交织。
1. FlashAttention 与 Online Softmax:流式计算怎么保持数值正确#
在之前关于 FlashAttention 核心思想 的讨论中,我详细分析过它如何避免把 \( S \times S \) 的 Attention Matrix 物化到 HBM。
而从数值稳定的角度看,FlashAttention 之所以能成立,数学上的底牌是 Online Softmax(在线流式 Softmax)。
常规写法要分三遍处理整行数据:
- Pass 1:计算整行的全局最大值 \( m = \max_{j} S_j \)。
- Pass 2:计算指数项之和 \( l = \sum_{j} e^{S_j - m} \)。
- Pass 3:计算每个元素的归一化概率并与 Value 矩阵加权求和 \( O = \sum_{j} \frac{e^{S_j - m}}{l} V_j \)。
序列长度到 8192 时,单是一张 \( 8192 \times 8192 \) 的 score 矩阵按 FP16 算就有 128 MB,而它只是 attention 中间结果的一部分。常规写法要把这块矩阵写进 HBM,再读回来做 max、做 exp、做归一化,带宽开销比计算本身还贵。
FlashAttention 能一块块流式计算,是因为它不需要提前知道整行的全局最大值,也能得到精确的最终加权结果。
靠的是在线状态维护与动态重缩放(Dynamic Rescaling)。
在 GPU 的片上 Shared Memory(SRAM)中,FlashAttention 为每个 Query 维护一个局部三元组状态:
- \( m \):当前已处理数据块的局部最大值。
- \( l \):相对于当前最大值的局部指数和。
- \( O \):相对于当前最大值的未归一化加权累加值。
当从 HBM 加载一个新的分块(Block \( B \))进入 SRAM 时: 设历史累积块为 \( A \),其状态为 \( (m_A, l_A, O_A) \);新分块数据为 \( B \),其局部统计量为 \( (m_B, l_B, O_B) \)。
更新步骤如下:
- 刷新全局最大值: $$ m_{new} = \max(m_A, m_B) $$
- 计算历史块与当前块的重缩放因子(由于减去的是更大的 \( m_{new} \),两项指数均恒非正,彻底避免溢出): $$ \alpha = e^{m_A - m_{new}}, \quad \beta = e^{m_B - m_{new}} $$
- 更新分母与分子累加状态: $$ l_{new} = \alpha \cdot l_A + \beta \cdot l_B $$ $$ O_{new} = \alpha \cdot O_A + \beta \cdot O_B $$
直到所有分块处理完毕,在写出到 HBM 前,只需要执行一次除法:
$$ O_{final} = \frac{O_{new}}{l_{new}} $$这个更新方式和前面的 Welford 方差增量算法 是同一个套路:只要在片上寄存器里维护住足够表征当前状态的统计量,就能一边流式读数据一边得到精确结果,不用把中间状态写回显存。
需要明确说明的是:分块计算与完整计算在数学逻辑上严格等价,但在浮点位级上并不保证 Bitwise Identical。Tiling 改变了矩阵乘累加和指数求和的具体括号结合顺序,产生微小的舍入差异是必然的。
2. GPU 规约与分布式 AllReduce 的非确定性#
浮点加法不满足结合律,这件事放到分布式训练里,就变成了很多人遇到的"训练复现性困境”。
在分布式数据并行(DDP)与全切分并行(FSDP2)中,节点之间需要通过 AllReduce 同步梯度。关于通信机制与梯度桶重叠,可以参考之前的 DDP Gradient Bucketing 与 ZeRO 显存分片。
从数值稳定性的视角看,不同的 AllReduce 实现意味着不同的浮点归约树:
- Ring AllReduce:每个 GPU 将梯度切成 \( N \) 份,Reduce-Scatter 和 All-Gather 两个阶段各走 \( N-1 \) 步,加法沿环逐跳累加,顺序是严格线性的。
- Tree AllReduce:在多机跨节点高带宽网络(如 NVLink + InfiniBand)下,NCCL 常用双二叉树(Double Binary Tree)做并行规约,加法顺序是多路树状汇聚。
同一份代码,8 卡单机时 NCCL 走的是某种拓扑;扩到 16 卡甚至 64 卡跨机,NCCL 会根据网络拓扑切换算法和分块大小。
这意味着:只要集群规模(World Size)改变,或者底层的归约拓扑发生切换,每个参数梯度相加的浮点顺序就变了。
由于加法没有结合律,即使随机种子完全一致,第 1 个 step 同步后的梯度就会在低位产生微弱的浮点漂移;经过几千个 step 的非线性激活函数和优化器动量迭代后,Loss 曲线出现肉眼可见的分离并不奇怪。
这里有三组容易混用的词,值得分开看:
- Numerical Accuracy(数值精度):计算结果与实数理论解之间的绝对/相对距离。
- Determinism(确定性):在相同硬件、相同卡数、相同软件版本下多次重复运行,输出是否能够保持逐 bit 严格一致(Bitwise Identical)。
- Reproducibility(可复现性):在跨硬件拓扑、跨卡数配置、微调超参的环境下,模型最终的收敛轨迹、下游评估指标是否在统计意义上保持一致。
不过也不能把"不同 AllReduce 拓扑必然产生可观测差异"当成绝对结论。具体差异高度取决于数据分块尺寸、通信数据类型(Communication Dtype)、梯度累加器类型以及归约顺序。如果通信前已经将梯度正确量化,或者在 FP32 下规约,扰动通常落在模型能吸收的范围内。
盲目追求绝对的 Bitwise Determinism,往往要强制单线程顺序规约、关掉 GPU 内部的并发原子操作(如 atomicAdd 的乱序累加),代价是性能被砍掉一大截。实际工程里要的是保证数值稳定,容忍良性舍入扰动,靠优化器动力学拿到可复现的结果。
工程诊断框架:一套系统化的数值排查路径#
线上突然遇到 Loss NaN、梯度爆炸,或者推理算子输出异常时,我排查的顺序大致是这样,先分层定位,再动断点和单步:
- Representation(表示检查):
- 检查输入张量、权重与中间状态的物理 dtype。
- 是否存在意外的隐式降级(例如在算子边界无意间把关键张量 cast 成了 BF16)?
- 累加器是否被错误配置成了 16-bit?
- Range(极值与动态范围):
- 检查 NaN / Inf 诞生的第一现场。
- 算子中是否有裸除法?分母是否有潜在的除零风险(是否遗漏了 \( \epsilon \))?
- 指数项之前是否做了减最大值(Max Subtraction)?
- 梯度范数是否超出了数据类型的动态范围极限?
- Conditioning(病态性分析):
- 分析出现问题的数学公式本身:这是一个敏感的病态问题吗?
- 协方差矩阵是否接近奇异?损失函数的曲率是否极端陡峭?
- 如果问题本身 Ill-conditioned,升级精度毫无意义,必须改变算法表征或增加正则化约束。
- Algorithm(算法稳定性检查):
- 是否存在两接近大数相减导致的灾难性消去?
- 方差计算是否使用了危险的 \( \mathbb{E}[X^2] - (\mathbb{E}[X])^2 \)?是否应该切到 Two-pass 或 Welford?
- 是否有现成更稳定的数学等价实现(如将
log(1 + x)替换为log1p(x),将exp(x) - 1替换为expm1(x))?
- Accumulation(累加与拓扑结构):
- 归约维度的规模有多大?
- 是在长链条上做顺序串行累加,还是基于树状分层归约?
- 分布式通信中的 AllReduce 拓扑与累加类型是否合理?
- Trade-off(系统开销权衡):
- 解决当前数值问题所需的最小代价是什么?
- 将该层提回 FP32 会增加多少显存占用和延迟?这个局部开销是否能被整体性能预算吸收?
实战调试里最有用的一条:先定位「第一个产生显著相对误差的算子」,而不是盯着最终崩溃的 Loss。
在几十层的 Transformer 网络中,最终的 Loss 暴死往往是几十个 step 之前某个细小算子数值下溢的连锁反应。排查时可以在前向和反向传播中二分插桩,记录每个 Layer 输出的相对误差:
$$ \text{Relative Error} = \frac{\|y_{\text{test}} - y_{\text{ref}}\|_2}{\|y_{\text{ref}}\|_2 + \epsilon} $$当相对误差在某一个算子之后跳变式放大时,病灶就定位到了。
写在最后#
回到开头那条链路,三个判断可以再收紧一点:
- 数学等价和数值等价是两件事。代数推导只保证纸面上的结果,落到代码里还有求和顺序、中间变量范围和舍入约束。
- 精度是预算。Tensor Core 的吞吐、HBM 的带宽、SRAM 的容量,都在给这个预算定价,所以不存在"全用 FP32 就安全"这种答案。
- 数值稳定性是系统问题。Warp 里的 shuffle 归约、SRAM 分块上的 online softmax、跨机的 AllReduce 拓扑,都会改变误差的传播路径。
把这三件事分开看之后,很多"数值玄学"就能落到具体的检查项上:这个算子在哪一步丢的有效位,误差沿着哪棵树传播,最后被哪一层放大。
开头那个 H20 上的计算,最后也是靠这套清单落地的:主体计算用 FP32,长链求和交给 Kahan 补偿,统计量单独保 FP32。FP64 的算力缺口,很大一部分是能用算法补回来的。
参考资料#
- Goldberg, D. (1991). What Every Computer Scientist Should Know About Floating-Point Arithmetic. ACM Computing Surveys (CSUR), 23(1), 5-48.
- Higham, N. J. (2002). Accuracy and Stability of Numerical Algorithms (2nd ed.). Society for Industrial and Applied Mathematics (SIAM).
- Micikevicius, P., et al. (2017). Mixed Precision Training. International Conference on Learning Representations (ICLR 2018).
- Milakov, M., & Gimelshein, N. (2018). Online normalizer calculation for softmax. arXiv preprint arXiv:1805.02867.
- Dao, T., Fu, D. Y., Ermon, S., Rudra, A., & Ré, C. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. Advances in Neural Information Processing Systems (NeurIPS 2022).
- Welford, B. P. (1962). Note on a method for calculating corrected sums of squares and products. Technometrics, 4(3), 419-420.
- PyTorch Documentation. CUDA Automatic Mixed Precision examples & Reproducibility.
- NVIDIA Documentation. Deep Learning Performance Guide: Mixed Precision Training.