부스팅(Boosting): 약한 모델을 순차적으로 쌓아 강한 모델 만들기

배깅 선택 → 데이터에 노이즈가 많거나, 빠른 학습이 필요하거나, 과적합이 걱정될 때
부스팅 선택 → 정확도를 최대로 끌어올려야 할 때, 데이터가 비교적 깨끗할 때

1. 모든 샘플에 동일한 초기 가중치 부여: w_i = 1/N

2. 반복 (t = 1, 2, ..., T):
   a. 가중치 w를 사용해 약한 분류기 h_t 학습
   b. 가중 오류율 계산: ε_t = Σ w_i × 𝟙[h_t(x_i) ≠ y_i]
   c. 분류기 가중치 계산: α_t = 0.5 × ln((1-ε_t) / ε_t)
   d. 가중치 업데이트:
      - 오분류 샘플: w_i ← w_i × exp(+α_t)  (가중치 증가)
      - 정분류 샘플: w_i ← w_i × exp(-α_t)  (가중치 감소)
   e. 가중치 정규화: w_i ← w_i / Σw_j

3. 최종 예측: H(x) = sign(Σ α_t × h_t(x))

import numpy as np

def adaboost_alpha(error_rate):
    """분류기 가중치 계산"""
    # ε이 0이나 1에 너무 가까우면 클리핑
    eps = np.clip(error_rate, 1e-10, 1 - 1e-10)
    return 0.5 * np.log((1 - eps) / eps)

def update_weights(weights, alpha, correct_mask):
    """샘플 가중치 업데이트 및 정규화"""
    # 정분류: exp(-alpha), 오분류: exp(+alpha)
    w = weights.copy()
    w[correct_mask] *= np.exp(-alpha)
    w[~correct_mask] *= np.exp(alpha)
    return w / w.sum()  # 정규화

# 예시: 오류율에 따른 alpha 값
for err in [0.30, 0.20, 0.12]:
    alpha = adaboost_alpha(err)
    print(f"오류율 {err:.2f} → alpha = {alpha:.4f}")

오류율 0.30 → alpha = 0.4236
오류율 0.20 → alpha = 0.6931
오류율 0.12 → alpha = 0.9962

from sklearn.ensemble import AdaBoostClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

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
)

# 기본값: 100개 결정 그루터기(Decision Stump, max_depth=1)
ada = AdaBoostClassifier(
    n_estimators=100,
    learning_rate=1.0,
    random_state=42
)
ada.fit(X_train, y_train)

print(f"훈련 정확도: {ada.score(X_train, y_train):.4f}")
print(f"테스트 정확도: {ada.score(X_test, y_test):.4f}")

훈련 정확도: 1.0000
테스트 정확도: 0.9737

목표: y = 100을 예측하고 싶다

F1(x) = 70 (첫 번째 모델 예측)
잔차 = y - F1(x) = 100 - 70 = +30

→ h2는 잔차 30을 학습
F2(x) = F1(x) + η × h2(x) = 70 + 0.1 × 30 = 73

→ h3는 새 잔차 27을 학습
F3(x) = F2(x) + η × h3(x) = 73 + 0.1 × 27 = 75.7

...반복...

F_0(x) = 초기 예측 (보통 평균값)
F_m(x) = F_{m-1}(x) + η × h_m(x)

여기서 h_m은 음의 그래디언트(negative gradient)를 타겟으로 학습:
r_{im} = -∂L(y_i, F(x_i)) / ∂F(x_i)

MSE 손실일 때: r_{im} = y_i - F_{m-1}(x_i)  ← 바로 잔차!

import numpy as np

# Gradient Boosting 핵심 로직 (MSE 회귀 예시)
y_true = np.array([100.0, 150.0, 200.0, 250.0, 300.0])

# Step 0: 초기 예측 = 평균
F = np.full_like(y_true, y_true.mean())
print(f"F0(x) = {F[0]:.1f} (평균)")
print(f"잔차(음의 그래디언트): {y_true - F}")

# Step 1: 잔차를 타겟으로 약한 분류기 h1 학습 (단순화: 잔차를 그대로 사용)
lr = 0.1
residuals = y_true - F
# h1이 잔차를 완벽히 예측한다고 가정
F = F + lr * residuals
print(f"\nF1(x) = {F}")
print(f"새 잔차: {(y_true - F).round(2)}")

F0(x) = 200.0 (평균)
잔차(음의 그래디언트): [-100.  -50.    0.   50.  100.]

F1(x) = [190. 195. 200. 205. 210.]
새 잔차: [-90. -45.   0.  45.  90.]

from sklearn.ensemble import GradientBoostingClassifier

gb = GradientBoostingClassifier(
    n_estimators=100,      # 약한 학습기(트리) 수
    learning_rate=0.1,     # 학습률 η
    max_depth=3,           # 각 트리의 최대 깊이
    subsample=1.0,         # 샘플링 비율 (1.0 = 전체 사용)
    random_state=42
)
gb.fit(X_train, y_train)

print(f"훈련 정확도: {gb.score(X_train, y_train):.4f}")
print(f"테스트 정확도: {gb.score(X_test, y_test):.4f}")

훈련 정확도: 1.0000
테스트 정확도: 0.9561

일반 GBM/XGBoost: 레벨 중심(Level-wise)
  분할: 모든 리프를 한 레벨씩 동시에 확장
  → 균형 잡힌 트리, 안정적이지만 느림

LightGBM: 리프 중심(Leaf-wise)
  분할: 손실 감소가 가장 큰 리프 하나만 확장
  → 불균형한 트리, 더 빠르고 정확하지만 과적합 위험

Level-wise:          Leaf-wise:
    Root               Root
   /    \             /    \
  A      B           A      B
 / \    / \         / \
