---
tags: [AI, 继续预训练, 领域适配]
阶段: 07-微调与对齐
难度: ★★★
created: 2026-10-18
related: "[[微调方法全景]], [[指令微调SFT]], [[数据集质量控制]], [[LoRA与QLoRA]]"
---

# 继续预训练与领域适配

## 定义

**继续预训练**（continued pretraining，CPT），亦称**领域自适应预训练**（domain-adaptive pretraining，DAPT），指在已收敛的预训练模型 $\theta_0$ 上，用目标领域的无标注文本、以与预训练完全相同的自回归语言建模目标继续训练若干 token，使模型在该领域文本上的平均负对数似然下降。

$$
\mathcal{L}_{\text{CPT}}(\theta)
=-\frac{1}{D}\sum_{i=1}^{D}\log \pi_\theta\bigl(x_i\mid x_{<i}\bigr),
\qquad x_{1:D}\sim\mathcal{D}_{\text{mix}}=(1-\alpha)\,\mathcal{D}_{\text{gen}}+\alpha\,\mathcal{D}_{\text{dom}} .
$$

逐项说明符号与术语。

| 符号 | 含义 |
|---|---|
| $\theta_0$ | 预训练结束时的参数，作为 CPT 的初始化点与回滚基准 |
| $\theta$ | 训练中的参数，$\theta_{t}$ 表示第 $t$ 步 |
| $\pi_\theta(\cdot\mid x_{<i})$ | 模型在位置 $i$ 给出的下一 token 分布，经 softmax 归一化 |
| $x_{1:D}$ | 从混合语料中抽出的长度为 $D$ 的 token 序列（实现上切分为多个长度 $L$ 的窗口） |
| $D$ | **token 预算**，本次 CPT 训练消耗的 token 总数，等于 步数 $\times$ 每步 token 数 |
| $L$ | 单条训练序列的窗口长度，Llama 2 的 7B 模型为 4096 |
| $\mathcal{D}_{\text{dom}}$ | 领域无标注语料，如行业标准、内部技术文档、领域论坛 |
| $\mathcal{D}_{\text{gen}}$ | 通用无标注语料，用于回放，抑制分布漂移 |
| $\alpha$ | **领域占比**，$\alpha=\lvert\mathcal{D}_{\text{dom}}\rvert/(\lvert\mathcal{D}_{\text{dom}}\rvert+\lvert\mathcal{D}_{\text{gen}}\rvert)$，按 token 计 |
| $N$ | 模型参数量，本篇取 7B |

其余术语。**单遍**（epoch）指一条语料被完整读过一次；**回放**（replay）指在领域批次中按比例掺入通用语料；**灾难遗忘**（catastrophic forgetting）指模型在目标分布上损失下降的同时，在其他分布上的能力显著退化；**困惑度**（perplexity，PPL）定义为平均交叉熵的指数 $\mathrm{PPL}=\exp(\mathcal{L})$；**子词碎片率**（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 样本是长度 $L$ 的连续文本 $x_{1:L}$，一条 SFT 样本是指令 $x$ 与回复 $y_{1:T}$ 的拼接。两个目标函数的梯度期望分别为

$$
g_{\text{CPT}}=\mathbb{E}_{x\sim\mathcal{D}_{\text{mix}}}\Bigl[\sum_{i=1}^{L}\nabla_\theta \log \pi_\theta(x_i\mid x_{<i})\Bigr],
$$

$$
g_{\text{SFT}}=\mathbb{E}_{(x,y)\sim\mathcal{D}_{\text{sft}}}\Bigl[\sum_{t=1}^{T}m_t\,\nabla_\theta \log \pi_\theta(y_t\mid x,y_{<t})\Bigr],
$$

其中 $m_t\in\{0,1\}$ 是损失掩码。两式的差别有两处，且都影响优化行为。

第一处是求和范围。CPT 的每个位置都贡献梯度，一条 4096 token 的样本产生 4096 个监督信号；SFT 只保留回复段，一条样本通常只有 100 至 600 个有效位置。等量 token 下，CPT 的梯度估计方差更小。

