6.3 一次预训练长什么样:训练循环逐步走查

本页范围:第 6 章第 3 节 | 整理时间:2026-09-29

快速浏览

核心问题论文里的「预训练」只有一句话:在海量文本上做下一个 token 预测。落到代码里,一个 batch 从进来到参数更新,到底经过哪几步?
本节主张预训练循环是一条七步流水线:取 batch、forward、算交叉熵损失、backward、梯度裁剪、优化器 step、周期性记录与存盘。「预测下一个 token」在代码里的形态,就是 labels 右移一位再算交叉熵。
一句话结论把 minimind 的 train_pretrain.py 逐行拆开看,宏观叙事里的「预训练」就是一段几十行、可复现的循环:64M 小模型单卡一个多小时跑完一轮,GPT-3 量级则要数千卡月。
关键词
训练循环labels 右移交叉熵梯度裁剪混合精度梯度累积checkpoint

  前两节分别解决了「练什么」与「怎么调」:训练目标是下一个 token 预测,参数更新靠 AdamW 与学习率调度。本节把这两块拼起来,回答一个更具体的问题——一次真实的预训练,从启动脚本到存出权重,中间每一行代码在干什么。我们不用玩具代码,直接用本工程自带的 minimind 工程(64M 小模型,Apache 2.0 协议)做走查对象,它的 train_pretrain.py 与工业界大模型的训练脚本同构,只是训练算力小了约六个数量级。

  本节沿四条线展开,读完后你应该能打开任何一个 LLM 训练脚本,一眼认出它的骨架:

  1. 训练循环七步:从取数据到存盘(6.3.1):把 train_epoch 函数逐行对照,认清七步流水线各自的代码位置;
  2. labels 右移:「预测下一个 token」的代码形态(6.3.2):右移发生在哪一行、为什么要右移、padding 位置怎么剔除;
  3. loss 曲线怎么读(6.3.3):开局陡降、长尾缓降、loss spike 各说明什么,验证 loss 背离意味着什么;
  4. 混合精度与梯度累积:脚本里的两道保险(6.3.4):autocast、GradScaler、accumulation 的用法点到为止;
  5. 从玩具到巨兽:规模账本(6.3.5):同一套循环,minimind 与 GPT-3 的算力账单差几个数量级。

  本节涉及的代码都在 minimind 工程的 trainer/train_pretrain.py 里,读完后建议对照源码把七步循环走一遍。

  图 1 标出预训练在 LLM 生命周期中的位置,图 2 展示训练目标与优化器如何落实到代码。

原创示意图 · 非论文原图 训练数据: 收集 · 清洗 · 配比 (第 1 章) 预训练: 海量语料自监督 (本节内容) 训练工程: 并行 · 精度 · 稳定 (第 7 章) 中间训练: 收口 · 长上下文 (第 8 章) SFT: 学会对话格式 (第 9 章) 偏好对齐: RLHF / DPO (第 10 章) 推理训练: RLVR / GRPO (第 11 章) 推理与部署: 解码 · 加速 (第 12–13 章) 实线框:已讲章节 虚线框:后续章节
图 1:预训练在 LLM 生命周期中的位置。训练数据(第 1 章)备好后进入预训练(本章,紫框):在海量语料上做自监督学习,把文本规律压进参数;配套的并行、精度与稳定性工程在第 7 章,之后的中间训练(第 8 章)、SFT(第 9 章)、偏好对齐(第 10 章)、推理训练(第 11 章)、推理与部署(第 12–13 章)在对应章节展开。目标与优化器定了之后,预训练落到代码里就是一段几十行的训练循环,七步一个来回。

  图 1 里这个紫框放大之后长什么样?一个 batch 从进来到参数更新,中间要走哪几步?把训练循环单独拆开看:

原创示意图 · 非论文原图 局部放大:训练循环——一个 batch 的七步环形之旅 对应 minimind train_pretrain.py 第 26–47 行;每步先用 get_lr 重算学习率(cosine,5×10⁻⁴ 降到 10%) 梯度累积:攒满 8 个小 batch 才执行一次 ⑤⑥ 更新 有效批量 32 × 8 = 256 条 ① 取 batch input_ids:32 × 340 ② forward 前向 logits 32×340×6400 ③ 算损失 交叉熵 → 标量 loss ④ backward 梯度反传回全部参数 ⑤ 梯度裁剪 全局范数裁到 1.0 ⑥ 优化器 step AdamW 更新 → zero_grad ⑦ 日志与 checkpoint 每 100 步日志 / 1000 步存盘 一圈又一圈直到数据跑完;⑦ 的 checkpoint 是训练中断后唯一能接着跑的存档点
图 2:一个 batch 在训练循环里的七步环形路径。输入一批 32 × 340 的 token ID,前向得到 32 × 340 × 6400 的 logits,与右移一位的 labels 算交叉熵得到标量 loss,反向传播后裁剪梯度范数到 1.0,再由 AdamW 更新参数并清零梯度;日志与 checkpoint 周期性执行。梯度累积让 ⑤⑥ 每攒满 8 个小 batch 才做一次,有效批量 256 条。

6.3.1 训练循环七步:从取数据到存盘

  先给一个整体直觉。训练循环很像学生刷题:每轮拿一批题(取 batch),自己先做一遍(forward),对照答案算错得有多离谱(算损失),复盘错因、总结到笔记本上(backward 与优化器 step),每刷完一批就歇口气,记一笔进度、阶段性存档(日志与 checkpoint)。区别是学生靠脑子记,模型靠梯度更新参数。minimind 的 trainer/train_pretrain.py 里,train_epoch 函数(第 24 行起)就是这条流水线,核心循环只有二十来行:

for step, (input_ids, labels) in enumerate(loader, start=start_step + 1):
    input_ids = input_ids.to(args.device)
    labels = labels.to(args.device)
    lr = get_lr(epoch * iters + step, args.epochs * iters, args.learning_rate)
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr

    with autocast_ctx:
        res = model(input_ids, labels=labels)
        loss = res.loss + res.aux_loss
        loss = loss / args.accumulation_steps

    scaler.scale(loss).backward()

    if step % args.accumulation_steps == 0 or step == iters:
        scaler.unscale_(optimizer)
        torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)

        scaler.step(optimizer)
        scaler.update()

        optimizer.zero_grad(set_to_none=True)

  (节选自 trainer/train_pretrain.py 第 26–47 行,出处:minimind 工程,Apache 2.0 协议;行号以本工程实读版本为准,下同。)把这段代码拆开,正好是七步:

步骤干什么minimind 对应位置
① 取 batchDataLoader 吐出一批 input_ids 与 labels,搬到 GPU。数据由 PretrainDataset 逐条提供(见 6.3.2)train_pretrain.py 第 26–28 行;数据集定义在 dataset/lm_dataset.py 第 40–58 行
② forward 得 logits模型前向跑一遍,得到每个位置对词表的打分(logits)第 34 行 model(input_ids, labels=labels);logits 的计算在 model/model_minimind.py 第 253 行
③ 算交叉熵损失logits 与右移一位的 labels 算交叉熵,得到这一步的 lossmodel_minimind.py 第 256–257 行(细节见 6.3.2);第 35 行把 MoE 辅助损失加进来
④ backward 反传对 loss 求梯度,一路反传回每个参数第 38 行 scaler.scale(loss).backward()
⑤ 梯度裁剪梯度总范数超过阈值就整体缩放,防止个别 batch 把参数带飞第 41–42 行,阈值 grad_clip 默认 1.0
⑥ 优化器 stepAdamW 按梯度更新参数,随后清零梯度,准备下一轮第 44–47 行;AdamW 定义在第 130 行,初始学习率默认 5e-4
⑦ 周期性记录与存盘每隔一段打印日志、保存 checkpoint,支持断点续训日志:第 49–57 行,间隔 log_interval=100 步;存盘:第 59–69 行,间隔 save_interval=1000 步

  几个容易看漏的细节。第 29–31 行每步都重算学习率:get_lr(trainer/trainer_utils.py 第 42–43 行)给出一条余弦曲线,让学习率从峰值平滑滑落到峰值的十分之一:

\[ \mathrm{lr}_t = \mathrm{lr}_{\max}\left[\,0.1 + 0.45\left(1 + \cos\frac{\pi t}{T}\right)\right] \tag{1} \]
公式 (1):余弦学习率调度——开局用满峰值学习率大胆走,训练后期步长越来越小,细调收敛。符号说明:\(\mathrm{lr}_t\) 是第 \(t\) 步实际使用的学习率;\(\mathrm{lr}_{\max}\) 是初始学习率(脚本默认 5e-4);\(t\) 是全局步数(跨 epoch 累计,代码里就是 epoch * iters + step);\(T\) 是计划的总步数。\(t=0\) 时括号内为 1,\(t=T\) 时 \(\cos\pi=-1\)、括号内为 0.1,正好从峰值降到十分之一。这个脚本没有单独的 warmup 预热段。

  第 59–69 行的存盘动作也值得一看:每隔 1000 步把权重转成半精度(v.half())存成 out/pretrain_768.pth,同时往 checkpoints/ 目录写一份含优化器状态的完整检查点,训练中断后加 --from_resume 1 就能接着跑。一次预训练短则数小时、长则数月,checkpoint 是唯一的「存档点」,没有它,一次断电就意味着从头再来。

  注意这段循环里没有「验证集」。预训练的数据量远大于模型能记住的规模,通常只训一两遍,过拟合不是主要矛盾,所以 minimind(和多数预训练脚本)不划分验证集,只用训练 loss 加周期性 checkpoint,效果交给训练后的下游评测确认。验证集的事在 6.3.3 还会回来讲。

  这七步是几乎所有 LLM 预训练脚本的共同骨架:换成 Megatron-LM 或工业界的内部代码,多的只是分布式、流水并行与容错机制,循环本身一模一样。读懂这二十行,就拿到了读一切训练脚本的钥匙。

6.3.2 labels 右移:「预测下一个 token」的代码形态

  上一节说了训练目标是「预测下一个 token」:看到 [x1, x2, …, xT],位置 \(t\) 要预测 \(x_{t+1}\)。这句话在代码里长什么样?答案分两半,一半在数据集,一半在模型。

  先看数据集。PretrainDataset.__getitem__(dataset/lm_dataset.py 第 50–58 行)把一条文本变成一对张量:

tokens = self.tokenizer(str(sample['text']), add_special_tokens=False, max_length=self.max_length - 2, truncation=True).input_ids
tokens = [self.tokenizer.bos_token_id] + tokens + [self.tokenizer.eos_token_id]
input_ids = tokens + [self.tokenizer.pad_token_id] * (self.max_length - len(tokens))
input_ids = torch.tensor(input_ids, dtype=torch.long)
labels = input_ids.clone()
labels[input_ids == self.tokenizer.pad_token_id] = -100

  (节选自 dataset/lm_dataset.py 第 52–57 行,Apache 2.0。)流程是:分词、首尾加上 BOS 与 EOS、用 PAD 补齐到固定长度。注意第 6 行:labels 就是 input_ids 的原样克隆,这里并没有右移。唯一的加工是最后一句:把 padding 位置的 label 改成 -100。

  右移发生在模型内部。MiniMindForCausalLM.forward(model/model_minimind.py)算完 logits 后,用两行代码完成对齐:

x, y = logits[..., :-1, :].contiguous(), labels[..., 1:].contiguous()
loss = F.cross_entropy(x.view(-1, x.size(-1)), y.view(-1), ignore_index=-100)

  (model_minimind.py 第 256–257 行,Apache 2.0。)logits[..., :-1, :] 切掉最后一个位置的预测,labels[..., 1:] 切掉第一个 token 的编号——两刀下去,位置 \(t\) 的预测正好对上位置 \(t+1\) 的真实 token。这就是「右移一位」:输入是 \([x_1, \dots, x_T]\),标签实际上是 \([x_2, \dots, x_{T+1}]\)。

  用一句小例子落到纸面。假设「我爱北京」分词后是四个 token,加上首尾标记,一个样本的输入与每个位置的预测目标是这样错开一格的(token ID 为示意):

