> Machine Learning Guru|

Градиентный бустинг относится к семейству ансамблевых методов машинного обучения, где финальное предсказание формируется как взвешенная сумма предсказаний множества слабых моделей. Ключевое отличие от других ансамблевых подходов — последовательное обучение, при котором каждая новая модель корректирует ошибки предыдущих. Алгоритм строит композицию из простых моделей (чаще всего деревьев решений малой глубины), добавляя их итеративно и минимизируя функцию потерь на каждом шаге.

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

Последовательное построение ансамбля

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

Первое дерево обучается предсказывать остатки между базовым предсказанием и истинными значениями. Предсказание первого дерева добавляется к базовому с определенным весом, формируя обновленное предсказание.

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

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

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

Название «градиентный бустинг» отражает связь алгоритма с методом градиентного спуска. Классический градиентный спуск минимизирует функцию потерь, обновляя параметры модели в направлении антиградиента. Градиентный бустинг применяет ту же идею, но вместо обновления параметров добавляет новые модели.

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

Гибкость подхода проявляется в возможности работать с произвольными дифференцируемыми функциями потерь. Для регрессии часто используется MSE (mean squared error), для классификации — log loss или экспоненциальная функция потерь. Выбор функции потерь определяет, какие аспекты данных алгоритм будет оптимизировать в первую очередь.

Математический аппарат градиентного бустинга

Формализация алгоритма строится на итеративном обновлении предсказаний. Обозначим F_m(x) как предсказание композиции после m итераций, h_m(x) — предсказание дерева на итерации m, L(y, F) — функцию потерь. Обновление на каждом шаге записывается как:

F_m(x) = F_(m-1)(x) + ν · h_m(x)

где:

• F_m(x) — предсказание композиции на итерации m;
• F_(m-1)(x) — предсказание на предыдущей итерации;
• h_m(x) — предсказание нового дерева;
• ν — learning rate (коэффициент скорости обучения).

Параметр ν контролирует величину шага. При ν = 1 предсказание нового дерева добавляется полностью, при меньших значениях — частично.

Новое дерево h_m(x) обучается аппроксимировать антиградиент функции потерь через следующий расчет:

h_m(x) ≈ -∂L(y_i, F_(m-1)(x_i)) / ∂F_(m-1)(x_i)

где:

• L(y_i, F_(m-1)(x_i)) — значение функции потерь для i-го наблюдения;
• ∂L/∂F — частная производная функции потерь по предсказанию;
• антиградиент указывает направление коррекции предсказаний.

Для квадратичной функции потерь L(y, F) = (y — F)² градиент упрощается до 2(F — y), антиградиент — до (y — F), что соответствует остаткам. В этом случае обучение на антиградиенте эквивалентно обучению на остатках между истинными значениями и текущими предсказаниями.

Рис. 1: Эволюция предсказаний градиентного бустинга с увеличением числа итераций. Каждая панель демонстрирует аппроксимацию синусоиды после 1, 3, 10 и 50 итераций. Первая итерация дает грубое приближение, последующие деревья корректируют ошибки и улучшают fit к данным. После 50 итераций модель точно воспроизводит нелинейную зависимость, сохраняя способность к обобщению

Отличия бустинга от бэггинга

Градиентный бустинг и бэггинг (bootstrap aggregating) представляют две фундаментально различные стратегии построения ансамблей. Обе техники комбинируют множество базовых моделей для улучшения предсказательной способности, но механизмы достижения этой цели противоположны:

• Бэггинг снижает дисперсию за счет усреднения независимых моделей;
• Градиентный бустинг уменьшает смещение через последовательную коррекцию ошибок.

Различия проявляются на всех уровнях: от способа обучения моделей до типов задач, где каждый метод демонстрирует преимущества. Понимание этих различий критично для выбора подходящего алгоритма под конкретную задачу.

Параллельное и последовательное обучение

В бэггинге все модели обучаются параллельно и независимо. Каждая получает случайную подвыборку данных (bootstrap sample), а итоговое предсказание формируется усреднением (для регрессии) или голосованием (для классификации). Независимость моделей позволяет использовать сразу несколько ядер процессора для вычислений.

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

Итоговое предсказание — взвешенная сумма с коэффициентами, задаваемыми скоростью обучения (learning rate). Последовательность увеличивает время обучения, но часто позволяет достичь высокой точности с меньшим количеством деревьев.

Независимость и зависимость моделей

В бэггинге каждая модель обучается на разных данных. Выбираются N наблюдений из исходного набора размером N с возвращением. Около 63% данных попадают в выборку, остальные 37% остаются для проверки (out-of-bag). Ошибки моделей некоррелированы, поэтому усреднение снижает разброс.

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

1. первое дерево ловит общие тренды;
2. второе — отклонения;
3. третье — отклонения от первых двух и т.д.

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

Смещение и разброс (bias-variance)

Ошибка модели состоит из смещения (bias), разброса (variance) и шума. Смещение отражает систематическую ошибку модели, а разброс показывает, насколько сильно предсказания меняются при изменении данных.

Алгоритмы Бэггинга уменьшают разброс. Глубокие деревья имеют низкое смещение, но высокую вариативность. Усреднение множества моделей снижает разброс, не увеличивая смещение. Алгоритм случайного леса (Random Forest) особенно эффективен, когда базовые модели сложные и разнообразные.

Градиентный бустинг, напротив, снижает смещение. Здесь используют простые модели с высоким смещением и низкой вариативностью. Каждое новое дерево исправляет ошибки предыдущих, постепенно уменьшая смещение ансамбля. Разброс контролируется через скорость обучения и ограничение числа итераций. Такой подход позволяет из простых моделей строить сложные зависимости.

