w wyl123ly 的博客
MD

继续预训练与领域适配

41 KB 2026.10.18 原文件

继续预训练与领域适配

定义

继续预训练(continued pretraining,CPT),亦称领域自适应预训练(domain-adaptive pretraining,DAPT),指在已收敛的预训练模型 上,用目标领域的无标注文本、以与预训练完全相同的自回归语言建模目标继续训练若干 token,使模型在该领域文本上的平均负对数似然下降。

逐项说明符号与术语。

符号含义
预训练结束时的参数,作为 CPT 的初始化点与回滚基准
训练中的参数, 表示第 步
模型在位置 给出的下一 token 分布,经 softmax 归一化
从混合语料中抽出的长度为 的 token 序列(实现上切分为多个长度 的窗口)
token 预算,本次 CPT 训练消耗的 token 总数,等于 步数 每步 token 数
单条训练序列的窗口长度,Llama 2 的 7B 模型为 4096
领域无标注语料,如行业标准、内部技术文档、领域论坛
通用无标注语料,用于回放,抑制分布漂移
领域占比,,按 token 计
模型参数量,本篇取 7B

其余术语。单遍(epoch)指一条语料被完整读过一次;回放(replay)指在领域批次中按比例掺入通用语料;灾难遗忘(catastrophic forgetting)指模型在目标分布上损失下降的同时,在其他分布上的能力显著退化;困惑度(perplexity,PPL)定义为平均交叉熵的指数 ;子词碎片率(fertility)指分词后 token 数与原始词数之比,衡量分词器对某语言的适配程度;语料污染(contamination)指训练语料与评测集存在重叠文本,使评测分数虚高。

为什么重要

预训练语料的分布与部署分布的差异是结构性的。通用网页语料中,某个行业的专有名词出现频次低,分词器倾向把它切成多个常见子词,模型对这些子词组合的联合概率也很低。结果是:模型并非不知道该概念对应的知识,而是在该领域的续写分布上给出了高熵的预测,表现为术语替换、术语拼写漂移、把领域内约定俗成的缩写展开成错误的全称。

这条因果链决定了 CPT 的位置。SFT 只在回复 token 上产生梯度(见 指令微调SFT 的损失掩码),它教的是「在给定指令下如何组织回复」,不是「某个术语在该领域的用法」。当领域术语的下一 token 分布本身偏离时,SFT 只能用大量样本强行覆盖,样本效率低,且容易把术语记成模板。CPT 先用无标注语料把分布移过去,SFT 再只需要教行为,两类数据的效率都提高。

没有 CPT 会怎样。第一种情形是新语言:分词器对目标语言的分词不经济,同一段文本消耗的 token 数是通用语言的 1.5 至 3 倍,既抬高推理成本,又压缩有效上下文。第二种情形是术语密集的垂直领域:模型在领域文本上的困惑度显著高于通用文本,下游任务的表现随术语密度下降。第三种情形是代码库与内部 API 文档:标识符与调用约定在通用语料中几乎不出现。

在本库的路径中,本篇承接 预训练-微调-对齐pipeline 的三阶段划分,处在「预训练之后、SFT 之前」的位置:它复用 数据集质量控制 的去重与污染检测方法,复用 Tokenizer与BPE 的分词知识判断是否需要扩词表,在显存受限时用 LoRA与QLoRA 降低训练开销,并把结果交给 指令微调SFT 继续训练。它要回答的问题是:在只有无标注语料、且不能重新预训练的条件下,如何用最小的参数位移换取领域分布的改善,同时把通用能力的退化控制在可度量、可回滚的范围内。

原理与推导

1 与 SFT 的目标差异

设一条 CPT 样本是长度 的连续文本 ,一条 SFT 样本是指令 与回复 的拼接。两个目标函数的梯度期望分别为

其中 是损失掩码。两式的差别有两处,且都影响优化行为。

第一处是求和范围。CPT 的每个位置都贡献梯度,一条 4096 token 的样本产生 4096 个监督信号;SFT 只保留回复段,一条样本通常只有 100 至 600 个有效位置。等量 token 下,CPT 的梯度估计方差更小。

第二处是被估计的分布。CPT 估计的是边缘分布 ,SFT 估计的是条件分布 。二者共享同一组参数,因此在参数空间中是两个不同的位移方向;把领域术语的先验抬高,与把「回答要给出引用」这一行为写入条件分布,是两件事。

维度继续预训练(CPT)监督微调(SFT)
数据形态无标注连续文本指令—回复对
损失位置全部 token仅回复 token
估计对象边缘分布 条件分布
数据轮数1 至 3 遍,单源上限 32 至 3 epoch
峰值学习率(全参 7B) 至 至
主要风险灾难遗忘格式过拟合、对少量样本过拟合
必须同时报告的评价领域困惑度与通用能力同时报告留出集损失与格式合法率

