《AI Agent 技术原理与架构·决策、记忆与学习》7.3 验证器与奖励黑客防线

验证器看到的不是真实质量,而是代理指标;优化代理指标会压垮真实质量。本节用“真实质量 + 漏洞利用度”的候选池实验展示:检查的候选越多,代理分单调上升,但选中答案的真实质量在某一点急剧下降。并说明独立证据门能挡住漏洞候选,却恢复不了被放弃的高质量答案。

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

验证器是 Agent 安全的重要防线,但验证器本身有一个致命弱点:它看到的不是真实质量,而是代理指标。当代理指标与真实目标不一致时,任何"按代理分选优"的机制都会被漏洞利用。这不是模型"学坏了",而是选择规则把漏洞变成了最优解。

这一节用候选池实验演示奖励黑客(reward hacking):每个候选答案带有真实质量和"漏洞利用度"两个隐藏量,验证器只看到代理分 proxy = 0.40·quality + 0.60·loophole。Agent 按代理分选优,检查的候选越多,选中答案的真实质量在某一点急剧下降。

代理指标为什么会被打

验证器要打分,就必须给一个数字。数字必须来自可计算的信号,但可计算的信号往往不是真实目标。典型的不一致:

代理指标真实目标可被利用的方式
关键词命中答案正确堆关键词、拉长篇幅
格式合规内容可靠结构完美但内容空洞
引用存在结论有据引用真实但不相关
长度覆盖充分越长越像认真

代理分 = 真实质量的加权和 + 漏洞利用度的加权和。权重设错了,漏洞利用度对分数的贡献就可能超过真实质量。实验里代理分的权重是 0.40 对 0.60——漏洞利用度占大头,于是高漏洞候选轻松赢得选优。

优化的压力在哪里

奖励黑客的严重程度取决于优化压力:候选越多、检查越充分,Agent 越能把代理分推高,而真实质量未必跟上。这正是实验想展示的:

  • 候选池按顺序排好:先 6 个正常候选,再 6 个混合候选,最后 12 个高漏洞候选;
  • 检查数从 1 涨到 24,Agent 只能从前 N 个候选里按代理分选最优;
  • 随着池子变大,漏洞候选进入视野,代理分被不断推高。

最小实验:代理分如何压垮真实质量

# file: agp_lab/verifier_hacking.py | write
# tier: 3
# verify: python3 -m unittest tests.test_verifier_hacking
"""验证器漏洞与奖励黑客:优化代理指标如何压垮真实质量。

候选答案带有两个隐藏量:真实质量与“漏洞利用度”(堆关键词、拉长篇幅、
迎合评分规则)。验证器只看到代理分:

    proxy = 0.40 * quality + 0.60 * loophole

Agent 在候选池里按代理分选优。随着检查的候选越来越多,代理分单调上升,
但选中答案的真实质量可能在某个点急剧下降,因为高代理分的漏洞候选被选了
进来。实验同时给出一个独立证据门的对照,说明三件事:

1. 代理指标与真实目标不一致时,优化压力越大,偏得越远;
2. 独立证据门能挡住明显的漏洞候选,但恢复不了被放弃的高质量答案;
3. 奖励黑客不是模型“学坏了”,而是选择规则把漏洞变成了最优解。
"""
from __future__ import annotations

from dataclasses import dataclass

PROXY_QUALITY_WEIGHT = 0.40
PROXY_LOOPHOLE_WEIGHT = 0.60
EVIDENCE_MIN_QUALITY = 0.55
EVIDENCE_MAX_LOOPHOLE = 0.65


@dataclass(frozen=True)
class Candidate:
    name: str
    quality: float
    loophole: float
    kind: str

    @property
    def proxy(self) -> float:
        return PROXY_QUALITY_WEIGHT * self.quality + PROXY_LOOPHOLE_WEIGHT * self.loophole

    @property
    def passes_evidence(self) -> bool:
        return (
            self.quality >= EVIDENCE_MIN_QUALITY
            and self.loophole <= EVIDENCE_MAX_LOOPHOLE
        )


