RAG与搜索融合：上下文压缩与重排序

可视化演示

演示检索上下文压缩裁剪、交叉编码器重排序及压缩-重排序融合的RAG全流程优化策略。

问题背景：行李箱装不下全部攻略

假设你是全家旅行的“首席规划师”。出发前一天，你从书架上翻出十几本攻略书，每本都密密麻麻地记着路线、美食与景点。问题是行李箱容量固定，而你还得把换洗衣服、相机和证件都塞进去——这些“随身物品”就像模型预留的指令和输出空间。纠结之下，你只能掂量着取舍：不是每一本攻略都值得带，也不是每一页都有用。

在 RAG 系统中，同样的问题每天发生：检索器返回的是大量候选文档，而大语言模型的上下文窗口无法容纳全文。更糟的是，和某一句关键词沾边的噪声内容也会被捞回来，这些噪声不仅挤占空间，还会把最终生成的内容带偏。如果不加处理，模型可能被迫在超长输入上运行，甚至直接截断丢失关键事实。

我们把每个检索文档看作信息包，设第 i 篇文档长度为 |d_i|。当 k 篇文档被拼接进上下文时，总长度必须满足上限约束：

$$\displaystyle L_{\text{ctx}} = \sum_{i=1}^{k} |d_i| \leq L_{\text{limit}}$$

1. 候选文档长度：每个检索返回的文档 d_i 都是一个待装载的信息包裹，其长度用 |d_i| 表示，单位通常是 token 数。

$$\displaystyle |d_i| = \text{len}(d_i)$$

2. 上下文总长求和：把 k 个候选文档的长度累加起来，得到上下文总长度 L_ctx。

$$\displaystyle L_{\text{ctx}} = \sum_{i=1}^{k} |d_i|$$

3. 长度上限约束：总长度必须小于等于模型支持的上下文窗口上限 L_limit，这是所有压缩与重排操作的出发点。

$$\displaystyle L_{\text{ctx}} \leq L_{\text{limit}}$$

回到行李箱的比喻，这一步相当于“先量尺寸再装箱”。知道了箱子容量，你才能判断何时需要压缩、何时只需重排。下一节将从最朴素的“撕书页”方案开始，看窗口裁剪到底有多大的吸引力与风险。

窗口裁剪：撕几页书来应急

最省事的办法是“撕书页”：从攻略书中间撕下若干页塞进包里。放在 RAG 里，这就是上下文窗口裁剪——在文档序列上取一个连续片段，其余部分毫不留情地丢弃。它非常快速，几乎不需要额外计算，尤其适合那种“答案恰好出现在文档开头”的简单问答。

但问题同样明显：如果答案落在被扔掉的部分，模型就“两眼一抹黑”，只能靠猜来生成，事实错误也由此而来。窗口裁剪本质上是一把没有语义感知的剪刀，它不知道哪一页是地图，哪一页是广告。

形式化地看，对第 i 篇文档 D，我们选取从位置 a 到位置 b 的连续片段，其余位置的内容统统丢弃。这个操作几乎不消耗额外计算，却会把关键信息暴露在风险之下——如果答案片段恰好在区间之外，模型将无从回答：

$$\displaystyle D_{\text{trim}} = D[a : b] \quad \text{其中} \quad b - a \le K$$

1. 起点与终点：a 是片段的起始下标，b 是结束下标，两个下标共同圈定一段连续的文本区间。

$$\displaystyle D[a : b]$$

2. 片段长度限制：裁剪后的片段长度 b - a 必须小于等于 K 个 token，避免单个片段就占据过大的上下文空间。

$$\displaystyle b - a \le K$$

3. 多文档拼接：所有被裁剪后的片段拼接起来作为模型输入，总长度仍需满足上一节中的全局上限约束。

$$\displaystyle C_{\text{in}} = D_1[a_1:b_1] \oplus D_2[a_2:b_2] \oplus \cdots \oplus D_k[a_k:b_k]$$

撕书页虽然快，但你可能撕下的是“停车场指南”而不是“山顶路线”。窗口裁剪给我们的教训是：简单暴力的方案会把关键信息置于险境，于是我们接着要看更聪明的做法——先读一遍，再做笔记。

关键段落提取：读书记笔记

一个经验丰富的旅行者不会撕书，而是带一支荧光笔，把每个景点的开放时间、门票价格、交通方式记在小本子上。RAG 中的关键段落提取正是这种“荧光笔思维”：先把文档切成若干段落，再选出与用户问题最相关的段落保留下来。

怎么判断相关？现代做法是使用嵌入模型（embedding model）把查询和每个段落都变成向量，再计算余弦相似度。与查询方向一致的段落，就好比被荧光笔重点标记的句子，会被优先选中。

