Strona główna / Artykuły

BM25 Plus pgvector z fuzją wzajemnych rankingu: hybrydowe wyszukiwanie dla RAG w Pythonie

Hybrydowe wyszukiwanie w RAG w Pythonie: dlaczego gęste odzyskiwanie danych pomija dokładne terminy, jak BM25 i wyszukiwanie kosinusowe pgvector uzupełniają się nawzajem, połączone z RRF w Postgresie.

Wydawca: REACTAPP.TOP8 min czytania1906 słów

Źródła: Why BM25 + pgvector Hybrid Search Beats Naive RAG — A Deep Technical Breakdown

Samych wektorów gęstych nie wystarcza do wykrycia dokładnych słów kluczowych, rzadkich terminów oraz żargonu specjalistycznego. Połączenie rankera leksykalnego z indeksem wektorowym wypełnia tę lukę, a całość mieści się w stacku Pythona opartym na Postgresie. Następnie przedstawiono matematykę, architekturę oraz kod.

Co idzie nie tak z zwykłym RAG

Podstawowy proces wzbogacania poprzez wyszukiwanie składa się z kilku kroków:

  1. Wbuduj zapytanie za pomocą modelu takiego jak text-embedding-3-small.
  2. Przeprowadź wyszukiwanie kosinusowe w bazie wektorowej takiej jak pgvector, Pinecone lub Weaviate.
  3. Weź najlepsze K fragmentów.
  4. Umieść je w promptzie LLM.

To działa dopóki zapytanie nie opiera się na dosłownym ciągu znaków. Załóżmy, że użytkownik pyta, w jaki sposób projekt wykorzystuje BM25 do rankowania. Wektor reprezentujący zapytanie znajduje się w pobliżu wektorów dotyczących rankowania, algorytmów wyszukiwania i oceny trafności, więc dokument zawierający dosłowny token BM25 może przegrać z bardziej ogólną stroną o modelach odzyskiwania informacji. To jest problem niezgodności słownictwa, o którym badacze odzyskiwania informacji wiedzą od lat 90.

Embeddingi przekształcają znaczenie w ciągły przestrzeń, a w tym procesie zacierają dokładne dopasowania. Bliskość między „zawałem mięśnia sercowego” a „atak serca” jest pożądana. Natomiast bliskość między BM25 a Okapi ranking stanowi przeszkodę, gdy zapytanie jest konkretne.

BM25 w skrócie

BM25, skrót od Best Match 25, to funkcja wagowania terminów oparta na prawdopodobieństwie, należąca do rodziny modeli wyszukiwania Okapi. Dla dokumentu d i zapytania q sumuje wartości wszystkich terminów zapytania:

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

Symboli oznaczają następujące rzeczy:

  • tᵢ to jeden z terminów zapytania.
  • f(tᵢ, d) podaje, jak często dany termin występuje w dokumencie.
  • |d| to długość dokumentu wyrażona w tokenach, a avgdl to średnia długość we całym korpusie.
  • k₁, zwykle w przedziale od 1,2 do 2,0, określa szybkość nasycenia częstotliwości terminów – im wyższa wartość, tym większe znaczenie ma częstotliwość.
  • b, w przedziale od 0 do 1, kontroluje normalizację długości, przy czym 0 oznacza brak normalizacji, a 1 pełną normalizację.
  • IDF(tᵢ) to log stosunku między dokumentami, które nie zawierają danego terminu, a tymi, które go zawierają (każdy z tych zestawów jest przesunięty o połowę dokumentu), plus jeden. Tutaj N oznacza łączną liczbę dokumentów, a n(tᵢ) liczbę dokumentów zawierających dany termin.

Trzy intuicje wyjaśniają, dlaczego ten algorytm zachowuje się dobrze. Częstotliwość występowania terminów ulega nasyceniu, więc dziesięć wzmianek o BM25 nie daje dziesięciokrotnie wyższej oceny niż jedna wzmianka, a k₁ kształtuje tę krzywą. Normalizacja długości zapobiega karaniu dokumentów za niską liczbę wystąpień, przy czym b skaluje wynik według średniej długości. Natomiast odwrotna częstotliwość dokumentów faworyzuje rzadkie terminy: „BM25” w korpusie tekstów z dziedziny uczenia maszyn ma wysoką wagę, podczas gdy „the” ma niemal żadną.

