ANN вглубь: HNSW, IVF, PQ и компромисс recall/latency/RAM

Точный перебор 523 тысяч эмбеддингов — десятки миллисекунд на запрос и линейный рост. Приближённый поиск (ANN) меняет точность на скорость: своя HNSW, IVF-Flat, SQ8 и PQ на Go против истины точного перебора — recall@10, время, число вычисленных расстояний и память по каждой ручке, сверка с Faiss и jvector. Плюс то, что в бенчмарках обычно не видно: недостижимые узлы графа, перекос списков IVF от нерепрезентативного обучения и метрики, которые совпадают только на нормированных векторах.

Вводную «зачем нужны векторные БД и когда не нужны» мы уже разбирали отдельно — векторные базы данных и эмбеддинги. Эта статья открывает серию «Векторные БД: глубокое погружение» и начинает с фундамента — алгоритмов приближённого поиска ближайших соседей (ANN), на которых стоят и pgvector, и Qdrant, и Milvus.

Точный поиск сравнивает запрос с каждым вектором коллекции. ANN меняет гарантию «найдём ровно ближайших» на «найдём почти всех ближайших, но намного быстрее». Вся инженерия векторного поиска — о том, где провести эту границу и чем за неё заплатить: временем, памятью или долей потерянных соседей. Здесь эти три величины измерены на одном корпусе для каждой ручки каждого алгоритма.

Стенд: digital-cookbook/vector-databases/ann, датасет серии — digital-cookbook/vector-databases/dataset.

Инженерная схема в стиле «Полдень. XXI век» на кремовой бумаге: над россыпью точек-векторов висят три полупрозрачных слоя графа HNSW — сверху редкие связи, ниже всё гуще. Оранжевый пунктир спускается от узла верхнего слоя через средний к нижнему и выходит к кругу из оранжевых соседей вокруг точки запроса — два соседа в нём не закрашены, найдены не все. Внизу поле точек разбито на ячейки-многоугольники, как списки IVF, часть ячеек подкрашена. В правом нижнем углу вставка: длинная полосатая лента вектора сжимается в короткий брусок из нескольких блоков — квантизация

В статье

Стенд: корпус, истина и мера работы

Корпус. BEIR Quora: 522 931 короткий вопрос и 10 000 тестовых запросов. Эмбеддинги считает self-hosted модель intfloat/multilingual-e5-small в контейнере на CPU: 384 измерения, векторы нормированы (длина 1), документы с префиксом passage: , запросы — query: . Ревизия модели и версии библиотек закреплены в dataset.json стенда датасета. Один и тот же корпус и одни и те же запросы — во всей серии.

Истина. Для 1000 тестовых запросов точным перебором посчитаны 100 ближайших документов. Все дальнейшие числа — recall@10: доля настоящих десяти ближайших, попавших в выдачу из десяти. Это ANN recall — мера того, сколько индекс теряет относительно точного поиска. Релевантны ли эти десять документов вопросу, он не говорит: это retrieval recall по разметке, его мерит статья о гибридном поискеготовится, с 4 декабря. Высокий ANN recall хорошего RAG не гарантирует, а потеря части соседей не обязательно его портит: пропущенные геометрические соседи могут быть и нерелевантны задаче.

// go/vec/vec.go
func Recall(got []int32, truth []int32, k int) float64 {
	want := make(map[int32]bool, k)
	for _, t := range truth[:k] {
		want[t] = true
	}
	hit := 0
	for i, g := range got {
		if i == k {
			break
		}
		if want[g] {
			hit++
		}
	}
	return float64(hit) / float64(k)
}

Мера работы. Время зависит от железа, языка и того, как скомпилирован цикл. Поэтому, кроме времени, стенд считает число вычисленных расстояний на запрос — это свойство алгоритма и его параметров, а не машины. Поиск меряется в один поток, построение индексов — на всех ядрах (10 ядер VM Docker на Mac, arm64).

Алгоритмы — свои, на Go, без СУБД: короткий код, который можно прочитать, с ручками наружу. Чтобы «свои» не значило «неправильные», каждая реализация сверена с Faiss на тех же параметрах, а граф — ещё и с jvector на Java (раздел сверка). Готовую Go-библиотеку HNSW (coder/hnsw) пришлось отбросить на пробе: на 20 тыс. векторов её recall@10 держался около 0,17 и не рос с шириной поиска.

