Обзор модуляЧасть IV · ~10 ч · Сложность: (продвинутый) · Пререквизиты: Модуль 1, 8
До сих пор скор документа мы собирали «вручную»: считали BM25, добавляли вес якорей, авторитет ссылочного графа, складывали это линейно с подобранными коэффициентами. Такой подход не масштабируется: факторов (features) становятся сотни и тысячи (Модуль 8), их взаимодействия нелинейны, а «крутить веса руками» — медленно, субъективно и неустойчиво. Обучение ранжированию (learning-to-rank, LTR) заменяет ручную настройку обучаемой моделью: мы собираем размеченные данные «запрос → документы → насколько они релевантны», описываем каждую пару (запрос, документ) вектором факторов и обучаем модель f(x) так, чтобы её порядок выдачи совпадал с эталонным.
В сквозном конвейере «обход → индекс → факторы → ранжирование → выдача → постобработка → измерение» этот модуль — сердце стадии ранжирования. Он стоит ровно между Модулем 8 (где мы научились вычислять и хранить факторы) и Модулем 12 (где модель встраивается в каскад L0–L3 и должна укладываться в бюджет латентности). Обучаемая модель — это и есть «ранжировщик L2», который пересортировывает несколько сотен кандидатов, отобранных дешёвыми уровнями L0–L1.
Ключевая идея, которая отличает LTR от обычной регрессии/классификации: нас интересует относительный порядок, а не абсолютные значения. Пользователю всё равно, выдала ли модель документу скор 0.81 или 8.1 — важно, чтобы релевантный документ стоял выше нерелевантного. Поэтому весь модуль строится вокруг трёх постановок задачи (pointwise, pairwise, listwise), специальных функций потерь и прямой связи с метрикой качества nDCG из Модуля 1 (и офлайн-оценкой из Модуля 19).
После модуля вы сможете: формализовать ранжирование как задачу обучения в трёх постановках и выбрать подходящую; вывести функции потерь RankNet, LambdaRank и ListNet и объяснить, как LambdaRank «подмешивает» nDCG в градиент; понять, почему именно градиентный бустинг деревьев (GBDT/LambdaMART) — рабочая лошадка промышленного LTR; собрать нейросеть поверх факторов, откалибровать её скоры и объединить модели в ансамбль; и критически оценить источники обучающих данных — разметку асессоров против клик-разметки — с учётом их смещений.
Как читать по трекамИнтуиция. LTR — это «не угадать оценку документа, а правильно его поставить в очередь». Метрики качества смотрят на верхушку списка, значит, и учить надо порядок верхушки, а не точное число для каждого документа по отдельности.
- Студент CS — обязательно всё. Ядро — главы 9.1 (постановки и loss-функции) и 9.2 (GBDT/LambdaMART). Прорешайте лабу по RankNet/LambdaRank руками: вывод градиента — главный навык модуля.
- Инженер поиска/ML — обязательно всё, особенно инженерные заметки про инференс деревьев в рантайме (9.2), калибровку и ансамбли (9.3), а также смещения клик-разметки (9.4) — это определяет, что вы вообще можете обучить.
- SEO-специалист — обязательно SEO-врезки и глава 9.4 (что попадает в обучающие данные, как поведение пользователей становится сигналом). Математику loss-функций — обзорно.
- Смешанный/руководитель — Обзор, интуиции, заблуждения, итоги. Главное: чем pairwise/listwise лучше pointwise, почему GBDT доминирует и почему клик-данные смещены.
- 9.1. Постановки pointwise/pairwise/listwise; функции потерь (RankNet, LambdaRank/LambdaMART, ListNet) (продвинутый)
- 9.2. Градиентный бустинг деревьев (GBDT) для ранжирования (продвинутый)
- 9.3. Нейросеть поверх факторов; калибровка скоров; ансамбли и комбинирование (продвинутый)
- 9.4. Сбор обучающих данных: разметка асессоров vs клик-разметка, смещения (средний)
Цели обучения
После главы студент сможет:
- Сформулировать задачу LTR: что такое обучающий пример, метка, группировка по запросу.
- Различать три постановки — pointwise, pairwise, listwise — и объяснить их компромиссы.
- Вывести функцию потерь RankNet и её градиент через вероятность «i выше j».
- Объяснить, как LambdaRank умножает градиент RankNet на |ΔnDCG| и почему это напрямую оптимизирует метрику.
- Сравнить ListNet (распределение перестановок / top-1 вероятность) с pairwise-подходом.
- Связать функции потерь с метрикой nDCG из Модуля 1.
Что такое обучающий пример в LTR
В обычном обучении с учителем пример — это пара (x, y): вектор признаков и метка. В LTR пример устроен иначе, потому что релевантность определена относительно запроса.
Обучающая выборка — это набор групп (query groups). Одна группа = один запрос q и список документов-кандидатов к нему:
Код: Выделить всё
группа q: (x_q1, rel_q1), (x_q2, rel_q2), ..., (x_qn, rel_qn)
- x_qi — вектор факторов пары (q, d_i): bm25_title, bm25_body, proximity, pagerank, host_authority, freshness, click_rate и т.д. (Модуль 8). Обычно сотни–тысячи чисел.
- rel_qi — метка релевантности, чаще всего градуированная: rel ∈ {0,1,2,3,4} (от «нерелевантно» до «идеальный ответ»), как в nDCG (Модуль 1).
Цель — обучить f(x) → ℝ, скалярную скоринг-функцию. На инференсе для нового запроса мы вычисляем f для всех кандидатов и сортируем по убыванию f. Качество порядка меряем nDCG@k / MAP / MRR (Модуль 1).Внимание. Группировка по запросу — не деталь, а суть. Документ с bm25=10 для редкого запроса и для частотного — разные ситуации. Сравнивать скоры можно только внутри одной группы. Любая корректная LTR-метрика и loss считаются внутри группы, потом усредняются по запросам.
Три постановки задачи
Разница между постановками — в том, на каком объекте определена функция потерь.
Код: Выделить всё
Постановка | Объект loss | Что моделируем | Метка | Плюсы | Минусы
------------+-------------------+------------------------------+--------------------------+----------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------
Pointwise | один документ | абсолютный скор/класс | rel_i как число/класс | просто, любые регрессоры/классификаторы | игнорирует, что важен порядок, а не значение; одинаково штрафует ошибки вверху и внизу списка
Pairwise | пара документов | какой из двух выше | знак rel_i − rel_j | учится относительному порядку; естественно ложится на градиентные методы | все инверсии равноценны, хотя ошибка в топе дороже
Listwise | весь список | правильный порядок целиком | весь вектор rel группы | напрямую целится в метрику списка (nDCG) | сложнее математически и вычислительно
Сводим ранжирование к регрессии (f(x)≈rel) или классификации (предсказать класс релевантности). Loss — обычный MSE или кросс-энтропия.
##### PairwiseИнтуиция. Pointwise говорит: «научись угадывать оценку каждого документа, а порядок получится сам». Проблема: модель тратит ёмкость на точное предсказание разницы между rel=0 и rel=1 где-то в хвосте, хотя для nDCG@10 это вообще не важно. И наоборот — путаница rel=4 и rel=3 на первой позиции стоит дорого, а MSE этого не знает.
Берём все пары документов внутри группы, где rel_i > rel_j, и учим модель: «i должен быть выше j». Loss штрафует инверсии (неправильно упорядоченные пары). Это самая популярная база — на ней стоят RankNet, RankSVM, LambdaRank.
##### ListwiseИнтуиция. Pairwise не пытается угадать оценку — только знак сравнения. Это ровно то, что нужно для порядка. Минус базового pairwise: переставить пару на позициях 1–2 и на позициях 999–1000 — одинаковый «штраф за инверсию», хотя пользователю первая важна, а вторую он не увидит. Это лечит LambdaRank (ниже).
Loss определён на всём списке сразу: либо моделируем вероятность правильной перестановки (ListNet, ListMLE), либо прямо оптимизируем сглаженную метрику (SoftRank, и — по духу — LambdaRank/LambdaMART).
RankNet: вероятностный pairwiseЗаблуждение (забегая вперёд). «Listwise всегда лучше pairwise». На практике listwise-методы тяжелее и не всегда дают выигрыш, оправдывающий сложность. LambdaMART — формально pairwise по структуре градиента, но с listwise-взвешиванием ΔnDCG — оказался лучшим компромиссом и доминирует в индустрии.
RankNet — основа, из которой вырастают LambdaRank и LambdaMART. Идея: превратить «i выше j» в вероятность.
Пусть s_i = f(x_i), s_j = f(x_j) — скоры модели. Определим вероятность того, что документ i должен стоять выше j, через логистическую (сигмоидную) функцию от разницы скоров:
Код: Выделить всё
P_ij = P(i ▷ j) = 1 / (1 + e^(−σ·(s_i − s_j)))
Целевая вероятность P̄_ij из меток:
- P̄_ij = 1, если rel_i > rel_j (i действительно релевантнее);
- P̄_ij = 0, если rel_i < rel_j;
- P̄_ij = 0.5, если rel_i = rel_j.
Код: Выделить всё
L_ij = −P̄_ij·log(P_ij) − (1 − P̄_ij)·log(1 − P_ij)
Код: Выделить всё
L_ij = log(1 + e^(−σ·(s_i − s_j)))
##### Градиент RankNet (ключевой вывод)Интуиция. Это «мягкий» штраф за инверсию. Если s_i ≫ s_j (правильный сильный порядок) — L_ij ≈ 0. Если s_i = s_j — L_ij = log 2 ≈ 0.69. Если s_i ≪ s_j (грубая инверсия) — штраф растёт линейно по разнице. Это сглаженная, дифференцируемая версия «числа инверсий».
Производная по разнице скоров для пары (i ▷ j):
Код: Выделить всё
∂L_ij/∂s_i = −σ / (1 + e^(σ·(s_i − s_j))) = −σ · (1 − P_ij) ≜ −λ_ij
∂L_ij/∂s_j = +λ_ij (антисимметрично)
Код: Выделить всё
λ_ij = −σ / (1 + e^(σ·(s_i − s_j)))
Код: Выделить всё
λ_i = Σ_{j: (i,j)∈I} λ_ij − Σ_{j: (j,i)∈I} λ_ij
LambdaRank: подмешиваем nDCG в градиентИнтуиция (λ как физическая сила). Представьте, что каждый документ — шарик на вертикальной оси скоров. Между каждой неправильно (или слабо правильно) упорядоченной парой натянута пружинка: она тянет более релевантный документ вверх, менее релевантный — вниз. λ_i — равнодействующая всех пружинок на шарике i. Обучение = отпустить шарики двигаться вдоль этих сил.
Проблема RankNet: все инверсии равноценны. Но nDCG штрафует инверсии в топе гораздо сильнее (множитель 1/log2(i+1) быстро убывает). Гениальное наблюдение LambdaRank: метрики типа nDCG негладкие (это функция от порядка, она кусочно-постоянна — её производная почти везде нуль), но нам и не нужна её производная. Нам нужны градиенты λ, а их можно домножить на изменение метрики при перестановке пары.
Код: Выделить всё
λ_ij^{Lambda} = λ_ij^{RankNet} · |ΔnDCG_ij|
= (−σ / (1 + e^(σ·(s_i − s_j)))) · |ΔZ_ij|
Код: Выделить всё
|ΔnDCG_ij| = | (2^{rel_i} − 1) − (2^{rel_j} − 1) | · | 1/log2(1+pos_i) − 1/log2(1+pos_j) | / IDCG
Интуиция. Пружинка между парой теперь не одинаковой жёсткости, а тем сильнее, чем сильнее её правильная установка поднимет nDCG. Инверсия на позициях 1–2 даёт большой |ΔnDCG| → сильная пружинка. Инверсия на позициях 500–501 даёт |ΔnDCG|≈0 → пружинка почти не тянет. Так мы прямо оптимизируем метрику, не вычисляя её градиент (которого нет).
|ΔnDCG| можно заменить на |ΔMAP|, |ΔMRR|, |ΔERR| — получим оптимизацию под нужную метрику. Это делает LambdaRank метрико-ориентированным.Внимание. LambdaRank определяется через градиенты, а не через явный loss. Существует функция, чьим градиентом являются эти λ (можно показать эмпирически), но на практике её и не выписывают — задают сразу λ_i, и этого хватает для градиентного обучения. Это и есть «трюк лямбд».
LambdaMART: LambdaRank + градиентный бустинг деревьев
LambdaMART = LambdaRank-градиенты (λ_i), поданные в MART (Multiple Additive Regression Trees = GBDT). Вместо нейросети f собирается из ансамбля решающих деревьев, а на каждой итерации бустинга деревья обучаются предсказывать λ_i (псевдо-остатки). Детали GBDT — в главе 9.2; здесь важно: LambdaMART годами держит первые места на бенчмарках LTR и в проде, потому что объединяет лучшую loss-логику (lambda+nDCG) с лучшим табличным регрессором (GBDT).
ListNet: листвайз через вероятности перестановок
ListNet идёт по-другому: моделирует распределение вероятностей на перестановках списка. Полная вероятность всех n! перестановок неподъёмна, поэтому используют top-1 вероятность: вероятность того, что документ i стоит первым, через softmax скоров:
Код: Выделить всё
P_top1(i) = e^{s_i} / Σ_k e^{s_k}
Код: Выделить всё
L = − Σ_i P̄_top1(i) · log P_top1(i)
Сводная таблица loss-функцийИнтуиция. ListNet говорит: «распределение вероятностей быть первым по нашим скорам должно совпадать с распределением по истинным оценкам». Это честно листвайз (loss смотрит на весь список через softmax), но top-1 приближение теряет информацию о порядке ниже первой позиции, поэтому не всегда бьёт LambdaMART.
Код: Выделить всё
Метод | Постановка | Loss / градиент | Учитывает позицию? | Где живёт
---------------+---------------------+-----------------------------+----------------------+-------------------------+------+------------------
MSE-регрессия | pointwise | (f(x)−rel)² | нет | базлайн
RankNet | pairwise | кросс-энтропия от s_i−s_j | нет | основа теории
LambdaRank | pairwise+listwise | λ_ij· | ΔnDCG | | да | нейросетевой LTR
LambdaMART | pairwise+listwise | те же λ, бустинг деревьев | да | промышленный стандарт
ListNet | listwise | КЭ top-1 softmax | частично | альтернатива
Заблуждение. «LTR — это просто регрессия скора релевантности». Это лишь pointwise — самый слабый вариант. Он оптимизирует не ту цель: точное значение метки вместо порядка верхушки. Pairwise/listwise учатся именно порядку и почти всегда лучше на nDCG.
Заблуждение. «Раз nDCG негладкая, её нельзя оптимизировать градиентами». Можно — обходным путём. LambdaRank не дифференцирует метрику, а взвешивает pairwise-градиенты на |ΔnDCG|. Так негладкая метрика входит в обучение через множитель, а не через производную.
Лаба / практикаЗаблуждение. «Больше пар в обучении — всегда лучше». Число пар внутри группы растёт квадратично; пары двух нерелевантных документов (rel=0 vs rel=0) бесполезны и шумят. На практике пары фильтруют/сэмплируют и взвешивают по |ΔnDCG|.
Задача: руками посчитать loss и λ-градиенты для одной группы. Время ~50 мин.
Дан запрос с 3 документами, текущие скоры модели s и метки rel:
Код: Выделить всё
Док | s | rel | Текущая позиция (по s)
-----+-------+-------+------------------------
A | 0.5 | 3 | 2
B | 0.8 | 1 | 1
C | 0.2 | 0 | 3
- Перечислите все «правильные» пары (i ▷ j) с rel_i > rel_j: (A▷B), (A▷C), (B▷C).
- Для каждой посчитайте RankNet-loss L_ij = log(1 + e^(−(s_i−s_j))) при σ=1.
- Посчитайте λ_ij = −1/(1+e^(s_i−s_j)) для каждой пары.
- Посчитайте IDCG@3 для меток [3,1,0] (идеальный порядок) и |ΔnDCG_ij| для перестановки каждой пары в текущем списке.
- Получите LambdaRank-силы λ_ij·|ΔnDCG_ij| и просуммируйте λ_i для каждого документа.
- Определите, куда «потянет» каждый документ (знак λ_i): должен ли A подняться над B?
Контрольные вопросы
- Чем обучающий пример в LTR отличается от примера в обычной регрессии? Что такое query group?
- Почему pointwise-подход плохо коррелирует с nDCG@10?
- Выведите градиент RankNet-loss по s_i для пары (i ▷ j). Что такое λ_ij?
- Объясните «физическую» интерпретацию λ_i через пружинки.
- Как LambdaRank вводит nDCG в обучение, не дифференцируя её? Что такое |ΔnDCG_ij|?
- Почему инверсия на позициях 1–2 даёт больший вклад, чем на позициях 500–501?
- Чем ListNet принципиально отличается от RankNet по объекту loss?
- Что такое LambdaMART и почему он считается промышленным стандартом?
Цели обучения
После главы студент сможет:
- Объяснить идею градиентного бустинга: аддитивный ансамбль слабых деревьев, обучаемых на остатках.
- Связать GBDT с LambdaMART: что именно предсказывают деревья на каждой итерации.
- Объяснить, почему деревья доминируют на табличных факторах (масштаб-инвариантность, нелинейность, монотонные ограничения).
- Перечислить ключевые гиперпараметры и риски переобучения.
- Спроектировать быстрый инференс ансамбля деревьев в рантайме (бюджет латентности, Модуль 12).
Почему именно деревья на факторах
Факторы ранжирования (Модуль 8) — это табличные данные: разнородные числа в разных масштабах (bm25∈[0,30], pagerank∈[0,1], длина_url∈[10,200], бинарные флаги). Решающие деревья почти идеальны для них:
- Масштаб-инвариантны. Дерево разбивает по порогу feature < t — ему не важны единицы измерения, нормировка не нужна (в отличие от нейросетей).
- Ловят нелинейности и взаимодействия автоматически: «если freshness высокая И запрос новостной — поднять».
- Устойчивы к выбросам и пропускам (пропуск = отдельная ветка).
- Интерпретируемы через важность факторов (feature importance), что критично для отладки и доверия.
Градиентный бустинг: механикаИнтуиция. Одно дерево — слабый ступенчатый предсказатель. Но если строить деревья последовательно, каждое исправляет ошибки предыдущих, сумма сотен мелких деревьев становится мощной гладкой функцией. Это и есть бустинг.
Модель — аддитивный ансамбль:
Код: Выделить всё
F_M(x) = Σ_{m=1..M} ν · h_m(x)
Алгоритм (на шаге m):
- Посчитать псевдо-остатки — отрицательный градиент loss по текущему предсказанию:
Код: Выделить всё
g_i = − ∂L / ∂F(x_i) при F = F_{m−1}
- Обучить дерево h_m регрессией на g_i (минимизируя MSE к остаткам).
- Подобрать значения в листьях (для деревьев — оптимальный шаг ньютона по второй производной).
- Обновить: F_m = F_{m−1} + ν·h_m.
Где тут LambdaMARTИнтуиция. На каждом шаге смотрим: где модель ещё ошибается (градиент) — и строим маленькое дерево, которое тянет предсказание в сторону уменьшения loss. Это градиентный спуск, но в пространстве функций, шагами-деревьями.
Связь с главой 9.1: в LambdaMART псевдо-остатки g_i — это и есть лямбды λ_i из LambdaRank.
Код: Выделить всё
g_i = λ_i = Σ_{j} λ_ij · |ΔnDCG_ij|
- Прогоняем текущий ансамбль, получаем скоры s_i = F_{m−1}(x_i).
- Внутри каждой группы сортируем по s_i, считаем позиции и |ΔnDCG_ij|.
- Считаем λ_i (силы из 9.1) — это псевдо-остатки.
- Обучаем дерево предсказывать λ_i.
- Для устойчивости листьев применяют Ньютоновский шаг — делят на сумму вторых производных (w_i), поэтому в реализациях хранят и λ_i, и w_i.
Ключевые гиперпараметрыИнтуиция. Каждое новое дерево учится: «куда и с какой силой надо двигать скоры документов, чтобы nDCG группы выросла». Метрика встроена в остатки — поэтому LambdaMART прямо оптимизирует ранжирование.
Код: Выделить всё
Гиперпараметр | Что делает | Риск перебора
------------------------+-----------------------------------------------+--------------------------------------------
num_trees (M) | ёмкость ансамбля | переобучение, рост латентности инференса
learning_rate (ν) | вклад каждого дерева | малый ν → точнее, но нужно больше деревьев
max_depth / num_leaves | сложность дерева, порядок взаимодействий | глубокие деревья → переобучение
min_data_in_leaf | минимум примеров в листе | регуляризация против шумных листьев
feature/row sampling | случайность (как в стохастическом бустинге) | снижает переобучение и коррелированность
L1/L2 на листьях | штраф на значения листьев | сглаживание
Внимание. В LTR гиперпараметры подбирают по nDCG@k на отложенной валидации, сгруппированной по запросам, а не по обучающему loss. Ранняя остановка (early stopping) по валидационному nDCG — обязательна (мост к Модулю 19).
Инференс деревьев в рантаймеИнженерная заметка (обучение). Современные реализации GBDT используют гистограммный поиск разбиений: непрерывные факторы биннингуются в ~256 корзин, дерево ищет порог по гистограмме градиентов — это ускоряет обучение на порядки и почти не теряет качество. Рост дерева бывает по уровням (level-wise) или по листьям (leaf-wise, агрессивнее и точнее, но легче переобучается). Категориальные факторы кодируют целевым/частотным энкодингом или нативной поддержкой.
Это центральная инженерная тема модуля: модель из тысяч деревьев должна отскорить сотни кандидатов за единицы миллисекунд на уровне L2 каскада (Модуль 12).
Стоимость наивного инференса:
Код: Выделить всё
T ≈ N_докум × M_деревьев × D_глубина (операций сравнения)
Приёмы ускорения:
- Скомпилированные/развёрнутые деревья. Вместо обхода узлов по указателям дерево разворачивают в плотный массив или в нативный код (кодогенерация: серия if-ов), чтобы максимально использовать предсказание переходов и кэш.
- Векторизация по документам (SIMD). Многие реализации (например, алгоритмы быстрого инференса ансамблей деревьев) меняют порядок циклов: вместо «документ → все деревья» делают «фактор → битовые маски листьев по всем деревьям», обрабатывая разбиения по факторам сразу для пачки деревьев с битовыми операциями. Это резко улучшает локальность кэша.
- Каскад/ранний выход. Деревья ансамбля упорядочены; после первых K деревьев документ с заведомо низким частичным скором отсеивается и не догоняется до конца (early-exit cascade). Топ-кандидаты досчитываются полностью.
- Квантизация порогов и факторов (фиксированная точка, int8/int16) — компактнее в кэше, быстрее сравнения.
- Снижение M. Дистилляция или прунинг: обучить большой ансамбль, затем сжать в меньший с близким качеством.
- Расположение в каскаде. Дорогую полную модель применяют только к top-K после дешёвых L0–L1; нижние уровни используют усечённую модель или линейную (Модуль 12).
Инженерная заметка (память и кэш). Главный враг — не арифметика, а промахи кэша при случайном обходе узлов. Поэтому дерево хранят в layout, дружественном к кэшу (узлы уровня рядом), а факторы документа держат в плотном массиве. Битовые/SIMD-схемы (алгоритмы быстрого инференса ансамблей деревьев) дают многократное ускорение именно за счёт предсказуемого доступа к памяти.
Инженерная заметка (онлайн vs офлайн факторы). Часть факторов (pagerank, host_authority) предвычислены и лежат в индексе (Модуль 8); часть (bm25, proximity) считается на лету под запрос. Инференс модели должен получить полный плотный вектор факторов с нулевой/дефолтной подстановкой для отсутствующих — деревья к пропускам устойчивы, но дефолт должен быть согласован между обучением и проддом, иначе будет train/serve skew.
Частые заблужденияSEO-врезка. «Веса факторов» в обучаемой модели — не фиксированные множители, а сотни нелинейных порогов, зависящих от типа запроса и контекста. Поэтому утверждения вида «фактор X весит 12%» бессмысленны: важность фактора (feature importance) — агрегат по тысячам деревьев, и для конкретного запроса вклад фактора может быть нулевым или решающим. Оптимизировать надо реальную пользу документа, отражённую во многих факторах сразу.
Заблуждение. «GBDT устарел, всё делают нейросетями». На табличных факторах ранжирования GBDT/LambdaMART до сих пор сильнейший или паритетный базлайн, дешевле в инференсе и проще в эксплуатации. Нейросети выигрывают там, где есть сырой текст/эмбеддинги (Модуль 10), а не голые скалярные факторы.
Заблуждение. «Чем больше деревьев, тем лучше». После некоторого M качество на валидации выходит на плато или падает (переобучение), а латентность инференса растёт линейно. M ограничен и бюджетом времени, и early stopping.
Лаба / практикаЗаблуждение. «Факторы для деревьев надо нормировать как для нейросети». Не надо — деревья масштаб-инвариантны. Лишняя нормировка бесполезна; важнее согласованность дефолтов для пропусков между train и serve.
Задача: собрать и профилировать LambdaMART. Время ~90 мин.
Дан публичный LTR-датасет в формате rel qid:Q f1:v1 f2:v2 ... (несколько сотен запросов, ~100 факторов).
- Разбейте на train/valid/test по запросам (qid не должен пересекаться между сплитами).
- Обучите GBDT в LambdaMART-режиме (objective = lambdarank, метрика = nDCG@10), с early stopping по валидации.
- Постройте кривую nDCG@10 от числа деревьев; найдите точку плато/переобучения.
- Выгрузите feature importance, объясните топ-5 факторов.
- Замерьте время инференса на 300 документах при M=500 и M=2000; постройте зависимость латентности от M.
- (Доп.) Включите ранний выход каскадом и сравните латентность при сохранении nDCG.
Контрольные вопросы
- Запишите аддитивную модель GBDT и опишите, что происходит на одной итерации бустинга.
- Что играет роль псевдо-остатков в LambdaMART? Почему именно λ_i?
- Почему деревья хороши для табличных факторов, а нормировка им не нужна?
- Перечислите 4 гиперпараметра GBDT и их влияние на переобучение/латентность.
- По какой метрике и на каком наборе делают early stopping в LTR?
- Оцените порядок числа операций инференса для N=200, M=1000, D=5. Какие приёмы его сокращают?
- Почему промахи кэша важнее арифметики при инференсе деревьев? Как с этим борются?
- Что такое train/serve skew в контексте дефолтных значений факторов?
Цели обучения
После главы студент сможет:
- Построить нейросеть-ранжировщик поверх скалярных факторов и обучить её LambdaRank-loss.
- Сравнить нейросеть и GBDT на табличных факторах, понять когда что уместно.
- Объяснить, что такое калибровка скоров и зачем она нужна, когда сам порядок уже хорош.
- Применить методы калибровки (Платт, изотоническая регрессия) и оценить её (reliability diagram, ECE).
- Скомбинировать модели в ансамбль (стекинг, каскад, смешивание) и объяснить выигрыш.
Нейросеть поверх факторов
Альтернатива деревьям — полносвязная сеть f(x) = MLP(x), обучаемая теми же LTR-loss (RankNet/LambdaRank/ListNet). Архитектура: вход — вектор факторов, 2–4 скрытых слоя, выход — один скаляр-скор. Обучение пакетами по группам: в батч кладут документы одного (или нескольких) запросов, считают pairwise/listwise loss внутри группы.
В отличие от деревьев, нейросеть требует:
- Нормировки факторов (стандартизация / квантильное преобразование) — иначе разный масштаб ломает обучение.
- Аккуратной обработки пропусков (импутация + флаг «было пропущено»).
- Регуляризации (dropout, weight decay) и подбора lr.
Интуиция. На голых скалярных факторах MLP редко выигрывает у GBDT и тяжелее в эксплуатации. Нейросети раскрываются, когда на вход идёт сырой сигнал: эмбеддинги текста запроса/документа, последовательности, разреженные признаки. Тогда сеть учит представление, недоступное деревьям (это уже мост к нейропоиску, Модуль 10). Частый промышленный паттерн — гибрид: GBDT по табличным факторам + нейросеть по тексту, объединённые в ансамбле.
Калибровка скоровИнженерная заметка. Нейросеть-ранжировщик дороже в инференсе матрично, но хорошо батчируется на GPU и допускает дистилляцию в маленькую сеть. На L2 каскада, где latency-бюджет жёсткий, чаще стоит GBDT, а нейросеть применяют выше (L2/L3 reranking малого top-K) или офлайн для генерации факторов.
Скор ранжировщика f(x) хорош для сортировки, но его абсолютное значение обычно не имеет смысла: pairwise/listwise loss инвариантны к монотонным преобразованиям скора (важен только порядок). Между тем многим потребителям нужна вероятностная интерпретация:
- порог «показывать/не показывать» документ или результат;
- решение «достаточно ли хорош топ, чтобы не звать дорогой источник» (федерация, Модуль 14);
- объединение скоров разных моделей/источников в один (нужна общая шкала);
- бизнес-логика: ожидаемая полезность, ставки в смешанной выдаче.
Методы:Интуиция. Калибровка не меняет порядок (преобразование монотонно → nDCG не страдает), она лишь «переразмечает» ось скоров в честные вероятности. Это разделение: ранжировщик отвечает за порядок, калибратор — за смысл числа.
- Платт-скейлинг (Platt scaling): обучаем логистическую регрессию P = σ(a·s + b) на отложенной выборке (s, rel∈{0,1}). Простой, параметрический, годится при сигмоидной форме ошибки.
- Изотоническая регрессия (isotonic regression): подбираем произвольную неубывающую ступенчатую функцию g, минимизируя ошибку калибровки. Гибче Платта, но требует больше данных и легче переобучается.
- Биннинг (histogram binning): разбить скоры на корзины, в каждой взять эмпирическую долю релевантных. Простейший непараметрический вариант.
- Диаграмма надёжности (reliability diagram): по оси X — предсказанная вероятность (по корзинам), по Y — наблюдаемая доля релевантных. Идеал — диагональ.
- ECE (Expected Calibration Error): средневзвешенное по корзинам отклонение |предсказано − наблюдаемо|.
Код: Выделить всё
ECE = Σ_b (n_b/N) · | acc(b) − conf(b) |
Внимание. Калибровка — это отдельная отложенная выборка, не та, на которой учился ранжировщик: иначе калибратор выучит переобученные скоры. И калибруют именно вероятность релевантности конкретной задачи (бинаризованную из градаций или CTR), а не «уверенность модели вообще».
Ансамбли и комбинированиеЗаблуждение. «Если модель хорошо ранжирует, она и хорошо калибрована». Нет. Высокий nDCG ничего не говорит о шкале: скоры могут быть сжаты в [0.49, 0.51] или раздуты — порядок верный, но вероятности врут. Калибровка решает именно это.
Несколько моделей почти всегда лучше одной — если их ошибки различны (декоррелированы). Способы объединения:
Код: Выделить всё
Способ | Идея | Когда
----------------------------------+-----------------------------------------------------------------+---------------------------------------
Усреднение/смешивание (blending) | взвешенная сумма скоров (после калибровки!) | быстрые однородные модели
Стекинг (stacking) | мета-модель учится на скорах базовых моделей как на факторах | разнородные модели (GBDT + нейросеть)
Каскад (cascade) | модели по уровням L0→L3, каждая сужает кандидатов (Модуль 12) | жёсткий бюджет латентности
Бэггинг | усреднение однотипных моделей на бутстрэп-выборках | снижение дисперсии
Интуиция. Смешивать сырые скоры разных моделей напрямую нельзя — они в разных шкалах. Сначала калибруем каждую в вероятность, потом смешиваем/стекаем. Поэтому калибровка — предпосылка комбинирования.
Инженерная заметка. Каскад — это и ансамбль, и способ уложиться в латентность: дешёвая модель отбирает top-K (recall важнее точности), дорогая пересортировывает top-K (точность важнее recall). Это прямое продолжение разговора об инференсе из 9.2 и тема Модуля 12 целиком. Метрики каскада: на ранних уровнях смотрят recall@K (не потеряли ли релевантное), на финальном — nDCG@k.
Частые заблужденияSEO-врезка. Финальная выдача — результат нескольких моделей и постправил (постранжирование — Модуль 16; блендинг вертикалей и группировка — Модули 14–15), а не одного «алгоритма». Отсюда нестабильность: один и тот же документ может прыгать по позициям из-за смены источника, калибровки, состава ансамбля и персонализации, а не из-за изменений на самой странице.
Заблуждение. «Калибровка улучшит ранжирование». Монотонная калибровка не меняет порядок → nDCG тот же. Она улучшает осмысленность абсолютных скоров (пороги, смешивание), а не качество сортировки.
Заблуждение. «Ансамбль из похожих моделей сильно поможет». Выигрыш ансамбля тем больше, чем некоррелированнее ошибки. Десять почти одинаковых GBDT дадут крохи; GBDT + нейросеть по тексту — много.
Лаба / практикаЗаблуждение. «Нейросеть всегда точнее на факторах». На голых скалярных факторах — обычно нет; нейросети нужны для сырого текста/эмбеддингов. Выбор модели — по типу сигнала и бюджету, а не по моде.
Задача: откалибровать ранжировщик и собрать ансамбль. Время ~75 мин.
- Возьмите обученный в лабе 9.2 GBDT. На отдельной выборке постройте reliability diagram сырых скоров (после сигмоиды) и посчитайте ECE.
- Откалибруйте Платтом и изотонической регрессией; перестройте диаграммы и ECE; убедитесь, что nDCG@10 не изменился (порядок сохранён).
- Обучите простую MLP-ранжировщик (LambdaRank-loss) на нормированных факторах; откалибруйте её.
- Смешайте калиброванные вероятности GBDT и MLP с весом α; найдите α, максимизирующий nDCG@10 на валидации; проверьте на test.
- Сравните корреляцию ошибок двух моделей и объясните величину выигрыша ансамбля.
Контрольные вопросы
- Почему абсолютное значение скора ранжировщика обычно бессмысленно, а порядок — нет?
- Что такое калибровка и почему она не меняет nDCG?
- Сравните Платт-скейлинг и изотоническую регрессию: гибкость, потребность в данных, риск переобучения.
- Что показывает reliability diagram и что измеряет ECE?
- Назовите 3 ситуации, где нужна именно вероятностная шкала, а не порядок.
- Чем стекинг отличается от блендинга? Почему перед смешиванием нужна калибровка?
- Когда нейросеть поверх факторов оправдана, а когда лучше GBDT?
- От чего зависит величина выигрыша ансамбля?
Цели обучения
После главы студент сможет:
- Сравнить два источника обучающих меток: экспертную разметку асессоров и клик-разметку.
- Объяснить ключевые смещения клик-данных: позиционное, презентационное, доверия, отбора.
- Описать идею устранения позиционного смещения (IPS / examination-модели, мост к клик-моделям Модуля 11).
- Оценить компромиссы: стоимость, масштаб, актуальность, шум, согласованность.
- Спроектировать разумный гибридный пайплайн сбора меток.
LTR-модель ровно настолько хороша, насколько хороши её метки. Откуда брать rel_i? Два источника, с противоположными свойствами.
Разметка асессоров (expert/editorial judgments)
Обученные оценщики по инструкции (guidelines) выставляют документам градуированную оценку rel∈{0..4} для пары (запрос, документ).
Плюсы:
- Высокое качество и согласованность (если инструкция хороша); измеряется через межоценочную согласованность (inter-annotator agreement, напр. каппа Коэна).
- Прямо даёт ту самую градуированную метку, которую любит nDCG.
- Нет поведенческих смещений — оценивается содержание, а не клики.
- Дорого и медленно — не покрыть миллионы запросов, особенно хвост.
- Запаздывает — для свежих/изменчивых запросов оценка устаревает.
- Субъективность интента: асессор может не знать, что искал реальный пользователь («ягуар» — животное, машина, ОС?).
- Покрывает в основном голову распределения запросов.
Клик-разметка (implicit feedback)Инженерная заметка. Пулинг (pooling): чтобы не размечать весь корпус, собирают кандидатов из топов нескольких систем и размечают только их. Это вносит смещение пула — документы, которых ни одна система не нашла, останутся неразмеченными (по умолчанию нерелевантны), что мешает оценивать новые модели, поднимающие ранее невидимое.
Метки выводятся из поведения пользователей в логах: клики, пропуски, время на странице (dwell time), возвраты к выдаче, реформулировки, последний клик в сессии. Сигнал бесплатный, огромный по объёму, актуальный и покрывает хвост.
Но клики — смещённый и шумный прокси релевантности. Главные смещения:
- Позиционное смещение (position bias). Верхние позиции кликают чаще просто потому, что они вверху, независимо от релевантности. Это сильнейшее смещение.
- Презентационное смещение (presentation bias). Привлекательный сниппет/заголовок/тип результата (картинка, видео) собирает клики помимо релевантности.
- Смещение доверия (trust bias). Пользователи доверяют верхним позициям и кликают их, считая «раз система поставила выше — релевантнее».
- Смещение отбора (selection bias). Мы видим клики только по показанному. Документ, который система никогда не показала, не получит клика — но не потому, что он плох. Это создаёт самоподтверждающуюся петлю: модель учит то, что сама же показывала.
- Шум. Случайные/ошибочные клики, боты, любопытство.
##### Устранение позиционного смещенияИнтуиция. Клик ≠ «релевантно». Клик = «релевантно ПЛЮС было показано высоко ПЛЮС сниппет завлёк». Чтобы вытащить из клика релевантность, надо вычесть позицию, презентацию и факт показа.
Модель examination: пользователь кликает документ d на позиции k, только если (а) рассмотрел позицию (examine) и (б) счёл документ релевантным:
Код: Выделить всё
P(click | d, k) = P(examine | k) · P(relevant | d)
IPS (Inverse Propensity Scoring) — переcвешивание примеров на 1/P(examine|k): клик на низкой позиции (где рассматривают редко) — сильный сигнал релевантности и получает большой вес; клик на позиции 1 — слабее, ведь там кликают и нерелевантное.
Код: Выделить всё
L_IPS = Σ_кликам (loss_i / P(examine | k_i))
Как оценивают propensity:Интуиция (IPS). «Кликнули документ, который еле кто разглядывал → он реально хорош, доверяем сильно. Кликнули верхнюю позицию → может, просто потому что верхняя, доверяем слабо». IPS делает оценку несмещённой при верных propensity, но дисперсия растёт (деление на малые вероятности) — propensity клипуют снизу.
- Рандомизация результатов (контролируемое перемешивание top-k в малой доле трафика) — золотой стандарт, но вредит UX, поэтому в малой дозе.
- Клик-модели (PBM, cascade, DBN — Модуль 11) — оценивают позиционные склонности из логов без вмешательства.
Сводное сравнениеВнимание (петля обратной связи). Если учить модель на кликах без дебиасинга, она усиливает то, что уже показывала вверху (selection + position bias) — rich-get-richer. Хорошие новые документы не получают шанса. Дебиасинг и доля рандомизированного/исследовательского трафика (exploration) разрывают петлю. Это связано с дилеммой explore/exploit и онлайн-экспериментами (Модуль 19).
Код: Выделить всё
Свойство | Асессоры | Клики
---------------------------+---------------------------------+------------------------------------
Качество отдельной метки | высокое | шумное, смещённое
Масштаб / покрытие хвоста | низкое | огромное
Стоимость | высокая | почти нулевая
Актуальность (свежесть) | запаздывает | в реальном времени
Знание реального интента | косвенное | прямое (агрегатно)
Главный риск | смещение пула, субъективность | позиционное/отбора смещение, петля
SEO-врезка. Поведенческие сигналы попадают в обучение агрегатно и с дебиасингом, а не «клик = ранжирование». Накрутка кликов малоэффективна и опасна: смещения вычитаются, аномалии ловятся антифродом (Модуль 16), а доминирует не клик сам по себе, а удовлетворённость (dwell time, отсутствие возврата и реформулировки). Делать «хорошо для пользователя» надёжнее, чем играть с кликами.
Частые заблужденияИнженерная заметка (гибрид). Промышленный пайплайн обычно комбинирует: асессоры дают чистый «золотой набор» для офлайн-оценки (nDCG, Модуль 19) и для калибровки/проверки; дебиасенные клики дают объёмные обучающие метки для головы и хвоста; рандомизированный трафик — propensity и борьбу с петлёй. Метки сверяют: расхождение асессоров и кликов — сигнал либо о смещении, либо о плохой инструкции.
Заблуждение. «Клик = релевантность, учим прямо на кликах». Без дебиасинга модель выучивает позиционное смещение и собственную прошлую выдачу (петля). Клики надо переcвешивать (IPS) или моделировать examination.
Заблуждение. «Асессорская разметка — объективная истина». Она ограничена инструкцией, субъективностью интента и смещением пула; для хвоста и свежих запросов часто неприменима. Это эталон для оценки, но не полный источник обучения.
Лаба / практикаЗаблуждение. «Больше данных решает всё». Больше смещённых данных лишь увереннее воспроизводит смещение. Качество и несмещённость меток важнее объёма.
Задача: показать позиционное смещение и исправить его IPS. Время ~60 мин.
- Симуляция: задайте «истинную» релевантность 10 документам и кривую склонности P(examine|k) (например, 1/k). Сгенерируйте клики по P(click)=P(examine|k)·P(rel).
- Обучите наивную pairwise-модель прямо на кликах (клик=1, показ-без-клика=0); оцените её ранжирование против истинной релевантности.
- Покажите, что модель воспроизводит исходный порядок показа (позиционное смещение), а не истинную релевантность.
- Примените IPS-перевзвешивание 1/P(examine|k) (с клиппингом) и переобучите; сравните с истинной релевантностью.
- (Доп.) Добавьте 5% рандомизированного трафика, оцените по нему propensity и сравните с заданными.
Контрольные вопросы
- Сравните асессорскую и клик-разметку по 4 осям (качество, масштаб, цена, актуальность).
- Перечислите четыре смещения клик-данных и объясните каждое одним предложением.
- Запишите examination-модель клика. Что такое propensity P(examine|k)?
- Как работает IPS и почему он делает оценку несмещённой? Какой ценой (дисперсия)?
- Что такое петля обратной связи (rich-get-richer) и чем её разрывают?
- Что такое смещение пула в асессорской разметке и чем оно опасно для оценки новых моделей?
- Почему dwell time / отсутствие возврата информативнее «голого» клика?
- Спроектируйте гибридный пайплайн меток: что берёте у асессоров, что из кликов, зачем рандомизация?
- LTR заменяет ручную настройку весов обучаемой моделью f(x); обучающий пример сгруппирован по запросу, метка — градуированная релевантность, цель — правильный порядок верхушки, измеряемый nDCG (Модуль 1).
- Три постановки: pointwise (регрессия скора, слабая), pairwise (учим знак сравнения, основа), listwise (целимся в метрику списка целиком).
- RankNet превращает «i выше j» в логистическую вероятность от s_i−s_j; его градиенты λ_ij интерпретируются как пружинки между парами.
- LambdaRank умножает λ_ij на |ΔnDCG_ij| — так негладкая метрика входит в обучение без дифференцирования; инверсии в топе давятся сильнее.
- LambdaMART = LambdaRank-лямбды как псевдо-остатки GBDT — промышленный стандарт LTR на табличных факторах.
- GBDT доминирует на факторах: масштаб-инвариантность, нелинейность, устойчивость к пропускам; ключ к проду — быстрый инференс деревьев (кэш-дружественный layout, SIMD/битовые схемы, ранний выход в каскаде, Модуль 12).
- Нейросеть поверх голых факторов редко бьёт GBDT — она для сырого текста/эмбеддингов (Модуль 10); гибрид GBDT+нейросеть в ансамбле — частый паттерн.
- Калибровка монотонно переводит скор в вероятность релевантности, не меняя порядок (nDCG тот же); она — предпосылка осмысленных порогов и комбинирования моделей.
- Метки решают всё: асессоры дают чистый, но дорогой и узкий «золотой набор»; клики дают объём и хвост, но смещены (позиция, презентация, доверие, отбор) и образуют петлю — лечится дебиасингом (IPS/examination, Модуль 11) и рандомизацией.
- Learning-to-rank (LTR) — обучение скоринговой функции f(x) так, чтобы её порядок выдачи совпадал с эталонной релевантностью.
- Query group (группа запроса) — список документов-кандидатов одного запроса с их факторами и метками; единица данных и подсчёта метрик в LTR.
- Pointwise / Pairwise / Listwise — постановки LTR с loss соответственно на одном документе / паре / всём списке.
- RankNet — pairwise-метод: вероятность «i выше j» через сигмоиду разницы скоров, кросс-энтропийный loss.
- λ_ij (лямбда) — pairwise-градиент-«сила», тянущая i вверх, j вниз.
- LambdaRank — λ_ij, домноженные на |ΔnDCG_ij|; метрико-ориентированное обучение без дифференцирования метрики.
- LambdaMART — LambdaRank-лямбды в роли псевдо-остатков градиентного бустинга деревьев (MART/GBDT).
- ListNet — listwise-метод через top-1 softmax-вероятности и кросс-энтропию с распределением меток.
- GBDT / MART — аддитивный ансамбль решающих деревьев, обучаемых на отрицательном градиенте loss.
- Псевдо-остатки — отрицательный градиент loss по предсказанию; цель обучения очередного дерева.
- Feature importance — агрегированный вклад фактора по всем деревьям ансамбля.
- Калибровка (calibration) — монотонное преобразование скора в вероятность релевантности; не меняет порядок.
- Платт-скейлинг / изотоническая регрессия — параметрический / непараметрический методы калибровки.
- ECE / reliability diagram — мера и график рассогласования предсказанной и наблюдаемой вероятности.
- Ансамбль (blending / stacking / cascade) — комбинирование моделей усреднением / мета-моделью / по уровням каскада.
- Разметка асессоров (editorial judgments) — экспертные градуированные метки релевантности по инструкции.
- Клик-разметка (implicit feedback) — метки из поведения пользователей в логах.
- Позиционное смещение (position bias) — рост кликов на верхних позициях независимо от релевантности.
- Смещение отбора / пула — видим клики только по показанному / размечаем только пул кандидатов.
- Propensity / examination-модель — вероятность рассмотреть позицию k; основа дебиасинга.
- IPS (inverse propensity scoring) — переcвешивание кликов на 1/P(examine|k) для несмещённого обучения.
- Петля обратной связи (feedback loop, rich-get-richer) — самоусиление прошлой выдачи при наивном обучении на кликах.
- Опирается на: Модуль 1 (метрики качества, особенно nDCG/DCG/IDCG, понятие градуированной релевантности, MAP/MRR); Модуль 8 (факторы ранжирования — вход модели, их вычисление и хранение, онлайн/офлайн признаки).
- Использует результаты: Модуль 6 (bm25_*, proximity, coverage как сильные факторы); Модуль 7 (ссылочные факторы — pagerank, авторитет).
- Питает дальше: Модуль 10 (нейропоиск — нейросети по сырому тексту/эмбеддингам как факторы и как самостоятельные ранжировщики, гибриды с GBDT); Модуль 11 (клик-модели — источник propensity и examination-вероятностей для дебиасинга); Модуль 12 (каскад L0–L3 — где и как инференсить модель в бюджете латентности, ранний выход); Модуль 16 (постранжирование и формирование выдачи поверх скоров).
- Тесно связан: Модуль 16 (антиспам/антифрод — накрутка кликов и манипуляции факторами); Модуль 19 (офлайн-оценка по nDCG на золотом наборе, подбор гиперпараметров, онлайн A/B и explore/exploit, ранняя остановка); Модуль 20 (прикладное SEO — почему «вес фактора» — миф, а поведение учитывается агрегатно и с дебиасингом).
- Обзорные работы по обучению ранжированию (taxonomy pointwise/pairwise/listwise, сравнительные исследования).
- Классические статьи по RankNet, LambdaRank и LambdaMART («from RankNet to LambdaRank to LambdaMART») — вывод λ-градиентов и связь с nDCG.
- Литература по листвайз-методам (ListNet, ListMLE, SoftRank) и прямой оптимизации метрик.
- Работы по градиентному бустингу деревьев и его масштабируемым реализациям (гистограммный поиск разбиений, leaf-wise рост).
- Исследования по быстрому инференсу ансамблей деревьев (алгоритмы быстрого инференса ансамблей деревьев, кэш-дружественные layout, каскады с ранним выходом).
- Литература по калибровке вероятностей (Платт-скейлинг, изотоническая регрессия, ECE, reliability diagrams).
- Работы по несмещённому LTR (unbiased learning-to-rank): IPS, оценка propensity, examination-модели, борьба с позиционным смещением и петлёй обратной связи (мост к клик-моделям).
- Методические материалы по разметке релевантности (guidelines, межоценочная согласованность, pooling) и их ограничениям.