Wszystko to sprawia, że BM25 jest doskonały do zapytań opartych na dokładnym dopasowaniu, rzadkich terminach oraz zapytań z dużą ilością słów kluczowych, co jest obszarem, w którym tracą na skuteczności gęste embeddingi.

pgvector i gęste wyszukiwanie

pgvector to rozszerzenie PostgreSQL, które przechowuje wektory embeddingowe i umożliwia przybliżone wyszukiwanie najbliższych sąsiadów za pomocą grafów HNSW lub indeksów IVFFlat. Podobieństwo między wektorem zapytania a wektorem dokumentu jest mierzone koseczną:

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

Zapytania HNSW zajmują mniej więcej czas liniowy, a pamięć potrzebna jest proporcjonalna do N razy M, gdzie M to liczba dwukierunkowych powiązań przechowywanych na każdym węźle. Dzięki temu wyszukiwanie trwa znacznie mniej niż milisekundę nawet przy milionach wektorów. Metoda gęstego wyszukiwania doskonale sprawdza się przy dopasowywaniu semantycznym, takim jak parafrazy, różnice językowe oraz podobieństwo na poziomie pojęć. Z powodu opisanego powyżej powodu nie tworzy ona indeksu dla dokładnych ciągów znaków.

Łączenie obu metod za pomocą Reciprocal Rank Fusion

Istnieją dwie listy uporządkowane – jedna z BM25, a druga z pgvector. Reciprocal Rank Fusion łączy je, przypisując każdemu dokumencie ocenę na podstawie jego pozycji we wszystkich listach:

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

Stała k wynosi 60. Zmniejsza wpływ bardzo wysokich rankingu i sprawdziła się w wielu zadaniami. Ta suma obejmuje oba algorytmy wyszukiwania.

Dlaczego lepiej wybrać RRF zamiast nauczonych kombinatorów? Nie są potrzebne oznaczone dane o powiązaniu. Działa na podstawie rankingu, a nie ocen, dzięki czemu unika niezgodności pomiędzy wartościami BM25, które są nieograniczone, a wartościami kosinusowymi, które mieszczą się w przedziale od -1 do 1. Ponadto Cormack i jego współpracownicy wykazali w 2009 roku, że RRF dorównuje lub przewyższa wagowaną kombinację liniową bez konieczności dostosowań. Prosty sposób łączenia, taki jak α · bm25_score + β · cosine_score, jest mniej niezawodny, ponieważ surowe liczby znajdują się na niekompatybilnych skalach.

Dowody z testów benchmarkowych

W teście benchmarkowym BEIR, który obejmuje zbiory danych z dziedziny biomedycyny, wiadomości i techniki, połączenie algorytmu BM25 z metodą gęstego wyszukiwania zazwyczaj przewyższa efektywność każdego z tych podejść stosowanego pojedynczo. Przykładem może być TREC-COVID: tam BM25 radzi sobie lepiej niż model gęsty, ponieważ zapytania biomedyczne, takie jak „SARS-CoV-2 spike protein ACE2 binding”, zawierają liczne wysoce specyficzne terminy, które metodę embeddingów zamazuje. Rozwiązanie hybrydowe łączy zalety obu podejść.

Implementacja w Pythonie

Ustawienia

Wszystko znajduje się w jednej strukturze bazy danych Postgres. Najpierw należy zainstalować wymagane zależności:

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

Następnie ustaw połączenie, typ wektora oraz biblioteki:

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()

Indeksowanie

Pomocnik otacza wywołanie API embedding:

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]

A funkcja indeksowania przechowuje każdy dokument wraz z jego embeddingiem:

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()

Hybrydowe wyszukiwanie

Wyszukiwanie leksykalne sortuje korpus za pomocą 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]

Zapytania wyszukiwania o dużej gęstości w pgvector oraz krok fuzji stosują następnie 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]
    ]

Generowanie odpowiedzi

Na końcowym etapie pobierane są najlepsze wyniki i tworzony jest kontekst:

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)

Restrykcyjny prompt utrzymuje model w ramach tego, co zostało pozyskane:

    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

Parametry wartowe dostosowania

