把 Megatron 的
pretrain()读完,你会撞上一个反直觉的事实:这份负责「预训练」的文件对模型一无所知。模型怎么构建(model_provider)、一步前向怎么算(forward_step_func)、数据长什么样(dataset_provider),全都是参数传进来的函数。它自己不生产任何一个 FLOP,只负责编排。
有读者问过我一个好问题:拿到一份 Megatron 的 training.py(就是定义 pretrain() 和 train() 的那个文件),能不能靠它彻底搞懂预训练?
我的回答是:搞懂一半,但恰好是大多数资料不讲的那一半。预训练可以粗暴地切成数据面和控制面。数据面是「一个 batch 进去、一个梯度出来」的数学与通信——前向反向、张量并行、流水线调度、优化器更新,这些都不在这个文件里。控制面是「几千张卡连续跑几十天不出错、出了错能恢复、每一秒都被记账」的工程,这个文件就是控制面的全部。教科书和论文讲数据面,控制面几乎只存在于源码里。
这是本站 Megatron 源码系列的第二篇。上一篇《模型配置到底在配置什么》拆的是模型如何被造出来(Config/Spec/Builder 三层);这一篇拆造出来之后如何被训练。如果你读过 nanoGPT 的训练配方,可以把 nanoGPT 那个几百行的训练脚本当作参照物:两者的骨架同构,差出来的部分就是工业级预训练的工程成本。
素材和版本:本文写于 2026-08,读的是一份 Megatron-LM 训练侧的 megatron/training/training.py(NVIDIA 2025 版权头),带若干实验性特性(线性注意力变体、RL 步、GTP 重物化等),不是某个可以指认 commit 的公开版本,所以文中源码片段不给行号。2026-11-04 我把其中几处关键代码和公开仓库 main 分支(commit 993bf83)的同名文件对照了一遍:FLOPs 公式里的因果掩码减半、packing 统计的去重除法、默认桶大小公式、startup-* 计时器、手动 GC,这几处在公开版里都能找到相同写法,下文用到时会说明。文中的手算数字都在文末脚本里,输出是真跑出来的。
读前需要的几个词
| 术语 | 一句话解释 |
|---|---|
| DP / TP / PP / CP | 四种并行轴:数据并行(复制模型分数据)、张量并行(切开单个矩阵乘)、流水线并行(按层切)、上下文并行(按序列长度切) |
| micro-batch / global batch | 一次前反向吃的小批 vs 一次参数更新对应的总样本数;global = micro × 梯度累积次数 × DP 数 |
| grad buffer / bucket | DDP 把所有梯度放进一块连续大缓冲区,再按「桶」为单位分批做通信,让通信和反向计算重叠 |
| distributed optimizer | 把优化器状态(动量等)按 DP 维度分片,每张卡只存 1/N,思路与 ZeRO 第一阶段同源 |
| loss scaling | fp16 训练时把 loss 乘一个大数再反传,防梯度下溢;溢出时该步作废、缩小系数重来 |
| forward pre-hook | 挂在前向计算之前的钩子函数,Megatron 用它把「取回分片参数的 all-gather」藏进前向 |
| CUDA Graph | 把一串 GPU kernel 的启动序列录下来整体重放,消除 CPU 逐个发射 kernel 的开销 |
| BSHD / THD | 两种 batch 布局:定长矩形(batch×seq)vs 把多条变长序列首尾相接打包成一条(sequence packing) |
| SDC | Silent Data Corruption,硬件静默出错——不崩溃、不报错,只是算出来的数悄悄不对 |
| GRPO | 一种 RL 后训练算法(PPO 家族),见《PPO 训练循环解剖》 |
这份文件 = 二十行理想循环 + 四本工程账
这是我的提炼,源码里没有这种说法:这份文件是一个二十行就能写完的理想训练循环,外面包了四本工程账。读的时候先把骨架认领出来,再把剩下的每一段代码归入四本账之一:
- 记账本(observability):每一秒、每一个 FLOP、每一焦耳都要有出处——吞吐、进度日志、能耗、计时器。
- 容错本(fault tolerance):几千张卡跑几十天,硬件故障是常态——checkpoint、重跑机、哈希对账、故障注入。
- 性能本(performance):能藏起来的开销都藏起来——通信与计算重叠、CUDA Graph、跨 rank 对齐的 GC。
- 胶水本(parallelism plumbing):让同一个循环在任意并行拓扑下都成立——进程组集合、DDP 包装、跨模型并行组的决策对齐。
骨架本身长这样:
# 伪代码:train() 的理想骨架(对应 megatron/training/training.py 的 train() 主干)
# 省略:容错、性能开关、RL 支线、日志细节——即本文其余全部内容
while iteration < train_iters:
update_num_microbatches(consumed_samples) # 批大小调度(可爬坡)
loss = train_step(data_iterator, model, optimizer) # 前向+反向+参数更新
iteration += 1
consumed_samples += global_batch_size # 进度以样本数记
training_log(loss, ...) # 记账
if iteration % eval_interval == 0:
evaluate(valid_iterator) # 验证
if should_save(iteration):
save_checkpoint(...) # 存档
if should_exit(iteration):
break # 退出(先存档)
这个骨架和 nanoGPT、和任何 PyTorch 教程里的训练循环没有本质区别。下文回答的是:从这二十行到这份数千行的文件,中间多了什么?
计时从 import 之前就开始了
文件的第一行可执行代码是抓时间戳,排在函数定义和 import 之前:
import time
_TRAIN_START_TIME = time.time() # The earliest we can measure the start time.
# ……然后才是几百行 import
把计时器放在 import 之前,是因为这个体量的代码库 import 本身就慢(torch、Transformer Engine、各种 CUDA 扩展的加载;具体多少秒取决于环境和文件系统,我没有测过),而「作业从调度器拉起到真正开始训练花了多久」是集群利用率的一部分,必须被记账。公开 main 版本在这一行旁边的注释说得更直接:时间戳必须在下面那些「(expensive) imports」之前抓。
pretrain() 启动后还会把每个 rank 各自的启动时间戳做一次全局 all-reduce 取最小值:
program_start_global = torch.tensor([_STARTUP_TIMESTAMPS['program_start']], ...)
torch.distributed.all_reduce(program_start_global, op=torch.distributed.ReduceOp.MIN)
几千个进程不会同时被拉起,「训练开始时间」取决于最早的那个,这才是调度器视角的真实成本。随后一组 startup-* 计时器把启动过程按阶段切开分别记账(库加载、进程内设置、megatron 初始化、JIT 融合配置……;公开 main 里这一处字典有 9 个 startup-* 键)。为它写几十行监控代码是值得的,账很好算:1 万张卡启动慢 10 分钟,就是 10/60 × 10000 ≈ 1667 卡时,千卡时量级。
pretrain() 的整体生命周期是线性的五步:初始化 Megatron(进程组、随机种子)→ 构建模型+优化器+学习率调度器 → 构建数据迭代器 → train() 主循环 → 收尾(补存 checkpoint、跑验证/测试集)。内容都藏在每一步的细节里。
train():主循环的一次迭代到底在干什么
下图是主循环单次迭代的控制流(简化,省略 RL 支线和 CUDA Graph 捕获):
flowchart TD
A["迭代开始"] --> B["校准微批数<br>update_num_microbatches"]
B --> C{"微批数变了?"}
C -- "是" --> D["先存 checkpoint"]
D --> E{"在跳过名单里?"}
C -- "否" --> E
E -- "是" --> F["dummy_train_step<br>只消费数据不训练"]
F --> A
E -- "否" --> G["train_step<br>前向 + 反向 + optimizer.step"]
G --> H{"首个迭代且成功?"}
H -- "是" --> I["启用 forward pre-hook<br>打开通信重叠"]
H -- "否" --> J["FLOPs / 样本记账 + 日志"]
I --> J
J --> K{"到 eval 间隔?"}
K -- "是" --> L["evaluate<br>先关重叠再评估"]
K -- "否" --> M["post-step 回调<br>心跳 / GC / 哈希对账"]
L --> M
M --> N{"存档或退出?"}
N -- "退出" --> O["先存档再退出"]
N -- "继续" --> A
下面挑四个分支展开。
批大小随训练进度变化
教程里 batch size 是个常量;生产里它是按进度调度出来的。Megatron 支持 batch size 爬坡(rampup):训练早期用小 batch,随训练推进逐步放大。所以每次迭代的第一件事是 update_num_microbatches(consumed_train_samples)——根据已消费的样本数算出当前应该用多少个 micro-batch。
由此带来两个连锁设计。第一,微批数一变,先存 checkpoint:源码在检测到 get_num_microbatches() != num_microbatches 时立刻保存。动机源码没写,我的推测是:恢复训练时批大小调度必须严格复现,在调度边界存档能保证断点前后的 global batch size 一致,学习率曲线不会错位。第二,源码 assert 微批数只增不减,爬坡是单向的。
同样的逻辑延伸到学习率:opt_param_scheduler.step(increment=samples_this_iteration)——学习率调度器走的是样本数轴,不是迭代数轴。batch size 会变,「第 1000 步」没有稳定含义,「第 200 万个样本」才有。
跳过一个迭代时,数据照样要消费
args.iterations_to_skip 允许跳过指定迭代(比如某段数据有问题)。但看 dummy_train_step() 的实现会发现它照常从数据迭代器取数、照常走 TP 广播、照常做 CP 切分,只是不进模型。
原因在于数据迭代器的位置是全局状态的一部分。几千个 rank 各自持有迭代器,跳过迭代如果不消费数据,恢复训练或对比实验时数据顺序就会错位一个 batch,且没有任何报错。所以「跳过」只能跳过计算,其余副作用一个都不能少。
第一个迭代用最保守的方式走
主循环对第一个迭代有特殊处理,注释写得很直白:
# Disable forward pre-hook to start training to ensure that errors in checkpoint
# loading or random initialization don't propagate to all ranks in first
# all-gather (which is a no-op if things work correctly).
展开说:开启通信重叠后,参数 all-gather 挂在 forward pre-hook 里异步进行。如果 checkpoint 加载有问题(某个 rank 的参数是坏的),异步 all-gather 会把坏参数静默扩散到所有 DP 副本,错误现场被彻底污染。所以第一个迭代同步跑、关掉重叠,确认无恙后再开钩子。
另外两处同样谨慎:fp16 训练下前若干个迭代可能因 loss scale 未稳定而溢出跳步,钩子的启用推迟到第一个成功的迭代之后;开启参数哈希对账(后述)时,训练前先做一次全量校验。三件事是同一个思路:先确认「当前状态是好的」,再开始加速。
四条退出路径,全部先存档
checkpoint_and_decide_exit() 汇聚了四种退出条件:收到 SIGTERM 信号、运行时长到限(exit_duration_in_mins)、到达指定迭代(exit_interval)、到达训练阶段切换点(phase_transition_iterations)。四条路径无一例外先存 checkpoint 再退出。
其中时长判断有个容易忽略的细节:
done_cuda = torch.tensor([train_time > args.exit_duration_in_mins], ...)
torch.distributed.all_reduce(done_cuda, op=torch.distributed.ReduceOp.MAX)
「要不要退出」要做一次 all-reduce(MAX:任何一个 rank 说到点了就全体退出)。各 rank 的时钟有偏差,如果各自判断,就会出现一部分 rank 退了、另一部分还在等集合通信的死锁。在分布式训练里,连「看表」都必须是集体行为。这种用 all-reduce 统一决策的写法在文件里反复出现,后面还会遇到两次。
train_step():一步更新的事务边界
单步的主干用伪代码写出来是这样:
# 伪代码:train_step() 主干(对应源码,省略:激活/梯度 dump、蒸馏、vision 分支)
while rerun_state_machine.should_run_forward_backward(data): # 可重跑事务
for chunk in model:
chunk.zero_grad_buffer()
optimizer.zero_grad()
losses = forward_backward_func(forward_step_func, data, model,
num_microbatches, ...) # 流水线调度器
update_ok, grad_norm, num_zeros = optimizer.step()
update_ok = logical_and_across_mp_group(update_ok) # 跨 MP 组对齐
if update_ok:
opt_param_scheduler.step(increment=samples_this_iter) # LR 按样本走
skipped = 0
else:
skipped = 1 # 本步作废
loss = per_token_average(losses, group=dp_cp) # 见下文
三个点展开。
前向反向被包在一个可重跑的事务里
注意最外层是 while rerun_state_machine.should_run_forward_backward(...)。这个循环大多数时候只跑一遍,但它的存在改变了单步的语义:一次前向反向成了一个可以被重放的事务。数据迭代器被 RerunDataIterator 包装(可以回带重放同一批数据),配合确定性计算,数值可疑时(比如 loss 出现 NaN)可以在同一批数据上重跑一遍:两次结果不同,说明是瞬态硬件错误(SDC);两次一样,才是真的软件 bug 或数据问题。
重跑机的内部实现在 megatron/core/rerun_state_machine.py,我没有展开读,以上是从接口用法和公开文档得出的理解。但接口本身已经说明了要点:在足够大的集群上,「硬件算错了」和「代码写错了」是两种需要区分的故障,区分它们靠重放。
「这步成功了吗」也要投票
optimizer.step() 返回的 update_successful 不能直接用,要先跨模型并行组做一次逻辑与:
update_successful = logical_and_across_model_parallel_group(update_successful, group=mp_group)
grad_norm = reduce_max_stat_across_model_parallel_group(grad_norm, group=mp_group)
原因藏在注释里:模型被 TP/PP 切开后,有的 rank 可能没有可训练参数(比如冻结了部分子模型),它报告的「成功」不说明任何问题;而 fp16 溢出可能只发生在某一个分片上。参数更新必须全有或全无——一部分 rank 更新了、另一部分没更新,模型就永久性地内部不一致了。这是继退出判断之后第二处用 all-reduce 统一的决策。
loss 要按 token 求全局平均
汇报 loss 时源码里有个不起眼的分支:每个 micro-batch 返回的 loss 如果是二元组 (loss_sum, token_count),就走新路径——把所有 micro-batch 的二元组相加、跨 DP 组 all-reduce、最后一除:
val = torch.vstack(val).sum(dim=0)
torch.distributed.all_reduce(val, group=dp_cp_group)
loss_reduced[key] = val[0] / val[1] # 全局 per-token 平均
而 legacy 路径是「先对每个 micro-batch 求平均、再对平均值求平均」。两者在定长 batch 下等价,但一旦序列变长(SFT、sequence packing),每个 micro-batch 的有效 token 数不同,「平均的平均」会让 token 少的 batch 里的每个 token 权重偏高。我没有找到 Megatron 官方说明这个偏差在实际训练里造成过什么问题,新路径的存在本身只说明有人在意它。修法是把分子分母分开传,最后再除。如果你在看训练曲线时遇到过换数据管线后 loss 突跳,我猜这里可能是原因之一,但没有验证过。
记账本:仪表盘上的 TFLOP/s 是怎么算的
num_floating_point_operations() 是整个文件里最数学的部分,它回答仪表盘上那个 TFLOP/s/GPU 是怎么来的。这个数字重要,因为它是 MFU(Model FLOPs Utilization,实际吞吐占硬件峰值的比例)的分子。
精确公式比 6ND 高约 8%
公式的骨架是三个系数的乘积,源码注释写得很清楚:
- ×2:一次
m×n · n×k矩阵乘是 2mnk 次浮点运算(乘加各算一次,FMA); - ×3:每个矩阵乘要做三遍——前向一遍,反向两遍(对权重的梯度 wgrad、对输入的梯度 dgrad);
- 剩下的就是逐模块数参数:QKV 投影、输出投影、MLP、logits 头。
2×3 = 6,这就是「训练成本 ≈ 6ND」(N 个参数、D 个 token)估算的出处,Kaplan 等人的 Scaling Laws 论文(arXiv:2001.08361)用的就是这个近似。Megatron 的公式可以看作 6ND 的精确版:把「N 个参数」展开成逐层逐模块的计数,并补上 6ND 忽略的注意力矩阵项。
注意力矩阵项有一个容易漏掉的系数。QKᵀ 和「softmax 结果乘 V」两次矩阵乘,每层前向各是 2s²h(s 是序列长,h 是隐藏维),合计 4s²h,乘上前反向的 3 是 12s²h。公开 main 里这一处还除了 2,注释写的是 causal mask (only half of the mask is non-zero)——因果掩码下只有下三角有效,所以按一半记,实际是 6s²h。本文素材那份源码我当时复算用的也是这个减半后的系数(文末脚本的 core)。
补多少?我用一个 LLaMA-7B 风格的稠密配置(hidden 4096、32 层、FFN 11008 + SwiGLU、词表 32000、序列长 4096、无 GQA)把源码公式复算了一遍(脚本和输出见文末):
- 公式给出每 token 约 4.29 × 10¹⁰ FLOPs;
- 6N(N ≈ 6.61B 含 embedding)给出约 3.96 × 10¹⁰;
- 比值 1.081,精确公式比 6ND 高约 8%,其中注意力的 L² 项在序列长 4096 时占总量约 7.5%。
这两个数都依赖上面的因果减半:如果不减半(比如双向注意力,或者某个框架不按掩码打折),同一配置下比值是 1.163、L² 项占 14.0%。所以拿不同框架报的 MFU 做比较时,先确认它们对注意力项的记法是否一致。在 4K 上下文的稠密模型上,6ND 低估不到一成;上下文越长,L² 项占比越大,6ND 越不准。源码在多头潜在注意力(MLA)分支的注释里还直接引用了两篇 arXiv 论文(2305.10403 与 2205.05198)作为 FLOPs 推导依据。
sequence packing 下,注意力只算了 37.5%
这个函数还要处理 THD 布局(sequence packing:把多条变长序列打包进一条定长序列,用 cu_seqlens 数组记录边界)。打包后有两笔账变了:
- token 线性项(投影、MLP、logits):应该按真实 token 数
sum(Lᵢ)记,padding 不算工作量; - 注意力 L² 项:打包后每条子序列只在自己内部做注意力(分块因果掩码),FLOPs 是
sum(Lᵢ²)而不是(总长)²。
这两个量在数学上互相独立(知道和推不出平方和),所以必须分别追踪。差距有多大?举个例子:把 [2048, 1024, 1024] 三条序列打包成一条 4096 的序列——
注意力的真实计算量只有按整条序列算的 37.5%。如果记账时不区分,MFU 会被虚报:你以为算了 16.7M 单位的注意力,实际只算了 6.3M。
实现上也很省。这两个统计量放在一个 GPU 上的 2 元素 fp64 张量里逐 micro-batch 累加(无 host 同步),每个迭代结束时只做一次 2 元素的 all-reduce + 一次 host 同步取回。这次 all-reduce 是在全部 rank 上做的,而 cu_seqlens 只在 DP 维度上不同、在 TP/CP/PP 组内是复制的:同一个 DP 副本里的 TP×CP×PP 个 rank 各自加了一份相同的值,所以总和多了 TP×CP×PP 倍,除掉这个倍数就是整个 global batch 的真实值;DP 维度上的各份本来就是不同数据,加起来正是要的结果,不用除(公开 main 的 docstring 原话:「the world all-reduce therefore overcounts by a factor of TP * CP * PP, which we divide out」)。不打包的 BSHD 路径从头到尾不碰这套机制,一个 _seqlen_stats_active 布尔门控保证它不分配张量、不发通信。
进度日志与能耗
记账本还有两页。一页是 progress.txt 进度日志:每次存 checkpoint 追加一行累计 FLOPs 和吞吐,重启后从日志里找到「同样 world size 的最早一次启动」来计算跨作业的累计吞吐。异步 checkpoint 要区分「Saving」和「Saved」两条记录,只有落盘确认的才算数,相当于一个朴素的两阶段提交。另一页是能耗:log_energy 打开后按 J/iter/GPU 和 W/GPU 记账。另外,checkpoint 保存期间计时器和能耗监控都会暂停,存档时间不算进训练吞吐,MFU 数字因此不被存档拉低。
容错本:把硬件故障当日常处理
在几千张 GPU 上跑几十天,硬件故障一定会发生,得当成日常流程来处理。文件里为此准备了一整套机制:
| 机制 | 对付什么 | 关键设计 |
|---|---|---|
| 异步 checkpoint | 存档时间挤占训练 | 每迭代非阻塞地推进落盘(maybe_finalize_async_save),退出时才阻塞收尾 |
| 本地非持久 checkpoint | 分布式文件系统太慢 | 存到本地盘,再用 CliqueReplicationStrategy 在节点间互备(这个类来自 nvidia_resiliency_ext,本文没读它的实现;从名字和 replication_jump、replication_factor 两个参数推测,是把节点按固定间隔分成小团、团内互存副本)——本节点挂了,副本还在别人那里 |
| rerun state machine | SDC(静默算错) | 同批数据重放对比,区分瞬态硬件错误与软件 bug(见上文) |
| DP 副本参数哈希对账 | 副本漂移 | 定期对所有 DP 副本的参数求哈希并交叉比对——理论上永远相同,不同就是出事了 |
| GPU sniff test | 慢性硬件退化 | 训练前和定期跑一轮 GPU 自检(实现在别的文件,本文未展开) |
| 故障注入 | 容错代码本身没被测过 | FaultInjectorConfig 在指定迭代主动制造故障——训练系统的混沌工程 |
| 掉队检测(straggler detection) | 个别慢卡拖垮全体 | StragglerDetector 用 FLOPs 记账数据找出持续偏慢的 rank |
两点评注。第一,参数哈希对账把前面「用 all-reduce 统一决策」的思路推到了参数本身:DP 副本的参数在数学上必须逐位相同,任何分歧都意味着某张卡算错了或某次通信丢了数据,冗余副本顺手就成了校验和。第二,故障注入的存在说明容错代码被当作一等公民测试——如果恢复路径只在真故障时才第一次执行,那它大概率是坏的。这一整本账配合集群网络层的容错设计看会更完整:网络层处理链路故障,这一层处理计算故障。
性能本:能藏的开销都藏起来
通信藏进计算:pre-hook 与梯度桶
数据并行的两大通信——梯度归约(reduce-scatter)和参数收集(all-gather,distributed optimizer 分片后需要)——都不该让 GPU 干等。Megatron 的做法:
- 梯度侧:所有梯度放进连续的 grad buffer,切成桶;反向传播每算完一个桶的梯度,立刻异步启动这个桶的 reduce-scatter,通信和后续层的反向计算重叠。
- 参数侧:把 all-gather 挂在 forward pre-hook 上——前向即将用到某块参数时,钩子确保它已经(或正在)被收集,理想情况下上一层计算时下一层参数已在路上。
桶的大小默认是(公开 main 同样如此,且只在开启梯度通信重叠时生效):
bucket_size = max(40000000, 1000000 * get_pg_size(dp_cp_group))
这是取两者的最大值:DP×CP 组小于 40 时桶固定 4000 万参数,从 40 往上才按每张卡 100 万线性增长。文末脚本算了四个点:8 和 40 都是 4000 万,64 是 6400 万,512 是 5.12 亿。方向不难理解——桶按组大小均分后每张卡的分片要足够大,否则集合通信退化为延迟主导;但 4000 万和 100 万这两个系数源码没有推导,我也没有实测过不同桶大小的吞吐差异。分片式数据并行的通信模式可以参考 ZeRO 论文(arXiv:1910.02054),Megatron 的 distributed optimizer 与 ZeRO-1 思路同源。
三种粒度的 CUDA Graph
文件里出现了三个独立的 CUDA Graph 开关:整迭代图(full_iteration,把一整个 train_step 的 kernel 序列录下来重放)、逐层图(transformer_engine,对每个 transformer 层单独录制)、优化器图(optimizer_cuda_graph)。它们对付同一个问题:CPU 发射 kernel 的速度跟不上 GPU 消化的速度(launch overhead)。粒度越大收益越高,约束也越苛刻:整迭代图要求迭代内的一切(包括 DDP 初始化用的 stream、FSDP 的参数收集时机)都是录制安全的,源码里好几处「因为 full_iteration 图所以必须……」的特判都源于这个约束。
跨 rank 对齐的垃圾回收
if args.manual_gc:
# Disable the default garbage collector and perform the collection manually.
# This is to align the timing of garbage collection across ranks.
gc.disable()
gc.collect()
Python 的 GC 会在不确定的时刻暂停进程(停多久取决于堆上对象的数量,我没有在训练进程里测过)。单机上无所谓;但在同步训练里,任何一个 rank 暂停,所有 rank 都在集合通信处等它。几千个 rank 各自随机 GC,等待就随机地叠加。解法是关掉自动 GC,让所有 rank 在同一个迭代号一起 GC,把随机的停顿变成同步的、可记账的停顿。
这三行是我在整份文件里最喜欢的代码:在同步 SPMD 系统里,连语言运行时的内务也得和其它 rank 对齐。
胶水本与 RL 支线
胶水本的核心是 ProcessGroupCollection——一个装着所有并行进程组(dp、tp、pp、cp、ep 及各种组合组)的容器,作为参数在整条调用链上传递。主循环从不假设自己知道全局拓扑,需要归约时问模型要它的 pg_collection。这样同一个 train() 能服务单机 8 卡,也能服务多模态的异构网格(不同子模型用不同并行度)。虚拟流水线(VPP)下连数据迭代器都是每个虚拟 stage 一份的列表。DDP 包装、分片布局计算(wrap_model_chunks_with_ddp)也归这本账,上一篇模型配置三问已详细拆过,不重复。
RL 支线是这份 2025 版源码里最显眼的新增部分(你的版本可能没有):perform_rl_step 打开后,主循环每次迭代先用当前模型生成 rollout(GRPO 流程),再用生成的数据做若干步梯度更新。两个细节透露了工程量。其一,可以构建一个并行度完全不同的独立推理模型(推理不支持 CP、偏好低 PP),每轮把训练权重「refit」过去——refit 是源码里的叫法,按上下文理解,是把训练模型刚更新的权重按推理模型的并行切法重新切分、装进推理模型,我没有读这部分的实现。其二,参考模型(reference model)的权重靠两次 load_checkpoint 拿到:先加载预训练 checkpoint 抓一份 CPU 状态字典,再把 RL checkpoint 加载回来。训练与推理两套模型在同一进程内共存、互相搬运权重——PPO 循环解剖里画过的那套多模型编排,正在被吸收进预训练框架本体。这只是我在这一个版本里看到的现象,也可能只是这个分支的特例。
这份文件学不到什么
回到开头的问题:能靠它彻底搞懂预训练吗?这份文件是控制面的全部,但以下四样东西它一行都没有:
- 前向的数学:
forward_step_func是传进来的参数。模型结构在megatron/core/models/,损失怎么算在各pretrain_*.py入口脚本里。 - 流水线调度:
forward_backward_func是从megatron/core/pipeline_parallel/取来的现成函数。1F1B、virtual pipeline 的排布逻辑全在那边,这是数据面最精彩的部分。 - 优化器数学:
optimizer.step()是黑盒。分片、主权重副本、混合精度的细节在megatron/core/optimizer/。 - 数据管线:数据集怎么构建、怎么混合、怎么打包,在
dataset_provider的另一端。
这些缺席本身就是设计:训练循环与它训练的东西彻底解耦。pretrain() 的函数签名就是证据——模型、数据、前向逻辑全是注入的依赖,同一个控制面既跑 GPT 也跑 Mamba 混合模型也跑多模态。上一篇讲的是「配置与构建分离」,这一篇的对应物是「编排与计算分离」。
拿这个读法去看 DeepSpeed、TorchTitan 或内部框架的主循环,可以带着六个问题:二十行骨架在哪;一步更新的事务边界是什么、什么算「这步成功」;进度按迭代、样本还是 token 记;每条退出路径是否都过 checkpoint;哪些开销被藏进了哪个阶段;哪些决定必须跨 rank 集体做。Megatron 的答案上文都已给出,我的预期是框架间的差异主要落在最后两问上——这是推测,我还没有拿另一个框架逐条对照过。
想检查文中的数字,或者换成你关心的模型配置(改 hidden/层数/FFN/词表/序列长)看 6ND 在你的场景里差多少,不需要 GPU,跑下面这段即可:
# 1) 源码公式 vs 6ND(LLaMA-7B 风格,无 GQA)
h, L, ffn, vocab, s = 4096, 32, 11008, 32000, 4096
lin = 3*2*(h*3*h + h*h) + 3*2*h*ffn*3 # 注意力线性项 + SwiGLU MLP,每层每 token
core = 3*2*2*h / 2 # QK^T 与 AV 两次乘法 ×FMA2 ×前反向3,再按因果掩码 /2
tot = s*(L*lin + 3*2*h*vocab) + s*s*core*L # 一条序列的总 FLOPs
N = L*(4*h*h + 3*h*ffn) + vocab*h
print(f"per-token = {tot/s:.3e}, 6N = {6*N:.3e}, N = {N/1e9:.2f}B")
print(f"formula/6ND = {tot/(6*N*s):.4f}, attn L^2 share = {s*s*core*L/tot:.1%}")
full = tot + s*s*core*L # 假如不做因果减半
print(f"[no causal /2] formula/6ND = {full/(6*N*s):.4f}, attn L^2 share = {2*s*s*core*L/full:.1%}")
# 2) packing:sum(L_i^2) / s^2
Ls = [2048, 1024, 1024]
print(f"packing: {sum(x*x for x in Ls)} / {sum(Ls)**2} = {sum(x*x for x in Ls)/sum(Ls)**2:.1%}")
# 3) 默认桶大小 max(4e7, 1e6 * dp_cp)
for dp in [8, 40, 64, 512]:
print(f"bucket(dp_cp={dp}) = {max(40_000_000, 1_000_000*dp)/1e6:.0f}M params")
# 4) 启动慢 10 分钟、1 万卡
print(f"10 min x 10000 GPUs = {10/60*10000:.0f} GPU-hours")
python3 运行的输出(2026-11-04):
per-token = 4.286e+10, 6N = 3.964e+10, N = 6.61B
formula/6ND = 1.0813, attn L^2 share = 7.5%
[no causal /2] formula/6ND = 1.1625, attn L^2 share = 14.0%
packing: 6291456 / 16777216 = 37.5%
bucket(dp_cp=8) = 40M params
bucket(dp_cp=40) = 40M params
bucket(dp_cp=64) = 64M params
bucket(dp_cp=512) = 512M params
10 min x 10000 GPUs = 1667 GPU-hours
参考来源
工程实践
- Megatron-LM 源码仓库:https://github.com/NVIDIA/Megatron-LM (本文对应
megatron/training/training.py;2026-11-04 对照的公开版本为 main 分支 commit993bf83) - 本站前篇:《模型配置到底在配置什么:从 Megatron 源码读懂 Config、Spec、Builder 三层》
arXiv 论文(编号均已核实)
- Shoeybi et al., Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism — arXiv:1909.08053
- Narayanan et al., Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM — arXiv:2104.04473(PTD-P 并行组合与吞吐分析)
- Kaplan et al., Scaling Laws for Neural Language Models — arXiv:2001.08361(6ND 成本近似的出处)
- Korthikanti et al., Reducing Activation Recomputation in Large Transformer Models — arXiv:2205.05198(源码 FLOPs 注释引用)
- Rajbhandari et al., ZeRO: Memory Optimizations Toward Training Trillion Parameter Models — arXiv:1910.02054(distributed optimizer 的思想源头)