首页 / 文章

BM25 Plus与pgvector结合互反排名融合技术:Python环境下的RAG混合搜索方案

Python中RAG的混合搜索:为何密集检索会遗漏精确匹配项,BM25与pgvector余弦搜索如何相互补充,以及如何在Postgres上结合RRF使用。

发布者:REACTAPP.TOP阅读约 8 分钟1906 词

来源: Why BM25 + pgvector Hybrid Search Beats Naive RAG — A Deep Technical Breakdown

仅靠密集向量无法捕捉到精确的关键词、罕见术语以及领域专用语。将词汇排名器与向量索引结合使用可以弥补这一缺陷,而且整个方案能够融入以 Postgres 为核心的 Python 技术栈中。相关的数学原理、架构设计以及代码实现如下。

普通 RAG 存在哪些问题

一个基础的检索增强流程非常简单:

  1. 使用如 text-embedding-3-small 这样的模型对查询进行嵌入。
  2. 在 pgvector、Pinecone 或 Weaviate 等向量存储系统中进行余弦搜索。
  3. 选取排名靠前的 K 个结果片段。
  4. 将这些片段放入大语言模型的提示词中。

这种情况在查询不涉及精确字符串时依然有效。假设用户询问某个项目是如何使用BM25进行排序的,那么查询嵌入向量会靠近与排序、搜索算法及相关性评分相关的向量,因此包含精确字符串BM25的文档可能会输给那些内容更宽泛、涉及检索模型的页面。这就是词汇不匹配问题,信息检索领域的研究人员自20世纪90年代就已知晓这一问题。

嵌入技术将含义压缩到连续空间中,这一过程会模糊精确匹配的结果。"心肌梗塞"与"心脏病发作"之间的相似度是可取的;但当查询非常具体时,BM25与"Okapi排序算法"之间的相似度反而会成为障碍。

BM25简述

BM25是Best Match 25的缩写,属于Okapi系列检索模型中的概率式词项权重函数。对于文档d和查询q,它会对查询词项进行求和:

score(q, d) = Σ IDF(tᵢ) · [f(tᵢ, d) · (k₁ + 1)] / [f(tᵢ, d) + k₁ · (1 - b + b · |d| / avgdl)]

这些符号的含义如下:

  • tᵢ 是查询词条中的一个项。
  • f(tᵢ, d) 衡量该词条在文档中出现的频率。
  • |d| 表示文档以词元为单位的长度,而 avgdl 是整个语料库的平均长度。
  • k₁ 的值通常在1.2到2.0之间,用于设定词频饱和的速度,数值越大则词频的权重越高。
  • b 的值在0到1之间,用于控制长度归一化,0表示不进行归一化,1表示完全归一化。
  • IDF(tᵢ) 是不含该词条的文档与含有该词条的文档(每类文档都减去半份)的比例的对数再加一。此处N表示所有文档的数量,n(tᵢ)表示包含该词条的文档数量。

有三种直觉可以解释为何BM25的表现如此优异。首先,词频会达到饱和状态,因此提及BM25十次并不会比仅提及一次获得十倍的分数,而k₁则负责塑造相应的曲线。其次,长度归一化机制可避免因文档的原始词频过低而受到惩罚,b则通过平均长度来进行缩放。最后,逆文档频率机制会优先考虑稀有词:在一般的机器学习文本语料库中,“BM25”的权重很高,而“the”的权重则几乎为零。

正是这些机制使得BM25在精确匹配、涉及稀有词以及关键词较多的查询场景中表现出色,而这正是密集向量表示方法容易出错的领域。

pgvector与密集检索

pgvector 是 PostgreSQL 的一个扩展,用于存储嵌入向量,并通过 HNSW 图或 IVFFlat 索引实现近似最近邻搜索。查询向量与文档向量之间的相似度用余弦值来表示:

cosine_sim(q, dᵢ) = (q · dᵢ) / (‖q‖ · ‖dᵢ‖)

HNSW查询的时间复杂度大致为对数级,其内存占用与N乘以M成正比,其中M是指每个节点保留的双向链接数量。因此,即便处理数百万个向量,检索速度也能保持在毫秒级以内。密集搜索在语义匹配方面表现优异,适用于处理同义表达、语言差异以及概念层面的相似性问题。由于上述原因,它不会为精确字符串建立索引。

通过互反排名融合技术结合两者

存在两个排序列表,一个来自BM25,另一个来自pgvector。互反排名融合技术通过根据每个文档在各个列表中的位置为其赋予分数,从而将这两个列表结合起来:

RRF(d) = Σᵢ 1 / (k + rankᵢ(d))

