在这里插入图片描述

目录

  1. 从每次重推到一次定型
  2. 蒸馏的原料:多次执行轨迹的对齐
  3. 共性提取:稳定部分与可变部分
  4. 蒸馏产出的验证:不比原路线差
  5. 蒸馏产出的落地形态
  6. 蒸馏的迭代与失效回收
  7. 蒸馏的边界:什么不该蒸
  8. 实战:轨迹蒸馏流水线

摘要

程序蒸馏把同型任务的多次执行轨迹提炼成一条稳定流程:对齐轨迹、提取共性、分离可变参数,产出经对照验证不低于原路线后固化为 SOP、提示模板或微调数据。本文拆解轨迹对齐、共性提取、验证对照、落地形态与蒸馏边界,给出轨迹蒸馏流水线的完整代码。

1. 从每次重推到一次定型

1.1 蒸馏要解决的问题

同型任务反复执行时,每次都完整走一遍"理解、规划、试错、修正":结果大致相同,过程重复烧钱。蒸馏的假设是:多次成功执行的轨迹里藏着一条收敛的稳定流程——把这条流程提取出来,后续执行直接照做,跳过探索与试错。

图:重复执行与蒸馏后的路径对比

是

否

同型任务到达

蒸馏流程可用吗

直接按流程执行

跳过探索与试错

现场规划执行

轨迹入库作蒸馏原料

积累到阈值触发蒸馏

图下解读:蒸馏是程序性知识的"从实践到制度":多次执行是探索阶段,蒸馏把探索成果固化,之后同型任务进入"照章执行"的低成本模式。探索与固化的切换点由轨迹积累量与任务复现频率共同决定。

1.2 蒸馏与技能沉淀的分工

第 7 篇的经验沉淀是"碎片级"(单条踩坑、策略、路径),蒸馏是"流程级"(完整可执行程序)。两者衔接:碎片经验是蒸馏的原料之一,蒸馏产出是技能库的顶级供给。

维度经验沉淀(第 7 篇)程序蒸馏(本篇)
提炼单位单条经验完整流程
触发每次执行后轨迹积累到阈值
产出去向经验库SOP、模板、微调数据
验证门槛复用有效率对照实验不劣于原路线

1.3 蒸馏的三种产出形态

蒸馏产出按固化程度递进:SOP 文本(给人与模型执行的步骤书)、提示模板(带占位符的一次性提示)、微调数据(多组任务与标准解的配对,用于训练)。本篇覆盖前两种,微调数据形态在第 7 节边界处讨论。

2. 蒸馏的原料:多次执行轨迹的对齐

2.1 轨迹对齐的必要性

多条轨迹的步骤数、粒度、表述各不相同,直接"取平均"会产出含糊流程。对齐先把轨迹映射到统一坐标系:按功能阶段对齐(理解、准备、执行、验证),功能相同的步骤归为一组。

图:多条轨迹对齐到统一阶段坐标系

轨迹1 五步

按功能阶段归组

轨迹2 六步

轨迹3 四步

理解阶段:各轨迹的1-2步

执行阶段:各轨迹的3-4步

验证阶段:各轨迹的末步

同组内提取共性

图下解读:对齐的单位是功能阶段而非步骤序号——轨迹 1 的第 2 步和轨迹 3 的第 1 步可能都是"理解"阶段。归组依据可用语义匹配(模型判断)或人工标注(首批蒸馏建议人工)。

2.2 对齐的实现

# 来源:自实现 / trace_aligner.py(轨迹对齐)
STAGE_KEYWORDS = {
    "理解": ("读", "理解", "分析", "明确"),
    "准备": ("加载", "读取", "提取", "收集"),
    "执行": ("计算", "生成", "修改", "调用"),
    "验证": ("核对", "校验", "检查", "对比"),
}

def classify_step(step: str) -> str:
    """按关键词把步骤归入功能阶段"""
    for stage, kws in STAGE_KEYWORDS.items():
        if any(k in step for k in kws):
            return stage
    return "执行"  # 默认归执行

def align_traces(traces: list[list[str]]) -> dict[str, list[str]]:
    """把多条轨迹的步骤按阶段归组"""
    grouped: dict[str, list[str]] = {s: [] for s in STAGE_KEYWORDS}
    for trace in traces:
        for step in trace:
            grouped[classify_step(step)].append(step)
    return grouped

