《AI Agent 技术原理与架构·决策、记忆与学习》8.3 遗忘、TTL 与冲突消解

把遗忘当作记忆系统的一等功能:用 TTL 把陈旧答案换成“不知道”,用 source_rank 与写入时间消解同键冲突;通过一个版本时间线实验比较无 TTL、长 TTL 与短 TTL 下的正确率、陈旧率与缺失率,说明过期、覆盖与审计为什么必须一起设计,最后给出可检查的判据表。

以下时间线、版本号与 TTL 均为教学设定,只用于展示遗忘与冲突消解的计算方式,不构成对任何真实系统或供应商的承诺。

记忆系统最容易缺少的功能不是“记住”,而是“忘记”。一个只增不减的记忆库会同时积累两类问题:旧值一直可检索,导致陈旧答案;同一键的多个来源并存,导致模型在冲突值之间随机选择。两者都不是容量问题,而是时效与权威性没有被建模。

这一节把遗忘拆成三个可计算的部分:过期判断、冲突消解、答案状态。它们共同决定 Agent 在某个时刻返回的是“正确值”“旧值”还是“不知道”。三者代价不同,不能用一个准确率指标混在一起看。

三种答案状态

给定一个键和一个查询时刻,记忆系统可能返回三种状态:

  • 命中(hit):返回一个未过期的值;它可能正确,也可能陈旧。
  • 过期(expired):曾经有过记录,但按 TTL 已失效;系统明确知道“我不知道现在的值”。
  • 未知(unknown):从来没有记录过这个键。

很多系统只区分“查到”和“没查到”,把过期折叠进“没查到”。这会丢掉一个重要区别:过期说明记录曾经存在但已不可信,系统可以据此触发重新查询、向用户澄清或走安全默认值;未知说明从未建立知识,需要走另一条路径。

更糟的是把过期值当命中返回。用户问退款窗口,记忆里有一条三个月前的“14 天”,系统返回得很有信心,但当前政策是 7 天。这个错误比“不知道”更难发现,因为输出看起来完整。

形式化:TTL、胜出规则与状态

一条事实写成五元组:

$$
f = (\text{key}, \text{value}, \text{written_at}, \text{ttl}, \text{source_rank})
$$

过期判断是时间差与 TTL 的比较:

$$
\text{valid}(f, t) = (t - \text{written_at} \leq \text{ttl})
$$

ttl = None 表示永不过期,只适合确实不会变化的常量。TTL 的边界取闭区间:年龄恰好等于 TTL 时仍然有效。这个选择本身不重要,重要的是全系统统一,并且在测试里固定下来。

同一键可能有多个来源。胜出规则定义为先比权威等级,再比写入时间:

$$
\text{winner}(k, t) = \arg\max_{f: f.\text{key}=k,\ \text{valid}(f,t)} (\text{source_rank}_f, \text{written_at}_f)
$$

这条规则表达一个明确立场:权威来源优先于新鲜度。人工确认的配置可以覆盖更晚写入的缓存值;反过来,如果一条低权威的缓存值更新,它不能自动推翻高权威记录。规则可以按场景调整,但必须先写下来,否则冲突消解会退化成“最后写入者获胜”,而最后写入者往往只是最吵的那个来源。

答案状态由胜出结果和键是否存在决定:

$$
\text{status}(k, t) =
\begin{cases}
\text{hit}, & \text{winner 存在} \
\text{expired}, & \text{有过记录但全部失效} \
\text{unknown}, & \text{从未记录}
\end{cases}
$$

最小实验:版本时间线与 TTL 扫描

实验构造一条简单时间线:服务版本在 t=0 是 v1,t=6 变成 v2,t=12 变成 v3;记忆写入滞后于真值变化,分别在 t=0、t=8、t=14 写入三个版本;查询发生在 t=3、7、10、13、16。

查询时刻真值最新已写值无 TTL 时的答案
3v1v1v1,正确
7v2v1v1,陈旧
10v2v2v2,正确
13v3v2v2,陈旧
16v3v3v3,正确

没有 TTL 时,五个查询里两个陈旧,陈旧率 0.400。加入 TTL 后,旧值会在某个时刻失效,答案从“陈旧”变成“过期”。实验扫描 None、10、6、3、1 五档 TTL,统计正确、陈旧、缺失三种结果。

# file: agp_lab/forgetting.py | write
# tier: 3
# verify: python3 -m unittest tests.test_forgetting
"""遗忘、TTL 与冲突消解。

记忆不只要写进去,还要能过期、能被覆盖。这个最小模型验证三件事:

1. TTL 把“陈旧答案”换成“不知道”,两种错误代价不同;
2. 同一键的多个来源按 source_rank 优先、时间次之消解;
3. 没有 TTL 时,旧值会一直可用,陈旧率不会随时间下降。
"""
from __future__ import annotations

from dataclasses import dataclass


