XGBoost vs LightGBM 2026: Gradient Boosting ve Data Science Mülakat Soruları

2026 yılında XGBoost ve LightGBM'in kapsamlı karşılaştırması. Mimari farklılıklar, optimizasyon teknikleri ve machine learning mülakat sorularına hazırlık rehberi.

Data Science için XGBoost ve LightGBM Karşılaştırması

XGBoost ve LightGBM, 2026 yılında tablo veriler için en etkili gradient boosting implementasyonları olmaya devam etmektedir. Her iki kütüphane de yapılandırılmış veri setlerinde derin öğrenme modellerini sürekli olarak geride bırakmaktadır. XGBoost 2.1 ve LightGBM 4.5 sürümleriyle birlikte GPU hızlandırma iyileştirmeleri ve kategorik değişken desteği önemli ölçüde geliştirilmiştir.

Mülakat İpucu

"Neden sinir ağı yerine XGBoost kullanmalıyız?" sorusu sorulduğunda, gradient boosting'in daha az örnekle tablo verilerini daha etkili işlediği, daha az özellik mühendisliği gerektirdiği ve yerleşik özellik önem sıralaması sağladığı vurgulanmalıdır. Sinir ağları yapılandırılmamış verilerde (görüntü, metin, ses) üstündür ancak heterojen tablo özellikleriyle zorlanır.

Gradient Boosting ile Random Forests Arasındaki Farklar

Gradient boosting ve Random Forests her ikisi de karar ağaçları kullanır, ancak eğitim yaklaşımları temelden farklıdır. Random Forests ağaçları bağımsız ve paralel olarak eğitir, ardından tahminleri ortalar. Gradient boosting ağaçları sıralı olarak eğitir ve her ağaç önceki ensemble'ın hatalarını düzeltir.

Matematiksel formülasyon bu ayrımı netleştirir. m iterasyonunda, gradient boosting mevcut ensemble tahminlerine göre kayıp fonksiyonunun negatif gradyanına yeni bir ağaç h_m(x) uydurur. Kare hata kaybı için bu negatif gradyan artıklara eşittir.

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):
    """Algoritmayi gosteren basitlestirilmis gradient boosting regresyonu."""
    # Tahminleri ortalama ile baslatma (kare hatayi minimize eder)
    predictions = np.full(len(y), y.mean())
    trees = []
    
    for _ in range(n_estimators):
        # Negatif gradyan hesaplama (MSE kaybi icin artiklar)
        residuals = y - predictions
        
        # Artiklara agac uydurma
        tree = DecisionTreeRegressor(max_depth=max_depth)
        tree.fit(X, residuals)
        trees.append(tree)
        
        # Shrinkage ile tahmin guncelleme (learning rate)
        predictions += learning_rate * tree.predict(X)
    
    return trees, y.mean()

Bu sıralı bağımlılık, gradient boosting eğitimini Random Forests'tan daha yavaş yapar, ancak genellikle aynı veri setinde daha yüksek doğruluk sağlar.

XGBoost Mimarisi ve Temel Parametreler

XGBoost (eXtreme Gradient Boosting), gradient boosting'i ölçekte pratik hale getiren birçok optimizasyon sunmuştur. Kütüphane, kaybı yaprak ağırlıklarındaki L1 ve L2 cezalarıyla birleştiren düzenlileştirilmiş bir amaç fonksiyonu kullanır ve kapsamlı çapraz doğrulama olmadan aşırı uyumu azaltır.

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

# Sentetik siniflandirma verisi olusturma
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)

# Performans icin DMatrix olusturma
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)

# Duzenlilestirmeli XGBoost parametreleri
params = {
    'objective': 'binary:logistic',
    'eval_metric': 'logloss',
    'max_depth': 6,                # Agac derinligi
    'learning_rate': 0.1,          # Eta (shrinkage)
    'subsample': 0.8,              # Satir orneklemesi
    'colsample_bytree': 0.8,       # Agac basina sutun orneklemesi
    'reg_alpha': 0.1,              # L1 duzenlilestirme
    'reg_lambda': 1.0,             # L2 duzenlilestirme
    'tree_method': 'hist',         # Histogram tabanli algoritma
    'device': 'cuda'               # GPU hizlandirma
}

# Early stopping ile egitim
evals = [(dtrain, 'train'), (dtest, 'eval')]
model = xgb.train(
    params,
    dtrain,
    num_boost_round=500,
    evals=evals,
    early_stopping_rounds=50,
    verbose_eval=100
)

DMatrix formatı verileri optimize edilmiş dahili bir yapıya dönüştürür, bellek kullanımını azaltır ve eğitimi hızlandırır. tree_method='hist' parametresi, XGBoost'un LightGBM yaklaşımından uyarladığı histogram tabanlı bölmeyi etkinleştirir.

