《AI Agent 技术原理与架构·决策、记忆与学习》11.2 归因方法:反事实、Shapley 与启发式

轨迹奖励只给一个总数,功劳要分到每个动作上。本节在五步小轨迹上比较精确归因(反事实、Shapley)与启发式(末步、均分),模型小到可精确枚举。实验展示 Shapley 满足效率性、能识别权重为零的无用步骤,而反事实低估互补步骤、启发式把功劳错分给无贡献步骤。

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

轨迹奖励把整条轨迹的成功缩成一个数。可有了这个数,还有一个问题没解决:这个功劳属于谁? 五个动作里,哪个才是"做成这件事"的关键?这个分配过程叫信用归因,它决定过程奖励怎么发、失败复盘怎么归责、轨迹怎么解释。

这一节把一次轨迹抽象成集合函数:五个步骤各自以一定概率贡献一个可验证的分数,总分达到阈值才算任务成功。模型小到可以精确枚举,所以四种归因方法的差异是可计算的数字,不是叙事。

模型:五步轨迹与集合函数

实验里的轨迹有五个步骤:

步骤成功概率 p权重语义
fetch0.901.0取回数据
log_intent1.000.0记录意图(可选动作)
verify0.801.0校验
draft0.701.0起草
send0.951.0发送

每个步骤独立地以概率 p 成功并贡献权重,总分达到阈值 2 即任务成功。log_intent 的权重是 0:它是不该拿到任何功劳的步骤——做不做都不影响成功。这是埋给归因方法的陷阱,用来检验哪种方法会犯糊涂。

两种精确归因

反事实归因问的问题是"把这步拿掉会怎样":

$$ \text{cf}_i = v(\text{全部步骤}) - v(\text{去掉步骤 } i) $$

全轨迹价值减去"单独移除该步"后的价值。直觉是:如果拿走这步任务基本不受影响,它就没贡献;如果拿走任务就塌了,它就是功臣。

Shapley 归因问的是"这步对所有可能合作方式的平均边际贡献":

$$ \phi_i = \sum_{S \subseteq \text{others}} \frac{|S|!(n-|S|-1)!}{n!} \left[ v(S \cup {i}) - v(S) \right] $$

它枚举全部子集,把"加入这步带来的价值增量"按组合数加权平均。Shapley 有两个性质值得记住:

  1. 效率性:所有步骤的功劳之和恰好等于总价值,不多不少;
  2. 对称性:两个贡献完全相同的步骤拿到相同份额。

反事实是"拿掉一步看损失",Shapley 是"一步在所有场景下的平均边际贡献"。对模型大到无法精确枚举的真实系统,Shapley 要采样估计,这是它的成本;反事实简单,但下面会看到它有系统性偏差。

两种启发式

启发式不做精确计算,图快:

  • 末步启发式:把全部功劳给最后一步。理由是"最后一步是临门一脚",但真实轨迹里最后的动作常常是发送这类收尾动作;
  • 均分启发式:每步拿相同份额。完全无视步骤差异。

启发式的吸引力是便宜、不需要模型、一行代码就能给每个动作记一笔功劳。它们的代价是准确性,实验里马上能看到。

最小实验:四种方法同台

下面的实验在五步轨迹上同时跑四种归因,输出每步分到的功劳与总账。

# file: agp_lab/credit_attribution.py | write
# tier: 3
# verify: python3 -m unittest tests.test_credit_attribution
"""小轨迹上的信用归因:反事实、Shapley 与两种启发式。

把一次轨迹抽象成集合函数:五个步骤各自以一定概率贡献一个可验证
的分数,任务成功定义为总分达到阈值 2。记录意图是可选步骤,权重为
0,因此它不该拿到任何功劳。模型小到可以精确枚举,所以三种归因方
法的差异是可计算的,而不是叙事。
"""
from __future__ import annotations

from collections.abc import Collection, Sequence
from dataclasses import dataclass
from itertools import combinations, product
from math import factorial

THRESHOLD = 2.0


@dataclass(frozen=True)
class Step:
    name: str
    prob: float
    weight: float


STEPS: tuple[Step, ...] = (
    Step("fetch", 0.90, 1.0),
    Step("log_intent", 1.00, 0.0),
    Step("verify", 0.80, 1.0),
    Step("draft", 0.70, 1.0),
    Step("send", 0.95, 1.0),
)
ALL_STEPS = frozenset(range(len(STEPS)))


def trajectory_value(selected: Collection[int]) -> float:
    """执行 selected 中的步骤时任务成功的概率。

    每个被选中的步骤独立地以 p 成功并贡献 weight;总分达到阈值即成功。
    空集与单步子集的分数都低于阈值,因此价值为 0。
    """
    chosen = frozenset(selected)
    if any(index < 0 or index >= len(STEPS) for index in chosen):
        raise ValueError("步骤下标越界")
    ordered = sorted(chosen)
    value = 0.0
    for outcomes in product((True, False), repeat=len(ordered)):
        probability = 1.0
        score = 0.0
        for index, succeeded in zip(ordered, outcomes):
            step = STEPS[index]
            probability *= step.prob if succeeded else 1.0 - step.prob
            if succeeded:
                score += step.weight
        if score >= THRESHOLD:
            value += probability
    return value