Рис. 2: Сравнение подходов к снижению ошибки. Левая панель: одно глубокое дерево с сильным переобучением и высокой вариативностью предсказаний. Средняя панель: Random Forest (бэггинг) усредняет множество деревьев, уменьшая разброс и давая более стабильную аппроксимацию. Правая панель: Gradient Boosting (градиентный бустинг) последовательно снижает смещение, добавляя простые деревья

Learning rate: управление скоростью обучения

Коэффициент скорости обучения Learning rate контролирует вклад каждого нового дерева в итоговую композицию. Параметр определяет величину шага при обновлении предсказаний и напрямую влияет на баланс между скоростью обучения и качеством модели:

• Малые значения learning rate требуют большего количества итераций для достижения оптимума, но обеспечивают лучшую генерализацию;
• Высокие значения ускоряют обучение, но повышают риск переобучения.

Выбор Learning rate — это компромисс между временем обучения и точностью модели. На практике модели с learning rate 0.001–0.1 и большим числом деревьев обычно точнее, чем модели с learning rate 0.1-0.5 и меньшим числом деревьев, даже при одинаковом времени обучения.

Роль коэффициента в итоговом предсказании

Learning rate ν определяет, какой вклад новое дерево вносит в ансамбль:

• При ν = 1 дерево полностью добавляется к текущему предсказанию, модель резко исправляет ошибки;
• При ν = 0.1 учитывается лишь 10% предсказания дерева, корректировка более осторожная.

Итоговое предсказание после M итераций выражается как:

F_M(x) = F_0(x) + ν · Σ h_m(x)

где:

• F_0(x) — базовое предсказание (среднее значение целевой переменной);
• h_m(x) — предсказание дерева на итерации m;
• ν — learning rate;
• Σ обозначает суммирование по всем M итерациям.

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

Соотношение между learning rate и числом деревьев нелинейное. Уменьшение learning rate в 10 раз (например, с 0.1 до 0.01) обычно требует увеличения числа деревьев в 5–7 раз, а не в 10, так как модель при малом learning rate использует каждое дерево более эффективно.

Компромисс между скоростью и точностью

Высокий learning rate (0.3–1.0) быстро снижает ошибку на обучении: первые 10–20 деревьев дают заметный эффект, дальше улучшение минимальное. Обучение проходит быстрее, но модель склонна к переобучению — на валидации качество часто достигает пика и затем падает.

Низкий learning rate (0.001–0.01) требует сотен или тысяч деревьев. Каждое дерево вносит небольшой вклад, ошибка снижается постепенно. Время обучения увеличивается, но оптимизация более плавная, модель реже переобучается, а качество на валидации продолжает расти дольше.

Промежуточные значения (0.03–0.3) обеспечивают баланс: 100–300 деревьев достаточно для хорошей точности и приемлемого времени обучения. Этот диапазон обычно используется как стартовая точка для подбора гиперпараметров, а дальнейшая оптимизация зависит от данных и требований к производительности.

Подходы к подбору скорости обучения (learning rate)

Оптимальная скорость обучения зависит от сложности задачи, размера выборки и архитектуры модели. Для датасетов с сильным сигналом и простыми зависимостями допустимы более высокие значения, например 0,1–0,3. Для зашумленных данных или сложных нелинейных паттернов лучше использовать меньшие значения — 0,005–0,05.

Распространенная стратегия подбора:

1. Начинать с learning rate = 0,1 и количества деревьев 100–200. Метрики на валидации отслеживаются с помощью ранней остановки (early stopping);
2. Если модель переобучается слишком рано (после 50–100 деревьев), learning rate уменьшают до 0,05 или 0,01 и пропорционально увеличивают максимальное количество деревьев;
3. Если после 200 деревьев качество продолжает улучшаться, learning rate можно повысить до 0,2 для ускорения обучения.

Learning rate влияет на работу модели в сочетании с другими гиперпараметрами:

• Глубокие деревья (max_depth 8–10) при высоком learning rate быстро приводят к переобучению;
• Мелкие деревья (max_depth 3–5) позволяют использовать более высокие значения learning rate без потери способности модели к генерализации.

Аналогично, малые значения min_samples_leaf усиливают переобучение при высоком learning rate.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Генерация данных
np.random.seed(42)
X = np.sort(np.random.uniform(0, 10, 400)).reshape(-1, 1)
y = np.sin(X).ravel() + 0.3 * np.sin(3 * X).ravel() + np.random.normal(0, 0.2, X.shape[0])

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3, random_state=42)

# Различные learning rates
learning_rates = [0.01, 0.05, 0.1, 0.5, 1.0]
max_iterations = 500

fig, axes = plt.subplots(2, 3, figsize=(16, 10))
axes = axes.ravel()

summary = []

