高级检索技术
课程简介
句子窗口检索、自动合并检索、HyDE 等技术实现更精准的检索。
🎬 本课程视频：Advanced RAG — 构建与评估高级 RAG 应用
高级检索技术：超越朴素 RAG
一、朴素 RAG 的三大问题
朴素 RAG（Naive RAG）是最基础的 RAG 实现：将文档切片 → 向量化 → 检索 → 生成。虽然简单，但面临三个核心问题：
1.1 切片切断语义
文档切片是朴素 RAG 的第一步，也是最关键的一步。常见的做法是按照固定 Token 数（如 256 或 512）切割文档。但这种方式的问题显而易见：
原文：「2024 年第一季度，公司营收达到 120 亿美元，同比增长 15%。这一增长主要得益于...
切片 1：「2024 年第一季度，公司营收达到 120 亿美元，同比增长 15%。这一增长主
切片 2：「要得益于亚洲市场的强劲表现以及新产品的成功发布。」
切片 1 的结尾「这一增长主」是一个不完整的语义单元，切断了一个完整的因果句。如果检索只命中了切片 1，模型只能看到「增长了 15%」而看不到「增长的原因」。
1.2 检索粒度过粗或过细
- 切片过大：包含太多无关信息，降低检索精度
- 切片过小：丢失上下文，让模型无法理解完整语义
- 切片边界任意：语义完整的段落被切到不同的切片中
1.3 查询-文档语义鸿沟
用户查询和文档的表述方式往往不同：
- 用户查：「什么样的贷款适合我这样的自由职业者？」
- 文档写：「灵活就业人员贷款产品的申请条件和额度说明」
- 「自由职业者」和「灵活就业人员」语义相似但用词不同
向量嵌入可能无法完美捕捉这种语义相似度，导致检索不到相关文档。
二、句子窗口检索（Sentence Window Retrieval）
2.1 核心思想
句子窗口检索不以固定的 Token 数切割文档，而是以自然句子为最小索引单元。检索时不仅返回目标句子，还返回其前后 N 句作为上下文窗口。
2.2 实现方式
class SentenceWindowRetriever:
def __init__(self, documents, window_size=3):
self.window_size = window_size
# 1. 文档分句
self.sentences = self._split_to_sentences(documents)
# 2. 为每个句子创建嵌入
self.embeddings = self._create_embeddings(self.sentences)
def _split_to_sentences(self, documents):
'''使用 NLP 分句工具将文档拆分为句子'''
sentences = []
for doc in documents:
# 使用 spacy 或 nltk 进行分句
doc_sentences = nlp_sentencize(doc)
sentences.extend(doc_sentences)
return sentences
def retrieve(self, query, top_k=5):
# 1. 对查询进行嵌入
query_emb = embed(query)
# 2. 向量检索找到最匹配的句子（及其索引）
best_sentences = self._vector_search(query_emb, self.sentences, top_k)
# 3. 为每个匹配句子扩展上下文窗口
results = []
for sent_idx, score in best_sentences:
start = max(0, sent_idx - self.window_size)
end = min(len(self.sentences), sent_idx + self.window_size + 1)
context = {
"target_sentence": self.sentences[sent_idx],
"context_window": self.sentences[start:end],
"window_range": (start, end),
"relevance_score": score
}
results.append(context)
return results
2.3 窗口大小的选择
- 窗口 = 1：只返回目标句子，缺乏上下文
- 窗口 = 3：常见配置，返回目标句 ± 3 句，共 7 句
- 窗口 = 5：适用于需要大量上下文的复杂问题
- 可变窗口：根据句子长度和语义连贯性动态调整
三、自动合并检索（Auto-Merging Retrieval）
3.1 核心思想
自动合并检索构建文档的层级结构（如章节→段落→句子），先在小粒度匹配，然后将命中的小单元自动合并到其父级单元。
3.2 层级结构构建
class HierarchicalDocumentIndex:
'''文档的层级索引结构'''
def __init__(self, document):
# 文档的层级结构
self.tree = {
"document": document, # 根节点：整个文档
"sections": [], # 子节点：章节
}
self._build_tree(document)
def _build_tree(self, document):
'''将文档解析为层级结构'''
# 1. 按标题分割为章节
sections = split_by_headings(document)
for section in sections:
section_node = {
"heading": section.heading,
"content": section.content,
"paragraphs": [] # 章节下的段落
}
# 2. 章节按段落分割
paragraphs = split_by_paragraphs(section.content)
for para in paragraphs:
para_node = {
"content": para,
"sentences": [] # 段落下的句子
}
# 3. 段落按句子分割
sentences = split_by_sentences(para)
para_node["sentences"] = sentences
section_node["paragraphs"].append(para_node)
self.tree["sections"].append(section_node)
3.3 检索与合并
检索时，先在最细粒度的层级（句子）进行匹配，然后将命中的句子合并到其段落层级，将命中的段落合并到其章节层级。
def auto_merge_retrieve(self, query):
# 1. 在句子层级检索
matched_sentences = self._search_sentences(query)
# 2. 统计每个父段落中命中的句子数量
parent_para_count = {}
for sent in matched_sentences:
para_id = sent.parent_id
parent_para_count[para_id] = parent_para_count.get(para_id, 0) + 1
# 3. 如果段落中有足够多的命中句子，将该段落作为整体返回
merged_results = []
for para_id, hit_count in parent_para_count.items():
para = self.get_paragraph(para_id)
total_sentences = len(para.sentences)
if hit_count / total_sentences > 0.3: # 命中率超过 30%
# 返回整个段落
merged_results.append(para.full_content)
else:
# 只返回命中的句子
merged_results.extend([s.content for s in matched_sentences if s.parent_id == para_id])
return merged_results
四、HyDE（假设文档嵌入）
4.1 核心思想
HyDE（Hypothetical Document Embeddings）的核心思想是：让 LLM 先根据查询生成一个假设的理想文档，再用这个假设文档的向量去检索真实文档库。
4.2 为什么 HyDE 有效？
通常在 RAG 中，我们直接用用户查询的向量去检索文档。但查询和文档的表达方式往往不同：
- 查询：「今年的销售情况怎么样？」
- 文档：「2024 年度销售数据分析报告——Q1 同比增长 15%，Q2 环比下降 3%...」
查询向量和文档向量之间存在语义鸿沟。HyDE 的思路是：让 LLM 先生成一个「如果有一篇完美回答这个问题的文档，它会长什么样」，再用这个假设文档去检索。
def hyde_retrieve(query, doc_index, llm):
# 1. 让 LLM 生成假设文档
hyde_prompt = f'''
请针对以下问题，写一段假设的理想文档内容。
这段内容应该是对该问题的理想回答。
请写得详细、具体。
问题：{query}
假设文档：
'''
hypothetical_doc = llm.generate(hyde_prompt)
# 2. 用假设文档的嵌入向量进行检索
hyde_embedding = embed(hypothetical_doc)
results = doc_index.search(hyde_embedding, top_k=10)
return results
4.3 HyDE 的变体
- 简单 HyDE：只生成一个假设文档
- 多视角 HyDE：生成多个不同角度的假设文档，分别检索后合并结果
- 迭代 HyDE：根据检索结果不断优化假设文档
五、多路召回融合（Ensemble Retrieval）
5.1 核心思想
不同的检索方法各有优劣。向量检索擅长语义匹配但可能遗漏精确关键词，BM25 擅长精确匹配但无法理解语义。多路召回融合同时使用多种检索方法，将结果合并排序。
5.2 融合策略
def ensemble_retrieve(query, retrievers, weights):
'''
多路召回融合
Args:
query: 用户查询
retrievers: 字典，{名称: 检索器实例}
weights: 字典，{名称: 权重}
'''
all_results = {}
for name, retriever in retrievers.items():
# 每种检索方法独立执行
results = retriever.retrieve(query, top_k=20)
for doc_id, score in results:
if doc_id not in all_results:
all_results[doc_id] = {
"scores": {},
"doc": doc_id
}
all_results[doc_id]["scores"][name] = score
# 融合评分
for doc_id, data in all_results.items():
weighted_score = 0
for name, score in data["scores"].items():
weighted_score += score * weights.get(name, 1.0)
data["final_score"] = weighted_score
# 按加权评分排序
ranked = sorted(all_results.values(), key=lambda x: x["final_score"], reverse=True)
return ranked[:10]
5.3 常用检索器组合
- 向量检索 + BM25：最经典组合，语义 + 关键词互补
- 向量检索 + 图检索：语义 + 结构化关系互补
- 向量检索 + BM25 + 图检索：三路互补，效果最强但成本最高
六、总结
高级检索技术系统性地解决了朴素 RAG 的三大核心问题。句子窗口检索解决了切片切断语义的问题。自动合并检索在粒度灵活性和语义完整性之间取得平衡。HyDE巧妙桥接了查询-文档的语义鸿沟。多路召回融合通过互补检索方法提升了整体召回质量。综合运用这些技术可以显著提升 RAG 系统在各类场景下的表现。
六、HyDE（假设文档嵌入）
6.1 HyDE 的核心思想
HyDE（Hypothetical Document Embeddings）是一种非常巧妙的检索增强技术。它的思路是：先用 LLM 根据用户的问题生成一段“假设的理想文档”，然后用这段文档的嵌入去检索相似的真实文档。
6.2 为什么 HyDE 有效？
传统的查询-文档匹配中，查询和文档的表述差异可能很大。例如问题“巴黎的著名景点有哪些”和文档“埃菲尔铁塔是巴黎的标志性建筑”在语义上是相关的，但表述方式不同。HyDE 让 LLM 先生成一段“假设文档”，把问题转换成文档风格，再用文档的嵌入进行检索，匹配效果显著提升。
6.3 HyDE 的实现
def hyde_search(query, llm, vector_db):
# 1. 生成假设文档
hyde_prompt = f"""
根据以下问题，写一段假设的理想文档内容：
问题：{query}
要求：使用陈述语气，像百科全书条目一样写作。
"""
hypothetical_doc = llm.generate(hyde_prompt)
# 2. 用假设文档嵌入进行检索
results = vector_db.similarity_search(hypothetical_doc)
return results
七、多路召回（Ensemble Retrieval）
7.1 什么是多路召回
多路召回是指同时使用多种检索策略，然后将结果融合排序。每种策略都有自己的优势和劣势，多路召回让它们互补。
7.2 常见召回策略组合
- 向量检索：语义匹配
- 关键词匹配：BM25 等传统方法
- 图查询：结构化匹配
- HyDE：假设文档嵌入
- 重排序：用交叉编码器重新排序
7.3 融合策略
def ensemble_retrieve(query, retrievers, weights):
all_results = []
for retriever, weight in zip(retrievers, weights):
results = retriever.retrieve(query)
for r in results:
r.score *= weight # 加权
all_results.extend(results)
# 按加权后的分数排序
return sorted(all_results, key=lambda x: x.score, reverse=True)[:top_k]
八、总结
高级检索技术从多个维度突破了传统 RAG 的检索瓶颈。
关键要点回顾：
- 句子窗口检索在小窗口精度和大窗口上下文之间取得平衡
- 自动合并检索通过层级结构实现多粒度检索
- HyDE 通过假设文档弥合查询-文档语义差异
- 多路召回融合多种策略优势
- 重排序是检索管道中不可或缺的最后一步
六、HyDE（假设文档嵌入）
6.1 HyDE 的核心思想
HyDE（Hypothetical Document Embeddings）是一种非常巧妙的检索增强技术。它的思路是：先用 LLM 根据用户的问题生成一段“假设的理想文档”，然后用这段文档的嵌入去检索相似的真实文档。
6.2 为什么 HyDE 有效？
传统的查询-文档匹配中，查询和文档的表述差异可能很大。例如问题“巴黎的著名景点有哪些”和文档“埃菲尔铁塔是巴黎的标志性建筑”在语义上是相关的，但表述方式不同。HyDE 让 LLM 先生成一段“假设文档”，把问题转换成文档风格，再用文档的嵌入进行检索，匹配效果显著提升。
6.3 HyDE 的实现
def hyde_search(query, llm, vector_db):
# 1. 生成假设文档
hyde_prompt = f"""
根据以下问题，写一段假设的理想文档内容：
问题：{query}
要求：使用陈述语气，像百科全书条目一样写作。
"""
hypothetical_doc = llm.generate(hyde_prompt)
# 2. 用假设文档嵌入进行检索
results = vector_db.similarity_search(hypothetical_doc)
return results
七、多路召回（Ensemble Retrieval）
7.1 什么是多路召回
多路召回是指同时使用多种检索策略，然后将结果融合排序。每种策略都有自己的优势和劣势，多路召回让它们互补。
7.2 常见召回策略组合
- 向量检索：语义匹配
- 关键词匹配：BM25 等传统方法
- 图查询：结构化匹配
- HyDE：假设文档嵌入
- 重排序：用交叉编码器重新排序
7.3 融合策略
def ensemble_retrieve(query, retrievers, weights):
all_results = []
for retriever, weight in zip(retrievers, weights):
results = retriever.retrieve(query)
for r in results:
r.score *= weight # 加权
all_results.extend(results)
# 按加权后的分数排序
return sorted(all_results, key=lambda x: x.score, reverse=True)[:top_k]
八、总结
高级检索技术从多个维度突破了传统 RAG 的检索瓶颈。
关键要点回顾：
- 句子窗口检索在小窗口精度和大窗口上下文之间取得平衡
- 自动合并检索通过层级结构实现多粒度检索
- HyDE 通过假设文档弥合查询-文档语义差异
- 多路召回融合多种策略优势
- 重排序是检索管道中不可或缺的最后一步
六、HyDE（假设文档嵌入）
6.1 HyDE 的核心思想
HyDE（Hypothetical Document Embeddings）是一种非常巧妙的检索增强技术。它的思路是：先用 LLM 根据用户的问题生成一段“假设的理想文档”，然后用这段文档的嵌入去检索相似的真实文档。
6.2 为什么 HyDE 有效？
传统的查询-文档匹配中，查询和文档的表述差异可能很大。例如问题“巴黎的著名景点有哪些”和文档“埃菲尔铁塔是巴黎的标志性建筑”在语义上是相关的，但表述方式不同。HyDE 让 LLM 先生成一段“假设文档”，把问题转换成文档风格，再用文档的嵌入进行检索，匹配效果显著提升。
6.3 HyDE 的实现
def hyde_search(query, llm, vector_db):
# 1. 生成假设文档
hyde_prompt = f"""
根据以下问题，写一段假设的理想文档内容：
问题：{query}
要求：使用陈述语气，像百科全书条目一样写作。
"""
hypothetical_doc = llm.generate(hyde_prompt)
# 2. 用假设文档嵌入进行检索
results = vector_db.similarity_search(hypothetical_doc)
return results
七、多路召回（Ensemble Retrieval）
7.1 什么是多路召回
多路召回是指同时使用多种检索策略，然后将结果融合排序。每种策略都有自己的优势和劣势，多路召回让它们互补。
7.2 常见召回策略组合
- 向量检索：语义匹配
- 关键词匹配：BM25 等传统方法
- 图查询：结构化匹配
- HyDE：假设文档嵌入
- 重排序：用交叉编码器重新排序
7.3 融合策略
def ensemble_retrieve(query, retrievers, weights):
all_results = []
for retriever, weight in zip(retrievers, weights):
results = retriever.retrieve(query)
for r in results:
r.score *= weight # 加权
all_results.extend(results)
# 按加权后的分数排序
return sorted(all_results, key=lambda x: x.score, reverse=True)[:top_k]
八、总结
高级检索技术从多个维度突破了传统 RAG 的检索瓶颈。
关键要点回顾：
- 句子窗口检索在小窗口精度和大窗口上下文之间取得平衡
- 自动合并检索通过层级结构实现多粒度检索
- HyDE 通过假设文档弥合查询-文档语义差异
- 多路召回融合多种策略优势
- 重排序是检索管道中不可或缺的最后一步
延伸阅读
- 📺 B 站播放列表：Advanced RAG — 构建与评估高级 RAG 应用
- 📚 更多学习资源，请访问 deeplearning.ai 官网