Почему RAG всё ещё даёт неверные ответы: гибридный поиск, переранжирование и Recall@K
Чистые фрагменты не гарантируют качественных ответов. Рассмотрим, где терпит неудачу поиск векторов, и как методы фьюжн, кросс-кодер для переранжирования, HyDE и метрика Recall@K это исправляют.
Источники: The AI Series: The Hardest Part of RAG, Part 2 — Why Perfect Chunks Still Give You Bad Retrieval
Типичная ситуация в проектах RAG: работа по парсингу завершена. Фрагменты текста очищены, таблицы формируются в формате Markdown, и каждый фрагмент сопровождается номером страницы и названием раздела. Однако пользователи в производственной среде по-прежнему получают неверные ответы на вопросы, которые система должна решать без труда. Проблема не в фрагментах текста — поисковый механизм просто продолжает извлекать неверные из них.
Хороший парсинг обеспечивает качественные данные, но качественные данные не гарантируют качественного поиска. Это разные проблемы, причем вторая получает гораздо меньше внимания, чем заслуживает.
Что на самом деле делает поиск по сходству
Многие команды рассматривают similarity_search() как «черный ящик», поэтому краткий взгляд внутрь помогает. Модель эмбеддингов преобразует текст в список чисел, вектор, который представляет собой точку в пространстве с количеством измерений от 384 до 3072 в зависимости от модели. Тексты с похожим значением должны находиться рядом друг с другом, а несвязанные тексты — на большом расстоянии.
Упрощённая версия с всего 4 измерениями делает числа более читаемыми:
"How do I reset my password?" → [0.81, 0.12, -0.44, 0.09]
"Steps to change your password" → [0.79, 0.15, -0.41, 0.11]
"How do I cancel my subscription?"→ [0.22, 0.68, 0.05, -0.39]
Два вектора сравниваются с помощью косинусного сходства, которое показывает, насколько они направлены в одном направлении, игнорируя при этом их длину. Оценка 1,0 означает одинаковое направление, 0 — отсутствие связи, а отрицательные значения — противоположные направления.
from numpy import dot
from numpy.linalg import norm
def cosine_similarity(a, b):
return dot(a, b) / (norm(a) * norm(b))
query = [0.80, 0.13, -0.42, 0.10] # "reset my password"
print(cosine_similarity(query, [0.81, 0.12, -0.44, 0.09])) # 0.998 - very close
print(cosine_similarity(query, [0.22, 0.68, 0.05, -0.39])) # 0.310 - far apart
За фразой «ИИ понимает вопрос» скрывается не что иное, как геометрия, а не истинное понимание; именно геометрия объясняет сбои: ИИ не может распознать, что указание «запрещено» меняет смысл понятия «разрешено», так же как и то, что «Ошибка 4092» — это буквальная строка, с которой должно совпасть введённое пользователем значение.
Четыре способа сбоя при поиске
Сжатие целого абзаца до одной точки приводит к потере информации. Как только система выходит за рамки демо-режима, продолжают возникать те же четыре типа сбоев.
- Несоответствие лексики. Человек вводит точный код ошибки или идентификатор продукта, но алгоритм обработки воспринимает его как обычный токен, в результате чего фрагмент текста с этой точной строкой не попадает в топ-10 результатов.
- Слепота к отрицанию. Политика, предусматривающая прекращение возврата средств через месяц, и вопрос о возможности возврата средств после этого срока используют почти один и тот же словарный запас, поэтому они могут оказаться в опасной близости друг от друга, несмотря на противоречивое значение.
- Изоляция фрагментов. Ответ располагается между двумя фрагментами: число указано в одном, а описание его — в предыдущем, и система возвращает только один из них.
- Путаница из-за свежести. Векторный индекс не учитывает, что документ устарел, поэтому старые и новые версии одной и той же политики часто получают одинаково высокий рейтинг релевантности.
Демонстрация с 20 документами не выявляет ничего из этого. Проблемы проявляются тогда, когда в корпусе появляются реальные дубликаты, перекрытия и неоднозначности, что характерно для любой производственной системы.
Пайплайн вместо одного вызова
Один вызов хранилищу векторов не является системой поиска. Надежная система имеет несколько этапов:
Каждый этап существует потому, что предыдущий сам по себе недостаточен. Именно в этом заключается главное отличие демо-версии RAG от его применения в производстве: каждый этап устраняет определенную слабость на предыдущем этапе, и ни один из них не является формальностью.
Гибридный поиск с слиянием рангов
Поиск по векторам плохо справляется с точными совпадениями, а поиск по ключевым словам (BM25) — с концептуальными совпадениями. Вместо того чтобы выбирать один из методов, следует использовать оба и объединить их результаты.
Метод слияния рангов на основе взаимности — это простейший способ объединения двух списков с рангами, когда их оценки не находятся на одной шкале. Типичная реализация выглядит следующим образом:
from collections import defaultdict
def reciprocal_rank_fusion(result_lists, k=60):
scores = defaultdict(float)
for result_list in result_lists:
for rank, doc_id in enumerate(result_list):
scores[doc_id] += 1 / (k + rank + 1)
return sorted(scores, key=scores.get, reverse=True)
vector_ids = [d.metadata["chunk_id"] for d in vector_store.similarity_search(query, k=20)]
bm25_ids = [d.metadata["chunk_id"] for d in bm25_index.search(query, k=20)]
final_ranking = reciprocal_rank_fusion([vector_ids, bm25_ids])
Частой ошибкой на ранних этапах является объединение двух списков результатов без их слияния. Тот список, который оказывается первым, незаметно доминирует в итоговом контексте, что сводит на нет смысл применения двух стратегий.
Переупорядочивание
Самым сложным этапом обработки текста является извлечение таблиц, а в поиске — переупорядочивание результатов. Модели встраивания кодируют запрос и каждый документ отдельно, затем сравнивают полученные результаты. Модель переупорядочивания, как правило, представляет собой кросс-кодер, который совместно обрабатывает запрос и кандидатские фрагменты, после чего напрямую выдает оценку релевантности. Этот процесс занимает больше времени, поэтому он применяется только к 20–50 лучших кандидатам после слияния данных, а не ко всему индексу.
from sentence_transformers import CrossEncoder
reranker = CrossEncoder("BAAI/bge-reranker-base")
def rerank(query, candidates, top_n=5):
pairs = [(query, c["text"]) for c in candidates]
scores = reranker.predict(pairs)
for c, s in zip(candidates, scores):
c["rerank_score"] = float(s)
return sorted(candidates, key=lambda c: c["rerank_score"], reverse=True)[:top_n]
В одной из внутренних систем поиска поддержки использование ранжировщика после процедуры слияния позволило повысить показатель Recall@5 с примерно 61% до 84%, при этом модель вкладки и размер фрагментов остались без изменений. Это единственное изменение оказалось более эффективным, чем весь остальной набор мероприятий, что делает его стандартным первым вариантом решения, когда ответы, полученные с использованием технологии RAG, кажутся близкими к правильным, но не совсем точными.
Преодоление разрыва в словарном запасе
Иногда индекс находится в нормальном состоянии, а настоящей проблемой является формулировка. Пользователи пишут неформально («Почему оно не позволяет мне войти?»), тогда как документация составлена в формальном стиле («Ошибка аутентификации может возникнуть при истечении срока действия токенов сессии»).
Существует два способа решения этой проблемы. При переписывании запросов ИИ-модель переформулирует нечеткый вопрос так, чтобы он больше соответствовал формулировке исходного материала. Метод HyDE (Hypothetical Document Embeddings) идет еще дальше: ИИ-модель составляет краткий вымышленный ответ, и именно этот текст, а не сам вопрос, подвергается вжиманию и поиску, поскольку правдоподобный ответ в векторном пространстве находится гораздо ближе к реальным ответам, чем сам вопрос.
def hyde_retrieve(query, llm, vector_store, k=5):
hypothetical = llm.invoke(f"Write a short passage answering: {query}")
return vector_store.similarity_search(hypothetical, k=k)
Система поддержки, внедрившая этот подход, смогла восстановить значительную долю запросов, которые ранее не давали никакой полезной информации, исключительно благодаря тому, что пользователи и документация используют разные варианты формулировок.
Прямое измерение качества поиска
Привлекательным упрощением является оценка качества поиска по тому, звучит ли окончательный ответ от большой языковой модели правильно. Однако это почти ничего не говорит о том, на каком этапе произошла ошибка.
Необходим небольшой набор с метками — даже 50–100 пар запросов и правильных фрагментов ответа, — чтобы можно было измерить показатель Recall@K ещё до вмешательства большой языковой модели. Recall@K позволяет определить: из фрагментов, которые действительно содержат ответ, сколько из них оказалось среди первых K результатов?
def recall_at_k(retrieved_ids, relevant_ids, k):
top_k = set(retrieved_ids[:k])
return len(top_k & relevant_ids) / len(relevant_ids) if relevant_ids else 0.0
Без этого каждая изменение размера блоков, модели встраивания данных или алгоритма переранжирования представляет собой лишь догадку, маскирующуюся под улучшение.
Подводные камни и разумная компоновка
Увеличение значения k редко помогает устранить проблемы с поиском, поскольку это в основном добавляет к LLM ещё больше отвлекающих факторов. Также нецелесообразно тратить первую неделю на настройку размера блоков — это не принесёт значительной пользы по сравнению с прогрессом, который даёт алгоритм переранжирования. Наконец, необходимо сформировать набор для оценки ещё до появления жалоб, ведь диагностика проблем с поиском позже лишь тратит целый срок работы.
Разумная компоновка для создания этого слоя с нуля: Qdrant для векторного поиска, BM25 через OpenSearch в сочетании с RRF, самостоятельно размещённый алгоритм переранжирования BGE с использованием Cohere Rerank в качестве резервного варианта, а также HyDE, предназначенный для обработки запросов в формате диалога.
Откуда на самом деле берётся качество ответов
Дискуссии обычно сосредотачиваются на том, какая ИИ-модель генерирует наиболее гладкий окончательный ответ, но настоящий фактор определяется ещё до использования модели: были ли вообще получены нужные фрагменты данных? Даже самая совершенная модель при неправильном контексте всегда будет давать блестящий, уверенный, но неверный ответ.
Парсинг вводит данные в систему, тогда как механизм поиска определяет, попадает ли к модели нужная часть информации. Если хотя бы один из этих этапов ошибочен, последующая настройка промптов не сможет спасти ситуацию. При наличии надежного механизма поиска возникает вопрос о том, как автоматически, от начала до конца, проверять, правильно ли система обрабатывает полученные данные, вместо того чтобы проверять результаты по одному.
Связанные материалы
- Поиск в RAG при десяти миллионах документов: воронки поиска, маршрутизаторы, агенты и метрики оценки — Воронка поиска с временем обработки запроса менее 200 мс, включающая фильтры SQL, гибридный поиск и переранжирование, а также маршрутизацию запросов, оркестрацию действий агентов, метрики оценки и скрипт работы с пайплайном Qdrant.
- Рецепт Spring AI: фильтрация результатов RAG с использованием метаданных по названию игры — Пошаговая инструкция Spring AI, предусматривающая присвоение документам метки с названием, использование большой языковой модели для выбора подходящего значения из вопроса и фильтрацию результатов векторного поиска на основе этого значения.