设查询 q 的嵌入向量为 e_q，段落 p 的嵌入向量为 e_p，相似度公式为点积除以两向量模长的乘积：

$$\displaystyle \text{sim}(e_q, e_p) = \frac{e_q \cdot e_p}{\lVert e_q \rVert \cdot \lVert e_p \rVert}$$

1. 查询向量化：用嵌入模型将用户查询编码成一个向量，表示问题的语义中心。

$$\displaystyle e_q = \text{embed}(q)$$

2. 段落向量化：把候选文档切分成段落后逐一编码，得到每个段落的向量 e_p。

$$\displaystyle e_p = \text{embed}(p)$$

3. 余弦相似度：对两个向量做点积并分别除以模长，得到语义相似度分数，这也决定段落是否被保留。

$$\displaystyle \text{sim}(e_q, e_p) = \frac{e_q \cdot e_p}{\lVert e_q \rVert \cdot \lVert e_p \rVert}$$

笔记比整本书小得多，却保留了真正的精华。段落提取的本质就是让语义来决定哪一段上桌，而不是让页码来决定。但这里还有一个问题：如果候选段落很多，我们仍然需要先确定“哪些文档更值得优先分段”，这正是重排序的用武之地。

重排序策略：出发前按价值排队

现在你面前摆着十几本攻略书，而你只打算带最值得的几本。怎么判断哪本最值得？你快速翻阅目录、看评价、对照目的地——这个“快速把关”的动作，在 RAG 中就叫重排序。

检索器通常用双编码器模型把查询和文档分别编码，效率高但交互不足，适合做第一轮粗召回。重排序模型则会让查询和文档进行深层交互，例如交叉编码器直接把两者拼在一起输入打分器，输出更精准的相关性分数。近年来，LLM 本身也能充当重排序器，让模型对每个候选文档直接给出相关度评分。

设重排序模型为 f_rerank，它对查询 q 与第 i 篇文档 d_i 打出一个相关度分数 s_i：

$$\displaystyle s_i = f_{\text{rerank}}(q, d_i), \qquad D^* = \{d_{i_1}, d_{i_2}, \dots, d_{i_K}\}$$

1. 成对打分：重排模型接收“查询 + 文档”的配对输入，输出一个相关性分数 s_i，分数越高表示越匹配。

$$\displaystyle s_i = f_{\text{rerank}}(q, d_i)$$

2. 降序排序：对所有候选文档按 s_i 从高到低重新排列，形成新的优先级序列。

$$\displaystyle \text{sorted} = \arg\mathop{\text{sort}}_{i} \; s_i$$

3. Top-K 截取：只保留排名最靠前的 K 篇文档，交给后续压缩器处理，避免无关文档进入上下文。

$$\displaystyle D^* = \{d_{i_1}, d_{i_2}, \dots, d_{i_K}\}$$

就像把最靠谱的攻略放在背包最上层，重排序把真正有用的文档顶到前排。但注意，重排序只改变顺序和筛选范围，并不能让文档变短。真正让文档“瘦身”的，还是前面提到的段落提取与压缩步骤。

质量评估：旅行复盘的尺子

旅行结束后，你会对着地图复盘：计划中的十个景点，你去了几个？有没有因为信息记错而绕远路？RAG 同样需要“复盘”，也就是质量评估——它要回答两个问题：生成的内容质量高不高？压缩后的事实信息有没有丢失？

生成质量通常通过文本连贯性、相关性、人工评分等指标来衡量；事实准确性则更严格：把答案拆成一个一个原子事实，再判断每个事实是否被压缩后的上下文证据所支持。如果压缩把关键日期、金额或限定词删掉了，答案看起来通顺，但事实根基已经没了。

一个常见的事实准确率指标 FactScore 可以表示为：先拆解出 N 个原子事实，再对每个事实做证据支持判断，最后取平均：

$$\displaystyle \text{FactScore} = \frac{1}{N}\sum_{i=1}^{N} \mathbb{I}[f_i \text{ 被上下文支持}]$$

1. 事实拆解：把模型生成的回答拆成 N 个原子事实，每个事实都是一个可独立验证的短句。

$$\displaystyle \text{answer} \to \{f_1, f_2, \dots, f_N\}$$

2. 支持判断：逐一判断每个事实 f_i 是否能在压缩后的上下文中找到证据，输出布尔指示值。

$$\displaystyle \mathbb{I}[f_i \text{ 被上下文支持}]$$

3. 准确率平均：把所有事实的支持指示值求平均，得到 0 到 1 之间的整体事实准确率。

$$\displaystyle \frac{1}{N}\sum_{i=1}^{N} \mathbb{I}[f_i \text{ 被上下文支持}]$$

