Machine Learning Academy · Les

Bias-variantieafweging: underfitting versus overfitting

U tekent foutcurves voor training en validatie, identificeert gebieden met underfitting en overfitting en begrijpt het concept van de bias-variantiedecompositie.

Les 3 van 413 stappen

Bias-variantieafweging: underfitting versus overfitting 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.

De centrale spanning in ML

Elk model voor machinaal leren staat voor een fundamentele spanning tussen twee tegenstrijdige krachten: het vermogen om complexe patronen in gegevens vast te leggen (flexibiliteit) en het vermogen om die patronen te generaliseren naar nieuwe voorbeelden (regelmatigheid). Te veel flexibiliteit leidt tot overaanpassing; te weinig leidt tot onderaanpassing. De juiste balans vinden is de grootste uitdaging bij modelselectie en het afstemmen van hyperparameters.

De afweging tussen vertekening en variantie geeft deze spanning een wiskundige naam en een kader. Het is essentieel om deze afweging te begrijpen, zodat je kunt vaststellen wat er mis is met een model en precies weet hoe je dat kunt oplossen.

Vertekening: systematische fout door verkeerde aannames

Bias is de fout die ontstaat door verkeerde aannames in het leeralgoritme. Een model met een hoge bias is te eenvoudig om de werkelijke relatie tussen kenmerken en het doel vast te leggen — het doet systematisch verkeerde voorspellingen, ongeacht hoeveel trainingsgegevens je het geeft.

Het klassieke voorbeeld: een rechte lijn proberen te passen op gegevens met een duidelijk niet-lineair (gebogen) patroon. Hoeveel gegevens je ook hebt, de lijn mist de kromming. Het model vertoont onderfitting — het heeft een hoge bias omdat de aanname van lineariteit niet geschikt is voor dit probleem.

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Non-linear data: y = sin(x) + noise
np.random.seed(42)
X = np.sort(np.random.uniform(0, 10, 200)).reshape(-1, 1)
y = np.sin(X.ravel()) + np.random.randn(200) * 0.2

# High-bias model: straight line on non-linear data
linear_model = LinearRegression()
linear_model.fit(X, y)
y_pred_linear = linear_model.predict(X)

print(f'Linear model train MSE: {mean_squared_error(y, y_pred_linear):.3f}')
# High error even on training data -- high bias

Variantie: gevoeligheid voor trainingsgegevens

Variantie is de fout die ontstaat door gevoeligheid voor kleine schommelingen in de trainingsgegevens. Een model met een hoge variantie leert de trainingsgegevens zo nauwkeurig — inclusief de ruis — dat kleine veranderingen in de trainingsset tot heel andere modellen leiden.

Het klassieke voorbeeld: een beslisboom met onbeperkte diepte die elk trainingsvoorbeeld uit het hoofd leert. Op een andere willekeurige trainingsset uit dezelfde verdeling zou de boom er volledig anders uitzien. Een hoge variantie betekent dat het model overfitting vertoont — het legt ruis vast in plaats van het onderliggende signaal en generaliseert slecht naar nieuwe gegevens.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

X, y = make_classification(n_samples=200, n_features=5, random_state=42)

# Demonstrate high variance: train on two different splits
for seed in [1, 2, 3]:
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=seed)
    deep_tree = DecisionTreeClassifier()  # unlimited depth
    deep_tree.fit(X_train, y_train)
    print(f'seed={seed}: train={deep_tree.score(X_train, y_train):.2f} test={deep_tree.score(X_test, y_test):.2f}')
# Large variation in test scores across seeds = high variance

Decompositie van bias en variantie

De verwachte testfout van elk model kan wiskundig worden opgesplitst in drie termen:

Expected Error = Bias² + Variance + Irreducible Noise

Bias²: gekwadrateerde systematische fout door verkeerde aannames. Kan worden verminderd door een flexibeler model te gebruiken.
Variantie: variatie door gevoeligheid voor trainingsgegevens. Kan worden verminderd met regularisatie, meer gegevens of eenvoudigere modellen.
Onvermijdelijke ruis: inherente willekeur in de gegevens die geen enkel model kan elimineren.

Je kunt alleen de bias en de variantie beheersen. Het doel is de modelcomplexiteit te vinden die hun som minimaliseert.

Onderfitting: symptomen en oorzaken

Onderfitting ontstaat wanneer een model te eenvoudig is om de patronen in de gegevens vast te leggen. Zowel de prestaties op de trainingsgegevens als die op de testgegevens zijn slecht. Het model heeft een hoge bias.

Symptomen van onderfitting:

