以下数字为教学示例,不构成对任何真实系统或供应商的承诺。
SFT(监督微调)让 Agent 学会"照着做":给它大量专家轨迹,它学演示里的动作分布。做法朴素,上限也朴素——策略只能学到演示里出现过的行为,只能做得和演示数据一样好。这一节用行为克隆的最小模型把"数据决定上限"量化出来:覆盖决定上限,噪声决定下限,过滤则依赖可验证的轨迹级标签。
模型:四种工单与动作序列
四种工单各有确定的专家动作序列:
| 工单 | 专家动作序列 |
|---|---|
| reset | lookup → validate → update |
| address | lookup → update → notify |
| refund | lookup → validate → notify → update |
| escalate | validate → 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.95 | p=0.99 |
|---|---|---|
| 2 | 0.9025 | 0.9801 |
| 4 | 0.8145 | 0.9606 |
| 8 | 0.6634 | 0.9227 |
| 16 | 0.4401 | 0.8515 |
单步准确率 0.95 的模型,16 步轨迹只有 44% 能整条做对;单步 0.99 的模型,16 步也只有 85%。轨迹越长,完整成功率掉得越快。这就是为什么多步 Agent 任务不能只堆 SFT 数据——行为克隆在决策树深处是会被累积误差拖垮的。
这也解释了 11.1 的关联:为什么需要过程奖励、为什么需要 RL——SFT 只保证"学过演示的动作",不保证"长轨迹能走到终点"。行为克隆的复合误差,正是后面 Agentic RL 要接手的问题。
数据策略的判据
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 覆盖审计 | 逐决策点查演示覆盖 | 只报"演示有多少条" |
| 噪声控制 | 标注噪声有量化 | 噪声未知、无监控 |
| 可验证过滤 | 过滤依赖轨迹级真值 | 过滤靠人工主观 |
| 步级准确率 | 报告 per-step accuracy | 只报端到端成功率 |
| 复合衰减 | 长轨迹成功率显式预估 | 默认短轨迹经验外推 |
“只报端到端成功率"是常见的误报:端到端成功率好,掩盖了某个工单完全没覆盖、某个决策点全靠退化动作。行为克隆评测要拆到决策点级别,否则覆盖缺口永远是黑的。
架构含义
SFT 数据策略对架构有三个直接约束:
- 覆盖是第一步评测。 上线前逐决策点核对演示覆盖,找出退化动作的决策点。
- 噪声要有可验证过滤通道。 能自动验证的轨迹走过滤,不能验证的要人工抽检。
- 长轨迹要配额外机制。 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:偏好与拒绝 。
常见错误与边界
- 只报端到端成功率。 掩盖某个工单完全没覆盖、某决策点全靠退化动作。
- 演示多就以为覆盖全。 条数与决策点覆盖是两回事,escalate 缺席时条数再多也学不会。
- 无条件信任过滤。 过滤依赖轨迹级真值;没有真值的轨迹过滤只是人工筛。
- 短轨迹经验外推。 单步 0.95 在 16 步只剩 44%,别用 2 步结论推长任务。
- 默认动作选"照常执行"。 未覆盖决策点应默认安全动作或明确拒绝,而不是硬做。
- 把 SFT 当全部训练。 复合衰减要 RL 或规划接手,SFT 只保证单步行为。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。