def shapley_credits() -> list[float]:
    """精确 Shapley:枚举全部子集,满足效率性 sum(phi) = v(全集) - v(空集)。"""
    count = len(STEPS)
    credits = [0.0] * count
    for index in range(count):
        others = [other for other in range(count) if other != index]
        total = 0.0
        for size in range(count):
            weight = factorial(size) * factorial(count - size - 1) / factorial(count)
            for subset in combinations(others, size):
                coalition = frozenset(subset)
                total += weight * (
                    trajectory_value(coalition | {index}) - trajectory_value(coalition)
                )
        credits[index] = total
    return credits


def counterfactual_credits() -> list[float]:
    """反事实:完整轨迹的价值减去“单独移除该步”后的价值。"""
    full_value = trajectory_value(ALL_STEPS)
    return [
        full_value - trajectory_value(ALL_STEPS - {index})
        for index in range(len(STEPS))
    ]


def last_step_credits() -> list[float]:
    """末步启发式:把全部功劳给最后一步。"""
    credits = [0.0] * len(STEPS)
    credits[-1] = trajectory_value(ALL_STEPS)
    return credits


def uniform_credits() -> list[float]:
    """均分启发式:每步拿相同的份额。"""
    share = trajectory_value(ALL_STEPS) / len(STEPS)
    return [share] * len(STEPS)


def recency_credits(decay: float = 0.5) -> list[float]:
    """近因启发式:越靠后的步骤权重越大,总和等于轨迹价值。"""
    if not 0.0 < decay <= 1.0:
        raise ValueError("decay 必须在 (0, 1] 内")
    count = len(STEPS)
    weights = [decay ** (count - 1 - index) for index in range(count)]
    total = sum(weights)
    full_value = trajectory_value(ALL_STEPS)
    return [full_value * weight / total for weight in weights]


@dataclass(frozen=True)
class Row:
    name: str
    prob: float
    shapley: float
    counterfactual: float
    last_step: float
    uniform: float


def attribution_table() -> list[Row]:
    methods = (
        shapley_credits(),
        counterfactual_credits(),
        last_step_credits(),
        uniform_credits(),
    )
    return [
        Row(STEPS[index].name, STEPS[index].prob, *(method[index] for method in methods))
        for index in range(len(STEPS))
    ]


def _print_method_table(rows: Sequence[Row]) -> None:
    print(f"{'step':<12}{'p':>6}{'shapley':>10}{'cf':>10}{'last':>10}{'uniform':>10}")
    for row in rows:
        print(
            f"{row.name:<12}{row.prob:>6.2f}{row.shapley:>10.4f}"
            f"{row.counterfactual:>10.4f}{row.last_step:>10.4f}{row.uniform:>10.4f}"
        )
    full_value = trajectory_value(ALL_STEPS)
    print(
        f"{'total':<12}{'-':>6}{sum(r.shapley for r in rows):>10.4f}"
        f"{sum(r.counterfactual for r in rows):>10.4f}"
        f"{sum(r.last_step for r in rows):>10.4f}"
        f"{sum(r.uniform for r in rows):>10.4f}"
    )
    print(f"trajectory value: {full_value:.4f}")


if __name__ == "__main__":
    _print_method_table(attribution_table())

运行:

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

输出:

step             p   shapley        cf      last   uniform
fetch         0.90    0.2706    0.0684    0.0000    0.1979
log_intent    1.00    0.0000    0.0000    0.0000    0.1979
verify        0.80    0.2324    0.0364    0.0000    0.1979
draft         0.70    0.1969    0.0224    0.0000    0.1979
send          0.95    0.2894    0.0874    0.9894    0.1979
total            -    0.9894    0.2146    0.9894    0.9894
trajectory value: 0.9894

这张表是四种归因的完整对比,四条结论。

Shapley 的总账正好等于轨迹价值。 total 行 0.9894 = 0.2706 + 0 + 0.2324 + 0.1969 + 0.2894,而最下面 trajectory value: 0.9894。效率性成立:功劳没多分也没漏分。它的排序也符合直觉——send 最高(0.2894),draft 最低(0.1969)。

Shapley 和反事实都给了 log_intent 0。 权重为 0 的步骤在两种精确方法下拿不到任何功劳。这是精确归因最漂亮的性质:无用步骤不被记功。观察者只看轨迹会以为"记录意图也是动作之一",但归因计算直接指出它对结果零贡献。

