Training, validatie en overfitting voorkomen
Bewaak val_loss, pas Dropout toe en gebruik callbacks voor early stopping.
Training, validatie en overfitting voorkomen is een gratis R Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject R Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus R Academy bevat in totaal 4 lessen.
Verdeling in training, validatie en test
Deep learning vereist drie gegevenspartities: training (het model leert parameters), validatie (controleer de generalisatie tijdens het trainen en stem hyperparameters af) en test (definitieve onbevooroordeelde evaluatie). Het argument validation_split in fit() maakt de validatieset 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)Het object met de trainingsgeschiedenis
Het object dat door fit() wordt geretourneerd, bevat een lijst $metrics met per gelogde meetwaarde per tijdperk één item. Roep plot(history) aan om de trainings- en validatiecurves naast elkaar weer te geven. Uiteengaande curves (training verbetert, validatie vlakt af) wijzen op overfitting.
# 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 detecteren
Overfitting treedt op wanneer het trainingsverlies blijft afnemen, maar het validatieverlies begint toe te nemen. Het model onthoudt de trainingsgegevens in plaats van generaliseerbare patronen te leren. Signalen zijn een groot verschil tussen de nauwkeurigheid van training en validatie en een zichtbaar minimum waarna het validatieverlies toeneemt.
# 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) stopt het trainen wanneer de gemonitorde meetwaarde niet meer verbetert. patience is het aantal tijdperken dat je na de laatste verbetering wacht. Stel restore_best_weights = TRUE in om automatisch terug te gaan naar de gewichten van het beste tijdperk.
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()
Wanneer het trainen vastloopt, zorgt het verlagen van de leersnelheid vaak voor nieuwe vooruitgang. callback_reduce_lr_on_plateau(monitor, factor, patience) vermenigvuldigt de huidige leersnelheid met factor wanneer de gemonitorde meetwaarde gedurende patience tijdperken niet is verbeterd.
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) slaat de modelgewichten aan het einde van elk tijdperk op schijf op (of alleen wanneer de prestaties verbeteren met save_best_only = TRUE). Dit beschermt tegen crashes tijdens het trainen en zorgt ervoor dat je het beste model kunt laden, zelfs als het trainen voorbij het optimale punt doorgaat.
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 versus validation_split
validation_split neemt de laatste N% van je trainingsgegevens. Als je gegevens geordend zijn (bijvoorbeeld een tijdreeks), leidt dit tot vertekening. Gebruik in plaats daarvan validation_data = list(x_val, y_val) om een vooraf samengestelde validatieset uit een willekeurige gestratificeerde verdeling aan te leveren.
# 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)
)Effect van de batchgrootte
De batchgrootte is een belangrijke hyperparameter voor het trainen. Kleinere batches voegen meer ruis toe aan schattingen van de gradiënt (wat als regularisatie werkt) en helpen bij generalisatie. Grotere batches zijn sneller, maar kunnen convergeren naar scherpere, minder generaliseerbare minima. Gebruikelijke waarden zijn 32, 64 en 128. Probeer eerst 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')
}Opwarming van de leersnelheid
Beginnen met een zeer kleine leersnelheid en deze tijdens de eerste paar tijdperken geleidelijk verhogen (opwarming) kan het trainen stabiliseren, vooral bij grote modellen of kleine gegevensverzamelingen. Met een aangepaste callback LearningRateScheduler kun je dit patroon toepassen.
# 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
)Samenvatting van regularisatie
Combineer meerdere regularisatietechnieken voor robuuste deep learning:
- Dropout: zet tijdens het trainen willekeurig neuronen op nul.
- Gewichtsverval (L2): bestraf grote gewichten in het verlies.
- Vroegtijdig stoppen: stop voordat het model overfit raakt.
- Gegevensaugmentatie: vergroot de omvang van de trainingsset kunstmatig.
- Batchnormalisatie: stabiliseert activeringen en vermindert 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')Trainingscurves weergeven
Geef de trainings- en validatiemeetwaarden altijd naast elkaar weer. Een goed getraind model laat zien dat beide curves naar elkaar toe bewegen en dicht bij elkaar blijven. Als ze uiteenlopen, voeg dan regularisatie toe of verklein de modelcapaciteit. Als beide curves bij een hoog verlies afvlakken, past het model te weinig.
# 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')Korte controle
Wat doet het instellen van restore_best_weights = TRUE in callback_early_stopping()?
Samenvatting van trainen en overfitting
Belangrijkste punten uit Trainen, valideren en overfitting voorkomen:
- Gebruik
validation_splitofvalidation_dataom de generalisatie tijdens het trainen te controleren. plot(history)geeft trainingscurves weer — uiteenlopende curves wijzen op overfitting.callback_early_stopping(patience, restore_best_weights=TRUE)stopt het trainen in het optimale tijdperk.callback_reduce_lr_on_plateau()verlaagt de leersnelheid wanneer de vooruitgang stilvalt.callback_model_checkpoint(save_best_only=TRUE)slaat het beste model op schijf op.- Combineer dropout, L2-regularisatie, batchnormalisatie en gegevensaugmentatie voor robuust trainen.
# 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
)
Leer R 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
- 43
- Lessen
- 159
Veelgestelde vragen
Is de les “Training, validatie en overfitting voorkomen” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad R Academy, waaronder “Training, validatie en overfitting voorkomen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus R Academy bevat in totaal 4 lessen.
Wat leer ik in “Training, validatie en overfitting voorkomen”?
Bewaak val_loss, pas Dropout toe en gebruik callbacks voor early stopping. Je oefent met R 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 R Academy te beginnen?
Ervaring vooraf is niet nodig. R 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 4 van 4.
Hoe lang duurt de les “Training, validatie en overfitting 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 R Academy?
Ja. Elke les over R 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
- Keras en TensorFlow instellen in R
- Sequentiële modellen bouwen
- Basisprincipes van convolutionele neurale netwerken
- Training, validatie en overfitting voorkomen