for idx, lr in enumerate(learning_rates):
    train_errors = []
    val_errors = []

    gb = GradientBoostingRegressor(
        learning_rate=lr,
        max_depth=3,
        warm_start=True,  # наращивание деревьев
        random_state=42
    )

    for n_trees in range(1, max_iterations + 1):
        gb.n_estimators = n_trees
        gb.fit(X_train, y_train)

        train_pred = gb.predict(X_train)
        val_pred = gb.predict(X_val)

        train_errors.append(mean_squared_error(y_train, train_pred))
        val_errors.append(mean_squared_error(y_val, val_pred))

    # Визуализация кривых обучения
    axes[idx].plot(range(1, max_iterations + 1), train_errors,
                   color='#3498DB', linewidth=2, label='Train MSE', alpha=0.8)
    axes[idx].plot(range(1, max_iterations + 1), val_errors,
                   color='#E74C3C', linewidth=2, label='Validation MSE', alpha=0.8)

    min_val_idx = np.argmin(val_errors)
    axes[idx].axvline(x=min_val_idx + 1, color='gray', linestyle='--',
                      linewidth=1.5, alpha=0.7)
    axes[idx].scatter([min_val_idx + 1], [val_errors[min_val_idx]],
                      color='#2C3E50', s=80, zorder=5)

    axes[idx].set_title(f'Learning Rate = {lr}\n(Optimal trees: {min_val_idx + 1})',
                        fontsize=11, fontweight='bold')
    axes[idx].set_xlabel('Количество деревьев')
    axes[idx].set_ylabel('MSE')
    axes[idx].legend(loc='upper right')
    axes[idx].grid(True, alpha=0.3)
    axes[idx].set_xlim(0, max_iterations)

    # Сохраняем результат для сводной таблицы
    summary.append((lr, min_val_idx + 1, val_errors[min_val_idx], train_errors[min_val_idx]))

# Удаление лишней панели
fig.delaxes(axes[5])
plt.tight_layout()
plt.show()

# Сводная таблица оптимальных параметров
print("\n" + "="*60)
print("Анализ влияния learning rate")
print("="*60)
for lr, opt_trees, val_mse, train_mse in summary:
    print(f"LR={lr:4.2f} | Оптимум: {opt_trees:3d} деревьев | "
          f"Val MSE: {val_mse:.4f} | Train MSE: {train_mse:.4f}")
print("="*60)

Рис. 3: Влияние скорости обучения learning rate на динамику обучения градиентного бустинга. Каждая панель показывает эволюцию ошибки на обучающей и валидационной выборках для разных значений коэффициента. Вертикальная пунктирная линия отмечает оптимальное количество деревьев для каждого learning rate. Чем ниже скорость обучения, тем больше деревьев требуется для обучения модели. При этом растет время обучения, но ниже ошибка MSE

Анализ влияния learning rate
============================================================
LR=0.01 | Оптимум: 338 деревьев | Val MSE: 0.0429 | Train MSE: 0.0352
LR=0.05 | Оптимум:  63 деревьев | Val MSE: 0.0427 | Train MSE: 0.0361
LR=0.10 | Оптимум:  32 деревьев | Val MSE: 0.0420 | Train MSE: 0.0354
LR=0.50 | Оптимум:   8 деревьев | Val MSE: 0.0496 | Train MSE: 0.0332
LR=1.00 | Оптимум:   6 деревьев | Val MSE: 0.0495 | Train MSE: 0.0298

Код демонстрирует базовую процедуру подбора learning rate через сравнение кривых обучения. На практике скорость обучения редко указывают вручную, используют grid search или случайный поиск по пространству гиперпараметров, включая max_depth, min_samples_split и subsample. Библиотеки вроде Optuna или Hyperopt автоматизируют процесс и находят комбинации параметров, недостижимые ручной настройкой.

Реализация градиентного бустинга на Python

Экосистема Python предлагает несколько реализаций градиентного бустинга с различными оптимизациями и возможностями:

• Scikit-learn предоставляет базовую имплементацию, достаточную для понимания алгоритма и решения стандартных задач;
• Специализированные библиотеки XGBoost, LightGBM и CatBoost добавляют продвинутые техники регуляризации, эффективную работу с категориальными признаками и распределенное обучение.

Выбор библиотеки зависит от требований к скорости, размера данных и специфики задачи.

Реализация градиентного бустинга с нуля полезна для глубокого понимания механизма работы алгоритма. Написание цикла обучения, вычисление градиентов и построение композиции проясняет детали, скрытые в высокоуровневых API. Далее рассматриваем базовую имплементацию и работу с готовыми инструментами.

Базовая имплементация с sklearn

Библиотека Scikit-learn предоставляет классы GradientBoostingRegressor и GradientBoostingClassifier для задач регрессии и классификации соответственно. Основные параметры включают:

• n_estimators — количество деревьев;
• learning_rate — скорость обучения;
• max_depth — глубина деревьев;
• min_samples_split и min_samples_leaf — контроль размера узлов.

Параметр subsample определяет долю наблюдений для обучения каждого дерева, значения меньше 1.0 добавляют стохастичность и регуляризацию.

Метод staged_predict возвращает предсказания после каждой итерации обучения. Функционал полезен для анализа динамики улучшения модели и определения оптимального количества деревьев без переобучения нескольких моделей.

Атрибут feature_importances_ содержит важности признаков, вычисленные как средний прирост качества разбиений во всех деревьях.

Параметр loss определяет функцию потерь для оптимизации:

• Для регрессии доступны ‘squared_error’ (MSE), ‘absolute_error’ (MAE), ‘huber’ и ‘quantile’;
• Для классификации — ‘log_loss’ (бинарная и мультиклассовая) и ‘exponential’ (эквивалентно AdaBoost).

Выбор функции потерь влияет на чувствительность к выбросам и интерпретацию предсказаний.

import numpy as np
import pandas as pd
import yfinance as yf
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

# Загрузка данных
ticker = yf.Ticker("2330.TW")  # Taiwan Semiconductor Manufacturing (TSMC)
data = ticker.history(period="5y", interval="1d")

# Если MultiIndex, убираем уровень
if isinstance(data.columns, pd.MultiIndex):
    data.columns = data.columns.droplevel(1)

