Градиентный бустинг изнутри

Зачем это нужно

В уроке 2.3.1 вы собрали бустинг из «пней» на остатках и узнали, что XGBoost, LightGBM и CatBoost — стандарт для таблиц. Чтобы вызвать fit, этого хватает. Но у LightGBM больше сотни параметров, и без понимания механики их подбирают наугад. Сегодня откроем капот: что делает дерево, когда мы предсказываем вероятность; откуда в XGBoost вторые производные и что значат reg_lambda и min_split_gain; как learning_rate, num_leaves и сабсэмплинг меняют качество — на числах; как не обмануться важностью признаков. Заодно встретим старого знакомого: p − y — градиент cross-entropy по логитам, как в каждой LLM (урок 1.3.2).

Градиентный спуск в пространстве функций

Напомним рецепт из урока 2.3.1: $F_0$ — константа, затем каждое новое дерево $h_m$ учится на остатках $y_i - F_{m-1}(x_i)$, и $F_m = F_{m-1} + \nu h_m$, где $\nu$ — темп обучения (shrinkage).

Теперь посмотрим на это глазами урока 1.4.1. Пусть в train $n$ примеров. Соберём предсказания модели на них в вектор $\mathbf{F} = (F(x_1), \dots, F(x_n))$ — это $n$ чисел, которые мы можем двигать. Функция потерь — обычная функция этого вектора: $\mathcal{L}(\mathbf{F}) = \sum_i L(y_i, F_i)$. Её градиент по $\mathbf{F}$ — вектор из $n$ чисел:

$$g_i = \frac{\partial L(y_i, F_i)}{\partial F_i}.$$

Читаем: «насколько вырастет потеря на примере $i$, если чуть-чуть увеличить предсказание для него». Шаг градиентного спуска был бы $F_i \leftarrow F_i - \nu g_i$. Но такой шаг определён только в $n$ точках train, а нам нужно предсказывать для любых новых $x$. Поэтому мы обучаем дерево приближать антиградиент $-g_i$ по признакам $x_i$ и делаем шаг деревом: оно обобщает «куда двигаться» на всё пространство признаков. Это и есть идея Фридмана (2001): градиентный бустингградиентный бустингEN gradient boosting (GBDT)Реализации — XGBoost, LightGBM, CatBoost. — градиентный спуск, где каждый шаг — новая функция.

Функция потерь $L(y, F)$	Антиградиент $-g$ — на что учится дерево
MSE: $\frac12 (y - F)^2$	остаток $y - F$
MAE: $\lvert y - F \rvert$	знак остатка: $+1$ или $-1$
log-loss (бинарная cross-entropy), $F$ — логит	$y - p$, где $p = \sigma(F)$

Для MSE остатки — это просто антиградиент; вот почему бустинг из урока 2.3.1 был градиентным. Для MAE дерево учится на знаках: каждый пример тянет с силой 1, и выброс не перетягивает модель (устойчивость MAE, урок 2.2.3).

Классификация: снова p − y

Для бинарной классификации бустинг предсказывает логит $F$, а вероятность получается сигмоидой $p = \sigma(F)$, как в логистической регрессии (урок 2.2.2). Функция потерь — бинарная cross-entropy, и её производная по логиту — та самая $p - y$ из уроков 1.3.2 и 2.2.2. Значит, дерево учится на $y - p$: «насколько вероятность не дотягивает до ответа».

На числах. Пример класса 1, текущий логит $F = 0$: $p = 0.5$, дерево получит цель $1 - 0.5 = 0.5$. Пример класса 0 с $F = 2$: $p = 0.881$, цель $-0.881$ — сильный толчок вниз, модель уверенно ошибается. Пример класса 1 с $F = -3$: $p = 0.047$, цель $0.953$. Для $K$ классов на каждом раунде строят $K$ деревьев, по одному на класс, и дерево класса $k$ учится на $y_k - p_k$ — градиенте softmax-cross-entropy.

Значения в листьях: шаг Ньютона

