核心区别：

余弦相似度：
  比较 query 向量 和 chunk 向量 的夹角相似度。

真正的 reranker：
  把 query 和 chunk 放在一起，让模型重新判断“这个 chunk 是否真的能回答这个问题”。

所以：

cosine similarity = 向量距离计算
reranker score     = query-document 相关性判断

1. 余弦相似度在做什么？

Embedding 模型会分别把问题和文档片段变成向量：

query:
"VIA0 enclosure by M1 under minimum width condition"
        ↓
q = [0.12, -0.08, 0.44, ...]

chunk:
"VIA0 enclosure by M1 is defined in Table ..."
        ↓
d = [0.10, -0.05, 0.41, ...]

然后计算：

cosine_similarity(q, d)

公式大概是：

cos(q, d) = q · d / (|q| |d|)

分数越高，说明两个向量方向越接近，系统就认为它们越相关。

这个方法的优点是：

快
便宜
文档向量可以提前算好
可以在海量 chunk 里快速检索

缺点是：

query 和 chunk 是分别编码的
模型没有同时看 query 和 chunk
细节关系容易丢失
rule ID / layer / condition 很像时容易混淆

也就是说，余弦相似度本质上是：

“这两个压缩后的语义向量像不像？”

而不是：

“这个 chunk 是否准确回答了这个 query？”

2. Reranker 在做什么？

真正的 reranker 通常不是只拿两个向量算距离，而是把问题和候选 chunk 作为一对输入：

输入：
[Query] VIA0 enclosure by M1 under minimum width condition
[Chunk] Table 4-12: VIA0 enclosure by M1 ...

输出：
relevance_score = 0.93

它看的是：

query + chunk 的整体匹配程度

而不是两个独立向量的距离。

典型 reranker 模型内部会让 query token 和 chunk token 互相交互。例如它能更细地判断：

query 里要的是 VIA0，不是 VIA1
query 里要的是 M1，不是 M2
query 里要的是 enclosure，不是 spacing
query 里要的是 minimum width condition，不是 default condition

所以 reranker 更像是在问：

“这个 chunk 是否真的包含回答这个问题所需的证据？”

3. 用你的 PDK / design rule 场景举例

假设问题是：

VIA0 enclosure by M1 under minimum width condition

第一轮 embedding + cosine 可能找出这些 chunk：

A. VIA0 enclosure by M1, minimum width condition
B. VIA0 enclosure by M2, minimum width condition
C. VIA1 enclosure by M1, minimum width condition
D. VIA0 spacing rule
E. M1 minimum width rule

用余弦相似度看，A、B、C、D、E 可能都挺像，因为它们都包含：

VIA
M1 / M2
enclosure
spacing
minimum width
rule

但真正最相关的是 A。

余弦相似度可能得到：

A: 0.82
B: 0.80
C: 0.79
E: 0.77
D: 0.75

这些分数很接近，排序可能不稳。

reranker 则会更像这样判断：

A: 0.94  # VIA0 + enclosure + M1 + minimum width condition 全部匹配
B: 0.61  # VIA0 对了，但 M2 不对
C: 0.55  # M1 对了，但 VIA1 不对
E: 0.43  # M1 minimum width 对了，但不是 VIA0 enclosure
D: 0.32  # VIA0 对了，但 rule type 是 spacing

这就是 reranker 的价值。

它不是简单问：

“语义像不像？”

而是更接近问：

“这个候选片段是否满足 query 里的关键约束？”

4. 本质区别表

对比项	余弦相似度 / embedding 检索	Reranker
输入	query 向量 + chunk 向量	query 原文 + chunk 原文
计算方式	向量夹角 / 距离	模型判断相关性
是否同时看 query 和 chunk	否，分别编码	是，一起判断
速度	很快	慢很多
能否全库搜索	可以	通常不可以
文档表示	通常一个 chunk 一个向量	每次 query 来了才对候选重评
适合阶段	第一轮召回	第二轮精排
对细粒度条件	较弱	较强
是否生成答案	否	否

5. 为什么不用 reranker 直接搜全库？

因为太慢。

假设你有：

100,000 个 chunk

用 embedding 检索时：

query 算一次向量
然后向量库快速找 Top 50 / Top 100

这很快。

但 reranker 如果直接扫全库，就要做：

100,000 次 query-chunk 成对判断

这会非常慢。

所以标准做法是两阶段：

第一阶段：快速召回
  keyword search + embedding cosine similarity
  从全库找 Top 50 / Top 100

