先把地基铺平,再学两类指标和一把噪声尺子,弄清浮点和硬件在哪儿舍入,然后跟着一次真实的排查走到底: TPU 的 loss 三百步以后平均比 GPU 低约 1.7e-4,查到最后,答案在一个谁都没怀疑的地方;再跟第二个案例:两种数学等价的并行方式对不上,这回又是谁的差?
这一讲另有一份讲义(授课稿)。
讲义写的是怎么讲:每一段的目的、讲到哪里该停、常见的误解、 被问到了怎么答。内容本身在你现在看的这份正文里。
两个用法。自己上台讲:照着讲义讲,台词、切图、时间都写着。 自学:把讲义整份丢给 AI,你会得到一个既有这一讲全部背景、 也知道该怎么讲的助教,让它带你走一遍。
全讲的例子是一次真实的对齐:混元 3(一个 MoE 模型,截前 4 层),GPU 侧 B200×8 + Megatron-Bridge,TPU 侧 v5p(8 颗芯片)/ v7x(4 颗芯片) + MaxText,同一份权重、同一批数据,1000 步。 数字都是这次实测的;自己推出来的,标了「本课推导」。出处在第十节末尾的台账。 后来又做了一次迁移(混元 4 的缩小版,一个更新的、带稀疏注意力的 MoE 模型,下文叫「第二次迁移」),同一套方法又走了一遍,后面借它当旁证和第二个案例(第八节),用到时都先报名字。第三次迁移是混元 4 的另一个尺寸,这次从生产代码原样起步,查清了几件「换了条件就不作数」的事(第五节)。
后两次迁移,两边为对上改了七十来处(改动台账 119 行,去掉诊断开关、工具和只核对不改的),编译器省掉的舍入一份程序就有 272 处,多数盖不过 GPU 自己的噪声。下面 16 处是真正查清的,三处在 GPU↔TPU 曲线上看不出、可会让配置或参照不作数。点一行看影响多大。
| 查出来的现象 | 影响多大 | 在哪讲 |
|---|---|---|
| 写的,不是生效的 3 处 | ||
| 权重衰减:GPU 框架模板里两个默认值分了家,优化器写 0.1、调度器写 0.033,调度器每步覆盖 | 0.1 一步都没用上,实际 0.033,差 3 倍;GPU↔TPU 曲线上看不出 | §2.3 |
| 「存下路由、反向不重选」,配错一种重算策略就被悄悄忽略 | 平均 2.4% 的 token(最多 3.05%)按另一套路由算梯度;参数范数 r 4.56,存下路由后 2.27 | §2.3 折叠 |
| TF32 开关说的不算:只关 PyTorch 的,另一条路照样走 TF32;设环境变量全关了,开关读回来反倒是「开」 | FP32 矩阵乘离 FP64:只关 PyTorch 开关时那条仍是 2.94e-4,设 NVIDIA_TF32_OVERRIDE=0 全关才到 1.15e-6;GPU↔TPU 曲线上看不出 | §5.5 |
| 在哪儿舍、怎么舍 6 处 | ||
| GPU 张量核每 16 个乘积抹一次零 | 同一次求和越长越偏:合成输入长 65,536 时朝零偏 3.1e-4(相对) | §5.2 |
| 4 个设备上验过的程序,换到 8 个设备,一次求和从舍 1 次变成舍 6 次 | 那批投影离 FP64:TPU 2.35e-3,GPU 1.66e-3,R 1.41;代码一行没改 | §5.3 |
| 名义 FP32 的输出头,在 TPU 默认精度下只算一遍 BF16;第 1 步看不出 | 权重离开格点后 logits 误差是真 FP32 的约 5000 倍(推断:1.9e-3 对 3.7e-7,在模拟离格 10 步的权重上测);前 300 步主 loss r 7.32,换 high 档 1.03 | §5.5 |
| TPU 默认的 exp、log 图快不图准 | v5p 上 exp 最多差 105 格、log 62 格(GPU ≤ 2 格);单算子离 FP64 最多是 GPU 的 8.68 倍;GPU↔TPU 曲线上看不出 | §5.5 |
| 一个 Python 常数(log₂e)跟着 BF16 的 q 一起被舍 | 注意力 logits 整体放大 1.8e-3 | §5.5 折叠 |
| 🆕MTP 头的梯度舍成 BF16 之前,两边乘的系数不同(GPU ×0.1,TPU ×0.1 再除以 token 数) | 正确词那一项挤在一个 BF16 格距里,两边舍的方向相反;1000 步 MTP 偏到尺子的 3.02–4.28 倍;诊断已定位(TPU 改在 GPU 的尺度上舍,回到 0.15–0.68 倍),修法待定 | §5.5 折叠 |
| 编译器替你省掉的舍入 2 处 | ||
| RMSNorm scale 那次「舍成 BF16」:4K 程序里在,32K 程序里 8 个全被删 | 没补时 1000 步主 loss r 7.8,不过;二分时只补这一处降到尺子的 0.54 倍,补别处的都还在 28 倍左右 | §5.4 |
| 三份梯度相加,两边舍的次数不一样 | 主 loss 判待定(r 1.55):第 551–1000 步对 GPU 16 份均值偏 +9.4e-6,照 GPU 写法全补上还剩 +6.9e-6 | §9.1 |
| 路由一翻,梯度就换了一份 2 处 | ||
| 输入只差一丝,近平局的 token 就换了专家 | 第 1 步 TPU 对 GPU 的 rel_L2:比到的 50 个张量合起来 1.28e-3,一个专家的梯度 0.102,是它的约 80 倍;对 FP64 这个专家 R 不超过 1.04,不是算错 | §4.3 |
| 🆕视觉塔自己不选专家,q、k 的梯度照样越线 | R 1.21–1.53;照 TPU 的路由重算 FP64,降到 0.43–0.83:全是路由翻转 | §4.3 折叠 |
| 两个案例,一个编译器 bug 3 处 | ||
| TPU 的主 loss 三百步以后平均比 GPU 低约 1.7e-4:TPU 算错了吗? | 第 301–1000 步对一份 GPU 基线的带符号均值 −1.66e-4(相对);第 1000 步参数范数多涨 2.1e-2(绝对差,参数范数约 3042)。答案在一个谁都没怀疑的地方 | 第七节 |
| DDP 和 FSDP 数学等价,曲线却超出噪声 | 词嵌入梯度离 FP64:纯数据并行 1.51e-2,GPU 4.17e-3,R 3.62;全出在 39 个词上 | 第八节 |
| 一个 FP32 开关打开,一块梯度凭空没了 | r 冲到 611 | §8.2 |
R:离 FP64 的距离之比(§4.2);r:曲线上的差 ÷ GPU 自己的噪声上限,过 2 判不过(§3.3);格:末位差几格(§5.5);🆕 新查到,正文在折叠里。
它们是怎么一处一处查出来的,就是这一讲。从最开头那件讲起 ↓
把一个在 GPU 上训好的模型搬到 TPU,要的保证只有一句:TPU 训的是同一个模型。同样的数据、同样的初始权重、同样的超参,两边训出来的东西在统计上分不出来。
⚠️ 本课推导:BF16 有 7 位尾数,1 附近的格距 2⁻⁷;1 + 2⁻⁸ 正好落在 1 和 1 + 2⁻⁷ 中间,就近舍入平局取偶,舍回 1。
📌 脚本里用 struct 把 float32 截到高 16 位并按平局取偶进位,真算两遍,结果写死在断言里。
同一个 GPU 程序跑两遍,会一位不差吗?不会:GPU 自己跑两遍也不一位不差。反向里有些算子(注意力的反向、MoE 分发 token 那一步的反向、融合的交叉熵都可能是,这次没拆到是哪个)要很多线程往同一个格子里加数(原子加),谁先算完谁先加进去,每次的先后都不一样。 前向通常是确定的,所以两次运行第 1 步的 loss 一样;从反向开始才分叉。
有人把 8 个大小悬殊的数(±1e-10、±1e-5、±1e-2、±1,正负成对,精确和是 0)用 Python 的 64 位浮点随机打乱求和 1 万次,得到 102 种不同的结果;同一篇文章也指出,大模型的前向在同一台机器上重跑是逐位一样的,大模型里常用、又要原子加的,基本只有 FlashAttention 的反向(Thinking Machines,Defeating Nondeterminism in LLM Inference,2025)。
GPU 上跑出来的标准答案叫 golden。同样设置的 GPU 再多跑几次,两两配对,每对算同样的统计量,取绝对值最大的那个,叫噪声上限 N,正负对称。拿它当尺子。道理一句话:如果 TPU 只是换了加法顺序,它跟 GPU 的差,应当跟 GPU 两次重跑之间的差一样大;比这个大,就是真有东西不一样。
📌 实测(从原始逐步记录重算):10 份同设置 GPU 运行(含最早跑的 3 份)两两 45 对,每对算第 301–1000 步主 loss 逐步相对差的带符号均值;绝对值最大的一对是 6.76e-5,就是 N。浅灰小点是各份对第一份的读数(−6.5e-5 至 +2.4e-6),只是画给人看,不参与算 N。
📌 实测:TPU 原样 −1.66e-4、不开重算 −1.35e-4、改编译器片上内存上限 −1.03e-4,都是对第一份 GPU;除以 N 是 2.45、2.00、1.53 倍。
📌 实测:三个蓝点彼此也散开约 6e-5,跟 N 差不多大:是整团挪了,不是哪一种跑法单独跑偏。
📌 实测:最左是原样跑:第 301–1000 步平均 −1.66e-4,开头说的「约 1.7e-4」就是它。
注:判过不过还要看纯噪声自己能拿几分(第三节);这里只立尺子。
GPU 也能开确定性模式,把重跑的差关成 0;可生产训练不开它,尺子要量的是生产配置下会有的执行噪声。
⭐ 地基不平,楼上量到的差就说不清是算出来的还是喂出来的(接上图)
L0 的要求是一位不差;L1–L4 才谈「差多少算正常」。
代价:每一级都要能单独拿到证据 —— 在 TPU 上怎么拿,后面专门讲。
验收从下往上一级级过,排查从上往下一级级缩小范围。每一级怎么判,后面几节讲。
| 级 | 查什么 | 怎么判 |
|---|---|---|
| L0 地基 | 每一步每张卡吃的数据、转换后的权重、配置 | 一位不差 |
| L1 单个算子 | 一个矩阵乘、一次优化器更新 | 两边各离 FP64 真值多远(第四节的 R 比) |
| L2 单层 | 第 1 步每一层的前向、反向,每层单独回放 | R 比(前向、反向都是) |
| L3 整网第 1 步 | 全部参数的梯度、更新后的权重和优化器状态 | 对 GPU 第 1 步重跑的噪声;超出的、尺子看不见的,对 FP64 定责(§4.2) |
| L4 多步 | 1000 步的 loss、梯度范数、参数范数 | 对 GPU 噪声(第三节) |
混元 3 截前 4 层,GPU B200×8 搬到 TPU v5p(8 颗芯片)。地基全部逐位,第 1 步 loss 只差 2.5e-6;可是三百步以后,TPU 的 loss 平均比 GPU 低约 1.7e-4,参数范数也多涨一截。方法是通用的;具体的数只对这个设置(截 4 层、1000 步、学习率 1e-5 不变)成立。
| 这一讲用到的几组运行 | 多少 | 用在哪 |
|---|---|---|
| ① GPU 默认设置 | 10 份 | 第 1 步那几级(L0–L3)的参照;第一节的尺子、§3.3 的基线贴边;§7.5 的零点是另跑的同设置 4 份(带探针)的均值 |
| ② GPU 生产 golden(生产近似:整层重算+路由回放) | 5 份 | §9.4 拆账的零点 |
| ③ 只修一处的 golden(② 的输出头那次长求和换成 FP32 一次累加,第七节揭晓) | 5 份、两两 10 对 | 定案前第一关的尺子(§3.3 的例子) |
| ④ 精确轨迹,② 的配置(整层重算+路由回放) | 1 份基线,另有 4 份扰动版 | 定案前第一关的基线;基线连同 4 份扰动版共 5 份,两两 10 对是定案前那次交叉核对(§10.6 台账)的尺子 |
| ④′ 精确轨迹(GPU 上全程 FP32 算术),不重算配置 | 1 份,另有一份扰动版和一份改过一处的 | §7.5 的诊断 |
| ⑤ 修好的 golden(② 的同一次长求和换成升 FP32 再分块,第七节揭晓) | 10 份、两两 45 对 | 第一关的基线(取其中一份)和尺子(§9.5) |
| ⑥ 真精确(精确轨迹再改一处,第九节) | 1 份 | §9.4 的真精确参照 |
| TPU | 3 种跑法;扰动臂 7 个+基线,28 对 | 第一节的三个点;TPU 自己的执行噪声(§10.3 的回归) |
| TPU 扰动组(定案后) | 9 份(v5p 5、v7x 4),只改执行参数 | §9.5 只报:TPU 不是挑出来的好样本 |
编号不用记,只记最后定下来的标准答案叫「修好的 golden」(表里标 ⑤,第九节讲它怎么来的);用到别的那几份时会说名字。下文的「第一关」=对修好的 golden 判过不过;「第二关」=对 GPU 生产 golden 写清差在哪、差多少,记「已解释差异」(§9.4)。
前六节备工具,第七节回来把它查到底;第八、九节是第二次迁移的两个案子。另外两次迁移当旁证,用到时都先报名字:
| 第二次迁移 | 混元 4 的缩小版(一个更新的、带稀疏注意力的 MoE 模型),同一套方法在它身上又走了一遍 |
| 第三次迁移 | 混元 4 的另一个尺寸,不先对齐代码,从生产代码原样起步、一个开关一个开关地打开;它的几个发现,都是「换了一个条件,之前的验证就不作数」 |
xla_allow_excess_precision,默认开);表现为中间值不按 BF16 落地:成对的「转 BF16 再转回」可能被删掉,也可能在 HLO 里还在、后端编 kernel 时省掉(§5.4)。光看这个数判断不了。要先量 GPU 自己重跑几次、两两差多少:如果 GPU 自己也常差到 1e-4,那就是噪声;如果 GPU 自己只差 1e-5 量级、而且 TPU 一直偏向同一边,才值得查。
这一节留下的问题:数据、权重、配置,怎么做到两边一位不差?
L0 只有一条要求:两边的输入一位不差。这一级不过,后面量到的任何差,都说不清是算出来的还是喂出来的。喂进去的有三样:数据、权重、配置;验法只有一个:不信过程,只比结果,把两边真正吃进去的东西拿出来逐位比。
三样输入,一个验法(只比结果、逐位比),第 1 步 loss 收口
📌 实测:每个单元记 tokens、labels、loss_mask、position_ids 各一个 sha256,另比每步非 padding 的 token 总数;对 GPU 比了前 30 步共 1,950 项,0 不同,之后按步号回放同一份批文件。
📌 实测:TPU 原生加载器读同一份数据,索引表逐字节相同、样本流逐位相同;按原样布局只有 2,000 / 16,000 个单元落到同号设备(两边梯度累积切分的方式不同),重排后全部逐位。
两边各读各的数据集,顺序、切分、分到哪张卡,任何一处不同,比的就不是同一个训练。所以 TPU 不读数据集,只回放 GPU 存下来的那一份。
框架建设备网格时会按物理拓扑重排设备,网格上的第 d 片不一定是设备列表里的第 d 个;梯度累积拆微批又发生在编译后的程序里面。所以按「全局批的第几行」来排:GPU 第 d 张卡的第 m 份放在全局批第 d·G+m 行(G 是每卡的微批数。这是本例框架的拆法,别的框架、甚至同一框架的别的训练器可能不同,按自己的代码核对)。排错了不报错,编译器会悄悄搬数据,分组照样错。核对办法:组好全局批以后遍历每个设备上那一片,用它的索引去对指纹。
从开源权重转成两边各自的格式,要处理改名、拼接、拆专家、转置。证明转对的办法是转过去再转回来,跟原始文件按原始字节逐个张量比: 1,781 个张量全部相同,包括 3 个 FP32 的路由偏置和 1,778 个 BF16 张量;参数总数(不含路由偏置)12,386,079,744,两边一致。
这里按开源权重的命名数,一个矩阵一个张量:3 个 MoE 层 × 192 个专家 × 3 个矩阵(gate、up、down;Megatron 里 fc1 = gate 和 up 拼在一起,fc2 = down)= 1,728,加其余 53 个(norm、投影、路由、共享专家、词嵌入、输出层)。§7.4 状态互换的文件按 GPU 框架的布局存,q/k/v 合成一个、gate/up 合成一个,每个专家只剩 2 个矩阵:1,152 加其余 41 个,同样的元素数出 1193 个。
参数全部比;FP32 主权重比的是 GPU 那边抓下来的 50 个张量。
📌 实测:每一步从 GPU 优化器参数组读出的权重衰减,1000 步全是 0.033(一维参数和 bias 是 0)。两个默认值都来自框架预训练模板:优化器 weight_decay 0.1;调度器 start_weight_decay = end_weight_decay = 0.033、constant,构造时就覆盖一次、之后每步覆盖。TPU 侧配 adam_weight_decay: 0.033。0.033 的来历框架没写,没查到。
⚠️ 本课推导:0.1 ÷ 0.033 ≈ 3。
两个默认值分了家。GPU 训练框架(Megatron-Bridge)的预训练模板里,优化器写 weight_decay = 0.1,学习率调度器里另写了一对起止值 0.033。调度器在第一次更新之前就把优化器的值改成 0.033、之后每一步都改,0.1 一步都没用上。TPU 照抄配置文件,每一步就多衰减三倍,而且不报任何错。
这不是谁写错了:预训练模板里优化器写 weight_decay = 0.1,学习率调度器里另写了一对 start_weight_decay = end_weight_decay = 0.033、constant。调度器在第一次参数更新之前就把优化器参数组的权重衰减改成自己的值,之后每一步都改(一维参数和 bias 是 0)。这是上游的默认行为,用这个模板、只改优化器那一项的人都会碰上;要改,得改调度器那两项。直接用 Megatron 自己的命令行入口不会碰上:那里调度器的起止值默认就取 --weight-decay。0.033 这个常数为什么是它,框架的提交记录里没写,我们没查到出处。
在 GPU 上用 FP64 重放优化器时对不上:不衰减的一维参数对到 FP32 舍入,二维参数的更新量差 1e-3 量级(rel_L2),最小二乘拟合出来正好是 0.033。再看每一步从优化器参数组里读出来的权重衰减,1000 步全是 0.033。改用每步读出的值以后,FP64 重放全部张量都在门槛内。TPU 那边从第一次起就配 0.033、一维参数按名字排除;配置检查和日常回归都钉死这个值。
| 设置 | 两边对成什么 |
|---|---|
| 权重衰减 | 0.033(GPU 配置里写 0.1,被调度器覆盖) |
| 学习率 | 常数 1e-5,逐步核对 |
| 精度 | BF16 计算,FP32 主权重,FP32 优化器状态 |
| 批大小 | 全局 16;每卡每步 2 个微批,TPU 改成跟 GPU 一样的切法(细节见表下折叠) |
| 重算 | 把第一次选中的专家存下来,反向照着用(细节见表下折叠) |
表有几十行,每行一条证据。连切法都要对:只换梯度累积的切分,词嵌入梯度差就是 GPU 自己重跑那点差的 31 倍。
批大小:全局 16;每卡每步 2 个微批,分两次前反向再累加。TPU 后来改成跟 GPU 一样的切法;第七节用到的 TPU 运行是改之前跑的(每设备一次算 2 条),只改这一项跑 30 步没有变好;第九节验收用的是改之后的配置
重算:GPU 生产近似(②,编号见第九节)每层整层重算;TPU 开部分重算(正式验收只存层输入和路由结果,其余在反向里重算;模型配置文件的默认写法还多存各投影,那是日常回归用的)。重算时 top-k 的顺序会变(首次前向不排序、重算时排序),加权求和就差一位;分数贴得很近时还会挑出别的专家 —— 所以把第一次选中的专家存下来,反向照着用(概率在重算里重新算)。归因参照 ① 不重算
同样是一步 16 条数据,一次算 2 条和分两次各算 1 条再相加,加法的分组不同,舍入就不同。GPU 自己做过对照:只换梯度累积的切分,词嵌入的梯度差就是 GPU 自己重跑那点差的 31 倍。 所以 TPU 也改成「每个设备分两次前反向再累加」,让设备 d 的第 m 份正好是 GPU 第 d 张卡的第 m 份。
moe_routing_maps: device),在 TPU 框架里只是自定义重算策略的一个参数:只有 remat_policy: custom 时才收进「要存下来」的名单;配置写的是整层重算(full),什么都不存、反向把整层前向重跑一遍,top-k 也重跑,不报错也不告警。配置项名字对了,不等于生效了。(实测,第二次迁移只差这一个开关:被忽略时,反向重算那次和前向比了 786,432 个(token, 专家)槽位,922 个选得不一样,1.17e-3;改成自定义重算、除层输入外全部重算、只存路由,重选为 0。)GPU 侧有对称的坑(混元 3 搭 GPU golden 时碰上的):Megatron 的「路由回放」开关单独打开也不起作用,训练循环从不去切换它的记录/回放动作,得自己写回调。第三次迁移从生产代码原样起步,又踩了一次,而且看清了后果:生产默认整层重算,反向抓到的路由跟前向在 160 次两两比较里 96 次不同,平均 2.4% 的 token(最多 3.05%)的梯度是按另一套路由算的;参数范数 1000 步判 4.56 倍、前 300 步 11.87 倍。换成那种自定义重算策略、把前向选出的专家存下来,降到 2.27 / 1.19,步时不变。这是语义差,不是精度差:生产也该开。办法只有一条:对照表逐行对写法,不只对名字;参照框架里找不到实现的,协议写了也不算。
第 10 步存档、恢复后跑第 11–20 步,跟一口气跑下来逐位相同:数据位置、逐步的数、FP32 状态都一样。
不能。没抽到的那 1,681 个可能就有一个转置错了;而且 FP32 主权重上小于 BF16 半格的错,第 1 步前向根本看不见。要全量逐位比,加载以后再从设备上读一遍。
这一节留下的问题:一千步的差,怎么压成几个能判的数?
loss、梯度范数、参数范数,每一步各出一个差。这一节把它们压成三个统计量,再拿噪声上限判。
loss 之外,另两个量这样取:
📌 实测:两条 1000 步运行(同权重、同数据、同顺序),第 301–1000 步 TPU 对 GPU 第一份的带符号均值 −1.66e-4,GPU 第二份对第一份 −3.8e-5;两条扣掉均值后逐步上下抖的幅度(标准差)是 1.33e-4 和 1.34e-4(GPU 三对 1.33e-4–1.34e-4),一阶自相关接近 0。
📌 首步差 d₀ 单独报,不进窗口:GPU 重跑第 1 步通常逐位相同,当不了尺子。
| 量 | 怎么算(在一个窗口里,去掉首步) | 看什么 |
|---|---|---|
| 带符号均值 | dₜ 直接平均,带正负号 | 随机的差正负抵消,剩下固定方向的偏移;最常出事的是它 |
| MARE(平均绝对相对差) | |dₜ| 的平均 | 整体抖多大,不管方向 |
| 最大单步 | 最大的 |dₜ| 和它在第几步 | 拦住某一步突然跳一下 |
| 窗口 | 混元 3 | 第二次迁移 | 为什么 |
|---|---|---|---|
| 全程 | 第 2–1000 步 | 第 2–300 步/第 2–1000 步 | 看整段 |
| 尾段(后段) | 第 301–1000 步 | 第 101–300 步/第 101–1000 步 | 前段两条轨迹还没分开,会冲淡偏移 |
| 第 1 步 d₀ | 单独报,不进窗口 | GPU 重跑第 1 步 loss 常常逐位相同,当不了尺子 | |
两个窗口读的是同一条 dₜ 序列,只是求平均的范围不同;每个统计量是整个窗口算出的一个数,不是逐步的滑动平均。窗口写哪段,事先写进协议。
loss 是结果,范数是总量。混元 3 那次,三个被比的量里参数范数最先冲出去:它是个累加器,只换顺序的差这步正、下步负,按步数的平方根散开;丢了精度的差有固定方向,按步数长。跑得够久,再小的系统偏差也会冲出噪声带:
⚠️ 本课推导 + 示意模拟:增量取标准正态(固定种子),蓝线每步多 0.1;设各步的差相互独立,噪声累加的幅度约 √t,偏差累加是 0.1·t(真实训练会把扰动放大,独立只是近似),两者在 0.1·t = 2√t 处相交,t* = 400。真实训练里 b 多大、噪声多宽各不相同,t* 只示意形状。参数范数是累加器:‖θ‖² 每步变 2θ·Δθ + ‖Δθ‖²,学习率小时 ‖θ‖ 的变化约等于 Δθ 沿 θ 方向的分量。
📌 实测锚点:混元 3 定案前第一关参数范数 r 3.45、loss 全程 1.92、尾段 1.29、梯度范数 1.14(判定图)。
| 被比的量 | 抓什么 | 盲区 |
|---|---|---|
| 参数范数、梯度范数 | 攒出来的固定方向的偏,最先有反应 | 只是一个长度:方向变了、一组多涨一组少涨看不出;被大张量主导,归一化权重、偏置上的错几乎看不见 |
| loss(各项分开) | 训练效果变没变 | 只对很大的局部错才显(MTP 那一项权重偏 1e-3 时,MTP loss 本身 r 50,主 loss 只有 0.88;偏到 1e-2 主 loss 才 6.2) |
| 路由偏置均值、散布 | 路由负载的漂移 | 均值在 0 附近来回穿,过零时 dₜ 和 N 一起放大,只抓得到大的语义差 |
所以逐步曲线要配第 1 步的逐张量比较(第四节):一个抓攒出来的偏,一个抓偏在哪个张量。
第二次迁移里故意让 loss 多乘 1.01(相当于漏除一个常数),梯度范数的 r 是 94.5,主 loss 只有 5.2;把 FSDP 改成纯数据并行(第八节的案例),梯度范数 2.62,主 loss 全程 1.85、后段 2.03(运行库 0.0.46;换到 0.0.52 同一改动领头的换成主 loss 后段 2.82,梯度范数 1.45 —— 哪一条先报警会变,所以几条都要看)。loss 告诉你训练效果变没变,可对不少数值问题反应慢;两个范数把几亿个数各压成一个,对固定方向的偏差最先有反应。
一条检查取三个 r 的最大,一次比较取所有检查的最大
| 第二次迁移,FSDP 改纯数据并行,前 300 步(TPU 自比,实测) | 统计 | 被测 | N(GPU 8 份两两 28 对的最大) | r |
|---|---|---|---|---|
| 主 loss | 带符号均值 | +5.58e-6 | 3.01e-6 | 1.85 |
| 主 loss | MARE | 8.84e-6 | 6.72e-6 | 1.31 |
| 主 loss | 最大单步(第 273 步) | 3.70e-5 | 4.53e-5 | 0.82 |
| 主 loss 后段(第 101–300 步) | 带符号均值 | +9.22e-6 | 4.54e-6 | 2.03 |
| 梯度范数 | 带符号均值 | −2.60e-4 | 9.92e-5 | 2.62 |
五个 r 里最大的是梯度范数的 2.62,这次比较就记 2.62,判不过;主 loss 全程三个数里最差的是带符号均值 1.85(待定),后段单独再判一遍是 2.03(不过)。纯噪声按同一套算法能拿几分,见 §3.4。
代码:判档:r = |被测| ÷ N,≤1 过、>2 不过 代码:逐步序列的三种统计
判法一句话:r = |被测| ÷ N,「被测」是 TPU 对基线那一条曲线算出的某个统计量(带符号均值、MARE 或最大单步),N 是 GPU 几份重跑两两成对、同一个统计量里取最大的那个。≤ 1:落在噪声样本的范围里,过;> 2:比最坏的噪声还大一倍,不过;中间待定,先补参照再判(2 是协议事先定的界,留出样本少时 N 偏窄的余量)。
参照对按跟被测一模一样的窗口、分母算三个统计,每个统计取所有对里的最大值当 N:被测如果只是噪声,就是又一个同分布的样本,应当落在已有样本的范围里。规则逐条:
两条自动处理:窗口里逐位相同的参照对剔除,不让它把 N 拉低;剔除后不足 3 对,最多判待定。r = 被测的统计 ÷ 对应的 N;一项检查取三个 r 里最大的,一次比较取所有检查里最大的。≤ 1 过,1–2 待定,> 2 不过;2 是约定的余量,不是统计推导出来的。
📌 实测(定案前那次):被测是 v5p 当前配置 1000 步,基线是精确轨迹的一份(它是什么,后面讲 golden 时细说),N 取 ③ 那组 GPU 重跑 5 份两两 10 对的最大值。
📌 param_norm 带符号均值 4.27e-7、N 1.24e-7;loss 全程 8.62e-5 / 4.48e-5,尾段 7.23e-5 / 5.62e-5;grad_norm 2.32e-3 / 2.03e-3。
📌 定案后:基线换成修好的 golden 的一份、N 取它自己 10 份两两 45 对,loss 全程 0.80、尾段 0.80、梯度范数 0.85、参数范数 0.50。N 取参照各对里绝对值最大的那个;r = |被测| ÷ N。参数范数的相对差只有 4e-7 也判不过,因为 r 不跟「看上去大不大」比,跟这个量自己的噪声比。
图上红黄那四个点是定案前的一次判定:这次判定后来按修好的 golden 重判过(§9.4),3.45 倍留在这里当判法的例子。绿色那一簇是换成修好的 golden 以后的同四项,全部过。
📌 Ⓐ 实测:混元 3 截 4 层,TPU v5p 第一次 1000 步运行对 GPU 第一份,逐步 loss 相对差 dₜ =(TPU − GPU)÷ GPU;全程(第 2–1000 步)带符号均值 −1.30e-4、MARE 1.53e-4、最大单步 6.65e-4(第 380 步);后段(第 301–1000 步)−1.66e-4、1.79e-4、同一步;第 1 步 +2.5e-6 单独报。
📌 Ⓑ 实测:第二次迁移小尺寸模型,TPU 自比「FSDP 8 改纯数据并行 8」对 TPU golden,前 300 步;N 是 GPU 同设置 8 份两两 28 对的上限;分母一律用参照(梯度范数也是,对齐记录 2026-11-10 起统一)。主 loss 全程 +5.58e-6 / 3.01e-6、8.84e-6 / 6.72e-6、3.70e-5(第 273 步)/ 4.53e-5;后段 +9.22e-6 / 4.54e-6;梯度范数 −2.60e-4 / 9.92e-5、5.23e-4 / 3.85e-4、1.84e-3(第 28 步)/ 2.24e-3。带符号均值判定时取绝对值,正负号另看方向。
⚠️ 两块数据来自两个模型:上块是混元 3(为了用一条完整的 1000 步序列),下块是第二次迁移(为了有一份完整公开的算例表)。
一个真实的例子,第三次迁移图文 32K 一千步的 MTP loss:
📌 实测:第三次迁移图文 32K、一种候选配置,TPU v5p 1000 步对 GPU 8 份里的基线那份;判定窗口第 2–1000 步。带符号均值 +2.08e-5,GPU 两两 28 对里最大 6.87e-6;平均绝对差 2.97e-5 对 2.58e-5;最大单步第 941 步 1.35e-4 对 1.43e-4。判定数取对齐记录这次运行的结果文件原值;在带里的步数占比 87% 是从逐步记录重算的(对齐记录未收)。
📌 背景带:每一步取 28 对在这一步的 |dₜ| 最大值,正负各画一边(对齐记录逐步曲线工具的 pairdiff 包络同一口径)。灰线:GPU 另外 7 份各自对同一份基线,跟红线同一个口径(被测减基线,除以基线);在零上面的步数 52%–60%,50 步平均线在零上面的时间 55%–84%(TPU 100%);带符号均值都略为正(+1.5e-6 到 +6.9e-6,基线那份本身略低),最大那份正好就是尺子那一对。
⚠️ 粗线都是 50 步滑动平均,只为看方向;判定只看右边三个数。
87% 的步落在灰带里,单步不乱跳;可红线一直浮在零上,带符号均值是尺子的 3.02 倍,判不过。抖和尖都正常,只有方向不对。
87% 的步落在灰带里,最大单步是尺子的 0.94 倍,平均绝对差 1.15 倍:抖动和尖峰都正常。可 75% 的步在零上面,带符号均值 +2.08e-5,是尺子 6.87e-6(GPU 8 份两两 28 对的最大值)的 3.02 倍,判不过。只有方向不对。图里的 7 条灰线是 GPU 另外 7 份各自对同一份基线,跟红线同一个口径:逐步看,它们在零上面的步数只占 52%–60%,50 步平均线来回穿过零;TPU 的平均线一直在零上面。7 份的带符号均值也都略为正(+1.5e-6 到 +6.9e-6,基线那份本身略低),TPU 是其中最大那份的三倍。这 7 条只是把「跟同一份基线比」画出来、方便看方向;尺子不是用它们算的,仍是 28 对两两、取绝对值的最大值,所以不会变窄。这一截偏后来定位到 MTP 头反向舍成 BF16 之前两边乘的系数不同(§5.5 折叠)。
灰带是这样画的:每一步取所有 GPU 对在这一步的 |dₜ| 最大值,正负各画一边。所以这条带是逐步从不同的对里拼出来的,只用来看,不参与判定。判定用的尺子是另一套算法:每一对先把整段压成三个数,每种数再取所有对里的最大值(§3.3)。对齐记录的曲线工具还画一张累计带符号均值(第 1 步到第 t 步的平均)的图,同样只用来看趋势。
⚠️ 本课推导:被测若只是噪声,而且它和 n 个参照彼此独立、同分布,每一个当最大值的机会相等,超过其余 n 个的概率是 1/(n+1)。实际上 n 对是几份运行两两配出来的,基线也是其中一份,配对彼此不独立:按高斯噪声模拟和留一法实测,带符号均值超线的机会都约是 1/(n+1) 的两倍。所以柱高是下限,签字以留一法实测的纯噪声误报率为准。
📌 实测:第一阶段 GPU 对 GPU 演练(每份 100 步,46 条检查,各级各种量加起来),3 份运行两两 3 对时有 8 条待定;扩到 6 份 15 对,重判那 8 条外加梯度范数一条,共 9 条,剩 3 条;8 份 GPU 对 GPU 28 对重判全部 46 条只剩 1 条(loss 最大单步,1.03 倍)。
只对一份事先指定的基线比,不对几份 golden 取平均,也不取最差:N 量的是「两份运行之间差多少」,被测也该是跟一份运行比,两边口径才一样。对平均比太松,对最差比太严。代价是基线自己也是一个样本,换一份当基线,读数会挪一点(图在折叠里)。
📌 实测:同一设置(默认设置、不开分布式优化器)的 GPU 运行 10 份,含基线那一份;每份对基线算第 301–1000 步 loss 逐步相对差的平均。10 份的均值 −2.46e−5;N = 10 份两两 45 对里最大的 6.76e-5。比基线高的两份只高 2.50e−7 和 2.44e−6。
📌 实测:TPU 三种跑法是同一份代码(原样、不重算、改编译器的片上内存上限),对同一份基线 −1.66e−4 / −1.35e−4 / −1.03e−4。
⚠️ 本课推导:扣掉均值 = 被测值 − 10 份均值;倍数 = 扣掉均值后 ÷ N。灰点竖着错开只为不重叠,没有纵轴。
日常回归里判「只换了舍入位置」的改动,另有一把故意改执行参数造出来的 TPU 尺子(§10.3),跟这里的验收尺子是两件事。尺子为什么只用 GPU 重跑?第二次迁移里,TPU 同一个程序重跑,换一组机器、换一个集群,结果都逐位相同:拿它当尺子,宽度是 0,什么都判不过。硬给 TPU 造点波动来撑宽,又成了被测给自己定门槛(§4.3)。
第二次迁移一次比较要看 8 项检查(7 条曲线,主 loss 开两个窗口),每项 3 个统计,一共 24 个 r,最差的那个说了算。每个数超过自己尺子的机会不大,24 个里总有一个超的机会就大了。纯噪声按同一套判法能拿几分?把 GPU 的重跑轮流拿一份当被测,试一遍:
📌 实测(第二次迁移,小尺寸模型):GPU 同设置 300 步 8 份(56 种轮换,每种尺子 21 对)、1000 步 16 份(240 种,每种 105 对);每种轮换:一份当被测、一份当基线,尺子用其余各份两两重算,检查跟 TPU 自比相同(主 loss 全程与后段、MTP、索引器蒸馏、梯度范数、参数范数、路由偏置均值与散布;1000 步多一条 MTP 后段)。300 步 59% 的最差 r 过 1(其中 11% 过 2,落在 1–2 之间的是 48%),最大 2.47;1000 步 16 份 22% 过 1、没有过 2 的,最大 1.82;1000 步只有 8 份时最大 2.00、64% 过 1。
📌 第三行:TPU 自比 1000 步对 TPU golden;八份尺子的上限比十六份的窄 1.0–2.1 倍,多数检查里放大最多的是带符号均值(路由偏置均值 2.07 倍、梯度范数 1.84 倍)。六个改动:少开投影 FP32 累加 2.75 → 1.64、关矩阵乘之间的融合 2.50 → 1.49、SwiGLU 少舍一次 2.34 → 1.37、每层多记几个统计量 2.33 → 1.40、16 设备纯数据并行 + FP32 词嵌入梯度 2.07 → 1.30、TPU 运行库降一版 2.00 → 1.19(16 份一列是 2026-11-10 曲线分母统一为参照以后的值;8 份一列是统一之前判的,所以 8 → 16 同时换了份数和梯度范数的分母口径,各占多少没拆);其中少开投影 FP32 累加、SwiGLU 少舍一次动了精度,另两个只换顺序,剩下两个(16 设备纯数据并行+FP32 词嵌入梯度、运行库降一版)这里没单独归类。
⚠️ 口径:「GPU 轮换(留一法)最大值」是看到 TPU 结果以后才补的解读,只用来读表,不改判档;对齐记录把它事先登记了,再拿后来的新改动和新尺寸检验。
份数少,尺子就短:300 步、8 份时纯噪声最高 2.47,常常超线;1000 步补到 16 份,纯噪声最高 1.82。所以 r 落在 1–2 之间,先拿纯噪声的最差 r 对一下:不超过它、第 1 步也没有离 FP64 更远的张量(§4.2 末尾),就写「跟重跑分不开」。图第三行那六个分不开的 TPU 改动就是这样落定的。「分不开」不等于「没改精度」:这六个里有两个动了精度,这把尺子只是量不出来(第十节)。
三个量里最差的决定结论:1.6 落在 1–2 倍之间,判待定。待定不能直接签:先加参照重判;再看纯噪声按同一口径能到多少(§3.4)—— 这里只看尾段 loss 一条,1000 步、16 份时纯噪声在这一条上最高 1.23,1.6 已经超了,往下一级去定责;拿整次比较的 1.82 来比就比松了。
这一节留下的问题:偏在哪一层、哪个张量?
第三节的曲线每步只有一个标量,说得出「偏了」,说不出偏在哪。这一节换另一类度量:第 1 步的激活、梯度、权重,一个张量压成一个数;几个指标各管一类错,各有盲点。
⚠️ 本课推导:同长度、夹角 θ 时 rel_L2 = 2·sin(θ/2);cos θ = 0.999 → θ ≈ 2.56°,rel_L2 ≈ 4.47%。图里中格的角度放大了 6 倍画,方便看见。
📌 指标一律在 FP64 里算:两个相近的数相减本身是精确的,丢精度的是后面的平方和、点积和除法。
rel_L2 说差多大;拆开看,cos 说方向偏没偏,范数比说长短变没变。三个一起报,才分得清是转了个角还是整体缩放。
rel_L2 = ‖a − b‖ ÷ ‖b‖(a 被测、b 参照)。记 k = ‖a‖ ÷ ‖b‖(范数比;这里不用 r,免得跟 §3.3 的 r 混),把 ‖a − b‖² = ‖a‖² + ‖b‖² − 2‖a‖‖b‖cos 两边除以 ‖b‖²: rel² = (k − 1)² + 2k(1 − cos)(本课推导)。第一项是长短不一,第二项是方向不一;两个都为零,rel_L2 才是零。
等长时 k = 1,只剩 rel² = 2(1 − cos)。纯旋转 θ:两支等长箭头的箭尖相距 2 sin(θ/2),所以转 2.5° 左右(cos = 0.999)rel_L2 就是 4.5% —— cos 看着很近,差向量已经不短了。
| 指标 | 抓什么 | 看不见什么 |
|---|---|---|
| 宽度比 | 分布变宽变窄 | 只看宽度 |
| 均值偏移 ÷ 宽度 | 整体往一个方向偏了几个宽度:偏置、缩放类错 | 只改宽度不改均值的错 |
| 零元素比例差 | 多出来或少掉的稀疏:漏了 mask、专家没收到 token | 非零值对不对 |
| 逐元素相对误差 p99 | 「大多数元素」错了多少(分母带兜底,不被近零元素干扰) | 最大值 |
| 最大绝对差(带坐标) | 有没有单点大错、错在哪 | 不同张量之间不能比 |
| KL(只用于 logits) | 对「下一个词」的预测分布差多少 | 只适用于 logits |
ULP 是「两个数差了几格」,按原始格式数格子(BF16 就按 BF16 数,按 FP32 数会放大 65,536 倍)。差 1 格占大头,是「同一算法、不同累加顺序」; 重心在 17 格以上,说明误差在累加里被放大了。可跨芯片、经过长求和以后,健康的差也常有几十格:GPU 自己两次运行第 1 步梯度,差 1 格的只占 1.3%,17 格以上占 67%(逐元素口径,跟整个张量的 rel_L2 不是一回事;梯度存的是 FP32,按 FP32 数格:最大差约 1.1e8 格,而 BF16 同号两数最多只差约 3.3e4 格,所以只能是 FP32 格)。所以它只诊断,不能判过不过。
这是 TPU 自比的写法。GPU 搬 TPU 时没有基线那一项:R = TPU 离 FP64 ÷ GPU 几份(现行规则至少 6 份)离 FP64 的中位数。多出一份同量级、互相独立的舍入误差,误差平方相加:R ≈ √2 ≈ 1.41,所以线画在两者之间的 1.2
| 例子(实测) | 被测离 FP64 | 参照离 FP64 | R | 记作 |
|---|---|---|---|---|
| qkv 投影,打开 FP32 累加之前(混元 3,v5p) | 2.33e-3 | 1.89e-3 | 1.235 | 丢了精度 |
| 同上,打开以后 | 1.89e-3 | 1.89e-3 | 1.000 | 换了顺序 |
| 例子(实测) | 被测离 FP64 | 参照离 FP64 | d(超尺子几倍) | R | 记作 |
|---|---|---|---|---|---|
| 词嵌入梯度,纯数据并行(第二次迁移) | 1.51e-2 | 4.17e-3(GPU 中位数) | 5.89 | 3.62 | 丢了精度 |
| 同上,修好以后 | 3.79e-3 | 4.17e-3 | 1.36 | 0.91 | 换了顺序 |
| 8 个设备,往里投的那批投影(第三次迁移) | 2.35e-3 | 1.66e-3 | — | 1.41 | 多舍一次 |
| 视觉塔 q、k 的梯度(第三次迁移,§4.3 折叠) | — | — | — | 1.21–1.53 → R_flip 0.43–0.83 | 路由翻转 |
路由翻转:R_flip = rel_L2(被测, FP64 用被测自己选的专家) ÷ 同一个分母 (R_flip ≤ 1.2 且比不灌时更近 → 记「路由翻转」,不算丢精度;分母不换,换了就等于给翻转放宽尺子)
「修好以后」那一行照样超尺子 1.36 倍,看似没修好;R 0.91,比基线和 GPU 都近,其实修好了:超尺子只说两边不一样,R 才说谁丢了精度。路由翻转按第 4 行判;量级上,一个专家 n 个 token 里换掉 k 个,梯度相对差约 √(k ÷ n)(估量级,推断,§4.3)。
第 1 步前向,GPU 默认设置下两次运行逐位相同,噪声是 0,当不了尺子(反向的梯度有噪声,第三节那把尺子量的是它);FP64 就在这里派上用场。
📌 距离都用 rel_L2 量(离 FP64 的相对误差,两边各用自己抓到的算子输入算真值);靶子上两个点画在不同角度只为分开,只有离圆心多远有意义。
⚠️ 推断(门槛):只差舍入顺序时 R ≈ 1;多一次同量级的独立舍入,误差按平方相加,R ≈ √2 ≈ 1.41;取 1.2 当线。
📌 实测:v5p 上单算子 FP64 对比,qkv 投影 R 1.235 → 1.000,第 0 层稠密 MLP 的输入投影 1.294 → 1.117(打开 FP32 累加的开关后,9 条单算子检查全过)。
R = TPU 离 FP64 的误差 ÷ GPU 离 FP64 的误差:≈ 1 是两边一样远、只差加法顺序;明显大于 1,是 TPU 多出一份同量级的误差(约 √2 ≈ 1.41;不一定只是一次舍入,§5.3 就是多舍了好几次小的)。
但对齐的目标仍然是 GPU(参照自己偏了怎么办,第七节会碰上)。
R 和 §3.3 的 r 别混:小写 r 只说两边差多少,TPU 和 GPU 换个位置它不变,说不出谁错;大写 R 对的是真值,才能定责。同一处可以 r 很大、R 却说 TPU 更准:
📌 课上不讲的例子(备答)。实测(第二次迁移,优化器 8 步回放):照 GPU 把那段迭代改到 BF16 之前,TPU 对 GPU 的更新差最多 12.8%、之后 1.6%;改之前 97% 的张量步 TPU 比 GPU 更接近 FP64,更新对 FP64 的相对误差中位数 3.0e-3 对 3.95e-2。GPU 那段迭代离 FP64 1.2%–13%(同一 8 步回放,范围);两个中位数同一口径(约 13 倍):TPU 原来 3.0e-3,TPU 照 GPU 写法改成 BF16 迭代后 3.95e-2。
📌 FP64 参照是同系数、同样 5 步的 Newton–Schulz 迭代,全程 FP64(结果文件写明),不是 SVD 的精确极分解,所以离 FP64 的距离只是精度差、不含算法差。
📌 落点带里那个例子是另一处:Adam 管的一个小张量,TPU 的除法、开方、偏差修正不够精确,R 3.82 → 1.00(§5.5 折叠)。⚠️ 两边都小于一个 BF16 格时,R 只是两种舍入之比,会来回摆;这时看绝对值。注:左图两点的距离、右图圆的半径是示意,只表示大小关系。
两把参照一起用:第 1 步每个张量既跟基线比(超没超出 GPU 重跑的噪声),又跟 FP64 比(离真值远了没有)。超出噪声、离真值没变远,是换了顺序;远了 1.2 倍以上,才是丢了精度。一个张量走一遍:
代码:FP64 参照(GPU 一侧代码在 CPU 上整网 FP64) 代码:从动量反推梯度、逐张量定责、程序指纹
📌 实测(第二次迁移,TPU v5p 自比,运行库 0.0.46,对 TPU golden):词嵌入梯度离 FP64 的 rel_L2,golden 4.00e-3、GPU 三份中位数 4.17e-3;纯数据并行 1.51e-2,对 golden 的 d 1.46e-2,尺子 2.48e-3,d ÷ 尺子 5.89,R 3.62;修复后 3.79e-3、d 3.37e-3、1.36、R 0.91。205 个张量的尺子中位数 2.68e-3。
📌 梯度:TPU 两侧都从第一动量倒推(Adam 参数 m ÷ (1 − β₁),Muon 参数 buf ÷ (1 − β)),再除以第 1 步的裁剪系数得到裁剪前的梯度;倒推本身带进几个 2⁻²⁴ 量级的相对舍入,所以尺子不低于 2⁻²⁰(GPU 三份逐位相同的张量尺子是 0,205 个里 10 个)。
⚠️ 门槛 1.2 的来历(推断):只差加法顺序时 R ≈ 1;多一次同量级的独立舍入,误差方差约翻倍,R ≈ √2 ≈ 1.41;1.2 取在两者之间。FP64 参照是用参照一侧(GPU)的同一套模型代码,在 CPU 上把第 1 步整网改成 FP64 重算的。GPU↔TPU 对齐时 R 的分母只用 GPU 几份的中位数(2026-11-11 起 6 份),另有「两边离 FP64 都小于一次 BF16 舍入(2⁻⁸)就按下限判过」一条。
顺带记一句:逐步曲线和第 1 步两样都过,才敢说这个改动只是换了求和顺序。
📌 四格各一个例子(第二次迁移,TPU 自比)。左上:换切分、升运行库 0.0.46→0.0.48(基准配置下),大多落在这一格。左下:比如只作用在权重一侧的开关,第 1 步权重还在 BF16 格点上,测不到。右上:比如关小矩阵乘改写:300 步曲线 r 0.94,第 1 步一个归一化权重离 FP64 远 1.40 倍(同一次运行输出头另有三个小参数远 18–46 倍,2026-11-12 加倍数上限后整次判超)。右下:纯数据并行、关省舍入:曲线 2.62、13.3,第 1 步词嵌入梯度 R 3.62、26.1(运行库 0.0.46 上的读数)。
📌 实测(第二次迁移,小尺寸模型,TPU v5p 自比,运行库 0.0.46,对同一个 TPU golden):第 1 步 205 个参数张量的训练梯度,其中多路残差混合的 45 个小参数(缩放、偏置、混合权重)已知病态、单列,不画;画 160 个。单列原先没有倍数上限;2026-11-12 起上限 R 5.22,超过的记未定责:换 v7x 那次输出头的 3 个小参数 R 18–46,这一次因此由「在噪声内」改判「超」(偏差来自输出头反向那颗融合 kernel 里的舍入)。
📌 横:被测对 golden 的 rel_L2 ÷ GPU 第 1 步三份两两的最大 rel_L2(这个张量自己的尺子)。纵:被测离 CPU FP64 的 rel_L2 ÷ max(golden 离 FP64, GPU 三份离 FP64 的中位数);对齐记录的定责规则是 ≤ 1.2 记「换了顺序」,超过记「丢了精度」。
📌 词嵌入梯度离 FP64:golden 4.00e-3、GPU 三份中位数 4.17e-3;纯数据并行 1.51e-2(R 3.62;对 golden 3.77 倍);关 excess precision 1.09e-1(R 26.1;对 golden 27 倍)。关省舍入那一块另有第 4 层路由门控权重 1.20 倍,按规则也记丢了精度、定不了责。横轴大到上千的点,是 GPU 三份完全逐位相同的张量:尺子是 0,按一个很小的下限(2⁻²⁰)算。
左块是常态:九成张量超出 GPU 的噪声,一个都没远过 1.2 倍,只是换了顺序。中、右两块飞得远的都是词嵌入梯度 —— 为什么偏偏是它,第八节整节讲。
九成张量超出 GPU 的噪声,一个都没远过 1.2 倍(最远 1.11)。但这只对画出的 160 个成立:45 个多路残差混合的小参数单列没画(多路残差是混元 4 把残差流复制成 4 路、每层按权混合的结构),其中输出头的 3 个在 v7x 上离 FP64 远 18–46 倍,2026-11-12 单列加了倍数上限 5.22 以后,换 v7x 这次改判「超」。所以左块只说明大张量是换了顺序,换 v7x 本身不能算只换了顺序(§10.1)。中、右两块飞得远的都是词嵌入梯度(运行库 0.0.46 的读数;0.0.52 上 R 3.60、26.11,几乎一样。右块另有一个路由门控权重 1.20 倍刚过线)—— 为什么偏偏是它,第八节整节讲。
这是逐张量比较会误判的一个反例。混元 3 那次,第 1 步的梯度,比到的 50 个张量合起来 rel_L2 是 1.28e-3;第 3 层 0 号专家的两个矩阵是 0.102,是它的约 80 倍。GPU 自己重跑这两个张量一位不差,尺子宽度是 0,照字面就是「不过」;对不对,要靠 FP64 来判。
📌 实测:第 1 步梯度对 GPU 的 rel_L2,第 3 层 0 号专家的权重梯度 0.102,比到的 50 个张量合起来 0.00128;隔离回放的那批 token 里这个专家分到 139 个,TPU 侧少 3 多 1;发生翻转的 token,第 8、9 名「分数+偏置」之差的中位数按层在 2.7e-5 到 6.3e-5 之间。
⚠️ 示意:左格名次条的长度和第 1–10 名的分数是示意,只有「第 8、9 名对调」和分差中位数是实测;右格点阵的个数是实测,哪几个点被换出是随手标的位置。
MoE 的路由给每个 token 挑前 8 名专家(共 192 个),有的 token 第 8、9 名几乎平局;上游注意力两边舍入差一点点,排名就对调,选中的专家换了。给路由器喂两边完全相同的输入,翻转是 0;根子在路由器的输入差,不在路由打分那次矩阵乘。
翻了的 token 第 8、9 名「分数 + 偏置」的分差中位数只有 2.7e-5 到 6.3e-5;路由器输入换成 TPU 自己算出来的(跟 GPU 差 rel_L2 3.4e-3 到 3.9e-3),每层就翻 3.5%–5.4% 的 token。排名用「分数 + 负载均衡偏置」,选中以后加权用不带偏置的分数:偏置只管选谁。在隔离回放的一批 4,096 个 token 里,第 3 层 0 号专家只分到 139 个,换出 3 个、换进 1 个;每个 token 的贡献像方向各异的小向量,换掉 k 个、共 n 个,相对差约 √(k ÷ n) = √(4 ÷ 139) ≈ 0.17,跟 0.102 同量级(推断;翻的都是第 8 名,门控权重小,所以实测低于这个估计也合理)。「喂相同输入翻转是 0」那项检查里,sigmoid 在主机上用 FP64 算,TPU 上近似 sigmoid 的贡献没测。
回头看 FP64:这个专家离 FP64 不比 GPU 远,R 不超过 1.04。不是算错,是两边选中的 token 不一样。
比到的张量:TPU 每层只存了 0、1 号两个专家的梯度,专家只比这两个;其余是全部非专家参数。50 个张量按能量合计 R 1.20(只作参考),逐张量最大 R 2.20 出在第 3 层的 q_norm,前五都是归一化权重和输出层。这个专家自己的 R 结果文件没单独存,但第 3 层只存了最差的 5 个(第五名 1.04),它不在里面,所以不超过 1.04:离 FP64 不比 GPU 远(FP32 累加开关打开后那一版的读数,这一版里该专家对 GPU 是 0.105;1.04 是上限,不是确切值)。两边按能量合计各离 FP64 9.22e-4(TPU)和 7.66e-4(GPU),R 1.20;照抄 TPU 路由重算 FP64 的读数,对齐记录里没查到。
所以张量比较里先看零元素比例和路由槽位;路由翻了的专家,要按「两边选中同一批 token」重比,不能直接判算错。
会翻的不只是两种硬件:同一个 TPU 程序只改编译器的片上内存上限,这两个专家梯度就差 0.080(TPU 对 GPU 是 0.105)。我们一度以为只改执行方式路由不翻,其实这只在逐层隔离回放(每层输入取同一份,§6.2)里成立。
第三次迁移的图文模型(32K),从同一个状态各算一步(§6.3),越线的只有视觉塔的 q、k 投影:一种候选配置 10 个(R 1.21–1.53),另一种 5 个(R 1.22–1.38),两种配置越线的层不重合。视觉塔自己不选专家,可它的梯度要穿过后面的 MoE 层才传得回来;这一状态下各 MoE 层有 8%–26% 的 token 换了专家,传回来的已经不是同一份梯度。
照上面的办法定责:把 TPU 自己选的路由灌给 FP64 重算,这些张量的 R 降到 0.43–0.83(另一种配置 0.44–0.62),全部记「路由翻转」,两格都由不过改判为过。R 小于 1 别读成 TPU 更准:同一状态下 FP64 用的是 FP32 主权重,两边实际乘的是舍成 BF16 的那份,取值点本来就不同(对齐记录,2026-11-14)。
这种差 GPU 重跑的尺子看不见(宽度是 0)。规矩是:每一级的尺子都只来自参照一侧的重跑,被测自己的波动只作诊断 —— 让 TPU 给自己定门槛,等于自证。尺子看不见的差,超出的部分对 FP64 定责(§4.2)。
混元 3 当时在第 1 步这一级把 TPU 只改执行参数的重跑也并进尺子(并集,§9.5),后来撤掉,按只用 GPU 的尺子重判:第 1 步整步改判「不过 · 已解释」,多步那一级的结论不变。第二次迁移在多步那一级也并过一次,随后撤回。(正文的 0.105 是 TPU 对 GPU、并集那组运行当前配置的读数,前面的 0.102 是更早那次。)
方向全对、整体大了一倍:典型的「漏除了一个系数」,比如每卡每步 2 个微批,累加完忘了除以 2(本讲的配置正是每卡 2 个)。cos 对整体缩放完全看不见,靠范数比才抓得到。
这一节留下的问题:R 超线,根子都在某一次舍入上 —— 两边的硬件到底在哪儿舍入?
这一节只讲两个案子,都是第三次迁移碰上的:一个换了设备数,一个换了梯度累积。先铺一句底:一次矩阵乘先两两相乘、再把乘积加起来,乘是精确的,舍入落在加法上。
📌 第二次迁移的根因一览一共 30 行,每行「根因」一栏都标了它属于哪一类边界或语义;本课据此归成四堆:精度 22(16/32 位交界、矩阵乘精度档、长求和、超越函数与优化器里的实现精度、编译器省掉的舍入、FP32 里病态的记录写法、GPU 一侧在 BF16 里算的旋转位置编码、一处累加写法(第八节揭晓)、多路残差流梯度的舍入写法)、语义 6(设置、优化器公式、框架里一处 bug(扫描层共用缩放、累积时最大 logit 被求和)、辅助 loss 的加权与重标写法、统计量取法、算法边界)、两样都有 1(输出头单遍 BF16 是精度,整层重算重选路由是语义)、顺序 1(四路相加配对还是依次,对上它只为照 GPU)。
⚠️ 归类是本课做的,对齐记录里没有这四个数。
📌 位宽:FP32 1/8/23(IEEE 754 binary32);BF16 1/8/7;TF32 1/8/10(NVIDIA 张量核用的 19 位格式,按 32 位存放)。
⚠️ 本课推导:有效数字含隐含的那一位,BF16 是 8 位、FP32 是 24 位,8 × 8 位的乘积至多 16 位 ≤ 24 位,所以只要不溢出就精确。
只记一句,第七节要用:GPU 张量核每 16 个乘积一组,低位直接抹掉,绝对值只少不多,求和越长,朝零偏得越多。
组内相加后写回 FP32,也朝零;「16」「25」是在 B200 上拟合出来的,不是厂商规格:拿它重算三层路由打分,4096 × 192 个元素逐位对上,改成 8 个一组、24 位或就近舍入,命中率都掉到 1% 以下
| 量的是什么(朝零的相对偏差) | 短 | 中 | 长 |
|---|---|---|---|
| 合成正数输入,K = 256 / 4,096 / 65,536(输出写回 BF16) | 2.2e-5 | 7.0e-5 | 3.1e-4 |
| 只算截断模型(推断,没写回 BF16) | 约 3e-7 | 约 1.1e-5 | — |
| FP32 不走张量核 | ≤ 5e-8 | ||
短求和那一格比只算截断大得多(截断只给约 3e-7),差在哪没拆;正负两组输入在这一格也不对称,像噪声多过偏差。截断要到长求和才主导。
📌 实测的 B200 张量核模型(一个经验模型,不是厂商规格):每 16 个乘积连同累加器对齐到最大指数,低于 2^(emax−25) 的位向零截掉,写回 FP32 也向零舍入。「25 位」是拟合出来的窗口宽度,跟 FP32 的 24 位有效数字不是一回事。它在路由打分(K = 4096)上逐位复现了三层全部 4096 × 192 个元素;把参数改成 8 个一组、24 位或就近舍入,命中率都掉到 1% 以下。
📌 实测:合成负数输入 −9.5e-6 / −6.9e-5 / −3.4e-4,同样朝零;TF32 小约一个量级;FP32 不走张量核 ≤ 5e-8。K = 120,832 时合成输入的偏差反而降到 6.4e-5(推断:cuBLAS 对这个形状换了算法),所以图上没有画这一点。
⚠️ 推断:量这条曲线时输出写回的是 BF16。只算截断模型,K = 256 约 3e-7、K = 4096 约 1.1e-5;加上输出舍成 BF16,才回到实测的量级 —— 所以短求和那几点主要是输出舍入,长求和才是截断主导。
注:左图每个乘积右移几位是示意,不是实测数据。
注:动画终点的 3.5e-4 是同一张量核模型的模拟(单条点积,只有累加器截断,不含输出舍到 BF16、不含 cuBLAS 分块),跟右图实测 3.1e-4 口径不同;两者差多少、差在哪,没有单独拆过。另外动画纵轴带正负号(朝零偏画成负的),这张右图画的是偏了多少,取的绝对值。
收银台的比方:每一单抹零,单单都只少不多。张量核就是在每 16 个乘积这一单上抹零,而一次长求和有成千上万单。看上去是 FP32,末尾那几位其实从来没算过。(抹零只是一种偏法:小项相对整个和小到一定程度时,就近舍入也会把同号的小零头整个吞掉,见下面折叠。)
十进制的例子(示意,只留 4 位):累加值 1234 加 5.6 和 7.8,对齐到千位、只留 4 位,小数部分全扔:1234 + 5 + 7 = 1246,真值 1247.4。累加值涨到 12340 以后,同样加 5.6 和 7.8,个位也落到窗口外:12340 + 0 + 0,一下少了 13.4。
16 和 25 是从实测里拟合出来的(按这个模型重算,三层路由打分逐位对上),不是 NVIDIA 公开的规格。
朝零偏:结果的绝对值偏小,数值上是偏大(离零近了)。截断总是丢低位,正数、负数都是往零的方向少一点 —— 这是「抹零」,不是「往下取整」。
TPU 的矩阵单元 MXU 同样吃 BF16、乘积精确、在 FP32 里累加。同一份输入算路由打分,TPU 对 FP64 的相对误差是 4.8e-8,GPU 是 3.8e-6;长求和上 TPU 也会偏,但小得多。
MXU 累加是不是就近舍入,没有直接证据,是推断。「BF16 乘、FP32 累加」有公开出处:Google Cloud TPU 的 bfloat16 文档(同页还写明 TPU 上转 BF16 是就近舍入、平局取偶,BF16 不支持非正规数),以及 ST-MoE 的脚注(arXiv:2202.08906)。JAX 里要 FP32 累加的写法是 preferred_element_type=float32;矩阵乘精度档 HIGH、HIGHEST 是用 3 遍、6 遍 BF16 去模拟 FP32,不是 IEEE FP32。
设备=软件看到的一个计算单元:v5p 一颗芯片一个,v7x 一颗芯片两个;所以混元 3 的 v5p 8 颗、v7x 4 颗都是 8 个设备。混元 3 那次就查到是窗口化循环在 BF16 里累加部分积、也修好了(下面第二张图右下角:qkv R 1.235 → 1.000),可没查为什么有的投影中招有的不中招、设备少时为什么不拆。第三次迁移从生产代码原样起步,把它从头到尾查清了。
「曲线上认不出」的口径:别处的开关都补齐以后,三条曲线也只在噪声附近(主 loss 1.14 倍,单份运行);单算子回放在生产原样那一级就已经报警。
现象。第三次迁移从生产代码原样起步,8 个设备。曲线上认不出它;是单算子回放(§6.2)先报了警。反常:同样是投影,一批多舍,一批不多舍。第三次迁移的单算子回放(8 个设备)里,q、kv 的四个低秩投影、注意力的输出门、MLP 的 gate 和 up,TPU 离 FP64 都是 GPU 的 1.41 倍(TPU 2.35e-3、GPU 1.66e-3),约 √2,像多舍了一次(§4.2);同样是投影的注意力输出投影 o_proj 和 MLP 的 down,却是 1.00。
📌 实测:对齐记录里第三次迁移的单算子回放(8 个设备):往里投的那批投影 TPU 对 FP64 2.35e-03、GPU 1.66e-03,R 1.41(结果文件原值 1.41–1.42);o_proj、down 是 1.00。
📌 每个设备拿到哪一维的哪一片,取自 8 个设备编译产物里的权重片形状:往里投的一片是模型宽度的 1/8(2816 ÷ 8 = 352)乘整个输出维;o_proj 的一片是整个输入维乘模型宽度的 1/8。
📌 q_b、kv_b 的输入是 MLA 的低秩中间维(不是模型宽度),这一维也被 FSDP 切了,同样是切在求和维上。路由打分那次矩阵乘也切在求和维上,但生产本来就让它输出 FP32,不中招。路由专家走另一条路(权重收齐后在本卡做分组矩阵乘),不受影响。
📌 这不是张量并行那种「8 张卡各算一份再 all-reduce」:8 片权重轮流传到同一个设备上,由它依次乘完、加起来(下一张图)。
注:左右两边的激活、权重、输出画的是形状关系,不按比例。
规律:看 FSDP(把权重切开分到各设备、用时再收齐的数据并行)切的那一维是不是求和维。往里投,模型宽度是求和维,每片只给一份部分和,要加;往外投,模型宽度是输出维,每片给完整的几列,只拼。中招的全是前一种。
机制:编译器把一次矩阵乘拆成了几段。它可以先收齐 8 片权重、一次乘完;也可以边传边乘(collective matmul):权重片一片片传过来,到一片乘一段、加进累加器。后一种做法里,每段结果和累加器都是 BF16。一次 2816 宽的求和,GPU 舍 1 次,这里舍 6 次:
实测 R 1.41。部分和小,舍掉的也小;按 6 次各自独立粗算约 1.6 倍,实测更低的原因没查清。
为什么 8 个设备才出现:代码一行没改,只是设备数变了。同一份生产配置为不同设备数离线编译来数(下图右边):4 个设备一个这种循环都没有,8 个、16 个各二十个。切法没变,也不看矩阵大小,拆不拆是编译器按快慢定的(设备少为什么不拆是推断,见图下出处)。
📌 编译产物显示(第三次迁移,8 个设备,运行库 0.0.46):q 低秩下投影的循环体里,8 片权重沿两个方向的环传过来,排成 2 轮;每轮两次 704(= 2 × 352)宽的矩阵乘,输出是 BF16;和 BF16 累加器在一颗融合里转成 FP32 相加,再舍回 BF16。v7x 上这一步直接在 BF16 里加,舍入次数相同。
📌 实验确认:同一份生产配置在 CPU 上为不同拓扑离线编译训练步。v5p 4 个设备没有窗口化循环,权重整块收齐;8 个、16 个设备各 64 个窗口化循环,其中带部分和相加、累加器 BF16 的 20 个(正好是上一张图里中招的那几种投影的前向和重算),其余是按输出维写各自的列,或权重梯度一侧(本来就是 FP32)。打开投影 FP32 累加后,这 20 个全部变成 FP32。
📌 大小不是门槛:8 个设备上,连最小的路由打分矩阵也拆了;4 个设备上,连最大的 gate、up 也整块收。拆不拆看的是切法和设备数。为什么设备少不拆是推断:编译器按快慢选,设备少时环上首尾那几次传递的固定开销占比大,拆了省不下时间。更大的规模没有编过,按「会拆」准备。
📌 混元 3(v5p 8 个设备)是同一个机制:qkv 投影 R 1.235 → 1.000,配置里有 41 个这样的循环。
⚠️ 部分和小,舍掉的也小;按 6 次各自独立的舍入粗算,R 约 1.6(四份部分和各约最终值方差的 1/4、累加器约 1/2、出口 1),实测 1.41 更低,原因没查清。
修法:让这批矩阵乘声明 FP32 输出。累加器跟着变成 FP32,循环结束只舍一次:单算子 R 回到 1.00,步时 +0.4%。另一条硬证据:编译产物里那 20 个循环的累加器全部变成 FP32。
| 看哪一级 | 打开前 | 打开后 |
|---|---|---|
| 单算子:那批投影的 R | 1.41 | 1.00 |
| 整网第 1 步:超出 GPU 两倍噪声的梯度张量 | 91 个 | 63 个 |
| 1000 步:主 loss / 梯度范数 / 参数范数的 r | 1.14 / 0.93 / 0.97 | 0.96 / 0.98 / 1.00 |
| 步时 | +0.4% | |
曲线别读过头:打开前主 loss 1.14 只是待定,打开后三项都 ≤ 1,可两级都只有一份运行,逐级加开关时主 loss、MTP、梯度范数本来就在 0.9–1.2 之间来回(参数范数更大,0.9–1.9),分不开。硬证据是单算子 R 1.41→1.00,和编译产物里 20 个循环的累加器全变 FP32。
第 1 步剩下的 63 个超 2N 的张量里,离 FP64 比 GPU 远(R > 1.2)的 8 个,还没定责的 3 个(打开前 10 个、6 个);再按路由翻转定责,这 3 个都归到路由翻转,剩 0(打开前剩 2)。
混元 3 用的是同一个开关:单层那一处修好了(qkv 投影 R 1.235 → 1.000),可对 1000 步的参数范数漂移几乎没用:参数范数那一项的 r(§3.3 的例子,对定案前的基线 ④ 精确轨迹)开关前 3.52、开关后 3.45。第三次迁移里曲线跟着动了,可两级都只有一份运行,不按小数点排先后。
它不是 MLA 特有的:稠密 MLP、共享专家的 gate 和 up 一样中招,凡是 FSDP 切的那一维正好是求和维的投影都会。MLA 只是让中招的矩阵变多:每层注意力 q、kv 各有两个往里投的矩阵(第二个的输入是低秩中间维,也被切);标准的多头注意力只有 q、k、v 三个,还常融合成一个。
精度验证要在生产的设备数上编。在 4 个设备的小切片上验,这件事完全看不到;8 个、16 个设备都拆,更大的规模没编过,按「会拆」准备。小切片上验也行,先离线编译一份生产设备数的训练步,数一数边传边乘的循环(编译产物里叫窗口化循环)和它们的累加器类型。
裁判工具要跟生产编得一样。单算子回放把多 token 预测层的几个投影也编成了边传边乘,R 同样 1.41;可训练步的编译产物里没有给多 token 预测层的那组边传边乘循环,推断这几个矩阵乘在训练里是先收齐权重再整段乘的,回放这几格不代表生产。更早一版回放没把输入按 batch 切,投影 R 到了 2.12,也是工具和生产切法不一样。用回放之前,先拿编译产物对一遍:工具里的程序和训练步里的,是不是同一种写法。
落到代码上,是给那处矩阵乘指定 FP32 累加(JAX 里给 jax.lax.dot 写 preferred_element_type=jnp.float32,出口再转回 BF16),不是加一个编译参数。别的框架要找的是「BF16 矩阵乘的部分和用什么精度相加」这一项;例如 PyTorch 在 GPU 上有 torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction,设成 False 就关掉(PyTorch 的 CUDA 语义文档)。反向那一侧,第三次迁移的编译产物里不用改:权重梯度一侧的累加器本来就是 FP32;求输入梯度时,o_proj、down、q_b、kv_b 是权重先收齐再在本卡乘;gate、up 和路由打分只是按列写各自的一段;都没有部分和相加。
另一条路是用编译参数把边传边乘整个关掉。混元 3 试过:那样连 GPU 本来就有的一次舍入也省掉了(投影输出不舍就直接进了残差加),MLP 前归一化的 R 到了 1.64,反而对不齐 —— 多舍少舍都不行,所以用开关不用参数。
MaxText(混元 3 公开分支):开关 dense_fp32_accumulation MaxText(混元 3 公开分支):矩阵乘里 FP32 累加、只舍一次
现象。第三次迁移换到 32K 序列,1000 步主 loss 不过:第 2–1000 步带符号均值 −4.4e-5,是 GPU 噪声尺子(8 份两两 28 对)5.6e-6 的 7.8 倍;偏得最狠的第 51–300 步,尺子按这段重算是 53.6 倍;第 301–1000 步平均 1.5 倍。
反常。RMSNorm 有个开关,照 GPU 先把 FP32 的 scale 舍成 BF16 再乘。4K 上开不开它,300 步除墙钟外 13800 个逐步量逐位相同,结论是「这个开关没用」。可到 32K 上逐个加开关二分(下图右栏),只补这一处就降到 0.54 倍(120 步短跑,尺子按这段重算),补别的都还在 28 倍左右。
📌 实测:对齐记录第三次迁移,32K(16 个设备,上下文并行 8 × FSDP 2)。偏差从第 20 步起系统性偏低,第 100 步 TPU 对第一份 GPU −2.69e-4(GPU 另 7 份 −1.64e-5 到 +1.13e-5),第 500 步前后翻正;MTP 第 51–300 步 −5.77e-4,是它的尺子的 23 倍。离线编译扫描:32K 程序里 RMSNorm 乘之前那次舍入 8 个 norm 全部被删、保住 0 个;4K 程序 8 处全保住。对照:4K 只把梯度累积改成 1(FSDP 8 不变)8 处全删;32K 只改成 2(上下文并行 8 × FSDP 2 不变)8 处全保住;两份程序里 8 个 scale 都整份复制、不切分;4K 那颗转换内核的芯片指令里有 BF16 打包指令,32K 那颗没有。
📌 四处 = 主输出头反向、路由权重前移、RMSNorm scale、sigmoid 输出的舍入。各行的带符号均值:不加(第 2 级,1000 步运行) −1.98e-4;投影 FP32 累加 −2.00e-4;精确超越函数 −2.00e-4;精确 Adam + 正交化迭代的舍入 −1.97e-4;四处一起(见底注) −7.27e-6;只加其余三处之一(三条运行) −2.03e-4;只加 RMSNorm scale −3.87e-6。尺子 N:上组 3.70e-6,下组 7.19e-6。
📌 二分取的是对齐爬梯第二级之上加开关的诊断运行;第 51–120 步那组是 120 步的短跑,四条运行各只加一处,没有不加开关的对照:N = GPU 8 份两两 28 对、同一窗口主 loss 逐步相对差带符号均值的绝对值最大,被测和 GPU 都对第一份 GPU;两组窗口不同,N 不同,只在组内比(从原始运行重算)。scale 偏离每 50 步读一次(16 个 norm scale 的中位数);舍成 BF16 后不等于 1.0 的元素比例第 200 步中位数 2.9%、最多 30%,第 250 步 7% / 55%。
📌 4K 负对照:只开 RMSNorm scale 舍入,300 步除墙钟外 13800 个逐步量跟全关逐位相同,第 1 步梯度文件逐字节相同 —— 4K 程序里这次舍入本来就在。修法步时 32K 1.804 → 1.802 s(各一份)。
⚠️ 推断:凡是梯度累积为 1 的配置这次舍入都会被删(只编过这四份);转换被提出循环是循环不变量外提,也是推断;虚线是按每步 6.4e-6 外推。
揭晓。代码写的是「转 BF16 再转回」。离线编译一扫:4K 程序里这次舍入在,32K 程序里 8 个 norm 的这次舍入全被编译器删了。我们一开始推断是切法:4K 是 FSDP 8,32K 是上下文并行 8 × FSDP 2。
再揭一层:不是切法,是有没有梯度累积循环。两份程序里这 8 个 scale 都整份复制、不切分。4K 开着梯度累积(每步分 2 份先后算、梯度加起来,程序里是一个循环):编译器把转 BF16 那一下提到循环外面,BF16 值作为循环状态存进内存,再由另一颗内核转回 FP32,芯片指令里有 BF16 打包指令,舍入真发生了。32K 梯度累积是 1,没有这个循环,这一对转换落在同一颗小融合里,打包指令 0 条,舍入被删。删它的是 XLA 一个默认开着的选项 excess precision(下文叫「省舍入」):融合起来的一块里,中间那几次舍入可以省掉。
对照把变量钉住:一次只改一样,离线编四份,数 8 个 norm 的这次舍入还在不在:
| 离线编译 | 梯度累积 2(程序里有循环) | 梯度累积 1(没有循环) |
|---|---|---|
| 4K(FSDP 8) | 原样:8 处都在 | 只改梯度累积:8 处全删 |
| 32K(上下文并行 8 × FSDP 2) | 只改梯度累积:8 处全保住 | 原样:8 处全删 |
切法不动,只看有没有循环。当初 4K 和 32K 一比,切法和梯度累积是一起变的。(推断:凡是梯度累积为 1 的配置,这次舍入都会被删,跟切法无关;我们只编过这四份。)
4K 上「没用」,是因为那里舍入本来就在 —— 换了梯度累积,之前的验证就不作数。第 1 步看不见:scale 初值 1.0 正好在 BF16 格点上,两边相同;之后 FP32 原值每步只偏开一点,攒到半格才跳格:GPU 那份 BF16 头 150 多步一直是 1.0,这段时间里两边的差一步步长大(这个盲区见 §6 折叠)。
FP32 原值每步偏开约 6.4e-6;BF16 在 1.0 附近一格 3.9e-3(1 以下),攒到半格才跳;第 200 步才有元素跳格(16 个 scale 中位数 2.9%)。
修法。写成强制舍入(lax.reduce_precision),编译器删不掉;32K 上步时 1.804 → 1.802 s(各一份)。
📌 实测(混元 3 · v5p,只加关掉 excess precision 这一个编译参数):单层回放里每个张量对 GPU 的 rel_L2 都变大,约大 10%–60%,例如 qkv 输出 2.36e-3 → 3.49e-3;跑 1000 步,第 301–1000 步 loss 偏移 -1.27e-4 → -6e-5,小了一半;参数范数的漂移一点没少。
📌 实测:MoE 层 MLP 前的 RMSNorm,代码里写的是舍两次,开着时 XLA 把中间那次省掉,跟 GPU(FP32 算完舍一次的融合 kernel)逐位相同 99.9987%;关掉以后只剩 74.1%。这一处恰好是「开着更像 GPU」。
注:四个算子、融合切成两块、显式舍写在第一个算子出口,都是示意;真实的融合怎么切由编译器决定。GPU 那一行画的是「每个算子单独一个 kernel」的常见情形。
excess precision(下文简称「省舍入」)是 XLA 的一个默认开着的选项:允许结果比程序写的更精确。最常见的表现是融合块里跳过中间那几次「舍到 BF16」,只在出口舍一次。
它开着时也在替你省舍入。第二次迁移的 TPU 自比里,v5p 上词嵌入梯度「飞出去」两次(§4.2 末尾):一次是把 FSDP 改成纯数据并行,一次就是关掉 excess precision(R 26.1)。两次都出在词嵌入梯度上。为什么偏偏是它,第八节把这一处整个查一遍。
| 混元 3 关掉 excess precision | 结果 | 读法 |
|---|---|---|
| 单层回放 | 每个张量对 GPU 反而都更远 | 省掉舍入的结果本来更接近 GPU |
| 1000 步 loss 偏移 | 小了一半 | loss 对执行方式本来就敏感(只改片上内存上限也挪 6e-5),分不出是不是效果 |
| 1000 步参数范数漂移 | 一点没少 | 判据看它:没用 |
(v7x 上关省舍入后,变远的地方跟 v5p 不一样,§10.1。)
为什么 TPU 上会有这种「更精确」:一份公开的事故复盘(Anthropic,2025 年 9 月)提到 TPU 的向量单元按 FP32 原生计算,编译器可以把融合块里的一些运算按 FP32 算。
对齐记录数过编译后的后端指令(静态条数,运行库 0.0.52):v5p 整步 1750 颗 kernel 里没有一条 BF16 算术指令;v7x 的向量单元有 BF16 算术,整步有 40 来颗带它,条数最多的几颗是加 0 拼接、取最大(结果精确),以及 BF16 的乘和加。静态条数看不出它们会不会多舍一次。
想在 TPU 上把 FP32 权重舍成 BF16 再用,写成「转 BF16、再转回 FP32」两步,excess precision 开着时,编译器会把这一对转换直接消掉,权重根本没舍。
这样做出的「舍过的参照」实际用的还是 FP32 主权重;第二次迁移里拿「转 BF16 再转回、看变没变」判权重离没离格点,在 TPU 上几乎全判成没离,那组读数作废。要舍就用 JAX 的 lax.reduce_precision(BF16 对应 exponent_bits=8, mantissa_bits=7)才对 —— 它不会被优化掉;输出类型仍是 FP32,只是数值已经舍到 BF16 的格点上。自查办法:把编译后的程序转储出来,看那处还有没有成对的 convert —— 可第二次迁移的例子说明,convert 都还在,后端照样可以只省一半,所以更稳的是把选项关掉重跑一次对比,或者直接在那一处写 reduce_precision。
第二次迁移里,同一件事成了一处真正的偏差。GPU 在一处中间值上每次都存成 BF16,TPU 的代码也写了「转 BF16」;可把紧挨着的一处四路加权和照 GPU 的顺序改了(从配对相加改成依次相加,§5.5)以后,这次舍入在 TPU 上丢了一半。这是在一个最小复现里看到的:编译后的程序里「转过去再转回来」都还在,可后端生成指令时,算均方那一步用的是没舍的 FP32,归一化输出那一步用的是舍过的值,两步不再用同一个数:
📌 实测(第二次迁移):五次 TPU 运行对 GPU 8 份均值 +3.7e-6 到 +8.6e-6,GPU 两两 28 对的带符号均值最大 3.8e-6;强制舍入后判定 r 2.12 → 0.76(对 GPU 基线,带符号均值),对 GPU 均值约 +3.5e-6(实测)。TPU 开、关 base2 各 4 份共八份,主 loss 全部比 GPU 偏高、平均约 4.3e-6(第 1 步还没有);同口径(每份 GPU 对其余各份)GPU 只在 ±2.6e-6 以内,灰段是两两最大差,口径更宽。
📌 编译产物:优化后的 HLO 里「转 BF16 再转回」都还在,差别在后端 —— 算均方那颗 kernel 用的是没舍的 FP32,归一化输出那颗舍了(在一个最小复现里数过后端指令;长跑偏高归到这一处是推断)。五次里有三次只改执行参数(注意力分块、专家并行、MoE 实现),同号偏高,说明不是轨迹偶然分开。
1000 步下来五次 TPU 运行的 loss 都偏高(+3.7e-6 到 +8.6e-6),其中 4 次超出 GPU 自己的 ±3.8e-6。在那两处显式写一次「舍到 BF16」,回到 +3.5e-6,判定 r 2.12 → 0.76,回到线以内。
修了就回来,这是唯一的直接证据。整网 HLO 看不出这一层,后端指令只在最小复现里数过;第 1 步定责时还发现,单这一处解释不了:要连同第 0 层分支输入、层内的流三处一起,才对上第 0、1 层的读数(第 5 层仍对不上)。
上一代配置下 TPU 主 loss 有一截共同偏高(8 份平均约 4.3e-6,GPU 每份对其余各份在 ±2.6e-6 以内),几乎全在第 550 步以后才显出来。主因后来定到多路残差流梯度的舍法;可现行对齐配置下后段跟不修分不开,主 loss 0.98 倍只是刚好过线,剩下那截没定责(§9.1)。
MaxText(混元 4 公开分支):多路残差强制舍 BF16 的开关(ihc_force_bf16_rounding) MaxText(混元 4 公开分支):用 reduce_precision 舍,编译器不会删
省舍入还有一个副作用:代码里写「转 BF16、再转回 FP32」想舍一次,这一对落在同一颗融合里,会被整个删掉,等于没舍。要真舍,写 lax.reduce_precision(强制舍入),编译器不会删。
所以生产代码里这一类「转 BF16 再转回」,别交给编译器,显式选一种:要跟 GPU 一致(从 GPU 迁移、接着 GPU 的检查点续训、拿 GPU 当参照排查),就用强制舍入(lax.reduce_precision)钉死,多数地方步时几乎不变(多 token 预测的 logits 那一处 +8.1%,单份);要精度,就删掉往返、明确用 FP32。开强制舍入为的是一致,不是更准:怕的是它随配置(比如梯度累积)和编译器版本悄悄变。
| 想要的效果 | 写法 | 编译器会不会改 |
|---|---|---|
| 舍成 BF16,再继续用 FP32 算(照 GPU 的舍入) | jax.lax.reduce_precision(x, exponent_bits=8, mantissa_bits=7) | 不会删 |
同上,写成 x.astype(bf16).astype(f32) | 不要这样写 | 往返落在同一颗融合里就会被删 |
| 真的用 BF16 存或传(省显存、带宽) | 只写 x.astype(bf16),后面不转回 | 不会删:下游拿到的类型就是 BF16 |
| 要 FP32 | 不写任何往返 | — |
第三次迁移上会被删的六处,最后一处 2026-11-14 才查出(RMSNorm scale 只在 32K 被删;正交化迭代一部分删、一部分保住):多路残差的分支输入、流更新、收拢处(不补时第 1 步那几个小参数 R 超 1.2,参数范数 1.65 倍);RMSNorm 的 scale(就是上面这处);一处 FP32 sigmoid 的输出(没有可测影响);Muon 正交化每步迭代的结果(参数范数第 300 步后一路往下漂,补上不漂);多 token 预测输出头的 logits(交叉熵吃的是 FP32 logits);多 token 预测层的输入(下一个折叠)。查法都是 §9.1 那一招:离线编译,扫「FP32 → BF16 → FP32 落在同一颗融合里」的位置。
多 token 预测(MTP)层的输入,是主干末层归一化的输出:代码先把它存成 BF16,进 MTP 自己的归一化再转回 FP32,又是一对「转 BF16 再转回」。GPU 两次都舍;TPU 开着省舍入,把中间那次省了。
少舍一次本来只差半格、有正有负,可这里紧跟一个乘法:输入已经归一化过,MTP 的归一化再乘一个约 0.997 的系数,离 1 很近。输入在 BF16 格点上、乘完再舍回 BF16,结果常被吸回原来那个格点。两次都舍的一边(GPU)因此整体偏大约 4.4e-4;只舍其中一次,都没有这个偏差(FP64 仿真逐项核过)。这一截占 MTP 残差流的大头,经过 MTP 的末层归一化和输出头,成了整个 MTP 层梯度的同一个比例差:19 个张量两边差 1.8e-3 到 4.9e-3,全部同号,GPU 6 份之间只差约 1e-4。
只在 MTP 输入上补一个强制舍入:同一状态算一步,MTP loss 跟 GPU 的差 3.9e-5 → 2.6e-6,主 loss 逐位不变;MTP 层 18 个张量(前面说的 19 个去掉路由 gate,判法不计它)里 15 个的比例差回到 ±4e-4 以内。按事先定的判法这一格仍记「不过」:q 路三个还差 1.1e-3 到 1.4e-3,原来被整体那个比例差盖住了。原因还在查:在那里补一个强制舍入没用,改变融合方式才回来,对齐记录推断起作用的是融合而不是舍入(推断,未核)。
1000 步上:只补这一处,第一份反而偏到 4.50 倍;单份分不清是开关还是噪声,又补了两份只改执行方式的副本,3 份对 3 份范围重叠(不补 3.02/4.28/4.06 倍,补上 4.50/3.31/5.16 倍),记「对 MTP 没有可分辨的作用」。同一状态一步修好了一处真实的写法差,1000 步那份偏差纹丝不动:偏差另有来源(§5.5 折叠)。
📌 实测:官方训练容器设了 TORCH_ALLOW_TF32_CUBLAS_OVERRIDE=1,allow_tf32 两个开关默认 True。只关 torch 开关,torch 自己的 FP32 矩阵乘变成 IEEE FP32,Transformer Engine 的 FP32 GEMM 仍是 2.94e-4;设 NVIDIA_TF32_OVERRIDE=0 后两者都是 1.15e-6。
📌 TPU 没有 TF32;FP32 操作数按编译时的矩阵乘精度档处理,默认档是先舍成 BF16 单遍乘、FP32 累加。
TF32 是 NVIDIA 张量核上的 19 位格式:FP32 的矩阵乘一进张量核,就悄悄按 10 位尾数算。训练容器默认开着它,所以名义上的「FP32」常常不是 FP32。 要拿来当精确参照的程序,每次启动都实测一遍,把实测值记进运行的元数据。
BF16 训练里,TF32 只碰输入本来是 FP32 的矩阵乘(本例第 1 步只有路由反向那十来次),所以「BF16 设置下关不关 TF32 没影响」和「精确参照必须真关 TF32」两句并不打架。
三层开关,各管各的。PyTorch 的开关只管 PyTorch 自己的 cuBLAS 句柄;Transformer Engine 绕开 PyTorch 自己调 cuBLASLt,对纯 FP32 的矩阵乘一律请求 TF32 快速模式,不看 PyTorch 的开关;NVIDIA_TF32_OVERRIDE=0 是 cuBLAS 库自己读的,压在所有调用者之上,PyTorch 不读它,所以这时 PyTorch 的开关读回来还是「开」。读回值是请求,不是库实际做了什么。训练里真正以 FP32 输入的矩阵乘只有路由的反向,恰好走 Transformer Engine。
| 设置 | PyTorch 矩阵乘 | Transformer Engine 矩阵乘 |
|---|---|---|
| 默认(训练容器打开 TF32) | 2.94e-4 | 2.94e-4 |
| 只关 PyTorch 的开关 | 1.15e-6 | 2.94e-4 |
设 NVIDIA_TF32_OVERRIDE=0(PyTorch 读回仍是开) | 1.15e-6 | 1.15e-6 |
PyTorch 里矩阵乘的 TF32 开关 1.7–1.11 版默认开、1.12 起默认关,cuDNN 那个开关一直默认开;另有一个环境变量 NVIDIA_TF32_OVERRIDE=0,压过所有框架和 NVIDIA 库的设置、全局关掉 TF32(NVIDIA cuBLAS 文档)—— 所以它连 Transformer Engine 那条路也能关掉(TE 对纯 FP32 矩阵乘在源码里写死用 TF32,不看 torch 开关)。较新的 PyTorch 又加了 fp32_precision 这一套新开关,旧的 allow_tf32 将弃用。
📌 出处:第 2、4、5 行是第二次迁移(一个更新的、带稀疏注意力的 MoE 模型)读代码查出的;第 3 行是混元 3(第 5 行那处混元 3 代码里也写了两次,v5p 编译后中间那次被省掉、前向跟 GPU 逐位相同)。第 1 行是混元 3 时期就有的开关,第二次迁移才需要打开:TPU 把路由打分设成最高精度以后才出现这个差;混元 3 有同一个开关,但那时默认精度本来就先舍 BF16,开不开逐位相同。第 4 行是参照一侧自己写的不融合实现,生产的融合内核和 TPU 内核都留 FP32,所以改的是 GPU。
📌 第 4 行只改这一处,第 1 步 loss +8.1e-7、梯度范数 −3.0e-5,GPU 同设置 8 份重跑第 1 步的相对极差是 1.7e-6 / 9.3e-5,量级相当,单看第 1 步分不清 —— 它是按写法定的 bug,不是按大小抓到的。
📌 乘法那一格要看编译后的样子:一处 HIGHEST 写的多路残差四路加权和,编译器已改写成 FP32 逐元素乘加、不上矩阵单元,跟 GPU 只差加法顺序(TPU 配对相加、GPU 依次相加),归顺序那一格;改成依次相加后第 1 步该处梯度对 CPU FP64 R > 1.2 的张量 11 → 8,后一代配置没复现。
注:线高只分 16 位、32 位两档,HIGHEST 这类「多遍 BF16 拼近似 FP32」也画在 32 位,所以乘法那一格要比字、不只比高度;HIGHEST 是不是多遍 BF16,看编译后它还是不是矩阵乘;「舍在哪」一列不画线,红色刻痕一道 = 舍一次到 16 位,只在它本身是根子时画(第 5 行:TPU 默认归一化结果、缩放各舍一次,GPU 算完只舍一次)。第 3 行累加那一格:边传边乘时每段矩阵乘的输出和累加器都是 BF16,一次求和舍 6 次(编译产物显示,§5.3)。
第二次迁移把数值上的对不齐一处处查下来,几乎每一处都是一个精度换挡的地方:一个值从 16 位进 32 位、从 32 位落回 16 位,或者 GPU 上悄悄打开的 TF32;剩下一类是 32 位对 32 位,同样是 FP32 的 exp、log,两边的实现精度差几十倍(§5.5)。连「操作数转成 FP32」都不等于 FP32 矩阵乘:TPU 默认对 FP32 操作数也只算一遍 BF16(图第 2 行)。
还有一种是该留 32 位的中间值存成了 16 位:这是写错了,不是噪声,哪怕它小到 GPU 重跑都盖得住。参照的写法跟生产对不上时,以生产为准,改参照 —— 第 4 行改的就是 GPU。
MaxText(混元 4 公开分支):多路残差四路相加的两种写法(开关 ihc_stream_sum_unrolled;注释说 HIGHEST 是多遍 BF16,那是旧说法,以编译产物为准) MaxText(混元 4 公开分支):输出头单独设精度(logits_matmul_precision)
要更接近 FP32,得给那一处单独设 HIGHEST(多遍 BF16 拼出来的近似)。可一处写着 HIGHEST,不等于它真上了矩阵单元:编译器可能把小的加权和改写成 FP32 逐元素乘加,那时它跟 GPU 只差加法顺序。是不是多遍 BF16,看编译后它还是不是矩阵乘。
第三次迁移把图第 2 行那一格看清了:默认档舍的是离开格点的 FP32 主权重。第 1 步主权重还在格点上,看不见;第 2 步起 logits 误差是真 FP32 的几千倍(单算子回放、模拟离格,本课复算)。矩阵乘精度档有三档,前 300 步主 loss 的 r:默认(1 遍 BF16)7.32、high(3 遍)1.03、highest(6 遍)1.31;highest 贵一倍却不更好,因为差只是离格那一截,补回来就够(单份运行)。第 1 步超 2N 的张量 91 个,开前开后个数一个不变 —— 梯度其实变了,可这点变化比各张量离 FP64 的误差小两个量级,逐张量看不出来。推荐 high,步时 +5.7%。
生产的输出头写 logits = x · W,两边升成 FP32 再乘,精度档没单独设。x 是末层归一化的输出,本来就是 BF16,舍了不变;W 是 FP32 主权重。第 0 步 W 还在 BF16 的格点上,默认档舍了也不变,所以第 1 步三档前向一样;训练一步以后主权重离开格点,默认档把它舍回去,logits 的误差一下子成了真 FP32 的三千到五千倍(模拟离格 1 到 10 步)。第 1 步看不见,跟 §5.4 的 RMSNorm scale 是同一个盲区。前 300 步主 loss 的 r 是 7.32,判不过。
📌 实测:对齐记录第三次迁移,单独回放输出头这一次矩阵乘,输入取 GPU 第 1 步,对 CPU FP64。离格 1 步、10 步是模拟:在初始权重上加 1 步、10 步 Adam 量级的离格偏移(每元素 ±1e-5 × 步数),不是真训练后的权重。对 x 的梯度跟前向一样大(默认档离格 1.9e-03),乘的是同一个 W;对 W 的梯度只有一处小误差(默认档把 FP32 的 logits 梯度舍成 BF16,8.3e-06)。
📌 「约 5000 倍」:默认档离格 10 步 1.9e-03 ÷ 主机真 FP32 离格 3.7e-07 ≈ 5100(本课复算,对齐记录同口径)。
📌 曲线(4K,单份运行):1000 步主 loss 默认 1.82(待定)、high 0.99、highest 1.02;32K 上 high 0.94、highest 0.99。前 300 步 high 1.03、highest 1.31 只差在单份运行的噪声里,不按小数点排先后。步时 1.640 / 1.734 / 1.842 s。
📌 第 1 步的梯度其实变了:默认档对 highest,116 个张量相对差中位数 6.4e-04,比各张量对 FP64 的误差(约 1e-2)小两个量级,所以超 2N 的个数不动。
注:左格的格点间距和权重离格多远是示意。
改成 high(拆成两段 BF16,算 3 遍)就够了:前 300 步 1.03,1000 步 4K、32K 的主 loss 都过,步时 +5.7%;highest(6 遍)曲线一样好,步时 +12.3%。词表有 120,832 个词,多算一遍就贵一截。带走一句:BF16 检查点起训时,权重侧的精度开关第 1 步测不出来,主权重得先走出格点;判这类开关要看曲线,或者拿训练几步后的权重单独回放。
| 边界 | 例子 | 怎么对上 |
|---|---|---|
| 矩阵乘 FP32 累加,结果先存 BF16 再给下一个算子 | 注意力打分 q·k,参照自己写的不融合实现(图第 4 行) | 让它留 FP32,照生产的融合内核 |
| 跨分片的部分和先舍 BF16 再相加 | FSDP 切开求和维的投影(§5.3) | 部分和留 FP32 |
| 归一化舍一次还是两次 | RMSNorm(图第 5 行) | FP32 里算完只舍一次 |
| 逐元素函数在 FP32 里算再舍,还是直接在 BF16 上算 | 门控激活 silu·up:GPU 舍两次、TPU 默认舍一次,只有 73.7% 的元素逐位;注意力输出门的 sigmoid 两边也一个 FP32、一个 BF16,TPU 不比 GPU 远(R 0.90–1.00),定责、不处理 | 按 GPU 的写法逐个算子舍 |
| 路由打分要 FP32 | top-k 的集合跟 FP64 不同 | 两边路由打分都设 FP32 |
| FP32 操作数在 TPU 默认精度下只算一遍 BF16 | 名义 FP32 的输出头(图第 2 行);HIGHEST 是多遍 BF16 近似,但编译器可能把小的加权和改写成逐元素 FP32 | 给那一处单独设精度;先看编译后它还是不是矩阵乘 |
| 乘的是 FP32 主权重还是 BF16 权重 | 路由打分的权重(图第 1 行),另一处投影也是 | 按参照用哪份就用哪份 |
| GPU 上 TF32 悄悄打开 | 名义 FP32 的参照比 BF16 还偏(§5.5) | 启动时对 FP64 实测 |
| 梯度以 BF16 落地 | norm 权重、输出层、词嵌入(§9.5) | 梯度直接累加进 FP32 |
| 优化器内部的精度 | Muon 正交化的迭代 GPU 在 BF16 里算、TPU 默认 FP32(更准) | 对齐时照 GPU 舍,生产不必;写法差(§2.3 折叠)要对 |
| Python 常数被转成 BF16 | 注意力指数用 2 为底时,常数 log₂e 跟着 BF16 的 q 舍成 1.4453125,logits 整体乘 1.0018(第二次迁移真实宽度第 1 步);混元 3 的注意力缩放常数也舍成了 0.08837890625 | 常数在 FP32 里乘,或不用 2 为底;第二次迁移的对齐配置因此全部关掉 base2 |
| FP32 超越函数的实现精度(32 位对 32 位) | TPU 默认的 exp、log、sigmoid、silu 差几十格(§5.5) | 换高精度写法;先量 GPU 实际怎么算 |
| FP32 里的病态标量 | 小数是两个大数相减(§5.5 折叠) | 病态只放大;被放大的那一格是谁的,再查 |
另有两类不在这张表里:长求和的累加方式(张量核的抹零,§5.2),也属精度;语义差 —— 同一个量两边定义不同(§2.3 折叠的四处)、测量工具自己错了(§6.2),排查时另列。
两边代码里搜这些词,每一处都是一个可能的边界:astype、.to(、.float()、.bfloat16()、preferred_element_type、precision=、allow_tf32、NVIDIA_TF32_OVERRIDE、autocast、reduce_precision、dtype=。然后沿前向、反向,每个算子两边各写一行(输入 / 乘法精度 / 累加 / 输出存储 / 舍在哪)。
验的时候:单个算子对 FP64 算 R(§4.2);第 1 步逐张量梯度对 GPU 重跑的噪声,超出的对 FP64 定责。
第二次迁移第 1 步,195 个张量里 TPU 对 GPU 的差 ÷ GPU 三份两两的最大差,中位数 2.67,超过 2 倍的 139 个,从输出层到第 0 层普遍偏大。这不像一个模块写错,像好几处舍入位置一起跟 GPU 不同:打开三个照 GPU 写法舍入的开关(FP32 累加部分和、RMSNorm 只舍一次、路由权重先舍 BF16),中位数 2.67 → 1.65,超 2 倍的 139 → 52。第四个开关(门控激活逐算子舍)让统计略变差(1.72、62 个),照样打开 —— 开不开看 GPU 实际怎么写,不看统计好不好看。
上一代配置(关 base2、多路残差一带还没照 GPU 写法舍)第 1 步,GPU 参照补到六份(15 对)后:205 个梯度里 169 个超出 GPU 的波动,拿去对 CPU 上的 FP64 整网重算定责:167 个离 FP64 不超过 GPU 的 1.2 倍,2 个比 GPU 远(1 个是多路残差混合的小参数,超出波动 1.05 倍、判待定;1 个是 MTP 的归一化权重,已接受);另 10 个 GPU 各份逐位相同、26 个在波动内。只有三份时是 177 个超出、5 个小参数没定责:份数补够,尺子量准了,大半「没定责」自己就消失了。对齐配置 2026-11-11 换成新口径以后重判:163 个超出,没定责的只剩第 3 层 FFN 前一个多路残差小参数(超出波动 1.14 倍,R 1.43),原来那个进了噪声。定责一律对 FP64,不对 TPU 自己跑的 FP32 参照(裁判不能是选手,§4.2)。
默认精度下它只算一遍 BF16;设成 HIGHEST 是多遍 BF16 拼出来的近似。但写着 HIGHEST 不算数,要看编译后的样子:编译器若把它改写成逐元素 FP32 乘加,差的就只剩加法顺序,归到「顺序」那一格。
📌 实测(第二次迁移,第 1 步,稀疏注意力里的一项辅助蒸馏损失):同一行 TPU 图内对同一输入的 FP64 重算 −1.2e-3(对 GPU、全部运行合起来 −9.2e-4);TPU 图内 lse 对 FP64 平均 −0.95 格(只有 8.6% 的行偏正),CPU 上 PyTorch 的 f32 只差 −0.004 格(CPU 上的 JAX f32 算同一行 KD 是 +2.9e-4,不是同一种实现);输入与梯度见右格。lse 与同一行 KD 的前后两端设置不同;300 步 r 那一对同一代还开了一个优化器开关,没有拆开。
⚠️ 本课推导:比方按 lse 1 单位 ↔ 1000 吨换算,船 7100 吨、船长 110 公斤、一格 0.47 公斤,比例跟实测的「一格 = KL 的 4.3e-3」一致。⚠️ 照学生那一侧算,lse 低 0.95 格该让 KL 低约 4.1e-3,实测是 1.2e-3:两者只对得上量级,一手材料没有逐项对上(推断:教师那一侧的 lse 也偏、抵掉一部分,未核实)。
注:秤读到 0.47 公斤,对 7100 吨约是七位有效数字,正是 f32 的水平(约 7 位十进制)。这杆秤就是 f32 格式本身,不是前面那把噪声尺子。
第二次迁移里有一项辅助蒸馏损失(KL),每行只有约 1.1e-4,却是从约 7.1 的 log-sum-exp 里减出来的。300 步那一代,TPU 记下的它一直偏低(带符号均值 −5.1e-4,第 1 步差到 −9.2e-4),按噪声尺子判「不过」。图里那杆秤是 f32 格式本身,不是前面的噪声尺子:lse 差一格,就是 KL 的约 4e-3。
前三问认出这是病态在放大;第四问问被放大的那一格是谁的:同样的 f32 计算换到 CPU(PyTorch)上几乎不偏,TPU 偏了将近一格,来自 TPU 默认的 exp 和 log,换成高精度写法,300 步那一项的系统偏差没了。
这项 KL 的记录写法本身在 FP32 里病态(CPU 上调同一个函数也偏高),改记一种等价的广义 KL 以后,1000 步带符号均值的 r 1.06 → 0.69,三个统计里最差的 0.85,由待定变过;梯度一位不变。真实宽度上 GPU 自己记下的这一项也偏高,约六成来自 GPU 把索引器的旋转位置编码放在 BF16 里算。所以「更准就是更像 GPU」只在 lse 那一格成立(同一代还开了另一个开关,没拆开)。
把一行的原始输入存下来,在 FP64 里逐项重算:目标分布、对数概率,误差都在 1e-7 量级,比 1e-3 小四个数量级,差只能落在最后的 log-sum-exp 上。偏低的大小有两个口径:单行对 FP64 重算 −1.2e-3;TPU 全部运行对 GPU 全部运行 −9.2e-4。换成高精度的 exp、log 以后,同一行对 FP64 −1.2e-3 → +9.7e-5,lse −0.953 → +0.025 格(前后两端的其余设置不同)。由它出发的梯度对 FP64 的 R 中位数 0.97–0.99(实测)。要是同样的 f32 计算换到 CPU(PyTorch)上也偏同样多,那一格就是两边都躲不开的末位,才写「不过,已定责」。
现象。第三次迁移的图文模型 32K,12 份 TPU 运行 MTP loss 的 1000 步带符号均值都在 +2.07e-5 到 +3.23e-5,GPU 7 份对基线只有 +0.15e-5 到 +0.69e-5;形状都一样:第 1–50 步约 0,第 100–200 步升到 +2e-5 到 +5e-5,之后停在 +2e-5 到 +4e-5。加开关、换执行设置都去不掉。第 1 步 MTP 层 21 个张量加输出头、词嵌入,R 都 ≤ 1.10:权重还在格点上,看不见(§6 折叠「第 1 步逐位相同,不等于开关没用」)。
第一个嫌疑。同一状态各算一步,把两边的梯度差拆成「沿 FP64 方向的比例项」,整个 MTP 层是同一个比例差,追到 MTP 输入那次被省掉的舍入(§5.4 折叠)。补上以后同状态一步修好了,1000 步分不出作用。
主因。两边 MTP 头都在反向把 logits 的梯度舍成 BF16,只是舍之前乘的系数不同:GPU 乘 0.1(MTP loss 的权重)以后舍,TPU 是目标先除以 token 数再反向,等于乘 0.1 ÷ N 以后舍(那一步 N = 60,915)。正确词那一项 = 系数 × (py − 1),py 很小时几乎都挤在同一个格距里。系数 0.1 时最近的两个格点是 0.099609 和 0.100098,py < 1.46e-3 时全往 0.100098 舍:GPU 这一项舍后偏大 9.8e-4(相对),传到输出头反向的输入偏大 6.1e-4;TPU 这一项偏小 1.53e-3,输入偏小 7.1e-4。方向相反。
⚠️ 本课复算:p_y = 1e-5,系数 × (1 − p_y) 先在 FP32 里算好,再按 BF16 就近舍入(平局取偶)。p_y 取 1e-4、1e-3 时位置是 0.78/0.31、0.60/0.12,方向不变;p_y 趋于 0 的极限就是对齐记录的 +9.8e-4/−1.53e-3。
📌 对齐记录用 numpy 实测过 N 取 2 的幂时两种写法逐位相同;本图第三行是同一件事的复算。
N 取 2 的幂时,两种写法逐位相同(对齐记录 numpy 实测):问题在尾数落在格距里的什么位置,跟数大不大无关。也不是下溢:0.1 ÷ 60,915 约 1.6e-6,离 BF16 最小的正规数还差约 107 个二进制量级。
一度把它排除了。同一状态一步上,让 TPU 改在 GPU 的尺度上舍,MTP 参数梯度沿 FP64 方向只挪 5e-5 到 4e-4(相对);定位时据此把它排除在外。
1000 步推翻了这个排除。3 份对 3 份,尺子是 GPU 同设置重跑两两的最大差 6.866e-6:
| MTP loss 1000 步带符号均值 | 第 1 份 | 第 2 份 | 第 3 份 |
|---|---|---|---|
| 不改 | +2.08e-5(3.02 倍) | +2.94e-5(4.28 倍) | +2.79e-5(4.06 倍) |
| TPU 改在 GPU 的尺度上舍 | −1.06e-6(0.15 倍) | −3.80e-6(0.55 倍) | −4.66e-6(0.68 倍) |
两组不重叠。主 loss 两组都在 0.99–1.42 倍,参数范数都过。第 2、3 份只改执行方式(关一项调度、改片上内存上限)。为什么单步小、1000 步大:这份偏差方向每步一样(每个 token 沿自己正确词的方向),累积到 MTP 头和 MTP 层的权重上,单步梯度的投影体现不出来 —— 推断,未验证。
这个诊断开关只用来定位,不进生产;正式修法按 TPU 这边的写法改 GPU,golden 已重跑:MTP 从不过变成待定,可 TPU 反过来偏低约 1e-5,没收尾;生产建议 MTP 头的 logits 留 FP32。只要这一处还舍 BF16,换哪个固定系数都只是换偏的方向和大小(×0.1 偏大 9.8e-4,×0.1 ÷ N 偏小 1.53e-3);想根治,就让这份 logits 留 FP32。
⚠️ 纯文本 32K 上同样加这个开关,MTP 反而偏到负向 1.32–1.75 倍尺子;推断那里另有一份约 −1.6e-5 的偏差,原来被抵掉了大半,来源在查:单份读数指向一处被编译器省掉的舍入,未定论。
主结论:v5p 上 TPU 默认的 exp、log、sigmoid、silu 最大差几十到上百格(1 格 = 末位差 1;v7x 默认准一些,exp 仍差 64 格),GPU 只差个位数,而且默认的 exp 系统偏低。v5p 上打开框架里的「精确超越函数」开关,全部降到个位数,步时 +0.8%;v7x(运行库 0.0.46)上开了也降不下来,exp 仍差 64 格。只设 JAX 的精度档 highest 不够,sigmoid、silu 降不下来。
📌 实测:对齐记录第三次迁移,逐元素对 FP64 正确舍入值。v5p 只给 JAX 设 precision=highest:exp 1、log 3、sigmoid 83、silu 86。v7x 默认的平均误差:exp 11.8、log 0.65、sigmoid 2.4、silu 2.3 格。
📌 单算子回放(第三次迁移 v5p,生产原样):post 门 8.68 倍、路由权重 4.36、主交叉熵 2.97、MTP 交叉熵 3.97;开了以后 0.96、1.15、1.14、1.25。曲线上只有 MTP 一项看得出(1.06 → 0.99)。
📌 编译产物显示:v5p 默认的 exp、log 交给硬件的超越函数单元;精确档改到向量单元上用多项式,每个向量寄存器的指令 3 条 → 43–45 条。v7x 上开了以后 exp、log 逐位不变,sigmoid、silu 只差末位。
📌 实测(TPU v5p,FP32,对 FP64 正确舍入数格):默认 exp 105、log 62、sigmoid 83、silu 86;高精度写法 exp 1、log 3、sigmoid 3、silu 4。GPU:exp ≤ 2、log ≤ 1 是 CUDA 文档给的观测最大值(文档注明不作保证);B200 实测 log 1、sigmoid 和 silu 最大 3.4(根源一览第 11 行)。TPU 默认的上限跟 JAX 文档给这一代芯片写的一致。
⚠️ 右格是教科书做法(区间缩减、多项式、牛顿迭代),只讲思路;各家库的系数、项数和缩减方式不同。sigmoid、silu 的高精度写法用高精度的 exp 搭:e = exp(−|x|),再算 1 ÷ (1 + e),倒数做一次牛顿修正。
exp、log、sigmoid 这类函数,硬件不会一步算出来,都是软件拼的。TPU 默认那一版图快,最大误差几十到上百格;GPU 的 FP32 版本只差个位数。更要紧的是方向:在真实的输入上,默认的 exp 绝大多数结果没舍对,而且平均往低处偏(数在图下)—— §5.5 病态折叠里 lse 那一格就是这么来的。
sigmoid、silu 没这么顺,图下出处里有经过;教训是:改完一个函数,整网要再验一遍。
第三次迁移把这一项在两代芯片上量全了。先分清三样东西:JAX 的精度档 highest;框架里的「精确超越函数」开关;上面图里自己搭的高精度写法。v5p 上默认几十到上百格;只设 JAX 的 highest,exp、log 降下来,sigmoid、silu 不动;打开框架的精确超越函数开关才全部降到个位数(下面折叠里第二次迁移那个「读回是开、实际没变」的开关,说明开关要实测;这一次是逐元素量过的),步时 +0.8%。编译产物显示,开了以后整段从硬件的超越函数单元挪到向量单元上用多项式算,每个向量寄存器的指令从 3 条变成 43–45 条。v7x 配运行库 0.0.46 时,这个开关打开后 exp、log 逐位一样,sigmoid、silu 只差末位(silu 29 → 30 格),都降不下来:v7x 默认就比 v5p 准,可 exp 最大仍差 64 格,目前对不到 GPU 的水平。
高精度开关对 exp、log 生效,可 sigmoid、silu 走的那个函数在高精度档跟默认逐位相同,逐算子回放 99 个算子一个没变;改用高精度的 exp 自己搭,单算子降到 3、4 格,跟 GPU 实测的 3.4 格一样准,整网 loss 反而偏得更多(主 loss 带符号均值那一项的 r 0.65 → 1.79,前 300 步窗口)。精确写法的反向由自动微分推出来,跟 GPU 的解析式不同;改成同一个解析式以后,1000 步路由偏置均值 r 2.54 → 0.89。主 loss 那次偏大,下一代配置里就回到了噪声内,没有单独归因。
TPU 默认的 FP32 除法、开方、Adam 的偏差修正 1 − βᵗ,分别差 2、3、108 格(换成精确写法后 1、1、2 格):除法用牛顿修正的倒数再修一次商,开方做一步牛顿修正,1 − βᵗ 写成 −expm1(t·log β),免得两个接近 1 的数相减。几格的差平时看不见,可在 Adam 管的一个小张量上,第 5 步的更新离 FP64:GPU 1.49e-6、TPU 5.70e-6,R 3.82 → 1.00。
暗线:这一节里,设备数(§5.3)、梯度累积(§5.4)各换过一次,步数、芯片(§5.5 的折叠)也各换过一次,每次都推翻了之前的验证。
不一定。单算子对上,整网未必:第二次迁移把 sigmoid、silu 换成三四格的写法后,单算子跟 GPU 一样准,整网 loss 先偏得更多。说明还有别处没对上:查到一处是反向公式跟 GPU 不同,改成同一个解析式才收拢。要逐处查、整网再验。
这一节留下的问题:在 TPU 上,怎么把中间的张量拿出来,又不改动结果?
要定位,就得把中间的张量拿出来看。GPU 上随手挂个钩子就行;TPU 上不行:钩子会把编译器融合好的一块切开,舍入位置跟着变,量到的已经不是生产程序。
⚠️ 本课推导:Adam 一阶动量 mₖ = β₁·mₖ₋₁ + (1 − β₁)·gₖ(gₖ 是裁剪之后的梯度),倒过来 gₖ = (mₖ − β₁·mₖ₋₁) ÷ (1 − β₁);再除以裁剪系数得到裁剪之前的梯度。β₁ = 0.9。
📌 实测:GPU 上反推梯度对抓到的梯度 rel_L2 2e-7 – 4e-7;TPU 上固定探针单独编译,训练轨迹和不开探针时 1000 步逐位相同。
📌 实测:v5p 上加抓数输出的训练程序和生产程序不逐位;XLA 默认在融合内部跳过中间的 BF16 舍入(excess precision),融合一变,舍入位置就变。
注:中格四个算子、融合切成几块、舍几次都是示意(跟 §5.4 折叠里那张省舍入示意图同一种画法);真实的融合怎么切由编译器决定。
主权重、Adam 的两个动量、路由偏置,训练步和训练步之间从状态里读。梯度不用另抓:从相邻两步的一阶动量倒推。
process_allgather,把各主机上的分片收齐)或存检查点来读;最省事的是在要看的那段步数里每步存一次检查点。第 k 层的输入直接用 GPU 那一层的输入,TPU 上只编译这一层;第一个超线的那一层就是出错的那层。设备网格、参数切分、编译参数要跟训练一样:单卡回放看不到 8 个设备才有的那几次多舍(§5.3),会判反。
回放工具自己也要验。第二次迁移的单算子回放里,稠密 MLP 的 R 是 1.563:注入只换了按位置传的参数,那个分支按关键字传输入,算子吃的其实是 TPU 自己上游的输入。同一个 GPU 输入直接喂这个算子,R 0.999;修好注入以后 0.95。所以注入要覆盖全部输入,换不了就报错,别悄悄放过。
每隔 25 步,在一条固定的序列上单独跑一次前向,记每一层输出的均值、lse(log-sum-exp,所有 logits 的整体水平)。
只有不改生产程序的读数(步间读状态、逐步序列)能当证据;隔离回放和探针是另编的程序,只用来定责、确认修法方向。精度开关在生产程序里生没生效,日常回归直接数生产训练步编译后的程序(舍到低精度的算子、all-reduce、自定义 kernel 调用各几个),边传边乘(编译产物里叫窗口化矩阵乘)只靠整份程序的指纹兜底。
| 工具 | 改不改生产程序 | 读数能当什么 | 能比到第几步 |
|---|---|---|---|
| 步间读状态、倒推梯度(§6.1) | 不改 | 生产程序的证据 | 逐张量只比第 0、1 步 |
| 1000 步逐步序列 | 不改 | 生产程序的证据 | 多步只比标量曲线 |
| 隔离回放(§6.2)、固定探针 | 另编一个程序 | 只用来定责、确认修法方向 | 单层、单步 |
| 状态互换 | 另编一步 | 分开「这一步算得不一样」和「状态早就不一样」 | 任意一步各算一步 |
挂钩子、jax.debug.callback | 改了(切开融合) | 不能当证据 | — |
📌 实测(第二次迁移,真实权重截层,同一批数据上的 TPU FP32 轨迹 30 步;GPU 8 份、TPU 1 份):逐步相对差 =(被测 − FP32)÷ FP32;GPU 8 份最大最小差不到 3e-5,画成一条。TPU 对 GPU 8 份均值的分段带符号均值(同一次 300 步运行的前 100 步):第 1 步 −8.4e-5、第 2–10 步 −6.7e-5、第 11–100 步 −4.8e-5,同号、逐步衰减。
⚠️ FP32 参照自己离 FP64 多远没有测,第 1 步的比较只当诊断。红线是两条相对差相减,跟直接算 TPU 对 GPU 的相对差只差二阶小量。
把一侧某一步的 FP32 主权重搬到另一侧,用同一批数据各算一次梯度;Adam 缩放(二阶动量、裁剪系数)取原侧同一步的值,两边按同一把尺子折成这一步的更新(§7.4 就这么做:只搬权重,不搬优化器状态)。它能把「这一步算得不一样」和「状态已经不一样」分开(§7.4)。
从 BF16 检查点续训或微调时,有一类开关第 1 步开和不开逐位相同,要过几步才看得出差。
📌 本图脚本现跑的玩具实验:线性模型 256×32,批 64,MSE,Adam(lr 1e-05,FP32 主权重),输入舍成 BF16;「BF16 检查点」= 一份均值 0、幅度 0.02 的正态随机权重先舍到 BF16。开关关 = 权重先舍到 BF16 再乘;开关开 = 权重按 FP32 乘;其余逐行相同。两次训练第 1 步的 loss 和第 1 次更新后的整份权重逐位相同(脚本里 assert),第 2 步起 loss 不同。
📌 第 1 次更新后离开格点的元素占 100.0%;右格纵轴 = 同一份权重、同一批 2048 条 BF16 输入,开关开、关两种输出之差的 L2 范数除以输出的 L2 范数。
⚠️ 本课推导:BF16 有效位 8 位,两个相乘至多 16 位,FP32 有 24 位,乘积不舍入(脚本里对 10 万对随机数 assert 过)。高精度档把 FP32 拆成几份 BF16 分别乘再加,格点上的数拆出来只有第一份非零,其余几份乘出来全是 0;多遍和单遍逐位相同还要求那一份的累加顺序不变(推断)。
注:前提是权重以 FP32 进矩阵乘、开关只改权重这一侧;要是框架在进矩阵乘之前就把权重转成了 BF16,这类开关从头到尾都不起作用。左格挑了 15 个第 0 步正好落在这 5 个格点上的元素,每个格点三个;数轴位置是真实值,第 30 次更新后走出这一段的不画。玩具的差是多大没有意义,只看第 1 步是不是 0。
所以第 1 步「开关前后逐位相同」不能当「这个开关没用」的证据:要拿训练若干步以后的权重去测(状态互换,从那一步各算一步),或者看多步曲线。随机 FP32 初始化起训时没有这回事。
TPU 上的程序都由 XLA 整图编译(GPU 上用 JAX 或 torch.compile 也一样)。多一个输出,编译器就得把那个中间值落到内存里,原来融在一起的算子被切开、重新分组,FP32 求和的分组和顺序一变,末位就变(混元 3 实测:融合从 856 个变 859 个);融合里被省掉的 BF16 舍入也可能跟着变。
这一节留下的问题:TPU 的 loss 三百步以后为什么平均比 GPU 低约 1.7e-4?
混元 3 搬上 TPU,主 loss 三百步以后平均比 GPU 低约 1.7e-4,是 GPU 噪声尺子的两倍多(§1.2)。TPU 算错了吗?这一节按调查的顺序,一条线从现象查到源头,每一步只看一个数;细数和排除过的岔路都收在折叠里,课上不讲。
这一节的调查线(每一步只看一个数;细数在各小节和折叠里)
先把输出头摆清楚:混元 3,隐藏维 4096,词表 120,832,一个微批是一条 4096 个 token 的序列;输入词嵌入和输出矩阵不共用,输出层是单独一份权重。
(4096 × 120,832) · (120,832 × 4096) → 4096 × 4096:中间收缩的那一维就是词表。十二万项的求和只在这一步:输出头反向,把梯度传回隐状态(dgrad)。
前 100 步看不出,100–300 步拉开,300 步以后稳定在 −1.7e-4 左右。第 1 步没有、几百步才长出来:是每一步一点点攒起来的。那就看别的每步都记的量,谁也在慢慢长:
📌 实测:混元 3 截前 4 层,三份默认设置的 GPU 运行(一份当基线)和 TPU 第一次 1000 步运行;逐步原值来自对齐记录的逐步曲线文件。主 loss 第 301–1000 步带符号均值:TPU −1.66e-4,另两份 GPU −3.78e-5、2.47e-7。参数范数:GPU 基线从 3042.377 涨到 3042.503;TPU − 基线第 100 / 300 / 1000 步 +3.9e-04 / +4.6e-03 / +2.1e-02。
📌 两边记录的格距不同:GPU 侧是 FP32 平方和开根号,平方和(约 925 万)一格是 1,折成参数范数约 1 ÷ (2 × 3042) ≈ 1.6e-4,GPU 之间的差都是它的整数倍;TPU 侧记的就是 FP32 的参数范数,3042 附近一格 2.4e-4。
⚠️ 粗线是 50 步滑动平均,只为看方向;判定见第三节。
参数范数(§3.1)这里约 3042。第 1000 步 TPU 比 GPU 多 0.021(绝对差);GPU 自己一千步才涨了 0.127。
第 301–1000 步逐步相对差的带符号均值 −1.66e-4(对一份 GPU 基线;另两份 GPU 重跑对同一基线是 −3.8e-5 和 +2.5e-7;开场说的「约 1.7e-4」就是它)。§1.2 那把尺子已经量过:TPU 三种跑法(原样、不重算、改片上内存上限)都在尺子外面,而且方向一致。这一讲的规矩是每一处超出噪声的差都要说得出是谁的,所以得查清它是谁的差。
先别读成「TPU 训得更好」:loss 系统性地低,只说明两条轨迹有系统差别。第 1 步的更新量两边没有差别;前向算子的差第 1 步就该看得到。
📌 实测:分组参数平方和、逐行平方和都按 FP32 主权重算,两边组名一致;「合计减输出层」那一截大半是按组线性拆分的残差,不是别的参数组的贡献;第 100 / 200 / 300 步输出层贡献 +4.10e-4 / +1.85e-3 / +3.83e-3,逐步变大。
📌 换算(本课推导):参数范数 = √S(S = 全部参数平方和),S 多出 ΔS 时参数范数多出约 ΔS ÷ (2 × 参数范数)。输出层平方和差合计 +23.2 ÷(2 × 3042)≈ 3.81e-3,跟左边输出层的 3.83e-3 差约 0.4%。
📌 实测:没出现过的词那些行,√v̂ 均值两边只差 0–4%,Adam 更新的大小只差 1%–3%;Σ w·u(更新在这一行权重方向上的分量,加起来)从第 25 步起就分开。
没出现过的词(58,638 行)从来不是正确答案,每一步只收到一种梯度:softmax 按它那点极小的概率把它往下压,所以一直在缩。到第 300 步,这些行的平方和从初值算起 GPU 减了 66.3、TPU 只减了 49.2,少压约四分之一。这里只说两边不一样,不说谁对;哪一边偏,§7.4 才知道。
这些行的梯度很小,Adam 平时那层按每个元素的梯度大小归一化的保护在这里失效,所以梯度上一点系统偏差每步落在同一边,原样累积。
本例:β₁ = 0.9,β₂ = 0.95,ε = 1e-8(加在开根号之后),lr = 1e-5 常数,λ = 0.033(解耦的权重衰减;一维参数如 norm 权重、偏置不衰减)。下文 u = m̂ ÷ (√v̂ + ε):√v̂ 大致就是「梯度有多大」,ε 是分母上防除零的小常数。旁注:梯度长期稳定时 m̂ ≈ g、√v̂ ≈ |g|,u ≈ g ÷ (|g| + ε),只看形状(下面那张图就是它)。
| 第 300 步,输出层按词频分桶(实测中位数) | √v̂ | ε 在分母里占 | 更新被压小 | 在哪个区 |
|---|---|---|---|---|
| 100 次以上(16,326 行) | 1.17e-5 | 0.09% | 1.001 倍 | 常见区 |
| 11–100 次(31,999 行) | 3.29e-6 | 0.30% | 1.003 倍 | 常见区 |
| 1–10 次(13,869 行) | 2.64e-7 | 3.7% | 1.038 倍 | 常见区 |
| 没出现过(58,638 行) | 2.62e-9 | 79.3% | 4.8 倍 | ε 区 |
没出现过的词那 58,638 行,第 300 步有 92% 的元素 √v̂ < ε,也就是被压小 2 倍以上;中位数那一档压小 4.8 倍。压小 10 倍、20 倍以上的各占多少,结果文件里只有中位数和 ε 以下的比例,算不出来,不写。被压小本身两边一样,要紧的是这时更新跟梯度成正比、归一化的保护失效:「ε 在分母里占」那一列,正好就是梯度差 1% 时更新差几成(弹性 ε ÷ (√v̂ + ε))。梯度 4e-9 时 0.71,1e-6 时 0.0099:梯度方向上一点差,在 ε 区原样漏过去。
⚠️ 本课推导:Adam 更新 u = m̂ ÷ (√v̂ + ε)。梯度稳定时 m̂ ≈ g、√v̂ ≈ |g|,u ≈ g ÷ (|g| + ε);弹性 (du/u) ÷ (dg/g) = ε ÷ (|g| + ε):g = 4e-9 时 0.71,g = 1e-6 时 0.0099。
📌 实测:没出现过的词那些行,第 200–300 步 √v̂ 的均值在 4e-9 到 1e-8(第 1 步梯度中位数 5.2e-8,12% 小于 ε);第 300 步有 92% 的元素 √v̂ < ε,中位数 2.6e-9;β₁ = 0.9、β₂ = 0.95、ε = 1e-8;没有出现 FP32 下溢或非正规数。
注:绿色那一段「常见词的行」只是示意它们的梯度远大于 ε,具体位置没有画实测值。最下面那条实测只有三样是量到的:ε 分界、ε 以下的比例 92%、中位数;条的两端长度是示意,不是分布。
口径:ε 不制造偏差,也不放大偏差。常见行里,Adam 按每个元素自己的梯度大小归一化,梯度整体偏大一点、偏小一点都被约掉;冷门行分母被 ε 托住,这层保护失效,梯度上的系统偏差原样进了更新。更新被压小(中位数那一档 4.8 倍)对两边一样,不影响两边之比。
先查配置和名单(几分钟),再跑几十步的短运行,最后才跑 1000 步。
| 怀疑 | 怎么验 | 结果 |
|---|---|---|
| 两边数据不同 | L0 指纹 | 前 30 步 1,950 项对 GPU 逐位相同;1000 步按步号回放同一份批文件 |
| 权重衰减作用的参数集合 | 用 TPU 第 1 步读出的状态,按 GPU 的公式重算更新量 | 逐参数吻合;把掩码反过来,残差大 13 倍以上 |
| Adam 公式、状态精度 | 同上,另查编译结果里状态的类型 | ε 位置、偏差修正都吻合;两个动量都是 FP32 |
| 第 1 步更新量 | 逐张量比两边第 1 步的更新 | 比值 0.997–1.003:第 1 步没有差别 |
| 注意力实现 | GPU 换两种实现;TPU 换掉融合注意力 | GPU 都在噪声内,TPU 照样漂 |
| 重算 | TPU 不重算;GPU 换成整层重算的 golden | 偏移照样出现 |
| 梯度按 BF16 规约 | GPU 反过来也按 BF16 规约 | 噪声内 |
| 只是执行方式不同 | TPU 只改编译器的片上内存上限 | 参数范数漂得一模一样(loss 偏移的大小变了):是 TPU 系统性的 |
| GPU 的十几处写法 | GPU 一项项换成 TPU 那边的写法(交叉熵、Adam、裁剪、最后的归一化、注意力缩放、残差精度、专家加权求和、关 TF32……),各 300–400 步 | 全部复现不出来 |
冷门行每步挨多少压,跟着所有 logits 的整体水平走:水平越低,挨的压越小(为什么,见下面「这股力是什么」折叠里的恒等式)。固定探针(§6.3)量的 lse 就是这个整体水平:
📌 实测:两边在同一条固定序列上每 25 步跑一次前向(单独编译,不扰动训练),共 40 个点;TPU 对第一份 GPU 的 lse 均值差第 25 / 50 / 100 / 300 / 975 步 −0.0016 / −0.016 / −0.078 / −0.218 / −0.299,GPU 两次之间 −0.0001 / +0.0013 / −0.0062 / −0.021 / −0.013。
📌 实测:第 1000 步的训练批上,TPU 的 logits 在整个词表上整体低 0.27、lse 低约 0.33,GPU 两次之间 1.7e-4。
⚠️ 本课推导:dlogits 各项加起来是 0,可各行在 w̄ 上的投影长短不一,乘上各行以后沿 w̄ 并不抵消 —— 所以 dh 沿 w̄ 那一份不为零。
注:左图的箭头是示意:真实的输出层有 120,832 行、4096 维。
TPU 的整体水平一路比 GPU 低,第 300 步差 −0.218,所以冷门行压得少:有一股让所有 logits 一起升降的力,两边不一样大。冷门行梯度很小,Adam 按大小归一化的保护失效(§7.2 折叠),这点差每步落在同一边,就积起来了。
输出层各行权重有一个共同的平均方向 w̄:隐状态沿 w̄ 偏一点,打到每一行上,所有词的 logits 就一起偏;反向时,梯度里沿 w̄ 的那一份,就是把所有 logits 一起往下压的力(下面叫「这股力」)。
softmax 看不见整体平移,概率不变;可冷门行不一样:冷门行每步收到的那份「往下压」,沿这一行自己方向的分量,正好等于这个词的原始 logit 按概率加权的和。所有 logits 整体一低,这个分量就小,这一行就缩得慢。
输出层一行的梯度,等于各个 token 的隐状态按这个词的概率加权求和;所以冷门行往哪偏,取决于隐状态。顺着往回查主干,最先分开的是第 0 层:两边第 0 层权重拿出来,用同一份输入各算一遍,换上 TPU 的权重输出就偏,换成另两份 GPU 重跑的权重偏得小得多 —— 是第 0 层权重长歪了。
📌 ĥ 是什么:最后隐状态均值的方向,按最后归一化的 scale 加权;它跟前面输出层的 w̄(输出层各行权重的平均方向)不是同一个方向,一个在隐状态这边、一个由输出层权重定。实测(探针):两边在同一条固定序列上每 25 步另跑一次前向(单独编译,不扰动训练),各层输出在 token 上取均值向量,投到 ĥ = γ⊙û(γ:基线那份 GPU 运行该步最后归一化的 scale;û:它该步最后归一化输出均值的单位方向)。最后归一化输出 = γ⊙x/rms(x),所以这个投影就是这一层对「最后隐状态均值沿 û 那一份」的贡献。画的是(TPU − 基线 GPU)÷ |基线 GPU|;灰线是第二份 GPU 对基线的同一个量。
📌 实测:第 300 步第 0–3 层 −5.4e-3 / −6.8e-3 / −7.2e-3 / −1.14e-2;embedding 输出第 1–975 步 TPU 最大 2.3e-4,GPU 两次之间最大 1.5e-4。第 1 步第 0 层已差 +2.7e-5(GPU 两次之间约 −6e-9),是前向数值差,第 50 步起转负并随步数增长。
📌 实测(权重互换):取基线 GPU 运行该步第 0 层的输入(一个 microbatch),在 CPU 上 FP32 重算第 0 层,只换权重;数值 =(换上的权重 − 基线自己的权重)算出的输出均值沿 ĥ 的投影之差 ÷ |基线自己的投影|。第 100 步 −1.94e-3(第二、三份 GPU +7.5e-6 / −2.4e-4);第 50 步 −2.1e-4(+1.8e-5 / +5.5e-5),同步的探针是 −1.4e-4,对得上。
⚠️ 推断(案例记录里的,没有单独验证):第 50 → 100 步,步数翻倍、差涨约 9 倍,不像每步一点固定偏差在线性累积,像有反馈在放大 —— logit 水平一旦走低,梯度跟着变,再往同一方向推。
注:第 0 层是稠密层,第 1–3 层是 MoE 层;最后归一化输出那条线跟第 3 层几乎重合,没画。
第 0 层权重的范数几乎没变,所以 §7.2 按组拆的账里看不出它;变的是方向。这张图看的是隐状态这一侧的平均方向;正文看的是输出层这一侧的 w̄。两者相关,可这两环之间怎么定量接上,没有单独量过。推第 0 层的,是输出头流回来的梯度。
PaLM 训练时专门加了一项 z-loss,把 softmax 的归一化项 log Z 往 0 拉(arXiv:2204.02311);也有人发现输出 logits 整体漂得越来越负,训练会发散,z-loss 能管住(Wortsman 等,arXiv:2309.14322)。
先证明就是这股力:两边都把这个方向的梯度去掉,再让 GPU 往这个方向多推一把。
MaxText(混元 3 公开分支):诊断开关 lm_head_dh_wbar_remove MaxText(混元 3 公开分支):去掉沿 w̄ 那一份梯度
📌 实测(1000 步):两边都去掉 dh 沿 w̄ 的全部分量后,TPU 对 GPU:loss −3.4e-5,param_norm +6.1e-3;同设置 GPU 两次之间 loss −2.5e-5、param_norm +4.9e-4。
📌 实测(1000 步,lse):两边都去掉以后第 1000 步 lse 差 −0.007(原样约 −0.33),同设置 GPU 两次之间 −0.012。这里的 lse 是在第 1000 步的训练批上量的;上一张图右格终点 −0.299 是固定序列探针在第 975 步的读数,两种测法,数不一样。
📌 实测:人为沿这个方向加一股力 —— 把 GPU 自己一份本来接近零的小分量(每个 token 的 dlogits 加起来,再乘 w̄)变成原来的 −8 倍,跑 1000 步,对默认 GPU:loss −1.26e-4,param_norm +2.05e-2;再跑一份 −1.27e-4、+2.01e-2。TPU 原样对 GPU:−1.66e-4、+2.1e-2。GPU 人为多推一把,连 logits 下移、冷门行范数偏大一起复现。这股力的大小没有跟 6.5e-4 那个缺口对过,只看结果能复现。
去掉这个方向,第 1000 步 lse 差从 −0.33 降到 −0.007;GPU 多推一把,就复现了 TPU。是这股力。
📌 实测:每组一份 1000 步的运行;灰线呈台阶状,是 GPU 一侧参数范数的记录精度有限(台阶约 1.6e-4)。
拿训练里实际用到的张量,同一批数据,在 FP64 里重算一遍,看两边的输出头反向各离 FP64 多远:
📌 实测:三根柱都是 golden 第 1 步、第 0 号卡第 0 个 microbatch;参照是各自的 logits 在 FP64 里算 softmax 减 onehot、再乘 BF16 输出层权重。TPU 两根是同一批输入的输出头回放(另一台 v5p 回放同一批读 −2.4e-5)。
📌 另一组抓下来的生产张量(第 1 步)把 GPU 拆成两段:交叉熵反向 +2.7e-6,矩阵乘 −6.51e-4,所以偏差在矩阵乘;同一组张量上 dgrad 换 FP32、真关 TF32 是 −1.7e-6,没关 TF32 的那一版 −8.08e-4,比 BF16 还差 —— 一度被当成「精确」参照(第十节坑表)。第 100 步 GPU 矩阵乘 −6.10e-4,TPU −7.4e-5。
📌 求和越长偏得越多(K 从 16,384 到整张词表)另成一张图,在本节折叠里。
红柱就是开头那张卡里的 dH:GPU 在张量核上沿 12 万的词表做这次求和,结果系统地朝零截了一点(§5.2 的抹零),落在「所有 logits 一起升降」这个方向上,第 1 步少推 6.5e-4(相对;这是另一组抓下来的生产张量,图上这一批是 −4.4e-4)。同一批数据上,TPU 对 FP64 的误差约是 GPU 的十七分之一。
📌 实测:把真实输出头张量的词表行打乱后取前 K 行,沿该方向的误差 −6.9e-5 / −2.0e-4 / −6.5e-4;朝零的整体尺度偏差 1.9e-5 / 7.3e-5 / 2.3e-4。
朝零、随求和长度增大,是实测;说它就是 §5.2 那个抹零模型在起作用,是推断 —— 那个模型在这么长的求和上没有单独验证过。第 100 步那个指标连真 FP32 都偏得不小,只作旁证。 最早那一版「FP32 dgrad」没关 TF32,偏得比 BF16 还多,于是一度得出「换成FP32 dgrad 训练也不动」的错误结论。第 1 步几乎全是截断(FP32 一次累加只偏 −1.7e-6);训练中后期冷门词概率变小,FP32 一次累加也吞同号小项(到 −2.6e-4),和截断同量级;截断从第 1 步就在、不随训练变大(按 §7.5 的相减粗分还在变小);吞小项随冷门词概率变小才长出来,这一条是推断(cuBLAS 内核没有源码,合成长求和上一个累加器就近舍入吞到同一量级是旁证);分段让每段的和保持小,两样一起治。
别的矩阵乘也偏一点:合成的全正输入、求和长 4096 时朝零 7.0e-5(§5.2 右图)。可真实的激活和梯度有正有负,抹零的方向跟着每一项的符号走,大半互相抵消;后面也没有这样一个原样累积的地方(推断:其余矩阵乘沿各自方向的偏差没有逐个量)。
这还只是离线的一次矩阵乘,再在训练里确认一步:把 GPU 第 99 步的 FP32 主权重搬到 TPU,同一批数据两边各算一次梯度,按 GPU 的 Adam 缩放折成更新,再跟 GPU 上全程 FP32 算的那一步比,看沿 TPU − GPU 权重差的方向各少走多少(这个做法叫状态互换,§6 折叠)。
📌 实测:1193 个张量导入 TPU 后逐个核对 sha256(按 GPU 框架布局数,q/k/v、gate/up 已各合成一个,所以少于按开源命名数的 1781 个)。方向 d = 第 100 步 TPU 与 GPU 主权重之差;梯度差经 Adam 逐元素缩放、乘学习率和裁剪系数后投到 d 上,按 |d|² 归一。
📌 实测:θ₉₉ 上 TPU 0.00%、GPU FP32 dgrad −0.10%、GPU −0.36%;四个状态(GPU θ₉₉、θ₂₉₉,TPU θ₉₉、θ₂₉₉)、共 12 个 batch:TPU −0.04% 到 +0.10%,GPU FP32 dgrad −0.05% 到 −0.22%,GPU −0.31% 到 −0.47%。
📌 参照用 GPU 上的全程 FP32(权重先舍成 BF16,跟生产用的同一份):TPU 自己那份「全程 FP32」程序核对后发现路由专家实际按 BF16 算(对 FP64 3.2e-3),不能当参照。
GPU 一步少走 0.36%,只把那次求和换成 FP32 就只剩 0.10%;同一状态下 TPU 几乎正好(±0.1% 以内)。
搬的是 1193 个 FP32 主权重张量(逐个核过),两个动量不搬,Adam 缩放取 GPU 同一步的。这里的百分数量的是「TPU − GPU 权重差」方向上少走多少,跟 6.5e-4 量的「所有 logits 一起升降」方向不同,数不一样。这里的「精确值」和「FP32 dgrad」都是 GPU 算的,那次长求和交给 cuBLAS 一次累加到底,下面会看到它积上千步以后也偏,所以这张图只看谁少走得多、谁少走得少。别把两个百分比混了:§7.4 的 6.5e-4 量的是那一次矩阵乘沿 w̄ 少了多少;这里的 0.36% 量的是整个梯度经过 Adam 之后,权重沿漂移方向少走了多少。
最直接的修法:那次求和换成 FP32(真关 TF32)。第 1 步的偏差降到 −1.7e-6,可跑满一千步:
📌 实测(左):混元 3 截前 4 层,生产近似配置(整层重算+路由回放);逐步参数范数对 GPU 生产 5 份均值。橙线 = GPU 生产只把输出头那次求和换成 FP32 一次加到底(真关 TF32),5 份均值;绿线 = GPU 生产只把那次求和改成分块(升 FP32 再分块;修好的 golden 的基线那份;乘法留在张量核只分块的写法一千步跟它分不开;10 份第 1000 步之间最多差 1.15e-3);蓝线 = TPU 当前对齐配置;紫色虚线 = 真精确(BF16 权重、全程 FP32、那次求和分块)。灰底 = GPU 生产 5 份各自对均值的最大偏离(第 1000 步约 3.3e-04)。右格绿条是「张量核分块」、左格绿线是「升 FP32 再分块」:两种分块一千步分不开,所以同色。
📌 实测(右):训练里实际用到的那几个张量(第 1、100、300 步),一张 B200 上换写法重算这次矩阵乘,沿 w̄ 对 FP64 的相对偏差。
橙线:GPU 生产只换这一处,第 1000 步参数范数比 GPU 生产多 +0.0124,TPU 是 +0.0209,只追回六成(59%)。右格是同一次矩阵乘的离线测量:FP32 一次加到底,第 1 步几乎不偏,到第 100 步的状态已经偏到 −2.56e-4,跟张量核同一个量级。
为什么:吞小项。训练以后冷门词概率越压越小,沿 w̄ 每个冷门词贡献一个同号的小项;一项不到累加值最小一格的一半,就被整项舍掉,舍掉的都在同一边。FP32 一次加到底躲得开截断,躲不开这个(cuBLAS 怎么累加没有源码可看,这是推断)。
分块两样都治。每 1024 项先加成一块、块结果留 FP32,再把一百多块加起来:块里的和不大,小项丢不掉,截断也只在短段里。GPU 生产只改这一处,第 1000 步 +0.0207,跟 TPU 的 +0.0209 重合(图上绿线和蓝线);乘法留在 BF16 张量核、只分块也一样,步时只多 6%。只改 GPU 的标准答案,TPU 一行不动。
口径:图上绿线 +0.0207 是先升 FP32 再分块那一臂;乘法留在 BF16 张量核、只分块的那一臂跟它分不开。
两种误差,得分开。先纠正一个常见的误解:两边那次 120,832 项的求和,都是 BF16 输入、FP32 累加,不是 BF16 累加。差在 FP32 累加器怎么舍:GPU 张量核每 16 个乘积一组,按其中最大的指数对齐,约 25 位以下的低位朝零截掉(§5.2);TPU 的矩阵单元推断是就近舍入(没有直接证据;旁证是同一份输入算路由打分,TPU 对 FP64 4.8e-8、GPU 3.8e-6,§5.3)。
误差一:截断。刚开始几乎全是它。训练刚开始,各个词的概率都差不多,冷门词还没被压到很小,这次求和里没有「特别小的项」。所以第 1 步的误差几乎全来自张量核的截断:沿 w̄ 的相对偏差,张量核一次加到底 −6.51e-4,换成真 FP32 一次加到底只有 −1.7e-6,差了约 380 倍。
换 FP32,去掉的是截断。输入本来就是 BF16 的值,升成 FP32 数值一位不变,所以它修的是累加路径(BF16 精度本身没动):把张量核那条截断的累加路径,换成就近舍入的 FP32 累加:第 1 步的偏差降到 −1.7e-6;状态互换里 GPU 一步少走的从 0.36% 降到 0.10%。要注意两点:升 FP32 同时换了内核和求和顺序,严格说它证明的是「张量核那条累加路径」是主因,截断是最可能的机制;而且必须真关 TF32,否则 FP32 矩阵乘会走回张量核、按 10 位尾数算(§7.4 折叠)。
别误读成「截断是小问题」。不分块的长求和里,张量核的总偏差在每个阶段都比 FP32 一次加到底大:第 100 步 −6.10e-4 对 −2.56e-4,第 300 步 −4.60e-4 对 −2.6e-4;按相减粗分(假设两部分可以相加,推断),截断那一份第 100 步约 −3.5e-4、第 300 步约 −2.0e-4,跟吞小项同一个量级。状态互换里,只换掉截断这一条路就去掉了约 72% 的少走。生产 GPU 不显式分块,这次求和怎么切由 cuBLAS 自己定,生产程序里实测就是上面那个偏差:截断实实在在发生了。
总结成一张表:
| 写法 | 截断 | 吞小项 | 偏差 | 单次 | 一千步步时 |
|---|---|---|---|---|---|
| 张量核,一次加到底(生产) | 有 | 有 | −6.51e-4 / −6.10e-4 / −4.60e-4 | 2.45 ms | 基线 |
| 真 FP32,一次加到底(关 TF32) | 没有 | 有 | −1.7e-6 / −2.56e-4 / −2.58e-4 | 65.6 ms | — |
| 张量核分块(每 1024 项,块结果留 FP32) | 只在短段里 | 没有 | −6.9e-7 / +8.3e-7 / +3.1e-7 | 7.2 ms | +6% |
| FP32 分块(第九节修好的 golden 的写法) | 没有 | 没有 | +1e-8 / +3.5e-7 / +1.1e-7 | 71.7 ms | +61% |
结论:不用升 FP32,BF16 张量核加分块就够。一千步只分块(乘法留在 BF16 张量核)跟「升 FP32 再分块」分不开,步时 +6% 对 +61%。这处只影响 GPU 标准答案的制作,TPU 生产程序不动。
先把 GPU 输出头这一次矩阵乘换成 FP32(真关 TF32),1000 步下来 GPU 自己朝 TPU 走过去约六成;剩下的,在 GPU 上跑一条精确轨迹来看:权重的用法跟生产一样(FP32 主权重,每步舍成 BF16 再用),前向反向的算术全部 FP32、真关 TF32。它自己重跑一位不差;图里 loss 那一行的第二个紫点,是给第 0 层一处权重乘 (1 + 1e-6) 的扰动版。
📌 实测:精确轨迹 = 主权重 FP32,每步前向前舍到 BF16,前向反向全部 FP32、关 TF32、不用融合注意力;第 2 / 3 步 loss 11.23569 / 10.58785,TPU 11.23569 / 10.58784,GPU BF16 11.23543 / 10.58775。
📌 实测:第 975 步对 4 份默认 GPU 运行均值:param_norm 精确轨迹 +1.82e-2、TPU +1.99e-2、FP32 dgrad +1.23e-2 – +1.28e-2(图中取中点),4 份 GPU 自己 ±4.5e-4;lse −0.262 / −0.286 / −0.16 – −0.19,GPU ±0.013;301–1000 步 loss 精确轨迹两份 −1.53e-4、−1.16e-4,TPU −1.27e-4,FP32 dgrad −4.3e-5 – −1.02e-4,GPU ±9e-6。
注:lse 与 loss 两行里「FP32 dgrad」取两份运行的中点,画的是位置示意。
上图是不重算配置、对 4 份默认 GPU 均值;换到生产近似配置、对 GPU 生产 5 份均值,第 1000 步精确轨迹 +0.0186、TPU 生产 +0.0209,也是九成。把精确轨迹那次求和也改成分块,GPU 精确轨迹就跟 TPU 上的精确轨迹重合:参数范数逐步相对差的带符号均值 7.9e-8,GPU 精确自己重跑几份两两之间最大 1.07e-7,在尺子内。
换到第九节验收用的配置(整层重算+路由回放),第 1000 步 TPU 生产比 TPU 自己的精确轨迹少漂 6.35e-3;这一截是谁的,第九节拆账。
GPU 生产只改分块的那一份,对 TPU 生产,参数范数逐步相对差的带符号均值:v5p +5.2e-8、v7x −5.5e-8,两个平台方向相反,量级都在 1e-7 以下(对齐记录案例 01 证据链)。判档按第九节的第一关:TPU 对它全过,参数范数那一项 r = 0.50(v5p)、0.53(v7x)。对齐记录里这一组数配过两把尺子:定案前的旧尺子 1.24e-7(只修 dgrad 那组 5 份 10 对),定案后的 2.27e-7(修好的 golden 10 份 45 对);按定案的那把,两边都在内。
生产里矩阵乘用的是主权重舍到 BF16 的那一份,权重本身每个元素就差至多半个 BF16 格。纯 FP32 训练(权重不舍)前 100 步 loss 就比 BF16 低 1.75%,走的是另一条路,跟哪边都差得远。 精确轨迹保留生产的权重语义,只把算术换成 FP32,每一步的梯度就是「同一份权重下 BF16 程序应该算出来的精确值」。
另外:这里的精确轨迹跟 ① 一样不重算;定案前第一关用的那条精确轨迹是在 ② 的配置上(整层重算+路由回放)跑的,两处的数不能直接对。
⚠️ 推断:① 的量(沿 w̄ 第 1 步少推 6.5e-4)是实测;把它归因成「长求和偏向一边(张量核截断+吞小项)」是推断。
📌 实测:GPU dgrad 沿 w̄ 第 1 / 100 步 −6.5e-4 / −6.1e-4;第 0 层输出在各层里最先分开、往后逐层放大(第 50 步起转为偏低),换权重重算确认是权重长歪、大头在注意力输出投影;第 1000 步训练批上 TPU 的 logits 整体低 0.27。
📌 实测(第四环,第 300 步同一步,没出现过的词那些行):两边 |g| 的均方根之比 0.990;Σ w·g GPU 8.1e-5、TPU 1.2e-6;92% 的元素 √v̂ < ε(中位数 2.6e-9),这些元素的更新 ≈ m̂ ÷ ε;Σ w·u 两边差 −4994,其中 m̂ 那一份 −5450。
Adam 的更新量大小两边差不多,差在方向:更新和这一行权重之间的夹角两边不一样,从第 25 步起就分开了。这些行梯度很小,Adam 按大小归一化的保护失效,更新几乎跟梯度成正比,方向上一点系统差原样进了更新,一步步积成范数差。
第 1 步那股力只差约 6.5e-4(相对),单看一步、对 GPU 噪声比根本看不出;它是每一步同向地少一点,要累积几百步才显出 loss、lse 和参数范数的差。比的是轨迹,所以要跑满。
这一节留下的问题:同一份代码只换并行方式,数学上等价,曲线却对不上 —— 这回又是谁的差?
第二个案例在第二次迁移上,模型是混元 4 的缩小版(约 4.3 亿个参数,词表 120,832 行、隐藏维 1024)。纯数据并行(DDP)和 FSDP 数学上等价,TPU 上一比,曲线超出了噪声。这回是谁的差?跟第七节一样,一条线查到底,每一步只看一个数。
这一节的调查线(每一步只看一个数;细数在各小节和折叠里)
TPU 自己跟自己比(§10.1):基线是 FSDP 8 卡,只改成纯数据并行。前 300 步梯度范数是 GPU 噪声尺子的 2.62 倍,不过(前 150 步最明显):
📌 实测:第二次迁移小尺寸,TPU v5p 自比(运行库 0.0.46),基线 FSDP 8、微批 1 × 累积 2;被测只改并行方式。GPU 同设置 8 份(尺子就是它们两两 28 对)。窗口第 2–300 步;梯度范数带符号均值的尺子 9.92e-5。
⚠️ 粗线是 50 步滑动平均,只为看方向;纵轴超出 ±2e-3 的个别点截在边上。
曲线说不出偏在谁身上。照 §4.2 定责,第 1 步 205 个参数梯度各自对 FP64 比:只有词嵌入梯度丢了精度,离 FP64 是 GPU 的 3.62 倍。词嵌入的反向是一次 scatter-add:按 token 号(下标)把每个 token 的梯度加回词表那一行,一张卡一次加 4096 个下标。范围从整个模型缩到了这一次加法。
TPU 自比(§10.1):同一个模型、同一份权重和数据,基线是 FSDP 8 卡,只改成纯数据并行,尺子是 GPU 同设置重跑的噪声上限 N。r = 差 ÷ N,超过 2 判不过(对齐记录里这一档叫「超」,1 到 2 叫「略超」)。
| 条件 | 曲线最差 r(300 步;第一行最差那项是梯度范数) |
|---|---|
| 8 卡,每步两个微批(跟基线一样) | 2.62 |
| 8 卡,不做梯度累积 | 3.69 |
| 16 卡(每卡一个微批,不累积) | 2.65 |
| v7x,8 个设备 | 2.21 |
| v7x,8 个设备,不做梯度累积 | 4.06 |
以上都在 TPU 运行库 0.0.46 上。换到 0.0.52,最后一行变了(§8.6)。「不做梯度累积」=两个微批合成一次 scatter,一次加 8192 个下标,所以反而更差(§8.6 讲为什么)。
换卡数都一样不过:前 300 步主 loss 平均偏高(带符号均值 +5.58e-6,r 1.85),梯度范数平均偏低(−2.60e-4,r 2.62;前 150 步最明显,下图),§3.3「从 K 份运行到一个 r」那张图下块的算例就是它。换张量并行、专家并行、混合切分都跟 GPU 重跑分不开,所以问题出在纯数据并行特有的某处。v7x 的 2.21 单看曲线不算铁证(纯 GPU 噪声用留一法也能到 2.47,§3.4),是第 1 步对 FP64 抓到的。
拿第 1 步的 205 个参数梯度各自对 CPU 上的 FP64 比:只有词嵌入梯度丢了精度,其余 204 个里,除照例单列的多路残差小参数,都在噪声内或只差加法顺序(只换了顺序的 185 个 R ≤ 1.2)。
| 第 1 步离 FP64 | 词嵌入梯度 | 其余 204 个 |
|---|---|---|
| 纯数据并行 | 1.51e-2(R 3.62) | 比值中位数 0.99;记「换了顺序」的 185 个 R ≤ 1.2,多路残差小参数另算 |
| 基线 FSDP / GPU | 4.00e-3 / 4.17e-3 | — |
R 的分母取基线和 GPU 中位数里离 FP64 远的那个(GPU 的 4.17e-3):这样 TPU 自己的基线本来就偏时,不会被算成「新改动丢了精度」。§4.2 定责流程图第一行的算例就是它。多路残差混合的小参数照例单列(6 个超线,数值上病态,向来不定责)。
最顺手的猜测:纯数据并行每张卡一整张表,8 张卡加完还要用 BF16 再相加,多舍一次(FSDP 下表按隐藏维切,不用跨卡求和)。现成的 FP32 开关(下文叫修法①)一开,300 步 r 0.98,修好了;可它同时改了本卡累加和跨卡求和两处,修好不等于找到病根。中间还撞上一个编译器 bug,r 冲到 611(§10.3,下面折叠)。
打开它,r 反而冲到 611:一块梯度凭空没了。编译器把这份 FP32 梯度的跨卡求和挪出了梯度累积循环,又在循环里把 0 号以外各卡的累加器清零 —— 这就是 §10.3「改完先比指纹」那张图右块的编译器 bug,要「数据并行 + 梯度累积 + 这个开关」三样同时成立才出现。修好以后 300 步 r 0.98。
接着有人追问:只把本卡的累加换成 FP32、跨卡仍传 BF16,行不行?为此加了修法②,结果词嵌入梯度离 FP64 4.24e-3、300 步 r 0.93,也在噪声内。跨卡仍用 BF16 也够了 —— 这已经在暗示:跨卡那一步不是主因。
修法①的做法:前向从 FP32 主权重表取行再转 BF16,前向逐位不变,反向的累加落在 FP32 上。FSDP 下词嵌入表按隐藏维切,每张卡只管自己那 128 维,不用跨卡求和(为什么不用,§8.6 折叠里那张「两种加法」图看形状)。
把第 1 步的词嵌入梯度按行分组,每组对 FP64 算一次,再做两个对照:每张卡一次加的 token 翻倍(紫柱),卡数翻倍(橙柱)。
📌 实测:同一张按行分组的表(第 1 步,离 FP64 的 rel_L2)。四列每张卡一次 scatter 的下标数:FSDP 32768(收齐 8 张卡的 token,排序);纯数据并行 8 卡 4096;16 卡 4096(跨卡求和从 8 路变 16 路);8 卡不做梯度累积 8192(一步的数据不拆微批)。
📌 高频行:3.26e-3 / 1.57e-2 / 1.59e-2 / 3.07e-2;整张表:FSDP 4.00e-3、纯数据并行 8 卡 1.51e-2、不累积 2.92e-2。各组 rel² 按范数平方加权求和回到整张表的数(本课复算,差 3% 以内)。
⚠️ 「接近翻倍」是这一步实测到的,不是一般规律:舍入误差有正有负、互不相关时,次数翻倍误差只涨约 1.4 倍;训练里接近线性,推断是舍入误差偏向一边(后加进去的小梯度被系统地吞掉一部分)。
token 翻倍,误差接近翻倍;卡数翻倍,误差不变。误差跟着本卡加几次走,跨卡多几路它不在乎:第一个假设推翻了,主因在每张卡本地那次 BF16 scatter-add。高频那 39 行占整张梯度范数平方的 0.90,纯数据并行多出来的误差 99.6% 在它们身上。
把两种并行编出来的训练步程序逐个查一遍:每一次梯度跨卡求和是什么类型、在不在累积循环里、跨卡前后各舍几次;再把第 1 步的词嵌入梯度按行分组,每组对 FP64 算一次:
审计顺带改正了一个印象:纯数据并行下以 BF16 跨卡求和的不只词嵌入,32 个 all-reduce 里有 10 个用 BF16 加法(路由专家 6 个、稀疏注意力索引器的两个投影 2 个、词嵌入 2 个)。可路由专家和索引器在 FSDP 下同样是 BF16,舍入次数相同,离 FP64 的比值(纯数据并行 ÷ 基线)在 0.91–1.07。矩阵乘类权重的梯度来自矩阵乘,每张卡先算部分和再跨卡加:纯数据并行用 all-reduce,FSDP 用窗口化的 reduce-scatter(编成循环里的 collective-permute、逐跳相加,编译产物里搜不到 reduce-scatter 指令;路由专家两边都是 all-reduce);all-reduce = reduce-scatter + all-gather,all-gather 只搬不加,所以只差先后。例外是第 0 层和多 token 预测层:纯数据并行下它们的舍入落在跨卡之前,位置跟 FSDP 不同,但离 FP64 没有变远。词嵌入不同:它的累加走 scatter-add,不走矩阵乘,FSDP 那一侧换了写法。
图上还有个反常:FSDP 每张卡一次收齐 8 张卡的 token(32,768 个下标),同一个高频词加的次数是纯数据并行的 8 倍,误差反而最小(绿柱)。为什么?
两边编译产物里,那次 scatter 要紧的差别只有一处:FSDP 那份先按 token 号排了序,还带着「下标已排序」的标记(indices_are_sorted=true)。把这一个 scatter-add 单拿出来,在 v5p 上真跑(表是真实形状,下标是基线第 1 步的真实 token),跟 CPU 上「FP32 里累加、最后舍一次」和「每加一次舍一次」两种仿真逐位比:
不排序,同一个词的更新散在别人中间,后端每碰到一次就读出来、加上、舍回 BF16,高频词一次加几十到几百个,就舍几十到几百次。排好序并带上「下标已排序」的标记,后端把一块表搬进片上的 FP32 缓冲,全部加完再写回,每行只舍一次。
只看编译产物时,只能推断「排好序的 scatter 把连续的更新留在 FP32 里加」;这个单算子实验把它坐实了。
📌 实测(单算子,v5p,镜像与训练相同):表 bf16[120832,1024],下标取 golden 第 1 步的真实 token(前 4096 个),更新量是随机 BF16。四格的结果和 CPU 上两种仿真逐位比:「FP32 里累加、最后舍一次」和「每加一次舍一次 BF16」;排序+开那一格 100% 的行等于前者,其余三格等于后者。
📌 右块(同一次实测,4096 个下标):出现 1 / 2–9 / 10–99 / ≥ 100 次的行数 961 / 402 / 60 / 3;不排序 0 / 2.70e-3 / 7.81e-3 / 1.46e-2,排序 0 / 1.72e-3 / 1.66e-3 / 1.70e-3。
📌 后端指令(CPU 上为 v5p 交叉编译,打开后端 dump 数静态条数):不排序那颗 kernel 每个更新「读 BF16 → 转 FP32 → 加 → 舍回 BF16 → 写回」;排序那颗换成另一颗 kernel,累加器在片上 VMEM 的 FP32 缓冲里;同一份 HLO 只关掉 excess precision,这颗 kernel 多出 12,288 条舍到 BF16 的指令,夹在每次加法前后。条数是静态的,不是执行次数;「舍到 BF16」是由指令名和结果逐位等于仿真推断的。
⚠️ 更新量是随机数,这张图只比同一行的两列,不跟训练里的数直接对。左块 token 号随手写。
四格里只有「排序 + 标记 + excess precision 开」那一格在 FP32 里累加。只排好序不带标记,结果仍逐位等于每次舍:标记告诉后端「同一行的更新已经挨在一起」,后端见到它才换成片上累加的写法:把表一块一块搬进片上的 FP32 缓冲,这一块的更新加完再写回,每行只舍一次(后端指令和逐位结果都核过)。
每卡 4096 个下标、全局 32768 个(更新量是随机数,跟训练里的数不直接比,只看相对大小):FSDP 1.58e-3;纯数据并行 7.17e-3;纯数据并行只加上排序 2.86e-3。从纯数据并行到 FSDP 的差距,排序一项走了约八成(77%)(本课按这三个数复算);剩下的在本卡部分和先舍一次 BF16、再做 BF16 跨卡求和 —— 跟修法②是同一种舍入结构。
排序是 TPU 后端(libtpu)自己插的一道工序,公开的 XLA 代码里找不到它。把一次 scatter 的下标数往上扫:
📌 左块实测(单算子,v5p,表 bf16[120832,1024],下标取 golden 第 1 步真实 token 的前 N 个,更新量随机 BF16):不带标记 4.59e-3 / 6.75e-3 / 9.14e-3 / 1.55e-3 / 1.58e-3;排好序带标记 1.37e-3 / 1.48e-3 / 1.51e-3 / 1.55e-3 / 1.58e-3;关 excess precision 4.59e-3 / 6.75e-3 / 9.14e-3 / 1.29e-2 / 1.76e-2;FP32 累加 1.6e-9 到 1.1e-8。每格都逐位等于对应的 CPU 仿真。
📌 换表形状二分门槛(门槛 = 行数 ÷ 8 是怎么来的)另成一张图,在 §8.6 折叠里。
📌 插排序的是 TPU 后端(libtpu)里的一道工序:对(下标, 序号)稳定排序 → 按排序后的次序取更新量 → scatter 标上「下标已排序」。公开的 XLA 代码里找不到它,触发条件只能从实验反推。
⚠️ 门槛为什么定在这里(推断):看上去是为速度定的启发式,精度更好是附带效果;单算子耗时只部分支持(快慢交叉在 4096 到 8192 之间,和 15104 对不上)。
FSDP 每卡一次 32,768 个下标,过线;纯数据并行 4096 个,不过线。FSDP 加得多,恰好跨过了线。门槛跟着运行库版本、芯片变,会过期;要带走的只有一条:看编译产物里这次 scatter 排没排序。
📌 实测(CPU 上用同一个 TPU 运行库为 v5p 交叉编译,看优化后 HLO 里有没有 sort):1,000 × 1024 到 65536 都不插;30,000 × 128 到 65536 都不插;30,000 × 1024 最小 3,751;60,000 × 128 最小 7,501;120,832 × 128 最小 15,105;120,832 × 1024 最小 15,105;480,000 × 128 最小 60,001。插排序的,最小下标数都等于 行数 ÷ 8 + 1,门槛位置和列数无关;整张表按 FP32 放得进片上内存时不插(30000 行:128 列不插、1024 列插)。同一个运行库为 v7x、v6e 编译,120832 × 1024 的门槛也是 15104/15105(有的表形状在 v7x 上交给 SparseCore,另算)。
📌 实测(两边训练步优化后的 HLO,每个微批主输入、多 token 预测输入各一组):纯数据并行 —— scatter 输出 bf16[120832,1024]、没有排序,之后 all-reduce bf16[120832,1024]、BF16 加法;FSDP —— token 号 all-gather s32[8,4096,1],梯度 all-to-all bf16[1,4096,1024] → bf16[1,4096,8,128],先 sort 32768 个下标,scatter 输出 bf16[120832,128]、标「下标已排序」,结果直接加进 FP32 累加器,没有跨卡求和。
📌 本课推导:整张表 120832 × 1024 × 2 字节 ≈ 2.47e8;all-to-all 的结果 32768 × 128 × 2 字节 ≈ 8.4e6(token 号另有约 1.3e5)。
📌 矩阵乘类权重两边一样:每张卡先算本卡的部分和,再跨卡加;纯数据并行用 all-reduce、FSDP 用窗口化 reduce-scatter(循环里逐跳相加),all-reduce = reduce-scatter + all-gather,后者只搬不加,所以舍入次数相同,只差先后。
| 跑法 | 每卡一次的下标数 | 运行库 0.0.46 | 运行库 0.0.52 | 曲线最差 r(0.0.46 / 0.0.52) |
|---|---|---|---|---|
| FSDP 8(基线,收齐 8 卡的 token) | 32,768 | 排序 | 排序 | — |
| 纯数据并行 8,累积 2 | 4096 | 不排序 | 不排序 | 2.62 / 2.82 |
| 纯数据并行 8,不累积 | 8192 | 不排序 | 不排序 | 3.69 / 没跑 |
| 纯数据并行 16 | 4096 | 不排序 | 不排序 | 2.65 / 没跑 |
| v7x 纯数据并行 8,不累积 | 8192 | 不排序 | 排序 | 4.06 / 0.89 |
不累积时同一个词在一张卡上加的次数翻倍,所以最差;16 卡每卡仍 4096 个,跟 8 卡差不多。v7x 在 0.0.46 上跟 v5p 一样走不排序(第 1 步词嵌入梯度 1.50e-2 对 4.25e-3;v7x 上交给 SparseCore 的是 FSDP 那一侧的 scatter)。
门槛跟着运行库走。1/8 是在运行库 0.0.46 上二分出来的。升到 0.0.52 再二分(单算子离线编译),门槛跟列宽、芯片代际都有关(§10.2 图下出处里有全表):同样 120832 行,v5p 上列数 1024 的门槛 14,420,列数 128 的降到 1,783;v7x 上列数 1024 的降到 7,181。
表的最后一行就是拿它做的预测:离线编译先看到 0.0.52 排序,再上卡核对,词嵌入梯度 R 6.90 → 1.10,曲线回到噪声内。但第 1 步另有三个多路残差输出头的小参数离 FP64 远(R 最大 25.7),原先靠多路残差小参数的单列判在噪声内;2026-11-12 单列加了倍数上限(R 5.22),这次三个 R 25.7、17.3、8.8 都超上限,整次改判「超」。偏差另有来源:输出头反向那颗融合 kernel 里的舍入,给它补上强制舍入后其中一个(输出头那组多路残差小参数之一)离 FP64 从 0.561 降到 0.059。词嵌入这一处的结论不受影响。机理还是那一条,只是门槛挪了。
别急着把它当好消息。同样的规则搬到生产宽度(词表 120832、隐藏维 6144),0.0.52 上门槛跟着列数涨:v7x 涨到 43648,v5p 到 65536 都不插(§10.2 图下门槛表)。0.0.52 上,纯数据并行每卡 4096、8192、16384 个下标两代芯片都不排序(另测了 32768 一档)。每卡下标数=序列长 × 每卡微批:序列 4096、每卡微批 1–3 时,0.0.46 上也没过门槛,两个版本都要修。微批 4(16384 个)那档反过来了:0.0.46 的门槛是 15105,会排序;升到 0.0.52 不排了,按 §8.5 的机理,会从不丢变成丢(排不排序是离线编译看到的;丢不丢是推断,还没上卡跑)。小模型上的结论能不能搬,按自己的形状再判一次。
📌 实测(第二次迁移,TPU v5p 自比,第 1 步):词嵌入梯度按行分组,每组算 ‖被测 − FP64‖ ÷ ‖FP64‖。分组按这一行的 token 在这一步全局批里一共出现几次(16 条序列,主输入与多 token 预测输入合计):只在 1 张卡上出现的 7638 行(FSDP 9.31e-3,纯数据并行 9.41e-3)、在 ≥ 2 张卡上且合计 ≤ 300 次的 3234 行(7.77e-3 / 8.31e-3)、合计 ≥ 301 次的 39 行(3.26e-3 / 1.57e-2)。
📌 高频的 39 个词,在一张卡、一个微批里加几次:每个词取出现最多的那张卡、那个微批,中位数 74 次、最多 458 次(主输入和多 token 预测输入两次 scatter 合计;只算主输入是 37、229 次)。
⚠️ 圆点个数是示意(低频画 3 个、高频画 12 个);「不排序舍 k − 1 次、排序舍 1 次」按两种写法的定义成立(第一次是加到 0 上,不舍)。「99.6%」按误差平方相减估算(本课按上表复算)。
⚠️ 低频行的误差在加进词表之前就有,推断来自上游的 BF16 计算,没有核实。
两个条件缺一个都不丢精度:一行加的次数多,而且后端没排序、每加一次舍一次。差在 TPU 纯数据并行那一侧,没有谁算错,是那次加法的组织方式让高频词多舍了几十到几百次。
修法三种:① 整次用 FP32;② 本卡用 FP32;③ 其余参数照旧,只把词嵌入表像 FSDP 那样切开,编译器就自动走排序那条路(§8.9)。三种精度同档,③ 通信、显存、步时最省,所以纯数据并行时首选只切词嵌入表;过不了排序门槛,再退回修法①。
| 修法 | 第 1 步词嵌入梯度离 FP64 | 曲线最差 r(300 步 / 1000 步) | 步时(对基线) |
|---|---|---|---|
| 不修 | 1.51e-2 | 2.62 | −3.4% |
| ① 整次 scatter 和跨卡求和都在 FP32(修好 bug 以后的代码) | 3.79e-3 | 0.98 / 1.09 | −2.8% |
| ② 本卡 FP32 加完、舍一次,再 BF16 跨卡求和 | 4.24e-3 | 0.93 / 1.07 | −2.6% |
负数是比基线快:不修时纯数据并行本来就快,修法本身多花 0.6–0.8 个百分点。1000 步的 1.09、1.07 判待定(略超),可没超过纯噪声自己能拿到的分(§3.4 的留一法),跟 GPU 重跑分不开。后来又有第三种修法:不改精度、只改切分(§8.9)。三种的精度同档(都跟 GPU 重跑分不开),第三种通信、显存、步时最省,所以纯数据并行时首选只切词嵌入表;过不了排序门槛,再退回修法①。
回头看混元 3:按专家切 8 那份离线编译核过,词嵌入表沿隐藏维切开,每卡一次收齐 32768 个下标、排了序;FSDP 8 看的是一次观测运行存下的程序,每卡 65536 个、也排了序(运行库 0.0.46)。都过了门槛,所以推断 v5p 上不受这件事影响(正式 FSDP 程序没直接读);v7x 上那次 scatter 交给 SparseCore,累加精度没测。
| 情况 | 会怎样 | 做法 |
|---|---|---|
| N 不过门槛(运行库 0.0.46 上是 V/8) | 不排序,高频词丢精度 | 首选只切词嵌入表(切开后 N 变成切分组里所有卡的 token 数;它跟 FSDP 一样要 excess precision 开着,且不能跟按数据并行切优化器状态的 ZeRO-1 同开);合起来仍不过线,用修法① |
| N 过门槛 | 后端自动排序,只舍一次(excess precision 开时;v5p 实测) | 不修也行 |
N 在纯数据并行下是本卡一个微批的 token 数;词表按隐藏维切的 FSDP 下,是切分组里所有卡一个微批的 token 数;主输入、多 token 预测输入分开算。按这条规则,FSDP 一个微批的 token 太少,也会落到不排序那一边(推断,没跑过)。门槛随运行库版本、列宽和芯片变(§8.6),表很小时也不插 —— 所以别用 V/8 硬算:对齐记录的单算子脚本带了一个 check 子命令,在训练镜像里给出词表行数、每卡列数、每卡下标数,CPU 上只编不跑就告诉你插不插排序、门槛是多少;最后以整步编译产物里那次 scatter 有没有 sort 和 indices_are_sorted=true 为准(§8.10);开了第三种修法也要按切开后的 N 再核一遍;不过线、或者拿不准运行库版本时,开修法①最稳(用修好 bug 以后的代码)。另外:两种并行编出的是两个程序,求和顺序不同,逐位相同做不到。
加的顺序照样跟 FSDP 不同,但每次加法的舍入从 2⁻⁸ 量级降到 2⁻²⁴ 量级,小了 2¹⁶ = 65536 倍。最高频的词在一张卡上加 458 次,按 FP32 每次 2⁻²⁴ 线性累加也只有约 2.7e-5,仍远小于一次 BF16 舍入的 3.9e-3(本课推导)。单算子里 FP32 scatter 离 FP64 只有 2.6e-9。
GPU 的词嵌入反向下标多了就先排序(推断),所以没这个问题;关掉省舍入让两边「更像」,反而让 FSDP 那次排好序的 scatter 多舍,更差。让两边一样,不等于让两边都对。
GPU(推断):GPU 同设置的词嵌入梯度离 FP64 4.17e-3,跟 TPU FSDP 的 4.00e-3 接近。PyTorch 在 CUDA 上的词嵌入反向,下标超过 3072 个时先排序、按段在 float 里累加,最后才转回 BF16;GPU 每卡每个微批 4096 个 token,推断走的是这条:切法跟纯数据并行一样,本卡累加却跟 TPU FSDP 排序后是同一种舍入结构。
Embedding.cu 的 embedding_dense_backward_cuda 按下标数分两条路:不超过 3072 个时,每批 32 个下标在共享内存里用 float 合并,批与批之间舍一次;超过时走排序、分段累加。读的是 PyTorch 主分支上的一个提交(链接钉在那个提交;对齐记录只链主分支、没记提交号,对齐记录未收);GPU 镜像里那个版本没有逐行核过,实际走了哪条也没有单独确认。
关掉 excess precision:§5.4 开头那个「远 26.1 倍」就出在这里。有人建议关掉它让 FSDP 和 DDP 更像(另一个 6 层测试模型上差确实回到 0 附近,但那次主要是把一条梯度累积路径改成了 FP32)。
放到这里看,这条路走不通:纯数据并行那次 scatter 本来就每次舍,开关管不着;FSDP 那次排好序的 scatter 却从只舍一次退回每次舍,而且一次要顺序加 32,768 个更新。结果 FSDP 比纯数据并行还差得多:第 1 步词嵌入梯度离 FP64 1.09e-1,300 步 r 13.3。让两边一样,不等于让两边都对:修法要看离精确值近不近,不能只看两边的差。
FSDP 那条「先传后加」不是谁手写的,是编译器在「表按隐藏维切开」这个前提下自动切出来的。那就其余参数照旧纯数据并行,只给词嵌入表加一个开关,让它沿数据并行轴、按隐藏维切开:
📌 实测(第二次迁移,TPU v5p 8 设备,纯数据并行 8 + 梯度累积 2,只多一个开关:词嵌入表的隐藏维换一个逻辑轴,沿数据并行轴切):通信路径读自训练步优化后的 HLO —— 前向 token 号 all-gather s32[8,4096,1]、取到的行 all-to-all bf16[8,1,4096,128];反向 token 号 all-gather、梯度 all-to-all bf16[1,4096,8,128],先 sort 32768 个下标,scatter 输出 bf16[120832,128]、标「下标已排序」。跟 FSDP 8 的词嵌入通信一条不差。
📌 第 1 步:205 个梯度张量里 187 个换了顺序、11 个在 GPU 尺子以内、7 个是多路残差混合小参数(照例单列),没有丢精度的;梯度范数(裁剪前)6.35963,FP64 6.35944。开关关着时编出的程序去掉元数据后与原来逐字相同,重跑逐位相同。
📌 步时(第 11 步起每步中位数):只切表 0.478 s,不修 0.477 s,golden(FSDP 8)0.494 s;显存峰值每设备 6.16e9 → 4.46e9 字节,参数与优化器状态 4.41e9 → 3.12e9(表的主权重和两份动量只存 1/8)。
⚠️ 通信少了、步时却没快,推断是原来那份整表 all-reduce 本来就和计算重叠、不在关键路径上;没有看 profile 核实。只在 v5p、缩小版、纯数据并行 8 + 累积 2 上验证过;v7x、生产尺寸、数据并行 × FSDP 混合没跑。
编译器对这一个参数生成了跟 FSDP 一条不差的通信,每张卡那次加法收 32,768 个下标、排序、带标记,只舍一次。205 个张量没有丢精度的,曲线跟 GPU 重跑分不开;词嵌入那份通信每步每设备从 9.90e8 降到 6.82e7 字节,少九成以上,步时 −3.3%(对基线)。
📌 实测:第二次迁移小尺寸,TPU v5p 自比(运行库 0.0.46),基线 FSDP 8、微批 1 × 累积 2;被测只改并行方式。GPU 同设置 8 份(尺子就是它们两两 28 对)。窗口第 2–300 步;梯度范数带符号均值的尺子 9.92e-5。
⚠️ 粗线是 50 步滑动平均,只为看方向;纵轴超出 ±2e-3 的个别点截在边上。
MaxText(混元 4 公开分支):三种修法的开关 MaxText(混元 4 公开分支):词嵌入层:表怎么切、在什么精度里加 MaxText(混元 4 公开分支):全部开关一览
前两种修法都没动纯数据并行处理这份梯度的结构:每张卡一个微批只有 4096 个 token,跨卡求和传的却是整张表,占纯数据并行全部通信的 37%(本课按 §8.10 的字节复算);8 张卡各存一整份表和它的优化器状态。所以换个思路:不改精度,只切这一张表。
| 修法 | 第 1 步离 FP64 | 曲线最差 r(300 / 1000 步) | 词嵌入通信(每步每设备,按形状算) | 步时(对基线) | 靠什么 |
|---|---|---|---|---|---|
| 不修 | 1.51e-2 | 2.62 | 9.90e8 | −3.4% | — |
| ① 全程 FP32 | 3.79e-3 | 0.98 / 1.09 | 1.06e9 | −2.8% | 修好编译器 bug 的那道屏障 |
| ② 本卡 FP32、跨卡 BF16 | 4.24e-3 | 0.93 / 1.07 | 9.90e8 | −2.6% | — |
| ③ 只切词嵌入表 | 3.97e-3 | 1.02 / 1.15 | 6.82e7 | −3.3% | 每卡那次加法过排序门槛 |
上面那些「传什么、传几次、在哪排序」,都是上卡之前离线编译看清的:在 CPU 上为目标拓扑编一遍训练步,把编译后程序里的每一次集合通信读成形状和字节、数出每步几次。
上面那些「传什么、传几次、在哪排序」,都是上卡之前就看清的:把训练步按目标拓扑在 CPU 上编一遍(不占芯片,缩小版编译 75–215 秒,连追踪整次中位数 184 秒),从编译后的程序里把每一次集合通信找出来,读成「形状 × 字节宽 × 每步次数」:
📌 做法(对齐记录所用):用训练同一套配置和同一个训练步,把设备换成目标拓扑的描述,在 CPU 上为它做完整的切分和后端编译(JAX 的提前编译);让 XLA 把训练步模块存成文本(--xla_dump_to、--xla_dump_hlo_as_text),只看切分、融合、调度都做完以后那一份(after_optimizations)。上卡后存下的程序里,集合通信与离线编的逐条一致(只差设备分组的写法;核对的是只切词嵌入表那份)。
📌 读法:五种集合通信 all-reduce、all-gather、all-to-all、collective-permute、reduce-scatter;异步版 xxx-start/xxx-done 成对,算一次,也可能包成 async-start、calls=子计算,集合通信在子计算里。认参数按形状(词嵌入 [120832,1024],切开后 [120832,128];输出头是 [1024,120832])和 metadata 里的 op_name(前向取行是 gather,反向是 scatter-add),对不上就顺着数据流看使用者。每步次数 = 从入口到它所在计算一路上各层循环次数之积,循环次数读条件计算里 compare(计数器, 常数), direction=LT 的那个常数。字节:all-reduce 算被求和的那块、all-gather 算拼好后的结果、all-to-all 算交换的那块、异步 collective-permute 只算一块缓冲。
📌 右块(取自各运行上卡时存下的训练步程序,每步次数已乘上循环次数;字节仍按形状算):词嵌入/全部每步每设备字节 —— 不修 9.90e8/2.70e9;修法① 1.06e9/2.77e9(主输入和多 token 预测输入合成一次 FP32 all-reduce,每个微批 1 次,仍在循环里;另多 6.7e7 字节的 collective-permute);修法② 9.90e8/2.70e9;FSDP 8 6.82e7/1.32e10;只切词嵌入表 6.82e7/1.78e9(39 条集合通信)。
⚠️ 线上实际传多少还取决于通信算法:例如 ring all-reduce 每设备约收发 2(n−1)/n 倍,all-to-all 约 (n−1)/n 倍(通用估算)。
--xla_dump_to=<目录> --xla_dump_hlo_as_text,在目录里找名字带训练步、结尾是 after_optimizations.txt 的那份。xxx-start/xxx-done,也可能包成通用的 async-start(…), calls=%某个子计算,真正的通信在那个子计算里。成对的算一次;异步版的结果是元组(例如 collective-permute 是「发送缓冲, 接收缓冲, 两个上下文」),只算一块缓冲,all-gather 只算输出那块。body= 或 calls= 调它,一路往上走到入口;每碰到一个 while,读它 condition= 那个计算里 compare(计数器, 常数), direction=LT 的常数(计数器从 0 起、每次加 1 时就是循环次数,梯度累积、层扫描都是这样),一路乘起来。metadata={op_name="…"},反向往表里加的那一串里带 scatter-add,前向取行带 gather;还拿不准,顺着数据流看谁用了它。这把尺子也有边界(字节按形状算这一条写在图下):
按运行库 0.0.46 的规则,门槛是 V/8 = 31250。8192 不过线,不排序,高频词每加一次舍一次,会中招。首选只切词嵌入表:8 张卡合起来 65536 个,过线,会走排序、只舍一次。40000 本来就过线,后端会自己排序(前提是 excess precision 开着)。换到 0.0.52,门槛跟列宽、芯片走,不能再用 V/8 估。所以这些都只是初判:用对齐记录脚本的 check 子命令在自己的形状、自己的运行库上判一次,再看整步编译产物里那次 scatter 有没有 sort 和「下标已排序」的标记(§8.10);拿不准就开修法①。
这一节留下的问题:两个案例查完了。第二次迁移还有一条主 loss 的尾巴,查得比这两个都久 —— 它最后是怎么查出来的?
这一节讲第二次迁移里查得最久的一件:一条主 loss 的尾巴,排除了一圈、找到了主因、补上以后还剩一截。剩下那截最后是怎么找的?节末揭晓。
第二次迁移换成现行对齐配置之前,小尺寸的主 loss 判了待定(1.55 倍):八份 TPU 全部比 GPU 高,第 50–100 步有个小鼓包,中间贴着零,第 550 步以后一路往上爬。八份同一个方向,不像噪声;同一份权重上两边前向几乎没差,所以是训练里一步步攒出来的。
📌 实测(第二次迁移,小尺寸,TPU v5p 8 设备 ↔ B200×8,1000 步,现行对齐配置之前那一代):TPU 8 份 = 开、关 base2 各 4 份(其中 6 份只改执行方式);每一份对 GPU 16 份逐步均值算相对差,画 50 步滑动平均;粗线是 8 份的平均;灰线是 GPU 16 份轮流当被测、对其余 15 份均值的相对差(同样平滑),浅灰带是它们的逐步最大绝对值。窗口值:第 2–1000 步 +4.3e-6,第 751–1000 步 +1.3e-5,MTP 同窗口 −3.2e-5。隔离实验(第 551–1000 步;对照 1 份、对 GPU 16 份均值;关 MTP、关 KD、都关各 TPU 2 份、对同配置 GPU 4 份均值):对照 +1.5e-5,关 MTP +1.2e-5,关 KD +9.0e-6,两个都关 +8.7e-6。
📌 前段鼓包:多路残差收拢成一路的地方,GPU 前向舍一次 BF16、反向传回的梯度也舍一次;TPU 省掉了梯度那次(最小复现的后端指令里核过,打包 0 条)。加一个强制舍入的开关(前向、梯度都舍),第 51–100 步回到 GPU 附近,第 751–1000 步不变;只在前向舍、梯度原样传回,鼓包又回来。
📌 同一份权重上的前向:6 个状态、19 批,TPU 减 GPU 写法 +0.83e-6 ± 1.15e-6;偏差跟步数、参数范数同步(第 501 步起相关 0.96),跟梯度范数无关。关掉 MTP、KD 后幅度约为对照的六成;是它们放大了还是样本少,对齐记录只作推断,没再单独查。
📌 后段(第 551–1000 步,对 GPU 16 份均值):修之前 4 份均值 +9.4e-6,补流梯度舍法(流的梯度逐个舍、分支输出也舍)5 份均值 +1.9e-6;把它拆成两半各跑 1 份:只补梯度累加 +0.6e-6、只补分支输出 +3.0e-6;两边都去掉多路残差,TPU 2 份 +1.9e-6、+0.7e-6。延长到 2000 步:尾部在第 1000–1250 步到顶(+2.9e-5)后回落到 GPU 两份的散布里。
⚠️ 曲线是 50 步滑动平均,只为看方向,不是判档;那一代判档按第三节的三个统计和 GPU 16 份的尺子是主 loss 1.55、1.52 待定,现行对齐配置下主 loss 过。
前面第 50–100 步那个小鼓包先破了:在多路残差(混元 4 把残差流复制成 4 路,最后再收成一路)收成一路那处照 GPU 强制舍一次,鼓包就没了;可后段一点没降。记住这个补丁,后面还会回来。
延长到 2000 步时,修之前的尾巴在第 1000–1250 步到顶(只跑了 1 份),之后回落到 GPU 的散布里 —— 它更像一段暂时的轨迹差,不是一直在长的系统偏差。
先认地方。混元 4 把残差流复制成 4 路(多路残差),下面这张地图标出三处在代码里写了「转 BF16」的地方。再记住 §5.4 那件事:「转 BF16、再转回 FP32」的一对,编译器开着省舍入时可以省掉;写成 reduce_precision(强制舍入)就省不掉。后面每补一处,用的都是它。
⭐⭐ 三处在代码里都写了「转 BF16」;GPU 都真舍了,TPU 可能被编译器省掉(接上图)
⓪ 修之前就补上了;① 和 ② 是这一段要查的两处。
前段那个小鼓包先破了。在 ② 收拢处,GPU 前向舍一次、梯度传回来也舍;TPU 省掉了梯度那次。在收拢处强制舍,第 51–100 步回到 GPU 附近;只在前向舍、梯度原样传回,鼓包又回来。可后段没降,均值反而略高(4 份,单看分不开)。记住这个补丁,它后面还会回来。
后段先排除嫌疑。关掉 MTP、关掉蒸馏,都还偏;两边都把多路残差换成普通残差,尾巴没了。嫌疑锁定在多路残差这一段:
📌 实测(第二次迁移,小尺寸,TPU v5p,1000 步):第 551–1000 步主 loss 对 GPU 均值的带符号均值。对照是一份运行(后两张图的修之前四份含它),对 GPU 16 份均值;去多路残差那组对它自己的 GPU 3 份;关 MTP、关蒸馏那三行对同配置的 GPU 4 份均值。GPU 侧索引器旋转位置编码改 FP32 也一样飘;TPU 自比里换运行库、换 v7x、换并行方式等 35 个 1000 步运行,第 751–1000 步主 loss 全部偏高。
📌 GPU 那边的写法在 CPU 上用 GPU 同一段代码逐位核过(三份 BF16 梯度按分组相加、每加一次舍一次);TPU 这几处是否被省掉是推断,没看后端指令;GPU 一边照这个推断改写就长出同样的偏(后两张图)。
⚠️ 标准答案按现在这份 GPU 参照的写法;对齐记录一度凭单边几份运行写成定案、又撤回,后来每格补到 4–5 份、两头各改一处做两样本检验才定下。
换运行库、换芯片、换并行方式,35 次长跑最后 250 步全是正的。
两头验证,定下主因:流梯度。多路残差的流在一层里被用三次,反向回来三份梯度要相加。GPU 三份梯度每加一次舍一次 BF16;TPU 推断是在 FP32 里加完才舍一次。每次差得很小,一千步攒成那截尾巴。照 GPU 的写法补上(每份先舍、按 GPU 的顺序逐个加;分支输出也舍),尾巴降下来(后段 +9.4e-6 → +1.9e-6)。
📌 实测(第二次迁移,小尺寸,TPU v5p 8 设备,1000 步):主 loss 对 GPU 16 份逐步均值的相对差,25 步滑动平均(两端各留半窗不画);灰带是 GPU 16 份每份对其余 15 份均值的相对差(同样平滑)的逐步最大绝对值,只作背景。「尾巴还在」按对齐记录的判据:第 751–1000 步均值超过 3e-6。p 是对修之前那一格的置换检验。
📌 两列都开着「多路残差分支输入和更新后的流强制舍 BF16」那个开关(修之前就开着)。修之前四份里三份只改执行方式(片上内存上限、调度),同一配置。「补流梯度舍法」再让流的几份梯度先各舍 BF16、照 GPU 的顺序逐个相加(分支输出也舍 BF16)。只补流梯度时,第 51–100 步的小鼓包还在(+5.6e-6,修之前 +3.9e-6)。
⚠️ 都是小尺寸;延长到 2000 步时,修之前的尾巴在第 1000–1250 步到顶(窗口平均 +2.9e-5,峰值约 +4.5e-5,只有 1 份)后回落到 GPU 散布里。
只补一边还不够,像医生判一种药的副作用:停药症状消失,换个人吃同样的药也长出同样的症状,两头都对上才算是它。这次两头各改一处,每格 4–5 份:
📌 实测(第二次迁移,小尺寸,TPU v5p 8 设备 ↔ B200×8,1000 步):每格 4–5 份(GPU 自己那格 16 份),第 551–1000 步主 loss 带符号均值;p 是对同一块里第一格做的置换检验(左块对修之前,右块对 GPU 自己)。
📌 GPU 那边的写法在 CPU 上用 GPU 同一段代码逐位核过;GPU 的三个诊断开关都不开时,CPU 上 191 个梯度逐位不变。GPU 只换收拢处整段写法,后段不变,可第 51–100 步冒出 +3.7e-6(p 0.001)—— 正是 TPU 不补收拢处舍入时的前段鼓包,又一处两头对上。
⚠️ 都是小尺寸、每格份数不多;这里的结论是「主因」。
TPU 改成 GPU 的写法,偏高降下来;GPU 改成 TPU 的写法,GPU 自己长出同方向的尾巴。两个方向对上,主因定在这里(两头验证,每格 4–5 份)。
图里的 p 是检验值:把这些运行随机重新分组,分出这么大差别的概率;4 份对 5 份一共只有 126 种分组,完全分开时 p 最小就是 0.016。这一节做了十几次这样的检验,没做多重比较校正,单个 p 0.02 上下只当方向性的证据。
可把前面那个补丁(收拢处,最后四路收成一路那处)也加上,就是现行对齐配置,后段还剩 +6.9e-6,跟不修那组分不开。剩下那截一张张猜太慢。回头看抓到的两处:鼓包那处在芯片指令里核过,是代码写了舍、编译器省掉了;流梯度按同一规律推断也是。两处是同一个毛病。这个毛病到底是怎么回事?
反转。把 ① 和 ② 都照 GPU 补上,就是现行的对齐配置;可后段还剩 +6.9e-6,比只补流梯度大,跟修之前分不开(p 0.32)。收拢处一开,再补流梯度就测不出作用了(逐份读数收在下面的折叠里)。
📌 实测(第二次迁移,小尺寸,TPU v5p 8 设备,1000 步):左块每格 4 份,第 551–1000 步主 loss 对 GPU 16 份逐步均值的带符号均值;三格对修之前(只开分支输入与流的强制舍入)也都分不开。「只补梯度一半」「只补分支输出一半」是把流梯度舍法拆成两半各自单开。
📌 右块:现行检查项目录、GPU 16 份两两 120 对的尺子;GPU 那 15 份是每份对基线那份的同样判档(留一法)。对齐配置 6 份没有不过,现行那份 0.98。
⚠️ 都是小尺寸、每格份数不多;「测不出作用」是这几份运行下的结论,不等于证明没有作用。
为什么?对齐记录的解释(推断):一台秤有三个毛病。甲让读数偏重,是流梯度少舍(主因,已找到);乙让读数偏轻,是收拢处那次梯度少舍;丙也偏重,还没找到。只修甲,乙和丙大致抵掉,读数看着准了;甲乙都修,丙就露出来了。乙这个毛病有点怪:在前段它把 loss 往上鼓(就是那个鼓包),在后段却往下压。
📌 实测:四格都是第 551–1000 步主 loss 对 GPU 16 份逐步均值的带符号均值,单位 1e-6;都没修 4 份、只修乙 4 份、只修甲 5 份、甲乙都修 6 份;甲乙都修对只修甲是置换检验。GPU 那一行对 GPU 16 份留一法,4 份;它只拿掉收拢处反向那一次梯度舍入,跟上面「两头各改一处」那张图里整段换收拢处写法的那格不是同一个改法。
⚠️ 推断:三个毛病、乙丙抵掉、丙在别处,是对齐记录的解释;GPU 一侧方向一致,但大小只占 5.0 的一部分。箭头只表示方向,甲乙丙各自多大没有单独测出。
按这个解释,对齐配置剩下的 +6.9e-6 主要是丙(推断)。下一步:找丙。
丙在哪?先查能一次列全的那种。丙有两种可能:两边算的东西不一样,或者算的一样、舍的位置不一样。收拢处这一段的代码已经对到只差累加顺序,上卡照旧(出处见本节末的折叠);鼓包那处在后端指令里核过,是代码写了舍、编译器省掉了;流梯度两头验证定了是原因,按同一规律推断也是被省掉。后一种有个好处,能让编译器自己交代,一次列全。先查便宜的。
先在一处上看清楚,就拿 ⓪ 来看:它在这次排查之前就补上了;把它退回没补时的写法,为 v5p 离线编译:HLO 里那对 convert 都在,可算均方那颗 kernel 的后端指令(LLO)里,把 FP32 打包成 BF16 的指令一条都没有(§8.5 也是这样数的);同一处写成强制舍入,就有 256 条。往返留在一颗 kernel 里就不舍;值写回内存交给下一颗、或直接喂给矩阵乘,才真舍:
先在一处上看:声明了,却被省掉。代码里写一对「转 BF16 再转回」,不改数学,写它只有一个意思:这里要舍。拿已补上的一处退回旧写法,离线编一遍:优化后的程序(HLO)里两条转换都在;芯片指令里真把 FP32 打包成 BF16 的,0 条;写成强制舍入,256 条(下图)。编译器看这个值马上还要接着算,往返留在一颗 kernel 里就不舍;写回内存交给下一颗,才真舍。第五节那个 32K 上的 RMSNorm scale(§5.4),就是这样被省掉的。
📌 实测:多路残差「4 路加权和 → 转 BF16 → 归一化」的最小复现(MaxText 真模块),CPU 上为 TPU v5p 离线编译(运行库 0.0.46,省舍入默认开),读优化后 HLO 与后端指令(LLO);训练步的优化后 HLO 里同一对 convert 也都在。打包指令指后端指令里把 FP32 打包成 BF16 的那一类。关掉省舍入,两种写法都真舍。收拢处那一段(另一份最小复现)两路梯度各转 BF16 的两条 convert 也是 0 条打包。
⚠️ 省不省取决于融合怎么切,同一个值可能这边舍了、那边没舍。
那整个模型里,还有多少处?把整个训练步离线编译一次(不用上卡),把写了往返、芯片指令里没舍的地方全列出来:272 处,按位置归几类(下图)。
📌 各条细分:A 分支输入的梯度合流:反向 · 几份梯度在 FP32 里相加,典型是注意力的输入;B 每个微批的权重梯度 dW:反向;C 前向几处:线性层输出 51 · 输出门 34 · 专家 13;其余(专家反向、norm):专家反向 7 · norm 输入梯度 7 · norm 输出 6;索引器掩码(0 和 −∞,转了也精确):无害。
📌 负对照:关掉省舍入再编,同类 kernel 35 颗,打包 0 条的 0 颗。三类里 LLO 能逐颗核的只有 dW;合流、前向几处跟真舍混在一颗 kernel 里,按同一规则推断。
📌 整颗只含往返的 kernel 41 颗(dW 34、norm 3、掩码 4),LLO 打包指令全是 0。
📌 实测:现行对齐配置(多路残差分支输入与流、流梯度、收拢处都照 GPU 舍)的训练步,v5p-16 离线编译。272 是 convert(f32→bf16) 在同一计算里又被转回 f32 的使用次数(同一行代码在 scan 外的层、MTP 块、前向、重算、反向里各记一次),按源码行与形状归类(经验规则);用 reduce_precision 补上、或输入本来就在 BF16 网格上的往返不计。「只含往返」= 这颗 kernel 有往返、没有真舍、没有 reduce_precision。
⚠️ 省不省取决于融合怎么切,同一个值可能这边舍了、那边没舍。小尺寸、单一配置;别的模型要重编重扫。
三根橙条 A、B、C 是先查的范围,A、B 在反向的梯度路径上,排在最前。A 跟刚抓到的流梯度是同一种手法:几份梯度在 FP32 里合流,只是换到了各层分支的输入上(典型是注意力的输入)。这些地方 TPU 少舍一次,单看这一处离精确值更近(推断,没量过);可对齐比的是像不像 GPU,GPU 在这里舍了,两边就差这一次。
两条边界:
gradient_accumulation_fusion,每个微批的 dW 先出 BF16 再加进 FP32 的累加器;开着的话,这一类就不算差别。另外只有 dW 那一类整颗 kernel 只含往返,能在 LLO 里一颗颗数;另两类跟真舍混在一起,是按同一规则推断的。收尾:上卡验证。还是两头验证那一招:GPU 上把 A、B 拆成三处照 TPU 改,看 GPU 自己长不长出尾巴;TPU 上在对齐配置之上补上,看尾巴下不下去。
📌 实测(第二次迁移,小尺寸,1000 步,每格 4 份):第 551–1000 步主 loss 的带符号均值。左块 B200×8,改了一处的格子对 GPU 16 份均值,GPU 自己那格是每份对其余 15 份,p 对 GPU 自己;右块 TPU v5p 8 设备,对 GPU 16 份均值,p 对对齐配置 6 份。「注意力输入」:q、kv 下投影和输出门三份梯度合流;「MoE 输入」:路由、共享专家、路由专家三份梯度合流;「每微批 dW」:每个微批的权重梯度。
📌 p 值(只当方向性证据,课上不讲):A · 注意力输入 p 0.021,合开就没了;A · MoE 输入 p 0.47;A · 两处一起 p 0.87;B · 每微批 dW p 0.73;+补 A · 注意力输入 p 0.67;+补 A · 两处 p 0.37。
⚠️ 判读来自对齐记录。之后又验了两批:C 前向几处在 TPU 上补(4 份,+5.5e-6,对对齐配置 p 0.42);扫描看不到的注意力内核四处在 GPU 上照 TPU 改(四处全开 +2.0e-6,复现不出 TPU 的 +6.95e-6)。都不是。剩累加顺序没查;这条线暂停,残余约 +7e-6 未定责。
都没坐实:A 两头都没对上,B 在 GPU 一头就排除了。后来 C 类前向几处在 TPU 上补了,扫描看不到的注意力内核四处在 GPU 上照 TPU 改了,也都不是;只剩累加顺序没查,这条线暂停,残余约 +7e-6 没定责。这就是清单是候选,不是结论:扫描告诉你先查哪儿,判它的只有上卡。
以后碰到这类差,别一处处猜:代码里的往返(FP32 → BF16 → FP32)不改数学,写它只有一个意思 —— 这里要舍;把整个训练步离线编译一次(不用上卡),列出写了往返、芯片指令里却没舍的地方。清单是候选,不是结论:每一类还要两头验证(GPU 照 TPU 改看长不长出差,TPU 照 GPU 补看差下不下去)才算数;它也只找得到「写了舍、被省掉」这一类。
| 对齐配置(三处都照 GPU 写法,现行) | 不开收拢处(只补到流梯度) | |
|---|---|---|
| 1000 步,第一份 | 过 8、待定 1(路由偏置均值 1.31) | 九项全过 |
| 1000 步,各份 | 6 份没有不过,3 份九项全过 | 5 份没有不过,2 份九项全过 |
| 前 300 步,第一份 | 过 8、待定 1(梯度范数 1.01) | 过 7、待定 2(主 loss 1.18、梯度范数 1.30) |
| 后段(第 551–1000 步)主 loss 偏差 | +6.9e-6(6 份),跟不修分不开 | +1.9e-6(5 份,2 份仍有尾巴) |
| 前段鼓包(第 51–100 步) | −2.8e-7,没了 | +5.6e-6,还在 |
| 备注 | — | 这几份用的是早一代 MaxText |
两边各缺一块:一个后段没修掉,一个前段鼓包还在。哪个当对齐配置,取决于更在意哪一段,课程不替它定。
收拢处加末层归一化这一段,在 CPU 上跟 GPU 逐位对照;再开一个开关让 TPU 的多 token 预测和输出头共用同一次末层归一化(GPU 本来就这样),两边就只差 FP32 累加顺序。可上卡 4 份,后段照旧(对对齐配置 p 0.40)。
代码:对齐记录 · 案例 17「后段为什么慢慢偏开」(重点在「先编译、再扫描」一节) 代码:扫描脚本 代码:整步扫描结果 代码:排查指南「扫全图找被省掉的舍入」
两关验收。噪声尺子量不出 golden 自己的偏差,所以验收分两关:第一关必须过,TPU 对修好的 golden(⑤)的一份比,尺子是 ⑤ 自己重跑 10 份、两两 45 对;第二关不判过不过,TPU 对 GPU 生产 golden 的差,写清量级、由哪个查清了的 GPU 偏差造成、证据在哪,记「已解释差异」。当基线的那份 golden 不是一开始就有的:先往精确方向改了两步(GPU 生产 golden → 只换 FP32 → 精确轨迹),查清以后发现只要在 GPU 生产 golden 上改一处,这就是修好的 golden(下文图上标 ⑤)。
📌 实测:被测是 v5p 上生产配置 1000 步(FP32 累加开关打开之前的那一版),param_norm 带符号均值对 ② 2.93e-6、对 ③ 1.25e-6(结果目录已删,对齐记录未收)、对 ④ 4.36e-7;N = 1.24e-7。开关打开后的当前配置对 ④ 是 4.27e-7(3.45 倍)。
📌 实测:③ − ② 在第 301–1000 步 loss 上是 −9.8e-5,TPU 对 ② 偏移是 −1.34e-4(当时算的占比后来作废:③ 自己也偏);第 1000 步参数范数 +1.24e-2(③ 的 dgrad 用的是 cuBLAS FP32 一次累加,本身也偏,所以这只是 BF16 那一截)。
一句大白话:GPU 当标准答案的那份,在一次 12 万长的求和里每一步都朝零少算了一点;修好的 golden ⑤ 就是只把这一处改成升 FP32、分段累加(只分段也够,步时只多 6%)。编号速查:① 框架默认;② 生产近似(整层重算+路由回放);③ ② 加输出头 dgrad 换 FP32;④ 精确轨迹(全程 FP32);⑤ ② 加输出头 dgrad 分段 FP32 累加,修好的 golden;⑥ 真精确(④ 再分段)。
每一处改动记一行,连试过没采用的也写上,免得后人再试一遍。
| 改了什么 | 上游默认 | 修好的 golden ⑤ | 方向 | 为什么 |
|---|---|---|---|---|
| 输出头 dgrad 的长求和 | BF16 张量核,沿词表一次累加 | FP32、词表按 1024 一段分段累加,结果舍回 BF16(起作用的是分段,§7.5) | GPU 向精确值、向 TPU | 唯一的数值改动:12 万长的累加偏向一边(张量核截断+吞小项),BF16 张量核和 FP32 一次累加都偏(§7.4、§7.5) |
| 重算 | 不重算 | 整层重算 + 路由回放 | GPU 向生产 | 按假设的生产配置开重算;回放让重算和首次前向逐位相同 |
| 学习率、批与梯度累积 | 余弦调度带预热;另一种批切法 | 常数学习率;每卡 2 份累加,TPU 设成一样 | 两边设成一样 | 1000 步里不让调度器成为变量;累加分组决定舍入位置 |
| 分布式优化器、通信重叠 | 开、开 | 关、关 | — | 开着时有一批运行持续偏一点(原因没查清);全量抓数也要每张卡都有完整的梯度 |
| 权重衰减 | 写 0.1,实际 0.033 | 同原始(0.033) | 两边设成同一个实际值 | §2.3 |
其余(结构参数、优化器其他超参、裁剪、TF32、注意力实现、混合精度、梯度规约精度)都跟上游相同;框架源码一行没改,全是配置和运行时的小补丁。定案前那份精确轨迹 ④ 的配置(全程 FP32、关 TF32、不融合注意力)只留作参考裁判。
表里还有一节「试过、没采用的」:交叉熵写法、注意力实现、梯度 BF16 规约、关 TF32(在 BF16 设置下)……各自的结论是「无影响」还是「有害」。
把每条运行第 1000 步的参数范数钉在一根数轴上(下图):TPU 生产那颗点和 ⑤(GPU 生产只把那次长求和升 FP32、分段累加)几乎叠在一起。GPU 生产到 ⑤ 那一截,全是 12 万长的求和带来的;⑤ 到 ⑥(真精确,只当参照)那一截两边都有,不是两边的差。
定案前那 3.45 倍又是什么?是两笔相反的偏差相抵后剩下的差额:当参照的精确轨迹 ④ 自己少漂一截,让 TPU 对它显得多漂;TPU 把流进输出头反向的梯度存成 BF16,自己也少漂一截,往回抵掉大半;剩下的差额就是 3.45 倍。
从 GPU 生产到 ⑤ 涨了 +2.07e-2:只换 FP32 先挪 +0.0124(去掉截断那条路),再分块又挪 +0.0083(去掉吞小项,推断);从 ⑤ 到 ⑥ 再涨 +6.7e-3,原因是流进输出头反向的梯度在生产程序里存成了 BF16 —— GPU 生产和 TPU 生产都舍了这一次(GPU 真精确只多舍这一次,参数范数就小了 −6.7e-3)。TPU 生产落在 +2.09e-2,⑤ 在 +2.07e-2。③ 到 ④ 缩掉的那截(§9.2 折叠里那支动画的橙块)大小跟这份共有误差差不多,很可能是同一类,TPU 生产也带着它(推断)。
📌 实测:第 1000 步参数范数对 GPU 生产 golden 5 份均值:④ +1.857e-2、⑤ +2.071e-2、TPU 生产 +2.092e-2(v5p、v7x 当前配置同值)、⑥ +2.744e-2;TPU 精确轨迹 +2.73e-2。TPU 生产对 TPU 精确少 6.3e-3,对 ⑥ 少 6.5e-3,差不到一个记录刻度。
📌 实测(v7x):第一笔 +8.697e-3(GPU 精确改分段累加 +8.55e-3);第二笔 −6.836e-3(TPU 只把 dlogits 舍成 BF16、其余全精确);第三笔由差额得出,约两个 FP32 记录刻度。v5p 那组:+7.97e-3、−6.10e-3、+4.9e-4,同样合到 +2.35e-3。GPU 真精确只多舍这一次 dlogits 少漂 6.74e-3。
早先有一版拆账把 ④ 当成了精确值,而 ④ 自己也偏,那一版作废。
为什么验收要分两关?像打靶:噪声尺子是同一把枪连打几发,看弹孔散得多开;它看不出整团弹孔偏离了靶心。golden 自己偏,就是靶心画歪了。所以第一关对着重画的靶心(⑤)判过不过,第二关写清旧靶心(生产 golden ②)歪在哪、歪多少。
📌 实测:第一关对 ⑤ 的一份、尺子 ⑤ 自己 45 对。v5p loss 全程 0.80、尾段 0.80、梯度范数 0.85、参数范数 0.50;v7x 0.82 / 0.83 / 0.85 / 0.53;EP=8 两平台也全过;学习率逐位。
📌 实测:第二关对 ②:参数范数 +2.09e-2,loss −1.37e-4(v5p);v7x −1.07e-4(直接算)。定案前的旧协议:对精确轨迹、尺子 ③ 10 对,v5p 参数范数 3.45 倍。
| 平台 · 配置 | loss 全程 | loss 尾段 | 梯度范数 | 参数范数 | 学习率 |
|---|---|---|---|---|---|
| v5p 当前对齐配置 | 0.80 ✅ | 0.80 ✅ | 0.85 ✅ | 0.50 ✅ | 逐位 ✅ |
| v7x 当前对齐配置 | 0.82 ✅ | 0.83 ✅ | 0.85 ✅ | 0.53 ✅ | 逐位 ✅ |
| v5p EP=8 | 0.76 ✅ | 0.78 ✅ | 0.74 ✅ | 0.48 ✅ | 逐位 ✅ |
| v7x EP=8 | 0.77 ✅ | 0.81 ✅ | 0.68 ✅ | 0.35 ✅ | 逐位 ✅ |
每格是三个统计里最差的 r。v5p 和 v7x 当前对齐配置,1000 步的每一项都在 GPU 自己重跑的噪声内,最差 0.85 倍;按专家切(EP=8)也过。换掉的只是一处查清了的 GPU 偏差;对原来那份生产 golden ② 的差(参数范数 +0.0209,loss −1.37e-4(v5p;这里是验收用的整层重算配置、对 GPU 生产 5 份均值,所以跟第七节对一份基线的 −1.66e-4 不一样;§9.2 折叠的 −1.34e-4 是开关打开前那一版 TPU)),在第二关写成已解释差异:全部来自 GPU 输出头 dgrad 的长求和。
基线事先定为 ⑤ 的第一份。事后把十份逐份都当一次基线、尺子不变重判:单条检查的 r 在十份基线之间最多差 0.47,四条取最差以后最多差 0.33;v5p 两个配置、v7x 按专家切十份基线全过,v7x 当前配置有 3 份基线落进待定(最差 1.11),没有不过。这正是 §3.3 说的代价:基线自己也是一个样本,能挪一个 N 以内。所以报结论时写清「对哪一份基线」。
只改执行参数的 9 份扰动运行(v5p 5、v7x 4),8 份四项都不超过 0.85 倍;剩 1 份(v7x,注意力分块 1024)梯度范数待定(MARE 1.02、最大单步 1.15),按 GPU 尺子判就是待定,不拿 TPU 自己的散布解释;它说明只改注意力分块,v7x 的梯度范数就可能落进待定(v7x 扰动组两两的逐步涨落比 GPU 重跑宽约两成,只作诊断)。按专家切那一档没测路由偏置曲线和健康信号;当前配置的路由偏置曲线和健康信号也过。
| 检查 | 为什么 |
|---|---|
| TPU 原生数据加载器与 GPU 逐样本一致(L0) | 切微批的顺序不同(§2.1);对齐时原样回放 GPU 的数据,每一步每张卡的输入指纹全部相同 |
| v7x 单算子、单层前向(L1、L2) | 按当前配置重跑后,v7x 四层前向 R 比 1.06 / 1.01 / 1.01 / 1.02(开关前 1.53–1.57),v5p 也全过;只剩第 2 层 MoE 块 R 1.27 一格:4096 个 token 里有 1 个在近平局处选了跟 FP64 不同的专家,去掉它 R 是 0.95(v5p 同层去掉 2 个这样的 token 是 0.94)。一两个 token 就能让这个比值跨线,反映的是路由翻转;路由本身另有检查,两平台都过 |
| 第 1 步整步的参数梯度、优化器状态(L3;以下是当时按两侧执行噪声的并集判的,这把尺子后来撤回,§4.3:v5p 待定 1.05–1.75 倍,第 0–2 层参数梯度不过 2.1 / 4.5 / 2.3 倍;v7x 待定 1.05–1.86 倍,第 1 层不过 3.1 倍) | 两处来源:路由近平局翻转(§4.3),每层 0.44%–0.56% 的槽位两边各落一边;另一处是 TPU 有几类参数的梯度先以 BF16 落地(下一个折叠)。v5p 第 0 层是稠密层、没有路由,那一层的不过全来自后者。比到的张量合起来 rel_L2 只差 1.28e-3,1000 步的统计在噪声内 |
| 第 1 步更新后主权重(L3,尺子只用 GPU 重跑:v5p 待定 1.63 倍,v7x 待定 1.61 倍) | 同上的下游,量级很小;对 FP64 按能量 R 0.92,TPU 的更新量反而更接近精确 |
| v7x 更新后路由偏置(L3) | 192 个专家里 1 个翻号。平均负载 2730.67 个 token;按 FP64 整步算,这个专家选中 2730 个,比均值少,偏置该加 —— v7x 跟精确算术一致,GPU 三份和 v5p 都差一个 token 落到了均值另一边。判不过是因为当时并集的 24 对噪声里没有一对翻号,尺子宽度是 0 |
| 开不开抓数,结果逐位相同(L4) | 加抓数输出会改变编译器的融合(§6.3),所以正式验收用不加钩子的构建 |
先老实交代:补跑和改口径都是看到待定以后做的,事先没有写停止规则;跑完 10 份以后没再加。所以要靠下面三条让你自己判断:N 取最大值,样本少时系统性偏窄,10 对时所有 r 都挤在 0.7–1.3、没有离群项,像尺子短而不像真差;另外两条旁证 —— 不做口径改正、10 份两两 45 对下最差 0.84,TPU 9 份扰动运行里 8 份不超过 0.85,剩下一份(只改注意力分块)按 GPU 尺子判仍是待定。
验收时为对齐打开的开关,上线那天要是原样全开,有的白白多花步时,有的还让 TPU 变得不如不开准。
📌 步时:部分和 FP32(混元 3,100 步对比)v5p +0.66%、v7x +1.9%;四路相加改依次 +0.2%(第二次迁移;对 FP64 是否更准没证实,暂归对齐专用);强制舍入 +0.1%(小尺寸 300 步单开关对比)。
⚠️ 1% 的界是对齐记录台账的分类线(B 类修 bug 或更准、代价 < 1%;C 类取舍、≥ 1%);v7x +1.9% 按这条线归「取舍」,对齐记录也写「v7x 看情况」(小模型上这个开关记作「更准且便宜」);精确除法开方的 +0.1% 是小尺寸模型上量的。另有不进这棵树的两类:按训练配方定的设置(例如路由偏置做不做零均值更新),和判法、工具、量法。
对齐时开的开关分三类看:部分和 FP32、RMSNorm 只舍一次(第二次迁移最后一层输出那两次舍入)是少舍、更准,按第三问看代价;门控激活逐个算子舍是多舍一次,属对齐专用,生产关。1% 是本课取的界,按目标规模和平台重量一次再定。
第二次迁移照同一条路走:先在保留全部结构、只缩宽度和层数的小模型上做 L0–L4 全套;再让 GPU 自己扩到多台机器、换切法,看参照守不守得住尺子;最后上真实宽度。模型的规模要一级级上,像装修一次只换一样:小模型上查出的根源不能直接外推,一下子跳到真实权重,冒出新的差又说不清是谁带来的。
结果一句话:小尺寸 1000 步九项过八项;GPU 扩机器、换切法守得住尺子;真实宽度上冒出的差,一半定到一个常数舍入(注意力里 eˣ 改用 2 为底,常数 log₂e 被舍成 BF16,叫 base2),还有一截在查。
📌 实测,第 1 步主 loss 对 CPU 上 GPU 同一套代码的 FP64 整网前向:小模型 GPU 8 份 −2.46e-6 到 +4.7e-7,TPU 关 base2 −3.68e-6(开 −2.14e-6);中等尺寸(真实宽度与注意力、随机权重)GPU +1.42e-5、TPU +2.4e-7,比 GPU 8 份第 1 步的极差(9.4e-6)还大;真实权重截前三层(真实宽度)GPU 4 份 +5.1e-5 到 +5.8e-5(条上标的是中位数 +5.3e-5;第二次迁移成绩单那张图用的是其中一份 +5.76e-5),TPU 开 base2 −9.87e-5、只关 base2 −1.24e-6。
📌 中等尺寸 300 步对 GPU 8 份两两 28 对:5 过、0 不过、4 待定(最差 1.04 N,最老一代配置的读数;现行配置最差 1.25 N,是 MTP loss,结论不变);它的 1000 步和单层、单算子两级都没做。格子只写同谁一样,不写具体尺寸。
注:中等尺寸 TPU +2.4e-7 是最老一代配置的读数,现行配置 TPU −2.67e-6,差仍在 GPU 一侧。⚠️ 「GPU 一侧的偏高跟宽度有关」是从「第二级才出现」推的;GPU 那份偏高从哪一层起还没查。
第二次迁移一开始就是从小模型直接跳到真实权重截层,第 1 步前向冒出一个小模型上没有的差,那一步同时换了尺寸、专家和权重。补上中间一级、而且两边各自对 FP64 以后,这个差拆成了两半(图下那条带):GPU 一半,TPU 一半。只看两边的差,这两半是分不开的。全套结果:
📌 Ⓐ 小尺寸(约 4.3 亿参数,保留新模型全部结构、缩宽度和层数,随机初始化)TPU v5p 8 设备 ↔ B200×8,1000 步,现行比较:对齐配置关 base2、多路残差一带的舍入照 GPU 写法,被测是事先定的第一份,尺子 GPU 16 份两两 120 对;每格是三个统计里最差的 r。主 loss 0.98(最差是平均绝对相对误差)、后段 0.97、MTP 0.81、后段 0.80、索引器蒸馏 0.75、梯度范数 0.79、参数范数 0.14、路由偏置均值 1.31、散布 0.85;同配置 6 份都判,没有不过;另一份主 loss、MTP 略超(1.14、1.07),一份梯度范数略超(1.04)。上一代(现行对齐配置之前)主 loss 1.55、后段 1.52 待定:TPU 8 份主 loss 都偏高、平均 +4.3e-6,主因后来定到流梯度的舍法(§9.1)。
📌 Ⓑ 对单机 GPU golden 的前 300 步,尺子是单机 8 份两两 28 对;8 项检查取最差倍数。2 台 DP16+EP4 跑了 8 份(最大 1.76,参数范数);多机自己的尺子在主 loss、梯度范数、参数范数上是单机的 1.0–1.3 倍;两组对单机基线的窗口带符号均值没有系统偏移(Welch |t| ≤ 1.3)。正对照:同 2 台设置、学习率大 10%,8 项里 7 项超出,最大 4149 倍。存档续跑:确定性模式下「跑 20 步」对「跑 10 步、存、续跑 10 步」,2 台 PP2+DP8+EP8 的 8760 个状态张量、真实宽度 2 台的 14512 个状态张量都逐位相同。
📌 Ⓒ 真实宽度第 0–2 层 + MTP(3.21e10 参数),GPU 2 台跑 1000 步当 golden,TPU v5p 16 片原样回放:第 1 步主 loss 对 CPU FP64 GPU(基线那份)+5.76e-5(4 份 +5.1e-5 到 +5.8e-5)、TPU −9.87e-5;注意力内核里 q 是 BF16,常数 log₂e 跟着舍成 1.4453125,logits(不含 sink)整体乘 1.0018;只关 base2 这一个开关,TPU −1.24e-6(CPU FP64 只加这个系数的移动跟实测相符)。1000 步回放九项:开 base2 过 2/待定 4/不过 3,关 base2 过 3/待定 6/不过 0。后段主 loss 偏低:同一份权重上 32 批对比,前向差不到一个标准误,后段的偏低全是轨迹差。索引器蒸馏那一项 GPU 自己偏高,约六成来自 GPU 把索引器的旋转位置编码放在 BF16 里算。所有尺寸的对齐配置因此都关了 base2。
| 图里三块 | 结论 | 还差什么 |
|---|---|---|
| 小尺寸 1000 步(2026-11-11 起关 base2、多路残差一带照 GPU 写法舍,尺子 GPU 16 份) | 九项过 8、待定 1(路由偏置均值;同配置另五份这一项都过,其中一份主 loss、MTP 略超,一份梯度范数略超,都不到 1.2);主 loss 0.98 倍,刚好过线 | 上一代 TPU 8 份主 loss 都偏高、平均约 4.3e-6:前段鼓包、后段主因都查到了(§9.1);可对齐配置的后段跟不修分不开,机制在查;第 1 步在新配置上重判,还剩 1 个小参数待定;离签字还差几件 |
| GPU 扩机器、换切法 | 守得住尺子,多机 GPU 可以当 golden | 多机重跑本身略宽(单机尺子的 1.0–1.3 倍),判多机被测要用多机自己的尺子 |
| 真实宽度三层 | 第 1 步 TPU 偏低定到 base2:常数 log₂e 跟着 BF16 的 q 舍成 1.4453125,logits 整体乘 1.0018;只关它就对上 FP64,所有尺寸的对齐配置因此都关了 base2 | GPU 第 1 步自己也偏高(对 FP64,4 份中位数 +5.3e-5),只拆清约一半;后段主 loss 偏低:同一份权重上 TPU 前向反而高 1.5e-5(第 151 步的单批读数;第 900 步 32 批平均差不到一个标准误),所以偏低是轨迹差(上一代配置);现行对齐配置 1000 步过 8、待定 1(主 loss 全程最大单步 1.07),后段已在噪声内 |
base2 在小模型上显不出来,是因为效果跟 logits 的大小成正比:随机初始化时最大 logit 只有约 0.13,真实权重截层上到 14.5。
第三次迁移换了一个起点:不从对齐好的代码出发,从生产代码原样出发,一个开关一个开关地打开,每一级跑一遍全套。这样每个开关修了什么、代价多少、上不上生产(§9.6 的三类),一级一级都记得清。其中打开投影 FP32 累加那一级,修的就是 §5.3 那件只在 8 个以上设备才有的事。它也补上一句:先缩模型、不缩设备 —— 模型宽度和层数可以从小做起,可精度验证用的设备数和切法要跟生产一样,有的差只在 8 个以上设备才长出来(§5.3)。
不能。第三级同时换了专家个数、专家宽度、层数和权重,四样拆不开。而且「过了」只是 300 步那一级:第二级第 1 步两边各自对 FP64,GPU 已经偏高 1.42e-5(比 GPU 8 份之间的极差还大)、TPU 只有 2.4e-7(最老一代配置的读数;现行配置 TPU −2.67e-6,两边的差仍在 GPU 一侧)—— 宽度一换成真的,GPU 那边就有一截偏差(还在查),只是 300 步的判定没把它显出来。要定,就再补一级只换其中一样,比如真实结构配随机权重。(TPU 那一半后来定到了「权重」那一行:真实权重的 logits 大,把 base2 常数舍入的误差放大了,§9.7。)
这一节留下的问题:验收是一次性的。模型投产以后训练代码每天都在变,怎么知道它没有悄悄改了数值?
守住数值靠回归;少走弯路,靠把走过的弯路记下来。
改完结果不逐位了,是改出了 bug,还是只换了加法顺序?第二次迁移把日常会碰到的改动一样一样量了一遍:每次只改一样东西,跟一次确认过的 TPU 运行比,尺子借 GPU 重跑(TPU 自己重跑逐位相同,量不出宽度),第 1 步再对 FP64 定责。
📌 实测(第二次迁移,小尺寸模型,TPU v5p 8 设备,FSDP 8、每设备微批 1 × 累积 2):每个改动从 golden 的命令出发只改一样,跑 300 步,对 golden 比 8 项检查(7 条曲线,主 loss 两个窗口)的三个统计;尺子是 GPU 同设置重跑的噪声上限(300 步 8 份两两 28 对,留一法最大 2.47);第 1 步 205 个梯度张量另对 CPU FP64 定责(离 FP64 比 golden 与 GPU 里远的那个还远 1.2 倍以上,记丢了精度)。
📌 分堆由对齐记录的生成器按每次实验的结果文件自动归类(共 121 种,其中 33 种另外跑到 1000 步,尺子 GPU 16 份两两 120 对、留一法最大 1.82)。真有影响的 7 件:纯数据并行(不能忍);输出头反向少舍一次(待拍板(真实的数值缺陷,第 1 步符号能反;曲线看不出));关省舍入(不能忍);关小矩阵乘改写(能忍);RMSNorm 多舍一次(运行库 0.0.46 上能忍;0.0.52 在 v5p FSDP 8 上不能忍(v7x 0.0.52 上略超、和 GPU 重跑分不开));多路残差不强制舍 BF16(能忍);上下文并行(能忍(判超是一个随求和顺序跳一倍的张量压线,按事先分类算规则误判))。
📌 量不出来的 5 种:关掉「投影照 GPU 的 FP32 累加」对齐开关(300 步 0.97,1000 步 1.64)、指数等函数回到 TPU 默认近似(300 步 0.91,1000 步 1.07)、SwiGLU 少舍一次(300 步 0.98,1000 步 1.37)、Muon 正交化改 FP32(300 步 0.98,1000 步 0.97)、索引器打分不用真 FP32(300 步 1.06,1000 步 1.06)。
⚠️ 蓝点竖着错开只为不重叠;红点一行一件,同一件的几次实验画在一行。
图上分六堆,要记的是三堆:
| 堆 | 哪些改动 | 怎么办 |
|---|---|---|
| 逐位相同 | 重跑、换机器、换集群;起名字、拆函数这类不改程序的重构 | 不用管 |
| 不逐位,跟重跑分不开 | 只换顺序:换切分、专家并行、重算策略、升运行库(0.0.46 → 0.0.48 那次;0.0.52 见 §10.2) | 只换了加法顺序 |
| 真有影响(七件) | 运行库 0.0.46 上不能忍的只有两件:纯数据并行(第八节)、关掉省舍入 | 其余五件:四件能忍、一件待定 |
换到 v7x 原先放在「跟重跑分不开」那堆,后来查出它动了精度,只是被小参数单列不判的豁免盖住了(下一个折叠)。
另外五件曲线分不开,只在第 1 步对 FP64 抓到:关小矩阵乘改写、RMSNorm 多舍一次、多路残差不强制舍 BF16、上下文并行四件能忍,各有开关;第七件是输出头反向少舍一次(换 v7x、einsum 换广播乘、跨切片数据并行都碰上,输出头 3 个小参数 R 7.5–46),2026-11-12 单列加了倍数上限才显出来,是真实的数值缺陷,忍不忍待定。
其中 RMSNorm 那件只靠一个压线张量判出来:第 0 层归一化权重 R 1.2025,GPU 参照换成六份是 1.1955,就落回线下 —— 贴着线的判定,份数一变就翻。换到 0.0.52,v5p 上 RMSNorm 多舍一次也不能忍了(§10.2)。
其中 33 个改动又跑满 1000 步、用 GPU 16 份当尺子(运行库 0.0.46),有 3 个判「超」(多路残差不强制舍 BF16,和换 v7x、einsum 换广播乘这两次的 1000 步,后两次是 2026-11-12 单列加上限以后改判的),都是同一次比较里第 1 步对 FP64 判出来的;它们的 1000 步曲线 r 0.91–1.36,仍在 GPU 纯噪声能拿的 1.82 以内。
这把尺子能抓多小?反过来故意埋 bug、扫大小:学习率偏大 1e-4 就抓得到,偏 3e-5 以下跟重跑分不开。也有尺子量不出来的:
📌 实测(第二次迁移,TPU v5p 自比,300 步对 golden,r 用 GPU 8 份两两 28 对的上限):学习率 × (1 + ε),ε = 1e-5 / 3e-5 / 1e-4 / 1e-3 / 1e-2 / 1e-1,曲线最差 r 1.21 / 1.06 / 4.11 / 46.3 / 461 / 4505,ε ≥ 3e-5 时领头的是主 loss 带符号均值(1e-5 时是路由偏置散布);ε ≥ 1e-4 时 r ≈ (4.1–4.6)e4 × ε。MTP loss 权重 × (1 + ε),ε = 1e-3 / 1e-2 / 1e-1:主 loss r 0.88 / 6.18 / 48.0,记下的 MTP loss 本身 50 / 502 / 5011。另:loss 多乘 1.01(漏除常数),梯度范数 r 94.5、主 loss 5.23(分母统一为参照后;统一前 93.9)。
📌 右块:对 golden 的 1000 步比较,尺子 GPU 1000 步 16 份两两 120 对,纯噪声(GPU 留一法)最大 1.82;五个都是「动了精度」的改动,300 步时 r 0.91–1.06。
⚠️ 「抓得到的下限在 3e-5 到 1e-4 之间」只对学习率这类全局偏差、这个模型、300 步成立。
所以两条用法:记下的每一项 loss 都逐项比,不只看总 loss;动到精度的改动,曲线分不开也要对 FP64 看一眼(多路残差那一个就是第 1 步抓到的)。折叠图里那 5 个动了精度的改动,两样都抓不到 —— 分不开只说明这把尺子量不出,不说明没影响。
上面那张图都在 TPU 运行库 0.0.46 上量的。升到 0.0.52,对齐记录把同一条路又走了一遍:先离线编译看哪些程序变了,再上卡重建基准运行、把当时的六件逐件重测(第七件后来才显出,没在这批里),每件对同版本的基准比:
📌 实测(第二次迁移,小尺寸,TPU v5p 8 设备,FSDP 8;JAX 0.11.1 不变、只换运行库,这不是官方配套的组合,换官方组合要重测):新基准换一组机器重跑逐位相同;新基准对旧基准 300 / 1000 步 0.99 / 0.96,步时 -5.5%。当时的六件(第七件是 11-12 才显出的)各按基准的命令只改那一样,对同版本的基准比 8 项检查的三个统计(上下文并行对同版本的普通注意力底),尺子 GPU 同设置重跑 8 份(留一法最大 2.47)。
📌 第 1 步:纯数据并行词嵌入梯度 R 3.62 → 3.60,关省舍入 26.13 → 26.11,两个版本几乎一样;RMSNorm 多舍一次第 0 层归一化权重的 R 1.20 → 1.17(第 1 步看不出,偏差是跑起来以后攒的),前 300 步主 loss 对基准的带符号均值 1.3e-6 → 1.65e-5,换一组机器重跑逐位相同。三种修法 0.0.52 上(300 / 1000 步):① 1.55 / 0.92;② 1.20 / 1.28;③ 1.23 / 0.97,都跟 GPU 重跑分不开。
整张表按 FP32 放得进片上内存的小表(1000 × 1024;v5p 上的 30000 × 128)两个版本都不插。v7x 上部分形状走另一条执行路径(HLO 可见),另算;表里 v7x 只列 1024 以上的列宽。最后一行是生产宽度(隐藏维 6144),0.0.52 上 v5p 查到 65536 都不插。
⚠️ RMSNorm 那件为什么变强,对齐记录已查清,机理在本节折叠里。上下文并行那件降到 0.95,只能说这次没超。
所以换版本不能当成「只换了加法顺序」:JAX 交出的是同一份程序,编译器优化后的程序和后端的代码生成都一起换了。
把 RMSNorm 单次舍入的开关开着,这件就没事(§10.3 清单④):换版本时,「开关开着没事」比「这件以前能忍」可靠。
门槛那一处是先离线预测、再上卡核对的:
📌 门槛表(单算子离线编译二分出的最小插排序下标数):表 120,832 × 1024 —— v5p 0.0.46 15,105、0.0.52 14,420,v7x 0.0.46 15,105、0.0.52 7,181;120,832 × 128 —— v5p 15,105 → 1,783;480,000 × 128 —— v5p 60,001 → 7,132;生产宽度 120,832 × 6144 —— v7x 0.0.52 43,648,v5p 0.0.52 查到 65,536 都不插。0.0.46 上都是行数 ÷ 8 + 1,0.0.52 上随列宽和芯片变。
📌 门槛的测法:单算子离线编译(CPU 上为目标芯片编译,看优化后 HLO 里有没有 sort),单设备、BF16 表,二分最小插排序的下标数,查到 65536。📌 Ⓑ 上卡:v7x 4 颗芯片(8 个设备),各对同版本的 FSDP 8 比:r 4.06 → 0.89,词嵌入梯度离 FP64 2.93e-02 → 4.63e-03,R 6.90 → 1.10。
逐步看,RMSNorm 那件在 0.0.52 上是真的「一直偏高」,不是一两步的尖峰:
📌 实测(第二次迁移,小尺寸,TPU v5p 8 设备,FSDP 8,每个改动对同版本的基准运行):0.0.52 第 2–300 步平均 +1.7e-5、第 2–1000 步 +1.7e-5;0.0.46 第 2–300 步 +1.3e-6;0.0.52 只让最后一层舍两次第 2–300 步 +2.1e-5。灰带:GPU 同设置 16 份两两 120 对,每一步取最大 |dₜ|,再 5 步平滑。
⚠️ 每条线都是单份运行;0.0.46 那条只跑了 300 步,末 100 步平均 +5.4e-6,更长没有数据。灰带只用来看单步幅度,判档仍按窗口统计量对尺子。
一句话:0.0.52 挡住了一次融合,两次舍入都真舍了,而第二次的输入已经在格点上,结果系统偏小。
RMSNorm 那件为什么变强(v5p、FSDP 8 上查清):默认写法是先把归一化值舍成 BF16、乘 γ 再舍一次。运行库 0.0.46 上,最后一层的这一段融在一颗 kernel 里,中间那次被省掉,实际只舍一次;0.0.52 在定内存布局时给归一化值插了一次布局转换,挡住了融合,两次舍入都真发生了:
📌 实测(第二次迁移,小尺寸,TPU v5p 8 设备,FSDP 8):整步优化后的程序里,「融合出口就是归一化值转 BF16」的融合只在 0.0.52 默认写法里有 1 处(最后一层);0.0.46、0.0.52 只把最后一层改回一次、v7x 0.0.52 都是 0 处。v7x 0.0.52 默认写法没有单独写回,300 步 1.22(跟 GPU 重跑分不开)。
📌 同一份权重(0.0.52 基准第 300 步更新后)各算 16 批前向:默认写法 − 单次舍入 +3.23e-5;0.0.46 上同样的比较 16 批平均 −8e-11、单批都在 ±1.1e-7 内。CPU FP64 模拟第 301 步这一批 +3.17e-5(TPU 同一批 +3.13e-5),第 1 步 +2.5e-7(在误差内)。把两次舍入的变化拆成「沿输出方向的整体缩放」和其余部分,整体缩放解释了全部增量的 100.3%。
📌 Ⓑ 是推导配实测:FP64 里 400 万个标准正态数,单个 γ,先舍 BF16 再乘 γ 再舍,对比一次舍入,|h| 平均的相对变化。
⚠️ 为什么只有最后一层要紧是推断:它的输出直接进输出头;层内的输出还要过投影、加回残差、再归一化,整体缩放被冲淡,没有单独量。
两次舍入本该是随机误差,可第二次舍入的输入已经在 BF16 格点上,乘一个贴近 1 的 γ 再舍,往哪边落由 γ 决定,于是输出头的输入被整体缩小。模型学会预测以后,这一点缩小就把预测压平、抬高 loss。所以换版本时,「开关开着没事」比「这件以前能忍」可靠得多。
不能。基准运行只说明「这一个配置」换版本跟重跑分不开;别的改动走的 kernel 可能变了。0.0.46 → 0.0.52 就是例子:基准 0.99,可 RMSNorm 多舍一次从 1.06 变成 5.50。要把已知的几件在新版本上重测,或者干脆把相应的开关都开着(RMSNorm 单次舍入)。
第一步:改完先比程序指纹(编译后的整份程序去掉元数据、名字重新编号以后的哈希)。像门禁按工牌放行:今天的程序跟上次登记的一字不差(同一运行库、镜像、芯片上),结果就一定逐位相同,回归直接过;不一样,再跑 300 步看档。对齐记录把它做成了跑前离线筛,拿已经上过卡的改动回测过:
📌 实测(对齐记录「跑前离线筛:回测」):109 个改动,判程序相同 23、不同 72、判不了 14;能判的 95 个跟 TPU 实际全部相符。共编 95 份规格,每份整次 114–265 s(中位数 184 s),单进程峰值内存 13.2–16.9 GiB。
📌 判不了的 14 个:SparseCore 相关开关(图里写 SC 开关)6、换运行库 5、换芯片代际 3。「程序相同」的规则:取编译器优化后的训练步程序,去掉元数据与源码位置、名字按出现顺序重编号、设备分组展开、子计算参数按编号排前,再逐字比;CPU 上编的跟 TPU 上实际存下的规范化后一字不差。
代码:跑前离线筛 代码:用法与规范化规则(「跑前离线筛」一节)
指纹加上噪声尺子和 FP64,还抓到过一个编译器的真 bug:数据并行 + 梯度累积 + 词嵌入梯度 FP32 累加三样同时成立时,编译器把跨卡求和挪出累积循环,又在循环里把 1–7 号卡的累加器清零,第一个微批的梯度没了、只剩第二个(r 611,第八节撞上的就是它)。
📌 实测(第二次迁移,TPU v5p 自比):指纹 = 训练步优化后程序去掉元数据和源码位置表后的哈希。起名字(重算名)、拆辅助函数、mean 换 sum/n,程序相同、结果逐位;乘法换序、除以 n 换乘 1/n、换梯度裁剪写法、多记一个逐头监控量、reduce-scatter 交给 SparseCore,程序不同、结果仍逐位(按各臂结果文件里的程序比对);x·x 代替 lax.square、einsum 换广播乘,程序不同、结果不逐位,300 步 r 1.09 / 1.10(x/sqrt 代替 x·rsqrt 同理,0.98)。
📌 bug:纯数据并行 8、每设备微批 1 × 累积 2、词嵌入梯度 FP32 累加三样同时成立。编译后的循环体里有一条 select(卡号, 0, 累加器),这份 FP32 梯度只有 1 次跨卡求和(BF16 版每个微批一次,共 2 次)。第 1 步词嵌入梯度范数是正确值的 0.51 倍,正确值里有梯度的 10911 行中 2829 行整行为零,离 FP64 远 130 倍;raw 梯度范数 6.19(正确 6.36)。修法:三者同时成立时每个微批的梯度累加前加 optimization_barrier;修后纯数据并行 + FP32 累加词嵌入梯度离 FP64 3.79e-3、梯度范数 6.3596(FP64 6.3594)、300 步 r 0.98;golden 用修后代码重跑逐位相同、程序相同。
⚠️ 卡数画 8、微批画 2 是这次的实际设置;「求和挪到循环外、循环里清零」是从编译后程序读出来的。
修法只在那三样同时成立时生效;golden 用修后的代码重跑逐位不变、程序指纹也不变 —— 修 bug 的改动自己先过了「数学不变」那一行。
指纹变了,再按下面这张流程分流:
📌 实测(v5p,8 颗芯片):20 步那档一次约 10 分钟(提交到取回);1000 步那档约 25 分钟。首个 LKG 同一提交双跑逐位;「数学不变」复测逐位通过,故意改一个开关被拦下。
📌 首次标定在 FP32 累加开关打开之前的配置上做;开关打开后,上一次全过的运行同一提交双跑逐位、负责人批准后重建,7 个扰动臂在新配置下重跑全过,TPU 28 对重新标定(正式)。扰动臂要过三项检查:臂自己重跑逐位;配置、版本、编译出的程序除了改的那一处都不变;1000 步 loss 对基线不超过 GPU 自噪声的上限,第 1 步梯度离 FP64 不比基线远(这一关后来补做了 6 个臂,R:v5p 1.001–1.008、v7x 1.003–1.039,全过;其中 5 个在参照的 7 个臂里,另 1 个不在,参照里有 2 个臂这一关没补)。标定绑死平台、档位、训练配置、镜像和依赖版本,任何一样变了就重标。
| PR 声明 | 什么时候用 | 回归怎么判 |
|---|---|---|
| 数学不变 | 重构、加日志、预期逐位不变的性能改动 | 全部逐位;不逐位就退回。没写声明的按这一条 |
| 会改数值 | 改精度、算法、默认配置、并行或重算设置;会改变融合、分块的性能改动 | 写明是执行级(只改舍入位置)还是数学级(公式、精度、算法变了):执行级用 TPU 执行噪声判,数学级对修好的 golden 判(细节见表下折叠) |
| 升级依赖 | 框架、编译器、kernel 库、镜像、编译开关 | 先要求逐位;不逐位按执行级判,并做归因。换运行库这类连后端一起换的,还要在新版本上建基准、把已知会动精度的几件重测(§10.2) |
写明是执行级(只改舍入位置,比如融合、分块变了)还是数学级(公式、精度、算法变了),以及会影响哪些检查;执行级用 TPU 执行噪声判,数学级对修好的 golden ⑤(GPU 生产+分段累加)不能变差:基线是验收事先定下的那一份,尺子是它自己 10 份两两 45 对。这道门原先挂在起点那份 GPU golden(§9.2 的①)上,是两关验收定下来之前设的,2026-11-15 换成了 ⑤;本课没有引用过按旧那份算出的数学级读数,所以没有要重算的数。自己搭回归时,也对验收用的那份基线判。
回归失败了,先补跑一次上次通过的那个提交:它也不逐位,变的是环境(镜像、硬件);它逐位,再在两次提交之间二分。
PyTorch 自己的文档就写明,不保证跨版本、跨提交、跨平台的结果完全可复现。所以噪声标定和上一次全过的运行都要绑死版本。
📌 每站的细节:① 数据原样回放、权重逐张量逐位、按实际生效的权重衰减;② 同设置 GPU 跑 10 份,偏移超出噪声尺子,是真偏差;③ 参数范数多涨的那截拆到组、拆到行;④ 两边都去掉「所有 logits 一起升降」那股力;⑤ 拿训练里的真张量对 FP64 拆输出头反向,TPU 第 1 步 −2.4e-5;⑥ ② 生产近似 → ③ dgrad 换 FP32 → ④ 精确轨迹;⑦ 边传边乘的部分和不再在 BF16 里累加,对 ④ 3.52 → 3.45 倍;⑧ 只修那一次长求和,10 对时几项 1.02–1.24 倍待定,补到 45 对。
📌 走错的四步:「FP32 dgrad」偏 8.08e-4,比 BF16 的 6.51e-4 还大,一度判成换 dgrad 也不动;TPU 那份 FP32 参照里路由专家其实按 BF16 算,翻转是它的下游,撤回;精确轨迹只看一对扰动,像是比借来的尺子窄 18 倍,五份 10 对一量同一量级;FP32 一次累加 12 万也偏,④ 自己少漂 +8.70e-3,分段累加后两边精确轨迹重合。
📌 最终方案里改数值的主要是两处:TPU 的部分和留 FP32、GPU golden 的分段累加;其余几步都是把量法和参照弄对。各数都在出处台账里。
归成前面一路埋下的三条暗线:每个结论先问拿什么比;名字对了不等于生效,读回值、工具输出都要实测核对;先排除自己(包括当参照的那一份),再怀疑硬件。第二次迁移的坑也都落在这三条里(下方坑表里标了出处的几行)。
| 坑 | 长什么样 | 判据 |
|---|---|---|
| TF32 没关干净 | 「FP32」参照比 BF16 还偏,一度判反了 dgrad 的结论 | 开关读回值不算数,启动实测 |
| 精确参照自己不精确 | 全程 FP32 的精确轨迹,12 万长的求和用 FP32 一次累加,积上千步也偏;拿它当基线,TPU 的判定是两笔相反偏差相减 | 参照里每一处长求和单独查:改成分段累加对一遍 |
| 量错了张量 | TPU 那份 FP32 参照,路由专家一段实际是 BF16(据此一度认为全程 FP32 下两边路由也会翻、两边实现不同,后来撤回);「舍成 BF16 的参照」被编译器删掉了舍入;拿 FP32 主权重当参照,量出一个假的 1.5% 差 | 参照先对 FP64 核一遍,再拿来量别人 |
| 钩子改了编译 | TPU 上加了抓数输出的程序和生产程序不逐位 | 证据从程序外面拿(§6) |
| 尺子太短 | 只有 10 对时几项落在 1.02–1.24 倍,补到 10 份两两 45 对全过;只用 3 份 GPU 运行,带符号均值的噪声上限只有一半大;精确轨迹只看一对扰动,散布像是小 18 倍,凑齐五份再量就不小了 | 参照凑到 15 对以上;尺子要量真实的执行噪声 |
| 尺子看不见的差 | 第 1 步 GPU 重跑路由一个不翻,尺子对路由翻转宽度是 0;以为 TPU 只改执行参数也不翻,其实会(同一个专家的梯度,TPU 只改片上内存上限差 0.080,TPU 对 GPU 0.105) | 先问这把尺子能不能看见这种差;看不见就对 FP64 定责,别拿被测自己的波动去撑宽尺子。第二次迁移在多步那一级并过一次又撤回:同一批运行只用 GPU 的尺子重判,梯度范数三次比较 r 1.77 → 2.08、1.75 → 2.69、1.68 → 2.75,待定全转不过;后来一组改动(大半是修边界,§5.5)把它收回到待定(r 1.34),现行配置 1000 步对 16 份尺子 0.79,过;没有一处是靠尺子 |
| 测量口径撑大了 r | TPU 的参数范数自己就测得粗(单步误差占尺子一半以上);梯度范数的带符号均值以 golden 当分母,交换两边不只差一个符号 | 被测和尺子用同样精度的量法;统计量要对两边对称。第二次迁移又碰上一次:TPU 的参数范数整棵树在 FP32 里一路相加,对精确值偏低 1e-7 至 3e-7,正好是要判的偏差那么大;两边改比精确值(每 128 个元素一段 FP32 平方和、FP64 合成)以后,第 1 步只差 1.6e-9 |
| 切法也是数值的一部分 | 只换梯度累积的切分,词嵌入梯度差到噪声的 31 倍;只换专家并行度,反向就不逐位 | golden 和噪声参照固定同一种切分 |
| 参照没载入权重 | 转换往返逐位全过,可 GPU 训练入口没设载入路径,按初始化随机建了权重,第一轮 golden 整轮作废(同期另一个模型) | 训练入口在第 1 步之前逐参数对检查点自检,不过就退出 |
| 参照自己写的代码 | 不融合的注意力把 q·k 先存成 BF16 再进 softmax;生产的融合内核和 TPU 都留 FP32(§5.5) | 参照的代码也按五格表查一遍 |
| 名字一样、写法不一样 | 优化器、重算、路由偏置更新、梯度累积里的「取最大」四处(§2.3 折叠) | 对照表逐行对写法;参照里找不到实现的,协议写了也不算 |
| 测量工具自己错了 | 单算子回放 R 1.56 → 0.95:注入漏了按关键字传的输入(§6.2) | 回放先自检:同一输入单独喂一次对 FP64;注入换不了就报错 |
| 算法的前提被新结构打破 | 一种按注意力最大 logit 缩放 q、k 权重的稳定化办法(QK-Clip),缩放 η = min(1, τ ÷ 最大 logit)。有一个头把注意力全放在一个额外的空位上,q·k 全为负,最大 logit 为负(GPU 记下 −0.4956,TPU 同样为负):τ = 100 时 η = −201.8,再开根号就是 NaN(第二次迁移;参照框架的写法也有同样的隐患,只是还没碰上) | 每个公式先问前提(这里是「最大 logit 为正」);不满足时取安全值(η = 1),并加单测 |
| 更精确,不等于更一致 | 编译器省掉一次 GPU 必做的舍入,loss 同号偏高(§5.4);sigmoid 单算子跟 GPU 一样准了,整网反而偏得多(§5.5) | 舍入点照 GPU 写死;「更准」的改动也要整网再验,没查清前不下结论 |
| 在小切片上验精度 | 4 个设备上编译器不拆矩阵乘,8 个设备上拆,往里投的投影一次求和多舍 5 次(§5.3,第三次迁移) | 在生产的设备数上编;至少离线编一份数窗口化循环 |
| 裁判工具和生产编得不一样 | 单算子回放把训练步里(推断)不拆的几个投影也拆了,量到的多舍在生产里很可能不存在(§5.3) | 用工具前先拿编译产物对一遍写法 |
| 拿第 1 步判权重侧的开关 | 输出头精度档、RMSNorm 的 scale 舍入:第 1 步权重还在 BF16 格点上,差小得看不出,要几步到几十步以后才显(§5.4、§5.5,第三次迁移) | 权重侧、优化器侧的开关在曲线上判;或者拿训练几步后的权重单独回放 |
| 「这个开关没效果」只对测它的那份配置成立 | RMSNorm 的 scale 舍入在 4K 程序里没效果(舍入本来就在),到 32K 程序里被编译器删了,成了漂移主因;我们先以为是切法,离线编译对照查出是有没有梯度累积循环(§5.4) | 记结论时写明配置(设备数、梯度累积、切法、规模);换了就重验 |
| 拿编译产物判断哪里慢 | 32K 每步 58 秒,编译产物里只有一个开关多出 120 个循环,就把慢归给了它;逐个实测,慢的是另一个开关(只开它 57.8 秒,只开前者 1.85 秒) | 编译产物看得出改了什么,看不出哪里慢;慢在哪,逐个开关量步时 |
| 参照自己写的层吞掉了掩码 | GPU 参照自写的多路残差层没把填充掩码交给 MoE,有填充的图文行上路由权重的梯度差 25%(第三次迁移;纯文本运行没有填充,不受影响) | 参照里自己写的层,逐个输入对生产的签名 |
| 把单格 r 的升降当成开关效果 | 逐个加开关时主 loss、MTP、梯度范数在 0.9–1.2 倍之间来回(参数范数 0.9–1.9),TPU 只改执行方式也是这个量级(第三次迁移) | 判「有效」要另有证据:单算子降下来,或曲线形状变了 |
| 只信配置文件 | 权重衰减写 0.1,实际 0.033 | 对照表写运行时读出的实际值 |
| 把工具和结论混在一起 | 通用文档里夹着某个模型的数字,换模型时没人敢删 | 工具目录只放方法 |
TPU 没算错。TPU 的 loss 低约 1.7e-4,按噪声尺子是真偏差;查到最后,大头偏在 GPU 的 golden:一次 12 万长的求和,每一步都朝零少算了一点。改成分块累加、拿它当基线,v5p、v7x 每一项都在噪声内(最差 0.85 倍)。第二个案例里,两种数学等价的并行对不上,查到最后是一次加法的组织方式。
这一节留给要在自己的模型上做一次对齐的人。前四个折叠按用的顺序排;后面是延伸阅读和出处台账。
判定那一步的骨架(伪代码,本课推导):
STATS = ["signed_mean", "mare", "max_step"]
CHECKS = {"loss": ["all", "tail"], "grad_norm": ["all"], "param_norm": ["all"]} # 本例的检查项和各自的窗口
WINDOWS = {"all": (2, T), "tail": (t0, T)} # 训练步号,含两端;t0:事先写定的尾段起点
def d(test, base): # 每一步的相对差,d[0] 是第 1 步
return [(t - b) / abs(b) for t, b in zip(test, base)]
def sel(dt, w):
return [dt[t - 1] for t in range(w[0], w[1] + 1)]
def stats(x): # 一个窗口里的三个统计
return {"signed_mean": abs(mean(x)), "mare": mean(abs(v) for v in x), "max_step": max(abs(v) for v in x)}
verdict = {}
for c, wins in CHECKS.items(): # 每个检查项、每个窗口各出一个判定
for wn in wins:
w = WINDOWS[wn]
N = {k: max(stats(sel(d(a[c], b[c]), w))[k] for a, b in pairs(gpu_runs)) for k in STATS}
r = {k: stats(sel(d(tpu[c], base[c]), w))[k] / N[k] for k in STATS} # N 为 0 时不能除,见排查表
worst = max(r.values()) # 三个统计里最差的决定这一项
verdict[(c, wn)] = "过" if worst <= 1 else ("待定" if worst <= 2 else "不过")
# 单算子定责:R = rel_l2(tpu, fp64) / rel_l2(gpu, fp64);≤ 1.2 算两边一样远
本例的尺子最后补到 10 份两两 45 对;只有 10 对时有两项落在待定区(§9.5)。
| 量 | 怎么算 | 门槛 / 读法 |
|---|---|---|
| dₜ | (被测 − 基线)÷ |基线|,同一步 | 只是原料;首步单独报 |
| 带符号均值 / MARE / 最大单步 | 窗口内 dₜ 的平均 / |dₜ| 的平均 / 最大 |dₜ| | 窗口:全程从第 2 步起;尾段从两条轨迹分开、偏移稳定以后起(本例第 301–1000 步);三个都判,最差的决定 |
| N(噪声上限) | 同设置 GPU 两两配对,同口径算,取绝对值的最大 | 纯噪声超过 n 对最大值的概率约 1/(n+1) 起(带符号均值约翻倍,以留一法实测为准);正式签字 ≥ 15 对;1000 步这样的长窗口用 16 份、120 对(份数少会低估噪声) |
| r | |被测| ÷ N | ≤ 1 过;1–2 待定;> 2 不过 |
| 哪一级用哪把尺子 | L0 地基;L1/L2 单算子、单层;L3/L4 整网第 1 步、多步 | L0 逐位;L1/L2 前向(GPU 重跑噪声为 0)用 R 比定责;L2 逐层反向也用 R 比(本例 GPU 重跑反向逐位、量不到路由翻转);L3 整网第 1 步对 GPU 第 1 步重跑的噪声,超出的、尺子看不见的(路由翻转、舍入位置不同)对 FP64 定责 —— 尺子只来自参照(混元 3 曾并入 TPU 扰动,后来撤回,§4.3);L4 多步用 GPU 噪声尺子 |
| rel_L2 | ‖被测 − 参照‖ ÷ ‖参照‖(整个张量拉直) | 张量主判;长度相同时 cos 0.999 ≈ rel_L2 4.5% |
| cos / 范数比 | 方向 / 长度之比 | cos 看不见整体缩放;范数比 2.000 = 漏除了一个 2 |
| R(对真值的距离比) | TPU 到 FP64 的 rel_L2 ÷ GPU 到 FP64 的 rel_L2 | ≈ 1 一样远;> 1.2 查 TPU;≈ 1.41 像多舍了一次;< 1 GPU 更远 |
| ULP | 按原始格式数差了几格 | 只诊断,不当门槛 |
| L0 | 数据、权重、配置、续训 | 必须逐位 |
| 症状 | 多半是 | 先查 |
|---|---|---|
| 第 1 步 loss 相对差明显大过前向舍入的量级(本例 2.5e-6) | 地基没铺平:数据、权重、配置 | 数据指纹、权重逐字节、配置的实际生效值 |
| 第 1 步对上,第 2 步起的差明显大于 GPU 重跑第 2 步的差 | FP32 主权重有小于 BF16 半格的错 | 加载后从设备读回、跟 GPU 第 0 步逐位比主权重 |
| 差从第 1 步起就稳定在一个常数 | 口径:loss 分母、步号错位 | 故意错开一步再比;核对 loss 归一化 |
| 梯度 cos ≈ 1、范数比是整数倍 | 漏除了微批数或卡数 | 梯度累积和规约里的除法 |
| 某个专家梯度大得离谱,GPU 重跑却一位不差 | 路由近平局翻转 | 路由槽位;给路由器喂相同输入再比 |
| 单层 R > 1.2 | TPU 多舍了一次(例如 FSDP 下部分积在 BF16 里累加) | 累加器精度、collective matmul、excess precision |
| 名义 FP32 的参照比 BF16 还偏 | TF32 没关干净 | 启动时实测 FP32 矩阵乘对 FP64;打印环境变量 |
| 加了抓数的程序和生产程序不逐位 | 钩子切开了融合 | 改用步间读状态、隔离回放、探针 |
| 第 1 步逐张量梯度普遍是 GPU 噪声的 2–3 倍,没有哪一处突出 | 好几处舍入位置跟 GPU 不同 | 五格表逐个算子对(§5.5);超线的对 FP64 定责 |
| 一个小标量一直超线,它的输入和梯度都没事 | f32 里的病态在放大一格 | 用大数的格量差;同样的计算换 CPU(PyTorch)算,看那一格是谁的(§5.5 折叠) |
| 含 exp、log、sigmoid 的量,TPU 系统偏一边 | TPU 默认的超越函数精度低、而且有偏 | 逐函数对 FP64 数格;换高精度写法后整网再验(§5.5) |
| 长跑 loss 次次同号偏一点,只改执行参数也一样 | 编译器省掉了一次 GPU 一定会做的舍入 | 在那一处显式「舍到 BF16」做 A/B(§5.4) |
| jit 下结果错得远超舍入量级(比如相对误差 0.47),一步一步执行却是对的 | 编译器 bug,不是精度问题(对齐记录里的实例:一次多输出融合在 v5p 上把一个输出算丢了,运行库 0.0.46–0.0.52 都有,上游 11-06 起的 nightly 不再这样合并) | 先关掉 jit 一步一步执行,跟 jit 比;再把每道编译工序之后的程序导出来、在 CPU 上执行(那一次每一步都对,说明错在程序翻成 TPU 指令那一步),再比相邻工序找出是哪次融合;绕开的办法是关掉那种融合,或在出事的读取前加 optimization_barrier |
| 已经定位到一处「编译器省掉的舍入」,想知道同类的还有几处 | 代码里写了 FP32 → BF16 → FP32 往返、编译器在融合里省掉的地方不止一处 | 离线编译整个训练步,扫同一颗融合里的往返 convert,只含往返的 kernel 数 LLO 打包指令;每类对照 GPU 代码,再上卡验证(§9.1) |
| 训练突然出 NaN,只在某一层、某个开关打开时 | 公式的前提被打破(负数开根号、除以零) | 逐层定位;查公式的前提(§10.4) |
| 单算子回放 R 大,同一输入单独喂这个算子却没事 | 回放没把输入全换掉,算子吃的是本侧上游的输入 | 注入覆盖关键字参数;换不了就报错(§6.2) |
| loss 慢慢偏、参数范数一起漂 | 每一步更新里有一个固定方向的小差 | 按组、按行拆参数范数;看哪些行梯度小到失去 Adam 的归一化保护(√v̂ 跟 ε 比);状态互换 |
| TPU 的 loss 更低、参数范数更大,单步上 TPU 反而离 FP64 更近 | golden 自己偏了,比如大词表 dgrad 的长求和朝零少算 | FP32 dgrad 的 A/B;状态互换;在 GPU 上跑精确轨迹(长求和分段累加) |
| TPU 对精确轨迹还差一截,可同状态单步看不出 | 精确参照里的长求和自己有偏,或 TPU 某处多舍了一次,两笔可能相抵 | 把参照的长求和改成分段累加再比;TPU 一侧从精确一处一处降回生产精度 |
| GPU 重跑逐位相同,N = 0 | 开着确定性设置;或这一级(第 1 步前向、单算子)本来就没有噪声 | 整网多步改用生产配置的重跑当尺子;单算子、单层用 FP64 的 R 比 |
| TPU 自己重跑也不逐位 | 环境变了(镜像、依赖、硬件),或程序里有非确定的算子 | 补跑上次通过的提交;对比依赖版本 |
| 只有最大单步超线 | 某一步突然跳了一下 | 看那一步的数据单元和梯度范数 |
| 第一关判待定 | 参照太少,或差就在噪声边上 | 补参照到 15 对以上重判;还在 1–2 倍就往下一级定责 |
| 超出噪声尺子,但绝对差很小 | 不是噪声;小不等于没事 | 定责:是谁的差,再决定写成已解释差异还是修 |
| 纯数据并行和 FSDP 对不上,第 1 步只有词嵌入梯度远 | 高频词在本卡 BF16 里一次次地加、后端没排序(每卡一次的下标数没过表行数 1/8) | 首选只把词嵌入表沿数据并行轴切开,过不了门槛再改 FP32 累加;按行分组看高频行;看编译产物里那次 scatter 有没有排序(门槛随运行库变,0.0.46 上是行数 ÷ 8;§8.6、§8.9) |
| 不同配置之间偏移不一致 | 并行切法、重算、批大小切法也是数值的一部分 | 参照和被测固定同一切法、同一设置 |
| 结论 | 材料与测量条件 |
|---|---|
| BF16 里 1 + 2⁻⁸ + 2⁻⁸ 换个顺序差一格 | 本课推导,图脚本里按就近舍入、平局取偶真算 |
| 10 次 GPU 重跑:尾段 loss 带符号均值 −2.5e-5 ± 2.7e-5;TPU −1.03e-4 到 −1.66e-4 | B200×8 默认设置、关分布式优化器,10 份;TPU v5p(8 颗芯片) 三种跑法,各 1000 步,对第一份 GPU |
| 数据:前 30 步 1,950 项指纹对 GPU 逐位(30 步 × 8 卡 × 2 微批 × 4 个字段,另加每步一个非 padding 总数);原生加载器 2,000/16,000 同号 | 每个单元四个字段各一个 sha256,另比每步非 padding token 数 |
| 1,781 个张量逐位、参数 12,386,079,744 | 开源权重 → TPU 格式 → 转回,按原始字节比 |
| 权重衰减 0.1 → 0.033 | GPU 运行每一步从优化器参数组读出的权重衰减(1000 步全是 0.033);框架预训练模板与调度器源码 |
| 第 1 步 loss +2.5e-6 | 11.465785 对 11.465756 |
| TPU 对 GPU 尾段带符号均值 −1.66e-4,扣掉均值后逐步上下抖的幅度(标准差)1.33e-4,九成的步更低 | 逐步原值,TPU 第一次 1000 步运行对 GPU 第一份 |
| 定案前第一关验收 r(对 ④ 精确轨迹):参数范数 3.45、loss 1.92 / 1.29、梯度范数 1.14;v7x(开关打开前的配置)参数范数 3.53 | v5p 当前配置 1000 步对精确轨迹一份;N 取 ③ 那组 GPU 重跑 5 份两两 10 对 |
| 参照 3 / 15 / 28 对:待定 8/46、3/9、1/46 | 第一阶段 100 步的 GPU 对 GPU 演练(46 条检查),被测和参照都是默认设置;15 对时只重判了那 8 条外加梯度范数一条 |
| qkv 投影 R 1.235 → 1.000;对 GPU rel_L2 2.36e-3 → 1.8e-4 | v5p 单算子对 FP64、逐层回放;打开 FP32 累加的开关前后 |
| 第三次迁移:往里投的投影 R 1.41 → 1.00;BF16 累加的窗口化循环 4 / 8 / 16 个设备 0 / 20 / 20;第 1 步超 2N 91 → 63;1000 步主 loss 1.14 → 0.96,步时 +0.4% | 第三次迁移:单算子回放(8 个设备,对 FP64);同一份生产配置在 CPU 上为各拓扑离线编译训练步(运行库 0.0.46);整网第 1 步与 1000 步各一份运行,阶梯上相邻两级 |
| GPU 自比第 1 步梯度:差 1 格 1.3%,≥17 格 67% | 第一阶段,两次默认设置 GPU 运行,按 FP32 数格(梯度存 FP32) |
| 张量核模型:16 个一组、25 位、向零截断 | B200 上逐位复现路由打分三层全部元素;试过的三种改法(8 个一组、24 位、就近舍入)命中率都 <1% |
| 合成输入朝零偏差 2.2e-5 / 7.0e-5 / 3.1e-4(K = 256 / 4096 / 65536) | B200 BF16 张量核,正数输入;负数输入同样朝零(K = 256 时幅度约为正数的一半);FP32 非张量核 ≤ 5e-8 |
| TF32:只关 torch 开关 2.94e-4,设环境变量 1.15e-6,读回仍 True | 官方训练容器里实测 FP32 GEMM 对 FP64 |
| 路由打分对 FP64:TPU 4.8e-8 – 5.7e-8,GPU 3.8e-6 – 4.0e-6(三层) | 第 1 步单算子回放,输入用 GPU 那一层的路由输入 |
| 反推梯度只差 FP32 舍入:拿二阶动量独立核对,rel_L2 6e-8(最大 2e-7) | 混元 3 第 1 步,从一阶动量反推,再用二阶动量独立核一遍 |
| 参数范数多涨 0.021(GPU 自己涨 0.127) | 逐步原值;GPU 第二份对基线最多 6.6e-4,第三份对基线最多 9.9e-4 |
| 第 300 步:输出层贡献 3.83e-3 / 4.39e-3;没出现过的词 +17.1 | FP32 主权重的分组、逐行平方和,词频按前 300 步数据统计 |
| 冷门行梯度很小、失去 Adam 归一化保护:第 300 步 92% 的元素 √v̂ < ε(中位数 2.6e-9);ε 区的弹性 | 第 300 步两侧输出层状态实测;弹性为本课推导(稳态近似) |
| lse 差 −0.0016 / −0.016 / −0.078 / −0.218;第 1000 步约 −0.33 | 固定序列探针第 25 / 50 / 100 / 300 步(对第一份 GPU);第 1000 步那个数取自训练批 |
| 干预:去掉方向后 loss −3.4e-5、参数范数 +6.1e-3;GPU 加力 −1.26e-4、+2.05e-2 | 两边各 1000 步,同设置 |
| 输出头反向误差:GPU dgrad −6.51e-4,TPU −2.4e-5,交叉熵 +2.7e-6,TF32 版 −8.08e-4,真 FP32 −1.7e-6;同一批数据(fig-head)整个输出头反向 GPU −4.4e-4、TPU −2.6e-5(约 1/17)、TPU 精确配置 −1.2e-6 | 第 1 步,用训练里实际用到的张量离线对 FP64;第 100 步 GPU −6.10e-4、TPU −7.4e-5。机制是张量核抹零为推断 |
| 同状态各算一步:TPU 0.00%,GPU FP32 dgrad −0.10%,GPU −0.36% | GPU 第 99 步状态导入 TPU(1193 个张量核对指纹;按 GPU 框架布局数,q/k/v、gate/up 各合成一个,所以比 §2.2 按开源命名数的 1,781 少,元素一个不少),第 100 步数据,共同参照为 GPU 全程 FP32;4 个状态 12 个 batch 范围见图 |
| 精确轨迹:参数范数 +1.82e-2(TPU +1.99e-2,FP32 dgrad +1.23e-2 – +1.28e-2) | 第 975 步,对 4 份默认 GPU 运行均值;GPU 自己 ±4.5e-4 |
| 旧版拆账 59% / 29% / 12%(作废:把 ④ 当成了精确值);loss 73% | TPU(开关打开前的配置)、生产 golden(5 份)、只修 dgrad 的 golden、精确轨迹,第 1000 步与第 301–1000 步 |
| 新的账:④ +1.86e-2、⑤ +2.07e-2、TPU 生产 +2.09e-2、⑥ +2.74e-2;生产 → ⑤ +2.07e-2、⑤ → ⑥ +6.7e-3 | 第 1000 步参数范数,对生产 golden 5 份均值;生产近似配置;TPU v5p、v7x 当前配置同值 |
| TPU 对 ④ +2.35e-3 = +8.70e-3 −6.84e-3 +4.9e-4(v7x;v5p +7.97e-3、−6.10e-3、+4.9e-4);TPU 生产比 TPU 精确轨迹少漂 6.35e-3(对 GPU 真精确 ⑥ 是 6.5e-3);GPU 真精确多舍一次 dlogits −6.7e-3 | 第 1000 步;第一笔由 GPU 精确改分段累加证实,第二笔由 TPU 精确只把 dlogits 舍 BF16 证实,第三笔是差额 |
| cuBLAS FP32 一次累加的偏差:第 1 步 −1.8e-6(第 299 步对照用的这一组张量;正文和 §7.4、§7.5 的表用生产张量,是 −1.7e-6),第 299 步状态 −2.6e-4;改分段累加后 GPU 精确对 TPU 精确 7.9e-8;漂移比 1.45 / 1.10 | B200,输出头 dgrad 沿 w̄ 的相对偏差;后两项为不重算配置第 1000 步(参数范数带符号均值;漂移对 4 份默认 GPU 运行均值,取前后 25 步平均) |
| 定案前比过的基线:⑤ 参数范数 0.42 倍、loss 尾段 0.59 倍;⑥ 参数范数 6.2 到 7.1 倍;dlogits 留 FP32 的诊断版步时 +9.6% | v5p 当前配置(⑥ 一项含 v7x),尺子为 ③ 那组 10 对 |
| 定案后第一关:最差 0.85 倍(v5p 参数范数 0.50、v7x 0.53),EP=8 也过;TPU 扰动组 9 份里 8 份 ≤ 0.85、1 份梯度范数待定(MARE 1.02、最大单步 1.15,v7x 扰动组梯度范数 MARE 两两 0.039 对 GPU 0.033);v7x 当前配置四层前向 R 1.06 / 1.01 / 1.01 / 1.02、第 2 层 MoE 块 1.27 → 去掉 1 个翻转 token 0.95;10 对时待定 1.02–1.24;原口径(10 份两两 45 对)最差 0.84 | 对 ⑤ 的一份,尺子 ⑤ 自己 10 份两两 45 对;v5p、v7x 当前配置 1000 步 |
| 两处测量口径:TPU 参数范数单步自测误差 2.6e-7(GPU 8e-8,GPU 重跑单步差 4.86e-7);梯度范数 N 随配对方向 1.26e-3 / 2.49e-3 | 同一次运行里按组记录的平方和与整网一次归约对比;梯度范数改用两边均值当分母 |
| 开关代价:FP32 累加步时 v7x +1.9%、v5p +0.66%;按专家切 v7x −28%;GPU 升 FP32 加分段 +61%(BF16 张量核分段 +6%) | FP32 累加为 100 步对比;按专家切为 1000 步运行第 50–1000 步步时中位数;分段累加为 GPU 侧步时 |
| TPU 自己剩下的(旧口径,对精确轨迹;第一个数对 ④′,后两个对 ④):+1.7e-3 / +2.6e-3 / +2.3e-3 | 分别是:不重算配置第 975 步;生产近似配置、开关打开前第 1000 步;当前配置第 1000 步 |
| 回归:20 步那档约 10 分钟、1000 步那档约 25 分钟;扰动臂旧配置 14 试 7 过、28 对;新配置 7 个重跑全过、重标 28 对 | v5p(8 颗芯片),提交到取回 |
| 第 1 步路由翻转:翻了的 token 第 8、9 名分差中位数 2.7e-5 – 6.3e-5;某专家梯度 0.102、50 个张量合起来 1.28e-3 | 第 1 步隔离回放;被测梯度由 Adam 一阶动量反推 |
| 路由翻转对照(动画):全部 token 第 8、9 名分差中位数 3.1e-4 – 8.0e-4;喂相同路由输入,两边路由打分(logits)的 rel_L2 仍约 4e-6、翻转 0;输入换成 TPU 自己算的,每层翻 3.5%–5.4%;全程 FP32 下第 1 层翻的那个 token 分差 1.6e-6(据此得出的「两边实现不同」已撤回) | 前两项:第 1 层起逐层隔离回放(路由输入用 TPU 自己算的,或换成 GPU 那份),3 层各 4096 个 token;第三项:GPU 第 99 步状态,两侧全程 FP32 前向逐点比 |
| 逐层 rel_L2:MoE 三层 0.016 / 0.020 / 0.028(R 比过);第 0 层前向 4.0e-3、反向 2.1e-3 | v5p,第 1 步逐层回放;第 0 层两平台相同 |
| 去掉 w̄ 方向后 loss:前半 +4.9e-5、后半 −9.6e-5(尾段平均 −3.4e-5) | 两侧都去掉 dh 沿 w̄ 的分量,1000 步,对 GPU 第一份 |
| 第 1 步换尺子:最差张量 TPU 只改片上内存上限 0.080、TPU 对 GPU 0.105;并集 24 对;隔离回放反向 R v5p 0.98 / 0.74 / 0.83 / 1.01、v7x 0.98 / 0.96 / 0.88 / 0.95;整步按能量 R 1.20(v5p)/ 1.21(v7x);逐处改掉 RMSNorm 的 scale 1.35 → 0.58;输出层 1.60 → 0.91;embedding 1.21 → 0.87;三个开关步时 v5p +0.79%、v7x +1.6%,打开后 1000 步对 ⑤:v5p loss 全程 0.88、尾段 0.91、梯度范数 0.79、参数范数 0.60、路由偏置曲线 0.85,v7x 梯度范数最大单步 1.05 倍(带符号均值 0.10 倍、MARE 0.97 倍)、其余过;路由偏置 FP64 选中 2730(均值 2730.67) | 第 1 步;前两个数是最差张量的相对差;诊断改动的 R 只在 v5p 上测;FP64 真值是同一全局批在 FP64 里求的梯度;开关步时为 100 步对比 |
| (定案前)交叉核对:精确轨迹 5 份(基线+4 份扰动版)两两 10 对 4.00 / 2.03 / 1.21 / 2.24;TPU 执行噪声 28 对 5.03 / 1.81 / 1.42 / 0.99 | 参数范数 / loss 全程 / loss 尾段 / 梯度范数,v5p 当前配置,只报不判 |
| (定案前)EP=8:参数范数带符号均值 4.27e-7 → 3.52e-7,3.45 倍 → 2.85 倍;变化 7.5e-8 小于 GPU 精确轨迹 5 份两两的上限 1.07e-7(尺子只取参照一侧;比较为本课推导) | v5p 当前配置,TPU 改成按专家切,对精确轨迹 |
| (第二次迁移)第 1 步逐张量比值中位数 2.67 → 1.65、超 2 倍 139 → 52(共 195);四个开关 1.72 / 62 | 更新的、带稀疏注意力的 MoE 模型,小尺寸、随机初始化;TPU 对 GPU 第 1 步三份,按开关逐一打开 |
| (第二次迁移)注意力打分改留 FP32:第 1 步 loss +8.1e-7、梯度范数 −3.0e-5;GPU 噪声 1.7e-6 / 9.3e-5;多路残差四路相加改成依次相加,第 1 步该处梯度对 CPU FP64 R > 1.2 11 → 8(后一代没复现) | GPU 只改这一处的第 1 步对比、8 份两两 28 对;四路相加为第 1 步对 CPU FP64 定责 |
| (第二次迁移)病态:KL ≈ 1.1e-4、lse ≈ 7.1、一格 4.73e-7 = KL 的 4.3e-3;TPU lse −0.95 格;同一行对 FP64 −1.2e-3,全部运行对 GPU −9.2e-4;输入 R 0.94–0.99、梯度 R 0.81–1.05 | 第 1 步,存下一行 KD 的原始输入在 FP64 里逐项重算;船和船长的数为本课推导(按比例换算) |
| (第二次迁移)尺子撤回并集:梯度范数 r 1.77 → 2.08、1.75 → 2.69、1.68 → 2.75;路由偏置均值 r 19.1 → 0.31;回放注入 R 1.56 → 0.95(单独喂 0.999;对齐记录未收);参数范数测量偏低 1e-7 至 3e-7,改精确值后第 1 步差 1.6e-9 | 300 步比较,并集 38 对 → GPU 28 对(梯度范数三组 r 与并集对数只在对齐记录的旧提交里,现行对齐记录未收);偏置为 TPU 关零均值更新后重跑;回放为第 1 步前向的单算子回放 |
| (第二次迁移)优化器单测:三处写法都不对上 0.13、都对上 1.3e-6(另一用例 NAdam 对 Adam 0.56);选 token 的 top-k 翻转:九成以上的 query、槽位 0.147% | 对参照框架实现生成的固定参照逐步比每步更新的相对差;翻转为第 1 步 GPU 对 FP64 |
| (第二次迁移)编译器省掉舍入:五次 1000 步 loss 对 GPU 均值 +3.7e-6 到 +8.6e-6,GPU 最大 ±3.8e-6;强制舍入后 +3.5e-6(r 2.12 → 0.76);五次里 4 次超出 GPU 噪声 | 同一组 GPU 8 份;三次只改执行参数;「后端只省一半」在最小复现里看到;长跑偏高归到它为推断 |
| (第二次迁移)超越函数:默认 exp 105、log 62、sigmoid 83、silu 86 格,高精度 exp 1、log 3、sigmoid 3、silu 4 格;exp 真实输入正好舍对 6%、平均 −2.5 格;lse −0.953 → +0.025 格、300 步 r 3.67 → 0.01(同一代还开了一个优化器开关,没拆开);sigmoid 开关前后 99 个算子逐位相同,精确写法后 r 0.65 → 1.79;除法、开方、偏差修正 2/3/108 → 1/1/2 格,小张量 R 3.82 → 1.00 | TPU v5p FP32 对 FP64 正确舍入数格;GPU 上限按 CUDA 文档(sigmoid、silu 为推断);整网为 300 步比较 |
| (第二次迁移)r 与 R:更新差 12.8% → 1.6%,97% 张量步 TPU 更近,误差中位数 3.0e-3 对 3.95e-2,GPU 1.2%–13%;QK-Clip 最大 logit −0.4956 → η −201.8 | 优化器 8 步回放;NaN 为真实权重截层第 1 步 |
| (第二次迁移)规模:中等尺寸 300 步 过 / 不过 / 待定 5 / 0 / 4;真实权重截层第 1 步 −8.5e-5;FP32 轨迹第 2 步起离开 2e-3 到 1e-2;第 1 步 R 0.31 | GPU 8 份两两 28 对;FP32 参照自己的误差没有测 |
| (第二次迁移)纯噪声轮换:300 步 8 份 56 种,59% 过 1、最高 2.47;1000 步 16 份 240 种,22% 过 1、最高 1.82;单条检查最高 1.23–1.82;粗算 67% / 23%(本课推导) | GPU 同设置重跑轮流当被测,尺子用其余各份,检查同 TPU 自比;单条最高与粗算是本课从逐种轮换数据算的 |
| (第二次迁移)8 → 16 份尺子上限放宽 1.0–2.1 倍;六个 TPU 改动 2.00–2.75 → 1.19–1.64 | 1000 步对 TPU golden;尺子 GPU 8 份 28 对 vs 16 份 120 对 |
| (第二次迁移)第 1 步两把参照:三个改动各 160 个张量;词嵌入梯度 R 3.62(纯数据并行)、R 26.1(关 excess precision;分母是基线与 GPU 中位数里远的那个) | TPU v5p 自比第 1 步训练梯度(由动量反推),对 CPU FP64;45 个多路残差小参数单列 |
| (第二次迁移)30 条根因:精度 22 / 语义 6 / 两样都有 1 / 顺序 1(第 27 条 GPU 一侧把索引器旋转位置编码放在 BF16 里算、第 28 条多路残差收拢后少舍的那次 BF16、第 29 条纯数据并行时词嵌入不排序、第 30 条多路残差流梯度的舍入写法(主因两头验证;收拢处舍入开着时测不出作用,机制待查),都归精度) | 对齐记录根因一览逐行的「根因」标注;归类是本课做的 |
| (第二次迁移)TPU 的脾气(绝大多数在运行库 0.0.46 上):121 种改动分六堆,逐位 34、跟重跑一样大 44、真有影响 17(归成 7 件,不能忍 2 件、待定 1 件;其中 1 种是查 RMSNorm 机理的诊断臂)、量不出来 5、故意改坏 15、没出结果 6;另有 0.0.52 上的 25 次重测(逐位 5、一样大 11、真有影响 7、其余 2 次归在量不出来,§10.2;后补的三次是专家并行 4、8 和它们的底,离线编译先看到多了排序、上卡核对只换了求和顺序);其中 33 种跑满 1000 步,3 个分得开;(2026-11-12 对齐记录口径)换 v7x 第 1 步中位数 3.9e-3、300 步 r 1.02、芯片·秒省 65% | 同一小尺寸模型,每次只改一样,300 步对 TPU golden;r 的分母取 GPU 重跑;第 1 步对 FP64 定责;分堆由对齐记录的生成器按结果文件自动归类 |
| (第二次迁移)灵敏度:学习率偏 1e-4 → r 4.11,3e-5 → 1.06;五个精度改动 1000 步 0.97–1.64 | 故意埋 bug、300 步;右块 1000 步、GPU 16 份 |
| (第二次迁移 · 案例二)纯数据并行四种条件 r 2.62/3.69/2.65/2.21;第 1 步 205 个张量只有词嵌入梯度远 3.62 倍 | TPU v5p(v7x 那行在 v7x)自比,对 FSDP 8 的 TPU golden,300 步;各臂结果文件的曲线判定与第 1 步逐张量表 |
| (案例二)按行分组:39 个高频词占梯度范数平方 0.90,纯数据并行多出来的误差 99.6% 在它们身上;本卡次数翻倍误差近翻倍、卡数翻倍不变 | 第 1 步词嵌入梯度对 CPU FP64,按 token 在全局批里的出现次数分组(对齐记录:梯度的跨卡归约);占比本课按误差平方相减复算 |
| (案例二)先加后传 vs 先传后加的形状;跨卡数据量约差 30 倍 | 形状读自两边训练步优化后的 HLO;数据量按形状算,本课推导,线上实际字节数没测 |
| (案例二)四格、按出现次数分组、下标数扫过门槛、8 设备两种切法 | 单算子,v5p 真跑,下标取 golden 第 1 步真实 token,更新量随机 BF16;结果与 CPU 两种仿真逐位比 |
| (案例二)门槛 N > V/8、插排序的工序名、关省舍入多出 12,288 条舍入指令 | CPU 上用同一个运行库为 v5p 交叉编译:逐道工序 dump HLO、二分七种表形状;后端指令是静态条数 |
| (案例二)修法 ① ② 的 r 与步时;关省舍入 r 13.3 | 各臂结果文件(300 步对 golden,1000 步对 1000 步的 golden);步时取第 11 步起每步中位数对 golden |
| (案例二 · 第三种修法)只切词嵌入表:第 1 步 3.97e-3(R 0.95),r 1.02 / 1.15,步时 −3.3% | TPU v5p 8 设备,纯数据并行 8 + 累积 2 只多一个开关;300 步对 golden、1000 步对 1000 步 golden,尺子 GPU 8 份 / 16 份 |
| (案例二)五种跑法的通信字节:词嵌入 9.90e8 → 6.82e7(−93%),全部 −34%;修法① 1.06e9 | 各运行上卡时存下的训练步优化后 HLO,按(类型, 形状)合并,形状 × 字节宽 × 每步次数;按形状算,不是线上实测 |
| (案例二)GPU 为什么没这个问题 | 推断:读 PyTorch 主分支 aten/src/ATen/native/cuda/Embedding.cu 的分路门槛(3072);GPU 镜像里那个版本没有逐行核过 |
| (第二次迁移)程序指纹相同 3 种改写;编译器 bug:词嵌入梯度 0.51 倍、2829/10911 行为零、r 611 → 修后 0.98 | 各改写臂结果文件的 program_equal;bug 读自编译后程序的循环体与第 1 步抓数 |
| (第二次迁移)小尺寸 1000 步九项(现行对齐配置、尺子 16 份):过 8、待定 1(路由偏置均值 1.31),主 loss 0.98;上一代配置是过 7、待定 2(主 loss 1.55、1.52),后段主因已定到流梯度的舍法(§9.1);GPU 换机器数和切法最大 1.76、正对照 4149;真实宽度第 1 步 GPU +5.76e-5 / TPU −9.87e-5,只关 base2 → −1.24e-6;1000 步回放开 2/4/3、关 3/6/0 | TPU v5p 8 设备 ↔ B200×8;GPU 扩展对单机 8 份尺子前 300 步;真实宽度 TPU v5p 16 片原样回放 GPU 2 台的 1000 步;base2 的系数 1.0018 本课按 BF16 舍入复算 |
| 混元 3 第 1 步按只用 GPU 的尺子重判:变严 11 项,没有变松;部分张量 R 超 1.2:梯度最差 2.20/2.70、优化器状态最差 7.95/7.86(v5p/v7x) | GPU 第 1 步重跑 3 对;1000 步结论不变 |
← 回 课程总纲 ·
相关:专题九 · 精度与量化 ·
想自己讲一遍?看 本讲讲义(授课稿)
本页由 Courses/tools/topic08-build.py 生成 —— 正文写在那个脚本里。