“合成数据不是魔法。它是一面放大镜——放大优点，也放大缺陷。”

2025 年，合成数据从”锦上添花”变成了”不可或缺”。但这面放大镜照出了两种截然不同的前途：一边是 Phi 系列证明了高质量合成数据可以让小模型逼近大模型的能力；另一边是多项研究发现不加控制的合成数据会导致不可逆的模型退化。

2026 年，行业共识进一步收敛：合成数据不再是一份”方法清单”，而是一套工程体系——生成（Generation）、验证（Verification）、进化（Evolution） 三段闭环。生解决”数据从哪里来”，验证解决”哪些数据可以进训练集”，进化解决”下一轮数据怎么比这一轮更好”。本章将以这三段式为主线，重构合成数据的全部知识版图。

---

24.1 引言：从”方法清单”到”工程体系”

认知演变时间线

合成数据在大模型中的角色经历了一个完整的认知转变：

认知演变时间线：

2022 年  "合成数据只是数据增强的手段之一"
    ↓
2023 年  Phi-1 发布："教科书即一切"——高质量合成数据训练出的 1.3B 模型
         在编码能力上超过很多 10B+ 模型
    ↓
2024 年  两个方向同时爆发：
         ✅ Phi-3/4 → 合成数据是小模型崛起的关键
         ❌ Nature 论文 → Model Collapse 是真实风险
    ↓
2025 年  "第二代合成数据"兴起：
         → 合成不是简单生成，而是带验证、带反馈、带课程的工程
         → EMNLP 论文量化了合成数据的 Scaling Law
         → ICLR 2025 证明：验证机制（而非真实数据比例）是防坍缩核心
    ↓
2026 年  合成数据成为每个训练阶段的标配
         → 但混合比例、质量控制、多样性保证变成核心工程问题
         → 行业进入"体系化"阶段：生成-验证-进化三段闭环成为
           大规模训练管线的标准架构

为什么需要”三段式”体系

早期的合成数据实践是线性的：找种子 → 生成 → 过滤 → 训练。这种一次性流水线有三个致命缺陷：

1. 生成与验证脱节。生成端不知道验证端在检查什么，导致大量算力浪费在注定被淘汰的数据上——Phi-3 的合成管线淘汰率约 40%，意味着近一半生成算力被浪费。
2. 没有反馈回路。第一批数据的缺陷不会 informs 第二批数据的生成策略，同样的错误被反复生成、反复过滤。
3. 无法应对递归风险。当合成数据训练出的模型再次生成数据时，线性流水线对分布退化的累积毫无感知，直到 Model Collapse 已成事实。

“生成-验证-进化”体系正是对这三个缺陷的系统性回应：

环节	核心问题	关键机制	失控后果
生成 Generation	数据从哪里来、长什么样	方法谱系、种子策略、多样性控制	分布单一、幻觉传播
验证 Verification	哪些数据可信、可入训练集	质量度量、verifier、四层过滤	噪声入库、渐进退化
进化 Evolution	下一轮如何比这一轮更好	迭代自提升、数据飞轮、崩溃防控	奖励黑客、模型崩溃

三段不是并列关系，而是闭环关系：验证的信号回流到生成端（修正 prompt 与种子策略），进化的课程设计决定下一轮生成的目标分布。理解了这一点，就理解了本章的全部结构。

各训练阶段的合成数据策略

合成数据在大模型的每个训练阶段都有应用，但角色、方法和风险各不相同：

阶段	合成数据类型	生成方法	目的	推荐比例	关键风险
预训练	改写、翻译、摘要、教科书化	大模型改写 + 模板化	增加数据量和多样性	5-20%	信息损失、风格均一化
中训练	教科书化、知识增强、代码生成	种子知识 + 大模型扩展	提高知识密度	10-30%	幻觉传播、模式坍缩
SFT	指令合成、回复合成、对话生成	Self-Instruct / Evol-Instruct	扩大覆盖面	30-80%	多样性不足、质量下限
RL	偏好合成、自我对弈、拒绝采样	On-policy 生成 + 验证	自动化偏好学习	50-100%	奖励黑客、分布偏移

🔍 反直觉发现：很多人以为合成数据主要用于 SFT 阶段。实际上，2025-2026 年最大的变化发生在预训练阶段——Apple、Microsoft（Phi 系列）、HuggingFace 都在预训练中引入了大量合成数据来改善数据质量，这在两年前是不可想象的。DCLM、FineWeb 等高质量预训练数据集的实证进一步表明：连”数据筛选”本身都可以用合成数据（训练分类器）来驱动，合成数据的边界已经从”造数据”扩展到”治理数据”。

更进一步的反例：合成数据还能改变”阶段的划分”

上面那张表默认了一个前提：预训练 / 中训练 / SFT / RL 这四个阶段是固定的容器，合成数据只是倒进每个容器的配料，话题只是”倒多少”。SYNTH（arXiv:2609.37891，PleIAs，NeurIPS 2026）给出了这个前提的反例。

SYNTH 是首个开源的全合成语料：从 58,698 篇维基百科条目（外加法律、医学等 8,698 篇专业条目与 Wikibooks）出发，经”结构化放大”（structured amplification）生成约 80B token、8 种语言的语料，并把 pre- / mid- / post-training 压成单一训练阶段——没有独立的 SFT，也没有 RLHF。指令遵循、答案格式、推理痕迹被直接写进”预训练”语料里，训出来的模型从随机初始化开始就能遵循指令。

换句话说：合成数据不只是每阶段的配料，它还能改变阶段划分本身。这是上一句”边界已从造数据扩展到治理数据”的再进一步——扩展到定义训练流程。对本章读者的实际含义是：做配比与阶段设计时，“这个能力该放在哪个阶段教”不再是一个只能从既有范式中选的答案，它本身也成了可设计的变量。

⚠️ 别把它读成”SFT 已死”：SYNTH 证明的是阶段划分可被消解，不是消解之后必然更好。代价见 24.6 新增的”知道边界”与 24.10 新增的极端点两节——它换来的是 token 效率，付出去的是覆盖范围与校准。

---

24.2 行业现状：2026 年的合成数据版图

在展开三段式体系之前，先建立对行业现状的坐标系。以下基于 2026 年公开的行业研究与报告，谨慎陈述。

锚点一：合成数据已成后训练数据的主体

Stanford HAI 发布的 AI Index 2026 报告指出：在主流大模型的后训练数据中，合成数据的占比已超过 55%，在数学、代码、垂直领域（法律、医疗、金融）等对专业知识密度要求高的场景，这一比例甚至超过 80%。这意味着：

• “要不要用合成数据”已不再是问题，问题变成”如何在合成占多数的数据混合中维持质量与安全”；
• 后训练阶段的 RL/偏好数据几乎完全依赖模型自生成 + 验证的闭环（拒绝采样、自博弈），天然是 100% 合成；
• 垂直领域的 80%+ 占比说明：当真实专业数据稀缺且昂贵时，合成是唯一可规模化的路径——数据稀缺性越强，合成占比越高。

锚点二：质量评估走向标准化

IEEE 在 2026 年推动了合成数据质量评估与溯源的标准方向，核心聚焦三个可度量维度：语义保真度（semantic fidelity，合成数据与目标语义空间的一致程度）、多样性（diversity，分布覆盖度与长尾保留）、偏差可审计性（bias auditability，可追溯、可量化、可复现的偏差记录）。这与本章第二篇”验证”中提出的度量框架高度一致——行业正从”各家自定 rubric”走向统一度量衡。标准的意义不在于规定阈值，而在于让不同团队的合成管线之间可以横向比较，让”高质量合成数据”成为一个可审计的声明而非营销话术。

标准化的一个可运行实例，以及它测出的第一个结果是个反例（2026）。上段说的”统一度量衡”，在 2026 年有了具体落地——DataPrep-Bench（北大 OpenDCAI 联合港中文、浙大、上海算法创新研究院）。它把数据准备拆成三条赛道（数据构建 / 数据选择 / 数据质量评估），关键在于统一实验协议：固定原始素材、底座模型、训练参数与下游 benchmark，所有造数方法在同条件下以真实训练增益计分，而不是以”数据看起来工整不工整”计分。这正是”让高质量合成数据成为可审计的声明”这句话的工程含义。

⚠️ 而它在统一协议下测出的头一个结果，是一个反例：多个 LLM / Agent / 工作流生成的合成数据，下游得分低于「只用 Dolly-15k」的纯基线。也就是说，“AI 生成的工整数据一定能提升模型”这个假设，在有对照的实验面前没有站住。

对本章的意义是双重的：其一，风险不只出现在多代递归训练中——单轮合成数据也可能直接是负收益；其二，既然合成不保证正向，那么”生成 → 验证”之间的验证环节就不是可选的质量装饰，而是决定这一批合成值不值得用的闸门。合成数据进入训练集之前，应有一道低成本的价值预判（见 ch29 §29.5.1b 的 DAS），而不是默认”合成了就该用”。

锚点三：数据墙倒计时

Epoch AI 对公共高质量文本数据耗尽时间的中位预测为 2028 年（区间 2026-2032 年）。换言之，公共互联网上可用的、经过去重与质量过滤的高质量文本，将在未来两到六年内被主流训练管线”用尽”。这为合成数据提供了最硬核的必要性论证：

• 数据墙之前，合成数据是”提质”工具（Phi 路线：用更少但更好的 token 训练更强的小模型）；
• 数据墙之后，合成数据是”扩量”工具（在真实数据边际枯竭时维持 scaling 的唯一出路）；
• 两条曲线的交汇点就在 2026-2028 年——这正是”生成-验证-进化”体系在此时成型的深层原因：当合成从可选项变成必选项，工程体系的严谨性就成了生死线。

锚点四：合成分类器优于规则过滤

DCLM（Data Comp for Language Models）与 FineWeb 等高质量预训练数据集的实证给出了一个关键证据：用高质量种子数据训练的合成分类器（neural classifier-based filtering），在数据筛选上系统性优于人工设计的规则过滤（heuristic rule-based filtering）。其机制是：

规则过滤（传统）：
  人工设计启发式（文档长度、符号比例、停用词频率……）
  → 规则是"平均正确"，对边界样本误杀/漏放严重
  → 无法适应领域差异

合成分类器过滤（新一代）：
  少量人工标注的高质量种子（如 DCLM 用教科书级页面）
  → 微调一个小型分类器（如 fasttext / 小型 BERT）
  → 分类器学习"质量的隐式表征"，而非表面规则
  → 在 DCLM 实验中，分类器筛选的数据训练出的模型
    显著优于规则筛选的数据

这一实证的影响是深远的：它把合成数据从”训练语料”扩展到了”数据治理工具”——你不仅可以用模型生成数据，还可以用模型（经由合成种子训练的分类器）来筛选数据。生成与验证的边界开始交融：最好的验证器，本身就是合成方法的产物。

锚点五：野生合成数据——不受你验证器管辖的那一类

前四个锚点讲的都是”你主动造的合成数据”：有种子、有生成配置、有验证记录、有溯源链。但真实预训练池里还有第二类，性质完全不同。

Pangram Labs 与马里兰大学的研究（arXiv:2609.40295，How Much Is an AI Token Worth?）给出第一个可引用的量级：在经 FineWeb 质量过滤后的网页抓取中，被标为 AI 生成的 token 占比从 2026 年 6 月的 27.5% 升到 8 月的 31.1%。作者称之为 wild AI text，并点明它与本书讨论的两种设定都不同——它来自许多不同的模型、是写给人类读者看的、而且进入预训练语料时不带任何标签。

⚠️ 口径限定：31.1% 是”经过 FineWeb 质量过滤的那部分网页抓取”中的占比，不是全网 AI 文本占比，也不是某个具体语料库的实测值。不同抓取与不同过滤器的结果会有明显差异，引用时必须带上这个限定。

作者训练了 800 个语言模型（系统改变 AI token 与人类 token 的配比）来量化代价，结论比”好”或”坏”都更有结构：

