Python’da Ensemble Learning: Random Forest ve XGBoost’a Uygulamalı Rehber

Tek bir karar ağacı yorumlaması kolaydır ancak aşırı uyuma (overfit) meyillidir. Basit bir doğrusal model iyi genelleşir ama karmaşık örüntüleri kaçırır. Her model türünün, gerçek dünya verilerinde doğruluğunu sınırlayan kör noktaları vardır.

Ensemble yöntemleri bunu, birden çok modeli tek bir modelde birleştirerek çözer. Tek bir tahminciye güvenmek yerine, birçok modelin tahminlerini bir araya getirirler; böylece bireysel hatalar birbirini götürür. Sonuç genellikle, tek bir modelin sağlayabileceğinden daha yüksek doğruluktur.

Bu eğitimde, temel ensemble yöntemleri arasındaki farkları anlatacak ve en popüler iki ensemble algoritmasına odaklanacağım: Random Forest ve XGBoost. 

Her birinin nasıl çalıştığını öğrenecek, her ikisini de çok sınıflı bir sınıflandırma probleminde uygulayacak ve performanslarını karşılaştıracaksınız. Amaç, her yaklaşımı ne zaman kullanmanız gerektiğini ve kendi projeleriniz için nasıl ayarlayacağınızı pratiğe dönük biçimde kavratmaktır.

Daha fazla uygulama arıyorsanız, Python ile Ensemble Yöntemleri kursuna göz atmanızı öneririm. 

Ensemble Learning Nedir?

Ensemble learning, birden fazla modeli eğitir ve tahminlerini tek bir çıktıda birleştirir. Fikir basit: farklı modeller farklı hatalar yapar; bu nedenle çok sayıda modelin ortalamasını almak ya da oylama yapmak bireysel hataları genellikle dengeler.

Ensemble learning, birden fazla modelin tahminlerini tek bir birleştirilmiş çıktıda toplar

Beş karar ağacı eğittiğiniz bir sınıflandırma görevini düşünün. Her ağaç tahminlerin %80’ini doğru yapabilir, ancak hepsi aynı örneklerde başarısız olmaz. Oylarını birleştirdiğinizde, bir veya iki ağaç yanlış olsa bile çoğunluk genellikle doğruyu bulur. Tüm ensemble yöntemlerinin temel ilkesi budur.

Bir ensemble içindeki modeller temel öğrenenler olarak adlandırılır. Herhangi bir algoritma olabilirler, ancak karar ağaçları en yaygın tercihtir; çünkü hızlı eğitilirler ve farklı veri altkümeleri verildiğinde doğal olarak çeşitli tahminler üretirler.

Bias-variance dengesi

Model hataları iki kaynaktan gelir: bias ve varyans.

Bias, problemi aşırı basitleştirmekten kaynaklanan hatadır. Kavisli bir ilişkiyi doğrusal bir modelle yakalamaya çalışmak, model ne kadar veri görürse görsün gerçek örüntüyü temsil edemediği için yüksek bias üretir. Yüksek bias’lı modeller farklı eğitim setlerinde benzer tahminler üretir; ancak bu tahminler her seferinde hedefin dışındadır.

Varyans, eğitime aşırı duyarlı olmaktan kaynaklanan hatadır. Eğitim setini ezberleyen derin bir karar ağacı, sinyalle birlikte gürültüyü de yakaladığı için yüksek varyansa sahiptir. Aynı ağacı biraz farklı bir örneklemle yeniden eğitirseniz, bambaşka tahminler elde edersiniz. Model eğitim verisini iyi uydurur ama yeni veride dağılır.

Hedef tahtalarıyla bias ve varyans görselleştirmesi: yüksek bias tutarlı ama hedef dışı tahminler, yüksek varyans dağınık ve tutarsız tahminler gösterir

Bunu bir kararlılık sorunu olarak düşünebilirsiniz. Yüksek bias’lı modeller stabildir ama her seferinde aynı şekilde yanlıştır. Yüksek varyanslı modeller ise stabıl değildir ve gördükleri veriye göre farklı şekillerde yanılır. 

Karar ağaçları yüksek varyans kampında yer alır. Açgözlü bölme (greedy splitting) kullanırlar; bu da eğitim verisindeki küçük değişikliklerin bambaşka ağaç yapıları üretmesine yol açar. 

Aynı ağaç algoritmasını aynı popülasyondan iki rastgele örneklemde eğitirseniz, birbirine hiç benzemeyen iki model elde edebilirsiniz. Bu istikrarsızlık tekil ağaçları güvenilmez kılsa da, onları ensemble’lar için mükemmel yapı taşları yapar. 

