Arrêt précoce pour l'apprentissage automatique

Introduction

Dans ce projet, vous allez apprendre à implémenter la technique d'arrêt précoce dans les modèles d'apprentissage automatique. L'arrêt précoce est une méthode puissante pour éviter le surapprentissage et améliorer les performances de vos modèles.

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comprendre le concept d'arrêt précoce et ses principales étapes
• Implémenter la fonction d'arrêt précoce pour déterminer l'époque d'arrêt optimale
• Tester la fonction d'arrêt précoce sur un ensemble de données d'échantillonnage

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

• Diviser un ensemble de données en ensembles d'entraînement et de validation
• Surveiller les performances du modèle sur l'ensemble de validation pendant l'entraînement
• Définir un critère d'arrêt basé sur la perte de l'ensemble de validation
• Utiliser la fonction d'arrêt précoce pour optimiser le processus d'entraînement de votre modèle

Skills Graph

Comprendre le concept d'arrêt précoce et implémenter la fonction

Dans cette étape, vous allez d'abord apprendre sur le concept d'arrêt précoce et ses principales étapes.

L'idée de base derrière l'arrêt précoce est de calculer les performances du modèle sur un ensemble de validation pendant l'entraînement. Lorsque les performances du modèle sur l'ensemble de validation commencent à diminuer, l'entraînement est arrêté pour éviter le surapprentissage. Les principales étapes sont les suivantes :

1. Diviser l'ensemble de données d'entraînement original en un ensemble d'entraînement et un ensemble de validation.
2. Entraîner le modèle uniquement sur l'ensemble d'entraînement et calculer l'erreur du modèle sur l'ensemble de validation à la fin de chaque époque.
   3.Comparer l'erreur du modèle sur l'ensemble de validation avec l'historique d'entraînement. Arrêter l'entraînement lorsque la comparaison répond au critère d'arrêt.
3. Utiliser les paramètres de la dernière itération comme paramètres finaux pour le modèle.

Il existe de nombreux critères d'arrêt différents, et ils peuvent être assez flexibles. Un critère couramment utilisé est de surveiller la valeur de perte sur l'ensemble de validation. Lorsque la valeur de perte n'a pas été optimisée davantage pendant n'époques consécutives (toujours supérieure à la perte minimale), l'entraînement est arrêté.

Maintenant, vous allez implémenter la fonction early_stop dans le fichier early_stop.py.

La fonction vérifie les valeurs de perte époque par époque. Si la perte n'améliore pas (diminue) pendant un certain nombre d'époques égal à patience, il est recommandé d'arrêter l'entraînement.

Voici le code pour la fonction early_stop :

def early_stop(loss: List[float], patience: int) -> Tuple[int, float]:
    """
    Détermine l'époque à laquelle l'entraînement devrait s'arrêter en fonction des valeurs de perte fournies et de la patience.

    La fonction vérifie les valeurs de perte époque par époque. Si la perte n'améliore pas (diminue) pour un
    nombre d'époques égal à `patience`, il est recommandé d'arrêter l'entraînement.

    Paramètres :
    - loss (List[float]) : Une liste de valeurs de perte, généralement dans l'ordre dans lequel elles ont été enregistrées pendant l'entraînement.
    - patience (int) : Le nombre d'époques sans amélioration de la perte après lesquelles l'entraînement devrait être arrêté.

    Retourne :
    - Tuple[int, float] : Un tuple contenant deux valeurs :
        1. Le numéro d'époque à laquelle l'entraînement devrait être arrêté (indexé à partir de 1).
        2. La valeur de perte minimale enregistrée jusqu'à ce point.
    """

    min_loss = np.Inf
    max_patience = 0
    stop_epoch = 0
    for epoch, current_loss in enumerate(loss):
        if current_loss < min_loss:
            min_loss = current_loss
            stop_epoch = epoch
            max_patience = 0
        else:
            max_patience += 1
        if max_patience == patience:
            break
    stop_epoch += 1
    return stop_epoch, min_loss

Dans la fonction early_stop, vous implémentez la logique pour déterminer l'époque à laquelle l'entraînement devrait être arrêté en fonction des valeurs de perte fournies et du paramètre patience.

La fonction devrait retourner un tuple contenant deux valeurs :

1. Le numéro d'époque à laquelle l'entraînement devrait être arrêté (indexé à partir de 1).
2. La valeur de perte minimale enregistrée jusqu'à ce point.

Tester la fonction d'arrêt précoce

Dans cette étape, vous allez tester la fonction early_stop en exécutant le fichier early_stop.py.

Ajoutez le code suivant dans le fichier early_stop.py :

if __name__ == "__main__":
    loss = [
        1.11,
        1.01,
        0.99,
        0.89,
        0.77,
        0.69,
        0.57,
        0.44,
        0.51,
        0.43,
        0.55,
        0.61,
        0.77,
        0.89,
        0.78,
    ]
    patience = 3
    stop_epoch, min_loss = early_stop(loss, patience)
    print(f"{stop_epoch=}, {min_loss=}")

Ensuite, exécutez le script à partir du terminal :

python early_stop.py

La sortie devrait être :

stop_epoch = 10, loss = 0.43

Cela signifie que l'entraînement devrait être arrêté à l'époque 10, et que la valeur de perte minimale enregistrée jusqu'à ce point est de 0.43.

Félicitations! Vous avez réussi à implémenter la fonction d'arrêt précoce. Vous pouvez désormais utiliser cette fonction dans vos projets d'apprentissage automatique pour éviter le surapprentissage et améliorer les performances de vos modèles.

Sommaire

Félicitations! Vous avez terminé ce projet. Vous pouvez pratiquer plus de laboratoires dans LabEx pour améliorer vos compétences.