• 数据饥饿的模型：加 AI token 起初确实能降低人类文本上的 loss，但收益会饱和，并且很快反转为损害——论文 Figure 1 给出的反转点约在 AI 占比 0.08（8%）处（终审补注：0.08 是在人类预算 ≥ 20 tokens/parameter 那一档读到的，5 TPP 那一档一个 AI token 的价值仍为正；因此它是”不那么饥饿”时的门槛，不是普适常数）。
• 人类文本预算充足的模型：AI token 几乎立刻抬高 loss，而同样数量的新鲜人类 token 仍在持续降低 loss。
• 算力代价：在 20 tokens/parameter 的标准下，用 2026 年 8 月的未过滤网页训练，达到”其人类子集”同等性能需要 1.6× 算力；按作者对 AI 占比的预测，这个倍数在 2027 年底（42%）升到 2.1×、2028 年底（51%）升到 3.0×。
• 作者的推荐：当目标是人类文本时过滤掉 AI 文本；在扩充数据集之前，先重复人类文本比加 AI 文本更划算。

方法层面也有一条对本章有用的方法论：作者提出一个把 AI 文本的收益项与损害项分开估计的新缩放律（可退化为 Chinchilla），允许”一个 AI token 的价值改变符号”；在小模型上拟合后，可预测最大 3.6× 规模模型的表现，误差比现有最优律低 41%。配套开源 Wild AI（83B token / 96M 文档，带 AI、主题、格式标签）与全部 800 个模型。

三条工程含义：

1. 本章 24.5–24.9 的整套”生成-验证-进化”机制，对这一类数据完全不适用——它没有种子溯源、没有生成配置、没有验证记录，审计链在第一环就断了。能用的只有”事后检测 + 过滤”（锚点四那一类分类器）。
2. 它就是 24.9 递归坍缩的现实入口：别人家多代递归的产物，会以无标签的形式直接进你的预训练池。24.9 讨论的是”你自己递归训练会不会坍缩”，锚点五说的是”别人的递归产物已经在你的池子里了”。
3. 锚点三的数据墙倒计时因此多了一个压力源：不只是”真实数据不够用”，还包括”爬进来的数据里三成是别人生成的”。这两件事叠加，才构成 2026-2028 年合成数据治理的真实紧迫性。

⚠️ 监测上还要防一个坑：该研究指出，混合验证集会在 95.5% 的有害运行中掩盖损害——即把人类文本与 AI 文本混在一起算 held-out loss 时，AI 文本的危害几乎看不出来。做野生 AI 文本监测时，验证集必须按来源分层分别报，否则你会得出”加了没什么影响”的错误结论。

---

第一篇 生成（Generation）

24.3 合成方法谱系

四大生成范式

不同的合成方法产出的数据质量、多样性和成本差异巨大。按照”数据从哪里来”可以把生成方法分为四大范式：

范式 1：基于改写（Rephrasing）

输入: 一篇维基百科原文
   ↓ Prompt: "请将这段文字改写为教科书风格，适合大学生阅读"
输出: 同一内容的教科书版本

特点：信息保真度高，但多样性受限于原文
成本：~$0.5/1M tokens（使用 API）
典型应用：Phi-1/2/3 的预训练数据

改写范式的本质是分布迁移：内容不变，表达形式迁移到目标风格。它是最安全（有原文锚定，幻觉风险低）但也最受限（信息上限就是原文）的范式。当目标是”把网络上的优质内容变成教学级语料”时，改写是首选。

范式 2：基于种子扩展（Seed-based Generation）

输入: 一个知识种子（如 "微积分基本定理"）
   ↓ Prompt: "以此为主题，写一个包含例题和解析的教学章节"
输出: 一个完整的教学内容

特点：内容丰富度高，但需要验证准确性
成本：~$2/1M tokens
典型应用：中训练知识增强

种子扩展的本质是知识放大：从一个知识点出发，生成远超种子本身信息量的内容。代价是准确性不再有原文锚定——模型可能编造定理的条件、捏造例题的数值。这决定了种子扩展必须配合强验证（见第二篇）。

范式 3：基于进化（Evolution-based）

输入: 一条简单指令 "写一首诗"
   ↓ Evol-Instruct: 增加约束、深化、具体化、增加推理步骤
第1代: "写一首关于春天的诗"
第2代: "写一首关于春天的七言绝句，要求包含'燕'字"
第3代: "以王维的风格写一首关于春天的七言绝句，要求首联含'燕'，尾联含'柳'..."

特点：多样性好，但可能偏离实际用户需求分布
成本：~$5/1M tokens（多轮生成）
典型应用：WizardLM 的 SFT 数据

进化范式的本质是分布探索：沿着”增加约束、增加深度、增加复杂度”的方向系统性地探索指令空间。它天然内嵌了”迭代”属性，是第三篇”进化”的生成端起点。

范式 4：基于概念图重组（Concept-graph Recombination）

这是 SynthLLM（COLM 2025, Microsoft）提出的新范式。它不从单个文档出发，而是从多个文档中提取高层概念，用图算法发现概念间的新连接，然后生成包含这些新连接的文本。

输入: 一组文档（如 50 篇关于分布式系统的论文）
   ↓ 概念提取: 从每篇论文中抽取核心概念节点
   ↓ 图构建: 建立概念间的关系图（因果、包含、对比等）
   ↓ 新路径发现: 图算法找到原始文档中不存在的概念连接
   ↓ 文本生成: 围绕这些新连接生成合成文本

特点：多样性极好——新概念组合产生真正新颖的内容
与改写的区别：改写保留原文信息，概念重组创造新知识组合
与种子扩展的区别：种子扩展围绕单一知识点，概念重组跨文档交叉
成本：~$8/1M tokens（多阶段处理）
典型应用：预训练数据增强（尤其是需要跨域推理能力时）

概念图重组目前仍属于前沿探索（COLM 2025 发表，尚未被广泛采用），但它提供了一个重要的思路：合成数据不一定要模仿原始分布，也可以创造原始数据中不存在的知识组合。

四大范式的工程选型可以总结为一张决策表：

范式	信息来源	保真度	多样性	验证强度需求	成本	适用阶段
改写	原文（强锚定）	高	低	弱	$	预训练
种子扩展	种子（弱锚定）	中	中	强	$$	中训练/SFT
进化	前代指令（迭代锚定）	中	高	中	$$$	SFT
概念图重组	概念图（结构锚定）	中	极高	强	$$$$	预训练增强

一个值得注意的规律：锚定越弱，多样性越好，但验证需求越强。这就是生成与验证的守恒律——生成端省下的约束，必须由验证端的机制补回来。

指令合成谱系：Self-Instruct → Evol-Instruct → Magpie

在 SFT 数据合成领域，三个里程碑工作构成了一条清晰的演化谱系。理解这条谱系，就理解了”生成”如何一步步走向自主。

第一代：Self-Instruct（Stanford, 2022）——从种子自举指令

核心循环：
1. 维护一个种子指令池（最初仅 175 条人工指令）
2. 采样 6 条已有指令作为 few-shot 示例
3. 让 LLM 生成新指令（或判定新指令属于哪个任务类型）
4. 过滤：与已有指令 ROUGE-L 相似度过高的丢弃
5. 对每个新指令，让 LLM 生成对应输出
6. 生成的 (指令, 输出) 对入池，回到第 2 步

结果：从 175 条种子自举出 52K 指令数据
      训练出的 Alpaca 以极低成本逼近原始 InstructGPT

Self-Instruct 的历史意义在于证明了指令数据可以自举——模型自己给自己出题。它的局限同样明显：生成的指令分布高度依赖种子池，且”泛化指令”居多（如”写一封邮件”），复杂推理类指令占比很低。

第二代：Evol-Instruct（WizardLM, 2023）——指令的定向进化

Evol-Instruct 把生物进化的思路引入指令生成：不满足于随机变异（Self-Instruct 的新指令生成近似随机采样），而是定向地增加指令的深度与广度：

进化算子（in-depth evolving）：
  add_constraints   增加约束条件
  deepen            要求更深入的分析
  concretize        抽象 → 具体
  add_reasoning     增加推理步骤
  complicate        增加任务复杂度

进化算子（in-breadth evolving）：
  broaden           扩展到新话题/新领域（维持难度）

退化处理：
  进化后指令无效（太长/不可回答/语义漂移）→ 淘汰
  → "进化淘汰"本身就是一种验证

Evol-Instruct 的关键洞察：复杂度是可以被工程化制造的。WizardLM 用这种方法把简单指令逐步升级为多约束、多步骤的复杂指令，在复杂任务上显著超过了 Self-Instruct。它同时也是”生成-验证-进化”体系的微缩标本：进化算子是生成，淘汰无效指令是验证，代际迭代是进化。

第三代：Magpie（2024）——去掉人工种子，模型自我对齐

Magpie 提出了一个更彻底的问题：能否完全不用人工种子指令，让对齐后的模型自己产出高质量的指令-回复对？

Magpie 核心机制：
1. 在模型回复的开头预填一个用户 query 占位 token（或空 query prompt）
2. 让对齐模型"倒推"生成一个合理的用户问题
   （模型在对齐训练中见过大量 Q-A 对，具备逆向生成能力）
3. 把生成出的问题作为真实输入，让同一个模型正面回答
4. 轻量过滤（质量、相关性、去重）后直接作为 SFT 数据

结果要点：
  - Llama-3-8B 用 Magpie 数据微调后，
    对齐能力可匹敌官方 Llama-3-8B-Instruct 的官方 SFT 数据
  - 数据多样性、指令复杂度、任务覆盖面均优于
    Self-Instruct / Evol-Instruct / Alpaca 系数据集
  - 全程无需人工种子，也无需 GPT-4 等更强模型蒸馏

Magpie 的意义在于把”生成”推向了自举的极限：对齐模型本身就是指令分布的采样器。它生成的不是”模型认为人类可能问的问题”（Self-Instruct），也不是”从种子变异出的问题”（Evol-Instruct），而是模型内部指令表征的直接投影——分布上更接近模型”擅长什么”，从而在同样数据量下训练效果更好。当然，这也带来一个体系性风险：Magpie 数据的天花板就是生成模型自身的能力，若用于多代递归训练，分布退化会更快——这再次说明生成端的自举必须与验证端联动。

谱系小结：

维度	Self-Instruct	Evol-Instruct	Magpie
种子依赖	175 条人工种子	少量种子 + 进化	零人工种子
复杂度来源	随机采样	定向进化算子	对齐模型内在分布
多样性	受种子池限制	好	最好（内在分布投影）
验证机制	ROUGE-L 去重	进化淘汰	质量过滤 + 去重
成本	低	中	极低（单模型单轮）
典型产物	Alpaca 52K	WizardLM 数据	Magpie-Pro 系列

种子策略：生成质量的起点决定权

无论哪种范式，种子（seed）都决定了合成数据的分布上界。生产级管线中的种子策略包括：

1. 种子覆盖率设计。 Phi-3 的合成种子覆盖超过 20 个知识领域和超过 50 种题目类型。覆盖率不足的种子池会导致合成数据呈现”局部过密、大片空白”的分布——模型在这些空白区域的能力不会因数据量增加而提升。实操上，建议用一个人工维护的”知识领域 × 任务类型 × 难度等级”三维矩阵来规划种子配额，每个格子至少保证若干种子，而不是任由高频领域挤占低频领域。

2. 种子质量分级。 并非所有种子等价。生产管线通常把种子分为三级：

A级种子：来源权威（教科书、论文、官方文档）、事实可核验
  → 用于高保真合成（改写、种子扩展），产出的数据可直接进入候选池
B级种子：来源一般（博客、论坛精选）、信息密度尚可
  → 必须配合强验证（事实核查、交叉验证）才能使用
C级种子：来源不明或低质
  → 仅用于多样性探索（如概念图重组的原始语料），产出数据
    需经完整四层质量控制（见 24.6）

3. 种子的多样性与代表性审计。 种子池本身也需要度量：领域分布是否均衡？语言/方言覆盖如何？难度梯度是否连续？一个常见的失败模式是：种子池被某个高频领域（如通用编程问答）主导，导致合成数据 80% 集中在同一领域，表面上数据量翻倍，实际分布熵几乎没变。审计方法与合成数据的多样性度量相同（见 24.6），只是作用对象换成了种子。

4. 种子的溯源记录。 每个种子保留来源、许可状态、抽取时间与置信度。这不仅是合规要求（版权灰区问题见 24.11），也是进化环节的前提——当某类合成数据在下游任务上表现不佳时，需要回溯到种子层面诊断是”种子覆盖不足”还是”生成端失真”。

多样性控制：生成端的核心旋钮

多样性是合成数据的生命线（多样性与坍缩的关系见 24.9）。生成端可用的多样性控制手段，按作用层次分为四类：

