Training, Validierung und Vermeidung von Overfitting
Überwachen Sie val_loss, wenden Sie Dropout an und nutzen Sie Callbacks für Early Stopping
Training, Validierung und Vermeidung von Overfitting ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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 R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Aufteilung in Training, Validierung und Test
Deep Learning erfordert drei Datenpartitionen: Training (das Modell lernt Parameter), Validierung (Überwachung der Generalisierungsfähigkeit während des Trainings und Abstimmung der Hyperparameter) und Test (abschließende, unverfälschte Bewertung). Das Argument validation_split in fit() erstellt den Validierungssatz automatisch.
# validation_split = 0.2 reserves last 20% as validation
history <- model |> fit(
x_train, y_train,
epochs = 50,
batch_size = 32,
validation_split = 0.2,
verbose = 0
)
# history contains train and val metrics per epoch
names(history$metrics)Das Trainingsverlaufsobjekt
Das von fit() zurückgegebene Objekt enthält eine $metrics-Liste mit einem Eintrag pro protokollierter Metrik und Epoche. Rufen Sie plot(history) auf, um Trainings- und Validierungskurven nebeneinander darzustellen. Auseinanderlaufende Kurven (Training verbessert sich, Validierung stagniert) weisen auf Overfitting hin.
# Training loss and accuracy over epochs
head(history$metrics$loss)
head(history$metrics$val_loss)
# Plot training curves
plot(history)
# Or create a custom ggplot
library(ggplot2)
df <- data.frame(
epoch = seq_along(history$metrics$loss),
train = history$metrics$loss,
val = history$metrics$val_loss
)
ggplot(df, aes(epoch)) +
geom_line(aes(y = train, colour = 'Train')) +
geom_line(aes(y = val, colour = 'Validation')) +
labs(y = 'Loss', title = 'Training Curves')Overfitting erkennen
Overfitting tritt auf, wenn der Trainings-Loss weiter sinkt, während der Validierungs-Loss zu steigen beginnt. Das Modell merkt sich die Trainingsdaten, anstatt verallgemeinerbare Muster zu lernen. Anzeichen sind ein großer Abstand zwischen Trainings- und Validierungsgenauigkeit sowie ein sichtbares Minimum des Validierungs-Loss, auf das ein Anstieg folgt.
# Overfitting is visible in the history
# Example of overfitting signatures:
cat('Epoch 5 — Train loss: 0.12, Val loss: 0.18\n')
cat('Epoch 10 — Train loss: 0.06, Val loss: 0.21\n')
cat('Epoch 20 — Train loss: 0.02, Val loss: 0.31\n')
# The model should have stopped at epoch 5!
# Strategies: early stopping, dropout, regularisation, more datacallback_early_stopping()
callback_early_stopping(monitor, patience, restore_best_weights) beendet das Training, wenn sich die überwachte Metrik nicht mehr verbessert. patience gibt an, wie viele Epochen nach der letzten Verbesserung gewartet wird. Setzen Sie restore_best_weights = TRUE, um automatisch die Gewichte der besten Epoche wiederherzustellen.
early_stop <- callback_early_stopping(
monitor = 'val_loss',
patience = 10, # wait 10 epochs
restore_best_weights = TRUE # rollback to best
)
history <- model |> fit(
x_train, y_train,
epochs = 200,
batch_size = 32,
validation_split = 0.2,
callbacks = list(early_stop),
verbose = 0
)
cat('Stopped at epoch:', length(history$metrics$loss))callback_reduce_lr_on_plateau()
Wenn das Training stagniert, kann eine Reduzierung der Lernrate den Fortschritt häufig wieder in Gang bringen. callback_reduce_lr_on_plateau(monitor, factor, patience) multipliziert die aktuelle Lernrate mit factor, wenn sich die überwachte Metrik über patience Epochen hinweg nicht verbessert hat.
reduce_lr <- callback_reduce_lr_on_plateau(
monitor = 'val_loss',
factor = 0.5, # halve the learning rate
patience = 5, # after 5 stagnant epochs
min_lr = 1e-6 # floor for learning rate
)
history <- model |> fit(
x_train, y_train,
epochs = 100,
batch_size = 64,
validation_split = 0.2,
callbacks = list(early_stop, reduce_lr),
verbose = 1
)callback_model_checkpoint()
callback_model_checkpoint(filepath, save_best_only) speichert die Modellgewichte am Ende jeder Epoche auf der Festplatte (oder nur bei einer Leistungsverbesserung mit save_best_only = TRUE). Dadurch sind Sie gegen Trainingsabstürze geschützt und können das beste Modell laden, selbst wenn das Training über den optimalen Zeitpunkt hinaus fortgesetzt wird.
checkpoint <- callback_model_checkpoint(
filepath = '/tmp/best_model.h5',
monitor = 'val_accuracy',
save_best_only = TRUE,
mode = 'max', # higher accuracy = better
verbose = 1
)
history <- model |> fit(
x_train, y_train,
epochs = 100,
batch_size = 32,
validation_split = 0.2,
callbacks = list(early_stop, reduce_lr, checkpoint)
)
# Reload best model
best_model <- load_model_hdf5('/tmp/best_model.h5')validation_data im Vergleich zu validation_split
validation_split verwendet die letzten N % Ihrer Trainingsdaten. Wenn Ihre Daten geordnet sind (z. B. Zeitreihen), führt dies zu einer Verzerrung. Verwenden Sie stattdessen validation_data = list(x_val, y_val), um einen vorab erstellten Validierungssatz aus einer zufälligen, stratifizierten Aufteilung bereitzustellen.
# Manually create a random validation split
set.seed(42)
val_idx <- sample(nrow(x_train), size = 0.2 * nrow(x_train))
x_val <- x_train[val_idx, ]
y_val <- y_train[val_idx, ]
x_tr <- x_train[-val_idx, ]
y_tr <- y_train[-val_idx, ]
history <- model |> fit(
x_tr, y_tr,
epochs = 50,
batch_size = 32,
validation_data = list(x_val, y_val), # explicit val set
callbacks = list(early_stop)
)Auswirkung der Batch-Größe
Die Batch-Größe ist ein wichtiger Hyperparameter beim Training. Kleinere Batches führen zu mehr Rauschen in den Gradienten-Schätzungen (wirken also als Regularisierung) und unterstützen dadurch die Generalisierung. Größere Batches sind schneller, können aber zu schärferen und schlechter verallgemeinerbaren Minima konvergieren. Typische Werte sind 32, 64 und 128. Beginnen Sie mit 32.
# Compare training with different batch sizes
for (bs in c(32, 128, 512)) {
set_weights(model, init_weights) # reset
h <- model |> fit(
x_train, y_train,
epochs = 20,
batch_size = bs,
validation_split = 0.2,
verbose = 0
)
cat('Batch:', bs, '| Val Acc:',
tail(h$metrics$val_accuracy, 1), '\n')
}Warmup der Lernrate
Mit einer sehr kleinen Lernrate zu beginnen und sie während der ersten Epochen schrittweise zu erhöhen (Warmup), kann das Training stabilisieren, insbesondere bei großen Modellen oder kleinen Datensätzen. Ein benutzerdefinierter LearningRateScheduler-Callback ermöglicht dieses Vorgehen.
# Custom learning rate schedule with warmup
lr_schedule <- function(epoch, lr) {
if (epoch < 5) {
return(lr * (epoch + 1) / 5) # warmup
} else if (epoch < 30) {
return(lr) # constant
} else {
return(lr * 0.95) # decay
}
}
lr_callback <- callback_learning_rate_scheduler(lr_schedule)
history <- model |> fit(
x_train, y_train,
epochs = 50,
callbacks = list(lr_callback, early_stop),
validation_split = 0.2
)Zusammenfassung der Regularisierung
Für robustes Deep Learning sollten mehrere Regularisierungstechniken kombiniert werden:
- Dropout: Setzt während des Trainings zufällig Neuronen auf null.
- Weight Decay (L2): Bestraft große Gewichte im Loss.
- Early Stopping: Beendet das Training, bevor das Modell überfitten kann.
- Datenaugmentation: Vergrößert den Trainingsdatensatz künstlich.
- Batch-Normalisierung: Stabilisiert Aktivierungen und verringert Covariate Shift.
model <- keras_model_sequential(input_shape = c(784)) |>
layer_dense(512, use_bias = FALSE,
kernel_regularizer = regularizer_l2(1e-4)) |>
layer_batch_normalization() |>
layer_activation('relu') |>
layer_dropout(0.4) |>
layer_dense(256, kernel_regularizer = regularizer_l2(1e-4)) |>
layer_batch_normalization() |>
layer_activation('relu') |>
layer_dropout(0.3) |>
layer_dense(10, activation = 'softmax')
model |> compile('adam', 'categorical_crossentropy', 'accuracy')Trainingskurven darstellen
Stellen Sie Trainings- und Validierungsmetriken immer nebeneinander dar. Ein gut trainiertes Modell sollte zeigen, dass beide Kurven konvergieren und nahe beieinander bleiben. Wenn sie auseinanderlaufen, fügen Sie Regularisierung hinzu oder verringern Sie die Modellkapazität. Wenn beide Kurven bei einem hohen Loss stagnieren, liegt Underfitting vor.
# Detailed training curve plot
df <- data.frame(
epoch = seq_along(history$metrics$loss),
train_loss = history$metrics$loss,
val_loss = history$metrics$val_loss,
train_acc = history$metrics$accuracy,
val_acc = history$metrics$val_accuracy
)
par(mfrow = c(1, 2))
plot(df$epoch, df$train_loss, type = 'l', col = 'blue',
xlab = 'Epoch', ylab = 'Loss', main = 'Loss')
lines(df$epoch, df$val_loss, col = 'red')
legend('topright', c('Train', 'Val'), col = c('blue','red'), lty=1)
plot(df$epoch, df$train_acc, type = 'l', col = 'blue',
xlab = 'Epoch', ylab = 'Accuracy', main = 'Accuracy')
lines(df$epoch, df$val_acc, col = 'red')Kurze Überprüfung
Was bewirkt die Einstellung restore_best_weights = TRUE in callback_early_stopping()?
Zusammenfassung: Training und Overfitting
Wichtige Erkenntnisse zu Training, Validierung und der Vermeidung von Overfitting:
- Verwenden Sie
validation_splitodervalidation_data, um die Generalisierungsfähigkeit während des Trainings zu überwachen. plot(history)stellt Trainingskurven dar – auseinanderlaufende Kurven weisen auf Overfitting hin.callback_early_stopping(patience, restore_best_weights=TRUE)beendet das Training in der optimalen Epoche.callback_reduce_lr_on_plateau()reduziert die Lernrate, wenn der Fortschritt stagniert.callback_model_checkpoint(save_best_only=TRUE)speichert das beste Modell auf der Festplatte.- Kombinieren Sie Dropout, L2-Regularisierung, Batch-Normalisierung und Datenaugmentation für ein robustes Training.
# Best practice training setup
callbacks <- list(
callback_early_stopping(
monitor = 'val_loss', patience = 15,
restore_best_weights = TRUE
),
callback_reduce_lr_on_plateau(
monitor = 'val_loss', factor = 0.5, patience = 5
),
callback_model_checkpoint(
'/tmp/best.h5', monitor = 'val_accuracy',
save_best_only = TRUE
)
)
model |> fit(
x_train, y_train,
epochs = 200, batch_size = 64,
validation_split = 0.2,
callbacks = callbacks, verbose = 0
)Häufig gestellte Fragen
Ist die Lektion „Training, Validierung und Vermeidung von Overfitting“ kostenlos?
Ja — der vollständige Text von „Training, Validierung und Vermeidung von 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 R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Training, Validierung und Vermeidung von Overfitting“?
Überwachen Sie val_loss, wenden Sie Dropout an und nutzen Sie Callbacks für Early Stopping Du übst R 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 R Academy zu starten?
Keine Vorkenntnisse erforderlich. R 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 4 von 4.
Wie lange dauert die Lektion „Training, Validierung und Vermeidung von 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 R Academy-Lektion Code schreiben und ausführen?
Ja. Jede R 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
- Keras und TensorFlow in R einrichten
- Sequenzielle Modelle erstellen
- Grundlagen konvolutionaler neuronaler Netze
- Training, Validierung und Vermeidung von Overfitting