Дерево, обученное на антиградиент, задаёт структуру — какие примеры попадают в один лист. А значение листа можно выбрать точнее: то число $w$, которое сильнее всего уменьшает потерю на примерах этого листа. Для MSE это среднее остатков (как у обычного регрессионного дерева). Для log-loss точного ответа формулой нет, и берут один шаг метода Ньютонаметод НьютонаEN Newton's methodШаг оптимизации с учётом кривизны: приблизить функцию параболой g·w + ½·h·w² и прыгнуть в её минимум w = −g/h. В бустинге так считают значения листьев..

Идея Ньютона: градиентный спуск знает только наклон $g$ и не знает, насколько далеко идти. Если знать ещё кривизну — вторую производную $h$ — функцию можно приблизить параболой $g w + \frac12 h w^2$ и сразу прыгнуть в её минимум $w = -g / h$. Крутая парабола (большое $h$) — шаг короче, пологая — длиннее. Для log-loss $h_i = p_i (1 - p_i)$, и значение листа

$$w = \frac{\sum_{i \in \text{лист}} (y_i - p_i)}{\sum_{i \in \text{лист}} p_i (1 - p_i)}.$$

Читаем: «сумма антиградиентов, делённая на сумму кривизн». На числах. В лист попали 4 примера с метками $(1, 1, 1, 0)$, у всех пока $p = 0.5$ ($F = 0$). Числитель $0.5 + 0.5 + 0.5 - 0.5 = 1.0$, знаменатель $4 \cdot 0.25 = 1.0$, значение листа — 1.0. Идеальный ответ для этого листа — логит доли единиц $\ln \frac{3/4}{1/4} = \ln 3 \approx 1.10$: Ньютон за один шаг почти попал, а среднее остатков дало бы всего $1.0 / 4 = 0.25$. Так устроен GradientBoostingClassifier в scikit-learn, а XGBoost и LightGBM обобщают эту идею.

XGBoost: второй порядок и регуляризация

Тяньци Чэнь пошёл дальше и сделал вторые производные частью выбора разбиений. Цель на шаге $m$ — потеря плюс штраф за сложность нового дерева $f$ с $T$ листьями и весами листьев $w_j$:

$$\sum_i L\big(y_i, F_{m-1}(x_i) + f(x_i)\big) + \gamma T + \tfrac12 \lambda \sum_{j=1}^{T} w_j^2.$$

Первое слагаемое раскладывают в ряд Тейлора до второго порядка: $L(y_i, F + f) \approx L(y_i, F) + g_i f + \frac12 h_i f^2$ (та же парабола, что у Ньютона). Пусть $G_j$ и $H_j$ — суммы $g_i$ и $h_i$ по примерам листа $j$. Тогда для каждого листа задача — минимизировать параболу $G_j w + \frac12 (H_j + \lambda) w^2$, и её минимум

$$w_j^* = -\frac{G_j}{H_j + \lambda}.$$

Это шаг Ньютона, у которого знаменатель увеличен на $\lambda$: L2-штраф из урока 2.1.2 прижимает значения листов к нулю. Подставив $w^*$ обратно, получают формулу выигрыша от разбиения узла на левую и правую части:

$$\mathrm{Gain} = \frac12 \left[ \frac{G_L^2}{H_L + \lambda} + \frac{G_R^2}{H_R + \lambda} - \frac{(G_L + G_R)^2}{H_L + H_R + \lambda} \right] - \gamma.$$

Читаем: «насколько качество двух детей лучше качества родителя, минус плата $\gamma$ за лишний лист». Если выигрыш отрицательный, узел не делят.

На числах. Те же 4 примера с $p = 0.5$: для класса 1 $g = p - y = -0.5$, для класса 0 $g = 0.5$, у всех $h = 0.25$. В узле $G = -1.0$, $H = 1.0$. При $\lambda = 1$ вес листа $w^* = 1.0 / (1 + 1) = 0.5$ — вдвое меньше, чем без штрафа. Разобьём узел на $\{1, 1\}$ и $\{1, 0\}$: $G_L = -1.0$, $H_L = 0.5$, $G_R = 0$, $H_R = 0.5$.