De nauwkeurigheid op de trainingsgegevens is laag (het model kan zelfs de trainingsgegevens niet goed passend maken).
De fouten op de trainings- en validatiegegevens zijn beide hoog en liggen dicht bij elkaar (er is geen groot verschil).
Meer trainingsgegevens toevoegen helpt niet aanzienlijk.

Oorzaken: een te eenvoudig algoritme (bijvoorbeeld een lineair model voor niet-lineaire gegevens), te sterke regularisatie, te weinig kenmerken of te weinig modelparameters.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Underfitting: depth=1 is too shallow for 30-feature dataset
shallow = DecisionTreeClassifier(max_depth=1)
shallow.fit(X_train, y_train)
train_acc = shallow.score(X_train, y_train)
test_acc = shallow.score(X_test, y_test)

print(f'depth=1 (underfitting): train={train_acc:.3f} test={test_acc:.3f}')
print('Both low -- classic underfitting signature')

Overfitting: symptomen en oorzaken

Overfitting ontstaat wanneer een model de trainingsgegevens te nauwkeurig leert — inclusief de ruis — en niet goed kan generaliseren. De prestaties op de trainingsgegevens zijn zeer hoog, maar de prestaties op de testgegevens zijn veel lager. Het model heeft een hoge variantie.

Symptomen van overfitting:

De nauwkeurigheid op de trainingsgegevens is zeer hoog (bijna 100%), terwijl de nauwkeurigheid op de testgegevens aanzienlijk lager is.
Er is een groot verschil tussen de foutcurven van de trainings- en validatiegegevens.
Meer trainingsgegevens toevoegen verbetert de prestaties op de testgegevens voortdurend.

Oorzaken: een te complex model, te weinig trainingsvoorbeelden, te veel kenmerken (de vloek van dimensionaliteit) of onvoldoende regularisatie.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Overfitting: unlimited depth memorises training data
deep = DecisionTreeClassifier()  # max_depth=None
deep.fit(X_train, y_train)
train_acc = deep.score(X_train, y_train)
test_acc = deep.score(X_test, y_test)

print(f'depth=None (overfitting): train={train_acc:.3f} test={test_acc:.3f}')
print(f'Overfit gap: {train_acc - test_acc:.3f} -- classic overfitting signature')

De bias-variantiecurve tekenen

De meest verhelderende visualisatie ontstaat door de fout op de trainings- en validatiegegevens uit te zetten als functie van de modelcomplexiteit (bijvoorbeeld de boomdiepte). Naarmate de complexiteit toeneemt:

Daalt de trainingsfout monotoon (of blijft deze laag).
Vormt de validatiefout een U-vorm: aanvankelijk hoog (onderfitting), daarna dalend tot een minimum bij de optimale complexiteit, om vervolgens weer te stijgen (overfitting).

De optimale modelcomplexiteit bevindt zich onderaan de U-vormige curve van de validatiefout.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

train_errors, test_errors = [], []
depths = range(1, 20)
for d in depths:
    m = DecisionTreeClassifier(max_depth=d).fit(X_train, y_train)
    train_errors.append(1 - m.score(X_train, y_train))
    test_errors.append(1 - m.score(X_test, y_test))

plt.plot(depths, train_errors, label='Train Error')
plt.plot(depths, test_errors, label='Test Error')
plt.xlabel('Tree Depth (Model Complexity)')
plt.ylabel('Classification Error')
plt.legend()
plt.title('Bias-Variance Trade-off Curve')
plt.show()

Leercurven: diagnosticeren met de gegevensomvang

Een leercurve zet de fout op de trainings- en validatiegegevens uit als functie van de omvang van de trainingsset (in plaats van de modelcomplexiteit). Met leercurven kun je vaststellen of je model baat heeft bij meer gegevens:

Als beide curven naar dezelfde hoge fout convergeren: hoge bias — meer gegevens helpen niet; je hebt een beter model nodig.
Als de trainingsfout laag is maar de validatiefout hoog, en het verschil kleiner wordt naarmate de hoeveelheid gegevens toeneemt: hoge variantie — meer gegevens helpen; ga door met verzamelen.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)

train_sizes, train_scores, val_scores = learning_curve(
    DecisionTreeClassifier(max_depth=None),  # overfitting model
    X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 10)
)

plt.plot(train_sizes, train_scores.mean(axis=1), label='Train')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validation')
plt.fill_between(train_sizes,
    val_scores.mean(axis=1) - val_scores.std(axis=1),
    val_scores.mean(axis=1) + val_scores.std(axis=1), alpha=0.2)
plt.xlabel('Training Set Size')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Learning Curve')
plt.show()

Regularisatie: variantie beheersen