Точный перебор

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

$ python3 scripts/run-brute.py all
{"variant": "control", "outcome": "match", "detail": "выдача совпала с истиной на 200 запросах из 200"}
{"variant": "scaling", "outcome": "match", "detail": "1212 мкс на 10 тыс. документов … 63 мс на 522931; 120.24 мкс на тысячу документов (медиана)"}
документов время на запрос, мс (p50) расстояний на запрос
10 000 1,2 10 000
50 000 6,1 50 000
100 000 12,0 100 000
250 000 30,1 250 000
522 931 62,8 522 931

Время растёт строго линейно — около 120 мкс на тысячу документов, и на полном корпусе это 63 мс на запрос в один поток. Меньше двадцати запросов в секунду на ядро — потолок этой реализации: скалярный цикл на Go, один запрос за раз. Векторные инструкции и пакетная обработка (матрица запросов на матрицу корпуса через BLAS, как делает Faiss в точном поиске) сдвигают его в разы, но рост остаётся линейным: каждый запрос по-прежнему сравнивается с каждым документом. Индекс устроен иначе: он сокращает саму работу — число сравнений, — сохраняя выбранный recall.

Подвох, найденный на пробе. Пока истина считала скалярное произведение одним циклом, а перебор стенда — развёрнутым на четыре суммы, выдачи совпадали не всегда: на FiQA (57 тыс. документов) — на 191 запросе из 200. Порядок сложения float32 меняет последние биты, и соседи с почти равным скором меняются местами на границе десятки. То же давало расстояние 1 − dot вместо −dot: вычитание из единицы съедает точность. Теперь у истины и у стенда одна и та же функция и −dot. Если вы сравниваете свой индекс с «точным» поиском другой системы, часть потерь recall может оказаться не потерей, а округлением.

HNSW: граф с этажами

HNSW (Hierarchical Navigable Small World, Malkov и Yashunin) — граф соседства в несколько слоёв. На нижнем слое все векторы, каждый связан с ближайшими. Каждый следующий слой — случайная примерно 1/M-я часть предыдущего, и связи там длиннее. Поиск начинается с единственной точки входа на верхнем слое, жадно идёт к запросу, спускается на слой ниже и так до нижнего, где обходит граф с очередью ширины ef.

flowchart TB E[точка входа, верхний слой] -->|жадно к запросу| L2[слой 2: длинные рёбра] L2 -->|спуск в ближайший узел| L1[слой 1] L1 -->|спуск| L0[слой 0: все векторы, по 2·M связей] L0 -->|обход с очередью ef| R[top-10]

flowchart TB
    E[точка входа, верхний слой] -->|жадно к запросу| L2[слой 2: длинные рёбра]
    L2 -->|спуск в ближайший узел| L1[слой 1]
    L1 -->|спуск| L0[слой 0: все векторы, по 2·M связей]
    L0 -->|обход с очередью ef| R[top-10]
Поиск в HNSW: жадный спуск по редким верхним слоям и обход с очередью ширины ef на нижнем

У графа с M = 16 на этом корпусе шесть слоёв: 522 931, 32 330, 1960, 140, 12 и 1 узел — каждый следующий примерно в 16 раз меньше.

Три ручки:

  • M — сколько связей у узла (на нижнем слое — 2·M). Больше M — граф плотнее, recall выше, построение дольше, памяти больше.
  • ef_construction — ширина поиска соседей при вставке узла. Влияет на качество графа и время построения, но не на поиск.
  • ef_search (дальше — ef) — ширина обхода при запросе. Главная ручка recall ↔ latency: её крутят в проде, не перестраивая индекс.

Соседей узла выбирает эвристика из оригинальной статьи: кандидат берётся, только если он ближе к узлу, чем к любому уже выбранному соседу. Так у узла остаются связи в разные стороны, а не десяток соседей из одного сгустка.

// go/hnsw/hnsw.go
func (g *Graph) selectNeighbors(cands []item, m int) []int32 {
	sort.Slice(cands, func(i, j int) bool { return cands[i].d < cands[j].d })
	out := make([]int32, 0, m)
	for _, c := range cands {
		if len(out) == m {
			break
		}
		ok := true
		for _, r := range out {
			if g.Dist(g.vecs[c.id], g.vecs[r]) < c.d {
				ok = false
				break
			}
		}
		if ok {
			out = append(out, c.id)
		}
	}
	return out
}