表中学习率区间接近,容易被误读为「两者可以互换」。差别在步数与数据量:CPT 的 token 预算是 SFT 的十到百倍,因此即便单步学习率相近,累计参数位移也大得多(见第 5 节的上界估计),这正是 CPT 必须配置回放与通用能力监控的原因。CPT 的保守性因此不体现在学习率的数值上,而体现在调度与停止条件上:单源轮数设上限、早停按通用困惑度判定、不追求把领域损失压到最低点。

2 何时需要 CPT

四条判据,任意两条成立时应做 CPT;只有一条成立时,优先扩充 SFT 数据。

  1. 新语言或新文字系统。先测子词碎片率。取目标语言 1 万句,统计 token 数与词数之比;若比值超过同规模通用中文语料的 1.3 倍,说明分词器对该语言不经济。此时 CPT 只能缓解、不能修复:必须扩词表并重新初始化新增 embedding 行,再做 CPT(见 Tokenizer与BPE)。
  2. 领域术语密集。抽样 200 条领域文本,统计被切成 3 个以上子词的术语比例。若超过 20%,术语的联合概率过低,SFT 需要大量重复样本才能覆盖。
  3. 分布差异大。用 5-gram 集合比较领域语料与通用语料的 Jaccard 相似度,低于 0.2 说明重叠小,通用能力无法自动迁移。
  4. 有大量无标注语料。可用 token 数(含允许的重复轮数)应达到 以上;对 7B 模型即 0.7B。低于该阈值时,CPT 的有效更新太少,收益小于同等人力投入下扩充 SFT 数据。

一条反例同样重要。若错误分析显示失败样本以「格式不对、答非所问、不拒答、引用缺失」为主,术语本身拼写正确、概念正确,那么问题在 SFT 数据与提示模板,CPT 不会改善。判断方法是按错误类型分桶,统计「术语或概念错误」占比;低于 15% 时不做 CPT。

3 数据:采集、清洗、去重、混合比例与 token 预算

采集阶段先建立来源登记表,每条记录包含来源标识、许可类型、抓取时间、文档数与字符数。没有许可结论的语料不得进入训练集,这一条在交付审计时会被要求出示。

清洗按顺序执行,顺序影响保留率。先做模板去除(导航栏、页脚、重复的表单文本),再做语言识别与编码修复,再做长度过滤(去掉低于 200 字符与高于 20 万字符的文档),再做质量过滤(符号占比、重复行占比、停用词占比),最后用一个小的参考模型计算困惑度分桶,去掉最高与最低各 5%。本篇的保留率取值为 0.60 至 0.80,与公开网页语料的经验区间一致。

去重分两级。精确去重对规范化后的文本取 SHA-256,命中即删;近似去重使用 MinHash-LSH,以 5-gram shingle 构造签名,Jaccard 阈值 0.8,20 个 band、每 band 5 行。网页类语料的去重率通常在 30% 至 60%,未去重时模型会记住重复段落,领域困惑度虚低而下游任务不改善。

污染检测与 数据集质量控制 的方法相同:把领域评测集的每条样本切成 13-gram,与训练语料求交集,命中即从训练集删除整篇文档。领域评测集往往只有几百条,一篇被污染的标准文档就足以让领域困惑度下降一个明显的量,而这一下降不来自模型能力。

混合比例 与 token 预算 不是两个独立参数,它们受语料容量约束。设第 个来源的可用 token 为 、允许的最大轮数为 ,则领域与通用的容量分别为

可行预算的上界为

该式说明一个常被忽略的事实:领域语料不足时,提高 不能提高预算,只会让预算被领域容量卡住。反解可得语料结构允许的最小领域占比

它是总量约束下的最优占比,因为在该点两侧的容量同时被用满。

与 Chinchilla 的对照给出量级感。Chinchilla 的结论是计算最优训练量约为每参数 20 个 token(见参考来源),对 即 。本篇的 4.07B 预算只有该值的 2.9%,10B 也只有 7.1%。这个比值解释了为什么 CPT 只能做局部修正:它消耗的算力比完整预训练小两个数量级,不足以改变模型的表示能力,只能移动已有分布。

4 训练目标仍是 next-token prediction

CPT 不更换目标函数,原因有三条,都是机制层面的。

第一,目标一致才能复用已收敛的权重几何。预训练结束时参数位于一个局部极小附近,其邻域的曲率由该目标的损失曲面决定。换用掩码语言建模(masked language modeling)会引入双向注意力,与解码器的因果掩码冲突;换用对比目标需要构造正负对,与生成式下游不一致。

第二,掩码全为 1。SFT 的掩码来自对话模板的回复段,CPT 没有回复段,所有位置都参与损失。这一点在代码实现上意味着 labels = input_ids,且打包时不需要区分样本边界之外的掩码逻辑(仍需要块对角注意力防止跨样本可见)。

