---
tags: [AI, context, rag]
阶段: 06-Prompt与RAG
难度: ★★☆
created: 2026-10-18
related: "[[Prompt工程]], [[RAG原理与流程]], [[检索优化与重排Rerank]]"
---

# 上下文工程与Few-shot

## 定义

**上下文**（context）是一次前向计算中模型可见的全部 token 序列 $C=(c_1,\dots,c_n)$，包括系统提示、few-shot 示例、检索文档、对话历史与已生成的输出前缀；**上下文工程**（context engineering）是在总预算 $B$ 的约束下，选择各组件的子集并确定其排列顺序，使任务回报的期望最大的过程，

$$
\max_{\{S_i\}_{i=1}^{m},\ \pi}\ \mathbb{E}_{(q,a)\sim\mathcal{D}}\Big[R\big(y\sim p_\theta(\cdot\mid \pi(S_1,\dots,S_m)\oplus q)\big)\Big]
\quad\text{s.t.}\quad \sum_{i=1}^{m}n(S_i)+n_{out}\le B,
$$

其中 $S_i$ 是第 $i$ 类组件的被选中内容，$n(S_i)$ 是其 token 数，$\pi$ 是拼接顺序，$n_{out}$ 是为输出预留的 token 数。

符号约定如下。

| 符号 | 含义 |
|---|---|
| $B$ | 上下文窗口上限，单位 token |
| $B_{in}=B-n_{out}$ | 可用于输入的预算 |
| $n_{sys},n_{ex},n_{ret},n_{hist}$ | 系统提示、示例、检索文档、对话历史占用的 token 数 |
| $n_{out}$ | 输出预留，通常取输出长度的 p99 |
| $k$ | few-shot 示例条数 |
| $\mathbf{e}(x)$ | 文本 $x$ 的嵌入向量，见 [[Embedding与向量检索]] |
| $\mathrm{sim}(x,y)$ | 相似度，默认为余弦相似度 $\mathbf{e}(x)^{\top}\mathbf{e}(y)/(\lVert\mathbf{e}(x)\rVert\lVert\mathbf{e}(y)\rVert)$ |
| $\mathrm{pos}(d)$ | 文档 $d$ 在上下文中首次出现的位置序号 |
| $\rho=n'/n$ | 压缩率，$n$ 为压缩前 token 数，$n'$ 为压缩后 |
| $\lambda$ | MMR 中相关性项与冗余项的权衡系数 |

其余术语在首次出现处定义：**few-shot 示例**是提供给模型的输入输出对；**近因偏差**（recency bias）指位置靠后的内容对输出的影响更大；**中间遗忘**（lost in the middle）指关键信息位于长上下文中间时被利用率下降的现象；**上下文污染**指上下文中混入错误、过期、互相冲突或恶意内容；**动态 few-shot** 指按查询实时检索示例，**固定 few-shot** 指人工挑选后写死在提示中。

## 为什么重要

上下文窗口从 4k 增长到 128k 以上，但没有改变一个事实：模型对上下文的利用是不均匀的，且每一步推理都要为全部输入 token 付费。把窗口当作容量不受限制的输入空间会产生三类可测量的损失。第一类是成本与延迟，prefill 的计算量随 $n_{in}$ 线性增长，注意力的显存与计算随 $n_{in}^{2}$ 增长，在长上下文下这两项成为吞吐的主要约束。第二类是位置损失，同一篇关键文档放在上下文的开头、中间、结尾，问答准确率不同，中间位置最差，这与 [[超长上下文-无限注意力]] 讨论的建模能力是不同层面的问题。第三类是干扰，检索到的无关文档越多，关键文档的注意力权重被稀释得越严重，检索条数增加反而可能降低准确率。

上下文工程在本库中的位置是输入控制层的第二个环节。[[Prompt工程]] 确定了指令、约束与输出格式的写法，本篇决定这些内容与外部知识如何共享有限的窗口；[[RAG原理与流程]] 提供检索结果，本篇决定取多少条、按什么顺序放；[[检索优化与重排Rerank]] 输出的相关性分数是装配时的排序依据；[[Agent记忆与上下文]] 把同一套预算模型扩展到多轮轨迹。对应学习目标中的"会评估"：能对给定的查询与检索结果算出预算表，并用对照实验判断重排或压缩是否真的提升了指标。