采样层控制：

温度阶梯（temperature ladder）：
  对同一种子生成 n 个变体时，温度逐级升高
  t₀=0.7（保守）→ t₁=0.8 → t₂=0.9（激进）
  → 变体间的差异随温度差扩大

top-p / top-k 联动：
  高温度 + 高 top-p：探索性变体（可能失败，需验证兜底）
  高温度 + 低 top-p：局部多样（在高质量区域内部变异）

Prompt 层控制： 变体提示（variant hint）显式要求”尝试不同的表达方式和角度”、“换一种论证结构”、“面向不同受众”。实践证明，显式的角度指令比单纯提高温度能产生更有意义的多样性——温度带来的是词级抖动，角度指令带来的是篇章级结构差异。

策略层控制： 同一批种子混合使用多种合成策略（改写 + 扩展 + 进化），不同策略的输出分布天然不同，混合后比单一策略批量生成多样性显著更高。这也是 24.4 通用管线把 strategy 作为一等参数的原因。

分布层控制（主动探索）： 第二代合成数据的标志——不停留在”被动采样”，而是检测 embedding 空间中的低密度区域（覆盖空白），定向生成填补空白的数据。这把多样性控制从”事后检查”升级为”事前规划”，是生成端对进化环节的接口。

---

24.4 生成管线工程

通用合成管线架构

一个生产级合成数据管线需要以下组件：

"""
合成数据管线框架
支持多种合成策略、质量过滤、多样性控制
"""
import json
import hashlib
from dataclasses import dataclass, field
from collections import Counter
from typing import Callable

@dataclass
class SyntheticSample:
    """合成数据样本"""
    content: str
    source_type: str          # "rephrased" | "seed_expanded" | "evolved" | "translated"
    seed_id: str              # 种子数据 ID（用于溯源）
    generator_model: str      # 生成模型名称
    generation_config: dict   # 生成参数（温度、top_p 等）
    quality_scores: dict = field(default_factory=dict)
    metadata: dict = field(default_factory=dict)

class SyntheticDataPipeline:
    """合成数据管线"""

    def __init__(self, generator_fn: Callable, quality_scorer_fn: Callable):
        self.generator = generator_fn
        self.quality_scorer = quality_scorer_fn
        self.generated_hashes = set()  # 用于去重

    def generate_batch(
        self,
        seeds: list[dict],
        strategy: str = "rephrase",
        n_variants: int = 3,
        temperature: float = 0.7,
        min_quality: float = 0.6,
    ) -> list[SyntheticSample]:
        """
        从种子数据批量生成合成样本

        Args:
            seeds: 种子数据列表，每个包含 content 和 id
            strategy: 合成策略
            n_variants: 每个种子生成的变体数
            temperature: 生成温度（越高越多样）
            min_quality: 最低质量分数阈值
        """
        results = []
        prompt_template = self._get_prompt_template(strategy)

        for seed in seeds:
            for i in range(n_variants):
                # 生成
                prompt = prompt_template.format(
                    content=seed["content"],
                    variant_hint=f"变体 {i+1}，尝试不同的表达方式和角度"
                )
                output = self.generator(
                    prompt,
                    temperature=temperature + i * 0.1,  # 逐渐增加温度提高多样性
                    max_tokens=2048,
                )

                # 去重检查
                content_hash = hashlib.md5(output.encode()).hexdigest()
                if content_hash in self.generated_hashes:
                    continue
                self.generated_hashes.add(content_hash)

                # 质量评估
                scores = self.quality_scorer(output, seed["content"])

                sample = SyntheticSample(
                    content=output,
                    source_type=strategy,
                    seed_id=seed["id"],
                    generator_model="llm-api",
                    generation_config={"temperature": temperature + i * 0.1},
                    quality_scores=scores,
                )

                # 质量过滤
                if scores.get("overall", 0) >= min_quality:
                    results.append(sample)

        return results

    def _get_prompt_template(self, strategy: str) -> str:
        templates = {
            "rephrase": (
                "请将以下内容改写为清晰易懂的教科书风格。保留所有关键信息，"
                "但改善表达的清晰度和教学效果。{variant_hint}\n\n"
                "原文：\n{content}\n\n改写版："
            ),
            "expand": (
                "基于以下知识点，撰写一段详细的教学内容。包含：\n"
                "1. 概念解释 2. 具体例子 3. 常见误区 4. 总结\n"
                "{variant_hint}\n\n知识点：\n{content}\n\n教学内容："
            ),
            "translate_style": (
                "将以下技术内容转换为面向初学者的通俗解释。"
                "使用类比和日常生活中的例子。{variant_hint}\n\n"
                "原文：\n{content}\n\n通俗版："
            ),
        }
        return templates.get(strategy, templates["rephrase"])

    def diversity_check(self, samples: list[SyntheticSample]) -> dict:
        """检查一批合成数据的多样性"""
        # 1. N-gram 多样性
        all_trigrams = []
        for s in samples:
            words = s.content.split()
            trigrams = [tuple(words[i:i+3]) for i in range(len(words)-2)]
            all_trigrams.extend(trigrams)

        unique_ratio = len(set(all_trigrams)) / max(len(all_trigrams), 1)

        # 2. 开头多样性（检测模式坍缩的早期信号）
        openings = [s.content[:50] for s in samples]
        unique_openings = len(set(openings)) / max(len(openings), 1)

        # 3. 长度分布
        lengths = [len(s.content) for s in samples]
        length_std = (sum((l - sum(lengths)/len(lengths))**2 for l in lengths) / len(lengths)) ** 0.5

        return {
            "trigram_unique_ratio": round(unique_ratio, 4),
            "opening_unique_ratio": round(unique_openings, 4),
            "length_mean": round(sum(lengths) / len(lengths), 1),
            "length_std": round(length_std, 1),
            "sample_count": len(samples),
            "health": "good" if unique_ratio > 0.7 and unique_openings > 0.8 else "warning",
        }

这个框架里有几个值得注意的工程设计：

• SyntheticSample 携带完整溯源：seed_id、generator_model、generation_config、quality_scores 全部内嵌在样本结构里。这是进化环节的基础设施——没有溯源，就无法做”按策略/按模型/按种子分组分析下游表现”的归因。
• 生成即去重：用内容哈希在生成现场去重，而不是事后批量去重，可避免同一批次的算力浪费。
• 生成与验证内联：quality_scorer 在生成循环内部调用，低于阈值的样本当场丢弃。这已经带有”生成中内嵌验证”的第二代特征（见 24.8）。

预训练阶段：教科书化改写

Phi 系列的核心洞察是：数据质量比数据量更重要。通过将网络文本改写为教科书风格，可以在更少的 token 上训练出更强的模型。

"""
预训练合成数据：教科书化改写管线
参考 Phi-1 "Textbooks Are All You Need" 的方法
"""

TEXTBOOK_PROMPT = """你是一位优秀的大学教授。请将以下网络文本改写为高质量的教科书段落。

要求：
1. 保留所有核心知识点和技术细节
2. 使用清晰的结构：概念定义 → 原理解释 → 示例 → 总结
3. 去除广告、个人观点、口语化表达
4. 如果原文包含代码，保留并添加注释
5. 对于不确定的事实，标注"需要验证"

原始文本：
{raw_text}

教科书版本："""

# 质量过滤：教科书化内容的评估维度
QUALITY_RUBRIC = {
    "coherence": "内容是否逻辑连贯、结构清晰",
    "informativeness": "信息密度是否足够（避免废话）",
    "accuracy": "改写是否保留了原文的关键事实",
    "educational_value": "是否适合作为学习材料",
    "fluency": "语言是否流畅自然（非机器翻译腔）",
}

教科书化改写的验证要点是信息保真度：改写版本的每个关键事实必须能追溯到原文。prompt 中的第 5 条（“对于不确定的事实，标注’需要验证’“）是一个低成本但高效的技巧——它把生成模型的”不确定感”显式化，为验证层提供了锚点。

SFT 阶段：Self-Instruct + Evol-Instruct

"""
SFT 合成数据：指令进化管线
结合 Self-Instruct (Stanford) + Evol-Instruct (WizardLM)
"""

# 阶段 1：从种子指令生成新指令（Self-Instruct）
SELF_INSTRUCT_PROMPT = """以下是一些高质量的指令示例：
{seed_instructions}

请生成 5 条新的、不同类别的指令。
要求：
- 涵盖不同的任务类型（问答/分析/创作/代码/推理）
- 避免与示例相似
- 指令应该清晰、可执行
- 难度适中

新指令："""

# 阶段 2：指令进化（Evol-Instruct）
EVOLUTION_STRATEGIES = {
    "add_constraints": "在原指令基础上增加 2-3 个约束条件",
    "deepen": "要求更深入的分析或更详细的解释",
    "concretize": "将抽象指令具体化到某个领域或场景",
    "add_reasoning": "要求展示推理过程，而不仅仅是最终答案",
    "complicate": "增加任务复杂度，如多步骤推理、条件分支",
    "broaden": "扩大任务范围，要求综合多个知识领域",
}

def evolve_instruction(instruction: str, strategy: str, model_fn) -> str:
    """单步指令进化"""
    prompt = (
        f"请对以下指令进行'{EVOLUTION_STRATEGIES[strategy]}'的变换。\n"
        f"保持核心意图不变，但提高复杂度和挑战性。\n\n"
        f"原始指令：{instruction}\n\n进化后的指令："
    )
    return model_fn(prompt, temperature=0.7)

def multi_step_evolution(
    seed_instruction: str,
    model_fn,
    n_generations: int = 3,
) -> list[str]:
    """多步进化，生成一系列难度递增的指令"""
    chain = [seed_instruction]
    strategies = ["add_constraints", "deepen", "complicate"]

    for i in range(min(n_generations, len(strategies))):
        evolved = evolve_instruction(chain[-1], strategies[i], model_fn)
        chain.append(evolved)

    return chain

注意 multi_step_evolution 返回的是整条进化链而不是只返回最终代——链上每一代都是有价值的训练数据，它们天然构成一个难度课程（curriculum），从易到难连续覆盖。这是”生成”环节为”进化”环节预留的另一个接口：难度梯度数据是课程学习与自提升闭环的原料。

RL 阶段：拒绝采样 + 自验证

"""
RL 合成数据：On-policy 拒绝采样
DeepSeek-R1 风格的自我生成 + 验证
"""

def rejection_sampling_for_math(
    problems: list[dict],
    policy_model_fn,
    n_samples: int = 64,
    temperature: float = 0.8,
) -> list[dict]:
    """
    拒绝采样生成数学 RL 训练数据

    对每个问题:
    1. 用 policy model 采样 N 个解
    2. 通过答案验证筛选正确解
    3. 保留正确解作为正样本，错误解作为负样本
    """
    rl_data = []

    for problem in problems:
        prompt = f"Problem: {problem['question']}\n\nSolve step by step:"
        solutions = []

        for _ in range(n_samples):
            response = policy_model_fn(prompt, temperature=temperature)
            answer = extract_final_answer(response)
            is_correct = (answer == problem["ground_truth"])
            solutions.append({
                "response": response,
                "answer": answer,
                "correct": is_correct,
            })

        correct_solutions = [s for s in solutions if s["correct"]]
        incorrect_solutions = [s for s in solutions if not s["correct"]]

        if correct_solutions and incorrect_solutions:
            # 选择最短的正确解（通常推理更清晰）和最长的错误解
            best_positive = min(correct_solutions, key=lambda x: len(x["response"]))
            hard_negative = max(incorrect_solutions, key=lambda x: len(x["response"]))

            rl_data.append({
                "prompt": prompt,
                "chosen": best_positive["response"],
                "rejected": hard_negative["response"],
                "pass_rate": len(correct_solutions) / n_samples,
                "difficulty": "hard" if len(correct_solutions) / n_samples < 0.3 else "medium",
            })

    return rl_data

def extract_final_answer(text: str) -> str:
    """从推理文本中提取最终答案"""
    import re
    match = re.search(r'\\boxed\{(.+?)\}', text)
    if match:
        return match.group(1).strip()
    numbers = re.findall(r'-?\d+\.?\d*', text)
    return numbers[-1] if numbers else ""