@dataclass(frozen=True)
class Fact:
    key: str
    value: str
    written_at: int
    ttl: int | None = None
    source_rank: int = 0


def valid_at(fact: Fact, now: int) -> bool:
    if now < fact.written_at:
        raise ValueError("now 不能早于 written_at")
    if fact.ttl is None:
        return True
    if fact.ttl < 0:
        raise ValueError("ttl 不能为负")
    return now - fact.written_at <= fact.ttl


def resolve(facts: list[Fact], key: str, now: int) -> Fact | None:
    """同一键的胜出规则:source_rank 高者优先,同秩取更新时间更晚者。"""
    candidates = [
        fact for fact in facts
        if fact.key == key and fact.written_at <= now and valid_at(fact, now)
    ]
    if not candidates:
        return None
    return max(candidates, key=lambda fact: (fact.source_rank, fact.written_at))


def answer(facts: list[Fact], key: str, now: int) -> tuple[str | None, str]:
    """返回 (值, 状态),状态为 hit / expired / unknown。"""
    winner = resolve(facts, key, now)
    if winner is not None:
        return winner.value, "hit"
    if any(fact.key == key and fact.written_at <= now for fact in facts):
        return None, "expired"
    return None, "unknown"


# 真值随时间变化:0 起 v1,6 起 v2,12 起 v3。
TRUTH = ((3, "v1"), (7, "v2"), (10, "v2"), (13, "v3"), (16, "v3"))
# 记忆写入滞后于真值变化:t=0 写 v1,t=8 才写 v2,t=14 才写 v3。
WRITES = ((0, "v1"), (8, "v2"), (14, "v3"))


def build_facts(ttl: int | None) -> list[Fact]:
    return [
        Fact("service_version", value, written_at, ttl=ttl, source_rank=1)
        for written_at, value in WRITES
    ]


def evaluate(ttl: int | None) -> tuple[int, int, int]:
    """返回 (正确, 陈旧, 缺失)。"""
    facts = build_facts(ttl)
    correct = stale = missing = 0
    for now, truth in TRUTH:
        value, status = answer(facts, "service_version", now)
        if status != "hit":
            missing += 1
        elif value == truth:
            correct += 1
        else:
            stale += 1
    return correct, stale, missing


TTLS: tuple[int | None, ...] = (None, 10, 6, 3, 1)


def conflict_demo() -> str:
    facts = [
        Fact("deploy_target", "green", 5, source_rank=1),
        Fact("deploy_target", "blue", 8, source_rank=2),
    ]
    winner = resolve(facts, "deploy_target", now=20)
    assert winner is not None
    return winner.value


if __name__ == "__main__":
    print(f"{'TTL':<6}{'正确':>4}{'陈旧':>4}{'缺失':>4}{'陈旧率':>8}")
    for ttl in TTLS:
        correct, stale, missing = evaluate(ttl)
        total = correct + stale + missing
        label = "∞" if ttl is None else str(ttl)
        print(f"{label:<6}{correct:>4}{stale:>4}{missing:>4}{stale / total:>8.3f}")
    print()
    print(f"冲突消解:source_rank 更高的 blue 覆盖 green -> {conflict_demo()}")

运行:

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

输出:

TTL     正确  陈旧  缺失     陈旧率
∞        3   2   0   0.400
10       3   2   0   0.400
6        3   1   1   0.200
3        3   0   2   0.000
1        0   0   5   0.000

这张表说明四件事。

第一,TTL 不是越小越好。 TTL 从无限制降到 6,陈旧从 2 降到 1,缺失从 0 升到 1,正确数保持 3。它把一次“自信地说错”换成了一次“明确地不知道”,这是进步,但代价是多了一次重新查询。

第二,TTL 太短会把正确值也删掉。 TTL=1 时,所有查询都落在过期区,正确数从 3 掉到 0,缺失 5。系统变得“永远不知道”,可用性崩塌。遗忘的目标不是清空,而是在陈旧与缺失之间选一个可接受的平衡点。

第三,TTL=10 与无 TTL 在这条时间线上结果相同。 因为最长的有效年龄没有超过 10。这说明 TTL 必须相对于真值变化频率与写入延迟来设,而不是拍一个“看起来安全”的天数。对变化快的键,10 天等于永不过期。

第四,正确数在 3 到 0 之间不是线性变化。 TTL=3 时正确仍是 3,因为三次正确查询的年龄都在 3 以内;TTL=1 时全部失效。阈值落在分布的空隙里,结果会突然跳变。调 TTL 要看时间线分布,不能只看平均值。

冲突消解单独演示:deploy_target 在 t=5 由低权威来源写成 green,在 t=8 由高权威来源写成 blue。source_rank 更高的 blue 胜出,即使它不是最后写入的。如果反过来让最后写入者获胜,一次缓存刷新就可能覆盖人工确认的部署目标。

边界与失败模式