Yüksek varyans, toplulaştırma (aggregation) ile iyileştirme payı olduğu anlamına gelir. Ağaçlar ayrıca hızlı eğitilir ve elle özellik mühendisliği gerektirmeden doğrusal olmayan ilişkileri yakalar; bu nedenle Random Forest ve XGBoost, bias-variance probleminin farklı kısımlarına saldırmalarına rağmen ikisi de ağaçları kullanır.

Ensemble yöntemleri bu dengeyi, birden fazla modeli birleştirerek kırar:

Bagging 

Bagging, verinin rastgele altkümelerinde paralel olarak birçok model eğitir ve tahminlerini ortalar. Bu, bireysel modellerin tuhaflıklarını düzleyerek varyansı azaltır. Sezgi açıktır: Her model bir miktar bağımsız hata yapıyorsa, ortalama bu hataları götürme eğilimindedir. Ne kadar çok modeli birleştirirseniz, nihai tahmin o kadar istikrarlı olur. Bu nedenle Random Forest varsayılan olarak 10 yerine 100 ağaç kullanır.

Boosting 

Boosting, modelleri ardışık olarak eğitir; her yeni model öncekilerin hatalarına odaklanır. Bu, birçok zayıf öğrenenden güçlü bir öğrenen oluşturarak bias’ı azaltır.

Ensemble Learning: Bagging vs Boosting

Bagging ve boosting’in pratikte nasıl çalıştığını adım adım inceleyelim.

Bagging: varyansı azaltmak için paralel eğitim

Bagging, bootstrap aggregate’in kısaltmasıdır. Süreç üç adımdan oluşur:

1.      Orijinal veriden yerine koyarak örnekleme ile birden çok eğitim seti oluşturun (bootstrap örnekleri)

2.     Her bootstrap örneğinde bağımsız bir model eğitin

3.     Tahminleri ortalama (regresyon) veya çoğunluk oyu (sınıflandırma) ile birleştirin

Bootstrap örnekleme, her eğitim setinin orijinalle aynı boyutta olduğu, ancak bazı örneklerin birden fazla kez göründüğü, bazılarının ise hiç yer almadığı anlamına gelir. Ortalama olarak, her bootstrap örneği orijinal verideki benzersiz örneklerin yaklaşık %63’ünü içerir. Kalan %37’si out-of-bag örneklerdir ve doğrulama için kullanılabilir.

Bagging iş akışı: eğitim verisi bootstrap örneklerine bölünür, her biri bağımsız bir karar ağacı eğitir, ardından çoğunluk oyu ile birleştirilir

Her model verinin farklı bir kesitini gördüğü için farklı tuhaflıklar geliştirir. Bazıları özellik uzayının bir bölgesine aşırı uyarken, diğerleri başka bir bölgeye aşırı uyar. Tahminlerini topladığınızda bu bireysel hatalar yıkanır gider. Ensemble tahmini, tek bir modelden daha stabildir.

Modeller birbirine bağlı olmadığından eğitim paralel gerçekleşir. Bu da bagging’i birden fazla CPU çekirdeğine ölçeklemeyi kolaylaştırır. Bu eğitimde daha sonra uygulayacağınız Random Forest, en yaygın kullanılan bagging algoritmasıdır. Teoriye daha derin bakmak için DataCamp’in makine öğreniminde bagging rehberine bakın.

Boosting: bias’ı azaltmak için ardışık eğitim

Boosting farklı bir yaklaşım benimser. Modelleri bağımsız olarak eğitmek yerine, onları art arda eğitir; her yeni model, önceki modellerin yanlış yaptığı örneklere odaklanır.

Genel süreç şu şekildedir:

1.     Tam eğitim setinde zayıf bir model eğitin

2.     Modelin kötü tahmin ettiği örnekleri belirleyin

3.     Bir sonraki modeli bu zor örneklere ekstra ağırlık vererek eğitin

4.     Kalan hataları düzelten modeller ekleyerek tekrarlayın

5.     Tüm modelleri ağırlıklı bir toplamda birleştirin; daha iyi performans gösteren modellere daha yüksek ağırlık verin

“Zayıf öğrenen”, rastgele tahminden sadece biraz daha iyi performans gösteren model anlamına gelir. Karar kütükleri (tek bölmeli ağaçlar) yaygın bir tercihtir. Tek başına bir kütük neredeyse işe yaramaz. Ancak boosting yüzlercesini yığar; her biri, öncekilerin bıraktığı hataları biraz daha törpüler. Nihai ensemble, çok sayıda zayıf katkıdan oluşan güçlü bir öğrenendir.

Boosting iş akışı: her model bir öncekilerin hatalarını düzeltir ve ağırlıklı toplamda birleştirilir