## 原理与推导

### 1 上下文窗口的预算模型

预算约束是硬约束。设组件集合为 $\{S_1,\dots,S_m\}$，每个组件的 token 数为 $n_i$，输出预留为 $n_{out}$，则可行装配必须满足

$$
\sum_{i=1}^{m}n_i+n_{out}\le B.
$$

把目标写成带乘子的形式 $\mathcal{L}=\mathbb{E}[R]-\mu\left(\sum_i n_i+n_{out}-B\right)$，对 $n_i$ 求偏导并令其为零，得到最优分配的必要条件：

$$
\frac{\partial\,\mathbb{E}[R]}{\partial n_i}=\mu,\qquad i=1,\dots,m.
$$

即每一类组件在最优点的边际收益相等。实践中 $\partial R/\partial n_i$ 不可解析，只能通过消融实验估计：固定其他组件，令 $n_i$ 取若干档，测量指标变化。可观察到的一般规律是边际收益递减，因此分配问题可以用贪心近似：按"单位 token 的边际收益"从高到低依次填充，直到预算用尽。

输出预留不能压缩到零。若 $n_{out}$ 小于实际输出长度，生成会在句子或 JSON 对象中间被截断，截断的输出既不可解析也不可重试，等于浪费了全部输入预算。合理的取值是输出长度分布的 p99，再乘一个安全系数；对结构化输出，还应加上最坏情况下字段数与嵌套深度的估计。

成本与延迟可以写成

$$
C=c_{in}n_{in}+c_{out}n_{out},\qquad T\approx T_{0}+\frac{2N n_{in}}{\eta F}+\frac{2N n_{out}}{F},
$$

其中 $N$ 为非嵌入参数量，$F$ 为峰值算力，$\eta$ 为 prefill 阶段的实际利用率，$T_0$ 为调度与网络开销。取 $N=7\times10^{9}$、$n_{in}=8000$、$F=3\times10^{14}$ FLOP/s、$\eta=0.4$，prefill 项为 $2\times7\times10^{9}\times8000/(0.4\times3\times10^{14})\approx0.93$ 秒。该式说明两件事：输入长度直接进入延迟的一阶项；解码阶段的成本由输出长度决定，因此"让模型少说话"和"让输入更短"是两种独立的优化。

一个 32k 窗口的预算表如下，用于说明各组件在真实系统中的相对量级。

| 组件 | 上限（token） | 典型用量 | 超限时的处理 |
|---|---|---|---|
| 系统提示与工具定义 | 3,000 | 1,800 | 精简工具描述，删除未使用工具 |
| few-shot 示例 | 3,000 | 2,400（8 条 × 300） | 减到 4 条或改用动态示例 |
| 检索文档 | 12,000 | 9,600（12 条 × 800） | 按分数截断，先删低分与重复 |
| 对话历史 | 4,000 | 2,200 | 摘要早期轮次，保留最近 4 轮原文 |
| 输出预留 | 4,000 | 2,000 | 按 p99 设定，结构化输出另加余量 |
| 合计 | 26,000 | 18,000 | 利用率约 55% |

利用率不需要接近 100%。剩余额度是应对长文档与长输出的缓冲，也是重试时追加错误信息的空间。把预算用满的系统在遇到超长输入时只能截断，而截断位置往往落在关键段落上。

### 2 示例选择策略

相似度检索是最直接的选择方式。给定查询 $q$ 与候选示例池 $\{(x_i,y_i)\}_{i=1}^{M}$，取

$$
\mathcal{S}=\operatorname{TopK}_{i}\ \mathrm{sim}\big(\mathbf{e}(q),\mathbf{e}(x_i)\big).
$$

该策略假设"输入相似则所需输出模式相似"，对格式复杂、术语密集的任务有效。两个失效条件必须检查：其一是近似重复，若某条示例与查询几乎相同，模型会直接抄写示例的答案而不是执行任务，评测指标虚高；其二是分布偏移，若示例池只覆盖简单查询，检索出的示例无法提供查询所需的推理模式。

多样性用于避免示例同质化。最大边际相关性（maximal marginal relevance，MMR）在每一步选择时同时考虑与查询的相关性和与已选集合的冗余：