Regularisatie is de belangrijkste techniek om variantie (overfitting) te verminderen zonder de fundamentele modelfamilie te veranderen. Hierbij wordt een straf voor modelcomplexiteit aan de verliesfunctie toegevoegd, zodat het model wordt ontmoedigd om ruis passend te maken.

Veelgebruikte regularisatietechnieken:

Limiet voor boomdiepte (max_depth): voorkomt dat bomen diep genoeg groeien om de trainingsgegevens uit het hoofd te leren.
L2-straf (Ridge): verkleint gewichten in de richting van nul.
L1-straf (Lasso): brengt sommige gewichten exact op nul (kenmerkselectie).
Dropout (neurale netwerken): zet tijdens het trainen willekeurig activaties op nul.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np

X, y = load_breast_cancer(return_X_y=True)

# Compare regularised vs non-regularised tree
for max_depth in [None, 10, 5, 3, 2]:
    model = DecisionTreeClassifier(max_depth=max_depth, random_state=42)
    cv = cross_val_score(model, X, y, cv=5, scoring='accuracy')
    print(f'max_depth={max_depth}: CV acc = {cv.mean():.3f} (+/- {cv.std():.3f})')

De ideale balans: optimale modelcomplexiteit

De optimale modelcomplexiteit bevindt zich op het minimum van de curve van de test- of validatiefout. Je vindt deze systematisch als volgt:

Definieer een bereik van complexiteitswaarden (bijvoorbeeld een boomdiepte van 1 tot 20 of regularisatieparameter C van 0,001 tot 100).
Train voor elke waarde op een trainingsdeel en evalueer op een validatiedeel (gebruik kruisvalidatie voor stabiliteit).
Selecteer de complexiteit die de beste score bij kruisvalidatie oplevert.
Train het uiteindelijke model opnieuw op alle trainingsgegevens met die optimale complexiteit.

Dit proces heet afstemming van hyperparameters en je automatiseert het met GridSearchCV in een latere les.

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
import numpy as np

X, y = load_breast_cancer(return_X_y=True)

best_score, best_depth = 0, 1
for depth in range(1, 25):
    model = DecisionTreeClassifier(max_depth=depth, random_state=42)
    score = cross_val_score(model, X, y, cv=5).mean()
    if score > best_score:
        best_score, best_depth = score, depth
    print(f'depth={depth:2d}: CV acc = {score:.3f}')

print(f'\nOptimal depth: {best_depth} with CV acc: {best_score:.3f}')

Praktisch overzicht van bias en variantie

Een beknopte handleiding voor het diagnosticeren en oplossen van problemen met bias en variantie:

Oplossingen voor hoge bias (onderfitting): gebruik een complexer model, voeg meer kenmerken toe, verlaag de sterkte van de regularisatie en maak polynomiale kenmerken of interactiekenmerken.
Oplossingen voor hoge variantie (overfitting): verzamel meer trainingsgegevens, pas sterkere regularisatie toe, verlaag de modelcomplexiteit, gebruik ensembles (bagging), pas dropout toe (neurale netwerken) en voer kenmerkselectie uit om ruiskenmerken te verwijderen.
Onduidelijk welk probleem zich voordoet: teken leercurven — als de fouten op de trainings- en validatiegegevens beide hoog zijn, is er sprake van bias; bij een groot verschil is er sprake van variantie.

Korte controle

Test je begrip van de concepten uit deze les over Machine Learning met Python.

Beantwoord dit in de interactieve les

Samenvatting van de les

In deze les heb je geleerd dat bias een systematische fout is van te eenvoudige modellen die de gegevens niet goed passend maken, dat variantie de gevoeligheid voor trainingsgegevens is die overfitting en slechte generalisatie veroorzaakt, en dat de optimale modelcomplexiteit de som van bias en variantie minimaliseert; je vindt deze door de U-vormige curve van de validatiefout te onderzoeken of leercurven te gebruiken om de twee problemen van elkaar te onderscheiden. Hierna bouwen we een DummyClassifier als referentiemodel en stellen we de minimale prestatiedrempel vast die elk echt model moet overtreffen.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Bias-variantieafweging: underfitting versus overfitting” gratis?

Ja — de volledige tekst van “Bias-variantieafweging: underfitting versus overfitting” 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 “Bias-variantieafweging: underfitting versus overfitting”?

U tekent foutcurves voor training en validatie, identificeert gebieden met underfitting en overfitting en begrijpt het concept van de bias-variantiedecompositie. 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 “Bias-variantieafweging: underfitting versus overfitting”?

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

Waarom u niet op trainingsgegevens kunt evalueren
train_test_split: verhoudingen, seeds en stratificatie
Bias-variantieafweging: underfitting versus overfitting
Basismodellen: versla altijd de DummyClassifier

← Terug naar Machine Learning Academy