拒绝采样是”生成-验证”一体化最纯粹的示范：生成与验证在同一个循环里完成，pass_rate（通过率）同时是难度标签和数据可用性判据。通过率过低（如 < 5%）的题目说明模型完全不会，训练价值有限；通过率过高（如 > 95%）的题目说明模型已经掌握，边际收益趋零——最有效的训练数据集中在中等通过率区间。这种”用验证信号反过来筛选生成目标”的模式，正是数据飞轮（见 24.8）的最小可行版本。

---

第二篇 验证（Verification）

24.5 验证为什么是体系的枢纽

从”混入真实数据”到”验证机制”：防线升级

早期的防坍缩共识是”100% 合成数据必然坍缩，混入真实数据是必须的”。这个结论在 2025 年被显著修正。

ICLR 2025 论文（Beyond Model Collapse: Scaling Up with Synthesized Data Requires Verification）正式证明：验证（verification）才是防止合成数据坍缩的核心机制，而非真实数据的混入比例。 关键结论：

• 有验证的合成数据可以安全扩展到很高比例——甚至接近 100%，前提是每条合成数据都经过独立验证
• 验证可以是形式化的（代码测试、数学证明检查器）或半形式化的（多模型交叉验证）
• 无验证的合成数据在任何比例下都有坍缩风险——即使混入大量真实数据，只要递归代数足够多

⚠️ 这条结论只成立一半：验证防住了坍缩，但把收敛终点交给了验证器（arXiv:2510.16657，ICLR 2026）。

上面那三条讲的是”验证阻止了发散式退化”。ICLR 2026 的后续工作把同一套”生成—验证—重训”递归环做了偏差—方差分解，给出被本章此前遗漏的另外半句：

1. 短期：验证器是方差削减资源——即使它略有偏差，注入的信息也能压过合成噪声，带来立竿见影的提升。实验上，不加验证器的 VAE 在 40 轮内就崩成不可辨认的噪声；加了强验证器后 FID 回到 21.17，接近全量 60K 真实图训练出的 CVAE 基线 17.56。
2. 长期：参数估计必然收敛到验证器的知识中心 θc，而不是真实分布 θ*（Theorem 4.1）。模型不是”变好”，而是”变得和验证器想的一样”——这不是崩坏，是稳定地错成验证器的样子。
3. 选择性不改终点：把验证器调得更挑剔，只让收敛更快，不改变终点。
4. 平台与反转：除非验证器完全无偏，早期收益终将平台化，甚至反转。

对本书两处写法的修正：

• 第 24.10 节”最优合成比例基本是验证器强度的单调函数”应理解为同时受验证器强度与验证器偏差约束——一个很强但有偏的验证器，会把模型稳稳地拖到它自己的知识中心。
• 24.8 列出的飞轮停转信号”验证通过率虚高但下游表现停滞（验证器被钻空子）“，此前只有现象没有机制，这条长期收敛结论正是它的机制解释。

工程落点：周期性用真实数据或人工抽检重新校准验证器。验证器的偏差不会以”崩溃”的形式报警，它会静默地成为模型的事实标准。

真实数据的作用被本节写小了。“验证是核心机制，而非真实数据的混入比例”说的是主因，不是排除。PRL 上的一项研究（Lost in Retraining: Closed-Loop Learning and Model Collapse in Exponential Families，DOI 10.1103/156q-3ngc）从指数族分布的解析角度给出另一半图景：完全依赖合成数据的封闭循环下坍缩几乎不可避免，但只需引入极少量外部真实数据——哪怕远少于 AI 生成数据，甚至生成数据无限增加——就足以阻止性能持续退化。

两个结论属于不同层面，不构成冲突：验证决定”会不会崩”，真实数据决定”崩的底线在哪”。工程上不要把真实数据当”比例项”来调，而是当作每轮必保的最小剂量。

📌 适用边界：PRL 该研究的核心证明基于简化的统计模型，作者自述在复杂神经网络上的验证仍在进行中；ICLR 2026 那篇的三档实验分别为线性回归、MNIST 上的 VAE 与 SmolLM2-135M 微调，读者在百亿级模型上引用时应保留余量。

这改写了 Model Collapse 的叙事。新的认知框架是：

条件	坍缩风险	原因
无验证 + 多代递归	极高	每代的噪声累积无法修正
无验证 + 真实数据锚定	中	真实数据限制了偏移上界，但无法消除
有验证 + 合成为主	低	验证在每一步阻断噪声传播
有验证 + 真实数据锚定	最低	双重保障

回到 Phi-3 案例：它之所以成功，核心不是因为保留了 40% 真实数据（这只是安全冗余），而是因为单代生成 + 严格质量过滤本质上就是一种验证机制。

从体系视角看，这篇论文的真正贡献是把”验证”从质量保障环节提升为架构必需品：在”生成-验证-进化”三段中，验证是唯一能阻断噪声跨代传播的机制。生成端的多样性控制降低初始噪声，进化端的课程设计决定迭代方向，但只有验证端在每个环节上对每条数据做出”可入训练集/不可入”的二元裁决。没有验证的生成-进化闭环，就是一个噪声放大器。

验证器的三重身份

在体系里，验证器（verifier）同时扮演三个角色：

1. 守门人（gatekeeper）：逐条裁决数据能否进入训练集——这是最传统的角色；
2. 信号源（signal source）：验证结果（通过率、错误类型分布、分数分布）是进化环节最重要的反馈信号——拒绝采样中的 pass_rate 就是例子；
3. 数据本身（data）：验证过程本身可以产出训练数据——代码合成中”代码 + 测试用例”成对入集，验证器写出的测试既是筛选工具也是训练语料。

24.6 合成数据的质量度量

三个核心维度：语义保真度、多样性、偏差

与 IEEE 合成数据质量评估标准方向一致，合成数据的质量度量可以归纳为三个核心维度：

语义保真度（Semantic Fidelity）——合成数据在语义层面与目标知识空间的一致程度：

度量层次：
1. 事实保真：合成内容中的实体、数值、日期、因果关系
   是否与种子/外部知识库一致
   → 度量：与 ground truth 的实体级匹配率、
     开卷问答的答对率（用 RAG 检索权威来源核对）
2. 语义等价：改写类合成是否保留原文完整语义
   → 度量：embedding 余弦相似度（阈值通常 > 0.85）、
     NLI 蕴含率（原文 ⊨ 改写版 且 改写版 ⊨ 原文）
3. 逻辑一致：推理类合成的推理链是否无跳跃、无自相矛盾
   → 度量：逐步骤检验（LLM-as-judge 逐步骤审查）、
     形式化验证通过率（Lean/Isabelle 可检验的子集）

多样性（Diversity）——分布覆盖度与长尾保留：

度量层次：
1. 表层多样性：n-gram unique ratio、开头/结尾模式分布、长度分布
2. 语义多样性：embedding 空间的覆盖度（聚类数、平均类间距、
   低密度区域占比）、话题分布熵
3. 长尾保留：低频话题/低频表达在合成数据中的存留率
   → 这是 Model Collapse 最敏感的指标——长尾最先丢失

偏差可审计性（Bias Auditability）——偏差的可追溯、可量化、可复现：

度量层次：
1. 分布偏差：合成数据 vs 真实参考数据在敏感维度
   （地域、性别、语言、领域、难度）上的分布偏移
   → 度量：分维度统计检验（如卡方、JS 散度）
2. 生成偏差：生成模型的系统性倾向被放大的程度
   → 度量：同一种子多模型生成结果的横截面比较
3. 审计链完整性：每条合成数据能否回溯到
   种子 → 生成模型 → 生成配置 → 验证记录 的完整链路
   → 度量：溯源字段的完备率（生产级要求 100%）

三个维度之间存在张力：过度追求保真度（如全用低温改写）会压缩多样性；过度追求多样性（如高温 + 激进进化）会引入幻觉、拉低保真度。质量工程的本质不是把三个维度都推到极限，而是根据训练阶段的目标分布找到平衡点——预训练语料偏多样性，知识增强偏保真度，偏好数据偏可审计性（需要可复盘的偏好来源）。

事实保真的一个现成实现：从落地的段落反译

上面第 1 条”事实保真”给的是度量方法（怎么查），但没给生成端的实现（怎么造出本身就保真的数据）。SYNTH 给了一个可以直接抄的版本。

关键在于它不让学生模型自由回答。流程是：先给定一段可追溯的种子段落（grounded passage），由辅助模型从段落反推出问题与答案。答案是被种子段落约束出来的，因此模型记住的是被核验过的事实，而不是教师的幻觉。论文摘要里那句 “SYNTH is back-translated from grounded passages” 说的就是这件事，它也正是前文”把验证做进生成端”那一格的可运行版本——与上面”审计链完整性”（种子 → 生成模型 → 生成配置 → 验证记录）天然一致：反译把”种子”这一环从”输入”升级成了”约束”。

配套还有一个本章没写过的小技巧：SYNTH 用速记语法（→ 表蕴含、∴ 表结论、•/⃝ 分别标确定与不确定）代替自然语言的 CoT 来写推理痕迹。一举两得——推理痕迹的 token 成本被压下来，同时把”确定 / 不确定”做成了可训练的认知标记。

三维度之外还缺一格：知道自己不知道

上面三个维度量的是”生成得像不像、覆盖得全不全、追不追得回去”，但没有一个在量模型的弃权行为——它是否知道自己不知道。SYNTH 的实验给了一个可引用的刻度，且这个刻度很有说服力：

情形	Baguettotron-MoE（SYNTH 训练）	OLMoE-1B-7B-Instruct（网页训练，同激活规模）
种子内实体的弃权率	20%	—
种子外（留出）实体的弃权率	67%	7%
尝试作答时的精确率	82%（种子内）→ 62%（种子外）	81%（种子外）

读法：SYNTH 模型的弃权率随实体是否见过而大幅变化（20% → 67%），说明弃权行为确实在跟踪”模型知道什么”；而网页训练的对照模型在未见实体上只弃权 7%，把不知道的东西也照样答了——它的”精确率 81%“是在更少的实体上算出来的，可比性有限。论文自己的结论是：网页规模数据覆盖了更多实体，所以这个差异是预期的。

这一格该写进质量框架：建议把校准化的弃权（对分布外实体弃权率、弃权时的精确率变化）作为语义保真度的第四个度量层次。它与”事实保真”正交——事实保真量的是”答对多少”，弃权量的是”知道自己答不了多少”。一个在这两个指标上都好的模型，才谈得上可信。

⚠️ 别把 67% 读成优点：高弃权率是种子覆盖有限的直接后果（SYNTH 只有 58k 篇种子条目），不是设计目标。它的价值在于证明了”弃权率可作为知识边界的探针”，以及”不弃权的模型未必更 knowledgeable，可能只是更敢编”。

多维度评估框架

合成数据的质量评估不能只看单一指标，需要多维度交叉验证：

"""
合成数据质量评估框架
覆盖 5 个维度 × 4 层检查
"""

