Tutorial: XGBoost gebruiken in Python

XGBoost installeren

Je kunt XGBoost installeren zoals elke andere bibliotheek via pip. Deze installatiemethode bevat ook ondersteuning voor de NVIDIA‑GPU van je machine. Wil je alleen de CPU-versie installeren, ga dan voor conda-forge:

$ 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

Het is aan te raden XGBoost in een virtuele omgeving te installeren om je basisomgeving schoon te houden.

We raden aan om de voorbeelden in de tutorial uit te voeren op een machine met GPU-ondersteuning. Als je die niet hebt, kun je alternatieven proberen zoals DataLab of Google Colab.

Als je voor Colab kiest: daar staat een oudere versie van XGBoost geïnstalleerd, dus voer pip install --upgrade xgboost uit om de nieuwste versie te krijgen.

Data laden en verkennen

We werken in de hele tutorial met de Diamonds-dataset. Die zit ingebouwd in de Seaborn-bibliotheek, of je kunt hem downloaden van Kaggle. De dataset heeft een mooie mix van numerieke en categorische features en meer dan 50k observaties, waardoor we alle voordelen van XGBoost goed kunnen laten zien.

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)

In een typisch real-world project wil je veel meer tijd besteden aan het verkennen van de dataset en het visualiseren van de features. Maar omdat deze data ingebouwd is in Seaborn, is hij relatief schoon.

We bekijken daarom alleen de 5-getallensamenvatting van de numerieke en categorische features en gaan dan aan de slag. Neem gerust even de tijd om de dataset te leren kennen.

diamonds.describe()

diamonds.describe(exclude=np.number)

Een XGBoost DMatrix bouwen

Nadat je klaar bent met de verkenning, is de eerste stap in elk project het formuleren van het machinelearning-probleem en het extraheren van de feature- en target-arrays op basis van de dataset.

In deze tutorial proberen we eerst diamantprijzen te voorspellen op basis van hun fysieke afmetingen, dus onze target is de kolom price.

We isoleren de features in X en de target in y:

from sklearn.model_selection import train_test_split

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

De dataset heeft drie categorische kolommen. Normaal gesproken zou je die encoderen met ordinale of one-hot-encoding, maar XGBoost kan intern met categorische variabelen omgaan.

Om deze functie te activeren, zet je de categorische kolommen om naar het Pandas-datatype category (standaard worden ze behandeld als tekstkolommen):

# 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')

Als je nu het attribuut dtypes print, zie je dat we drie category-features hebben:

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

Laten we de data splitsen in train- en testsets (0,25 testgrootte):

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

Nu het belangrijke deel: XGBoost heeft een eigen klasse voor het opslaan van datasets, DMatrix genaamd. Dit is een sterk geoptimaliseerde klasse voor geheugen en snelheid. Daarom is het converteren van datasets naar dit formaat een vereiste voor de native XGBoost-API:

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)

De klasse accepteert zowel de trainingsfeatures als de labels. Om automatische encoding van Pandas category-kolommen in te schakelen, zetten we enable_categorical ook op True.

Let op:

Waarom gebruiken we de native API van XGBoost in plaats van de Scikit-learn-API? Hoewel het in het begin misschien comfortabeler is om de Sklearn-API te gebruiken, zul je later merken dat de native API van XGBoost uitstekende functies bevat die de eerste niet ondersteunt. Wen er dus liever meteen aan. Er is echter een sectie aan het einde waarin we laten zien hoe je zelfs na het trainen van modellen met één regel code tussen API’s kunt schakelen.

Python XGBoost-regressie

Na het bouwen van de DMatrixen kies je een waarde voor de parameter objective. Deze vertelt XGBoost welk machinelearning-probleem je wilt oplossen en welke metrics of verliesfuncties daarvoor gebruikt moeten worden.

Om bijvoorbeeld diamantprijzen te voorspellen, een regressieprobleem, kun je de gangbare objective reg:squarederror gebruiken. Meestal bevat de naam van de objective ook de naam van de verliesfunctie voor het probleem. Voor regressie is Root Mean Squared Error gebruikelijk, die de vierkantswortel minimaliseert van de som van de kwadraten van de verschillen tussen werkelijke en voorspelde waarden. Zo ziet de metric eruit in NumPy:

import numpy as np

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

We leren later in de tutorial over classificatie-objectives.

Een opmerking over het verschil tussen een verliesfunctie en een prestatiemetric: een verliesfunctie wordt door machinelearning-modellen gebruikt om de verschillen tussen werkelijke (ground truth) waarden en modelvoorspellingen te minimaliseren. Een metric (of meerdere) wordt daarentegen door de ML-engineer gekozen om de overeenkomst tussen ground truth en modelvoorspellingen te meten.

Kortom: een verliesfunctie moet geminimaliseerd worden, terwijl een metric gemaximaliseerd moet worden. Een verliesfunctie wordt tijdens training gebruikt om het model richting te geven. Een metric wordt tijdens evaluatie gebruikt om de algehele prestatie te meten.

Training

