XGBoost vs LightGBM: 실전 부스팅 모델, 어떤 걸 써야 할까

Obj = Σᵢ₌₁ⁿ L(yᵢ, ŷᵢ)

Obj = Σᵢ₌₁ⁿ L(yᵢ, ŷᵢ) + Σₖ₌₁ᴷ Ω(fₖ)

Ω(f) = γT + (1/2)λ Σⱼ₌₁ᵀ wⱼ²

일반 Gradient Boosting:
  다음 트리가 학습할 타겟 = -∂L/∂ŷ  (1차 도함수만)

XGBoost:
  최적 리프 값 = -Σgᵢ / (Σhᵢ + λ)
  gᵢ = ∂L/∂ŷᵢ (그래디언트), hᵢ = ∂²L/∂ŷᵢ² (헤시안)

import xgboost as xgb

model = xgb.XGBClassifier(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=6,
    tree_method='hist',       # v2.0+ 기본값
    reg_lambda=1.0,           # L2 정규화
    reg_alpha=0.0,            # L1 정규화
    random_state=42
)

Level-wise (XGBoost 기본):
  깊이 1의 모든 노드를 먼저 분할
  → 깊이 2의 모든 노드를 분할
  → ...

  장점: 균형 잡힌 트리, 과적합 위험 낮음
  단점: 손실 감소가 작은 노드도 분할 → 계산 낭비


Leaf-wise (LightGBM):
  전체 트리에서 손실 감소가 가장 큰 리프 하나만 분할
  → 다시 가장 큰 리프를 찾아 분할
  → ...

  장점: 같은 리프 수에서 더 낮은 손실 달성
  단점: 불균형한 트리, 과적합 위험 높음 (특히 작은 데이터)

전체 데이터: 100만 개
  │
  ├─ 그래디언트 큰 상위 20% (a=0.2) → 20만 개 전부 유지
  └─ 나머지 80% → 10%만 랜덤 샘플링 (b=0.1) → 8만 개

  실제 학습 데이터: 28만 개 (72% 감소!)

  단, 샘플링된 8만 개의 그래디언트에는 (1-a)/b 배 가중치 부여
  → 전체 그래디언트 분포의 추정치가 편향되지 않도록 보정

원-핫 인코딩된 특성:
  city_seoul:   [1, 0, 0, 1, 0, ...]
  city_busan:   [0, 1, 0, 0, 1, ...]
  city_daegu:   [0, 0, 1, 0, 0, ...]

  → 세 특성이 동시에 1인 경우가 없음 (상호 배타적)

번들링 후:
  city_bundled: [1, 2, 3, 1, 2, ...]

  3개 특성 → 1개로 압축

import lightgbm as lgb

model = lgb.LGBMClassifier(
    n_estimators=100,
    learning_rate=0.1,
    num_leaves=31,            # 리프 수 직접 제어
    min_child_samples=20,     # 리프 최소 샘플 수
    random_state=42
)

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

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    cancer.data, cancer.target, test_size=0.2, random_state=42
)

# XGBoost
t0 = time.time()
xgb_model = xgb.XGBClassifier(
    n_estimators=100, learning_rate=0.1, max_depth=6,
    reg_lambda=1.0, random_state=42, verbosity=0
)
xgb_model.fit(X_train, y_train)
xgb_time = time.time() - t0

# LightGBM
t0 = time.time()
lgb_model = lgb.LGBMClassifier(
    n_estimators=100, learning_rate=0.1, num_leaves=31,
    random_state=42, verbosity=-1
)
lgb_model.fit(X_train, y_train)
lgb_time = time.time() - t0

print(f"{'모델':<12} {'훈련':>8} {'테스트':>8} {'시간':>10}")
print("-" * 42)
print(f"{'XGBoost':<12} {xgb_model.score(X_train, y_train):>8.4f} "
      f"{xgb_model.score(X_test, y_test):>8.4f} {xgb_time:>9.4f}s")
print(f"{'LightGBM':<12} {lgb_model.score(X_train, y_train):>8.4f} "
      f"{lgb_model.score(X_test, y_test):>8.4f} {lgb_time:>9.4f}s")

모델         훈련       테스트       시간
------------------------------------------
XGBoost      1.0000     0.9649    0.0812s
LightGBM     1.0000     0.9737    0.0356s

from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_squared_error
import numpy as np

housing = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(
    housing.data, housing.target, test_size=0.2, random_state=42
)
print(f"학습 데이터: {X_train.shape[0]:,}개, 특성: {X_train.shape[1]}개")

# XGBoost
t0 = time.time()
xgb_reg = xgb.XGBRegressor(
    n_estimators=500, learning_rate=0.05, max_depth=6,
    reg_lambda=1.0, subsample=0.8, colsample_bytree=0.8,
    random_state=42, verbosity=0
)
xgb_reg.fit(X_train, y_train)
xgb_time = time.time() - t0
xgb_rmse = np.sqrt(mean_squared_error(y_test, xgb_reg.predict(X_test)))

