现代 AI 加速器 GPU / TPU 系统课程 / 深入 / 专题八 / GPU→TPU 训练精度对齐 📝 讲义(授课稿)

GPU→TPU 训练精度对齐

一个模型在 GPU 上训稳了,搬到 TPU 上,怎么证明训的还是同一个模型?
不可能一位不差。能要求的是:TPU 跟 GPU 的差,不比 GPU 自己跟自己的差大。

先把地基铺平,再学两类指标和一把噪声尺子,弄清浮点和硬件在哪儿舍入,然后跟着一次真实的排查走到底: TPU 的 loss 三百步以后平均比 GPU 低约 1.7e-4,查到最后,答案在一个谁都没怀疑的地方;再跟第二个案例:两种数学等价的并行方式对不上,这回又是谁的差?

前置 专题二(硬件)、专题四(Adam);浮点格式 §5.1 现讲 口径 截至 2026-11 ⏱ 照稿约 62 分钟(一次课)

课程作者 Chris Yang·Google Cloud AI Infra 架构师

这一讲另有一份讲义(授课稿)。

讲义写的是怎么讲:每一段的目的、讲到哪里该停、常见的误解、 被问到了怎么答。内容本身在你现在看的这份正文里。

两个用法。自己上台讲:照着讲义讲,台词、切图、时间都写着。 自学:把讲义整份丢给 AI,你会得到一个既有这一讲全部背景、 也知道该怎么讲的助教,让它带你走一遍。

全讲的例子是一次真实的对齐:混元 3(一个 MoE 模型,截前 4 层),GPU 侧 B200×8 + Megatron-Bridge,TPU 侧 v5p(8 颗芯片)/ v7x(4 颗芯片) + MaxText,同一份权重、同一批数据,1000 步。 数字都是这次实测的;自己推出来的,标了「本课推导」。出处在第十节末尾的台账。 后来又做了一次迁移(混元 4 的缩小版,一个更新的、带稀疏注意力的 MoE 模型,下文叫「第二次迁移」),同一套方法又走了一遍,后面借它当旁证和第二个案例(第八节),用到时都先报名字。第三次迁移是混元 4 的另一个尺寸,这次从生产代码原样起步,查清了几件「换了条件就不作数」的事(第五节)。

开场:三次迁移,真正查清的 16 处

后两次迁移,两边为对上改了七十来处(改动台账 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,第 1 步几乎一样,1000 步下来,三百步以后 TPU 的 loss 平均比 GPU 低约 1.7e-4。TPU 算错了吗?答案在第七节;先想两个更小的问题:同一个 GPU 程序跑两遍,会一位不差吗(§1.1)?BF16 比 FP32 少的是什么(下面热身第一问)?
🎯 开场热身:三道题 —— 第一问是浮点常识(§5.1 细讲),后两问预习这一讲。不做也不影响这一讲

第一问:BF16 和 FP32 的指数位一样多,都是 8 位。那 BF16 比 FP32 少的是什么、少了几位?这意味着什么?

看答案

少的是尾数:FP32 有 23 位,BF16 只有 7 位,少 16 位。指数一样宽,所以能表示的范围一样大,差的是精度: 1 附近,FP32 一格约 1.2e-7,BF16 一格约 7.8e-3。

预习(先想一想,这一讲里揭晓):

  1. 第二问:同一个 GPU 程序、同样的数据,跑两遍,结果会一位不差吗?(§1.1)
  2. 第三问:搬到 TPU 后,loss 三百步以后平均比 GPU 低约 1.7e-4。TPU 算错了吗?(§7.4)

把一个在 GPU 上训好的模型搬到 TPU,要的保证只有一句:TPU 训的是同一个模型。同样的数据、同样的初始权重、同样的超参,两边训出来的东西在统计上分不出来。

1.1 一位不差,做不到

加法换个顺序,末位就不一样 —— 所以「一位不差」做不到 竖线 = BF16 在 1 及以上能表示的数(一格 = 2⁻⁷ ≈ 0.0078;1 以下格距减半);圆点 = 精确结果,落在两格之间就要舍到最近的那一格 精确值 舍入后实际存下的数 先算 (1 + 0.0039),再 + 0.0039 1.0000 1.0078 1.0156 1.0234 第 1 次加:正好在两格中间 → 舍回 1.0000 第 2 次加:正好在两格中间 → 舍回 1.0000 结果:1.0000000 先算 (0.0039 + 0.0039),再 + 1 1.0000 1.0078 1.0156 1.0234 正好落在格上,不用舍 结果:1.0078125 差的不是谁算错了,是加法顺序不同
同一个式子,两种顺序,差了一整格。
格距按 BF16 在 1 附近的真实格距画;正好在两格中间时,舍到末位是偶数的那一格(平局取偶)。
出处与口径

⚠️ 本课推导: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)。

1.2 那拿什么当尺子:GPU 自己跟自己的差

GPU 上跑出来的标准答案叫 golden。同样设置的 GPU 再多跑几次,两两配对,每对算同样的统计量,取绝对值最大的那个,叫噪声上限 N,正负对称。拿它当尺子。道理一句话:如果 TPU 只是换了加法顺序,它跟 GPU 的差,应当跟 GPU 两次重跑之间的差一样大;比这个大,就是真有东西不一样。

尺子:不问 TPU 跟 GPU 差多少,问它比 GPU 自己跟自己差得多不多 横轴 = 第 301–1000 步 loss 逐步相对差的带符号均值(对第一份 GPU);灰带 = ±N,N = GPU 10 份两两 45 对里这个数的绝对值最大值 GPU 自己重跑的噪声上限 ±N TPU 三种跑法 混元 3 截 4 层,1000 步(实测) -2.0×10⁻⁴ -1.5×10⁻⁴ -1.0×10⁻⁴ -0.5×10⁻⁴ 0 +0.5×10⁻⁴ +1.0×10⁻⁴ 基线 = 第一份 GPU ±N = ±6.76e-5(GPU 两两 45 对的最大) 原样 · N 的 2.45 倍 不开重算 · N 的 2.00 倍 改片上内存上限 · N 的 1.53 倍 TPU:三种跑法都落在带外,方向一致 尺子一立,「1e-4 出头」就有了大小
灰带是尺子 ±N,蓝点都在带外,是 N 的 1.5 到 2.5 倍。
N = GPU 10 份两两 45 对里最大的那个差;浅灰小点只给人看。
出处与口径

📌 实测(从原始逐步记录重算):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;可生产训练不开它,尺子要量的是生产配置下会有的执行噪声。

1.3 从哪查起:五级

五级检查:验收从下往上,排查从上往下 塔越往下越宽 = 越基础、越要先过;左边箭头是验收的方向,右边箭头是排查的方向 必须一位不差 比噪声,或比 FP64 真值 L4 多步 整条训练轨迹 L3 整网第 1 步 整张网络,只看第 1 步 L2 单层 一层一层隔离开 L1 单个算子 最小的计算单元 L0 地基 喂进去的东西 验收:从下往上 低一级不过,上一级不可信 排查:从上往下 L4 发现,逐级缩小范围 地基不平,楼上量到的差就说不清是算出来的还是喂出来的
左边往上验收,右边往下排查。
每一级用什么尺子,见下面的表。
出处与口径

⭐ 地基不平,楼上量到的差就说不清是算出来的还是喂出来的(接上图)

L0 的要求是一位不差;L1–L4 才谈「差多少算正常」。

代价:每一级都要能单独拿到证据 —— 在 TPU 上怎么拿,后面专门讲。

验收从下往上一级级过,排查从上往下一级级缩小范围。每一级怎么判,后面几节讲。

五级各查什么、怎么判(用到的 R、定责第四节讲)
级查什么怎么判
L0 地基每一步每张卡吃的数据、转换后的权重、配置一位不差
L1 单个算子一个矩阵乘、一次优化器更新两边各离 FP64 真值多远(第四节的 R 比)
L2 单层第 1 步每一层的前向、反向,每层单独回放R 比(前向、反向都是)
L3 整网第 1 步全部参数的梯度、更新后的权重和优化器状态对 GPU 第 1 步重跑的噪声;超出的、尺子看不见的,对 FP64 定责(§4.2)
L4 多步1000 步的 loss、梯度范数、参数范数对 GPU 噪声(第三节)

1.4 这一讲跟着走的那一次

混元 3 截前 4 层,GPU B200×8 搬到 TPU v5p(8 颗芯片)。地基全部逐位,第 1 步 loss 只差 2.5e-6;可是三百步以后,TPU 的 loss 平均比 GPU 低约 1.7e-4,参数范数也多涨一截。方法是通用的;具体的数只对这个设置(截 4 层、1000 步、学习率 1e-5 不变)成立。

这一讲用到的几组运行:① 到 ⑥ 是哪几份 GPU 运行、各用在哪,用到时回这儿查
这一讲用到的几组运行多少用在哪
① 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 的真精确参照
TPU3 种跑法;扰动臂 7 个+基线,28 对第一节的三个点;TPU 自己的执行噪声(§10.3 的回归)
TPU 扰动组(定案后)9 份(v5p 5、v7x 4),只改执行参数§9.5 只报:TPU 不是挑出来的好样本

编号不用记,只记最后定下来的标准答案叫「修好的 golden」(表里标 ⑤,第九节讲它怎么来的);用到别的那几份时会说名字。下文的「第一关」=对修好的 golden 判过不过;「第二关」=对 GPU 生产 golden 写清差在哪、差多少,记「已解释差异」(§9.4)。

前六节备工具,第七节回来把它查到底;第八、九节是第二次迁移的两个案子。另外两次迁移当旁证,用到时都先报名字:

第二次迁移混元 4 的缩小版(一个更新的、带稀疏注意力的 MoE 模型),同一套方法在它身上又走了一遍
第三次迁移混元 4 的另一个尺寸,不先对齐代码,从生产代码原样起步、一个开关一个开关地打开;它的几个发现,都是「换了一个条件,之前的验证就不作数」
后面常出现的三个词,先认个脸 TPU 自比:在 TPU 上只改一样东西(换并行、关一个编译开关、升版本……),跟一次确认过的 TPU 运行比。尺子仍借 GPU 重跑,因为 TPU 自己重跑逐位相同、量不出宽度。第二次迁移的很多例子来自它(§10.1 汇总)。
运行库(libtpu):TPU 的编译器后端和运行时打包成的库;文中 0.0.46、0.0.52 是它的版本号(§10.2)。
对齐记录:这几次迁移的公开实验仓库,课件里的「代码:」链接都指向它,数字都能在里面追到结果文件。
遇到不认识的词,回这儿查:golden、噪声、BF16、张量核、MXU、FSDP、XLA、求和维、dgrad、Adam 的 ε、lse、留一法、定责、程序指纹……
  • golden:GPU 上跑出来、拿来当标准答案的那条训练记录。
  • 专家、路由:混元 3 是 MoE 模型,每层有很多组并排的前馈层(专家),每个 token 由路由器挑其中几个来算;路由偏置是路由打分上加的一个可学习的偏移。
  • 原子加:很多线程同时往同一个格子里累加,硬件保证不丢数,但不保证先后顺序。
  • 设备:软件看到的一个计算单元。v5p 一颗芯片是 1 个设备,v7x 一颗芯片是 2 个设备(Google Cloud TPU 文档);所以 v5p 8 颗、v7x 4 颗都是 8 个设备,都对上 GPU 的 8 张卡。
  • 噪声(噪声参照):同样设置的几次运行两两之间的差;N(噪声上限)是其中最大的那个。
  • 扰动臂:只改执行方式、不改数学的变体程序(比如改编译器的片上内存上限),用来给 TPU 造噪声。
  • 逐位相同:两个数的每一个二进制位都一样,不只是「看着相等」。
  • BF16 / FP32 / TF32:三种浮点格式,指数都是 8 位,尾数分别是 7、23、10 位(§5.1)。
  • 张量核 / MXU:GPU 和 TPU 上专门做矩阵乘的硬件单元。
  • EP:按专家切 —— 不同的专家放在不同的卡上,token 按路由结果发过去算。
  • 分布式优化器:把优化器状态切开分到各张卡上存;梯度规约也从 all-reduce 改成 reduce-scatter。本讲的 GPU 默认组把它关掉:有一批老运行(推断当时开着)持续偏低一点,原因没查清。
  • Megatron-Bridge、Transformer Engine:GPU 这一侧用的训练框架,以及 NVIDIA 给它提供低精度矩阵乘等算子的库。
  • FSDP:把权重切开分到各张卡、用的时候再拼起来的数据并行(专题五 §2.3)。
  • collective matmul:本课叫「边传边乘」,编译产物里叫窗口化矩阵乘;一边在设备之间收下一片数据、一边算矩阵乘,把通信藏在计算后面(§5.3)。
  • 微批(microbatch):一步要算的一批数据再切成几份,一份一份地过,梯度加起来。
  • dgrad:反向里「对输入的梯度」那一次矩阵乘(例如 dh = dlogits · W)。
  • Adam 的 ε:Adam 更新公式分母上加的一个小常数(这里是 1e-8),防止除以零。
  • logits / lse:模型给词表里每个词打的原始分数;lse 是把它们按 log-sum-exp 合成的一个数,代表 logits 的整体水平。
  • 参数范数(param_norm):全部参数平方和开根号,一个数;梯度范数(grad_norm)同理,取裁剪之前的值。
  • FP64 真值:同一份输入用 64 位浮点算一遍,几乎没有舍入,当靶心用。
  • XLA、融合:XLA 是 JAX 用的编译器,TPU 上的程序都经它整图编译;融合是把相邻几个算子编进同一块一起算,中间结果不落回内存。
  • excess precision:允许编译器让结果比程序写的更精确(XLA 的 xla_allow_excess_precision,默认开);表现为中间值不按 BF16 落地:成对的「转 BF16 再转回」可能被删掉,也可能在 HLO 里还在、后端编 kernel 时省掉(§5.4)。
  • 求和维(也叫收缩维):矩阵乘里被加起来、消掉的那一维,它的长度就是一次求和要加多少个乘积。
  • 路由槽位:每个 token 选几个专家就占几个槽位;「翻了一个槽位」=这个 token 有一个专家换了人(§4.3)。
  • MARE:mean absolute relative error,逐步相对差取绝对值再平均(§3.2)。
  • 超越函数:exp、log、sigmoid 这类不能用有限次加减乘除精确算出的函数;硬件和库用软件近似,精度各家不同(§5.5)。
  • 病态:结果对舍入极敏感;典型是两个几乎相等的大数相减剩下一个小数,大数上差一格,小数上就是一大截(§5.5 折叠)。
  • 第二次迁移:同一套方法在混元 4(公开口径总参数 770B、激活 49B)的缩小版上又走了一遍,它是一个更新的、带稀疏注意力的 MoE 模型;它的「小尺寸模型」保留全部结构、只缩宽度和层数,随机初始化,约 4.3 亿参数。
  • 第三次迁移:混元 4 的另一个尺寸,从生产代码原样起步、一个开关一个开关地打开(§1.4、§5.3、§9.7)。
  • MLA:多头潜在注意力,先把 q、k、v 投到一个低秩的中间维,再投回每个头(DeepSeek-V2,arXiv:2405.04434);混元 4 用它。
  • 纯数据并行:每张卡存一整份权重、各算各的数据,梯度再跨卡求和(FSDP 则把权重也切开)。
  • 词嵌入:词表里每个词一行向量;反向时,用到这个词的每个 token 的梯度都要加回它那一行,这一步叫 scatter-add(第八节)。
  • 下标:按号去取或去加时用的那个号;一次处理多少个元素,就有多少个下标。
  • 五种集合通信:all-reduce 各卡相加、每卡一份;reduce-scatter 相加后每卡只留一段;all-gather 把各卡的段拼成整份;all-to-all 每卡把自己的数据切成 n 份、第 i 份送给第 i 张卡;collective-permute 是点对点地传一块(§8.10)。
  • HLO:XLA 编译出来的程序文本;切分、融合做完以后那一份里,每个算子、每次跨卡通信的类型和形状都看得到(§8.10)。
  • LLO、打包指令:LLO 是后端给每颗 kernel 生成的机器指令;「打包」指把 FP32 舍成 BF16 存放的那类指令,数它就知道一处舍入有没有真做(§8.5、§9.1)。
  • R:被测离 FP64 的距离 ÷ 参照离 FP64 的距离;≤ 1.2 记「换了顺序」,更大记「丢了精度」(§4.2)。
  • 尺子、刻度:拿来比的那把叫尺子:多步曲线上是噪声上限 N,第 1 步逐张量上是 GPU 几份重跑两两的最大差(混元 3 三份,第二次迁移现在六份);「刻度」只指 FP32 记录值的分辨率(例如混元 3 的参数范数在 3042 附近一格约 2.44e-4)。
  • 留一法:轮流拿一份 GPU 重跑当被测,用其余几份当尺子,看纯噪声按同一套判法能拿几分(§3.4)。
  • 定责:查清一处差来自哪一边、为什么;第 1 步靠对 FP64 的 R 比,分「换了顺序」和「丢了精度」(§4.2)。
  • 程序指纹:编译后的整份程序去掉元数据、名字按出现顺序重新编号以后的哈希;编译开关和运行库也相同时,指纹一样,结果就逐位相同(§10.3)。
  • 运行库(libtpu):TPU 的编译器后端和运行时打包成的一个库。换它,优化后的程序、生成的 kernel 都可能变,所以换版本不能当成「只换了加法顺序」(§10.2)。
  • SparseCore:TPU 芯片上的专用小核,官方定位是加速嵌入查表这类稀疏计算(Google Cloud TPU 文档);本课用到两处:集合通信可以卸载给它;v7x 上有一处累加也交给了它(§8.6)。
  • RMSNorm:按均方根归一化、再乘一组可学的缩放;第二次迁移里它的舍入次数是一处边界(§5.4、§10.1);换到运行库 0.0.52,v5p 上最后一层的两次舍入都真发生,主 loss 偏高(§10.2)。
  • 重算、路由回放:重算是反向时把前向的中间结果再算一遍、省显存;路由回放是重算时沿用前向选中的专家,不重新选(§1.4、§2.3)。
  • MTP:多 token 预测,模型末尾多一层去预测再往后一个 token,记一项自己的 loss。
  • Muon:第二次迁移用的优化器,对矩阵参数先把动量正交化再更新;非矩阵参数仍用 Adam。
  • 多路残差混合:混元 4 把残差流复制成 4 路,每层用一组小参数按权把几路混进、混出;「多路残差混合的小参数」指这组参数,数值上病态,定责时单列(「四路流」的说法见对齐记录 TPU↔GPU 差异清单:末端把四路流加权收成一路再进最后一层 RMSNorm)。
  • 索引器、蒸馏损失(KD):稀疏注意力里给每个 query 挑一批 token 的小打分网络;它靠一项蒸馏损失向完整注意力学(§5.5 折叠)。
  • base2:注意力内核把 eˣ 写成 2 的 (x·log₂e) 次方来算的写法;第二次迁移里那个常数跟着 BF16 舍了,所有尺寸的对齐配置现在都关掉它(§9.7)。
  • HIGHEST:TPU 上矩阵乘的最高精度档,用多遍 BF16 拼出近似 FP32;默认档对 FP32 操作数只算一遍 BF16(§5.3、§5.5)。
考考自己:TPU 跟 GPU 的 loss 第 300 步差了 1e-4,算不算对不齐?

光看这个数判断不了。要先量 GPU 自己重跑几次、两两差多少:如果 GPU 自己也常差到 1e-4,那就是噪声;如果 GPU 自己只差 1e-5 量级、而且 TPU 一直偏向同一边,才值得查。

这一节留下的问题:数据、权重、配置,怎么做到两边一位不差?

第 二 节

地基 L0:输入必须一位不差

L0 只有一条要求:两边的输入一位不差。这一级不过,后面量到的任何差,都说不清是算出来的还是喂出来的。喂进去的有三样:数据、权重、配置;验法只有一个:不信过程,只比结果,把两边真正吃进去的东西拿出来逐位比。

三样输入,一个验法(只比结果、逐位比),第 1 步 loss 收口

① 数据(2.1)
1,950
项指纹对 GPU 逐个比(前 30 步),全部相同
→
② 权重(2.2)
1,781
个张量转过去再转回来,逐字节全部相同
→
③ 配置(2.3)
0.033
实际生效的权重衰减(配置文件写 0.1)
→
④ 收口(2.4)
2.5e-6
第 1 步 loss 两边的相对差:地基平了

2.1 数据:原样回放,不重读

数据不重读,原样回放 —— 每一步、每张卡、每一小份都对指纹 一格 = 一张卡这一步吃的一小份数据(microbatch);灰度深浅 = 它在 GPU 上属于哪张卡 指纹相同 画的是一步:16 个单元(8 张卡 × 2 小份);对 GPU 逐个比了前 30 步,全部相同 GPU 训练时 存下每一格 + 指纹 0·m0 0·m1 1·m0 1·m1 2·m0 2·m1 3·m0 3·m1 4·m0 4·m1 5·m0 5·m1 6·m0 6·m1 7·m0 7·m1 TPU 回放 设备 d 拿 GPU 第 d 卡 0·m0 0·m1 ✓ 1·m0 1·m1 ✓ 2·m0 2·m1 ✓ 3·m0 3·m1 ✓ 4·m0 4·m1 ✓ 5·m0 5·m1 ✓ 6·m0 6·m1 ✓ 7·m0 7·m1 ✓ 数据这一级必须一位不差:每步 8 卡 × 2 小份 = 16 个单元,逐个比
每一格都要对上指纹。
画的是一步;对 GPU 逐格比了前 30 步(1,950 项),全部相同。
出处与口径

📌 实测:每个单元记 tokens、labels、loss_mask、position_ids 各一个 sha256,另比每步非 padding 的 token 总数;对 GPU 比了前 30 步共 1,950 项,0 不同,之后按步号回放同一份批文件。

📌 实测:TPU 原生加载器读同一份数据,索引表逐字节相同、样本流逐位相同;按原样布局只有 2,000 / 16,000 个单元落到同号设备(两边梯度累积切分的方式不同),重排后全部逐位。

两边各读各的数据集,顺序、切分、分到哪张卡,任何一处不同,比的就不是同一个训练。所以 TPU 不读数据集,只回放 GPU 存下来的那一份。

「设备 d」怎么对上「GPU 第 d 张卡」:在 TPU 上照做时的定义和核对办法

框架建设备网格时会按物理拓扑重排设备,网格上的第 d 片不一定是设备列表里的第 d 个;梯度累积拆微批又发生在编译后的程序里面。所以按「全局批的第几行」来排:GPU 第 d 张卡的第 m 份放在全局批第 d·G+m 行(G 是每卡的微批数。这是本例框架的拆法,别的框架、甚至同一框架的别的训练器可能不同,按自己的代码核对)。排错了不报错,编译器会悄悄搬数据,分组照样错。核对办法:组好全局批以后遍历每个设备上那一片,用它的索引去对指纹。

2.2 权重:转过去,再转回来,逐张量比字节

从开源权重转成两边各自的格式,要处理改名、拼接、拆专家、转置。证明转对的办法是转过去再转回来,跟原始文件按原始字节逐个张量比: 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 主权重只比了一部分

参数全部比;FP32 主权重比的是 GPU 那边抓下来的 50 个张量。

2.3 配置:对「实际生效的值」

配置文件写的,不一定是实际用的 —— 权重衰减:写着 0.1,用的是 0.033 横轴 = 训练步;纵轴 = 这一步优化器实际用的权重衰减系数 配置里写的 每一步实际用的 同一个超参,两处写法 0 0.033 0.1 优化器配置:weight_decay = 0.1(一步都没用上) 调度器配置 start = end = 0.033,每一步覆盖 → 实际生效 TPU 要是照抄 0.1:每一步多衰减 3 倍 对照表要写「实际生效的值」和证据,不写「配置里的值」
虚线是写的,实线是用的。
证据是每一步从优化器参数组读出来的值,不是配置文件。
出处与口径

📌 实测:每一步从 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、一维参数按名字排除;配置检查和日常回归都钉死这个值。

摘自混元 3 几十行的对照表
设置两边对成什么
权重衰减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 份。

名字一样,写法不一样:第二次迁移在配置和优化器里查出的四处(重算那条第三次迁移又踩了一次),都不报错
  • 优化器:两边用的是同一个名字的优化器,可动量那一步做不做偏差修正、一部分参数走普通 Adam 还是 NAdam、一处归一化的 eps 怎么加,三处写法都不同。单测里拿参照框架的实现生成固定参照、逐步比每步更新:三处都不对上,相对差 0.13;三处都对上,1.3e-6。(另一个只测那部分参数的用例里,NAdam 对普通 Adam 差 0.56。)
  • 重算:「存下路由结果、反向不重选」这个设置(MaxText 的 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,步时不变。这是语义差,不是精度差:生产也该开。
  • 协议写了、参照做不到:协议写「两边的路由偏置都做零均值更新」,可参照框架根本没有这个更新。TPU 开着它,偏置均值逐步漂开,带符号均值的 r 到了 19.1;TPU 关掉以后降到 0.17(这时最差的一项换成平均绝对差,r 0.31)。
  • 统计量怎么跨微批合:梯度累积把各份微批的辅助量一律求和,连一个「取最大」的统计也被加成约累积份数倍,拿它当阈值去裁剪就裁多了。(这一次训练里那个裁剪从没触发过,修了,数值上没有前后对比。)

办法只有一条:对照表逐行对写法,不只对名字;参照框架里找不到实现的,协议写了也不算。

2.4 收口:第 1 步 loss,最便宜的自检

第 1 步 loss:地基铺平了没有,一眼就看出来 第 1 步还没有任何更新,两边 loss 只差前向的舍入。混元 3(v5p):TPU 11.465785,GPU 11.465756,相对差 +2.5e-6。 第 1 步就差得离谱,先回头查 L0,别去查数值。
续训也要逐位(课上不讲)

第 10 步存档、恢复后跑第 11–20 步,跟一口气跑下来逐位相同:数据位置、逐步的数、FP32 状态都一样。

考考自己:权重转换后抽 100 个张量比,全对,能说转换没问题吗?

不能。没抽到的那 1,681 个可能就有一个转置错了;而且 FP32 主权重上小于 BF16 半格的错,第 1 步前向根本看不见。要全量逐位比,加载以后再从设备上读一遍。

这一节留下的问题:一千步的差,怎么压成几个能判的数?

第 三 节

指标(一):逐步序列

loss、梯度范数、参数范数,每一步各出一个差。这一节把它们压成三个统计量,再拿噪声上限判。

3.1 每一步的相对差,和三个被比的量

dₜ =(被测ₜ − 基线ₜ)÷ |基线ₜ| 分子:同一步的被测减基线(被测是 TPU 那条,基线是事先指定的一份 golden),带正负号;分母:基线这一步的绝对值(混元 3 有一处例外,见下面折叠)。 例:第 1 步 loss,(11.465785 − 11.465756)÷ 11.465756 ≈ +2.5e-6。
参照是谁、分母为什么一律用参照:两种比较算法一样,只换参照;混元 3 的梯度范数用过两边均值
  • 参照是谁:GPU→TPU 对齐时,参照是事先指定的一份 GPU golden;TPU 自己改代码(§10.1)时,参照是一次确认过的 TPU 运行。读的是同一种逐步记录,算法完全一样。
  • dₜ 的单位是 1:dₜ = 1e-5 就是 0.001%;它也不是 ULP(按浮点格子数差几格)。
  • 混元 3 第一关的梯度范数用过两边均值当分母(§9.5 折叠):梯度范数逐步涨落约 ±3%,以参照为分母时,带符号均值天生带一个正偏,约等于 E[δ²](δ 是同一步上两份运行的相对差;本课推导)。假设两份运行的逐步梯度范数在共同趋势上下各自独立地抖约 3%,δ² 约 1e-3(这是条件,不是实测);交换两边 N 能差一倍。第二次迁移实测这个偏置约 2e-7(换分母前后带符号均值 −2.6013e-4 → −2.5993e-4;理论估算约 4e-7),比噪声上限约 9.9e-5 小两个数量级,所以第二次迁移 2026-11-10 起所有曲线一律以参照作分母:一条规则,好解释。混元 3 的成绩没有重判,梯度范数仍按两边均值作分母。

loss 之外,另两个量这样取:

3.2 带符号均值、MARE、最大单步

1000 个点压成三个数:偏多少、抖多大、最尖的一下 一个点 = 一步的相对差 dₜ =(被测 − 基线)÷ |基线|;阴影 = 第 301–1000 步(尾段窗口);黑线 = 窗口里的带符号均值 GPU 第二次 对 第一次(噪声) TPU 对 GPU 第一次 GPU 自己跟自己:点围着零抖 -6×10⁻⁴ -3×10⁻⁴ +3×10⁻⁴ +6×10⁻⁴ 带符号均值 -3.78e-5 第 1 步 第 300 步 第 1000 步 TPU 对 GPU:抖得一样宽,整团往下沉 -6×10⁻⁴ -3×10⁻⁴ +3×10⁻⁴ +6×10⁻⁴ 带符号均值 -1.66e-4 最大单步:第 380 步 -6.6e-04 第 301–1000 步:九成的步 TPU 更低;扣掉均值后逐步上下抖的幅度(标准差)1.33e-04,跟上排 1.34e-04 一样 第 1 步 第 300 步 第 1000 步 带符号均值专抓「一直往一边偏」:随机的抖动正负抵消,剩下的就是偏移
两团点一样宽,下面那团蓝点整体沉下去了。
点都是真实的逐步值。
出处与口径

📌 实测:两条 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ₜ| 和它在第几步拦住某一步突然跳一下
窗口表:全程、尾段、第 1 步各取哪几步
窗口混元 3第二次迁移为什么
全程第 2–1000 步第 2–300 步/第 2–1000 步看整段
尾段(后段)第 301–1000 步第 101–300 步/第 101–1000 步前段两条轨迹还没分开,会冲淡偏移
第 1 步 d₀单独报,不进窗口GPU 重跑第 1 步 loss 常常逐位相同,当不了尺子
窗口的两条细则:只有一份原始数据;每个统计量是整窗一个数

两个窗口读的是同一条 dₜ 序列,只是求平均的范围不同;每个统计量是整个窗口算出的一个数,不是逐步的滑动平均。窗口写哪段,事先写进协议。

三类曲线谁更灵、各自的盲区(课上不讲):loss、梯度范数、参数范数;第二次迁移故意埋错的证据

loss 是结果,范数是总量。混元 3 那次,三个被比的量里参数范数最先冲出去:它是个累加器,只换顺序的差这步正、下步负,按步数的平方根散开;丢了精度的差有固定方向,按步数长。跑得够久,再小的系统偏差也会冲出噪声带:

参数范数是个累加器:噪声按根号长,偏差按步数长 左:示意模拟(固定种子),每步一个随机增量;蓝线每步另多一个固定的小偏,只有噪声的十分之一。右:范数只看长度,看不见方向 只有噪声 噪声 + 每步一点固定偏差 噪声带 ±2√t Ⓐ 为什么灵:每步一点点,几百步冲出噪声带 0.1·t = 2√t:平均在 400 步追上带边 偏差:∝ t 噪声:∝ √t 0 250 500 750 1000 训练步 Ⓑ 盲区:只看长度,不看方向 GPU TPU 一样长:范数相同 指向不同:模型已经不一样 A 组 多涨一点 B 组 少涨一点 平方和加起来不变:总范数什么都看不出 随机的差每一步正负抵消,固定方向的差一步步攒起来:累加器会把小偏差放大成看得见的漂移
灰线越散越宽,蓝线一直斜着往上走。
左块是示意模拟;右块两支箭头一样长。
出处与口径

⚠️ 本课推导 + 示意模拟:增量取标准正态(固定种子),蓝线每步多 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、路由偏置各抓什么、看不见什么
被比的量抓什么盲区
参数范数、梯度范数攒出来的固定方向的偏,最先有反应只是一个长度:方向变了、一组多涨一组少涨看不出;被大张量主导,归一化权重、偏置上的错几乎看不见
loss(各项分开)训练效果变没变只对很大的局部错才显(MTP 那一项权重偏 1e-3 时,MTP loss 本身 r 50,主 loss 只有 0.88;偏到 1e-2 主 loss 才 6.2)
路由偏置均值、散布路由负载的漂移均值在 0 附近来回穿,过零时 dₜ 和 N 一起放大,只抓得到大的语义差

所以逐步曲线要配第 1 步的逐张量比较(第四节):一个抓攒出来的偏,一个抓偏在哪个张量。

第二次迁移的证据:故意埋的错,领头的常是范数,不是 loss

第二次迁移里故意让 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 告诉你训练效果变没变,可对不少数值问题反应慢;两个范数把几亿个数各压成一个,对固定方向的偏差最先有反应。

3.3 噪声上限 N,和怎么判

N 是从 5 份重跑两两组成的 10 对里挑出来的最大值;被测一出场,纵轴得缩一半才装得下。 (23 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。只演参数范数的带符号均值;10 根柱子都是真值,横轴只表示相对位置。)
1 逐步差dₜ = (被测ₜ − 基线ₜ) ÷ |基线ₜ| (同一步、带符号、单位 1;第 1 步单独报,不进窗口)
2 三个数窗口里:带符号均值 mean(dₜ) 平均绝对差 MARE = mean(|dₜ|) 最大单步 max|dₜ|
3 尺子GPU 同设置 K 份两两配对 C(K,2) 对,每对按同一窗口、同一分母算同样三个数;N = 各对里的最大值(三个数各一把)
r = |被测的那个数| ÷ N

一条检查取三个 r 的最大,一次比较取所有检查的最大

r ≤ 1:像多跑了一次噪声
被测落在 GPU 自己重跑的范围里,过
r > 2:比最坏的噪声还大一倍
不过;1 到 2 之间待定,先看纯噪声自己能拿几分(§3.4)
第二次迁移,FSDP 改纯数据并行,前 300 步(TPU 自比,实测)统计被测N(GPU 8 份两两 28 对的最大)r
主 loss带符号均值+5.58e-63.01e-61.85
主 lossMARE8.84e-66.72e-61.31
主 loss最大单步(第 273 步)3.70e-54.53e-50.82
主 loss 后段(第 101–300 步)带符号均值+9.22e-64.54e-62.03
梯度范数带符号均值−2.60e-49.92e-52.62

五个 r 里最大的是梯度范数的 2.62,这次比较就记 2.62,判不过;主 loss 全程三个数里最差的是带符号均值 1.85(待定),后段单独再判一遍是 2.03(不过)。纯噪声按同一套算法能拿几分,见 §3.4。

代码:判档:r = |被测| ÷ N,≤1 过、>2 不过 代码:逐步序列的三种统计

N 和 r 的规则,一条不漏:四步造 N、两条自动处理、两级取最差;为什么取最大值

判法一句话:r = |被测| ÷ N,「被测」是 TPU 对基线那一条曲线算出的某个统计量(带符号均值、MARE 或最大单步),N 是 GPU 几份重跑两两成对、同一个统计量里取最大的那个。≤ 1:落在噪声样本的范围里,过;> 2:比最坏的噪声还大一倍,不过;中间待定,先补参照再判(2 是协议事先定的界,留出样本少时 N 偏窄的余量)。

参照对按跟被测一模一样的窗口、分母算三个统计,每个统计取所有对里的最大值当 N:被测如果只是噪声,就是又一个同分布的样本,应当落在已有样本的范围里。规则逐条:

  1. 同一设置的 GPU 重跑 K 份(混元 3 定案时 10 份;第二次迁移 300 步 8 份、1000 步 16 份)。
  2. 两两配对:C(K, 2) 对(8 份 28 对、10 份 45 对、16 份 120 对)。
  3. 每一对里一份当被测、一份当参照,用跟被测完全相同的窗口、分母、去掉第 1 步的规则,算出三个统计(带符号均值取绝对值)。
  4. 每个统计的 N = 所有对里的最大值;三个统计各有各的 N。

两条自动处理:窗口里逐位相同的参照对剔除,不让它把 N 拉低;剔除后不足 3 对,最多判待定。r = 被测的统计 ÷ 对应的 N;一项检查取三个 r 里最大的,一次比较取所有检查里最大的。≤ 1 过,1–2 待定,> 2 不过;2 是约定的余量,不是统计推导出来的。

判定图和一条序列的完整算例(课上不讲):三种颜色的判定区、混元 3 定案前那次判定、一条序列两个窗口六个数
判过不过:被测值 ÷ 噪声上限 N N = 噪声参照里每一对运行算出来的同一个量,取绝对值最大的那个;r ≤ 1 就像多跑了一次噪声,r > 2 远超噪声能解释的范围 通过 待定(加参照,或者去定责) 不通过 例子:v5p 当前配置的两次判定(实测)—— 红黄点:定案前,基线是另一份 GPU 记录(不是开场那份);绿点:定案后,对修好的 golden、尺子 45 对(都在讲 golden 时细说) 过 待定 不过 0×N 1×N 2×N 3×N 4×N param_norm 3.45 loss 第 2–1000 步 1.92 loss 第 301–1000 步 1.29 grad_norm 1.14 定案后四项 0.50–0.85 每一项用三个统计各算一个 r,最差的决定这一项;图上画的就是最差的那个
落在哪个颜色里,就是什么判定。
红黄点是定案前那次判定,基线和尺子都跟第一节不同,所以 loss 的倍数跟第一节那张图(N 的 2.45 倍)对不上;绿点是定案后。
出处与口径

📌 实测(定案前那次):被测是 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 以后的同四项,全部过。

照着算一遍:一条序列 → 三个数 → 除以 N → 取最差 上:窗口只决定拿哪一段求平均,原始数据只有一份;下:r 怎么算出来、在两级上怎么取最差(算例数字都是实测) 被测对参照的 dₜ GPU 重跑 取最大 Ⓐ 一条序列,两个窗口,三种 reduce(混元 3,TPU 对 GPU 第一份,逐步 loss 相对差) d₀ 全程窗口:第 2–1000 步,999 个数 后段窗口:第 301–1000 步,700 个数 ← 第 380 步 每个窗口算出三个数(不是滑动平均) 全程 后段 带符号均值 -1.30e-4 -1.66e-4 MARE 1.53e-4 1.79e-4 最大单步 6.65e-4 6.65e-4 第 1 步单独报:d₀ = +2.5e-6,不进窗口 两个窗口读的是同一条序列 Ⓑ 从 K 份运行到一个 r(第二次迁移,TPU 自比,FSDP 改纯数据并行,前 300 步) GPU 重跑 8 份 同一设置 两两配对 C(8,2) = 28 对 每对算三个统计 同窗口、同分母、去第 1 步 各取 28 对里最大 → 三个 N 剔除逐位相同的对 不足 3 对最多待定 被测的三个统计 ÷ N 带符号均值 MARE 最大单步 一项检查取最大 主 loss 全程 5.58e-6 ÷ 3.01e-6 = 1.85 8.84e-6 ÷ 6.72e-6 = 1.31 3.70e-5 ÷ 4.53e-5 = 0.82 1.85 主 loss 后段 9.22e-6 ÷ 4.54e-6 = 2.03 1.11e-5 ÷ 8.46e-6 = 1.32 3.70e-5 ÷ 4.53e-5 = 0.82 2.03 梯度范数 2.60e-4 ÷ 9.92e-5 = 2.62 5.23e-4 ÷ 3.85e-4 = 1.36 1.84e-3 ÷ 2.24e-3 = 0.82 2.62 其余 5 项都 ≤ 1 · 后段 = 第 101–300 步(200 个 dₜ) 一次比较取最大 2.62 > 2:超出尺子 照着这四步就能自己算:dₜ → 窗口里三个统计 → 各除以 N → 检查、比较两级各取最差
上面一条序列配两个括号;下面一路除下来,最后取最大。
上块是混元 3、下块是第二次迁移的算例,数都是实测。
出处与口径

📌 Ⓐ 实测:混元 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,1000 步的 MTP loss;dₜ =(TPU − GPU 基线)÷ GPU 基线 背景:GPU 两两 28 对每步最大 |dₜ| GPU 另外 7 份对同一基线(细:逐步;粗:50 步平均) TPU 对同一基线 TPU 50 步平均 看这张图分两步 -1.5×10⁻⁴ -0.75×10⁻⁴ +0.75×10⁻⁴ +1.5×10⁻⁴ 0 最大单步 第 941 步 ① 出没出带?几乎没有(87% 的步在带里):单步不乱跳 ② 围不围着零?GPU 7 条灰色平均线时上时下;TPU 深红线一直在零上面 第 1 步 第 500 步 第 1000 步 三个数 ÷ 尺子 带符号均值 ② 偏不偏 3.02 不过 +2.08e-5 ÷ 6.87e-6 平均绝对差 抖多大 1.15 待定 2.97e-5 ÷ 2.58e-5 最大单步 ① 出不出带 0.94 过 1.35e-4 ÷ 1.43e-4 1:以内过 2:以上不过 抖动和尖峰都在 GPU 自己的范围里,只有方向不对:一直往一边偏,带符号均值是尺子的 3 倍
灰线来回穿过零,红线一直在零上面。
出没出带看单步乱不乱跳;围不围着零看有没有系统偏差。7 条灰线和背景带都只用来看,尺子仍是 28 对两两的最大值,判定按右边三个数。
出处与口径

📌 实测:第三次迁移图文 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 倍,判不过。抖和尖都正常,只有方向不对。

这张图的细数:三个 r、7 条灰线是什么、灰带怎么画、后来定位到哪

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 步的平均)的图,同样只用来看趋势。