De gekozen objective en andere hyperparameters van XGBoost moeten worden opgegeven in een dictionary, die volgens conventie params heet:

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

In deze initiële params zetten we ook tree_method op gpu_hist, wat GPU-versnelling inschakelt. Als je geen GPU hebt, kun je de parameter weglaten of op hist zetten.

Nu stellen we nog een parameter in, num_boost_round, wat staat voor aantal boostingrondes. Intern minimaliseert XGBoost de verliesfunctie RMSE in kleine incrementele rondes (later meer). Deze parameter geeft het aantal van die rondes op.

Het ideale aantal rondes wordt gevonden via hyperparametertuning. Voor nu zetten we hem op 100:

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

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

Wanneer XGBoost op een GPU draait, is het razendsnel. Kreeg je geen errors bij bovenstaande code, dan is de training geslaagd!

Evaluatie

Tijdens de boostingrondes heeft het model alle patronen in de trainingsset geleerd die het kon. Nu moeten we de prestatie meten door te testen op onzichtbare data. Daar komt onze dtest_reg DMatrix van pas:

from sklearn.metrics import mean_squared_error

preds = model.predict(dtest_reg)

Deze stap heet model-evaluatie (of inferentie). Nadat je voorspellingen met predict hebt gegenereerd, geef je ze door aan de functie mean_squared_error van Sklearn om ze te vergelijken met y_test:

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

We hebben een basisscore van ~543$ behaald, de prestatie van een basismodel met standaardparameters. Er zijn twee manieren om dit te verbeteren: door cross-validatie en hyperparametertuning. Maar eerst bekijken we een snellere manier om XGBoost-modellen te evalueren.

Validatiesets gebruiken tijdens training

Een machinelearning-model trainen is als een raket lanceren. Je kunt alles aan het model controleren tot de lancering, maar zodra het gelanceerd is, kun je alleen toekijken tot het klaar is.

Het probleem met ons huidige trainingsproces is dat we niet eens kunnen zien waar het model naartoe gaat. Om dit op te lossen, gebruiken we evaluatie-arrays waarmee we de modelprestatie kunnen volgen terwijl die stapsgewijs verbetert over de boostingrondes.

Laten we eerst de parameters weer instellen:

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

Vervolgens maken we een lijst van twee tuples die elk twee elementen bevatten. Het eerste element is de array die het model moet evalueren, en het tweede is de naam van de array.

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

Als we deze array doorgeven aan de parameter evals van xgb.train, zien we de modelprestatie na elke boostingronde:

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

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

Je zou een output moeten krijgen die lijkt op de onderstaande (hier ingekort tot 10 regels). Je ziet hoe het model de score minimaliseert van een forse ~3931$ naar slechts 543$.

Het mooiste is dat we de prestatie op zowel onze trainings- als validatieset kunnen zien. Meestal is het trainingsverlies lager dan het validatieverlies, omdat het model de eerste al heeft gezien.

[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

In real-world projecten train je meestal voor duizenden boostingrondes, wat veel outputregels oplevert. Om dit te beperken, kun je de parameter verbose_eval gebruiken, die XGBoost dwingt om prestatie-updates elke vebose_eval rondes te printen:

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 early stopping

Intussen zal het duidelijk zijn hoe belangrijk boostingrondes zijn. Over het algemeen geldt: hoe meer rondes, hoe meer XGBoost probeert het verlies te minimaliseren. Maar dat betekent niet dat het verlies altijd daalt. Laten we 5000 boostingrondes proberen met een verbosity van 500:

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

We krijgen het laagste verlies vóór ronde 500. Daarna blijft het trainingsverlies wel dalen, maar het validatieverlies (waar het ons om gaat) stijgt.

Bij een onnodig hoog aantal boostingrondes begint XGBoost te overfitten en de dataset te memoriseren. Dit leidt tot een daling in validatieprestatie, omdat het model onthoudt in plaats van generaliseert.

Onthoud: we willen de gulden middenweg: een model dat net genoeg patronen in de training heeft geleerd om de hoogste prestatie op de validatieset te geven. Hoe vinden we dan het perfecte aantal boostingrondes?

We gebruiken een techniek die early stopping heet. Early stopping laat XGBoost het validatieverlies in de gaten houden en stopt automatisch met trainen als dit gedurende een opgegeven aantal rondes niet verbetert.

Dit betekent dat we een hoog aantal boostingrondes kunnen instellen zolang we een verstandig aantal early stopping-rondes kiezen.

Gebruik bijvoorbeeld 10000 boostingrondes en zet de parameter early_stopping_rounds op 50. Zo stopt XGBoost automatisch met trainen als het validatieverlies 50 opeenvolgende rondes niet verbetert.

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

Zoals je ziet, stopte de training na de 167e ronde omdat het verlies 50 rondes daarvoor niet meer verbeterde.

XGBoost cross-validatie

Aan het begin van de tutorial hebben we 25% van de dataset apart gezet voor testen. Met de testset kunnen we de omstandigheden in productie simuleren, waar een model voorspellingen moet genereren voor onzichtbare data.

Maar slechts één testset is niet genoeg om nauwkeurig te meten hoe een model in productie zou presteren. Als we bijvoorbeeld hyperparametertuning uitvoeren met slechts één training- en één testset, zal kennis over de testset toch “weglekken”. Hoe?

Omdat we de beste waarde voor een hyperparameter proberen te vinden door de validatieprestatie van het model op de testset te vergelijken, eindigen we met een model dat is geconfigureerd om goed te presteren alleen op die specifieke testset. We willen juist een model dat overal goed presteert—op elke testset die we gebruiken.

Een mogelijke workaround is de data in drie sets splitsen. Het model traint op de eerste set, de tweede set wordt gebruikt voor evaluatie en hyperparametertuning, en de derde is de definitieve set waarop we het model testen vóór productie.

Maar als data beperkt is, maakt splitsen in drie sets de trainingsset schraal, wat de modelprestatie schaadt.

De oplossing voor al deze problemen is cross-validatie. Bij cross-validatie hebben we nog steeds twee sets: training en test.

Terwijl de testset opzij blijft, splitsen we de training in 3, 5, 7 of k splits of folds. Vervolgens trainen we het model k keer. Elke keer gebruiken we k-1 delen voor training en het kde deel voor validatie. Dit heet k-fold cross-validatie:

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

Bovenstaand is een visuele weergave van 5-fold cross-validatie. Nadat alle folds zijn voltooid, kunnen we het gemiddelde van de scores nemen als de definitieve, meest realistische prestatie van het model.

Laten we dit proces in code uitvoeren met de functie cv van XGB:

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
)