Domyślna wartość BM25 k₁ to 1,5 – im większa wartość, tym większe znaczenie mają powtarzające się terminy, co jest przydatne przy złożonych zapytaniach. Domyślna wartość BM25 b to 0,75, a jej zwiększenie wzmacnia karę za długość tekstu. W przypadku HNSW domyślna wartość m to 16, ponieważ większa liczba krawędzi zapewnia lepsze odzyskiwanie informacji, ale kosztem pamięci; domyślna wartość ef_construction to 64 – większa wartość poprawia jakość indeksu, ale spowalnia jego tworzenie. Wartość RRF k wynosząca 60 może być obniżona, jeśli chcesz, aby wynik o najwyższej pozycji dominował bardziej. Domyślna liczba 20 kandydatów na wynik od jednego mechanizmu wyszukiwania jest rozsądna, a większa liczba kandydatów zazwyczaj poprawia proces fuzji wyników.

W przypadku korpusów o silnym charakterze specjalistycznym, takich jak teksty medyczne, prawnicze lub kod programowy, obniż wartość b do 0,5, aby złagodzić karę za długie dokumenty techniczne, oraz zwiększ wartość k₁ do 2,0, aby nagradzać powtarzające się terminy techniczne.

Wybór odpowiedniego narzędzia wyszukiwania

Dokładne słowa kluczowe, kody produktów oraz nazwy API sprzyjają algorytmowi BM25. Zapytania konceptualne, parafrazowane lub wielojęzyczne lepiej radzą sobie z algorytmem dense search. Większość rzeczywistych zapytań to połączenie obu typów, dlatego hybrydowy model z RRF jest najlepszym wyborem, natomiast żargon specjalistyczny z dziedzin medycyny, prawa czy programowania najlepiej funkcjonuje przy użyciu BM25 lub modelu hybrydowego.

Wniosek

Naive RAG stanowi solidną bazę, ale nie zapewnia wystarczającej zdolności przywoływania informacji w przypadku zapytań bogatych w słowa kluczowe lub specjalistycznych. Naprawa tej sytuacji jest prosta pod względem architektury: należy zastosować BM25 do tego samego korpusu obok wyszukiwania z pgvector, połączyć obie listy uporządkowane za pomocą RRF przy k=60 i przesłać połączoną listę najważniejszych wyników do LLM. Otrzymany system radzi sobie równie dobrze zarówno z pytaniem semantycznym typu „co to jest uczenie maszynowe”, jak i z pytaniem leksykalnym typu „pokaż mi, jak obsługuje się parametr k1 w BM25Okapi”, bez konieczności trenowania dodatkowego modelu i przy jedynie krótkim dodatkowym przetworzeniu BM25 trwającym kilka mikrosekund.

pgvector jest dostępny wewnątrz Postgresa, BM25 można zainstalować za pomocą pakietu rank-bm25, a RRF zajmuje zaledwie kilka linijek kodu. Niewiele stoi na przeszkodzie w dodaniu hybrydowego wyszukiwania do produkcyjnego systemu RAG.

Literatura pokrewna

  • Projektowanie przenośnej wyszukiwarki semantycznej dla wielu użytkowników na Kubernetes i Qdrant — Jak platforma wyszukiwarki semantycznej wykorzystuje Kubernetes do zapewnienia przenośności oraz routingu uwzględniającego poszczególnych użytkowników, aby jej baza wektorowa była wymienna, a obciążenia izolowane.
  • Poza naïwnym RAG: koszty pamięci HNSW, wyszukiwarka hybrydowa i długi kontekst — Dlaczego indeksy wektorowe w pamięci komputera napotykają ograniczenia w dużych skali, gdzie wyszukiwanie dokładnych dopasowań zawodzi, oraz jak hybrydy BM25, RRF i PostgreSQL pasują do świata z długim kontekstem.
  • Self-Hosted RAG do pytań i odpowiedzi w dokumentach: LangChain, pgvector oraz zmienne LLM — Jak aplikacja RAG o otwartym kodzie przekształca pliki PDF i DOCX w odpowiedzi: dzielenie na fragmenty, pgvector, przełączanie się między OpenAI a Claude przy użyciu jednego ustawienia oraz wnioski z tworzenia w ograniczonym budżecie.