参照要几对、比较只对一份(课上不讲):几对参照纯噪声超线的概率、GPU 对 GPU 演练、换一份当基线读数挪多少、口径与旁证
参照对太少,尺子就太短 —— 3 对时,纯噪声至少四分之一会「超线」 左:柱高 = 一个纯噪声的被测超过 n 对参照最大值的概率,1/(n+1),是下限;右:第一阶段 100 步的 GPU 对 GPU 演练(本该全过),一格一条检查,橙色 = 判成待定 推导(纯噪声) 实测:待定 实测:通过 纯噪声超线的概率:下限(本课推导) 25.0% 3 对 9.1% 10 对 6.25% 15 对 3.4% 28 对 2.2% 45 对 第一阶段 100 步的 GPU 对 GPU 演练:本该全过(实测) GPU 对 GPU 3 对 46 条检查,8 条待定 GPU 对 GPU 15 对 重判那 8 条+梯度范数 1 条:剩 3 条待定 GPU 对 GPU 28 对 重判全部 46 条:只剩 1 条 百步级短窗口每种设置至少跑 6–8 份(15–28 对);1000 步要更多(第二次迁移用 16 份 120 对)
左边是道理,右边是实测。
左边柱高是配对彼此独立时的下限,模拟和留一法实测都显示带符号均值约翻倍;右边那次演练里,被测和参照是同一种设置,本该全过。
出处与口径

⚠️ 本课推导:被测若只是噪声,而且它和 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 量的是「两份运行之间差多少」,被测也该是跟一份运行比,两边口径才一样。对平均比太松,对最差比太严。代价是基线自己也是一个样本,换一份当基线,读数会挪一点(图在折叠里)。

换一份当基线,读数挪多少(图):10 份 GPU 运行各自当基线时,偏移读数怎么挪
基线只是 10 份里的一份,还贴在右沿 —— 量到 10 份的中心,TPU 照样偏 横轴 = 尾段 loss 的带符号均值(对基线那一份,越往左越低);灰点 = 同设置的 GPU 运行,圈出的是基线自己;细灰线 = 到基线,粗蓝线 = 到 10 份均值 GPU 同设置 10 份 TPU 三种跑法 10 份的均值(虚线) 第 301–1000 步 loss 带符号均值(实测) −2.0e−4 −1.5e−4 −1.0e−4 −5.0e−5 0 基线自己(= 0),10 份里排第 3 高 10 份的范围 −6.5e−5 到 +2.4e−6 10 份均值 −2.46e−5 原样 到基线 −1.66e−4 到均值 −1.41e−4 不重算 到基线 −1.35e−4 到均值 −1.10e−4 改片上内存上限 到基线 −1.03e−4 到均值 −7.84e−5 N 取最大值,兜住了「基线贴边」;被测值被带偏多少,拿 10 份的均值重算一遍就看得出
被圈的灰点就是基线;粗蓝线才是扣掉噪声中心以后的偏移。
灰点竖着错开只为不重叠。
出处与口径

📌 实测:同一设置(默认设置、不开分布式优化器)的 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。灰点竖着错开只为不重叠,没有纵轴。

口径与旁证:这把尺子只含执行噪声;A/A 测试;逐步的绝对差不是判定量
  • 本课的噪声只含执行噪声:随机种子和数据顺序两边都固定。
  • 尺子只能借同设置的重跑:第二次迁移换成生产配方(学习率调度、YaRN(长上下文位置编码的扩展)、路由偏置零均值三样一起改)跑 1000 步时,同配方的 GPU 两份拿旧配置的尺子一量,自己就 r 4.12 —— 借来的尺子不适用;补同配方 GPU 当尺子重判:先补到 8 份(这把尺子是看过借尺判档才定的),后来事先登记再补到 16 份,两回都是 TPU 九项全过(只跑了 1 份,最差 0.996)。主 loss 的带符号均值那一项,这把尺子比旧配置宽 4.8 倍:配方一换,GPU 自己的波动就变了,尺子得跟着重量。
  • 做线上实验的人有个老问法 ——「要是两边其实一模一样,这个差有多稀奇?」两组都吃安慰剂,叫 A/A 测试(Microsoft ExP 团队的 A/A 测试博客)。样本少时它会骗人:同一套超参只换随机种子跑 10 次,分成两组各 5 次,两组曲线就能「统计上显著不同」(Henderson 等,Deep Reinforcement Learning that Matters,arXiv:1709.06560)。
  • 另一种读法是看某一步的绝对差(例:「第 975 步参数范数多 +1.99e-2」),那是看漂移的形状用的,不是判定量。

3.4 份数要够:纯噪声也能拿到两倍上下

为什么尺子只用 GPU 重跑(课上不讲):TPU 重跑逐位相同;日常回归另有一把 TPU 尺子

日常回归里判「只换了舍入位置」的改动,另有一把故意改执行参数造出来的 TPU 尺子(§10.3),跟这里的验收尺子是两件事。尺子为什么只用 GPU 重跑?第二次迁移里,TPU 同一个程序重跑,换一组机器、换一个集群,结果都逐位相同:拿它当尺子,宽度是 0,什么都判不过。硬给 TPU 造点波动来撑宽,又成了被测给自己定门槛(§4.3)。

第二次迁移一次比较要看 8 项检查(7 条曲线,主 loss 开两个窗口),每项 3 个统计,一共 24 个 r,最差的那个说了算。每个数超过自己尺子的机会不大,24 个里总有一个超的机会就大了。纯噪声按同一套判法能拿几分?把 GPU 的重跑轮流拿一份当被测,试一遍:

代码:留一法 代码:尺子的入门(文档)

纯噪声互相比,也常常超线 一个点 = GPU 重跑里挑一份当被测、一份当基线,尺子用被测以外的各份(含基线)两两重算;判法跟 TPU 一样:几十个 r 取最差的(300 步 24 个,1000 步 27 个) GPU 对 GPU(纯噪声) TPU 改动:空心 = 8 份尺子,实心 = 16 份尺子 同一把判法,先拿纯噪声试一遍(实测) 0 1 2 3 r = 被测的差 ÷ 尺子 N 过 待定 不过 300 步 · GPU 8 份 56 种轮换 纯噪声最大 2.47 59% 过 1,11% 过 2 1000 步 · GPU 16 份 240 种轮换 纯噪声最大 1.82 22% 过 1,没有过 2 的 1000 步 · TPU 六个改动 8 份时压线或越过 2 的 TPU 没重跑,只换了尺子 1000 步、8 份时纯噪声最大 2.00 8 份尺子:2.00–2.75 16 份尺子:1.19–1.64 r 在 1–2 之间,先别急着判错:纯噪声自己就常常到这里
灰点是纯噪声,不少落进「待定」那一格(1 到 2 之间)。
出处与口径

📌 实测(第二次迁移,小尺寸模型):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 改动就是这样落定的。「分不开」不等于「没改精度」:这六个里有两个动了精度,这把尺子只是量不出来(第十节)。

坦白:这条读法是看到结果以后才补的;为什么份数少,带符号均值最吃亏
  • 事后补的:「拿纯噪声的最差 r 对一下」是 TPU 那批结果出来以后才想到的读法,所以它只用来解读,不改判档;对齐记录先把它登记下来,再拿之后的新改动和新尺寸去检验它站不站得住。尺子从 8 份扩到 16 份,也是看到灰区以后才定的,那六个改动是重判,不算前瞻检验;那几天梯度范数的分母也同时统一成了参照,两样一起换的,各占多少没拆。
  • 口径要对上:1.82 是一整次比较几十个数里最差的那个。同一种轮换单看一条检查,纯噪声能到的最高分各不相同:主 loss 全程 1.29、后段 1.23,参数范数 1.58,路由偏置均值 1.82(本课按对齐记录的逐种轮换数据算)。拿哪一条的 r 去比,就要比那一条的最高分。
  • 份数少,尺子偏窄:N 取各对的最大值,样本越少越窄(§3.3)。8 份补到 16 份,各项上限放宽 1.0–2.1 倍,多数检查里放宽最多的是带符号均值(路由偏置均值 2.07 倍、梯度范数 1.84 倍),MARE 多半只放宽一成上下。原因(本课推导):带符号均值量的是每份运行整体偏在哪,两两之差的最大值就是这几份里最高减最低,份数越多这个极差越大;MARE 是每一步抖动的平均,各对差不多。
  • 能不能先算出来:一个统计量超过 n 对最大值的机会,约 1/(n+1) 起;带符号均值约翻倍(模拟和留一法实测都显示),因为基线和那几份参照运行是共用的,配对彼此不独立。几十个统计量要是各自独立,至少一个超的机会是 1 − (n/(n+1))^m(本课推导)。300 步:尺子 21 对、24 个统计,算出 67%,实测 59%;1000 步:105 对、27 个统计,算出 23%,实测 22%。这里算出和实测对上,是凑巧:配对共用运行让单个统计量超线的机会变大,统计量彼此相关又让「至少一个超」变小,两头抵消了。判档以留一法实测为准,规则不变。
  • 为什么补份数,不按 Bonferroni 把门槛加严:Bonferroni 等于把每把尺子都按「看了几十个数」加严,可这些数彼此相关,那样会过严(推断)。粒子物理找新粒子时也有同样的问题(look-elsewhere effect),修正系数靠模拟来算;我们的模拟就是 GPU 多跑几份,直接量「几十个里最差那个」在纯噪声下落在哪。
  • 门槛不变:判档仍是 ≤ 1 过、> 2 不过;「跟重跑分不开」是另起一列的读法。不干脆把 2 改大,是因为纯噪声能拿几分取决于份数和检查条数(300 步 8 份 2.47、1000 步 16 份 1.82),没有一个放之四海的数;该做的是把份数补够。
考考自己:尾段 loss 的带符号均值 r = 1.6,MARE r = 0.9,最大单步 r = 0.7,怎么判?

三个量里最差的决定结论:1.6 落在 1–2 倍之间,判待定。待定不能直接签:先加参照重判;再看纯噪声按同一口径能到多少(§3.4)—— 这里只看尾段 loss 一条,1000 步、16 份时纯噪声在这一条上最高 1.23,1.6 已经超了,往下一级去定责;拿整次比较的 1.82 来比就比松了。

这一节留下的问题:偏在哪一层、哪个张量?

第 四 节

指标(二):张量

第三节的曲线每步只有一个标量,说得出「偏了」,说不出偏在哪。这一节换另一类度量:第 1 步的激活、梯度、权重,一个张量压成一个数;几个指标各管一类错,各有盲点。

比的是哪四类张量、几个张量怎么合成一个数:逐张量取最差;参数范数是另一回事;按能量合起来只用来定责
  • 四类:权重(FP32 主权重,每步舍成 BF16 再用);激活(前向每层的中间结果);梯度(反向里对参数、对输入的导数);优化器状态(Adam 的两个动量)。
  • 判定逐张量:每个张量单独拉直、单独算 rel_L2;一条检查选中一批张量时取最差的那个,不把它们拼成一个大向量 —— 拼起来,大张量会把小张量上的错淹掉。
  • 参数范数不是张量比较:它是每一步把全部主权重(约 124 亿个元素)合成的一个数,§3 的逐步序列比的是它。
  • 按能量合成:一组张量当一个大向量,√(Σ‖a − b‖²) ÷ √(Σ‖b‖²),R 比同理。只用来回答「整体差多少、整体谁离精确更远」(§4.3 的 1.28e-3、§9.5 的整网 R),不当门槛。

4.1 rel_L2、cos、范数比

一个张量出一个数:rel_L2 主判,cos 和范数比各补一个盲点 灰箭头 = 参照(GPU);彩色箭头 = 被测(TPU);红色虚线 = 两者之差 a − b,rel_L2 就是它的长度 ÷ 灰箭头的长度 参照 b 被测 a 差 a − b 被测 = 参照 × 2 cos = 1(看不出) rel_L2 = 100% 范数比 = 2 一样长,转了 2.56° cos = 0.999(看着很近) rel_L2 = 4.5% 范数比 = 1 谁看得见什么 整体 × 2 方向偏 个别大错 rel_L2 ✓ ✓ ✓(分不清哪种) cos ✕ ✓ ✓ 范数比 ✓ ✕ ✕ 长度相同、差很小时 1 − cos ≈ ½·rel_L2²: cos 0.999 ≈ rel_L2 4.5% 主判看 rel_L2:差占信号几成;梯度一定要配范数比
红色虚线的长度就是 rel_L2。
中格的角度放大了画。
出处与口径

⚠️ 本课推导:同长度、夹角 θ 时 rel_L2 = 2·sin(θ/2);cos θ = 0.999 → θ ≈ 2.56°,rel_L2 ≈ 4.47%。图里中格的角度放大了 6 倍画,方便看见。

📌 指标一律在 FP64 里算:两个相近的数相减本身是精确的,丢精度的是后面的平方和、点积和除法。

rel_L2 说差多大;拆开看,cos 说方向偏没偏,范数比说长短变没变。三个一起报,才分得清是转了个角还是整体缩放。

三个指标是一回事的三个侧面:rel² = (k − 1)² + 2k(1 − cos);纯旋转为什么 rel_L2 不是 0

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 看着很近,差向量已经不短了。

其余几个指标:宽度比、均值偏移、零元素比例、逐元素 p99、最大绝对差、KL,以及只诊断不当门槛的 ULP
指标抓什么看不见什么
宽度比分布变宽变窄只看宽度
均值偏移 ÷ 宽度整体往一个方向偏了几个宽度:偏置、缩放类错只改宽度不改均值的错
零元素比例差多出来或少掉的稀疏:漏了 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 格)。所以它只诊断,不能判过不过。

4.2 谁的错:对 FP64 的 R 比

1 距离rel_L2(被测, 参照) = ‖被测 − 参照‖ ÷ ‖参照‖ (全部元素,FP64 里累加;两边等长时 rel_L2² = 2(1 − cos))
2 拿到梯度g = m₁ ÷ (1 − β₁) ÷ 裁剪系数 (第 1 步从一阶动量倒推,β₁ = 0.9)
3 对基线d = rel_L2(被测, 基线) ÷ 尺子 (尺子 = GPU 第 1 步重跑几份两两的最大差,下限 2⁻²⁰)
R = rel_L2(被测, FP64) ÷ max(rel_L2(基线, FP64), GPU 几份离 FP64 的中位数)

这是 TPU 自比的写法。GPU 搬 TPU 时没有基线那一项:R = TPU 离 FP64 ÷ GPU 几份(现行规则至少 6 份)离 FP64 的中位数。多出一份同量级、互相独立的舍入误差,误差平方相加:R ≈ √2 ≈ 1.41,所以线画在两者之间的 1.2

超出尺子、R ≤ 1.2:只是换了加法顺序
平台固有,记「换了顺序」,不修
R > 1.2:这一步多舍了
丢了精度,去查被测那一边,找到多舍的那一步
例子(实测)被测离 FP64参照离 FP64R记作
qkv 投影,打开 FP32 累加之前(混元 3,v5p)2.33e-31.89e-31.235丢了精度
同上,打开以后1.89e-31.89e-31.000换了顺序
表里另外几行:词嵌入(修好了却照样超尺子)、8 个设备、视觉塔;路由翻转怎么记
例子(实测)被测离 FP64参照离 FP64d(超尺子几倍)R记作
词嵌入梯度,纯数据并行(第二次迁移)1.51e-24.17e-3(GPU 中位数)5.893.62丢了精度
同上,修好以后3.79e-34.17e-31.360.91换了顺序
8 个设备,往里投的那批投影(第三次迁移)2.35e-31.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 就在这里派上用场。

TPU 离 GPU 远了,先问:两边各离真值多远 靶心 = 各用自己的输入在 FP64 里算的真值;R = TPU 离靶心的距离 ÷ GPU 离靶心的距离;底色 = 落在这一圈该怎么读 GPU 的距离(R = 1) 门槛 R = 1.2 多舍一次 R ≈ 1.41 单个算子:注意力的 qkv 投影(实测) FP64 真值 R < 1 TPU 更近、GPU 远 R ≈ 1–1.2 平台固有:只是加法顺序不同 R > 1.2 TPU 多舍了:去查 TPU R ≈ 1.41 像是多舍入了一次同量级的数 改之前 R = 1.235(TPU 2.33e-3 / GPU 1.89e-3) 改之后 R = 1.000(TPU 1.89e-3 / GPU 1.89e-3) FP64 不是标准答案,是定责的工具:它告诉你差是谁带来的
先看点落在哪一圈底色里。
灰圈是 GPU 离真值的距离,定为 1;两次独立、同量级的舍入叠起来,误差平方相加:√(1²+1²) ≈ 1.41。
出处与口径

📌 距离都用 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 更准:

小写 r 只说差多少,大写 R 才说谁错 左:r = 两边的差 ÷ GPU 自己的噪声(对称);右:R = TPU 离真值 ÷ GPU 离真值(能定责);示意,距离只表示大小关系 GPU TPU 两边的差 FP64 真值 小写 r:两边差多少 GPU 噪声 差 ÷ 噪声 = r GPU TPU 两个点换个位置,r 一样:说不出谁错 → r ≤ 1:在 GPU 自己的抖动以内 大写 R:各离真值多远 FP64 灰圈:GPU 离真值多远 蓝圈:TPU 离真值多远 R = 蓝圈 ÷ 灰圈 → R ≤ 1.2:只是换了顺序;R > 1.2: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 只是两种舍入之比,会来回摆;这时看绝对值。注:左图两点的距离、右图圆的半径是示意,只表示大小关系。

R 为什么通常在 1 附近,什么时候不能这么读:分母接近 0;两边的精度路径本来就不同
  • 通常 ≈ 1:两边走同一条精度路径(BF16 输入、乘积精确、FP32 累加、出口舍一次),每一步舍入的大小同量级,只是先后顺序不同,离真值的距离也就差不多。
  • 分母接近 0:GPU 那一份碰巧几乎正好(比如结果恰好落在格点上、或那一处根本没有舍入),R 会被除得很大,说明不了 TPU 错。看 R 之前先看分母本身有多大。
  • 误差不到一个 BF16 格:R 是两种舍入实现之比,这时它会随上游一处写法在 0.6–1.6 之间摆(第二次迁移实测)。误差本身还在 BF16 舍一次的量级(rel_L2 1e-3 量级)以内时,R 过了 1.2 先别判 TPU 错,先看两边的绝对误差是不是都只有一格。
  • 噪声是 0 的张量:GPU 重跑逐位相同(第二次迁移里有两层的一组梯度三份逐位),尺子量不出来,只能看对外部参照的 R。
  • 精度路径不同:路由打分那次矩阵乘,GPU 离 FP64 3.8e-6、TPU 4.8e-8,R ≈ 0.013(§5.3)。R 远小于 1 只说明 TPU 这一处离真值近得多,不是「TPU 算错了」;门槛 1.2 只拦一个方向。

两把参照一起用:第 1 步每个张量既跟基线比(超没超出 GPU 重跑的噪声),又跟 FP64 比(离真值远了没有)。超出噪声、离真值没变远,是换了顺序;远了 1.2 倍以上,才是丢了精度。一个张量走一遍:

代码:FP64 参照(GPU 一侧代码在 CPU 上整网 FP64) 代码:从动量反推梯度、逐张量定责、程序指纹

第 1 步逐张量:先量差多少,再请 FP64 判是谁的 一个张量走一遍定责流程;两行算例是同一个张量在两次改动下的读数 第 1 步逐张量 换了顺序 丢了精度 定责流程(第二次迁移,TPU 自比,词嵌入梯度) ① 拿到梯度 一阶动量倒推: m₁ ÷ (1 − β₁) ÷ 裁剪系数 ② 跟基线比 d = ‖被测 − 基线‖ ÷ ‖基线‖ 全部元素,FP64 里累加 ③ 除以尺子 尺子 = GPU 三份两两最大差 不低于 2⁻²⁰;≤ 1 在噪声内 ④ 对 FP64 定责 R = 离 FP64 ÷ max(基线, GPU 中位数) ≤ 1.2 换了顺序;> 1.2 丢了精度 算例:词嵌入梯度(基线离 FP64 4.00e-3,GPU 三份中位数 4.17e-3,尺子 2.48e-3) 离 FP64 对基线 d d ÷ 尺子 R 记作 纯数据并行 1.51e-2 1.46e-2 5.89(超出尺子) 3.62 丢了精度 修复后(FP32 累加) 3.79e-3 3.37e-3 1.36(超出尺子) 0.91 换了顺序 修好以后仍超出尺子,可离真值比基线和 GPU 都近:超出尺子不等于有问题,第 ③ 步之后一定要走第 ④ 步
上面一行四步;同一个张量两次读数,第三步都超出,第四步才分出谁丢了精度。
两行算例都是第二次迁移的词嵌入梯度。
出处与口径

