《AI Agent 技术原理与架构·决策、记忆与学习》12.1 SFT:行为克隆与轨迹数据

SFT 的第一课是数据决定上限:策略只能学到演示里出现过的行为。本节用四种工单的确定性动作序列演示三类数据问题——专家覆盖不足、标签噪声、轨迹级成功过滤——并展示步级准确率在长轨迹上如何指数级复合衰减,说明覆盖决定上限、噪声决定下限、过滤依赖可验证标签。

以下数字为教学示例,不构成对任何真实系统或供应商的承诺。

SFT(监督微调)让 Agent 学会"照着做":给它大量专家轨迹,它学演示里的动作分布。做法朴素,上限也朴素——策略只能学到演示里出现过的行为,只能做得和演示数据一样好。这一节用行为克隆的最小模型把"数据决定上限"量化出来:覆盖决定上限,噪声决定下限,过滤则依赖可验证的轨迹级标签。

模型:四种工单与动作序列

四种工单各有确定的专家动作序列:

工单专家动作序列
resetlookup → validate → update
addresslookup → update → notify
refundlookup → validate → notify → update
escalatevalidate → escalate

策略按(工单类型, 步号)做多数投票;没见过的决策点退化为默认动作 lookup。演示数据只覆盖前三种工单,其中 refund 只录到第一步,escalate 完全缺席。这就是"覆盖"的模型:演示没到过的决策点,策略只能用默认动作顶。

三类数据问题的实验

实验比较三种演示数据变体:

变体数据来源
expert干净演示:reset/address 全量,refund 只录第一步,escalate 缺席
noisy-20%上述数据里 20% 的动作被替换成另一个动作(标注噪声)
noisy-filtered带噪数据按"与专家前缀逐字一致"过滤后的结果

运行行为克隆,输出每种变体的覆盖率、每个工单的步级准确率、总准确率与完整成功工单数:

# file: agp_lab/behavior_cloning.py | write
# tier: 3
# verify: python3 -m unittest tests.test_behavior_cloning
"""SFT/行为克隆的数据视角:专家覆盖、标签噪声与分布偏移。

四种工单各自对应一条确定性的动作序列。演示数据只覆盖前三种工单,
其中退款工单只录到第一步。策略按 (工单类型, 步号) 做多数投票;没见
过的决策点退化为默认动作。实验比较干净演示、带噪演示与按轨迹级成
功过滤后的演示,说明覆盖决定上限、噪声决定下限,而过滤依赖可验证
的轨迹级标签。
"""
from __future__ import annotations

import random
from dataclasses import dataclass

ACTIONS = ("lookup", "validate", "update", "notify", "escalate")
FALLBACK = "lookup"

TASKS: tuple[tuple[str, tuple[str, ...]], ...] = (
    ("reset", ("lookup", "validate", "update")),
    ("address", ("lookup", "update", "notify")),
    ("refund", ("lookup", "validate", "notify", "update")),
    ("escalate", ("validate", "escalate")),
)
EXPERT = dict(TASKS)
FULL_DEMO_TASKS = ("reset", "address")
PARTIAL_DEMO_STEPS = {"refund": 1}
TOTAL_STEPS = sum(len(sequence) for _, sequence in TASKS)


@dataclass(frozen=True)
class Trace:
    task: str
    actions: tuple[str, ...]


def build_demos(reps: int = 5) -> list[Trace]:
    """干净演示:reset/address 全量,refund 只录第一步,escalate 缺席。"""
    if reps <= 0:
        raise ValueError("reps 必须为正")
    traces: list[Trace] = []
    for task in FULL_DEMO_TASKS:
        for _ in range(reps):
            traces.append(Trace(task, EXPERT[task]))
    for task, prefix in PARTIAL_DEMO_STEPS.items():
        for _ in range(reps):
            traces.append(Trace(task, EXPERT[task][:prefix]))
    return traces


def fit(traces: list[Trace]) -> dict[tuple[str, int], str]:
    """按决策点做多数投票,平票时取 ACTIONS 中靠前的动作。"""
    if not traces:
        raise ValueError("演示不能为空")
    counts: dict[tuple[str, int], dict[str, int]] = {}
    for trace in traces:
        for step, action in enumerate(trace.actions):
            if action not in ACTIONS:
                raise ValueError(f"未知动作: {action}")
            bucket = counts.setdefault((trace.task, step), {})
            bucket[action] = bucket.get(action, 0) + 1
    policy: dict[tuple[str, int], str] = {}
    for key, bucket in counts.items():
        policy[key] = max(ACTIONS, key=lambda action: (bucket.get(action, 0), -ACTIONS.index(action)))
    return policy


def predict(policy: dict[tuple[str, int], str], task: str, step: int) -> str:
    return policy.get((task, step), FALLBACK)


def evaluate(policy: dict[tuple[str, int], str], task: str) -> bool:
    sequence = EXPERT[task]
    return all(predict(policy, task, step) == action for step, action in enumerate(sequence))


