Früher Stopp für Machine Learning

Einführung

In diesem Projekt lernst du, wie du die Technik des frühen Stoppens in Machine-Learning-Modellen implementierst. Early Stopping ist eine leistungsstarke Methode, um Overfitting zu vermeiden und die Leistung deiner Modelle zu verbessern.

🎯 Aufgaben

In diesem Projekt wirst du lernen:

• Verstehen den Begriff des frühen Stoppens und seine Hauptschritte
• Implementiere die Funktion für den frühen Stopp, um die optimale Stopp-Epoche zu bestimmen
• Teste die Funktion für den frühen Stopp auf einem Beispiel-Datensatz

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

• Ein Datensatz in Trainings- und Validierungssätze aufzuteilen
• Die Leistung des Modells auf dem Validierungssatz während des Trainings zu überwachen
• Ein Stoppkriterium basierend auf der Validierungsmenge-Verlust zu definieren
• Die Funktion für den frühen Stopp verwenden, um den Trainingsvorgang deines Modells zu optimieren

Verstehen den Begriff des frühen Stoppens und Implementieren die Funktion

In diesem Schritt wirst du zunächst über den Begriff des frühen Stoppens und seine Hauptschritte lernen.

Die Grundidee hinter dem frühen Stoppen besteht darin, die Leistung des Modells auf einem Validierungssatz während des Trainings zu berechnen. Wenn die Leistung des Modells auf dem Validierungssatz beginnt zu sinken, wird das Training gestoppt, um Overfitting zu vermeiden. Die Hauptschritte lauten wie folgt:

1. Teile den ursprünglichen Trainingsdatensatz in einen Trainingssatz und einen Validierungssatz auf.
2. Trainiere das Modell nur auf dem Trainingssatz und berechne den Fehler des Modells auf dem Validierungssatz am Ende jeder Epoche.
3. Vergleiche den Fehler des Modells auf dem Validierungssatz mit der Trainingsgeschichte. Stoppe das Training, wenn die Vergleichung das Stoppkriterium erfüllt.
4. Verwende die Parameter aus der letzten Iteration als Endparameter für das Modell.

Es gibt viele verschiedene Stoppkriterien, und sie können ziemlich flexibel sein. Ein häufig verwendetes Kriterium ist es, den Verlustwert auf dem Validierungssatz zu überwachen. Wenn der Verlustwert für n aufeinanderfolgende Epochen nicht weiter optimiert wurde (immer größer als min Verlust), wird das Training gestoppt.

Jetzt wirst du die early_stop-Funktion in der Datei early_stop.py implementieren.

Die Funktion prüft die Verlustwerte von Epoche zu Epoche. Wenn der Verlust für eine Anzahl von Epochen gleich patience nicht verbessert (abnimmt), wird empfohlen, das Training zu stoppen.

Hier ist der Code für die early_stop-Funktion:

def early_stop(loss: List[float], patience: int) -> Tuple[int, float]:
    """
    Bestimmt die Epoche, an der das Training gestoppt werden sollte, basierend auf den bereitgestellten Verlustwerten und der Geduld.

    Die Funktion prüft die Verlustwerte von Epoche zu Epoche. Wenn der Verlust für eine
    Anzahl von Epochen gleich `patience` nicht verbessert (abnimmt), wird empfohlen, das Training zu stoppen.

    Parameter:
    - loss (List[float]): Eine Liste von Verlustwerten, typischerweise in der Reihenfolge, in der sie während des Trainings aufgezeichnet wurden.
    - patience (int): Die Anzahl der Epochen ohne Verbesserung des Verlusts, nach denen das Training gestoppt werden sollte.

    Rückgabe:
    - Tuple[int, float]: Ein Tupel, das zwei Werte enthält:
        1. Die Epochennummer, an der das Training gestoppt werden sollte (1-basiert).
        2. Der minimale Verlustwert, der bis zu diesem Zeitpunkt aufgezeichnet wurde.
    """

    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

In der early_stop-Funktion implementierst du die Logik, um die Epoche zu bestimmen, an der das Training gestoppt werden sollte, basierend auf den bereitgestellten Verlustwerten und dem patience-Parameter.

Die Funktion sollte ein Tupel zurückgeben, das zwei Werte enthält:

1. Die Epochennummer, an der das Training gestoppt werden sollte (1-basiert).
2. Der minimale Verlustwert, der bis zu diesem Zeitpunkt aufgezeichnet wurde.

Teste die Funktion für den frühen Stopp

In diesem Schritt wirst du die early_stop-Funktion testen, indem du die Datei early_stop.py ausführst.

Füge den folgenden Code in die Datei early_stop.py hinzu:

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=}")

Dann führe das Skript aus der Kommandozeile aus:

python early_stop.py

Die Ausgabe sollte lauten:

stop_epoch = 10, loss = 0.43

Dies bedeutet, dass das Training in der 10. Epoche gestoppt werden sollte und der bis zu diesem Zeitpunkt aufgezeichnete minimale Verlustwert 0.43 beträgt.

Herzlichen Glückwunsch! Du hast die Funktion für den frühen Stopp erfolgreich implementiert. Du kannst jetzt diese Funktion in deinen Machine-Learning-Projekten verwenden, um Overfitting zu vermeiden und die Leistung deiner Modelle zu verbessern.

Zusammenfassung

Herzlichen Glückwunsch! Du hast dieses Projekt abgeschlossen. Du kannst in LabEx weitere Labs absolvieren, um deine Fähigkeiten zu verbessern.