Wat is underfitting? Zo spoor je hoge bias op en los je het op in ML-modellen

Tijdens het bouwen van modellen om uitkomsten te voorspellen of patronen te ontdekken, kom je verschillende uitdagingen tegen. Een veelvoorkomende horde is een model maken dat de onderliggende trends in je data goed vastlegt. Soms zijn modellen te simpel en leren ze de complexiteit niet, met slechte prestaties tot gevolg. Dit fenomeen heet underfitting.

Een underfitting-model presteert niet alleen slecht op de data waarop het is getraind, maar generaliseert ook niet naar nieuwe, ongeziene data. Dat betekent dat je voorspellingen onbetrouwbaar kunnen zijn in de praktijk. Underfitting herkennen en aanpakken is een belangrijke stap richting robuuste en effectieve machine learning-modellen. 

Afbeelding door auteur

In dit artikel kijken we naar wat underfitting is, waarom het gebeurt, hoe je het herkent, en vooral: hoe je underfitting oplost. Wil je praktisch met machine learning aan de slag? Bekijk dan zeker onze Machine Learning Fundamentals in Python-track. 

Wat is underfitting?

Laten we dieper ingaan op het concept underfitting en het contrast met de tegenhanger, overfitting. Dit onderscheid begrijpen is essentieel voor diagnose en verbetering van modellen.

Afbeelding door auteur

Simpel gezegd: underfitting treedt op wanneer een machine learning-model te eenvoudig is om de onderliggende patronen in de trainingsdata te vangen. Stel je voor dat je een rechte lijn door punten probeert te leggen die duidelijk een kromme volgen, en de lijn (ons model) is gewoon niet complex genoeg. Een underfitting-model heeft een hoge bias, wat betekent dat het sterke aannames maakt over de data (bijv. een lineaire relatie aannemen waar die er niet is). 

Omdat het de data niet goed leert, presteert het slecht op zowel de trainingsdata als op nieuwe, ongeziene data (testdata). Zulke modellen hebben doorgaans wel een lage variantie: hun voorspellingen veranderen weinig als je op andere subsets traint. De eenvoud maakt ze consistent, maar dan wel consequent fout.

Wiskundig hangt dit samen met de bias-variantie-decompositie van de verwachte fout van het model. De verwachte fout kan worden opgesplitst in drie componenten: bias in het kwadraat, variantie en onherleidbare fout:

Waarbij:

• E[(y - f̂(x))²] de verwachte kwadratische fout van de voorspelling is.

• Bias(f̂(x)) meet de fout die ontstaat door de echte functie f(x) te benaderen met het model.

• Var(f̂(x)) is de variabiliteit van de modelvoorspelling voor verschillende trainingsdatasets.

• σ² staat voor de onherleidbare fout — de inherente ruis in de data die niet te voorspellen is.

Bij underfitting domineert de term Bias(f̂(x)) de fout. Het model is te simpel, wat leidt tot systematische fouten en het niet vangen van de werkelijke relatie in de data.

Underfitting vs overfitting in contrast

Underfitting wordt duidelijker in vergelijking met overfitting. Waar underfitting-modellen te simpel zijn, zijn overfitting-modellen te complex. Ze leren de trainingsdata té goed, en vangen niet alleen de onderliggende patronen maar ook de ruis en willekeurige fluctuaties.

Bias-variantie-afweging — afbeelding door auteur

Laten we de belangrijkste verschillen tussen underfitting en overfitting bekijken:

Dit leidt tot het cruciale concept van de bias-variantie-afweging.

• Hoge bias (underfitting): Eenvoudige modellen hebben hoge bias maar lage variantie. Ze zitten er consequent naast, maar variëren weinig bij andere trainingsdata.
• Hoge variantie (overfitting): Complexe modellen hebben lage bias maar hoge variantie. Ze passen de trainingsdata heel goed (lage bias) maar zijn erg gevoelig voor de specifieke trainingsdata, wat leidt tot slechte generalisatie op nieuwe data. Lees meer in ons artikel What is Overfitting?.

