《AI Agent 技术原理与架构·决策、记忆与学习》8.2 读写策略:什么该记、什么时候记

把 Agent 的“该不该记”拆成值判断与时机判断:用重要性、置信度、新颖度加权成写入分数,用任务边界决定何时提交;通过扫描阈值观察召回率、噪声率与 token 成本如何一起变化,说明缓冲写入在崩溃时为什么会丢数据,并区分排练式写入与持久写入,最后给出按负载配置的读写判据。

以下候选条目、分数与阈值均为教学设定,只用于展示写入策略的计算方式,不构成对任何真实系统或供应商的承诺。

上一节把记忆分成四层,但分层本身不回答一个更基础的问题:一条信息到底该不该写进去。Agent 的写入失败通常有三种形态:记太多,检索时噪声淹没事实;记太少,下一轮需要时找不到;记了但没落盘,进程一崩就全部丢失。

这一节把“该不该记”拆成两个独立判断:值不值与什么时候提交。值不值用一条可计算的分数表达,什么时候提交用任务边界表达。两者分开,才能分别测试、分别调参,也才能在失败时知道是哪一环出了问题。

三种写入失败

先看三种常见症状,它们对应三种不同的修法。

噪声型:什么都记。 用户说“谢谢”、工具返回了 12 条文档、页面颜色是蓝色,全部写进长期记忆。下一次检索时,真正的事实被大量弱相关条目包围。问题不在检索算法,而在写入阈值太低。调检索只能缓解排序,不能减少总量。

漏记型:只记“重要”的。 团队凭直觉判断“这个应该不重要”,结果把用户早先说过的一个硬约束丢了。问题不在存储容量,而在写入判据没有覆盖“不可替代性”。重要性、置信度、新颖度是三个不同维度,用一个主观标签代替会漏。

丢失型:记在内存里。 信息已经抽取出来,也判断为有用,但只放在当前进程的缓冲里。任务还没到提交点,进程重启或超时终止,缓冲全部消失。问题不在记忆模型,而在提交时机与持久化语义。

这三种失败说明:写入策略至少要同时定义分数与提交点。只定义分数,会在崩溃时丢数据;只定义提交点,会把噪声一起持久化。

形式化:分数、阈值与提交点

给一条候选记忆 $c$ 定义三个信号:

  • $i(c)$:重要性,任务成功是否依赖它;
  • $q(c)$:置信度,这条信息是工具确认的还是模型猜的;
  • $n(c)$:新颖度,它与已有记忆是否重复。

写入分数取加权和:

$$
\text{score}(c) = 0.5 \cdot i(c) + 0.3 \cdot q(c) + 0.2 \cdot n(c)
$$

权重不是真理,而是本实验的选择。它表达一个立场:重要性优先,置信度次之,新颖度最后。生产系统应该按负载调整:W3 运维处置可以提高置信度权重,因为未确认的信息不能进入持久记忆;W2 代码修复可以提高新颖度权重,因为重复的失败输出没有新增信息。

写入规则是阈值判断:

$$
\text{write}(c) = [\text{score}(c) \geq \tau]
$$

在写入之前还要做同键去重。同一个键只保留分数最高的一条,否则重复写入会同时放大召回率和噪声率,让评测看起来变好,实际只是同一事实被数了多次。

提交规则单独定义。设任务边界为 $b$,当前步为 $t$:

$$
\text{commit}(c, t) =
\begin{cases}
\text{skip}, & \text{score}(c) < \tau \
\text{buffer}, & \text{score}(c) \geq \tau \land t \neq b \
\text{persist}, & \text{score}(c) \geq \tau \land t = b
\end{cases}
$$

任务边界可以是任务完成、明确失败、用户确认,或者一次不可逆动作之前的检查点。边界的选择直接决定崩溃时会丢多少东西;它不是实现细节,而是可靠性语义的一部分。

最小实验:扫描阈值与提交时机

实验准备了 12 条候选记忆,覆盖退款请求、订单状态、账户等级、工具输出、闲聊、无根据猜测和一条硬约束。每条候选带三个信号、token 成本,以及一个只用于评测的 relevant 标签。

