---
tags: [AI, rag, retrieval]
阶段: 06-Prompt与RAG
难度: ★★☆
created: 2026-10-18
related: "[[Embedding与向量检索]], [[向量数据库]], [[RAG评估]]"
---

# RAG原理与流程

## 定义

**检索增强生成**（retrieval-augmented generation，RAG）指在生成答案前，从外部知识库检索与输入相关的文档片段 $z$，并把 $z$ 作为条件送入生成模型，使输出分布条件于外部证据的过程。其概率形式为

$$
p(y\mid x)=\sum_{z\in\mathcal{Z}}p_\eta(z\mid x)\,p_\theta(y\mid x,z),
$$

其中 $x$ 是用户输入，$y$ 是输出序列，$\mathcal{Z}$ 是文档片段集合，$p_\eta(z\mid x)$ 是**检索器**（retriever）给出的相关性分布，$p_\theta(y\mid x,z)$ 是**生成器**（generator）在证据条件下的输出分布。实际系统用前 $k$ 个片段近似求和：

$$
p(y\mid x)\approx\sum_{z\in\mathcal{Z}_k(x)}p_\eta(z\mid x)\,p_\theta(y\mid x,z),
\qquad
\mathcal{Z}_k(x)=\operatorname*{topk}_{z\in\mathcal{Z}}\ p_\eta(z\mid x).
$$

**索引阶段**（indexing）是离线过程：采集文档、清洗、分块、编码为向量、写入索引与元数据。**查询阶段**（querying）是在线过程：改写查询、检索、过滤与重排、拼接提示词、生成、校验引用。

符号约定如下。

| 符号 | 含义 |
|---|---|
| $x$ | 用户输入，通常是一个问题或指令 |
| $y=(y_1,\dots,y_m)$ | 输出 token 序列，长度 $m$ |
| $z$ | 一个文档片段，检索的最小单位 |
| $\mathcal{Z}$ | 全部片段集合，$\lvert\mathcal{Z}\rvert=N$ |
| $\mathcal{Z}_k(x)$ | 检索器返回的前 $k$ 个片段 |
| $p_\eta(z\mid x)$ | 检索器分布，$\eta$ 为检索模型参数 |
| $p_\theta(y\mid x,z)$ | 生成器分布，$\theta$ 为生成模型参数 |
| $k$ | 检索条数 |
| $B$ | 上下文窗口长度，以 token 计 |
| $T_{\text{sys}},T_q,T_{z_i},T_{\text{out}}$ | 系统提示、问题、第 $i$ 个片段、输出预留的 token 数 |
| $\epsilon_k$ | 截断误差，被丢弃片段的概率质量 |
| $e_{\text{miss}},e_{\text{hit}}$ | 检索未命中与命中条件下的生成错误率 |
| $s$ | 检索得分，用于阈值判定 |

其余术语在首次出现处定义：**RAG-Sequence** 指整段输出共享同一组检索片段；**RAG-Token** 指每个输出 token 可对片段重新加权；**上下文**（context）指拼接后送入生成器的全部文本；**忠实性**（faithfulness）指输出内容可由给定上下文支持的程度；**幻觉**（hallucination）指输出包含无证据支持或与证据冲突的内容。

## 为什么重要

参数化知识有三个固有约束。第一，训练截止：模型不知道截止日期之后发生的事。第二，长尾覆盖：低频实体与私有文档在预训练语料中占比极低，模型只能给出笼统或错误的回答。第三，不可追溯：即使答案正确，也无法指出它来自哪段文本，审计与纠错缺少入口。微调可以注入知识，但每次更新都要重新训练，且注入的事实仍以参数形式存在，无法逐条核对。

RAG 把“记住”改为“查证”：知识存放在外部索引中，可以随时增删改；生成时把相关片段写入上下文，使答案有条件地依赖证据，并可通过引用编号追溯到具体片段。这一改变不需要修改模型参数，因此知识更新与模型迭代解耦。代价是系统从“一次模型调用”变成“检索加生成”的流水线，新增了检索未命中、上下文噪声、引用错位等失效模式。

RAG 并不能消除幻觉。它改变的是生成时的条件项，而不是生成器的训练目标；模型仍可能忽略上下文、混用参数知识、或忠实地复述一条错误资料。把 RAG 当作事实性保证的系统，会在检索失败时得到看起来同样自信的错误答案。正确的做法是把系统拆成检索、上下文、生成三层分别度量，定位错误发生在哪一层，这决定了优化投入的方向。

在本库中，本篇位于检索与生成的接合处：前置是 [[Embedding与向量检索]] 与 [[向量数据库]]，它们解决“如何找到候选”；后续是 [[RAG文档分块策略]]（检索单位如何切分）、[[检索优化与重排Rerank]]（候选如何精排）、[[进阶RAG-Self-RAG与Agentic-RAG]]（检索时机与迭代）与 [[RAG评估]]（如何按层度量）。对照 [[幻觉与缓解]] 可以看清 RAG 能缓解与不能缓解的幻觉类型。学习目标是能写出形式化目标、实现一个可运行的最小系统、并设计分层评估。