# Создание признаков
data['Returns'] = data['Close'].pct_change()
data['SMA_20'] = data['Close'].rolling(window=20).mean()
data['SMA_50'] = data['Close'].rolling(window=50).mean()
data['Volatility_10'] = data['Returns'].rolling(window=10).std()
data['Volatility_30'] = data['Returns'].rolling(window=30).std()

# Безопасное вычисление изменений объема (частая аномалия)
volume_change = data['Volume'].pct_change()
volume_change.replace([np.inf, -np.inf], np.nan, inplace=True)  # заменить inf на NaN
data['Volume_Change'] = volume_change.interpolate(method='linear')  # линейная интерполяция

# Лаговые признаки
for lag in [1, 2, 3, 5, 10]:
    data[f'Return_Lag_{lag}'] = data['Returns'].shift(lag)
    data[f'Vol_Lag_{lag}'] = data['Volatility_10'].shift(lag)

# Целевая переменная
data['Target'] = data['Close'].shift(-5) / data['Close'] - 1

# Удаление пропусков
data = data.dropna()

# Подготовка данных
feature_cols = [col for col in data.columns if col not in ['Close', 'Open', 
                                                           'High', 'Low', 
                                                           'Volume', 'Dividends',
                                                           'Stock Splits', 'Target']]
X = data[feature_cols]
y = data['Target']

# Разделение на train/test
split_idx = int(len(X) * 0.8)
X_train, X_test = X[:split_idx], X[split_idx:]
y_train, y_test = y[:split_idx], y[split_idx:]

# Обучение Gradient Boosting
gb_model = GradientBoostingRegressor(
    n_estimators=200,
    learning_rate=0.05,
    max_depth=4,
    min_samples_split=20,
    min_samples_leaf=10,
    subsample=0.8,
    random_state=42,
    verbose=0
)

gb_model.fit(X_train, y_train)

# Предсказания и метрики
y_pred_train = gb_model.predict(X_train)
y_pred_test = gb_model.predict(X_test)

print("="*60)
print("Результаты Gradient Boosting на TSMC")
print("="*60)
print(f"Train R²: {r2_score(y_train, y_pred_train):.4f}")
print(f"Test R²: {r2_score(y_test, y_pred_test):.4f}")
print(f"Train RMSE: {np.sqrt(mean_squared_error(y_train, y_pred_train)):.6f}")
print(f"Test RMSE: {np.sqrt(mean_squared_error(y_test, y_pred_test)):.6f}")
print(f"Test MAE: {mean_absolute_error(y_test, y_pred_test):.6f}")
print("="*60)

# Визуализация важности признаков
importances = gb_model.feature_importances_
indices = np.argsort(importances)[::-1][:10]

plt.figure(figsize=(12, 6))
plt.barh(range(10), importances[indices], color='#2C3E50', alpha=0.8)
plt.yticks(range(10), [feature_cols[i] for i in indices])
plt.xlabel('Важность признака')
plt.title('Top-10 признаков по важности (Gradient Boosting)', fontweight='bold')
plt.gca().invert_yaxis()
plt.grid(axis='x', alpha=0.3)
plt.tight_layout()
plt.show()

Результаты Gradient Boosting на TSMC
============================================================
Train R²: 0.7807
Test R²: -0.2721
Train RMSE: 0.018136
Test RMSE: 0.043908
Test MAE: 0.033989

Рис. 4: Важность признаков в модели градиентного бустинга для прогнозирования доходности акций TSMC. Скользящие средние и лаговые значения волатильности доминируют, что подтверждает автокорреляционную природу финансовых временных рядов

Представленный выше код демонстрирует типичный пайплайн для задач прогнозирования на финансовых данных:

1. Сначала выполняется инжиниринг признаков (Feature engineering). Этап включает создание лаговых переменных, различных индикаторов и метрик волатильности;
2. Разделение данных (train/test split) выполняется по времени без перемешивания, что критично для корректной оценки на временных рядах;
3. Модель обучается на исторических данных и тестируется на более поздних периодах. После чего оцениваются метрики ошибок на тестовой выборке.

Визуализация влияния learning rate

Динамика обучения при различных значениях learning rate позволяет наглядно увидеть взаимосвязь между скоростью конвергенции модели и ее качеством. Построение кривых ошибки на обучающей и валидационной выборках для нескольких значений learning rate помогает определить момент, когда дальнейшее увеличение числа деревьев перестает улучшать способность модели к генерализации.

Метод staged_predict из sklearn существенно упрощает процесс: он позволяет получать предсказания после каждой итерации без необходимости заново обучать модель с увеличенным числом деревьев. Это особенно полезно при визуализации кривых обучения и поиске оптимального числа деревьев.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error

# Используем ранее подготовленные данные X_train, X_test, y_train, y_test

learning_rates = [0.001, 0.01, 0.05, 0.1]
n_estimators = 150

fig, axes = plt.subplots(2, 2, figsize=(14, 10))
axes = axes.ravel()

