RAG 学习 Day 7:从向量检索到 Rerank,如何让 RAG 找到真正有用的知识

29 阅读11分钟

RAG 学习 Day 7:从向量检索到 Rerank,如何让 RAG 找到真正有用的知识

在前几天的学习中,我们已经了解了 RAG(Retrieval-Augmented Generation)的基本工作流程:

用户问题
   ↓
Embedding
   ↓
向量数据库
   ↓
相似度搜索
   ↓
TopK
   ↓
Context
   ↓
LLM
   ↓
最终回答

但是,一个真正的问题开始出现:

如果向量数据库没有找到正确的知识怎么办?

或者:

如果找到了一堆相关知识,但真正能够回答问题的知识没有排在前面怎么办?

这就是 Day 7 要解决的问题。

今天主要学习:

  • Chunk
  • Chunk Overlap
  • Embedding
  • Similarity Search
  • TopK
  • Recall
  • Precision
  • Rerank
  • Hybrid Search

一、为什么 RAG 需要 Chunk?

假设现在有一份员工手册:

公司员工手册

第一章 公司制度

第一条 工作时间
公司工作时间为 9:30 - 18:30。

第二条 考勤制度
员工需要按时上下班。

第二章 薪资制度

第一条 工资发放
工资于每月15日发放。

第二条 年终奖
公司根据员工年度表现发放年终奖。

最简单的想法是:

整个 Word
   ↓
Embedding
   ↓
一个 Vector

但这样会出现问题。

假设用户问:

工资什么时候发?

真正相关的内容其实只有:

工资于每月15日发放。

但是整个文档还包含:

工作时间
考勤制度
年终奖
...

如果整个文档只对应一个 Vector,那么检索粒度就太粗了。

因此 RAG 通常需要先进行文档切分:

Document
   ↓
Chunk 1
Chunk 2
Chunk 3
Chunk 4

例如:

Chunk 1:
第一章 公司制度
第一条 工作时间
公司工作时间为 9:30 - 18:30。

Chunk 2:
第二条 考勤制度
员工需要按时上下班。

Chunk 3:
第二章 薪资制度
第一条 工资发放
工资于每月15日发放。

Chunk 4:
第二条 年终奖
公司根据员工年度表现发放年终奖。

然后每个 Chunk 单独进行 Embedding:

Chunk 1 → Vector 1
Chunk 2 → Vector 2
Chunk 3 → Vector 3
Chunk 4 → Vector 4

这样用户询问工资问题时,就更容易精准找到 Chunk 3。


二、Chunk 不能太大,也不能太小

Chunk 的大小非常重要。

1. Chunk 太大

例如:

Chunk = 整个 100 页 PDF

可能包含大量无关内容:

公司介绍
工作时间
考勤
工资
奖金
福利
安全制度
...

用户只问:

工资什么时候发?

但是检索结果里面却包含大量无关内容。

这会造成:

语义被大量无关信息稀释。

同时,如果最终把大量内容全部发送给 LLM,也会增加 Context 和 Token 消耗。


2. Chunk 太小

反过来,如果切得太小:

Chunk 1:工资

Chunk 2:每月

Chunk 3:15日

Chunk 4:发放

虽然粒度很细,但一个完整的语义可能被拆散。

用户问:

工资什么时候发?

系统可能无法通过单独的 Chunk 得到完整答案。

因此:

Chunk 太大
→ 无关信息太多

Chunk 太小
→ 上下文不足

真正的目标是:

在语义完整性和检索粒度之间找到平衡。


三、Chunk Overlap

为了减少语义被切断的问题,RAG 中经常会使用:

Chunk Overlap

假设原始文本:

A B C D E F G H I J

如果每 5 个字符切一次:

Chunk 1:
A B C D E

Chunk 2:
F G H I J

那么 E 和 F 之间的语义关系可能被切断。

于是可以使用 Overlap:

Chunk 1:
A B C D E

Chunk 2:
D E F G H

Chunk 3:
G H I J

这里:

Chunk Size = 5
Overlap = 2

也就是每个 Chunk 保留一部分和前一个 Chunk 重叠的内容。

目的就是:

尽可能避免完整语义因为切分而被破坏。


四、不同文档需要不同的 Chunk 策略

Chunk 并不是固定使用一种切法。

不同类型的文档可以采用不同策略。

普通文章

可以优先按照:

段落

进行切分。

Word

可以尽量保留:

标题
  ↓
章节
  ↓
段落

这样的层级结构。

PDF

可以考虑:

页面
 ↓
标题
 ↓
段落
 ↓
表格

Markdown

可以按照:

#
##
###

这样的标题层级进行切分。

API 文档

则可以按照:

接口
请求参数
响应参数
示例

进行切分。

所以在实际 AI 应用开发中:

Chunk 策略本身就是 RAG 系统设计的一部分。


五、Embedding 到底做了什么?

之前容易产生一个误解:

Embedding 是把用户问题转成向量,然后把知识库中的关键词转成向量。

这个理解并不准确。

