Главная / Статьи

BM25 Plus pgvector с объединением взаимных рангов: гибридный поиск для RAG на Python

Гибридный поиск для RAG на Python: почему плотный поиск упускает точные термины, как BM25 и косинусный поиск pgvector дополняют друг друга, объединённые с RRF в Postgres.

Издатель: REACTAPP.TOP8 мин чтения1906 слов

Источники: Why BM25 + pgvector Hybrid Search Beats Naive RAG — A Deep Technical Breakdown

Одни лишь плотные векторы упускают точные ключевые слова, редкие термины и специфическую терминологию определенной области. Сочетание лексического ранжировщика с векторным индексом устраняет этот недостаток, причем вся система может быть реализована в рамках Python-стека, ориентированного на Postgres. Далее приводятся математические основы, архитектура и код.

В чем проблемы простого RAG

Базовый процесс поиска с дополнением данных имеет простую структуру:

  1. Встраиваем запрос с помощью модели вроде text-embedding-3-small.
  2. Проводим поиск по коэффициенту косинуса в векторном хранилище, таком как pgvector, Pinecone или Weaviate.
  3. Берем K лучших результатов.
  4. Включаем их в промпт для большой языковой модели.

Этот подход работает до тех пор, пока запрос не основан на буквальной строке. Предположим, пользователь спрашивает, как проект использует BM25 для ранжирования. Эмбеддинг запроса оказывается рядом с векторами, связанными с ранжированием, алгоритмами поиска и оценкой релевантности, поэтому документ, содержащий буквальный токен BM25, может проиграть более общей странице, посвящённой моделям извлечения информации. Это проблема несоответствия словаря, известная исследователям в области поиска информации с 1990-х годов.

Эмбеддинги сжимают смысл в непрерывное пространство, в процессе чего стираются точные совпадения. Близость между «инфарктом миокарда» и «сердечным приступом» считается желательной. Однако близость между BM25 и Okapi ranking является недостатком, когда запрос конкретен.

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 — количество двунаправленных связей, хранящихся у каждого узла. Это позволяет выполнять поиск среди миллионов векторов менее чем за миллисекунду. Метод плотного поиска особенно эффективен для семантического сопоставления, такого как парафразы, языковые вариации и сходство на уровне концепций. По причинам, описанным выше, он не создает индексы для точных строк.

Слияние двух методов с использованием метода Reciprocal Rank Fusion

Существуют два списка с рангами: один от алгоритма BM25, другой — от pgvector. Метод Reciprocal Rank Fusion объединяет их, присваивая каждому документу оценку на основе его позиции в каждом списке:

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

Константа k равна 60. Она снижает влияние чрезвычайно высоких рангов и эффективно работает во многих задачах. Эта сумма учитывает оба метода поиска.

Почему предпочтительнее использовать RRF вместо метода на основе обученной комбинации? Для его работы не требуются меткированные данные о релевантности. Он работает с рангами, а не с оценками, что позволяет избежать несоответствия между значениями BM25, которые не имеют верхнего предела, и значениями косинуса, находящимися в диапазоне от -1 до 1. Кроме того, в 2009 году Кормак и его коллеги показали, что RRF сопоставим с взвешенной линейной комбинацией или превосходит её без необходимости настройки. Примитивная комбинация вида α · bm25_score + β · cosine_score менее надежна, поскольку исходные числа имеют несовместимые масштабы.

Данные из тестов

В рамках тестовой базы BEIR, включающей смешанные наборы данных из области биомедицины, новостей и технической литературы, где применяется комбинация алгоритма BM25 и метода плотного поиска, обычно достигается лучший результат, чем при использовании любого из методов по отдельности. Хорошим примером является тест TREC-COVID: здесь алгоритм BM25 превосходит модель плотного поиска, поскольку запросы в области биомедицины, такие как «SARS-CoV-2 spike protein ACE2 binding», содержат высокоспецифичные термины, которые смазываются при использовании эмбеддингов. Гибридный подход сохраняет преимущества обоих методов.

Реализация на 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: чем оно выше, тем больше веса получают повторяющиеся термины, что подходит для длинных запросов. Значение b по умолчанию равно 0,75, и его увеличение усиливает штраф за длину текста. Для алгоритма HNSW значение m по умолчанию равно 16, поскольку большее количество рёбер способствует лучшему восстановлению информации за счёт увеличения потребностей в памяти; значение ef_construction по умолчанию составляет 64 — более высокое значение улучшает качество индекса, но замедляет процесс его создания. Значение k в алгоритме RRF равно 60, но его можно снизить, если вы хотите, чтобы результат с наивысшим рейтингом играл более значимую роль. Установка значения 20 кандидатов на каждого поисковика является разумным стандартным значением, и увеличение их количества обычно улучшает процесс объединения результатов.

В корпусах с преобладанием специализированного контента, таком как медицинские, юридические или программные документы, следует снизить значение b до 0,5, чтобы уменьшить штраф за длину технических текстов, и повысить значение k₁ до 2,0, чтобы поощрять использование повторяющихся технических терминов.

Выбор подходящего поисковика

Точные ключевые слова, коды продуктов и названия API лучше всего обрабатывает алгоритм BM25. Концептуальные, перефразированные или многоязычные запросы подходят для глубокого поиска. Большинство реальных запросов представляют собой смесь обоих типов, поэтому гибридный вариант с алгоритмом RRF является лучшим выбором; кроме того, специализированная терминология в медицине, праве или программировании наилучшим образом обрабатывается с помощью BM25 или гибридного подхода.

Вывод

Простая реализация RAG обеспечивает хорошую базовую производительность, но не позволяет эффективно обрабатывать запросы с большим количеством ключевых слов и специализированные запросы с точки зрения покрытия информации. Исправление этой проблемы просто с точки зрения архитектуры: необходимо применить алгоритм BM25 к тому же корпусу данных наряду с поиском с использованием pgvector, объединить два полученных списка сортировки с помощью алгоритма RRF при параметре k=60, а затем передать объединенный список из топ-K элементов в нейросеть. Полученный механизм поиска одинаково хорошо справляется как с семантическими запросами вроде «Что такое машинное обучение», так и с лексическими запросами вроде «Покажите мне, как обрабатывается параметр k1 в BM25Okapi», при этом не требуется дополнительная настройка модели, а обработка данными с помощью 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, а также уроки, полученные при разработке в условиях ограниченного бюджета.