# XGBoost vs LightGBM 2026: Gradient Boosting dan Pertanyaan Interview Data Science

> Kuasai XGBoost dan LightGBM untuk interview data science. Bandingkan algoritma gradient boosting, pelajari hyperparameter tuning, dan latihan pertanyaan interview dengan contoh kode.

- Published: 2026-09-17
- Updated: 2026-09-17
- Author: Anthony Fillion-Maillet
- Tags: xgboost, lightgbm, gradient-boosting, machine-learning, data-science-interview
- Reading time: 9 min

---

XGBoost dan LightGBM tetap menjadi implementasi gradient boosting paling efektif untuk data tabular di tahun 2026, secara konsisten mengungguli deep learning pada dataset terstruktur. Kedua library ini telah berkembang signifikan, dengan XGBoost 2.1 dan LightGBM 4.5 memperkenalkan peningkatan akselerasi GPU dan penanganan fitur kategorikal yang lebih baik.

> **Tips Interview**
>
> Ketika ditanya "Mengapa menggunakan XGBoost daripada neural network?", tekankan bahwa gradient boosting menangani data tabular dengan sampel lebih sedikit secara lebih efektif, membutuhkan lebih sedikit feature engineering, dan menyediakan feature importance bawaan. Neural network unggul pada data tidak terstruktur (gambar, teks, audio) tetapi kesulitan dengan fitur tabular heterogen.

## Perbedaan Gradient Boosting dengan Random Forests

Gradient boosting dan Random Forests sama-sama menggunakan decision trees, tetapi pendekatan trainingnya berbeda secara fundamental. Random Forests melatih tree secara independen dan paralel, kemudian merata-ratakan prediksi. Gradient boosting melatih tree secara sekuensial, dengan setiap tree mengoreksi kesalahan dari ensemble sebelumnya.

Formulasi matematis memperjelas perbedaan ini. Pada iterasi `m`, gradient boosting menyesuaikan tree baru `h_m(x)` ke gradien negatif dari loss function terhadap prediksi ensemble saat ini. Untuk squared error loss, gradien negatif ini sama dengan residual.

```python
# gradient_boosting_demo.py
import numpy as np
from sklearn.tree import DecisionTreeRegressor

def gradient_boosting_from_scratch(X, y, n_estimators=100, learning_rate=0.1, max_depth=3):
    """Simplified gradient boosting for regression to illustrate the algorithm."""
    # Initialize predictions with the mean (minimizes squared error)
    predictions = np.full(len(y), y.mean())
    trees = []
    
    for _ in range(n_estimators):
        # Compute negative gradient (residuals for MSE loss)
        residuals = y - predictions
        
        # Fit a tree to the residuals
        tree = DecisionTreeRegressor(max_depth=max_depth)
        tree.fit(X, residuals)
        trees.append(tree)
        
        # Update predictions with shrinkage (learning rate)
        predictions += learning_rate * tree.predict(X)
    
    return trees, y.mean()
```

Ketergantungan sekuensial ini membuat gradient boosting lebih lambat untuk dilatih dibandingkan Random Forests, tetapi biasanya lebih akurat pada dataset yang sama.

## Arsitektur XGBoost dan Parameter Utama

