Все исследования

/ru/research · что мы измерили

Нужен ли late interaction в RAG: замерили вторую фазу поиска и нашли маркер, который не передавали

Двухфазный поиск: обычный вектор отбирает 50 кандидатов, ColBERT-модель их переранжирует. Замерили, сколько вторая фаза стоит и сколько приносит: нужный фрагмент оказывается первым в 73% случаев вместо 36%. По дороге выяснилось, что мы не передавали модели её собственный маркер роли, и это ещё 9 пунктов сверху. Плюс замер цены: пулинг, fp16, int8 и int4 — что из этого бесплатно, а что ломает выдачу.

Авторы: slavb18
  • AI
  • LLM
  • ML
  • Research
  • Retrieval
  • RAG
  • ColBERT
  • PostgreSQL
  • pgvector
  • Embeddings

Чаще всего поиск для RAG делают в один проход: у каждого фрагмента лежит один вектор, запрос превращается в такой же вектор, база отдаёт ближайшие. Это быстро, потому что представления фрагментов посчитаны заранее и лежат в базе статикой — на запрос считается только вопрос. Когда качества такого поиска не хватает, сверху обычно ставят реранкер: кросс-энкодер или внешний API, который заново читает пары «вопрос + фрагмент». Порядок он правит хорошо, но платить приходится вызовом модели на каждый кандидат, и задержка растёт вместе с их числом.

Есть третий вариант, и он ближе к первому: late interaction. У фрагмента хранится не один вектор, а матрица — по вектору на каждый токен. Эти матрицы тоже статика в базе, поэтому второй проход не зовёт никакую модель: он считает арифметику по уже посчитанным числам. Дорого здесь другое — место в базе и процессор на сравнение матриц.

Мы решили выяснить, окупается ли этот второй проход. Короткий ответ: на нашем корпусе он вдвое повышает точность первого места — нужный фрагмент оказывается первым в 73% случаев вместо 36%. Длинный ответ интереснее: по дороге выяснилось, что мы неправильно вызывали модель, и увидеть это удалось только потому, что рядом считалась базовая линия.

Что крутится

Стек скучный, и это осознанно:

  • PostgreSQL, в нём же метаданные, права и векторы. Права фильтруются до векторного поиска — запрещённый фрагмент не должен попадать даже в ранжирование, — а дешевле всего такой фильтр обходится там, где данные и права лежат в одной транзакции;
  • у фрагмента (мы называем его чанком) два представления: emb vector(768) — обычный вектор для первого прохода, и embs vector(128)[] — матрица токенов для второго;
  • свой сервер эмбеддингов на sentence-transformers: класс SentenceTransformer для обычной модели и MultiVectorEncoder для ColBERT-модели. HTTP-контракт в стиле OpenAI: {model, input} → {data: [{embedding}]}. Первый проход считает mDenseOn, второй — mLateOn (обе от LightOn, многоязычные). Всё на CPU, без GPU;
  • сам поиск: emb <=> вектор_вопроса по индексу HNSW отбирает 50 кандидатов, дальше их порядок решает MaxSim.

MaxSim — это способ сравнить два текста по токенам. Для каждого токена вопроса ищется самый похожий токен фрагмента, и такие максимумы складываются. Считать MaxSim умеет сама база: у PostgreSQL есть расширение VectorChord с готовым оператором. Если расширение поставить нельзя, как на управляемых базах у облачных провайдеров, — то же самое считает приложение: забирает матрицы пятидесяти кандидатов и сравнивает их в коде. Мы так и делаем. Схема данных при этом не меняется, меняется только место вычисления и его цена: расширение считает внутри базы, приложение — на своём процессоре.

Стенд: почему без базовой линии это не замер

Проверять, что поиск «находит нужное», бессмысленно: находит и LIKE '%слово%'. Смысл появляется, когда рядом посчитано что-нибудь дешёвое, поэтому стенд считает четыре способа на одних и тех же вопросах и одном корпусе:

способ что это
lexical полнотекстовый поиск PostgreSQL — самый дешёвый вариант, не требует ни моделей, ни векторов
dense только первый проход, без переранжирования
late только MaxSim, зато по всему корпусу — без отбора кандидатов
twoPhase то, что работает в продукте: первый проход отбирает, второй расставляет

dense против twoPhase отвечает на главный вопрос статьи: что добавляет вторая фаза. late против twoPhase отвечает на другой: нужен ли отбор кандидатов или он только теряет верные ответы.

Эталон — дословный кусок текста, а не номер фрагмента. Номера меняются при каждой пересборке, и набор вопросов, привязанный к номерам, после переиндексации указывал бы в никуда: стенд показал бы обвал качества там, где поменялась только нумерация. Поэтому эталон записан подстрокой и на каждом прогоне заново находится в тексте.

Стенд отказывается работать в двух случаях:

  • эталон не нашёлся — такой вопрос нельзя ни зачесть, ни провалить, а посчитанный промахом он занизил бы все способы разом;
  • эталон нашёлся больше чем в пяти фрагментах — он слишком общий, зачтётся всегда и ничего не проверит.

Корпус: 6936 готовых фрагментов внутренней переписки, 22 вопроса, у каждого ровно один эталонный фрагмент (проверили запросом до прогона). Метрики обычные для поиска: R@1 — доля вопросов, где нужный фрагмент оказался первым, R@5 и R@10 — где он попал в первые пять и десять, MRR — среднее от единицы, делённой на его место (первое место даёт 1, второе 0.5, третье 0.33). Тексты вопросов и содержание корпуса не привожу: к выводам они не относятся.

Результат 1: что даёт вторая фаза

Что добавляет каждый слой поиска: 14% лексика, 36% плотный вектор, 73% с MaxSim

способ R@1 R@5 R@10 MRR
lexical 14% 14% 14% 0.136
dense (только первый проход) 36% 64% 68% 0.506
twoPhase (первый проход + MaxSim) 73% 77% 77% 0.750

Три вещи, которые тут видно:

  1. Первый проход находит, второй расставляет. Обычный вектор приносит нужный фрагмент в первую пятидесятку почти всегда, но первым ставит только в трети случаев. MaxSim по токенам поднимает его первым в трёх случаях из четырёх. Для пользователя это разница между «ответ где-то в выдаче» и «вот он».
  2. R@10 у двухфазного выше, чем у обычного вектора (77% против 68%), хотя вторая фаза не добавляет новых фрагментов — она переставляет те же пятьдесят. Просто у обычного вектора нужный фрагмент часто стоял на 11–50 месте и в первую десятку не попадал.
  3. Полнотекстовый поиск на этом корпусе не альтернатива: 14% против 73%, разница кратная. Вопросы задают человеческими словами, а не словами текста, и лексика их не связывает.

Цена второй фазы в числах нашей базы: 6936 фрагментов, в среднем 51 токен на фрагмент, матрицы токенов занимают 176 МБ против 20 МБ у обычных векторов — почти в девять раз больше за то же знание. Плюс MaxSim на каждый запрос.

Здесь же ответ, зачем нужен отбор кандидатов. Способ late — полный MaxSim по всему корпусу без первого прохода — идёт на CPU минуты на один вопрос. Отбор пятидесяти кандидатов и превращает дорогую вторую фазу в применимую.

Результат 2: маркер, который мы не передавали

Обе модели обучены асимметрично: один и тот же текст в роли вопроса и в роли фрагмента надо кодировать по-разному, и роль сообщают модели маркером в начале текста. У обычной модели это буквальные слова, у ColBERT — служебные токены. Мы это знали и дописывали в начало текста фрагмента слова document: .

Проще всего спросить сами модели, чего они ждут (те же поля конфига, но у загруженного объекта):

from sentence_transformers import SentenceTransformer, MultiVectorEncoder
dense = SentenceTransformer("lightonai/mDenseOn", device="cpu")
late  = MultiVectorEncoder("lightonai/mLateOn", device="cpu")
print(dense.prompts, dense.default_prompt_name)
print(late.prompts,  late.default_prompt_name)
{'query': 'query: ', 'document': 'document: '}  None
{'query': '[Q] ',    'document': '[D] '}        None