$$\mathrm{Gain} = \tfrac12 \left[ \tfrac{1.0}{1.5} + 0 - \tfrac{1.0}{2.0} \right] - \gamma \approx 0.083 - \gamma.$$

При $\gamma = 0.1$ выигрыш отрицательный, и разбиение не делается: на четырёх примерах оно не стоит лишнего листа.

Так читаются параметры XGBoost: reg_lambda — это $\lambda$, gamma (в LightGBM min_split_gain) — это $\gamma$, min_child_weight — минимальная сумма $H$ в листе. Для MSE $h_i = 1$, и это просто минимальное число примеров. Посмотрите после этого раздела видео StatQuest «XGBoost Part 1: Regression» (26 минут, ссылка в источниках): тот же вывод выигрыша и роль $\lambda$ и $\gamma$ на четырёх точках, с картинками.

Гиперпараметры на числах

Возьмём синтетику Фридмана — классический тест для бустинга: $y = 10 \sin(\pi x_0 x_1) + 20 (x_2 - 0.5)^2 + 10 x_3 + 5 x_4$ плюс шум с $\sigma = 1$. Признаков 10, из них $x_5 \dots x_9$ — чистый шум. 2000 строк на обучение, 1000 на валидацию. Стандартное отклонение $y$ около 5, а ниже RMSE 1.0 не опуститься: это уровень шума. Все модели — LightGBM с ранней остановкой (терпение 100 деревьев) и, если в таблице не сказано иное, с num_leaves = 8 и learning_rate = 0.05, как в коде из практики.

learning_rate	Лучшее число деревьев	RMSE на валидации	Время, с
0.3	192	1.331	0.10
0.1	280	1.223	0.12
0.03	841	1.200	0.29
0.01	2178	1.213	0.88

Большой шаг быстро спускается и рано начинает переобучаться: после 192-го дерева ошибка на валидации растёт. Маленький шаг идёт дольше, но приходит ниже. Дальше 0.03 выигрыша почти нет (0.01 даже чуть хуже из-за шума валидации), а время растёт пропорционально числу деревьев. Практическое правило: learning_rate 0.03–0.1, число деревьев — ранней остановкой, никакого перебора n_estimators.

num_leaves	2	4	8	16	31	64	128
RMSE на валидации	1.786	1.181	1.200	1.239	1.289	1.362	1.368

Пни (num_leaves = 2) не могут выразить взаимодействие $x_0 x_1$: каждое дерево смотрит на один признак, и сумма пней — сумма функций от отдельных признаков. Уже 4 листа ловят взаимодействие. Дальше деревья переобучаются: на 2000 строк по умолчанию 31 лист — это много. num_leaves (или max_depth) — главный рычаг сложности, рядом с ним min_data_in_leaf (минимум примеров в листе, по умолчанию 20) и lambda_l2.

Сабсэмплинг — идея случайного леса внутри бустинга (Фридман назвал это стохастическим градиентным бустингом): каждое дерево видит случайную долю строк (bagging_fraction с bagging_freq = 1) и признаков (feature_fraction). Деревья становятся разнообразнее, переобучение — слабее:

Строк / признаков на дерево	100% / 100%	80% / 100%	80% / 80%	50% / 50%
RMSE на валидации (num_leaves = 8)	1.200	1.194	1.176	1.187

Выигрыш скромный, но бесплатный. Порядок настройки, который работает почти всегда: learning_rate = 0.05 и ранняя остановка → num_leaves и min_data_in_leaf → сабсэмплинг и lambda_l2 → в конце уменьшить learning_rate и снова найти число деревьев. Как перебирать комбинации честно — тема следующего урока.

XGBoost, LightGBM, CatBoost: чем отличаются

Гистограммы. Перебирать все пороги дорого: для каждого признака нужно отсортировать $n$ значений. LightGBM (а также XGBoost в режиме tree_method="hist", с версии 2.0 он выбран по умолчанию) один раз разбивает каждый признак на корзины — по умолчанию до 255 (в XGBoost — до 256) — и дальше перебирает только границы корзин, суммируя $g$ и $h$ по корзинам. Это гистограмма из урока 0.3.3, только вместо числа точек в корзине — суммы градиентов. Сколько корзин нужно:

max_bin	7	15	63	255
RMSE на валидации	1.641	1.310	1.198	1.200

С 63 корзин потери точности нет. Отличие вашего бустинга от LightGBM с пнями в задании ниже — тоже от гистограмм.

Рост по листьям. XGBoost по умолчанию растит дерево «по уровням»: делит все узлы текущей глубины. LightGBM растит по листьямрост дерева по листьямEN leaf-wise tree growthСтратегия LightGBM: каждый раз делить один лист с наибольшим выигрышем. Альтернатива — рост по уровням (XGBoost по умолчанию).: каждый раз делит один лист с наибольшим выигрышем, где бы он ни был.

flowchart LR
subgraph L1["По уровням (XGBoost): глубина 2 — 4 листа"]
  A1["корень"] --> B1["узел"]
  A1 --> C1["узел"]
  B1 --> D1["лист"]
  B1 --> E1["лист"]
  C1 --> F1["лист"]
  C1 --> G1["лист"]
end
subgraph L2["По листьям (LightGBM): 4 листа, делим самый выгодный"]
  A2["корень"] --> B2["узел"]
  A2 --> C2["лист"]
  B2 --> D2["узел"]
  B2 --> E2["лист"]
  D2 --> F2["лист"]
  D2 --> G2["лист"]
end

При том же числе листьев рост по листьям уходит глубже там, где это выгоднее

При одинаковом числе листьев рост по листьям обычно точнее, но легче переобучается на маленьких данных: поэтому у LightGBM главный параметр — num_leaves, а не глубина. Ещё два ускорения из статьи LightGBM: GOSS (в выборку для дерева берут все примеры с большими градиентами и случайную долю остальных) и EFB (склеивание взаимоисключающих разреженных признаков, например one-hot столбцов, в один).

	XGBoost	LightGBM	CatBoost
Авторы	Тяньци Чэнь (DMLC), 2014–2016	Microsoft Research Asia, 2017	Яндекс, 2017
Деревья	по уровням, режим hist	по листьям	симметричные: один вопрос на весь уровень
Особенность	регуляризованная цель второго порядка	гистограммы, GOSS, EFB — скорость	ordered boosting, категории «из коробки»
Пропуски NaN	для каждого разбиения учится, в какую ветку их слать	так же	по умолчанию считает пропуск меньше любого значения
Категориальные признаки	есть поддержка	есть поддержка	сильнейшая: ordered target statistics

Пропуски — приятная особенность всех трёх. XGBoost и LightGBM при обучении пробуют отправить строки с NaN и налево, и направо и запоминают лучшее направление; CatBoost по умолчанию ставит их левее всех значений. Заполнять пропуски для бустинга не обязательно. CatBoost, напомним из урока 2.3.1, борется с утечкой целевой переменной: target statistics для категорий и остатки для бустинга считаются только по «прошлым» примерам случайной перестановки — та же идея out-of-fold, что в target encoding из прошлого урока.

Важность признаков и SHAP

Когда модель обучена, первый вопрос заказчика: «на что она смотрит?». Обучим LightGBM на тех же данных (код — в практике) и сравним способы ответить.

важность признаковважность признаковEN feature importanceSplit — число разбиений по признаку, gain — суммарное уменьшение потери, permutation — рост ошибки на валидации при перемешивании признака. Описывает модель, а не причинность. бывает разной:

• split — сколько раз признак использовался в разбиениях;
• gain — насколько суммарно уменьшилась потеря от этих разбиений;
• перестановочная (permutation) — насколько вырастет ошибка на валидации, если перемешать значения признака и разрушить его связь с ответом.

Признак	$x_0$	$x_1$	$x_2$	$x_3$	$x_4$	$x_5 \dots x_9$ (шум)
split, разбиений	742	671	534	502	400	243–283
gain, доля	0.224	0.227	0.084	0.365	0.091	по 0.002
рост RMSE при перестановке	2.47	2.56	1.14	2.96	1.12	около 0