Bagging’in aksine boosting doğası gereği ardışık bir süreçtir. 1’den 46’ya kadar olan modellerin hangi örneklerde zorlandığını bilmeden 47. modeli eğitemezsiniz. Bu, boosting’i eğitirken daha yavaş kılar; fakat çoğu zaman daha yüksek doğruluk sağlar; çünkü her model, ensemble’ın belirli zayıflıklarını gidermek için özel olarak inşa edilir.

Bu eğitimde daha sonra uygulayacağınız XGBoost, tablo verisi için başvuru niteliğinde hale gelmiş bir gradyan boosting algoritmasıdır. Matematiğe daha ayrıntılı bakmak isterseniz boosting’e giriş rehberini öneririm.

Yan yana karşılaştırma: bagging varyansı azaltmak için paralel eğitim, boosting bias’ı azaltmak için ardışık eğitim kullanır

Diğer Ensemble Learning Yaklaşımları

Bagging ve boosting en yaygın ensemble stratejileridir; ancak tek seçenek bunlar değildir. Random Forest ve XGBoost’a dalmadan önce başka neler olduğuna değinmekte fayda var.

Oylama ve ortalama alma

Modelleri birleştirmenin en basit yolu onlara oy kullandırmaktır. Sert oylamada (hard voting), her model bir tahmin yapar ve en çok oyu alan sınıf kazanır. Örneğin bir lojistik regresyon, bir destek vektör makinesi ve bir karar ağacınız varsa ve ikisi A sınıfını, biri B sınıfını tahmin ediyorsa ensemble A’yı çıktılar.

Yumuşak oylama (soft voting) bunu, ayrık oyları saymak yerine tahmin olasılıklarını ortalayarak bir adım öteye taşır. A sınıfını %90 güvenle tahmin eden bir model, %51 güvenle tahmin edene göre nihai karara daha fazla katkıda bulunur. Bu, her modelin ne kadar emin olduğunu yansıttığı için genellikle sert oylamadan daha iyi performans gösterir.

Ayrıca güçlü modellere daha fazla etki vermek için ağırlıklar atayabilirsiniz. Lojistik regresyonunuz doğrulamada diğerlerini sürekli geride bırakıyorsa, onun tahminlerini 2x ile ağırlıklandırıp diğerlerini 1x’te tutabilirsiniz.

Oylama, problemi farklı şekillerde ele alan modelleri birleştirirken en iyi sonucu verir. Doğrusal bir model, ağaç tabanlı bir model ve en yakın komşu modeli, her biri farklı kör noktalara sahiptir. Birleşik tahminleri, tek tek modeller güçlü olmasa bile genellikle her birinden daha iyidir. scikit-learn bu amaçla VotingClassifier ve VotingRegressor sağlar.

Stacking ve blending

Stacking ensemble fikrini bir seviye daha derine taşır. Tahminleri ortalamak yerine, bunları birleştirmek için ikinci bir model (meta-öğrenen) eğitirsiniz. Süreç şöyle işler: birkaç temel model eğitin, doğrulama seti üzerinde tahminlerini toplayın, ardından meta-öğreneni bu tahminleri doğru etiketlere eşleyecek şekilde eğitin. Meta-öğrenen, hangi durumda hangi temel modele güveneceğini öğrenir.

Çeşitli temel modellerin tahminlerinin, nihai çıktı için bunları birleştiren bir meta-öğrenene aktığını gösteren stacking mimarisi

Blending, çapraz doğrulama katları yerine tek bir holdout seti kullanan daha basit bir varyanttır. Uygulaması daha hızlıdır; ancak bazı eğitim verisini boşa harcar ve holdout setine aşırı uyum sağlamaya daha yatkındır.

Her iki teknik de ekstra doğruluk sıkıştırabilir; fakat eklenen karmaşıklığa kıyasla kazanımlar genellikle küçüktür (%0,1–0,5 iyileşme). Yığılmış ensemble’lar hata ayıklaması zor, eğitimi yavaş ve paydaşlara açıklaması güçtür. Eğitim süresinin sınırsız olduğu ve her ondalık puanın önemli olduğu Kaggle yarışmalarında parlarlar; ama üretimde nadiren bu yükü karşılarlar.

İlginçtir ki, çoğu yığılmış ensemble zaten temel öğrenen olarak Random Forest ve XGBoost’u kullanır. Bu iki algoritma o kadar güçlüdür ki stacking çoğu zaman onların tahminlerini ortalamanın süslü bir yoluna dönüşür.

Bu eğitimin bagging ve boosting’e odaklanma nedeni