C   D  E   F       C   D  ← D가 가장 큰 손실 감소
                        / \
                       G   H  ← 계속 D 방향 확장

from sklearn.ensemble import HistGradientBoostingClassifier

hgb = HistGradientBoostingClassifier(
    max_iter=100,
    learning_rate=0.1,
    random_state=42
)
hgb.fit(X_train, y_train)

print(f"훈련 정확도: {hgb.score(X_train, y_train):.4f}")
print(f"테스트 정확도: {hgb.score(X_test, y_test):.4f}")

훈련 정확도: 1.0000
테스트 정확도: 0.9737

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
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
)

models = {
    'DecisionTree': DecisionTreeClassifier(random_state=42),
    'RandomForest': RandomForestClassifier(n_estimators=100, random_state=42),
    'GradientBoosting': GradientBoostingClassifier(
        n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42
    ),
}

print(f"{'모델':<20} {'훈련 정확도':>12} {'테스트 정확도':>12} {'학습 시간':>10}")
print("-" * 58)
for name, m in models.items():
    t0 = time.time()
    m.fit(X_train, y_train)
    elapsed = time.time() - t0
    tr = m.score(X_train, y_train)
    te = m.score(X_test, y_test)
    print(f"{name:<20} {tr:>12.4f} {te:>12.4f} {elapsed:>9.4f}s")

모델                 훈련 정확도   테스트 정확도    학습 시간
----------------------------------------------------------
DecisionTree         1.0000       0.9474      0.0035s
RandomForest         1.0000       0.9649      0.0759s
GradientBoosting     1.0000       0.9561      0.2109s

import matplotlib.pyplot as plt
import numpy as np

feature_names = cancer.feature_names
fig, axes = plt.subplots(1, 3, figsize=(18, 6))

for ax, (name, m) in zip(axes, models.items()):
    importances = m.feature_importances_
    top_idx = np.argsort(importances)[-10:]
    ax.barh(feature_names[top_idx], importances[top_idx], color='#0d9488')
    ax.set_title(f'{name}\n특성 중요도 Top 10', fontsize=11)
    ax.set_xlabel('중요도')

plt.tight_layout()
plt.show()

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

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

learning_rates = [0.001, 0.01, 0.1, 1.0]
n_est_range = [5, 10, 20, 50, 100, 150, 200]

for lr in learning_rates:
    gb = GradientBoostingClassifier(
        n_estimators=200, learning_rate=lr, max_depth=3, random_state=42
    )
    gb.fit(X_train, y_train)
    print(f"lr={lr:.3f}: train={gb.score(X_train, y_train):.4f}, "
          f"test={gb.score(X_test, y_test):.4f}")

lr=0.001: train=0.6286, test=0.6228
lr=0.010: train=0.9934, test=0.9561
lr=0.100: train=1.0000, test=0.9561
lr=1.000: train=1.0000, test=0.9649

학습률 × n_estimators ≈ 일정

lr=0.1, n_estimators=100 ≈ lr=0.01, n_estimators=1000
(같은 "총 학습량", 하지만 낮은 lr이 더 부드럽게 수렴)

# 빠른 프로토타이핑
GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)

# 최고 성능 추구 (시간이 있다면)
GradientBoostingClassifier(n_estimators=1000, learning_rate=0.01, max_depth=3,
                            subsample=0.8)  # subsample < 1.0으로 확률적 GBM

from sklearn.ensemble import GradientBoostingClassifier

gb = GradientBoostingClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=3,
    validation_fraction=0.1,     # 10%를 검증용으로 사용
    n_iter_no_change=20,         # 20번 개선이 없으면 멈춤
    tol=1e-4,                    # 개선 임계값
    random_state=42
)
gb.fit(X_train, y_train)

print(f"실제 사용된 트리 수: {gb.n_estimators_}")
print(f"테스트 정확도: {gb.score(X_test, y_test):.4f}")

실제 사용된 트리 수: 173
테스트 정확도: 0.9615

# ❌ n_estimators만 늘린다 (학습률 고정)
gb = GradientBoostingClassifier(n_estimators=1000, learning_rate=0.1)
# learning_rate=0.1에서 100개면 이미 충분히 수렴했을 수 있다
# → 1000개는 낭비 + 과적합 위험

# ✅ 학습률을 낮추면서 n_estimators도 함께 늘린다
gb = GradientBoostingClassifier(n_estimators=1000, learning_rate=0.01)
# 학습률과 트리 수는 함께 조정해야 한다

# ❌ 이상치가 있는 데이터를 그대로 부스팅에 넣는다
ada = AdaBoostClassifier(n_estimators=100)
ada.fit(X_with_outliers, y)
# AdaBoost는 오분류 샘플에 가중치를 부여 → 이상치가 계속 높은 가중치를 받음
# → 이상치를 맞추기 위해 모델이 비틀린다

# ✅ 이상치 제거 또는 RobustScaler 사용, 또는 Huber 손실 함수 사용
from sklearn.ensemble import GradientBoostingClassifier
gb = GradientBoostingClassifier(loss='log_loss')  # 분류에는 log_loss가 안정적

# ❌ 깊은 트리 → 각 약한 학습기가 너무 강함 → 한두 번의 부스팅으로 과적합
gb = GradientBoostingClassifier(n_estimators=100, max_depth=8)

# ✅ Gradient Boosting의 권장 max_depth는 3~5
gb = GradientBoostingClassifier(n_estimators=100, max_depth=3)
# 약한 학습기답게 약해야 부스팅이 제 역할을 한다

선형 회귀 → 로지스틱 회귀 → 결정 트리 → 배깅(랜덤 포레스트) → 부스팅
   │              │              │                │                  │
  직선으로        확률로         질문으로        병렬로            순차로
  예측           분류           분기            합산              보완