《AI Agent 技术原理与架构·决策、记忆与学习》9.1 检索:召回、重排与注入位置

检索不是一次查询,而是两阶段分工:第一阶段用词重叠把相关文档捞进候选池,第二阶段加标题权重把正确文档排到最前。本节用固定小语料演示召回与 top-1 精度的差异、重排的价值,以及注入位置如何衰减证据权重,并给出三阶段检索与注入位置的架构判据。

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

Agent 里的检索不是"搜一次取个结果",而是三个问题:相关文档进没进候选池(召回)、正确的那个排没排到前面(top-1 精度)、注入上下文后模型用没用上(位置与证据)。三个问题对应三个不同的阶段,混在一起就说不清失败在哪里。

这一节用两阶段检索的最小模型把这三件事拆开:第一阶段只看正文词重叠,负责召回;第二阶段加标题权重,负责排序;注入位置的衰减权重负责"证据的有效性"。实验用一个固定小语料展示它们的分工。

两阶段检索的分工

阶段信号目标指标
召回词重叠、粗筛相关文档进候选池recall@k
重排标题、结构、语义正确文档到最前top-1 精度
注入位置、长度、噪声模型用上证据证据有效权重

召回和重排的目标不同。召回只要求"别把对的丢了",允许候选池大一点、排序乱一点;重排才要求"把对的放最前"。很多人拿同一套排序同时干两件事,结果往往是召回勉强、top-1 很差。

为什么正文召回够了、top-1 还不够

正文词重叠是一个不错的召回信号:相关文档通常和查询共享关键词,召回率容易做高。但正文重叠对排序不够用——同一批相关文档在正文里都命中同样的词,重叠数相同,排序就落到文档号、时间这类和相关性无关的键上。

标题是更好的排序信号。标题通常概括文档的主旨,标题命中往往比正文命中更说明"这正是用户问的"。重排阶段把标题权重调高,能把标题相关的文档提到最前。

注入位置衰减

检索结果注入上下文时,还有一个独立问题:位置。文档放在上下文的前段还是后段,对模型使用证据的效果有影响。实验用 1 / (1 + decay·(position−1)) 这个衰减模型表示:位置越靠后,证据的有效权重越低。

这不是"模型读不到后面的内容",而是放在后面更容易被忽略。对 Agent 来说,这决定了两件事:

  1. 证据放哪:关键引用要放在注入位置的前段;
  2. 多长:长文档堆在后面,等于把证据塞进模型不容易用的区域。

最小实验:两阶段分工

下面的实验用 9 篇文档的固定小语料,4 个查询。第一阶段按正文重叠排序,第二阶段加标题权重重排。

# file: agp_lab/retrieval_rank.py | write
# tier: 3
# verify: python3 -m unittest tests.test_retrieval_rank
"""检索:召回、重排与注入位置。

两阶段检索的最小模型:

1. 第一阶段只看正文词重叠,负责把相关文档放进候选池(recall@k);
2. 第二阶段加入标题权重,负责把正确文档排到前面(top-1 精度);
3. 注入位置会衰减证据的有效权重,位置越靠后越容易被忽略。

实验用固定小语料展示:候选池的 recall@3 已经饱和时,重排仍然能显著
改善 top-1。它验证的是两阶段分工,不是某个检索器的普遍性能。
"""
from __future__ import annotations

from dataclasses import dataclass

TITLE_WEIGHT = 3.0
DECAY = 0.5


@dataclass(frozen=True)
class Doc:
    doc_id: str
    title: str
    body: str


DOCS = (
    Doc("d01", "订单 状态 查询", "订单 状态 已支付 已发货 退款 窗口 咨询"),
    Doc("d02", "退款 政策", "退款 窗口 7 天 订单 支付 原路 退回"),
    Doc("d03", "会员 权益 介绍", "账户 等级 权益 会员 价格 等级"),
    Doc("d04", "账户 等级 说明", "账户 等级 gold silver 权益 折扣"),
    Doc("d05", "账户 安全 设置", "账户 密码 二次验证 登录 权益 说明"),
    Doc("d06", "服务 扩容 操作", "扩容 实例 配额 服务 健康检查 重启"),
    Doc("d07", "服务 重启 手册", "服务 重启 drain healthcheck 实例"),
    Doc("d08", "报销 材料 清单", "发票 抬头 税号 报销 材料 清单"),
    Doc("d09", "发票 开具 流程", "发票 抬头 税号 订单 金额"),
)