第三,困惑度是平均交叉熵的指数,与损失一一对应。若领域留出集上的平均交叉熵从 2.518 降到 2.092 nats,则

降幅为 0.426 nats,合 0.614 bit。报告时应给出 nats/token,因为困惑度不可跨分词器比较:同一段文本在不同词表下被切成不同数量的 token, 的分母随之改变。固定分词器版本是 CPT 报告有效性的前提。

5 学习率、训练步数、warmup 与批大小

学习率必须比预训练小一个数量级,理由可以用一阶近似给出。Adam 的单步元素级更新量为 ,其中 、 是一阶矩与二阶矩的估计;在梯度方向稳定的维度上该比值接近 ,在噪声维度上更小,因此 的绝对值以 为上界。于是 步的累计位移范数上界约为

预训练的取值约 、,上界 300;本篇 CPT 为 、,上界 0.0776。该上界在方向完全一致时才能取到,实际位移远小于它,但两者的比值(约 )说明了量级:CPT 的位移预算只够移动分布,不够学习新能力。若把学习率设成预训练量级,同样的步数会产生约 1164 的位移上界,等价于在已收敛点上做随机重启。

warmup 的作用是控制训练初期的有效步长。Adam 的二阶矩估计在最初若干步方差很大, 偏小,等效步长偏大;线性升温把前 步的学习率压到 。 取总步数的 1% 至 5%,本篇取 2%(78 步)。

主调度用余弦衰减到峰值的 10%:

批大小按 token 计,因为不同样本长度不同时,按序列数计的批大小不反映梯度噪声。本篇的全局批为

即每步约 1.05M token,4.07B 预算对应 3881 步。CPT 倾向使用较大的批:梯度噪声小,对已收敛权重的随机扰动小;代价是步数减少,有效更新次数下降。实践中的区间是每步 0.5M 至 2M token。

阶段(7B)峰值学习率warmup数据轮数每步 token
预训练约 2000 步1 遍2M 至 4M
CPT 全参 至 总步数 1% 至 5%1 至 3 遍0.5M 至 2M
CPT LoRA 至 同上同上0.25M 至 1M
SFT 全参 至 3%2 至 3 epoch64k 至 256k

6 灾难遗忘的机制与度量

把通用语料上的损失在 处做二阶展开。对位移 ,

其中 是通用损失在该点的 Hessian。预训练结束时 ,因此增量为 。

遗忘的发生机制由此清楚: 在不同方向上的曲率差异很大。通用语料覆盖的主方向曲率大,沿之移动很小的距离就带来显著的损失上升;领域语料的专有方向在通用数据中几乎没有样本,曲率小,同一位移在该方向上的损失下降大。领域批次给出的梯度并不区分两个方向,它只最小化领域损失,因此 同时含两个分量,前者只产生代价,后者产生收益。二者之比决定了 CPT 是否值得。

度量应覆盖五类量,缺一类就无法判断退化来自哪里。

指标定义采样频率参考阈值
通用基准回退,固定子集每 200 步绝对值小于 1 个百分点
通用困惑度变化每 200 步小于 5%
输出分布偏移每 500 步小于 0.02 nats/token
层位移结束时逐层观察,底层应小于顶层
遗忘率,逐任务计算结束时任一项大于 10% 视为不可接受

前两项是结果指标,第三项是过程指标:它在通用基准尚未明显下降时就能给出预警。第四项用于定位,若底层位移与顶层同量级,说明学习率过大或未做逐层衰减。第五项把「退化」折算成逐任务的相对量,便于在多个任务间比较严重程度。

选择检查点时不要只看领域困惑度。把每个检查点记录为平面上的一个点 ,取曲线拐点;在拐点之后,领域收益的边际下降而通用代价的边际上升。

7 缓解手段

五种手段可以叠加,前两种是必需的。

  1. 回放。按 掺入通用语料。 时遗忘最重, 在 0.25 至 0.5 之间通常能同时保持领域收益与通用能力。回放的代价是算力:总预算 不变时,领域有效 token 只有 ,因此回放比例提高需要相应扩大预算,否则领域收益被摊薄。
  2. 低学习率、少轮数、早停。单源轮数上限 3,超过后模型开始记忆原文;早停的判据是通用困惑度而非训练损失。
  3. LoRA。冻结 ,只训练低秩增量 ,其中 、、。基座权重不变,通用能力的大部分保留在基座中;代价是容量受限,领域困惑度的降幅通常小于全参训练。实现见 LoRA与QLoRA。
  4. L2-SP 正则。在损失中加入 , 取 至 。它把参数约束在 附近,作用与降低学习率同向,但对不同层不区分。
  5. KL 蒸馏到参考模型。在通用批次上加入 , 取 0.1 至 1.0。它直接约束输出分布而非参数,比 L2-SP 更贴近「不改变通用行为」的目标,代价是每步多一次参考模型前向。