[XGBoost](https://xgboost.readthedocs.io/en/stable/) (eXtreme Gradient Boosting) memperkenalkan beberapa optimisasi yang membuat gradient boosting praktis untuk skala besar. Library ini menggunakan fungsi objektif terregularisasi yang menggabungkan loss dengan penalti L1 dan L2 pada bobot leaf, mengurangi overfitting tanpa cross-validation yang ekstensif.

```python
# xgboost_classification.py
import xgboost as xgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Generate synthetic classification data
X, y = make_classification(n_samples=10000, n_features=20, n_informative=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# XGBoost with commonly tuned hyperparameters
model = xgb.XGBClassifier(
    n_estimators=500,           # Number of boosting rounds
    max_depth=6,                # Maximum tree depth (controls complexity)
    learning_rate=0.1,          # Shrinkage factor (eta in XGBoost docs)
    subsample=0.8,              # Row sampling ratio per tree
    colsample_bytree=0.8,       # Column sampling ratio per tree
    reg_alpha=0.1,              # L1 regularization on leaf weights
    reg_lambda=1.0,             # L2 regularization on leaf weights
    tree_method='hist',         # Histogram-based algorithm (faster)
    early_stopping_rounds=50,   # Stop if no improvement after 50 rounds
    random_state=42
)

model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],  # Validation set for early stopping
    verbose=False
)

print(f"Best iteration: {model.best_iteration}")
print(f"Test accuracy: {model.score(X_test, y_test):.4f}")
```

Parameter `tree_method='hist'` layak mendapat perhatian khusus. Histogram-based tree building mengkuantisasi fitur kontinu menjadi bin diskrit, mengurangi penggunaan memori dan mempercepat pencarian split. XGBoost 2.0+ menggunakan metode ini secara default.

## LightGBM: Pertumbuhan Leaf-Wise dan Penanganan Kategorikal

[LightGBM](https://lightgbm.readthedocs.io/en/stable/) (Light Gradient Boosting Machine) dari Microsoft memperkenalkan dua inovasi yang sering membuatnya lebih cepat dari XGBoost: pertumbuhan tree leaf-wise dan Gradient-based One-Side Sampling (GOSS).

Decision tree tradisional tumbuh level-by-level, memisahkan semua node pada kedalaman tertentu sebelum bergerak lebih dalam. LightGBM tumbuh leaf-wise, selalu memisahkan leaf dengan potensi gain tertinggi. Pendekatan asimetris ini menghasilkan tree yang lebih kompleks dengan split lebih sedikit, sering mencapai training loss yang lebih rendah lebih cepat.

```python
# lightgbm_with_categorical.py
import lightgbm as lgb
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

# Create dataset with categorical features
np.random.seed(42)
df = pd.DataFrame({
    'category_a': np.random.choice(['low', 'medium', 'high'], 10000),
    'category_b': np.random.choice(['type1', 'type2', 'type3', 'type4'], 10000),
    'numeric_1': np.random.randn(10000),
    'numeric_2': np.random.randn(10000),
    'target': np.random.randint(0, 2, 10000)
})

# Convert to categorical dtype (LightGBM reads this automatically)
df['category_a'] = df['category_a'].astype('category')
df['category_b'] = df['category_b'].astype('category')

X = df.drop('target', axis=1)
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# LightGBM handles categorical features natively
model = lgb.LGBMClassifier(
    n_estimators=500,
    max_depth=-1,               # No limit (leaf-wise growth controls complexity)
    num_leaves=31,              # Maximum leaves per tree (key LightGBM param)
    learning_rate=0.1,
    subsample=0.8,
    colsample_bytree=0.8,
    min_child_samples=20,       # Minimum samples in a leaf
    reg_alpha=0.1,
    reg_lambda=1.0,
    random_state=42,
    verbose=-1
)

model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    callbacks=[lgb.early_stopping(50, verbose=False)]
)

print(f"Best iteration: {model.best_iteration_}")
print(f"Test accuracy: {model.score(X_test, y_test):.4f}")
```

Penanganan kategorikal native LightGBM mengungguli one-hot encoding untuk fitur dengan kardinalitas tinggi. Algoritma ini menemukan split optimal di seluruh nilai kategorikal tanpa membuat matriks sparse.

## XGBoost vs LightGBM: Perbandingan Praktis

Pilihan antara XGBoost dan LightGBM tergantung pada karakteristik dataset dan batasan yang ada. Berikut perbandingan langsung berdasarkan benchmark dan pengalaman praktis:

| Aspek | XGBoost 2.1 | LightGBM 4.5 |
|-------|-------------|---------------|
| Kecepatan training | Lebih lambat pada dataset besar | 2-5x lebih cepat dengan GOSS |
| Penggunaan memori | Lebih tinggi | Lebih rendah (histogram binning) |
| Fitur kategorikal | Membutuhkan encoding | Dukungan native |
| Pertumbuhan tree | Level-wise (default) | Leaf-wise |
| Dukungan GPU | CUDA, metode histogram | CUDA, dukungan native |
| Risiko overfitting | Lebih rendah (level-wise) | Lebih tinggi (leaf-wise, tune `num_leaves`) |
| Dataset kecil (<10k baris) | Sering lebih baik | Sebanding |
| Dataset besar (>1M baris) | Lebih lambat | Lebih disukai |

Untuk tugas [feature engineering](/blog/data-science/feature-engineering-machine-learning-techniques-interview-2026) di mana waktu training penting, keunggulan kecepatan LightGBM menjadi signifikan selama eksperimen iteratif.

## Strategi Hyperparameter Tuning untuk Interview

Pewawancara sering bertanya bagaimana melakukan tuning model gradient boosting. Pendekatan terstruktur menunjukkan pemikiran sistematis daripada random grid search.

```python
# hyperparameter_tuning.py
import optuna
import xgboost as xgb
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=5000, n_features=20, n_informative=10, random_state=42)

def objective(trial):
    """Optuna objective for XGBoost hyperparameter optimization."""
    params = {
        # Start with learning rate and n_estimators
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'n_estimators': trial.suggest_int('n_estimators', 100, 1000),
        
        # Tree complexity (most important for bias-variance tradeoff)
        'max_depth': trial.suggest_int('max_depth', 3, 10),
        'min_child_weight': trial.suggest_int('min_child_weight', 1, 10),
        
        # Regularization (reduce overfitting)
        'reg_alpha': trial.suggest_float('reg_alpha', 1e-8, 10.0, log=True),
        'reg_lambda': trial.suggest_float('reg_lambda', 1e-8, 10.0, log=True),
        
        # Sampling (stochastic gradient boosting)
        'subsample': trial.suggest_float('subsample', 0.5, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        
        'tree_method': 'hist',
        'random_state': 42
    }
    
    model = xgb.XGBClassifier(**params)
    scores = cross_val_score(model, X, y, cv=5, scoring='roc_auc')
    return scores.mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50, show_progress_bar=True)

print(f"Best ROC-AUC: {study.best_value:.4f}")
print(f"Best params: {study.best_params}")
```

Urutan prioritas tuning penting: learning rate dan jumlah estimator terlebih dahulu, kemudian kompleksitas tree (`max_depth`, `num_leaves`), kemudian regularisasi, lalu rasio sampling. Urutan ini mencerminkan bagaimana parameter mempengaruhi bias-variance tradeoff.

## Pertanyaan Interview Umum tentang Gradient Boosting

Interview data science menguji pemahaman teoritis dan kemampuan debugging praktis. Pertanyaan-pertanyaan ini sering muncul dalam interview di perusahaan yang bekerja dengan data tabular.

**Q: Mengapa gradient boosting lebih mudah overfit dibanding Random Forests?**

Gradient boosting melatih secara sekuensial, dengan setiap tree secara eksplisit menyesuaikan kesalahan ensemble. Tree tahap akhir dapat menghafal noise dalam residual. Random Forests melatih tree secara independen pada sampel bootstrap, dan perata-rataan mengurangi varians. Regularisasi (learning rate, subsampling, batasan tree) mengurangi masalah ini dalam gradient boosting.

**Q: Apa yang menyebabkan XGBoost memberikan hasil berbeda pada data yang sama?**

Non-determinisme berasal dari tiga sumber: row subsampling (`subsample`), column subsampling (`colsample_bytree`), dan konstruksi histogram paralel. Mengatur `random_state` memperbaiki dua yang pertama. Untuk reprodusibilitas yang tepat, atur juga `n_jobs=1`, meskipun ini memperlambat training.

**Q: Bagaimana menangani class imbalance di XGBoost?**

Tiga pendekatan yang berhasil:
1. `scale_pos_weight`: Atur ke `(negative_count / positive_count)` untuk klasifikasi biner
2. `sample_weight`: Berikan bobot instance ke `fit()`
3. Resampling: SMOTE atau random undersampling sebelum training

Pendekatan `scale_pos_weight` memodifikasi loss function dan mempertahankan distribusi data asli, sering lebih disukai daripada resampling.

**Q: Kapan memilih CatBoost daripada XGBoost atau LightGBM?**

[CatBoost](https://catboost.ai/en/docs/) unggul ketika dataset berisi banyak fitur kategorikal dengan kardinalitas tinggi, dan ketika mengurangi overfitting dengan tuning minimal adalah prioritas. Ordered boosting dan struktur tree simetrisnya membuatnya lebih tahan terhadap overfitting pada dataset kecil. Tradeoff-nya adalah training lebih lambat dari LightGBM.

Untuk fundamental klasifikasi lebih lanjut, tinjau [modul klasifikasi supervised learning](/technologies/data-science/interview-questions/ml-supervised-classification).

## Feature Importance dan Interpretabilitas Model

Menjelaskan prediksi penting di industri yang diregulasi dan membangun kepercayaan dengan stakeholder. XGBoost dan LightGBM menyediakan feature importance bawaan, tetapi interpretasinya memerlukan kehati-hatian.

```python
# feature_importance.py
import xgboost as xgb
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=5000, n_features=20, n_informative=10, random_state=42)
feature_names = [f'feature_{i}' for i in range(20)]

model = xgb.XGBClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# Three importance types available
importance_types = ['weight', 'gain', 'cover']

for imp_type in importance_types:
    importance = model.get_booster().get_score(importance_type=imp_type)
    print(f"\n{imp_type.upper()} importance (top 5):")
    sorted_imp = sorted(importance.items(), key=lambda x: x[1], reverse=True)[:5]
    for feat, score in sorted_imp:
        print(f"  {feat}: {score:.2f}")
```

- **Weight**: Jumlah kali fitur muncul dalam split di seluruh tree
- **Gain**: Rata-rata peningkatan dalam fungsi objektif ketika fitur digunakan untuk splitting
- **Cover**: Rata-rata jumlah sampel yang terpengaruh oleh split pada fitur ini

Gain biasanya memberikan ukuran importance paling bermakna, karena langsung berkaitan dengan peningkatan model. Namun, fitur yang berkorelasi dapat memiliki importance yang kurang dinyatakan karena model mungkin melakukan split pada salah satunya.

Untuk interpretasi kausal, SHAP values ([tersedia melalui library shap](https://shap.readthedocs.io/en/latest/)) menyediakan atribusi fitur yang konsisten dan berdasar teori per prediksi.

## Pertimbangan Deployment Produksi

Men-deploy model gradient boosting memperkenalkan masalah latensi dan serialisasi yang berbeda dari training.

```python
# model_serialization.py
import xgboost as xgb
import json

# Train a model
model = xgb.XGBClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Save in XGBoost's native binary format (recommended for production)
model.save_model('model.ubj')  # Universal Binary JSON format

# Load for inference
loaded_model = xgb.XGBClassifier()
loaded_model.load_model('model.ubj')

# For model versioning, save with metadata
metadata = {
    'version': '1.0.0',
    'trained_at': '2026-09-17',
    'features': feature_names,
    'best_iteration': model.best_iteration
}
with open('model_metadata.json', 'w') as f:
    json.dump(metadata, f)
```

Latensi inferensi tergantung pada kedalaman dan jumlah tree. Untuk aplikasi real-time dengan persyaratan latensi ketat (di bawah 10ms), pertimbangkan:
- Mengurangi `n_estimators` dengan learning rate yang lebih tinggi
- Membatasi `max_depth` ke 4-5
- Menggunakan metode `predict()` dengan `iteration_range` untuk menggunakan lebih sedikit tree

## Poin Penting untuk Interview XGBoost dan LightGBM

- Gradient boosting melatih tree secara sekuensial pada residual, tidak seperti Random Forests yang melatih secara paralel dan merata-ratakan
- XGBoost menambahkan regularisasi L1/L2 ke fungsi objektif, mengurangi overfitting tanpa cross-validation ekstensif
- LightGBM menggunakan pertumbuhan leaf-wise dan sampling GOSS, membuatnya 2-5x lebih cepat pada dataset besar
- Penanganan kategorikal native di LightGBM mengungguli one-hot encoding untuk fitur kardinalitas tinggi
- Tune secara berurutan: learning rate, kompleksitas tree, regularisasi, rasio sampling
- `scale_pos_weight` menangani class imbalance dengan memodifikasi loss function, mempertahankan distribusi asli
- Feature importance berbasis gain mengukur peningkatan model aktual, tetapi fitur berkorelasi dapat tampak kurang penting
- Untuk produksi, gunakan format `.ubj` dan pertimbangkan mengurangi jumlah tree untuk aplikasi sensitif latensi

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/id/blog/data-science/xgboost-lightgbm-gradient-boosting-interview-2026