第二阶段：精细重排
  reranker
  从 Top 50 / Top 100 里选 Top 8 / Top 12

第三阶段：生成回答
  chat model
  基于 Top chunks 回答

也就是：

cosine similarity 负责“从全库快速捞候选”
reranker 负责“从候选里认真挑证据”

6. “Vector rerank” 这个词可能有两种含义

这里要小心。

有些系统里说的 vector rerank 只是：

先用关键词检索召回一批结果
然后再用向量余弦相似度重新排序

这种情况下，所谓 vector rerank 本质上还是：

cosine similarity reranking

它和第一轮向量检索没有本质区别，只是使用场景变了：不是从全库 ANN 检索，而是在已有候选里重新计算向量分数。

但如果系统里说的 reranker 是：

bge-reranker
qwen-reranker
cross-encoder reranker
rerank model

那它通常不是简单 cosine similarity，而是：

score = reranker_model(query, chunk)

这和 embedding cosine 有本质区别。

所以你可以这样判断：

如果输入是两个向量，然后算距离：
  这是 cosine / vector similarity

如果输入是 query 文本 + chunk 文本，然后模型输出相关性分数：
  这是 reranker

7. 和 embedding model 的关系

Embedding model 做的是：

text -> vector

例如：

"setNanoRouteMode routeTopRoutingLayer"
        ↓
[0.01, -0.23, 0.88, ...]

然后系统用余弦相似度算：

similarity(query_vector, chunk_vector)

Reranker 做的是：

query + chunk -> relevance score

例如：

query:
"How to limit top routing layer in Innovus?"

chunk:
"Use setNanoRouteMode -routeTopRoutingLayer ..."

        ↓

score = 0.95

所以：

embedding model 输出向量
reranker 输出相关性分数

embedding model 的输出可以存进数据库。
reranker 的分数不能提前存，因为它依赖当前 query。

8. 和 chat model 的关系

Chat model 做的是：

query + retrieved chunks -> final answer

例如：

根据检索到的文档片段，回答：
可以使用 setNanoRouteMode -routeTopRoutingLayer ...

它负责：

理解
推理
组织语言
写答案
写代码
解释步骤

Reranker 不负责生成答案。它只负责排序。

所以三者分工是：

Embedding model:
  帮你从全库找可能相关的材料

Reranker:
  帮你把这些材料按相关性重新排序

Chat model:
  读排序后的材料，生成最终回答

9. 对你的 EDA / PDK 文档，为什么 reranker 更重要？

因为你的文档里有大量“看起来很像但实际不同”的内容：

M1 spacing vs M1 enclosure
VIA0 vs VIA1
M0 vs M1
default rule vs exception rule
minimum width condition vs maximum width condition
DRC rule vs LVS rule
N5 rev A vs N5 rev B

cosine similarity 容易觉得这些都很接近。

但你真正需要的是：

严格命中 layer
严格命中 rule type
严格命中 condition
严格命中文档版本
严格命中表格/脚注

reranker 通常能改善这种细粒度排序。

不过它不是万能的。对于 design rule，我仍然建议：

1. 不同 PDK revision 分开 dataset
2. metadata 里保留 node / revision / document type
3. 检索时尽量指定 dataset
4. keyword 权重不要太低
5. reranker 开启
6. 回答必须带 page / table / rule ID

10. 最简单的一句话

余弦相似度是在比较两个已经压缩好的向量像不像；reranker 是把问题和文档片段放在一起，重新判断这个片段是否真的能回答问题。

推荐你的 RAGFlow 流程是：

keyword + embedding cosine
  ↓
召回 Top 50

reranker
  ↓
重排并保留 Top 8~12

Claude Code 本地 Kimi / GLM
  ↓
基于证据回答

对于 Innovus user guide，reranker 是加分项。
对于 PDK / TSMC N5 design rule，reranker 很值得开。

Reranker 的 score 不是像余弦相似度那样用一个固定公式手算出来的。
它本质上是一个神经网络学出来的打分函数：

score = fθ(query, chunk)

其中 θ 是模型训练得到的参数。

你可以把它理解成：

余弦相似度：
  score = cos(query_vector, chunk_vector)

Reranker：
  score = 一个模型读完 query 和 chunk 后，输出“相关性分数”

1. 最典型的 reranker：Cross-Encoder

很多 reranker，例如 BGE reranker、SentenceTransformers CrossEncoder 类模型，本质上是这种结构：

输入：
[CLS] query [SEP] chunk [SEP]

经过 Transformer