旅行复盘能让你下次打包更聪明；同样，评估结果会反过来指导我们调整压缩比，在信息保留和成本之间寻找更好的平衡点。

最优平衡：背包的黄金分割

压缩能省钱，但压缩太狠会丢信息。那么到底该压缩到什么程度？这就像打包：包太小什么都装不下，包太满翻东西费劲还容易超重。真正的最优方案，是在信息价值与上下文预算之间做一次权衡。

我们定义压缩比 R=1-|C|/|O|，它表示从原始上下文 O 中删减了多少比例的内容。R 越高，保留的子集 C 越小，token 成本越低，但信息量与事实覆盖率也可能随之下降。为了自动找到平衡点，可以引入一个可调参数 λ 来控制对长上下文的惩罚强度。

一个经典的平衡优化形式是：从原始集合 O 中选出一个子集 C，用 Info(C) 衡量信息收益，再用 λ·|C|/B 惩罚长度超支，目标是最大化两者之差：

$$\displaystyle C^* = \arg\max_{C \subseteq O} \left( \mathrm{Info}(C) - \lambda \cdot \frac{|C|}{B} \right)$$

1. 候选子集：C 是从原始文档集合 O 中选出的一个子集，它将被最终放进上下文窗口。

$$\displaystyle C \subseteq O$$

2. 信息收益：Info(C) 对子集 C 中各片段的信息权重求和，代表这部分内容对回答问题的贡献总量。

$$\displaystyle \mathrm{Info}(C) = \sum_{p \in C} w_p$$

3. 长度惩罚与平衡：λ 是惩罚系数，B 是 token 预算；上下文越长，惩罚越大，从而鼓励系统选择小而关键的子集。

$$\displaystyle \lambda \cdot \frac{|C|}{B}$$

行李箱的容量永远有限，但我们可以通过重排、压缩、评估和调参，让有限的背包发挥最大的效用。这也是“LLM 时代搜索”中，RAG 与搜索技术融合最核心的艺术：不是背更多书，而是选对书、做对笔记。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-# 演示 RAG 上下文压缩与重排序的简化过程import re  def tokenize(text):    """将文本切分为词项集合（模拟向量化）。"""    return set(re.findall(r'[\w\u4e00-\u9fff]+', text.lower()))  def keyword_overlap(q_terms, doc_terms):    """用词项重叠度作为相关度分数（模拟重排序模型打分）。"""    if not doc_terms:        return 0.0    return len(q_terms & doc_terms) / len(q_terms)  def rerank(query, docs):    """按查询相关度对文档做重排序，返回 (文档, 分数) 列表。"""    q_terms = tokenize(query)    scored = [(doc, keyword_overlap(q_terms, tokenize(doc))) for doc in docs]    scored.sort(key=lambda x: -x[1])    return scored  def compress(query, docs, top_k=3):    """压缩：只保留与 query 最相关的 top_k 篇文档。"""    ranked = rerank(query, docs)    return [doc for doc, _ in ranked[:top_k]]  def main():    query = "什么是上下文压缩？"    docs = [        "RAG 系统检索到的文档数量往往很多，上下文过长。",        "上下文压缩能减少冗余信息，提升生成质量。",        "重排序模型可以按相关性重新排列候选文档的顺序。",        "上下文窗口大小限制了输入内容的长度，必须裁剪。",        "关键段落提取关注与查询最相关的内容片段。",        "压缩比过高会导致重要信息丢失，影响事实准确性。",        "embedding 相似度可以衡量查询与段落的语义相关性。",    ]    print("原始文档数:", len(docs))    ranked = rerank(query, docs)    print("重排序后 Top-3:")    for doc, score in ranked[:3]:        print(f"  [{score:.2f}] {doc}")    selected = compress(query, docs, top_k=3)    compressed_len = sum(len(tokenize(d)) for d in selected)    original_len = sum(len(tokenize(d)) for d in docs)    ratio = 1 - compressed_len / original_len    print(f"压缩比: {ratio:.2%}")    print("压缩后上下文:")    for doc in selected:        print(" -", doc)  if __name__ == "__main__":    main()

1. return set(re.findall(r'[\w\u4e00-\u9fff]+', text.lower()))同时提取中文和英文词项，生成无重复词集合，作为文档的轻量“向量”
2. return len(q_terms & doc_terms) / len(q_terms)用重叠词比例模拟重排序模型的相关度打分
3. scored.sort(key=lambda x: -x[1])按分数降序排列，让高相关文档排到最前
4. ranked = rerank(query, docs)执行重排序，得到按相关度排列的文档列表
5. selected = compress(query, docs, top_k=3)压缩器只保留最相关的 3 篇文档
6. ratio = 1 - compressed_len / original_len计算压缩比，即删减了多少比例的原始信息

常见误区

面试题