LightGBM Ağaç Büyütme Algoritması

Microsoft'un LightGBM kütüphanesi iki temel yenilik getirmiştir: yaprak bazlı ağaç büyütme ve Gradient-based One-Side Sampling (GOSS). XGBoost gibi seviye bazlı büyümek yerine, LightGBM en büyük kayıp azalmasına sahip yaprağı genişletir ve bu da daha derin, asimetrik ağaçlara yol açar.

python
# lightgbm_classification.py
import lightgbm as lgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Veri hazirlama
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)

# LightGBM veri setleri olusturma
train_data = lgb.Dataset(X_train, label=y_train)
test_data = lgb.Dataset(X_test, label=y_test, reference=train_data)

# LightGBM parametreleri
params = {
    'objective': 'binary',
    'metric': 'binary_logloss',
    'boosting_type': 'gbdt',
    'num_leaves': 31,              # Agac basina maksimum yaprak sayisi
    'learning_rate': 0.1,
    'feature_fraction': 0.8,       # Sutun orneklemesi
    'bagging_fraction': 0.8,       # Satir orneklemesi
    'bagging_freq': 5,             # Bagging sikligi
    'verbose': -1,
    'device': 'gpu'                # GPU hizlandirma
}

# Callback'lerle egitim
model = lgb.train(
    params,
    train_data,
    num_boost_round=500,
    valid_sets=[train_data, test_data],
    valid_names=['train', 'eval'],
    callbacks=[
        lgb.early_stopping(stopping_rounds=50),
        lgb.log_evaluation(period=100)
    ]
)

num_leaves parametresi model karmaşıklığını doğrudan kontrol eder, XGBoost'taki max_depth parametresinin aksine. Karşılaştırılabilir karmaşıklık için num_leaves yaklaşık 2^max_depth - 1 olmalıdır.

Kategorik Değişken İşleme

Her iki kütüphane de one-hot encoding gerektirmeden yerel kategorik değişken desteği sunar. Bu yaklaşım yüksek kardinaliteli kategorilerdeki bilgiyi korur ve boyutsallığı azaltır.

python
# categorical_features.py
import pandas as pd
import numpy as np
import xgboost as xgb
import lightgbm as lgb

# Ornek kategorik veri
data = pd.DataFrame({
    'city': pd.Categorical(['Istanbul', 'Ankara', 'Izmir'] * 1000),
    'product_type': pd.Categorical(['A', 'B', 'C', 'D'] * 750),
    'numeric_feature': np.random.randn(3000),
    'target': np.random.randint(0, 2, 3000)
})

# XGBoost yaklasimi: category tipiyle enable_categorical
X = data[['city', 'product_type', 'numeric_feature']]
y = data['target']

dtrain = xgb.DMatrix(X, label=y, enable_categorical=True)
xgb_params = {
    'objective': 'binary:logistic',
    'tree_method': 'hist',
    'max_cat_to_onehot': 10  # One-hot vs optimal bolumleme esigi
}

# LightGBM yaklasimi: kategorik sutunlari belirtme
lgb_train = lgb.Dataset(
    X, label=y,
    categorical_feature=['city', 'product_type']
)
lgb_params = {
    'objective': 'binary',
    'cat_smooth': 10,           # Kategoriler icin yumusatma
    'cat_l2': 10                # Kategoriler icin L2 duzenlilestirme
}

LightGBM kategorik özellikler için optimal ağaç bölmesi kullanır ve tüm olası kategori kombinasyonlarını hesaplamadan en iyi bölmeyi bulur. XGBoost 2.0+ max_cat_to_onehot parametresiyle benzer yetenekler eklemiştir.

Hiperparametre Optimizasyonu

Hiperparametre optimizasyonu model performansını önemli ölçüde etkiler. Modern yaklaşımlar Bayesian optimizasyonu için Optuna veya benzeri framework'ler kullanır.

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, random_state=42)

def objective(trial):
    params = {
        'objective': 'binary:logistic',
        'eval_metric': 'logloss',
        'tree_method': 'hist',
        'max_depth': trial.suggest_int('max_depth', 3, 10),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'subsample': trial.suggest_float('subsample', 0.6, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.6, 1.0),
        '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),
        'min_child_weight': trial.suggest_int('min_child_weight', 1, 10),
        'n_estimators': trial.suggest_int('n_estimators', 100, 1000)
    }
    
    model = xgb.XGBClassifier(**params, use_label_encoder=False)
    scores = cross_val_score(model, X, y, cv=5, scoring='neg_log_loss')
    return scores.mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100, n_jobs=-1)