$$
x_{t+1}=\arg\max_{x\in\mathcal{R}\setminus\mathcal{S}_{t}}\left[\lambda\,\mathrm{sim}(q,x)-(1-\lambda)\max_{x'\in\mathcal{S}_{t}}\mathrm{sim}(x,x')\right],
$$

其中 $\mathcal{R}$ 是候选池，$\mathcal{S}_t$ 是已选集合，$\lambda\in[0,1]$ 控制两者权衡。$\lambda=1$ 退化为纯相似度选择，$\lambda=0$ 只追求多样性而忽略相关性。工程上常用 $\lambda\in[0.6,0.8]$，并用聚类代替逐对冗余计算：先对候选池做 $k$-means，每个簇取一条最相似的示例，复杂度从 $O(kM)$ 次相似度计算降到一次聚类加 $k$ 次检索。

难度分层处理示例难度与查询难度的匹配问题。把示例按推理步数、答案长度或人工标注分为易、中、难三档，按查询的预估难度选择对应档位的示例，或按固定比例混合。混合的作用是覆盖不同深度的推理模式；匹配的作用是避免用简单示例回答复杂查询，模型会模仿示例的浅层推理而漏掉必要步骤。难度代理指标必须可自动计算，否则无法在推理时使用。

示例数量 $k$ 的选择由边际收益决定。$k$ 从 0 增到 4 时收益通常最显著，从 4 增到 8 时收益递减，超过 8 后新增示例主要带来长度成本与冲突概率。若示例之间存在矛盾（同一问题不同答案），模型的行为取决于示例顺序而不是示例的正确性，这是第 7 节讨论的污染问题。

### 3 示例顺序的影响

同一组示例按不同顺序排列，输出可能不同，这一现象称为近因偏差：靠近生成位置的内容对输出的影响更大。测量方法是固定示例集合，随机抽取 $M$ 种排列，对每种排列在评测集上计算准确率 $A_{\pi}$，报告均值与极差：

$$
\bar{A}=\frac{1}{M}\sum_{\pi}A_{\pi},\qquad \Delta A=\max_{\pi}A_{\pi}-\min_{\pi}A_{\pi}.
$$

$\Delta A$ 是提示稳定性的直接度量。若 $\Delta A$ 与两个不同提示之间的差距同量级，说明所谓"提示改进"可能只是排列带来的噪声，必须固定顺序或对多种排列取平均后再比较。

机制上有三个来源。第一是位置编码，绝对位置编码在训练分布之外的位置上外推误差增大，相对位置编码虽然缓解了这一点，但注意力分数仍随距离衰减。第二是因果注意力，生成位置只能看到之前的 token，排在其后的示例在最后一层的表示与生成位置的距离更近，参与最终预测的路径更短。第三是训练数据的分布，指令微调数据中"最后一条示例之后紧跟目标输出"的模式出现频率高，模型学到了这一模式。

工程结论是把最相关的示例放在最后，把稳定的格式说明放在开头，把输出格式要求在结尾重复一次。重复会消耗 token，因此只在格式违规率高的任务上使用；重复的内容必须逐字一致，措辞不同的两份指令会被模型当作两条不同约束，反而增加冲突。

### 4 长上下文中的信息位置效应

中间遗忘的典型实验设置是：给定 $N$ 篇文档，其中一篇包含答案，其余为干扰项，把含答案的文档放在第 $1$ 到第 $N$ 个位置，测量问答准确率。结果呈 U 形：开头与结尾位置准确率最高，中间位置最低，在文档数较多时中间位置甚至低于不提供任何文档的闭卷基线。两端都高于中间，但两端之间的相对高低依模型与数据而变，不能假定结尾必然优于开头。

第一个机制是注意力归一化的稀释。考虑单个注意力头、单个查询位置，键为金标文档与 $n$ 个干扰项，分数分别为 $s_g$ 与 $s_j$。金标文档获得的注意力权重为

$$
w_g=\frac{e^{s_g}}{e^{s_g}+\sum_{j=1}^{n}e^{s_j}}.
$$

若所有干扰项分数相同为 $s$，则 $w_g=1/\left(1+n\,e^{s-s_g}\right)$。取 $s_g=3$、$s=0$，$n=0,1,5,10,50,200$ 时 $w_g$ 依次为 $1.0000$、$0.9526$、$0.8007$、$0.6676$、$0.2866$、$0.0913$。只要金标文档与干扰项的分数差固定，权重就随干扰项数量单调下降，且下降在 $n$ 较大时才显著。真实模型有多层、多头与残差连接，稀释会被部分补偿，但方向不变：增加无关文档会降低关键文档的有效权重。

