← DSPy From First Principles

别让优化器作弊

为 DSPy 优化搭建一道实验防火墙,让工具、记忆、反馈、检索和保留集证据都无法悄悄泄露答案。

开篇 —— 优化器不必故意作弊

第 15 章和第 16 章扩展了程序的访问权限。智能体可以搜索仓库、检索记忆,并自适 应地选择证据。第 17 章又加上了在推理状态上的搜索,表明树搜索可以把推理时的 算力分配给有希望的路径。

现在这个问题变得紧迫起来:一旦程序能够搜索、记忆,并自适应地选择证据与推理, 我们怎么证明它没有拿到那些它本来绝不该看到的信息?

这种能力威胁着这次实验。

核心问题是:

一次优化实验如何能在程序或优化器已经悄悄拿到答案的情况下,依然看起来有效?

作弊往往无意间发生。一个名叫 validation_result 的字段溜进了输入。一个记忆工 具返回了历史上被接受的补丁。一条 GEPA 反馈字符串里包含着逐字的参考答案。一位 开发者查看了保留集上的失败,改动了指令,然后又在同一批保留集上评估。

这些都不需要恶意。它们只需要一个没有被执行的信息边界。

这个实验需要一道防火墙。


18.1 泄漏是一种信息流故障

在列出检查项之前,我们需要一个威胁模型。我们在保护什么?防的是谁?

泄漏不只是一个糟糕的字段名。它是一次信息流违规:受保护的信息越过了一道本该 关闭的边界。

我们来定义参与者与边界。

    graph TD
    subgraph 受保护信息
        P1[参考/结果标签]
        P2[未来状态/保留集]
        P3[历史已接受的解决方案]
        P4[含答案的工具能力]
    end

    subgraph 消费方
        C1[推理时的任务程序]
        C2[优化器 / DSPy 编译器]
        C3[检索器 / 记忆]
        C4[工具运行时]
        C5[调优期间的开发者]
    end

    P1 -->|训练/推理期间不得流动| C1
    P1 -->|不得流入候选生成| C2
    P2 -->|评估前不得可见| C2
    P3 -->|不得被记忆检索到| C3
    P4 -->|未获许可则不得可用| C4
    P2 -->|不得指导人工改动| C5

    C1 -->|允许:决策时刻的输入| OK1[可准入证据]
    C2 -->|允许:训练/开发证据| OK2[优化器可见集合]
    C3 -->|允许:可准入语料库| OK3[净化后的记忆]
    C4 -->|允许:固定的工具/修订| OK4[工具清单]
    C5 -->|允许:仅冻结前的诊断| OK5[开发窗口]
  

原则是:

泄漏是一次信息流违规。 不只是一个糟糕的字段名。

我们必须设计边界,然后用无法被意外绕过的机制去执行它们。

参与者 / 子系统 它可以看什么 它绝不能看什么
任务程序 决策时刻的输入 参考答案/结果
优化器 协议许可的训练/开发证据 保留集
指标 评估所需的标签/参考 不得把它们反馈给候选
检索器 可准入语料库 未来/保留集/结果来源
工具运行时 固定的环境 更晚的仓库状态
记忆 可准入的历史证据 与当前样例结果相关的内容
人类开发者 开发期诊断 冻结前从未被触碰的最终保留集

我们将搭建一个执行这些边界的防火墙栈。


18.2 划分不是防火墙

最简单的保护是一次训练/开发/保留集划分。我们把一部分样例挡在优化器可见集合之 外,并在这些样例上评估最终候选。

这是必要的,但不充分。

划分控制的是哪些样例可见。它不控制关于这些样例的哪些信息流入了候选。

划分可能被这样击破:

  • 一个意外包含了标签的字段。
  • 一个因为共享来源血缘而返回保留集样例的检索系统。
  • 一个能读到含解决方案的未来提交的工具。
  • 一条包含参考答案的反馈信号。

划分是一种策略。它假定只要你没把某个样例命名为"保留集",优化器就看不到它。但 信息会通过许多并不叫"保留集"的路径泄漏出去。

我们需要显式的防火墙,检查真实的信息流,而不只是 ID。

本章余下的部分会搭建一道正好做这件事的六层防火墙。