class SyntheticDataEvaluator:
    """合成数据多维度评估器"""

    def evaluate(self, synthetic_samples: list[str], real_samples: list[str] = None) -> dict:
        """
        全面评估一批合成数据的质量

        Args:
            synthetic_samples: 待评估的合成数据
            real_samples: 真实数据参考（用于分布比较）
        """
        results = {}

        # 维度 1: 内在质量
        results["intrinsic"] = self._intrinsic_quality(synthetic_samples)

        # 维度 2: 多样性
        results["diversity"] = self._diversity_metrics(synthetic_samples)

        # 维度 3: 与真实数据的分布一致性
        if real_samples:
            results["distributional"] = self._distributional_alignment(
                synthetic_samples, real_samples
            )

        # 维度 4: 可检测性（越难区分越好）
        if real_samples:
            results["detectability"] = self._detectability(
                synthetic_samples, real_samples
            )

        # 维度 5: 下游任务贡献（需要实际训练，这里给出估算方法）
        results["utility_proxy"] = self._utility_proxy(synthetic_samples)

        return results

    def _intrinsic_quality(self, samples: list[str]) -> dict:
        """内在质量检查"""
        issues = {"too_short": 0, "too_long": 0, "repetitive": 0, "encoding_error": 0}

        for s in samples:
            if len(s) < 100:
                issues["too_short"] += 1
            if len(s) > 50000:
                issues["too_long"] += 1
            # 重复检测：同一句话出现 3 次以上
            sentences = s.split("。")
            if len(sentences) != len(set(sentences)):
                issues["repetitive"] += 1
            try:
                s.encode('utf-8').decode('utf-8')
            except UnicodeError:
                issues["encoding_error"] += 1

        return {
            "total_samples": len(samples),
            "issues": issues,
            "pass_rate": 1 - sum(issues.values()) / (len(samples) * len(issues)),
        }

    def _diversity_metrics(self, samples: list[str]) -> dict:
        """多样性指标"""
        # Self-BLEU：越低越多样
        # 这里用简化版的 n-gram 多样性替代
        all_bigrams = []
        all_trigrams = []
        for s in samples:
            words = s.split()
            all_bigrams.extend(zip(words, words[1:]))
            all_trigrams.extend(zip(words, words[1:], words[2:]))

        return {
            "bigram_diversity": len(set(all_bigrams)) / max(len(all_bigrams), 1),
            "trigram_diversity": len(set(all_trigrams)) / max(len(all_trigrams), 1),
            "vocab_size": len(set(w for s in samples for w in s.split())),
            "avg_sample_length": sum(len(s) for s in samples) / len(samples),
        }

    def _distributional_alignment(
        self, synthetic: list[str], real: list[str]
    ) -> dict:
        """合成数据与真实数据的分布对齐度"""
        # 长度分布对比
        syn_lengths = sorted(len(s) for s in synthetic)
        real_lengths = sorted(len(s) for s in real)

        # 词频分布对比（简化版，完整版应使用 embedding 空间距离）
        syn_words = Counter(w for s in synthetic for w in s.split())
        real_words = Counter(w for s in real for w in s.split())

        # 共享词比例
        common_words = set(syn_words.keys()) & set(real_words.keys())
        vocab_overlap = len(common_words) / max(
            len(set(syn_words.keys()) | set(real_words.keys())), 1
        )

        return {
            "vocab_overlap": round(vocab_overlap, 4),
            "syn_avg_length": sum(syn_lengths) / len(syn_lengths),
            "real_avg_length": sum(real_lengths) / len(real_lengths),
            "length_ratio": (
                sum(syn_lengths) / len(syn_lengths)
            ) / max(sum(real_lengths) / len(real_lengths), 1),
        }

    def _detectability(self, synthetic: list[str], real: list[str]) -> dict:
        """可检测性评估（合成数据越难与真实数据区分越好）"""
        # 简化版：基于统计特征的可区分性
        syn_features = self._extract_features(synthetic)
        real_features = self._extract_features(real)

        # 特征差异越小，越难区分
        diffs = {
            k: abs(syn_features[k] - real_features[k])
            for k in syn_features if k in real_features
        }

        return {
            "feature_diffs": diffs,
            "avg_diff": sum(diffs.values()) / max(len(diffs), 1),
            "assessment": "hard_to_detect" if sum(diffs.values()) / max(len(diffs), 1) < 0.1
                         else "detectable",
        }

    def _extract_features(self, texts: list[str]) -> dict:
        words = [w for t in texts for w in t.split()]
        return {
            "avg_word_len": sum(len(w) for w in words) / max(len(words), 1),
            "punct_ratio": sum(1 for w in words if not w.isalnum()) / max(len(words), 1),
            "avg_sent_len": len(words) / max(sum(t.count("。") + t.count(".") for t in texts), 1),
        }

    def _utility_proxy(self, samples: list[str]) -> dict:
        """下游效用的代理指标"""
        # 信息密度：unique 内容词比例
        all_words = [w for s in samples for w in s.split()]
        stopwords = {"的", "了", "是", "在", "和", "有", "我", "他", "这", "那", "就", "也",
                     "the", "a", "an", "is", "are", "was", "in", "on", "at", "to", "of"}
        content_words = [w for w in all_words if w not in stopwords and len(w) > 1]
        info_density = len(set(content_words)) / max(len(content_words), 1)

        return {
            "info_density": round(info_density, 4),
            "content_word_ratio": round(len(content_words) / max(len(all_words), 1), 4),
        }

四层质量控制体系

生产级的验证体系是分层的——不同层级的成本、覆盖率和检错能力不同，层层递进：

第 1 层：格式与完整性检查（自动，100% 覆盖）
  ├── 文本完整性（无截断、无乱码）
  ├── 编码正确（UTF-8）
  ├── 长度合理（排除 < 50 字或 > 50000 字的异常样本）
  ├── 格式正确（JSON/Markdown 解析成功）
  └── 淘汰率：通常 5-10%

第 2 层：模型打分（自动，100% 覆盖）
  ├── 用独立的评分模型（非生成模型本身）评估
  ├── 维度：连贯性、信息量、准确性、教学价值
  ├── 使用 5 分制或 0-1 连续分数
  ├── 阈值：通常保留 top 60-80%
  └── 淘汰率：20-40%

第 3 层：多样性检查（自动，批次级）
  ├── N-gram 多样性（trigram unique ratio > 0.7）
  ├── Embedding 空间覆盖度（聚类分析）
  ├── 开头/结尾模式检测（防止模板化输出）
  ├── 与已有数据的去重（MinHash 近似去重）
  └── 作用：防止 Model Collapse 的早期信号

第 4 层：人工抽检（人工，1-5% 采样）
  ├── 深入检查事实性（特别是数字、日期、专有名词）
  ├── 逻辑一致性（推理链是否有跳跃）
  ├── 评估"AI 味"（是否过度使用特定句式）
  ├── 发现自动检测遗漏的系统性偏差
  └── 反馈用于改进 Prompt 和过滤策略

四层体系的关键设计思想是成本-召回的梯度配置：第 1 层每条数据的检查成本近乎为零，能拦截最粗暴的错误；第 4 层人工抽检成本最高，但只有人类能发现”系统性但隐蔽”的偏差（如所有合成法律文本都隐含大陆法系预设）。特别注意第 4 层的反馈流向——它不是终点，抽检发现的系统性问题要回流到生成端的 prompt 修正与验证端的过滤策略更新，这正是”验证 → 生成”的闭环。

第 2 层的上界：过滤与坍缩共用一个旋钮

上面第 2 层那句”保留 top 60-80%，淘汰率 20-40%“有一个本章此前没有写出的上限：过滤强度不能单调地往上调，因为过滤本身会加速坍缩。

两条 2026 年的证据指向同一件事。

其一，实证（AIES-26，DOI 10.1609/aies.v9i4.43319，Stevenson 等，南丹麦大学）。模型坍缩此前几乎没在表格数据合成中被研究过——而这恰恰是医疗、金融等高风险域做数据增强与隐私保护的主力场景。作者证明坍缩效应在该场景同样存在，并进一步给出：不同强度的样本级 curation（输出质量过滤）会诱发 mode dropping 与多样性损失——过滤越狠，模式掉得越多。作者据此讨论的是”审计的权衡”，而非”审计越多越好”。

其二，机制与理论（arXiv:2606.13732，When Sample Selection Bias Precipitates Model Collapse）。这条把上面的现象讲透了，并且给了理论证明：数据选择是否可靠，取决于验证器所用的参考分布。在低资源验证场景下——每个验证器只能看到目标流形的一个小、碎、有偏的切片——选择本身就变成了有偏的。这种情形在医疗联合体、金融机构这类数据无法汇总的孤岛里天然发生：每个机构拿自己的局部数据跑自己的验证器，结果就是选择算法优先保留贴合局部流形的样本，同时剪掉全局相关的尾部模式。作者证明这种孤岛式选择会加速坍缩并导致多样性的幂律衰减。

这与本章自己的论述正面对冲，值得点明：24.9 把”长尾最先丢失”写成坍缩最敏感的指标，而第 2 层的”全局排序取 top-k”恰好等价于每次都保留最典型的样本——最可能造成长尾丢失的操作，就是自家第 2 层那个过滤器。过滤确实挡住了噪声，但它同时在削长尾，这两件事在同一个旋钮上。

两条可执行改法：

1. 把”全局排序取 top-k”改成分层配额取样。先在 embedding 空间分簇，给每个簇（尤其是低频小簇）设保底配额，再在簇内按分数排序取用。这样第 2 层与第 3 层才真正闭环——否则第 3 层只是在测量第 2 层已经造成的损失。
2. 把第 2 层的验收指标从”保留率/淘汰率”扩展为长尾留存率。定义为低频话题、低频表达在过滤前后的存留比，过滤前后都要报。一个”淘汰率 30%、长尾留存率 95%“的过滤器，和一个”淘汰率 30%、长尾留存率 40%“的过滤器，是两种完全不同的东西，而现有指标区分不出它们。

缓解方向（来自 2606.13732）：在不能共享原始数据的前提下，从多个孤岛构造 Wasserstein 代理参考分布；实验显示局部参考选择在偏斜分布上失效，而协作式代理参考能缓解多样性退化。这给跨机构场景提供了一条不违反数据隐私的改法。

⚠️ 适用边界：AIES-26 的实证在表格数据合成域，向文本合成外推须标注——但 mode dropping 是分布层面的机制，与模态弱相关，故可写。2606.13732 同样是理论 + 表格/合成实验，未在 LLM 文本合成上做过同等规模的验证。两条都应按”机制成立、量级待定”引用，不要直接套用其中的具体百分比。

24.7 Verifier 的构造

验证器的强度谱系

不同领域可用的验证器强度差异极大，直接决定了该领域合成数据可安全扩展的比例：

验证器强度谱系（从强到弱）：

1. 形式化验证（代码执行、数学证明检查器）
   → 判决：二值、客观、可复现
   → 领域：代码、形式化数学
   → 这就是为什么代码合成数据可以占到 30-50%
     甚至更高——每个合成函数都能跑单元测试

2. 规则/约束验证（编译器、linter、schema 校验、
   单位一致性检查、答案格式匹配）
   → 判决：二值或离散等级，覆盖部分错误类型

3. 参考答案验证（有 ground truth 的题目：拒答采样、
   自动评分器 rubric grading）
   → 判决：接近客观，但依赖题目质量

4. 模型交叉验证（LLM-as-Judge、多模型投票、
   生成模型与评分模型分离）
   → 判决：主观但有统计意义，需校准 judge 偏差
     （位置偏差、长度偏差、自我偏好）

5. 分布统计验证（与真实参考数据的分布距离、
   多样性监控、可检测性）
   → 判决：批次级而非逐条级，作为整体质量信号

6. 人工抽检
   → 判决：最可靠但不可扩展，用于校准上述所有自动验证器

验证器强度与可安全合成比例的正相关，是 24.10 各任务最优混合比例差异的根本原因：代码任务（可执行验证）最优合成比例 30-50%，知识问答（只能靠弱验证器）只有 10-20%。

形式化验证：代码与数学的黄金路径

代码是合成数据的”模范领域”：生成 → 编译 → 执行测试 → 通过才算数，全链路自动且客观：

"""
代码合成数据的执行验证
"""
import subprocess

def verify_synthetic_code(
    code: str,
    test_cases: list[dict],   # [{"input": ..., "expected": ...}, ...]
    timeout_sec: int = 5,
) -> dict:
    """
    三重验证：编译 → 执行 → 断言
    返回结构化验证结果，嵌入样本溯源元数据
    """
    # 1. 编译检查（语法层）
    compile_result = subprocess.run(
        ["python", "-m", "py_compile", "-"],
        input=code, capture_output=True, text=True, timeout=timeout_sec,
    )
    if compile_result.returncode != 0:
        return {"verdict": "REJECT", "stage": "compile",
                "error": compile_result.stderr[:500]}

    # 2+3. 逐用例执行 + 输出断言（语义层）
    for i, tc in enumerate(test_cases):
        runner = subprocess.run(
            ["python", "-c", code + f"\nprint(solution({tc['input']}))"],
            capture_output=True, text=True, timeout=timeout_sec,
        )
        if runner.returncode != 0:
            return {"verdict": "REJECT", "stage": f"case_{i}_runtime",
                    "error": runner.stderr[:500]}
        if runner.stdout.strip() != str(tc["expected"]):
            return {"verdict": "REJECT", "stage": f"case_{i}_assert",
                    "got": runner.stdout.strip(), "expected": str(tc["expected"])}

    return {"verdict": "ACCEPT", "stage": "all_passed",
            "n_cases": len(test_cases)}

数学领域的形式化路径是证明助手（Lean 4、Isabelle）：用 LLM 生成数学证明 → 形式化验证器检验 → 只保留通过验证的证明。通过率虽然不高，但通过即意味着正确——这是”宁缺毋滥”的极致。