第二个机制是位置编码的外推。训练时见过的位置范围有限，超出范围的位置编码与相邻位置的区分度下降，模型难以精确区分"第 40 篇"与"第 41 篇"文档的边界。第三个机制是训练分布的先验，人类书写的材料通常把结论放在开头或结尾，模型学到的注意力模式与之匹配。

缓解手段按成本从低到高排列。

| 手段 | 做法 | 代价 |
|---|---|---|
| 重排 | 按相关性排序后，最高分的放开头与结尾，低分放中间 | 需要分数，无额外调用 |
| 减少干扰 | 提高检索阈值，只保留高分文档 | 可能漏掉召回，需与 [[检索优化与重排Rerank]] 联合调参 |
| 分段处理 | 每段独立问答后再汇总 | 调用次数线性增长，跨段推理丢失 |
| 显式编号与引用 | 每篇文档加编号，要求答案引用编号 | token 增加，需校验引用 |
| 问题复述 | 在文档之后重复问题与输出格式 | token 增加，需与指令一致 |
| 压缩 | 对文档做抽取或摘要 | 信息损失，见第 5 节 |

需要强调的是，这些手段都不改变模型的位置偏好，只改变关键信息落在哪个位置。因此"把最好的文档放在最后"是一个稳定的工程默认值，而"增加检索条数"必须与位置策略一起评估，否则可能得到负收益。

### 5 上下文压缩

压缩把长内容映射为短内容，压缩率 $\rho=n'/n<1$。三种基本方法的信息损失性质不同。

摘要由模型生成，压缩率高，但会丢失数值、否定词、限定条件与实体名，且可能引入原文没有的内容。摘要适合叙述性材料，不适合需要精确引用的规范条文与代码。

抽取从原文中选择句子或段落，保真度高，但会破坏指代与上下文衔接，选出的句子可能缺少主语或前提。抽取可以形式化为子集选择问题：

$$
\max_{S\subseteq\mathcal{D}}\ \sum_{d\in S}rel(q,d)-\lambda\sum_{d,d'\in S}\mathrm{sim}(d,d')
\quad\text{s.t.}\quad\sum_{d\in S}n_d\le b,
$$

这是一个带预算的二次目标，实践中用贪心近似：每步选择"相关性增量减去冗余惩罚"最大的段落。该式与第 2 节的 MMR 同构，区别只在于这里的候选是文档内的段落。

去重针对近似重复。检索结果常包含同一文档的多个分块、同一新闻的多源转载、同一段落的父子块。近似重复的代价是双重的：占用预算，且让同一信息在注意力中重复出现，挤压其他信息的权重。检测方法包括 Jaccard 相似度

$$
J(A,B)=\frac{\lvert A\cap B\rvert}{\lvert A\cup B\rvert},
$$

以词或 $n$-gram 为集合元素，阈值通常取 $0.7$ 到 $0.9$；以及 MinHash 估计，用 $h$ 个哈希函数把集合映射为签名，用签名一致比例估计 $J$，复杂度从 $O(\lvert A\rvert+\lvert B\rvert)$ 降到 $O(h)$。嵌入聚类可以发现字面不同但语义重复的内容，代价是一次嵌入计算。

压缩本身有成本。摘要需要一次模型调用，其成本与压缩率、批处理方式有关；压缩误差会向下游传播，且不可恢复，因为原文已不在上下文中。因此压缩只应在预算确实不足时使用，且必须对比"压缩后"与"减少条数"两种方案：多数情况下，删掉低分文档比摘要全部文档更可靠。

### 6 动态 few-shot 与固定 few-shot 的取舍

| 维度 | 固定 few-shot | 动态 few-shot |
|---|---|---|
| 可复现性 | 高，提示逐字固定 | 低，依赖检索结果与索引版本 |
| 与查询的匹配度 | 中，取决于人工覆盖 | 高，按相似度选择 |
| 延迟 | 无额外开销 | 增加一次检索，通常 10 到 100 毫秒 |
| 一致性 | 所有查询看到相同示例 | 不同查询看到不同示例，行为方差大 |
| 标签泄漏风险 | 低 | 高，近似重复会把答案直接送入上下文 |
| 维护成本 | 修改提示即可 | 需维护示例库、索引与选择策略 |
| 评测复杂度 | 一次评测 | 需固定检索快照才能复现 |