准确来说:

Embedding 是把文本的语义内容转换成向量。

例如用户问题:

公司什么时候发工资?

经过 Embedding:

Query Vector

知识库中的 Chunk:

公司薪资于每月15日统一结算并发放。

经过 Embedding:

Document Vector

然后比较:

Query Vector
       VS
Document Vector

也就是说比较的是:

问题的语义和知识 Chunk 的语义。

而不是简单比较:

关键词 VS 关键词

六、为什么语义搜索可以找到不同表达方式?

例如用户问:

公司什么时候发工资?

知识库写的是:

公司薪酬于每月十五日统一结算并发放。

两句话的关键词并不完全一致:

工资

和:

薪酬

并不是完全相同的字符串。

但是它们表达的语义非常接近。

Embedding 希望捕捉的就是这种:

语义上的相似性。

因此:

工资什么时候发?
≈
薪酬什么时候结算?
≈
薪资发放日期是什么?

这就是向量检索相比传统关键词搜索的重要优势。


七、Similarity Search

假设 Vector Database 中存在:

Vector A → 工作时间
Vector B → 考勤制度
Vector C → 工资发放
Vector D → 年终奖

用户输入:

工资什么时候发?

首先把问题转换成 Query Vector。

然后计算 Query Vector 和各个 Document Vector 的相似度:

A:0.21

B:0.18

C:0.92

D:0.61

然后按照相似度排序:

C:0.92
D:0.61
A:0.21
B:0.18

这就是:

Similarity Search(相似度搜索)


八、TopK 是什么?

TopK 指的是:

从搜索结果中选择相似度最高的 K 个结果。

例如:

TopK = 2

那么最终得到:

C
D

如果:

TopK = 3

则得到:

C
D
A

九、TopK 不是越大越好

这是 RAG 中一个非常重要的概念。

假设:

A:0.92
B:0.89
C:0.87
D:0.42
E:0.21

如果:

TopK = 3

得到:

A
B
C

通常比较精准。

但是如果:

TopK = 20

虽然可以增加找到正确答案的概率,但也会带来大量无关信息。

所以:

TopK 太小
→ 可能漏掉答案

TopK 太大
→ 无关信息增加
→ Context 变长
→ 噪声增加

因此真实的 RAG 系统通常不会简单地认为:

TopK 越大越好。


十、向量相似度高,不代表一定能够回答问题

这是 Day 7 最重要的一个问题。

假设用户问:

公司年假有多少天?

Vector Search 返回:

Chunk A
相似度:0.92

公司员工每年享有带薪年假。

Chunk B
相似度:0.89

员工入职满一年后可以申请年假。

Chunk C
相似度:0.87

年假需要提前向直属领导申请。

这三个 Chunk 都和“年假”相关。

但是:

没有一个真正回答了“有多少天”。

这说明:

语义相关
≠
能够回答问题

这也是为什么生产环境中的 RAG 往往需要更加复杂的检索流程。


十一、Recall:答案有没有被找到?

假设知识库里真正的答案是:

Chunk D:

员工每年享有 10 天带薪年假。

但是 Vector Search 返回:

A
B
C

而 D 排在第 8:

A  0.92
B  0.89
C  0.87
E  0.85
F  0.84
G  0.83
H  0.82 ← 真正答案

如果:

TopK = 3

那么真正答案根本没有进入后续流程。

最终:

Vector DB
   ↓
没有找到答案
   ↓
LLM
   ↓
无法根据正确知识回答

所以:

Recall 关注的是:应该找到的知识,有没有被召回。

可以用一句话记忆:

Recall = 别漏

十二、Precision:找到的东西够不够准确?

Precision 关注的是:

召回出来的内容中,有多少是真正相关的?

例如真正相关的是:

A
B
C
D

系统返回:

A
B
E
F

那么:

A、B → 相关
E、F → 不相关

因此 Precision 就体现了:

结果中“杂质”有多少。

可以简单记忆:

Recall
→ 别漏

Precision
→ 别杂

十三、Recall 和 Precision 的矛盾

假设真正答案排在第 8。

如果:

TopK = 3

可能:

噪声少

但是:

答案被漏掉

如果:

TopK = 50

可能:

更容易把答案召回

但是:

无关信息也会增加

所以:

TopK 小
→ Precision 可能更高
→ Recall 可能更低

TopK 大
→ Recall 可能更高
→ Precision 可能下降

这就是 RAG 检索阶段需要解决的核心矛盾。


十四、Rerank:重新排序

为了解决这个问题,我们可以把流程变成:

Vector Search
      ↓
Top20
      ↓
Rerank
      ↓
Top3
      ↓
LLM

这里的 Rerank 可以理解成:

对初步召回的候选知识进行第二次、更精细的相关性判断。

Vector Search 更像:

海选

Rerank 更像:

复试


十五、为什么要先 Top20,再 Rerank?

因为 Vector Search 的优势是:

速度快。

面对大量知识:

100 万个 Chunk

我们没必要让一个更加复杂的排序模型去判断全部 100 万个 Chunk。