📌 实测(第二次迁移,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 步:梯度从哪来、尺子为什么有下限、1.2 是怎么定的、R 的两种写法、FP64 由谁来算
  • 梯度从哪来:TPU 上不挂钩子(§6),从第 1 步更新后的一阶动量倒推:m₁ = (1 − β₁)·g,所以 g = m₁ ÷ (1 − β₁)(用 Muon 的参数同理,动量缓冲 ÷ (1 − β));裁剪触发过的,再除以裁剪系数 = 阈值 ÷ 裁剪前范数(混元 3 第 1 步裁剪前范数 17.5,系数约 0.057)。用二阶动量独立核一遍,混元 3 第 1 步相对差约 6e-8。
  • 尺子:每个张量各自一个,等于 GPU 第 1 步三份两两的最大 rel_L2;倒推本身会带进几个 2⁻²⁴ 量级的相对舍入,所以尺子不低于 2⁻²⁰,GPU 三份逐位相同的张量也按这个下限算。
  • 1.2 的来历(推断):只差加法顺序时,两边离真值差不多远,R ≈ 1;多一次同量级的独立舍入,误差方差约翻倍,R ≈ √2 ≈ 1.41;1.2 取在两者之间。
  • R 的两种写法:本节(GPU 搬 TPU)R = TPU 离 FP64 ÷ GPU 几份离 FP64 的中位数(2026-11-11 起 GPU 6 份、两两 15 对;TPU 自比仍按 3 份);GPU 几份逐位相同、且两边离 FP64 都小于一次 BF16 舍入(2⁻⁸ ≈ 3.9e-3)的张量,比远近没有意义,直接按过。TPU 自比时分母换成「基线、GPU 中位数里离得远的那个」,门槛同为 1.2。
  • FP64 由谁来算:一律用 GPU golden 那一侧的同一套模型代码(TPU 自比时也一样),在 CPU 上把第 1 步整网改成 FP64 重算;被测一侧的代码一行不用。裁判不能来自被测。

顺带记一句:逐步曲线和第 1 步两样都过,才敢说这个改动只是换了求和顺序。

两类尺子怎么配合:两样都过,才是只换了顺序 行:逐步曲线过没过尺子;列:第 1 步有没有丢精度的张量 没问题 再查一步 按 bug 查 四种组合 第 1 步:没有丢精度的张量 第 1 步:有丢精度的张量 曲线:分不开 只是换了顺序,不是 bug 多是曲线没灵敏到那一处 曲线:超出 多半是第 1 步之后的事 按 bug 查 曲线说有没有差、差多大、怎么随时间攒;第 1 步说差在谁身上、是换了顺序还是丢了精度
先看右下那格:两样都不过,按 bug 查。
四格各一个例子在图下出处。
出处与口径

📌 四格各一个例子(第二次迁移,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 上的读数)。

第 1 步逐张量:一把尺子量差多少,另一把量离真值多远 每个蓝点 = 一个参数张量第 1 步的梯度(每块 160 个) 横轴 r:跟 TPU 基线差多少 ÷ GPU 自己重跑差多少(> 1 超出噪声) 纵轴 R:离 FP64 真值多远 ÷ 原来离真值多远 (> 1.2 丢了精度) 两轴都是对数刻度 一个参数张量 词嵌入梯度 在噪声里 超出噪声但只换了顺序 丢了精度 v5p 换 v7x 0.1 1 10 100 1e3 1e4 0.2 1 5 30 1.2 横轴 r:对基线的差 ÷ GPU 噪声(对数) 纵轴 R:离真值 ÷ 原来(对数) 在噪声里 超出噪声,只换了顺序 丢了精度 词嵌入 超出噪声 148/160 离真值变远:0 → 换了顺序 FSDP 改成纯数据并行 0.1 1 10 100 1e3 1e4 0.2 1 5 30 1.2 横轴 r:对基线的差 ÷ GPU 噪声(对数) 纵轴 R:离真值 ÷ 原来(对数) 在噪声里 超出噪声,只换了顺序 丢了精度 词嵌入梯度 3.6 倍 超出噪声 159/160 离真值变远:1 关掉编译器的省舍入 0.1 1 10 100 1e3 1e4 0.2 1 5 30 1.2 横轴 r:对基线的差 ÷ GPU 噪声(对数) 纵轴 R:离真值 ÷ 原来(对数) 在噪声里 超出噪声,只换了顺序 丢了精度 词嵌入梯度 26.1 倍 超出噪声 160/160 离真值变远:2 超出噪声不等于出错:离真值没变远,就是换了顺序;变远了,才是丢了精度
先看红虚线上面有没有点。
横轴对数,大于 1 就超出 GPU 噪声;纵轴对数,红虚线是 1.2。
出处与口径

📌 实测(第二次迁移,小尺寸模型,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 倍,只是换了顺序。中、右两块飞得远的都是词嵌入梯度 —— 为什么偏偏是它,第八节整节讲。

这张图的口径(课上不讲):没画的 45 个小参数、换 v7x 为什么仍判「超」、换运行库后的读数

九成张量超出 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 倍刚过线)—— 为什么偏偏是它,第八节整节讲。

4.3 第 1 步,一个专家的梯度大得离谱

这是逐张量比较会误判的一个反例。混元 3 那次,第 1 步的梯度,比到的 50 个张量合起来 rel_L2 是 1.28e-3;第 3 层 0 号专家的两个矩阵是 0.102,是它的约 80 倍。GPU 自己重跑这两个张量一位不差,尺子宽度是 0,照字面就是「不过」;对不对,要靠 FP64 来判。

先想一想这个专家的梯度差了这么多倍,是 TPU 的专家矩阵乘算错了吗?
路由翻转的静态图:的名次与长红柱(下面动画讲的是同一件事)
第 8、9 名一对调,一个专家就换了一批 token 左格:同一个 token 的专家名次,上面 8 名入选(共 192 个专家);右格:这个专家换了几个 token、梯度差多大(柱长按 rel_L2 线性画) GPU TPU 对调的两名 / 偏差来源 名次表:同一个 token,两边的第 8、9 名对调 GPU TPU 1 2 3 4 5 6 7 8 9 10 专家 A 专家 B 专家 B 专家 A 以上入选 以下落选 ⋮ 后面还有 182 名 第 8、9 名分差:中位数 2.7e-5–6.3e-5 (条长是示意;真实差小到画不出来) 后果:这个专家的梯度差 第 3 层 0 号专家分到 139 个 token TPU 换出 3 个 换进 1 个 一个点 = 一个 token 这个专家的梯度(rel_L2) 0.102 50 个张量合起来 1.28e-3 GPU 重跑 0 路由不变,尺子宽度 0 约 80 倍 差出在路由上,不在专家的算术上
左边两条红框换了位置,右边就多出一根长红柱。
名次条的长短和被换掉的点位是示意,个数和柱长是实测。
出处与口径

📌 实测:第 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 名对调」和分差中位数是实测;右格点阵的个数是实测,哪几个点被换出是随手标的位置。

输入只差一丝,近平局的 token 就换了专家;分到 token 少的专家,第 1 步梯度差被放大到 0.102。 (29 秒,Manim 渲染,可一步一步看。条的高度、每个分数挪动的量和放大框里的分差是示意(取在实测中位数范围内);其余数字是实测。)

MoE 的路由给每个 token 挑前 8 名专家(共 192 个),有的 token 第 8、9 名几乎平局;上游注意力两边舍入差一点点,排名就对调,选中的专家换了。给路由器喂两边完全相同的输入,翻转是 0;根子在路由器的输入差,不在路由打分那次矩阵乘。

翻转的细账:分差多小、输入差多大、换出换进几个、为什么是 √(k÷n)

翻了的 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 不一样。

FP64 那边的细账:50 个张量的 R、1.04 为什么是上限、哪些读数没查到

比到的张量: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 只改片上内存上限,路由也会翻

会翻的不只是两种硬件:同一个 TPU 程序只改编译器的片上内存上限,这两个专家梯度就差 0.080(TPU 对 GPU 是 0.105)。我们一度以为只改执行方式路由不翻,其实这只在逐层隔离回放(每层输入取同一份,§6.2)里成立。

不选专家的层也会被带偏:第三次迁移的图文模型里,视觉塔的 q、k 梯度越线

第三次迁移的图文模型(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)。

这条规矩怎么来的:两次迁移都把 TPU 的波动并进过尺子,又撤回

混元 3 当时在第 1 步这一级把 TPU 只改执行参数的重跑也并进尺子(并集,§9.5),后来撤掉,按只用 GPU 的尺子重判:第 1 步整步改判「不过 · 已解释」,多步那一级的结论不变。第二次迁移在多步那一级也并过一次,随后撤回。(正文的 0.105 是 TPU 对 GPU、并集那组运行当前配置的读数,前面的 0.102 是更早那次。)

口径与旁证:翻了多少槽位;推理和训练两套引擎也翻
  • 隔离回放(每一层喂 GPU 那一层的输入,§6.2)里有 0.44–0.56% 的路由槽位翻了(3.5–4.5% 的 token 至少换了一个专家)。正文「每层翻 3.5%–5.4%」是另一种回放量的;两个比例来自两种量法不同的回放,不是开关造成的:那三个开关开不开,路由逐位不变。
  • 翻转不一定要紧:第二次迁移的稀疏注意力要给每个 query 挑一批 token,第 1 步 GPU 对 FP64 就有九成以上的 query 至少翻了一个(占全部槽位 0.147%);可把 GPU 的选法灌给 FP64 注意力,输出误差几乎不变 —— 翻的都在名次的边上,那些 token 的注意力权重很小。所以翻转要报,不能拿「有翻转」直接判不过,要看翻掉的那一份有多重:MoE 里分到 token 少的专家就很重。
  • 同一份模型用推理引擎和训练框架各跑一遍前向,约 10% 的路由选得不一样,94% 的 token 至少在一层换了专家(Ma 等,arXiv:2510.11370)。常见的建议是路由打分用 FP32(Megatron Core 的 MoE 文档)—— 这里两边的路由打分本来就输出 FP32(输入仍是 BF16),挡不住。
考考自己:TPU 某层的梯度 cos = 0.99999,可范数比是 2.000。可能是什么错?

方向全对、整体大了一倍:典型的「漏除了一个系数」,比如每卡每步 2 个微批,累加完忘了除以 2(本讲的配置正是每卡 2 个)。cos 对整体缩放完全看不见,靠范数比才抓得到。

这一节留下的问题:R 超线,根子都在某一次舍入上 —— 两边的硬件到底在哪儿舍入?

第 五 节

浮点与硬件:差从哪来

这一节只讲两个案子,都是第三次迁移碰上的:一个换了设备数,一个换了梯度累积。先铺一句底:一次矩阵乘先两两相乘、再把乘积加起来,乘是精确的,舍入落在加法上。

两个案子,各一个数 案子一(§5.3):8 个设备上,几个投影离 FP64 是 GPU 的 1.41 倍,像多舍了一次;同样是投影,另两个正好 1 倍。
案子二(§5.4):换到 32K 序列,1000 步主 loss 偏离,是 GPU 噪声尺子的 7.8 倍;4K 上验过「没用」的一个开关,在这里管用。
收成一句:换了条件,之前的验证就不作数。
两边对不上,差只有三种(课上不讲):噪声、语义、精度
两边对不上,差只有三种 先分清是哪一种,再决定修不修:顺序是噪声,精度要定责,语义必须对齐 顺序 精度 语义 两样都有 ① 只换了加法顺序 a + b + c vs a + (b + c) 精度一样,舍入落在不同的地方 怎么认:结果不逐位,但离 FP64 没变远 怎么办:不修,噪声尺子兜住 ② 丢了精度 16 → 32 → 16,一侧多舍一次 或长求和越加越偏、32 位函数本身不准 16 位 怎么认:离 FP64 变远;找到多舍的那一步 怎么办:定责,离真值远的那边修 ③ 语义不同 x ÷ (1 − βᵗ) vs x 两边写的根本不是同一个公式 怎么认:读代码对公式,差常常很大 怎么办:必须对齐,参照找不到就不算 第二次迁移查清的 30 条根因(本课归类) 1 精度 22 1 语义 6 「两样都有」「顺序」各 1 条 差的大头是精度:一个值在 16 位和 32 位之间换挡、一次长求和越加越偏;顺序只是噪声
先认是哪一种,再决定修不修。
中间那排小线是示意;底下的条数是本课按对齐记录逐条归的类。
出处与口径

📌 第二次迁移的根因一览一共 30 行,每行「根因」一栏都标了它属于哪一类边界或语义;本课据此归成四堆:精度 22(16/32 位交界、矩阵乘精度档、长求和、超越函数与优化器里的实现精度、编译器省掉的舍入、FP32 里病态的记录写法、GPU 一侧在 BF16 里算的旋转位置编码、一处累加写法(第八节揭晓)、多路残差流梯度的舍入写法)、语义 6(设置、优化器公式、框架里一处 bug(扫描层共用缩放、累积时最大 logit 被求和)、辅助 loss 的加权与重标写法、统计量取法、算法边界)、两样都有 1(输出头单遍 BF16 是精度,整层重算重选路由是语义)、顺序 1(四路相加配对还是依次,对上它只为照 GPU)。

⚠️ 归类是本课做的,对齐记录里没有这四个数。

5.1 乘是精确的,加才舍入

指数一样宽、尾数不一样长 —— 乘是精确的,加才舍入 一格 = 一位;红 = 符号,蓝 = 指数(决定范围),绿 = 尾数(决定精度) 符号 指数 尾数 虚线白格 = 不用的位(TF32 那 13 位、乘积空出的 8 位) 浅灰底深灰框 = 加法里的大数(只示位数) 三种格式 FP32 1 附近一格 2⁻²³ ≈ 1.2e-7 TF32 1 附近一格 2⁻¹⁰ ≈ 9.8e-4 BF16 1 附近一格 2⁻⁷ ≈ 7.8e-3 BF16 × BF16 → FP32:乘积放得下;加法要对齐,挤出去的位要舍掉 乘 8 位有效数字 × 8 位 1 1 BF16 只存 7 位尾数,前面还有一位不存的 1(白格),所以有效数字是 8 位 = 16 位放进 FP32 的 24 位,还空 8 位:精确 加 大数(24 位) 小数往右对齐:挤出 24 位窗口的 10 位要舍掉 普通 FP32 加法:就近舍入(可能进一位) 张量核怎么舍:见下一节的折叠 两个硬件都是「BF16 乘、FP32 累加」,BF16 输入时差别在累加那一步怎么舍
蓝色一样宽,绿色不一样长。
下半的对齐位数是示意。
出处与口径

📌 位宽: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 位,所以只要不溢出就精确。

5.2 GPU(B200)张量核:每 16 个一组,抹零

只记一句,第七节要用:GPU 张量核每 16 个乘积一组,低位直接抹掉,绝对值只少不多,求和越长,朝零偏得越多。

张量核怎么抹零:公式卡、实测曲线、动画、外面的测量(课上不讲)
1 分组每 16 个乘积 p₁…p₁₆,连同累加器 a,一组一起加
2 对齐按这一组里最大的指数 e_max 对齐
低于 2^(e_max − 25) 的位,直接丢掉(朝零)

组内相加后写回 FP32,也朝零;「16」「25」是在 B200 上拟合出来的,不是厂商规格:拿它重算三层路由打分,4096 × 192 个元素逐位对上,改成 8 个一组、24 位或就近舍入,命中率都掉到 1% 以下

四舍五入:有进有舍
每一项都比累加值的一格大得多时,误差有正有负、大体抵消
抹零:每单都亏
累加值越长越大,窗口往高位挪,后来的小项被丢的比例越来越大:越长越偏
量的是什么(朝零的相对偏差)短中长
合成正数输入,K = 256 / 4,096 / 65,536(输出写回 BF16)2.2e-57.0e-53.1e-4
只算截断模型(推断,没写回 BF16)约 3e-7约 1.1e-5—
FP32 不走张量核≤ 5e-8

短求和那一格比只算截断大得多(截断只给约 3e-7),差在哪没拆;正负两组输入在这一格也不对称,像噪声多过偏差。截断要到长求和才主导。

GPU 张量核:每 16 个一组,低位抹掉 —— 只少不多,加得越长少得越多 左:一行 = 一个乘积(对齐后);虚线右边 = 窗口外的低位,被截掉。右:横轴 = 一次求和加多少个乘积(对数),纵轴 = 结果朝零偏了多少(对数) 留下的位 截掉的位(向零) 实测:GPU BF16 张量核 实测:FP32 不走张量核 一组 16 个乘积 + 累加器,按最大指数对齐(实测的 B200 模型) 累加器 乘积 1 乘积 2 乘积 3 乘积 4 乘积 5 乘积 6 乘积 7 乘积 8 乘积 9 乘积 10 乘积 11 乘积 12 乘积 13 乘积 14 乘积 15 乘积 16 最高位后 25 位 偏差随求和长度长大(实测,合成正数输入,输出写回 BF16) 1e-08 1e-06 1e-04 K = 256 K = 4,096 K = 65,536 2.2e-05 7.0e-05 3.1e-04 只算截断(推断) 这一点比只算截断大,差在哪没拆 FP32 不走张量核:≤ 5e-8 抹零每一项都亏,长了就积成朝零的系统偏差;四舍五入只有每项都不到半格时才亏,每项比一格大得多时有多有少、能抵消
左边虚线右侧的红格全被丢掉,右边那条线一路往上。
右图画的是偏差的大小(对数刻度),符号是负的、朝零;合成数据,不是模型里的数。
出处与口径

📌 实测的 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 口径不同;两者差多少、差在哪,没有单独拆过。另外动画纵轴带正负号(朝零偏画成负的),这张右图画的是偏了多少,取的绝对值。

抹零一路往下,就近舍入在 0 附近晃:同一次求和,越长偏得越多。 (24 秒,Manim 渲染,可一步一步看。数据是按实测张量核模型在合成正数输入上的模拟,不是实测曲线;右边那条只叫「就近舍入(对照)」,不代表任何一家硬件。)

收银台的比方:每一单抹零,单单都只少不多。张量核就是在每 16 个乘积这一单上抹零,而一次长求和有成千上万单。看上去是 FP32,末尾那几位其实从来没算过。(抹零只是一种偏法:小项相对整个和小到一定程度时,就近舍入也会把同号的小零头整个吞掉,见下面折叠。)

慢一点:张量核这一单是怎么抹零的:对齐窗口、截掉移出去的位、为什么越长越偏;十进制的例子
  1. 普通的浮点加法:两个数相加,小的那个先右移对齐;移出去的那几位不扔,留几位保护位,加完再就近舍入。每一项都比累加值的一格大得多时,误差有正有负、大体抵消;可一大串同号小项、每项都不到半格时,就近舍入也会整项舍掉,同样偏向一边(§7.5 的 FP32 一次累加就是这样)。张量核的抹零不用等到这一步:每一单都截,只少不多。
  2. 张量核一次加一单:16 个乘积加上当前的累加值,一起相加。
  3. 对齐到最大的那个指数:这一单里谁的指数最大,所有数都往它对齐,只保留最高位往下大约 25 位的一个固定窗口。
  4. 移出窗口的位直接扔掉:不留保护位,不舍入。扔掉的永远是绝对值的一部分,所以每一单的误差都朝零。
  5. 越长越偏:单数越多,丢得越多,而且同一个方向;累加值越长越大,窗口跟着它往高位挪,后来的小乘积被扔掉的比例越来越大。

十进制的例子(示意,只留 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 公开的规格。

外面的人怎么量到同一件事:V100 到 B200 的张量核测量、FP8 上的同类问题;附两种不抹零的加法作对照
  • V100、T4、A100 三代上就有人量出:张量核里乘积精确,加法向零舍入,只在最后规格化(Fasi、Higham、Mikaitis、Pranesh,Numerical behavior of NVIDIA tensor cores,PeerJ Computer Science,2021)。
  • 对 H100/B200 的比特级建模,BF16 进、FP32 出:16 项一组对齐、截断,累加器比 FP32 多 2 个对齐位(等价于本课说的「最高位后 25 位」),H100、H200 与 B200 相同 —— 跟本课在 B200 上独立量出的模型一致(Khattak、Mikaitis,Accurate Models of NVIDIA Tensor Cores,arXiv:2512.07004)。
  • 同一类问题在 FP8 上更凶:DeepSeek-V3 报告实测 H800 上 FP8 矩阵乘的累加只保留约 14 位,于是每 128 个元素搬到 CUDA core 用 FP32 加一次(arXiv:2412.19437 sec. 3.3.2)。口径不同,只借问题的类型,不比大小。
  • 对照:Kahan 求和是每一单把抹掉的零头记账、下一单补回去,误差几乎不随长度长;成对求和像淘汰赛,误差随长度按对数长。张量核的抹零正好是反面。
考考自己:一段长求和在 GPU 张量核上算,输入全是负数,结果会偏大还是偏小?

朝零偏:结果的绝对值偏小,数值上是偏大(离零近了)。截断总是丢低位,正数、负数都是往零的方向少一点 —— 这是「抹零」,不是「往下取整」。

5.3 8 个设备才出现的多舍

TPU 的矩阵单元怎么累加;混元 3 那次(课上不讲)

TPU 的矩阵单元 MXU 同样吃 BF16、乘积精确、在 FP32 里累加。同一份输入算路由打分,TPU 对 FP64 的相对误差是 4.8e-8,GPU 是 3.8e-6;长求和上 TPU 也会偏,但小得多。

MXU 怎么累加:MXU 的累加怎么舍是推断;「BF16 乘、FP32 累加」的公开出处

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。

先想一想同样是 BF16 矩阵乘、同样是投影,凭什么分成两拨?(答案在下面这张图的上半)
同一刀,落在求和维上要加,落在输出维上只拼 y = x·W。FSDP 把 W 切成 8 片、每个设备存一片;切开的那一维在左边是求和维(多数是模型宽度,q_b、kv_b 是低秩维),在右边是输出维 一片权重 要加起来 只拼起来 往里投:FSDP 切开的是求和维(q_a、gate、up……) 激活 x(每个设备上完整) 模型宽度:按片对上权重 × 权重:按行切 8 片 8 份部分和 形状都是整个 y y = x₁W₁ + x₂W₂ + … + x₈W₈ 8 份必须加起来:在什么精度里加,决定多出多少误差 往外投:模型宽度是输出维(o_proj、down) 激活 x(每个设备上完整) 另一维,不切 × 权重:按列切 8 片 8 段拼起来 y = [ x·W₁ | x·W₂ | … | x·W₈ ] 每个输出元素仍是一次完整的求和、只舍一次,跟 GPU 一样 第三次迁移,单算子回放(8 个设备):TPU 离 FP64 ÷ GPU 离 FP64(R) 实测 q_a q_b kv_a kv_b 输出门 稠密 MLP 的 gate、up 共享专家的 gate、up 往里投的 7 种:TPU 离 FP64 2.35e-3、GPU 1.66e-3 → R 1.41 o_proj 稠密 MLP 的 down 共享专家的 down 往外投的 3 种:R 1.00 判据:FSDP 切的那一维,是不是这次矩阵乘的求和维
左边每片给出整个 y 的一份,要加;右边每片给出 y 的几列,只拼。
q_a、q_b 和 kv_a、kv_b 是 MLA 里 q、kv 各两个低秩投影,o_proj 是注意力输出投影。形状只画关系,不按比例;底下一行是实测。
出处与口径

📌 实测:对齐记录里第三次迁移的单算子回放(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 次:

同一个往里投的投影:4 个设备先收齐、一次乘完,舍 1 次;8 个设备边传边乘,红块一格格冒出来,舍 6 次;打开投影 FP32 累加,又只舍 1 次。 (28 秒,Manim 渲染,可一步一步看。循环体结构取自编译产物;片从顶上落下只表示这一段用到哪几片,不画环上谁传给谁。)
舍了 6 次,为什么只有 1.41 倍(课上不讲)

实测 R 1.41。部分和小,舍掉的也小;按 6 次各自独立粗算约 1.6 倍,实测更低的原因没查清。

为什么 8 个设备才出现:代码一行没改,只是设备数变了。同一份生产配置为不同设备数离线编译来数(下图右边):4 个设备一个这种循环都没有,8 个、16 个各二十个。切法没变,也不看矩阵大小,拆不拆是编译器按快慢定的(设备少为什么不拆是推断,见图下出处)。

设备一到 8 个,编译器把一次矩阵乘拆成几段 —— 一次求和舍 6 次 同一个投影、同一种 FSDP 切法;变的只是编译器选「先收齐再乘」还是「边传边乘」。红块 = 一次舍到 BF16 矩阵乘 累加器 舍到 BF16 留在 FP32(不舍) q 低秩下投影的一次前向(编译产物显示) 4 个设备 先收齐,再乘 整块收齐权重 (整块 all-gather) 一次矩阵乘,2816 宽 FP32 累加到底 ① 舍 1 次 8 个设备 生产原样:边传边乘 第 1 轮(片 1–4) 片 1+2 704 宽 ① 片 3+4 704 宽 ② 累加器 += 两份 ③ 第 2 轮(片 5–8) 片 5+6 704 宽 ④ 片 7+8 704 宽 ⑤ 累加器 += 两份 ⑥ 舍 6 次 8 个设备 打开投影 FP32 累加 第 1 轮(片 1–4) 片 1+2 704 宽 片 3+4 704 宽 累加器 += 两份 第 2 轮(片 5–8) 片 5+6 704 宽 片 7+8 704 宽 累加器 += 两份 ① 舍 1 次 离线编译训练步:累加器是 BF16 的循环 实测 v5p · 4 个设备 0 (不拆) v5p · 8 个设备 20 个循环 v5p · 16 个设备 20 个循环 v7x · 16 个设备 20 个循环 打开开关后 0 (全部变 FP32) 单算子 R:1.41 → 1.00 在 4 个设备的小切片上验精度,这件事完全看不到
数每一行的红块:1 个、6 个、1 个。再看右边,4 个设备那一行是空的。
左边三行的结构取自编译产物;右边是离线编译训练步数出来的。
出处与口径

📌 编译产物显示(第三次迁移,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。

打开前后各级读数:第 1 步逐张量、1000 步曲线、步时(单份运行,曲线分不开)
看哪一级打开前打开后
单算子:那批投影的 R1.411.00
整网第 1 步:超出 GPU 两倍噪声的梯度张量91 个63 个
1000 步:主 loss / 梯度范数 / 参数范数的 r1.14 / 0.93 / 0.970.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 的张量是怎么回事

第 1 步剩下的 63 个超 2N 的张量里,离 FP64 比 GPU 远(R > 1.2)的 8 个,还没定责的 3 个(打开前 10 个、6 个);再按路由翻转定责,这 3 个都归到路由翻转,剩 0(打开前剩 2)。

两个旁注:混元 3 上同一个开关为什么没动曲线;这跟 MLA 有没有关系

混元 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,也是工具和生产切法不一样。用回放之前,先拿编译产物对一遍:工具里的程序和训练步里的,是不是同一种写法。

这个开关在代码里怎么开:JAX、PyTorch 各叫什么;反向那几处要不要一起改

落到代码上,是给那处矩阵乘指定 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 累加、只舍一次

5.4 32K:同一个舍入,4K 程序里在,32K 程序里被删

现象。第三次迁移换到 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 倍左右。

4K 上「没用」的开关,32K 上只补它一处就回到尺子以内 第三次迁移:RMSNorm 先把 FP32 的 scale 舍成 BF16 再乘(照 GPU),用「转 BF16 再转回」写。右:32K 上逐个加开关二分;左:两边乘的 scale 离 1.0 多远 GPU:乘 BF16 的 scale TPU 32K:乘 FP32 的 scale 主 loss 偏差 为什么到几十步以后才显出来:scale 离 1.0 多远 实测 + 外推虚线 0 50 100 150 200 250 训练步 0 5.0e-04 1.0e-03 1.5e-03 GPU:BF16 副本头 150 多步都是 1.0 3.2e-04 6.5e-04 9.5e-04 TPU:乘 FP32 原值,每步偏开约 6.4e-6 第 200 步起 GPU 才有元素跳格 二分:32K,在已开的基础开关之上逐个加(主 loss,是尺子 N 的几倍) 实测 ≤ 1 在噪声内 1 2 10 50 上组:300 步运行,看第 51–300 步 不加(第 2 级,1000 步运行) 53.6 倍 投影 FP32 累加 54.0 倍 精确超越函数 54.1 倍 精确 Adam + 正交化迭代的舍入 53.3 倍 四处一起(下组拆开) 1.97 倍 下组:120 步短跑,看第 51–120 步(四处拆开) 只加其余三处之一(三条运行) 约 28.3 倍 只加 RMSNorm scale 0.54 倍 在一个配置上验过「这个开关不用开」,换了配置要重验
左边蓝线一路往上、灰线贴着零;右边只有一根短绿条(只补 RMSNorm scale)在尺子以内(r ≤ 1)。
左边虚线是外推;右边两组窗口不同,组内比。
出处与口径

📌 实测:对齐记录第三次迁移,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(各一份)。

省舍入是怎么回事、别的例子、写法规则(课上不讲):融合里省掉的舍入;关掉它会怎样;第二次迁移的一例;会被删的六处;MTP 输入
excess precision 改的是「舍在哪儿」 —— 关掉它,位置定了,不等于更准 从左往右是一串算子;红色小块 = 一次舍到 BF16,数一数每行有几块、落在哪;虚线框 = 编译器融合成的一块(块里不落地) GPU 上的算子 TPU 上的算子 舍到 BF16 显式写的那一次 示意:同样四个算子,四种舍法 GPU:逐个算子 一个算子一个 kernel,输出写回 BF16 算子 1 舍 算子 2 舍 算子 3 舍 算子 4 舍 舍 4 次 每个算子出口一次 TPU 默认 excess precision 开:块里不舍 算子 1 算子 2 舍 算子 3 算子 4 舍 舍 2 次 落在融合块边界上 关掉 excess precision 块还在,块里照写的舍 算子 1 舍 算子 2 舍 算子 3 舍 算子 4 舍 舍 4 次 位置跟 GPU 那一行一样 只在一处显式写 开关不动,写「舍到 BF16」 算子 1 你写的 算子 2 舍 算子 3 算子 4 舍 舍 3 次 写了的那处一定舍 开着时少舍几次,离精确值更近,可舍入落在哪由融合怎么切说了算;关掉换来的是位置确定
数每一行的红块:第二行少了,第三行又回到第一行的位置。
四个算子、融合怎么切都是示意。
出处与口径

📌 实测(混元 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 关掉它的三条读数;v7x 上变远的地方;TPU 为什么会「更精确」;后端指令条数
混元 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 的乘和加。静态条数看不出它们会不会多舍一次。

一个坑:「先转 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。

第二次迁移的一例:一处中间值两处用,一处没舍;1000 步五次偏高(下面 RMSNorm 那件讲的是同一件事)

第二次迁移里,同一件事成了一处真正的偏差。GPU 在一处中间值上每次都存成 BF16,TPU 的代码也写了「转 BF16」;可把紧挨着的一处四路加权和照 GPU 的顺序改了(从配对相加改成依次相加,§5.5)以后,这次舍入在 TPU 上丢了一半。这是在一个最小复现里看到的:编译后的程序里「转过去再转回来」都还在,可后端生成指令时,算均方那一步用的是没舍的 FP32,归一化输出那一步用的是舍过的值,两步不再用同一个数:

编译器省掉一次舍入,1000 步 loss 五次同号偏高、四次出了噪声 横轴 = 1000 步主 loss 的带符号均值(TPU 对 GPU 8 份平均,×1e-6);灰段 = GPU 自己两两最大的差;一个点 = 一次 TPU 运行 GPU 自己的噪声 TPU 运行 强制舍入以后 同一 TPU,三版代码,同一把尺子 −4 −2 0 +2 +4 +6 +8 +10 改顺序之前 改顺序以后(5 次) 两处强制舍入以后 GPU 自己最大 ±3.8e-6 GPU 每次都把中间值存成 BF16;TPU 上这个值后面两处用,归一化输出那处舍了,算均方那处没舍:值更精确,跟 GPU 反而对不上
中间一行五个点都在零的右边,四个出了灰段。
一个点是一次 1000 步的 TPU 运行;三行都是实测,「省了一半」的机制在最小复现里看到。
出处与口径

📌 实测(第二次迁移):五次 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 舍,编译器不会删

写法规则:四种想要的效果,各怎么写;第三次迁移上会被删的六处(含 MTP 输入、MTP 输出头 logits 各一处)

省舍入还有一个副作用:代码里写「转 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 落在同一颗融合里」的位置。

图文 32K 又查到一处:多 token 预测层的输入少舍一次,MTP 层梯度一齐差几乘十的负三次方

多 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 折叠)。

两个案子收成一句换了设备数、换了梯度累积,之前的验证就不作数;在小切片上、在 4K 上验过的,到生产配置上要重验。

5.5 课上不讲的三件:TF32 开关、16 位和 32 位的交界、超越函数

TF32:开关说的不算:读回来是关,矩阵乘照样走 TF32
「我关了 TF32」不算数 —— 开关读回来的值,和实际跑的不一样 柱长 = FP32 矩阵乘对 FP64 的误差(对数刻度,一格 = 十倍,越短越准);左边小字 = 那一刻 torch 的开关读回来是什么 实际走 TF32 实际是真 FP32 判据线(虚线) GPU 训练容器里的 FP32 矩阵乘(实测) 1e-7 1e-6 1e-5 1e-4 1e-3 只关 torch 的两个开关 读回 allow_tf32 = False;Transformer Engine 那条路照样走 TF32 2.94e-4 设 NVIDIA_TF32_OVERRIDE=0 读回 allow_tf32 = True(!);两条路都关了 1.15e-6 判据:启动时实测 ≤ 1e-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 有没有影响

BF16 训练里,TF32 只碰输入本来是 FP32 的矩阵乘(本例第 1 步只有路由反向那十来次),所以「BF16 设置下关不关 TF32 没影响」和「精确参照必须真关 TF32」两句并不打架。

开关为什么这么乱:PyTorch 各版本的默认值和一个压过一切的环境变量

三层开关,各管各的。PyTorch 的开关只管 PyTorch 自己的 cuBLAS 句柄;Transformer Engine 绕开 PyTorch 自己调 cuBLASLt,对纯 FP32 的矩阵乘一律请求 TF32 快速模式,不看 PyTorch 的开关;NVIDIA_TF32_OVERRIDE=0 是 cuBLAS 库自己读的,压在所有调用者之上,PyTorch 不读它,所以这时 PyTorch 的开关读回来还是「开」。读回值是请求,不是库实际做了什么。训练里真正以 FP32 输入的矩阵乘只有路由的反向,恰好走 Transformer Engine。

FP32 输入的矩阵乘(1024×4096 乘 4096×1024)对 FP64 的 rel_L2,实测
设置PyTorch 矩阵乘Transformer Engine 矩阵乘
默认(训练容器打开 TF32)2.94e-42.94e-4
只关 PyTorch 的开关1.15e-62.94e-4
设 NVIDIA_TF32_OVERRIDE=0(PyTorch 读回仍是开)1.15e-61.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 将弃用。

差几乎都出在 16 位和 32 位的交界:边界表、输出头三档、病态、MTP 头
每个算子两边各画一条精度路径,分开的那一格就是要对上的边界 前四格:线高 = 值在 32 位、线低 = 16 位;最后一格数舍了几次;蓝线蓝字 = TPU,灰虚线黑字 = GPU;红底 = 两边分开的那一格 TPU GPU 两边不一样 五个例子,五列各一个 输入 乘法 / 矩阵乘精度 累加 输出 / 存储 舍在哪 改哪边 路由打分:乘哪份权重 第二次迁移 FP32 主权重 BF16 权重 FP32 里乘 FP32 FP32 打分 — 改 TPU 名义 FP32 的输出头 第二次迁移;第三次迁移又遇到 FP32 默认:单遍 BF16 真 FP32(TF32 关) FP32 FP32 — 改 TPU FSDP 切开求和维的投影 混元 3 查清并修过、第三次迁移又碰上 BF16 BF16 × BF16 每段输出、累加器都舍 BF16 FP32 里加完 BF16 随累加那格 改 TPU 注意力打分 q·k 第二次迁移 BF16 BF16 × BF16 FP32 留 FP32 先存 BF16 softmax 在 FP32 改 GPU RMSNorm 输出 第二次迁移 BF16 FP32 里算 FP32 BF16 TPU 舍 2 次 GPU 舍 1 次 改 TPU 两条线重合、格里的字也一样,才只剩加法顺序的差(噪声);分开一格,就是一个要对上的边界
每一行先找两条线分开的那一格:五个例子,五列各一个。
例子取自三次迁移;只讲在哪不一样,不讲差多大。
出处与口径

📌 出处:第 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)

HIGHEST 也只是近似:多遍 BF16 拼的;编译器还可能把它改写成逐元素 FP32

要更接近 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%。

输出头三档的图与读数:为什么第 1 步看不见、三档怎么选

生产的输出头写 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,判不过。

默认精度档舍的不是激活,是离开格点的主权重 —— 第 1 步看不见,离开格点就差几千倍 第三次迁移的输出头:logits = x · W,x 是 BF16,W 是 FP32 主权重;两边升成 FP32 交给矩阵单元,精度档没单独设 主权重(FP32) 默认档舍回格点 BF16 格点 为什么第 1 步看不出来(示意) 第 0 步 主权重在格点上 舍了不变 训练 1 步后 主权重离开格点 默认档舍回格点,差出这一截 用 high 拆成两段 BF16 算 3 遍 剩一点点 logits 对 FP64 的相对误差(单独回放这一次矩阵乘,实测) 对数刻度 1e-7 1e-6 1e-5 1e-4 1e-3 默认 · 格点上 1.1e-07 默认 · 模拟离格 1 步 1.3e-03 默认 · 模拟离格 10 步 1.9e-03 high · 模拟离格 10 步 5.9e-06 highest · 模拟离格 10 步 1.4e-07 主机真 FP32 · 离格 3.7e-07 三档怎么选:前 300 步主 loss 的 r,条尾是步时(单份运行) 1:过 2:不过 默认(1 遍,生产原样) 7.32 步时基准 high(3 遍) 1.03 步时 +5.7% highest(6 遍) 1.31 步时 +12.3% 推荐 high:high 和 highest 都回到噪声附近(单份运行,分不开),high 代价约一半
左边第二行那一截红线,就是右边红条比灰条长出来的那三到四个数量级。
左格是示意;右格和下面三张卡是实测,单份运行。
出处与口径

📌 实测:对齐记录第三次迁移,单独回放输出头这一次矩阵乘,输入取 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 步测不出来,主权重得先走出格点;判这类开关要看曲线,或者拿训练几步后的权重单独回放。

边界清单:两次迁移碰到的十三类(本课整理,单列了「Python 常数」一类),各举一例
边界例子怎么对上
矩阵乘 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 的写法逐个算子舍
路由打分要 FP32top-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),排查时另列。

十分钟看代码:grep 哪些词,两行对照怎么写

两边代码里搜这些词,每一处都是一个可能的边界: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 步逐张量梯度普遍是 GPU 噪声的 2–3 倍,没有哪一处突出

第二次迁移第 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)。

考考自己:TPU 上把一处矩阵乘的两个操作数都转成 FP32,别的没改。为什么离 GPU 的真 FP32 还差末位?

默认精度下它只算一遍 BF16;设成 HIGHEST 是多遍 BF16 拼出来的近似。但写着 HIGHEST 不算数,要看编译后的样子:编译器若把它改写成逐元素 FP32 乘加,差的就只剩加法顺序,归到「顺序」那一格。

病态:小数是两个大数相减:一个小量若是两个大数相减得来的,大数上差一格,小量上就差一大截。查到一个小标量对不上,先问它是不是这样算出来的、被放大的那一格是谁的。 例子:第二次迁移里一项 KL 辅助损失,船上称船长;四问认出病态,再找被放大的那一格
小数是两个大数相减时,f32 差一格就是几个 1e-3 —— 病态是放大器,不是根因 左边:在一杆称船的秤上称船长;右边:前三问认出放大器,第四问找被放大的那一格是谁的 大数(船、lse) 小数(船长、KL) 秤的一格 船上称船长(比方;比例跟实测一样) 船 + 船长 7,100,110 公斤 空船 7,100,000 公斤 两次相减 = 110 公斤:船长只有船的约 1/65,000,两根条看不出差别 放大到船长那一截:一格 0.47 公斤 船长 110 公斤 差一格 = 船长体重的 0.43% 船 log-sum-exp ≈ 7.1 船长 辅助损失 KL ≈ 1.1e-4 秤的一格 f32 在 lse 处一格 ≈ 4.73e-7 一格 = KL 的 4.3e-3;实测偏低 0.12%(一行对 FP64),同一量级 病态还是 bug:问四件事(实测) ① 它的输入,两边离参照一样近? 三组输入:R 0.94–0.99 ✓ 1.2 GPU TPU ② 由它出发的梯度,两边一样近? 20 个张量:R 0.81–1.05(最大那个 GPU 6.81e-3、TPU 7.14e-3) ✓ 1.2 GPU TPU ③ 大数相减剩小数、差在一两格内? lse 对 FP64:平均 −0.95 格 ✓ -2 -1 0 1 2 单位:f32 的格 ④ 那一格是谁的?同样的计算换 CPU 算 CPU(PyTorch)−0.004 格,TPU −0.95 格 → CPU TPU ①–③ 是:病态在放大;④ 指向 TPU 的 exp、log 换高精度写法:lse −0.953 → +0.025 格;300 步 r 3.67 → 0.01 ①② 有一条不是 → 回到五格表找边界 病态把一格以内的差放大成 1e-3 量级;放大器认出来以后,还要问被放大的那一格是谁的
红色那一小截就是秤的一格。
船和船长是比方,比例跟实测一样;右边四问是实测。
出处与口径

📌 实测(第二次迁移,第 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 步那一项的系统偏差没了。

后来还有两步:记录写法本身病态;GPU 自己也偏

这项 KL 的记录写法本身在 FP32 里病态(CPU 上调同一个函数也偏高),改记一种等价的广义 KL 以后,1000 步带符号均值的 r 1.06 → 0.69,三个统计里最差的 0.85,由待定变过;梯度一位不变。真实宽度上 GPU 自己记下的这一项也偏高,约六成来自 GPU 把索引器的旋转位置编码放在 BF16 里算。所以「更准就是更像 GPU」只在 lse 那一格成立(同一代还开了另一个开关,没拆开)。

FP64 怎么把它拆出来:逐项重算同一行,差只剩最后那一步

把一行的原始输入存下来,在 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)上也偏同样多,那一格就是两边都躲不开的末位,才写「不过,已定责」。

MTP 头:就近舍入也会一边倒:舍之前乘的系数不同,正确词那一项两边往相反方向舍

现象。第三次迁移的图文模型 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。方向相反。

同一次舍成 BF16,往哪边舍,看值落在格距里的什么位置 正确词那一项 = 系数 ×(p_y − 1),p_y = 1e-5;一行 = 一个格距,0 = 左格点,1 = 右格点 GPU TPU N 取 2 的幂 本课复算:FP32 里乘好,再按 BF16 就近舍入 GPU:乘 0.1 以后舍 舍后 +9.9e-4(相对) 0.80 左格点 右格点 中点 TPU:乘 0.1 ÷ N 以后舍(N = 60,915) 舍后 −1.5e-3(相对) 0.33 对照:N 取 2 的幂(65,536) 舍后 +9.9e-4(相对) 0.80 就近舍入只在值随机落在格距里时才无偏;这一项挤在同一个格距里,往哪边舍由舍之前乘的系数决定
红点过了中点往右舍,蓝点没到中点往左舍;灰点跟红点在同一个位置。
本课复算,p_y = 1e-5。
出处与口径

⚠️ 本课复算: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 的偏差,原来被抵掉了大半,来源在查:单份读数指向一处被编译器省掉的舍入,未定论。

超越函数:TPU 默认的 exp、log 差几十格(v5p):格数与写法

主结论: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 降不下来。

超越函数的格数与算法:两代芯片的格数(图);软件怎么把 exp 算准;第二次迁移里 sigmoid 改准了整网反而更偏;第三次迁移的编译产物
精确超越函数的开关:v5p 上管用,v7x(运行库 0.0.46)上降不下来 第三次迁移,同一份输入、同一种算法;柱高 = 最大误差(格),对数刻度 v5p 默认 v5p 开 v7x 默认 v7x 开 虚线:GPU(exp 是 CUDA 文档观测值、不作保证;其余 B200 实测) 逐元素最大误差(实测) 1 10 100 105 1 64 64 exp GPU 2 62 3 2 2 log GPU 1 83 3 30 30 sigmoid GPU 3.4 86 4 29 30 silu GPU 3.4 换芯片要重验开关:同一个开关,在一代芯片上管用,在另一代上可能几乎不起作用
v5p 两根柱子从几十格掉到 GPU 虚线附近;v7x 两根一样高,exp 还在虚线上面一大截。
对数刻度;v5p 两根就是下一张图左格的数,这张多了 v7x。
出处与口径

📌 实测:对齐记录第三次迁移,逐元素对 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 默认的 exp、log 差几十格,GPU 只差个位数 左:条长 = 对正确舍入的最大误差(格,对数刻度);右:高精度的软件 exp 和倒数,分几步算 TPU 默认 TPU 高精度写法 GPU 最大误差,按格计(实测) 1 2 5 10 20 50 100 200 exp 105 1 2 log 62 3 1 sigmoid 83 3 3.4 silu 86 4 3.4 高精度的软件实现:分三步(示意) ① 区间缩减 x = k·ln2 + s,|s| ≤ ln2 ÷ 2 把大范围的 x 压到一小段 ② 多项式 eˢ ≈ 1 + s + s²/2 + … + s⁶/720 s 小,几项就到 FP32 末位 ③ 乘 2ᵏ 只改指数位,精确 eˣ = 2ᵏ · eˢ 倒数:牛顿修正 y ← y·(2 − a·y) 每修一次,误差平方一次 默认的 exp 不只是粗,还系统偏低:真实输入上只有 6% 正好舍对,平均偏 −2.5 格
左边看蓝条比灰条长多少。
对数刻度;右边是教科书做法的示意。
出处与口径

📌 实测(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 的水平。

第二次迁移 sigmoid 改准的经过:高精度开关对 sigmoid 不起作用;改解析式前后的读数

高精度开关对 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 的折叠)也各换过一次,每次都推翻了之前的验证。

考考自己:TPU 上的 sigmoid 比 GPU 粗几十格,换成跟 GPU 一样准的写法,两边就该对上了吧?

不一定。单算子对上,整网未必:第二次迁移把 sigmoid、silu 换成三四格的写法后,单算子跟 GPU 一样准,整网 loss 先偏得更多。说明还有别处没对上:查到一处是反向公式跟 GPU 不同,改成同一个解析式才收拢。要逐处查、整网再验。

这一节留下的问题:在 TPU 上,怎么把中间的张量拿出来,又不改动结果?

第 六 节

观测:在 TPU 上怎么看

要定位,就得把中间的张量拿出来看。GPU 上随手挂个钩子就行;TPU 上不行:钩子会把编译器融合好的一块切开,舍入位置跟着变,量到的已经不是生产程序。

在 TPU 上「看一眼」会改掉你要看的东西 —— 证据要从程序外面拿 方块 = 算子;虚框 = 编译器融成的一块;红色小块 = 一次舍到 BF16;放大镜 = 抓数的钩子 GPU 的算子 TPU 的算子 一次舍到 BF16 钩子不改数值 !钩子改了数值 GPU:钩子读的是已落地的数 矩阵乘 归一化 激活 矩阵乘 每个 kernel 的输出本来就写回显存, 钩子读的是已经落地的数 开不开钩子:逐步逐位相同 (确定性设置下实测) TPU:多一个输出,融合就变了 生产程序:舍 1 次 矩阵乘 归一化 激活 矩阵乘 舍 加了钩子的程序:舍 2 次 矩阵乘 归一化 激活 矩阵乘 舍 舍 ! 多一个输出:融合切开 切口多舍一次 ! 和生产程序不再逐位(v5p 实测) TPU 上三条不扰动的路 ① 步与步之间读状态 主权重、两个动量;梯度从动量倒推 g = (mₖ − 0.9·mₖ₋₁) ÷ 0.1 ÷ 裁剪系数 ② 隔离回放 拿 GPU 的输入,单独编译一层来跑 ③ 固定探针 每 25 步单独编译跑一次前向 规矩:生产程序本身就是测量对象,证据从它外面拿
中间那格:虚框被切成两块,就是舍入位置变了。
出处与口径

⚠️ 本课推导: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 折叠里那张省舍入示意图同一种画法);真实的融合怎么切由编译器决定。