合并后的目标函数为

此外可用逐层学习率衰减:第 层(自底向上编号 至 )的学习率为 , 取 0.9 至 0.95。底层学到的是通用特征,衰减后位移小;顶层承担领域特化,位移大。

8 评价:领域困惑度、下游任务与通用能力

三组指标必须同时报告,只报一组等于没有评估。

轴指标数据通过条件
领域拟合领域留出集困惑度,按文档类型分桶每源留出 1% 文档相对 下降 20% 以上
下游能力领域问答 EM、分类 F1、术语抽取 F1200 至 500 条标注相对 SFT-only 基线提升 3 个百分点以上
通用能力MMLU 子集、C-Eval 子集、代码 pass@1、指令遵循固定子集,每项 200 条任一项回退不超过 2 个百分点

领域困惑度按文档类型分桶是必要的:手册、论坛帖、内部文档的难度不同,混在一起的均值会掩盖某类语料上的恶化。下游任务必须与「只在通用模型上做同样 SFT」的基线对比,否则无法区分收益来自 CPT 还是来自 SFT 数据。

9 CPT 与 SFT 的顺序、数据配比

顺序应为 CPT 在前、SFT 在后。反序会引入一个具体问题:SFT 已经把对话模板的角色标记与结束符写入条件分布,随后的 CPT 语料没有这些标记,其梯度会把格式先验重新拉平;若 CPT 规模较大,SFT 的效果需要重跑才恢复。若因工程原因必须交错,把 5% 至 10% 的 SFT 数据混入 CPT 作为格式锚点,并把这部分数据的损失掩码保持为全 1。

阶段数据目标停止条件
CPT领域无标注 50%,通用 50%降低领域困惑度通用困惑度上升超过 5%,或领域困惑度连续 500 步不再下降
SFT领域指令 60%,通用指令 40%学会任务格式与拒答留出集损失连续 3 次评估上升
对齐偏好数据(可选)与人类偏好一致见 [[DPO与偏好优化]]
flowchart TD
    A[通用预训练模型 theta_0] --> B{领域困惑度是否显著高于通用基线}
    B -- 否 --> C[直接进入 SFT]
    B -- 是 --> D[领域语料采集与清洗]
    D --> E[去重与 13-gram 污染检测]
    E --> F[按 alpha 与通用语料混合]
    F --> G[CPT 全参或 LoRA 学习率 1e-5 至 3e-5]
    G --> H[双指标监控 领域困惑度下降 通用困惑度上升]
    H -- 通用回退超阈值 --> I[提高回放比例或降低学习率并回滚检查点]
    I --> G
    H -- 通过 --> J[CPT 检查点]
    J --> K[领域指令数据做 SFT]
    K --> L[领域评测与通用能力回归]
    L -- 未通过 --> G
    L -- 通过 --> M[交付]

10 成本估算

训练算力由 估计:前向约 FLOPs,反向约 。设硬件峰值为 、实测算力利用率为 ,则卡时为

预算 ()A100 卡时()H100 卡时()美元(A100 按 2 美元/卡时)
1B9324186
4.07B38096761
10B9352361870
50B467411809348

显存方面,7B 全参训练需要 bf16 权重 14 GB、fp32 主权重 28 GB、Adam 一阶与二阶矩各 28 GB,合计 98 GB,尚未计入激活;单张 80 GB 卡不足,需要 ZeRO-3 或 FSDP 在 4 至 8 卡上分片。LoRA 只需 14 GB 基座加少量适配器参数,单卡 24 GB 可运行;4-bit 量化后(见 LoRA与QLoRA)约 4 GB 至 6 GB。

单位成本可用于决策:本篇 4.07B 预算耗 380 A100 卡时,折合每百万 token 0.187 美元。若扩大到 10B,单位成本不变,总额约 1870 美元;这给出了「把领域困惑度再降一点」的边际价格。

关键直觉

CPT 改变的是模型在任意上下文下「下一个 token 是什么」的边缘分布,SFT 改变的是「给定指令后回复是什么」的条件分布;两者共享同一组参数,因此 CPT 的收益与代价在同一个参数空间内结算:领域方向的曲率小、单位位移收益大,通用方向的曲率大、单位位移代价大,位移总量由学习率与步数之积控制。由此得到三条可操作的推论:学习率必须比预训练低一个数量级;通用语料必须按比例回放,因为它提供的是曲率信息而非额外知识;判断 CPT 是否成功,必须同时观察领域的下降与通用的上升,单一指标必然误导。这一直觉与本篇的严格定义一致:它只是把第 6 节二阶展开的结论用文字复述,并未引入新的假设。