if __name__ == "__main__":
    traces = [
        ["读任务要求", "读取数据表", "计算环比", "核对数字"],
        ["分析目标", "提取字段", "生成报表", "检查格式", "复核"],
    ]
    aligned = align_traces(traces)
    for stage, steps in aligned.items():
        print(f"{stage}: {len(steps)}步")

源码说明:classify_step 用阶段关键词归组(生产换语义嵌入更准),align_traces 输出"阶段到步骤列表"的映射。归组后每个阶段内的步骤变体就是下一步共性提取的输入。

2.2a 对齐的失败处理

情形处理
某轨迹缺某阶段该阶段以"多数轨迹包含"为准
阶段顺序不一致以多数轨迹的顺序为准,冲突标注
轨迹间成功率不同只蒸馏成功轨迹,失败轨迹作反例

只蒸成功轨迹是铁律:失败轨迹的流程混进来,蒸馏产出就是"怎么把事做砸"的流程。

3. 共性提取:稳定部分与可变部分

3.1 共性与变量的分离

同组步骤里反复出现的部分是流程骨架(稳定),随任务变化的参数是占位符(可变)。分离后产出"带参数的流程模板":读取{table_path},计算{metric}的环比。

图:共性提取与模板化

读取10月表

共性:读取与计算环比

读取11月表

10月

变量:表名

11月

流程骨架

模板:读取table计算metric环比

图下解读:骨架保留操作语义,变量用占位符承载任务差异。占位符清单(params)是模板的接口声明——执行前必须全部填充,缺参即拒绝执行。

3.2 共性提取的实现

# 来源:自实现 / commonality.py(共性提取与模板化)
import re

def extract_template(steps_group: list[str],
                      var_pattern: str = r"\d+月|[\w.]+\.\w+") -> dict:
    """从同组步骤提取骨架与变量"""
    # 找出所有变量实例
    vars_seen: dict[str, set] = {}
    skeletons = []
    for s in steps_group:
        vars_found = re.findall(var_pattern, s)
        skeleton = s
        for i, v in enumerate(vars_found):
            slot = f"{{v{i}}}"
            skeleton = skeleton.replace(v, slot, 1)
            vars_seen.setdefault(f"v{i}", set()).add(v)
        skeletons.append(skeleton)
    # 出现过半的骨架形态即稳定骨架
    from collections import Counter
    common = Counter(skeletons).most_common(1)[0][0]
    stable = Counter(skeletons)[common] / len(skeletons) >= 0.5
    return {"template": common, "stable": stable,
            "params": {k: sorted(v) for k, v in vars_seen.items()}}

if __name__ == "__main__":
    group = ["读取10月.csv并计算销量环比",
             "读取11月.csv并计算销量环比"]
    t = extract_template(group)
    print("骨架:", t["template"])
    print("稳定:", t["stable"], "参数:", t["params"])

源码说明:extract_template 把变量实例替换为占位符,统计骨架形态的出现占比——过半即稳定。var_pattern 是可配置的变量识别模式(生产中按域定制:文件名、日期、数值区间)。稳定率不足五成的阶段说明任务差异太大,不宜模板化。

3.3 变量的类型标注

变量类型示例执行期校验
路径{table_path}文件存在
数值区间{threshold}在合法区间
枚举{metric}在候选列表
自由文本{comment}长度上限

类型标注写进 params,执行前的参数校验按类型跑——路径不存在、枚举越界这类低级错误在执行前拦截。

4. 蒸馏产出的验证:不比原路线差

4.1 对照实验的设计

蒸馏产出必须通过对照验证:同一批测试任务,分别走"蒸馏流程"与"原探索路线",比较成功率、耗时、token 成本。蒸馏不是免费的固化——固化了错误的流程会让所有后续执行系统性偏差。

图:蒸馏产出的对照验证

是且成本更低

否

持平且无成本优势

蒸馏流程模板

测试任务集N个

原探索路线

组1 按模板执行

成功率不劣于原路线

固化落地

不固化 回炉分析

不固化 保留探索

图下解读:固化的判据是双条件:成功率不劣于原路线,且有成本优势(耗时或token)。成功率持平但无成本优势的蒸馏不值得——多一份流程就多一份维护成本。

4.2 对照验证的实现