## 原理与推导

### 1 形式化：检索器、生成器与两种边缘化

RAG 把片段 $z$ 视为潜变量，对全部片段做边缘化。直接计算需要遍历 $N$ 个片段并为每个片段运行一次生成器，代价为 $O(N)$ 次前向，不可行。两个近似同时使用：只保留概率质量最高的 $k$ 个片段；用检索得分构造 $p_\eta$。若检索器是双塔模型，则

$$
p_\eta(z\mid x)=\frac{\exp\big(\mathbf{q}(x)^{\top}\mathbf{d}(z)\big)}{\sum_{z'\in\mathcal{Z}}\exp\big(\mathbf{q}(x)^{\top}\mathbf{d}(z')\big)},
$$

分母需要对全库求和，实际用 top-k 的得分做 softmax 近似，或直接以排序作为权重。

在生成侧有两种边缘化方式。**RAG-Sequence** 对整段输出使用同一组片段：

$$
p_{\text{seq}}(y\mid x)\approx\sum_{z\in\mathcal{Z}_k(x)}p_\eta(z\mid x)\prod_{t=1}^{m}p_\theta\big(y_t\mid x,z,y_{<t}\big).
$$

**RAG-Token** 在每个 token 位置重新加权：

$$
p_{\text{tok}}(y\mid x)\approx\prod_{t=1}^{m}\sum_{z\in\mathcal{Z}_k(x)}p_\eta(z\mid x)\,p_\theta\big(y_t\mid x,z,y_{<t}\big).
$$

两者的差别在于假设。RAG-Sequence 假设一段答案由一个片段支撑，适合同一文档内的问答；RAG-Token 允许逐 token 切换证据，适合需要综合多个片段的答案，但计算量与实现复杂度更高。工程上多数系统采用 RAG-Sequence 的近似：检索一次，拼接全部片段，生成一次。

需要区分混合与拼接。混合按 $p_\eta$ 加权，对每个片段各运行一次生成器再求和，代价是 $k$ 倍前向；拼接把所有片段放入同一上下文，条件变为集合 $\mathcal{Z}_k(x)$，只需一次前向。工程系统几乎都采用拼接，形式化中的求和给出的是拼接行为的概率解释，而不是实际计算图。这一区别在评估时很重要：拼接下模型可以跨片段组合信息，混合下每个片段独立生成，二者的忠实性失效模式不同。

截断误差可以界定。设 $\tilde p(y\mid x)=\sum_{z\in\mathcal{Z}_k}p_\eta(z\mid x)p_\theta(y\mid x,z)$，由于 $p_\theta\le1$，

$$
\big\lvert p(y\mid x)-\tilde p(y\mid x)\big\rvert
=\sum_{z\notin\mathcal{Z}_k}p_\eta(z\mid x)\,p_\theta(y\mid x,z)
\le\sum_{z\notin\mathcal{Z}_k}p_\eta(z\mid x)=\epsilon_k .
$$

因此增大 $k$ 会单调减小截断误差；但上下文长度随 $k$ 线性增长，噪声与成本同步上升，$k$ 的选择是误差与干扰的权衡，而不是越大越好。

训练层面，原始 RAG 把检索器与生成器联合优化：固定 top-k 集合，用生成似然对检索器参数求梯度。由于 top-k 的选取不可导，梯度只通过被选中片段的得分传播，未被选中的片段不获得梯度。这一近似使训练可行，但也意味着检索器的学习信号稀疏，实践中常用“冻结检索器 + 只训练生成器”或“先用对比学习单独训练检索器”的两阶段方案。

### 2 索引阶段

索引阶段决定检索的上限。流程与每步的失败后果如下。

| 步骤 | 产出 | 设计选择 | 失败后果 |
|---|---|---|---|
| 采集 | 原始文档与来源信息 | 覆盖范围、权限、时效 | 知识缺口，答案无从检索 |
| 清洗 | 正文与结构 | 去模板、去导航、保留标题层级 | 噪声片段进入索引 |
| 分块 | 片段 $z$ | 长度、重叠、按结构切分 | 语义被切断或片段过大 |
| 编码 | 向量 $\mathbf{d}(z)$ | 模型、维度、归一化 | 与查询不同空间，召回骤降 |
| 建索引 | ANN 结构 | HNSW、IVF、PQ 及参数 | 召回或延迟不达标 |
| 元数据 | id、来源、时间、权限 | 字段设计与过滤下推 | 过滤失效或越权 |

分块是影响最大的选择，单独在 [[RAG文档分块策略]] 展开。此处只给出与 RAG 形式化直接相关的约束：片段必须足够小，使 $k$ 个片段能放进上下文预算；又必须足够大，使单个片段包含完整语义。两个约束冲突时，常用父子块结构：用小块检索，用大块生成。