В трёх строках две новости:

  • у ColBERT-модели маркеры — [Q] для вопроса и [D] для фрагмента, а никакие не «query» и «document». Наши слова стояли на месте маркера, а сам маркер не появлялся: для модели это были просто два лишних слова внутри текста;
  • поле default_prompt_name пустое у обеих моделей. Значит encode(texts) без параметра prompt_name не подставляет никакого маркера, и модель кодирует текст без роли вообще.

Видно это по длине матрицы: у одной и той же короткой строки с именем роли токенов семь, без имени шесть, и седьмой токен — маркер. Команды, которыми это проверяется, лежат ниже, в разделе «Пощупать обе фазы».

Дальше — два прогона на одном корпусе и одних вопросах. Между ними менялись только матрицы токенов у фрагментов: обычные векторы и сами вопросы оставались теми же, поэтому разницу можно относить на маркер.

роль фрагмента R@1 R@5 R@10 MRR
слова document: в тексте — так работало у нас 64% 68% 68% 0.659
маркер [D] через prompt_name 73% 77% 77% 0.750

Правильно названная роль дала +9 пунктов R@1 и +0.09 MRR. Всё это время вторая фаза работала вполноги.

Третий вариант мы тоже посчитали: слова из текста убрать и никакого маркера не передавать. Он дал те же 64% R@1 и MRR 0.666, то есть сами слова ничего не давали и ничего не портили — важен был именно маркер.

Это второй случай той же ошибки. Годом раньше те же слова document: стояли на стороне вопроса — то есть вопрос кодировался как документ. Тогда это стоило 18 пунктов R@1 и тоже нашлось только замером: вторая фаза отрабатывала, порядок менялся, выдача выглядела правдоподобно.

Ошибка такого класса не падает. Индекс наполняется, поиск отвечает 200, порядок выглядит осмысленным. Обнаруживает её только базовая линия, посчитанная рядом.

Грабли замера: приблизительный индекс двигает результат на девять пунктов

Первый проход идёт по индексу HNSW, а он приблизительный: находит близкие векторы быстро, но не обязан находить всех. Пока сравниваются способы поиска, это не мешает — приблизительность одинаково действует на всех. Но как только начинаешь сравнивать варианты хранения матриц, она подмешивает собственный разброс, и он оказывается больше измеряемого эффекта.

Наткнулись мы на это, вернув корпус в исходное состояние после серии пересчётов: он дал 64% вместо прежних 73%. Сами матрицы при этом совпадали с эталонными до последнего бита — сравнили расстояние между хранимым и заново посчитанным, получили ноль. Разошёлся не корпус, а отбор кандидатов: индекс перестраивался между прогонами, и граф лёг иначе.

Замер отбора это подтвердил. Из 22 эталонных фрагментов в первую полусотню попадали 18 при точном переборе и 16 через индекс. Два потерянных фрагмента — ровно те девять пунктов R@1 и есть: чего первый проход не принёс, второй не исправит. Проверка прямая: удалить индекс и прогнать снова. Без него база перебирает все 6936 строк — на таком объёме это доли секунды, — и результат вернулся к 73% / 0.750.

Отсюда правило стенда: всё, что сравнивает варианты второй фазы, считается без приблизительного индекса. Он нужен на объёмах, которых у замера нет, а взамен добавляет разброс шире измеряемого.

Результат 3: место под матрицы и чем его можно срезать

Матрицы токенов — главная статья расхода: 176 МБ против 20 МБ у обычных векторов на 6936 фрагментах. Это около 25 КБ на фрагмент, и растёт линейно с перепиской. Мы проверили два способа платить меньше: сократить число токенов в матрице и сократить размер каждого числа.

Меньше токенов: пулинг

Пулинг усредняет соседние векторы токенов: из матрицы 52×128 при коэффициенте 2 получается 26×128. В sentence-transformers для этого есть готовые классы — HierarchicalTokenPooling (сливает похожие соседние токены, первый защищён от слияния) и LambdaTokenPooling (произвольная функция; мы взяли усреднение подряд по четыре).