# 来源:自实现 / distill_verify.py(蒸馏产出对照验证)
def verify_distilled(template_fn, baseline_fn,
                     tasks: list[dict]) -> dict:
    """同一批任务对照两种执行方式"""
    result = {"template": [0, 0], "baseline": [0, 0]}
    for t in tasks:
        for name, fn in (("template", template_fn),
                         ("baseline", baseline_fn)):
            ok = fn(t)
            result[name][0] += int(ok)
            result[name][1] += 1
    t_rate = result["template"][0] / max(result["template"][1], 1)
    b_rate = result["baseline"][0] / max(result["baseline"][1], 1)
    return {"template_rate": round(t_rate, 3),
            "baseline_rate": round(b_rate, 3),
            "not_worse": t_rate >= b_rate - 0.05}

if __name__ == "__main__":
    tasks = [{"id": i} for i in range(10)]
    out = verify_distilled(
        lambda t: t["id"] % 5 != 4,      # 模板:8成成功
        lambda t: t["id"] % 4 != 3,      # 原路线:7成5
        tasks)
    print(out)

源码说明:verify_distilled 的容差设为负五个百分点内视为"不劣"(样本量的噪声容忍),双条件判定交给调用方(not_worse 加成本比较)。测试任务集要覆盖变量的取值范围——只测典型值的验证会漏掉边缘参数下的流程失效。

4.3 验证的样本要求

要素要求理由
任务数量至少二十个五个百分点容差需要足够样本
变量覆盖占位符取值各至少三类边缘参数暴露流程脆弱点
顺序随机两种路线交替执行消除环境漂移干扰

5. 蒸馏产出的落地形态

5.1 三种落地的选择

图:蒸馏产出的三种落地形态

人与模型共同执行

模型高频执行

超高频且稳定

验证通过的流程模板

执行者与频率

SOP文本 入SOP库

提示模板 入技能库

候选微调数据

第4篇的版本管理

第6篇的技能治理

需专项评估 第7节

图下解读:落地形态按执行者与频率选择:SOP 给人机共用,提示模板给模型高频执行,微调数据是"把流程烧进权重"的重型方案(只在超高频且极稳定时考虑)。三种形态都继承蒸馏的验证结论。

5.2 落地为SOP与模板

# 来源:自实现 / distill_land.py(蒸馏产出的落地)
def land_as_sop(template: dict, name: str) -> str:
    """把蒸馏模板渲染为SOP四段结构"""
    params = "、".join(template["params"]) if template.get("params") else "无"
    return (f"【SOP名称】{name}\n"
            f"【前置条件】\n  P1 参数齐备:{params}\n"
            f"【步骤】\n  S1 {template['template']}\n"
            f"【验收标准】\n  A1 按模板各占位符产出核对无误\n"
            f"【异常处理】\n  E1 参数缺失或校验失败 → 停止并报告")

def land_as_prompt(template: dict, name: str) -> str:
    """把蒸馏模板渲染为提示模板"""
    return (f"按以下流程处理,占位符由任务提供:\n"
            f"流程:{template['template']}\n"
            f"参数清单:{list(template.get('params', {}))}")

if __name__ == "__main__":
    tmpl = {"template": "读取{v0}并计算{v1}环比",
            "stable": True,
            "params": {"v0": ["10月.csv"], "v1": ["销量"]}}
    print(land_as_sop(tmpl, "月度环比报表")[:80])
    print("---")
    print(land_as_prompt(tmpl, "环比报表"))

源码说明:land_as_sop 与 land_as_prompt 把验证过的模板分别渲染为 SOP 四段结构与提示模板——落地不只是换个格式,SOP 版本补齐了前置条件与异常处理段(第 4 篇的结构要求)。落地后分别走第 4 篇与第 6 篇的治理机制。

5.3 落地的登记

登记内容用途
来源蒸馏批次号与原料轨迹溯源
验证结论对照实验数据后续复审依据
生效范围适用任务类型与变量域防超范围套用

6. 蒸馏的迭代与失效回收

6.1 蒸馏不是一次定型

环境变化(数据源改版、模板更新、模型升级)会让已固化的流程逐步失效。蒸馏是持续过程:落地流程的执行失败率上升时,收集新的失败轨迹重新蒸馏。

图:流程失效与新一轮蒸馏

正常

上升超阈值

通过

不通过

已固化流程执行中

失败率监控