索引阶段还应记录模型版本与索引版本。查询向量与文档向量必须来自同一模型、同一归一化方式；模型升级后必须全量重编码并重建索引，新旧索引不能混用。

### 3 查询阶段与最小流程

查询阶段的最小流程包含六步，任何一步缺失都会引入可观测的失效。

```mermaid
flowchart LR
    DOC[文档] --> CH[清洗与分块]
    CH --> EMB[嵌入编码]
    EMB --> IDX[(向量索引)]
    CH --> META[(元数据)]
    Q[用户问题] --> RW[查询改写]
    RW --> RET[检索 top-k]
    IDX --> RET
    META --> RET
    RET --> RR[过滤与去重]
    RR --> ASM[预算内拼接]
    ASM --> GEN[生成]
    GEN --> CITE[引用校验]
```

各步的作用与省略后的后果如下。

| 步骤 | 作用 | 省略后的典型失败 |
|---|---|---|
| 查询改写 | 补全指代、扩展同义词、拆分子问题 | 多轮对话中的指代查询检索不到 |
| 检索 | 返回 $k$ 个候选 | 无候选则生成器只能依赖参数知识 |
| 过滤与去重 | 应用权限、时间与来源条件，去除重复片段 | 越权内容进入上下文，重复片段挤占预算 |
| 拼接 | 按模板组织片段、问题与约束 | 模型无法区分资料与指令，或忽略资料 |
| 生成 | 在上下文中产生答案与引用 | 无引用则无法追溯 |
| 引用校验 | 检查引用编号存在且内容匹配 | 引用错位不会被发现 |

延迟预算按阶段分配。以交互式问答为例：查询编码 10 到 50 ms，ANN 检索 5 到 50 ms，重排 30 到 200 ms，生成 0.5 到 5 s。检索阶段通常只占总延迟的 5% 到 20%，因此用重排换取精度往往是划算的；但生成延迟随输出长度线性增长，控制输出长度比压缩检索更有效。

### 4 拼接模板与上下文预算

拼接把检索结果转换为生成器的输入。一个最小模板包含四个区段。

```text
[资料]
[D1] 片段一正文
[D2] 片段二正文

[问题]
用户问题

[要求]
仅依据 [资料] 回答；每个结论后标注 [D编号]；
资料不足时只输出“无法从给定资料确定”。
```

模板中的编号承担两个功能：为模型提供引用锚点，为下游程序提供校验依据。编号必须在拼接后保持不变，去重与重排如果改变了顺序，必须同步重编号，否则引用会错位。

上下文预算是硬约束：

$$
T_{\text{sys}}+T_q+\sum_{i=1}^{k}T_{z_i}+T_{\text{out}}\le B .
$$

超出预算时有四种处理：减小 $k$、截断单个片段、对片段做摘要压缩、把问题拆成多轮。四种方式的失效不同：减小 $k$ 会提高截断误差 $\epsilon_k$；截断片段可能切断关键句；摘要压缩会引入新的生成错误；拆分子问题会增加调用次数与延迟。选择依据是下游指标的敏感度，需实测。

片段顺序影响利用率。经验结果是相关信息放在上下文中部时被利用的概率低于放在首尾，这一现象被称为“中间遗失”（lost in the middle），在长上下文中更明显。工程上的做法是把最相关的片段放在最前，把次相关或补充材料放在最后，避免把唯一的关键证据放在中间。

### 5 为什么缓解幻觉但不消除

幻觉的来源可以按与上下文的关系分为四类：知识缺失（模型不知道）、知识过时（模型记得旧版本）、证据冲突（上下文与参数知识矛盾）、生成不忠实（上下文正确但输出偏离）。RAG 直接作用于前两类：把缺失或过时的知识放入上下文。它对第三类只提供仲裁材料，对第四类没有直接影响。

用命中率分解错误率。设检索命中率为 $h$，未命中条件下的生成错误率为 $e_{\text{miss}}$，命中条件下的错误率为 $e_{\text{hit}}$，则

$$
P(\text{err})=(1-h)\,e_{\text{miss}}+h\,e_{\text{hit}} .
$$

取 $h=0.8$、$e_{\text{miss}}=0.6$、$e_{\text{hit}}=0.15$，得 $P=0.2\times0.6+0.8\times0.15=0.24$。把命中率提高到 0.9，$P=0.1\times0.6+0.9\times0.15=0.195$，下降 0.045；把命中条件下的错误率降到 0.08，$P=0.2\times0.6+0.8\times0.08=0.184$，下降 0.056；两者同时改进得 $0.06+0.072=0.132$。边际效应为

$$
\frac{\partial P}{\partial h}=e_{\text{hit}}-e_{\text{miss}}=-0.45,\qquad
\frac{\partial P}{\partial e_{\text{hit}}}=h=0.8 .
$$