常数 k 的值为 60。它能够减弱极高排名带来的影响,并且在许多任务中都表现稳定。该值适用于两种检索器。

为何选择 RRF 而非学习型组合方法?因为无需标注过的相关性数据。它基于排名而非分数进行计算,从而避免了 BM25 值(无上限)与余弦值(介于 -1 和 1 之间)之间的不匹配问题。Cormack 及其同事在 2009 年证明,无需调整参数,RRF 的性能即可与加权线性组合相媲美甚至更优。而像 α · bm25_score + β · cosine_score 这样的简单混合方法则不够可靠,因为各数值所处的量级并不兼容。

基准测试结果

在BEIR基准测试中,那种涵盖生物医学、新闻和技术领域语料库的混合检索方法,通过结合BM25与密集检索技术,往往能优于单独使用任一方法的效果。TREC-COVID就是一个典型的例子:在该数据集上BM25的表现优于密集模型,因为诸如“SARS-CoV-2刺突蛋白与ACE2的结合”这类生物医学查询包含大量高度特定的术语,而嵌入模型会削弱这些术语的区分度。混合检索方法则能保留两种方法的优点。

Python实现

环境准备

所有数据都存储在同一个Postgres数据库表结构中。首先需要安装相关依赖项:

# requirements: psycopg2, pgvector, rank-bm25, openai, numpy

接着设置连接、向量类型以及所需库:

import psycopg2
from pgvector.psycopg2 import register_vector
from rank_bm25 import BM25Okapi
import openai
import numpy as np
from typing import List, Tuple# ── DB setup ──────────────────────────────────────────────────────────────
conn = psycopg2.connect("postgresql://user:pass@localhost/ragdb")
register_vector(conn)with conn.cursor() as cur:
    cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
    cur.execute("""
        CREATE TABLE IF NOT EXISTS documents (
            id        SERIAL PRIMARY KEY,
            content   TEXT NOT NULL,
            embedding vector(1536)       -- text-embedding-3-small dim
        );
    """)
    # HNSW index: m=16 (edges/node), ef_construction=64 (build-time beam width)
    cur.execute("""
        CREATE INDEX IF NOT EXISTS doc_hnsw_idx
        ON documents USING hnsw (embedding vector_cosine_ops)
        WITH (m = 16, ef_construction = 64);
    """)
    conn.commit()

索引生成

有一个辅助工具用于封装嵌入模型API调用:

def embed(texts: List[str]) -> List[List[float]]:
    resp = openai.embeddings.create(
        model="text-embedding-3-small",
        input=texts
    )
    return [r.embedding for r in resp.data]

索引功能会将每份文档与其嵌入向量一起存储:

def index_documents(docs: List[str]) -> None:
    embeddings = embed(docs)
    with conn.cursor() as cur:
        for doc, emb in zip(docs, embeddings):
            cur.execute(
                "INSERT INTO documents (content, embedding) VALUES (%s, %s)",
                (doc, emb)
            )
        conn.commit()

混合检索

词汇搜索使用BM25Okapi对语料库进行排序:

def bm25_search(
    corpus: List[str],
    query: str,
    top_k: int = 20
) -> List[Tuple[int, float]]:
    """Returns [(doc_idx, bm25_score), ...] sorted descending."""
    tokenized = [doc.lower().split() for doc in corpus]
    bm25 = BM25Okapi(tokenized, k1=1.5, b=0.75)
    scores = bm25.get_scores(query.lower().split())
    ranked = sorted(enumerate(scores), key=lambda x: x[1], reverse=True)
    return ranked[:top_k]

密集搜索查询pgvector以及后续的融合步骤会应用RRF算法:

def dense_search(
    query: str,
    top_k: int = 20
) -> List[Tuple[int, float]]:
    """Returns [(doc_id, cosine_sim), ...] sorted descending."""
    q_emb = embed([query])[0]
    with conn.cursor() as cur:
        cur.execute("""
            SELECT id, 1 - (embedding <=> %s::vector) AS cosine_sim
            FROM documents
            ORDER BY embedding <=> %s::vector
            LIMIT %s;
        """, (q_emb, q_emb, top_k))
        return [(row[0], row[1]) for row in cur.fetchall()]
def reciprocal_rank_fusion(
    *ranked_lists: List[Tuple[int, float]],
    k: int = 60
) -> List[Tuple[int, float]]:
    """
    RRF(d) = Σᵢ 1 / (k + rankᵢ(d))
    k=60 is the standard constant from Cormack et al. 2009.
    """
    scores: dict[int, float] = {}
    for ranked in ranked_lists:
        for rank, (doc_id, _) in enumerate(ranked, start=1):
            scores[doc_id] = scores.get(doc_id, 0.0) + 1.0 / (k + rank)
    return sorted(scores.items(), key=lambda x: x[1], reverse=True)