Het doel is de sweet spot te vinden: een model dat complex genoeg is om de echte patronen te vangen (lage bias), maar niet zo complex dat het de ruis leert (lage variantie).

Voorbeelden:

• Voorbeeld van underfitting: Huisprijzen voorspellen, die afhangen van grootte, locatie, leeftijd, enz., met alleen het aantal kamers. Het model is te simpel (hoge bias) en zal voor de meeste huizen waarschijnlijk slecht voorspellen.
• Voorbeeld van overfitting: Een zeer complex polynomiaal regressiemodel maken dat perfect door elk datapunt in je trainingsset voor huisprijzen loopt. Dit model heeft misschien bijna nul fout op de trainingsdata, maar presteert slecht op nieuwe huizen omdat het de ruis specifiek voor de trainingsset heeft geleerd (hoge variantie).

Weten waar jouw model op dit spectrum valt, is belangrijk voor effectieve ML-oplossingen, zoals we zien in de volgende secties over detectie en aanpak van underfitting.

Oorzaken van underfitting en diagnostische indicatoren

Nu we weten wat underfitting is, kijken we waarom het gebeurt en hoe je het in je eigen projecten kunt detecteren. De oorzaak achterhalen is essentieel om de juiste aanpak te kiezen. 

Primaire oorzaken van underfitting

Meerdere factoren kunnen tot een underfitting-model leiden:

Onvoldoende modelcomplexiteit

Het gekozen algoritme kan te simpel zijn voor de onderliggende structuur van de data. Bijvoorbeeld lineaire regressie gebruiken wanneer de relatie tussen features en target sterk niet-lineair is. Het model mist dan simpelweg de capaciteit om de complexiteit te vangen.

Onvoldoende training

Het model is mogelijk niet lang genoeg getraind (bijv. te weinig epochs bij neurale netwerken) of met ongeschikte leerparameters. Als je te vroeg stopt, krijgt het model geen kans om patronen te leren, zelfs als het daar wel de capaciteit voor heeft.

Slechte featurerepresentatie 

De features waarmee het model is getraind, vertegenwoordigen mogelijk niet de onderliggende factoren die de target beïnvloeden. Dit kan betekenen:

• Belangrijke features ontbreken: Cruciale voorspellers zijn niet in de dataset opgenomen.
• Irrelevante features: De dataset bevat ruis of features die niet correleren met de uitkomst, wat een simpel model kan misleiden.
• Features die transformatie vereisen: Features moeten mogelijk geschaald, genormaliseerd of gecodeerd worden (bijv. categorische variabelen) om bruikbaar te zijn voor het model.

Overmatige regularisatie

Regularisatietechnieken (zoals L1- of L2-straffen) worden vooral gebruikt om overfitting te voorkomen door complexiteit te bestraffen. Maar als de regularisatiekracht (bijv. de lambda-parameter) te hoog staat, kan het model te hard worden vereenvoudigd, wat underfitting veroorzaakt. Lees meer over regularisatie in Towards Preventing Overfitting in Machine Learning: Regularization.

Lage kwaliteit of onvoldoende data

• Te weinig data: Als de trainingsset te klein is, heeft het model te weinig voorbeelden om de onderliggende patronen effectief te leren.
• Veel ruis: Bij erg luidruchtige data kan een model moeite hebben het signaal van de ruis te scheiden, zeker als het simpel is.
• Missende waarden: Grote hoeveelheden missende data kunnen het leerproces belemmeren, vooral als dit niet goed wordt afgehandeld. Technieken hiervoor vind je in Handling Missing Data with Imputations in R.

Detectiemethoden

Hoe zie je of je model underfit? Dit zijn veelgebruikte diagnostische technieken:

Analyseren van prestatiestatistieken 

