/ru/research · что мы измерили
Двухфазный поиск: обычный вектор отбирает 50 кандидатов, ColBERT-модель их переранжирует. Замерили, сколько вторая фаза стоит и сколько приносит: нужный фрагмент оказывается первым в 73% случаев вместо 36%. По дороге выяснилось, что мы не передавали модели её собственный маркер роли, и это ещё 9 пунктов сверху. Плюс замер цены: пулинг, fp16, int8 и int4 — что из этого бесплатно, а что ломает выдачу.
Чаще всего поиск для RAG делают в один проход: у каждого фрагмента лежит один вектор, запрос превращается в такой же вектор, база отдаёт ближайшие. Это быстро, потому что представления фрагментов посчитаны заранее и лежат в базе статикой — на запрос считается только вопрос. Когда качества такого поиска не хватает, сверху обычно ставят реранкер: кросс-энкодер или внешний API, который заново читает пары «вопрос + фрагмент». Порядок он правит хорошо, но платить приходится вызовом модели на каждый кандидат, и задержка растёт вместе с их числом.
Есть третий вариант, и он ближе к первому: late interaction. У фрагмента хранится не один вектор, а матрица — по вектору на каждый токен. Эти матрицы тоже статика в базе, поэтому второй проход не зовёт никакую модель: он считает арифметику по уже посчитанным числам. Дорого здесь другое — место в базе и процессор на сравнение матриц.
Мы решили выяснить, окупается ли этот второй проход. Короткий ответ: на нашем корпусе он вдвое повышает точность первого места — нужный фрагмент оказывается первым в 73% случаев вместо 36%. Длинный ответ интереснее: по дороге выяснилось, что мы неправильно вызывали модель, и увидеть это удалось только потому, что рядом считалась базовая линия.
Стек скучный, и это осознанно:
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). Тексты вопросов и содержание корпуса не привожу: к выводам они не относятся.
| способ | 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 |
Три вещи, которые тут видно:
Цена второй фазы в числах нашей базы: 6936 фрагментов, в среднем 51 токен на фрагмент, матрицы токенов занимают 176 МБ против 20 МБ у обычных векторов — почти в девять раз больше за то же знание. Плюс MaxSim на каждый запрос.
Здесь же ответ, зачем нужен отбор кандидатов. Способ late — полный MaxSim по всему корпусу без
первого прохода — идёт на CPU минуты на один вопрос. Отбор пятидесяти кандидатов и превращает
дорогую вторую фазу в применимую.
Обе модели обучены асимметрично: один и тот же текст в роли вопроса и в роли фрагмента надо
кодировать по-разному, и роль сообщают модели маркером в начале текста. У обычной модели это
буквальные слова, у 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
В трёх строках две новости:
[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.
Отсюда правило стенда: всё, что сравнивает варианты второй фазы, считается без приблизительного индекса. Он нужен на объёмах, которых у замера нет, а взамен добавляет разброс шире измеряемого.
Матрицы токенов — главная статья расхода: 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%).
Второй путь не трогает число токенов, а уменьшает каждое число. Проверяли три варианта, все — пересчётом уже лежащих матриц, без повторного вызова модели:
halfvec, и приведение
работает поэлементно прямо в базе: embs::halfvec[];max|x| / 127, числа делятся на него и
округляются;| хранение | 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'ы, сжимать в них нечего;Самое большое сокращение лежит не в кодировке, а в ответе на вопрос «кому вообще нужна матрица»: у старой переписки, у коротких реплик и у всего, что классификатор считает шумом, вторая фаза не окупается. Это уже регламент хранения, а не замер.
Запрос к серверу выглядит так, и в нём три поля:
{"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']"}
Ниже — самодостаточный опыт: ни базы, ни корпуса, ни нашего кода. Нужен только сервер эмбеддингов с
двумя моделями. У нас это контейнер на сто строк вокруг 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 минут) и прогнать стенд, задав роль вопроса теми же именами.
Границы важнее красивых чисел:
late в этой серии не считался — без оператора в базе он идёт минуты на вопрос. На
прошлом корпусе он оказывался чуть лучше двухфазного по MRR, и это пока остаётся вопросом: с
ростом корпуса полный MaxSim перестанет быть бесплатным.Вторая фаза нужна, и мера у этого есть: нужный фрагмент оказывается первым вдвое чаще (36% → 73%),
MRR растёт с 0.51 до 0.75. Цена — примерно девятикратный объём представлений в базе и MaxSim на
каждый запрос, а отбор кандидатов первым проходом делает эту цену подъёмной. Половина этой цены
снимается сменой типа колонки на halfvec: на метриках это не отражается никак.
Главный вывод касается способа работы. Вызов модели надо сверять с её собственным контрактом, а не с аналогией из соседней модели. Дважды подряд у нас стояли слова там, где модель ждала маркер, и оба раза это ничего не ломало, а тихо стоило десятков пунктов качества. Находится такое только базовой линией, посчитанной рядом с продуктовым путём, и стендом, который отказывается работать на непригодных эталонах.