for idx, lr in enumerate(learning_rates):
    # Обучение модели
    gb = GradientBoostingRegressor(
        n_estimators=n_estimators,
        learning_rate=lr,
        max_depth=4,
        min_samples_split=20,
        subsample=0.8,
        random_state=42,
        verbose=0
    )
    
    gb.fit(X_train, y_train)
    
    # Получение предсказаний после каждой итерации
    train_errors = []
    test_errors = []
    
    for pred_train, pred_test in zip(gb.staged_predict(X_train), gb.staged_predict(X_test)):
        train_errors.append(mean_squared_error(y_train, pred_train))
        test_errors.append(mean_squared_error(y_test, pred_test))
    
    # Визуализация
    axes[idx].plot(range(1, n_estimators + 1), train_errors, 
                   color='#3498DB', linewidth=2, label='Train MSE', alpha=0.8)
    axes[idx].plot(range(1, n_estimators + 1), test_errors, 
                   color='#E74C3C', linewidth=2, label='Test MSE', alpha=0.8)
    
    # Отметка минимума
    min_test_idx = np.argmin(test_errors)
    axes[idx].axvline(x=min_test_idx + 1, color='gray', linestyle='--', 
                      linewidth=1.5, alpha=0.7)
    axes[idx].scatter([min_test_idx + 1], [test_errors[min_test_idx]], 
                      color='#2C3E50', s=80, zorder=5)
    
    axes[idx].set_title(f'Learning Rate = {lr}\n(Минимум test MSE: {min_test_idx + 1} деревьев)', 
                        fontsize=11, fontweight='bold')
    axes[idx].set_xlabel('Количество деревьев')
    axes[idx].set_ylabel('MSE')
    axes[idx].legend()
    axes[idx].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Рис. 5: Кривые обучения градиентного бустинга на данных TSMC для 4-х значений learning rate. При LR=0.001 порог переобучения модели происходит после 149 итераций, после порога тестовая ошибка становится слишком высокой. При LR=0.01 оптимум достигается на 36 деревьях. При LR=0.05 порог срабатывает уже всего на 11 деревьях. При LR=0.1 модель не может эффективно обучаться, так как метрики на тестовых данных отрываются практически сразу от метрик на обучающей выборке

Анализ кривых обучения помогает выявить признаки переобучения. Если ошибка на валидационной выборке начинает расти при продолжающемся снижении ошибки на тренировочных данных, модель начинает запоминать шум вместо закономерностей. Оптимальное число деревьев определяется минимумом валидационной ошибки, обеспечивая баланс между недообучением и переобучением.

Использование метода ранней остановки Early stopping автоматизирует этот процесс: обучение прекращается, когда валидационная ошибка не улучшается в течение заданного числа итераций, что ускоряет обучение и предотвращает переобучение.

Сравнение с Random Forest

Модели Градиентного бустинга и Случайного леса (Random Forest) решают схожие задачи, но показывают разную эффективность в зависимости от данных. Random Forest хорошо работает на данных с высокой дисперсией, множеством нерелевантных признаков и выбросами, а градиентный бустинг — на структурированных данных с сильным сигналом, где последовательная оптимизация дает преимущество.

Сравнение моделей показывает:

• Random Forest быстрее обучается и не требует тонкой настройки гиперпараметров.
• Градиентный бустинг может давать более высокую точность при оптимальном learning_rate и числе деревьев, но чувствителен к шуму и выбросам.

Таким образом, градиентный бустинг эффективнее на структурированных табличных данных, а Random Forest предпочтителен при ограниченном времени обучения или высоком шуме. Для максимальной точности в соревнованиях и продакшен среде часто используют ансамбли обеих моделей.

Применение в задачах классификации и регрессии

Градиентный бустинг одинаково хорошо работает как для регрессии, так и для классификации, адаптируясь через выбор функции потерь.

В задачах регрессии алгоритм минимизирует среднеквадратичную ошибку (MSE), среднюю абсолютную ошибку (MAE) или другие метрики разницы между предсказанными и истинными значениями.

В классификации оптимизируются функции log loss для вероятностных предсказаний или exponential loss для жестких меток классов. Такая универсальность делает градиентный бустинг базовым инструментом для широкого спектра задач.

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

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

Волатильность является ключевым параметром для риск-менеджмента и оценки опционов. Классические модели семейства GARCH предполагают определенную параметрическую структуру и требуют стационарности данных. В отличие от них, градиентный бустинг способен работать с произвольными нелинейными зависимостями и автоматически выявлять важные лаговые переменные без априорных предположений о процессе генерации данных.

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

• Исторические значения волатильности с различными окнами, доходности;
• Диапазоны High-Low и технические индикаторы, включая экспоненциальные скользящие средние (EWMA), ATR и фильтр Баттерворта.

Целевая переменная — стандартное отклонение доходностей за следующие две недели. Модель обучается на исторических данных с учетом лагов до 3–4 недель, что позволяет учитывать автокорреляцию и динамику финансового временного ряда.

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from scipy.signal import butter, filtfilt
import warnings
warnings.filterwarnings('ignore')

# Загрузка данных (EUR/USD, недельный таймфрейм)
ticker = yf.Ticker("EURUSD=X")
data = ticker.history(period="5y", interval="1wk")

# Проверка на MultiIndex
if isinstance(data.columns, pd.MultiIndex):
    data.columns = data.columns.droplevel(1)

# Предобработка
data['Returns'] = data['Close'].pct_change()
data['Abs_Returns'] = data['Returns'].abs()
data['HL_Range'] = (data['High'] - data['Low']) / data['Close']

# EWMA
for span in [4, 8]:
    data[f'EWMA_{span}'] = data['Returns'].ewm(span=span).mean()

# Реализованная волатильность (RV)
for window in [2, 4, 8]:
    data[f'RV_{window}'] = data['Returns'].rolling(window=window).std()

# ATR
for window in [4, 8]:
    data[f'ATR_{window}'] = (data['High'] - data['Low']).rolling(window=window).mean()

# Butterworth filter для High-Low
b, a = butter(N=2, Wn=0.1)
data['Close_Butter'] = filtfilt(b, a, data['Close'])
data['Butter_Range'] = (data['Close'] - data['Close_Butter']).abs()

