Belajar Machine Learning - Gradient Boosting Lanjutan & XGBoost Deep Dive

#Pendahuluan

Di episode 7 kita mengenal gradient boosting dan memakainya sebagai baseline. Episode ini kita membongkarnya sampai ke dalam: mengapa GBM begitu dominan di data tabular 2026, hyperparameter mana yang paling berpengaruh, bagaimana mengendalikan overfitting, dan bagaimana mempercepat training dengan GPU. Di akhir, kalian akan tahu cara memilih dan mengatur GBM secara profesional — bukan sekadar memakai default.

Mengapa topik ini layak satu episode penuh? Karena untuk data tabular — jenis data terbanyak di industri — gradient boosting adalah state of the art. Menguasai tuning-nya adalah keterampilan yang langsung terbayar di proyek nyata maupun kompetisi.

#Cara Kerja Boosting (Mengapa Ia Kuat)

Boosting membangun model sebagai jumlah dari pohon-pohon lemah yang dilatih berurutan. Pohon baru t+1 difokuskan untuk memperbaiki residual — kesalahan — yang tersisa dari gabungan pohon sebelumnya.

import numpy as np
from sklearn.tree import DecisionTreeRegressor
 
pred = np.zeros(len(y_train))
for _ in range(10):
    residual = y_train - pred
    stump = DecisionTreeRegressor(max_depth=2).fit(X_train, residual)
    pred = pred + 0.1 * stump.predict(X_train)

Kunci kekuatannya ada di dua parameter:

• learning_rate (eta): seberapa besar kontribusi tiap pohon. Kecil = lebih hati-hati tapi butuh banyak pohon.
• n_estimators: jumlah pohon. Banyak = lebih kuat tapi rawan overfit.

Inilah trade-off inti: learning_rate kecil + n_estimators besar umumnya akurat, selama dihentikan di titik yang tepat (early stopping).

#Hyperparameter Paling Penting per Library

#XGBoost

import xgboost as xgb
 
model = xgb.XGBClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=6,
    min_child_weight=5,
    gamma=0.1,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0.1,
    reg_lambda=1.0,
    tree_method="hist",
    random_state=42,
    eval_metric="logloss",
)

#LightGBM

import lightgbm as lgb
 
model = lgb.LGBMClassifier(
    n_estimators=500,
    learning_rate=0.05,
    num_leaves=31,
    min_child_samples=20,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0.1,
    reg_lambda=1.0,
    random_state=42,
)

Perbedaan kunci LightGBM: leaf-wise growth — ia menumbuhkan daun yang paling menguntungkan, bukan level penuh seperti XGBoost (level-wise). Konsekuensinya: num_leaves lebih sensitif daripada max_depth; terlalu besar = overfit instan.

#CatBoost

from catboost import CatBoostClassifier
 
model = CatBoostClassifier(
    iterations=500,
    learning_rate=0.05,
    depth=6,
    l2_leaf_reg=3.0,
    cat_features=["kota", "produk"],
    eval_metric="Logloss",
    random_seed=42,
    verbose=False,
)

CatBoost menonjol di tiga hal: ordered boosting (anti-leakage), native categorical support, dan performa stabil dengan default yang baik — paling jarang butuh tuning dalam.

#Kontrol Overfitting

Boosting adalah model dengan kapasitas besar — ia bisa overfit jika dibiarkan. Dua mekanisme paling efektif:

#1. Early Stopping

Latih dengan validation set, berhenti saat error tidak membaik:

model.fit(
    X_train, y_train,
    eval_set=[(X_val, y_val)],
    eval_metric="auc",
    callbacks=[lgb.early_stopping(50), lgb.log_evaluation(0)],
)
print(f"best_iteration = {model.best_iteration_}")

Model otomatis menemukan jumlah pohon optimal — tidak perlu menebak n_estimators.

#2. Regularisasi dan Sampling

Gabungkan kontrol kapasitas (depth/leaves) dengan regularisasi (alpha/lambda) dan sampling (subsample/colsample). Aturan praktis untuk data dengan banyak noise:

• Kurangi max_depth / num_leaves.
• Turunkan learning_rate menjadi 0.01-0.05.
• Naikkan min_child_samples / min_child_weight.
• Aktifkan regularisasi L1/L2.

#GPU Acceleration

XGBoost dan LightGBM mendukung training GPU dengan perubahan minimal:

pip install xgboost --upgrade

model = xgb.XGBClassifier(
    tree_method="hist",
    device="cuda",
    n_estimators=500,
    learning_rate=0.05,
)

Percepatan GPU paling terasa di dataset besar (jutaan baris) dan n_estimators besar — untuk data kecil, overhead transfer CPU/GPU justru bisa memperlambat. Jangan langsung asumsi GPU selalu menang; ukur dulu.

#Benchmark Tabular dan Praktik

Alur yang saya sarankan untuk benchmark GBM di dataset kalian:

import time
import lightgbm as lgb
import xgboost as xgb
from catboost import CatBoostClassifier
 
def bench(name, model, X, y):
    start = time.time()
    model.fit(X, y)
    score = model.score(X_test, y_test)
    print(f"{name}: acc={score:.4f} ({time.time()-start:.1f}s)")
 
bench("XGBoost", xgb.XGBClassifier(tree_method="hist", random_state=42,
                                   eval_metric="logloss"), X_train, y_train)
bench("LightGBM", lgb.LGBMClassifier(random_state=42), X_train, y_train)
bench("CatBoost", CatBoostClassifier(verbose=False, random_seed=42),
      X_train, y_train)

Yang penting: ukur akurasi dan waktu sekaligus, dengan split yang sama. Library terbaik di dataset A belum tentu terbaik di dataset B — itulah kenapa benchmark langsung lebih berharga daripada rekomendasi dari artikel.

#Interpretasi dengan SHAP

Model GBM kuat tapi sulit dijelaskan. SHAP (Shapley Additive Explanations) memberi nilai kontribusi tiap fitur untuk tiap prediksi:

import shap
 
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
 
shap.summary_plot(shap_values, X_test, feature_names=X.columns)

Plot summary SHAP menjawab dua pertanyaan sekaligus: fitur mana yang paling penting, dan arah pengaruhnya (nilai tinggi menaikkan atau menurunkan prediksi). Detail lengkap interpretasi model kita bahas di episode 20.

#Common Pitfalls

• Tuning n_estimators dan learning_rate terpisah — suboptimal dan boros.
• num_leaves LightGBM terlalu besar — overfit cepat, tidak terlihat di train.
• Tanpa early stopping — n_estimators asal pilih.
• GPU untuk dataset kecil — overhead transfer justru lambat.
• Membandingkan library dengan parameter default yang tidak seimbang — benchmark tidak adil.

#Penutup

Pada episode 19 ini, kalian telah mendalami gradient boosting secara profesional.

Inti yang harus dibawa pulang:

• Boosting = jumlah pohon yang memperbaiki residual; learning_rate × n_estimators adalah pasangan kunci.
• Tuning inti: depth/leaves, min_child, subsample, colsample, dan regularisasi L1/L2.
• Early stopping adalah kontrol overfitting paling praktis.
• GPU mempercepat training dataset besar — ukur dulu sebelum memakai.
• SHAP menjelaskan kontribusi dan arah tiap fitur.

Di episode 20 selanjutnya kita membahas model interpretation (XAI) — SHAP, LIME, permutation importance, dan partial dependence, lengkap dengan praktik explainability untuk stakeholder dan kepatuhan seperti credit scoring. Sampai jumpa di episode 20!