命中率每提高 0.1，错误率下降约 0.045；命中条件下的错误率每降低 0.01，错误率下降 0.008。命中率越高，生成忠实性的边际收益越大；当 $h\to1$ 时，错误率的下界由 $e_{\text{hit}}$ 决定。这解释了为什么在检索已经较好时，继续堆检索参数收益有限，而约束生成、校验引用更有效。

RAG 不消除幻觉的四个具体原因如下。

1. 训练目标不包含忠实性。模型优化的是下一个 token 的似然，不是“输出被上下文蕴含”。忠实行为来自指令微调与偏好数据，是习得的行为而非结构保证。
2. 检索可能失败。未命中时上下文为空或无关，模型回退到参数知识；若参数知识错误，输出仍是流畅的错误答案。此时系统甚至没有可用于拒答的证据。
3. 证据可能冲突。多个片段给出不同数字或结论时，模型可能择一、混合或平均，输出无法由任何单一来源支持。
4. 语料本身可能错误。模型忠实复述一条错误资料，忠实性指标会给出高分，而事实性仍然错误。忠实不等于正确，两者必须分开度量。

因此 RAG 的正确表述是：它降低知识缺失型幻觉的概率，并提供可追溯性；它不保证事实正确，也不保证引用与内容一致。

### 6 与长上下文、微调、工具调用的边界

四种手段都能改变模型可用信息的范围，但作用位置不同。

| 维度 | RAG | 长上下文 | 微调 | 工具调用 |
|---|---|---|---|---|
| 知识更新 | 重建索引即可 | 每次请求携带最新文本 | 重新训练 | 实时查询 |
| 单次成本 | 检索开销加少量 token | 注意力随长度平方增长，token 费用高 | 训练成本高，推理成本不变 | 工具调用与网络开销 |
| 延迟 | 中，检索加生成 | 高，长序列前向慢 | 低 | 取决于工具 |
| 可追溯 | 强，片段可引用 | 中，模型可能引用原文 | 弱，知识在参数中 | 强，结果是结构化记录 |
| 能力改变 | 不改变模型能力 | 不改变模型能力 | 改变风格、格式与领域行为 | 扩展动作空间 |
| 适用场景 | 大规模、更新快、非结构化语料 | 小规模语料、需要整体理解 | 输出格式、语气、领域语感 | 精确计算、事务、结构化数据 |

四条判据可用于选择。第一，知识是否频繁更新：是则优先 RAG 或工具调用，微调不适合承载易变事实。第二，数据是否结构化：SQL、库存、订单等适合工具调用，RAG 处理的是非结构化文本。第三，是否需要改变行为而非补充知识：格式、语气、拒答策略适合微调。第四，语料能否整体放入上下文且问题需要跨文档全局理解：是则长上下文更直接，检索反而会破坏全局结构。

四者可以组合。常见架构是 RAG 提供文档证据、工具调用提供实时数据、微调固化输出格式，长上下文用于单次处理整篇报告。组合的代价是失效归因变难，必须为每条路径记录日志与指标。

### 7 三类失效：检索未命中、上下文噪声、生成不忠实

| 失效 | 定义 | 可观测信号 | 常见根因 | 缓解手段 |
|---|---|---|---|---|
| 检索未命中 | 标准片段不在前 $k$ 条 | Recall@k 低，标准片段排名靠后 | 词表不匹配、分块不当、嵌入模型不匹配、过滤条件过严、查询歧义 | 混合检索、查询改写、调整分块、更换嵌入模型、放宽过滤 |
| 上下文噪声 | 上下文中含无关、重复或冲突片段 | 上下文精确率低，答案引用无关片段 | $k$ 过大、检索精度低、文档重复、多版本共存 | 重排、去重、按时间过滤、压缩、降低 $k$ |
| 生成不忠实 | 输出内容不被上下文支持 | 忠实性评分低，引用编号与内容不符 | 约束过弱、模型先验过强、上下文过长、证据冲突 | 强化指令、先引用后作答、NLI 校验、拒答策略、拆分问题 |

三类失效的归因顺序是先检索、后上下文、最后生成。原因是检索未命中时，任何生成侧的修改都无法恢复正确证据；上下文噪声会同时拉低忠实性与正确率，掩盖生成器的真实能力；只有在检索与上下文都合格时，生成不忠实才可以被单独测量。

把命中与否、忠实与否交叉，得到四种结果。

| | 生成忠实 | 生成不忠实 |
|---|---|---|
| 检索命中 | 正确答案，系统目标 | 有证据但答错，属于生成问题 |
| 检索未命中 | 拒答或泛泛而谈，可接受但无用 | 编造，风险最高 |

右下角是 RAG 系统最危险的状态：没有证据，模型仍然给出自信的答案。缓解手段是显式的拒答策略：在提示中定义“资料不足”的输出，并在生成后检查引用是否为空；空引用且无拒答标记时，判定为高风险输出。