决策规则可以写成三条。第一，任务分布稳定且格式统一时用固定示例，减少变量。第二，查询异质、领域术语多时用动态示例，但必须固定索引快照用于评测，否则指标不可复现。第三，两者可以混合：固定示例承担格式与语气，动态示例补充领域模式，混合时把固定示例放在前面、动态示例放在后面，兼顾稳定性与匹配度。

### 7 上下文污染与冲突

上下文污染指上下文中出现错误、过期、互相矛盾或恶意内容。按来源分为四类。

第一类是事实冲突，多篇文档对同一事实给出不同取值。第二类是时效冲突，旧文档与新文档同时出现，模型可能采信旧值，因为旧文档措辞更完整或位置更靠前。第三类是指令冲突，检索文档中包含"忽略上述要求"之类的文本，属于间接提示注入，见 [[Prompt工程]] 第 7 节。第四类是错误传播，多轮对话中模型早前的错误答案被写入历史，后续轮次把它当作既定事实继续推理。

处理冲突的第一步是不要静默选择。提示中应显式要求模型在发现冲突时报告冲突及各自来源，而不是自行取舍；输出格式中预留 `conflicts` 字段。第二步是给出裁决规则：按来源可信度、按时间戳、按多数一致。第三步是工程侧的过滤：丢弃低相关文档、按发布时间过滤、对同一事实的多个来源做一致性检查。

few-shot 示例的错误标签属于同一类问题。示例中的错误答案会被模型当作模式复制，且由于示例靠近生成位置，其影响大于指令中的一句正确说明。因此示例库必须有标签校验流程，任何人工修改都要经过评测集回归。

## 关键直觉

> [!tip] 上下文是带价格的稀缺资源，且其可用性随位置与干扰项数量衰减：预算分配决定"放什么"，排列顺序决定"放在哪"，压缩与去重决定"同样预算能放多少有效信息"。
>
> 与严格定义的关系：定义中的约束 $\sum n_i+n_{out}\le B$ 对应价格，$w_g=1/(1+n e^{s-s_g})$ 对应可用性的衰减，$\max_{\pi}$ 对应顺序。三者共同解释一个现象——把更多文档放进上下文并不等价于给模型更多信息，边际收益可能为负。

## 例子与代码

### 例 1：按 token 预算装配上下文

下面的函数实现第 1 节的贪心分配：系统提示与收尾指令为固定开销，剩余额度按 50/30/20 分给资料、示例与历史；第一轮按份额装填，第二轮把未用额度按优先级补入；最终顺序为系统、历史、示例、资料、收尾，资料按分数升序排列，使最高分文档最靠近生成位置。