Эта серия считалась ещё с индексом, поэтому базовая линия в ней читается как 64%, а не 73%: строки таблицы сравнимы между собой, но не с другими таблицами статьи.

матрицы R@1 MRR токенов на фрагмент embs
без пулинга 64% 0.659 51 176 МБ
иерархический ×2 64% 0.659 26 88 МБ
иерархический ×4 59% 0.642 13 45 МБ
подряд по 4, среднее 55% 0.590 13 45 МБ

Вдвое — даром: ни одна метрика не сдвинулась, места вдвое меньше. Вчетверо — уже платно, и способ слияния тут важен: иерархический, который смотрит на похожесть соседей, держится лучше слепого усреднения подряд (59% против 55%).

Меньше байт на число: квантование

Второй путь не трогает число токенов, а уменьшает каждое число. Проверяли три варианта, все — пересчётом уже лежащих матриц, без повторного вызова модели:

  • fp16 — половинная точность. В pgvector для этого есть готовый тип halfvec, и приведение работает поэлементно прямо в базе: embs::halfvec[];
  • int8 — на каждый вектор считается свой масштаб max|x| / 127, числа делятся на него и округляются;
  • int4 — то же самое с делителем 7.
хранение R@1 R@5 R@10 MRR байт на число embs
float32 — как есть 73% 77% 77% 0.750 4 176 МБ
fp16 73% 77% 77% 0.750 2 ~88 МБ
int8 73% 77% 77% 0.750 1 ~44 МБ
int4 41% 73% 77% 0.526 0.5 ~22 МБ

Половина места и четверть места достаются бесплатно: ни одна метрика не шелохнулась. У int4 ломается именно порядок внутри выдачи — R@10 остался прежним, а R@1 упал вдвое; для фазы, которая только и делает, что расставляет, это отказ.

Практический выбор упирается не в качество, а в тип колонки. fp16 — родной тип pgvector: он есть везде, где есть само расширение, и переключение стоит одной миграции. Для int8 родного типа в PostgreSQL нет. Он есть в расширении VectorChord — veci8, со своими операторами расстояния, — но это отдельное расширение, которого на управляемой базе может не оказаться; у нас его нет. Свой формат (bytea плюс масштаб) возможен, но тогда квантование и обратное восстановление переезжают в приложение, а оператор MaxSim в базе работает с массивом vector. Поэтому берём fp16 сейчас, а int8 остаётся заготовкой на случай, когда место снова станет вопросом.

Что проверили и не взяли:

  • сжатие страниц: перевод колонки на lz4 вместо pglz дал меньше процента — матрицы это плотные float'ы, сжимать в них нечего;
  • выбрасывание коротких фрагментов: короче 100 символов — 57% строк, но всего 16% текста. Строк много, места они почти не занимают.

Самое большое сокращение лежит не в кодировке, а в ответе на вопрос «кому вообще нужна матрица»: у старой переписки, у коротких реплик и у всего, что классификатор считает шумом, вторая фаза не окупается. Это уже регламент хранения, а не замер.

Чем управляют параметры запроса

Запрос к серверу выглядит так, и в нём три поля:

{"model": "lightonai/mLateOn", "input": ["текст"], "prompt_name": "document"}
  • model — какая из двух моделей считает. Адрес один, поэтому клиент выбирает фазу именем модели, а не отдельным сервисом. Неизвестное имя — отказ 400, а не пустой ответ: пустой не отличить от честного результата.
  • input — строка или список строк. Список превращается в одну пачку на инференсе, и это единственный способ ускорить пересчёт корпуса: пачка по 24 текста идёт вшестеро быстрее, чем те же 24 по одному.
  • prompt_name — роль текста, query или document: та самая, из-за которой вторая фаза работала вполноги.