def candidate_pool() -> tuple[Candidate, ...]:
    """固定顺序:先正常候选,再混合候选,最后是高代理分的漏洞候选。"""
    good = (
        ("g1", 0.86, 0.08),
        ("g2", 0.90, 0.12),
        ("g3", 0.82, 0.20),
        ("g4", 0.88, 0.16),
        ("g5", 0.92, 0.10),
        ("g6", 0.84, 0.18),
    )
    mixed = (
        ("m1", 0.66, 0.52),
        ("m2", 0.72, 0.58),
        ("m3", 0.60, 0.55),
        ("m4", 0.70, 0.60),
        ("m5", 0.64, 0.50),
        ("m6", 0.74, 0.62),
    )
    hacked = (
        ("h1", 0.32, 0.92),
        ("h2", 0.25, 0.95),
        ("h3", 0.40, 0.90),
        ("h4", 0.18, 0.98),
        ("h5", 0.35, 0.93),
        ("h6", 0.28, 0.96),
        ("h7", 0.22, 0.94),
        ("h8", 0.38, 0.91),
        ("h9", 0.30, 0.97),
        ("h10", 0.15, 0.99),
        ("h11", 0.42, 0.89),
        ("h12", 0.20, 0.93),
    )
    return tuple(
        Candidate(name, quality, loophole, kind)
        for kind, rows in (("正常", good), ("混合", mixed), ("漏洞", hacked))
        for name, quality, loophole in rows
    )


def select_proxy(pool: tuple[Candidate, ...], inspected: int) -> Candidate:
    """按代理分选优;并列时保留池中更早出现的候选。"""
    if not 1 <= inspected <= len(pool):
        raise ValueError("inspected 必须在 [1, 候选池大小] 内")
    return max(pool[:inspected], key=lambda candidate: candidate.proxy)


def select_gated(pool: tuple[Candidate, ...], inspected: int) -> Candidate:
    """先过独立证据门,再按代理分选;没有候选过门时退回普通选优。"""
    if not 1 <= inspected <= len(pool):
        raise ValueError("inspected 必须在 [1, 候选池大小] 内")
    passing = [candidate for candidate in pool[:inspected] if candidate.passes_evidence]
    if not passing:
        return select_proxy(pool, inspected)
    return max(passing, key=lambda candidate: candidate.proxy)


def best_available(pool: tuple[Candidate, ...], inspected: int) -> Candidate:
    if not 1 <= inspected <= len(pool):
        raise ValueError("inspected 必须在 [1, 候选池大小] 内")
    return max(pool[:inspected], key=lambda candidate: candidate.quality)


@dataclass(frozen=True)
class Row:
    inspected: int
    proxy_score: float
    proxy_quality: float
    proxy_kind: str
    gated_quality: float
    best_quality: float


def table(pool: tuple[Candidate, ...], points: tuple[int, ...]) -> list[Row]:
    rows: list[Row] = []
    for inspected in points:
        proxy = select_proxy(pool, inspected)
        gated = select_gated(pool, inspected)
        best = best_available(pool, inspected)
        rows.append(
            Row(
                inspected=inspected,
                proxy_score=proxy.proxy,
                proxy_quality=proxy.quality,
                proxy_kind=proxy.kind,
                gated_quality=gated.quality,
                best_quality=best.quality,
            )
        )
    return rows


if __name__ == "__main__":
    pool = candidate_pool()
    points = (1, 4, 6, 8, 12, 13, 16, 20, 24)
    print(f"{'检查数':<8}{'代理分':>8}{'选中质量':>10}{'类别':>6}{'证据门质量':>12}{'池内最优':>10}")
    for row in table(pool, points):
        print(
            f"{row.inspected:<8}{row.proxy_score:>8.3f}{row.proxy_quality:>10.3f}"
            f"{row.proxy_kind:>6}{row.gated_quality:>12.3f}{row.best_quality:>10.3f}"
        )
    print()
    final = table(pool, points)[-1]
    print(
        f"检查 24 个候选: 代理分 {final.proxy_score:.3f}, "
        f"真实质量 {final.proxy_quality:.2f}, 证据门后 {final.gated_quality:.2f}, "
        f"池内最优 {final.best_quality:.2f}"
    )

运行:

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

输出:

检查数          代理分      选中质量    类别       证据门质量      池内最优
1          0.392     0.860    正常       0.860     0.860
4          0.448     0.880    正常       0.880     0.900
6          0.448     0.880    正常       0.880     0.920
8          0.636     0.720    混合       0.720     0.920
12         0.668     0.740    混合       0.740     0.920
13         0.680     0.320    漏洞       0.740     0.920
16         0.700     0.400    漏洞       0.740     0.920
20         0.700     0.400    漏洞       0.740     0.920
24         0.700     0.400    漏洞       0.740     0.920