这一节只留一句:在 TPU 上,证据要从训练程序外面拿多要一个输出,融合就变,舍入的位置跟着变;所以换三条不碰训练程序的路:步间读状态(6.1)、隔离回放(6.2)、固定探针(6.3)。

6.1 步与步之间读状态,从动量里倒推梯度

主权重、Adam 的两个动量、路由偏置,训练步和训练步之间从状态里读。梯度不用另抓:从相邻两步的一阶动量倒推。

gₖ = (mₖ − β₁·mₖ₋₁) ÷ (1 − β₁) ÷ 裁剪系数 mₖ、mₖ₋₁ 是相邻两步读出来的一阶动量,β₁ = 0.9。
在 TPU 上照做的三个坑:多主机、状态被复用、动量精度
  • 8 颗 v5p 芯片分在两台主机上,切开的状态要用多主机收集(如 JAX 的 process_allgather,把各主机上的分片收齐)或存检查点来读;最省事的是在要看的那段步数里每步存一次检查点。
  • 训练步会复用(donate)上一步的状态缓冲区,喂进下一步以后就读不到了,要先读再喂。
  • 倒推梯度要相邻两步成对存;一阶动量要是被设成 BF16,公式就不准了。裁剪系数从记录裁剪前、后梯度范数的指标文件里取,别从控制台日志抄。整张量上相对差在 1e-7 量级,逐元素在梯度远小于动量的地方不准:两个几乎相等的数相减,有效位被抵消了。

6.2 隔离回放:拿 GPU 的输入,单独跑一层

第 k 层的输入直接用 GPU 那一层的输入,TPU 上只编译这一层;第一个超线的那一层就是出错的那层。设备网格、参数切分、编译参数要跟训练一样:单卡回放看不到 8 个设备才有的那几次多舍(§5.3),会判反。

回放工具自己也要验:第二次迁移一次注入漏了输入

回放工具自己也要验。第二次迁移的单算子回放里,稠密 MLP 的 R 是 1.563:注入只换了按位置传的参数,那个分支按关键字传输入,算子吃的其实是 TPU 自己上游的输入。同一个 GPU 输入直接喂这个算子,R 0.999;修好注入以后 0.95。所以注入要覆盖全部输入,换不了就报错,别悄悄放过。

6.3 固定探针

每隔 25 步,在一条固定的序列上单独跑一次前向,记每一层输出的均值、lse(log-sum-exp,所有 logits 的整体水平)。

读数算不算数(课上不讲):只有不改生产程序的读数能当证据

只有不改生产程序的读数(步间读状态、逐步序列)能当证据;隔离回放和探针是另编的程序,只用来定责、确认修法方向。精度开关在生产程序里生没生效,日常回归直接数生产训练步编译后的程序(舍到低精度的算子、all-reduce、自定义 kernel 调用各几个),边传边乘(编译产物里叫窗口化矩阵乘)只靠整份程序的指纹兜底。

工具表:哪些读数能当生产程序的证据
工具改不改生产程序读数能当什么能比到第几步
步间读状态、倒推梯度(§6.1)不改生产程序的证据逐张量只比第 0、1 步
1000 步逐步序列不改生产程序的证据多步只比标量曲线
隔离回放(§6.2)、固定探针另编一个程序只用来定责、确认修法方向单层、单步
状态互换另编一步分开「这一步算得不一样」和「状态早就不一样」任意一步各算一步
挂钩子、jax.debug.callback改了(切开融合)不能当证据—
为什么分叉以后只比标量曲线(图):一条 FP32 轨迹第 2 步起离两边多远
连权重都不舍的 FP32 轨迹,第 2 步起就走开了:分叉以后只比标量曲线 纵轴 = 主 loss 相对差的大小(对数);灰 = GPU 8 份离 FP32;蓝 = TPU 离 FP32;红 = TPU 减 GPU 8 份均值;空心点 = 该步是负的 GPU 离 FP32 TPU 离 FP32 TPU − GPU 真实权重截层,主 loss,逐步(实测,FP32 轨迹只跑了 30 步) 1e-05 1e-04 1e-03 1e-02 第 1 步 第 5 步 第 10 步 第 15 步 第 20 步 第 25 步 第 30 步 第 8 步:两边恰好穿过 FP32(GPU 9.0e-5、TPU 3.1e-5) 第 20 步:穿到另一侧(GPU −2.0e-4) 第 1 步:TPU −2.0e-5、GPU +6.5e-5 TPU − GPU:30 步全是负的,3e-5 到 1e-4 逐元素、逐张量只在第 0、1 步比;第 2 步起两边各走各的,只比 loss、范数这类标量曲线
蓝灰两条离 FP32 几乘十的负三次方,红线两边之差多数步只有它的几十分之一到百分之一。
这条 FP32 轨迹连权重都不舍成 BF16;只有第 1 步能拿它比。
出处与口径

📌 实测(第二次迁移,真实权重截层,同一批数据上的 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)。

第 1 步逐位相同,不等于开关没用(课上不讲,图):从 BF16 检查点续训时,权重全压在格点上

从 BF16 检查点续训或微调时,有一类开关第 1 步开和不开逐位相同,要过几步才看得出差。

第 1 步开关前后逐位相同,不等于开关没用 —— 权重还在 BF16 格点上 只管权重一侧精度的开关(例:权重按 FP32 乘,还是先舍成 BF16 再乘);左:主权重在不在格点上;右:同一份权重开关开、关差多少 BF16 格点 FP32 主权重(从 BF16 检查点起训) 随机 FP32 初始化起训 Ⓐ 主权重:第 0 步全在格点上,更新以后散开 第 0 步 全部在格点上 第 1 次更新后 全部平均离格点 0.17 格 第 30 次更新后 全部平均离格点 0.25 格 一格 = 2⁻¹³([2⁻⁶, 2⁻⁵) 这一段 BF16 的格距) Ⓑ 同一份权重,开关开、关算出的输出差 1e-05 1e-04 1e-03 1e-02 0 1 10 20 30 40 50 60 训练步 第 1 步 = 0:逐位相同 随机初始化:第 1 步就是 1.7e-3 第 2 步 4.7e-4 几十步后约 1.6e-3 权重一侧的开关,拿训练若干步以后的权重去测,或者看多步曲线;别拿第 1 步「逐位相同」当没用的证据
左边第一行的点都压在竖线上,右边蓝线第 1 步落在 0 上。
两格的数都是玩具实验现跑的,只看第 1 步是不是 0,差多大没有意义。
出处与口径

📌 本图脚本现跑的玩具实验:线性模型 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 上「加一个输出」会改变别的张量的值,哪怕那个输出什么都不改?

TPU 上的程序都由 XLA 整图编译(GPU 上用 JAX 或 torch.compile 也一样)。多一个输出,编译器就得把那个中间值落到内存里,原来融在一起的算子被切开、重新分组,FP32 求和的分组和顺序一变,末位就变(混元 3 实测:融合从 856 个变 859 个);融合里被省掉的 BF16 舍入也可能跟着变。

这一节留下的问题:TPU 的 loss 三百步以后为什么平均比 GPU 低约 1.7e-4?

第 七 节

案例一:loss 偏低,查到是谁的差

混元 3 搬上 TPU,主 loss 三百步以后平均比 GPU 低约 1.7e-4,是 GPU 噪声尺子的两倍多(§1.2)。TPU 算错了吗?这一节按调查的顺序,一条线从现象查到源头,每一步只看一个数;细数和排除过的岔路都收在折叠里,课上不讲。

这一节的调查线(每一步只看一个数;细数在各小节和折叠里)

① 现象(7.1)
−1.7e-4
三百步以后 TPU 的 loss 平均偏低,尺子的两倍多
→
② 拆(7.2)
少压 ¼
没出现过的词那些行,TPU 每步被压得少
→
③ 为什么(7.3)
−0.218
所有 logits 的整体水平(lse),第 300 步 TPU 低
→
④ 是这股力(7.3)
差归零
去掉这个方向,lse 差 −0.33 → −0.007
→
⑤ 谁推歪的(7.4)
6.5e-4
输出头反向那次十二万项求和,第 1 步沿这个方向就差这么多,之后每步同向
→
⑥ 怎么修(7.5)
分块
那次求和改成分块累加,两条参数范数重合,步时 +6%

先把输出头摆清楚:混元 3,隐藏维 4096,词表 120,832,一个微批是一条 4096 个 token 的序列;输入词嵌入和输出矩阵不共用,输出层是单独一份权重。

形状隐状态 H:4096 token × 4096 维  输出矩阵 W:120,832 词 × 4096 维(每个词一行)
① 前向logits Z = H · Wᵀ → 4096 token × 120,832 词 (每个分数是 token 向量和一个词那一行的点积,沿 4096 维求和)
② lossp = softmax(Z) 逐 token;loss = 对所有 token 平均的 −log p正确词
③ 求导dZt,v = (pt,v − [v 是正确词]) ÷ token 数 (正确词一项接近 −1,其余十二万多项是很小的正数,整行加起来精确为 0)
dH = dZ · W  dHt,j = Σv=1…120,832 dZt,v · Wv,j

(4096 × 120,832) · (120,832 × 4096) → 4096 × 4096:中间收缩的那一维就是词表。十二万项的求和只在这一步:输出头反向,把梯度传回隐状态(dgrad)。

为什么偏偏是这一次求和,另外两处为什么没有十二万项(课上不讲)
为什么这次求和最容易出事
一项接近 −1,十二万项小正数,要加出一个很小的结果:大量抵消。每项截掉一点、小项整个被舍掉,相对结果都不小;五万八千多个从没出现过的词,概率越压越小,正是最容易被吞的那批。
另外两处没有十二万项
输出矩阵自己的梯度 dW = dZᵀ · H,收缩的是 token 那一维(4096 项)。输入词嵌入是查表,反向按 token 编号把梯度加回对应行(第八节),不沿词表求和。

7.1 现象:loss 往下、参数范数往上,第 100 步前后一起离开噪声

前 100 步看不出,100–300 步拉开,300 步以后稳定在 −1.7e-4 左右。第 1 步没有、几百步才长出来:是每一步一点点攒起来的。那就看别的每步都记的量,谁也在慢慢长:

loss 往下、参数范数往上:两条线都从第 100 步前后离开噪声 同一条时间轴;对照都是同一份 GPU 基线;灰 = 另两份 GPU 重跑对同一基线,当噪声 GPU 重跑 − 基线(细:逐步;粗:50 步平均) TPU − 基线 主 loss 的逐步相对差 dₜ =(被测 − 基线)÷ |基线| -4×10⁻⁴ -2×10⁻⁴ +2×10⁻⁴ 0 第 301–1000 步平均 −1.66e-4(两份 GPU:−3.78e-5、2.47e-7) 参数范数的逐步差(全部 FP32 主权重平方和开根号,约 3042;绝对差) +0.01 +0.02 0 第 1000 步 +0.021(GPU 自己一千步涨 0.127) 两份 GPU 重跑:最多差 9.9e-04,贴着零 第 1 步 第 100 步 第 300 步 第 500 步 第 1000 步 约第 100 步:两条一起离开噪声 偏移是一步步攒出来的:loss 往下、参数范数往上,同一时间离开噪声
上格蓝粗线往下、下格蓝线往上,都从第 100 步前后离开灰线。
真实的逐步值;灰线是另两份 GPU 重跑对同一基线,粗线是 50 步平均。
出处与口径

📌 实测:混元 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。

细数:loss 偏多少、跟谁比、为什么要查

第 301–1000 步逐步相对差的带符号均值 −1.66e-4(对一份 GPU 基线;另两份 GPU 重跑对同一基线是 −3.8e-5 和 +2.5e-7;开场说的「约 1.7e-4」就是它)。§1.2 那把尺子已经量过:TPU 三种跑法(原样、不重算、改片上内存上限)都在尺子外面,而且方向一致。这一讲的规矩是每一处超出噪声的差都要说得出是谁的,所以得查清它是谁的差。

先别读成「TPU 训得更好」:loss 系统性地低,只说明两条轨迹有系统差别。第 1 步的更新量两边没有差别;前向算子的差第 1 步就该看得到。

先排除两个假警报:步号错位、常数口径
  • 步号错位:被测第 k 步错对 golden 第 k−1 步,也会有稳定的差。故意错开一步再比,MARE(全程)从 1.53e-4 涨到 1.41e-2,大 90 多倍 —— 步号是对的。
  • 常数口径(比如 loss 的分母不同):那种差第 1 步就该在;这里第 1 步只差 2.5e-6,偏移是后来长出来的。

7.2 往下拆:近九成在输出层,四分之三在没出现过的词;这些行 TPU 压得少

漂移近九成在输出层,其中四分之三在没出现过的词那几行 左:柱长 = 这一组贡献的参数范数差;右:柱长 = 输出层平方和多出多少。换算:右 ÷(2 × 参数范数 3042)≈ 左(合计 23.2 → 3.81e-3,对 3.83e-3) TPU − GPU GPU 两次之间(噪声) 按参数分组,第 300 步(实测) 输出层 3.83e-3 占合计 87% 合计减输出层 5.60e-4 合计 4.39e-3;GPU 两次之间输出层只差 6e-6 输出层贡献随步数(3 个实测点) 第 100 步 第 200 步 第 300 步 3.83e-3 输出层按词频分桶,第 300 步平方和差(实测) 没出现过 +17.1 占合计 74% 出现 1–10 次 +3.1 11–100 次 +2.5 100 次以上 +0.5 没出现过的词一共 58,638 行;灰色细条 = GPU 两次之间每桶的差,都不超过 0.21 TPU 上冷门词的行被压得少:从初值算起 GPU 缩了 66.3,TPU 只缩了 49.2
左边一根独大,右边第一根独大。
灰色细条是噪声,短到几乎看不见。
出处与口径

📌 实测:分组参数平方和、逐行平方和都按 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 公式卡与 ε(课上不讲):为什么这些行失去了归一化的保护;ε 不制造、也不放大偏差

这些行的梯度很小,Adam 平时那层按每个元素的梯度大小归一化的保护在这里失效,所以梯度上一点系统偏差每步落在同一边,原样累积。

0 裁剪g ← g × min(1, 1.0 ÷ ‖g‖) (全部梯度按全局范数先裁剪,再进 Adam)
1 两个本子mt = β₁·mt−1 + (1 − β₁)·gt  vt = β₂·vt−1 + (1 − β₂)·gt² (逐元素平方)
2 偏差修正m̂ = mt ÷ (1 − β₁t)  v̂ = vt ÷ (1 − β₂t)
θ ← θ − lr · [ m̂ ÷ (√v̂ + ε) + λ·θ ]

本例:β₁ = 0.9,β₂ = 0.95,ε = 1e-8(加在开根号之后),lr = 1e-5 常数,λ = 0.033(解耦的权重衰减;一维参数如 norm 权重、偏置不衰减)。下文 u = m̂ ÷ (√v̂ + ε):√v̂ 大致就是「梯度有多大」,ε 是分母上防除零的小常数。旁注:梯度长期稳定时 m̂ ≈ g、√v̂ ≈ |g|,u ≈ g ÷ (|g| + ε),只看形状(下面那张图就是它)。

梯度够大,ε 等于没有
√v̂ = 1e-6 时,ε 只占分母的 1%;u 几乎就是 m̂ ÷ √v̂,梯度大小约掉,步子都差不多大
梯度很小,ε 变成一个把更新压小的开关
压小倍数 = (√v̂ + ε) ÷ √v̂;√v̂ 比 ε 小,就压小 2 倍以上,u ≈ m̂ ÷ ε,更新跟梯度成正比
第 300 步,输出层按词频分桶(实测中位数)√v̂ε 在分母里占更新被压小在哪个区
100 次以上(16,326 行)1.17e-50.09%1.001 倍常见区
11–100 次(31,999 行)3.29e-60.30%1.003 倍常见区
1–10 次(13,869 行)2.64e-73.7%1.038 倍常见区
没出现过(58,638 行)2.62e-979.3%4.8 倍ε 区

没出现过的词那 58,638 行,第 300 步有 92% 的元素 √v̂ < ε,也就是被压小 2 倍以上;中位数那一档压小 4.8 倍。压小 10 倍、20 倍以上的各占多少,结果文件里只有中位数和 ε 以下的比例,算不出来,不写。被压小本身两边一样,要紧的是这时更新跟梯度成正比、归一化的保护失效:「ε 在分母里占」那一列,正好就是梯度差 1% 时更新差几成(弹性 ε ÷ (√v̂ + ε))。梯度 4e-9 时 0.71,1e-6 时 0.0099:梯度方向上一点差,在 ε 区原样漏过去。

Adam 的 ε 区:梯度太小,Adam 就不再「拉平」 —— 一点偏差原样漏过去 横轴 = 一个参数的梯度大小(对数);纵轴 = Adam 这一步的更新量(÷ 学习率);稳态下更新 ≈ g ÷ (|g| + ε),ε = 1e-8 Adam 的更新 冷门词的行 常见词的行 更新量 ≈ g ÷ (|g| + ε)(本课推导,稳态近似);下面那条是本例冷门行的实测 1e-11 1e-10 1e-9 1e-8 1e-7 1e-6 1e-5 0 0.5 1 ε = 1e-8 冷门词的行 梯度差 1% → 更新差 0.7% 常见词的行 梯度差 1% → 更新差 0.01% 第 300 步,冷门行 √v̂:92% 的元素在 ε 左边(实测) 中位数 2.6e-9,约为 ε 的四分之一 其余 8% 常见词的行,Adam 把每一步拉成差不多大,梯度里的小偏差被拉平;冷门词的行不会
红区在斜坡上,绿区在平台上。
曲线是稳态近似,只讲形状。
出处与口径

⚠️ 本课推导: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 倍)对两边一样,不影响两边之比。

ε 是干什么的、两种区长什么样、对齐怎么处理
  • 公式:更新量 u = m̂ ÷ (√v̂ + ε),m̂、v̂ 是梯度和梯度平方的滑动平均(带偏差修正)。ε(这里 1e-8)本来只为防止除以零。
  • 常见区(√v̂ ≫ ε):u ≈ m̂ ÷ √v̂,梯度整体偏大偏小都约掉了,每个元素的步子都在 1 附近;梯度上一点相对误差,分子分母一起变,大部分抵消。
  • ε 区(√v̂ ≪ ε):u ≈ m̂ ÷ ε,更新跟梯度成正比:归一化的保护失效,梯度错多少、更新就原样错多少(不放大),而且每一步都错在同一边。
  • 本例长什么样:第 300 步,没出现过的词那些行,92% 的元素 √v̂ < ε,√v̂ 的中位数 2.6e-9,约为 ε 的四分之一;两边这些行梯度大小几乎一样(均方根之比 0.99),差在方向。
  • 对齐怎么处理:两边用同一个 ε(配置对照表里核对),不靠调 ε 把差藏起来;要做的是让这些小梯度本身算准 —— 本例就是去修推歪它们的那次长求和(§7.5)。
  • 外面的人怎么说:梯度的均方根小到跟 ε 同一量级时,Adam 的步子就会跟着变小(Wortsman 等,Small-scale proxies for large-scale Transformer training instabilities,arXiv:2309.14322);PaLM 的报告也提过,冷门词的嵌入二阶矩估得不准(arXiv:2204.02311)。
排除清单:按成本从低到高验过、不是原因的一串(数据、切法、优化器、注意力、重算、规约精度、TF32、十几处 GPU 写法……)

先查配置和名单(几分钟),再跑几十步的短运行,最后才跑 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 步全部复现不出来

7.3 为什么压得少:一股让所有 logits 一起升降的力,两边不一样大

冷门行每步挨多少压,跟着所有 logits 的整体水平走:水平越低,挨的压越小(为什么,见下面「这股力是什么」折叠里的恒等式)。固定探针(§6.3)量的 lse 就是这个整体水平:

有一个方向,能让所有词的 logits 一起升降 —— 那股力每步少一点,几百步就积出来了 左:细箭头 = 每个词那一行权重,粗箭头 = 平均方向 w̄,红箭头 = h 沿 w̄ 的一小步;右:横轴 = 训练步(每 25 步一个探针点),往下 = TPU 的 lse 更低 平均方向 w̄ 隐状态 h h 沿 w̄ 的一小步 TPU − GPU GPU 两次之间 输出头:logit = h · 这个词的那一行 w̄ 隐状态 h h 沿 w̄ 挪一小步 每个词的 logit = h·这一行;各行都带着 w̄ 那一份 → 所有 logits 一起升降 lse(logits 整体水平)差随步数往下走(实测,固定一条序列的探针) 0 -0.1 -0.2 -0.3 第 1 步 第 250 步 第 500 步 第 750 步 第 1000 步 -0.078 -0.218 -0.299 灰线:GPU 两次之间,第 975 步 -0.013 这股力第 1 步只差 6.5e-4(相对;第 100 步 6.1e-4;哪一边少推,后面揭晓),同一个方向、每一步都差,几百步积成 logits 整体水平的差
左边是那个方向,右边是它每步少一点积出来的结果。
左图的箭头是示意。
出处与口径

📌 实测:两边在同一条固定序列上每 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̄:隐状态沿 w̄ 偏一点,打到每一行上,所有词的 logits 就一起偏;反向时,梯度里沿 w̄ 的那一份,就是把所有 logits 一起往下压的力(下面叫「这股力」)。

softmax 看不见整体平移,概率不变;可冷门行不一样:冷门行每步收到的那份「往下压」,沿这一行自己方向的分量,正好等于这个词的原始 logit 按概率加权的和。所有 logits 整体一低,这个分量就小,这一行就缩得慢。

w·g = Σ pᵢ·(w·hᵢ) = Σ pᵢ·logitᵢ 对没出现过的词,一行权重 w 跟它的梯度 g(= Σ pᵢhᵢ)的内积,恒等于这个词的原始 logit 按概率加权求和(输出层没有偏置、不跟词嵌入共享时的精确恒等式;出现过的词还多一项)。
主干那一侧(课上不讲,图):第 0 层最先分开,是第 0 层权重的方向长歪了;跟 w̄ 怎么接上

输出层一行的梯度,等于各个 token 的隐状态按这个词的概率加权求和;所以冷门行往哪偏,取决于隐状态。顺着往回查主干,最先分开的是第 0 层:两边第 0 层权重拿出来,用同一份输入各算一遍,换上 TPU 的权重输出就偏,换成另两份 GPU 重跑的权重偏得小得多 —— 是第 0 层权重长歪了。

冷门行的方向从哪来:第 0 层最先分开,往后逐层放大 —— 是第 0 层的权重长歪了 左:纵轴 = 各层输出(token 均值)沿隐状态方向 ĥ = γ⊙û 的投影,TPU 对 GPU 的相对差,往下 = TPU 更低;右:同一份输入只换第 0 层权重重算,柱长 = 沿 ĥ 低了多少 TPU 对 GPU:第 0 层 第 1–3 层 embedding GPU 两次之间(第 0 层) 大头 残差流固定探针:每 25 步一个点(实测) 0 −5e-3 −1e-2 −1.5e-2 第 100 步 第 300 步 第 500 步 第 1000 步 第 0 层 第 1 层 第 2 层 第 3 层 embedding 第 100 步 −1.8e-3 第 300 步 −5.4e-3 第 50 步起转为偏低 第 0 层权重互换:第 100 步(实测) 整层换掉 · 柱往右 = 输出沿 ĥ 更低 换成 TPU 的第 0 层权重 −1.94e-3 换成 GPU 重跑 A 的 +7.5e-6 换成 GPU 重跑 B 的 −2.4e-4 探针同一步 −1.8e-3 只换一组(换成 TPU 的) 注意力输出投影 −1.33e-3 qkv 投影 −2.6e-4 MLP 输出投影 −2.2e-4 MLP gate/up −6.6e-5;归一化的 scale、q/k 归一化:都在 6e-5 以下 偏低从第 0 层的权重来:同一份输入,换上 TPU 那一份第 0 层权重,就复现了探针量到的偏低
粗蓝线最先往下走,浅蓝线一层比一层低;右边只有换上 TPU 权重那根长。
ĥ:最后一层隐状态的均值方向(û),每一维再乘最后那次归一化的缩放 γ;左图每 25 步一个实测点;探针读的是残差流,第 k 层的读数含前面各层的贡献,所以越往后越低 —— 看的是谁最先分开。
出处与口径