По числу разбиений шумные признаки выглядят лишь вдвое слабее полезного $x_4$: их можно делить сотни раз с крошечной пользой. По gain и перестановке видно правду. Вторая ловушка — коррелированные признаки: если добавить почти точную копию $x_3$, gain поделится между ними (0.204 и 0.163 вместо 0.365), и каждый будет выглядеть вдвое менее важным. Третья — важность описывает модель, а не мир: «модель опирается на признак» не значит «признак вызывает ответ».

SHAP: вклад признаков в один прогноз

Важность — одно число на признак для всей модели. А часто нужно объяснить конкретный прогноз: почему этому клиенту отказали? Ответ даёт теория игр. Представим, что признаки — игроки, которые вместе «заработали» отклонение прогноза от среднего, и разделим выигрыш честно. Значение ШеплиSHAP (значения Шепли)EN SHAP (Shapley additive explanations)Вклад каждого признака в конкретный прогноз по теории игр: базовое значение плюс сумма вкладов равно прогнозу. Для деревьев — точный алгоритм TreeSHAP. признака — его средний вклад по всем порядкам, в которых игроки могли присоединяться к команде.

На числах. Два признака. Средний прогноз (никто не известен) — 2; известен только первый — 6; только второй — 3; оба — 9. Вклад первого, если он пришёл первым: $6 - 2 = 4$; если вторым: $9 - 3 = 6$. Значение Шепли — среднее: $\varphi_1 = 5$. Для второго: $3 - 2 = 1$ и $9 - 6 = 3$, $\varphi_2 = 2$. Проверка: $2 + 5 + 2 = 9$ — базовое значение плюс вклады равно прогнозу. Это свойство аддитивности держится всегда.

Для $d$ признаков порядков $d!$, но для деревьев есть точный быстрый алгоритм TreeSHAP (Лундберг и соавторы). В LightGBM он встроен: booster.predict(X, pred_contrib=True), отдельная библиотека не нужна. Для первой строки валидации базовое значение 14.41, вклады признаков от −1.89 до 0.87, сумма 9.73 — ровно прогноз модели. Средний модуль SHAP по строкам — ещё один, самый надёжный из перечисленных способ ранжировать признаки.

Почему бустинг до сих пор силён на таблицах

К причинам из урока 2.3.1 (нейросети тяготеют к гладким функциям и страдают от бесполезных признаков) добавьте то, что вы увидели сегодня: NaN и смешанные типы без предобработки, никакого масштабирования, секунды на CPU, ранняя остановка и встроенный SHAP. Поэтому первый бейзлайн для таблицы — бустинг.

Практика

Задание: свой бустинг против LightGBM

Напишите векторизованный поиск лучшего пня по всем признакам, бустинг на пнях для MSE и функцию, которая снимает кривую RMSE на валидации у LightGBM. Данные — синтетика Фридмана из 5 признаков (400 строк train, 200 validation). Тесты проверят, что ваш пень совпадает с медленным перебором, бустинг опускает RMSE с 4.9 ниже 1.95, кривая LightGBM с num_leaves = 2 почти повторяет вашу, а 4 листа обгоняют пни.

Новое в поиске пня — формула суммы квадратов отклонений через суммы: для $m$ чисел $\sum (r_i - \bar r)^2 = \sum r_i^2 - (\sum r_i)^2 / m$. После сортировки признака суммы слева от каждого порога даёт np.cumsum, и SSE всех $n - 1$ порогов считается одной строкой без цикла.

Бустинг на пнях против LightGBMnumpy, lightgbm · нужен интернет7 тестов

import lightgbm as lgb
import numpy as np