18.3 六层实验防火墙

这道防火墙是一叠彼此独立的检查。每一层都能抓住前面几层抓不住的东西。

    graph TD
    A[候选 / 优化器请求] --> B[1. schema 防火墙]
    B --> C[2. 内容防火墙]
    C --> D[3. 血缘防火墙]
    D --> E[4. 时间防火墙]
    E --> F[5. 能力防火墙]
    F --> G[6. 划分防火墙]
    G --> H{可准入?}
    H -->|是| I[执行这次运行]
    H -->|否| J[拒绝 / 隔离]
  

每一层回答一个不同的问题:

  1. schema:输入负载里是否存在绝不该出现的字段或键?
  2. 内容:无论键名如何,是否有输入值与受保护内容匹配(或高度相似)?
  3. 血缘:这份证据是否与某个保留集样例出自同一来源,即使 ID 不同?
  4. 时间:这份证据是否来自该样例决策时刻之后(例如未来的提交)?
  5. 能力:运行时是否暴露了可能访问受保护信息的工具或权限,即便它们没被调用?
  6. 划分:是否有显式指定的保留集 ID 泄漏进了优化器可见集合?

我们会依次探讨每一层,并给出具体实现。


18.4 第 1 层 —— schema 与结果字段

最明显的泄漏:一个本该只出现在输出里的字段出现在了输入中。

在 CoCoder 项目里,语料层定义了这样的结果键:

OUTCOME_KEYS = {
    "reference_rewrite",
    "human_accepted",
    "validation_result",
    "metric_score",
    "promotion_decision",
}

一道 schema 防火墙检查这些键有没有出现在输入负载里:

def assert_no_leakage(inputs: dict) -> None:
    leaked = sorted(key for key in inputs if key in OUTCOME_KEYS)
    if leaked:
        raise ValueError(f"input contains outcome leakage: {', '.join(leaked)}")

但这只能抓住键名。它抓不住藏在一个无辜键名(如 retrieval_hint)之下的同 一段参考文本。

考虑:

bad_example = dspy.Example(
    sentence=row["sentence"],
    editorial_goal=row["editorial_goal"],
    local_context=row["local_context"],
    reference_rewrite=row["reference_rewrite"],
).with_inputs(
    "sentence",
    "editorial_goal",
    "local_context",
    "reference_rewrite",
)

模型现在收到了参考答案。schema 防火墙会挡住它,因为 reference_rewrite 在 OUTCOME_KEYS 里。

但如果有人把它改名:

bad_example = dspy.Example(
    sentence=row["sentence"],
    editorial_goal=row["editorial_goal"],
    local_context=row["local_context"],
    retrieval_hint=row["reference_rewrite"],  # disguised
).with_inputs(
    "sentence", "editorial_goal", "local_context", "retrieval_hint"
)

schema 检查通过了。答案仍然在输入里。

所以我们需要第 2 层。


18.5 第 2 层 —— 内容与改写

内容防火墙检查的是值,不是键。它检查是否有输入字段包含逐字的受保护内容, 或者高度相似的内容。

对于精确匹配:

PROTECTED_VALUES = {
    "exact_reference_string_1",
    "exact_reference_string_2",
    # ...
}

def assert_no_exact_content_leak(inputs: dict) -> None:
    for key, value in inputs.items():
        if isinstance(value, str) and value in PROTECTED_VALUES:
            raise ValueError(f"content leak in field '{key}'")

对于 n-gram 包含度(用来抓住部分泄漏):

def ngrams(text: str, n: int = 5) -> set[str]:
    tokens = text.split()
    return {" ".join(tokens[i:i+n]) for i in range(len(tokens) - n + 1)}

def assert_no_ngram_leak(inputs: dict, protected_values: set[str], threshold: float = 0.8) -> None:
    for key, value in inputs.items():
        if not isinstance(value, str):
            continue
        input_ngrams = ngrams(value)
        for pv in protected_values:
            pv_ngrams = ngrams(pv)
            overlap = len(input_ngrams & pv_ngrams) / max(1, len(pv_ngrams))
            if overlap > threshold:
                raise ValueError(f"ngram overlap between '{key}' and protected value")

对于模糊的语义相似度,我们可以用嵌入。但嵌入是启发式的,并不权威:

from sentence_transformers import SentenceTransformer, util

model = SentenceTransformer("all-MiniLM-L6-v2")

def semantic_similarity(a: str, b: str) -> float:
    emb_a = model.encode(a)
    emb_b = model.encode(b)
    return float(util.cos_sim(emb_a, emb_b))

# Use only as a flag for manual review
def flag_semantic_similarity(inputs: dict, protected_values: set[str], threshold: float = 0.82):
    flags = []
    for key, value in inputs.items():
        if not isinstance(value, str):
            continue
        for pv in protected_values:
            sim = semantic_similarity(value, pv)
            if sim > threshold:
                flags.append((key, sim))
    return flags  # raise or quarantine

重要:语义相似度阈值不是安全保证。它会产生假阳性(与主题相关的正当文本), 也会产生假阴性(在嵌入空间里并不接近的改写提示)。

我们把语义检测当作供审计用的标记,而不是自动拒绝。逐字内容与高 n-gram 重 叠是更强的证据。

实测套件究竟执行了什么。 本章后面那次 288 次攻击的运行只用了精确匹配与子串 检查。上面的 n-gram 重叠比例与嵌入标记,是这一层将来应该长成的设计;在采集这些 数字的时候,它们还不属于被执行的防火墙。这就是为什么 18.12 节里每一个残余风险, 都是"精确匹配加子串"看不见的改写或抽象。


18.6 第 3 层 —— 血缘与重复来源

一个重复的来源可以同时击破 schema 检查与内容检查。如果你有一个来自文档 X、ID 为 ed-004 的保留集样例,而优化器的训练集以另一个 ID 包含了文档 X,那么内容 也许被改写了,来源血缘(lineage)却是一样的。

血缘防火墙检查来源信息:这个样例从哪里来?它是否与某个保留集样例共享同 一个来源?

@dataclass
class CaseLineage:
    case_id: str
    source_document_id: str | None
    source_url: str | None
    source_hash: str | None
    split: str  # "train", "dev", "holdout"

我们按来源分组:

def assert_no_lineage_overlap(
    candidate_manifest: dict, holdout_lineages: set[tuple[str, str, str]]
) -> None:
    # candidate_manifest contains list of case lineages visible to optimizer
    for lineage in candidate_manifest["lineages"]:
        key = (lineage["source_document_id"], lineage["source_url"], lineage["source_hash"])
        if key in holdout_lineages:
            raise ValueError(f"lineage overlap with holdout: {lineage['case_id']}")

如果两个样例出自同一份源文档,即使 ID 不同、内容被改写,它们也靠得太近。优化 器可能从保留集样例的"兄弟"身上学到东西,并以一种并不正当的方式泛化。


18.7 第 4 层 —— 时光穿越式泄漏

仓库智能体可以查看 git 历史。如果一个样例被固定在某个 commit 上,而智能体能运 行 git log、git show 或 git diff 看到更晚的提交,它就可能发现样例创建之 后才提交进去的解决方案。

问题出现在 commit A

A ---- B ---- C ---- D
^                 ^
样例修订          修复在此提交

时间防火墙固定仓库状态,并限制对该样例决策时刻之后的历史的访问。

class RepositoryPinner:
    def __init__(self, allowed_revision: str, allowed_history_end: str | None = None):
        self.allowed_revision = allowed_revision
        self.allowed_history_end = allowed_history_end or allowed_revision

    def assert_allowed_command(self, command: str) -> None:
        # Block any command that might reveal future history
        dangerous_commands = [
            "git log",
            "git show",
            "git diff",
            "git checkout",
            "git branch",
        ]
        if any(dc in command for dc in dangerous_commands):
            raise ValueError(f"command '{command}' may reveal future or unpinned history")
        # Also check that no command references a revision newer than allowed_history_end
        # ...

但更好的做法是在一个固定的 worktree 里运行智能体:仓库在物理上被检出到允许 的修订,未来的提交根本不存在。这样即使智能体尝试 git log,它也只能看到截至 那一刻的历史。

关键的洞察:在工具层执行,而不是靠指令。 如果只是告诉智能体"别看未来的提 交",而工具却能看到它们,那就是一个漏洞。