📌 ĥ 是什么:最后隐状态均值的方向,按最后归一化的 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 层的,是输出头流回来的梯度。

外面的人怎么说:z-loss 管的就是这个方向

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̄ 那一份梯度

去掉它:logits 水平差归零,loss 接近噪声,参数范数剩三成;加上它:差就回来了 柱长 = 差有多大(零点 = GPU 第一次运行);灰色带 = GPU 自己重跑的差(噪声),带边标了数 原样:TPU 对 GPU 两边都去掉那个方向 GPU 人为多推一把,对 GPU 默认 loss 平均偏移(第 301–1000 步,相对) 原样 −1.66e-4 两边都去掉 −3.40e-5 GPU 多推一把 −1.26e-4 灰色带 = GPU 重跑的差 −2.5e-5 参数范数差(第 1000 步,绝对) 原样 +2.11e-2 两边都去掉 +6.14e-3 GPU 多推一把 +2.05e-2 灰色带 = GPU 重跑的差 +4.9e-4 lse 差(第 1000 步训练批) 原样 −0.330 两边都去掉 −0.007 GPU 多推一把 1000 步没有这一项(300 步探针 −0.168) 灰色带 = GPU 重跑的差 −0.012 loss 偏移、参数范数漂移、logits 整体偏低,是同一股力的三个后果
先看绿柱缩回去(参数范数还剩三成),再看橙柱长回来。
每组一份 1000 步的运行,实测;柱上方写了是哪一组。
出处与口径

📌 实测(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。是这股力。

逐步看:去掉它,参数范数的差一路长得慢得多(图)
逐步看:去掉它,参数范数的差一路长得慢得多 参数范数差(绝对差),第 1–1000 步,实测;颜色同上一张图 原样:TPU 对 GPU 两边都去掉那个方向 GPU 人为多推一把 GPU 重跑两份之间 参数范数差逐步(第 1–1000 步,绝对差,实测) 0 0.01 0.02 第 1 步 第 250 步 第 500 步 第 750 步 第 1000 步 原样:TPU 对 GPU +2.11e-2 GPU 人为多推一把 +2.05e-2 两边都去掉那个方向 +6.14e-3 GPU 重跑两份之间 +3.3e-4 去掉它,参数范数的差一路长得慢得多;加上它,跟原样一路同涨
蓝橙两条一路同涨,绿线长得慢得多。
灰线呈台阶状,是 GPU 一侧参数范数的记录精度有限(台阶约 1.6e-4)。
出处与口径

📌 实测:每组一份 1000 步的运行;灰线呈台阶状,是 GPU 一侧参数范数的记录精度有限(台阶约 1.6e-4)。

7.4 谁推歪的:TPU 多推了,还是 GPU 少推了?

先想一想是 TPU 多推了,还是 GPU 少推了?先押一下,再往下看。

拿训练里实际用到的张量,同一批数据,在 FP64 里重算一遍,看两边的输出头反向各离 FP64 多远:

少掉的那一点,在 GPU 输出头反向那一次长求和里 柱长 = 沿「所有 logits 一起动」方向的相对误差(对数刻度,一格 = 十倍,越短越准),参照 FP64;三根是同一批数据 GPU 张量核 TPU 精确档 第 1 步,同一批数据、各自对 FP64(实测) 1e-6 1e-5 1e-4 1e-3 GPU 输出头反向,BF16 dh = dlogits · W,沿词表 12 万项求和 4.4e-04 TPU 输出头反向,生产配置 MXU:BF16 乘、FP32 累加 2.6e-05 TPU 输出头反向,精确档 精确配置(矩阵乘用最高精度),当「准」的刻度 1.2e-06 同一批数据上,GPU 的误差约是 TPU 的 17 倍:偏的是 GPU 那一次 12 万长的 BF16 求和 —— 朝零偏了一点(归因成张量核截断是推断)
红柱是 GPU 的张量核,误差约是 TPU 那根的十七倍(对数刻度,看着只长一截)。
三根柱是同一批数据,参照是各自 logits 在 FP64 里重算的结果;绿柱是 TPU 精确配置,当「准」的刻度。
出处与口径

📌 实测:三根柱都是 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 从 16,384 起 横轴 K = 词表行随机打乱后取的行数;纵轴 = 沿「所有 logits 一起动」方向对 FP64 的相对误差;横纵都是对数刻度(实测,GPU BF16) GPU 张量核,BF16 同一份输出头张量,只改求和长度 1e-04 1e-03 16,384 6.9e-05 65,536 2.0e-04 120,832 6.5e-04 K = 词表行随机打乱后取的行数(对数刻度) 同样朝零,求和越长偏得越多:K 从 65,536 到 120,832,误差涨了三倍多,比线性还快
求和越长,红线越高。
横纵都是对数刻度;三个点都是实测。
出处与口径

📌 实测:把真实输出头张量的词表行打乱后取前 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 内核没有源码,合成长求和上一个累加器就近舍入吞到同一量级是旁证);分段让每段的和保持小,两样一起治。

别的矩阵乘也在抹零,为什么偏偏是输出头露了馅:三个条件凑齐了
  • 求和够长:沿词表 120,832 项,是全网最长的一次收缩。
  • 小项大多同号:沿 w̄ 这个方向,每个词贡献的是「它的概率 × 它那一行在 w̄ 上的分量」。训练以后冷门词概率很小,行在 w̄ 上又大多同号:一大串同号的小数,抹零在每一项上都朝同一边,抵消不掉。
  • 后面有地方原样累积:w̄ 方向推的是所有 logits 的整体水平,水平一变,冷门行被压多少跟着变;冷门行梯度很小,Adam 的归一化保护失效(§7.2),每步的小差落在同一边、原样积起来。

别的矩阵乘也偏一点:合成的全正输入、求和长 4096 时朝零 7.0e-5(§5.2 右图)。可真实的激活和梯度有正有负,抹零的方向跟着每一项的符号走,大半互相抵消;后面也没有这样一个原样累积的地方(推断:其余矩阵乘沿各自方向的偏差没有逐个量)。

这还只是离线的一次矩阵乘,再在训练里确认一步:把 GPU 第 99 步的 FP32 主权重搬到 TPU,同一批数据两边各算一次梯度,按 GPU 的 Adam 缩放折成更新,再跟 GPU 上全程 FP32 算的那一步比,看沿 TPU − GPU 权重差的方向各少走多少(这个做法叫状态互换,§6 折叠)。

同一个起点,各算一步:GPU 每一步都少走一点 —— TPU 几乎正好 柱长 = 这一步沿「TPU − GPU 权重差」方向,比精确值少走了漂移本身的百分之几(往左 = 少走);细线 = 12 个 batch 的范围 TPU GPU,只换FP32 dgrad GPU 同一状态、同一批数据(实测,全体参数) 精确值 TPU 生产程序 0.00%(几乎正好) GPU 只换FP32 dgrad 少走 0.10% GPU 生产程序 少走 0.36% 同一个状态、同一批数据,GPU 算出来的梯度每一步都偏一点 —— 偏差在单步计算里就有
蓝色几乎贴着精确值,红柱最长。
每根柱子是「这一步」的偏,不是累积。
出处与口径

📌 实测: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 之后,权重沿漂移方向少走了多少。

开场那一问「TPU 算错了吗?」的答案偏移的大头不是 TPU 算错,是 GPU 当标准答案的那份 BF16 golden 自己离精确值远。先排除自己这一侧,包括当参照的那一份。

7.5 怎么修:只换 FP32 只追回六成,分块才跟 TPU 重合

最直接的修法:那次求和换成 FP32(真关 TF32)。第 1 步的偏差降到 −1.7e-6,可跑满一千步:

只换 FP32:单步好了,一千步只走到六成 —— 改成分块,跟 TPU 重合 左 = 训练轨迹(生产近似配置;参数范数绝对差,对 GPU 生产 5 份均值);右 = 同一次矩阵乘离线换写法,沿「所有 logits 一起升降」方向对 FP64 的相对偏差 只换 FP32 一次加到底 改成分块(修好的 golden:升 FP32 再分块) TPU 生产 真精确(虚线) GPU 生产 5 份的散布 参数范数的差(实测逐步) +0.01 +0.02 +0.03 0 +0.0274 真精确 +0.0209 TPU +0.0207 分块 +0.0124 只换 FP32 GPU 生产 = 0(灰底是它 5 份的散布) 减去 TPU 生产(实测逐步;粗线 50 步平均) -0.008 -0.004 0 -0.0085 -0.0002 第 1 步 第 200 步 第 500 步 第 1000 步 同一次矩阵乘,离线换写法(实测) 1e-9 1e-7 1e-5 1e-3 对数轴:相邻两格差 100 倍 张量核一次加到底 第 1 步 −6.5e-4 第 100 步 −6.1e-4 第 300 步 −4.6e-4 FP32 一次加到底 第 1 步 −1.7e-6 第 100 步 −2.6e-4 第 300 步 −2.6e-4 张量核分块 第 1 步 −6.9e-7 第 100 步 8.3e-7 第 300 步 3.1e-7 只换 FP32 治好了截断(第 1 步 1.7e-6),一千步却只走到 TPU 的六成;改成分块两样都治,跟 TPU 重合
橙线(只换 FP32)一千步只到六成,下格一路往下离开;绿线(改成分块)跟蓝线(TPU)重合,下格贴着零。
左格是训练轨迹(逐步实测,生产近似配置);右格离线。
出处与口径

📌 实测(左):混元 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 倍。

怎么确定是截断:三样证据,哪些是实测、哪些是推断
  • 硬件建模(实测):按 B200 张量核模型逐位重算路由打分,三层全部元素逐位对上;跟公开论文对 H100/B200 的比特级建模一致(Khattak、Mikaitis,arXiv:2512.07004,§5.2)。
  • 合成测试(实测):B200 上真跑 BF16 矩阵乘(不是模型模拟),合成正数输入,求和长 65536 朝零偏 3.1e-4(短求和那几点比截断模型大、来源没拆,所以不拿来作截断的证据);不走张量核的真 FP32 几乎为零(≤ 5e-8)。
  • 案例里的真张量(实测):把训练里实际用到的输出头张量的词表行打乱、取前 K 行在 FP64 里重算,K 从 16,384 起行越多误差越大、都朝零缩(更短的 K 沿这个方向的读数被其余行的随机误差盖住,不单调):K = 16,384 时 6.9e-5,K = 65536 时 2.0e-4,整张词表 120,832 行时 6.5e-4。
  • 推断:「案例里的偏差就是这个抹零模型在起作用」—— 那个模型在这么长的求和上没有单独逐位验证过。

换 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 自己定,生产程序里实测就是上面那个偏差:截断实实在在发生了。

总结成一张表:

偏差:训练里实际用到的张量,第 1 / 100 / 300 步沿 w̄ 对 FP64 的相对偏差;单次:一张 B200 上这一次矩阵乘的耗时(分块是逐段调库、没做融合);步时:一千步训练,对生产
写法截断吞小项偏差单次一千步步时
张量核,一次加到底(生产)有有−6.51e-4 / −6.10e-4 / −4.60e-42.45 ms基线
真 FP32,一次加到底(关 TF32)没有有−1.7e-6 / −2.56e-4 / −2.58e-465.6 ms—
张量核分块(每 1024 项,块结果留 FP32)只在短段里没有−6.9e-7 / +8.3e-7 / +3.1e-77.2 ms+6%
FP32 分块(第九节修好的 golden 的写法)没有没有+1e-8 / +3.5e-7 / +1.1e-771.7 ms+61%

结论:不用升 FP32,BF16 张量核加分块就够。一千步只分块(乘法留在 BF16 张量核)跟「升 FP32 再分块」分不开,步时 +6% 对 +61%。这处只影响 GPU 标准答案的制作,TPU 生产程序不动。

整个修法排成一排(第 1000 步参数范数,对 GPU 生产 5 份均值,生产近似配置) GPU 生产 0 < 只换 FP32 +0.0124 < 精确轨迹 +0.0186 < 分块后的 golden +0.0207 ≈ TPU 生产 +0.0209 < 真精确 +0.0274。这里漂得多,是离真值近。真精确比 TPU 生产还高一截:两边生产程序都把流进输出头反向的梯度存成 BF16,这一截两边一样,不算谁的差(第九节拆账)。
旁证:GPU 全程 FP32 的精确轨迹:GPU 别处全换 FP32 也只到九成,剩下的差就在这次求和

先把 GPU 输出头这一次矩阵乘换成 FP32(真关 TF32),1000 步下来 GPU 自己朝 TPU 走过去约六成;剩下的,在 GPU 上跑一条精确轨迹来看:权重的用法跟生产一样(FP32 主权重,每步舍成 BF16 再用),前向反向的算术全部 FP32、真关 TF32。它自己重跑一位不差;图里 loss 那一行的第二个紫点,是给第 0 层一处权重乘 (1 + 1e-6) 的扰动版。

精确轨迹站在 TPU 一边 —— 可它自己也还差一步才到真精确 零点 = 4 次默认 GPU 运行的平均(不重算配置);往右 = 离 GPU 越远;精确轨迹 = BF16 权重、全程 FP32(真关 TF32),可它的输出头长求和是 FP32 一次累加,中后期自 己会偏,改成分段才到真精确 GPU 只换FP32 dgrad 精确轨迹 TPU GPU 自己的散布(灰底) 第 975 步参数范数差 +0.0110 +0.0220 0(GPU 均值) FP32 dgrad +0.0125 精确轨迹 +0.0182 TPU +0.0199 第 975 步 lse 差 -0.160 -0.320 0(GPU 均值) FP32 dgrad -0.175 精确轨迹 -0.262 TPU -0.286 第 301–1000 步 loss 平均偏移(相对) -8.50e-05 -1.70e-04 0(GPU 均值) FP32 dgrad -7.30e-05 精确轨迹(权重扰动 1e-6) -1.16e-04 TPU -1.27e-04 精确轨迹 -1.53e-04 精确轨迹走了 TPU 九成的路:参数范数 91%,lse 九成以上;loss 上 TPU 落在精确轨迹两份之间
三行里,紫点都挨着蓝点。
零点是 GPU 默认运行的平均。
出处与口径

📌 实测:精确轨迹 = 主权重 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,在尺子内。

给第九节的伏笔:换到验收配置后 TPU 少漂多少

换到第九节验收用的配置(整层重算+路由回放),第 1000 步 TPU 生产比 TPU 自己的精确轨迹少漂 6.35e-3;这一截是谁的,第九节拆账。

分块修好的 GPU golden 对 TPU 生产:两条一千步轨迹逐步比

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 对);按定案的那把,两边都在内。

分块的两个条件,和一千步的确认
  • 两个条件:块结果必须留 FP32 —— 每块先舍 BF16 再相加就不行;块长不超过 1024 —— 到 4096 已剩 −5.6e-6,再长剩得更多,跟 §5.2「越长越偏」一致。
  • 训练上的确认:修好的 golden(第九节)的设置原样、只把这一处换成 BF16 张量核分块,跑满 1000 步 2 份,拿修好的 golden 的 45 对尺子对它的基线判,全过,最差 0.91 倍,跟同一台机器原样重跑修好的 golden 的对照一样(0.91);步时 0.250 s。TPU 当前配置拿它当基线交叉核对:v5p 全过;v7x 梯度范数 1.09 倍待定,可同一个 TPU 运行改对修好的 golden 的各份逐一当基线,也在 0.70–1.11 之间起伏,是单份基线自己的涨落。正式基线仍是修好的 golden。
为什么不直接用全程 FP32 训练当参照:那是另一条轨迹;精确轨迹和定案前那条的配置区别

生产里矩阵乘用的是主权重舍到 BF16 的那一份,权重本身每个元素就差至多半个 BF16 格。纯 FP32 训练(权重不舍)前 100 步 loss 就比 BF16 低 1.75%,走的是另一条路,跟哪边都差得远。 精确轨迹保留生产的权重语义,只把算术换成 FP32,每一步的梯度就是「同一份权重下 BF16 程序应该算出来的精确值」。

另外:这里的精确轨迹跟 ① 一样不重算;定案前第一关用的那条精确轨迹是在 ② 的配置上(整层重算+路由回放)跑的,两处的数不能直接对。

7.6 串起来:五环一条链

  1. GPU 输出层 dgrad 那次 12 万长的累加偏向一边(张量核截断+吞小项),每一步沿「所有 logits 一起升降」的方向少推一点(第 1 步 6.5e-4);
  2. 主干权重沿这个方向每步少走一点,从第 0 层开始(第 0 层里大头在注意力输出投影);
  3. 所有 logits 整体偏开一截(lse 差),softmax 看不见;
  4. 冷门词那几行压多压少跟着 logit 整体水平走;它们梯度很小,Adam 的归一化保护失效,偏差原样累积;
  5. 参数范数多涨、loss 偏低,几百步积成看得见的漂移。
五环一条链的静态图:(下面动画讲的是同一件事)
从一次求和到参数范数:五环一条链 一格 = 一环,从左往右一环推一环;右上角的小标签 = 这一环有直接测量;① 的原因另标 实测 推断 TPU 在这一环上偏得小得多、GPU 每步少推一点 —— 两边一比,看上去像是 TPU 偏了 ① GPU 输出层 dgrad 实测 量:每步少推(第 1 步 6.5e-4) 实测 因:截断+吞小项 推断 ② 主干权重 实测 第 0 层注意力输出投影最先歪 ③ logits 的整体水平 实测 整体偏一截,softmax 看不见 ④ 冷门词那几行 实测 压多少跟着 logit 整体水平走 ⑤ 看到的现象 实测 TPU 参数范数显大、loss 偏低 证据:两边都去掉第一环那个方向的力,logit 水平的差归零、loss 接近噪声、参数范数剩三成;GPU 人为加上它,整套现象一起出现
从左往右读,每一格是下一格的原因。
五格的现象都是量到的;第一格的原因是推断,②③ 两格的定量衔接没测过(§7.3),loss 为什么跟着变也没有验证;积起来以后还有反馈放大(推断)。
出处与口径