ef: главная ручка. M = 16, ef_construction = 200:

ef ANN recall@10 p50, мкс p99, мкс расстояний на запрос
10 0,887 180 354 381
20 0,945 255 596 557
40 0,972 374 598 884
80 0,983 613 937 1508
160 0,991 1320 4289 2678
400 0,997 2598 4299 5909

Уже при ef = 40 найдено 97% настоящих соседей за 0,4 мс — против 63 мс у перебора, при 884 вычисленном расстоянии вместо 522 931. Дальше каждый следующий процент recall стоит всё дороже: от ef = 40 до ef = 400 работа растёт в шесть с лишним раз, а recall — на 2,5 пункта.

M и ef_construction. Все четыре графа при одном и том же ef = 40:

граф построение, с связи, МБ ANN recall@10 при ef = 40 p50 при ef = 40, мкс recall 0,95 — с ef недостижимых узлов
M = 8, ef_construction = 200 132 31 0,940 297 80 387
M = 16, ef_construction = 200 182 49 0,972 374 40 26
M = 32, ef_construction = 200 215 66 0,984 520 20 1
M = 16, ef_construction = 100 84 41 0,953 317 40 34

M растит recall при том же ef и время построения. ef_construction = 100 строит граф вдвое с лишним быстрее, чем 200, и теряет около двух пунктов recall — это цена, которую платит каждый запрос, пока индекс не перестроят.

Память графа. Связи M = 16 занимают 49 МБ — это 4 байта на ребро, — а сами векторы 766 МБ. Граф HNSW прибавляет к векторам проценты, а не разы: память HNSW — это прежде всего векторы в RAM, поэтому разговор о памяти неизбежно приводит к квантизации. В Go-реализации к этому добавляются заголовки срезов (по срезу на слой каждого узла), и рост кучи после построения — 121 МБ, больше самих связей: накладные расходы структуры тоже память индекса.

Недостижимые узлы. Контроль «при ef ≥ N поиск точный» для HNSW неверен. Эвристика выбора соседей и обрезка переполненных списков могут оставить узел без единого входящего ребра на нижнем слое — до него поиск не дойдёт ни при каком ef. Стенд считает такие узлы обходом графа от точки входа: при M = 8 их 387, при M = 16 — 26, при M = 32 — 1. Тест стенда проверяет и обратное: при ef = N поиск находит всех соседей, кроме недостижимых. Для 523 тыс. документов 26 недостижимых — мелочь, но это документы, которых не найдёт ни один запрос, и их число растёт с удалениями и обновлениями (об этом — в статье серии про фильтрацию и консистентностьготовится, с 10 декабря).

Детали реализации решают при малом ef. На пробе своя HNSW отставала от Faiss при ef = 10 (0,596 против 0,648 на FiQA). Нашлись два отличия. Новому узлу на нижнем слое давалось M соседей, а не 2·M — так делает hnswlib, а Faiss и pgvector дают 2·M. И узлы вставлялись в порядке номеров, а Faiss вставляет от высоких уровней к низким: сначала строится редкий верх графа. Обе правки подтянули recall при малом ef; оставшаяся разница — в сверке. Вывод для практики: «HNSW с M = 16» в двух разных системах — не одна и та же кривая recall, особенно в левой её части.

IVF: разбиение на ячейки

IVF (inverted file) режет пространство k-means на nlist ячеек. Каждый вектор кладётся в список своего ближайшего центроида. Запрос сравнивается со всеми центроидами, берёт nprobe ближайших и перебирает только их списки. Обучение центроидов — на выборке: здесь каждый десятый вектор корпуса, 20 итераций алгоритма Ллойда.

Контроль: nprobe = nlist просматривает весь корпус и обязан дать recall 1.

$ python3 scripts/run-ivf.py nlist723
{"variant": "control", "outcome": "match", "detail": "recall@10 1.0000, просмотрено 523654 векторов на запрос (корпус + 723 центроидов)"}
{"variant": "nlist723", "outcome": "match", "detail": "списки 7…2368 (медиана 691); recall@10 0.520 / 0.653 / 0.741 / 0.808 / 0.866 / 0.909 / 0.947 / 0.972 при nprobe 1/2/4/8/16/32/64/128"}