第二处是被估计的分布。CPT 估计的是边缘分布 $p(x_{1:L})$，SFT 估计的是条件分布 $p(y\mid x)$。二者共享同一组参数，因此在参数空间中是两个不同的位移方向；把领域术语的先验抬高，与把「回答要给出引用」这一行为写入条件分布，是两件事。

| 维度 | 继续预训练（CPT） | 监督微调（SFT） |
|---|---|---|
| 数据形态 | 无标注连续文本 | 指令—回复对 |
| 损失位置 | 全部 token | 仅回复 token |
| 估计对象 | 边缘分布 $p(x)$ | 条件分布 $p(y\mid x)$ |
| 数据轮数 | 1 至 3 遍，单源上限 3 | 2 至 3 epoch |
| 峰值学习率（全参 7B） | $1\times10^{-5}$ 至 $3\times10^{-5}$ | $1\times10^{-5}$ 至 $2\times10^{-5}$ |
| 主要风险 | 灾难遗忘 | 格式过拟合、对少量样本过拟合 |
| 必须同时报告的评价 | 领域困惑度与通用能力同时报告 | 留出集损失与格式合法率 |

表中学习率区间接近，容易被误读为「两者可以互换」。差别在步数与数据量：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 数（含允许的重复轮数）应达到 $0.1N$ 以上；对 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，与训练语料求交集，命中即从训练集删除整篇文档。领域评测集往往只有几百条，一篇被污染的标准文档就足以让领域困惑度下降一个明显的量，而这一下降不来自模型能力。

混合比例 $\alpha$ 与 token 预算 $D$ 不是两个独立参数，它们受语料容量约束。设第 $i$ 个来源的可用 token 为 $t_i$、允许的最大轮数为 $e_i$，则领域与通用的容量分别为

$$
C_{\text{dom}}=\sum_{i\in\text{dom}} t_i e_i,\qquad C_{\text{gen}}=\sum_{i\in\text{gen}} t_i e_i ,
$$

可行预算的上界为

$$
D_{\max}(\alpha)=\min\Bigl(\frac{C_{\text{dom}}}{\alpha},\ \frac{C_{\text{gen}}}{1-\alpha}\Bigr).
$$

该式说明一个常被忽略的事实：领域语料不足时，提高 $\alpha$ 不能提高预算，只会让预算被领域容量卡住。反解可得语料结构允许的最小领域占比

$$
\alpha_{\min}=\frac{C_{\text{dom}}}{C_{\text{dom}}+C_{\text{gen}}},
$$

它是总量约束下的最优占比，因为在该点两侧的容量同时被用满。

与 Chinchilla 的对照给出量级感。Chinchilla 的结论是计算最优训练量约为每参数 20 个 token（见参考来源），对 $N=7\times10^{9}$ 即 $D\approx1.4\times10^{11}$。本篇的 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，则

$$
\mathrm{PPL}_0=e^{2.518}=12.4,\qquad \mathrm{PPL}_1=e^{2.092}=8.1,
$$

降幅为 0.426 nats，合 0.614 bit。报告时应给出 nats/token，因为困惑度不可跨分词器比较：同一段文本在不同词表下被切成不同数量的 token，$\mathrm{PPL}$ 的分母随之改变。固定分词器版本是 CPT 报告有效性的前提。

### 5 学习率、训练步数、warmup 与批大小

学习率必须比预训练小一个数量级，理由可以用一阶近似给出。Adam 的单步元素级更新量为 $\eta\cdot m_t/\sqrt{v_t}$，其中 $m_t$、$v_t$ 是一阶矩与二阶矩的估计；在梯度方向稳定的维度上该比值接近 $\pm1$，在噪声维度上更小，因此 $\eta\cdot m_t/\sqrt{v_t}$ 的绝对值以 $\eta$ 为上界。于是 $T$ 步的累计位移范数上界约为

$$
\lVert\theta_T-\theta_0\rVert\lesssim \eta T .
$$

