Mesin boosting manual yang kita rakit pada Chapter Gradient Boosting memang bekerja, tetapi implementasi sederhana itu cepat mentok ketika data membesar dan derau menebar. XGBoost (Extreme Gradient Boosting) lahir dari observasi tersebut: algoritme boosting yang sama, dibangun ulang dengan fungsi tujuan teregularisasi dan lapisan optimasi sistem yang serius. Hasilnya adalah pustaka yang selama bertahun-tahun menjadi pilihan utama pada kompetisi data tabular di Kaggle — cukup sering sehingga memunculkan kesalahpahaman umum bahwa XGBoost selalu menang otomatis, padahal keunggulannya paling nyata pada data terstruktur berukuran besar dengan tuning yang cermat. Chapter ini membedah apa sebenarnya yang ditambahkan XGBoost di atas gradient boosting standar, lalu mengujinya lewat XGBClassifier dengan antarmuka scikit-learn yang sudah kita kuasai.

Apa yang Ditambahkan XGBoost #

Perbedaan pertama dan paling mendasar ada pada fungsi tujuannya. Gradient boosting standar hanya mengecilkan loss; XGBoost menambahkan komponen penalti kompleksitas pada tiap pohon:

text 
Obj = total_loss + Omega(h)
Omega(h) = gamma * T + 0.5 * lambda * Sigma(w_j^2) + alpha * Sigma(|w_j|)

T adalah jumlah daun dan w_j bobot keluaran tiap daun. Penalti gamma menaikkan biaya setiap daun tambahan — pemecahan hanya layak jika penurunan loss melampaui biayanya, sehingga pohon otomatis berhenti tumbuh pada bagian yang tidak informatif. lambda dan alpha bekerja seperti regularisasi L2/L1 pada Chapter Regularisasi Ridge, Lasso, dan Elastic Net, tetapi diterapkan pada bobot daun: prediksi tiap daun ditarik mendekati nol agar koreksi tidak melonjak liar.

Perbedaan kedua: gradien orde kedua. Boosting standar mengikuti gradien loss (orde pertama); XGBoost turut memakai turunan keduanya — informasi kelengkungan. Intuisinya seperti membandingkan menuruni lembah hanya dengan merasakan kemiringan tanah versus juga merasakan seberapa cepat kemiringan berubah: langkah koreksi bisa berukuran sesuai, tidak seragam untuk semua titik. Pendekatan semacam ini dikenal sebagai metode Newton dan membuat tiap iterasi lebih informatif.

Dua penyempurnaan lain berperan pada skala besar. Sparsity-aware splits: saat sebuah baris kehilangan nilai pada fitur pemecah, XGBoost memelihara “arah bawaan” per simpul yang dipelajari dari data, sehingga nilai hilang ditangani tanpa imputasi terpisah. Lalu lapisan rekayasa: pemindaian kandidat pemecahan diparalelkan per fitur (menentukan urutan pemrosesan yang aman pada algoritme yang sekuensial), struktur data dirancang cache-aware agar memori tidak menjadi penghambat, dan data dapat diolah blok demi blok dari disk.

AspekGradientBoostingClassifierXGBClassifier
Fungsi tujuanloss murniloss + penalti gamma/lambda/alpha pada struktur pohon
Informasi gradienorde pertamaorde pertama + orde kedua (metode Newton)
Nilai hilangperlu imputasi di huluarah bawaan per simpul (sparsity-aware)
Paralelismesatu utaspemindaian fitur paralel, cache-aware

Antarmuka scikit-learn dan Parameternya #

XGBoost menyediakan antarmuka aslinya sendiri (DMatrix, train()), tetapi untuk alur kerja kita cukup kelas XGBClassifier/XGBRegressor yang mengikuti kontrak fit()/predict() scikit-learn — estimator tersebut bisa dimasukkan ke Pipeline dan GridSearchCV seperti estimator lain. Tiga parameter yang paling sering disentuh memiliki makna yang persis sama dengan versi scikit-learn: n_estimators (jumlah koreksi berantai), learning_rate (skala tiap koreksi), dan max_depth (kedalaman pohon, lazimnya 3–8).