Две ручки: nlist (на этапе построения) и nprobe (на запросе). Классическая отправная точка — nlist ≈ √N, то есть 723; рядом — 4√N = 2892:

nprobe nlist 723: ANN recall@10 векторов на запрос nlist 2892: ANN recall@10 векторов на запрос
1 0,520 1591 0,473 3180
2 0,653 2458 0,603 3447
4 0,741 4152 0,702 3979
8 0,808 7467 0,776 4977
16 0,866 14 000 0,829 6884
32 0,909 26 846 0,878 10 631
64 0,947 52 294 0,911 17 886
128 0,972 102 165 0,939 32 011
256 — — 0,965 59 549

У nprobe та же природа, что у ef, но цена другая. Recall 0,9 при nlist = 723 стоит nprobe = 32 и 26 846 векторов на запрос, при nlist = 2892 — nprobe = 64 и 17 886: мелкие ячейки точнее отсекают лишнее. Зато при малом nprobe у мелкого разбиения дорог сам выбор ячейки: 2892 центроида надо сравнить с запросом всегда. И главное сравнение — с HNSW: recall 0,97 у IVF-Flat при nlist = 723 стоит 37 мс на запрос, у HNSW — 0,4 мс. IVF выигрывает не скоростью, а другим: простое построение, предсказуемая память, естественное сочетание со сжатием (IVF-PQ) и с хранением на диске.

Нерепрезентативное обучение. Центроиды обучаются один раз, на выборке. Если выборка не похожа на данные — например, индекс обучили на первой партии документов одной темы, а потом залили всё остальное, — ячейки ложатся не туда. Опыт стенда: обучение на 10% корпуса, ближайших к одному случайному документу.

обучение центроидов самый короткий список медиана самый длинный ANN recall@10 при nprobe = 1 векторов на запрос при nprobe = 8
каждый 10-й вектор 7 691 2368 0,520 7467
10% корпуса вокруг одного документа 1 363 17 246 0,426 16 731

Самый длинный список вырос до 17 246 векторов — перекос max/медиана в 14 раз больше, чем у обучения на равномерной выборке. При nprobe = 1 recall упал с 0,520 до 0,426, а при каждом nprobe просмотр дороже: запросы, попавшие в раздутую ячейку, перебирают её целиком. В pgvector это объясняет рекомендацию строить IVFFlat после загрузки данных, а не на пустой таблице.

Квантизация: SQ8 и PQ

Векторы float32 — 1536 байт на документ, 766 МБ на корпус. Квантизация хранит вместо них компактные коды:

  • SQ8 (скалярная): по каждой координате свой диапазон [min, max] делится на 256 уровней, координата — один байт. Сжатие в 4 раза.
  • PQ (product quantization, Jégou и соавторы): вектор режется на m подвекторов, для каждого подпространства k-means обучает 256 центроидов, и подвектор заменяется номером ближайшего — одним байтом. m = 48 — по 8 координат на подвектор, сжатие в 32 раза; m = 96 — по 4, в 16 раз.

Поиск по кодам PQ — асимметричный (ADC): запрос не квантуется. Для него один раз строится таблица m × 256 скалярных произведений его подвекторов с центроидами, а скор каждого кода — сумма m чисел из таблицы:

// go/quant/quant.go
func (p *PQ) Search(query []float32, k, r int, data [][]float32, exact bool) []int32 {
	table := make([]float32, p.M*256)
	for s := 0; s < p.M; s++ {
		qs := query[s*p.Sub : (s+1)*p.Sub]
		for c, cv := range p.Codebooks[s] {
			table[s*256+c] = vec.Dot(qs, cv)
		}
	}
	n := len(p.Codes) / p.M
	cs := topR(n, func(i int) float32 {
		var s float32
		for j, c := range p.Codes[i*p.M : (i+1)*p.M] {
			s += table[j*256+int(c)]
		}
		return s
	}, max(r, k))
	return rescore(query, cs, k, data, exact)
}

Пересчёт (rescoring). Коды дают приближённый скор. Если взять по нему не 10, а r лучших кандидатов и пересчитать их по исходным векторам, ошибка квантизации почти исчезает — при условии, что исходные векторы где-то есть (на диске, в другом хранилище).