需要强调:relevant 是评测时的真值,生产系统在写入时并不知道它。实验用它来计算召回率与噪声率,不能把它当成线上可用的判据。线上只能用重要性、置信度、新颖度这些可观测信号,再用离线标注校准阈值。

代码同时演示两件事:扫描阈值看召回、噪声与 token 如何变化;在非边界与边界分别提交,看缓冲与持久化的差别。

# file: agp_lab/memory_policy.py | write
# tier: 3
# verify: python3 -m unittest tests.test_memory_policy
"""写入策略:什么该记、什么时候记。

写入判断由两部分组成:

1. 值:重要性、置信度、新颖度加权成一条分数,低于阈值不写;
2. 时机:只有到达任务边界(完成、失败、用户确认)才把缓冲提交为持久记忆。

实验扫描阈值,观察召回率、噪声率与 token 成本如何一起变化。
这不是产品实现,而是把“记忆变多”拆成两个可测的量:写进来的有多少是
有用的,以及为这些有用信息付出了多少噪声与上下文成本。
"""
from __future__ import annotations

from dataclasses import dataclass

WEIGHTS = (0.5, 0.3, 0.2)  # importance, confidence, novelty


@dataclass(frozen=True)
class Candidate:
    key: str
    text: str
    importance: float
    confidence: float
    novelty: float
    tokens: int
    relevant: bool


def score(candidate: Candidate) -> float:
    for value in (candidate.importance, candidate.confidence, candidate.novelty):
        if not 0.0 <= value <= 1.0:
            raise ValueError("importance/confidence/novelty 必须在 [0, 1] 内")
    if candidate.tokens <= 0:
        raise ValueError("tokens 必须为正")
    importance, confidence, novelty = WEIGHTS
    return (
        importance * candidate.importance
        + confidence * candidate.confidence
        + novelty * candidate.novelty
    )


def dedupe(candidates: list[Candidate]) -> list[Candidate]:
    """同键只保留分最高的一条,避免重复写入放大召回与噪声。"""
    best: dict[str, Candidate] = {}
    for candidate in candidates:
        old = best.get(candidate.key)
        if old is None or score(candidate) > score(old):
            best[candidate.key] = candidate
    return list(best.values())


def admit(candidates: list[Candidate], threshold: float) -> list[Candidate]:
    if not 0.0 <= threshold <= 1.0:
        raise ValueError("threshold 必须在 [0, 1] 内")
    return [item for item in dedupe(candidates) if score(item) >= threshold]


@dataclass(frozen=True)
class Metrics:
    written: int
    recall: float
    noise: float
    tokens: int


def metrics(admitted: list[Candidate], universe: list[Candidate]) -> Metrics:
    unique = dedupe(universe)
    relevant_total = sum(1 for item in unique if item.relevant)
    relevant_written = sum(1 for item in admitted if item.relevant)
    noise_written = sum(1 for item in admitted if not item.relevant)
    written = len(admitted)
    recall = relevant_written / relevant_total if relevant_total else 1.0
    noise = noise_written / written if written else 0.0
    return Metrics(written, recall, noise, sum(item.tokens for item in admitted))


def commit(
    candidates: list[Candidate],
    threshold: float,
    step: int,
    boundary_step: int,
) -> tuple[list[Candidate], list[Candidate]]:
    """返回 (持久写入, 缓冲)。未到任务边界时只进缓冲,崩溃即丢失。"""
    admitted = admit(candidates, threshold)
    if step == boundary_step:
        return admitted, []
    return [], admitted


CANDIDATES = (
    Candidate("refund_request", "用户要求退款", 0.90, 0.95, 0.80, 20, True),
    Candidate("thanks", "用户说谢谢", 0.10, 0.90, 0.10, 5, False),
    Candidate("order_status", "订单状态为已支付", 0.80, 0.90, 0.60, 20, True),
    Candidate("weather", "闲聊天气", 0.05, 0.60, 0.20, 8, False),
    Candidate("refund_window", "退款窗口为 7 天", 0.85, 0.80, 0.50, 18, True),
    Candidate("doc_list", "工具返回 12 条文档", 0.30, 0.70, 0.20, 12, False),
    Candidate("account_tier", "用户等级为 gold", 0.75, 0.95, 0.90, 15, True),
    Candidate("account_tier", "用户等级为 gold(重复)", 0.70, 0.95, 0.10, 15, True),
    Candidate("page_color", "页面颜色是蓝色", 0.10, 0.50, 0.30, 6, False),
    Candidate("ticket_escalated", "工单已升级", 0.60, 0.90, 0.70, 12, True),
    Candidate("guess", "没有根据的猜测", 0.50, 0.20, 0.90, 10, False),
    Candidate("hard_constraint", "用户禁止改动生产库", 0.95, 0.99, 0.95, 16, True),
)

