Dropout-regularisatie om overfitting te voorkomen
Cursisten voegen nn.Dropout met verschillende kansen toe, vergelijken trainings- en validatielosscurves en roepen model.eval() aan om dropout tijdens inferentie uit te schakelen.
Dropout-regularisatie om overfitting te voorkomen 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.
Wat is Dropout en waarom gebruik je het?
Dropout, geïntroduceerd door Srivastava et al. in 2014, is een regularisatietechniek die tijdens elke trainingsstap willekeurig een deel van de activaties van neuronen op nul zet. Doordat het netwerk met een willekeurige subset van neuronen moet werken, voorkomt Dropout dat één neuron te gespecialiseerd raakt en wordt het netwerk gedwongen redundante representaties te leren. Dit vermindert overfitting aanzienlijk in grote volledig verbonden netwerken.
import torch
import torch.nn as nn
dropout = nn.Dropout(p=0.5) # 50% chance each neuron is zeroed
x = torch.ones(1, 8)
# Training mode: randomly zeros activations
dropout.train()
out = dropout(x)
print('Training output:', out)
# Some values are 0, survivors are scaled by 1/(1-p)
# Eval mode: dropout is disabled (identity function)
dropout.eval()
out_eval = dropout(x)
print('Eval output:', out_eval) # all onesDe truc van inverted dropout
PyTorch implementeert inverted dropout: tijdens het trainen worden overgebleven activaties opgeschaald met 1/(1-p) om de neuronen die op nul zijn gezet te compenseren. Hierdoor blijft de verwachte som van de activaties hetzelfde, ongeacht het dropoutpercentage. Het voordeel is dat je tijdens inferentie Dropout uitschakelt en het netwerk ongewijzigd gebruikt — je hoeft de uitvoer niet te schalen. Daarom is Dropout in de eval-modus gewoon een identiteitsfunctie.
import torch
import torch.nn as nn
# With p=0.5, surviving neurons are scaled by 2.0
dropout = nn.Dropout(p=0.5)
dropout.train()
# Start with all-ones tensor
x = torch.ones(1, 10)
out = dropout(x)
print('Scaled values:', out)
# Values are either 0 or 2.0 (= 1 / (1 - 0.5))
# Expected value = (1-p) * (1/(1-p)) = 1.0 (same as input)
print('Expected value preserved:', out.mean().item())Dropout aan een netwerk toevoegen
Dropout-lagen worden in volledig verbonden netwerken meestal na activatiefuncties geplaatst, of na pooling in CNN's. Veelgebruikte dropoutkansen zijn p=0.5 voor grote verborgen lagen en p=0.2-0.3 voor kleinere lagen of CNN's. Dropout wordt meestal niet toegepast op de invoerlaag of de uiteindelijke uitvoerlaag. Het onderstaande voorbeeld toont een diep MLP met Dropout tussen verborgen lagen.
import torch.nn as nn
model = nn.Sequential(
nn.Linear(784, 512),
nn.ReLU(),
nn.Dropout(p=0.5), # regularise large hidden layer
nn.Linear(512, 256),
nn.ReLU(),
nn.Dropout(p=0.5),
nn.Linear(256, 128),
nn.ReLU(),
nn.Dropout(p=0.3), # less aggressive for smaller layer
nn.Linear(128, 10) # no dropout on output layer
)
print(model)train() versus eval(): essentieel gebruik
Vergeten om te wisselen tussen de trainings- en evaluatiemodus is een van de meest voorkomende en lastigst te debuggen fouten. In de trainingsmodus (model.train()) zet Dropout activaties willekeurig op nul. In de eval-modus (model.eval()) is Dropout volledig uitgeschakeld en zijn alle neuronen actief. Als je vóór de evaluatie model.eval() niet aanroept, zal de validatieloss kunstmatig hoger en niet-deterministisch zijn, waardoor je runs niet betrouwbaar kunt vergelijken.
import torch
import torch.nn as nn
model = nn.Sequential(
nn.Linear(4, 16), nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(16, 2)
)
x = torch.randn(1, 4)
# Different output each time in training mode!
model.train()
print(model(x))
print(model(x)) # different due to random dropout
# Deterministic in eval mode
model.eval()
with torch.no_grad():
print(model(x))
print(model(x)) # same result both timesHet effect van Dropout op overfitting waarnemen
Vergelijk de trainings- en validatielosscurves met en zonder Dropout om het regularisatie-effect ervan te zien. Zonder Dropout vertoont een groot netwerk meestal het klassieke patroon van overfitting: de trainingsloss is bijna nul, terwijl de validatieloss hoog blijft. Met Dropout volgen beide curves elkaar nauwer. Het verschil tussen de trainings- en validatienauwkeurigheid (de generalisatiekloof) is de belangrijkste maatstaf die Dropout verkleint.
import torch
import torch.nn as nn
import torch.optim as optim
def make_net(use_dropout):
layers = [nn.Linear(20, 256), nn.ReLU()]
if use_dropout: layers.append(nn.Dropout(0.5))
layers += [nn.Linear(256, 2)]
return nn.Sequential(*layers)
for use_do in [False, True]:
model = make_net(use_do)
print(f'Dropout={use_do}:')
# Train on 50 samples -> large model will overfit without DO
X = torch.randn(50, 20)
y = torch.randint(0, 2, (50,))
opt = optim.Adam(model.parameters())
crit = nn.CrossEntropyLoss()
for e in range(100):
model.train(); opt.zero_grad()
loss = crit(model(X), y); loss.backward(); opt.step()
print(f' Train loss: {loss.item():.3f}')De dropoutkans afstemmen
De dropoutkans p is een hyperparameter die je moet afstemmen. p=0.5 is de oorspronkelijke standaardwaarde uit het Dropout-artikel en werkt goed voor zeer grote lagen. Voor convolutionele lagen is p=0.1 tot 0.25 gebruikelijk, omdat ruimtelijke kenmerken meer structuur hebben. Voor Transformers is p=0.1 standaard. Als je model niet overfit, verlaag je p of verwijder je Dropout. Als het sterk overfit, verhoog je p stapsgewijs en houd je de validatieprestaties in de gaten.
# Dropout rate guidelines
rates = {
'Large FC layer (1000+ units)': 0.5,
'Small FC layer (100-500 units)': 0.3,
'CNN hidden layers': 0.1,
'Transformer attention': 0.1,
'LSTM': 0.2,
'Input layer (rare)': 0.1
}
for context, rate in rates.items():
print(f'{context}: p={rate}')Monte Carlo Dropout voor onzekerheid
Een geavanceerde toepassing van Dropout is MC Dropout voor het schatten van onzekerheid. In plaats van Dropout tijdens inferentie uit te schakelen, houd je het ingeschakeld en voer je het model N keer uit met dezelfde invoer. Het gemiddelde van de N voorspellingen is de schatting; de variantie tussen de voorspellingen meet de onzekerheid van het model. Dit benadert Bayesiaanse inferentie zonder een volledig Bayesiaans neuraal netwerk. De methode wordt gebruikt in veiligheidskritische toepassingen, zoals medische diagnoses, waar het waardevol is om te weten wanneer een model iets niet weet.
import torch
import torch.nn as nn
model = nn.Sequential(
nn.Linear(4, 16), nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(16, 2)
)
x = torch.randn(1, 4)
model.train() # keep dropout ON for MC dropout
# Run 100 stochastic forward passes
preds = torch.stack([model(x) for _ in range(100)])
mean_pred = preds.mean(dim=0)
uncertainty = preds.std(dim=0)
print('Mean prediction:', mean_pred)
print('Uncertainty:', uncertainty) # high = unsureSpatial Dropout voor CNN's
nn.Dropout2d (Spatial Dropout) zet volledige kanalen op nul in plaats van afzonderlijke activaties in convolutionele kenmerkkaarten. Dit is effectiever voor CNN's, omdat aangrenzende pixels in hetzelfde kanaal sterk gecorreleerd zijn — afzonderlijke pixels verwijderen heeft weinig effect. Door volledige kanalen te verwijderen, kan het netwerk niet op één filter vertrouwen en moet het informatie over veel kanalen verdelen. Gebruik Dropout2d na Conv2d-lagen in plaats van gewone Dropout.
import torch
import torch.nn as nn
conv_model = nn.Sequential(
nn.Conv2d(3, 32, 3, padding=1),
nn.ReLU(),
nn.Dropout2d(p=0.1), # drops entire channels
nn.Conv2d(32, 64, 3, padding=1),
nn.ReLU(),
nn.Dropout2d(p=0.1)
)
conv_model.train()
x = torch.randn(4, 3, 16, 16) # batch of 4 images
out = conv_model(x)
print(out.shape) # torch.Size([4, 64, 16, 16])Dropout versus weight decay: complementaire technieken
Dropout en weight decay (L2-regularisatie) zijn complementaire regularisatoren — gebruik ze samen. Dropout voorkomt co-adaptatie tussen neuronen; weight decay bestraft grote gewichten en trekt alle parameters naar nul. De combinatie is sterker dan elk van beide afzonderlijk. In AdamW wordt weight decay correct toegepast als een afzonderlijke term, in plaats van te worden vermengd met de gradiëntupdate zoals bij Adam. De meeste modellen die in productie worden gebruikt, passen beide technieken toe.
import torch.nn as nn
import torch.optim as optim
model = nn.Sequential(
nn.Linear(64, 256), nn.ReLU(),
nn.Dropout(0.4),
nn.Linear(256, 128), nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(128, 10)
)
# Combine dropout in model with weight decay in optimizer
optimizer = optim.AdamW(
model.parameters(),
lr=1e-3,
weight_decay=1e-4 # L2 regularisation
)
print('Model has both Dropout and L2 regularisation')Overfitting met Dropout diagnosticeren
Gebruik de grafiek van de trainings- en validatieloss om vast te stellen of je meer regularisatie nodig hebt. Een stijgende validatieloss terwijl de trainingsloss daalt is kenmerkend voor overfitting. Verhoog de dropoutkans systematisch of voeg Dropout-lagen toe waar die ontbreken. Andere signalen van ernstige overfitting zijn een trainingsnauwkeurigheid van 98% of hoger terwijl de validatienauwkeurigheid blijft steken op 70-80%, of een zeer hoge variatie in validatiemaatstaven tussen verschillende willekeurige seeds.
# Decision guide for dropout tuning
# Gap = train_acc - val_acc
# Gap < 2% -> no overfitting, Dropout not needed (or reduce p)
# Gap 2-5% -> mild overfitting, add p=0.2-0.3
# Gap 5-10% -> moderate overfitting, use p=0.4-0.5
# Gap > 10% -> severe overfitting:
# 1. Increase dropout probability
# 2. Add more Dropout layers
# 3. Increase weight decay
# 4. Collect more training data
# 5. Reduce model capacity
print('Diagnose overfitting gap, then tune p')Dropout in de praktijk: samenvatting
Gebruik Dropout als volgt: voeg nn.Dropout(p) toe na activaties van verborgen lagen; roep tijdens het trainen model.train() aan om Dropout in te schakelen en tijdens de evaluatie model.eval() om het uit te schakelen; begin met p=0.5 voor grote volledig verbonden lagen en verlaag dit als het model underfit. Combineer Dropout met weight decay via AdamW voor de beste resultaten. Houd altijd zowel trainings- als validatiemaatstaven bij om te controleren of Dropout echt helpt — soms vertraagt het de convergentie zonder de generalisatie te verbeteren wanneer het model al goed geregulariseerd is.
import torch.nn as nn
import torch.optim as optim
# Complete setup: Dropout + BatchNorm + AdamW
model = nn.Sequential(
nn.Linear(128, 512),
nn.BatchNorm1d(512),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(512, 256),
nn.BatchNorm1d(256),
nn.ReLU(),
nn.Dropout(0.4),
nn.Linear(256, 10)
)
optimizer = optim.AdamW(
model.parameters(), lr=1e-3, weight_decay=1e-4
)
print('Ready to train with full regularisation stack')Korte kennistest
Test je begrip van de concepten uit deze les over Machine Learning met Python.
Samenvatting van de les
In deze les heb je geleerd: Dropout zet neuronactivaties tijdens het trainen willekeurig op nul om co-adaptatie te voorkomen en overfitting te verminderen, inverted dropout schaalt overblijvende waarden met 1/(1-p), zodat er tijdens inferentie geen aanpassing nodig is, en model.eval() schakelt Dropout uit voor deterministische en correcte inferentie. Hierna verkennen we strategieën voor gewichtsinitialisatie die verdwijnende en exploderende gradiënten in diepe netwerken voorkomen.
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 “Dropout-regularisatie om overfitting te voorkomen” gratis?
Ja — de volledige tekst van “Dropout-regularisatie om overfitting te voorkomen” 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 “Dropout-regularisatie om overfitting te voorkomen”?
Cursisten voegen nn.Dropout met verschillende kansen toe, vergelijken trainings- en validatielosscurves en roepen model.eval() aan om dropout tijdens inferentie uit te schakelen. 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 “Dropout-regularisatie om overfitting te voorkomen”?
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
- Learning rate: de belangrijkste hyperparameter
- Batchnormalisatie: stabieler en sneller trainen
- Dropout-regularisatie om overfitting te voorkomen
- Gewichtsinitialisatie: Xavier- en He-initialisatie