LightGBM | Cara kerja dan tips tuning

1. Fitur utama #

• Leaf-wise growth: mengembangkan leaf dengan penurunan loss terbesar. Atur dengan max_depth atau num_leaves.
• Histogram approximation: mengelompokkan nilai kontinu (mis. 256 bin) untuk mengurangi komputasi dan memori.
• Reuse gradien/Hessian: agregasi statistik per bin meningkatkan efisiensi cache.
• Dukungan kategorikal native: memilih split biner optimal tanpa one-hot.
• Fitur produksi: early stopping, sample weight, monotonic constraints, GPU.

2. Tujuan dalam rumus #

Seperti gradient boosting biasa, LightGBM menambahkan weak learner berdasarkan gradien negatif.

$$ \mathcal{L} = \sum_{i=1}^n \ell\big(y_i, F_{m-1}(x_i) + f_m(x_i)\big) + \Omega(f_m) $$

LightGBM mengumpulkan gradien \(g_i\) dan Hessian \(h_i\) per histogram bin lalu menghitung gain split:

$$ \text{Gain} = \frac{1}{2} \left( \frac{\left(\sum_{i \in L} g_i\right)^2}{\sum_{i \in L} h_i + \lambda} + \frac{\left(\sum_{i \in R} g_i\right)^2}{\sum_{i \in R} h_i + \lambda} - \frac{\left(\sum_{i \in (L \cup R)} g_i\right)^2}{\sum_{i \in (L \cup R)} h_i + \lambda} \right) - \gamma $$

\(\lambda\) adalah regularisasi L2 dan \(\gamma\) adalah penalti split.

3. Klasifikasi biner dengan Python #

import lightgbm as lgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score

X, y = make_classification(
    n_samples=30_000,
    n_features=40,
    n_informative=12,
    n_redundant=8,
    weights=[0.85, 0.15],
    random_state=42,
)

X_train, X_valid, y_train, y_valid = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

params = {
    "objective": "binary",
    "metric": ["binary_logloss", "auc"],
    "learning_rate": 0.05,
    "num_leaves": 31,
    "feature_fraction": 0.8,
    "bagging_fraction": 0.8,
    "bagging_freq": 5,
    "lambda_l2": 1.0,
    "min_data_in_leaf": 30,
}

train_data = lgb.Dataset(X_train, label=y_train)
valid_data = lgb.Dataset(X_valid, label=y_valid)

gbm = lgb.train(
    params,
    train_data,
    num_boost_round=1000,
    valid_sets=[train_data, valid_data],
    valid_names=["train", "valid"],
    callbacks=[lgb.early_stopping(stopping_rounds=50, verbose=True)],
)

y_pred = gbm.predict(X_valid)
print("ROC-AUC:", roc_auc_score(y_valid, y_pred))
print(classification_report(y_valid, (y_pred > 0.5).astype(int)))

Early stopping memungkinkan num_boost_round besar tanpa overfitting.

4. Hiperparameter utama #

5. Fitur kategorikal dan missing value #

• Cukup berikan indeks/nama kolom ke categorical_feature. Tidak perlu target encoding.
• Missing value diarahkan ke cabang khusus; dengan banyak missing, pertimbangkan imputasi.
• Monotonic constraints tersedia lewat monotone_constraints.

categorical_cols = [0, 2, 5]
train_data = lgb.Dataset(
    X_train,
    label=y_train,
    categorical_feature=categorical_cols,
)

6. Alur tuning yang praktis #

1. Baseline: learning_rate=0.1, num_leaves=31, feature_fraction=1.0.
2. Kapasitas: atur num_leaves dan min_data_in_leaf sambil memantau loss validasi.
3. Randomisasi: set feature_fraction atau bagging_fraction ke 0.6–0.9.
4. Regularisasi: tambahkan lambda_l1/lambda_l2 atau min_gain_to_split.
5. Turunkan learning rate: jika mentok, gunakan 0.01 dan tambah num_boost_round.
6. Ensemble: gabungkan beberapa LightGBM dengan seed/inisialisasi berbeda.

7. Ringkasan #

• LightGBM mengandalkan histogram dan leaf-wise growth untuk boosting yang cepat dan akurat.
• Seimbangkan num_leaves dan learning_rate, serta gunakan regularisasi dan subsampling.
• Dukungan kategorikal, missing value, dan GPU membuatnya kuat untuk produksi dan ensemble.