继续执行

标记流程待复审

收集新轨迹 含失败轨迹

重新对齐与共性提取

新一轮对照验证

替换旧流程 版本升级

回退旧流程 人工介入

图下解读:流程失效不是蒸馏的失败而是蒸馏循环的正常环节:收集新轨迹(这次含失败轨迹作对照)、重新提取、重新验证、版本替换。替换失败时回退旧流程——固化流程也要有回滚能力(第 19 篇的思想在流程层的复用)。

6.2 迭代的实现

# 来源:自实现 / distill_iterate.py(蒸馏迭代与版本替换)
class DistilledFlow:
    """已固化流程的版本管理"""

    def __init__(self):
        self.versions: list[dict] = []

    def deploy(self, template: dict, verify_result: dict):
        self.versions.append({"template": template,
                              "verify": verify_result,
                              "active": True})
        for v in self.versions[:-1]:
            v["active"] = False

    def rollback(self) -> dict | None:
        actives = [v for v in self.versions if v["active"]]
        if len(self.versions) < 2:
            return None
        actives[0]["active"] = False
        prev = self.versions[-2]
        prev["active"] = True
        return prev

if __name__ == "__main__":
    flow = DistilledFlow()
    flow.deploy({"template": "v1流程"}, {"not_worse": True})
    flow.deploy({"template": "v2流程"}, {"not_worse": False})
    print("v2验证未通过,当前激活:",
          [v["template"] for v in flow.versions if v["active"]])
    flow.rollback()
    print("回滚后激活:",
          [v["template"] for v in flow.versions if v["active"]])

源码说明:DistilledFlow 只允许一个激活版本,验证不通过的新版不激活(deploy 时 active 标记由验证结论决定),rollback 回退到上一激活版本。验证不通过的版本留在历史里(分析它为什么不通过是有价值的信息)。

6.3 失效回收的经济账

情形处置
少数变量取值下失效模板加适用条件,不整体废弃
普遍失效整体回炉重新蒸馏
失败轨迹有共性新坑经验沉淀(第 7 篇)并行吸收

7. 蒸馏的边界:什么不该蒸

7.1 不该蒸的四类任务

任务类型原因后果
一次性任务没有复现就无从复用蒸馏纯成本
高变异任务每次条件差异大,无共性可提模板空有骨架全是占位符
探索性任务流程本身就是要发现的东西固化流程扼杀探索
快速演化任务环境变化快于蒸馏周期固化即过时

图:可蒸性与任务特征的关系

否

是

否

是

否

是

任务特征评估

复现频率高吗

不蒸馏 现场执行

条件稳定吗

不蒸馏 只沉淀碎片经验

流程有共性吗

蒸馏 产出稳定流程

图下解读:可蒸性的三问(复现、稳定、有共性)依次淘汰:不复现的蒸了没人用,不稳定的蒸出来就过时,无共性的蒸出来全是变量。三问全过才进入蒸馏管线——蒸馏决策本身也要有纪律。

7.2 微调数据形态的额外边界

蒸馏到微调数据(把流程烧进权重)是重型方案,额外条件:任务超高频(每天数千次)、流程极稳定(半年未变)、模型可自托管。不满足就停在提示模板——微调的成本与返工代价远高于一份模板。

7.3 蒸馏的伦理与审计

关注点处理
轨迹中的敏感信息蒸馏前脱敏(路径、密钥、业务数据)
产出流程的归属记录来源与贡献者,可审计
固化决策的可追溯验证数据随流程版本归档

8. 实战:轨迹蒸馏流水线

8.1 流水线的总装

图:蒸馏流水线的组件串联

否

是

双条件通过

不通过

成功轨迹集

trace_aligner 对齐

extract_template 共性提取

稳定性达标

不蒸馏 沉淀碎片经验

verify_distilled 对照验证

land_as_sop或prompt 落地

回炉 新轨迹再蒸馏

DistilledFlow 版本管理

图下解读:五组件串成完整流水线:对齐、提取、验证、落地、版本管理。稳定性不达标与对照验证不通过各有出口(碎片沉淀与回炉),蒸馏流水线的每个阶段都有"不做"的合法退出。

# 来源:自实现 / distill_pipeline.py(轨迹蒸馏流水线总装)
from trace_aligner import align_traces, STAGE_KEYWORDS
from commonality import extract_template
from distill_verify import verify_distilled
from distill_land import land_as_sop, land_as_prompt
from distill_iterate import DistilledFlow