QUERIES = (
    ("退款窗口", ("退款", "窗口"), ("d02",)),
    ("账户权益", ("账户", "等级", "权益"), ("d04",)),
    ("服务重启", ("服务", "重启", "健康检查"), ("d07",)),
    ("发票抬头", ("发票", "抬头", "税号"), ("d09",)),
)


def terms(text: str) -> set[str]:
    return set(text.split())


def body_score(doc: Doc, query: tuple[str, ...]) -> float:
    return float(len(terms(doc.body) & set(query)))


def rerank_score(doc: Doc, query: tuple[str, ...]) -> float:
    query_terms = set(query)
    title_hits = len(terms(doc.title) & query_terms)
    body_hits = len(terms(doc.body) & query_terms)
    return TITLE_WEIGHT * title_hits + body_hits


def rank_body(query: tuple[str, ...]) -> list[str]:
    ordered = sorted(DOCS, key=lambda doc: (-body_score(doc, query), doc.doc_id))
    return [doc.doc_id for doc in ordered]


def rank_rerank(query: tuple[str, ...]) -> list[str]:
    ordered = sorted(DOCS, key=lambda doc: (-rerank_score(doc, query), doc.doc_id))
    return [doc.doc_id for doc in ordered]


def recall_at_k(ranked: list[str], relevant: tuple[str, ...], k: int) -> float:
    if k < 1:
        raise ValueError("k 至少为 1")
    return 1.0 if set(ranked[:k]) & set(relevant) else 0.0


def mean_recall(ranker, k: int) -> float:
    return sum(recall_at_k(ranker(query), relevant, k)
               for _, query, relevant in QUERIES) / len(QUERIES)


def position_weight(position: int, decay: float = DECAY) -> float:
    """注入位置的衰减权重,仅为本实验声明的教学模型。"""
    if position < 1:
        raise ValueError("position 从 1 开始")
    if decay < 0:
        raise ValueError("decay 不能为负")
    return 1.0 / (1.0 + decay * (position - 1))


def position_table(limit: int = 6) -> list[tuple[int, float]]:
    return [(position, position_weight(position)) for position in range(1, limit + 1)]


def experiment() -> list[tuple[str, int, int, float, float]]:
    """返回 (查询, raw 位置, rerank 位置, raw@3, rerank@3)。"""
    rows: list[tuple[str, int, int, float, float]] = []
    for label, query, relevant in QUERIES:
        raw = rank_body(query)
        reranked = rank_rerank(query)
        target = relevant[0]
        rows.append((
            label,
            raw.index(target) + 1,
            reranked.index(target) + 1,
            recall_at_k(raw, relevant, 3),
            recall_at_k(reranked, relevant, 3),
        ))
    return rows


if __name__ == "__main__":
    print(f"{'查询':<10}{'raw位置':>8}{'rerank位置':>10}{'raw@3':>7}{'rerank@3':>9}")
    for label, raw_pos, rerank_pos, raw3, rerank3 in experiment():
        print(f"{label:<10}{raw_pos:>8}{rerank_pos:>10}{raw3:>7.1f}{rerank3:>9.1f}")
    print(
        f"平均:raw@1={mean_recall(rank_body, 1):.3f} "
        f"rerank@1={mean_recall(rank_rerank, 1):.3f} "
        f"raw@3={mean_recall(rank_body, 3):.3f} "
        f"rerank@3={mean_recall(rank_rerank, 3):.3f}"
    )
    print()
    print(f"{'注入位置':<10}{'有效权重':>10}")
    for position, weight in position_table():
        print(f"{position:<10}{weight:>10.3f}")

运行:

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

输出:

查询           raw位置  rerank位置  raw@3 rerank@3
退款窗口             2         1    1.0      1.0
账户权益             2         1    1.0      1.0
服务重启             2         1    1.0      1.0
发票抬头             2         1    1.0      1.0

平均:raw@1=0.000 rerank@1=1.000 raw@3=1.000 rerank@3=1.000

注入位置            有效权重
1              1.000
2              0.667
3              0.500
4              0.400
5              0.333
6              0.286

这张表把三件事一次讲清。