例子与代码

例 1:预算、配比与步数的手算

给定领域语料三个来源、通用语料两个来源,清洗后的可用量与允许轮数如下表。

来源类型可用 token轮数上限容量
行业标准与手册领域0.486B31.458B
内部技术文档领域0.167B30.501B
领域问答与论坛领域0.076B10.076B
通用中文网页通用2.400B24.800B
英文技术语料通用0.663B21.326B
合计B,B

按 ,由第 3 节的 公式,

因此 10B 的初始预算不可行,预算被领域语料卡在 4.07B。若把 降到 0.25,则 B,接近总量约束 B 在 处的值。这说明:在语料固定的条件下,想扩大预算只能降低领域占比,而降低 又会摊薄领域收益,二者的权衡点由 给出。

取 4.07B、每步 1.05M token,得 3881 步;warmup 2% 为 78 步;,在 A100、 下为 380 卡时。

例 2:预算与配比的计算脚本

下面的脚本把上面的手算过程自动化,并给出可行性扫描。脚本无第三方依赖,可直接运行。

# cpt_budget.py —— 纯 Python 3.10+,无第三方依赖
# 输入:各数据源的规模、分词密度、清洗保留率、允许重复轮数上限
# 输出:可行 token 预算、领域/通用配比、每源 epoch、优化步数与卡时量级
from dataclasses import dataclass


@dataclass
class Source:
    name: str
    kind: str            # "dom" 领域语料,"gen" 通用语料
    docs: int
    chars_per_doc: float
    chars_per_token: float
    keep_rate: float     # 清洗、去重、污染过滤后的保留率
    max_epoch: float     # 允许重复的最大轮数,重复过多会退化为记忆

    @property
    def tokens(self) -> float:
        return self.docs * self.chars_per_doc / self.chars_per_token * self.keep_rate

    @property
    def capacity(self) -> float:
        return self.tokens * self.max_epoch


SOURCES = [
    Source("行业标准与手册", "dom", 120_000, 9_000, 1.60, 0.72, 3.0),
    Source("内部技术文档",   "dom",  45_000, 6_500, 1.40, 0.80, 3.0),
    Source("领域问答与论坛", "dom",  80_000, 2_200, 1.50, 0.65, 1.0),
    Source("通用中文网页",   "gen", 2_000_000, 3_000, 1.50, 0.60, 2.0),
    Source("英文技术语料",   "gen",   900_000, 4_000, 3.80, 0.70, 2.0),
]

D_REQUEST = 10e9              # 期望 token 预算
ALPHA_REQUEST = 0.50          # 期望领域占比
TOKENS_PER_STEP = 1_048_576   # 4 卡 × 批 4 × 序列 4096 × 梯度累积 16
N_PARAMS = 7.0e9              # 模型参数量
PEAK_FLOPS = 3.12e14          # A100 80GB bf16 峰值 312 TFLOPS
MFU = 0.40                    # 实测算力利用率
WARMUP_RATIO = 0.02
PEAK_LR = 2e-5


def water_fill(sources, caps, total):
    """在每源 capacity 上限下按语料量比例分配 total;触顶的源固定后重新分配。"""
    alloc = [0.0] * len(sources)
    fixed = [False] * len(sources)
    remaining = total
    for _ in range(len(sources) + 1):
        active = [i for i, f in enumerate(fixed) if not f]
        if not active or remaining <= 1e-6:
            break
        pool = sum(sources[i].tokens for i in active)
        progressed = False
        for i in active:
            want = alloc[i] + remaining * sources[i].tokens / pool
            if want >= caps[i]:                     # 该源已达轮数上限
                remaining -= caps[i] - alloc[i]
                alloc[i] = caps[i]
                fixed[i] = True
                progressed = True
        if not progressed:
            for i in active:
                alloc[i] += remaining * sources[i].tokens / pool
            remaining = 0.0
    return alloc


dom = [s for s in SOURCES if s.kind == "dom"]
gen = [s for s in SOURCES if s.kind == "gen"]
dom_cap = sum(s.capacity for s in dom)
gen_cap = sum(s.capacity for s in gen)

print("== 语料容量 ==")
print(f"{'来源':<9}{'可用(B)':>9}{'上限(B)':>9}  类型  最大 epoch")
for s in SOURCES:
    print(f"{s.name:<9}{s.tokens/1e9:9.3f}{s.capacity/1e9:9.3f}  {s.kind}    {s.max_epoch:.0f}")
print(f"领域容量 {dom_cap/1e9:.3f} B,通用容量 {gen_cap/1e9:.3f} B")