class DistillPipeline:
    """对齐-提取-验证-落地的蒸馏流水线"""

    def __init__(self, min_success_traces: int = 5):
        self.min_traces = min_success_traces
        self.flow = DistilledFlow()

    def run(self, success_traces: list[list[str]],
            test_tasks: list[dict], template_fn, baseline_fn
            ) -> dict:
        if len(success_traces) < self.min_traces:
            return {"verdict": "原料不足",
                    "note": f"需{self.min_traces}条成功轨迹"}
        aligned = align_traces(success_traces)
        templates = {}
        for stage in STAGE_KEYWORDS:
            steps = aligned.get(stage, [])
            if not steps:
                continue
            t = extract_template(steps)
            if t["stable"]:
                templates[stage] = t
        if not templates:
            return {"verdict": "无稳定阶段", "note": "不宜模板化"}
        # 用执行阶段模板做对照验证
        main = templates.get("执行") or next(iter(templates.values()))
        verify = verify_distilled(template_fn, baseline_fn,
                                  test_tasks)
        verdict = (verify["not_worse"] and
                   len(templates) >= 2)
        if verdict:
            self.flow.deploy(main, verify)
            return {"verdict": "已落地",
                    "sop": land_as_sop(main, "蒸馏流程v1"),
                    "prompt": land_as_prompt(main, "蒸馏流程")}
        return {"verdict": "验证未通过", "verify": verify}

if __name__ == "__main__":
    traces = [
        ["读任务", "读取10月.csv", "计算环比", "核对数字"],
        ["分析目标", "读取11月.csv", "计算环比", "复核结果"],
        ["读要求", "读取12月.csv", "计算环比", "检查输出"],
        ["理解任务", "读取01月.csv", "计算环比", "核对"],
        ["明确目标", "读取02月.csv", "计算环比", "复查"],
    ]
    pipe = DistillPipeline()
    out = pipe.run(traces, [{"id": i} for i in range(10)],
                   template_fn=lambda t: t["id"] % 4 != 3,
                   baseline_fn=lambda t: t["id"] % 3 != 2)
    print("蒸馏结论:", out["verdict"])
    if "sop" in out:
        print(out["sop"].splitlines()[0])

源码说明:DistillPipeline 串起五环节:原料不足直接退出(合法退出点)、对齐归组、逐阶段提取模板(只保留稳定阶段)、执行阶段模板做对照验证、双条件通过才落地登记。落地产出同时渲染 SOP 与提示模板,覆盖两种执行者。约八十行总装,"从轨迹到流程"的完整蒸馏管线齐备。

8.2 指标与监控

指标定义健康值
蒸馏触发率达到原料阈值并启动的比例与任务复现频率匹配
阶段稳定率提取出稳定模板的阶段占比高于六成
对照通过率蒸馏产出首次验证即通过高于五成
落地后失败率固化流程执行的失败占比低于一成
流程失效响应时长失败超阈值到复审的间隔天级

8.3 与后续篇目的衔接

衔接点说明所属篇
验证器对照验证是验证器思想的实例第 9 篇
评测蒸馏收益进入程序性知识评测第 10 篇
技能库落地模板是技能库的顶级供给第 6 篇

总结

程序蒸馏把同型任务多次执行的稳定规律固化成一条流程:后续执行从"现场规划加试错"降为"照章执行",成本降一个量级。原料侧只蒸成功轨迹,对齐按功能阶段归组(理解、准备、执行、验证)而非步骤序号;共性提取分离骨架与占位符,稳定率过半的阶段才可模板化,变量带类型标注供执行前校验。固化的闸门是对照验证:同一批测试任务比较蒸馏流程与原路线,成功率不劣且有成本优势才落地——落地形态按执行者选择(SOP 给人机、模板给模型、微调只留给超高频极稳定)。蒸馏不是一次定型:落地流程的失败率上升触发新一轮蒸馏,含失败轨迹作对照,版本替换带回滚能力。可蒸性三问(复现、稳定、有共性)依次淘汰,一次性、高变异、探索性、快速演化任务不蒸。流水线约八十行总装,对照通过率高于五成、落地后失败率低于一成是健康线。

外部引用

Logo

更多推荐