位置012345
输入 input_idsBOS我爱北京EOS
该位置的预测目标我爱北京EOS—(被切掉,不参与)

  位置 0 只看到 BOS,要学会吐出「我」;位置 3 看到「BOS 我 爱 北」,要吐出「京」。一个 batch 里每个位置都是一道「接龙题」,一次 forward 就出了 \(T\) 道题,这就是语言模型训练数据利用率高的原因:一段文本不只提供一个监督信号,而是每个位置一个。

  这些题目的「判分标准」就是交叉熵损失:

\[ \mathcal{L} = -\frac{1}{T}\sum_{t=1}^{T} \log P_\theta\!\left(x_{t+1} \mid x_{\le t}\right) \tag{2} \]
公式 (2):下一个 token 预测的交叉熵——模型给正确下一个 token 的概率越高,\(\log\) 越接近 0,损失越小;整个序列取平均。符号说明:\(x_t\) 是序列第 \(t\) 个 token;\(x_{\le t}\) 表示位置 \(t\) 及其之前的全部 token(即模型能看到的历史);\(P_\theta(x_{t+1} \mid x_{\le t})\) 是参数为 \(\theta\) 的模型在该历史下给正确 token 分配的概率,由 logits 过 softmax 得到;\(T\) 是参与计算的位置数。代码里的 ignore_index=-100 会把 padding 位置从求和与平均中剔除,让它们不算题、不计分。

  易错点:两个易错点都藏在这两行代码里。其一,不要二次右移:minimind 的 labels 在数据集里不右移,右移由模型里的切片完成;如果有人在数据侧先把 labels 平移一格,模型再切一刀,预测和目标就错开两位,loss 会停在一个降不下去的高位。其二,padding 位必须置 -100:否则模型会被迫学习「句子结束后继续输出 PAD」,白白浪费容量。

  一句话总结这一节:所谓「预测下一个 token」,代码里就是 labels 克隆输入、模型里错开一格、交叉熵打分,外加用 -100 把 padding 踢出考场。

6.3.3 loss 曲线怎么读

  训练启动后,loss 是持续变化的主要指标。通过它可以观察优化是否正常,常见读法如下。

  先看起点。随机初始化的模型对词表里的 token 近乎均匀猜测,开局 loss 约等于 \(\ln V\):minimind 词表 \(V=6400\),所以第一步的 loss 通常在 \(\ln 6400 \approx 8.76\) 附近。如果开局远低于这个数,说明初始化或数据处理有问题;如果降不下去,先查 labels 对齐(6.3.2 的两个易错点)。

原创示意图 · 非论文原图 loss 训练步数 step 随机基线 ln(6400) ≈ 8.76(均匀猜测) 开局陡降 先学词频与语法 长尾缓降 知识与推理模式慢慢磨合 loss spike 突刺:回滚到上个 checkpoint
图 3:预训练 loss 曲线的典型形态——从随机基线起步,开局陡降后进入长尾缓降,中途可能出现突刺(loss spike)。曲线形状为示意,非实测数据。

  曲线的主体分两段,各讲一个故事:

  • 开局陡降:最初几百到几千步,loss 断崖式下跌。这一阶段模型在学「便宜」的统计规律:哪些 token 常见(词频分布)、标点怎么用、词序大致什么样。这些规律到处都是、信号极强,所以学得飞快。
  • 长尾缓降:陡降之后进入漫长的缓降期,曲线几乎贴着地面平移。这一段学的是知识、事实关联与推理模式——它们稀疏、难学,每降 0.1 都要喂进去海量 token。本章 Scaling Law 一节会告诉你,这段长尾的下降是幂律的:想再压低一点,算力就得翻着倍地加。

  再看异常。曲线上偶尔冒出的突刺叫 loss spike:loss 突然蹿升几倍再回落。常见诱因是学习率过高、遇上一批脏数据、或底层硬件抖动。偶尔一次 spike 不必惊慌,模型通常自己能爬回来;频繁 spike 或 spike 后 loss 站上新台阶,标准处置是回滚到最近一个健康的 checkpoint、调低学习率、跳过可疑数据再续训。Meta 训练 OPT-175B 时的公开日志记录了数十次这类中断与回滚,是这套做法最透明的第一手记录(见参考来源)。

  最后是训练 loss 与验证 loss 的关系。验证 loss 是在模型没见过的数据上算的同一个交叉熵:训练 loss 降、验证 loss 也降,说明学到的是通用规律;训练 loss 降而验证 loss 掉头向上,就是过拟合的经典信号——模型开始背诵训练集而不是学规律。不过在预训练阶段这种情况较少出现:数据只过一两遍,模型还没来得及背。它更常出现在数据要反复过多遍的微调阶段(第 9 章会再用到这条判据)。

  注意:读 loss 曲线时警惕「只看训练 loss」。训练 loss 单调下降只能证明模型在拟合训练数据,证明不了泛化。minimind 这类预训练脚本不内置验证集,补救手段是训完用评测脚本(如 eval_llm.py)和下游基准兜底;工业界大训练则会全程挂一条留出集的验证 loss。

  补一个换算关系:论文里常见的困惑度(perplexity,ppl)就是 \(\mathrm{ppl} = e^{\mathcal{L}}\),把 loss 换回「平均在每个位置上面临多少个等概率候选」的直觉尺度。loss 从 8.76 降到 3,相当于候选从 6400 个收窄到约 20 个。

