Python’da XGBoost Kullanımı Eğitimi

XGBoost Kurulumu

XGBoost’u herhangi bir kütüphane gibi pip ile kurabilirsiniz. Bu kurulum yöntemi, makinenizin NVIDIA GPU’su için desteği de içerir. Yalnızca CPU sürümünü kurmak isterseniz, conda-forge kullanabilirsiniz:

$ pip install --user xgboost

# CPU only

$ conda install -c conda-forge py-xgboost-cpu

# Use NVIDIA GPU

$ conda install -c conda-forge py-xgboost-gpu

Temel ortamınızı kirletmemek için XGBoost’u sanal bir ortamda kurmanız önerilir.

Eğitimdeki örnekleri GPU destekli bir makinede çalıştırmanızı öneririz. Böyle bir makineniz yoksa DataLab veya Google Colab gibi alternatiflere göz atabilirsiniz.

Colab’i tercih ederseniz, içinde XGBoost’un eski bir sürümü yüklüdür; en son sürümü almak için pip install --upgrade xgboost komutunu çağırmalısınız.

Veriyi Yükleme ve Keşfetme

Bu eğitim boyunca Diamonds veri kümesiyle çalışacağız. Bu veri kümesi Seaborn kütüphanesine dahildir; alternatif olarak Kaggle’dan da indirebilirsiniz. Sayısal ve kategorik özelliklerin güzel bir birleşimine ve 50 binden fazla gözleme sahiptir; bu sayede XGBoost’un tüm avantajlarını rahatlıkla gösterebiliriz.

import seaborn as sns

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import warnings


warnings.filterwarnings("ignore")


diamonds = sns.load_dataset("diamonds")

diamonds.head()

>>> diamonds.shape
(53940, 10)

Gerçek dünya projesinde veri kümesini keşfetmek ve özelliklerini görselleştirmek için çok daha fazla zaman harcamak isteyebilirsiniz. Ancak bu veri Seaborn’a yerleşik geldiği için nispeten temizdir.

Bu nedenle, sayısal ve kategorik özelliklerin 5 sayı özetine bakıp devam edeceğiz. Siz de veri kümesine aşina olmak için birkaç dakikanızı ayırabilirsiniz.

diamonds.describe()

diamonds.describe(exclude=np.number)

Bir XGBoost DMatrix Nasıl Oluşturulur

Keşfi tamamladıktan sonra, herhangi bir projedeki ilk adım, makine öğrenimi problemini çerçevelemek ve veri kümesine dayanarak özellik ve hedef dizilerini çıkarmaktır.

Bu eğitimde, önce elmas fiyatlarını fiziksel ölçümlerini kullanarak tahmin etmeye çalışacağız; dolayısıyla hedefimiz price sütunu olacak.

Bu nedenle, özellikleri X’e, hedefi de y’ye ayırıyoruz:

from sklearn.model_selection import train_test_split

# Extract feature and target arrays
X, y = diamonds.drop('price', axis=1), diamonds[['price']]

Veri kümesinde üç kategorik sütun var. Normalde bunları sıralı ya da one-hot kodlamayla dönüştürürdünüz; ancak XGBoost kategorikleri dahili olarak işleyebilir.

Bu özelliği etkinleştirmenin yolu, kategorik sütunları Pandas’ın category veri tipine dökmektir (varsayılan olarak metin sütunu olarak ele alınırlar):

# Extract text features
cats = X.select_dtypes(exclude=np.number).columns.tolist()

# Convert to Pandas category
for col in cats:
   X[col] = X[col].astype('category')

Şimdi dtypes özniteliğini yazdırdığınızda, üç adet category özellik olduğunu göreceksiniz:

>>> X.dtypes
carat       float64
cut        category
color      category
clarity    category
depth       float64
table       float64
x           float64
y           float64
z           float64
dtype: object

Veriyi eğitim ve test setlerine bölelim (test boyutu 0,25):

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)