Dua parameter khas XGBoost yang perlu dikenali sejak awal: objective menentukan fungsi loss — "binary:logistic" untuk klasifikasi biner (bawaan XGBClassifier), "reg:squarederror" untuk regresi kuadrat (bawaan XGBRegressor) — dan eval_metric memilih metrik pemantauan internal seperti "logloss". Untuk klasifikasi biner, "logloss" adalah pilihan standar karena peka terhadap kualitas probabilitas, bukan sekadar label akhir. Dan satu disiplin lingkungan kerja kita: selalu tulis n_jobs=1, random_state=42 agar eksekusi dapat direproduksi persis.

Kapan XGBoost Bersinar #

Kekuatan XGBoost paling terasa pada data terstruktur (tabular) berukuran sedang hingga besar — puluhan ribu baris ke atas, puluhan hingga ratusan fitur campuran numerik dan hasil encoding. Pada rezim tersebut, regularisasi strukturalnya menjaga generalisasi, optimasi sistemnya menjaga waktu pelatihan tetap praktis. Sebaliknya, pada dataset mainan ratusan baris, keunggulan atas GradientBoostingClassifier atau random forest sering tidak terlihat — bahkan hyperparameter yang lebih banyak bisa menjadi beban tuning. Untuk teks, gambar, dan sinyal berdimensi sangat tinggi, deep learning tetap kandidat utama.

Eksperimen: XGBClassifier pada Data 300 Sampel #

Skrip berikut berlatar satu dataset klasifikasi tetap (300 sampel, 12 fitur, dengan 5% label terbalik agar tidak steril), lalu menjalankan tiga pemeriksaan: model dasar beserta fitur terpentingnya, sweep learning_rate, dan duel langsung melawan random forest.

python 
# XGBoost: gradient boosting dengan regularisasi eksplisit pada fungsi
# tujuannya plus sejumlah optimasi sistem untuk data besar.
# Bagian 1: XGBClassifier dasar + tiga fitur terpenting.
# Bagian 2: sweep learning_rate (0.05 / 0.1 / 0.3) dengan 100 pohon.
# Bagian 3: random forest vs XGBoost pada data yang sama.

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier

X, y = make_classification(n_samples=300, n_features=12, n_informative=6,
                           n_redundant=3, flip_y=0.05, class_sep=0.9,
                           random_state=42)
X_latih, X_uji, y_latih, y_uji = train_test_split(
    X, y, test_size=90, random_state=42)
nama_fitur = [f"fitur_{i}" for i in range(X.shape[1])]

# --- Bagian 1: model dasar ---------------------------------------------
# Kontrak sklearn tetap berlaku: fit() lalu predict()/score().
# n_jobs=1 menjaga determinisme; eval_metric="logloss" memilih metrik
# evaluasi internal untuk klasifikasi biner.
xgb = XGBClassifier(n_estimators=100, learning_rate=0.1, max_depth=3,
                    eval_metric="logloss", n_jobs=1, random_state=42)
xgb.fit(X_latih, y_latih)
print("Bagian 1 - XGBClassifier (100 pohon, lr=0.1, depth=3):")
print(f"  akurasi latih : {xgb.score(X_latih, y_latih):.3f}")
print(f"  akurasi uji   : {xgb.score(X_uji, y_uji):.3f}")
urutan_penting = np.argsort(xgb.feature_importances_)[::-1]
print("  3 fitur terpenting (feature_importances_):")
for i in urutan_penting[:3]:
    print(f"    {nama_fitur[i]:<10} {xgb.feature_importances_[i]:.3f}")

# --- Bagian 2: sweep learning_rate -------------------------------------
print("\nBagian 2 - sweep learning_rate (n_estimators=100):")
print(f"  {'learning_rate':<14} {'latih':>6} {'uji':>6}")
for lr in [0.05, 0.1, 0.3]:
    model = XGBClassifier(n_estimators=100, learning_rate=lr, max_depth=3,
                          eval_metric="logloss", n_jobs=1, random_state=42)
    model.fit(X_latih, y_latih)
    print(f"  {lr:<14} {model.score(X_latih, y_latih):>6.3f} "
          f"{model.score(X_uji, y_uji):>6.3f}")

# --- Bagian 3: random forest vs XGBoost --------------------------------
hutan_acak = RandomForestClassifier(n_estimators=300, random_state=42)
hutan_acak.fit(X_latih, y_latih)
print("\nBagian 3 - random forest vs XGBoost (data uji sama):")
print(f"  {'model':<28} {'pohon':>6} {'uji':>6}")
print(f"  {'random forest':<28} {300:>6} "
      f"{hutan_acak.score(X_uji, y_uji):>6.3f}")