# Лаговые признаки (1, 2, 3, 4 недели)
lags = [1, 2, 3, 4]
for lag in lags:
    for col in ['RV_4', 'Abs_Returns', 'HL_Range', 'Butter_Range']:
        data[f'{col}_Lag_{lag}'] = data[col].shift(lag)

# Целевая переменная: волатильность следующих 2 недель
data['Target_Volatility'] = data['Returns'].rolling(window=2).std().shift(-1)

# Удаление пропусков
data = data.dropna()

# Подготовка данных для модели
feature_cols = [col for col in data.columns if col not in ['Open', 'High', 'Low', 'Close', 'Volume', 'Dividends', 'Stock Splits', 'Target_Volatility']]
X = data[feature_cols]
y = data['Target_Volatility']

# Разделение на train/test
split_idx = int(len(X) * 0.8)
X_train, X_test = X[:split_idx], X[split_idx:]
y_train, y_test = y[:split_idx], y[split_idx:]
dates_test = data.index[split_idx:]

# Обучение модели Gradient Boosting
gb_vol = GradientBoostingRegressor(
    n_estimators=250,
    learning_rate=0.05,
    max_depth=4,
    min_samples_split=20,
    min_samples_leaf=10,
    subsample=0.8,
    random_state=42
)

gb_vol.fit(X_train, y_train)

# Предсказания
y_pred_train = gb_vol.predict(X_train)
y_pred_test = gb_vol.predict(X_test)

# Метрики
print("="*60)
print("Прогнозирование недельной волатильности EUR/USD")
print("="*60)
print(f"Train R²: {r2_score(y_train, y_pred_train):.4f}")
print(f"Test R²: {r2_score(y_test, y_pred_test):.4f}")
print(f"Train RMSE: {np.sqrt(mean_squared_error(y_train, y_pred_train)):.6f}")
print(f"Test RMSE: {np.sqrt(mean_squared_error(y_test, y_pred_test)):.6f}")
print(f"Test MAE: {mean_absolute_error(y_test, y_pred_test):.6f}")
print("="*60)

# Визуализация
fig, axes = plt.subplots(2, 1, figsize=(14, 10))

# Временной ряд
axes[0].plot(dates_test, y_test.values, color='#2C3E50', linewidth=2, label='Истинная волатильность', alpha=0.8)
axes[0].plot(dates_test, y_pred_test, color='#E74C3C', linewidth=1.5, label='Предсказанная волатильность', alpha=0.8)
axes[0].set_xlabel('Дата')
axes[0].set_ylabel('Волатильность')
axes[0].set_title('Прогноз недельной реализованной волатильности EUR/USD', fontweight='bold')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# Scatter plot: Pred vs True
axes[1].scatter(y_test, y_pred_test, alpha=0.6, s=40, color='#3498DB')
axes[1].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], '--', color='#2C3E50', linewidth=2)
axes[1].set_xlabel('Истинная волатильность')
axes[1].set_ylabel('Предсказанная волатильность')
axes[1].set_title(f'Точность предсказаний (R² = {r2_score(y_test, y_pred_test):.4f})', fontweight='bold')
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Прогнозирование недельной волатильности EUR/USD
============================================================
Train R²: 0.9830
Test R²: 0.4108
Train RMSE: 0.000804
Test RMSE: 0.005680
Test MAE: 0.003832

Интерпретация полученных метрик:

1. Метрики на тренировочном наборе демонстрируют высокую объясняющую способность модели (Train R² = 0.9830), что говорит о том, что градиентный бустинг хорошо подстраивается под исторические данные;
2. Однако тестовое R² = 0.4108 значительно ниже, что отражает сложность прогнозирования реальной недельной волатильности валютных пар: финансовые временные ряды высокошумные, имеют нестационарные паттерны и неожиданные макроэкономические влияния, которые модель не может полностью уловить;
3. Несмотря на это, относительно низкие значения RMSE и MAE на тесте (0.005680 и 0.003832) показывают, что модель все же способна давать полезные ориентиры для волатильности, даже если точность ограничена природой данных.

Рис. 6: Прогнозирование недельной реализованной волатильности EUR/USD с помощью градиентного бустинга. Верхняя панель показывает временной ряд истинной волатильности (черная линия) и предсказания модели (красная) на тестовом периоде. Нижняя панель — график рассеяния, демонстрирующий соответствие предсказанных значений волатильности истинным; диагональная линия показывает идеальное совпадение

Прогнозирование волатильности с помощью градиентного бустинга показывает лучшие результаты по сравнению с простыми моделями, такими как скользящие средние или экспоненциальное скользящее среднее (EWMA, exponentially weighted moving average). Модель сама выявляет сложные, нелинейные зависимости между признаками и быстро адаптируется к изменениям на рынке. Использование таких прогнозов в системах управления рисками позволяет динамически настраивать кредитное плечо и уровни стоп-лосс в зависимости от ожидаемой волатильности.

Интерпретация важности признаков

Понимание того, какие признаки влияют на предсказания модели, важно для проверки результатов и улучшения подготовки признаков (feature engineering).

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

• Важность на основе прироста качества (Gain-based importance) показывает среднее улучшение модели при разбиении по признаку в деревьях;
• Важность по количеству разбиений (Split-based importance) учитывает, как часто признак использовался для разделений;
• Важность по перестановке (Permutation importance) измеряет снижение качества модели при случайной перестановке значений признака.

Анализ важности помогает находить избыточные признаки, которые можно убрать без потери точности. Если два признака сильно коррелируют и один важнее другого, менее значимый можно удалить. Это упрощает модель, ускоряет обучение и предсказания, а также снижает риск переобучения. Кроме того, важность признаков помогает строить гипотезы о причинах зависимостей в данных.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.inspection import permutation_importance