### 8 评估切口

评估必须分层，否则无法定位改进点。

| 层次 | 指标 | 计算方式 | 用途 |
|---|---|---|---|
| 检索 | Recall@k、MRR、nDCG | 与标注的相关片段比较 | 判断证据是否被找到 |
| 上下文 | 上下文精确率、冗余率、覆盖率 | 相关片段占上下文的比例，重复片段比例 | 判断进入生成器的材料质量 |
| 生成 | 忠实性、引用合法率、答案相关性 | 逐句或逐结论判定是否被上下文支持 | 判断模型是否使用证据 |
| 端到端 | 正确率、拒答准确率、延迟、成本 | 与标准答案比较，统计拒答与资源消耗 | 判断系统是否可用 |

三元组评估把上述层次归纳为三个量：上下文相关性（检索到的内容是否与问题相关）、忠实性（答案是否由上下文支持）、答案相关性（答案是否回应问题）。三个量分别对应检索、生成、任务完成度，任一为低都可以定位到具体环节。

评估协议需要注意三点。第一，查询集要包含不可回答的问题，比例建议 20% 到 30%，否则拒答能力无法测量。第二，标注要区分“相关”与“包含答案”，前者用于召回指标，后者用于端到端正确率。第三，任何改动都要在固定查询集上重跑全部层次，只报告端到端指标会掩盖层次间的抵消，详见 [[RAG评估]]。

## 关键直觉

> [!tip] RAG 把“把知识记在参数里”改为“把知识放在索引里，生成时按查询取回并条件化”；它改变的是条件分布的证据项 $p_\theta(y\mid x,z)$，不改变生成器的训练目标，因此只能提高“有证据可用”的概率，不能保证“使用了证据”。
>
> 与严格定义的关系：定义中的边缘化式 $p(y\mid x)=\sum_z p_\eta(z\mid x)p_\theta(y\mid x,z)$ 说明检索器与生成器是两个可分别度量的部件；截断误差 $\epsilon_k$ 说明 $k$ 的选择是在遗漏证据与引入噪声之间的权衡；错误分解 $P=(1-h)e_{\text{miss}}+he_{\text{hit}}$ 说明检索改进与生成改进的边际收益取决于当前的命中率，这就是分层评估的理论依据。

## 例子与代码

以下实现是一个不依赖外部 API 的最小 RAG：TF-IDF 检索器、字符二元组分词、模板拼接、抽取式伪生成器与分层评估。运行环境为 Python 3.12 标准库，无第三方依赖。伪生成器的作用是把流水线跑通并暴露失效，而不是模拟语言模型的能力。

```python
import math
import re

DOCS = {
    "D1": "KV 缓存保存已计算的键与值张量，解码时避免重复计算，代价是显存占用随序列长度线性增长。",
    "D2": "分组查询注意力让多个查询头共享一组键值头，减少键值缓存的显存占用。",
    "D3": "LoRA 在权重旁加入低秩分解矩阵，只训练新增参数，冻结原始权重。",
    "D4": "QLoRA 将基座权重量化为 4 比特，并引入双重量化与分页优化器降低显存。",
    "D5": "HNSW 用多层图组织向量，查询从顶层贪心下行，在底层用束搜索返回近邻。",
    "D6": "IVF 先用聚类把向量分桶，查询时只扫描最近的若干桶，nprobe 控制扫描桶数。",
    "D7": "乘积量化把向量切成子向量并分别聚类，用码字编号代替原始浮点向量。",
    "D8": "BM25 依据词频、逆文档频率与文档长度归一化对文档打分，适合关键词匹配。",
    "D9": "对比学习用批内负例训练双塔编码器，温度参数控制负例权重的集中程度。",
    "D10": "RAG 在生成前检索外部文档，把检索结果写入提示词，使回答可引用来源。",
}

TOKEN = re.compile(r"[a-z0-9]+|[\u4e00-\u9fff]+")

def tokenize(text):
    """英文数字按整词、中文按字符二元组切分，避免依赖分词库。"""
    out = []
    for m in TOKEN.findall(text.lower()):
        if m.isascii() or len(m) == 1:
            out.append(m)
        else:
            out.extend(m[i:i + 2] for i in range(len(m) - 1))
    return out

tf = {k: {} for k in DOCS}
for k, text in DOCS.items():
    for t in tokenize(text):
        tf[k][t] = tf[k].get(t, 0) + 1
df = {}
for counts in tf.values():
    for t in counts:
        df[t] = df.get(t, 0) + 1
N = len(DOCS)

def idf(t):
    return math.log((1 + N) / (1 + df.get(t, 0))) + 1.0

def l2(vec):
    norm = math.sqrt(sum(v * v for v in vec.values()))
    return {t: v / norm for t, v in vec.items()} if norm else {}

# 文档向量：tf 乘 idf 后归一化
DVEC = {k: l2({t: c * idf(t) for t, c in tf[k].items()}) for k in DOCS}

def retrieve(question, k=3):
    qv = {}
    for t in tokenize(question):
        if t in df:
            qv[t] = qv.get(t, 0.0) + idf(t)
    qv = l2(qv)
    scored = [(sum(qv.get(t, 0.0) * w for t, w in DVEC[d].items()), d) for d in DOCS]
    scored.sort(key=lambda x: (-x[0], x[1]))
    return scored[:k]

TEMPLATE = """[资料]
{context}

[问题]
{question}

[要求]
仅依据 [资料] 回答，每个结论后标注 [D编号]；资料不足时只输出"无法从给定资料确定"。"""

def build_prompt(question, hits):
    context = "\n".join(f"[{d}] {DOCS[d]}" for _, d in hits)
    return TEMPLATE.format(context=context, question=question)

CLAUSE = re.compile(r"[^。；，]+")

def best_clause(text, qtokens):
    best, best_hit = "", 0
    for c in CLAUSE.findall(text):
        c = c.strip()
        if len(c) < 4:
            continue
        hit = len(set(qtokens) & set(tokenize(c)))
        if hit > best_hit:
            best, best_hit = c, hit
    return best, best_hit

def generate(prompt, min_hit=2):
    """伪生成器：不调用模型，抽取与问题词面重合最高的子句并附引用。"""
    question = prompt.split("[问题]")[1].split("[要求]")[0].strip()
    qtokens = tokenize(question)
    blocks = re.findall(r"^\[(D\d+)\] (.+)$", prompt, flags=re.M)
    parts, cited = [], []
    for did, text in blocks:
        clause, hit = best_clause(text, qtokens)
        if hit >= min_hit:
            parts.append(f"根据 [{did}]：{clause}")
            cited.append(did)
    if not parts:
        return "无法从给定资料确定。", []
    return "；".join(parts) + "。", cited
```