取 [CLS] 或最后 hidden state

接一个线性层

输出一个 logit

logit 经过 sigmoid 或 softmax 得到 score

可以写成公式：

x = "[CLS] query [SEP] chunk [SEP]"

h = Transformerθ(x)

logit = W · h_cls + b

score = sigmoid(logit)

其中：

h_cls = Transformer 输出里代表整对 query-chunk 关系的向量
W, b = 模型训练出来的参数
score = 相关性分数

所以 reranker 的 score 不是人手设计的公式，而是模型内部经过大量训练后学出来的。

2. 一个具体例子

假设 query 是：

VIA0 enclosure by M1 under minimum width condition

候选 chunk A：

Table 5-12: VIA0 enclosure by M1. For minimum width condition, enclosure shall be ...

候选 chunk B：

Table 5-18: VIA1 enclosure by M1. For minimum width condition, enclosure shall be ...

候选 chunk C：

M1 minimum width design rule is defined as ...

Embedding + cosine 看到它们都包含很多相似词：

VIA
M1
enclosure
minimum width
condition

所以分数可能很接近。

但 reranker 会把 query 和每个 chunk 拼在一起，让模型自己判断：

fθ(query, chunk A) = 0.94
fθ(query, chunk B) = 0.58
fθ(query, chunk C) = 0.41

它为什么能区分？因为 Transformer 里 query token 和 chunk token 会互相 attention。模型可以学到：

query 要的是 VIA0，chunk A 是 VIA0，匹配
query 要的是 M1，chunk A 是 M1，匹配
query 要的是 enclosure，chunk A 是 enclosure，匹配
query 要的是 minimum width condition，chunk A 也包含，匹配

而 chunk B 虽然很像，但它是 VIA1，不是 VIA0。
chunk C 虽然有 M1 minimum width，但它不是 VIA0 enclosure。

3. Reranker score 是怎么训练出来的？

训练数据通常长这样：

query: "How to limit top routing layer in Innovus?"

positive chunk:
"Use setNanoRouteMode -routeTopRoutingLayer to specify the top routing layer..."

negative chunk:
"Top-level floorplan setup includes macro placement and power planning..."

训练目标是让模型学会：

score(query, positive_chunk) 高
score(query, negative_chunk) 低

常见训练方式有三类。

第一类：Pointwise

每个 query-chunk 对都有一个标签：

(query, chunk, label)

label = 1 相关
label = 0 不相关

模型输出：

score = sigmoid(logit)

然后用 binary cross entropy 训练：

loss = - y log(score) - (1 - y) log(1 - score)

也就是：

相关 chunk 的 score 越接近 1 越好
不相关 chunk 的 score 越接近 0 越好

第二类：Pairwise

训练数据是：

query
positive chunk
negative chunk

模型分别打分：

s_pos = fθ(query, positive_chunk)
s_neg = fθ(query, negative_chunk)

训练目标是：

s_pos > s_neg

常见 loss 形式类似：

loss = -log sigmoid(s_pos - s_neg)

也就是鼓励正样本分数比负样本高。

第三类：Listwise

给一个 query 和一组候选 chunk：

query
chunk_1, chunk_2, chunk_3, ..., chunk_n

模型学习整个排序列表，目标是把真正相关的 chunk 排在前面。

很多现代 reranker 会混合使用这些训练方式。

4. 和余弦相似度的关键差别

余弦相似度是：

query -> embedding vector q
chunk -> embedding vector d

score = q · d / (|q| |d|)

这里 query 和 chunk 是分别编码的。

也就是说：

query 先被压缩成一个向量
chunk 也先被压缩成一个向量
然后两个向量做距离计算

而 reranker 是：

query + chunk -> Transformer -> score

query 和 chunk 是一起输入模型的。

所以 reranker 能做更细的 token-level 交互，例如：

VIA0 是否等于 VIA1？
M1 是否等于 M2？
spacing 是否等于 enclosure？
default rule 是否等于 exception rule？
minimum width condition 是否真的出现在这个表格条件里？

余弦相似度更像：

这两个文本整体语义像不像？

Reranker 更像：

这个 chunk 是否真的回答了这个 query？

5. Reranker score 的数值应该怎么理解？

要注意一点：reranker 的 score 通常不是绝对概率。

比如：

chunk A: 0.94
chunk B: 0.72
chunk C: 0.48

你可以理解为：

在当前 query 下，A 比 B 更相关，B 比 C 更相关

但不要过度理解成：

A 有 94% 概率绝对正确