Şimdi önemli kısma gelelim: XGBoost, DMatrix adlı kendi veri kümesi saklama sınıfıyla gelir. Bellek ve hız açısından oldukça optimize edilmiştir. Bu nedenle, veri kümelerini bu biçime dönüştürmek yerel XGBoost API’si için bir gerekliliktir:

import xgboost as xgb

# Create regression matrices
dtrain_reg = xgb.DMatrix(X_train, y_train, enable_categorical=True)
dtest_reg = xgb.DMatrix(X_test, y_test, enable_categorical=True)

Sınıf hem eğitim özelliklerini hem de etiketleri kabul eder. Pandas kategori sütunlarının otomatik olarak kodlanmasını etkinleştirmek için enable_categorical parametresini True yapıyoruz.

Not:

Neden XGBoost’un Scikit-learn API’si yerine yerel API’sini kullanıyoruz? İlk başta Sklearn API’sini kullanmak daha rahat olabilir; ancak ileride XGBoost’un yerel API’sinin, diğerinin desteklemediği bazı harika özellikler içerdiğini fark edeceksiniz. Bu yüzden baştan alışmak daha iyi. Yine de, eğitimden sonra tek satır kodla API’ler arasında nasıl geçiş yapabileceğinizi gösterdiğimiz bir bölüm de var.

Python XGBoost Regresyonu

DMatrices oluşturulduktan sonra, objective parametresi için bir değer seçmelisiniz. Bu parametre XGBoost’a çözmeye çalıştığınız makine öğrenimi problemini ve bu problemi çözmek için hangi metrik veya kayıp fonksiyonlarını kullanacağını söyler.

Örneğin, elmas fiyatlarını tahmin etmek bir regresyon problemidir; bu yüzden yaygın reg:squarederror amacını kullanabilirsiniz. Genellikle amacın adı, problem için kullanılan kayıp fonksiyonunun adını da içerir. Regresyonda yaygın olarak Kök Ortalama Kare Hata (RMSE) kullanılır; bu, gerçek ve tahmin edilen değerler arasındaki farkların karelerinin ortalamasının karekökünü minimize eder. NumPy ile uygulanmış hâli şöyledir:

import numpy as np

mse = np.mean((actual - predicted) ** 2)
rmse = np.sqrt(mse)

Sınıflandırma amaçlarını eğitimin ilerleyen kısmında öğreneceğiz.

Kayıp fonksiyonu ile performans metriği arasındaki fark hakkında bir not: Kayıp fonksiyonu, makine öğrenimi modelleri tarafından gerçek (gerçek değerler) ile model tahminleri arasındaki farkları minimize etmek için kullanılır. Öte yandan bir metrik, makine öğrenimi mühendisi tarafından gerçek değerlerle model tahminleri arasındaki benzerliği ölçmek için seçilir.

Kısacası, bir kayıp fonksiyonu minimize edilmeli, bir metrik ise maksimize edilmelidir. Kayıp fonksiyonu eğitim sırasında modele nerede iyileşmesi gerektiğini gösterir. Metrik ise değerlendirme sırasında genel performansı ölçmek için kullanılır.

Eğitim

Seçilen amaç fonksiyonu ve diğer XGBoost hiperparametreleri bir sözlükte belirtilmelidir; gelenek gereği bu sözlüğe params denir:

# Define hyperparameters
params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}

Bu ilk params içinde, tree_method’u gpu_hist olarak ayarlıyoruz; bu seçim GPU hızlandırmasını etkinleştirir. GPU’nuz yoksa bu parametreyi çıkarabilir ya da hist olarak ayarlayabilirsiniz.

Şimdi, num_boost_round adlı başka bir parametre ayarlıyoruz; bu, boosting turlarının sayısı anlamına gelir. XGBoost, içsel olarak RMSE kayıp fonksiyonunu küçük artımlarla turlarda minimize eder (buna daha sonra değineceğiz). Bu parametre, bu turların sayısını belirtir.

İdeal tur sayısı, hiperparametre ayarıyla bulunur. Şimdilik 100 olarak ayarlayacağız:

# Define hyperparameters
params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}

n = 100
model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
)