检索器部分做三件事：把文档与查询映射为稀疏向量，用 IDF 给罕见词加权，用 L2 归一化使内积等于余弦。`retrieve` 对每个文档计算 $q$ 与 $d$ 的稀疏内积，并按分数降序、id 升序返回，稳定排序保证零分文档的顺序可复现。若去掉归一化，长文档的 TF-IDF 模长更大，短查询会系统性偏向长文档。

生成器部分不调用任何模型，只做抽取：从提示词中解析 `[D编号]` 块，按查询词项与子句的重合数选句，重合数低于阈值则跳过。`min_hit=2` 是一个可调的策略参数，它近似“证据支持度”的下界，而不是模型能力。

```python
print("=== 查询 1：可回答 ===")
q1 = "如何降低键值缓存的显存占用"
hits = retrieve(q1)
prompt = build_prompt(q1, hits)
print(prompt)
print("--- 生成 ---")
answer, cited = generate(prompt)
print(answer)
print("引用:", cited, "Top3:", [(d, round(s, 3)) for s, d in hits])

print("\n=== 查询 2：资料未覆盖（部分词面重合）===")
q2 = "量子计算机的退相干时间如何测量"
hits = retrieve(q2)
print("Top3:", [(d, round(s, 3)) for s, d in hits])
print("生成:", generate(build_prompt(q2, hits)))

print("\n=== 查询 3：资料未覆盖（无词面重合）===")
q3 = "护照办理需要哪些材料"
hits = retrieve(q3)
print("Top3:", [(d, round(s, 3)) for s, d in hits])
print("生成:", generate(build_prompt(q3, hits)))
```

```text
=== 查询 1：可回答 ===
[资料]
[D2] 分组查询注意力让多个查询头共享一组键值头，减少键值缓存的显存占用。
[D1] KV 缓存保存已计算的键与值张量，解码时避免重复计算，代价是显存占用随序列长度线性增长。
[D4] QLoRA 将基座权重量化为 4 比特，并引入双重量化与分页优化器降低显存。

[问题]
如何降低键值缓存的显存占用

[要求]
仅依据 [资料] 回答，每个结论后标注 [D编号]；资料不足时只输出"无法从给定资料确定"。
--- 生成 ---
根据 [D2]：减少键值缓存的显存占用；根据 [D1]：代价是显存占用随序列长度线性增长；根据 [D4]：并引入双重量化与分页优化器降低显存。
引用: ['D2', 'D1', 'D4'] Top3: [('D2', 0.508), ('D1', 0.162), ('D4', 0.106)]

=== 查询 2：资料未覆盖（部分词面重合）===
Top3: [('D1', 0.331), ('D10', 0.0), ('D2', 0.0)]
生成: ('无法从给定资料确定。', [])

=== 查询 3：资料未覆盖（无词面重合）===
Top3: [('D1', 0.0), ('D10', 0.0), ('D2', 0.0)]
生成: ('无法从给定资料确定。', [])
```