def coverage(policy: dict[tuple[str, int], str]) -> float:
    covered = sum(
        1
        for task, sequence in TASKS
        for step in range(len(sequence))
        if (task, step) in policy
    )
    return covered / TOTAL_STEPS


def corrupt(traces: list[Trace], rate: float, rng: random.Random) -> list[Trace]:
    """以 rate 的概率把单个动作替换成另一个动作,模拟标注噪声。"""
    if not 0.0 <= rate <= 1.0:
        raise ValueError("rate 必须在 [0, 1] 内")
    corrupted: list[Trace] = []
    for trace in traces:
        actions = []
        for action in trace.actions:
            if rng.random() < rate:
                alternatives = [candidate for candidate in ACTIONS if candidate != action]
                action = alternatives[rng.randrange(len(alternatives))]
            actions.append(action)
        corrupted.append(Trace(trace.task, tuple(actions)))
    return corrupted


def filter_success(traces: list[Trace]) -> list[Trace]:
    """只保留与专家前缀逐字一致的成功轨迹。"""
    kept = []
    for trace in traces:
        prefix = EXPERT[trace.task][: len(trace.actions)]
        if trace.actions == prefix:
            kept.append(trace)
    return kept


def compounding(per_step_accuracy: float, steps: int) -> float:
    if not 0.0 <= per_step_accuracy <= 1.0:
        raise ValueError("accuracy 必须在 [0, 1] 内")
    if steps < 1:
        raise ValueError("steps 必须大于 0")
    return per_step_accuracy ** steps


def step_accuracy(policy: dict[tuple[str, int], str], task: str) -> float:
    sequence = EXPERT[task]
    correct = sum(
        1 for step, action in enumerate(sequence) if predict(policy, task, step) == action
    )
    return correct / len(sequence)


def summary(policy: dict[tuple[str, int], str]) -> dict[str, float]:
    return {task: step_accuracy(policy, task) for task, _ in TASKS}


def exact_success(policy: dict[tuple[str, int], str]) -> int:
    return sum(1 for task, _ in TASKS if evaluate(policy, task))


def _print_variants() -> None:
    clean = build_demos(2)
    noisy = corrupt(clean, 0.20, random.Random(13))
    variants = (
        ("expert", clean),
        ("noisy-20%", noisy),
        ("noisy-filtered", filter_success(noisy)),
    )
    header = f"{'variant':<16}{'cov':>6}" + "".join(f"{task:>10}" for task, _ in TASKS)
    print(header + f"{'step':>8}{'exact':>8}")
    for name, traces in variants:
        policy = fit(traces)
        scores = summary(policy)
        total = sum(scores[task] * len(EXPERT[task]) for task in scores) / TOTAL_STEPS
        print(
            f"{name:<16}{coverage(policy):>6.2f}"
            + "".join(f"{scores[task]:>10.2f}" for task, _ in TASKS)
            + f"{total:>8.2f}{exact_success(policy):>6}/4"
        )