def make_data(seed=0):
    """Синтетика Фридмана: y = 10·sin(π·x0·x1) + 20·(x2 − 0.5)² + 10·x3 + 5·x4 + шум (σ = 1).

    600 точек: первые 400 — train, остальные 200 — validation.
    """
    rng = np.random.default_rng(seed)
    X = rng.uniform(0, 1, (600, 5))
    y = 10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - 0.5) ** 2 + 10 * X[:, 3] + 5 * X[:, 4]
    y = y + rng.normal(0, 1, 600)
    return X[:400], y[:400], X[400:], y[400:]


def rmse(y, pred):
    return float(np.sqrt(np.mean((np.asarray(y) - np.asarray(pred)) ** 2)))


def best_stump(X, r):
    """Лучший «пень» по MSE для целей r: перебрать ВСЕ признаки j и пороги t.

    Пень отвечает left, если X[:, j] <= t, иначе right; left и right — средние r в своих листьях.
    Пороги — середины между соседними РАЗЛИЧНЫМИ значениями признака (как в уроке 2.3.1).
    Лучший — с минимальной суммой квадратов ошибок; при равенстве — первый найденный
    (меньший номер признака, затем меньший порог).
    Вернуть кортеж (j, t, left, right).

    Подсказка для скорости: отсортируйте признак, тогда суммы r и r² слева от каждого порога
    даёт np.cumsum, и SSE всех порогов считается одной формулой без цикла по порогам.
    """
    # TODO: ваш код
    ...


def predict_stump(stump, X):
    """Предсказание пня (готово)."""
    j, t, left, right = stump
    return np.where(X[:, j] <= t, left, right)


def boost_stumps(X_tr, y_tr, X_val, y_val, n_rounds=200, lr=0.1):
    """Градиентный бустинг на пнях для MSE.

    F0 = среднее y_tr (одинаковое для train и val). На каждом раунде:
    остатки r = y_tr − F_tr (антиградиент MSE) → пень best_stump(X_tr, r) →
    F_tr += lr · пень(X_tr), F_val += lr · пень(X_val).
    Вернуть список длины n_rounds: RMSE на валидации после каждого раунда.
    """
    # TODO: ваш код
    ...


def lgbm_curve(X_tr, y_tr, X_val, y_val, n_rounds=200, lr=0.1, num_leaves=2):
    """То же в LightGBM: список RMSE на валидации после каждого раунда.

    params = {"objective": "regression", "metric": "rmse", "learning_rate": lr,
              "num_leaves": num_leaves, "verbose": -1, "num_threads": 1}
    Обучите lgb.train(params, lgb.Dataset(X_tr, y_tr), num_boost_round=n_rounds,
    valid_sets=[lgb.Dataset(X_val, y_val)], callbacks=[lgb.record_evaluation(res)]),
    где res = {} — словарь, куда LightGBM запишет историю: res["valid_0"]["rmse"].
    """
    # TODO: ваш код
    ...


# «Запустить»: сравниваем кривые
X_tr, y_tr, X_val, y_val = make_data()
print("бейзлайн (всегда среднее):", round(rmse(y_val, np.full(len(y_val), y_tr.mean())), 3))
own = boost_stumps(X_tr, y_tr, X_val, y_val)
if own is not None:
    print("свой бустинг, RMSE на раундах 1/10/50/100/200:", [round(own[i], 3) for i in (0, 9, 49, 99, 199)])
for leaves in (2, 4):
    curve = lgbm_curve(X_tr, y_tr, X_val, y_val, num_leaves=leaves)
    if curve is not None:
        print(f"LightGBM, num_leaves={leaves}:", [round(float(curve[i]), 3) for i in (0, 9, 49, 99, 199)])

ЗапуститьПроверитьПодсказкаСбросить

LightGBM с ранней остановкой, важностью и SHAP (локально)

Код, которым получены таблицы урока. Установка: pip install lightgbm.

import numpy as np
import lightgbm as lgb

rng = np.random.default_rng(1)
X = rng.uniform(0, 1, (3000, 10))                     # 10 признаков, из них x5…x9 — чистый шум
y = (10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - 0.5) ** 2
     + 10 * X[:, 3] + 5 * X[:, 4] + rng.normal(0, 1, 3000))