查询 1 暴露了一个容易被指标掩盖的问题。答案引用了三条片段，引用全部合法，但 [D1] 的子句说明的是显存随序列增长的代价，不是降低显存的方法；[D4] 的子句描述 QLoRA 的显存优化，与键值缓存无关。引用合法率会是 1.0，答案相关性却不高。这说明引用校验只能排除“编号不存在”这类错误，不能替代忠实性与相关性判断。

查询 2 中，检索器返回 D1，得分 0.331，因为查询中的“计算”与 D1 的“已计算”共享字符二元组；生成器因重合数不足 2 而拒答。若把阈值改为 1，同一系统会输出一条与量子计算无关的 KV 缓存结论，且引用合法。阈值在这里承担拒答策略的角色，它必须与检索质量联合标定。

查询 3 中全部文档得分为零，排序退化为 id 顺序，生成器拒答。这是理想的未命中行为，但它同时说明检索器没有任何“不知道”的信号可用：零分只是恰好因为查询字符与语料完全不重合。

```python
LABELED = [
    ("如何降低键值缓存的显存占用", "D2"),
    ("HNSW 的查询过程如何从顶层向下搜索", "D5"),
    ("IVF 如何用聚类分桶减少扫描", "D6"),
    ("BM25 的长度归一化起什么作用", "D8"),
    ("RAG 的回答如何引用来源", "D10"),
    ("如何在单卡上训练大模型", "D4"),
]
UNANSWERABLE = ["量子计算机的退相干时间如何测量", "护照办理需要哪些材料"]

print("\n=== 评估 ===")
recalls, mrrs, cite_ok, gold_in_answer = [], [], [], []
for q, gold in LABELED:
    hits = retrieve(q, k=3)
    ids = [d for _, d in hits]
    rank = ids.index(gold) + 1 if gold in ids else 0
    recalls.append(1.0 if rank else 0.0)
    mrrs.append(1.0 / rank if rank else 0.0)
    ans, cited = generate(build_prompt(q, hits))
    cite_ok.append(all(c in ids for c in cited))
    gold_in_answer.append(gold in cited)
    print(f"{q:<22} gold={gold} top3={ids} rank={rank} cited={cited}")

refuse = []
for q in UNANSWERABLE:
    ans, cited = generate(build_prompt(q, retrieve(q)))
    refuse.append(ans.startswith("无法"))
    print(f"{q:<22} 拒答={ans.startswith('无法')} 输出={ans[:24]}")

print(f"\nRecall@3={sum(recalls)/len(recalls):.3f}  MRR@3={sum(mrrs)/len(mrrs):.3f}")
print(f"引用合法率={sum(cite_ok)/len(cite_ok):.3f}  答案含标准文档={sum(gold_in_answer)/len(gold_in_answer):.3f}")
print(f"无答案拒答率={sum(refuse)/len(refuse):.3f}")
```

```text
=== 评估 ===
如何降低键值缓存的显存占用          gold=D2 top3=['D2', 'D1', 'D4'] rank=1 cited=['D2', 'D1', 'D4']
HNSW 的查询过程如何从顶层向下搜索    gold=D5 top3=['D5', 'D2', 'D6'] rank=1 cited=['D5']
IVF 如何用聚类分桶减少扫描        gold=D6 top3=['D6', 'D2', 'D7'] rank=1 cited=['D6']
BM25 的长度归一化起什么作用       gold=D8 top3=['D8', 'D1', 'D10'] rank=1 cited=['D8']
RAG 的回答如何引用来源          gold=D10 top3=['D10', 'D1', 'D2'] rank=1 cited=['D10']
如何在单卡上训练大模型            gold=D4 top3=['D3', 'D9', 'D1'] rank=0 cited=[]
量子计算机的退相干时间如何测量        拒答=True 输出=无法从给定资料确定。
护照办理需要哪些材料             拒答=True 输出=无法从给定资料确定。

Recall@3=0.833  MRR@3=0.833
引用合法率=1.000  答案含标准文档=0.833
无答案拒答率=1.000
```

评估结果需要分三层解读。检索层：Recall@3 为 0.833，唯一失败的是“如何在单卡上训练大模型”，标准片段 D4 未进入前三。根因是词表不匹配：D4 的文本中没有“训练”“单卡”“模型”这些词，检索器只能匹配到 D3 的“只训练新增参数”，这是同主题但不同问题的片段；换成按语义编码的嵌入或加入查询改写可以缓解。生成层：引用合法率为 1.0，但如查询 1 所示，合法引用不等于答案相关，真实系统还需要忠实性判定。拒答层：两个不可回答问题的拒答率均为 1.0，其中查询 2 依赖 `min_hit` 阈值，查询 3 依赖零分，两者的机制不同。

这套指标不能直接外推到生产系统。语料只有 10 条，检索得分绝对值（0.508、0.331）没有可比性；标注只有 6 条可回答问题，Recall@3 的一个错误就造成 0.167 的波动。它适合验证流水线连通性与指标计算，不适合作为参数选择的依据。