LLM-as-Judge 与交叉验证：弱验证领域的最佳实践

对无法形式化验证的领域（写作、开放问答、摘要），LLM-as-Judge 是主流方案，但需要工程化对抗其已知偏差：

• 生成-评分分离：评分模型不得是生成模型本身——模型对自己的输出有系统性偏好（self-preference bias）；
• 偏差校准：judge 存在位置偏差（偏好多选项中的第一个）、长度偏差（偏好更长回复）、风格偏差（偏好格式华丽的回复）。缓解手段包括选项随机化、长度归一化打分、用已知 ground truth 的小集合定期测评 judge 本身；
• 多模型交叉：关键数据用 2-3 个不同家族的模型分别打分，分歧大的样本进入人工队列。分歧率本身就是质量信号——高分歧区往往是任务定义模糊区。

合成分类器：用合成数据治理数据

DCLM/FineWeb 的实证（见 24.2 锚点四）揭示了一个自举式的巧妙结构：用少量人工标注的高质量种子训练分类器，用分类器筛选海量数据。流程如下：

合成分类器管线（DCLM 路线）：
1. 从优质语料（如教科书、精选页面）采样正例 ~ 几千条
2. 从普通网页采样负例
3. 训练轻量分类器（fasttext / 小型 transformer）
4. 用分类器对候选池全量打分（推理成本极低）
5. 高分数据进入训练集
→ 实证结果：分类器筛选的数据训练出的模型
   优于规则过滤筛选的数据（同预算下 benchmark 更高）

这个模式的价值在于它同时解决了规则过滤的两个缺陷：规则是”平均正确”而分类器可以学到质量的隐式表征；规则需要逐领域手工设计而分类器只需更换种子即可迁移。它也再次印证了本章的主线——生成（种子扩展出训练集）与验证（分类器执行筛选）在此合为一体。

---

第三篇 进化（Evolution）

24.8 迭代自提升闭环与数据飞轮

第二代合成数据

2025-2026 年，合成数据正在从”简单生成”进化到”带反馈的精炼生成”：

特征	第一代（2023-2024）	第二代（2025-2026）
生成方式	单次生成	生成→验证→修正→再生成
质量控制	事后过滤	生成过程中内嵌验证
多样性	温度调节	主动探索未覆盖区域
事实性	依赖生成模型	外部知识库验证
反馈	无	下游任务信号反传

第二代合成数据的本质是把”生成-验证”从流水线改造成循环：验证不通过的数据不直接丢弃，而是携带验证错误信息回到生成端重新生成（修正-再生成）；下游任务的性能信号反传，调整下一轮的种子配额与难度课程。这个循环一旦跑通，就形成了所谓的数据飞轮。

数据飞轮的完整形态

数据飞轮（Data Flywheel）：

    ┌──────────────────────────────────────────┐
    │                                          │
    ↓                                          │
  生成 ──→ 验证 ──→ 训练 ──→ 部署/评测          │
    ↑         │        │         │             │
    │         │        │         ↓             │
    │         │        └── 模型更强 ──→ 新错误模式、│
    │         │                       用户反馈     │
    │         ↓                              │
    │      淘汰信号 ──→ 分析失败模式 ──→ 修正种子/ │
    │                                      prompt/课程│
    └──────────────────────────────────────────┘

飞轮转起来的三个标志：
1. 每一圈的数据质量分布优于上一圈（淘汰率下降）
2. 模型发现的新错误模式在下一圈被针对性覆盖
3. 人工介入比例逐圈下降（自动化程度提升）

飞轮停转的三个信号：
1. 多样性指标逐圈下降（坍缩前兆，见 24.9）
2. 验证通过率虚高但下游表现停滞（验证器被"钻空子"）
3. 数据越来越难、模型通过率越来越低（超出能力圈）

飞轮与一次性管线的关键区别在于信号回流的方向数：一次性管线只有”验证 → 淘汰”一条信号路径；飞轮至少有四条——验证失败模式 → 生成端修正、下游性能 → 课程调整、部署反馈 → 新种子发现、模型新能力 → 更高难度数据解锁。每一圈飞轮都在消耗算力，但也在让下一圈的边际收益更高。

合成自博弈：模型自己出题

SPICE 框架（Challenger-Reasoner 双角色）正在合成数据领域产生更广泛的影响。核心思路：模型不仅生成答案，还自动生成训练题目本身，从文档中挖掘新的推理任务。这将合成数据从”模仿人类出题”升级为”自主探索知识空间”。

SPICE 风格的自博弈闭环：

  文档/知识库
      ↓
  Challenger（出题者）
  → 从文档中构造带可验证答案的推理题
  → 目标：出"当前模型恰好不会"的题（能力边界探测）
      ↓
  Reasoner（解题者）
  → 尝试解题
      ↓
  规则验证器（答案匹配/执行检验）
  → 通过：入训练数据（正解 + 过程）
  → 不通过：题目本身可能过难或有歧义 → 反馈给出题者
      ↓
  梯度更新 → 模型变强 → Challenger 出更难的题
  → 循环继续

SPICE + RLVR（Reinforcement Learning with Verifiable Rewards）的组合构成了一个完全自循环的训练闭环：自动出题 → 自动解题 → 规则验证 → 梯度更新。目前这一方向主要在数学和代码推理领域成熟（因为验证器强，见 24.7），向通用领域的扩展仍是开放问题。

自博弈把”进化”推到了极致，但它同时是崩溃风险最高的形态——出题者与解题者同源，分布退化的速度可能远超跨模型生成。这就是为什么自博弈系统必须配合 24.9 的全套崩溃监控：进化越自主，监控越严格。

课程进化：难度与覆盖的动态规划

进化环节除了”质量自提升”，还承担课程设计的职能——决定下一轮数据在难度 × 覆盖 × 混合比例三维空间中如何配置：

课程进化的决策依据（每一轮迭代回答三个问题）：

1. 难度推进：模型在当前难度档位的通过率 > 80%？
   → 是：解锁下一难度档（进化链的下一代）
   → 否：在当前档位扩充变体，巩固后再推进

2. 覆盖扩展：embedding 空间哪些区域仍是低密度？
   → 定向生成填补空白（主动多样性探索）
   → 同时防止高频区域过度重复

3. 混合再平衡：上一轮各来源数据的边际贡献如何？
   → 用数据归因（data attribution / 数据消融）
     估计每类数据的边际收益
   → 边际收益低的数据类减产，高者扩产

这里的”难度推进”逻辑与拒绝采样的 pass_rate 判据（24.4）完全一致——生成端产生的 pass_rate 信号，正是进化端课程决策的输入。三段式体系在这种细节处的环环相扣，就是它优于方法清单式组织的根本原因。

24.9 崩溃风险与防控

进化闭环带来能力自提升的同时，也带来了合成数据最著名的风险：Model Collapse（模型崩溃）。这是进化环节必须正面处理的核心议题。

Nature 论文的核心发现

2024 年 Nature 上发表的论文《The Curse of Recursion: Training on Generated Data Makes Models Forget》（Shumailov et al.）揭示了一个深刻的风险：

当模型 A 生成数据训练模型 B，模型 B 再生成数据训练模型 C……经过多代递归后，模型的能力会系统性地退化。

递归坍缩的过程：

  真实数据分布 P_real
      ↓ 训练
  模型 1 → 生成分布 P_1（近似 P_real，有微小偏差）
      ↓ 训练
  模型 2 → 生成分布 P_2（近似 P_1，偏差累积）
      ↓ 训练
  模型 3 → 生成分布 P_3（偏差进一步累积）
      ↓
  ... 经过 N 代 ...
      ↓
  模型 N → 生成分布 P_N（严重退化，丢失长尾）

信息论视角

从信息论的角度理解坍缩：

• 每一轮合成都是对原始分布的一次有损压缩
• 低概率事件（长尾分布中的罕见模式）在每轮压缩中被优先丢弃
• 经过多轮后，只剩下高频模式——输出变得单一和重复

数学上，这可以用 KL 散度的不可逆性来理解：

D_KL(P_real || P_1) ≤ D_KL(P_real || P_2) ≤ ... ≤ D_KL(P_real || P_N)

每一代模型与真实分布的距离单调递增，
因为 KL 散度在数据处理不等式下只能增大或不变。

实验证据：坍缩的量化观察

论文中的实验揭示了几个重要的量化规律：

代数	PPL 变化	Unique 3-gram 比例	下游任务准确率	可观察现象
第 0 代（真实数据）	基准	100%	基准	正常
第 1 代	+2-5%	~95%	-0.5~1%	几乎看不出差异
第 3 代	+10-20%	~80%	-3~5%	输出开始趋同
第 5 代	+30-50%	~60%	-8~15%	明显的模式重复
第 9 代	+100%+	~30%	-20~40%	严重退化，输出近乎相同

这张表最令人不安的是第 1 代的隐蔽性：PPL 仅 +2-5%、准确率仅降 0.5-1%，几乎无法通过常规评测发现。等到第 3 代”输出开始趋同”时，损害已经累积。这解释了为什么多样性监控必须作为持续性手段（见下文 CollapseMonitor），而不是事后审计。

🔬 显微镜案例：Phi-3 如何避免 Model Collapse

Microsoft 的 Phi-3 模型大量使用合成数据（占训练数据约 60%），但并没有出现 Model Collapse。他们的关键做法：

1. 单代生成：所有合成数据都由 GPT-4 直接生成，而不是用 Phi-2 的输出再训练 Phi-3——避免了递归链
2. 种子多样性保证：种子数据覆盖 >20 个知识领域和 >50 种题目类型
3. 真实数据锚定：即使合成数据占比很高，仍保留 ~40% 的真实网络数据
4. 质量过滤：合成数据经过严格的质量过滤，淘汰率约 40%
5. 多模型集成：部分合成数据使用多个不同模型（GPT-4, Claude, Gemini）生成，增加风格多样性

教训：合成数据的”多少”不是关键，“怎么合成”才是。

Strong Model Collapse：微量合成数据即可引发崩溃

Nature 论文的结论是”多代递归使用合成数据导致崩溃”，暗示坍缩需要迭代。但 ICLR 2025 论文（Strong Model Collapse）发现了一个更严峻的现实：仅需 0.1% 的合成数据混入训练集即可引发可检测的模型崩溃，无需多代迭代。

更令人警醒的是大模型放大效应：更大的模型对合成数据污染更敏感。这与”大模型更鲁棒”的直觉相反——大模型之所以更脆弱，是因为它们对分布偏移更敏感，合成数据的微小分布偏差在大模型中被放大而非吸收。

Strong Model Collapse 的关键修正：

原有结论（Nature 论文）：
  "多代迭代使用合成数据导致崩溃"
  → 防御策略：避免递归代数过多

修正结论（ICLR 2025）：
  "微量合成数据单次混入即有风险，大模型风险更高"
  → 防御策略：任何合成数据混入都需监控，尤其是大模型训练

对 30% 安全阈值的重新评估：
  如果 0.1% 就有效应，那么 30% 的"经验安全值"
  可能只适用于小模型
  大模型的安全阈值需要更低（建议 5-15% 起步监控）

形式化视角：为什么合成数据比例必须趋近于零？

上文的 Strong Model Collapse 论文本身就是这一命题的形式化来源：Dohmatob、Feng、Subramonian 与 Kempe（Meta FAIR、NYU Center for Data Science、NYU Courant、UCLA）在 scaling law 范式下（φ→0+）证明，要保持模型稳定则必须要求合成数据比例 p₂→0+。换句话说，任何正比例的合成数据在极限下都会导致崩溃——这不是经验风险，而是数学必然性。

模型规模的作用是双向的，这一点常被简化错：该研究在随机投影模型上证明，当合成数据与真实数据的分布偏差显著时，更大的模型会放大坍缩；但越过插值阈值（interpolation threshold，m = n）之后趋势反转，过参数化模型反而缓解坍缩（只是不能完全消除）。论文把这条先放大、后缓解的曲线称为坍缩现象的 double descent。

BabiStories + GPT-2 实验印证了阈值前后两段：在 12/18/24 层三组模型上，token 数低于 1×10¹⁰ 时更深的模型测试损失更低；超过约 3×10¹⁰ token 后，小模型反而因过拟合更轻而取得更低损失——这与”大模型更鲁棒”的直觉相反，但只在阈值之后成立。