召回已经饱和,top-1 还差得远。 四个查询的 raw@3 全是 1.0,正文召回在候选池层面已经满分;但 raw@1 是 0.000——四个查询的正确文档全部排在第 2 位,没有一个进到第 1 位。如果评测只测 recall@k,你会以为检索已经完美;测 top-1 才发现它完全不可用。 这正是"召回与 top-1 是两个指标"的最好例证。

重排把 top-1 从 0.000 修到 1.000。 加标题权重后,四个查询的正确文档全部进到第 1 位,rerank@1=1.000。为什么有效?看"退款窗口"这个查询:退款政策(d02)标题命中"退款",而 订单状态查询(d01)标题不命中;正文两人重叠数相同,标题让 d02 胜出。重排在这里不是"更智能",只是用了排序更有效的信号。

位置衰减解释了"为什么证据要往前放"。 第 1 位权重 1.0,第 3 位 0.5,第 6 位 0.286。同样的证据,放在第 3 位只有一半有效权重,放在第 6 位只剩 28.6%。检索系统不只决定"给哪些文档",还决定"给完的代价"——堆在后面的证据,价值被打折。

指标要分开读

三个指标回答三个问题,必须分开报:

指标回答差在哪
recall@k相关的进候选池了吗漏检
top-1 / top-k 精度正确的排到前面了吗排序错
证据命中率模型引用对了吗注入错

只报一个指标会掩盖一种失败。报 recall 掩盖排序失败;报 top-1 掩盖候选池漏检;报"模型说对了"掩盖证据根本没用上。实验里 recall 满分而 top-1 为零,就是单指标谎报的典型案例。

架构含义

检索对架构有三个直接约束:

  1. 召回与重排分离。 两阶段用不同信号,各自可调、各自可测。
  2. 证据要带来源与位置。 注入结果要记录文档 ID、片段与位置,才能审计"模型用了哪条证据"。
  3. 注入顺序要可控。 关键证据往前放,长文档与低相关文档往后放或省略。

第 2 条连接更广的可靠性要求:如果注入不记录来源,Agent 的引用就无法回查,幻觉防线就断了。

架构判据

判据合格的样子不合格的样子
两阶段分工召回与重排信号分离一套排序干两件事
指标分开recall 与 top-1 都报只报一个平均分
证据可溯源文档 ID + 片段 + 位置只给一段文本
注入有序关键证据靠前结果按检索原序堆
位置衰减后置证据权重显式打折假设位置无影响

“指标分开"是最低要求。一次评测同时输出 recall@k 和 top-1,两种失败立刻可见;合一个分,两种失败互相抵消。

与三条工作负载的关系

  • W1 检索问答:top-1 几乎决定成败——答案来自排第一的文档,排序错一步,答案就错。
  • W2 代码修复:recall 更重要,候选补丁/相关函数进没进池子比顺序更要紧。
  • W3 运维处置:证据溯源最重要,处置依据的文档要能回查到版本与来源。

W1 是最依赖重排的负载,W2 是最依赖召回的负载,W3 是最依赖溯源的负载。同一套检索管线服务三类负载,就要按负载配重排强度与溯源要求。

小结

  • 检索是三件事:召回、重排、注入位置;三个指标分开报。
  • 正文重叠召回效率高,但对排序不够用;标题是更有效的排序信号。
  • recall@k 可以满分而 top-1 为零:候选池对了、顺序全错。
  • 注入位置衰减证据权重,位置越靠后越容易被忽略。
  • 两阶段分工让召回与重排各自可调、各自可测。
  • 证据要带文档 ID、片段与位置,否则引用无法回查。

阅读导航:上一节:8.3 遗忘、TTL 与冲突消解 · 下一节:9.2 摘要与压缩:损失、可逆性与风险 。

常见错误与边界

  1. 一套排序干两件事。 召回和重排的目标不同,混在一起 top-1 必然受损。
  2. 只报 recall。 recall 满分而 top-1 为零时,单指标会谎报成功。
  3. 只看 top-1。 候选池漏检时,排序再准也救不了丢失的相关文档。
  4. 证据不溯源。 不记文档 ID 与位置,引用无法回查,幻觉防线断掉。
  5. 按原序堆结果。 关键证据被埋到后段,权重衰减让它的价值打折。
  6. 假设位置无影响。 模型确实更容易忽略后置证据;注入顺序是系统决策。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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