THRESHOLDS = (0.0, 0.3, 0.4, 0.5, 0.7, 0.9)


def threshold_table() -> list[tuple[float, Metrics]]:
    return [(threshold, metrics(admit(CANDIDATES, threshold), CANDIDATES))
            for threshold in THRESHOLDS]


TIMING_CANDIDATES = (
    Candidate("refund_request", "用户要求退款", 0.90, 0.95, 0.80, 20, True),
    Candidate("order_status", "订单状态为已支付", 0.80, 0.90, 0.60, 20, True),
    Candidate("account_tier", "用户等级为 gold", 0.75, 0.95, 0.90, 15, True),
)


if __name__ == "__main__":
    print(f"{'阈值':<6}{'写入':>4}{'召回率':>8}{'噪声率':>8}{'token':>7}")
    for threshold, row in threshold_table():
        print(
            f"{threshold:<6.1f}{row.written:>4}{row.recall:>8.3f}"
            f"{row.noise:>8.3f}{row.tokens:>7}"
        )
    print()
    writes, buffered = commit(TIMING_CANDIDATES, 0.5, step=3, boundary_step=10)
    print(f"非边界提交(step=3):写入 {len(writes)} 条,缓冲 {len(buffered)} 条")
    writes, buffered = commit(TIMING_CANDIDATES, 0.5, step=10, boundary_step=10)
    print(f"边界提交(step=10):写入 {len(writes)} 条,缓冲 {len(buffered)} 条")

运行:

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

输出:

阈值      写入     召回率     噪声率  token
0.0     11   1.000   0.455    142
0.3      9   1.000   0.333    128
0.4      8   1.000   0.250    123
0.5      6   1.000   0.000    101
0.7      6   1.000   0.000    101
0.9      1   0.167   0.000     16

非边界提交(step=3):写入 0 条,缓冲 3 条
边界提交(step=10):写入 3 条,缓冲 0 条

这张表可以读出四个结论。

第一,噪声的下降不是线性的。 阈值从 0 提到 0.5,噪声率从 0.455 降到 0,但召回率一直是 1.000。原因是在这组候选里,相关条目的分数本来就高于不相关条目;0.5 恰好把噪声全部挡住,又没有误伤相关项。这是理想情况,不是普遍规律。

第二,阈值继续提高会突然损失召回。 从 0.5 到 0.7,结果完全不变;到 0.9,只有硬约束(0.962)留下,召回率掉到 0.167。这说明阈值曲线可能存在平台,也可能存在悬崖。调阈值不能只看一两个点,必须看整条曲线,并且分别看召回与噪声。

第三,降噪同时降成本。 token 从 142 降到 101,因为写入条目从 11 条减到 6 条。记忆成本不是免费的:每一条被写入的噪声都会在未来的检索、注入和上下文里重复付费。写入时省一条,检索时省很多次。

第四,提交时机与分数无关。 非边界时,三条高分数候选全部进入缓冲,持久写入为 0;到边界才变成 3 条持久写入。如果进程在 step=3 之后崩溃,这三条高价值信息就丢了。分数再高,也救不了没有提交的数据。

边界与失败模式

写入策略至少有五类边界。

信号可以被“刷分”。 模型可能把一条无关信息标成高重要性、高置信度,从而通过阈值。重要性不能只由生成模型自己打;关键场景要由规则、工具返回值或人工确认提供。

同键去重不是语义去重。 实验里两条账户等级用了同一个键,所以能去重。如果一条写成 account_tier,另一条写成 user_level,去重就失效。键的规范化是写入路径的一部分,不能留给检索时猜。

任务边界可能永远不到达。 长任务、挂起任务、用户中途离开,都可能让边界迟迟不出现。缓冲需要上限与超时提交:缓冲满了要落盘,超时了要落盘,而不是无限等待。