## 易错点

> [!warning] 以下六条均可在日志、对照实验或错误分析中直接检验。
> 1. 把 RAG 当作消除幻觉的方案：检索命中后模型仍可能忽略证据或混用参数知识。必须分别测量检索命中率与忠实性，不能只看端到端正确率。
> 2. 只评估最终答案：答案错误可能来自检索未命中、上下文噪声或生成不忠实，三者修复方式不同。没有分层指标就无法归因，改进只能靠猜测。
> 3. 拼接后重编号或改变片段顺序：引用编号与正文错位，引用校验失效。去重与重排后必须重新生成编号映射，并用程序校验每个 `[D编号]` 都能在上下文中找到对应片段。
> 4. 无限增大 $k$：上下文变长会引入噪声与“中间遗失”，成本线性上升；截断误差 $\epsilon_k$ 的下降在 $k$ 超过一定值后可以忽略。$k$ 应按上下文预算与评估结果确定。
> 5. 认为“忠实”等于“正确”：模型可以忠实复述一条错误资料，忠实性评分高而事实错误。评估必须同时包含事实正确性与证据质量，语料本身的错误需要单独抽检。
> 6. 用同一批查询反复调参并报告该批指标：这等价于在测试集上训练，指标随迭代上升而线上不变。参数选择与最终评估必须使用不同查询集，或至少保留一份从未参与调参的留出集。

## 关联笔记

- 前置 [[Embedding与向量检索]] 与 [[向量数据库]]：前者决定检索器打分函数、归一化与 $p_\eta(z\mid x)$ 的质量，后者决定大规模检索的召回率与延迟，本篇的命中率 $h$ 与端到端延迟都以二者为前提。
- 后续 [[RAG文档分块策略]]：片段 $z$ 的粒度决定了检索精度与上下文完整性，是本篇索引阶段最关键的设计选择。
- 后续 [[检索优化与重排Rerank]]：混合检索与交叉编码器重排修正 $p_\eta$ 的排序误差，降低上下文噪声。
- 后续 [[RAG评估]]：本篇给出分层评估的切口，该篇给出查询集构造、标注协议与指标实现。
- 对照 [[幻觉与缓解]]：本篇说明 RAG 能缓解哪几类幻觉，该篇给出幻觉的分类与模型侧的缓解方法。

## 达标检测

- [ ] 写出 RAG 的边缘化式与 top-k 近似式，说明 $p_\eta$ 与 $p_\theta$ 分别由什么模型实现，并解释 RAG-Sequence 与 RAG-Token 的差别。
- [ ] 证明截断误差满足 $\lvert p-\tilde p\rvert\le\epsilon_k$，并说明为什么增大 $k$ 不能无限降低端到端错误率。
- [ ] 取 $h=0.7$、$e_{\text{miss}}=0.5$、$e_{\text{hit}}=0.2$，计算错误率；再分别计算命中率提高 0.1 与 $e_{\text{hit}}$ 降低 0.05 的收益，说明哪个更值得投入。
- [ ] 写出上下文预算不等式，给定 $B=8192$、$T_{\text{sys}}=300$、$T_q=50$、$T_{\text{out}}=800$、每片段 400 token，计算最多可放入多少片段。
- [ ] 运行本篇代码，把 `min_hit` 从 2 改为 1，观察查询 2 的输出变化，并解释拒答策略与检索质量的关系。
- [ ] 为一个真实问答场景设计三层评估表，列出每层的指标、数据来源与判定阈值，并说明如何区分“检索未命中”与“生成不忠实”。

## 参考来源

- Lewis et al., "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks", arXiv:2005.11401, 2020 —— 对应第 1 节的边缘化形式化、RAG-Sequence 与 RAG-Token 两种分解，以及检索器与生成器的联合训练。
- Gao et al., "Retrieval-Augmented Generation for Large Language Models: A Survey", arXiv:2312.10997, 2023 —— 对应第 3 节的索引与查询流程划分、第 7 节的失效分类与第 8 节的三元组评估框架。
- Liu et al., "Lost in the Middle: How Language Models Use Long Contexts", arXiv:2307.03172, 2023 —— 对应第 4 节关于片段顺序与位置效应的经验结论。
- Asai et al., "Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection", arXiv:2310.11511, 2023 —— 对应第 3 节检索时机与第 7 节生成不忠实的缓解思路，进阶方法见 [[进阶RAG-Self-RAG与Agentic-RAG]]。
- Karpukhin et al., "Dense Passage Retrieval for Open-Domain Question Answering", arXiv:2004.04906, 2020 —— 对应第 1 节检索器 $p_\eta$ 的双塔实现与批内负例训练。
- d2l.ai《动手学深度学习》第 10 章注意力机制与第 15 章自然语言处理：应用 —— 对应上下文条件化与序列到序列生成的基础推导。