反事实系统性低估了每个步骤。 cf 列所有值都远小于 Shapley:fetch 只有 0.0684,send 只有 0.0874,总和 0.2146 只是轨迹价值的五分之一。原因在于互补性——五步相互补位,单独拿掉一步,其余四步联合起来仍大概率成功,于是"拿掉这步的损失"被低估。反事实适合问"哪一步是咽喉",不适合做功劳分配。

启发式各有一个方向性的错。 末步把全部功劳堆给 send(0.9894),把 fetch、verify、draft 全部清零——它错在"临门一脚"幻觉,前四步对 fetch 0.90 成功率毫无功劳;均分给 log_intent 也发了 0.1979——它错在"平均主义",连无用步骤都记功。启发式的错不是数值误差,是归因目标错了。

归因方法的选择判据

判据合格的样子不合格的样子
效率性功劳之和等于轨迹价值总和与价值对不上
无用步骤归零权重 0 的步骤记 0 功平均主义发奖励
互补可识别能区分咽喉与功劳反事实把功劳都摊薄
可计算成本模型小则精确,大则采样大模型上昂贵到放弃
可解释方法原理可复述黑盒评分

“无用步骤归零"是最容易忽略的一条:如果你用启发式归因去做过程奖励,log_intent 这类"陪着跑了全程"的动作会拿到持续奖励,Agent 就会学会把无用的动作塞满轨迹——因为归因方法会把自己认可的行为模式变成奖励信号。

归因的用途与误用

信用归因在 Agent 系统里至少有四个用途:

  1. 过程奖励的替代信号:没有逐点标注时,把轨迹价值按归因拆回各步;
  2. 失败复盘:某条轨迹失败了,看哪一步的反事实损失最大;
  3. 可解释性:回答"为什么给它功劳”,给审计留依据;
  4. 冗余检测:长期归因几乎为零的步骤,考虑从流程里删掉。

误用的典型是把归因结果当"因果证据"。归因是在既定轨迹上的分配,它回答"功劳怎么分才公平",不回答"如果换了动作轨迹会怎样"。反事实归因做的是"拿掉这一步",它做的是反事实,但它只能在观测到的步骤集合内做反事实——轨迹外从来没用过的动作,不在任何归因方法的视野里。

架构含义

信用归因对架构有三个直接约束:

  1. 归因方法要显式声明。 用 Shapley 还是末步,是架构决策,不是实现细节;它决定了奖励会鼓励什么行为。
  2. 无用步骤要有记录。 如果存在 log_intent 这类可选动作,归因要能把它分出来归零,否则它就是奖励漏洞。
  3. 过程奖励与轨迹奖励要同源。 过程奖励如果和轨迹归因不一致,Agent 会被两个信号互相拉扯。

第 2 条最隐蔽:很多系统根本没想过"某个动作可能是无用的",它们默认所有步骤都有价值。归因实验的价值就在于把"无用步骤"显式暴露出来。

与三条工作负载的关系

  • W1 检索问答:归因用于"这条回答里哪个检索证据起了作用",可用反事实做定性检查。
  • W2 代码修复:归因用于"这次修复哪个操作真正消除了失败",防"改了又改"的表演性工作。
  • W3 运维处置:归因最危险,把功劳错记给复核类动作,会把"多复核"变成奖励目标;W3 要倾向精确归因。

W3 的教训:运维处置里大量动作是"陪着执行"的记录类、审计类步骤,权重天然为 0。用均分类启发式给它们发奖励,等于训练 Agent 多做审计动作而不做处置——归因方法在这里直接决定行为。

小结

  • 轨迹奖励拿到一个数后,功劳要分到每个动作上,这叫信用归因。
  • Shapley 枚举全部子集取平均边际贡献,满足效率性,能识别无用步骤。
  • 反事实是"拿掉一步看损失",简单但会因互补性系统性低估功劳。
  • 末步启发式把功劳全给最后一步,均分启发式把功劳发给了无用步骤。
  • 精确方法适合模型小到可枚举的场景,启发式便宜但要接受方向性偏差。
  • 归因是分配不是因果:它回答"功劳怎么分",不回答"换了动作会怎样"。

阅读导航:上一节:11.1 轨迹奖励与过程奖励 · 下一节:11.3 信用分配的局限与评测 。

常见错误与边界

  1. 用末步启发式做过程奖励。 临门一脚幻觉:前序步骤功劳全清零,Agent 会学会不做前置工作。
  2. 均分发奖励。 无用步骤也拿份额,等于主动奖励"陪着跑"的动作。
  3. 把反事实当功劳分配。 互补步骤会被系统性低估,总和与轨迹价值对不上。
  4. 归因范围限于观测轨迹。 没用过的动作不在视野里,“如果换了策略会怎样"答不了。
  5. 把归因当因果证据。 归因是既定轨迹上的分配,不是策略因果。
  6. 归因方法与奖励不同源。 过程奖励和轨迹归因打架,Agent 被两个信号互相拉扯。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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