这进一步强化了本节的核心论点：验证机制的价值不在于提高”安全合成比例”，而在于它是在数学必然崩溃的前提下唯一可行的信号保真手段。

事前预防：Token-Level Editing 的半合成方案

验证机制是”事后防线”——合成数据已经生成，验证负责发现和过滤问题。但 2025 年的研究提出了一个更根本的思路：从生成方式本身预防崩溃。

Token-Level Editing（ICML 2025）提出通过 token 级编辑（而非从零生成）创建半合成数据。核心思路：保留真实数据的分布骨架，仅编辑关键 token（如答案/推理步骤），而非从零生成完整文本。

从零生成 vs 编辑式半合成：

从零生成（传统合成）：
  种子主题 → LLM 从头生成完整文本
  → 引入全新的分布模式 → 可能触发 Model Collapse
  → 即使验证通过，分布偏差仍然存在

编辑式半合成（Token-Level Editing）：
  真实文本 → 仅修改关键 token（如答案、数值、特定术语）
  → 保留原始分布骨架 → 不引入新分布模式
  → 不会触发 Strong Model Collapse 的崩溃效应

这为”第二代合成数据”提供了首个经过验证的防崩溃生成方案。此前，第二代合成数据的特征（生成→验证→修正循环）更多是概念性的，Token-Level Editing 给出了具体的工程实现：在 SFT/偏好数据构建中，优先使用编辑式半合成而非从零生成，从源头上避免分布偏移。

实践建议：对于高比例合成数据场景（>30%），结合验证机制（事后）+ Token-Level Editing（事前）双重保障；对于低比例场景（<10%），验证机制已足够，但大模型训练中建议额外使用编辑式半合成。

把防坍缩手段按时序排列，就得到一个纵深防御体系：

防线	时序	机制	代表方法
生成端预防	事前	保留真实分布骨架	Token-Level Editing、改写范式
种子端控制	事前	多样性与覆盖规划	种子矩阵、多模型集成
验证端阻断	事中	逐条/批次噪声过滤	四层质量控制、形式化验证
监控端预警	事中	多样性退化早期信号	CollapseMonitor
混合端冗余	事后	真实数据锚定	保留一定真实数据比例
代际端约束	架构	避免自源递归	单代生成、跨模型生成

实践防护：多样性监控与自动告警

"""
Model Collapse 防护：多样性监控 + 自动告警
"""

class CollapseMonitor:
    """监控合成数据管线的多样性健康度"""

    def __init__(self, baseline_stats: dict = None):
        self.baseline = baseline_stats
        self.history = []

    def check_batch(self, texts: list[str]) -> dict:
        """检查一批合成数据的健康度"""
        stats = self._compute_diversity_stats(texts)
        self.history.append(stats)

        alerts = []

        # 检查 1：绝对多样性
        if stats["unique_trigram_ratio"] < 0.5:
            alerts.append("🚨 CRITICAL: trigram 多样性 < 0.5，疑似严重坍缩")
        elif stats["unique_trigram_ratio"] < 0.7:
            alerts.append("⚠️ WARNING: trigram 多样性偏低")

        # 检查 2：相对于基线的退化
        if self.baseline:
            diversity_drop = (
                self.baseline["unique_trigram_ratio"] - stats["unique_trigram_ratio"]
            ) / self.baseline["unique_trigram_ratio"]
            if diversity_drop > 0.2:
                alerts.append(f"🚨 多样性相比基线下降 {diversity_drop:.1%}")

        # 检查 3：批次间趋势
        if len(self.history) >= 3:
            recent = [h["unique_trigram_ratio"] for h in self.history[-3:]]
            if all(recent[i] > recent[i+1] for i in range(len(recent)-1)):
                alerts.append("⚠️ 多样性连续 3 个批次下降，可能正在坍缩")

        # 检查 4：开头重复度
        openings = [t[:100] for t in texts]
        opening_unique = len(set(openings)) / len(openings)
        if opening_unique < 0.6:
            alerts.append("⚠️ 开头高度重复，模型可能在使用模板化输出")

        return {
            "stats": stats,
            "alerts": alerts,
            "health": "critical" if any("CRITICAL" in a for a in alerts)
                      else "warning" if alerts
                      else "healthy",
        }

    def _compute_diversity_stats(self, texts: list[str]) -> dict:
        from collections import Counter
        all_trigrams = []
        all_words = []
        for text in texts:
            words = text.split()
            all_words.extend(words)
            trigrams = [tuple(words[i:i+3]) for i in range(len(words)-2)]
            all_trigrams.extend(trigrams)

        trigram_counts = Counter(all_trigrams)

        return {
            "unique_trigram_ratio": len(set(all_trigrams)) / max(len(all_trigrams), 1),
            "unique_word_ratio": len(set(all_words)) / max(len(all_words), 1),
            "top10_trigram_concentration": (
                sum(c for _, c in trigram_counts.most_common(10)) / max(len(all_trigrams), 1)
            ),
            "avg_length": sum(len(t) for t in texts) / max(len(texts), 1),
            "n_samples": len(texts),
        }

CollapseMonitor 的四项检查分别对应四类坍缩信号：绝对阈值（已经坍缩）、相对退化（正在偏离基线）、趋势（连续下降的前兆）、模式化（模板输出的特异信号）。其中检查 3（批次间趋势）在工程上最有价值——它能在指标尚未跌破绝对阈值时就捕捉到单调退化趋势，为干预争取一个批次的提前量。

从”防止坍缩”到”利用坍缩”

Model Collapse 一直被视为纯粹的负面现象，但 2025-2026 年开始有研究者探索它的”选择性应用”——坍缩本质上是对分布的有损压缩，如果控制得当，它可以被用来主动压缩噪声分布、保留高质量核心。这个方向仍处于非常早期的探索阶段，但它暗示了对 Model Collapse 更成熟的理解：不是一个需要彻底避免的灾难，而是一个需要精确控制的工具。

---

跨篇视角：规模法则

24.10 合成数据的 Scaling Law

生成、验证、进化三段各自解决”怎么做”的问题，而 Scaling Law 回答”做多少”的问题——它是横跨三段的预算约束。

EMNLP 2025 的关键发现

2025 年的研究（Demystifying Synthetic Data in LLM Pre-training, EMNLP 2025）首次系统地量化了合成数据的 scaling 规律，得出了几个重要结论：

发现 1：边际收益递减显著

合成数据比例 vs 下游任务提升（以代码能力为例）：

合成比例    HumanEval 提升    边际收益
   0% →  5%     +8.2%          +1.64%/每1%
   5% → 10%     +4.1%          +0.82%/每1%
  10% → 20%     +3.5%          +0.35%/每1%
  20% → 40%     +2.0%          +0.10%/每1%
  40% → 60%     +0.8%          +0.04%/每1%
  60% → 80%     -0.3%          < 0（开始负面影响）
  80% →100%     -2.1%          < 0（明显退化）

→ 存在一个最优点，超过之后弊大于利
→ 对于代码任务，最优合成比例约在 20-40%

发现 2：最优混合比例与任务高度相关

能力维度	最优合成比例	原因
代码生成	30-50%	代码可以自动验证，合成质量有保证
数学推理	20-40%	数学有标准答案，但推理路径多样性重要
知识问答	10-20%	知识需要事实准确，合成容易引入幻觉
创意写作	5-10%	创意高度依赖多样性，合成数据风格趋同
多语言	20-30%	低资源语言可以借助翻译合成，但翻译腔是风险

这张表是 24.7 验证器强度谱系的最直接应用：最优合成比例基本是验证器强度的单调函数。代码可自动验证（强验证器）→ 比例最高；创意写作没有客观对错（弱验证器）→ 比例最低。

“单调函数”这句需要加一个约束维度。按 24.9 引述的 ICLR 2026 结论，长期收敛终点是验证器的知识中心 θc 而非真实分布 θ*，且提高选择性只加速、不改终点。强度决定”能筛得多干净”，偏差决定”筛完之后模型会变成谁”，二者不可互换。由此得到一条判据：弱但无偏的验证器，在长期递归下会优于强但有偏的验证器——后者会把模型稳定地拖向一个错误但自洽的终点。

📌 该判据是由上述理论推出的推论，原论文未直接做”弱无偏 vs 强有偏”的对照实验，引用时按推论处理。

发现 3：质量 > 数量的量化证据

实验设置：固定总 token 数 = 100B

方案 A: 100B token 全部真实数据
方案 B: 80B 真实 + 20B 低质量合成（未过滤）
方案 C: 80B 真实 + 20B 高质量合成（严格过滤，原始的 50% 被淘汰）
方案 D: 80B 真实 + 10B 高质量合成（严格过滤 + 仅保留最优的 25%）

MMLU 结果: A(62.3) < B(63.1) < D(65.8) < C(66.4)
代码结果: A(38.2) < B(40.1) < D(43.5) < C(44.7)

→ 方案 C（严格过滤的 20%）比 方案 B（未过滤的 20%）高 3 个点
→ 方案 D（10% 最优）与 方案 C（20% 过滤后）接近
→ 结论：1 份高质量合成 ≈ 4-5 份未过滤合成

这个实验是对”验证环节价值”的最有力定价：同样是 20B token 的合成预算，花在验证上（过滤掉一半）能换来 3 个点的提升。验证不是成本，是杠杆。

SynthLLM 修正缩放法则（COLM 2025）

SynthLLM 的 Scaling Law 研究提供了三个更精确的工程指导：

发现 4：合成数据遵循修正缩放法则（Rectified Scaling Law）

与预训练的 Chinchilla 缩放法则不同，合成数据的性能增益是可预测但有天花板的——给定模型大小和合成方法，你可以提前估算在多少 tokens 处性能将饱和。

发现 5：约 300B tokens 是当前方法的饱和点

在固定合成方法和模型大小的条件下，约 300B tokens 处出现性能平台期。超过这个量级，增加更多合成数据的边际收益趋近于零。

发现 6：模型规模与最优数据量呈反比关系

模型大小	接近最优性能所需的合成数据量
3B	~4T tokens
8B	~1T tokens

这意味着：更大的模型需要更少的合成数据就能接近最优——它们的内部表示更丰富，从同样的合成数据中提取更多信息。对于工程团队来说，这提供了一个清晰的决策依据：先评估模型规模，再决定合成数据的投入量。

香农缩放定律：信息论统一视角

上述 EMNLP 2025 和 SynthLLM 的发现都基于经验观察——它们描述了”什么现象发生”，但未解释”为什么发生”。香农缩放定律（ByteDance Seed + UVA + Berkeley, 2026-05）提供了信息论层面的统一解释。

核心思想：将 LLM 视为通信系统中的有噪信道。

传统视角：LLM = 函数逼近器（输入→输出）
香农视角：LLM = 有噪信道（发送端编码知识 → 信道传输 → 接收端解码）

关键映射：
  模型参数量 N  → 信道带宽 B
  训练数据量 D  → 信号功率 S
  合成数据噪声 → 噪声功率 N₀
  模型 Loss     → 误码率

香农-哈特利定理的应用：

传统 scaling law 遵循幂律递减，性能单调提升——但这仅适用于无限高质量数据假设。一旦引入合成数据噪声，信道容量存在硬上限：

C = B · log₂(1 + S/N₀)

其中 B ∝ 模型容量，S ∝ 真实数据信号，N₀ ∝ 合成数据噪声

香农定律对合成数据的三个关键推论：

应用	解释
U 型退化	合成数据比例增加 → N₀ 上升 → log₂(1+S/N₀) 下降 → 模型性能先升后降。这是信噪比恶化的必然结果。
饱和点可预测	给定合成数据质量（即 SNR），可提前计算性能平台期位置。SynthLLM 观察到的约 300B tokens 饱和点是特定 SNR 的实例。
终极香农极限	任何合成方法都存在信噪比上限——超过此上限后继续增加数据或参数均无效。

对全章结论的统一：

• EMNLP 2025（边际递减）→ 香农定律中信噪比恶化的自然表现
• SynthLLM（300B 饱和点）→ 特定 SNR 下的信道容量上限
• 24.9 节（Model Collapse）→ 递归训练中信噪比指数衰减 → C → 0
• 24.9 节（验证机制防坍缩）→ 验证 = 在接收端增加纠错码 → 有效 SNR 提升

