Träning, validering och att förhindra överanpassning
Övervaka val_loss, tillämpa Dropout och använd callbacks för tidigt stopp.
Träning, validering och att förhindra överanpassning är en gratis lektion i R Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för R Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i R Academy innehåller totalt 4 lektioner.
Uppdelning i träning, validering och test
Djupinlärning kräver tre datadelar: träning (modellen lär sig parametrar), validering (övervaka generaliseringen under träningen och finjustera hyperparametrar) och test (slutlig opartisk utvärdering). Argumentet validation_split i fit() skapar valideringsmängden automatiskt.
# 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)Objektet med träningshistorik
Objektet som returneras av fit() innehåller en lista $metrics med ett element per loggat mätvärde och epok. Anropa plot(history) för att visualisera tränings- och valideringskurvor sida vid sida. Kurvor som skiljer sig åt (träningen förbättras medan valideringen planar ut) tyder på överanpassning.
# 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')Upptäcka överanpassning
Överanpassning uppstår när träningsförlusten fortsätter att minska, men valideringsförlusten börjar öka. Modellen memorerar träningsdata i stället för att lära sig generaliserbara mönster. Tecken är ett stort avstånd mellan träffsäkerheten för träning och validering samt att valideringsförlusten når ett tydligt minimum och sedan ökar.
# 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) avbryter träningen när det övervakade mätvärdet slutar förbättras. patience är antalet epoker som ska väntas efter den senaste förbättringen. Ange restore_best_weights = TRUE för att automatiskt återgå till vikterna från den bästa epoken.
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()
När träningen stannar upp kan en sänkt inlärningshastighet ofta få utvecklingen att fortsätta. callback_reduce_lr_on_plateau(monitor, factor, patience) multiplicerar den aktuella inlärningshastigheten med factor när det övervakade mätvärdet inte har förbättrats under patience epoker.
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) sparar modellvikterna på disk i slutet av varje epok (eller endast när resultatet förbättras med save_best_only = TRUE). Detta skyddar mot träningskrascher och gör att du kan läsa in den bästa modellen även om träningen fortsätter förbi den optimala punkten.
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 jämfört med validation_split
validation_split tar de sista N procenten av dina träningsdata. Om dina data är ordnade (t.ex. tidsserier blir detta skevt. Använd i stället validation_data = list(x_val, y_val) för att ange en färdig valideringsmängd från en slumpmässig stratifierad uppdelning.
# 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)
)Effekten av batchstorleken
Batchstorleken är en viktig hyperparameter under träningen. Mindre batcher tillför mer brus i gradientberäkningarna (vilket fungerar som regularisering) och kan förbättra generaliseringen. Större batcher är snabbare men kan konvergera till skarpare minimipunkter som generaliserar sämre. Typiska värden är 32, 64 och 128. Börja med 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')
}Uppvärmning av inlärningshastigheten
Att börja med en mycket liten inlärningshastighet och gradvis öka den under de första epokerna (uppvärmning) kan stabilisera träningen, särskilt för stora modeller eller små datamängder. En anpassad callback av typen LearningRateScheduler möjliggör detta mönster.
# 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
)Sammanfattning av regularisering
Flera regulariseringstekniker bör kombineras för robust djupinlärning:
- Dropout: sätter slumpmässigt neuroner till noll under träningen.
- Viktförfall (L2): straffar stora vikter i förlustfunktionen.
- Tidig avbrytning: stoppar innan modellen överanpassas.
- Dataaugmentering: ökar träningsmängdens storlek artificiellt.
- Batchnormalisering: stabiliserar aktiveringar och minskar kovariatförskjutning.
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')Plotta träningskurvor
Visualisera alltid tränings- och valideringsmätvärden sida vid sida. En vältränad modell bör visa att båda kurvorna konvergerar och förblir nära varandra. Om de skiljer sig åt kan du lägga till regularisering eller minska modellens kapacitet. Om båda kurvorna planar ut vid hög förlust är modellen underanpassad.
# 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')Snabbkontroll
Vad gör inställningen restore_best_weights = TRUE i callback_early_stopping()?
Sammanfattning av träning och överanpassning
Viktiga punkter från Träning, validering och att förhindra överanpassning:
- Använd
validation_splitellervalidation_dataför att övervaka generaliseringen under träningen. plot(history)visualiserar träningskurvor – kurvor som skiljer sig åt tyder på överanpassning.callback_early_stopping(patience, restore_best_weights=TRUE)stoppar träningen vid den optimala epoken.callback_reduce_lr_on_plateau()minskar inlärningshastigheten när utvecklingen stannar upp.callback_model_checkpoint(save_best_only=TRUE)sparar den bästa modellen på disk.- Kombinera dropout, L2-regularisering, batchnormalisering och dataaugmentering för robust träning.
# 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
)
Lär dig R med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 43
- Lektioner
- 159
Vanliga frågor
Är lektionen ”Träning, validering och att förhindra överanpassning” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen R Academy, inklusive ”Träning, validering och att förhindra överanpassning”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i R Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Träning, validering och att förhindra överanpassning”?
Övervaka val_loss, tillämpa Dropout och använd callbacks för tidigt stopp. Ni övar på R Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig R Academy?
Du behöver inga förkunskaper. Utbildningen i R Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Träning, validering och att förhindra överanpassning”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här R Academy-lektionen?
Ja. Varje R Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Konfigurera Keras och TensorFlow i R
- Bygga sekventiella modeller
- Grunderna i konvolutionella neurala nätverk
- Träning, validering och att förhindra överanpassning