Дальше сервер зовёт encode(), и там появляются ещё два аргумента, которых в HTTP нет:

  • normalize_embeddings=True у плотной модели. Без него длина вектора у той же строки — 37.97, с ним — ровно 1. Нормализация нужна, чтобы косинус стал скалярным произведением: тогда и SQL (emb <=> вектор), и демо выше считают близость одним умножением, а не делением на длины. У late-модели этого аргумента нет — её токенные векторы приходят единичными сами.
  • device="cpu" — модель загружается один раз на старте процесса. Вместе с блокировкой на инференсе это и есть весь «рантайм» сервера: ни очереди, ни батчинга по времени.

Роль и маркеры модель объявляет сама, в своём конфиге (config_sentence_transformers.json), и клиент их не хардкодит:

// mDenseOn
{"prompts": {"query": "query: ", "document": "document: "}, "default_prompt_name": null}

// mLateOn
{"model_type": "ColBERT", "similarity_fn_name": "MaxSim",
 "prompts": {"query": "", "document": ""}, "default_prompt_name": null,
 "query_prefix": "[Q] ", "document_prefix": "[D] ", "do_query_expansion": false}
  • prompts — словарь «имя роли → что подставить в начало текста». Это данные модели: сменилась модель — сменились префиксы, а вызов остался тот же. У ColBERT-модели в файле они пустые, а настоящие маркеры лежат в своих полях query_prefix и document_prefix; класс MultiVectorEncoder переносит их в prompts при загрузке, поэтому у загруженного объекта видно {'query': '[Q] ', 'document': '[D] '}.
  • default_prompt_name — какую роль применять, если вызывающий не назвал. У обеих моделей null, поэтому encode(texts) не подставляет ничего. Опираться на это поле нельзя в обе стороны: поставь автор "query" — и простой вызов молча кодировал бы фрагменты как вопросы.
  • do_query_expansion: false — расширения запроса масками у этой модели нет, то есть роли различаются ровно одним служебным токеном. Тем самым, который виден в длине матрицы.
  • similarity_fn_name — как модель предлагает считать близость: cosine у плотной, MaxSim у late. Поле информационное, считаем мы сами — в SQL или в приложении.

Опечатка в имени роли не проходит молча:

{"error": "ValueError: Prompt name 'нет-такой' not found in the configured prompts dictionary with keys ['query', 'document']"}

Пощупать обе фазы: контейнер и curl

Ниже — самодостаточный опыт: ни базы, ни корпуса, ни нашего кода. Нужен только сервер эмбеддингов с двумя моделями. У нас это контейнер на сто строк вокруг sentence-transformers: одна модель грузится классом SentenceTransformer, вторая — MultiVectorEncoder, и HTTP-контракт как у OpenAI.

docker run --rm -p 7997:7997 iembedding    # внутри: python + torch (CPU) + обе модели
curl -s localhost:7997/health              # {"status": "ok"}

Фаза 1 — один вектор на текст. Роль текста передаётся полем prompt_name: query для вопроса, document для фрагмента.

curl -s localhost:7997/embeddings -H 'content-type: application/json' \
  -d '{"model":"lightonai/mDenseOn","prompt_name":"query",
       "input":["чем закрыть повторные обращения к внешнему api"]}'
# вектор: 768 чисел, первые три: [0.0024, -0.0357, -0.0692]

Фаза 2 — матрица токенов. Тот же адрес, другая модель:

curl -s localhost:7997/embeddings -H 'content-type: application/json' \
  -d '{"model":"lightonai/mLateOn","prompt_name":"document",
       "input":["Ответы внешнего сервиса кладём в кэш на пять минут."]}'
# матрица: 19 x 128

Дальше считается арифметика. Векторы плотной модели нормированы, поэтому косинус — это скалярное произведение. MaxSim — сумма по токенам вопроса от максимума по токенам фрагмента. Обе строчки влезают в скрипт на двадцать строк, который делает три запроса и печатает оба числа:

import json, urllib.request

E = "http://localhost:7997/embeddings"
DENSE, LATE = "lightonai/mDenseOn", "lightonai/mLateOn"

def emb(model, text, role):
    body = json.dumps({"model": model, "input": [text], "prompt_name": role}).encode()
    req = urllib.request.Request(E, body, {"content-type": "application/json"})
    return json.load(urllib.request.urlopen(req))["data"][0]["embedding"]