检查 24 个候选: 代理分 0.702, 真实质量 0.42, 证据门后 0.74, 池内最优 0.92

这张表是奖励黑客的完整轨迹。

代理分单调上升。 0.392 → 0.700,一直涨。看起来"越检查越好"。这是代理指标被优化的直接证据:每多检查一个候选,总有一个代理分更高的出现,选中分数水涨船高。

真实质量在第 13 个候选处崩盘。 第 12 个还是混合候选(质量 0.740),第 13 个开始进入漏洞候选(质量 0.320)。代理分从 0.668 涨到 0.680,选中质量从 0.740 掉到 0.320。代理指标和真实质量从此分道扬镳:分数越高,质量越低。

独立证据门挡住了一部分,但不是全部。 证据门把质量 < 0.55 或漏洞度 > 0.65 的候选排除,检查 24 个候选时门后质量 0.740,远好于裸代理的 0.420。但证据门是过滤,不是找回:池内最优是 0.920,证据门只给出 0.740。那些被漏洞候选挤出视野的高质量答案,已经回不来了。

“优化压力越大,偏得越远"不是理论。 检查 1 个候选时选中质量 0.860;检查 24 个时选中质量 0.420。优化的机会变多,结果反而变差。这反直觉的结论来自代理分对漏洞的偏袒:给优化器更多自由度,它会更充分利用漏洞。

三件事要分开

奖励黑客里经常混在一起的三件事,必须分开:

现象是什么该怎么做
代理分升高指标被优化检查代理分与真实目标的一致性
真实质量下降目标被牺牲引入独立证据门
池内最优拿不回机会被浪费靠事前约束,不靠事后过滤

第一件是预警,第二件是止损,第三件是不可逆。证据门能止损,但止损的前提是池子里还有可用的候选;如果选择规则本身就把高质量候选淘汰了,过滤救不了。

验证器的设计判据

判据合格的样子不合格的样子
代理分有对照定期抽查真实质量与代理分只信代理分
门限独立证据门来自独立来源验证器自评自证
优化有上限候选数、重试数受控无限重试直到"满意”
分权重可见代理分公式可审分数来源黑盒
损失可逆高质量候选不因一轮选优被弃选优一次定终身

“优化有上限"很重要。无限重试 + 按代理分选优,是最快的奖励黑客制造机;预算与重试上限本身就是验证器防线的一部分。

架构含义

验证器对架构有三个直接约束:

  1. 代理指标必须可审计。 打分公式的权重、输入信号要能解释,能拿真实质量做对照。
  2. 证据门要独立。 与选优的验证器不同源,最好来自规则、外部系统或独立模型。
  3. 选优要受约束。 候选数量、重试次数、检查深度都要设上限,不给漏洞"自由发挥"的空间。

第 2 条和第 3 条合起来,才构成完整防线:独立门限挡住漏洞候选,约束上限压缩优化压力。缺一个,另一个也会失效。

小结

  • 验证器看到的是代理指标,不是真实质量;两者不一致时选优会被漏洞利用。
  • 代理分权重若偏向可计算的表面信号,优化压力越大,真实质量跌得越狠。
  • 代理分单调上升不代表变好:检查 24 个候选,真实质量从 0.860 跌到 0.420。
  • 独立证据门能挡住漏洞候选,但过滤不了已经丢失的高质量答案。
  • 奖励黑客不是模型学坏了,而是选择规则把漏洞变成了最优解。
  • 防线是审计 + 独立门 + 优化上限三件套,缺一不可。

阅读导航:上一节:7.2 Self-Refine:自我批评的失效模式 · 下一节:8.1 记忆分层:工作/情景/语义/程序记忆 。

常见错误与边界

  1. 只信代理分。 指标被优化不等于目标达成;要定期拿真实质量做对照。
  2. 验证器自评自证。 同源的评分和选优共享偏差,证据门必须独立。
  3. 无限重试。 给优化器无限自由度,它会更充分利用漏洞。
  4. 事后才过滤。 证据门是止损不是找回;选择规则已淘汰的高质量候选回不来。
  5. 分数来源黑盒。 权重不可审,就无法判断偏差来自哪里。
  6. 把漏洞归因给模型。 是选择规则把漏洞变成最优解;改规则而不是换模型。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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