X_tr, y_tr, X_val, y_val = X[:2000], y[:2000], X[2000:], y[2000:]

params = {"objective": "regression", "metric": "rmse", "learning_rate": 0.05,
          "num_leaves": 8, "verbose": -1, "seed": 0,
          "num_threads": 1}                     # на 2000 строк один поток быстрее; на больших данных уберите
booster = lgb.train(params, lgb.Dataset(X_tr, y_tr), num_boost_round=5000,
                    valid_sets=[lgb.Dataset(X_val, y_val)],
                    callbacks=[lgb.early_stopping(100, verbose=False)])   # стоп, если 100 деревьев без улучшения
pred = booster.predict(X_val)                          # по умолчанию — с лучшим числом деревьев
print("лучшее число деревьев:", booster.best_iteration)
print("RMSE на валидации:", round(float(np.sqrt(np.mean((y_val - pred) ** 2))), 3))

split = booster.feature_importance("split")            # сколько раз признак использовали в разбиениях
gain = booster.feature_importance("gain")              # суммарное уменьшение loss от этих разбиений
print("split:", split)
print("gain, доли:", np.round(gain / gain.sum(), 3))

contrib = booster.predict(X_val, pred_contrib=True)    # SHAP: (n, 10 + 1), последний столбец — базовое значение
print("SHAP первой строки:", np.round(contrib[0], 2))
print("сумма вкладов:", round(float(contrib[0].sum()), 2), " прогноз:", round(float(pred[0]), 2))

лучшее число деревьев: 600
RMSE на валидации: 1.2
split: [742 671 534 502 400 265 283 243 277 283]
gain, доли: [0.224 0.227 0.084 0.365 0.091 0.002 0.002 0.002 0.002 0.002]
SHAP первой строки: [-0.06  0.87 -1.47 -1.89 -1.87 -0.08 -0.07 -0.03 -0.03 -0.06 14.41]
сумма вкладов: 9.73  прогноз: 9.73

Числа могут слегка отличаться в другой версии LightGBM. Поменяйте num_leaves на 2 и 64, learning_rate на 0.3 и сравните с таблицами. Перестановочную важность даёт sklearn.inspection.permutation_importance, графики SHAP — библиотека shap.

🖥 На вашей машине (4×GPU)

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

import numpy as np, xgboost as xgb                    # pip install xgboost (колёса для Linux уже с поддержкой CUDA)
rng = np.random.default_rng(0)
X = rng.uniform(0, 1, (10_000_000, 50)).astype(np.float32)   # 10 млн × 50 ≈ 2 ГБ
y = 10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - 0.5) ** 2 + 10 * X[:, 3] + rng.normal(0, 1, len(X))
for device in ["cpu", "cuda"]:
    model = xgb.XGBRegressor(n_estimators=500, learning_rate=0.1, max_depth=6, tree_method="hist", device=device)
    model.fit(X, y)                                    # засеките время: %time в Jupyter или time.perf_counter()

Ожидания (оценка, проверьте сами): массив — около 2 ГБ RAM, одной RTX 4080 с 32 ГБ хватит с запасом (на GPU признаки хранятся квантованными). На 48 ядрах EPYC обучение займёт порядка минут, на GPU — обычно в разы быстрее. Остальные GPU пригодятся для параллельного подбора гиперпараметров: четыре процесса с CUDA_VISIBLE_DEVICES=0…3, у каждого своя конфигурация. У CatBoost GPU включает task_type="GPU". О машине — на странице «Ваше железо».

Китайский угол: слайды, из которых вырос XGBoost

Вывод с $g_i$, $h_i$, весом листа $-G/(H + \lambda)$ и формулой выигрыша, который вы прочитали выше, впервые появился не в статье, а в учебных слайдах Чэнь Тяньци (Tianqi Chen) «Introduction to Boosted Trees» — лекции 22 октября 2014 года, когда он был ассистентом курса машинного обучения в Вашингтонском университете. Из них вырос раздел «Introduction to Boosted Trees» в документации XGBoost (ссылка в источниках). Чэнь и Тун Хэ рассказывали и о применении бустинга в конкурсе по поиску бозона Хиггса — слайды доклада «Boosted Trees for Higgs Discovery» лежат на сайте CERN. Статья о системе XGBoost вышла в 2016 году (arXiv:1603.02754).