XGBoost bir GPU üzerinde çalıştığında son derece hızlıdır. Yukarıdaki koddan herhangi bir hata almadıysanız, eğitim başarılı olmuştur!

Değerlendirme

Boosting turları sırasında model nesnesi, eğitim setindeki tüm örüntüleri mümkün olduğunca öğrendi. Şimdi, onu görülmemiş veride test ederek performansını ölçmeliyiz. İşte burada dtest_reg DMatrix devreye girer:

from sklearn.metrics import mean_squared_error

preds = model.predict(dtest_reg)

Bu sürece model değerlendirme (veya çıkarım) denir. predict ile tahminleri ürettikten sonra, onları Sklearn’ın mean_squared_error fonksiyonuna y_test ile karşılaştırmak üzere geçirirsiniz:

rmse = mean_squared_error(y_test, preds, squared=False)

print(f"RMSE of the base model: {rmse:.3f}")
RMSE of the base model: 543.203

Temel modelin varsayılan parametrelerle performansı ~543$ oldu. Bunu iyileştirmenin iki yolu var: çapraz doğrulama yapmak ve hiperparametre ayarı uygulamak. Ancak ondan önce, XGBoost modellerini değerlendirmenin daha hızlı bir yoluna bakalım.

Eğitim Sırasında Doğrulama Setleri Kullanma

Bir makine öğrenimi modelini eğitmek uzaya roket fırlatmaya benzer. Fırlatmaya kadar modelle ilgili her şeyi kontrol edebilirsiniz; fakat fırlatmadan sonra tek yapabileceğiniz beklemek olur.

Mevcut eğitim sürecimizin sorunu ise modelin nereye gittiğini dahi izleyemememiz. Bunu çözmek için, boosting turları boyunca model performansını artımlı şekilde iyileştikçe görmemizi sağlayan değerlendirme dizilerini kullanacağız.

Önce parametreleri tekrar ayarlayalım:

params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
n = 100

Sonra, her biri iki unsur içeren iki demetlik bir liste oluşturalım. İlk unsur modelin değerlendireceği dizi, ikincisi ise dizinin adı.

evals = [(dtrain_reg, "train"), (dtest_reg, "validation")]

Bu diziyi xgb.train’in evals parametresine verdiğimizde, her boosting turundan sonra model performansını göreceğiz:

evals = [(dtrain_reg, "train"), (dtest_reg, "validation")]

model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
   evals=evals,
)

Aşağıdakine benzer bir çıktı almalısınız (burada 10 satıra kısaltılmıştır). Modelin, ~3931$ gibi oldukça yüksek bir skordan 543$’a nasıl indiğini görebilirsiniz.

En güzeli, modelin hem eğitim hem de doğrulama setlerindeki performansını görebilmemiz. Genellikle eğitim kaybı, modelin onu zaten görmüş olması nedeniyle doğrulamadan daha düşük olur.

[0] train-rmse:3985.18329 validation-rmse:3930.52457

[1] train-rmse:2849.72257 validation-rmse:2813.20828
[2] train-rmse:2059.86648 validation-rmse:2036.66330
[3] train-rmse:1519.32314 validation-rmse:1510.02762
[4] train-rmse:1153.68171 validation-rmse:1153.91223
...
[95] train-rmse:381.93902 validation-rmse:543.56526
[96] train-rmse:380.97024 validation-rmse:543.51413
[97] train-rmse:380.75330 validation-rmse:543.36855
[98] train-rmse:379.65918 validation-rmse:543.42558
[99] train-rmse:378.30590 validation-rmse:543.20278

Gerçek dünya projelerinde genellikle binlerce boosting turu ile eğitilir; bu da çok sayıda çıktı satırı demektir. Bunları azaltmak için, XGBoost’un performans güncellemelerini her vebose_eval turda yazmasını sağlayan verbose_eval parametresini kullanabilirsiniz:

params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
n = 100

evals = [(dtest_reg, "validation"), (dtrain_reg, "train")]


model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
   evals=evals,
   verbose_eval=10 # Every ten rounds
)

[OUT]: 

