Dropout-Regularisierung gegen Overfitting
Lernende fügen nn.Dropout mit unterschiedlichen Wahrscheinlichkeiten hinzu, vergleichen Loss-Kurven von Training und Validierung und rufen model.eval() auf, um Dropout bei der Inferenz zu deaktivieren.
Dropout-Regularisierung gegen Overfitting ist eine kostenlose Machine Learning Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Machine Learning Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Machine Learning Academy-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
What Is Dropout and Why Use It?
Dropout, introduced by Srivastava et al. in 2014, is a regularisation technique that randomly sets a fraction of neuron activations to zero during each training step. By forcing the network to operate with a random subset of neurons, it prevents any single neuron from becoming too specialised and forces the network to learn redundant representations. This reduces overfitting significantly in large fully connected networks.
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 onesThe Inverted Dropout Trick
PyTorch implements inverted dropout: during training, surviving activations are scaled up by 1/(1-p) to compensate for the zeroed neurons. This means the expected sum of activations stays the same regardless of the dropout rate. The advantage is that at inference you disable dropout and use the network as-is — no need to scale outputs. This is why Dropout in eval mode is simply an identity function.
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())Adding Dropout to a Network
Dropout layers are typically placed after activation functions in fully connected networks, or after pooling in CNNs. Common dropout probabilities are p=0.5 for large hidden layers and p=0.2-0.3 for smaller layers or CNNs. Dropout is usually not applied to the input layer or the final output layer. The example below shows a deep MLP with Dropout between hidden layers.
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() vs eval(): Critical Usage
Forgetting to switch between training and evaluation mode is one of the most common and hard-to-debug mistakes. In training mode (model.train()), Dropout randomly zeros activations. In eval mode (model.eval()), Dropout is completely disabled and all neurons are active. Failing to call model.eval() before evaluation means the validation loss will be artificially higher and non-deterministic, making it impossible to reliably compare runs.
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 timesObserving Dropout's Effect on Overfitting
To see Dropout's regularisation effect, compare training and validation loss curves with and without it. Without Dropout, a large network will typically show the classic overfitting pattern: training loss near zero while validation loss remains high. With Dropout, both curves track each other more closely. The gap between training and validation accuracy (the generalisation gap) is the key metric Dropout reduces.
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}')Dropout Rate Tuning
The dropout probability p is a hyperparameter you need to tune. p=0.5 is the original default from the Dropout paper and works well for very large layers. For convolutional layers, p=0.1 to 0.25 is typical because spatial features are more structured. For Transformers, p=0.1 is standard. If your model is not overfitting, reduce p or remove Dropout. If it is strongly overfitting, increase p incrementally and monitor validation performance.
# 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 for Uncertainty
An advanced use of Dropout is MC Dropout for uncertainty estimation. Instead of disabling Dropout at inference, keep it enabled and run the model N times on the same input. The mean of the N predictions is the estimate; the variance across predictions measures model uncertainty. This approximates Bayesian inference without a full Bayesian neural network. It is used in safety-critical applications like medical diagnosis where knowing 'I don't know' is valuable.
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 for CNNs
nn.Dropout2d (Spatial Dropout) zeros entire channels rather than individual activations in convolutional feature maps. This is more effective for CNNs because adjacent pixels in the same channel are highly correlated — dropping individual pixels has little effect. By dropping entire channels, the network cannot rely on any single filter and must distribute information across many channels. Use Dropout2d after Conv2d layers in place of regular 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 vs Weight Decay: Complementary Techniques
Dropout and weight decay (L2 regularisation) are complementary regularisers — use them together. Dropout prevents co-adaptation between neurons; weight decay penalises large weights, shrinking all parameters towards zero. The combination is stronger than either alone. In AdamW, weight decay is applied correctly as a separate term, not mixed into the gradient update like in Adam. Most production models use both techniques.
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')Diagnosing Overfitting with Dropout
Use the training vs validation loss plot to diagnose whether you need more regularisation. The validation loss increasing while training loss decreases is the signature of overfitting. Systematically increase dropout probability or add Dropout layers where missing. Other signals of severe overfitting include training accuracy 98%+ while validation accuracy stagnates at 70-80%, or very high variance in validation metrics across different random 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 Practice: Summary
To use Dropout correctly: add nn.Dropout(p) after hidden layer activations; call model.train() during training to enable it and model.eval() during evaluation to disable it; start with p=0.5 for large FC layers and reduce if the model underfits. Pair with weight decay via AdamW for best results. Always track both training and validation metrics to confirm Dropout is actually helping — sometimes it hurts convergence speed without improving generalisation when the model is already well-regularised.
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')Quick Check
Test your understanding of Machine Learning with Python concepts from this lesson.
Lesson Recap
In this lesson you learned: Dropout randomly zeros neuron activations during training to prevent co-adaptation and reduce overfitting, inverted dropout scales surviving values by 1/(1-p) so inference requires no adjustment, and model.eval() disables Dropout for deterministic and correct inference. Next up we explore weight initialisation strategies that prevent vanishing and exploding gradients in deep networks.
Häufig gestellte Fragen
Ist die Lektion „Dropout-Regularisierung gegen Overfitting“ kostenlos?
Ja — der vollständige Text von „Dropout-Regularisierung gegen Overfitting“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Machine Learning Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Machine Learning Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Dropout-Regularisierung gegen Overfitting“?
Lernende fügen nn.Dropout mit unterschiedlichen Wahrscheinlichkeiten hinzu, vergleichen Loss-Kurven von Training und Validierung und rufen model.eval() auf, um Dropout bei der Inferenz zu deaktiviere… Du übst Machine Learning Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Machine Learning Academy zu starten?
Keine Vorkenntnisse erforderlich. Machine Learning Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Dropout-Regularisierung gegen Overfitting“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Machine Learning Academy-Lektion Code schreiben und ausführen?
Ja. Jede Machine Learning Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Learning Rate: Der wichtigste Hyperparameter
- Batch-Normalisierung: Stabileres und schnelleres Training
- Dropout-Regularisierung gegen Overfitting
- Gewichtsinitialisierung: Xavier- und He-Initialisierung