print(f"  {'xgboost (lr=0.1)':<28} {100:>6} "
      f"{xgb.score(X_uji, y_uji):>6.3f}")

Output yang Dihasilkan:

text 
Bagian 1 - XGBClassifier (100 pohon, lr=0.1, depth=3):
  akurasi latih : 0.995
  akurasi uji   : 0.878
  3 fitur terpenting (feature_importances_):
    fitur_5    0.265
    fitur_8    0.141
    fitur_1    0.102

Bagian 2 - sweep learning_rate (n_estimators=100):
  learning_rate   latih    uji
  0.05            0.986  0.889
  0.1             0.995  0.878
  0.3             1.000  0.867

Bagian 3 - random forest vs XGBoost (data uji sama):
  model                         pohon    uji
  random forest                   300  0.878
  xgboost (lr=0.1)                100  0.878

Mari kita telaah bagian-bagian kunci skrip tersebut:

  1. Baris 13–17 (dataset dan split tetap): make_classification(random_state=42) dengan flip_y=0.05 menyisipkan label terbalik agar generalisasi benar-benar teruji; train_test_split(..., random_state=42) menyisihkan 90 sampel uji yang sama pada setiap eksekusi.
  2. Baris 18 (nama fitur): daftar fitur_0 sampai fitur_11 sekadar memberi label terbaca pada laporan kepentingan fitur.
  3. Baris 24–26 (konstruktor): kelima parameter kunci dipasang — n_estimators=100, learning_rate=0.1, max_depth=3, eval_metric="logloss", serta n_jobs=1, random_state=42 untuk reproduksibilitas. Baris 26 memanggil fit() persis seperti estimator scikit-learn mana pun.
  4. Baris 30–33 (fitur terpenting): feature_importances_ dinormalisasi berjumlah 1; np.argsort(...)[::-1] mengurutkan indeks dari yang terbesar, lalu tiga teratas dicetak berpasangan nama dan skor.
  5. Baris 38–43 (sweep learning rate): tiga model identik kecuali learning_rate dilatih dan dievaluasi — pola sweep sederhana yang juga dipakai saat tuning sungguhan.
  6. Baris 46–53 (duel dengan random forest): RandomForestClassifier(n_estimators=300) dilatih pada split yang sama, lalu kedua akurasi uji dicetak berdampingan beserta jumlah pohon masing-masing.

Membaca Hasil Eksperimen #

Bagian 1 menunjukkan XGBClassifier yang sehat: akurasi latih 0,995 tanpa sempurna — penalti kompleksitas dan langkah koreksi kecil menahan model dari menghafal label terbalik. Laporan kepentingan fitur memperlihatkan konsentrasi yang wajar: fitur_5 (0,265), fitur_8 (0,141), dan fitur_1 (0,102) menyerap separuh total kepentingan — tiga dari dua belas fitur membawa sebagian besar sinyal, sisanya berbagi porsi kecil.

Bagian 2 adalah pelajaran shrinkage dalam tiga baris. Ketika learning_rate dinaikkan dari 0,05 ke 0,3, akurasi latih merambat naik (0,986 → 0,995 → 1,000) sementara akurasi uji justru menurun (0,889 → 0,878 → 0,867). Langkah koreksi yang besar membuat model cepat memasukkan data latih — termasuk 5% labelnya yang terbalik — ke dalam jumlahan. Pada data berlabel bising semacam ini, learning rate kecil menang: koreksi halus berulang lebih tahan terhadap derau.

Bagian 3 menutup dengan duel yang jujur: random forest 300 pohon dan XGBoost 100 pohon berakhir seri di angka 0,878. Kedua model sama-sama kompeten pada data berukuran ini, dan hasilnya menggarisbawahi pesan awal chapter — pada 300 sampel, XGBoost tidak otomatis unggul; keunggulan biaya-manfaatnya tumbuh seiring ukuran dan kompleksitas data.

XGBoost memangkas waktu pelatihan lewat paralelisme dan cache, tetapi tetap memindai kandidat pemecahan satu per satu pada nilai fitur yang presisi. Pustaka berikutnya menyerang bottleneck itu secara langsung: LightGBM mengelompokkan nilai fitur ke dalam bin sebelum mencari pemecahan, lalu menumbuhkan pohon per daun alih-alih per tingkat. Chapter LightGBM melanjutkan perjalanan kita.

Referensi Resmi #