Bu eğitim, Random Forest (bagging) ve XGBoost’a (boosting) odaklanır; çünkü gerçek dünyadaki tablo verisi problemlerinin büyük çoğunluğunu bunlar karşılar. Çok seviyeli yığılmış ensemble’lara kıyasla uygulaması daha basit, ayarlaması daha kolay ve bakımı daha rahattırlar.

Oylama ve stacking’e daha derin dalmak isterseniz, DataCamp’in Python ile Ensemble Yöntemleri kursu tüm teknikleri kapsar. Şimdilik veri setiyle uygulamaya geçelim.

Ensemble Sınıflandırma İçin Veriyi Hazırlama

Bu eğitim, UCI Makine Öğrenimi Deposundaki Dry Beans veri setini kullanır. Araştırmacılar Koklu ve Ozkan (2020), yedi çeşitten 13.611 kuru fasulyeyi fotoğrafladı ve her görüntüden alan, çevre, eksen uzunlukları ve şekil faktörleri dahil 16 geometrik özellik çıkardı. Görev, bu ölçümlere dayanarak her fasulyeyi çeşidine göre sınıflandırmaktır.

Bu veri seti, tüm özelliklerin sayısal olduğu temiz bir çok sınıflı problem olduğu için bu eğitim için uygundur. Eksik değer yok, kategorik kodlama yok, metin ön işleme yok. Tümüyle ensemble yöntemlerine odaklanabilirsiniz.

Veriyi yükleme ve bölme

!uv add ucimlrepo scikit-learn pandas xgboost

 from ucimlrepo import fetch_ucirepo
 from sklearn.model_selection import train_test_split
 import pandas as pd

 dry_bean = fetch_ucirepo(id=602)
 X = dry_bean.data.features
 y = dry_bean.data.targets.values.ravel()

 print(f"Features shape: {X.shape}")
 print(f"Target classes: {pd.Series(y).nunique()}")Altyapı:

Features shape: (13611, 16)
 Target classes: 7Altyapı:

X.head()Altyapı:

pd.Series(y).value_counts()Altyapı:

DERMASON	3546
 SIRA    	2636
 SEKER   	2027
 HOROZ   	1928
 CALI    	1630
 BARBUNYA	1322
 BOMBAY   	522Altyapı:

Sınıflar makul ölçüde dengeli; en yaygını Dermason, en azı Bombay. Tabakalı (stratified) bir bölme, bu oranları hem eğitim hem test setinde korur:

X_train, X_test, y_train, y_test = train_test_split(
 	X, y, test_size=0.2, random_state=42, stratify=y
 )
 print(f"Training set: {X_train.shape[0]} samples")
 print(f"Test set: {X_test.shape[0]} samples")Altyapı:

Training set: 10888 samples
 Test set: 2723 samplesAltyapı:

Python’da Random Forest Sınıflandırıcı

Veri hazır olduğuna göre ilk ensemble modelini eğitme zamanı. Bu bölümde Random Forest’ın kaput altında nasıl çalıştığını, eğitim ve değerlendirme adımlarını ve hiperparametre ayarlarını göreceksiniz.

Random Forest nasıl çalışır

Random Forest, karar ağaçlarına bagging uygular ve bir ek dokunuş yapar. Her ağaç, verinin bir bootstrap örneğinde eğitilir (önceki bölümde anlatıldığı gibi); ancak her bölmede algoritma tüm özellikler yerine sadece rastgele bir özellik altkümesini dikkate alır.

Bu özellik rastgeleleştirmesi, ağaçların fazla benzemesini engeller. Aksi halde, aynı güçlü öngördürücüler her ağaçta baskın olur ve ensemble neredeyse özdeş modellerin birçok kopyasından ibaret kalır. 

Her bölmeyi sınırlı bir özellik seti arasından seçmeye zorlayarak, algoritma farklı hatalar yapan çeşitli ağaçlar oluşturur. Bu ağaçlar birlikte oy kullandığında, bireysel hataları birbirini götürme eğilimindedir.

Sınıflandırmada scikit-learn, her bölmede toplam özelliklerin karekökünü dikkate almayı varsayılan yapar. Dry Beans veri setinde 16 özellik olduğundan, her bölme yalnızca rastgele seçilmiş 4 özelliği değerlendirir. Sonuç, tek bir ağacın sağlayamayacağı kadar iyi genelleşen, ilişkisiz ağaçlardan oluşan bir ensemble’dır.

Eğitim ve değerlendirme

from sklearn.ensemble import RandomForestClassifier
 from sklearn.metrics import classification_report, accuracy_score

 rf = RandomForestClassifier(n_estimators=100, random_state=42)
 rf.fit(X_train, y_train)
 y_pred_rf = rf.predict(X_test)

 print(f"Accuracy: {accuracy_score(y_test, y_pred_rf):.4f}")
 print(classification_report(y_test, y_pred_rf))Altyapı:

Accuracy: 0.9199
           	precision	recall  f1-score   support

 	BARBUNYA   	0.94      0.89  	0.92   	265
   	BOMBAY   	1.00      1.00  	1.00   	104
     	CALI   	0.94      0.94  	0.94   	326
 	DERMASON   	0.90      0.92  	0.91   	709
    	HOROZ   	0.96      0.95  	0.96   	386
    	SEKER   	0.94      0.96  	0.95   	406
     	SIRA   	0.86      0.85  	0.86   	527

 	accuracy                       	0.92 	 2723
    macro avg   	0.93      0.93  	0.93  	2723
 weighted avg   	0.92  	0.92      0.92  	2723Altyapı:

Bu kod, 100 karar ağacından oluşan bir orman yaratır, bunları bootstrap örneklerinde eğitir ve çoğunluk oyu ile tahmin üretir. random_state parametresi rastgelelik tohumunu sabitleyerek sonuçların tekrarlanabilir olmasını sağlar.

Sınıflandırma raporu performansı sınıf bazında döker. Precision, pozitif tahminlerin ne kadarının doğru olduğunu; recall, gerçek pozitiflerin ne kadarının bulunduğunu; F1 ise bunların harmonik ortalamasını ölçer. Bombay fasulyeler kusursuz sınıflandırılır (muhtemelen fiziksel olarak belirgin oldukları için), Sira ise diğer çeşitlerden ayırt edilmesi en zordur.

Random Forest’ın avantajlarından biri, yorumlanabilir özellik önemleridir. Algoritma, tüm ağaçlar boyunca her özelliğin saf olmayanlığı (varsayılan olarak Gini indeksi) ne kadar azalttığını takip eder ve hangi değişkenlerin daha çok önemli olduğunu gösteren yerleşik bir ölçü sunar:

import matplotlib.pyplot as plt

 importances = rf.feature_importances_
 feature_names = X.columns
 sorted_idx = importances.argsort()[::-1][:10]

 plt.figure(figsize=(10, 6))
 plt.barh(range(10), importances[sorted_idx][::-1])
 plt.yticks(range(10), feature_names[sorted_idx][::-1])
 plt.xlabel("Feature importance")
 plt.title("Top 10 features (Random Forest)")
 plt.tight_layout()
 plt.show()Altyapı:

Random Forest özellik önemi

feature_importances_ özniteliği, toplamı 1 olan bir puan dizisi döndürür; yüksek değerler, bölme kararlarına daha fazla katkıda bulunan özellikleri gösterir. ShapeFactor3 ve Compactness sınıflandırmaya en çok katkıda bulunur; ardından Perimeter ve MinorAxisLength gibi geometrik ölçümler gelir. Bu şekil temelli özellikler, veri setini tasarlayan araştırmacıların amaçladığı, çeşitler arasındaki görsel farklılıkları yakalar.

Ayarlamaya değer hiperparametreler

Random Forest’ta ayarlamaya değer üç ana hiperparametre vardır:

• n_estimators: Ormandaki ağaç sayısı. Daha fazla ağaç daha istikrarlı tahmin üretir, ancak eğitim süresi uzar. Çoğu veri setinde 200 ağacın ötesinde getiriler azalır.
• max_depth: Her ağacın maksimum derinliği. Varsayılan (None) yapraklar saf olana ya da 2’den az örnek kalana kadar ağacı büyütür. Daha düşük değerler aşırı uyumu engelleyebilir.
• max_features: Her bölmede dikkate alınacak özellik sayısı. Varsayılan "sqrt" sınıflandırma için iyi çalışır. "log2" kullanmak, tekil ağaç doğruluğu pahasına çeşitliliği artırır.

Bu parametreler üzerinde hızlı bir ızgara araması:

from sklearn.model_selection import GridSearchCV

 param_grid = {
 	"n_estimators": [100, 200],
 	"max_depth": [10, 20, None],
 	"max_features": ["sqrt", "log2"]
 }

 grid_search = GridSearchCV(
     RandomForestClassifier(random_state=42),
 	param_grid,
 	cv=3,
 	scoring="accuracy",
 	n_jobs=-1
 )
 grid_search.fit(X_train, y_train)

 print(f"Best params: {grid_search.best_params_}")
 print(f"Best CV accuracy: {grid_search.best_score_:.4f}")Altyapı:

Best params: {'max_depth': None, 'max_features': 'sqrt', 'n_estimators': 200}
 Best CV accuracy: 0.9244Altyapı:

GridSearchCV, ızgaradaki tüm parametre kombinasyonlarını dener ve her birini çapraz doğrulama ile değerlendirir. cv=3 argümanı eğitim verisini 3 katmana böler; ikisinde eğitir, birinde doğrular ve tüm kombinasyonlarda döner. n_jobs=-1 bayrağı, aramayı mevcut tüm CPU çekirdeklerine paralelleştirir.

y_pred_tuned = grid_search.best_estimator_.predict(X_test)
 print(f"Tuned test accuracy: {accuracy_score(y_test, y_pred_tuned):.4f}")Altyapı:

Tuned test accuracy: 0.9214Altyapı:

Ayarlama, doğruluğu %92,0’dan %92,1’e çıkarır; mütevazı bir iyileşme. En iyi yapılandırma, max_depth ve max_features için varsayılanları kullanırken ağaç sayısını 100’den 200’e çıkarır. Random Forest çoğu zaman kutudan çıktığı gibi iyi performans gösterir; bu da başlıca cazibelerinden biridir. Random Forest ve parametrelerine dair daha derin bir bakış için DataCamp’in Random Forest sınıflandırma eğitimine bakın.

Python’da XGBoost Sınıflandırıcı

XGBoost (Extreme Gradient Boosting), doğruluğa giden yolda Random Forest’tan farklı bir rota izler. Random Forest bağımsız ağaçların ortalamasıyla varyansı azaltırken, XGBoost ağaçları ardışık olarak eğitip her yeni ağacı o ana kadarki ensemble’ın hatalarını düzeltmek üzere eğiterek bias’ı azaltır. Bu bölüm, gradyan boosting’in nasıl çalıştığını, XGBoost’u özel kılan şeyleri ve Dry Beans veri setinde nasıl eğitilip ayarlanacağını kapsar.

Gradyan boosting nasıl çalışır

Gradyan boosting, ensemble’ı her seferinde bir ağaç ekleyerek inşa eder. İlk ağaç orijinal hedef üzerinde tahmin yapar. İkinci ağaç, orijinal hedefe değil, ilk ağacın artık hatalarına (residual) göre eğitilir. Üçüncü ağaç, ikinci ağacın tahminleri eklendikten sonra kalan artıkları uydurur. Bu, yüzlerce tur boyunca sürer; her yeni ağaç, geride kalan hataları biraz daha törpüler.

“Gradyan” terimi, algoritmanın neyi uyduracağına nasıl karar verdiğini ifade eder. Her adımda, kayıp fonksiyonunun mevcut tahminlere göre gradyanını hesaplar. Kare hata kaybı ile regresyonda bu gradyan sadece artık (gerçek eksi tahmin) olur. Sınıflandırmada matematik daha karmaşıktır; ancak sezgi aynıdır: her ağaç, kaybı en çok azaltacak yönde tahminleri hareket ettirmek üzere eğitilir.

Bir öğrenme oranı parametresi, her ağacın katkısını ensemble’a eklemeden önce küçültür. Örneğin öğrenme oranı 0,1 ise, her ağacın tahmininin sadece %10’u eklenir. Bu, algoritmayı daha küçük adımlar atmaya zorlar ve genellikle genelleştirmeyi iyileştirir. Takas şudur: aynı uyum düzeyine ulaşmak için daha fazla ağaca ihtiyaç duyarsınız. Küçük öğrenme oranı + çok sayıda ağaç, büyük öğrenme oranı + az sayıda ağaçtan genellikle daha iyi sonuç verir.

XGBoost’u farklı kılan nedir

XGBoost, LightGBM ve CatBoost ile birlikte bir dizi gradyan boosting uygulamasından biridir. Popülerleşmesinin nedeni, scikit-learn’ün GradientBoostingClassifier gibi önceki uygulamalara çeşitli iyileştirmeler eklemesidir.

Başlıca eklemeler şunlardır:

• Amaç fonksiyonuna yerleşik L1 ve L2 düzenlileştirme; bu, karmaşık ağaçları cezalandırarak aşırı uyumu azaltır
• Eksik değerleri her bölmede eksik veriye en uygun yönü öğrenerek doğal biçimde ele alma
• Her boosting turu içinde paralelleştirilmiş ağaç inşası; bu da tamamen ardışık uygulamalardan daha hızlıdır
• Sütun örnekleme; bu da her ağaçta veya bölmede özellikleri rastgele örnekler (Random Forest’taki özellik rastgeleleştirmesine benzer)

Bu özellikler XGBoost’u hem daha hızlı hem de sade gradyan boosting’e göre aşırı uyuma daha dayanıklı kılar. Düzenlileştirme parametreleri, gürültülü veya yüksek boyutlu verilerle çalışırken faydalı olan model karmaşıklığı üzerinde doğrudan kontrol sağlar.