预训练的取值约 $\eta=3\times10^{-4}$、$T\approx10^{6}$，上界 300；本篇 CPT 为 $\eta=2\times10^{-5}$、$T=3881$，上界 0.0776。该上界在方向完全一致时才能取到，实际位移远小于它，但两者的比值（约 $1/3900$）说明了量级：CPT 的位移预算只够移动分布，不够学习新能力。若把学习率设成预训练量级，同样的步数会产生约 1164 的位移上界，等价于在已收敛点上做随机重启。

warmup 的作用是控制训练初期的有效步长。Adam 的二阶矩估计在最初若干步方差很大，$\sqrt{v_t}$ 偏小，等效步长偏大；线性升温把前 $W$ 步的学习率压到 $\eta t/W$。$W$ 取总步数的 1% 至 5%，本篇取 2%（78 步）。

主调度用余弦衰减到峰值的 10%：

$$
\eta_t=\eta_{\min}+\tfrac12(\eta-\eta_{\min})\Bigl(1+\cos\frac{\pi(t-W)}{T-W}\Bigr),\qquad t\ge W .
$$

批大小按 token 计，因为不同样本长度不同时，按序列数计的批大小不反映梯度噪声。本篇的全局批为

$$
B_{\text{tok}}=B_{\text{dev}}\times A\times N_{\text{gpu}}\times L=4\times16\times4\times4096=1{,}048{,}576,
$$

即每步约 1.05M token，4.07B 预算对应 3881 步。CPT 倾向使用较大的批：梯度噪声小，对已收敛权重的随机扰动小；代价是步数减少，有效更新次数下降。实践中的区间是每步 0.5M 至 2M token。

| 阶段（7B） | 峰值学习率 | warmup | 数据轮数 | 每步 token |
|---|---|---|---|---|
| 预训练 | $3\times10^{-4}$ | 约 2000 步 | 1 遍 | 2M 至 4M |
| CPT 全参 | $1\times10^{-5}$ 至 $3\times10^{-5}$ | 总步数 1% 至 5% | 1 至 3 遍 | 0.5M 至 2M |
| CPT LoRA | $1\times10^{-4}$ 至 $3\times10^{-4}$ | 同上 | 同上 | 0.25M 至 1M |
| SFT 全参 | $1\times10^{-5}$ 至 $2\times10^{-5}$ | 3% | 2 至 3 epoch | 64k 至 256k |

### 6 灾难遗忘的机制与度量

把通用语料上的损失在 $\theta_0$ 处做二阶展开。对位移 $\Delta\theta=\theta-\theta_0$，

$$
\mathcal{L}_{\text{gen}}(\theta)\approx \mathcal{L}_{\text{gen}}(\theta_0)+\nabla\mathcal{L}_{\text{gen}}(\theta_0)^{\top}\Delta\theta+\tfrac12\Delta\theta^{\top}H_{\text{gen}}\Delta\theta ,
$$

其中 $H_{\text{gen}}$ 是通用损失在该点的 Hessian。预训练结束时 $\nabla\mathcal{L}_{\text{gen}}(\theta_0)\approx0$，因此增量为 $\tfrac12\Delta\theta^{\top}H_{\text{gen}}\Delta\theta$。

遗忘的发生机制由此清楚：$H_{\text{gen}}$ 在不同方向上的曲率差异很大。通用语料覆盖的主方向曲率大，沿之移动很小的距离就带来显著的损失上升；领域语料的专有方向在通用数据中几乎没有样本，曲率小，同一位移在该方向上的损失下降大。领域批次给出的梯度并不区分两个方向，它只最小化领域损失，因此 $\Delta\theta$ 同时含两个分量，前者只产生代价，后者产生收益。二者之比决定了 CPT 是否值得。

度量应覆盖五类量，缺一类就无法判断退化来自哪里。