香农视角也统一了三段式体系：生成端的多样性控制是在提升信号带宽，验证端是在提升有效信噪比，进化端是在逐轮迭代中防止 SNR 的跨代衰减。

实践启示：

• 与其关注”合成数据比例”，不如关注”合成数据的有效 SNR”
• 验证机制的价值不在于”过滤差数据”，而在于提升有效信噪比
• 最优数据量不是固定数字，而是模型容量 B 和信噪比 SNR 的函数

缺的那个极端点：100% 合成 + 单阶段

上面三条规律——边际递减、300B 饱和点、香农 SNR 上限——都在回答同一个问题：在”合成数据占多少比例”这根轴上，往上走到哪里会饱和。它们共享一个前提：阶段划分固定，合成数据只是配料。而 SYNTH（arXiv:2609.37891）恰好站在这个前提之外：100% 合成、且把三个阶段压成一个。

把它放进本节，不是为了推翻边际递减，而是因为它讲的是另一根轴——不是”多少比例会饱和”，而是”用什么换了多少 token”。

收益轴（强正向）：

• token 效率：论文摘要直接给出，SYNTH 训出的模型”以少 10–140× 的训练 token 达到高事实精度”。对照更直观：Baguettotron-600M 用 158B token 训练，在 22 个多选题任务上仅次于 Qwen3-0.6B 4.7 分、在 8 个开放式任务上仅差 0.7 分，而基线模型用了 80–700× 更多的 token。
• 事实精度：FActScore macro，Baguettotron-MoE（13B 总参 / 1B 激活，训 50B token）46.3%，高于同激活规模的 OLMoE-1B-7B-Instruct（33.4%）与 DeepSeek-MoE-16B-Chat（38.3%）；Baguettotron-600M 也能到 41.7%，超过 6× 大的 Phi-4-mini-instruct。
• 工具调用：BFCL v2 上 Baguettotron-600M（+工具调用后训练）达 53.1%，比 FunctionGemma-270M 高 3.9 分，而训练 token 少约 40×（158B + 1.5B vs 6T）。

代价轴（同样明确，且论文自己写了）：

• 覆盖：高事实精度是在种子实体内测得的。对种子语料外的留出实体，弃权率从 20% 升到 67%，尝试作答时的精确率从 82% 掉到 62%（详见 24.6 新增的”知道自己不知道”）。这不是 bug，是种子覆盖有限的直接后果——记忆是被种子语料定向的（memorization targeted by the seed corpus）。

• 开放式生成：论文的推理痕迹消融（Table 9）显示——有痕迹 vs 无痕迹，多选题基本不变（41.8% → 42.2%，Δ +0.4），开放式反而提升（22.0% → 24.3%，Δ +2.3）；增益集中在真实性（TruthfulQA 33.5 → 42.6，+9.1）与领域推理（NuclearQA 35.0 → 45.0，+10.0），事实回忆基本不变（五个基准的 Δ 平均约 +0.5），唯一反向的是 ConflictQA（42.4 → 38.5，−3.9）。

  ⚠️ 方向陷阱（终审标注）：论文正文是从「去掉痕迹」的方向叙述的，因而写作 TruthfulQA −9.1、NuclearQA −10.0、ConflictQA +3.9；而 Table 9 的 Δ 列是「有痕迹 − 无痕迹」，符号全部相反（+9.1 / +10.0 / −3.9）。两者说的是同一件事，但符号约定相反。本章统一按「有痕迹相对无痕迹」陈述；引用时必须先确认自己站在哪个方向上，否则会把「加痕迹让真实性 +9.1」读成「加痕迹让真实性 −9.1」。

• 广域知识：论文自陈，在奖励广域网络知识的基准（ARC-Challenge、GeoBench）上明显落后，并把它列为”只用维基种子”的局限。

与本节三条规律的关系：不冲突，是互补。边际递减与饱和点管的是”配料比例”这根轴，SYNTH 说明当你同时改变流程拓扑时，可以在 token 效率轴上换取一个数量级——代价转移到覆盖与校准轴上。用香农视角的话说：它把信道里的噪声压得很低（种子约束 + 反译），代价是信号带宽也变窄了（只有种子覆盖的那些实体）。追求低噪声会牺牲带宽，这就是 SNR 框架里”提高 SNR 的两种方式”的又一次现身——只不过这里的做法是降 N₀ 而不是升 S，而降得太狠会把 S 一起削掉。

⚠️ 注意别误读成”100% 合成可行”：SYNTH 的对照组是同等规模的小模型（56M / 0.3–0.6B / 13B-1B激活），证明的是”全合成 + 单阶段能训出有竞争力的小模型”，不是”能训出前沿大模型”。把这条结论外推到大规模预训练没有证据支持。

---

24.11 前沿趋势与伦理考量

多模态合成数据

随着多模态模型的兴起，合成数据也在向多模态扩展：

文本→图像描述合成：
  用 LLM 生成详细的图像描述 → 用图像生成模型验证描述的可行性

代码→测试用例合成：
  给定一段代码 → 自动生成单元测试 → 运行测试验证代码正确性
  → 代码和测试用例都成为训练数据

数学→形式化验证：
  用 LLM 生成数学证明 → 用 Lean 4 形式化验证器检验
  → 只保留通过验证的证明

多模态合成的一个体系性优势：模态间互为验证器。文本描述可以约束图像生成，图像生成结果反过来校验描述的可实现性；代码生成测试、测试验证代码。这种交叉验证结构天然地提高了验证器强度，因此多模态合成数据的可安全比例往往高于纯文本的弱验证领域。

合成数据的伦理考量

需要关注的伦理问题：

1. 偏见放大
   合成数据可能放大生成模型中的偏见
   → 需要专门的偏见检测和缓解步骤
   → 偏差可审计性因此成为 IEEE 标准方向的核心维度

2. 版权灰区
   用受版权保护的数据训练的模型生成的合成数据
   → 法律上是否算"衍生作品"？目前无定论

3. "数据霸权"
   只有拥有强大模型的公司才能生成高质量合成数据
   → 可能加剧 AI 领域的垄断

4. 环境成本
   大规模合成数据生成的计算成本很高
   → 生成 1T token 的合成数据约消耗 100 MWh 电力

值得强调的是，这些问题在”生成-验证-进化”体系下有了新的治理抓手：偏差问题可以通过验证端的分维度审计来度量与拦截；版权问题可以通过种子端的溯源记录来厘清责任链；数据霸权问题正在被 Magpie 这类零种子依赖的方法部分缓解——没有顶级模型 API 的团队，至少可以用开权重模型的自举能力构建自己的飞轮起点。

---

动手环节：构建一个合成数据质量评估流水线

目标：对一批合成的 SFT 数据进行多维度质量评估，生成质量报告。

"""
动手练习：合成数据质量评估流水线
评估一批模拟的合成 SFT 数据
"""
import json
from collections import Counter

# 模拟数据
synthetic_sft_data = [
    {"instruction": "解释什么是梯度下降", "response": "梯度下降是一种优化算法...（假设 500 字回复）"},
    {"instruction": "写一段 Python 排序代码", "response": "```python\ndef sort_list(arr):...```"},
    {"instruction": "解释什么是梯度下降", "response": "梯度下降是机器学习中最常用的优化方法..."},  # 重复指令
    {"instruction": "你好", "response": "你好！"},  # 过短
    # ... 假设共 1000 条
]

def evaluate_sft_batch(data: list[dict]) -> dict:
    """SFT 合成数据批量评估"""
    report = {
        "total": len(data),
        "issues": {
            "duplicate_instructions": 0,
            "too_short_response": 0,
            "too_long_response": 0,
            "low_diversity": False,
        },
        "quality_distribution": {"excellent": 0, "good": 0, "acceptable": 0, "poor": 0},
    }

    # 1. 指令去重检查
    instructions = [d["instruction"] for d in data]
    instruction_counts = Counter(instructions)
    report["issues"]["duplicate_instructions"] = sum(
        count - 1 for count in instruction_counts.values() if count > 1
    )

    # 2. 回复长度检查
    for d in data:
        resp_len = len(d["response"])
        if resp_len < 50:
            report["issues"]["too_short_response"] += 1
        elif resp_len > 10000:
            report["issues"]["too_long_response"] += 1

    # 3. 多样性检查
    unique_instruction_ratio = len(set(instructions)) / len(instructions)
    if unique_instruction_ratio < 0.9:
        report["issues"]["low_diversity"] = True

    # 4. 汇总报告
    report["unique_instruction_ratio"] = round(unique_instruction_ratio, 4)
    report["avg_response_length"] = sum(len(d["response"]) for d in data) / len(data)

    # 5. 建议
    report["recommendations"] = []
    if report["issues"]["duplicate_instructions"] > len(data) * 0.05:
        report["recommendations"].append("指令重复率过高，建议增加种子多样性或提高温度")
    if report["issues"]["too_short_response"] > len(data) * 0.1:
        report["recommendations"].append("短回复过多，建议设置最小生成长度或过滤短回复")
    if report["issues"]["low_diversity"]:
        report["recommendations"].append("整体多样性不足，建议使用 Evol-Instruct 进化策略")

    return report

# 运行评估
report = evaluate_sft_batch(synthetic_sft_data)
print(json.dumps(report, indent=2, ensure_ascii=False))

练习扩展：

1. 在 evaluate_sft_batch 中添加回复质量打分（可以用规则或调用 LLM-as-Judge）
2. 添加 embedding 空间的多样性分析（使用 sentence-transformers）
3. 对比不同温度生成的合成数据的质量-多样性 tradeoff
4. （体系化扩展） 为报告增加”进化接口”：把 recommendations 结构化为对生成端参数（温度、策略、种子配额）的具体调整指令，模拟一个单轮飞轮的验证 → 生成回流

---

本章要点回顾

1. 合成数据已从”锦上添花”变为”不可或缺”——但”怎么合成”比”合成多少”更重要；2026 年的后训练数据中合成占比已超 55%，垂直领域超 80%（Stanford HAI AI Index 2026）
2. 体系胜过清单：生成（数据从哪来）、验证（哪些可用）、进化（下轮怎么更好）三段闭环，是大规模合成管线的标准架构
3. 四大生成范式各有适用场景：改写（保真度高）、种子扩展（内容丰富）、进化（多样性好）、概念图重组（跨域创新）；锚定越弱、多样性越好、验证需求越强
4. 指令合成谱系：Self-Instruct（种子自举）→ Evol-Instruct（定向进化）→ Magpie（零种子自我对齐），生成自主性逐代提升，验证联动需求同步上升
5. 验证是防坍缩的核心机制（ICLR 2025）——而非”混入真实数据”。有验证的合成数据可安全扩展到很高比例；验证器强度与最优合成比例正相关。但该结论只成立一半（ICLR 2026，arXiv:2510.16657）：验证阻止的是发散式坍缩，换来的是长期收敛到验证器的知识中心 θc 而非真实分布 θ*；选择性只改收敛速度、不改终点。可安全比例的上界因此同时受验证器强度与验证器偏差约束——需周期性用真实数据重新校准验证器
6. 质量度量三维度：语义保真度、多样性、偏差可审计性——与 IEEE 合成数据标准方向一致
7. 四层质量控制：格式检查 → 模型打分 → 多样性监控 → 人工抽检；抽检反馈回流生成端
8. 合成分类器优于规则过滤（DCLM/FineWeb 实证）——合成数据不仅是语料，还是数据治理工具
9. 数据飞轮：验证失败模式、下游性能、部署反馈、模型能力四路信号回流，驱动逐轮自提升；SPICE + RLVR 构成完全自博弈闭环
10. Model Collapse 防线已成体系：事前（Token-Level Editing、种子控制）+ 事中（验证阻断、CollapseMonitor 监控）+ 事后（真实数据锚定）；Strong Model Collapse 警示微量污染即有风险、大模型更敏感
11. 合成数据有自己的 Scaling Law——修正缩放法则可预测饱和点（~300B tokens），模型规模与最优数据量呈反比；香农视角统一了边际递减、饱和点与坍缩现象
12. 质量 > 数量：1 份高质量合成 ≈ 4-5 份未过滤合成；验证不是成本，是杠杆
13. 数据墙倒计时：Epoch AI 中位预测 2028 年公共高质量文本耗尽——合成数据从”提质工具”转为”扩量出路”，这正是体系化工程成为生死线的原因

---