很多 reranker 输出的是 raw logit，例如：

A: 7.8
B: 2.1
C: -1.4

这种分数没有固定上限和下限。系统只关心排序：

7.8 > 2.1 > -1.4

有些系统会把 logit 过 sigmoid：

sigmoid(7.8) ≈ 0.9996
sigmoid(2.1) ≈ 0.89
sigmoid(-1.4) ≈ 0.20

但这仍然主要用于排序，不应该当成严格置信概率。

6. 为什么它不能提前算好？

Embedding 可以提前算：

chunk_1 -> vector_1
chunk_2 -> vector_2
chunk_3 -> vector_3

因为每个 chunk 的 embedding 只依赖 chunk 自己。

但 reranker score 依赖 query：

score = fθ(query, chunk)

同一个 chunk，对于不同 query 的分数完全不同。

例如同一个 chunk：

"setNanoRouteMode -routeTopRoutingLayer specifies the top routing layer..."

对于 query A：

How to limit top routing layer in Innovus?

score 可能很高：

0.95

对于 query B：

How to report timing violation in Innovus?

score 可能很低：

0.12

所以 reranker 必须在用户提问之后实时计算。

7. 为什么不能直接用 reranker 搜全库？

因为太慢。

假设你有：

500,000 个 chunks

如果直接 rerank 全库，就要算：

fθ(query, chunk_1)
fθ(query, chunk_2)
...
fθ(query, chunk_500000)

这等于跑 50 万次 query-chunk 推理，成本太高。

所以实际 RAG 是两阶段：

第一阶段：快速召回
  keyword search + embedding cosine
  从 500,000 个 chunks 找 Top 50 或 Top 100

第二阶段：精排
  reranker
  对 Top 50 / Top 100 逐个打分

第三阶段：生成
  chat model
  只读取 Top 5~12 个 chunks

也就是：

embedding / keyword search 负责广撒网
reranker 负责精挑选
chat model 负责写答案

8. 有些 reranker 不是 sigmoid 分类器

上面说的是最典型的 cross-encoder reranker。还有一些 LLM-style reranker，原理稍微不同。

例如输入 prompt：

Query: VIA0 enclosure by M1 under minimum width condition

Passage:
Table 5-12: VIA0 enclosure by M1 ...

Question:
Is the passage relevant to the query? Answer yes or no.

模型输出 yes 或 no。
系统可以拿 yes 这个 token 的概率作为相关性分数：

score = P("yes" | query, passage)

或者看：

score = logit("yes") - logit("no")

这种 reranker 仍然不是余弦相似度。它还是在做：

query + chunk -> relevance score

只是 score 的来源变成了语言模型对 yes/no 的概率判断。

9. 用伪代码看一下

余弦相似度

q_vec = embedding_model.encode(query)
d_vec = embedding_model.encode(chunk)

score = cosine_similarity(q_vec, d_vec)

Cross-encoder reranker

input_text = "[CLS] " + query + " [SEP] " + chunk + " [SEP]"

hidden = transformer(input_text)

logit = linear(hidden["CLS"])

score = sigmoid(logit)

LLM-style reranker

prompt = f"""
Query: {query}

Passage: {chunk}

Is this passage relevant to the query? Answer yes or no.
"""

logits = llm(prompt)

score = logits["yes"] - logits["no"]

三者都能产生“分数”，但分数来源完全不同。

10. 对你的 EDA / PDK 场景，reranker 在学什么？

理想情况下，它会学到类似这样的判断：

VIA0 ≠ VIA1
M1 ≠ M2
spacing ≠ enclosure
width ≠ pitch
DRC ≠ LVS
default condition ≠ exception condition
Innovus command syntax ≠ command explanation

当然，通用 reranker 不一定真正懂 TSMC N5 rule 的专业含义，但它通常比单纯 cosine 更擅长判断 query 和 chunk 的逐词、逐条件匹配关系。

所以对 design rule 查询，我会用：

keyword search 保证精确 token 命中
embedding search 保证语义召回
reranker 保证候选精排
chat model 负责基于证据回答

最核心的区别

余弦相似度：
  人定义的数学公式。
  输入是两个向量。
  输出是向量方向相似度。

Reranker score：
  模型学习出来的相关性函数。
  输入是 query 原文 + chunk 原文。
  输出是模型判断的相关性分数。

所以你可以这样理解：

cosine_score = cos(E(query), E(chunk))

reranker_score = NeuralNetwork(query, chunk)

前者是固定公式。
后者是训练出来的判断器。