if __name__ == "__main__":
    _print_variants()
    print()
    print(f"{'steps':>6}{'p=0.95':>10}{'p=0.99':>10}")
    for steps in (2, 4, 8, 16):
        print(f"{steps:>6}{compounding(0.95, steps):>10.4f}{compounding(0.99, steps):>10.4f}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.behavior_cloning

输出:

variant            cov     reset   address    refund  escalate    step   exact
expert            0.58      1.00      1.00      0.25      0.00    0.58     2/4
noisy-20%         0.58      1.00      0.67      0.25      0.00    0.50     1/4
noisy-filtered    0.58      1.00      1.00      0.25      0.00    0.58     2/4

 steps    p=0.95    p=0.99
     2    0.9025    0.9801
     4    0.8145    0.9606
     8    0.6634    0.9227
    16    0.4401    0.8515

覆盖决定上限

第一张表最扎眼的是 escalate 一列:三行全是 0.00。为什么?因为演示数据里 escalate 从来没有出现过,策略在 (escalate, 0) 这个决策点上只能退化到默认动作 lookup,而专家第一步是 validate——所以 escalate 的正确率是 0。这不是训练不充分,是数据根本没给它学的机会。

同理 refund 只有 0.25:演示只录到第一步 lookup(正确),第二、三步 validate、notify 是多数投票里没有的,全部退化到 lookup。所以 4 步里只有 1 步对。

覆盖决定上限的含义:Agent 能学会什么,止步于演示涵盖了什么。要让 escalate 达到 1.00,必须给演示加入 escalate 轨迹——任何损失函数、任何训练技巧都替代不了"数据里没有"。

噪声决定下限

对比 expert 与 noisy-20% 两行:cov 不变(0.58),但 address 从 1.00 掉到 0.67,总准确率从 0.58 掉到 0.50,完整成功的工单从 2/4 掉到 1/4。

原因在多数投票:address 的专家序列是 lookup → update → notify,三步各被投票 5 次;20% 的噪声把部分投票改成了错误动作,使某个决策点的多数票被噪声翻转。于是 address 的第一步还是 lookup(多数没翻),但后面某步翻成了错误动作,完整轨迹失败。

噪声决定下限的含义:噪声不改变覆盖,却压低策略在已覆盖决策点上的准确率,还可能把完整成功变成部分成功。标注噪声是行为克隆的下限压制器。

过滤依赖可验证的轨迹级标签

noisy-filtered 是带噪数据过滤后的结果:只保留"与专家前缀逐字一致"的成功轨迹。它的成绩回到了 expert 的水平——address 回到 1.00,总准确率 0.58,完整成功 2/4。

关键不是"过滤有用",而是过滤的前提:这个变体凭什么能从带噪数据里挑出好轨迹?凭的是"轨迹级标签"——每条轨迹都有一个可验证的、与专家前缀逐字一致的判据。这正是 Agent 数据和图像标注数据的区别:不是每条 Agent 轨迹都有客观真值。能验证的轨迹(代码测试通过、任务结果可查)才谈得上过滤;只有人工评分、无客观结果的轨迹,过滤就是人工筛,成本回到人身上。

长轨迹的复合衰减

第二张表是行为克隆的第二个通用教训——步级准确率在长轨迹上指数复合:

步数p=0.95p=0.99
20.90250.9801
40.81450.9606
80.66340.9227
160.44010.8515

单步准确率 0.95 的模型,16 步轨迹只有 44% 能整条做对;单步 0.99 的模型,16 步也只有 85%。轨迹越长,完整成功率掉得越快。这就是为什么多步 Agent 任务不能只堆 SFT 数据——行为克隆在决策树深处是会被累积误差拖垮的。

这也解释了 11.1 的关联:为什么需要过程奖励、为什么需要 RL——SFT 只保证"学过演示的动作",不保证"长轨迹能走到终点"。行为克隆的复合误差,正是后面 Agentic RL 要接手的问题。

数据策略的判据

判据合格的样子不合格的样子
覆盖审计逐决策点查演示覆盖只报"演示有多少条"
噪声控制标注噪声有量化噪声未知、无监控
可验证过滤过滤依赖轨迹级真值过滤靠人工主观
步级准确率报告 per-step accuracy只报端到端成功率
复合衰减长轨迹成功率显式预估默认短轨迹经验外推

“只报端到端成功率"是常见的误报:端到端成功率好,掩盖了某个工单完全没覆盖、某个决策点全靠退化动作。行为克隆评测要拆到决策点级别,否则覆盖缺口永远是黑的。

架构含义

SFT 数据策略对架构有三个直接约束:

  1. 覆盖是第一步评测。 上线前逐决策点核对演示覆盖,找出退化动作的决策点。
  2. 噪声要有可验证过滤通道。 能自动验证的轨迹走过滤,不能验证的要人工抽检。
  3. 长轨迹要配额外机制。 SFT 之外预留 RL/搜索等机制对抗复合衰减,不能指望数据本身。

第 3 条决定了 SFT 在整体训练中的位置:SFT 是起点不是终点。它让 Agent 学会单步动作;多步可靠要走 RL 或加规划。

与三条工作负载的关系

  • W1 检索问答:覆盖风险在长问答轨迹,检索步骤是 lookup 类动作,缺覆盖会静默退化。
  • W2 代码修复:过滤有天然真值(测试通过),是"可验证过滤"最好的场景。
  • W3 运维处置:覆盖风险最致命——没演示过的处置决策点退化为默认动作,可能在真实系统上做出错误操作。

W3 的教训:运维处置的演示数据天然稀缺,覆盖缺口多。对 W3,行为克隆的默认动作要选"安全且明确拒绝”,而不是"照常执行"——覆盖不到的动作,宁可放弃也不能硬做。这也呼应 10.3 的放弃动作。

小结

  • 策略只能学到演示里出现过的行为,覆盖决定上限。
  • 20% 的标注噪声把完整成功从 2/4 压到 1/4:噪声决定下限。
  • 过滤有用,但它依赖可验证的轨迹级标签,人工标注的轨迹没这条件。
  • 单步 0.95 的模型,16 步轨迹只有 44% 完整成功:长轨迹指数复合衰减。
  • 评测要拆到决策点,端到端成功率会掩盖覆盖缺口。
  • SFT 是起点不是终点,多步可靠要 RL 或规划接手。

阅读导航:上一节:11.3 信用分配的局限与评测 · 下一节:12.2 RLHF/DPO:偏好与拒绝 。

常见错误与边界

  1. 只报端到端成功率。 掩盖某个工单完全没覆盖、某决策点全靠退化动作。
  2. 演示多就以为覆盖全。 条数与决策点覆盖是两回事,escalate 缺席时条数再多也学不会。
  3. 无条件信任过滤。 过滤依赖轨迹级真值;没有真值的轨迹过滤只是人工筛。
  4. 短轨迹经验外推。 单步 0.95 在 16 步只剩 44%,别用 2 步结论推长任务。
  5. 默认动作选"照常执行"。 未覆盖决策点应默认安全动作或明确拒绝,而不是硬做。
  6. 把 SFT 当全部训练。 复合衰减要 RL 或规划接手,SFT 只保证单步行为。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图