Dropout-regularisering for at forhindre overfitting
De lærende tilføjer nn.Dropout med varierende sandsynligheder, sammenligner kurverne for trænings-loss og validerings-loss og kalder model.eval() for at deaktivere dropout under inferens.
Dropout-regularisering for at forhindre overfitting er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad er Dropout, og hvorfor bruges det?
Dropout, som blev introduceret af Srivastava m.fl. i 2014, er en regulariseringsteknik, der tilfældigt sætter en andel af neuronernes aktiveringer til nul under hvert træningstrin. Ved at tvinge netværket til at fungere med et tilfældigt udvalg af neuroner forhindrer det, at en enkelt neuron bliver for specialiseret, og tvinger netværket til at lære redundante repræsentationer. Det reducerer overtilpasning markant i store fuldt forbundne netværk.
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 onesTricket med inverteret Dropout
PyTorch implementerer inverteret Dropout: under træningen bliver de aktiveringer, der overlever, skaleret op med 1/(1-p) for at kompensere for de neuroner, der er sat til nul. Det betyder, at den forventede sum af aktiveringer forbliver den samme uanset dropout-raten. Fordelen er, at du under inferens deaktiverer Dropout og bruger netværket, som det er — du behøver ikke skalere output. Derfor er Dropout i eval-tilstand blot en identitetsfunktion.
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())Tilføjelse af Dropout til et netværk
Dropout-lag placeres typisk efter aktiveringsfunktioner i fuldt forbundne netværk eller efter pooling i CNN'er. Almindelige dropout-sandsynligheder er p=0.5 for store skjulte lag og p=0.2-0.3 for mindre lag eller CNN'er. Dropout anvendes normalt ikke på inputlaget eller det endelige outputlag. Eksemplet nedenfor viser en dyb MLP med Dropout mellem skjulte lag.
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() sammenlignet med eval(): kritisk brug
At glemme at skifte mellem trænings- og evalueringstilstand er en af de mest almindelige fejl, som er svære at fejlsøge. I træningstilstand (model.train()) sætter Dropout tilfældigt aktiveringer til nul. I eval-tilstand (model.eval()) er Dropout helt deaktiveret, og alle neuroner er aktive. Hvis du ikke kalder model.eval() før evalueringen, bliver valideringstabet kunstigt højere og ikke-deterministisk, hvilket gør det umuligt at sammenligne kørsler pålideligt.
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 timesObservation af Dropouts effekt på overtilpasning
For at se Dropouts regulariseringseffekt kan du sammenligne kurverne for trænings- og valideringstab med og uden Dropout. Uden Dropout vil et stort netværk typisk vise det klassiske mønster for overtilpasning: træningstabet er tæt på nul, mens valideringstabet forbliver højt. Med Dropout følger de to kurver hinanden tættere. Forskellen mellem trænings- og valideringsnøjagtigheden (det såkaldte generaliseringsgab) er den vigtigste måling, som Dropout reducerer.
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}')Justering af Dropout-raten
Dropout-sandsynligheden p er en hyperparameter, som du skal justere. p=0.5 er standardværdien fra den oprindelige Dropout-artikel og fungerer godt for meget store lag. For konvolutionelle lag er p=0.1 til 0.25 typisk, fordi spatiale egenskaber er mere strukturerede. For Transformers er p=0.1 standard. Hvis din model ikke overtilpasser, skal du reducere p eller fjerne Dropout. Hvis den overtilpasser kraftigt, skal du øge p gradvist og overvåge valideringsresultatet.
# 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 til usikkerhed
En avanceret anvendelse af Dropout er MC Dropout til estimering af usikkerhed. I stedet for at deaktivere Dropout under inferens lader du det være aktiveret og kører modellen N gange på det samme input. Middelværdien af de N forudsigelser er estimatet; variansen på tværs af forudsigelserne måler modellens usikkerhed. Det tilnærmer bayesiansk inferens uden et fuldt bayesiansk neuralt netværk. Det bruges i sikkerhedskritiske anvendelser som medicinsk diagnosticering, hvor det er værdifuldt at vide, hvornår modellen ikke ved det.
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 til CNN'er
nn.Dropout2d (Spatial Dropout) sætter hele kanaler til nul i stedet for individuelle aktiveringer i konvolutionelle feature maps. Det er mere effektivt til CNN'er, fordi tilstødende pixels i den samme kanal er stærkt korrelerede — det har kun ringe effekt at fjerne individuelle pixels. Ved at fjerne hele kanaler kan netværket ikke stole på et enkelt filter, men må fordele informationen på mange kanaler. Brug Dropout2d efter Conv2d-lag i stedet for almindelig 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 sammenlignet med vægtnedskalering: komplementære teknikker
Dropout og vægtnedskalering (L2-regularisering) er komplementære regulariseringsteknikker — brug dem sammen. Dropout forhindrer samtilpasning mellem neuroner, mens vægtnedskalering straffer store vægte og trækker alle parametre mod nul. Kombinationen er stærkere end hver teknik for sig. I AdamW anvendes vægtnedskalering korrekt som et separat led og blandes ikke ind i gradientopdateringen som i Adam. De fleste modeller i produktion bruger begge teknikker.
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')Diagnosticering af overtilpasning med Dropout
Brug grafen over trænings- og valideringstab til at afgøre, om du har brug for mere regularisering. At valideringstabet stiger, mens træningstabet falder, er det typiske tegn på overtilpasning. Øg systematisk dropout-sandsynligheden, eller tilføj Dropout-lag, hvor de mangler. Andre tegn på alvorlig overtilpasning er blandt andet en træningsnøjagtighed på over 98 %, mens valideringsnøjagtigheden stagnerer på 70-80 %, eller meget stor variation i valideringsmålingerne på tværs af forskellige tilfældige frø.
# 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 i praksis: opsummering
Sådan bruger du Dropout korrekt: tilføj nn.Dropout(p) efter aktiveringerne i de skjulte lag; kald model.train() under træningen for at aktivere det og model.eval() under evalueringen for at deaktivere det; start med p=0.5 for store fuldt forbundne lag, og reducer værdien, hvis modellen undertilpasser. Kombiner med vægtnedskalering via AdamW for at opnå de bedste resultater. Følg altid både trænings- og valideringsmålinger for at bekræfte, at Dropout faktisk hjælper — nogle gange gør det konvergensen langsommere uden at forbedre generaliseringen, når modellen allerede er tilstrækkeligt regulariseret.
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')Hurtigt tjek
Test din forståelse af begreberne inden for Machine Learning med Python fra denne lektion.
Opsummering af lektionen
I denne lektion lærte du: Dropout sætter tilfældigt neuronaktiveringer til nul under træning for at forhindre ko-adaptation og reducere overtilpasning, inverteret dropout skalerer overlevende værdier med 1/(1-p), så inferens ikke kræver nogen justering, og model.eval() deaktiverer Dropout for deterministisk og korrekt inferens. Nu ser vi nærmere på strategier til vægtinitialisering, som forhindrer forsvindende og eksploderende gradienter i dybe netværk.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Dropout-regularisering for at forhindre overfitting” gratis?
Ja — hele teksten til “Dropout-regularisering for at forhindre overfitting” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Dropout-regularisering for at forhindre overfitting”?
De lærende tilføjer nn.Dropout med varierende sandsynligheder, sammenligner kurverne for trænings-loss og validerings-loss og kalder model.eval() for at deaktivere dropout under inferens. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Dropout-regularisering for at forhindre overfitting”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Learning rate: Den vigtigste hyperparameter
- Batchnormalisering: Stabil og hurtigere træning
- Dropout-regularisering for at forhindre overfitting
- Vægtinitialisering: Xavier- og He-initialisering