# LightGBM
t0 = time.time()
lgb_reg = lgb.LGBMRegressor(
    n_estimators=500, learning_rate=0.05, num_leaves=63,
    bagging_fraction=0.8, feature_fraction=0.8, bagging_freq=5,
    random_state=42, verbosity=-1
)
lgb_reg.fit(X_train, y_train)
lgb_time = time.time() - t0
lgb_rmse = np.sqrt(mean_squared_error(y_test, lgb_reg.predict(X_test)))

print(f"\n{'모델':<12} {'RMSE':>10} {'학습 시간':>12}")
print("-" * 38)
print(f"{'XGBoost':<12} {xgb_rmse:>10.4f} {xgb_time:>11.4f}s")
print(f"{'LightGBM':<12} {lgb_rmse:>10.4f} {lgb_time:>11.4f}s")

학습 데이터: 16,512개, 특성: 8개

모델            RMSE      학습 시간
--------------------------------------
XGBoost       0.4594       1.2847s
LightGBM      0.4611       0.4123s

import xgboost as xgb
import lightgbm as lgb

# XGBoost — eval_set + early_stopping_rounds (callbacks 방식)
xgb_model = xgb.XGBRegressor(
    n_estimators=1000, learning_rate=0.05, max_depth=6,
    early_stopping_rounds=50,
    random_state=42, verbosity=0
)
xgb_model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    verbose=False
)
print(f"XGBoost 최적 트리 수: {xgb_model.best_iteration}")

# LightGBM — callbacks 방식
lgb_model = lgb.LGBMRegressor(
    n_estimators=1000, learning_rate=0.05, num_leaves=63,
    random_state=42, verbosity=-1
)
lgb_model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    callbacks=[lgb.early_stopping(50), lgb.log_evaluation(0)]
)
print(f"LightGBM 최적 트리 수: {lgb_model.best_iteration_}")

XGBoost 최적 트리 수: 287
LightGBM 최적 트리 수: 214

from catboost import CatBoostClassifier

cat_model = CatBoostClassifier(
    iterations=100,
    learning_rate=0.1,
    depth=6,
    cat_features=[],    # 범주형 특성 인덱스 (있다면)
    verbose=0
)
cat_model.fit(X_train, y_train)
print(f"CatBoost 테스트: {cat_model.score(X_test, y_test):.4f}")

CatBoost 테스트: 0.9737

데이터 크기는?
│
├── 100만+ 행 ──────────────→ LightGBM (속도 압도적)
│
├── 10만-100만 행:
│   ├── 범주형 변수가 많다 ──→ CatBoost
│   ├── 빠른 반복 실험 필요 ─→ LightGBM
│   └── 최고 정확도 목표 ───→ XGBoost + 세밀한 튜닝
│
└── ~10만 행 이하:
    ├── 범주형 변수가 많다 ──→ CatBoost
    ├── 튜닝할 시간이 없다 ─→ CatBoost (기본값이 좋음)
    └── 세밀한 제어가 필요 ─→ XGBoost
        (LightGBM은 과적합 주의 — num_leaves 낮게)

# ❌ num_leaves가 너무 큼 → Leaf-wise 과적합
lgb_model = lgb.LGBMClassifier(num_leaves=256, max_depth=-1)

# ✅ num_leaves는 보수적으로, max_depth로 안전장치
lgb_model = lgb.LGBMClassifier(num_leaves=31, max_depth=7)
# num_leaves(31) < 2^max_depth(128) → 안전

# ❌ v1.x 시절 습관 — exact는 느리다
xgb_model = xgb.XGBClassifier(tree_method='exact')

# ✅ v2.0+에서는 지정하지 않아도 hist가 기본
xgb_model = xgb.XGBClassifier()  # tree_method='hist' 자동

# ❌ XGBoost 설정을 그대로 LightGBM에 복사
xgb_model = xgb.XGBClassifier(max_depth=6)
lgb_model = lgb.LGBMClassifier(max_depth=6)  # ⚠️ 의미가 다름

# ✅ 각 모델의 제어 방식에 맞게 세팅
xgb_model = xgb.XGBClassifier(max_depth=6)                    # 최대 64 리프
lgb_model = lgb.LGBMClassifier(num_leaves=63, max_depth=7)    # 63 리프 + 깊이 안전장치

# ❌ 무조건 원-핫 인코딩 (예전 습관)
import pandas as pd
df = pd.get_dummies(df, columns=['color', 'size'])

# ✅ LightGBM: 네이티브 범주형 지원
lgb_model = lgb.LGBMClassifier()
lgb_model.fit(X, y, categorical_feature=['color', 'size'])

# ✅ XGBoost v1.6+: enable_categorical
xgb_model = xgb.XGBClassifier(enable_categorical=True)
xgb_model.fit(X, y)  # dtype이 'category'인 컬럼 자동 인식