⚠️ 推断:① 的量(沿 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。

同一个小差每一步都一样,积到第 300 步就成了看得见的漂移。 (29 秒,Manim 渲染,可一步一步看。第 3 环每 25 步一个实测点(12 个),点间连直线;第 4 环只有第 300 步一个实测值,走到第 300 步才出现;⑤ 是逐步实测。)
考考自己:冷门词那些行的梯度大小两边几乎一样(√v̂ 只差 0–4%),为什么 TPU 上它们被压得少?(从初值算起 GPU 缩了 66.3、TPU 缩了 49.2;扣掉两边一样的权重衰减那一份 31.8,GPU 多缩 34.5、TPU 只多缩约 17,少一半。)

Adam 的更新量大小两边差不多,差在方向:更新和这一行权重之间的夹角两边不一样,从第 25 步起就分开了。这些行梯度很小,Adam 按大小归一化的保护失效,更新几乎跟梯度成正比,方向上一点系统差原样进了更新,一步步积成范数差。

考考自己:为什么「GPU 把 dgrad 换成 FP32」和「精确轨迹」都要跑满 1000 步,不能只看第 1 步?

第 1 步那股力只差约 6.5e-4(相对),单看一步、对 GPU 噪声比根本看不出;它是每一步同向地少一点,要累积几百步才显出 loss、lse 和参数范数的差。比的是轨迹,所以要跑满。

这一节留下的问题:同一份代码只换并行方式,数学上等价,曲线却对不上 —— 这回又是谁的差?

第 八 节

案例二:DDP 和 FSDP 对不上

第二个案例在第二次迁移上,模型是混元 4 的缩小版(约 4.3 亿个参数,词表 120,832 行、隐藏维 1024)。纯数据并行(DDP)和 FSDP 数学上等价,TPU 上一比,曲线超出了噪声。这回是谁的差?跟第七节一样,一条线查到底,每一步只看一个数。

这一节的调查线(每一步只看一个数;细数在各小节和折叠里)

① 现象(8.1)
2.62 倍
梯度范数超出 GPU 噪声尺子
→
② 定位(8.1)
3.62 倍
第 1 步只有词嵌入梯度离 FP64 远,是 GPU 的几倍
→
③ 按行拆(8.2–8.3)
39 行
误差全在高频词,跟本卡加几次走,跨卡几路不管
→
④ 反常(8.4)
8 倍
FSDP 同一个词加得多八倍,误差反而最小
→
⑤ 揭晓(8.5–8.6)
一处差别
两边编译产物里,那次加法只差一处
→
⑥ 修法(8.7–8.9)
切表
只切词嵌入表,精度同档、通信少九成以上

8.1 现象:数学等价,曲线却超出噪声;第 1 步只剩一个张量

TPU 自己跟自己比(§10.1):基线是 FSDP 8 卡,只改成纯数据并行。前 300 步梯度范数是 GPU 噪声尺子的 2.62 倍,不过(前 150 步最明显):

纯数据并行:梯度范数前 150 步明显偏低,是尺子的 2.62 倍 梯度范数逐步相对差 dₜ(前 300 步);被测对 TPU 自己的 FSDP 基线;灰 = GPU 同设置另 7 份对其中一份(尺子用的就是这 8 份) GPU 另 7 份(细:逐步;粗:50 步平均) 纯数据并行 纯数据并行(不修) -1×10⁻³ +1×10⁻³ 0 前 300 步带符号均值 −2.60e-4,尺子 9.92e-5 的 2.62 倍 第 1 步 第 100 步 第 200 步 蓝线的平均前 150 步明显在零下面:方向固定,不是噪声来回晃
蓝粗线前 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 个下标。范围从整个模型缩到了这一次加法。

细数:换几种跑法的 r、第 1 步离 FP64 的表、R 的分母怎么取

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 / GPU4.00e-3 / 4.17e-3—

R 的分母取基线和 GPU 中位数里离 FP64 远的那个(GPU 的 4.17e-3):这样 TPU 自己的基线本来就偏时,不会被算成「新改动丢了精度」。§4.2 定责流程图第一行的算例就是它。多路残差混合的小参数照例单列(6 个超线,数值上病态,向来不定责)。

8.2 第一个假设:BF16 跨卡求和 —— FP32 开关修好了,可它同时改了两处

最顺手的猜测:纯数据并行每张卡一整张表,8 张卡加完还要用 BF16 再相加,多舍一次(FSDP 下表按隐藏维切,不用跨卡求和)。现成的 FP32 开关(下文叫修法①)一开,300 步 r 0.98,修好了;可它同时改了本卡累加和跨卡求和两处,修好不等于找到病根。中间还撞上一个编译器 bug,r 冲到 611(§10.3,下面折叠)。

插曲:那个编译器 bug 怎么回事

打开它,r 反而冲到 611:一块梯度凭空没了。编译器把这份 FP32 梯度的跨卡求和挪出了梯度累积循环,又在循环里把 0 号以外各卡的累加器清零 —— 这就是 §10.3「改完先比指纹」那张图右块的编译器 bug,要「数据并行 + 梯度累积 + 这个开关」三样同时成立才出现。修好以后 300 步 r 0.98。

MaxText(混元 4 公开分支):绕开这个编译器 bug 的那道屏障

只把本卡换成 FP32 呢:修法②;修法①为什么没证明主因、省没省通讯

接着有人追问:只把本卡的累加换成 FP32、跨卡仍传 BF16,行不行?为此加了修法②,结果词嵌入梯度离 FP64 4.24e-3、300 步 r 0.93,也在噪声内。跨卡仍用 BF16 也够了 —— 这已经在暗示:跨卡那一步不是主因。

修法①的做法:前向从 FP32 主权重表取行再转 BF16,前向逐位不变,反向的累加落在 FP32 上。FSDP 下词嵌入表按隐藏维切,每张卡只管自己那 128 维,不用跨卡求和(为什么不用,§8.6 折叠里那张「两种加法」图看形状)。

  • 修法①同时改了本卡累加和跨卡求和两处,所以它有效不等于主因在跨卡。
  • 修法②没省下 all-reduce 的字节;修法①也没让它翻倍:修法①里编译器把主输入、多 token 预测输入两路合成一次 FP32 all-reduce,每个微批 1 次(默认是两次 BF16),all-reduce 的字节一样;另在加法之前多了 6.7e7 字节的点对点交换(collective-permute,把一部分 token 的梯度和 id 换到别的卡),词嵌入那份每步每设备 1.06e9 对 9.90e8 字节(怎么数,§8.10)。只有一路输入的模型,FP32 那份会多传一倍(推断)。

8.3 按行拆:误差全在 39 个高频词,跟着本卡加几次走

把第 1 步的词嵌入梯度按行分组,每组对 FP64 算一次,再做两个对照:每张卡一次加的 token 翻倍(紫柱),卡数翻倍(橙柱)。

第一个假设被推翻:误差跟本卡一次加几次走,不跟跨卡几路走 第 1 步,词嵌入梯度按行分三组,每组离 FP64 的距离(实测);柱子越高越远 FSDP(golden) 纯数据并行 8 卡 纯数据并行 16 卡 8 卡、不做梯度累积 按行分组,四种跑法(第二次迁移,TPU v5p) 0 1.00e-2 2.00e-2 3.00e-2 只在 1 张卡上出现 7,638 行,占范数平方 1.3e-2 ≥ 2 张卡、合计 ≤ 300 次 3,234 行,占 8.9e-2 3.26e-3 1.57e-2 1.59e-2 3.07e-2 合计 ≥ 301 次:高频词 39 行,占 0.90 本卡一次加的次数翻倍 误差接近翻倍 卡数翻倍、跨卡多一倍路 误差不变 低频行:四种跑法几乎一样高(误差在加进词表之前就有,推断) 主因在每张卡自己那次 BF16 累加;8 路 BF16 跨卡求和只是次要的
看右边一组:紫柱接近红柱的两倍,橙柱跟红柱一样高。
绿柱是 FSDP。
出处与口径

📌 实测:同一张按行分组的表(第 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% 在它们身上。

编译产物审计:矩阵乘类权重也有 BF16 跨卡求和,为什么两边一样

把两种并行编出来的训练步程序逐个查一遍:每一次梯度跨卡求和是什么类型、在不在累积循环里、跨卡前后各舍几次;再把第 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 那一侧换了写法。

8.4 反常:FSDP 同一个词加得多八倍,误差反而最小

图上还有个反常:FSDP 每张卡一次收齐 8 张卡的 token(32,768 个下标),同一个高频词加的次数是纯数据并行的 8 倍,误差反而最小(绿柱)。为什么?

8.5 揭晓:排好序、带标记,后端才在 FP32 里加完只舍一次

两边编译产物里,那次 scatter 要紧的差别只有一处:FSDP 那份先按 token 号排了序,还带着「下标已排序」的标记(indices_are_sorted=true)。把这一个 scatter-add 单拿出来,在 v5p 上真跑(表是真实形状,下标是基线第 1 步的真实 token),跟 CPU 上「FP32 里累加、最后舍一次」和「每加一次舍一次」两种仿真逐位比:

不排序时同一个词每来一次就舍一次;排好序以后挨在一起,在片上 FP32 缓冲里加完才舍一次。 (28 秒,Manim 渲染,可一步一步看。下标流、词 17 出现 6 次和左边的误差条是示意;第 3、4 步的数是实测。)

不排序,同一个词的更新散在别人中间,后端每碰到一次就读出来、加上、舍回 BF16,高频词一次加几十到几百个,就舍几十到几百次。排好序并带上「下标已排序」的标记,后端把一块表搬进片上的 FP32 缓冲,全部加完再写回,每行只舍一次。

四格单算子(图):只排序不带标记不行,关掉 excess precision 也不行

只看编译产物时,只能推断「排好序的 scatter 把连续的更新留在 FP32 里加」;这个单算子实验把它坐实了。

排序以后,为什么只舍一次 左:后端的两种写法(示意,同一个词出现 3 次);中:同一个 scatter 换四种条件(实测);右:按这一行出现几次分组(实测) 舍成 BF16 片上 FP32 缓冲 一次更新 两种写法 不排序:下标照原来的顺序 … 17 … 902 … 17 … 5 … 17 … 第 1 次 读 BF16 转 FP32 加 加到 0,不舍 写回 第 2 次 读 BF16 转 FP32 加 舍回 BF16 写回 第 3 次 读 BF16 转 FP32 加 舍回 BF16 写回 第一次是加到 0 上,不舍;一行出现 k 次,舍 k − 1 次 排序后:同一个词的更新挨在一起 … 5 … 17 17 17 … 902 … 片上 FP32 缓冲:g₁ + g₂ + g₃ 舍一次,写出 不管出现几次,都只舍 1 次 前提:excess precision 开着(默认开) 四格:4096 个下标 excess precision 开 关 不排序 6.75e-3 每次舍 6.75e-3 每次舍 排序 +标记 1.48e-3 只舍一次 6.75e-3 每次舍 只排好序、不带标记: 仍是 6.75e-3,每次舍 按这一行出现几次分组 0 5.00e-3 1.00e-2 1.50e-2 1 次 961 行 2–9 次 402 行 10–99 次 60 行 ≥ 100 次 3 行 1.46e-2 红柱不排序,绿柱排序 出现 1 次 = 加到 0 上,两边都是 0 一行出现 k 次:不排序舍 k − 1 次,排序只舍 1 次 —— k 上百时差约 8.5 倍
左边数红框:不排序每次都舍,排序只舍一次;中间只有一格绿。
右块红柱随次数涨,绿柱不动。
出处与口径

📌 实测(单算子,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 缓冲,这一块的更新加完再写回,每行只舍一次(后端指令和逐位结果都核过)。

8 个设备上照两种切法各跑一份:排序一项走了多少

每卡 4096 个下标、全局 32768 个(更新量是随机数,跟训练里的数不直接比,只看相对大小):FSDP 1.58e-3;纯数据并行 7.17e-3;纯数据并行只加上排序 2.86e-3。从纯数据并行到 FSDP 的差距,排序一项走了约八成(77%)(本课按这三个数复算);剩下的在本卡部分和先舍一次 BF16、再做 BF16 跨卡求和 —— 跟修法②是同一种舍入结构。

8.6 谁来排序:下标数过了门槛,后端才排;FSDP 恰好跨过了线

排序是 TPU 后端(libtpu)自己插的一道工序,公开的 XLA 代码里找不到它。把一次 scatter 的下标数往上扫:

谁来排序:一次 scatter 的下标数过了门槛,后端自己插(运行库 0.0.46 上是表行数的 1/8) 同一个 scatter,下标数从 2048 扫到 32768(单算子,实测,横轴每格翻倍) 不带标记(训练里的写法) 排好序、带标记 关掉 excess precision 下标数扫过门槛(词表 120832 行) 0 5e-3 1e-2 1.5e-2 离 FP64 的相对差(rel_L2) 2,048 4,096 8,192 16,384 32,768 门槛:超过 15,104(= 行数 ÷ 8)才插排序 9.14e-3 编译器插了排序 → 1.55e-3 门槛以下,灰线和红线重合 1.76e-2 纯数据并行每卡 不累积 FSDP 每卡 门槛只认下标数,不认并行方式:FSDP 一次加得多,恰好跨过了线
红线过了竖线就掉下来。
竖线左右各标了训练里三种跑法每卡一次的下标数。
出处与口径

📌 左块实测(单算子,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 排没排序。

门槛为什么是行数的 1/8(图):换表形状二分出来的
门槛是怎么来的:换表形状二分,插排序的点都落在「行数 ÷ 8」上 横轴:表的行数;纵轴:最小插排序的下标数(CPU 上为 v5p 交叉编译,运行库 0.0.46,实测) 最小插排序的下标数 表太小,不插 换表形状二分门槛(v5p,运行库 0.0.46) 下标数 = 行数 ÷ 8 0 120,832 480,000 0 30,000 60,000 表的行数 空心:到 65536 都不插(表太小) 实心:最小插排序的下标数 换哪种表形状,门槛都跟着行数走、不看列数;表太小时干脆不插
实心点都落在虚线上。
空心点是表太小、不插排序。
出处与口径

📌 实测(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,另算)。

FSDP 为什么一次收齐 8 卡(图):同一批数,纯数据并行先加后传,FSDP 先传后加
同一批数,两种加法 —— 纯数据并行先加后传,FSDP 先传后加 每张卡每个微批 1 条序列、4096 个 token;词表 E = [120,832, 1024];反向传回来 dX = [4096, 1024] BF16;卡画 4 张是示意,实际 8 张 本卡的梯度 不排序:加一次舍一次 排序:只舍一次 跨卡 纯数据并行:每张卡存整张表 —— 先加后传 卡 0:dX [4096, 1024] scatter-add dE₀:整张表 BF16 [120832, 1024] 卡 1:dX [4096, 1024] scatter-add dE₁:整张表 BF16 [120832, 1024] 卡 2:dX [4096, 1024] scatter-add dE₂:整张表 BF16 [120832, 1024] 卡 3:dX [4096, 1024] scatter-add dE₃:整张表 BF16 [120832, 1024] 4096 个下标 < 门槛 15104(行数 ÷ 8)→ 不排序,每碰一次就舍一次 BF16 all-reduce,整张表 每卡每次 ≈ 2.47e8 字节 dE = dE₀ + … + dE₇ 8 堆各自加完,再把 8 个结果相加 FSDP(词表按隐藏维切,每张卡管 128 维):先传后加 卡 0:dX 按列切成卡数段 卡 1:dX 按列切成卡数段 卡 2:dX 按列切成卡数段 卡 3:dX 按列切成卡数段 all-to-all 每段 [4096, 128] 收到 ≈ 8.4e6 字节/卡 另:token 号 all-gather 卡 0 收齐:8 张卡在它那 128 维上的梯度 [32768, 128]:每张卡的第 0 段 先排序 32768 个下标 scatter-add → dE[:, 128k : 128k+128] 片上 FP32 里加完,只舍一次 加完就是最终梯度,不再跨卡求和 32768 个下标 > 门槛 15104 → 后端自己插排序、标「已排序」,同一个词的更新挨在一起 「先传后加」让每次 scatter 的下标数翻了 8 倍,正好跨过门槛
上一条先加后传,下一条先传后加;下面那次加法收了 32768 个下标。
形状读自编译后的程序。
出处与口径

📌 实测(两边训练步优化后的 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,后者只搬不加,所以舍入次数相同,只差先后。

各种跑法排没排序:每卡下标数、两个运行库版本、曲线 r
跑法每卡一次的下标数运行库 0.0.46运行库 0.0.52曲线最差 r(0.0.46 / 0.0.52)
FSDP 8(基线,收齐 8 卡的 token)32,768排序排序—
纯数据并行 8,累积 24096不排序不排序2.62 / 2.82
纯数据并行 8,不累积8192不排序不排序3.69 / 没跑
纯数据并行 164096不排序不排序2.65 / 没跑
v7x 纯数据并行 8,不累积8192不排序排序4.06 / 0.89
门槛的具体数:不累积为什么最差、0.0.52 上门槛怎么变、生产宽度下的门槛(数会随运行库版本过期)

不累积时同一个词在一张卡上加的次数翻倍,所以最差;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 的机理,会从不丢变成丢(排不排序是离线编译看到的;丢不丢是推断,还没上卡跑)。小模型上的结论能不能搬,按自己的形状再判一次。

8.7 结论:高频词 × 不排序;首选只切词嵌入表

查到最后:丢精度要两个条件同时成立 —— 高频词 × 不排序 第 1 步,词嵌入梯度按行分组,离 FP64 的距离(实测);圆点 = 这一行收到几次更新,红竖线 = 舍了几次(示意) 一次更新 一次舍成 BF16 片上 FP32 里一口气加完 低频词的行(10,872 行,占梯度范数平方的一成) 高频词的行(39 行,占九成) 排序,只舍一次 FSDP 走这一行 收几次更新,舍 1 次 离 FP64 1 张卡 9.31e-3 / 多张卡 7.77e-3 8 张卡收齐,次数约是纯数据并行那格的 8 倍,舍 1 次 离 FP64 3.26e-3 不排序,加一次舍一次 纯数据并行走这一行 收几次更新,舍几次 离 FP64 1 张卡 9.41e-3 / 多张卡 8.31e-3 不明显 收几十到几百次更新,舍几十到几百次 离 FP64 1.57e-2 是上一格的 4.8 倍 低频行两种写法差别小(最多 1.07 倍);高频行在 BF16 里一次次地加,才把误差攒起来
只有右下那一格红:高频又不排序。
圆点个数是示意;格子里的数是第 1 步实测。低频那两格写两个数:「1 张卡」是只在 1 张卡上出现的 7,638 行,「多张卡」是在 ≥ 2 张卡上出现的 3,234 行;它们的误差加进词表之前就有(推断:上游的 BF16 计算),所以跟排不排序无关。
出处与口径

📌 实测(第二次迁移,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、步时
修法第 1 步词嵌入梯度离 FP64曲线最差 r(300 步 / 1000 步)步时(对基线)
不修1.51e-22.62−3.4%
① 整次 scatter 和跨卡求和都在 FP32(修好 bug 以后的代码)3.79e-30.98 / 1.09−2.8%
② 本卡 FP32 加完、舍一次,再 BF16 跨卡求和4.24e-30.93 / 1.07−2.6%

负数是比基线快:不修时纯数据并行本来就快,修法本身多花 0.6–0.8 个百分点。1000 步的 1.09、1.07 判待定(略超),可没超过纯噪声自己能拿到的分(§3.4 的留一法),跟 GPU 重跑分不开。后来又有第三种修法:不改精度、只改切分(§8.9)。三种的精度同档(都跟 GPU 重跑分不开),第三种通信、显存、步时最省,所以纯数据并行时首选只切词嵌入表;过不了排序门槛,再退回修法①。

回头看混元 3:为什么 v5p 上不受这件事影响

回头看混元 3:按专家切 8 那份离线编译核过,词嵌入表沿隐藏维切开,每卡一次收齐 32768 个下标、排了序;FSDP 8 看的是一次观测运行存下的程序,每卡 65536 个、也排了序(运行库 0.0.46)。都过了门槛,所以推断 v5p 上不受这件事影响(正式 FSDP 程序没直接读);v7x 上那次 scatter 交给 SparseCore,累加精度没测。

换到自己的模型怎么自查:比较每卡一次 scatter 的下标数 N 和词表行数 V
情况会怎样做法
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 以后的代码)。另外:两种并行编出的是两个程序,求和顺序不同,逐位相同做不到。

FP32 为什么能修:舍入一次小 2¹⁶ 倍

加的顺序照样跟 FSDP 不同,但每次加法的舍入从 2⁻⁸ 量级降到 2⁻²⁴ 量级,小了 2¹⁶ = 65536 倍。最高频的词在一张卡上加 458 次,按 FP32 每次 2⁻²⁴ 线性累加也只有约 2.7e-5,仍远小于一次 BF16 舍入的 3.9e-3(本课推导)。单算子里 FP32 scatter 离 FP64 只有 2.6e-9。

8.8 两个旁证(课上不讲):GPU 为什么没这个问题;关掉 excess precision 反而更差

GPU 的词嵌入反向下标多了就先排序(推断),所以没这个问题;关掉省舍入让两边「更像」,反而让 FSDP 那次排好序的 scatter 多舍,更差。让两边一样,不等于让两边都对。

两个旁证的细节:PyTorch 的两条路;关掉省舍入为什么走不通

GPU(推断):GPU 同设置的词嵌入梯度离 FP64 4.17e-3,跟 TPU FSDP 的 4.00e-3 接近。PyTorch 在 CUDA 上的词嵌入反向,下标超过 3072 个时先排序、按段在 float 里累加,最后才转回 BF16;GPU 每卡每个微批 4096 个 token,推断走的是这条:切法跟纯数据并行一样,本卡累加却跟 TPU FSDP 排序后是同一种舍入结构。

PyTorch 的两条路:在哪段代码、哪里没核

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。让两边一样,不等于让两边都对:修法要看离精确值近不近,不能只看两边的差。

8.9 第三种修法:只切词嵌入表,通信少九成以上

FSDP 那条「先传后加」不是谁手写的,是编译器在「表按隐藏维切开」这个前提下自动切出来的。那就其余参数照旧纯数据并行,只给词嵌入表加一个开关,让它沿数据并行轴、按隐藏维切开:

第三种修法:只把词嵌入表沿数据并行轴切开 —— 编译器自己生成 FSDP 那条路 其余参数仍是纯数据并行(每卡一整份);只有词嵌入表 [120,832, 1024] 按隐藏维切 8 段,每卡 [120,832, 128];卡画 4 张是示意,实际 8 张 本卡的数据 跨卡 只切表以后 前向:不取整表,只换取到的行 每卡存的那一段表 卡0 卡1 卡2 卡3 token 号收齐 8 卡 × 4096 = 32768 个 每卡从自己那 128 列取行 [32768, 128] all-to-all 换回整行 本卡 4096 个 token X [4096, 1024] 跟原来一样往下算 每张卡存什么、省了什么(反向那条路跟 FSDP 一样,见「两种加法」那张图下半) 不修:每卡一整张表 + 主权重 + 两份动量 卡0 卡1 卡2 卡3 只切表:每卡只存 1/8 卡0 卡1 卡2 卡3 词嵌入那份跨卡通信,每步每设备(按形状算) 不修 9.90e8 只切表 6.82e7 少 93% 实测显存峰值,每设备 不修 6.16e9 只切表 4.46e9 精度跟前两种修法一样,通信反而少了:词嵌入那份每步少 93%,步时跟不修一样快
看右下:词嵌入那份通信,绿条只剩灰条的零头。
上面是前向只换取到的行(备答用);通信按形状算,显存是实测;两对条各按自己的「不修」画长短。
出处与口径

📌 实测(第二次迁移,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%(对基线)。

纯数据并行:梯度范数前 150 步明显偏低 —— 只切词嵌入表以后平均回到尺子以内 梯度范数逐步相对差 dₜ(前 300 步);被测对 TPU 自己的 FSDP 基线;灰 = GPU 同设置另 7 份对其中一份(尺子用的就是这 8 份) GPU 另 7 份(细:逐步;粗:50 步平均) 纯数据并行 只切词嵌入表 纯数据并行(不修) -1×10⁻³ +1×10⁻³ 0 前 300 步带符号均值 −2.60e-4,尺子 9.92e-5 的 2.62 倍 第 1 步 第 100 步 第 200 步 只切词嵌入表(第三种修法) -1×10⁻³ +1×10⁻³ 0 前 300 步带符号均值 −3.8e-5,尺子的 0.39 倍 第 1 步 第 100 步 第 200 步 不修时蓝线的平均前 150 步明显在零下面;只切词嵌入表以后,绿线前 300 步的带符号均值回到尺子以内
先看下格:绿线回到尺子以内。
同一组灰线;上格就是 §8.1 那张图。
出处与口径

📌 实测:第二次迁移小尺寸,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-22.629.90e8−3.4%—
① 全程 FP323.79e-30.98 / 1.091.06e9−2.8%修好编译器 bug 的那道屏障
② 本卡 FP32、跨卡 BF164.24e-30.93 / 1.079.90e8−2.6%—
③ 只切词嵌入表3.97e-31.02 / 1.156.82e7−3.3%每卡那次加法过排序门槛
  • ③ 的显存峰值每设备少 1.70e9 字节,其中 1.30e9 是表的主权重和两份动量只存 1/8;其余推断来自不再需要整表的梯度缓冲。
  • 通信少了 9.2e8 字节、步时却几乎不变:推断是原来那份整表 all-reduce 本来就和计算重叠了,不在关键路径上;没有看 profile 核实。
  • 重算不会把这些通信再做一遍:词嵌入在层扫描之外;重算策略换成整层重算再编一遍,通信条数和字节都不变。
  • 三种的精度同档(1000 步它的 1.15 还略高一点,都在纯噪声分数以内);它赢在通信、显存、步时,所以纯数据并行时首选它。它不靠 FP32 开关、也不靠绕编译器 bug 的屏障,换的是切分方式本身;但跟 FSDP 一样要 excess precision 开着(默认开),也不能跟 ZeRO-1 同开;但它靠排序门槛:数据并行路数或每卡 token 数小到合起来也不过线时,会退回不排序(推断,没跑过),这时仍要用修法①。只在 v5p、缩小版、纯数据并行 8 + 累积 2 上验证过(运行库 0.0.46;0.0.52 上重测,三种修法也都跟 GPU 重跑分不开:① 1.55 / 0.92;② 1.20 / 1.28;③ 1.23 / 0.97)。

8.10 方法(课上不讲):怎么从编译产物看通信

上面那些「传什么、传几次、在哪排序」,都是上卡之前离线编译看清的:在 CPU 上为目标拓扑编一遍训练步,把编译后程序里的每一次集合通信读成形状和字节、数出每步几次。

怎么读、怎么数:集合通信读成「形状 × 字节宽」、数每步次数,图、照着做、代码、边界

上面那些「传什么、传几次、在哪排序」,都是上卡之前就看清的:把训练步按目标拓扑在 CPU 上编一遍(不占芯片,缩小版编译 75–215 秒,连追踪整次中位数 184 秒),从编译后的程序里把每一次集合通信找出来,读成「形状 × 字节宽 × 每步次数」:

怎么从编译产物看通信:形状 × 字节宽 × 每步次数 左:一条集合通信读成字节(本课按编译后程序里的原文示意);右:五种跑法每步每设备的通信字节(按形状算,对数刻度) 词嵌入的通信 全部集合通信 一条通信,四步读成字节 %all-reduce = bf16[120832,1024] all-reduce(%x), to_apply=%add 1 2 4 ① 是哪种通信 all-reduce:各卡相加,每卡一份;to_apply 是加法, 结果类型就是相加用的类型 ② 属于哪个参数 形状 [120832, 1024] 是词嵌入表;op_name 里有 scatter-add, 是反向往表里加 ③ 每步几次 它在梯度累积那个 while 循环里;循环次数读条件里的「计数器 < 2」; 主输入、多 token 预测各一条 → 2 × 2 = 4 次 ④ 字节 120832 × 1024 × 2 字节(BF16)≈ 2.47e8; × 4 次 = 9.90e8 字节/步/设备 五种跑法,每步每设备字节(v5p 8 设备) 1e7 1e8 1e9 1e10 不修(纯数据并行) 2.70e9 9.90e8 修法① 全程 FP32 2.77e9 1.06e9 修法② 本卡 FP32 2.70e9 9.90e8 FSDP 8(golden) 1.32e10 6.82e7 只切词嵌入表 1.78e9 6.82e7 FSDP 全部通信大,是其余参数也切开了,跟词嵌入无关 上卡之前就能看清「传什么、传几次、在哪排序」:离线编一遍,不占芯片
左边四步把一行读成字节;右边橙条最短的两行是 FSDP 和只切词嵌入表。
对数刻度;字节按形状算,不是线上实测。
出处与口径

📌 做法(对齐记录所用):用训练同一套配置和同一个训练步,把设备换成目标拓扑的描述,在 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 倍(通用估算)。

照着做一遍:真实程序里的几种写法、怎么顺着调用链数次数
  • 拿到程序:用训练同一套配置和同一个训练步函数,把设备换成目标拓扑的描述、把参数和数据换成同形状同切分的抽象值,走 JAX 的提前编译;编译时加 --xla_dump_to=<目录> --xla_dump_hlo_as_text,在目录里找名字带训练步、结尾是 after_optimizations.txt 的那份。
  • 异步的写法:集合通信常拆成成对的 xxx-start/xxx-done,也可能包成通用的 async-start(…), calls=%某个子计算,真正的通信在那个子计算里。成对的算一次;异步版的结果是元组(例如 collective-permute 是「发送缓冲, 接收缓冲, 两个上下文」),只算一块缓冲,all-gather 只算输出那块。
  • 数次数:先找到这条通信所在的计算(computation)名,再搜谁用 body= 或 calls= 调它,一路往上走到入口;每碰到一个 while,读它 condition= 那个计算里 compare(计数器, 常数), direction=LT 的常数(计数器从 0 起、每次加 1 时就是循环次数,梯度累积、层扫描都是这样),一路乘起来。
  • 认参数:形状先认(词嵌入 [120832, 1024],切开后 [120832, 128];输出头是 [1024, 120832],第一维不同);再看 metadata={op_name="…"},反向往表里加的那一串里带 scatter-add,前向取行带 gather;还拿不准,顺着数据流看谁用了它。
  • 核对:本课这一份,上卡后存下的程序里集合通信跟离线编的逐条一致(只差设备分组的写法;核对的是只切词嵌入表那份)。

代码:列出每条集合通信、每步次数和字节

这把尺子也有边界(字节按形状算这一条写在图下):

  • 看不到精度:§8.5 那一格就是程序一字不差、只关一个开关,后端的写法就变了;换运行库也一样(§10.2)。精度仍要上卡做第 1 步逐张量定责。
  • 看不到快慢:通信能不能藏在计算后面,要看实测步时或 profile。③ 就是例子:通信少了一大截,步时跟不修的纯数据并行几乎一样(对基线 −3.4% 和 −3.3%)。
考考自己:你的模型词表 25 万行,8 张卡纯数据并行、每卡每个微批 8192 个 token,没开 FP32 修法。按这一节,会不会中招?换成每卡 40000 个呢?

按运行库 0.0.46 的规则,门槛是 V/8 = 31250。8192 不过线,不排序,高频词每加一次舍一次,会中招。首选只切词嵌入表:8 张卡合起来 65536 个,过线,会走排序、只舍一次。40000 本来就过线,后端会自己排序(前提是 excess precision 开着)。换到 0.0.52,门槛跟列宽、芯片走,不能再用 V/8 估。所以这些都只是初判:用对齐记录脚本的 check 子命令在自己的形状、自己的运行库上判一次,再看整步编译产物里那次 scatter 有没有 sort 和「下标已排序」的标记(§8.10);拿不准就开修法①。

这一节留下的问题:两个案例查完了。第二次迁移还有一条主 loss 的尾巴,查得比这两个都久 —— 它最后是怎么查出来的?

第 九 节

一条查不完的尾巴

这一节讲第二次迁移里查得最久的一件:一条主 loss 的尾巴,排除了一圈、找到了主因、补上以后还剩一截。剩下那截最后是怎么找的?节末揭晓。

9.1 一条主 loss 的尾巴

第二次迁移换成现行对齐配置之前,小尺寸的主 loss 判了待定(1.55 倍):八份 TPU 全部比 GPU 高,第 50–100 步有个小鼓包,中间贴着零,第 550 步以后一路往上爬。八份同一个方向,不像噪声;同一份权重上两边前向几乎没差,所以是训练里一步步攒出来的。

小尺寸主 loss 那截偏高:几乎全在第 550 步以后,越往后越大 TPU 8 份对 GPU 16 份逐步均值的相对差,都是 50 步滑动平均;灰线 = GPU 16 份各自对其余 15 份均值,浅灰带 = 它们的最大偏离(实测) TPU 8 份(细)与均值(粗),主 loss 同上,MTP loss GPU 16 份留一法(细) GPU 最大偏离 主 loss:TPU 减 GPU(相对差) +1e-5 -1e-5 0 第 1 步 第 250 步 第 500 步 第 750 步 第 1000 步 小鼓包 第 100–550 步在 0 附近,正负相抵 第 550 步起一路往上,最后 25 步平均 +1.8e-5 同一批运行的 MTP loss:反着走(纵轴量程是上图的 2.5 倍) +2e-5 -2e-5 0 第 751–1000 步 −3.2e-5,8 份全部偏低(MTP 的尺子宽 4 倍,判档能过) 是训练轨迹慢慢偏开,不是前向的差
上面的红粗线第 550 步以后一路往上;下面 MTP 反着往下。
细线是 8 份各自,粗线是均值;灰带是 GPU 自己的散布。
出处与口径

📌 实测(第二次迁移,小尺寸,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 步,尾巴自己回落了(课上不讲)

延长到 2000 步时,修之前的尾巴在第 1000–1250 步到顶(只跑了 1 份),之后回落到 GPU 的散布里 —— 它更像一段暂时的轨迹差,不是一直在长的系统偏差。

地图与前段鼓包:多路残差上写了「转 BF16」的三处;收拢处梯度那次被省,前段鼓包先破

先认地方。混元 4 把残差流复制成 4 路(多路残差),下面这张地图标出三处在代码里写了「转 BF16」的地方。再记住 §5.4 那件事:「转 BF16、再转回 FP32」的一对,编译器开着省舍入时可以省掉;写成 reduce_precision(强制舍入)就省不掉。后面每补一处,用的都是它。

多路残差这一段:三处该舍 BF16 的地方 地图,不是结论:哪一处让尾巴长出来,后面一处处验 前向:流 反向:梯度 修之前就照 GPU 舍了 4 路流走过一层,最后收成一路 残差流 × 4 路 分支(注意力/MLP) 0 分支输入 修之前就照 GPU 舍了 1 ① 流梯度:流在一层里被用了三次, 反向回来三份梯度,要加成一份 末层归一化 2 ② 收拢处:4 路收成一路 前向舍一次,梯度传回来也舍 三处在代码里都写了「转 BF16」;GPU 都真舍了,TPU 可能被编译器省掉
三个编号是后面一直要用的地名:⓪ 分支输入、① 流梯度、② 收拢处。
示意图,只画一层。
出处与口径

⭐⭐ 三处在代码里都写了「转 BF16」;GPU 都真舍了,TPU 可能被编译器省掉(接上图)

⓪ 修之前就补上了;① 和 ② 是这一段要查的两处。

前段那个小鼓包先破了。在 ② 收拢处,GPU 前向舍一次、梯度传回来也舍;TPU 省掉了梯度那次。在收拢处强制舍,第 51–100 步回到 GPU 附近;只在前向舍、梯度原样传回,鼓包又回来。可后段没降,均值反而略高(4 份,单看分不开)。记住这个补丁,它后面还会回来。

后段先排除嫌疑。关掉 MTP、关掉蒸馏,都还偏;两边都把多路残差换成普通残差,尾巴没了。嫌疑锁定在多路残差这一段:

后段偏高:排除了一圈,范围缩到多路残差这一段 第二次迁移,小尺寸,v5p,现行对齐配置之前那一代;对比基准是 GPU 现行写法 TPU 偏高 两边都去掉多路残差 排除的候选 Ⓐ 嫌疑人:流的三份梯度怎么加(下一步验证) GPU 三份各舍 BF16 逐个相加 每加一次舍一次 CPU 上用 GPU 同一段代码逐位核过 TPU 三份留 FP32 FP32 里加完 最后舍一次 推断:省舍入下中间那几次被合掉(虚线) 每次舍入的差都很小,1000 步攒下来成了那截偏高。 是不是它,靠后面两张图两头各改一处来验。 Ⓑ 第 551–1000 步主 loss,TPU 减 GPU GPU 自己的散布 2.1e-6 关掉 MTP +1.2e-5 关掉索引器蒸馏 +9.0e-6 两个都关 +8.7e-6 对照(1 份) +1.48e-5 两边都去掉多路残差(2 份) +1.3e-6 关掉 MTP、蒸馏都还偏;两边都换成普通残差就不飘 —— 问题在多路残差这一段
右边灰条(排除的候选)都还长,只有绿条(两边都去掉多路残差)缩进灰带。
右边实测;左边 TPU 那排虚线是推断。
出处与口径

📌 实测(第二次迁移,小尺寸,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 一边的读数
把 GPU 的流梯度舍法补上,尾巴降下来:均值 +1.9e-6(5 份里 2 份仍有尾巴) 第二次迁移,小尺寸,v5p,1000 步;两列同一纵轴;每条线一份运行 修之前 补流梯度舍法 GPU 自己的散布 修之前(4 份) -2e-5 -1e-5 +1e-5 +2e-5 +3e-5 +4e-5 0 1 500 1000 第 551–1000 步平均(每份): +1.5e-5、+8.6e-6、+7.9e-6、+6.2e-6 均值 +9.4e-6;尾巴还在:4 份 / 4 份 补流梯度舍法(5 份) 1 500 1000 第 551–1000 步平均(每份): +5.9e-6、+2.7e-6、+9.7e-7、+7.2e-7、-6.5e-7 均值 +1.9e-6;尾巴还在:2 份 / 5 份 补上 GPU 的流梯度舍法,尾巴降下来
左边红线四条都爬出灰带;右边绿线多数贴着 0。
两列同一纵轴;每条线一份运行;实测。
出处与口径

📌 实测(第二次迁移,小尺寸,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 换成 GPU 的舍法,偏高降下来;GPU 换成 TPU 的舍法,自己偏高 第二次迁移,小尺寸,1000 步,第 551–1000 步主 loss 带符号均值;每点一份运行,横线是均值 TPU 原写法 TPU 改成 GPU 写法 GPU 原写法 GPU 改成 TPU 写法 Ⓐ TPU 一边:对 GPU 16 份均值 -1e-5 -5e-6 +5e-6 +1e-5 +1.5e-5 0 修之前 4 份,均值 +9.4e-6 补流梯度舍法 5 份,均值 +1.9e-6 差 -7.5e-6,p 0.016 灰带:GPU 16 份每份对其余 15 份,−4.5e-6 到 +3.2e-6(最小到最大) Ⓑ GPU 一边:每份对其余 15 份均值 -1e-5 -5e-6 +5e-6 +1e-5 +1.5e-5 0 GPU 自己 16 份,均值 0 换流梯度舍法 4 份,均值 +3.9e-6 换收拢处整段写法 4 份,均值 +1.8e-7 4 份全为正,p 0.0025 p 0.89,没变 灰带:GPU 16 份每份对其余 15 份,−4.5e-6 到 +3.2e-6(最小到最大) 两头对上,才说得上主因是它:流的几份梯度怎么相加、在哪儿舍
左块红点降到绿点;右块灰点升到橙点:两头各改一处,方向对上。
每点一份运行;实测。
出处与口径

📌 实测(第二次迁移,小尺寸,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 怎么读:只当方向性的证据

图里的 p 是检验值:把这些运行随机重新分组,分出这么大差别的概率;4 份对 5 份一共只有 126 种分组,完全分开时 p 最小就是 0.016。这一节做了十几次这样的检验,没做多重比较校正,单个 p 0.02 上下只当方向性的证据。

可把前面那个补丁(收拢处,最后四路收成一路那处)也加上,就是现行对齐配置,后段还剩 +6.9e-6,跟不修那组分不开。剩下那截一张张猜太慢。回头看抓到的两处:鼓包那处在芯片指令里核过,是代码写了舍、编译器省掉了;流梯度按同一规律推断也是。两处是同一个毛病。这个毛病到底是怎么回事?

反转、一台秤三个毛病、丙在哪、在一处上看清楚(推断多;两段动画在这里)

反转。把 ① 和 ② 都照 GPU 补上,就是现行的对齐配置;可后段还剩 +6.9e-6,比只补流梯度大,跟修之前分不开(p 0.32)。收拢处一开,再补流梯度就测不出作用了(逐份读数收在下面的折叠里)。

逐份读数:收拢处开着时,补不补流梯度分不开
收拢处一开,流梯度那处就测不出作用;对齐配置第一份主 loss 0.98 刚好过线 第二次迁移,小尺寸,v5p,1000 步;每点一份运行;机制还在查 只开收拢处舍入 再补流梯度舍法 GPU 自己 Ⓐ 收拢处开着时,再补流梯度舍法(第 551–1000 步主 loss 偏差) -5e-6 +5e-6 +1e-5 +1.5e-5 +2e-5 0 只开收拢处 4 份,均值 +1.3e-5 +全套 4 份,均值 +6.7e-6 p 0.14 +只补梯度一半 4 份,均值 +7.9e-6 p 0.14 +只补分支输出一半 4 份,均值 +1.1e-5 p 0.54 p:对「只开收拢处」那格的置换检验;灰带:GPU 16 份每份对其余 15 份,−4.5e-6 到 +3.2e-6 Ⓑ 主 loss 判档倍数:对齐配置 6 份 vs GPU 自己 15 份 1(过线) GPU 最高 0.97 0.8 0.9 1.1 1.2 GPU 自己(15 份) 对齐配置(6 份) 6 份里 3 份高过 GPU 的全部 15 份: 过线是过了,可后段那截偏还在。 收拢处那次舍入开着时,再补流梯度舍法测不出作用
左边:在橙点那格上再补,三格紫点都没明显往下;右边:紫点有三个落在所有灰点的右边。
每点一份运行;实测;机制在查。
出处与口径

📌 实测(第二次迁移,小尺寸,TPU v5p 8 设备,1000 步):左块每格 4 份,第 551–1000 步主 loss 对 GPU 16 份逐步均值的带符号均值;三格对修之前(只开分支输入与流的强制舍入)也都分不开。「只补梯度一半」「只补分支输出一半」是把流梯度舍法拆成两半各自单开。

📌 右块:现行检查项目录、GPU 16 份两两 120 对的尺子;GPU 那 15 份是每份对基线那份的同样判档(留一法)。对齐配置 6 份没有不过,现行那份 0.98。

⚠️ 都是小尺寸、每格份数不多;「测不出作用」是这几份运行下的结论,不等于证明没有作用。

为什么?对齐记录的解释(推断):一台秤有三个毛病。甲让读数偏重,是流梯度少舍(主因,已找到);乙让读数偏轻,是收拢处那次梯度少舍;丙也偏重,还没找到。只修甲,乙和丙大致抵掉,读数看着准了;甲乙都修,丙就露出来了。乙这个毛病有点怪:在前段它把 loss 往上鼓(就是那个鼓包),在后段却往下压。

修好一个毛病,读数反而偏了:另一个毛病一直在帮着抵(推断) 第二次迁移,小尺寸,v5p;读数 = 第 551–1000 步主 loss 偏差(TPU − GPU,×1e-6),每格 4–6 份运行的平均;甲乙丙的解释是推断 偏重:甲 流梯度少舍、丙 还没找到 偏轻:乙 收拢处梯度少舍 已修 一台秤,三个毛病:四种修法,读数是多少 甲 乙 丙 都没修(修之前) ? +9.4 三股相抵后的读数 只修乙(收拢处) 已修 ? +12.5 均值往上走 3.1,4 份单看分不开(p 0.26) 只修甲(流梯度) 已修 ? +1.9 乙和丙大致抵掉,看着准了 甲乙都修(对齐配置) 已修 已修 ? +6.9 比只修甲高 5.0(p 0.024):丙露出来了 反过来在 GPU 上验乙: 只拿掉收拢处那次梯度舍入(4 份),后段压低 2.9:方向一致,推断是那 5.0 的一部分。 甲乙都修以后剩下的 +6.9,不是修坏了,是被乙遮住的丙露了出来(推断)
只补收拢处那一行读数最大;只补流梯度那一行最小,可往下拉的那股还在。
读数是实测;「往下拉的那份」是推断,箭头只表示方向。
出处与口径

📌 实测:四格都是第 551–1000 步主 loss 对 GPU 16 份逐步均值的带符号均值,单位 1e-6;都没修 4 份、只修乙 4 份、只修甲 5 份、甲乙都修 6 份;甲乙都修对只修甲是置换检验。GPU 那一行对 GPU 16 份留一法,4 份;它只拿掉收拢处反向那一次梯度舍入,跟上面「两头各改一处」那张图里整段换收拢处写法的那格不是同一个改法。

⚠️ 推断:三个毛病、乙丙抵掉、丙在别处,是对齐记录的解释;GPU 一侧方向一致,但大小只占 5.0 的一部分。箭头只表示方向,甲乙丙各自多大没有单独测出。

拨一个开关,指针往意料之外的方向跑:只修甲几乎回零,再修乙反而往右跑回去;GPU 上只拿掉乙,GPU 自己被往下压。 (20 秒,Manim 渲染,可一步一步看。读数是实测;「三个毛病、乙丙抵掉、丙露出来」是推断。只修乙那一格单看分不开,没放进动画(静态图里有)。)

按这个解释,对齐配置剩下的 +6.9e-6 主要是丙(推断)。下一步:找丙。

丙在哪?先查能一次列全的那种。丙有两种可能:两边算的东西不一样,或者算的一样、舍的位置不一样。收拢处这一段的代码已经对到只差累加顺序,上卡照旧(出处见本节末的折叠);鼓包那处在后端指令里核过,是代码写了舍、编译器省掉了;流梯度两头验证定了是原因,按同一规律推断也是被省掉。后一种有个好处,能让编译器自己交代,一次列全。先查便宜的。

先在一处上看清楚,就拿 ⓪ 来看:它在这次排查之前就补上了;把它退回没补时的写法,为 v5p 离线编译:HLO 里那对 convert 都在,可算均方那颗 kernel 的后端指令(LLO)里,把 FP32 打包成 BF16 的指令一条都没有(§8.5 也是这样数的);同一处写成强制舍入,就有 256 条。往返留在一颗 kernel 里就不舍;值写回内存交给下一颗、或直接喂给矩阵乘,才真舍:

同一个值走同一串盒子:代码的本意是舍,在一颗融合里没舍,写回内存才舍;写成强制舍入才真舍。 (31 秒,Manim 渲染,可一步一步看。值是随手取的 FP32 数,BF16 当场算;打包条数是最小复现的实测。)

先在一处上看:声明了,却被省掉。代码里写一对「转 BF16 再转回」,不改数学,写它只有一个意思:这里要舍。拿已补上的一处退回旧写法,离线编一遍:优化后的程序(HLO)里两条转换都在;芯片指令里真把 FP32 打包成 BF16 的,0 条;写成强制舍入,256 条(下图)。编译器看这个值马上还要接着算,往返留在一颗 kernel 里就不舍;写回内存交给下一颗,才真舍。第五节那个 32K 上的 RMSNorm scale(§5.4),就是这样被省掉的。

代码里写了往返 convert,就是「这里该舍」的声明 —— 可编译器没舍 第二次迁移,小尺寸,TPU v5p 离线编译(省舍入默认开);一处往返(多路残差分支输入,退回没补时的写法),从代码一层层看下去 写了舍、被省掉 补上以后真舍 FP32 一处往返:声明了,但被省掉 ① 代码 写了往返 ② 优化后 HLO 两条 convert 都在 ③ LLO 芯片指令 打包成 BF16 的有几条 4 路加权和 转 BF16 转回 FP32 往返不改数学,写它只有一个意思: 「这里要舍」 算均方那颗融合 convert → bf16 convert → f32 这一层看不出毛病:两条都在,读着是舍了 照原样 0 条打包 补上 reduce_precision 256 条打包 同一个值:均方那颗用没舍的,归一化那颗读舍过的 规律:往返留在一颗融合里就不舍;写回内存、喂给矩阵乘的才真舍。 声明了,被省掉:HLO 里在,芯片指令里没有
从左往右:代码写了往返,HLO 里两条 convert 都在,芯片指令里打包却是 0。
最小复现离线编译,实测。
出处与口径

📌 实测:多路残差「4 路加权和 → 转 BF16 → 归一化」的最小复现(MaxText 真模块),CPU 上为 TPU v5p 离线编译(运行库 0.0.46,省舍入默认开),读优化后 HLO 与后端指令(LLO);训练步的优化后 HLO 里同一对 convert 也都在。打包指令指后端指令里把 FP32 打包成 BF16 的那一类。关掉省舍入,两种写法都真舍。收拢处那一段(另一份最小复现)两路梯度各转 BF16 的两条 convert 也是 0 条打包。

⚠️ 省不省取决于融合怎么切,同一个值可能这边舍了、那边没舍。

那整个模型里,还有多少处?把整个训练步离线编译一次(不用上卡),把写了往返、芯片指令里没舍的地方全列出来:272 处,按位置归几类(下图)。

整个训练步离线编一次:写了往返却被省掉的,一共 272 处 第二次迁移,小尺寸,现行对齐配置,TPU v5p 离线编译;按位置归类,条长是使用次数(不是 kernel 数) 先查的范围 优先级低 无害 按位置分:先查三根橙条 A 分支输入的梯度合流 70 B 每个微批的权重梯度 dW 75 C 前向几处 98 其余(专家反向、norm) 20 索引器掩码(0 和 −∞,转了也精确) 9 先查的范围:243 处 已补上 55 处,不计入: 多路残差、流梯度、收拢处 30 其余 25(相减得出) 清单告诉你先查哪儿:A、B、C 三类,共 243 处
三根橙条 A、B、C 是先查的范围。
条长按使用次数算,不是 kernel 数;实测。
出处与口径

📌 各条细分: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。

⚠️ 省不省取决于融合怎么切,同一个值可能这边舍了、那边没舍。小尺寸、单一配置;别的模型要重编重扫。

扫描过程的动画
一格一格扫过整个程序,同一个模式亮起来就按位置归堆;只含往返的 kernel 拿 LLO 一颗颗数,全是 0 条;关掉省舍入,没有一颗是 0。 (23 秒,Manim 渲染,可一步一步看。上面那条「程序」只画 60 格,哪几格亮是示意;各堆的终值、41 颗和 35 颗是实测。)

三根橙条 A、B、C 是先查的范围,A、B 在反向的梯度路径上,排在最前。A 跟刚抓到的流梯度是同一种手法:几份梯度在 FP32 里合流,只是换到了各层分支的输入上(典型是注意力的输入)。这些地方 TPU 少舍一次,单看这一处离精确值更近(推断,没量过);可对齐比的是像不像 GPU,GPU 在这里舍了,两边就差这一次。

这一招的两条边界:只找得到这一类;GPU 舍不舍要对照 GPU 代码

两条边界:

  • 只找得到这一类。写了往返、被编译器省掉的,扫得出来;代码里本来没写舍入、累加顺序不同、近似超越函数这类差,扫不出来。
  • GPU 舍不舍,要对照 GPU 代码。清单只说 TPU 省掉了。dW 这一类算数,是因为 GPU 参照关了 Megatron 的 gradient_accumulation_fusion,每个微批的 dW 先出 BF16 再加进 FP32 的累加器;开着的话,这一类就不算差别。另外只有 dW 那一类整颗 kernel 只含往返,能在 LLO 里一颗颗数;另两类跟真舍混在一起,是按同一规则推断的。

收尾:上卡验证。还是两头验证那一招:GPU 上把 A、B 拆成三处照 TPU 改,看 GPU 自己长不长出尾巴;TPU 上在对齐配置之上补上,看尾巴下不下去。

两头验证:A、B 两类都没坐实 第二次迁移,小尺寸,第 551–1000 步主 loss 偏差,每点一份运行,横线是均值 参照格 改了一处(A = 分支输入的梯度合流,B = 每微批 dW) GPU 一头:照 TPU 改,长不长出尾巴(对 GPU 16 份均值) −4e-6 +4e-6 +8e-6 +1.2e-5 0 GPU 自己 16 份 A · 注意力输入 均值 +3.0e-6 A · MoE 输入 均值 +9.6e-7 A · 两处一起 均值 +1.9e-7 B · 每微批 dW 均值 −3.8e-7 TPU 一头:补上,尾巴下不下去 −4e-6 +4e-6 +8e-6 +1.2e-5 0 对齐配置 6 份 +6.9e-6 +补 A · 注意力输入 均值 +6.1e-6 +补 A · 两处 均值 +5.3e-6 清单是候选,不是结论:A 两头都排除,B 在 GPU 一头排除
左边改了一处的格子都没稳稳长出尾巴;右边补上的两格跟对齐配置一样高。
每点一份运行;实测;判读来自对齐记录。
出处与口径

📌 实测(第二次迁移,小尺寸,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 写法,还是不开收拢处
对齐配置(三处都照 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)。

照着做:自己的模型怎么扫
  1. 离线编译整个训练步(CPU 上为目标芯片编译就行,不用上卡),存下优化后的 HLO 和后端指令(LLO)。
  2. 找每一处 convert(f32→bf16),看它在同一颗融合里有没有又被 convert 回 f32 用。前面已经有 reduce_precision、或者输入本来就在 BF16 网格上的,往返是精确的,跳过。
  3. 按 HLO 里记的源码行和形状归类,看是哪个模块、前向还是反向。
  4. 只含往返的 kernel,数 LLO 里打包成 BF16 的指令,应该是 0;再关掉省舍入编一次当负对照,应该不再是 0。
  5. 每一类去对照 GPU 代码,看那里舍不舍;GPU 舍的,才是候选。候选再上卡,两头各改一处验证。

代码:对齐记录 · 案例 17「后段为什么慢慢偏开」(重点在「先编译、再扫描」一节) 代码:扫描脚本 代码:整步扫描结果 代码:排查指南「扫全图找被省掉的舍入」

验收与 golden 设计(课上不讲):基线换成修好的 golden,全部过;五份 golden、出处总表与拆账、两关验收与定案、开关上不上生产

两关验收。噪声尺子量不出 golden 自己的偏差,所以验收分两关:第一关必须过,TPU 对修好的 golden(⑤)的一份比,尺子是 ⑤ 自己重跑 10 份、两两 45 对;第二关不判过不过,TPU 对 GPU 生产 golden 的差,写清量级、由哪个查清了的 GPU 偏差造成、证据在哪,记「已解释差异」。当基线的那份 golden 不是一开始就有的:先往精确方向改了两步(GPU 生产 golden → 只换 FP32 → 精确轨迹),查清以后发现只要在 GPU 生产 golden 上改一处,这就是修好的 golden(下文图上标 ⑤)。

9.2 五份 golden,一步一步来

golden 是一步步改出来的 —— 先对齐超参和数据,再每一步只加一样东西 卡片 = 一份 golden(GPU 上跑的标准答案);柱子 = TPU 被测对它的参数范数差是噪声的几倍(②–④ 同被测同尺子;⑤ 换成当前 TPU 和它自己的尺子) 起点 生产近似 只修一处 精确轨迹 修好的 golden 不过:超过 2×N 混元 3 的五份 golden(实测) ① 起点 框架默认配置 BF16,不重算 TF32 开着 归因参照 (不重算;1000 步 验收不用它) ② 生产近似 + 整层重算 + 路由回放 模仿生产开重算 跟①比:各项都在 GPU 噪声内 生产 golden:差要写清来由 2×N TPU 对它:23.6 × N ③ 只修一处 + 输出头 dgrad 换成 FP32 loss 挪回 −9.8e-5 参数范数 +0.0124 定案前的尺子取自这组 归因证据 2×N TPU 对它:10.1 × N ④ 精确轨迹 + BF16 权重、全程 FP32 真关 TF32;可输出头 长求和一次累加,有偏 定案前的基线 2×N TPU 对它:3.5 × N 被测:开关打开前那一版 TPU ⑤ 修好的 golden ② + dgrad 升 FP32 分块 只改这一处;一步 0.38 s(生产 0.236) 只分块不升 FP32 也够:0.25 s 尺子:自己 10 份 45 对 第一关的基线(定案) 2×N TPU 对它:0.07 × N 被测:当前 TPU;尺子换成 ⑤ 自己 10 份 (带符号均值;三个统计取最差是 0.50) 柱子:TPU 被测的参数范数带符号均值 ÷ N(②–④ 的 N = ③ 那组 5 份两两 10 对的最大值;⑤ 用它自己 10 份 45 对);竖线 = 2×N 每往精确值靠一步,TPU 的「偏差」就缩一截:24 倍 → 10 倍 → 3.5 倍;修好的 golden 上 0.07 倍
②–④ 的柱子从左到右一截截变短。
②–④ 同一个被测、同一把尺子;⑤ 换了被测和它自己的尺子,单独看。
出处与口径

📌 实测:被测是 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 一步步改的动画:,同一根柱子一截截缩
同一个 TPU 被测、同一把尺子:golden 每加一样东西,同一根柱子就缩一截,缩掉的那截换成标了名字的「已查清」色块。 (22 秒,Manim 渲染,可一步一步看。色块长度是带符号均值之差,不是 §9.4 拆账图的百分比。)

9.3 出处总表:golden 对上游默认改了什么

每一处改动记一行,连试过没采用的也写上,免得后人再试一遍。

出处总表:改了什么、上游默认、修好的 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 设置下)……各自的结论是「无影响」还是「有害」。

9.4 拆账,和两关验收

把每条运行第 1000 步的参数范数钉在一根数轴上(下图):TPU 生产那颗点和 ⑤(GPU 生产只把那次长求和升 FP32、分段累加)几乎叠在一起。GPU 生产到 ⑤ 那一截,全是 12 万长的求和带来的;⑤ 到 ⑥(真精确,只当参照)那一截两边都有,不是两边的差。

定案前那 3.45 倍是什么:两笔相反的偏差相抵后的差额

定案前那 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 生产也带着它(推断)。

新的账:两个生产程序只差 GPU 那一次长累加 上:各条运行第 1000 步落在哪(实测);下:TPU 对精确轨迹那一小截的三笔(实测,按定义加起来正好闭合) GPU 生产 精确轨迹 / 真精确 GPU 生产+升 FP32 分段 TPU 生产 GPU 长累加偏差 两个生产程序都有 第 1000 步参数范数,对 GPU 生产 golden 5 份均值的差(生产近似配置:整层重算 + 路由回放) 0 +0.01 +0.02 GPU 生产 ④ 精确轨迹 +0.0186 ⑤ 生产+升 FP32 分段 +0.0207 TPU 生产 +0.0209 ⑥ 真精确 +0.0274 换成 FP32(去掉截断那条路)+0.0124 再分块(去掉吞小项,推断)+0.0083 两个生产程序都有(对真精确比):输出头反向的 dlogits 舍成 BF16 +0.0067 TPU 生产和 ⑤ 几乎落在同一点;⑥ 真精确 = ④ 再把那次长求和分段(只当参照),TPU 自己的精确轨迹也落在这里 TPU 生产对 ④ 的 +0.00235 是三笔相加(第 1000 步,v7x 那组补跑;v5p 那组见出处) 0 第一笔 → ④ 自己少漂:cuBLAS FP32 一次累加整个词表(GPU 一侧) +8.70e-3 ← 第二笔 TPU 的 dlogits 舍成 BF16(④ 没有这一舍) −6.84e-3 第三笔 其余 BF16 存储与逐元素 +4.9e-4 合计 2.35e-3,正好等于实测 两个生产程序之间,唯一测得出的差是 GPU 输出头 dgrad 的长累加
先看上面的数轴:蓝点和橙点几乎叠在一起。
都是第 1000 步、生产近似配置、TPU 当前配置;下面三笔里红色是 GPU 一侧,蓝色是 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 ②)歪在哪、歪多少。

golden 自己有偏差时:分两关验收(定案版) 上 = 必须过的那一关;下 = 只写清楚、不判过不过的那一关;箭头 = 谁对谁比 第一关:对修好的 golden ⑤ 第二关:对 GPU 生产 golden ② TPU 被测 过 混元 3 的验收协议(第一关基线已定) TPU 被测 当前对齐配置,1000 步 ⑤ 修好的 golden(一份当基线) GPU 生产 + 输出头 dgrad 升 FP32 分段累加 尺子:⑤ 自己重跑 10 份两两 45 对 只报:TPU 扰动组 9 份(只改执行参数) 8 份四项 r ≤ 0.85;1 份梯度范数待定(只改注意力分块) ② GPU 生产 golden 整层重算 + 路由回放 已解释差异 参数范数全部、loss 主要:GPU 输出头 dgrad 第一关:必须过 v5p 最差 0.85×N · v7x 最差 0.85×N,全过 量出 N 其中参数范数:v5p 0.50×N、v7x 0.53×N 第二关:不判 参数范数 +0.0209、loss −1.37e-4(v5p) 噪声尺子量的是「重跑会差多少」,量不出 golden 自己的系统偏差 —— 所以要分两关
橙色那一关要判过不过,灰色那一关只写清楚。
虚线框是只报不判的交叉核对(TPU 扰动组)。
出处与口径

📌 实测:第一关对 ⑤ 的一份、尺子 ⑤ 自己 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 倍。

9.5 今天的结论

结论:对齐了,1000 步这一级最差是噪声上限的 0.85 倍 第一关的基线定为修好的 golden(⑤):GPU 生产程序只把输出头那次求和改成升 FP32 再分块;基线取它的一份,尺子是它自己 10 份同设置重跑、两两 45 对。
平台 · 配置loss 全程loss 尾段梯度范数参数范数学习率
v5p 当前对齐配置0.80 ✅0.80 ✅0.85 ✅0.50 ✅逐位 ✅
v7x 当前对齐配置0.82 ✅0.83 ✅0.85 ✅0.53 ✅逐位 ✅
v5p EP=80.76 ✅0.78 ✅0.74 ✅0.48 ✅逐位 ✅
v7x EP=80.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 以内。所以报结论时写清「对哪一份基线」。

TPU 不是挑出来的好样本:9 份只改执行参数的扰动运行

只改执行参数的 9 份扰动运行(v5p 5、v7x 4),8 份四项都不超过 0.85 倍;剩 1 份(v7x,注意力分块 1024)梯度范数待定(MARE 1.02、最大单步 1.15),按 GPU 尺子判就是待定,不拿 TPU 自己的散布解释;它说明只改注意力分块,v7x 的梯度范数就可能落进待定(v7x 扰动组两两的逐步涨落比 GPU 重跑宽约两成,只作诊断)。按专家切那一档没测路由偏置曲线和健康信号;当前配置的路由偏置曲线和健康信号也过。

怎么走到 10 份、两两 45 对的:10 对时有两项待定;两处测量口径;补 5 份重跑
  1. 先只有 ⑤ 的 5 份(10 对),v5p 的梯度范数、v7x 的梯度范数和参数范数落在 1.02–1.24 倍的待定区。
  2. 查出两处测量口径(不是数值差):TPU 记的参数范数是整网一次 FP32 归约,自己的单步误差 2.6e-7,占了 GPU 重跑两两单步差上限 4.86e-7(45 对)的一半以上(GPU 同样比法只有 8e-8),改读按组求和再合成的值;梯度范数逐步涨落约 3%,以 golden 当分母时带符号均值有约 1e-3 的正偏,两两配对按哪边在前,N 从 1.26e-3 变成 2.49e-3,改用两边均值当分母。改完 10 对下仍有两项待定。
  3. 所有 r 都在 0.7–1.3 之间,没有一项明显偏大,像是参照太少(N 取最大值,样本越少越窄)。看到待定以后决定再跑 5 份(事先没有写停止规则,跑完这 5 份没再加),10 份两两 45 对把它们全部收进来,最差 0.85。不做那两处口径改正,45 对(10 份两两)下也全部过,最差 0.84。
1000 步这一级全过;其余几级还有几格不是「过」:每一格都对上了一条机制
检查为什么
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),所以正式验收用不加钩子的构建
第 1 步的张量换过尺子:当时改成两侧执行噪声的并集,后来撤回;对 FP64 分清谁更远;TPU 三类参数的梯度先舍成 BF16
  • 先说结局:这把并集尺子后来按「每一级的尺子都只来自参照」撤回(§4.3),混元 3 的第 1 步也按新尺子重判了:只用 GPU 第 1 步重跑 3 对,11 项变严(待定→不过 10、过→待定 1),没有一项变松;不过的各项标「不过 · 已解释」:机理找到了、都对过 FP64;可其中一部分张量 R 超过 1.2(梯度最差 2.20/2.70、优化器状态最差 7.95/7.86(v5p/v7x)),按 R ≤ 1.2 的字面还不算「已定责」。1000 步的结论不变。下面几条是当时的做法。
  • 为什么换:第 1 步 GPU 重跑路由一个不翻,尺子对路由翻转宽度是 0;可 TPU 只改执行参数也会翻。第 1 步整步的张量改用两侧执行噪声放在一起(并集)当尺子:GPU 第 1 步重跑 3 份、两两 3 对,加上 TPU 只改执行参数的 7 份、两两 21 对,共 24 对,取最大当 N。
  • 逐层隔离回放的反向:每层输入固定,只改执行方式时路由不翻,并集里没有路由翻转这一份,改按 FP64 的 R 比判(跟单算子、单层一样):v5p 0.98 / 0.74 / 0.83 / 1.01,v7x 0.98 / 0.96 / 0.88 / 0.95,全部 ≤ 1.2,这一项结案。
  • 整步超出并集的部分对 FP64 定责(只用来分清谁离精确更远,不当门槛):把每个张量的误差按梯度大小加权合起来,整网 R 1.20(v5p)/ 1.21(v7x)。投影、共享专家、稠密 MLP 的梯度 R 0.45–0.96,TPU 更接近精确;路由专家与路由权重 0.76–1.32(v5p;v7x 最高 1.44),两边差不多远,来自路由近平局;一维 norm 权重、输出层、词嵌入的梯度大多是 TPU 更远,最高 2.2(v7x 2.7)。
  • 后面那一处的机制(逐一用诊断改动验证过):TPU 框架把这几类 FP32 参数先转成 BF16 再用,梯度在每个设备、每份小批上先舍成 BF16 存下来(落地),再累加回 FP32;GPU 框架把权重梯度直接累加进 FP32。三个地方:RMSNorm 把 scale 舍到 BF16(JAX 在反向对梯度也舍一次);输出层先把权重转成 BF16 再乘,权重梯度也以 BF16 输出;词嵌入整张表先转 BF16 再取行,反向把梯度加回各行(scatter-add)也在 BF16 里。逐处改掉后 R(v5p,按组):RMSNorm 的 scale 1.35 → 0.58;输出层 1.60 → 0.91;embedding 1.21 → 0.87;三处一起,整网 1.20 → 0.67,第 1 步 loss 一位不变。
  • 对应的开关:三个,默认关,前向不变(第 1 步 loss 一位不变),步时 v5p +0.79%、v7x +1.6%(100 步对比)。它只管这一处,路由翻转那一份不受影响;v7x 上整网 R 1.21 → 0.72。打开以后 1000 步对 ⑤ 复核过:v5p 全过(loss 全程 0.88、尾段 0.91、梯度范数 0.79、参数范数 0.60、路由偏置曲线 0.85);v7x loss 全程 0.78、尾段 0.73、参数范数 0.53、路由偏置曲线 0.68 过,梯度范数待定,最大单步 1.05 倍(带符号均值 0.10 倍、MARE 0.97 倍)。没有加进正式对齐配置,是可选开关:1000 步这一级不需要它,只有想让第 1 步这三类梯度不比 GPU 离 FP64 远时才开。
  • 签字清单里「第 1 步的噪声检查全部过」这一项:按签字原则不满足;超线处的机理都已查到、实测不累积,但其中一部分张量 R 还没压到 1.2 以内,没达到定责线;接不接受由使用方决定。
想两边对得更紧,要动哪些开关:TPU 一侧必需两项、推荐两项,GPU 一侧一处,各有代价
  • TPU 必需:边传边乘(collective matmul)的部分和留在 FP32(§5.3),步时 v7x +1.9%、v5p +0.66%。它是单算子、单层这两级要的;1000 步这一级不靠它,开关打开前的配置对 ⑤ 也全过(最差 v5p 0.79、v7x 0.78)。梯度累积的分组跟 GPU 一样。
  • TPU 推荐:RMSNorm 在 FP32 里算完只舍一次(第二次迁移在 v5p、运行库 0.0.52 上,不开就超,§10.2);门控激活逐个算子舍入(不开时这个算子只有约四分之三元素跟 GPU 逐位)。可选:按专家切,步时反而少 28%(v7x)。
  • GPU(只影响 golden 的制作):输出头 dgrad 分段累加,修好的 golden 唯一的数值改动。⑤ 升 FP32 再分段,步时多 61%(大头在升 FP32,按单次乘法耗时推断);乘法留在 BF16 张量核、只分段,1000 步跟 ⑤ 分不开,步时只多 6%(§7.5)。
  • 想朝真精确再近一步:两边都让 dlogits 留在 FP32(TPU 步时多 9.6%,v7x),对齐本身不需要。
考考自己:只有 5 份、两两 10 对时几项落在 1.02–1.24 倍,补到 10 份、两两 45 对就全过了。这算不算「把尺子放宽了好过关」?

先老实交代:补跑和改口径都是看到待定以后做的,事先没有写停止规则;跑完 10 份以后没再加。所以要靠下面三条让你自己判断:N 取最大值,样本少时系统性偏窄,10 对时所有 r 都挤在 0.7–1.3、没有离群项,像尺子短而不像真差;另外两条旁证 —— 不做口径改正、10 份两两 45 对下最差 0.84,TPU 9 份扰动运行里 8 份不超过 0.85,剩下一份(只改注意力分块)按 GPU 尺子判仍是待定。

9.6 开关上不上生产:三类

验收时为对齐打开的开关,上线那天要是原样全开,有的白白多花步时,有的还让 TPU 变得不如不开准。

一个开关上不上生产:问三件事 蓝色圆角框 = 一个问题;彩框 = 结论和例子;1% 是对齐记录台账的分类线 修错:生产也开 更准且便宜:生产也开 对齐专用:生产关 取舍:看代价 决策树(例子取自两次迁移) 修的是正确性吗? 修错 → 生产也开 · 负数开根号出 NaN 的修复 是 不是 打开后 TPU 离 FP64 更近吗? 对齐专用 → 对齐时开、生产关 · 照 GPU 强制舍成 BF16 · 优化器一段迭代改到 BF16 · 多舍一次 BF16、照 GPU 的舍入位置 · 四路相加照 GPU 的顺序(+0.2%,更准未证实) 不是 是 步时代价 < 1%? 更准且便宜 → 生产也开 · 部分和留 FP32(v5p +0.66%) · 精确的除法、开方(+0.1%) 是 取舍 → 看代价 · 同一个部分和开关,v7x +1.9% · 平台不同,类别可能不同 不是 对齐要开的开关,不等于生产要开的开关:先问它让 TPU 更准还是只是更像 GPU
从左上那个问题开始往下走。
1% 是对齐记录台账的分类线。
出处与口径

📌 步时:部分和 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% 是本课取的界,按目标规模和平台重量一次再定。

第二次迁移:换一个模型,方法还灵不灵(课上不讲)

9.7 第二次迁移:换一个模型,方法还灵不灵

第二次迁移照同一条路走:先在保留全部结构、只缩宽度和层数的小模型上做 L0–L4 全套;再让 GPU 自己扩到多台机器、换切法,看参照守不守得住尺子;最后上真实宽度。模型的规模要一级级上,像装修一次只换一样:小模型上查出的根源不能直接外推,一下子跳到真实权重,冒出新的差又说不清是谁带来的。

结果一句话:小尺寸 1000 步九项过八项;GPU 扩机器、换切法守得住尺子;真实宽度上冒出的差,一半定到一个常数舍入(注意力里 eˣ 改用 2 为底,常数 log₂e 被舍成 BF16,叫 base2),还有一截在查。

第二次迁移的全套结果:梯子图、拆成两半的那个差、三块成绩单、base2 机理
每一级两边各自对 FP64:差冒出来的那一级翻了哪几行,嫌疑就在那几行 行 = 模型的一样属性;列 = 一级;颜色 = 这一级的这一样跟谁一样;右 = 第 1 步主 loss 两边各自对 FP64 同小模型 同真实模型 改了,两边都不像 三级,每级换了哪几样(第二次迁移) ① 小模型 ② 中等尺寸 ③ 真实权重截层 宽度、注意力形状 同小模型 同真实模型 同真实模型 专家个数 同小模型 同小模型 同真实模型 专家宽度 同小模型 改了 同真实模型 层数 同小模型 同小模型 改了 权重 同小模型 同小模型 同真实模型 黑粗框 = 这一级新换的 第 1 步主 loss 对 CPU FP64(对数轴,标正负) ① GPU 8 份都在 ±2.5e-6 内 TPU −3.7e-6(同一量级) ② GPU +1.42e-5 TPU +2.4e-7 ③ GPU +5.3e-5 TPU −9.9e-5 1e-07 1e-06 1e-05 1e-04 深灰 GPU、紫 TPU;③ 紫条里的白线 = 只关 base2 以后:−1.2e-6 每一级尽量只换一类,而且两边各自对 FP64 看:差是谁的、从哪一级冒出来,一眼分开
右边每一级两根条:② 那一级灰条(GPU)先变长,③ 那一级紫条(TPU)才变长。
格子只写跟谁一样,不写尺寸;右边对数轴。
出处与口径

📌 实测,第 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 一半。只看两边的差,这两半是分不开的。全套结果:

第二次迁移:同一套方法再走一遍 左:小尺寸 1000 步成绩(尺子 GPU 16 份);中:GPU 自己扩机器、换切法;右:真实宽度三层,第 1 步的差定了责,1000 步跑完 过 待定 不过 GPU 运行 关 base2 以后 Ⓐ 小尺寸,1000 步九项(现行对齐配置,实测) 主 loss(全程) 0.98 主 loss(后段) 0.97 MTP loss(全程) 0.81 MTP loss(后段) 0.80 索引器蒸馏 loss 0.75 梯度范数 0.79 参数范数 0.14 路由偏置均值 1.31 路由偏置散布 0.85 1 过 8、待定 1(路由偏置均值;另五份 0.36–0.80) 主 loss 0.98 刚好过线;后段跟不修还分不开 Ⓑ GPU 换机器数、换切法(实测) 0 1 2 1 台,原设置重跑 1 台,EP 8 2 台 DP16+EP4(8 份) 2 台 DP16+EP16 2 台 PP2 4 台 PP2 学习率大 10% 的正对照:4149 倍(出了图) 存档续跑:跟不断开逐位相同 (两台机器,上万个状态张量逐个比) Ⓒ 真实宽度三层(实测) 第 1 步主 loss 对 CPU FP64 的相对差 0 = 真值 GPU TPU TPU 偏低,定到注意力的 base2: 常数 log₂e 舍成 BF16,logits 整体 ×1.0018 只关这个开关:-9.87e-05 → -1.24e-06 1000 步回放九项(过/待定/不过) 开 base2 关 base2 关了以后不过清零;剩下的后段偏低, 在同一份权重上核过:是轨迹差, 不是前向差,来源还在查 换一个模型,方法照样走得通:小尺寸九项八项对上,真实宽度第 1 步的差查到了根
左边只有一根橙条(路由偏置均值)略过 1;中间没有点过 2;右边红点关掉 base2 以后挪到真值旁边。
三块都是实测;左块那项待定,同配置另五份的这一项都过。
出处与口径

📌 Ⓐ 小尺寸(约 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,所有尺寸的对齐配置因此都关了 base2GPU 第 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。

MaxText(混元 4 公开分支):开关 sa_use_base2_exp(默认开)

第三次迁移换了一个起点:不从对齐好的代码出发,从生产代码原样出发,一个开关一个开关地打开,每一级跑一遍全套。这样每个开关修了什么、代价多少、上不上生产(§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。)

这一节留下的问题:验收是一次性的。模型投产以后训练代码每天都在变,怎么知道它没有悄悄改了数值?

第 十 节

工程化与教训

守住数值靠回归;少走弯路,靠把走过的弯路记下来。

10.1 TPU 的脾气:改了什么,结果变不变

改完结果不逐位了,是改出了 bug,还是只换了加法顺序?第二次迁移把日常会碰到的改动一样一样量了一遍:每次只改一样东西,跟一次确认过的 TPU 运行比,尺子借 GPU 重跑(TPU 自己重跑逐位相同,量不出宽度),第 1 步再对 FP64 定责。

TPU 的脾气:改一样东西,结果变不变、要不要管 第二次迁移(混元 4 缩小版),绝大多数在运行库 0.0.46 上;每次只改一样,对 TPU 自己的 golden;r 的分母取 GPU 同设置重跑 逐位相同 34 变了,跟 GPU 重跑一样大 44 真有影响(归成 7 件) 17 动了精度、量不出来 5 故意改坏 15 没出结果 6 Ⓐ 121 种改动,一格一种 Ⓑ 300 步曲线最差 r(对数):蓝 = 跟重跑一样大,红 = 真有影响 1 2 5 10 20 纯噪声最高 2.47 跟重跑一样大 44 纯数据并行 不能忍 4.1 → 611(FP32 开关撞上编译器 bug) 输出头反向少舍一次 待定 关省舍入 不能忍 13 关小矩阵乘改写 能忍 RMSNorm 多舍一次 能忍 多路残差不强制舍 BF16 能忍 上下文并行 能忍 300 步曲线最差 r(对数) 空心:曲线分不开, 第 1 步对 FP64 才抓到 不逐位不等于有 bug:34 种逐位、44 种跟重跑一样大;真有影响的 7 件里,不能忍的只有两件(运行库 0.0.46)
蓝点挤在 1 附近;红点实心的出了线,空心的曲线分不开、靠第 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 上不能忍的只有两件:纯数据并行(第八节)、关掉省舍入其余五件:四件能忍、一件待定
七件里的细节:另外五件、1000 步长跑那几个

换到 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 以内。

几个值得记住的脾气:换 v7x、换运行库、重算、「第 1 步一样、后面分开」
  • 换到 v7x:同一个镜像、同一个程序,第 1 步梯度相对差中位数 3.9e-3、离 FP64 的比值 1.01;300 步最差 r 1.02;v7x 上自己重跑逐位相同。编译出的程序不一样(v7x 直接用 reduce-scatter),步时 0.343 s(4 片) 对 v5p 0.494 s(8 片),按芯片·秒省 65%。关省舍入在 v7x 上同样分得开,但机制不同:v7x 上 FSDP 那次词嵌入 scatter 交给了 SparseCore,没变远(1.11 倍);超出来的是梯度范数,主干梯度整体小约 4e-4。v5p 上也有同样的缩小(被词嵌入盖住了),在那里的最小复现里看后端指令,查到多路残差那一段反向里一颗求和,后端把每个 FP32 乘积先舍成 BF16 再累加;照这一处改写,MLP 的缩小几乎全部复现,注意力只复现约三分之二。v7x 是按同一机制推断,为什么会让梯度系统性变小也没查清。这一层在编译后的 HLO 里看不到,要看后端指令。改纯数据并行在 v7x 上曲线 r 2.21,按 2 倍线判超、按纯噪声最高 2.47 读分不开,最后是第 1 步对 FP64 抓到的。
    换到 v7x 本身也不是纯换顺序:输出头反向那颗 kernel 里省掉了一次 BF16 舍入,多路残差收拢处三个小参数第 1 步离 FP64 1.25–1.30(golden 0.03–0.07),最大 R 46.2,有几个元素符号反了。它们原先被单列,没有倍数上限,曲线就判成「分不开」;2026-11-12 单列加了上限(R 5.22),这几次改判「超」,归成真有影响的第七件。单列的张量偏了多少也要看一眼:没有上限的豁免,会把真缺陷盖住。
  • 换运行库:0.0.45–0.0.48 相邻版本两两比,有一对逐位相同,有两对不逐位但跟重跑分不开。第 1 步的变化比换切分小一个数量级,可几百步以后照样分开到同一个量级:轨迹会把任何不逐位的扰动放大到「换了顺序」的幅度。但「基准运行跟重跑分不开」不等于「别的改动的结论不变」,见 §10.2。
  • 重算策略:数学上应当逐位相同,三种实测都不逐位 —— 编译器按不同的保存方案重排了融合和通信,求和顺序跟着变,跟换切分是同一个量级。
  • 第 1 步一样、后面分开,不一定是 bug:把 all-reduce 交给 SparseCore(芯片上的专用小核),第 1 步 loss 逐位不变,可 14 个专家权重的梯度变了,更新以后第 2 步起分开;300 步 r 1.03。一次集合通信换一条硬件路径,就能造出这个现象。
这把尺子能抓多小:故意埋 bug 扫大小(图)

这把尺子能抓多小?反过来故意埋 bug、扫大小:学习率偏大 1e-4 就抓得到,偏 3e-5 以下跟重跑分不开。也有尺子量不出来的:

尺子能抓多小:学习率偏 1e-4 抓得到,偏 3e-5 就分不开 左:故意埋 bug、扫大小(300 步,对数对数);右:尺子量不出来的几个精度改动(1000 步,GPU 16 份当尺子) 学习率 × (1 + ε) MTP loss 权重 × (1 + ε):主 loss 同上:记下的 MTP loss 纯噪声能到的范围 Ⓐ 故意埋 bug:r 跟 bug 的大小成正比,太小就淹进噪声 纯噪声能到 2.47(300 步) 1e-5 1e-4 1e-3 1e-2 1e-1 1 10 100 1000 10000 埋进去的 bug 有多大:ε r 1e-4:r 4.1,抓得到 3e-5 以下:分不开 记下的 MTP loss:跟蓝线几乎重合 训练效果要到 1e-2 才显 r ≈ (4.1–4.6)e4 × ε Ⓑ 动了精度,尺子却量不出来(1000 步) 少开「投影照 GPU 的 FP32 累加」 1.64 SwiGLU 少舍一次 1.37 索引器打分不用真 FP32 1.06 指数等函数回到 TPU 默认近似 1.07 Muon 正交化改 FP32 0.97 纯噪声最大 1.82 全局的系统偏差,相对大小 1e-4 就抓得到;再小,或者只动一小块,曲线就看不出来
蓝线从 1e-4 起斜着往上,左下那两个点埋在灰带里。
左块对数对数;右块五根条都没过虚线。
出处与口径

📌 实测(第二次迁移,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 个动了精度的改动,两样都抓不到 —— 分不开只说明这把尺子量不出,不说明没影响。

10.2 换运行库:不一定只换了加法顺序

上面那张图都在 TPU 运行库 0.0.46 上量的。升到 0.0.52,对齐记录把同一条路又走了一遍:先离线编译看哪些程序变了,再上卡重建基准运行、把当时的六件逐件重测(第七件后来才显出,没在这批里),每件对同版本的基准比:

换运行库,不一定只换了求和顺序 第二次迁移,TPU 运行库 0.0.46 → 0.0.52:基准运行重建,当时的六件逐件重测,各对同版本的基准比 空心 = 0.0.46 0.0.52,超出纯噪声最高分 0.0.52,在线内 300 步曲线最差 r(对数):结论变了的只有 RMSNorm 一件 1 2 5 10 20 纯噪声最高 2.47 基准运行自己 0.0.52 对 0.0.46,在噪声内 纯数据并行(不修) 2.62 2.82 关省舍入 12.56 13.28 关小矩阵乘改写 0.94 1.00 RMSNorm 多舍一次 1.06 5.50 主 loss 系统偏高;1000 步 3.68;最后一层真舍了两次 多路残差不强制舍 BF16 1.09 1.18 上下文并行(不开 FP32 logits) 0.95 1.27 两次都在线内;那个张量随顺序跳一倍,降了不说明变好 换运行库:先建新基准,再把当时的六件重测;结论只对测过的版本对和配置成立
先看最上面的基准点在线内,再看 RMSNorm 那一行往右蹿出了线。
横轴对数;空心是 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 交出的是同一份程序,编译器优化后的程序和后端的代码生成都一起换了。

代码:升运行库 0.0.52 的三步与全部结果

把 RMSNorm 单次舍入的开关开着,这件就没事(§10.3 清单④):换版本时,「开关开着没事」比「这件以前能忍」可靠。

另外几件在 0.0.52 上:程序变了多少;一件变弱、一个门槛变了、四件不变
  • 程序变了多少:v5p、v7x 各种并行一共 113 项、去重后 103 份配置,编出的程序在两个版本下全部不同。
  • 一件变弱、一个门槛变了:上下文并行降到 0.95(那个张量本来就随加法顺序跳一倍,只算这次没过线);词嵌入排序门槛变了,v7x 上不累积的纯数据并行,词嵌入梯度不再丢精度(§8.6;这次运行整体另因输出头 3 个小参数判「超」,是另一件)。纯数据并行、关省舍入、关小矩阵乘改写、多路残差这四件,在 v5p 上结论不变。

门槛那一处是先离线预测、再上卡核对的:

换运行库,排序门槛也挪了:先离线预测,再上卡 第二次迁移,v7x 纯数据并行、不累积;门槛 = 后端开始自己插排序的下标数(单算子离线编译二分) 每卡的下标数 8,192 蓝色阴影 = 过了门槛、会排序 v7x 纯数据并行、不累积:先离线预测,再上卡核对 每卡一次 scatter 加 8,192 个下标; 下标数过了门槛(蓝色阴影),后端才自己插排序 运行库 0.0.46 0 5,000 10,000 15,000 门槛 15,105 8,192 在门槛左边 → 不排序 运行库 0.0.52 0 5,000 10,000 15,000 门槛 7,181 8,192 过了门槛 → 排序 上卡核对:曲线是噪声的 4.06 → 0.89 倍; 词嵌入梯度离 FP64 的 R:6.90 → 1.10 词嵌入这一处预测成立:先离线编译看排没排序,再上卡
红点 8,192 在 0.0.46 门槛左边、0.0.52 门槛右边。
门槛全表在图下出处里;上卡核对是实测。
出处与口径

📌 门槛表(单算子离线编译二分出的最小插排序下标数):表 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 那件为什么变强:逐步曲线;两次舍入为什么系统偏小(图、机理)

逐步看,RMSNorm 那件在 0.0.52 上是真的「一直偏高」,不是一两步的尖峰:

RMSNorm 多舍一次:0.0.46 上 300 步在噪声里,0.0.52 上一直在零上面 纵轴 = 主 loss 逐步相对差(被测 − 同版本基准)÷ 基准;灰带 = GPU 16 份两两每步最大差;粗线 = 50 步平均 0.0.52 多舍一次(1000 步) 0.0.46 多舍一次(300 步) 0.0.52 只让最后一层舍两次(300 步) GPU 重跑每步最大差 第二次迁移小尺寸,TPU v5p FSDP 8,主 loss 逐步(实测) −5e-5 0 +5e-5 第 1 步 第 250 步 第 500 步 第 750 步 第 1000 步 0.0.52:平均 +1.7e-5 0.0.46:平均 +1.3e-6 只动最后一层:+2.1e-5 同一个改动,换运行库从「300 步在噪声里」变成「一直偏高」:0.0.52 上第 2–1000 步 95% 的步在零上面
红粗线一直在零上面,蓝粗线 300 步在噪声里(末尾略往上翘,更长没有数据);橙线跟红线重合。
单步约七成在灰带里,看得出的是方向一致;单份运行,实测。
出处与口径

📌 实测(第二次迁移,小尺寸,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 在定内存布局时给归一化值插了一次布局转换,挡住了融合,两次舍入都真发生了:

RMSNorm 多舍一次:0.0.52 让最后一层真的舍了两次 第二次迁移,小尺寸,v5p;默认写法 = 归一化值先舍成 BF16、乘 γ 再舍一次 只舍一次 真舍两次 Ⓐ 最后一层 RMSNorm,两个版本编出来不一样 运行库 0.0.46 归一化 × γ 舍 BF16 一颗 kernel,中间那次被省掉 运行库 0.0.52 归一化 舍 BF16,写回内存 读回 × γ 再舍 BF16 布局转换挡住了融合,两次都真舍 Ⓑ 为什么两次舍入有偏:γ 贴近 1 0 −1.5e-3 γ = 1:第二次舍入精确,没偏差 γ = 0.996:缩小 1.7e-3 离 1 远处只剩几e-5,有正有负 0.9 1 1.1 1.2 最后一层的 γ:均值 1.001,范围 0.86–1.18 → 输出头的输入整体缩小 1.49e-4 Ⓒ 只动最后一层,就能打开、关掉这件事(300 步曲线最差 r) 0.0.46 其余各层 默认写法,最后一层 默认写法(编译器只舍一次) 1.06 0.0.46 其余各层 单次舍入,最后一层 强制舍两次 6.83 0.0.52 其余各层 默认写法,最后一层 默认写法(编译器真舍两次) 5.50 0.0.52 其余各层 默认写法,最后一层 单次舍入 0.84 0.0.52 其余各层 单次舍入,最后一层 强制舍两次 6.97 纯噪声最高 2.47 机理跟版本无关,版本只决定编译器有没有把中间那次舍入省掉
左上两排只差一个虚线框:0.0.52 把归一化值单独写回了内存。右上 γ 贴近 1 时偏得最多;下面只动最后一层就开关这件事。
Ⓐ Ⓒ 实测;Ⓑ 是推导配 FP64 实测。
出处与口径

📌 实测(第二次迁移,小尺寸,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。所以换版本时,「开关开着没事」比「这件以前能忍」可靠得多。

代码:RMSNorm 多舍一次:0.0.52 上为什么变强(证据六条)

考考自己:升级运行库以后,新基准跟旧基准在噪声内。能不能直接沿用旧版本上「这几件能忍」的结论?

不能。基准运行只说明「这一个配置」换版本跟重跑分不开;别的改动走的 kernel 可能变了。0.0.46 → 0.0.52 就是例子:基准 0.99,可 RMSNorm 多舍一次从 1.06 变成 5.50。要把已知的几件在新版本上重测,或者干脆把相应的开关都开着(RMSNorm 单次舍入)。

10.3 日常回归:逐位优先

第一步:改完先比程序指纹(编译后的整份程序去掉元数据、名字重新编号以后的哈希)。像门禁按工牌放行:今天的程序跟上次登记的一字不差(同一运行库、镜像、芯片上),结果就一定逐位相同,回归直接过;不一样,再跑 300 步看档。对齐记录把它做成了跑前离线筛,拿已经上过卡的改动回测过:

跑前离线筛:上卡之前,先在 CPU 上编一次、比程序 对齐记录拿已经上过卡的 109 个改动回测(第二次迁移,TPU v5p 为主) 程序相同:不用跑 程序不同:上卡看档 判不了:直接上卡 Ⓐ 一次编译,三个出口 改了一处 CPU 上为目标拓扑编译 约 3 分钟,不占芯片 比优化后的程序 去元数据、名字重编号 程序相同 23 不用跑;上卡实际全部逐位 程序不同 72 上卡 300 步看档;5 个仍逐位 判不了 14 SC 开关 6、换运行库 5、换芯片 3 Ⓑ 判得准不准 能判的 95 个,对上 TPU 实际: 相符 95 不符 0 运行库升到 0.0.52 以后: 104 个能比的改动,判定一条没变 抽 3 条判相同的上卡,全部逐位 判不了 ≠ 判错:只是规则上直接上卡 程序不同也可能逐位:只会多跑,不会漏 改完先编译比程序:一样就不用跑,不一样再上卡;后端会一起变的几类,规则上直接上卡
左边一次编译三个出口;右边能判的全部对上。
数都是对齐记录的回测实测。
出处与口径

📌 实测(对齐记录「跑前离线筛:回测」):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 上实际存下的规范化后一字不差。

离线筛怎么比、那几类为什么判不了
  • 怎么比:取编译器优化后的训练步程序,去掉元数据和源码位置,指令名按出现顺序重新编号(CPU 上编和 TPU 上编,名字里的序号会差几十),设备分组展开成设备号,每个子计算的参数按编号排到最前,然后逐字比。CPU 上编出的程序跟 TPU 上实际存下的,规范化以后一字不差。
  • 判不了的几类:换运行库、换镜像(后端代码生成一起换了,程序相同也不能推出逐位相同);换芯片代际(本来就是两个程序);SparseCore 卸载的开关(卸载可能不体现在优化后的程序里,规则上谨慎起见直接上卡;目前程序相同的两个这类开关,实测结果也都逐位)。这几类直接上卡。
  • 程序不同,结果也可能逐位相同:比如全局矩阵乘最高精度,程序变了、结果一位没变。离线筛只会让你多跑,不会让你漏跑。

代码:跑前离线筛 代码:用法与规范化规则(「跑前离线筛」一节)

指纹加上噪声尺子和 FP64,还抓到过一个编译器的真 bug:数据并行 + 梯度累积 + 词嵌入梯度 FP32 累加三样同时成立时,编译器把跨卡求和挪出累积循环,又在循环里把 1–7 号卡的累加器清零,第一个微批的梯度没了、只剩第二个(r 611,第八节撞上的就是它)。

程序指纹与那个编译器 bug(图):程序指纹哪些改动一样;1–7 号卡微批 1 被清零的那个 bug
改完先比指纹;工具抓到的一个真 bug 左:程序一样就一定逐位,省掉一次训练;右:一个只在「数据并行 + 梯度累积 + 词嵌入梯度 FP32 累加」同时成立时出现的编译器 bug(第二次迁移,实测) 逐位相同 程序变了:跑 300 步看档 被清零的梯度 Ⓐ 改完先只编译,比程序指纹 改了一处代码 只编译,不训练 比程序指纹 一样 → 一定逐位相同,不用跑 · 给中间值起名字 · 拆出一个函数 · 求平均写成求和再除 不一样 → 跑 300 步看档 结果仍逐位: · 乘法换个顺序 · 除以 n 换成乘 1/n · 梯度裁剪换写法 · 多记一个监控量 不逐位: · x·x 代替 square(x) r 1.09 · einsum 换广播乘 r 1.10 Ⓑ 编译器把跨卡求和挪出了累积循环 微批 1 微批 2 卡0 卡1 卡2 卡3 卡4 卡5 卡6 卡7 跨卡求和 只在这里一次 循环里每一圈都对「卡号 ≠ 0」的卡把累加器清零,求和挪到了循环外面: 1–7 号卡只剩最后一个微批,0 号卡完整。 词嵌入梯度范数 0.51 倍 有梯度的行里整行为零 2829/10911(26%) 离 FP64 远 130 倍 300 步曲线 r 611 修法:每个微批的梯度累加前加一道屏障,挡住这次挪动 → r 0.98;golden 重跑逐位不变 便宜的先做:先比程序指纹,再跑 300 步;尺子和 FP64 一起看,连编译器的 bug 都能抓出来
左边:一样就不用跑。右边:七个红叉,是编译器丢掉的梯度。
8 张卡、每卡 2 个微批是这次的实际设置。
出处与口径

📌 实测(第二次迁移,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 的改动自己先过了「数学不变」那一行。

指纹变了,再按下面这张流程分流:

日常回归:先要求逐位,不逐位再按声明分流 方块 = 一个环节;菱形 = 一个判断;参照不是 GPU,是上一次全部通过的 TPU 运行(LKG) 通过 退回 用 TPU 噪声判 回到对齐验收 TPU 同一程序重跑逐位相同,所以「数学不变」的改动应当一位不变 训练代码改动 写「数值影响」声明 跑一轮回归 一次约 10–25 分钟 对 LKG 逐位? 通过,LKG 前移 看声明 写了数学不变却不逐位 → 退回 没写声明的也按这条处理 执行级 / 升级依赖 容差门:TPU 执行噪声(TPU 28 对) 数学级 对齐门:对修好的 golden 不变差 是 否 迁移验收证明「TPU 和 GPU 训的是同一个模型」;日常回归证明「今天的 TPU 和上次验过的 TPU 是同一个」
大多数改动走上面那条绿线就结束了。
LKG 是 last-known-good 的缩写。
出处与口径

📌 实测(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 官方不保证跨版本可复现

PyTorch 自己的文档就写明,不保证跨版本、跨提交、跨平台的结果完全可复现。所以噪声标定和上一次全过的运行都要绑死版本。

搬上 TPU 以后改代码,照这几步做 ① 改完先只编译,比训练步程序的指纹:一样就逐位相同,不用跑(本节上面)。
② 指纹变了,跑 300 步对 TPU 的 golden:曲线最差 r 不超过纯噪声的最高分、第 1 步没有离 FP64 更远的张量,就是换了顺序。
③ 动到精度或数值路径的,再跑 1000 步、用 GPU 16 份当尺子;记下的每一项 loss 都逐项比。
还有四条:四个已知会动精度的坑、对顺序敏感的小张量、换运行库、换设备数/梯度累积/切法
  1. 四个已知会动精度的坑:纯数据并行时只切词嵌入表(或词嵌入梯度用 FP32 累加,第八节);别关 excess precision;RMSNorm 开单次舍入(最后一层输出舍两次那件;v5p、运行库 0.0.52 上不开就超;跟第五节那个 norm scale 舍入不是一回事);上下文并行目前只能配普通注意力,要让 softmax 真走 FP32(新版代码起,旧代码写了也不生效)。
  2. 本身对加法顺序很敏感的小张量(比如注意力的 sink 参数:每个头一个可学习的标量,给 softmax 多一个「哪都不看」的去处),1.2 倍的门槛对它太紧,先看只换顺序的几次运行会跳多大;被小参数豁免单列的,要看豁免清单里的倍数。
  3. 换运行库版本:离线筛判不了;先建新的基准运行,跟旧的比,再把上面几件重测一遍(§10.2)。
  4. 换设备数、换梯度累积、换切法:先离线编译一份生产规模的训练步,数边传边乘的循环和它们的累加器类型、数被删掉的「转 BF16 再转回」(§5.3、§5.4);要真舍,写强制舍入。

10.4 踩过的坑,和怎么记

一路走来:八步留下,四步走错又折回 混元 3 截 4 层;绿站 = 留下来的一步(只写一个数),红虚框 = 走错的一步(只写教训),细节在图下 留下来的一步 走错、折回 这一次排查的路线(实测) 1 地基铺平 第 1 步 loss 只差 2.5e-6 2 换成噪声尺子 是 N 的 1.53–2.45 倍 3 按参数分组定位 87% 在输出层,大头是冷门词 4 双向干预 lse 的差 −0.33 → −0.007 5 找到源头 GPU dgrad 朝零 −6.51e-4 6 golden 一步步改 23.6 → 10.1 → 3.5 倍噪声 7 部分和留 FP32 qkv R 1.235 → 1.000 8 定案 ⑤ 最差 0.85 倍,全过 ✗ 「FP32 dgrad」其实是 TF32 教训:开关以实测为准 ✗ 路由翻转当成两边实现不同 教训:参照先对 FP64 验 ✗ 精确轨迹的噪声只看一对 教训:一对量不出散布 ✗ 把 ④ 当成了精确值 教训:裁判也要被核对 四步走错,三步错在「参照」:开关、FP32 参照、精确轨迹都被当成了它名字说的那样
先看红虚框:四步走错,各留一条教训。
绿色八站是留下来的,每站一个数;细节在图下出处里。
出处与口径

📌 每站的细节:① 数据原样回放、权重逐张量逐位、按实际生效的权重衰减;② 同设置 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 的分段累加;其余几步都是把量法和参照弄对。各数都在出处台账里。

归成前面一路埋下的三条暗线:每个结论先问拿什么比;名字对了不等于生效,读回值、工具输出都要实测核对;先排除自己(包括当参照的那一份),再怀疑硬件。第二次迁移的坑也都落在这三条里(下方坑表里标了出处的几行)。

坑表:23 行,每行一个坑、一条规矩
坑长什么样判据
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,过;没有一处是靠尺子
测量口径撑大了 rTPU 的参数范数自己就测得粗(单步误差占尺子一半以上);梯度范数的带符号均值以 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对照表写运行时读出的实际值
把工具和结论混在一起通用文档里夹着某个模型的数字,换模型时没人敢删工具目录只放方法
第二次迁移:哪些原样带过去省了时间,哪些是新的
  • 原样带过去的:协议在看到结果之前写死,之后每一处改动新旧判定并列;TF32 启动实测;设备 d 对 GPU 第 d 张卡、原样回放数据;每个统计取各对的最大值;逐张量 sha256 清单当地基锚点。第一天就都有了。
  • 新的:每一级的尺子都只来自参照,并集撤回(§4.3);TPU 同设置重跑逐位相同,也不改尺子的取法(它的波动只作诊断);「FP32」在 TPU 默认精度下只算一遍 BF16,HIGHEST 也只是近似(§5.5);稀疏注意力的 top-k 翻得多却几乎不影响输出(§4.3);f32 小标量会病态(§5.5 折叠);回放工具要覆盖关键字参数(§6.2);参照一侧自己写的代码也要按五格表查;先拆测量误差再谈数值差。
  • 流程上的两条:定参照之前先把训练配置逐项对齐到生产,查不到写「未知」,别替它选一个常见默认 —— 第二次迁移一开始没查到生产用的优化器,参照选了 AdamW,那一批 golden 全部作废;作业要能无人值守,下载、校验、训练、上传都写进启动脚本。
怎么记:七条,让下一个人从仓库里看出查到哪了
  • 一个问题一份案例文件:标题就是发现,开头写状态、数据从哪来、复现命令;事实带出处,推断标「推断」。
  • 假设表按成本排,排除了的也写:省得后人再查一遍。
  • 一次只改一件事,新结果不覆盖旧的;结论只写一处,错了追加更正,不悄悄改。
  • 工具和结果分开放:工具的文档只讲方法,某个模型的结论和坑写在它自己的目录里。
  • 结果带上检查清单的指纹,只算检查内容:清单里的检查一改,这份清单下的旧结果自动作废;改注释、改说明文字不改指纹,不用为了改文档重跑。
  • 交给别人看的文档按发布标准写:份数和对数分开说(「10 份重跑,两两 45 对」,不写「45 组测试」);每个代号就地加括号说全称;不留「待验证」挂着 —— 要么验掉,要么写清楚还缺什么。
  • 排查和讲课两条线互相喂:讲课时说不清的地方,往往就是排查里没坐实的地方;排查的新结果当天回到课件,课件的追问再变成下一个实验。

10.5 回到开头

TPU 没算错。TPU 的 loss 低约 1.7e-4,按噪声尺子是真偏差;查到最后,大头偏在 GPU 的 golden:一次 12 万长的求和,每一步都朝零少算了一点。改成分块累加、拿它当基线,v5p、v7x 每一项都在噪声内(最差 0.85 倍)。第二个案例里,两种数学等价的并行对不上,查到最后是一次加法的组织方式。

这门课带走的三句话 一、拿 GPU 自己的重跑当尺子:TPU 跟 GPU 的差,不能比 GPU 自己跟自己的差大;超了,就查到底是谁的差,当参照的那一份也要查。
二、超了就对 FP64 定责:离真值远了 1.2 倍以上才是丢了精度,找到多舍的那一步;没变远就只是换了加法顺序,不修。
三、换了条件就要重验:设备数、梯度累积、步数、芯片、运行库,换一样,之前的验证就不作数;精度验证在生产的设备数上做,改完代码先离线编译看一眼。

10.6 拿回去用:清单、速查卡、排查表、练习

这一节留给要在自己的模型上做一次对齐的人。前四个折叠按用的顺序排;后面是延伸阅读和出处台账。

动手清单:在自己的模型上做一次 GPU→TPU 对齐,一步一步来
  1. 定目标和预算:写下要对齐的配置(层数、步数、批大小、学习率、精度),和「对谁比」—— 默认对 GPU 那份 golden。参照的优化器、loss 写法逐项对到生产,查不到写「未知」。协议开跑前写死这几项:基线是哪一份;检查项和各自的窗口;三个统计;用哪组运行当尺子、几对;门槛 1 和 2、R 比 ≤ 1.2;例外怎么处理。开跑前埋好记录点:每步的实际学习率、实际权重衰减、裁剪前梯度范数、裁剪系数;主权重和两个动量的快照节奏;探针序列;数据单元的指纹字段。设备数要跟 GPU 卡数对上(本例 v5p 8 颗芯片、v7x 4 颗芯片,都是 8 个设备);对不上时,切法差会算进 TPU 一侧,留一次切法消融(本例改成按专家切,变化在 TPU 执行噪声以内)。截短模型(本例 4 层)能让每次对比便宜很多;签字前 GPU 侧要跑三四十次 1000 步(本例:默认 10 份、② 5 份、③ 5 份、两条精确轨迹连扰动版 7 份,最后修好的 golden ⑤ 又 10 份)。
  2. 先量 GPU 自己的噪声:同一设置的 GPU 至少跑 6 份(15 对),这是几百步短窗口的下限;1000 步要更多(第二次迁移用 16 份 120 对),够不够用拿留一法看;只用同一种设置的运行配对(确定性开关、分布式优化器开不开,都算设置)。算出每个检查项的 N。默认检查项:loss(两个窗口)、梯度范数、参数范数、学习率;训练时顺手记这几个便宜的量,出事时它们就是线索。
  3. 铺地板 L0:数据原样回放、逐单元比指纹;权重转过去再转回来、逐张量比字节;加载后从设备上再读一遍,参照一侧的训练入口也在第 1 步前对检查点自检;配置对照表写实际生效的值(每步从运行时读出的值,不是配置文件),优化器、重算、统计量的聚合逐行对写法;续训逐位。
  4. 第 1 步自检:看第 1 步 loss 的相对差。第 1 步还没有任何更新,两边只差前向舍入;本例是 2.5e-6。明显大过前向舍入的量级,先回清单第 3 步查地基,别查数值;在这个量级,直接做下一步的张量比较、用 FP64 的 R 比定责(本课经验)。本例的 2.5e-6 只当量级参考,不是下限。
  5. 第 1 步张量:先给每个算子两边写五格 dtype 路径(§5.5),有差的格子先对上;再逐个大张量算 rel_L2、cos、范数比;超线(GPU 重跑的差不是 0 就比它;GPU 重跑一位不差,前向常见,就直接挑差最大的几处)的那一处请 FP64 来算 R 比定责(≤ 1.2 算两边一样远)。MoE 先看路由槽位翻了没有,翻了就按「两边选中同一批 token」重比。
  6. 跑满步数:两个窗口(全程;尾段 = 两条轨迹分开、偏移稳定以后,本例从第 301 步起;窗口事先写进协议;学习率有调度时,尾段要避开预热)各算带符号均值、MARE、最大单步,除以 N 得 r;≤ 1 过、1–2 待定、> 2 不过。待定先补参照重判(补几份、补到哪停,事先写进协议;混元 3 当时没写,是看到待定才补的)。检查项多时,纯噪声也会出待定:至少「条数 × 1/(n+1)」条,带符号均值约翻倍;以留一法实测为准。
  7. 不过就往下排查:从上往下一级级缩小(见下面的排查表);TPU 上拿证据走程序外面(步间读状态、隔离回放、固定探针、状态互换)。
  8. golden 自己可疑时:在 GPU 上跑一条精确轨迹(FP32 主权重照常更新、每步舍成 BF16 再用;前向反向的算术全部 FP32、真关 TF32;像输出头 dgrad 那样的长求和要分段累加,FP32 一次累加也会偏;核长求和要拿训练中途的状态、按实际长度、看关键方向上带符号的偏差,第 1 步对 FP64 核一遍抓不到它;§7.5),分两关:第一关对它判过不过;第二关对生产 golden 写成「已解释差异」。什么时候算可疑:排查表里「TPU 更低、更近 FP64」那一行。参照先对 FP64 核一遍再用(例如真 FP32 的矩阵乘对 FP64 应在 1e-5 以内,§5.5)。尺子怎么选没有通用规则(本例定案前借 ③ 那组重跑,定案时重新写了协议,换成 ⑤(修好的 golden)自己 10 份两两 45 对,旧判定留着并写明作废原因),关键是写进协议、不在判定中途悄悄换。代价:全程 FP32 的矩阵乘比 BF16 慢一到两个数量级(看硬件,以自己卡上实测为准),精确轨迹还得换成不融合的注意力。
  9. 投产后:日常回归先要求逐位;不逐位按 PR 的数值声明分流;TPU 执行噪声用只改执行方式的扰动臂标定,配置一换就重标。扰动臂的常见候选:编译器片上内存上限、注意力分块大小、重算策略(路由结果已存下时)、层是否用 scan;两条筛选:臂对基线必须不逐位(逐位的臂贡献 0、却虚增对数),会系统性增减 BF16 舍入次数的改动(关掉边传边乘、关 excess precision、改累加精度)不能当臂 —— 它们带来的是偏差,不是噪声。选进来的臂还要过三项检查:臂自己重跑一位不差;配置、版本、编译出的程序除了改的那一处都不变;第三项分两半,第 1 步梯度那一半比 FP64:臂离 FP64 不比基线远(按能量 R ≤ 1.2), 只改执行方式的臂也会翻近平局的路由,GPU 噪声那把尺子看不见;1000 步 loss 那一半对基线不超过 GPU 自己的噪声(本例当前配置补做了 6 个臂,R v5p 1.001–1.008、v7x 1.003–1.039,全过;参照里另两个改片上内存上限的臂没有单独补)。这样标出来的 TPU 噪声带里含着路由翻转。本例旧配置试了 14 个臂,过了 7 个。
  10. 记下来:一个问题一份案例文件,事实带出处、推断标出来、排除的也写;坑写进通用文档。

判定那一步的骨架(伪代码,本课推导):

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.2TPU 多舍了一次(例如 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)
不同配置之间偏移不一致并行切法、重算、批大小切法也是数值的一部分参照和被测固定同一切法、同一设置
练习:七道题,答案在每题下面
  1. GPU 重跑 4 份,两两 6 对,参数范数带符号均值的绝对值最大是 2.0e-7;TPU 对基线是 3.0e-7。怎么判?还缺什么?
    答:r = 1.5,待定。只有 6 对,纯噪声超线的概率至少 1/7(各对互不相干时;实际共用运行,带符号均值约 2/7);再补到 15 对以上重判,还在 1–2 倍就往下一级定责。
  2. 第 1 步 loss 的相对差是 3e-4。该先查数值还是先查地基?
    答:本例第 1 步只差 2.5e-6,3e-4 大了一百多倍,远超前向舍入的量级,先回 L0:数据指纹、权重逐字节、配置的实际生效值。第 1 步还没有任何更新,两边只差前向舍入。
  3. 某个注意力投影的 R = 1.40。说明什么?下一步查哪?
    答:像 TPU 多舍了一次同量级的数(√2 ≈ 1.41)。查这处矩阵乘的累加器精度、是否是 collective matmul 在 BF16 里累加部分积、有没有 excess precision 改了舍入位置。
  4. 你的「FP32 参照」对 FP64 的 rel_L2 是 3e-4,GPU 的 BF16 程序是 6.5e-4。能拿它当参照吗?
    答:不能。§5.5 的判据是真 FP32 对 FP64 ≤ 1e-5;3e-4 说明它多半走了 TF32。先真关 TF32(环境变量),启动时实测一遍再用。
  5. 定案前,迁移验收第一关 3.45 倍不过,loss 待定。经理问能不能上线,你怎么答?(再想想:定案以后怎么答。)
    答:先说协议结论:第一关不过,不能签字。定案以后:第一关全过(最差 0.85 倍),对 GPU 生产 golden 的差全部写成已解释差异(GPU 输出头 dgrad 的长求和),剩下几格各有机制;下游评测没测,带条件上线还缺下游评测和更长的运行。一般地给四行:已解释的部分(几成是 GPU golden 自己的偏差);没解释的部分和下一步;下游没测;要带条件上线,还缺哪些证据、止损线设在哪(样子比如:上线后保留 GPU 并跑,loss 尾段 r 超过 2 或下游评测掉过线就回退;具体数按业务定)。能不能上线是业务判断,拿这四行去定。
  6. 换一个词表 25 万的模型,输出层 dgrad 那次长求和的朝零偏差,会比 12 万时更大还是更小?
    答:多半更大:求和越长,截掉的总量越多(抹零每一单只会让绝对值变小);词表越大,失去 Adam 归一化保护的冷门行也越多(推断)。§7.4 真实输出头上,K 从 16,384 到 120,832,偏差从 6.9e-5 涨到 6.5e-4,比线性还快;外推到 25 万是推断,没测过;合成输入在 12 万处偏差反而降,可能是库换了算法,所以「更大」不保证。要么在 GPU 上把这一次 dgrad 改成分段累加(升 FP32 不分段也偏,§7.5),要么至少在第一关前,拿训练中途的状态先测它沿关键方向对 FP64 的偏差。
  7. 一项辅助 loss 每行约 1e-4,从约 7 的 log-sum-exp 里减出来。TPU 记下的比 GPU 低 1e-3(相对),GPU 重跑几乎不散,判「不过」。先查什么?
    答:先问病态的前三问(§5.5 折叠):它的输入两边离 FP64 一样近吗?由它出发的梯度一样近吗?f32 在 7 附近一格约 4.8e-7,约是 1e-4 的 5e-3 倍 —— 差折成大数的格在一两格以内吗?都是,说明病态在放大;再问第四问:同样的计算换 CPU 上算偏不偏。CPU 不偏、TPU 偏,那一格是 TPU 的 exp、log,换高精度写法;CPU 也偏同样多,才写「不过,已定责」。
延伸阅读:想把这一讲的几个底层问题读透,从这几篇开始
  • 浮点加法为什么换顺序就变、前向为什么其实是确定的:Thinking Machines,Defeating Nondeterminism in LLM Inference(2025)。
  • 张量核里的累加到底怎么舍:Fasi 等,Numerical behavior of NVIDIA tensor cores(PeerJ Computer Science,2021);Khattak、Mikaitis,Accurate Models of NVIDIA Tensor Cores(arXiv:2512.07004)。
  • 低精度累加在大模型训练里的代价与对策:DeepSeek-V3 技术报告 sec. 3.3.2(arXiv:2412.19437)。
  • logits 漂移、ε 与训练不稳定:Wortsman 等,Small-scale proxies for large-scale Transformer training instabilities(arXiv:2309.14322)。
  • MoE 路由两套引擎选得不一样:Ma 等,Stabilizing MoE Reinforcement Learning by Aligning Training and Inference Routers(arXiv:2510.11370)。
  • 一次看很多个数、总有一个「超线」:xkcd 882《Significant》(软糖漫画);粒子物理的 look-elsewhere effect,Bayer、Seljak,The look-elsewhere effect from a unified Bayesian and frequentist perspective(arXiv:2007.13821,修正系数通常靠模拟来算)。
  • 拿噪声当尺子:Microsoft ExP 团队关于 A/A 测试的博客;Henderson 等,Deep Reinforcement Learning that Matters(arXiv:1709.06560)。
出处台账:每个结论来自哪一次测量(混元 3 截 4 层;除标「本课推导」外都是实测,步数、配置、单算子还是整网,见右栏)
结论材料与测量条件
BF16 里 1 + 2⁻⁸ + 2⁻⁸ 换个顺序差一格本课推导,图脚本里按就近舍入、平局取偶真算
10 次 GPU 重跑:尾段 loss 带符号均值 −2.5e-5 ± 2.7e-5;TPU −1.03e-4 到 −1.66e-4B200×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.033GPU 运行每一步从优化器参数组读出的权重衰减(1000 步全是 0.033);框架预训练模板与调度器源码
第 1 步 loss +2.5e-611.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.53v5p 当前配置 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-4v5p 单算子对 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.1FP32 主权重的分组、逐行平方和,词频按前 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.10B200,输出头 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-3v5p,第 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-9300 步比较,并集 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.00TPU 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.31GPU 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.641000 步对 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/0TPU 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 生成 —— 正文写在那个脚本里。