$ python3 scripts/run-quant.py pq48
{"variant": "pq48", "outcome": "match", "detail": "коды 23.9 МБ (сжатие в 32 раза); recall@10 0.507 без пересчёта, 0.889 / 0.989 с пересчётом 100 / 1000"}
способ коды, МБ сжатие ANN recall@10 без пересчёта пересчёт 100 пересчёт 1000 p50 с пересчётом 1000, мс
SQ8 191,5 в 4 раза 0,988 1,000 1,000 64,2
PQ, m = 48 23,9 в 32 раза 0,507 0,889 0,989 10,0
PQ, m = 96 47,9 в 16 раз 0,724 0,996 1,000 22,1

SQ8 почти ничего не теряет и без пересчёта. PQ при m = 48 без пересчёта теряет около половины соседей — сжатие в 32 раза не бесплатно; пересчёт 1000 кандидатов возвращает recall 0,989. Гипотеза стенда до прогона была строже — «теряет больше половины» — и не устояла на 0,007: порог был взят с пробы на FiQA, где PQ давал 0,27. Faiss на тех же параметрах дал 0,499 — дело не в реализации, а в корпусе. Это записано в expected.json стенда как ревизия гипотезы.

Время здесь — плоский перебор кодов в один поток без SIMD, поэтому SQ8 почти не быстрее перебора float32: выигрыш квантизации — память, а не скорость сканирования. В движках коды сочетают с графом или IVF (HNSW по SQ8-векторам, IVF-PQ), и тогда сжатие оплачивает размещение индекса в RAM.

Метрика расстояния

Модели эмбеддингов обучают под конкретную метрику, и движки спрашивают её при создании индекса: cosine, L2 или скалярное произведение (dot). Для нормированных векторов это одно и то же: L2² = 2 − 2·dot, а cosine = dot. Стенд проверяет это на 100 тыс. документов и 200 запросах — и повторяет на тех же векторах, умноженных на случайную длину от 0,5 до 2:

векторы cosine и L2: общих в top-10 cosine и dot: общих в top-10
нормированные 1,000 1,000
длина от 0,5 до 2 0,316 0,111

На нормированных векторах выдачи совпали полностью. На ненормированных cosine и dot делят в среднем один документ из десяти: dot предпочитает длинные векторы, а длина здесь — шум. Практический вывод: нормированы ли векторы, которые отдаёт ваша модель, — надо проверить, а не предположить, и указать индексу ту метрику, под которую модель обучена. Если модель обучена под косинус (как e5), нормировка при записи делает cosine, dot и L2 равнозначными, а dot — самым дешёвым. Если же модель или задача — поиск по максимальному скалярному произведению (MIPS), где длина вектора несёт сигнал (популярность, уверенность), нормировка этот сигнал стирает: выбор метрики — решение о модели, а не только об индексе.

Сверка с Faiss и jvector

Свои реализации прогнаны на тех же данных и параметрах в Faiss 1.10.0:

алгоритм точка своя реализация Faiss
HNSW, M = 16, ef_construction = 200 ef 10 0,887 0,910
HNSW, M = 16, ef_construction = 200 ef 40 0,972 0,981
HNSW, M = 16, ef_construction = 200 ef 160 0,991 0,993
IVF-Flat, nlist = 723 nprobe 1 0,520 0,511
IVF-Flat, nlist = 723 nprobe 8 0,808 0,808
IVF-Flat, nlist = 723 nprobe 64 0,947 0,948
PQ, m = 48 без пересчёта 0,507 0,499
PQ, m = 48 пересчёт 100 0,889 0,890
PQ, m = 48 пересчёт 1000 0,989 0,987
SQ8 без пересчёта 0,988 0,987
SQ8 пересчёт 100 1,000 1,000

IVF, PQ и SQ8 сходятся в пределах сотых. HNSW при ef = 10 отстаёт от Faiss на два пункта при почти том же числе вычисленных расстояний (381 против 388) — граф Faiss немного лучше; при ef = 160 разница — 0,002.

Вторая, независимая реализация графа — jvector на Java (граф в духе DiskANN/Vamana с иерархией, как у HNSW), M = 16, ширина при построении 200:

ширина обхода jvector: ANN recall@10 jvector: посещено узлов своя HNSW: ANN recall@10 своя HNSW: расстояний
10 0,854 278 0,887 381
20 0,916 387 0,945 557
40 0,955 591 0,972 884
80 0,974 974 0,983 1508
160 0,986 1696 0,991 2678
400 0,991 3711 0,997 5909