18.8 第 5 层 —— 能力面

即使智能体从未调用过危险工具,“工具可用"这件事本身也会改变实验协议。如果智能 体本可以访问某个含答案的文件却选择不访问,我们无法证明它没有访问。

所以防火墙应该在执行之前审计能力面。

@dataclass
class CapabilityManifest:
    allowed_tools: set[str]
    allowed_repo_revision: str
    network_allowed: bool
    shell_allowed: bool
    writable_paths: set[str]

在运行之前,我们把声明的预期能力面与实际的运行时配置作比较:

def assert_capability_compliance(
    declared: CapabilityManifest,
    actual: CapabilityManifest,
) -> None:
    # Actual must be a subset of declared
    if not actual.allowed_tools.issubset(declared.allowed_tools):
        extra = actual.allowed_tools - declared.allowed_tools
        raise ValueError(f"unexpected tools available: {extra}")
    if actual.allowed_repo_revision != declared.allowed_repo_revision:
        raise ValueError("repository revision mismatch")
    if actual.network_allowed and not declared.network_allowed:
        raise ValueError("network unexpectedly enabled")
    if actual.shell_allowed and not declared.shell_allowed:
        raise ValueError("shell unexpectedly enabled")
    if not actual.writable_paths.issubset(declared.writable_paths):
        extra = actual.writable_paths - declared.writable_paths
        raise ValueError(f"unexpected writable paths: {extra}")

如果一次运行本该只读,运行时就不该挂载任何可写路径。如果网络不被允许,容器就 不该有网络接口。这是一种结构性保证,不是一次运行时检查。


18.9 第 6 层 —— 划分与保留集隔离

最后,我们确保显式的保留集 ID 永远不会进入优化器的可见集合——无论是作为示范, 还是作为可见样例。

def assert_holdout_not_visible(candidate_manifest: dict, holdout_ids: set[str]) -> None:
    demos = set(candidate_manifest.get("demonstration_case_ids", []))
    visible = set(candidate_manifest.get("optimizer_visible_case_ids", []))
    leaked = sorted((demos | visible) & holdout_ids)
    if leaked:
        raise ValueError(f"holdout cases were visible: {', '.join(leaked)}")

这是最基本的检查,它应当应用于每一个接触优化器的产物:提示词、少样本示例、 检索索引、工具输出和日志。

但保留集耗尽是一种更隐蔽的违规。如果我们查看了保留集上的失败、然后修改了系统, 保留集就变成了开发集。我们需要追踪这一点:

class HoldoutTracker:
    def __init__(self, holdout_ids: set[str]):
        self.holdout_ids = holdout_ids
        self.exposed_to_developer: set[str] = set()

    def mark_developer_visible(self, case_id: str) -> None:
        if case_id in self.holdout_ids:
            self.exposed_to_developer.add(case_id)

    def assert_no_exhaustion(self) -> None:
        if self.exposed_to_developer:
            raise ValueError(
                f"holdout cases have been exposed to developer: {self.exposed_to_developer}. "
                "They are no longer a valid holdout."
            )

一旦某个保留集样例的结果影响了一个设计决定,它就不再独立。它必须被移到开发集, 并由一个全新的样例取代。


18.10 当防火墙挡住正确答案

我们搭起来的这些防火墙层级是为了挡住泄漏。但它们也可能挡住正当的行为。

在我们的编辑改写任务里,有时正确答案就是不改。这句话本来就很好。参考改写 与原句完全相同。

input sentence: "The service should use item.price rather than item.cost."
reference_rewrite: "The service should use item.price rather than item.cost."

我们当时的防火墙规则是:

程序不得接收或吐出受保护的参考值

但如果参考值等于原句,那么一个干净的正确答案就与一个泄漏出来的答案无法区分。 防火墙会拒绝一个正当的样例。

这是一次克制失败(restraint failure):防火墙无法区分"模型抄了答案"与"模 型产出了唯一正确的输出”。

这直接连回前面几章:

  • 第 2 章里,契约没有显式表达"无需修改"。
  • 第 8 章里,指标给一个未改动的正确答案打了 0.65 分。
  • 第 9 章里,表达问题出现在指标层。