| 指标 | 定义 | 采样频率 | 参考阈值 |
|---|---|---|---|
| 通用基准回退 | $\mathrm{acc}_t-\mathrm{acc}_0$，固定子集 | 每 200 步 | 绝对值小于 1 个百分点 |
| 通用困惑度变化 | $\mathrm{PPL}_{\text{gen}}(\theta_t)/\mathrm{PPL}_{\text{gen}}(\theta_0)-1$ | 每 200 步 | 小于 5% |
| 输出分布偏移 | $\mathbb{E}_{x\sim\mathcal{D}_{\text{gen}}}\mathrm{KL}\bigl(\pi_{\theta_0}\Vert\pi_{\theta_t}\bigr)/L$ | 每 500 步 | 小于 0.02 nats/token |
| 层位移 | $\lVert\theta_l^{t}-\theta_l^{0}\rVert_2/\lVert\theta_l^{0}\rVert_2$ | 结束时 | 逐层观察，底层应小于顶层 |
| 遗忘率 | $1-s_t/s_0$，逐任务计算 | 结束时 | 任一项大于 10% 视为不可接受 |

前两项是结果指标，第三项是过程指标：它在通用基准尚未明显下降时就能给出预警。第四项用于定位，若底层位移与顶层同量级，说明学习率过大或未做逐层衰减。第五项把「退化」折算成逐任务的相对量，便于在多个任务间比较严重程度。

选择检查点时不要只看领域困惑度。把每个检查点记录为平面上的一个点 $(\Delta\mathrm{PPL}_{\text{dom}},\Delta\mathrm{PPL}_{\text{gen}})$，取曲线拐点；在拐点之后，领域收益的边际下降而通用代价的边际上升。

### 7 缓解手段

五种手段可以叠加，前两种是必需的。

1. 回放。按 $\alpha$ 掺入通用语料。$\alpha=1$ 时遗忘最重，$\alpha$ 在 0.25 至 0.5 之间通常能同时保持领域收益与通用能力。回放的代价是算力：总预算 $D$ 不变时，领域有效 token 只有 $\alpha D$，因此回放比例提高需要相应扩大预算，否则领域收益被摊薄。
2. 低学习率、少轮数、早停。单源轮数上限 3，超过后模型开始记忆原文；早停的判据是通用困惑度而非训练损失。
3. LoRA。冻结 $\theta_0$，只训练低秩增量 $\Delta W=BA$，其中 $B\in\mathbb{R}^{d\times r}$、$A\in\mathbb{R}^{r\times k}$、$r\ll\min(d,k)$。基座权重不变，通用能力的大部分保留在基座中；代价是容量受限，领域困惑度的降幅通常小于全参训练。实现见 [[LoRA与QLoRA]]。
4. L2-SP 正则。在损失中加入 $\frac{\lambda}{2}\lVert\theta-\theta_0\rVert_2^2$，$\lambda$ 取 $1\times10^{-4}$ 至 $1\times10^{-3}$。它把参数约束在 $\theta_0$ 附近，作用与降低学习率同向，但对不同层不区分。
5. KL 蒸馏到参考模型。在通用批次上加入 $\beta\,\mathbb{E}_{x\sim\mathcal{D}_{\text{gen}}}\mathrm{KL}\bigl(\pi_{\theta_0}(\cdot\mid x)\Vert\pi_\theta(\cdot\mid x)\bigr)$，$\beta$ 取 0.1 至 1.0。它直接约束输出分布而非参数，比 L2-SP 更贴近「不改变通用行为」的目标，代价是每步多一次参考模型前向。

合并后的目标函数为

$$
\mathcal{L}=\mathcal{L}_{\text{CPT}}(\theta)+\frac{\lambda}{2}\lVert\theta-\theta_0\rVert_2^2+\beta\,\mathbb{E}_{x\sim\mathcal{D}_{\text{gen}}}\mathrm{KL}\bigl(\pi_{\theta_0}\Vert\pi_\theta\bigr).
$$

此外可用逐层学习率衰减：第 $l$ 层（自底向上编号 $0$ 至 $L-1$）的学习率为 $\eta_l=\eta\cdot d^{\,L-1-l}$，$d$ 取 0.9 至 0.95。底层学到的是通用特征，衰减后位移小；顶层承担领域特化，位移大。