遗忘与冲突消解至少有六类边界。

时钟不可信。 written_at 来自不同机器时,时钟偏移会让 TTL 提前或延后触发。跨节点记忆必须用统一的逻辑时钟或服务端时间,而不是各节点本地时间。

TTL 是键级属性,不是全局常量。 账户等级可能几个月不变,服务版本可能几分钟就变。全局 TTL 要么让稳定事实过早失效,要么让易变事实长期陈旧。TTL 应该按键类型配置。

删除与过期语义不同。 过期是“不再可信但可审计”,删除是“不应再存在”。合规场景下,用户要求删除的数据不能只是标记过期;反过来,审计要求保留的历史不能因为 TTL 到期就被物理删除。

权威等级也会过期。 高权威来源曾经确认过的值,可能在外部系统变化后失效。source_rank 解决“谁更可信”,不解决“它是否仍然正确”;权威记录同样需要 TTL 或变更通知。

冲突值可能都错。 两个来源给出不同值,胜出规则只能选一个,不能保证选对。高风险场景需要第三个信号:实时查询、健康检查或人工确认。

过期后的路径没有定义。 返回 expired 只是开始;系统还要决定是重新检索、向用户澄清、使用安全默认值,还是拒绝执行。没有这条路径,expired 和 unknown 在行为上没有区别。

架构含义

把遗忘落到系统上,需要五条可检查的设计:

  1. 答案状态是显式的。 返回值必须带 hit / expired / unknown,不能把过期折叠成空字符串或默认值。
  2. TTL 按键类型配置。 稳定事实、易变配置、会话事件各自有不同 TTL,并且有变更通知机制兜底。
  3. 冲突规则先于写入生效。 同键多来源在写入或组装阶段按 source_rank 与时间消解,并记录胜出来源与理由。
  4. 过期有后续动作。 expired 触发重新检索、澄清或安全默认值;这条路径要像正常路径一样被测试。
  5. 审计与遗忘分离。 面向用户的可检索记忆可以过期,审计日志按合规策略保留;两者不能共用一套删除逻辑。

三条负载的遗忘重点不同:

负载易变键建议 TTL 倾向过期后的动作
W1 检索问答文档内容、政策条款按文档版本,不按天数重新检索并核对引用
W2 代码修复测试结果、分支状态很短,按会话或提交重跑测试,不使用缓存结论
W3 运维处置服务版本、实例健康很短,接近实时重新健康检查,未确认不执行

判据表

判据合格的样子不合格的样子验证方式
状态返回 hit/expired/unknown过期值当命中返回构造过期记录,检查返回状态
TTL按键类型配置,有依据全站一个天数抽查高变化键的 TTL 设置
冲突规则显式,记录胜出来源最后写入者获胜构造双来源冲突,检查结果与日志
时钟统一服务端时间或逻辑时钟各节点本地时间注入时钟偏移,检查过期边界
删除过期与删除语义分离删除等同标记过期审计删除请求与留存记录
后续动作expired 有明确处理路径返回空值后继续执行过期场景的端到端测试

小结

  • 遗忘是记忆系统的一等功能;只增不减的记忆会同时积累陈旧答案与来源冲突。
  • 答案要区分命中、过期、未知;把过期折叠成“没查到”会丢掉重要的行为分支。
  • TTL 把“自信地说错”换成“明确地不知道”,但太短会让正确值也失效;它必须相对于真值变化频率与写入延迟来设。
  • 同键冲突按权威等级优先、时间次之消解;若让最后写入者获胜,缓存刷新可能覆盖人工确认。
  • 时钟、删除语义、权威记录的时效、过期后的动作,都是 TTL 之外必须单独定义的边界。
  • TTL 与冲突规则要按负载配置:W1 跟文档版本,W2 跟会话或提交,W3 接近实时并优先重新检查。

阅读导航:上一节:8.2 读写策略:什么该记、什么时候记 · 下一节:9.1 检索:召回、重排与注入位置 。

常见错误与边界

  1. 只增不减。 没有 TTL、没有覆盖、没有删除,记忆会同时变旧和变吵;容量只是表象,时效才是根因。
  2. 把过期当未知。 过期记录说明“曾经知道但已不可信”,可以触发重新查询;未知说明“从未建立知识”,路径不同。
  3. 全局一个 TTL。 稳定事实与易变配置共用 TTL,必然一头过早失效、一头长期陈旧。
  4. 最后写入者获胜。 缓存刷新、批量导入、低权威来源都可能最后写入;没有权威等级,冲突消解不可审计。
  5. 用本地时钟算 TTL。 跨节点时钟偏移会让过期边界漂移;统一时间源是前提。
  6. 删除与过期混用。 用户删除请求与审计留存是两种语义;用同一套标记处理会违反其中一边。
  7. 过期后没有动作。 返回 expired 却不重新查询、不澄清、不使用安全默认值,等于把问题留给下游。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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