现在它出现在了安全层:一条安全不变式无法独立于任务语义来定义。

解决办法是:对于正确答案与受保护值相同的样例,我们必须要么:

  1. 把它们从评估集中移除,要么
  2. 把它们标记为恒等参考样例(identity-reference case),并允许防火墙在输出 与输入相同、却不是从任何外部来源抄来时放行。

这就要求追踪程序究竟有没有机会拿到参考值。如果它没有,却仍然产出了同一个字符 串,那就不是泄漏——那是正确的。

所以防火墙必须是上下文感知的:它必须知道受保护内容是否可能被看到过。如果没 有,那么与参考值一致并不构成泄漏的证据。

这是一个有力的提醒:安全不是一个布尔属性;它是一个相对于可用信息而言的属性。


18.11 攻击防火墙

我们没有只是搭好防火墙然后信任它。我们攻击了它。

这套确定性攻击套件如今覆盖了编辑任务中的 32 个合格样例。对每个样例,我们构 造了 9 种攻击变体,试图把被禁止的证据偷运进程序的输入或优化器的可见集合。

总执行次数:32 × 9 = 288。

攻击矩阵:

攻击 越过边界的东西 预期的防火墙层级
outcome_key 显式的结果键(reference_rewrite) schema
innocent_key_gold_value 藏在无辜键名下的参考答案(retrieval_hint) 内容
gold_feedback GEPA 中逐字的参考反馈字符串 内容
duplicate_source 与保留集同源的文档,换了新 ID 血缘
future_revision 来自更晚提交的证据 修订
accepted_memory 被检索到的历史已接受补丁 内容/记忆
answer_bearing_tool 有能力读取答案文件的工具 能力
holdout_manifest 出现在优化器可见列表中的保留集 ID 划分
identity_reference 输出等于参考值的正确"不改"样例 克制(特殊处理)

全部 288 次攻击都被防火墙挡住了。干净的载荷没有产生任何假阳性。

但关键的数字是:如果那些证据当时被放行,224 次攻击执行会抬高分数。参考污染 的平均效应是 +0.3856。

没有防火墙
      ↓
224 / 288 次攻击造成表面改进

有防火墙
      ↓
288 / 288 条不可准入路径被拒绝

这既表明防火墙在起作用,也表明作弊的诱惑(无论是有意还是无意)是真实存在的。

identity_reference 攻击尤其有意思。它们并不提供答案;它们检验防火墙是否会错 误地挡住一个正当的"不改"样例。在我们的套件里,我们不得不对它们做特殊处理:当 程序没有机会接触受保护值时,防火墙被调整为允许恒等参考样例通过。这说明了我们在 17.10 讨论过的克制失败。


18.12 假阴性

尽管取得了成功,没有哪道防火墙是完美的。我们必须考虑还有什么可能溜过去。

  • 低于阈值的改写:一段对参考答案的总结,避开了精确的 n-gram,语义上接近却 低于嵌入阈值,可能通过内容检查。
  • 抽象化的提示:“bug 在 service.py 里,看看 item 字段是怎么被使用的"可能就 足以把智能体指向解决方案,而不含任何受保护的文本。
  • 衍生产物:一个能看到评估分数的优化器,即使看不到答案,也能推断哪些方向有 希望。这是较弱形式的泄漏,但仍然会污染结果。
  • 经由旁路通道的未来状态:即使没有 git 历史,一个带有某个修改时间的文件的 存在也可能暗示出解决方案。
  • 工具日志:智能体可能没调用危险工具,但先前运行的日志(如果没被清掉)可能 包含答案。

因此,我们应该把防火墙与审计日志和红队演练配对使用。防火墙是第一道防 线,不是保证。


18.13 多智能体泄漏

信息流保证必须是可传递的。考虑这样一个多智能体设置:

智能体 A
 看到被禁止的证据
      ↓
把摘要发给智能体 B
      ↓
智能体 B
 从未直接看到被禁止的来源
      ↓
使用了泄露的信息

智能体 B 自己的输入可能是干净的,但信息已经被智能体 A 污染了。一个简单的、按 智能体划分的防火墙会漏掉这一点。

我们需要污点传播。智能体之间的每条消息都携带血缘:

@dataclass
class MessageLineage:
    source_case_ids: set[str]
    repository_revisions: set[str]
    tool_calls: list[str]
    contains_outcome_evidence: bool = False

如果智能体 A 消费了一个被禁止的来源,它的输出就被污染了。当那份输出被发给智能 体 B 时,污点随之传播。

def propagate_taint(msg: dict, tainted: bool) -> dict:
    msg["tainted"] = tainted
    return msg

# Later, when evaluating Agent B's candidate:
if any(msg.get("tainted", False) for msg in agent_b_inputs):
    raise ValueError("candidate used tainted information")

这把防火墙从单个进程扩展成了一张信息流的图。


18.14 防火墙不变式

现在我们可以简洁地陈述这些不变式:

  1. schema 不变式:程序输入中的任何字段,名字都不得落在被禁止的结果键集合 之内。
  2. 内容不变式:任何程序输入值都不得与受保护内容逐字匹配,或与之有高 n-gram 重叠。
  3. 血缘不变式:任何可见样例都不得与某个保留集样例共享同一来源血缘。
  4. 时间不变式:不得访问来自比该样例固定修订更晚的仓库修订的证据。
  5. 能力不变式:运行时实际的工具与权限面,必须是所声明能力面的子集。
  6. 划分不变式:任何保留集 ID 都不得出现在任何优化器可见清单中。
  7. 克制不变式:对于恒等参考样例,如果程序不可能看到过参考值,那么输出与参 考值相同就不会被标记。
  8. 传递性不变式:如果任何上游智能体消费过不可准入的证据,那么所有下游输出 都被污染了。

这些不变式构成了实验防火墙。它们在实验运行器里以显式检查的形式实现,而不是文 档里的一纸策略。


通常会出什么错

症状 可能的原因 如何诊断 改什么
人工调优之后保留集分数持续上升 保留集现在成了开发集 检查第一次保留集运行之后的改动历史 冻结一套新的最终测试集
看起来无辜的字段里含有参考答案 防火墙只查键不查值 把载荷的值与受保护的结果作比较 增加内容/值层面的泄漏检查
智能体找到了逐字的历史补丁 记忆/工具泄漏了结果 检查被检索的样例 ID、来源血缘和字段 按划分、血缘与字段策略过滤记忆
GEPA 产出针对参考答案的指令 反馈泄漏了参考答案 阅读反馈记录与受保护值的匹配情况 给出失败原因,而不是完整答案
候选的示范里包含保留集 ID 缺少划分校验 把示范 ID 与保留集 ID 作比较 拒绝该产物并重跑
证据里出现了未来的仓库文件 工具用了错误的修订 检查工具记录中的仓库修订 按样例固定 worktree/修订
智能体从未调用危险工具,但它当时可用 能力面本身就比协议更宽 执行之前审计声明的工具 拒绝带有被禁止能力的运行
正确的"不改"样例被挡住 恒等参考的克制失败 查找 output == input == reference 的样例 对恒等参考样例做特殊处理

本章小结

我们得到了一道实验防火墙,然后攻击了它。

确定性套件在 32 个合格样例上执行了 288 次攻击。全部 288 次都被挡住 了。干净的载荷产生零个假阳性,每一项预期的检测契约都得到了满足。

这些攻击也演示了防火墙为什么重要。如果被禁止的证据当时被放行,224 次被污染 的执行会把表面分数抬高,平均幅度约为 0.3856。

最深刻的教训不只是"把 reference_rewrite 从输入里删掉”。

划分不是防火墙,被禁止键的清单也不是防火墙。

参考信息可以披着无辜的键名到来,可以藏在反馈里,可以来自重复来源,可以经由未来 的修订,可以经由记忆,也可能仅仅因为工具面上含有一个带答案的能力。因此,防止泄 漏需要 schema、内容、血缘、修订、能力与划分检查协同工作,并额外关注恒等参考样 例与传递性污点。

我们移除了"仅靠划分就能防止泄漏"这一假定。

现在我们可以产出一个足够值得信任、可以考虑部署的候选。但一次离线胜利还不是一个 生产版本。

下一章,我们从实验跨到生产:当程序必须运行在真实数据上、面对真实用户、并且没有 实验者护航时,会有什么不同。