R Academy · Leçon

Entraînement, validation et prévention du surapprentissage

Surveillez val_loss, appliquez Dropout et utilisez des fonctions de rappel pour l’arrêt anticipé.

Entraînement, validation et prévention du surapprentissage est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Séparer les données d’entraînement, de validation et de test

L’apprentissage profond nécessite trois partitions de données : l’entraînement (le modèle apprend les paramètres), la validation (surveiller la généralisation pendant l’entraînement et ajuster les hyperparamètres) et le test (évaluation finale impartiale). L’argument validation_split de fit() crée automatiquement l’ensemble de 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’objet d’historique de l’entraînement

L’objet renvoyé par fit() contient une liste $metrics avec une entrée par métrique enregistrée et par époque. Appelez plot(history) pour visualiser côte à côte les courbes d’entraînement et de validation. Des courbes qui s’écartent (l’entraînement s’améliore, la validation plafonne) signalent un surapprentissage.

# 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')

Détecter le surapprentissage

Le surapprentissage se produit lorsque la perte d’entraînement continue de diminuer, mais que la perte de validation commence à augmenter. Le modèle mémorise les données d’entraînement au lieu d’apprendre des motifs généralisables. Signes révélateurs : écart important entre les précisions d’entraînement et de validation, et perte de validation qui atteint un minimum visible avant d’augmenter.

# 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 data

callback_early_stopping()

callback_early_stopping(monitor, patience, restore_best_weights) arrête l’entraînement lorsque la métrique surveillée cesse de s’améliorer. patience indique le nombre d’époques à attendre après la dernière amélioration. Définissez restore_best_weights = TRUE pour revenir automatiquement aux poids de la meilleure époque.

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()

Lorsque l’entraînement stagne, réduire le taux d’apprentissage permet souvent de relancer les progrès. callback_reduce_lr_on_plateau(monitor, factor, patience) multiplie le taux d’apprentissage actuel par factor lorsque la métrique surveillée ne s’est pas améliorée pendant patience époques.

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) enregistre les poids du modèle sur le disque à la fin de chaque époque (ou uniquement lorsque les performances s’améliorent avec save_best_only = TRUE). Cela protège contre les plantages de l’entraînement et vous permet de charger le meilleur modèle même si l’entraînement se poursuit au-delà du point optimal.

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 ou validation_split

validation_split prend les N % dernières données d’entraînement. Si vos données sont ordonnées (par exemple, une série temporelle), cela crée un biais. Utilisez plutôt validation_data = list(x_val, y_val) pour fournir un ensemble de validation préparé à partir d’une séparation aléatoire stratifiée.

# 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)
)

Effet de la taille des lots

La taille des lots est un hyperparamètre d’entraînement essentiel. Les lots plus petits introduisent davantage de bruit dans les estimations du gradient (ce qui agit comme une régularisation) et favorisent la généralisation. Les lots plus grands sont plus rapides, mais peuvent converger vers des minima plus accentués et moins généralisables. Valeurs courantes : 32, 64, 128. Commencez par essayer 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')
}

Phase de montée en puissance du taux d’apprentissage

Commencer avec un taux d’apprentissage très faible, puis l’augmenter progressivement au cours des premières époques (phase de montée en puissance) peut stabiliser l’entraînement, en particulier pour les grands modèles ou les petits jeux de données. Un rappel LearningRateScheduler personnalisé permet de mettre en œuvre cette approche.

# 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
)

Résumé de la régularisation

Il convient de combiner plusieurs techniques de régularisation pour obtenir un apprentissage profond robuste :

Dropout : mettre aléatoirement des neurones à zéro pendant l’entraînement.
Décroissance des poids (L2) : pénaliser les poids élevés dans la perte.
Arrêt anticipé : arrêter avant que le modèle ne surapprenne.
Augmentation des données : augmenter artificiellement la taille de l’ensemble d’entraînement.
Normalisation par lots : stabiliser les activations et réduire le décalage de covariance.

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')

Tracer les courbes d’entraînement

Visualisez toujours côte à côte les métriques d’entraînement et de validation. Un modèle bien entraîné doit présenter deux courbes qui convergent et restent proches. Si elles s’écartent, ajoutez de la régularisation ou réduisez la capacité du modèle. Si les deux courbes plafonnent à une perte élevée, le modèle est en sous-apprentissage.

# 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')

Vérification rapide

Que fait la définition de restore_best_weights = TRUE dans callback_early_stopping() ?

Récapitulatif de l’entraînement et du surapprentissage

Points clés de l’entraînement, de la validation et de la prévention du surapprentissage :

Utilisez validation_split ou validation_data pour surveiller la généralisation pendant l’entraînement.
plot(history) visualise les courbes d’entraînement — des courbes qui s’écartent signalent un surapprentissage.
callback_early_stopping(patience, restore_best_weights=TRUE) arrête l’entraînement à l’époque optimale.
callback_reduce_lr_on_plateau() réduit le taux d’apprentissage lorsque les progrès stagnent.
callback_model_checkpoint(save_best_only=TRUE) enregistre le meilleur modèle sur le disque.
Combinez dropout, régularisation L2, normalisation par lots et augmentation des données pour obtenir un entraînement robuste.

# 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
)

Questions Fréquemment Posées

La leçon « Entraînement, validation et prévention du surapprentissage » est-elle gratuite ?

Oui — le texte complet de « Entraînement, validation et prévention du surapprentissage » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Entraînement, validation et prévention du surapprentissage » ?

Surveillez val_loss, appliquez Dropout et utilisez des fonctions de rappel pour l’arrêt anticipé. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Entraînement, validation et prévention du surapprentissage » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Configurer Keras et TensorFlow dans R
Construire des modèles séquentiels
Bases des réseaux neuronaux convolutifs
Entraînement, validation et prévention du surapprentissage

← Retour à R Academy