可以先:

100 万
 ↓
Vector Search
 ↓
Top20

然后:

20
 ↓
Rerank
 ↓
Top3

最后:

Top3
 ↓
LLM

所以 RAG 可以形成一个非常经典的架构:

用户问题
                         ↓
                    Query Embedding
                         ↓
                 ┌───────────────┐
                 │ Vector Search │
                 └───────────────┘
                         ↓
                       TopK
                         ↓
                      Rerank
                         ↓
                       TopN
                         ↓
                  Question + Context
                         ↓
                        LLM
                         ↓
                       Answer

十六、Hybrid Search:为什么还需要关键词搜索?

向量搜索非常擅长:

语义匹配

但它并不是所有场景都最优秀。

例如用户搜索:

React 19

知识库里:

React 19 新特性

这种情况下关键词搜索非常有效。

因为:

React 19

本身就是非常明确的关键词。

但是:

用户:
怎么进行前端组件开发?

知识库:
UI Component Engineering

这种情况下,关键词可能无法很好地匹配。

而 Vector Search 可以从语义上发现:

前端组件开发
≈
UI Component Engineering

因此两种方式各有所长:

搜索方式擅长
Keyword Search精确关键词匹配
Vector Search语义匹配
Hybrid Search两者结合

十七、Hybrid Search 的基本流程

可以变成:

Query
                           ↓
              ┌────────────┴────────────┐
              ↓                         ↓
       Vector Search              Keyword Search
              ↓                         ↓
           Top20                     Top20
              └────────────┬────────────┘
                           ↓
                         合并
                           ↓
                         Rerank
                           ↓
                          Top5
                           ↓
                           LLM

这样既可以利用:

Vector Search

的语义理解能力,也可以利用:

Keyword Search

的精确匹配能力。

这就是:

Hybrid Search(混合检索)


十八、最终的 RAG 检索架构

经过 Day 7 的学习,我们可以把最开始的 RAG:

Document
 ↓
Chunk
 ↓
Embedding
 ↓
Vector DB
 ↓
TopK
 ↓
LLM

升级成:

Document
                       ↓
                     Chunk
                       ↓
                   Embedding
                       ↓
                 Vector Database


用户 Query
     ↓
 ┌───────────────┐
 │ Vector Search │
 └───────────────┘
         ↓
      TopK 候选
         ↓
      ┌────────┐
      │ Rerank │
      └────────┘
         ↓
       TopN
         ↓
      Context
         ↓
        LLM
         ↓
      Answer

如果需要进一步提升检索效果,还可以:

Vector Search
      +
Keyword Search
      ↓
Hybrid Search
      ↓
Rerank
      ↓
LLM

十九、Day 7 的核心认知

通过 Day 7,我对 RAG 的理解从:

“把知识库转换成向量,然后搜索。”

进一步变成了:

RAG 的核心并不仅仅是把知识存进 Vector DB,而是如何高质量地把真正有用的知识检索出来。

整个过程可以理解成:

Chunk
↓
决定知识如何被切分

Embedding
↓
把文本转换成语义向量

Vector Search
↓
快速召回可能相关的知识

Recall
↓
关注有没有漏掉真正答案

Precision
↓
关注召回结果中有没有太多无关内容

Rerank
↓
从候选知识中进一步筛选真正相关的内容

Hybrid Search
↓
结合语义搜索和关键词搜索

Context
↓
把最终知识交给 LLM

LLM
↓
基于知识生成最终答案

二十、Day 7 最终总结

今天最重要的不是记住一堆名词,而是理解下面这条链路:

用户问题
                    ↓
                Embedding
                    ↓
          ┌─────────┴─────────┐
          ↓                   ↓
    Vector Search       Keyword Search
          ↓                   ↓
        候选结果              候选结果
          └─────────┬─────────┘
                    ↓
               Hybrid Search
                    ↓
                  TopK
                    ↓
                 Rerank
                    ↓
                  TopN
                    ↓
                 Context
                    ↓
                   LLM
                    ↓
                  Answer

最终可以把 RAG 的检索目标总结成一句话:

先尽可能不要漏掉答案,再尽可能减少无关信息,最后把最有价值的知识交给 LLM。

也就是:

Recall
  ↓
别漏

Precision
  ↓
别杂

Rerank
  ↓
选得更准

LLM
  ↓
基于正确 Context 回答

这也是从“会使用 RAG”走向“会设计 RAG 系统”的重要一步。


下一步:Day 8

Day 7 主要解决的是:

RAG 怎么把知识找出来。

Day 8 开始进入真正的代码实践:

TXT 文档
   ↓
读取
   ↓
Chunk
   ↓
Embedding
   ↓
Vector DB
   ↓
用户提问
   ↓
Similarity Search
   ↓
TopK
   ↓
Context
   ↓
LLM
   ↓
回答

我们会先不用 LangChain / LlamaIndex,自己实现一个最小 RAG。

这样可以真正理解:

一个 RAG 框架到底帮我们封装了什么。