Eğitim ve değerlendirme

XGBoost, dize yerine sayısal sınıf etiketleri bekler; bu nedenle ilk adım hedef değişkenini kodlamaktır:

from xgboost import XGBClassifier
 from sklearn.preprocessing import LabelEncoder

 le = LabelEncoder()
 y_train_encoded = le.fit_transform(y_train)
 y_test_encoded = le.transform(y_test)

 xgb = XGBClassifier(n_estimators=100, random_state=42, eval_metric="mlogloss")
 xgb.fit(X_train, y_train_encoded)
 y_pred_xgb = xgb.predict(X_test)

 print(f"Accuracy: {accuracy_score(y_test_encoded, y_pred_xgb):.4f}")
 print(classification_report(y_test_encoded, y_pred_xgb, target_names=le.classes_))Altyapı:

Accuracy: 0.9232
           	precision	recall  f1-score   support

 	BARBUNYA   	0.95      0.89  	0.92   	265
   	BOMBAY   	1.00      1.00  	1.00   	104
     	CALI   	0.94      0.94  	0.94   	326
 	DERMASON   	0.90      0.93  	0.91   	709
    	HOROZ   	0.96      0.96  	0.96   	386
    	SEKER   	0.95      0.96  	0.95   	406
     	SIRA   	0.87      0.86  	0.87   	527

 	accuracy                       	0.92 	 2723
    macro avg   	0.94      0.93  	0.93  	2723
 weighted avg   	0.92  	0.92      0.92  	2723Altyapı:

LabelEncoder, sınıf adlarını tamsayılara (0’dan 6’ya) eşler ve bu eşlemeyi, tahminleri sınıf adlarına geri çevirebilmeniz için saklar. eval_metric="mlogloss" argümanı, XGBoost’a dahili değerlendirme için çok sınıflı log loss kullanmasını söyler.

Varsayılan ayarlarla XGBoost %92,3 doğruluk elde eder; bu, Random Forest’ın %92,0’ından biraz yüksektir. Sınıf bazında desen benzerdir: Bombay mükemmel sınıflandırılırken, Sira ayırt edilmesi en zor sınıf olmaya devam eder.

XGBoost, bir özelliğin kullanıldığı tüm bölmelerde doğruluğu ortalamada ne kadar iyileştirdiğini ölçen kazanca (gain) dayalı özellik önemleri sağlar:

importances_xgb = xgb.feature_importances_
 sorted_idx_xgb = importances_xgb.argsort()[::-1][:10]

 plt.figure(figsize=(10, 6))
 plt.barh(range(10), importances_xgb[sorted_idx_xgb][::-1])
 plt.yticks(range(10), feature_names[sorted_idx_xgb][::-1])
 plt.xlabel("Feature importance (gain)")
 plt.title("Top 10 features (XGBoost)")
 plt.tight_layout()
 plt.show()Altyapı:

XGBoost özellik önemi

Sıralama Random Forest’tan farklıdır. XGBoost Compactness ve ConvexArea’yı üste koyarken, Random Forest ShapeFactor3’ü birinci sıraya koymuştu. 

Bu fark, iki algoritmanın özellikleri nasıl kullandığını yansıtır: Random Forest, birçok bağımsız ağaçta bir özelliğin saf olmayanlığı ne sıklıkla azalttığını ölçerken; XGBoost, artıklar düzeltilirken her özelliğin ne kadar doğruluk eklediğini ölçer. Her iki sıralama da geçerlidir; sadece özellik faydasının farklı yönlerini yakalarlar.

Ayarlamaya değer hiperparametreler

XGBoost, daha büyük esnekliğini yansıtır biçimde Random Forest’tan daha fazla ayar düğmesine sahiptir. Dikkate alınacak başlıca parametreler şunlardır:

• learning_rate: Her ağaca uygulanan küçültme (varsayılan 0,3). Daha düşük değerler daha fazla ağaç gerektirir ama genellikle daha iyi genelleşir.
• max_depth: Maksimum ağaç derinliği (varsayılan 6). Daha sığ ağaçlar aşırı uyumu azaltır. XGBoost’un varsayılanı, Random Forest’ın sınırsız derinliğine göre daha muhafazakârdır.
• n_estimators: Boosting tur sayısı. Düşük öğrenme oranıyla özellikle daha ince düzeltmeler sağlar.
• reg_alpha: Yaprak ağırlıklarında L1 düzenlileştirme (varsayılan 0). Daha yüksek değerler ağırlıkları sıfıra iter, daha seyrek modeller oluşturur.
• reg_lambda: Yaprak ağırlıklarında L2 düzenlileştirme (varsayılan 1). Daha yüksek değerler büyük ağırlıkları cezalandırır, tahminleri yumuşatır.

