Toernooi voor modelselectie: vijf algoritmen vergelijken
U traint logistic regression, random forest, XGBoost, SVM en een neuraal netwerk binnen pipelines met geneste cross-validatie en zet de prestaties op een gedeelde testset in een tabel.
Toernooi voor modelselectie: vijf algoritmen vergelijken is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Waarom meerdere algoritmen vergelijken?
Geen enkel algoritme presteert op elke dataset het best. De No Free Lunch-stelling bewijst dat elk algoritme, gemiddeld over alle mogelijke problemen, even goed presteert — je moet algoritmen dus empirisch vergelijken op jouw specifieke gegevens. Bij een toernooi voor modelselectie train en evalueer je systematisch meerdere uiteenlopende algoritmen onder identieke omstandigheden, zodat zichtbaar wordt welk algoritme het best bij de structuur van de gegevens past. De winnaar komt in aanmerking voor het afstemmen van hyperparameters en voor beoordeling met het oog op implementatie.
De gedeelde pijplijnstructuur opzetten
Een eerlijke vergelijking vereist dat elk algoritme begint met dezelfde voorbewerkte kenmerkmatrix en wordt geëvalueerd op dezelfde achtergehouden testset. Verpak elk algoritme in een Pipeline waarin ook de voorbewerking zit, zodat de voorbewerking alleen op trainingsvouwen wordt aangepast. Gebruik overal een vaste random_state voor reproduceerbaarheid. Houd de testset afgeschermd — bekijk deze pas bij de uiteindelijke eenmalige evaluatie van de winnaar van het toernooi.
import numpy as np
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import train_test_split, cross_val_score
# Load preprocessed data
X, y = load_features() # returns numpy arrays after EDA cleaning
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 (LOCKED): {X_test.shape[0]} samples')
print(f'Positive class rate (train): {y_train.mean():.3f}')Concurrent 1: Logistische regressie
Logistische regressie is de essentiële lineaire basislijn. Deze is interpreteerbaar (coëfficiënten tonen de effecten van kenmerken), snel te trainen en werkt goed wanneer de beslissingsgrens ongeveer lineair is. In het toernooi vormt dit algoritme de ondergrens — als modellen op basis van bomen het niet duidelijk beter doen, bevat de dataset mogelijk geen complexe niet-lineaire patronen die het waard zijn om met complexere modellen vast te leggen. Gebruik class_weight='balanced' voor datasets met ongelijke klassen.
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
lr_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(
C=1.0,
class_weight='balanced',
max_iter=1000,
random_state=42
))
])
cv_scores = cross_val_score(lr_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'Logistic Regression — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Concurrent 2: Random Forest
Random Forest verwerkt niet-lineaire relaties, interacties tussen kenmerken en gemengde gegevenstypen van nature, zonder dat kenmerken geschaald hoeven te worden. Het levert betrouwbare scores voor het belang van kenmerken en is robuust tegen uitschieters. In wedstrijden is het vaak het op één na beste algoritme na gradient boosting en een sterke basislijn voor tabelgegevens. Stel n_estimators=200 en class_weight='balanced' in voor een solide standaardconfiguratie.
from sklearn.ensemble import RandomForestClassifier
rf_pipe = Pipeline([
('clf', RandomForestClassifier(
n_estimators=200,
max_depth=10,
class_weight='balanced',
random_state=42,
n_jobs=-1
))
])
cv_scores = cross_val_score(rf_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'Random Forest — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Concurrent 3: XGBoost
XGBoost wordt het vaakst genoemd als winnaar in wedstrijden met tabelgegevens voor machine learning. De opeenvolgende boosting corrigeert bij elke stap resterende fouten, wat sterke prestaties op gestructureerde gegevens oplevert. Belangrijke standaardwaarden voor een toernooirun zijn: n_estimators=300, learning_rate=0.05, max_depth=6 en scale_pos_weight, ingesteld op de verhouding tussen de negatieve en positieve klasse om ongelijke klassen te verwerken. Geef eval_set door voor optioneel vroegtijdig stoppen.
from xgboost import XGBClassifier
import numpy as np
# Compute class imbalance ratio
neg_count = (y_train == 0).sum()
pos_count = (y_train == 1).sum()
xgb_pipe = Pipeline([
('clf', XGBClassifier(
n_estimators=300,
learning_rate=0.05,
max_depth=6,
scale_pos_weight=neg_count / pos_count,
use_label_encoder=False,
eval_metric='logloss',
random_state=42,
n_jobs=-1
))
])
cv_scores = cross_val_score(xgb_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'XGBoost — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Concurrent 4: Support Vector Machine
SVM met een RBF-kernel blinkt uit op datasets met duidelijk gescheiden klassen en weinig irrelevante kenmerken. Het gebruikt veel geheugen (omdat het ondersteuningsvectoren opslaat) en is traag op grote datasets (een trainingstijd van O(n²) tot O(n³)), maar kan beter presteren dan modellen op basis van bomen op kleinere datasets met complexe grenzen. Standaardiseer kenmerken vóór het trainen — SVM's zijn zeer gevoelig voor de schaal van kenmerken. Gebruik probability=True voor gekalibreerde waarschijnlijkheidsuitvoer bij de AUC-evaluatie.
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
svm_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', SVC(
C=1.0,
kernel='rbf',
gamma='scale',
class_weight='balanced',
probability=True,
random_state=42
))
])
cv_scores = cross_val_score(svm_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'SVM (RBF) — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Concurrent 5: Neuraal netwerk
Een eenvoudig meerlagig perceptron (MLP) met 2-3 verborgen lagen kan complexe niet-lineaire patronen vastleggen, maar vereist zorgvuldige schaling en regularisatie en is op tabelgegevens trager te trainen dan modellen op basis van bomen. Gebruik het wanneer de andere vier algoritmen allemaal op hetzelfde prestatieniveau blijven steken, wat erop wijst dat de beslissingsgrens een model met grotere capaciteit vereist. sklearn.neural_network.MLPClassifier is handig voor het toernooi zonder een volledige PyTorch-configuratie.
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
mlp_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', MLPClassifier(
hidden_layer_sizes=(128, 64),
activation='relu',
alpha=0.01, # L2 regularisation
max_iter=300,
early_stopping=True,
validation_fraction=0.1,
random_state=42
))
])
cv_scores = cross_val_score(mlp_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'MLP Neural Network — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Resultaten samenvoegen in een ranglijst
Verzamel alle AUC-scores van de vijfvoudige kruisvalidatie in een tabel, gerangschikt op gemiddelde AUC. Noteer ook de standaardafwijking — een model met een iets lagere gemiddelde AUC maar veel lagere variantie kan de voorkeur hebben voor implementatie, omdat de prestaties voorspelbaarder zijn over verschillende gegevenspartities heen. Toon de resultaten als een horizontaal staafdiagram voor communicatie met belanghebbenden.
import pandas as pd
import matplotlib.pyplot as plt
results = {
'Logistic Regression': (0.821, 0.013),
'Random Forest': (0.867, 0.009),
'XGBoost': (0.883, 0.007),
'SVM (RBF)': (0.845, 0.011),
'MLP Neural Network': (0.858, 0.010)
}
df_results = pd.DataFrame(results, index=['AUC_mean', 'AUC_std']).T
df_results = df_results.sort_values('AUC_mean', ascending=False)
print(df_results.to_string())
df_results['AUC_mean'].plot(kind='barh', xerr=df_results['AUC_std'], figsize=(8, 4))
plt.xlabel('5-fold CV AUC')
plt.title('Model Selection Tournament Results')
plt.tight_layout()
plt.savefig('tournament.png', dpi=150)Statistische significantie van verschillen
Een AUC-verschil van 0,002 tussen twee modellen kan simpelweg ruis door een willekeurige gegevenspartitionering zijn. Gebruik een gepaarde t-toets of een Wilcoxon-toets met rangtekens op de scores per vouw om te bepalen of het verschil statistisch significant is. Als de p-waarde groter is dan 0,05, kies je het eenvoudigere model — door de lagere complexiteit is dit gemakkelijker te debuggen, uit te leggen en te onderhouden in productie.
from scipy import stats
import numpy as np
# Simulated per-fold scores for XGBoost vs Random Forest
xgb_folds = np.array([0.889, 0.881, 0.875, 0.883, 0.887])
rf_folds = np.array([0.871, 0.863, 0.869, 0.865, 0.867])
# Paired t-test
t_stat, p_value = stats.ttest_rel(xgb_folds, rf_folds)
print(f'XGBoost mean: {xgb_folds.mean():.4f}')
print(f'Random Forest mean: {rf_folds.mean():.4f}')
print(f'Paired t-test: t={t_stat:.3f}, p={p_value:.4f}')
if p_value < 0.05:
print('Difference is statistically significant — prefer XGBoost.')
else:
print('Difference is NOT significant — prefer simpler model (Random Forest).')Eenmalige evaluatie op de testset
Evalueer de winnaar van het toernooi precies één keer op de achtergehouden testset. Dit is de onbevooroordeelde prestatie-inschatting die je op de modelkaart rapporteert. Stem nooit hyperparameters af nadat je de resultaten van de testset hebt bekeken — dat veroorzaakt gegevenslekken via het evaluatieproces. Als de test-AUC aanzienlijk lager is dan de AUC van de kruisvalidatie (meer dan 2–3 standaardafwijkingen), onderzoek dan mogelijke overfitting of een verschuiving in de verdeling tussen de trainings- en testpartities.
from sklearn.metrics import roc_auc_score, classification_report
# Fit winner on full training set
best_pipeline = xgb_pipe
best_pipeline.fit(X_train, y_train)
# One-time test evaluation
y_proba = best_pipeline.predict_proba(X_test)[:, 1]
y_pred = best_pipeline.predict(X_test)
test_auc = roc_auc_score(y_test, y_proba)
print(f'Test AUC: {test_auc:.4f}')
print('\nClassification report:')
print(classification_report(y_test, y_pred, target_names=['retained', 'churned']))De winnaar kiezen: verder kijken dan AUC
AUC is niet het enige criterium. Houd rekening met: interpreteerbaarheid (logistische regressie kan verplicht zijn voor naleving van regelgeving), trainingstijd (bij wekelijkse hertraining op 10 miljoen rijen is het snelheidsvoordeel van XGBoost belangrijk), geheugengebruik (een SVM die 100.000 ondersteuningsvectoren opslaat, kan het implementatiebudget overschrijden) en eerlijkheid (het model met de hoogste AUC kan een slechtere demografische gelijkheid hebben). Het toernooi selecteert de kandidaat; gereedheid voor implementatie is een afzonderlijke beslissing op basis van meerdere criteria.
# Multi-criteria scoring table
criteria = {
'AUC': {'XGBoost': 5, 'RandomForest': 4, 'LogReg': 2, 'SVM': 3, 'MLP': 4},
'Interpretability': {'XGBoost': 3, 'RandomForest': 3, 'LogReg': 5, 'SVM': 2, 'MLP': 1},
'Training speed': {'XGBoost': 4, 'RandomForest': 4, 'LogReg': 5, 'SVM': 2, 'MLP': 3},
'Memory': {'XGBoost': 4, 'RandomForest': 3, 'LogReg': 5, 'SVM': 2, 'MLP': 3}
}
import pandas as pd
df_crit = pd.DataFrame(criteria).T
df_crit.loc['Total'] = df_crit.sum()
print(df_crit)Korte controle
Test je begrip van de concepten uit deze les over machine learning met Python.
Samenvatting van de les
In deze les heb je geleerd dat elk algoritme in een Pipeline moet worden verpakt en met identieke vouwen voor kruisvalidatie op dezelfde trainingsset moet worden geëvalueerd, dat de ranglijst van het toernooi modellen rangschikt op gemiddelde AUC van de kruisvalidatie, met een gepaarde significantietoets om echte verschillen van ruis te onderscheiden en dat de testset precies één keer voor het winnende model wordt gebruikt om de eerlijke prestatie-inschatting voor de modelkaart te verkrijgen. Hierna verpakken, documenteren en presenteren we het uiteindelijke model voor implementatie.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Toernooi voor modelselectie: vijf algoritmen vergelijken” gratis?
Ja — de volledige tekst van “Toernooi voor modelselectie: vijf algoritmen vergelijken” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “Toernooi voor modelselectie: vijf algoritmen vergelijken”?
U traint logistic regression, random forest, XGBoost, SVM en een neuraal netwerk binnen pipelines met geneste cross-validatie en zet de prestaties op een gedeelde testset in een tabel. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Toernooi voor modelselectie: vijf algoritmen vergelijken”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Projectafbakening: het probleem en de succescriteria definiëren
- Datavoorbereiding en verkennende data-analyse
- Toernooi voor modelselectie: vijf algoritmen vergelijken
- Het uiteindelijke model verpakken, documenteren en presenteren