De meest directe indicator is slechte performance op zowel de trainingsset als de validatie-/testset. Als je model hoge fout (of lage nauwkeurigheid, lage R-squared, etc.) behaalt op de data waarop het is getraind, is dat een sterk teken dat het de patronen niet goed heeft geleerd. In tegenstelling tot overfitting (uitstekend op training, slecht op test) laat underfitting overal slechte performance zien.

Leercurves

De performance van het model (bijv. fout of nauwkeurigheid) op de trainings- en validatiesets uitzetten tegen traintijd of datasetgrootte kan erg verhelderend zijn. Bij underfitting laten leercurves typisch zien:

• Hoge trainingsfout die vroeg afvlakt.
• Hoge validatiefout die dicht bij de trainingsfout ligt en ook afvlakt.
• Beide curven convergeren op een hoog foutniveau, wat aangeeft dat het model niet veel verbetert, zelfs niet met meer data of training.

Feature-analyse

Evalueer de gebruikte features. Zijn ze relevant? Zijn er interacties die je niet hebt vastgelegd? Zijn numerieke features geschaald? Zijn categorische features passend gecodeerd? 

Soms laat een nieuwe blik op feature engineering zien waarom het model moeite heeft. Basisconcepten vind je in Machine Learning Fundamentals in R. Voor meer inzicht in statistische relaties kun je bronnen zoals Statistical Inference in R raadplegen.

Vergelijkend modelleren

Train een complexer model (bijv. een beslisboom of gradient boosting-machine als je aanvankelijk lineaire regressie gebruikte) op dezelfde data. Als het complexere model je initiële model duidelijk overtreft op zowel training als validatie, wijst dat erop dat je oorspronkelijke model waarschijnlijk underfitte door onvoldoende complexiteit. 

Je kunt zulke vergelijkingen bijhouden met de tools uit Machine Learning Experimentation: An Introduction to Weights & Biases.

Met dit inzicht in oorzaken en detectiemethoden kun je underfitting effectief diagnosticeren en stappen zetten om de prestaties te verbeteren.

Strategieën en best practices om underfitting te verhelpen

Zodra je underfitting hebt vastgesteld, is de volgende stap weten hoe je het oplost. Gelukkig zijn er diverse effectieve strategieën om de capaciteit van je model te vergroten om onderliggende patronen te leren. Laten we er een paar bekijken:

Modelcomplexiteit vergroten

Als je model te simpel is (hoge bias), kan het verhogen van de complexiteit underfitting vaak verhelpen. Dat kan op de volgende manieren:

Algoritmekeuze