### 8 评价：领域困惑度、下游任务与通用能力

三组指标必须同时报告，只报一组等于没有评估。

| 轴 | 指标 | 数据 | 通过条件 |
|---|---|---|---|
| 领域拟合 | 领域留出集困惑度，按文档类型分桶 | 每源留出 1% 文档 | 相对 $\theta_0$ 下降 20% 以上 |
| 下游能力 | 领域问答 EM、分类 F1、术语抽取 F1 | 200 至 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与偏好优化]] |

```mermaid
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 成本估算

训练算力由 $6ND$ 估计：前向约 $2ND$ FLOPs，反向约 $4ND$。设硬件峰值为 $P$、实测算力利用率为 $u$，则卡时为

$$
H=\frac{6ND}{3600\,P\,u}.
$$

| 预算 $D$ | $6ND$（$N=7\times10^{9}$） | A100 卡时（$u=0.4$） | H100 卡时（$u=0.5$） | 美元（A100 按 2 美元/卡时） |
|---|---|---|---|---|
| 1B | $4.2\times10^{19}$ | 93 | 24 | 186 |
| 4.07B | $1.71\times10^{20}$ | 380 | 96 | 761 |
| 10B | $4.2\times10^{20}$ | 935 | 236 | 1870 |
| 50B | $2.1\times10^{21}$ | 4674 | 1180 | 9348 |

显存方面，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 美元；这给出了「把领域困惑度再降一点」的边际价格。

## 关键直觉

> [!tip] CPT 改变的是模型在任意上下文下「下一个 token 是什么」的边缘分布，SFT 改变的是「给定指令后回复是什么」的条件分布；两者共享同一组参数，因此 CPT 的收益与代价在同一个参数空间内结算：领域方向的曲率小、单位位移收益大，通用方向的曲率大、单位位移代价大，位移总量由学习率与步数之积控制。由此得到三条可操作的推论：学习率必须比预训练低一个数量级；通用语料必须按比例回放，因为它提供的是曲率信息而非额外知识；判断 CPT 是否成功，必须同时观察领域的下降与通用的上升，单一指标必然误导。这一直觉与本篇的严格定义一致：它只是把第 6 节二阶展开的结论用文字复述，并未引入新的假设。

## 例子与代码

### 例 1：预算、配比与步数的手算

给定领域语料三个来源、通用语料两个来源，清洗后的可用量与允许轮数如下表。

| 来源 | 类型 | 可用 token | 轮数上限 | 容量 |
|---|---|---|---|---|
| 行业标准与手册 | 领域 | 0.486B | 3 | 1.458B |
| 内部技术文档 | 领域 | 0.167B | 3 | 0.501B |
| 领域问答与论坛 | 领域 | 0.076B | 1 | 0.076B |
| 通用中文网页 | 通用 | 2.400B | 2 | 4.800B |
| 英文技术语料 | 通用 | 0.663B | 2 | 1.326B |
| 合计 | | | | $C_{\text{dom}}=2.036$B，$C_{\text{gen}}=6.126$B |

按 $\alpha=0.5$，由第 3 节的 $D_{\max}$ 公式，

$$
D_{\max}(0.5)=\min\Bigl(\frac{2.036}{0.5},\frac{6.126}{0.5}\Bigr)=\min(4.071,\ 12.253)=4.071\ \text{B}.
$$

因此 10B 的初始预算不可行，预算被领域语料卡在 4.07B。若把 $\alpha$ 降到 0.25，则 $D_{\max}=\min(8.143,8.168)=8.14$B，接近总量约束 $2.036+6.126=8.16$B 在 $\alpha_{\min}=0.249$ 处的值。这说明：在语料固定的条件下，想扩大预算只能降低领域占比，而降低 $\alpha$ 又会摊薄领域收益，二者的权衡点由 $\alpha_{\min}$ 给出。

取 4.07B、每步 1.05M token，得 3881 步；warmup 2% 为 78 步；$6ND=1.71\times10^{20}$，在 A100、$u=0.4$ 下为 380 卡时。

### 例 2：预算与配比的计算脚本

下面的脚本把上面的手算过程自动化，并给出可行性扫描。脚本无第三方依赖，可直接运行。

```python
# 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` 按语料量比例分配预算，某源触到轮数上限后固定并重新分配剩余量，等价于带上下界的比例分配。

