RRF vs MMR 全面对比：从核心原理到RAG实战选型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

def rrf_fuse(doc_lists: list[list], k: int = 60, weights: list[float] = None) -> list:
    """
    RRF倒数排名融合
    :param doc_lists: 多路检索结果列表，每个元素是一路文档对象列表
    :param k: 平滑常数，默认60
    :param weights: 每路检索的权重，默认全1
    :return: 融合排序后的文档列表
    """
    if weights is None:
        weights = [1.0] * len(doc_lists)
    
    fused_scores = {}
    doc_map = {}
    
    # 遍历每路检索，累加RRF得分
    for list_idx, docs in enumerate(doc_lists):
        weight = weights[list_idx]
        for rank, doc in enumerate(docs, start=1):
            # 用文档内容作为唯一键，实际生产可用文档ID
            doc_key = doc.page_content
            doc_map[doc_key] = doc
            # 计算单路RRF得分并加权
            score = (1.0 / (k + rank)) * weight
            fused_scores[doc_key] = fused_scores.get(doc_key, 0) + score
    
    # 按总分降序排序
    sorted_items = sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)
    return [doc_map[key] for key, _ in sorted_items]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever
from langchain_community.vectorstores import FAISS

# 初始化两路检索器
bm25_retriever = BM25Retriever.from_documents(docs)
bm25_retriever.k = 4

faiss_retriever = FAISS.from_documents(docs, embeddings).as_retriever(search_kwargs={"k": 4})

# 集成检索器，底层默认RRF融合，可自定义权重
ensemble_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, faiss_retriever],
    weights=[0.5, 0.5]
)

# 直接检索
results = ensemble_retriever.get_relevant_documents("耳机进水保修多久？")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def mmr_rerank(query_embedding: np.ndarray, 
               doc_embeddings: list[np.ndarray], 
               docs: list,
               top_k: int = 4,
               lambda_param: float = 0.6) -> list:
    """
    MMR最大边际相关性重排
    :param query_embedding: 查询向量
    :param doc_embeddings: 候选文档向量列表
    :param docs: 候选文档对象列表
    :param top_k: 返回结果数量
    :param lambda_param: 平衡系数，越大越看重相关性
    :return: MMR重排后的文档列表
    """
    # 计算所有文档与查询的相关性得分
    relevance_scores = cosine_similarity([query_embedding], doc_embeddings)[0]
    
    selected_indices = []
    candidate_indices = list(range(len(docs)))
    
    for _ in range(min(top_k, len(docs))):
        best_score = -float('inf')
        best_idx = -1
        
        # 遍历所有候选，找MMR得分最高的
        for idx in candidate_indices:
            # 相关性项
            rel_score = lambda_param * relevance_scores[idx]
            
            # 冗余项：与已选文档的最大相似度
            if len(selected_indices) == 0:
                redundancy_score = 0
            else:
                selected_embeds = [doc_embeddings[i] for i in selected_indices]
                sims = cosine_similarity([doc_embeddings[idx]], selected_embeds)[0]
                redundancy_score = (1 - lambda_param) * max(sims)
            
            # MMR最终得分
            mmr_score = rel_score - redundancy_score
            
            if mmr_score > best_score:
                best_score = mmr_score
                best_idx = idx
        
        selected_indices.append(best_idx)
        candidate_indices.remove(best_idx)
    
    return [docs[i] for i in selected_indices]

1
2
3
4
5
6
7
8
9

# FAISS 开启MMR检索
retriever = faiss_db.as_retriever(
    search_type="mmr",
    search_kwargs={
        "k": 4,          # 返回结果数
        "fetch_k": 20,   # 先召回20个候选，再做MMR重排
        "lambda_mult": 0.6  # 对应lambda参数，0.6平衡相关性与多样性
    }
)

1
2
3
4
5
6
7
8
9

用户Query → Query改写（Step-Back/HyDE等）→ 多路检索（BM25+向量+...）
    ↓
RRF融合：把所有路的结果合并成一个统一排序列表
    ↓
MMR重排：对融合后的候选集做多样性去冗余
    ↓
（可选）Cross-Encoder精排：对Top-N做精准相关性打分
    ↓
最终上下文 → 送入LLM生成答案