# Используем обученную модель gb_vol и данные X_test, y_test

# Gain-based importance (встроенная в sklearn)
gain_importance = gb_vol.feature_importances_
gain_importance_df = pd.DataFrame({
    'Feature': feature_cols,
    'Importance': gain_importance
}).sort_values('Importance', ascending=False)

# Permutation importance
perm_importance = permutation_importance(
    gb_vol, X_test, y_test, 
    n_repeats=10, 
    random_state=42, 
    n_jobs=-1
)

perm_importance_df = pd.DataFrame({
    'Feature': feature_cols,
    'Importance': perm_importance.importances_mean,
    'Std': perm_importance.importances_std
}).sort_values('Importance', ascending=False)

# Визуализация
fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Gain-based importance
top_10_gain = gain_importance_df.head(10)
axes[0].barh(range(10), top_10_gain['Importance'], color='#2C3E50', alpha=0.8)
axes[0].set_yticks(range(10))
axes[0].set_yticklabels(top_10_gain['Feature'])
axes[0].set_xlabel('Gain-based Importance')
axes[0].set_title('Top-10 признаков (Gain)', fontweight='bold')
axes[0].invert_yaxis()
axes[0].grid(axis='x', alpha=0.3)

# Permutation importance
top_10_perm = perm_importance_df.head(10)
axes[1].barh(range(10), top_10_perm['Importance'], 
             xerr=top_10_perm['Std'], color='#3498DB', alpha=0.8)
axes[1].set_yticks(range(10))
axes[1].set_yticklabels(top_10_perm['Feature'])
axes[1].set_xlabel('Permutation Importance')
axes[1].set_title('Top-10 признаков (Permutation)', fontweight='bold')
axes[1].invert_yaxis()
axes[1].grid(axis='x', alpha=0.3)

plt.tight_layout()
plt.savefig('feature_importance_comparison.png', dpi=300, bbox_inches='tight')
plt.show()

# Вывод топ-10 признаков
print("\n" + "="*70)
print("Top-10 признаков по Gain-based Importance")
print("="*70)
print(gain_importance_df.head(10).to_string(index=False))
print("\n" + "="*70)
print("Top-10 признаков по Permutation Importance")
print("="*70)
print(perm_importance_df.head(10).to_string(index=False))
print("="*70)

Рис. 7: Сравнение 2-х метрик важности признаков для модели прогнозирования волатильности. Левая панель показывает gain-based importance — насколько каждый признак в среднем улучшает разбиения в деревьях. Правая панель демонстрирует permutation importance — падение качества модели при перестановке значений признака. Признак Butter_Range (сглаженный диапазон фильтром Баттеруорта) доминирует в обеих метриках. Абсолютные доходности и High-Low диапазон также вносят существенный вклад

======================================================================
Top-10 признаков по Gain-based Importance
======================================================================
           Feature  Importance
      Butter_Range    0.227625
       Abs_Returns    0.194788
          HL_Range    0.095616
      Close_Butter    0.048617
    HL_Range_Lag_1    0.036969
Butter_Range_Lag_1    0.036223
 Abs_Returns_Lag_1    0.024764
    HL_Range_Lag_3    0.024736
 Abs_Returns_Lag_2    0.022781
            EWMA_4    0.021870

======================================================================
Top-10 признаков по Permutation Importance
======================================================================
           Feature  Importance      Std
      Butter_Range    0.211098 0.055118
       Abs_Returns    0.167270 0.060618
          HL_Range    0.087954 0.039019
    HL_Range_Lag_3    0.038707 0.016686
        RV_4_Lag_1    0.026645 0.017122
Butter_Range_Lag_1    0.023744 0.016664
 Abs_Returns_Lag_2    0.013815 0.006870
      Close_Butter    0.013680 0.012836
              RV_2    0.009985 0.006796
            EWMA_8    0.005997 0.006811

Различия между метриками важности могут указывать на артефакты. Если признак имеет высокую важность по приросту качества (gain-based importance), но низкую важность по перестановке (permutation importance), возможно, он сильно коррелирует с другими признаками и дублирует их информацию.

Важность permutation importance более надежна для оценки истинного вклада признака, но требует больше вычислений. Использование обеих метрик вместе дает полное понимание роли признаков в модели.

Мониторинг переобучения

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

Библиотеки sklearn, XGBoost и LightGBM поддерживают раннюю остановку (early stopping) — автоматическую остановку обучения модели при отсутствии улучшения. В sklearn параметр n_iter_no_change задает число итераций без улучшения валидационной метрики перед остановкой, а validation_fraction — долю обучающих данных для валидации.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error

# Используем данные X_train, y_train

# Модель с early stopping
gb_early = GradientBoostingRegressor(
    n_estimators=300,  
    learning_rate=0.03,
    max_depth=4,
    min_samples_split=20,
    subsample=0.8,
    validation_fraction=0.2, # 20% train данных для валидации
    n_iter_no_change=50,     # Остановка если нет улучшения за 50 итераций
    random_state=42,
    verbose=0
)

gb_early.fit(X_train, y_train)

print(f"\nОбучение остановлено на {gb_early.n_estimators_} итерации")
print(f"(из максимальных {gb_early.n_estimators})")

# Модель без early stopping для сравнения
gb_full = GradientBoostingRegressor(
    n_estimators=300,
    learning_rate=0.03,
    max_depth=4,
    min_samples_split=20,
    subsample=0.8,
    random_state=42,
    verbose=0
)

gb_full.fit(X_train, y_train)

