Belajar Machine Learning - Tree-Based Models & Ensemble

#Pendahuluan

Setelah di episode 6 kita menguasai classification dengan logistic regression dan kNN, pada episode ini kita naik ke kelas model yang mendominasi data tabular hingga 2026: tree-based models dan ensemble.

Mengapa penting? Karena untuk data tabel (CSV biasa), model berbasis pohon hampir selalu menang di kompetisi — lebih akurat dari logistic regression tanpa perlu scaling, lebih tahan terhadap outlier, dan mampu menangkap hubungan non-linear. Jika kalian ingin serius di ML tabular, penguasaan tree-based adalah keharusan.

#Decision Tree: Cara Kerja

Decision tree memprediksi dengan serangkaian pertanyaan biner. Contoh untuk prediksi churn: "Apakah umur di bawah 30?" → jika ya: "Apakah pendapatan di bawah 3 juta?" → jika ya: churn. Setiap pertanyaan adalah split pada satu fitur.

Pertanyaan mana yang dipilih lebih dulu? Pohon memilih split yang paling "memisahkan" kelas. Dua ukuran yang umum:

• Gini impurity: mengukur seberapa campur aduk kelas dalam sebuah grup. Nilai 0 = murni satu kelas.
• Entropy: ukuran ketidakteraturan informasi. 0 = murni, 1 = paling campur.

from sklearn.tree import DecisionTreeClassifier
 
tree = DecisionTreeClassifier(max_depth=4, random_state=42)
tree.fit(X_train, y_train)
print(tree.score(X_test, y_test))

#Overfitting: Musuh Utama Pohon

Pohon tanpa batasan akan tumbuh sampai setiap daun hanya berisi satu sampel — hafal semua data latih, lalu gagal total di data baru. Parameter yang mengendalikan hal ini:

• max_depth: kedalaman maksimum pohon.
• min_samples_split: minimal sampel untuk melakukan split.
• min_samples_leaf: minimal sampel di setiap daun.

Mengapa pohon overfit mudah? Karena ia terlalu fleksibel — dengan kedalaman cukup, ia bisa mewakili hampir semua fungsi. Inilah inti bias-variance trade-off: model sederhana punya bias tinggi tapi variance rendah (underfit); model kompleks punya bias rendah tapi variance tinggi (overfit). Pohon sendiri adalah model high variance: dataset sedikit berubah, struktur pohon bisa berubah total.

#Ensemble: Menyatukan Banyak Pohon

Daripada mengandalkan satu pohon yang rapuh, ensemble menggabungkan banyak pohon. Dua strategi utama:

#Bagging dan Random Forest

Bagging melatih banyak pohon pada sampel acak dari data (dengan pengembalian), lalu menggabungkan prediksinya (suara mayoritas / rata-rata). Random Forest menambahkan satu lapis acak lagi: setiap split hanya mempertimbangkan sebagian kecil fitur.

from sklearn.ensemble import RandomForestClassifier
 
rf = RandomForestClassifier(
    n_estimators=200,
    max_depth=8,
    random_state=42,
    n_jobs=-1,
)
rf.fit(X_train, y_train)

Karena tiap pohon melihat data dan fitur yang sedikit berbeda, kesalahan individualnya saling "menutup". Hasilnya: variance menurun drastis tanpa menaikkan bias — itulah keunggulan ensemble.

#Boosting: XGBoost, LightGBM, CatBoost

Boosting berbeda: pohon dilatih berurutan, masing-masing pohon baru fokus memperbaiki kesalahan pohon sebelumnya. Hasilnya model yang kuat, tetapi rentan overfit jika tidak dikendalikan — karena justru "terlalu pandai" mengejar error.

import xgboost as xgb
 
model = xgb.XGBClassifier(
    n_estimators=300,
    max_depth=6,
    learning_rate=0.05,
    subsample=0.8,
    colsample_bytree=0.8,
    random_state=42,
    eval_metric="logloss",
)
model.fit(X_train, y_train)

Tiga implementasi boosting yang wajib dikenal di 2026:

Ketiganya sangat mirip secara API — fit, predict, predict_proba — sehingga berpindah antar library itu murah. Perbedaan mendalam hyperparameter-nya kita bedah di episode 19.

#Praktik: Klasifikasi dengan Gradient Boosting

Mari bandingkan tiga pendekatan pada satu dataset:

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score
import lightgbm as lgb
 
# Random Forest
rf = RandomForestClassifier(random_state=42).fit(X_train, y_train)
 
# LightGBM
lgbm = lgb.LGBMClassifier(random_state=42).fit(X_train, y_train)
 
for name, model in [("RF", rf), ("LightGBM", lgbm)]:
    proba = model.predict_proba(X_test)[:, 1]
    print(f"{name}: ROC-AUC = {roc_auc_score(y_test, proba):.4f}")

Perhatikan bahwa tree-based tidak memerlukan scaling — split hanya membandingkan nilai, bukan jarak. Ini salah satu alasan mengapa mereka jadi favorit untuk tabular: preprocessing jadi jauh lebih sederhana.

#Common Pitfalls

• Tidak membatasi kedalaman — pohon/GBM overfit di train set.
• learning_rate terlalu besar — model terlalu agresif, overfit.
• Mengabaikan eval_metric saat training GBM — susah memantau overfitting.
• Berpikir tree-based tidak bisa overfit — mereka justru sangat rentan; peran hyperparameter krusial.
• Memakai banyak n_estimators tanpa early stopping — setelah titik jenuh, hanya boros komputasi.

#Penutup

Pada episode 7 ini, kalian telah menguasai keluarga model yang paling berpengaruh di data tabular.

Inti yang harus dibawa pulang:

• Decision tree memecah data dengan split berbasis Gini/entropy dan mudah overfit.
• Bias-variance trade-off: model kompleks berisiko high variance.
• Random Forest (bagging) menurunkan variance dengan banyak pohon acak.
• Gradient boosting (XGBoost/LightGBM/CatBoost) melatih pohon berurutan untuk memperbaiki error.
• Tree-based tidak butuh scaling — salah satu keunggulan utamanya untuk tabular.

Di episode 8 selanjutnya kita berpindah ke unsupervised learning: clustering (k-Means, DBSCAN, hierarchical) dengan evaluasi silhouette, serta dimensionality reduction (PCA, t-SNE, UMAP) untuk visualisasi dan reduksi fitur. Sampai jumpa di episode 8!