print("\n== 预算-配比可行性扫描:D_max(alpha) = min(dom_cap/alpha, gen_cap/(1-alpha)) ==")
print(f"{'alpha':>6}{'领域上限(B)':>13}{'通用上限(B)':>13}{'D_max(B)':>10}")
for a in (0.20, 0.25, 0.40, 0.50, 0.75):
    d1, d2 = dom_cap / a, gen_cap / (1 - a)
    print(f"{a:6.2f}{d1/1e9:13.3f}{d2/1e9:13.3f}{min(d1, d2)/1e9:10.3f}")

d_cap = min(dom_cap / ALPHA_REQUEST, gen_cap / (1 - ALPHA_REQUEST))
D = min(D_REQUEST, int(d_cap / 1e7) * 1e7)
if D < D_REQUEST:
    print(f"\n请求 {D_REQUEST/1e9:.1f} B 在 alpha={ALPHA_REQUEST:.2f} 下不可行,"
          f"上限 {d_cap/1e9:.3f} B,收敛到 {D/1e9:.2f} B")

dom_alloc = water_fill(dom, [s.capacity for s in dom], ALPHA_REQUEST * D)
gen_alloc = water_fill(gen, [s.capacity for s in gen], D - ALPHA_REQUEST * D)
alloc = dict(zip([s.name for s in dom], dom_alloc)) | dict(zip([s.name for s in gen], gen_alloc))

print("\n== 各来源分配 ==")
print(f"{'来源':<9}{'分配(B)':>9}{'占总量':>8}{'epoch':>7}  类型")
for s in SOURCES:
    a = alloc[s.name]
    print(f"{s.name:<9}{a/1e9:9.3f}{a/D:8.1%}{a/s.tokens:7.2f}  {s.kind}")

steps = D / TOKENS_PER_STEP
warmup = max(1, round(steps * WARMUP_RATIO))
flops = 6 * N_PARAMS * D
gpu_h = flops / (PEAK_FLOPS * MFU) / 3600

print("\n== 训练配置 ==")
print(f"token 预算        {D/1e9:.2f} B(领域 {sum(dom_alloc)/1e9:.2f} B / 通用 {sum(gen_alloc)/1e9:.2f} B)")
print(f"每步 token        {TOKENS_PER_STEP:,}")
print(f"总步数            {steps:,.0f}")
print(f"warmup 步数       {warmup}")
print(f"峰值学习率        {PEAK_LR:.1e},cosine 衰减至 {PEAK_LR/10:.1e}")
print(f"总 FLOPs          6ND = {flops:.2e}")
print(f"A100 卡时         {gpu_h:,.0f}(MFU {MFU:.0%},2 美元/卡时 ≈ {gpu_h*2:,.0f} 美元)")
print(f"每百万 token 成本 {gpu_h*2/D*1e6:.3f} 美元")
print(f"领域 token/参数   {sum(dom_alloc)/N_PARAMS:.2f}")

在做什么:把「语料容量」与「预算」当作两个独立约束求解。water_fill 按语料量比例分配预算,某源触到轮数上限后固定并重新分配剩余量,等价于带上下界的比例分配。

为什么这样做:轮数上限必须显式建模。领域语料小、通用语料大,若只按比例分配,小语料会被重复十遍以上,训练退化为记忆;若不设上限,脚本会高估可用预算。

输出如下。

== 语料容量 ==
来源           可用(B)    上限(B)  类型  最大 epoch
行业标准与手册      0.486    1.458  dom    3
内部技术文档       0.167    0.501  dom    3
领域问答与论坛      0.076    0.076  dom    1
通用中文网页       2.400    4.800  gen    2
英文技术语料       0.663    1.326  gen    2
领域容量 2.036 B,通用容量 6.126 B

== 预算-配比可行性扫描:D_max(alpha) = min(dom_cap/alpha, gen_cap/(1-alpha)) ==
 alpha      领域上限(B)      通用上限(B)  D_max(B)
  0.20       10.178        7.658     7.658
  0.25        8.143        8.168     8.143
  0.40        5.089       10.211     5.089
  0.50        4.071       12.253     4.071
  0.75        2.714       24.505     2.714

请求 10.0 B 在 alpha=0.50 下不可行,上限 4.071 B,收敛到 4.07 B

== 各来源分配 ==
来源           分配(B)     占总量  epoch  类型
行业标准与手册      1.457   35.8%   3.00  dom
内部技术文档       0.501   12.3%   3.00  dom
领域问答与论坛      0.076    1.9%   1.00  dom
通用中文网页       1.594   39.2%   0.66  gen
英文技术语料       0.441   10.8%   0.66  gen

== 训练配置 ==
token 预算        4.07 B(领域 2.04 B / 通用 2.03 B)
每步 token        1,048,576
总步数            3,881
warmup 步数       78
峰值学习率        2.0e-05,cosine 衰减至 2.0e-06
总 FLOPs          6ND = 1.71e+20
A100 卡时         380(MFU 40%,2 美元/卡时 ≈ 761 美元)
每百万 token 成本 0.187 美元
领域 token/参数   0.29

