Addestramento, validazione e prevenzione dell'overfitting
Monitori val_loss, applichi Dropout e utilizzi callback per l'arresto anticipato
Addestramento, validazione e prevenzione dell'overfitting è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.
Suddivisione in training, validation e test
Il deep learning richiede tre partizioni dei dati: training (il modello impara i parametri), validation (si monitora la capacità di generalizzazione durante l'addestramento e si regolano gli iperparametri) e test (valutazione finale imparziale). L'argomento validation_split di fit() crea automaticamente il set di validation.
# 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)L'oggetto della cronologia di addestramento
L'oggetto restituito da fit() contiene una lista $metrics con una voce per ogni metrica registrata a ogni epoca. Chiami plot(history) per visualizzare affiancate le curve di addestramento e validation. Curve divergenti (il training migliora, mentre la validation si stabilizza) indicano 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')Rilevamento dell'overfitting
L'overfitting si verifica quando la loss di training continua a diminuire, ma la loss di validation inizia ad aumentare. Il modello memorizza i dati di addestramento invece di imparare pattern generalizzabili. Segnali tipici: grande differenza tra l'accuratezza di training e quella di validation; la loss di validation raggiunge un minimo evidente e poi aumenta.
# 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) interrompe l'addestramento quando la metrica monitorata smette di migliorare. patience indica il numero di epoche da attendere dopo l'ultimo miglioramento. Imposti restore_best_weights = TRUE per ripristinare automaticamente i pesi dell'epoca migliore.
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()
Quando l'addestramento si blocca, ridurre il learning rate spesso consente di riprendere i progressi. callback_reduce_lr_on_plateau(monitor, factor, patience) moltiplica il learning rate corrente per factor quando la metrica monitorata non migliora per patience epoche.
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) salva i pesi del modello su disco al termine di ogni epoca (oppure solo quando le prestazioni migliorano con save_best_only = TRUE). Questo protegge dagli arresti anomali durante l'addestramento e consente di caricare il modello migliore anche se l'addestramento prosegue oltre il punto ottimale.
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 rispetto a validation_split
validation_split utilizza l'ultima percentuale N% dei dati di training. Se i dati sono ordinati (ad esempio una serie temporale), il risultato è distorto. Utilizzi invece validation_data = list(x_val, y_val) per fornire un set di validation già creato a partire da una suddivisione casuale stratificata.
# 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)
)Effetto della dimensione del batch
La dimensione del batch è un iperparametro di addestramento fondamentale. I batch più piccoli introducono più rumore nelle stime del gradiente (con un effetto di regolarizzazione), favorendo la generalizzazione. I batch più grandi sono più veloci, ma possono convergere verso minimi più appuntiti e meno generalizzabili. Valori tipici: 32, 64, 128. Provi prima 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 del learning rate
Iniziare con un learning rate molto piccolo e aumentarlo gradualmente durante le prime epoche (warmup) può stabilizzare l'addestramento, soprattutto per modelli grandi o dataset piccoli. Un callback personalizzato LearningRateScheduler consente di adottare questo schema.
# 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
)Riepilogo della regolarizzazione
Per un deep learning robusto è opportuno combinare diverse tecniche di regolarizzazione:
- Dropout: azzera casualmente alcuni neuroni durante l'addestramento.
- Weight decay (L2): penalizza i pesi elevati nella loss.
- Early stopping: interrompe l'addestramento prima che il modello vada in overfitting.
- Data augmentation: aumenta artificialmente le dimensioni del set di addestramento.
- Batch normalization: stabilizza le attivazioni e riduce il 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')Grafici delle curve di addestramento
Visualizzi sempre affiancate le metriche di training e validation. Un modello ben addestrato dovrebbe mostrare entrambe le curve convergere e rimanere vicine. Se divergono, aggiunga regolarizzazione o riduca la capacità del modello. Se entrambe le curve si stabilizzano a una loss elevata, il modello è in underfitting.
# 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')Verifica rapida
Che cosa comporta impostare restore_best_weights = TRUE in callback_early_stopping()?
Riepilogo di addestramento e overfitting
Punti chiave dell'addestramento, della validation e della prevenzione dell'overfitting:
- Utilizzi
validation_splitovalidation_dataper monitorare la generalizzazione durante l'addestramento. plot(history)visualizza le curve di addestramento: curve divergenti indicano overfitting.callback_early_stopping(patience, restore_best_weights=TRUE)interrompe l'addestramento all'epoca ottimale.callback_reduce_lr_on_plateau()riduce il learning rate quando i progressi si arrestano.callback_model_checkpoint(save_best_only=TRUE)salva su disco il modello migliore.- Combini dropout, regolarizzazione L2, batch normalization e data augmentation per un addestramento robusto.
# 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
)Domande Frequenti
La lezione «Addestramento, validazione e prevenzione dell'overfitting» è gratuita?
Sì — il testo completo di «Addestramento, validazione e prevenzione dell'overfitting» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.
Cosa imparerò in «Addestramento, validazione e prevenzione dell'overfitting»?
Monitori val_loss, applichi Dropout e utilizzi callback per l'arresto anticipato Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare R Academy?
Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Addestramento, validazione e prevenzione dell'overfitting»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione R Academy?
Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Configurazione di Keras e TensorFlow in R
- Costruzione di modelli sequenziali
- Fondamenti delle reti neurali convoluzionali
- Addestramento, validazione e prevenzione dell'overfitting