Bu parametrelerin birkaçı üzerinde ızgara araması:

param_grid_xgb = {
 	"learning_rate": [0.05, 0.1],
 	"max_depth": [4, 6],
 	"n_estimators": [100, 200],
 	"reg_lambda": [1, 5]
 }

 grid_search_xgb = GridSearchCV(
 	XGBClassifier(random_state=42, eval_metric="mlogloss"),
 	param_grid_xgb,
 	cv=3,
 	scoring="accuracy",
 	n_jobs=-1
 )
 grid_search_xgb.fit(X_train, y_train_encoded)

 print(f"Best params: {grid_search_xgb.best_params_}")
 print(f"Best CV accuracy: {grid_search_xgb.best_score_:.4f}")Altyapı:

Best params: {'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 200, 'reg_lambda': 5}
 Best CV accuracy: 0.9284Altyapı:

y_pred_xgb_tuned = grid_search_xgb.best_estimator_.predict(X_test)
 print(f"Tuned test accuracy: {accuracy_score(y_test_encoded, y_pred_xgb_tuned):.4f}")Altyapı:

Tuned test accuracy: 0.9251Altyapı:

En iyi yapılandırma daha sığ ağaçlar (max_depth=4), daha fazla düzenlileştirme (reg_lambda=5) ve iki kat boosting turu (n_estimators=200) kullanır. Bu desen yaygındır: XGBoost çoğunlukla daha zayıf bireysel ağaçların daha çok boosting turuyla birleştirilmesiyle en iyi performansı verir. Ayarlama, test doğruluğunu %92,3’ten %92,5’e çıkarır.

XGBoost’un parametrelerine ve erken durdurma gibi gelişmiş özelliklerine daha derin bakmak için DataCamp’in Python’da XGBoost eğitimine bakın.

Random Forest vs XGBoost

Her iki modeli de eğitip ayarladıktan sonra, Dry Beans veri setinde karşılaştırmaları şöyle:

Performans karşılaştırması

Doğruluk sayıları XGBoost’u öne çıkarır; ancak makro F1’e baktığınızda fark kapanır. Her iki model de 0,93 elde eder; yani yedi fasulye sınıfının tümünde eşit derecede iyi performans gösterirler; sadece çoğunluk sınıfta parlamakla kalmazlar.

Sınıf bazında performans da benzer bir tablo sunar:

Her iki model de sınıfları aynı şekilde sıralar. Bombay fasulyeler en kolay sınıflandırılır (en büyük ve fiziksel olarak en belirgin olanlar); Sira ise en zordur (şekli Dermason ve Seker ile örtüşür). XGBoost’un sınıf bazındaki tek avantajı, Sira’da 1 puanlık F1 artışıdır.

Bu modeller arasındaki pratik fark doğruluk değildir. Fark, ayarlamaya ne kadar emek vermek istediğinizdir. Random Forest, varsayılan parametrelerle XGBoost’tan sadece %0,4 geride kaldı. XGBoost’un öne geçmesi için öğrenme oranı, ağaç derinliği ve düzenlileştirme üzerinde bir ızgara araması gerekti.

Her algoritma ne zaman kullanılmalı

Makûl bir iş akışı: Önce bir Random Forest ile baseline oluşturun; daha fazla performans sıkıştırmanız gerekiyorsa XGBoost’u deneyin. En iyi seçim, evrensel bir algoritma sıralamasından ziyade kısıtlarınıza bağlıdır.

Sonuç

Bu eğitimde, bagging ve boosting’in zayıf modelleri nasıl güçlüye çevirdiğini gösterdim. Bagging, modelleri paralel eğitir ve hatalarını ortalar. Boosting, modelleri sırayla eğitir; her biri bir öncekilerin yanlışını düzeltir.

Random Forest ve XGBoost başlıca uygulamalardır. Dry Beans veri setinde her ikisi de %92 civarında doğruluk elde etti. XGBoost ayarlamadan sonra öne geçti; ama Random Forest neredeyse hiç yapılandırma gerektirmeden bu seviyeye ulaştı. Esas takas bu: Random Forest düşük bakım ister; XGBoost ise ek çabayı ödüllendirir.

Yeni bir probleme başlarken önce bir Random Forest eğitin. Kurulumu dakikalar süren sağlam bir baseline’dır. Daha yüksek doğruluk itmeniz gerekiyorsa ve ayar yapmaya zamanınız varsa XGBoost’a geçin.

Bu algoritmalarla daha fazla uygulama için DataCamp’in Ağaç-Tabanlı Modellerle Makine Öğrenimi kursunu öneririm.