读法:epoch 列超过 3 说明该源被过度重复,需要补数据或降低 ;占总量 列与 的差说明水填之后实际配比偏离了请求值。本例中两个领域大源都顶到 3 轮,说明领域语料是瓶颈,而不是通用语料。

去掉轮数上限会怎样:industry 源会被分配到 4.07B 中的大部分,实际轮数达到 6 至 7,训练进入记忆模式,领域留出集困惑度反而上升。

例 3:带 L2-SP 与 KL 回放的一次 CPT 更新

下面的脚本用随机初始化的小模型验证损失组合与形状,运行需要 torch 与 transformers(示例在 transformers 5.x、torch 2.x 上验证)。换成真实 7B 检查点时,只需替换模型加载与分词,损失组合不变。

import copy
import torch
import torch.nn.functional as F
from transformers import GPT2Config, GPT2LMHeadModel

torch.manual_seed(0)
VOCAB, L, B = 1000, 64, 2
cfg = GPT2Config(vocab_size=VOCAB, n_positions=L, n_embd=64, n_layer=2, n_head=2,
                 bos_token_id=0, eos_token_id=1)
model = GPT2LMHeadModel(cfg).train()
ref = copy.deepcopy(model).eval()                 # theta_0:冻结的参考模型
for p in ref.parameters():
    p.requires_grad_(False)
theta0 = [p.detach().clone() for p in model.parameters()]

opt = torch.optim.AdamW(model.parameters(), lr=2e-5, betas=(0.9, 0.95), weight_decay=0.1)

dom_ids = torch.randint(0, VOCAB, (B, L))        # 领域批:随机 id 代替真实语料
gen_ids = torch.randint(0, VOCAB, (B, L))        # 通用批:用于 KL 回放
LAMBDA_SP, BETA_KL = 1e-4, 0.5


def kl_to_ref(batch: torch.Tensor) -> torch.Tensor:
    """通用批上当前模型与参考模型的逐位置 KL 均值,单位 nats/token。"""
    with torch.no_grad():
        logp_ref = F.log_softmax(ref(input_ids=batch).logits, dim=-1)
    logp = F.log_softmax(model(input_ids=batch).logits, dim=-1)
    return F.kl_div(logp, logp_ref.exp(), reduction="batchmean") / L


for step in range(1, 4):
    l_cpt = model(input_ids=dom_ids, labels=dom_ids).loss          # 标量
    l_sp = sum(((p - p0) ** 2).sum() for p, p0 in zip(model.parameters(), theta0))
    l_kl = kl_to_ref(gen_ids)
    loss = l_cpt + LAMBDA_SP * l_sp + BETA_KL * l_kl
    opt.zero_grad(set_to_none=True)
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
    opt.step()
    print(f"step {step}  l_cpt={l_cpt.item():.4f}  l2sp={l_sp.item():.4f}  "
          f"kl={l_kl.item():.6f}  loss={loss.item():.4f}")

print("参数位移总范数 =",
      f"{torch.sqrt(sum(((p - p0) ** 2).sum() for p, p0 in zip(model.parameters(), theta0))).item():.6f}")
print("logits 形状 =", model(input_ids=dom_ids).logits.shape)

在做什么:l_cpt 是常规自回归损失,labels 与 input_ids 相同即掩码全为 1;l_sp 是参数相对 的平方距离之和;l_kl 在通用批上计算当前模型与参考模型的逐位置 KL,除以 后得到 nats/token。

为什么这样做:三个量分别约束「领域拟合」「参数不远离」「输出不变形」。KL 项的梯度只作用在输出分布上,不需要通用标签,因此可以直接用无标注的通用语料。

输出如下。

step 1  l_cpt=6.9238  l2sp=0.0000  kl=0.001819  loss=6.9247
step 2  l_cpt=6.9127  l2sp=0.0001  kl=0.001922  loss=6.9137
step 3  l_cpt=6.9139  l2sp=0.0002  kl=0.001949  loss=6.9149
参数位移总范数 = 0.021121
logits 形状 = torch.Size([2, 64, 1000])

l_cpt 约 6.92,与 接近,符合随机初始化模型在 1000 类均匀分布上的预期;这提供了一个校验点:若真实语料的首步损失远高于该值,说明标签错位或分词异常。l2sp 从 0 增至 0.0002,说明位移量很小;kl 从 0.00182 增至 0.00195,说明输出分布正在缓慢偏离。三个数的相对变化即为第 6 节过程指标的直接读数。

去掉会怎样:删掉 l_kl 项后,通用批只受 CPT 梯度的间接影响,kl 会在数百步后升到 0.01 量级以上,此时通用基准通常已出现可测回退。删掉 l2sp 且把学习率放大十倍,l_cpt 在几步内降到 6.90 以下,但这是对 2 条固定批次的记忆,不是分布改善。