[0] train-rmse:3985.18329 validation-rmse:3930.52457
[10] train-rmse:550.08330 validation-rmse:590.15023
[20] train-rmse:488.51248 validation-rmse:551.73431
[30] train-rmse:463.13288 validation-rmse:547.87843
[40] train-rmse:447.69788 validation-rmse:546.57096
[50] train-rmse:432.91655 validation-rmse:546.22557
[60] train-rmse:421.24046 validation-rmse:546.28601
[70] train-rmse:408.64125 validation-rmse:546.78238
[80] train-rmse:396.41125 validation-rmse:544.69846
[90] train-rmse:386.87996 validation-rmse:543.82192
[99] train-rmse:378.30590 validation-rmse:543.20278

XGBoost Erken Durdurma

Şu ana kadar boosting turlarının ne kadar önemli olduğunu fark etmiş olmalısınız. Genel olarak, tur sayısı arttıkça XGBoost kaybı minimize etmeye daha çok çalışır. Ancak bu, kaybın her zaman düşeceği anlamına gelmez. Gelin, 500 turluk bildirimi 500 adımda olacak şekilde 5000 boosting turu deneyelim:

params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
n = 5000

evals = [(dtest_reg, "validation"), (dtrain_reg, "train")]


model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
   evals=evals,
   verbose_eval=250
)

[OUT]:

[0] train-rmse:3985.18329 validation-rmse:3930.52457
[500] train-rmse:195.89184 validation-rmse:555.90367
[1000] train-rmse:122.10746 validation-rmse:563.44888
[1500] train-rmse:84.18238 validation-rmse:567.16974
[2000] train-rmse:61.66682 validation-rmse:569.52584
[2500] train-rmse:46.34923 validation-rmse:571.07632
[3000] train-rmse:37.04591 validation-rmse:571.76912
[3500] train-rmse:29.43356 validation-rmse:572.43196
[4000] train-rmse:24.00607 validation-rmse:572.81287
[4500] train-rmse:20.45021 validation-rmse:572.89062
[4999] train-rmse:17.44305 validation-rmse:573.13200

En düşük kaybı 500. turdan önce elde ediyoruz. Sonrasında, eğitim kaybı düşmeye devam etse bile doğrulama kaybı (önemsediğimiz) artıyor.

Gereğinden fazla boosting turu verildiğinde XGBoost aşırı öğrenmeye başlar ve veri kümesini ezberler. Bu da genelleme yerine ezber yapıldığı için doğrulama performansının düşmesine yol açar.

Unutmayın, altın ortayı istiyoruz: eğitimde yeterli örüntüyü öğrenmiş, doğrulama setinde en yüksek performansı veren bir model. Peki mükemmel boosting turu sayısını nasıl bulacağız?

Erken durdurma adı verilen bir teknik kullanacağız. Erken durdurma, XGBoost’un doğrulama kaybını izlemesini sağlar; belirli sayıda tur boyunca iyileşme olmazsa eğitimi otomatik olarak durdurur.

Bu, makul bir erken durdurma turu sayısı belirlediğimiz sürece boosting turu sayısını yüksek tutabileceğimiz anlamına gelir.

Örneğin 10000 boosting turu kullanalım ve early_stopping_rounds parametresini 50 olarak ayarlayalım. Böylece XGBoost, doğrulama kaybı art arda 50 tur boyunca iyileşmezse eğitimi otomatik olarak durduracaktır.

n = 10000


model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
   evals=evals,
   verbose_eval=50,
   # Activate early stopping
   early_stopping_rounds=50
)

[OUT]: 

[0] train-rmse:3985.18329 validation-rmse:3930.52457
[50] train-rmse:432.91655 validation-rmse:546.22557
[100] train-rmse:377.66173 validation-rmse:542.92457
[150] train-rmse:334.27548 validation-rmse:542.79733
[167] train-rmse:321.04059 validation-rmse:543.35679

Gördüğünüz gibi, eğitim 167. turdan sonra durdu çünkü ondan önceki 50 tur boyunca kayıp iyileşmedi.