Кривая той же формы и в той же области. У jvector свой счётчик работы — посещённые узлы, он не равен числу расстояний, поэтому сравнивать стоит форму кривых, а не столбцы поштучно.

Компромисс recall ↔ latency ↔ RAM

Сводка по корпусу: для каждого способа — первая точка, где recall@10 не ниже 0,95, время на запрос и память индекса (без учёта исходных векторов там, где они нужны только для пересчёта).

способ параметры ANN recall@10 p50, мс память индекса, МБ
точный перебор — 1,000 62,8 766
HNSW, M = 8 ef = 80 0,964 0,4 797
HNSW, M = 16 ef = 40 0,972 0,4 815
HNSW, M = 32 ef = 20 0,966 0,3 832
IVF-Flat nlist = 723, nprobe = 128 0,972 37,1 769
IVF-Flat nlist = 2892, nprobe = 256 0,965 26,3 772
SQ8, перебор кодов без пересчёта 0,988 63,0 192
PQ, m = 48, перебор кодов пересчёт 1000 0,989 10,0 24
PQ, m = 96, перебор кодов пересчёт 100 0,996 20,1 48

Три оси нельзя оптимизировать одновременно, и каждая ручка двигает все три:

  • ef, nprobe, r — меняются на лету, двигают recall и время, память не трогают. Их подбирают последними, под требуемый recall.
  • M, nlist, ef_construction — заданы при построении: время построения, память и потолок recall при данном бюджете времени. Ошибка здесь лечится только перестройкой.
  • Квантизация — покупает память за recall, а пересчёт возвращает recall за время и доступ к исходным векторам.

Порядок решения в проде обычно такой: зафиксировать требуемый recall (его мерят на своих данных против точного перебора, как здесь), затем бюджет памяти (влезают ли векторы float32 в RAM узла), и только потом latency — она подбирается ручками поиска.

Как повторить

cd vector-databases/dataset && python3 scripts/make-dataset.py
cd ../ann && bash scripts/run-all.sh

Сборка датасета — около 70 минут на 10 ядрах (почти всё время — эмбеддинги Quora и FiQA), полный прогон стенда — около 40 минут. Одна ось — python3 scripts/run-hnsw.py, один вариант без записи фикстуры — python3 scripts/run-hnsw.py m16-efc200. Гипотезы записаны в expected.json до прогона, вместе с пробами на FiQA, после которых менялся код. Фикстуры двух сессий (вторая — с пересборкой всех образов и бинарников) сравниваются сводками; recall параллельно построенного графа немного отличается от сессии к сессии, поэтому в сравнение идут исходы проверок, а не третий знак recall.

Что из этого выбирают за вас

  • pgvector — HNSW и IVFFlat внутри PostgreSQL: те же ручки (m, ef_construction, hnsw.ef_search, lists, ivfflat.probes) плюс halfvec и бинарная квантизация. Разбор — в статье pgvector вглубь.
  • Выделенные движки — HNSW как основной индекс, квантизация с пересчётом как опция, сегменты вместо одного графа. Сравнение на этом же корпусе — в статье Qdrant, Milvus, Weaviateготовится, с 24 ноября.
  • Фильтры по метаданным ломают и граф, и ячейки неочевидным образом — фильтрация и консистентностьготовится, с 10 декабря; точные термины, на которых промахивается любой вектор, — гибридный поискготовится, с 4 декабря.

Итог

  • Точный перебор линеен: 63 мс на запрос на 523 тыс. векторов в один поток. ANN снижает работу в сотни раз ценой нескольких процентов соседей.
  • HNSW даёт лучший recall на единицу времени; его память — прежде всего векторы, граф прибавляет проценты. Малый ef чувствителен к деталям реализации, а часть узлов графа может быть недостижима.
  • IVF проще и предсказуемее по памяти, но медленнее при высоком recall и зависит от того, на чём обучены центроиды.
  • Квантизация сжимает векторы в 4–32 раза; пересчёт по исходным возвращает recall. Метрика должна совпадать с той, под которую обучена модель, а на нормированных векторах выбор метрики перестаёт иметь значение.

Документация и первоисточники

Обсуждение в Telegram

Присоединиться →