LightGBM için yaprak bazlı büyüme nedeniyle arama alanı biraz farklıdır:

python
# lightgbm_tuning.py
def lgb_objective(trial):
    params = {
        'objective': 'binary',
        'metric': 'binary_logloss',
        'boosting_type': 'gbdt',
        'num_leaves': trial.suggest_int('num_leaves', 20, 300),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'feature_fraction': trial.suggest_float('feature_fraction', 0.6, 1.0),
        'bagging_fraction': trial.suggest_float('bagging_fraction', 0.6, 1.0),
        'bagging_freq': trial.suggest_int('bagging_freq', 1, 7),
        'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),
        'lambda_l1': trial.suggest_float('lambda_l1', 1e-8, 10.0, log=True),
        'lambda_l2': trial.suggest_float('lambda_l2', 1e-8, 10.0, log=True)
    }
    return evaluate_model(params)  # Degerlendirme fonksiyonu implementasyonu

Model Yorumlanabilirliği ve Özellik Önemi

Gradient boosting modelleri özellik önemini değerlendirmek için birden fazla yöntem sunar ve her biri değişkenlerin etkisi hakkında farklı bir hikaye anlatır.

python
# feature_importance.py
import matplotlib.pyplot as plt
import xgboost as xgb
import shap

# XGBoost modeli egitme
model = xgb.XGBClassifier(n_estimators=100, max_depth=5)
model.fit(X_train, y_train)

# Yerlesik onem (gain, weight, cover)
importance_types = ['weight', 'gain', 'cover']
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

for ax, imp_type in zip(axes, importance_types):
    importance = model.get_booster().get_score(importance_type=imp_type)
    xgb.plot_importance(model, importance_type=imp_type, ax=ax, title=f'{imp_type.capitalize()} Importance')

plt.tight_layout()

# Yorumlanabilirlik icin SHAP degerleri
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)

# Ozellik etkisini gosteren ozet grafik
shap.summary_plot(shap_values, X_test, feature_names=feature_names)

SHAP değerleri, kooperatif oyun teorisinden Shapley değerlerine dayanan teorik olarak temellendirilmiş yorumlanabilirlik sağlar. Her tahmin bireysel özellik katkılarına ayrıştırılır.

Data Science & ML mülakatlarında başarılı olmaya hazır mısın?

İnteraktif simülatörler, flashcards ve teknik testlerle pratik yap.

Data Science & ML keşfet

Performans Karşılaştırması ve Seçim Kriterleri

XGBoost ve LightGBM arasındaki seçim projenin spesifik gereksinimlerine bağlıdır:

python
# benchmark_comparison.py
import time
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
import xgboost as xgb
import lightgbm as lgb

# Buyuk veri seti uzerinde benchmark
def benchmark(n_samples=100000, n_features=100):
    X, y = make_classification(n_samples=n_samples, n_features=n_features, random_state=42)
    
    # XGBoost zamanlama
    xgb_model = xgb.XGBClassifier(n_estimators=100, tree_method='hist', device='cuda')
    start = time.time()
    xgb_model.fit(X, y)
    xgb_time = time.time() - start
    
    # LightGBM zamanlama
    lgb_model = lgb.LGBMClassifier(n_estimators=100, device='gpu')
    start = time.time()
    lgb_model.fit(X, y)
    lgb_time = time.time() - start
    
    return {'xgboost': xgb_time, 'lightgbm': lgb_time}

Pratik seçim kriterleri şunları içerir:

  • Veri boyutu: LightGBM bellek verimliliği sayesinde büyük veri setlerinde genellikle daha hızlıdır
  • GPU desteği: Her ikisi de CUDA hızlandırma sunar, XGBoost daha olgun bir implementasyona sahiptir
  • Kategorik değişkenler: Her ikisinde de yerel destek, LightGBM daha uzun deneyime sahiptir
  • Veri kayması: XGBoost MLOps kütüphaneleriyle entegrasyon yoluyla yerleşik izleme araçlarına sahiptir

Yaygın Mülakat Soruları

Data science pozisyonları için yapılan mülakatlar sıklıkla gradient boosting hakkında sorular içerir. İşte en önemli konular:

Soru 1: "Seviye bazlı ve yaprak bazlı büyütme stratejileri arasındaki fark nedir?"

Cevap, seviye bazlı büyütmenin (XGBoost) aynı seviyedeki tüm düğümleri genişlettiğini, dengeli ağaçlar ve doğal düzenlileştirme sağladığını vurgulamalıdır. Yaprak bazlı büyütme (LightGBM) en büyük kayıp azalmasına sahip yaprağı seçer ve potansiyel olarak daha derin, asimetrik ağaçlara yol açar; daha yüksek doğruluk sağlar ancak aşırı uyum riski taşır.