dot = lambda a, b: sum(x * y for x, y in zip(a, b))
maxsim = lambda q, d: sum(max(dot(tq, td) for td in d) for tq in q)

question = "чем закрыть повторные обращения к внешнему api"
fragments = [
    "Ответы внешнего сервиса кладём в кэш на пять минут, повторный вызов берётся из него.",
    "Внешний сервис отвечает медленно, поэтому таймаут поднят до тридцати секунд.",
]

qd, ql = emb(DENSE, question, "query"), emb(LATE, question, "query")
for text in fragments:
    d1, d2 = emb(DENSE, text, "document"), emb(LATE, text, "document")
    print(f"фаза 1 {dot(qd, d1):.3f} · фаза 2 {maxsim(ql, d2):.2f} · {text[:40]}…")
фаза 1 0.470 · фаза 2 12.13 · Ответы внешнего сервиса кладём в кэш на …
фаза 1 0.321 · фаза 2 11.96 · Внешний сервис отвечает медленно, поэтом…

Здесь видно устройство, а не качество: оба числа считаются в три запроса и одну строку арифметики, и в проде разница только в том, что матрицы фрагментов уже лежат в базе, а не приезжают по HTTP. Порядок двух фрагментов на таком опыте ничего не доказывает: MaxSim складывается по всем токенам вопроса, поэтому на коротких текстах числа стоят близко (12.13 против 11.96). Разница между фазами проявляется на корпусе и наборе вопросов с эталонами — как в разделе про стенд.

Проверить маркер можно тем же curl. Одна и та же строка с ролью и без неё:

curl -s localhost:7997/embeddings -H 'content-type: application/json' \
  -d '{"model":"lightonai/mLateOn","prompt_name":"document","input":["короткая строка"]}'
# токенов в матрице: 7

curl -s localhost:7997/embeddings -H 'content-type: application/json' \
  -d '{"model":"lightonai/mLateOn","input":["короткая строка"]}'
# токенов в матрице: 6

Седьмой токен и есть маркер [D].

Свой замер на корпусе повторяется тем же способом: пересчитать матрицы фрагментов нужным регламентом (у нас это отдельный скрипт с бэкапом прежних значений, пересчёт 6936 фрагментов на CPU идёт около 20 минут) и прогнать стенд, задав роль вопроса теми же именами.

Чего замер не говорит

Границы важнее красивых чисел:

  • +9 пунктов R@1 — это два вопроса из 22. Величина сдвига измерена грубо. Направление надёжнее: все четыре метрики двинулись в одну сторону, а MRR учитывает места всех вопросов, а не только первого.
  • Вопросы написаны по текстам этого же корпуса. Между вариантами числа сравнимы, с другими корпусами — нет. Абсолютный процент здесь не «качество продукта», а способ сравнить конфигурации.
  • Способ late в этой серии не считался — без оператора в базе он идёт минуты на вопрос. На прошлом корпусе он оказывался чуть лучше двухфазного по MRR, и это пока остаётся вопросом: с ростом корпуса полный MaxSim перестанет быть бесплатным.
  • Кратный разрыв между дешёвым поиском и семантикой — единственное число из статьи, которое почти наверняка перенесётся на любой похожий корпус.

Ответ на вопрос заголовка

Вторая фаза нужна, и мера у этого есть: нужный фрагмент оказывается первым вдвое чаще (36% → 73%), MRR растёт с 0.51 до 0.75. Цена — примерно девятикратный объём представлений в базе и MaxSim на каждый запрос, а отбор кандидатов первым проходом делает эту цену подъёмной. Половина этой цены снимается сменой типа колонки на halfvec: на метриках это не отражается никак.

Главный вывод касается способа работы. Вызов модели надо сверять с её собственным контрактом, а не с аналогией из соседней модели. Дважды подряд у нас стояли слова там, где модель ждала маркер, и оба раза это ничего не ломало, а тихо стоило десятков пунктов качества. Находится такое только базовой линией, посчитанной рядом с продуктовым путём, и стендом, который отказывается работать на непригодных эталонах.

Все исследования