Het enige verschil met de train-functie is het toevoegen van de parameter nfold om het aantal splits op te geven. Het object results is nu een DataFrame met de resultaten van elke fold:

results.head()

Het heeft evenveel rijen als het aantal boostingrondes. Elke rij is het gemiddelde van alle splits voor die ronde. Om de beste score te vinden nemen we het minimum van de kolom test-rmse-mean:

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

best_rmse
550.8959336674216

Let op: deze vorm van cross-validatie gebruik je om de werkelijke prestatie van het model te zien. Als je tevreden bent met de score, moet je het model opnieuw trainen op de volledige data voordat je het uitrolt.

XGBoost-classificatie

Een XGBoost-classifier bouwen is zo eenvoudig als het wijzigen van de objective; de rest kan hetzelfde blijven.

De twee populairste classificatie-objectives zijn:

• binary:logistic - binaire classificatie (de target bevat slechts twee klassen, bijv. kat of hond)
• multi:softprob - multiclass-classificatie (meer dan twee klassen in de target, bijv. appel/sinaasappel/banaan)

Binaire en multiclass-classificatie in XGBoost zijn bijna identiek, dus we gaan met de laatste. Laten we eerst de data voor de taak voorbereiden.

We willen de slijpkwaliteit (cut) van diamanten voorspellen op basis van hun prijs en fysieke afmetingen. We bouwen de feature/target-arrays dienovereenkomstig:

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)

Het enige verschil is dat XGBoost in de target alleen nummers accepteert, dus encoderen we de tekstklassen in de target met OrdinalEncoder van Sklearn.

Nu bouwen we de DMatrixen…

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

…en zetten we de objective op multi:softprob. Deze objective vereist ook dat wij het aantal klassen instellen:

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"],
)

Tijdens cross-validatie vragen we XGBoost om drie classificatiemetrics te volgen die de modelprestatie vanuit drie verschillende hoeken rapporteren. Dit is het resultaat:

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')

Om de beste AUC-score te zien, nemen we het maximum van de kolom test-auc-mean:

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

Zelfs de standaardconfiguratie gaf ons 94% prestatie, wat geweldig is.

XGBoost native vs. XGBoost Sklearn

Tot nu toe hebben we de native XGBoost-API gebruikt, maar de Sklearn-API is ook behoorlijk populair.

Sklearn is een uitgebreid framework met veel machinelearning-algoritmen en utilities en heeft een API-syntax waar bijna iedereen dol op is. Daarom biedt XGBoost ook XGBClassifier- en XGBRegressor-klassen, zodat ze kunnen worden geïntegreerd in het Sklearn-ecosysteem (met wel enig functieverlies).

Als je waar mogelijk alleen de Scikit-learn-API wilt gebruiken en alleen naar de native API wilt schakelen wanneer je extra functionaliteit nodig hebt, dan kan dat.

Na het trainen van de XGBoost-classifier of -regressor kun je deze converteren met de methode get_booster:

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()

Het modelobject gedraagt zich precies zoals we in deze tutorial hebben gezien.

Conclusie

We hebben veel belangrijke onderwerpen behandeld in deze XGBoost-tutorial, maar er is nog meer te leren.

Bekijk de pagina met XGBoost-parameters, waar je leert hoe je de parameters configureert om het maximale uit je modellen te halen.

Ben je op zoek naar een complete, all-in-one bron om de bibliotheek te leren, bekijk dan onze cursus Extreme Gradient Boosting With XGBoost.