6.3.4 混合精度与梯度累积:脚本里的两道保险

  七步循环里有几行代码不属于主线逻辑,却是每个现代训练脚本的标配:混合精度与梯度累积。这里只讲清「它们在循环里干什么」,深入原理留给第 7 章预训练工程。

混合精度 Mixed Precision mixed precision = 前向计算用 16 位浮点,敏感部分保留 32 位

脚本第 114 行建了 autocast_ctx(默认 bfloat16),第 33 行的 with autocast_ctx: 让前向的矩阵乘自动落到 16 位执行:显存占用近腰斩,吞吐显著提升,而参数与梯度的主副本仍是 32 位,精度不受致命影响。

就像草稿纸上用速记符号、正式答卷上用工整楷体:计算过程求快,落账求稳。
梯度累积 Gradient Accumulation accumulation = 攒若干个小 batch 的梯度,再一次性更新

第 36 行把 loss 除以 accumulation_steps(默认 8),第 40 行的判断让梯度裁剪与优化器 step 每 8 步才执行一次:连续 8 个小 batch 的梯度先累加,再当成一个大 batch 更新。显存只装得下 batch=32,有效批量却是 \(32 \times 8 = 256\),大 batch 的稳定性与小 batch 的显存开销兼得。

就像零钱攒够一波再存银行:跑八趟柜台只办一次手续,账上的总数和一次性存一样。

  第 129 行有个反直觉的细节:GradScaler(enabled=(args.dtype == 'float16'))——只有选 float16 时才启用梯度缩放(防止 16 位下梯度下溢成 0),默认的 bfloat16 动态范围接近 32 位,不需要 scaler,此时 scaler.scale(...) 与 scaler.step(...) 是原样透传的安全壳。

  一句话总结:混合精度省显存、提速度,梯度累积用小显存伪造大 batch,两者合起来让 64M 模型能塞进一张消费级显卡。第 7 章会把它们和分布式并行放在一起细讲。

6.3.5 从玩具到巨兽:规模账本

  同一套七步循环,喂不同的规模,账单完全不同。先给一把估算尺子:训练一个 Transformer 的总算力约等于参数量乘训练 token 数再乘 6:

\[ C \approx 6\,N\,D \tag{3} \]
公式 (3):训练算力的经验估算(Kaplan et al., 2020)——每个 token 前向约花 \(2N\) 次运算,反向再花约 \(4N\),合计 \(6N\)。符号说明:\(C\) 是训练总浮点运算量(FLOPs);\(N\) 是模型参数量;\(D\) 是训练 token 总数;系数 6 来自前向与反向传播的运算量比值。拿 GPT-3 验证:\(N = 1.746 \times 10^{11}\)、\(D = 3 \times 10^{11}\),得 \(C \approx 3.14 \times 10^{23}\),与论文附录给出的数字分毫不差。

  用这把尺子量一量一大一小两个极端:

账本项minimind-3(64M)GPT-3(175B)
参数量64M(6400×768 的 Embedding 加 8 层 Transformer)1746 亿
训练数据pretrain_t2t_mini.jsonl,约 1.2GB 文本约 3000 亿 token
训练算力未公开换算;量级在 \(10^{17}\) FLOPs 上下(待查证)\(3.14 \times 10^{23}\) FLOPs,即 3640 PF-days(论文附录 D)
硬件与时间单卡 RTX 3090 约 1.2 小时跑完一轮预训练(README 实测估算)按 2020 年 V100 云实例折算约 355 个卡年,即四千多卡月(Lambda 测算)
一次成本约 1.6 元租卡费(按 1.3 元/时)约 460 万美元(Lambda 按 2020 年云价估算)

  3640 PF-days 这个单位值得展开:1 PF-day 指「以每秒千万亿次浮点运算的速度跑满一天」所做的功,GPT-3 一次训练要做 3640 份这样的功。V100 的实际有效吞吐远低于理论峰值,折算下来就是单卡跑约 355 年;换成一千张卡的集群,也要连续跑约四个月——这还没算 loss spike 回滚、硬件故障重训的损耗。

  两边对照着看,结论很直白:训练循环的代码不变,变的是每一项的规模,以及规模带来的工程难题。64M 模型一张消费卡、一杯咖啡的时间就能从随机权重跑到会说简单的话;175B 模型需要千卡集群、数月时间与数百万美元,还得养一支团队专门对付 spike、断训与硬件故障。两者的成本差异可由公式 (3) 的规模乘法估算,大规模训练还需要第 7 章介绍的分布式工程。

  亲手跑一次 minimind 预训练的价值正在于此:同样的七步循环、同样的余弦学习率、同样的 checkpoint 机制,花一块六毛钱就能把 GPT-3 级别的训练流程完整体验一遍,把纸面知识变成手感。

🧭本节要点回顾
minimind 的 labels 为什么不在数据集里预先右移?
数据集只做克隆并把 padding 置 -100(lm_dataset.py 第 56–57 行);错位发生在模型 forward 里:logits[..., :-1, :] 对 labels[..., 1:](model_minimind.py 第 256 行)。两边各切一刀,位置 \(t\) 的预测正好对上 \(t+1\) 的真实 token。
预训练 loss 曲线的三个阶段各说明什么?
开局从 \(\ln V\)(minimind 约 8.76)陡降,是在学词频与语法;长尾缓降是在磨知识与推理,每降一点都要成倍算力;中途突刺(loss spike)多由脏数据、学习率或硬件抖动引起,标准处置是回滚到健康 checkpoint 再续训。
梯度累积为什么能用小显存跑出大 batch 的效果?
把一个大 batch 拆成 8 次小 forward/backward,loss 先除以 8 再反传,梯度在参数上原地累加,攒满 8 步才裁剪、step、清零。显存只占 batch=32 的份,有效批量却是 256。

参考来源

  • minimind 工程(gongjy/minimind,Apache 2.0 协议):trainer/train_pretrain.py、dataset/lm_dataset.py、model/model_minimind.py、trainer/trainer_utils.py 及 README 的「训练开销」实测表(64M 模型单卡 3090 约 1.21 小时、约 1.57 元)。本页所有行号以本工程实读版本为准。
  • Brown et al., 2020. Language Models are Few-Shot Learners(GPT-3 原始论文,arXiv:2005.14165):附录 D 给出 175B 模型训练算力 3.14×10^23 FLOPs(3640 PF-days),正文表 2.1 给出 3000 亿训练 token。
  • Kaplan et al., 2020. Scaling Laws for Neural Language Models(arXiv:2001.08361):训练算力估算规则 C ≈ 6ND 的出处。
  • Zhang et al., 2022. OPT: Open Pre-trained Transformer Language Models(arXiv:2205.01068):175B 训练日志中大量 loss spike、硬件中断与 checkpoint 回滚的公开记录。
  • Lambda Labs(Chuan Li), 2020. Demystifying GPT-3(https://lambdalabs.com/blog/demystifying-gpt-3/):GPT-3 训练折合 355 个 V100 卡年、约 460 万美元的业界常用换算。
  • 待核实事项:6.3.5 表格中 minimind 预训练总算力(约 10^17 FLOPs 量级)为按数据体积的粗略估计,未找到公开换算,已标注待查证。