Soru 2: "Gradient boosting eksik değerleri nasıl işler?"

Her iki kütüphane de düğüm bölmesi sırasında eksik değerler için optimal yönü otomatik olarak öğrenir. İmputasyon gerekli değildir çünkü eksik değerler kaybı minimize eden dala gider.

Soru 3: "Gradient boosting'de learning rate'in rolünü açıklayın."

Learning rate (shrinkage) her ağacın katkısını ölçeklendirir ve tek bir ağacın son ensemble üzerindeki etkisini azaltır. Daha düşük değerler daha fazla ağaç gerektirir ancak daha yavaş, daha muhafazakar tahmin birikimi yoluyla genellemeyi iyileştirir.

Prodüksiyon için Gelişmiş Teknikler

Gradient boosting modellerinin prodüksiyon ortamına dağıtımı performans ve izleme hususlarını gerektirir:

python
# production_deployment.py
import json
import xgboost as xgb

# Model serializasyonu
model.save_model('model.json')  # Tasinabilirlik icin JSON formati
model.save_model('model.ubj')   # Performans icin binary format

# Cikarim optimizasyonu
config = {
    'nthread': 4,                  # Tahmin edilebilir gecikme icin is parcacigi sinirlamasi
    'predictor': 'cpu_predictor'   # Kararli produksiyon tahmincisi
}

# Optimizasyonlu batch tahmin
def batch_predict(model, data, batch_size=10000):
    predictions = []
    for i in range(0, len(data), batch_size):
        batch = data[i:i+batch_size]
        dmatrix = xgb.DMatrix(batch)
        predictions.extend(model.predict(dmatrix))
    return predictions

Sonuç

XGBoost ve LightGBM, 2026 yılında tablo veri modelleme için endüstri standartlarını temsil etmektedir. XGBoost olgunluk, geniş entegrasyon ve kararlı GPU implementasyonu sunar. LightGBM büyük veri setlerinde daha hızlı eğitim ve yenilikçi örnekleme algoritmaları sağlar. Aralarındaki seçim projenin spesifik gereksinimlerine bağlıdır, ancak pratikte performans farklılıkları uygun hiperparametre optimizasyonundan sonra genellikle marjinaldir. Ağaç büyütme stratejilerinden kategorik değişken işlemeye kadar her iki kütüphanenin iç mekanizmalarını anlamak, mülakata hazırlanan veya prodüksiyon projeleri üzerinde çalışan her data science uzmanı için kritik bilgidir.

Günün meydan okuması

Data Science & ML kodundaki hatayı bulabilir misin?

Gerçek bir kod parçası, gizli bir hata, günde bir deneme. Denemek için hesap gerekmez.

Meydan okumayı kabul et
Anthony Fillion-Maillet

Yazan:

Anthony Fillion-Maillet

SharpSkill kurucusu

10 yılı aşkın süredir fullstack geliştirici. SharpSkill’i yönetiyor ve burada yayımlanan her şeyden sorumlu.

17 Eylül 2026 tarihinde güncellendi

Etiketler

#xgboost
#lightgbm
#gradient boosting
#machine learning
#data science
#python

Paylaş

İlgili makaleler

Makine öğrenmesi için öznitelik mühendisliği tekniklerini gösteren Python kod örnekleri ve veri dönüşüm diyagramları

Makine Öğrenmesi İçin Öznitelik Mühendisliği: Teknikler ve Mülakat Soruları 2026

Makine öğrenmesi öznitelik mühendisliği tekniklerini Python ile uygulamalı olarak öğrenin. Kodlama, ölçekleme, öznitelik seçimi, scikit-learn pipeline yapıları ve veri bilimi mülakat soruları.

Scikit-learn Pipeline ve Python'da özellik mühendisliği

2026'da Scikit-Learn Pipeline: Özellik Mühendisliği ve Mülakat Soruları

Scikit-learn Pipeline ve ColumnTransformer için kapsamlı kılavuz. Özellik mühendisliği, veri sızıntısı önleme ve makine öğrenimi mülakat sorularını kapsar.

Vektör veritabanı ve LLM ile RAG retrieval-augmented generation pipeline mimarisi

2026'da RAG ve LLM: Veri Bilimi Mülakatları için Retrieval-Augmented Generation

2026'da veri bilimi mülakatları için Retrieval-Augmented Generation (RAG) açıklanıyor. Vektör veritabanları, chunking stratejileri, gömme modelleri, agentic RAG, Graph RAG ve üretime hazır pipeline mimarisi.