LightGBM — работа Microsoft Research Asia в Пекине; среди авторов статьи NIPS 2017 — Кэ Голинь (Guolin Ke) и Лю Теянь (Tie-Yan Liu).

Что почитать по-китайски. У Ли Хана в «Методах статистического обучения» глава 8 «Методы бустинга» начинается с AdaBoost и заканчивается разделом 8.4 «Бустинг деревьев», где выводится градиентный бустинг: отрицательный градиент как приближение остатка — ровно наш раздел «Градиентный спуск в пространстве функций». Курс Datawhale ensemble-learning в главе CH4 разбирает прямой пошаговый алгоритм (forward stagewise), GBDT, XGBoost и LightGBM с кодом.

Термины. Бустинг по-китайски буквально «подъём»: модель шаг за шагом «поднимают» новыми деревьями. Поэтому GBDT называют «деревом решений с градиентным подъёмом», антиградиент — «отрицательным градиентом», а лист — «листовым узлом». Learning rate («скорость обучения»), важность признаков и вторая производная переводятся дословно.

Проверь себя

Проверь себя6 вопросов·

1 Бинарная классификация, log-loss. Пример класса 0, текущий логит $F = 0$. На какое значение будет учиться следующее дерево для этого примера (антиградиент)?

2 В лист попали 2 примера: $y = (1, 1)$, у обоих $p = 0.5$. Чему равно значение листа шагом Ньютона (без регуляризации)?

3 В узле $G = -4$, $H = 3$. Каким будет оптимальный вес листа XGBoost при $\lambda = 1$?

4 Какие утверждения о гиперпараметрах верны?Можно выбрать несколько ответов

При меньшем learning_rate нужно больше деревьев, а число деревьев находят ранней остановкойБустинг на пнях не может выразить взаимодействие двух признаков вроде $x_0 x_1$Чем больше num_leaves, тем лучше на валидацииbagging_fraction меньше 1 делает деревья разнообразнее и обычно немного снижает переобучение

5 Шумный признак получил много разбиений (split), но почти нулевой gain. Чему верить?

split: признак часто нужен моделиgain и перестановочной важности: разбиений много, но пользы от них почти нетНи одной: важность признаков бессмысленна

6 Базовое значение SHAP равно 10, вклады трёх признаков строки: 2, −3 и 0.5. Каков прогноз модели для этой строки?

Проверить ответы

Итоги

• Градиентный бустинг — градиентный спуск в пространстве функций: каждое дерево приближает антиградиент потери по предсказаниям. Для MSE это остатки, для log-loss — $y - p$, тот же градиент, что у softmax-cross-entropy в LLM.
• Структуру дерева задаёт антиградиент, а значения листьев выбирают шагом Ньютона: $\sum (y - p) / \sum p(1-p)$. XGBoost делает вторые производные частью цели: $w^* = -G/(H + \lambda)$, разбиение — только если выигрыш больше $\gamma$.
• Главные рычаги LightGBM: learning_rate (0.03–0.1) и ранняя остановка, num_leaves и min_data_in_leaf, сабсэмплинг строк и признаков. Гистограммы с 63–255 корзинами почти не теряют точности.
• XGBoost — регуляризованная цель второго порядка, LightGBM — гистограммы и рост по листьям, CatBoost — ordered boosting и категории. Все три сами справляются с NaN.
• Важность по числу разбиений обманывает; смотрите gain, перестановочную важность и SHAP, а SHAP-вклады строки в сумме с базой дают её прогноз.

Как бустинг работает ранжировщиком в настоящей системе — ленте рекомендаций маркетплейса, — в уроке 11.2.3.

Дальше: проект с честной валидацией — Pipeline без утечек, стратегии кросс-валидации, подбор гиперпараметров и одна-единственная проверка на отложенном тесте.