В чём разница в реализации алгоритма между XGBoost и LightGBM?

Разница в реализации между XGBoost и LightGBM

Это две популярные библиотеки для gradient boosting, которые отличаются архитектурой и оптимизациями.

XGBoost (eXtreme Gradient Boosting)

Основные характеристики:

• Построение дерева: level-wise (по уровням)
• Обрабатывает каждый уровень целиком, затем переходит к следующему
• Может быть медленнее на больших датасетах
• Более стабилен и консервативен
• Полная информация о значениях весов (regularization L1/L2)

import xgboost as xgb
import numpy as np

# Данные
X = np.random.rand(1000, 10)
y = np.random.rand(1000)

# XGBoost
model_xgb = xgb.XGBRegressor(
    max_depth=5,
    learning_rate=0.1,
    n_estimators=100
)
model_xgb.fit(X, y)

print(f"XGBoost训练时间: ...")

LightGBM (Light Gradient Boosting Machine)

Основные характеристики:

• Построение дерева: leaf-wise (по листьям)
• Растит дерево вширь, выбирая листья с наибольшим loss reduction
• Намного быстрее на больших датасетах
• Может переобучиться на малых датасетах
• Использует Histogram-based learning

import lightgbm as lgb
import numpy as np

# Данные
X = np.random.rand(1000, 10)
y = np.random.rand(1000)

# LightGBM
model_lgb = lgb.LGBMRegressor(
    max_depth=5,
    learning_rate=0.1,
    n_estimators=100,
    num_leaves=31  # Характерный параметр LightGBM
)
model_lgb.fit(X, y)

print(f"LightGBM время: ...")

Стратегия роста дерева

XGBoost - Level-wise (слой за слоем):

        root
       /    \
      *      *     <- уровень 1
     / \    / \
    *   *  *   *   <- уровень 2


LightGBM - Leaf-wise (лист за листом):

        root
       /    \
      *      *     
     / \    / \
    *  (+)(*)(+)   <- растет выборочно

Таблица сравнения

Детальное сравнение

1. Построение дерева

from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
import xgboost as xgb
import lightgbm as lgb

X, y = make_regression(n_samples=10000, n_features=100, random_state=42)

# XGBoost - level-wise
xgb_model = xgb.XGBRegressor(
    max_depth=7,
    n_estimators=100,
    learning_rate=0.1,
    tree_method='hist'  # histogram-based для скорости
)

# LightGBM - leaf-wise
lgb_model = lgb.LGBMRegressor(
    max_depth=7,
    num_leaves=128,  # 2^7 = 128
    n_estimators=100,
    learning_rate=0.1
)

# Оценка
xgb_score = cross_val_score(xgb_model, X, y, cv=5, scoring='r2').mean()
lgb_score = cross_val_score(lgb_model, X, y, cv=5, scoring='r2').mean()

print(f"XGBoost R²: {xgb_score:.4f}")
print(f"LightGBM R²: {lgb_score:.4f}")

2. Histogram-based Learning

# LightGBM использует гистограммы для ускорения
# Вместо точных значений features используется бины

lgb_model = lgb.LGBMRegressor(
    max_bin=255,  # Количество бинов для гистограммы
    feature_fraction=0.8,  # Случайный выбор признаков
    bagging_fraction=0.8,  # Случайный выбор примеров
    bagging_freq=5,  # Каждые N итераций
    verbose=-1
)

3. Обработка категориальных признаков

# XGBoost требует кодирования
import pandas as pd

df = pd.DataFrame({
    'color': ['red', 'blue', 'red', 'green'],
    'value': [1, 2, 3, 4]
})

# Нужно кодировать
df['color_encoded'] = pd.Categorical(df['color']).codes
xgb_model.fit(df[['color_encoded']], df['value'])

# LightGBM может обрабатывать напрямую
lgb_model.fit(df[['color']], df['value'], 
              categorical_feature=['color'])

Когда использовать XGBoost

1. Малые/средние датасеты (< 100K примеров)
2. Конкурсы (Kaggle) - стабилен, проверен
3. Нужна максимальная точность на небольшом объеме
4. Требуется интерпретируемость - лучше поддерживается

import xgboost as xgb

model = xgb.XGBClassifier(
    max_depth=5,
    learning_rate=0.1,
    subsample=0.8,
    colsample_bytree=0.8
)
model.fit(X_train, y_train)

# Важность признаков
import matplotlib.pyplot as plt
xgb.plot_importance(model)
plt.show()

Когда использовать LightGBM

1. Большие датасеты (> 100K примеров)
2. Нужна скорость обучения
3. Ограничены ресурсы (память, время)
4. Много признаков (> 100)

import lightgbm as lgb

model = lgb.LGBMClassifier(
    num_leaves=31,
    max_depth=-1,  # Неограниченная глубина
    learning_rate=0.1,
    feature_fraction=0.8,
    bagging_fraction=0.8,
    num_leaves=32,
    verbose=-1
)
model.fit(X_train, y_train)

# Важность признаков
lgb.plot_importance(model)
plt.show()

Практический пример: сравнение производительности

import time
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import xgboost as xgb
import lightgbm as lgb

# Большой датасет
X, y = make_classification(n_samples=100000, n_features=200, 
                          n_informative=50, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# XGBoost
print("XGBoost обучение...")
start = time.time()
xgb_model = xgb.XGBClassifier(n_estimators=100, tree_method='hist')
xgb_model.fit(X_train, y_train)
xgb_time = time.time() - start
xgb_score = xgb_model.score(X_test, y_test)
print(f"Время: {xgb_time:.2f}s, Accuracy: {xgb_score:.4f}")

# LightGBM
print("LightGBM обучение...")
start = time.time()
lgb_model = lgb.LGBMClassifier(n_estimators=100)
lgb_model.fit(X_train, y_train)
lgb_time = time.time() - start
lgb_score = lgb_model.score(X_test, y_test)
print(f"Время: {lgb_time:.2f}s, Accuracy: {lgb_score:.4f}")

print(f"\nLightGBM быстрее в {xgb_time/lgb_time:.1f}x раз")

Гиперпараметры

XGBoost:

• max_depth - глубина дерева
• learning_rate - скорость обучения
• subsample - доля примеров для обучения
• colsample_bytree - доля признаков

LightGBM:

• num_leaves - число листьев (вместо max_depth)
• max_depth - максимальная глубина (опционально)
• learning_rate - скорость обучения
• feature_fraction - доля признаков
• bagging_fraction - доля примеров
• bagging_freq - частота bagging

Вывод

• XGBoost: стабильнее, лучше на малых датасетах, более проверен
• LightGBM: быстрее, лучше на больших датасетах, меньше памяти
• Выбирай на основе: размера данных, требуемой скорости и ресурсов
• На практике: часто используют оба, сравнивают результаты