Early Stopping von Gradient Boosting

Einführung

Gradient Boosting ist eine Ensemble-Technik, bei der mehrere schwache Lerner (Regressionsbäume) iterativ kombiniert werden, um ein leistungsstarkes Einzelmodell zu erzeugen. Der Early-Stopping-Support in Gradient Boosting ermöglicht es uns, die geringste Anzahl an Iterationen zu finden, die ausreichen, um ein Modell zu erstellen, das gut auf unbekannte Daten generalisiert.

VM-Tipps

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Laden der erforderlichen Bibliotheken und Daten

Zunächst müssen wir die erforderlichen Bibliotheken und Daten laden. Wir werden die scikit-learn-Bibliothek für die Implementierung von Gradient Boosting verwenden.

import time
import numpy as np
import matplotlib.pyplot as plt
from sklearn import ensemble
from sklearn import datasets
from sklearn.model_selection import train_test_split

data_list = [
    datasets.load_iris(return_X_y=True),
    datasets.make_classification(n_samples=800, random_state=0),
    datasets.make_hastie_10_2(n_samples=2000, random_state=0),
]
names = ["Iris Data", "Classification Data", "Hastie Data"]
n_estimators = 200

Daten vorbereiten

Als nächstes werden wir die Daten vorbereiten, indem wir sie in Trainings- und Testsets unterteilen.

for X, y in data_list:
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=0
    )

Modell erstellen und trainieren ohne Early Stopping

Wir werden nun ein Gradient Boosting-Modell erstellen und trainieren, ohne Early Stopping einzusetzen.

gb = ensemble.GradientBoostingClassifier(n_estimators=n_estimators, random_state=0)
start = time.time()
gb.fit(X_train, y_train)
time_gb.append(time.time() - start)

Modell erstellen und trainieren mit Early Stopping

Wir werden nun ein Gradient Boosting-Modell mit Early Stopping erstellen und trainieren. Wir geben einen validation_fraction an, der den Anteil des gesamten Datensatzes angibt, der von der Trainingsphase abgesondert wird, um die Validierungsverlustfunktion des Modells zu bewerten. Das Gradient Boosting-Modell wird mit dem Trainingssatz trainiert und mit dem Validierungssatz ausgewertet. Wenn jeder zusätzliche Stufe des Regressionsbaums hinzugefügt wird, wird der Validierungssatz verwendet, um das Modell zu bewerten. Dies wird fortgesetzt, bis die Bewertungen des Modells in den letzten n_iter_no_change Stufen um mindestens tol nicht mehr verbessern. Danach wird angenommen, dass das Modell konvergiert ist und die weitere Hinzufügung von Stufen wird "frühzeitig gestoppt". Die Anzahl der Stufen des endgültigen Modells ist über das Attribut n_estimators verfügbar.

gbes = ensemble.GradientBoostingClassifier(
        n_estimators=n_estimators,
        validation_fraction=0.2,
        n_iter_no_change=5,
        tol=0.01,
        random_state=0,
    )
start = time.time()
gbes.fit(X_train, y_train)
time_gbes.append(time.time() - start)

Vergleiche die Scores mit und ohne Early Stopping

Wir werden nun die Scores der beiden Modelle vergleichen.

score_gb.append(gb.score(X_test, y_test))
score_gbes.append(gbes.score(X_test, y_test))

Vergleiche die Anpassungszeiten mit und ohne Early Stopping

Wir werden nun die Anpassungszeiten der beiden Modelle vergleichen.

plt.figure(figsize=(9, 5))

bar1 = plt.bar(
    index, time_gb, bar_width, label="Ohne Early Stopping", color="crimson"
)
bar2 = plt.bar(
    index + bar_width, time_gbes, bar_width, label="Mit Early Stopping", color="coral"
)

max_y = np.amax(np.maximum(time_gb, time_gbes))

plt.xticks(index + bar_width, names)
plt.yticks(np.linspace(0, 1.3 * max_y, 13))

autolabel(bar1, n_gb)
autolabel(bar2, n_gbes)

plt.ylim([0, 1.3 * max_y])
plt.legend(loc="best")
plt.grid(True)

plt.xlabel("Datensätze")
plt.ylabel("Anpassungszeit")

plt.show()

Vergleiche die Scores mit und ohne Early Stopping

Wir werden nun die Scores der beiden Modelle vergleichen.

plt.figure(figsize=(9, 5))

bar1 = plt.bar(
    index, score_gb, bar_width, label="Ohne Early Stopping", color="crimson"
)
bar2 = plt.bar(
    index + bar_width, score_gbes, bar_width, label="Mit Early Stopping", color="coral"
)

plt.xticks(index + bar_width, names)
plt.yticks(np.arange(0, 1.3, 0.1))

autolabel(bar1, n_gb)
autolabel(bar2, n_gbes)

plt.ylim([0, 1.3])
plt.legend(loc="best")
plt.grid(True)

plt.xlabel("Datensätze")
plt.ylabel("Testscore")

plt.show()

Zusammenfassung

In diesem Lab haben wir uns mit Early Stopping in Gradient Boosting beschäftigt, was uns ermöglicht, die geringste Anzahl an Iterationen zu finden, die ausreichen, um ein Modell zu erstellen, das gut auf unbekannte Daten generalisiert. Wir haben die Leistung eines Gradient Boosting-Modells mit und ohne Early Stopping verglichen und festgestellt, dass Early Stopping die Trainingszeit, den Arbeitsspeicherbedarf und die Vorhersageverzögerung erheblich reduzieren kann.