```python
def count_tokens(text):
    """占位计数器：按字符计数。生产中替换为 tiktoken 编码器。"""
    return len(text)

SEP = 2  # 段间分隔符 "\n\n" 的字符数

SYSTEM = ("[角色] 你是检索问答助手，只依据 [资料] 中的证据回答。"
          "[约束] 每个结论后附 [D编号]；资料不足时回答 无法从给定资料确定。")
CLOSING = "只输出 JSON 对象，字段为 answer、citations、confidence。"

DOCS = [
    {"id": "D1", "text": "BM25 依据词频与逆文档频率对候选文档打分，适合关键词精确匹配。", "score": 0.91},
    {"id": "D2", "text": "稠密检索把查询与文档编码为向量，用余弦相似度比较语义接近程度。", "score": 0.88},
    {"id": "D3", "text": "RRF 按名次而非分数融合多路检索结果，避免分数量纲不一致。", "score": 0.83},
    {"id": "D4", "text": "交叉编码器把查询与文档拼接后输入模型，精度高但不能预计算文档表示。", "score": 0.79},
    {"id": "D5", "text": "HNSW 用多层近邻图组织向量，查询复杂度随层数对数增长。", "score": 0.64},
    {"id": "D6", "text": "分块长度影响召回粒度，块过长会引入无关内容并占用上下文预算。", "score": 0.58},
]
EXAMPLES = [
    {"q": "BM25 适合什么场景", "a": "关键词精确匹配场景，例如型号与专有名词检索。", "sim": 0.81},
    {"q": "如何融合两路检索", "a": "可用 RRF 按名次融合，避免分数归一化。", "sim": 0.77},
    {"q": "交叉编码器为什么慢", "a": "因为每个查询-文档对都要做一次完整前向。", "sim": 0.62},
]
HISTORY = [
    {"role": "用户", "text": "我在做一个技术文档问答系统。"},
    {"role": "助手", "text": "需要先确定检索方式与分块粒度。"},
    {"role": "用户", "text": "现在召回率偏低，应该先查哪一环？"},
]

SHARES = {"docs": 0.50, "examples": 0.30, "history": 0.20}
ORDER = ["docs", "examples", "history"]


def assemble(system, docs, examples, history, budget=400, reserve_out=100):
    """按优先级装填上下文，返回 (上下文, 统计行, 输入预算, 剩余额度)。"""
    n_sys, n_close = count_tokens(system), count_tokens(CLOSING)
    b_in = budget - reserve_out
    avail = b_in - n_sys - n_close - SEP          # 固定开销之外可分配的额度
    if avail <= 0:
        raise ValueError("系统提示与输出预留已占满预算")
    caps = {k: int(avail * v) for k, v in SHARES.items()}

    docs = sorted(docs, key=lambda d: d["score"], reverse=True)
    examples = sorted(examples, key=lambda e: e["sim"], reverse=True)
    texts = {
        "docs": [d["text"] for d in docs],
        "examples": [f"问：{e['q']}\n答：{e['a']}" for e in examples],
        "history": [f"{h['role']}：{h['text']}" for h in reversed(history)],
    }

    taken = {k: [] for k in ORDER}
    used = {k: 0 for k in ORDER}                  # 计入每段 2 个分隔符
    cursor = {k: 0 for k in ORDER}

    def fill(k, cap):
        while cursor[k] < len(texts[k]):
            cost = count_tokens(texts[k][cursor[k]]) + SEP
            if used[k] + cost > cap:              # 放不下就停止，不做半条截断
                break
            taken[k].append(texts[k][cursor[k]])
            used[k] += cost
            cursor[k] += 1

    for k in ORDER:                                # 第一轮：按份额
        fill(k, caps[k])

    leftover = avail - sum(used.values())          # 第二轮：剩余额度按优先级补入
    for k in ORDER:
        if leftover <= 0:
            break
        before = used[k]
        fill(k, used[k] + leftover)
        leftover -= used[k] - before

    taken["history"] = list(reversed(taken["history"]))
    parts = [("系统", system)]
    parts += [("历史", t) for t in taken["history"]]
    parts += [("示例", t) for t in taken["examples"]]
    parts += [("资料", t) for t in reversed(taken["docs"])]   # 高分资料最后出现
    parts.append(("收尾", CLOSING))
    context = "\n\n".join(t for _, t in parts)
    assert count_tokens(context) <= b_in

    rows = [(k, caps[k], used[k], len(taken[k]),
             len(texts[k]) - len(taken[k])) for k in ORDER]
    return context, rows, b_in, b_in - count_tokens(context)


context, rows, b_in, spare = assemble(SYSTEM, DOCS, EXAMPLES, HISTORY)
print(f"窗口 400，输出预留 100，输入预算 {b_in}")
print(f"{'组件':<6}{'首轮上限':>8}{'占用':>6}{'条数':>6}{'丢弃':>6}")
for name, cap, use, cnt, drop in rows:
    print(f"{name:<6}{cap:>10}{use:>8}{cnt:>8}{drop:>8}")
print(f"上下文长度 {count_tokens(context)}，剩余 {spare}")
print("-" * 44)
print(context)
```

```text
窗口 400，输出预留 100，输入预算 300
组件        首轮上限    占用    条数    丢弃
docs          94     100       3       3
examples        56      40       1       2
history        37      41       2       1
上下文长度 293，剩余 7
--------------------------------------------
[角色] 你是检索问答助手，只依据 [资料] 中的证据回答。[约束] 每个结论后附 [D编号]；资料不足时回答 无法从给定资料确定。

助手：需要先确定检索方式与分块粒度。

用户：现在召回率偏低，应该先查哪一环？

问：BM25 适合什么场景
答：关键词精确匹配场景，例如型号与专有名词检索。

RRF 按名次而非分数融合多路检索结果，避免分数量纲不一致。

稠密检索把查询与文档编码为向量，用余弦相似度比较语义接近程度。

BM25 依据词频与逆文档频率对候选文档打分，适合关键词精确匹配。

只输出 JSON 对象，字段为 answer、citations、confidence。
```

