Как XGBoost работает с фичами?

Как XGBoost работает с фичами?

XGBoost (eXtreme Gradient Boosting) имеет свой уникальный подход к обработке признаков (фич), отличающийся от базового Gradient Boosting. Давайте разберёмся в деталях.

Основной механизм: построение деревьев решений

XGBoost строит деревья последовательно, где каждое новое дерево пытается исправить ошибки предыдущих. На каждом шаге алгоритм:

1. Вычисляет остатки (residuals) от текущих предсказаний
2. Обучает новое дерево на этих остатках
3. Добавляет дерево к ансамблю с определённым шагом обучения (learning rate)

Как XGBoost выбирает фичи для разделения

В каждом узле дерева XGBoost ищет лучшее разделение среди всех доступных признаков:

import xgboost as xgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

# Создаём датасет с 20 признаками
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Обучаем XGBoost
model = xgb.XGBClassifier(
    n_estimators=100,
    max_depth=5,
    learning_rate=0.1,
    random_state=42,
    tree_method=hist,  # или exact для точного поиска
    verbosity=0
)
model.fit(X_train, y_train)

# Получаем важность признаков
import pandas as pd
feature_importance = pd.DataFrame({
    feature: [ffeature_{i} for i in range(X.shape[1])],
    importance: model.feature_importances_
}).sort_values(importance, ascending=False)

print(feature_importance)

Методы поиска оптимального разделения

XGBoost поддерживает несколько методов построения деревьев:

1. Exact Greedy Algorithm (точный жадный алгоритм)

# tree_method=exact
# Для каждой фичи:
# - перебирает ВСЕ возможные точки разделения
# - вычисляет информационный выигрыш (gain)
# - выбирает разделение с максимальным gain

# Плюсы: точный результат
# Минусы: медленнее, требует больше памяти

2. Approximate Algorithm (приближённый алгоритм)

# tree_method=approx
# - предварительно квантизует значения фич (разбивает на бины)
# - ищет оптимальное разделение среди этих бинов
# - быстрее, требует меньше памяти

model = xgb.XGBClassifier(tree_method=approx, max_depth=5)
model.fit(X_train, y_train)

3. Histogram-Based Method (метод гистограмм)

# tree_method=hist — современный стандарт
# - самый быстрый
# - использует гистограммы для квантизации
# - поддерживает параллельное обучение

model = xgb.XGBClassifier(
    tree_method=hist,
    max_bin=256,  # количество бинов для гистограмм
    n_jobs=-1
)
model.fit(X_train, y_train)

Расчёт gain (информационный выигрыш)

Для каждого потенциального разделения XGBoost вычисляет gain — метрику улучшения:

# Формула gain в XGBoost (упрощённо):
# Gain = (G_L^2 / (H_L + lambda)) + (G_R^2 / (H_R + lambda)) 
#        - (G^2 / (H + lambda))

# Где:
# G_L, G_R = сумма градиентов слева и справа от разделения
# H_L, H_R = сумма вторых производных (Hessian) слева и справа
# lambda = параметр регуляризации L2

# XGBoost использует ВТорые производные (Hessian),
# в отличие от обычного Gradient Boosting (только первые производные)

Регуляризация фич

XGBoost имеет встроенную регуляризацию, которая влияет на выбор фич:

model = xgb.XGBClassifier(
    lambda=1.0,        # L2 регуляризация (Ridge)
    alpha=0.0,         # L1 регуляризация (Lasso) — обнуляет коэффициенты
    max_depth=5,       # ограничивает глубину дерева
    min_child_weight=1, # минимальный вес (сумма Hessian) в листе
    subsample=0.8,     # выборка строк для каждого дерева (80%)
    colsample_bytree=0.8,  # выборка фич для каждого дерева
    colsample_bylevel=0.8,  # выборка фич для каждого уровня дерева
    colsample_bynode=0.8    # выборка фич для каждого узла
)
model.fit(X_train, y_train)

Анализ использования фич

# Сколько раз каждая фича использовалась в разделениях
feature_freq = model.get_booster().get_score(importance_type=frequency)
print("Frequency (сколько раз использовалась):")
for feat, count in sorted(feature_freq.items(), key=lambda x: x[1], reverse=True)[:10]:
    print(f"{feat}: {count}")

# Сумма gain по всем разделениям фичи
feature_gain = model.get_booster().get_score(importance_type=gain)
print("\nGain (улучшение качества):")
for feat, gain in sorted(feature_gain.items(), key=lambda x: x[1], reverse=True)[:10]:
    print(f"{feat}: {gain:.4f}")

# Сумма cover (количество примеров в узле)
feature_cover = model.get_booster().get_score(importance_type=cover)
print("\nCover (количество примеров):")
for feat, cov in sorted(feature_cover.items(), key=lambda x: x[1], reverse=True)[:10]:
    print(f"{feat}: {cov}")

Поддержка типов фич

XGBoost нативно работает с числовыми признаками.

Для категориальных фич:

# Способ 1: One-hot encoding
from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder(sparse_output=False)
X_encoded = encoder.fit_transform(X_categorical)
model.fit(X_encoded, y)

# Способ 2: Label encoding (если есть порядок)
from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
X_encoded = X_categorical.copy()
for col in X_categorical.columns:
    X_encoded[col] = le.fit_transform(X_encoded[col])
model.fit(X_encoded, y)

# Способ 3: Нативная поддержка категорий (XGBoost 1.5+)
# используя GPU или специальные параметры
model = xgb.XGBClassifier(
    tree_method=gpu_hist,
    enable_categorical=True  # Экспериментальная фича
)

Обработка пропусков

XGBoost автоматически обрабатывает пропуски (NaN):

import numpy as np

X_with_nan = X_train.copy()
X_with_nan[0, 0] = np.nan  # Добавляем пропуск

# XGBoost автоматически:
# - отправляет примеры с NaN в левое или правое поддерево
# - выбирает направление, которое максимизирует gain

model = xgb.XGBClassifier()
model.fit(X_with_nan, y_train)  # Работает без проблем

Шкалирование фич

Важный момент: XGBoost, как и другие tree-based модели, НЕ требует шкалирования числовых признаков:

# Это не нужно для XGBoost:
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_train)

# Деревья инвариантны к монотонным преобразованиям
# XGBoost будет работать одинаково хорошо с X_train и X_scaled

Пример полного workflow

import xgboost as xgb
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score

X, y = make_classification(n_samples=5000, n_features=30, n_informative=15, random_state=42)

model = xgb.XGBClassifier(
    n_estimators=200,
    max_depth=6,
    learning_rate=0.05,
    subsample=0.8,
    colsample_bytree=0.8,
    min_child_weight=5,
    gamma=1,  # минимальное улучшение для разделения
    tree_method=hist,
    random_state=42
)

# Cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring=roc_auc)
print(f"CV ROC AUC: {scores.mean():.4f} (+/- {scores.std():.4f})")

# Обучаем на всех данных
model.fit(X, y)

# Анализируем фичи
feature_importance = model.feature_importances_
top_features = np.argsort(feature_importance)[-10:][::-1]
print(f"\nTop 10 features: {top_features}")

Ключевые выводы

1. XGBoost автоматически выбирает фичи при построении каждого дерева
2. Использует жадный алгоритм поиска оптимального разделения по gain
3. Поддерживает несколько методов: exact, approximate, histogram-based
4. Использует вторые производные (Hessian) для более точной оптимизации
5. Автоматически обрабатывает пропуски в данных
6. Не требует шкалирования числовых признаков
7. Выбор фич регулируется параметрами: subsample, colsample_*, min_child_weight, gamma, lambda, alpha