XGBoost Çapraz Doğrulama

Eğitimin başında veri kümesinin %25’ini test için ayırdık. Test seti, modelin üretimdeki koşullarını simüle etmemizi sağlar; model görülmemiş veri için tahmin üretmelidir.

Ancak tek bir test seti, bir modelin üretimde nasıl performans göstereceğini doğru şekilde ölçmek için yeterli olmaz. Örneğin, yalnızca tek bir eğitim ve tek bir test setiyle hiperparametre ayarı yaparsak, test setine dair bilgi yine “sızar”. Nasıl?

Bir hiperparametrenin en iyi değerini, modelin test setindeki doğrulama performansını karşılaştırarak bulmaya çalıştığımız için, yalnızca o belirli test setinde iyi performans gösterecek şekilde yapılandırılmış bir modele sahip oluruz. Bunun yerine, hangi test setini verirsek verelim genelde iyi performans gösteren bir model isteriz.

Olası bir geçici çözüm, veriyi üç sete bölmektir. Model ilk sette eğitilir, ikinci set değerlendirme ve hiperparametre ayarı için kullanılır ve üçüncü set üretim öncesi modelin son testidir.

Ancak veri sınırlı olduğunda, veriyi üç sete bölmek eğitim setini seyrekleştirir ve bu da model performansını olumsuz etkiler.

Tüm bu sorunların çözümü çapraz doğrulamadır. Çapraz doğrulamada yine iki setimiz vardır: eğitim ve test.

Test seti kenarda beklerken, eğitimi 3, 5, 7 veya k parçaya (fold) böleriz. Ardından modeli k kez eğitiriz. Her seferinde k-1 parça eğitim için, son k’ıncı parça doğrulama için kullanılır. Bu sürece k-katlı çapraz doğrulama denir:

Kaynak: https://scikit-learn.org/stable/modules/cross_validation.html

Yukarıda 5 katlı bir çapraz doğrulamanın görsel gösterimi bulunuyor. Tüm katlar tamamlandıktan sonra, skorların ortalamasını alarak modelin en gerçekçi, nihai performansını elde edebiliriz.

Bu süreci XGB’nin cv fonksiyonunu kullanarak kodda gerçekleştirelim:

params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
n = 1000

results = xgb.cv(
   params, dtrain_reg,
   num_boost_round=n,
   nfold=5,
   early_stopping_rounds=20
)

Train fonksiyonundan tek fark, bölünme sayısını belirtmek için nfold parametresini eklemektir. Sonuç nesnesi artık her katın sonuçlarını içeren bir DataFrame’dir:

results.head()

Satır sayısı, boosting turu sayısıyla aynıdır. Her satır, o turun tüm bölünmelerinin ortalamasıdır. Bu nedenle en iyi skoru bulmak için test-rmse-mean sütununun minimumunu alırız:

best_rmse = results['test-rmse-mean'].min()

best_rmse
550.8959336674216

Bu çapraz doğrulama yöntemi, modelin gerçek performansını görmek için kullanılır. Skorundan memnun kaldığınızda, canlıya almadan önce modeli tam veri üzerinde yeniden eğitmelisiniz.

XGBoost Sınıflandırma

Bir XGBoost sınıflandırıcı oluşturmak, amaç fonksiyonunu değiştirmek kadar kolaydır; geri kalanlar aynı kalabilir.

En popüler iki sınıflandırma amacı şunlardır:

• binary:logistic - ikili sınıflandırma (hedef yalnızca iki sınıf içerir; örn. kedi veya köpek)
• multi:softprob - çok sınıflı sınıflandırma (hedefte ikiden fazla sınıf; örn. elma/portakal/muz)

XGBoost’ta ikili ve çok sınıflı sınıflandırma neredeyse aynıdır; bu yüzden ikincisiyle devam edeceğiz. Önce veriyi bu görev için hazırlayalım.

Fiyat ve fiziksel ölçümler verilerek elmasların kesim (cut) kalitesini tahmin etmek istiyoruz. Bu nedenle, özellik/hedef dizilerini buna göre oluşturacağız:

from sklearn.preprocessing import OrdinalEncoder

X, y = diamonds.drop("cut", axis=1), diamonds[['cut']]

# Encode y to numeric
y_encoded = OrdinalEncoder().fit_transform(y)

# Extract text features
cats = X.select_dtypes(exclude=np.number).columns.tolist()

# Convert to pd.Categorical
for col in cats:
   X[col] = X[col].astype('category')

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, random_state=1, stratify=y_encoded)

Tek fark, XGBoost hedefte yalnızca sayıları kabul ettiği için, hedeftedeki metin sınıfları Sklearn’in OrdinalEncoder’ı ile kodluyor olmamızdır.

Şimdi DMatrices’i oluşturalım…

# Create classification matrices
dtrain_clf = xgb.DMatrix(X_train, y_train, enable_categorical=True)
dtest_clf = xgb.DMatrix(X_test, y_test, enable_categorical=True)

…ve amacı multi:softprob olarak ayarlayalım. Bu amaç, sınıf sayısının da tarafımızdan belirtilmesini gerektirir:

params = {"objective": "multi:softprob", "tree_method": "gpu_hist", "num_class": 5}
n = 1000

results = xgb.cv(
   params, dtrain_clf,
   num_boost_round=n,
   nfold=5,
   metrics=["mlogloss", "auc", "merror"],
)

Çapraz doğrulama sırasında, XGBoost’tan modeli üç farklı açıdan raporlayan üç sınıflandırma metriğini izlemesini istiyoruz. İşte sonuç:

results.keys()

Index(['train-mlogloss-mean', 'train-mlogloss-std', 'train-auc-mean',

      'train-auc-std', 'train-merror-mean', 'train-merror-std',

      'test-mlogloss-mean', 'test-mlogloss-std', 'test-auc-mean',

      'test-auc-std', 'test-merror-mean', 'test-merror-std'],

     dtype='object')

En iyi AUC skorunu görmek için test-auc-mean sütununun maksimumunu alırız:

>>> results['test-auc-mean'].max()
0.9402233623451636

Varsayılan yapılandırma bile bize %94’lük bir performans verdi; bu harika.

XGBoost Yerel API vs. XGBoost Sklearn

Şimdiye kadar yerel XGBoost API’sini kullandık; ancak Sklearn API’si de oldukça popülerdir.

Sklearn; birçok makine öğrenimi algoritması ve yardımcı araç içeren geniş bir çerçevedir ve neredeyse herkesin sevdiği bir API sözdizimine sahiptir. Bu nedenle XGBoost, Sklearn ekosistemine entegre edilebilmeleri için XGBClassifier ve XGBRegressor sınıflarını da sunar (bazı işlevsellik kayıpları pahasına).

Mümkün olduğunda sadece Scikit-learn API’sini kullanmak, fazladan işlevselliğe ihtiyaç duyduğunuzda ise yerel API’ye geçmek isterseniz bir yol var.

XGBoost sınıflandırıcı veya regresörü eğittikten sonra, get_booster yöntemiyle dönüştürebilirsiniz:

import xgboost as xgb

# Train a model using the scikit-learn API
xgb_classifier = xgb.XGBClassifier(n_estimators=100, objective='binary:logistic', tree_method='hist', eta=0.1, max_depth=3, enable_categorical=True)
xgb_classifier.fit(X_train, y_train)

# Convert the model to a native API model
model = xgb_classifier.get_booster()

Model nesnesi, bu eğitim boyunca gördüğümüzle tamamen aynı şekilde davranacaktır.

Sonuç

Bu XGBoost eğitiminde birçok önemli konuyu ele aldık; ancak öğrenilecek daha pek çok şey var.

Modellerinizden maksimum performansı almak için parametreleri nasıl yapılandıracağınızı öğreten XGBoost parametreleri sayfasına göz atabilirsiniz.

Kütüphaneyi öğrenmek için kapsamlı ve hepsi bir arada bir kaynak arıyorsanız, Extreme Gradient Boosting With XGBoost kursumuza göz atın.