阈值是负载相关的。 W1 检索问答可以接受较低阈值,因为噪声主要由重排处理;W3 运维处置应该用较高阈值,因为错误事实会进入不可逆动作。一个全局阈值会让某一类负载长期受损。

评测标签会泄漏。 relevant 只存在于评测集。如果把评测集的标签写进线上写入逻辑,等于用未来信息做决策;上线后没有这个标签,行为会立刻漂移。

架构含义

把写入策略落到系统上,需要五条可检查的设计:

  1. 写入路径分两段。 第一段抽取候选并打分,第二段在任务边界提交。两段之间是缓冲,不是持久存储。
  2. 分数信号有来源。 重要性、置信度、新颖度各自记录来源;模型自评只能作为其中一个来源,不能是唯一来源。
  3. 阈值按负载配置。 W1、W2、W3 各自有阈值与权重,并且有回归集验证召回与噪声没有退化。
  4. 丢弃要留痕。 被阈值拒绝的候选、被去重覆盖的条目、被缓冲上限挤掉的条目,都要有计数和采样。否则你无法解释“为什么这条没记住”。
  5. 提交点可测试。 用故障注入在边界前后杀进程,验证已提交的不丢、未提交的不算成功。这与卷三的执行语义直接相连。

三条负载的写入重点不同:

负载主要风险建议阈值倾向必须记录
W1 检索问答噪声稀释引用中等,靠重排兜底事实来源、文档 ID
W2 代码修复丢失复现步骤偏低,情景优先命令、退出码、diff 摘要
W3 运维处置未确认信息进入不可逆动作偏高,置信度权重加大审批人、工具回执、时间

判据表

判据合格的样子不合格的样子验证方式
分数三个信号独立、有来源、可复算模型自评一个总分抽查 20 条写入记录
阈值按负载配置,有曲线依据全站一个固定值扫描阈值,检查召回/噪声曲线
去重键规范化,同键保留最高分依赖文本相似度构造同义键,检查是否重复
提交任务边界持久化,缓冲有上限与超时只存内存边界前后注入进程崩溃
留痕拒绝、覆盖、挤掉都有计数只记录成功写入对比候选数与写入数
评测标签只用于离线校准线上读取 relevant代码审计与线上抽查

小结

  • “该不该记”要拆成值判断与时机判断;只做其中一个,分别导致噪声或丢失。
  • 写入分数由重要性、置信度、新颖度等可观测信号组成;模型自评不能是唯一来源。
  • 阈值曲线可能既有平台也有悬崖;调参要看整条召回/噪声/token 曲线,不能只看一个点。
  • 同键去重必须在写入前做;否则重复条目会同时抬高召回与噪声。
  • 分数再高,未到任务边界也只是缓冲;缓冲需要上限与超时,崩溃语义要单独测试。
  • 阈值与权重按负载配置:W1 靠重排兜底,W2 保留复现步骤,W3 用高置信度门槛保护不可逆动作。

阅读导航:上一节:8.1 记忆分层:工作/情景/语义/程序记忆 · 下一节:8.3 遗忘、TTL 与冲突消解 。

常见错误与边界

  1. 把“重要”当单一维度。 重要性、置信度、新颖度回答不同问题;合并成一个主观标签,会漏掉“不重要但不可替代”的硬约束。
  2. 让模型给自己打分。 生成模型可以建议候选,但写入分数需要独立来源;否则相关性判断会退化成自我确认。
  3. 只在检索时降噪。 检索排序只能改变呈现顺序,不能减少存储与上下文总量;噪声应该在写入时就被阈值挡住。
  4. 用文本相似度代替键去重。 相似度会把“相关但不同”的条目合并,也会漏掉“同义但不同写法”的重复;键规范化更可靠。
  5. 把缓冲当已提交。 进程内列表不是持久记忆;任务边界、缓冲上限、超时提交三者缺一不可。
  6. 全站一个阈值。 不同负载的错误代价不同;全局阈值会让高风险负载过松或低风险负载过紧。
  7. 用评测标签做线上判据。 relevant 只存在于离线评测;把它写进写入逻辑,上线后行为必然漂移。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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