输出中有三处值得核对。第一，资料占用 100 超过首轮上限 94，因为第二轮把示例与历史未用尽的额度补给了资料；占用列含每段 2 个分隔符，所以 3 条资料的总长度是 94 个字符加 6 个分隔符。第二，历史只保留最近两轮，最早的一轮被丢弃，因为历史从最近一条开始装填，这是"保留最近"策略的直接实现。第三，资料按 RRF、稠密检索、BM25 的顺序出现，即分数从低到高，最高分的 BM25 文档紧邻收尾指令，利用了第 3 节与第 4 节的位置效应。

去掉 `assert` 会使预算超限时静默通过，输出被服务端截断而调用方无从得知；去掉 `SEP` 的计入会使实际长度系统性超出预算若干个字符，在长文档拼接时累积成可观的偏差；把 `fill` 改为按字符截断最后一条，会得到半句话，既浪费 token 又可能切断引用编号。

### 例 2：位置稀释的数值

以下代码计算单头注意力中金标文档的权重随干扰项数量的变化，对应第 4 节的 $w_g=1/(1+n e^{s-s_g})$。

```python
import numpy as np

for n in (0, 1, 5, 10, 50, 200):
    s = np.array([3.0] + [0.0] * n)          # 金标得分 3.0，干扰项得分 0.0
    p = np.exp(s - s.max())
    p = p / p.sum()
    print(f"干扰项 {n:>3} 个时，金标文档注意力权重 {p[0]:.4f}")
```

```text
干扰项   0 个时，金标文档注意力权重 1.0000
干扰项   1 个时，金标文档注意力权重 0.9526
干扰项   5 个时，金标文档注意力权重 0.8007
干扰项  10 个时，金标文档注意力权重 0.6676
干扰项  50 个时，金标文档注意力权重 0.2866
干扰项 200 个时，金标文档注意力权重 0.0913
```

手算核对 $n=10$：$e^{3}/(e^{3}+10e^{0})=20.0855/30.0855=0.6676$。前 5 个干扰项使权重下降约 20 个百分点，后 190 个干扰项再下降约 71 个百分点，下降是非线性的：干扰项少时权重接近 1，边际影响小；干扰项多时权重已低，继续增加仍有显著影响。该模型只描述单层单头，真实模型的多层残差会缓解稀释，但"文档越多、单篇权重越低"的关系成立。

### 例 3：MMR 选择示例

```python
import numpy as np

rng = np.random.default_rng(0)
U = rng.normal(size=(7, 16)); U /= np.linalg.norm(U, axis=1, keepdims=True)
q = U[0]                                     # 第 0 行作为查询向量
cand = list(range(1, 7))

def mmr(q, cand, k=3, lam=0.7):
    chosen, rest = [], list(cand)
    while rest and len(chosen) < k:
        best, best_val = None, -1e9
        for i in rest:
            rel = float(q @ U[i])
            div = max((float(U[i] @ U[j]) for j in chosen), default=0.0)
            val = lam * rel - (1 - lam) * div
            if val > best_val:
                best, best_val = i, val
        chosen.append(best); rest.remove(best)
        print(f"  选中 {best}，MMR={best_val:.4f}")
    return chosen

print("MMR 选择顺序：", mmr(q, cand, k=3, lam=0.7))
```

```text
  选中 6，MMR=0.2532
  选中 1，MMR=0.1314
  选中 5，MMR=0.0725
MMR 选择顺序： [6, 1, 5]
```

第一轮所有候选的冗余项为 0，选择等价于纯相似度，索引 6 与查询的内积最大。第二轮索引 1 的相关性可能高于 6 之外的其他候选，但它与已选 6 的相似度低，冗余惩罚小，因此入选。若把 $\lambda$ 设为 1，选择退化为 TopK 相似度，示例之间的重复不再被抑制；若设为 0，选择完全由多样性驱动，可能选出与查询无关的示例。实际系统应在评测集上扫描 $\lambda$，而不是固定取值。

## 易错点