易错点

以下六条均可在训练日志、样本抽查或评测脚本中直接检验。

1. 语料污染评测集:领域评测集只有几百条,一篇被收录进训练集的制度文档即可让领域困惑度明显下降。检验方法是把评测集切为 13-gram,与训练语料求交,命中数为 0 才允许开训。

2. 学习率按预训练量级设置:直接沿用 ,在已收敛点上等价于随机重启,训练损失先降后升,通用能力在 200 步内出现可测退化。检验方法是前 100 步的损失曲线应单调缓降,出现尖峰即停。

3. 混合比例失衡: 只用领域数据。表现为领域困惑度下降很快,但通用基准同步回退;检验方法是同时打印两个困惑度,若通用困惑度的相对升幅超过 5% 即判定失衡。

4. 忘记重新处理分词器:扩词表后未调用 resize_token_embeddings,或未给新增 embedding 行单独设置更大的学习率,新 token 保持随机初始化,训练初期损失剧烈波动。检验方法是对比 model.config.vocab_size 与 len(tokenizer),并抽查新 token 的输出概率。

5. 只监控领域指标:领域困惑度在过拟合、记忆、污染三种情况下都会下降。缺少通用基准与留出集分桶,无法区分「学到分布」与「记住原文」。

6. 用对话格式数据做 CPT:把指令—回复对去掉掩码直接送入 CPT,角色标记进入边缘分布,模型开始在任何上下文后生成「助手」段落;同时若同名数据也用于 SFT,等于提前泄漏 SFT 的留出集。

关联笔记

  • 前置 预训练-微调-对齐pipeline:给出三阶段的划分与各阶段的数据形态,本篇展开其中「预训练之后、SFT 之前」这一可选环节。
  • 前置 Tokenizer与BPE:子词碎片率与词表扩展决定 CPT 能否处理新语言,扩词表后的 embedding 初始化方式直接影响训练初期的稳定性。
  • 对照 指令微调SFT:两者目标分别是边缘分布与条件分布,损失掩码、轮数与评价指标都不同,混淆会导致数据用法错误。
  • 后续 LoRA与QLoRA:在显存不足时用低秩增量执行 CPT,基座冻结使通用能力保留更完整,代价是领域拟合的容量受限。
  • 资料 数据集质量控制:去重、质量过滤与 13-gram 污染检测的具体实现,本篇直接复用。

达标检测

  • [ ] 写出 CPT 的目标函数,说明它与 SFT 目标在求和范围与被估计分布上的两处差别,并各举一个由此产生的训练现象。
  • [ ] 给定 B、B,求 与 ,并说明为什么在该点两侧的约束同时紧。
  • [ ] 用 、 计算位移上界,与预训练 、 的上界比较,解释为何不能使用预训练的学习率。
  • [ ] 运行例 2 的脚本,把 ALPHA_REQUEST 改为 0.25,记录 D_max、总步数与卡时,并说明预算变化的原因。
  • [ ] 运行例 3 的脚本,把 BETA_KL 设为 0 与 1.0 各跑一次,比较 kl 序列与 l_cpt 的下降速度,解释差异。
  • [ ] 设计一份 CPT 评价表,覆盖领域困惑度分桶、下游任务与通用能力三类指标,并给出每类的通过阈值与采样频率。
  • [ ] 列举灾难遗忘的五种度量,说明哪一种能在通用基准尚未下降时给出预警,并解释原因。

参考来源

  • Gururangan et al., "Don't Stop Pretraining: Adapt Language Models to Domains and Tasks", ACL 2020, arXiv:2004.10964 —— 对应「为什么重要」中领域自适应预训练的动机,以及第 2 节的判据与第 9 节的阶段顺序。
  • Hoffmann et al., "Training Compute-Optimal Large Language Models", arXiv:2203.15556, 2022 —— 对应第 3 节中每参数 20 token 的计算最优估计,以及「CPT 预算只占完整预训练百分之几」的量级判断。
  • Touvron et al., "Llama 2: Open Foundation and Fine-Tuned Chat Models", arXiv:2307.09288, 2023 —— 对应第 5 节的窗口长度 4096、学习率与批大小的量级,以及第 10 节的显存估算。
  • Hugging Face Transformers 官方文档(Trainer、TrainingArguments、resize_token_embeddings、数据打包与 DataCollatorForLanguageModeling 的说明) —— 对应第 4 节的标签构造、第 5 节的调度器配置与例 3 的实现。
  • 张奇等,《大规模语言模型:从理论到实践》,2023,预训练数据与参数高效微调相关章节 —— 对应第 3 节的数据清洗与配比流程,以及第 7 节的回放与正则化手段。