为什么这样做：轮数上限必须显式建模。领域语料小、通用语料大，若只按比例分配，小语料会被重复十遍以上，训练退化为记忆；若不设上限，脚本会高估可用预算。

输出如下。

```text
== 语料容量 ==
来源           可用(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 说明该源被过度重复，需要补数据或降低 $\alpha$；`占总量` 列与 $\alpha$ 的差说明水填之后实际配比偏离了请求值。本例中两个领域大源都顶到 3 轮，说明领域语料是瓶颈，而不是通用语料。

去掉轮数上限会怎样：`industry` 源会被分配到 4.07B 中的大部分，实际轮数达到 6 至 7，训练进入记忆模式，领域留出集困惑度反而上升。

### 例 3：带 L2-SP 与 KL 回放的一次 CPT 更新

下面的脚本用随机初始化的小模型验证损失组合与形状，运行需要 `torch` 与 `transformers`（示例在 `transformers` 5.x、`torch` 2.x 上验证）。换成真实 7B 检查点时，只需替换模型加载与分词，损失组合不变。

```python
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` 是参数相对 $\theta_0$ 的平方距离之和；`l_kl` 在通用批上计算当前模型与参考模型的逐位置 KL，除以 $L$ 后得到 nats/token。

为什么这样做：三个量分别约束「领域拟合」「参数不远离」「输出不变形」。KL 项的梯度只作用在输出分布上，不需要通用标签，因此可以直接用无标注的通用语料。

输出如下。

```text
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，与 $\ln 1000=6.908$ 接近，符合随机初始化模型在 1000 类均匀分布上的预期；这提供了一个校验点：若真实语料的首步损失远高于该值，说明标签错位或分词异常。`l2sp` 从 0 增至 0.0002，说明位移量很小；`kl` 从 0.00182 增至 0.00195，说明输出分布正在缓慢偏离。三个数的相对变化即为第 6 节过程指标的直接读数。

去掉会怎样：删掉 `l_kl` 项后，通用批只受 CPT 梯度的间接影响，`kl` 会在数百步后升到 0.01 量级以上，此时通用基准通常已出现可测回退。删掉 `l2sp` 且把学习率放大十倍，`l_cpt` 在几步内降到 6.90 以下，但这是对 2 条固定批次的记忆，不是分布改善。

## 易错点

> [!warning] 以下六条均可在训练日志、样本抽查或评测脚本中直接检验。
> 1. 语料污染评测集：领域评测集只有几百条，一篇被收录进训练集的制度文档即可让领域困惑度明显下降。检验方法是把评测集切为 13-gram，与训练语料求交，命中数为 0 才允许开训。
> 2. 学习率按预训练量级设置：直接沿用 $3\times10^{-4}$，在已收敛点上等价于随机重启，训练损失先降后升，通用能力在 200 步内出现可测退化。检验方法是前 100 步的损失曲线应单调缓降，出现尖峰即停。
> 3. 混合比例失衡：$\alpha=1$ 只用领域数据。表现为领域困惑度下降很快，但通用基准同步回退；检验方法是同时打印两个困惑度，若通用困惑度的相对升幅超过 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 目标在求和范围与被估计分布上的两处差别，并各举一个由此产生的训练现象。
- [ ] 给定 $C_{\text{dom}}=2.0$B、$C_{\text{gen}}=6.0$B，求 $\alpha_{\min}$ 与 $D_{\max}(0.5)$，并说明为什么在该点两侧的约束同时紧。
- [ ] 用 $\eta=2\times10^{-5}$、$T=4000$ 计算位移上界，与预训练 $\eta=3\times10^{-4}$、$T=10^{6}$ 的上界比较，解释为何不能使用预训练的学习率。
- [ ] 运行例 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 节的回放与正则化手段。