Schakel over naar een krachtiger model. Als lineaire regressie underfit, probeer polynomiale regressie, beslisbomen, random forests, gradient boosting-machines (zoals XGBoost of LightGBM) of support vector machines (SVM's) met niet-lineaire kernels. Deze modellen hebben van nature meer capaciteit om complexe relaties te vangen.

Polynomiale feature-uitbreiding

Voor regressieproblemen kun je polynomiale features maken van je bestaande numerieke features. Zo kunnen lineaire modellen gebogen, complexere relaties fitten. Als je bijvoorbeeld een feature x hebt, kun je x2, x3, enz. als nieuwe features toevoegen. Scikit-learn biedt PolynomialFeatures hiervoor.

Hyperparametertuning

Veel complexe modellen hebben hyperparameters die hun complexiteit bepalen (bijv. de diepte van een beslisboom, het aantal neuronen in een neurale netwerklayer, de C-parameter in SVM's). Deze hyperparameters zo afstellen dat meer complexiteit mogelijk is, kan bias verlagen. 

Technieken als Grid Search of Randomized Search zijn hier essentieel. Leer meer met cursussen zoals Hyperparameter Tuning in Python of Hyperparameter Tuning in R. Zie ook onze tutorial Hyperparameter Optimization in Machine Learning Models.

Feature engineering en data-augmentatie

Soms ligt het probleem niet bij het model, maar bij de datarepresentatie. Beter passende features helpen enorm. Dat kan op de volgende manieren:

Domeinspecifieke featurecreatie

Gebruik je domeinkennis om nieuwe, informatievere features te maken. Bijvoorbeeld: bij huisprijsvoorspelling 'aantal slaapkamers' en 'aantal badkamers' combineren tot 'totaal aantal kamers', of 'huisleeftijd' berekenen uit 'bouwjaar'.

Interactiefeatures

Maak features die de interactie tussen bestaande features weergeven (bijv. twee features met elkaar vermenigvuldigen). Dit helpt modellen synergetische effecten te vangen.

Data-verrijking

Verrijk je dataset met externe databronnen als dat kan. Bijvoorbeeld demografische data toevoegen aan klantinformatie of weerdata aan verkoopprognoses.

Data-augmentatie (vooral bij ongestructureerde data)

Voor beeld- of tekstdata kunnen technieken zoals roteren/spiegelen van afbeeldingen of synoniemen vervangen in tekst de grootte en diversiteit van de trainingsset kunstmatig vergroten, wat het model kan helpen robuustere patronen te leren.

Regularisatie bijstellen

Als underfitting wordt veroorzaakt door overmatige regularisatie die juist overfitting moest voorkomen, moet je die terugschroeven. Verlaag de regularisatieparameter (bijv. alpha bij Ridge/Lasso, C bij SVM's — let op: bij SVM's betekent een kleinere C sterkere regularisatie, dus zou je C verhogen).

Gebruik je dropout, verlaag dan het dropoutrate (de fractie neuronen die tijdens training wordt weggelaten). Een lagere rate behoudt meer netwerkkapaciteit.

De juiste balans vinden vraagt vaak om zorgvuldige tuning, wat opnieuw het belang van hyperparameteroptimalisatie onderstreept.

Ensemblemethoden

Ensemblemethoden combineren voorspellingen van meerdere individuele modellen (zwakke leerders) tot een sterkere, robuustere eindvoorspelling. Ze zijn vaak effectief in het verminderen van zowel bias als variantie. Enkele ensemblemethoden zijn:

• Bagging (bijv. Random Forests): Trainde meerdere modellen (bijv. beslisbomen) onafhankelijk op verschillende bootstrap-samples en neemt het gemiddelde van hun voorspellingen. Dit vermindert vooral de variantie, maar kan ook helpen als de basisleerders licht bevooroordeeld zijn. Bekijk onze Bagging-tutorial voor meer info.
• Boosting (bijv. AdaBoost, Gradient Boosting): Trainde modellen sequentieel, waarbij elk nieuw model de fouten van de vorige corrigeert. Boosting is bijzonder effectief in het verlagen van bias en het omzetten van zwakke leerders in sterke, en is daarmee een krachtig middel tegen underfitting. We hebben een Boosting-gids voor meer uitleg. 
• Stacking: Trainde meerdere verschillende modeltypes en gebruikt dan een ander model (een meta-learner) om te leren hoe je hun voorspellingen het beste combineert.

Met deze strategieën, vaak in combinatie, kun je underfitting effectief aanpakken en modellen bouwen die de complexiteit van je data beter vangen.

Praktische toepassingen en casestudy's

Underfitting in actie zien met datasets en code kan het concept sterk verduidelijken. Laten we praktische voorbeelden bekijken om te laten zien hoe een underfitting-model zich gedraagt en hoe de prestaties kunnen verbeteren.

Voorbeeld underfitting met lineaire regressie

Een veelvoorkomend scenario voor underfitting is wanneer een simpel lineair model een niet-lineaire relatie moet beschrijven. We illustreren dit door een lineair regressiemodel te fitten op data die een kwadratisch patroon volgt.

We genereren synthetische data waarbij de targetvariabele y een kwadratische relatie heeft met een feature X. Eerst fitten we een simpel lineair regressiemodel. We zien de slechte performance (hoge Mean Squared Error - MSE) en visualiseren hoe het de kromme in de data niet vangt. 

Daarna breiden we de features uit met een polynomiale term en fitten we een polynomiale regressie. Zo zie je hoe meer modelcomplexiteit de bias kan verlagen en de nauwkeurigheid flink verbetert.

Laten we beginnen met het importeren van de benodigde libraries:

# Import necessary libraries
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_squared_errorMogelijk gemaakt door

Laten we synthetische niet-lineaire data genereren. We maken data met een kwadratische relatie: y = 0.5*X^2 + X + 2 + ruis.

np.random.seed(42) # for reproducibility
num_samples = 100
X = np.sort(10 * np.random.rand(num_samples, 1) - 5, axis=0) # Feature X (sorted for plotting)
y_true = 0.5 * X**2 + X + 2 # True quadratic relationship
y = y_true + np.random.randn(num_samples, 1) * 5 # Add some noise to make it realisticMogelijk gemaakt door

Nu fitten we een simpel lineair regressiemodel (Underfitting-model) zoals hieronder:

linear_model = LinearRegression()
linear_model.fit(X, y)
y_pred_linear = linear_model.predict(X)
mse_linear = mean_squared_error(y, y_pred_linear)

print(f"--- Simple Linear Regression (Potential Underfitting Model) ---")
print(f"Mean Squared Error (MSE): {mse_linear:.2f}")
print(f"Model Coefficients (slope): {linear_model.coef_[0][0]:.2f}")
print(f"Model Intercept: {linear_model.intercept_[0]:.2f}")Mogelijk gemaakt door

Output:

--- Simple Linear Regression (Potential Underfitting Model) ---

Mean Squared Error (MSE): 34.03

Model Coefficients (slope): 1.00

Model Intercept: 6.42Mogelijk gemaakt door

Nu fitten we een polynomiaal regressiemodel (Verbeterd model). We maken polynomiale features (graad 2) en fitten dan een lineair model op deze features. De stap PolynomialFeatures voegt nieuwe features toe. De stap LinearRegression heeft coëfficiënten voor elk daarvan.

Voor graad 2 verwachten we coëfficiënten voor X en X^2. Een pipeline maakt dit proces netter. Met het attribuut named_steps kun je de afzonderlijke stappen benaderen, zoals hieronder:

polynomial_model = make_pipeline(PolynomialFeatures(degree=2, include_bias=False), LinearRegression())
polynomial_model.fit(X, y)
y_pred_poly = polynomial_model.predict(X)
mse_poly = mean_squared_error(y, y_pred_poly)

print(f"\n--- Polynomial Regression (Degree 2) ---")
print(f"Mean Squared Error (MSE): {mse_poly:.2f}")
poly_reg_coeffs = polynomial_model.named_steps['linearregression'].coef_[0]
poly_reg_intercept = polynomial_model.named_steps['linearregression'].intercept_[0]
print(f"Model Coefficients (for X, X^2): {poly_reg_coeffs[0]:.2f}, {poly_reg_coeffs[1]:.2f}")
print(f"Model Intercept: {poly_reg_intercept:.2f}")Mogelijk gemaakt door

Output:

--- Polynomial Regression (Degree 2) ---

Mean Squared Error (MSE): 20.48

Model Coefficients (for X, X^2): 1.13, 0.50

Model Intercept: 2.04Mogelijk gemaakt door

Laten we nu de modelfit visualiseren zoals hieronder getoond:

# Visualization
plt.figure(figsize=(10, 4))
plt.scatter(X, y, s=30, label="Actual Data Points", alpha=0.7, edgecolors='k')
plt.plot(X, y_pred_linear, color='red', linewidth=2, label=f'Linear Fit (Underfitting)\nMSE: {mse_linear:.2f}')
plt.plot(X, y_pred_poly, color='green', linewidth=2, label=f'Polynomial Fit (Degree 2)\nMSE: {mse_poly:.2f}')
plt.title('Demonstrating Underfitting with Linear vs. Polynomial Regression', fontsize=16)
plt.xlabel('Feature X', fontsize=14)
plt.ylabel('Target y', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()Mogelijk gemaakt door

Output:

De plot bevestigt visueel het underfitten van het simpele lineaire model. Het vangt de kromme in de data niet. Het polynomiale regressiemodel, met de X^2-term, past veel beter, wat blijkt uit de lagere MSE.

Dit laat zien hoe feature-uitbreiding (meer modelcomplexiteit) bias kan verlagen en nauwkeurigheid kan verbeteren wanneer de onderliggende relatie niet-lineair is. Laten we vervolgens een medische casestudy bekijken.

Casestudy medische diagnose

We simuleren een medisch diagnosescenario met de bekende Breast Cancer Wisconsin (Diagnostic)-dataset uit scikit-learn.

Eerst bouwen we een classificatiemodel met slechts een zeer beperkte subset aan features, wat kan leiden tot underfitting. Daarna gebruiken we een uitgebreider feature-set en eventueel een complexer algoritme om de verbetering te tonen.

Laten we beginnen met het importeren van de benodigde libraries:

# Import necessary libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, roc_auc_score, confusion_matrix, ConfusionMatrixDisplayMogelijk gemaakt door

Nu laden en prepareren we de data:

cancer = load_breast_cancer()
X = pd.DataFrame(cancer.data, columns=cancer.feature_names)
y = cancer.target # 0 for malignant, 1 for benignMogelijk gemaakt door

Voor de demo kiezen we een zeer beperkte subset van features voor het underfitting-scenario. Deze zijn op zichzelf mogelijk niet het meest voorspellend:

features_limited = ['mean texture', 'mean symmetry']
X_limited = X[features_limited]Mogelijk gemaakt door

Voor het verbeterde model gebruiken we een grotere subset (of alle features). We kiezen de eerste 10 features als een meer uitgebreide set:

features_comprehensive = cancer.feature_names[:10]
X_comprehensive = X[features_comprehensive]Mogelijk gemaakt door

Laten we de data splitsen. We doen dit apart per featureset voor de duidelijkheid:

X_train_lim, X_test_lim, y_train, y_test = train_test_split(X_limited, y, test_size=0.3, random_state=42, stratify=y)
X_train_comp, X_test_comp, _, _ = train_test_split(X_comprehensive, y, test_size=0.3, random_state=42, stratify=y) # y_train and y_test are the sameMogelijk gemaakt door

We schalen de features, belangrijk voor logistic regression en veel andere algoritmen:

scaler_lim = StandardScaler().fit(X_train_lim)
X_train_lim_scaled = scaler_lim.transform(X_train_lim)
X_test_lim_scaled = scaler_lim.transform(X_test_lim)

scaler_comp = StandardScaler().fit(X_train_comp)
X_train_comp_scaled = scaler_comp.transform(X_train_comp)
X_test_comp_scaled = scaler_comp.transform(X_test_comp)Mogelijk gemaakt door

Nu fitten we een logistic regression met beperkte features:

print("Scenario 1: Logistic Regression (Limited Features - Potential Underfitting)")
log_reg_limited = LogisticRegression(random_state=42, solver='liblinear') # liblinear is good for small datasets
log_reg_limited.fit(X_train_lim_scaled, y_train)
y_pred_lim = log_reg_limited.predict(X_test_lim_scaled)
y_proba_lim = log_reg_limited.predict_proba(X_test_lim_scaled)[:, 1]

acc_lim = accuracy_score(y_test, y_pred_lim)
auc_lim = roc_auc_score(y_test, y_proba_lim)
print(f"Features used: {features_limited}")
print(f"Accuracy: {acc_lim:.4f}")
print(f"AUC: {auc_lim:.4f}")Mogelijk gemaakt door

Output:

Scenario 1: Logistic Regression (Limited Features - Potential Underfitting)

Features used: ['mean texture', 'mean symmetry']

Accuracy: 0.7544

AUC: 0.8151Mogelijk gemaakt door

We passen een mitigerende strategie toe. We fitten een logistic regression-model met meer features:

print("Scenario 2: Logistic Regression (Comprehensive Features)")
log_reg_comp = LogisticRegression(random_state=42, solver='liblinear')
log_reg_comp.fit(X_train_comp_scaled, y_train)
y_pred_comp_lr = log_reg_comp.predict(X_test_comp_scaled)
y_proba_comp_lr = log_reg_comp.predict_proba(X_test_comp_scaled)[:, 1]

acc_comp_lr = accuracy_score(y_test, y_pred_comp_lr)
auc_comp_lr = roc_auc_score(y_test, y_proba_comp_lr)
print(f"Features used: First 10 features") # For brevity
print(f"Accuracy: {acc_comp_lr:.4f}")
print(f"AUC: {auc_comp_lr:.4f}")Mogelijk gemaakt door

Output:

Scenario 2: Logistic Regression (Comprehensive Features)

Features used: First 10 features

Accuracy: 0.9181

AUC: 0.9831Mogelijk gemaakt door

Nu fitten we een complexer model zoals Random Forest met meer features:

print("Scenario 3: Random Forest (Comprehensive Features)")
rf_comp = RandomForestClassifier(random_state=42, n_estimators=100) # n_estimators is a key hyperparameter
rf_comp.fit(X_train_comp_scaled, y_train) # RF can also benefit from scaled data, though less sensitive
y_pred_comp_rf = rf_comp.predict(X_test_comp_scaled)
y_proba_comp_rf = rf_comp.predict_proba(X_test_comp_scaled)[:, 1]

acc_comp_rf = accuracy_score(y_test, y_pred_comp_rf)
auc_comp_rf = roc_auc_score(y_test, y_proba_comp_rf)
print(f"Features used: First 10 features")
print(f"Accuracy: {acc_comp_rf:.4f}")
print(f"AUC: {auc_comp_rf:.4f}")Mogelijk gemaakt door

Output:

Scenario 3: Random Forest (Comprehensive Features)

Features used: First 10 features

Accuracy: 0.9415

AUC: 0.9878Mogelijk gemaakt door

Laten we de confusion matrix voor elk geval plotten en vergelijken:

fig, axes = plt.subplots(1, 3, figsize=(20, 5))
fig.suptitle('Comparison of Model Performance (Confusion Matrices on Test Set)', fontsize=16)

# Model 1: Logistic Regression (Limited Features)
cm_lim = confusion_matrix(y_test, y_pred_lim)
disp_lim = ConfusionMatrixDisplay(confusion_matrix=cm_lim, display_labels=cancer.target_names)
disp_lim.plot(ax=axes[0], cmap='Blues')
axes[0].set_title(f'LogReg (Limited Features)\nAcc: {acc_lim:.2f}, AUC: {auc_lim:.2f}')

# Model 2: Logistic Regression (Comprehensive Features)
cm_comp_lr = confusion_matrix(y_test, y_pred_comp_lr)
disp_comp_lr = ConfusionMatrixDisplay(confusion_matrix=cm_comp_lr, display_labels=cancer.target_names)
disp_comp_lr.plot(ax=axes[1], cmap='Greens')
axes[1].set_title(f'LogReg (Comprehensive Features)\nAcc: {acc_comp_lr:.2f}, AUC: {auc_comp_lr:.2f}')

# Model 3: Random Forest (Comprehensive Features)
cm_comp_rf = confusion_matrix(y_test, y_pred_comp_rf)
disp_comp_rf = ConfusionMatrixDisplay(confusion_matrix=cm_comp_rf, display_labels=cancer.target_names)
disp_comp_rf.plot(ax=axes[2], cmap='Oranges')
axes[2].set_title(f'Random Forest (Comprehensive Features)\nAcc: {acc_comp_rf:.2f}, AUC: {auc_comp_rf:.2f}')

plt.tight_layout(rect=[0, 0, 1, 0.96]) # Adjust layout to make space for suptitle
plt.show()Mogelijk gemaakt door

Output:

In deze casestudy wordt een initieel LogisticRegression-model getraind op slechts twee features (Scenario 1), wat naar verwachting underfit door onvoldoende informatie, met lage nauwkeurigheid en AUC tot gevolg. 

De performance verbetert doorgaans wanneer hetzelfde algoritme een uitgebreidere set aan features krijgt (Scenario 2), omdat het meer data heeft om van te leren, waardoor de bias afneemt.

Verdere verbetering zie je vaak door een complexer algoritme te gebruiken zoals RandomForestClassifier met de uitgebreide featureset (Scenario 3), omdat dit niet-lineariteiten en feature-interacties effectiever kan vangen, wat de bias verder verlaagt en de fit op de data verbetert.

Geavanceerde onderwerpen en toekomstige richtingen

Hoewel we de basis hebben behandeld, evolueert het ML-landschap voortdurend. Hier is een korte blik op hoe underfitting zich verhoudt tot meer geavanceerde gebieden.

De rol van deep learning

Deep learning-modellen, met name diepe neurale netwerken met veel lagen, staan bekend om hun hoge capaciteit: ze kunnen in theorie zeer complexe functies benaderen.

Door hun inherente complexiteit zijn deep learning-modellen doorgaans minder vatbaar voor underfitting dan simpele modellen, mits ze goed getraind worden op voldoende data. Hun structuur stelt ze in staat complexe featurerepresentaties automatisch te leren uit ruwe data (zoals pixels of woorden).

Toch is deep learning niet immuun voor problemen die lijken op underfitting. Als een netwerk slecht is ontworpen (bijv. onvoldoende diepte/breedte), niet lang genoeg traint, of ongeschikte activatiefuncties of optimalisatie-algoritmen gebruikt, kan het alsnog niet convergeren en hoge trainingsfout vertonen.

Architecturale innovaties zoals residual connections (ResNets) en normalisatietechnieken (Batch Normalization) helpen zeer diepe netwerken effectief trainen, verhelpen vanishing/exploding gradients en stellen ze in staat hun volledige capaciteit te benutten, waardoor convergentieproblemen die op underfitting lijken worden vermeden.

Automated machine learning (AutoML)

Het vinden van het juiste model, de juiste features en hyperparameters om zowel underfitting als overfitting te vermijden, kost tijd. AutoML wil dit proces automatiseren.

AutoML-frameworks kunnen automatisch verschillende modeltypes verkennen (van lineaire modellen tot complexe ensembles en neurale netwerken), feature engineering en -selectie uitvoeren en hyperparameters optimaliseren. Door systematisch een grote zoekruimte te doorlopen, kan AutoML configuraties vinden die voldoende complex zijn om underfitting te voorkomen.

Methoden zoals Neural Architecture Search (NAS) ontwerpen automatisch netwerkarchitecturen, terwijl geavanceerde hyperparameteroptimalisatie (bijv. Bayesian Optimization) efficiënt goede instellingen vindt. Deze tools versnellen het vinden van een goed passend model en verminderen de handmatige inspanning om een underfitting-model te diagnosticeren en te fixen.

Conclusie

Het dilemma underfitting vs overfitting begrijpen is fundamenteel voor succesvolle machine learning. We zagen dat underfitting ontstaat wanneer een model te simpel is (hoge bias) om de onderliggende trends te vangen, met slechte prestaties op zowel training als ongeziene data. Belangrijke oorzaken zijn onvoldoende modelcomplexiteit, slechte features, onvoldoende training en overmatige regularisatie.

Underfitting diagnosticeren doe je door prestatiestatistieken te bekijken, leercurves te plotten en modellen te vergelijken, vaak ondersteund met code. Gelukkig zijn er meerdere strategieën om underfitting te verhelpen: modelcomplexiteit vergroten (betere algoritmen kiezen, feature-uitbreiding, hyperparametertuning), features verbeteren (feature engineering, dataverrijking), regularisatie bijstellen en krachtige ensemblemethoden inzetten, zoals in onze codevoorbeelden gedemonstreerd.

Wil je deze technieken en meer leren met hands-on voorbeelden? Bekijk dan onze Machine Learning Fundamentals in Python skill track.