Early Stopping

Fonctions :

EarlyStopping()

La fonction EarlyStopping() dans Keras (et d'autres frameworks de deep learning) est utilisée pour arrêter l'entraînement d'un modèle si une certaine condition d'arrêt est remplie avant le nombre d'itérations prédéfini. Cela permet d'éviter le sur-apprentissage (overfitting) en arrêtant l'entraînement lorsque la performance du modèle sur un ensemble de validation cesse de s'améliorer. Cette fonction est particulièrement utile pour optimiser le temps d'entraînement et améliorer la généralisation du modèle.

Importation :

from tensorflow.keras.callbacks import EarlyStopping

Attributs :

Paramètre	Type	Valeur par défaut	Description
monitor	str	'val_loss'	La métrique à surveiller. Cela peut être une valeur de perte ou une autre métrique comme 'val_accuracy'.
min_delta	float	0	Le changement minimum pour qu'une amélioration soit considérée comme significative. Si le changement est inférieur à ce seuil, l'arrêt est activé.
patience	int	0	Le nombre d'epochs sans amélioration avant d'arrêter l'entraînement. Par exemple, une valeur de 3 signifie que l'entraînement sera arrêté si la performance n'a pas amélioré pendant 3 epochs consécutifs.
verbose	int	0	Si égal à 1, un message est affiché lorsque l'entraînement est arrêté par la fonction EarlyStopping.
mode	str	'auto'	Le mode d'arrêt. Il peut être 'min' (lorsque la valeur surveillée doit être minimisée, comme la perte) ou 'max' (lorsque la valeur doit être maximisée, comme la précision). 'auto' sélectionne automatiquement le mode en fonction de la métrique.
restore_best_weights	bool	False	Si True, les poids du modèle seront restaurés à ceux du meilleur epoch observé avant l'arrêt.

Exemple de code :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.callbacks import EarlyStopping
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Générer des données d'exemple
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)

# Diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Créer un modèle simple
model = Sequential()
model.add(Dense(64, input_dim=20, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# Compiler le modèle
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Initialiser EarlyStopping
early_stopping = EarlyStopping(monitor='val_loss', patience=3, verbose=1, restore_best_weights=True)

# Entraîner le modèle avec EarlyStopping
history = model.fit(X_train, y_train, epochs=100, batch_size=32, validation_split=0.2, callbacks=[early_stopping])

# Évaluer le modèle sur les données de test
test_loss, test_acc = model.evaluate(X_test, y_test)
print("Test Loss:", test_loss)
print("Test Accuracy:", test_acc)

Explication du code :

Données d'exemple : Nous générons un jeu de données de classification avec 1000 échantillons et 20 caractéristiques à l'aide de make_classification(). Ces données sont ensuite séparées en ensembles d'entraînement et de test avec train_test_split().
Création du modèle : Nous créons un modèle de réseau de neurones simple avec 2 couches cachées denses (Dense) et une couche de sortie pour la classification binaire (sigmoid).
Compilation du modèle : Le modèle est compilé avec l'optimiseur Adam et la fonction de perte binary_crossentropy, qui est adaptée aux tâches de classification binaire.
Initialisation d'EarlyStopping : Nous créons une instance d'EarlyStopping avec les paramètres suivants :
- monitor : Nous surveillons la métrique val_loss (perte sur les données de validation).
- patience : L'entraînement sera arrêté après 3 epochs sans amélioration de la val_loss.
- verbose : Si l'entraînement s'arrête tôt, un message sera affiché.
- restore_best_weights : Si l'entraînement est arrêté prématurément, les poids du modèle seront restaurés à ceux obtenus au meilleur epoch.
Entraînement avec EarlyStopping : Nous entraînons le modèle avec les données d'entraînement, en spécifiant un ensemble de validation (20% des données d'entraînement). Le callback early_stopping est passé à la méthode fit() pour surveiller la progression de la perte sur les données de validation.
Évaluation du modèle : Après l'entraînement, nous évaluons la performance du modèle sur les données de test et affichons la perte et la précision du modèle.

Sortie attendue :

Un message indiquant que l'entraînement a été arrêté tôt si la perte sur l'ensemble de validation n'a pas diminué après 3 epochs.
La perte et la précision du modèle sur l'ensemble de test.

Applications :

Prévention du sur-apprentissage : EarlyStopping est utilisé pour empêcher le sur-apprentissage, car il arrête l'entraînement lorsqu'une métrique de performance cesse de s'améliorer.
Optimisation du temps d'entraînement : Cela permet de gagner du temps en n'entraînant pas le modèle plus longtemps que nécessaire.
Amélioration de la généralisation : En évitant d'entraîner le modèle trop longtemps, il est moins probable que celui-ci s'ajuste trop aux spécificités des données d'entraînement et puisse mieux généraliser sur de nouvelles données.