# Получение ошибок на каждой итерации
train_errors_full = []
test_errors_full = []

for pred_train, pred_test in zip(gb_full.staged_predict(X_train), gb_full.staged_predict(X_test)):
    train_errors_full.append(mean_squared_error(y_train, pred_train))
    test_errors_full.append(mean_squared_error(y_test, pred_test))

# Визуализация
fig, ax = plt.subplots(figsize=(12, 6))

ax.plot(range(1, len(train_errors_full) + 1), train_errors_full, 
        color='#3498DB', linewidth=2, label='Train MSE', alpha=0.8)
ax.plot(range(1, len(test_errors_full) + 1), test_errors_full, 
        color='#E74C3C', linewidth=2, label='Test MSE', alpha=0.8)

# Отметка точки early stopping
optimal_trees = gb_early.n_estimators_
ax.axvline(x=optimal_trees, color='#2C3E50', linestyle='--', 
           linewidth=2.5, label=f'Early Stop ({optimal_trees} trees)')

# Отметка минимума test MSE
min_test_idx = np.argmin(test_errors_full)
ax.scatter([min_test_idx + 1], [test_errors_full[min_test_idx]], 
           color='#2C3E50', s=100, zorder=5, label=f'Min Test MSE ({min_test_idx + 1} trees)')

ax.set_xlabel('Количество деревьев')
ax.set_ylabel('MSE')
ax.set_title('Early Stopping vs Полное обучение', fontweight='bold', fontsize=13)
ax.legend(loc='upper right')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Сравнение качества
y_pred_early = gb_early.predict(X_test)
y_pred_full = gb_full.predict(X_test)

from sklearn.metrics import r2_score

print("\n" + "="*60)
print("Сравнение моделей с Early Stopping и без")
print("="*60)
print(f"{'Метрика':<30} {'Early Stop':>12} {'Full (300)':>12}")
print("-"*60)
print(f"{'Количество деревьев':<30} {gb_early.n_estimators_:>12} {300:>12}")
print(f"{'Test R²':<30} {r2_score(y_test, y_pred_early):>12.4f} {r2_score(y_test, y_pred_full):>12.4f}")
print(f"{'Test RMSE':<30} {np.sqrt(mean_squared_error(y_test, y_pred_early)):>12.6f} {np.sqrt(mean_squared_error(y_test, y_pred_full)):>12.6f}")
print("="*60)

Обучение остановлено на 51 итерации
(из максимальных 300)

Сравнение моделей с Early Stopping и без
============================================================
Метрика                          Early Stop   Full (300)
------------------------------------------------------------
Количество деревьев                      51          300
Test R²                              0.4093       0.4218
Test RMSE                          0.005687     0.005627
============================================================

На примере выше мы видим что ранняя остановка (Early Stopping) позволила обучить модель на 51 дереве вместо 300 без значительной потери качества: тестовая R² изменилась несущественно (0.4093 vs 0.4218), а RMSE практически осталась той же. Это подтверждает, что модель достаточно обучена, и дальнейшие итерации только увеличивали риск переобучения, плюс время и вычислительные затраты на обучение.

Рис. 8: Демонстрация работы early stopping в градиентном бустинге. График показывает эволюцию ошибки на обучающей и тестовой выборках с увеличением количества деревьев. Тренировочная ошибка монотонно убывает, тестовая ошибка достигает минимума и начинает расти после определенного количества итераций. Вертикальная линия отмечает точку остановки, выбранную алгоритмом early stopping. Механизм автоматически определяет момент, когда дальнейшее обучение не улучшает генерализацию, экономя время и предотвращая переобучение

Механизм ранней остановки Early stopping служит эффективным способом регуляризации, который не требует заранее задавать оптимальное количество итераций. Этот подход особенно полезен при работе с новыми данными или в производственных системах, где важно экономить время обучения. В сочетании с подбором гиперпараметров (grid search) по скорости обучения (learning rate) и глубине деревьев (max_depth) он позволяет автоматически оптимизировать модель с минимальным участием специалиста.

Заключение

Градиентный бустинг — один из наиболее эффективных и универсальных методов машинного обучения для работы с табличными данными. Его сила в последовательной корректировке ошибок простыми моделями, что обеспечивает высокую точность без сложного создания признаков.

В отличие от бэггинга (Bagging), градиентный бустинг снижает смещение через зависимые модели, а не дисперсию через независимые. В сравнении с случайным лесом (Random Forest) он чаще обеспечивает более точные предсказания благодаря последовательному исправлению ошибок, хотя требует более внимательной настройки гиперпараметров. Понимание влияния скорости обучения (learning rate) помогает находить баланс между скоростью обучения и качеством обобщения.

Практическое применение моделей бустинга требует внимания к деталям:

1. Выбор функции потерь под конкретную задачу;
2. Контроль переобучения через валидацию;
3. Интерпретация важности признаков для проверки модели;
4. Анализ взаимодействия признаков и выявление мультиколлинеарности, чтобы понять, какие факторы реально влияют на прогноз;
5. Проверка адекватности модели на исторических и стрессовых сценариях, особенно для финансовых временных рядов, чтобы убедиться, что предсказания устойчивы к рыночным изменениям.

Современные библиотеки XGBoost, LightGBM и CatBoost расширяют базовый алгоритм регуляризацией и оптимизацией, делая градиентный бустинг конкурентоспособным даже на фоне глубокого обучения. Для структурированных данных — от прогнозирования волатильности до кредитного скоринга — метод остается надежным бейзлайном, который на практике нередко оказывается непревзойденным даже для более сложных моделей, в том числе трансформеров.