def hybrid_retrieve(
    corpus: List[str],
    doc_ids: List[int],        # DB IDs aligned with corpus
    query: str,
    top_k: int = 5
) -> List[dict]:
    """
    Full hybrid pipeline:
      1. BM25 sparse search
      2. pgvector dense ANN search
      3. RRF fusion
      4. Return top-K merged results
    """
    bm25_results  = bm25_search(corpus, query, top_k=20)
    # Map corpus index → DB id for BM25
    bm25_db = [(doc_ids[idx], score) for idx, score in bm25_results]    dense_results = dense_search(query, top_k=20)    fused = reciprocal_rank_fusion(bm25_db, dense_results, k=60)    # Fetch content for top-K
    top_ids = [doc_id for doc_id, _ in fused[:top_k]]
    with conn.cursor() as cur:
        cur.execute(
            "SELECT id, content FROM documents WHERE id = ANY(%s)",
            (top_ids,)
        )
        rows = {row[0]: row[1] for row in cur.fetchall()}    return [
        {"id": doc_id, "rrf_score": score, "content": rows.get(doc_id, "")}
        for doc_id, score in fused[:top_k]
    ]

答案生成

最后阶段会获取最佳结果并构建上下文:

def rag_answer(query: str, corpus: List[str], doc_ids: List[int]) -> str:
    results = hybrid_retrieve(corpus, doc_ids, query, top_k=5)
    context = "\n\n---\n\n".join(r["content"] for r in results)

限制性提示词能让模型始终基于已检索到的内容进行响应:

    prompt = f"""You are a precise technical assistant.
Use only the provided context to answer the question.
If the context doesn't contain the answer, say so.Context:
{context}Question: {query}
Answer:"""    resp = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )
    return resp.choices[0].message.content

值得调整的参数

BM25的k₁默认值为1.5,数值越大则对重复项的权重越高,这更适合包含大量内容的查询。BM25的b默认值为0.75,提高该值会增强对文档长度的惩罚。对于HNSW,m默认值为16,因为更多的边能提升召回率,但会占用更多内存;ef_construction默认值为64,数值越大则索引质量越高,但构建速度会变慢。RRF的k值为60,若希望排名靠前的结果更具优势,可将其调低。每个检索器返回20个候选项是一个合理的默认值,候选项数量越多通常有助于更好的结果融合。

在医学、法律或代码等以专业领域内容为主的语料库中,可将b值降至0.5,以减轻对长篇技术文档的惩罚,同时将k₁值提升至2.0,从而让重复出现的技术术语获得更高权重。

选择合适的检索引擎

精确的关键词、产品代码和API名称更适合BM25;而概念性、意译后的或多语言查询则更适合密集搜索。大多数实际查询都是两者的混合,因此采用RRF的混合检索引擎是最佳选择;而在医学、法律或编程领域中的专业术语,使用BM25或混合检索引擎效果最佳。

总结

Naive RAG虽然能提供良好的基准性能,但在处理关键词密集型或专业领域的查询时会出现召回率不足的问题。其架构上的改进很简单:在pgvector搜索的同时对同一语料库运行BM25,使用RRF算法以k=60的参数合并两个排序后的列表,再将合并后的前K条结果传递给大语言模型。这样得到的检索系统既能很好地处理“什么是机器学习”这类语义性问题,也能妥善应对“展示BM25Okapi k1参数的处理方式”这类词汇性问题,无需额外训练模型,仅需对BM25进行微秒级的额外处理即可。

pgvector内置在Postgres中,BM25可通过安装rank-bm25获得,而RRF的实现仅需几行代码。要将混合搜索功能加入生产环境中的RAG系统,几乎不存在任何障碍。

相关阅读

  • 在 Kubernetes 和 Qdrant 上设计可移植的多租户语义搜索 —— 语义搜索平台如何利用 Kubernetes 实现可移植性及租户感知的路由机制,从而保证向量数据库的可替换性并隔离不同工作负载。
  • 超越简单的 RAG:HNSW 的内存成本、混合搜索与长上下文 —— 为什么内存中的向量索引在大规模应用时会遇到瓶颈、精确匹配检索为何会失效,以及 BM25 混合算法、RRF 和 PostgreSQL 如何适应长上下文场景。
  • 用于文档问答的自托管RAG:LangChain、pgvector与可替换的LLM —— 一款开源RAG应用如何将PDF和DOCX文件转化为答案:分块处理、pgvector技术、在OpenAI与Claude之间一键切换的功能,以及低成本开发过程中的经验教训。