> [!warning] 以下六条均可在预算表或对照实验中直接检验。
> 1. 把窗口大小当作可用上下文大小：$n_{out}$、系统提示、工具定义、分隔符都要占用预算，且模型对中间位置的利用率低。按 $B$ 满额装配必然导致截断或指标下降。
> 2. 认为检索条数越多越好：每增加一条文档都会稀释关键文档的注意力权重，并可能引入冲突内容。条数必须与重排、阈值、位置策略联合调优。
> 3. 用字符数代替 token 数做预算：中文、代码、JSON 的字符与 token 比例差异大，纯 ASCII 代码约 3 到 4 字符每 token，中文接近 1 到 1.5 字符每 token。混用两种计数会使预算偏差超过一倍。
> 4. 在示例选择时用与查询同源的标注数据：示例与测试查询来自同一批标注，相似度检索会把近似重复的样本选入上下文，答案被直接抄写，离线指标虚高而线上无效。
> 5. 只测一种示例顺序：近因偏差使排列间的极差可能与提示改进的幅度同量级，单次排列的指标不可作为结论，应报告多种排列的均值与极差。
> 6. 对全部文档做摘要而不做筛选：摘要的成本与误差传播都高，且会丢失数值与否定；多数情况下删掉低分文档比压缩高分文档更可靠。

## 关联笔记

- 前置 [[Prompt工程]]：五元组结构、约束的可判定写法与失效原因分析是装配函数中各字段的来源，本篇第 1 节的预算是该篇上下文窗口约束的展开。
- 后续 [[RAG原理与流程]]：检索阶段产出候选文档与分数，本篇决定取多少条、如何排序与压缩，两篇共同决定生成阶段的实际输入。
- 后续 [[检索优化与重排Rerank]]：重排分数是资料排序与阈值过滤的依据，重排质量直接改变位置效应的作用对象。
- 对照 [[Embedding与向量检索]]：本篇的相似度选择与去重依赖嵌入空间的性质，归一化方式与各向异性程度会影响 MMR 与阈值的行为。
- 后续 [[Agent记忆与上下文]]：多轮轨迹中的历史压缩、记忆检索与预算分配沿用本篇的模型，只是把"对话历史"扩展为"长期记忆加工作记忆"。

## 达标检测

- [ ] 写出预算约束与拉格朗日条件，说明为什么最优点满足各类组件的边际收益相等，并解释实践中为何只能用消融实验估计边际收益。
- [ ] 给定 $B=8192$、$n_{out}=1024$、系统提示 600 token、示例 4 条各 250 token、检索 8 条各 500 token、历史 2000 token，计算总占用与剩余额度，并给出两种不同的削减方案及其代价。
- [ ] 用 $w_g=1/(1+n e^{s-s_g})$ 计算 $s_g=2$、$s=0$、$n=20$ 时的权重，并与 $n=5$ 比较，说明为什么增加检索条数的边际收益会变为负。
- [ ] 修改例 1 的 `assemble`，使其在资料超预算时按字符截断最后一条并追加省略标记，说明该改动为何可能降低引用准确率。
- [ ] 设计一个实验测量近因偏差：给出排列数量、指标、统计量与判定阈值，并说明如何区分排列噪声与真实的提示改进。
- [ ] 给定一组包含近似重复段落的检索结果，写出基于 Jaccard 阈值的去重流程，并说明阈值取 0.7 与 0.9 时分别会误删或漏删哪类内容。

## 参考来源

- Liu et al., "Lost in the Middle: How Language Models Use Long Contexts", arXiv:2307.03172, 2023 —— 对应第 4 节的位置实验设计、U 形曲线与"中间位置低于闭卷基线"的结论。
- Anthropic, "Context Engineering" 官方文档 —— 对应第 1 节的预算模型、第 5 节的压缩策略与第 7 节的上下文污染处理。
- Gao et al., "Retrieval-Augmented Generation for Large Language Models: A Survey", arXiv:2312.10997 —— 对应第 2 节的检索结果组织与第 6 节的上下文组织分类。
- Asai et al., "Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection", arXiv:2310.11511 —— 对应第 4 节的相关性判断与第 5 节"按需压缩"的思路。
- 张奇等《大规模语言模型：从理论到实践》第 5 章 —— 对应第 3 节的 few-shot 示例组织与第 2 节的示例数量经验区间。
