别让优化器作弊
为 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[拒绝 / 隔离]
每一层回答一个不同的问题:
- schema:输入负载里是否存在绝不该出现的字段或键?
- 内容:无论键名如何,是否有输入值与受保护内容匹配(或高度相似)?
- 血缘:这份证据是否与某个保留集样例出自同一来源,即使 ID 不同?
- 时间:这份证据是否来自该样例决策时刻之后(例如未来的提交)?
- 能力:运行时是否暴露了可能访问受保护信息的工具或权限,即便它们没被调用?
- 划分:是否有显式指定的保留集 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 章里,表达问题出现在指标层。
现在它出现在了安全层:一条安全不变式无法独立于任务语义来定义。
解决办法是:对于正确答案与受保护值相同的样例,我们必须要么:
- 把它们从评估集中移除,要么
- 把它们标记为恒等参考样例(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 防火墙不变式
现在我们可以简洁地陈述这些不变式:
- schema 不变式:程序输入中的任何字段,名字都不得落在被禁止的结果键集合 之内。
- 内容不变式:任何程序输入值都不得与受保护内容逐字匹配,或与之有高 n-gram 重叠。
- 血缘不变式:任何可见样例都不得与某个保留集样例共享同一来源血缘。
- 时间不变式:不得访问来自比该样例固定修订更晚的仓库修订的证据。
- 能力不变式:运行时实际的工具与权限面,必须是所声明能力面的子集。
- 划分不变式:任何保留集 ID 都不得出现在任何优化器可见清单中。
- 克制不变式:对于恒等参考样例,如果程序不可能看到过参考值,那么输出与参 考值相同就不会被标记。
- 传递性不变式:如果任何上游智能体消费过不可准入的证据,那么所有下游输出 都被污染了。
这些不变式构成了实验防火墙。它们在实验运行器里以显式检查的形式实现,而不是文 档里的一纸策略。
通常会出什么错
| 症状 | 可能的原因 | 如何诊断 | 改什么 |
|---|---|---|---|
| 人工调优之后保留集分数持续上升 | 保留集现在成了开发集 | 检查第一次保留集运行之后的改动历史 | 冻结一套新的最终测试集 |
| 看起来无辜的字段里含有参考答案 | 防火墙只查键不查值 | 把载荷的值与受保护的结果作比较 | 增加内容/值层面的泄漏检查 |
| 智能体找到了逐字的历史补丁 | 记忆/工具泄漏了结果 | 检查被检索的样例 ID、来源血缘和字段 | 按划分、血缘与字段策略过滤记忆 |
| GEPA 产出针对参考答案的指令 | 反馈泄漏了参考答案 | 阅读反馈记录与受保护值的匹配情况 | 给出失败原因,而不是完整答案 |
| 候选的示范里包含保留集 ID | 缺少划分校验 | 把示范 ID 与保留集 ID 作比较 | 拒绝该产物并重跑 |
| 证据里出现了未来的仓库文件 | 工具用了错误的修订 | 检查工具记录中的仓库修订 | 按样例固定 worktree/修订 |
| 智能体从未调用危险工具,但它当时可用 | 能力面本身就比协议更宽 | 执行之前审计声明的工具 | 拒绝带有被禁止能力的运行 |
| 正确的"不改"样例被挡住 | 恒等参考的克制失败 | 查找 output == input == reference 的样例 | 对恒等参考样例做特殊处理 |
本章小结
我们得到了一道实验防火墙,然后攻击了它。
确定性套件在 32 个合格样例上执行了 288 次攻击。全部 288 次都被挡住 了。干净的载荷产生零个假阳性,每一项预期的检测契约都得到了满足。
这些攻击也演示了防火墙为什么重要。如果被禁止的证据当时被放行,224 次被污染
的执行会把表面分数抬高,平均幅度约为 0.3856。
最深刻的教训不只是"把 reference_rewrite 从输入里删掉”。
划分不是防火墙,被禁止键的清单也不是防火墙。
参考信息可以披着无辜的键名到来,可以藏在反馈里,可以来自重复来源,可以经由未来 的修订,可以经由记忆,也可能仅仅因为工具面上含有一个带答案的能力。因此,防止泄 漏需要 schema、内容、血缘、修订、能力与划分检查协同工作,并额外关注恒等参考样 例与传递性污点。
我们移除了"仅靠划分就能防止泄漏"这一假定。
现在我们可以产出一个足够值得信任、可以考虑部署的候选。但一次离线胜利还不是一个 生产版本。
下一章,我们从实验跨到生产:当程序必须运行在真实数据上、面对真实用户、并且没有 实验者护航时,会有什么不同。