Meisterhaftigkeit in der Gradient Boosting Regularisierung

Einführung

In diesem Lab lernst du, wie du verschiedene Regularisierungstrategien für Gradient Boosting mit scikit-learn implementierst. Regularisierung ist eine Technik, die hilft, Overfitting zu vermeiden, was ein häufiges Problem in Machine-Learning-Modellen ist. Wir werden die binomiale Devianzverlustfunktion und den make_hastie_10_2-Datensatz für dieses Lab verwenden.

VM-Tipps

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

Manchmal musst du einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn du bei der Lernphase Probleme hast, kannst du Labby gerne fragen. Gib nach der Sitzung Feedback, und wir werden das Problem für dich prompt beheben.

Bibliotheken importieren

Lassen Sie uns beginnen, indem wir die erforderlichen Bibliotheken importieren.

import numpy as np
import matplotlib.pyplot as plt

from sklearn import ensemble
from sklearn import datasets
from sklearn.metrics import log_loss
from sklearn.model_selection import train_test_split

Daten laden und aufteilen

Wir werden den make_hastie_10_2-Datensatz verwenden und ihn in Trainings- und Testsets aufteilen.

X, y = datasets.make_hastie_10_2(n_samples=4000, random_state=1)

## map labels from {-1, 1} to {0, 1}
labels, y = np.unique(y, return_inverse=True)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.8, random_state=0)

Parameter definieren

Wir werden die Parameter für unseren Gradient Boosting Classifier definieren. Wir werden die folgenden Parameter verwenden:

n_estimators: Anzahl der Boosting-Stufen, die ausgeführt werden sollen
max_leaf_nodes: maximale Anzahl von Blättern in jedem Baum
max_depth: maximale Tiefe des Baumes
random_state: Zufallszahl für Konsistenz
min_samples_split: minimale Anzahl von Proben, die erforderlich sind, um einen internen Knoten aufzuteilen

original_params = {
    "n_estimators": 400,
    "max_leaf_nodes": 4,
    "max_depth": None,
    "random_state": 2,
    "min_samples_split": 5,
}

Regularisierungstrategien implementieren

Wir werden nun verschiedene Regularisierungstrategien implementieren und deren Leistung vergleichen.

Keine Schrumpfung

Wir beginnen mit keiner Schrumpfung, was bedeutet, dass die Lernrate auf 1 gesetzt wird.

params = dict(original_params)
params.update({"learning_rate": 1.0, "subsample": 1.0})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Lernrate = 0,2

Als nächstes setzen wir die Lernrate auf 0,2 und das Subsample auf 1.

params = dict(original_params)
params.update({"learning_rate": 0.2, "subsample": 1.0})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Subsample = 0,5

Wir setzen nun das Subsample auf 0,5 und die Lernrate auf 1.

params = dict(original_params)
params.update({"learning_rate": 1.0, "subsample": 0.5})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Lernrate = 0,2 und Subsample = 0,5

Als nächstes setzen wir die Lernrate auf 0,2 und das Subsample auf 0,5.

params = dict(original_params)
params.update({"learning_rate": 0.2, "subsample": 0.5})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Lernrate = 0,2 und maximale Anzahl von Merkmalen = 2

Schließlich setzen wir die Lernrate auf 0,2 und verwenden nur 2 Merkmale für jeden Baum.

params = dict(original_params)
params.update({"learning_rate": 0.2, "max_features": 2})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Testset-Abweichung plotten

Wir werden nun die Testset-Abweichung für jede Regularisierungstrategie plotten.

plt.figure()

for label, color, setting in [
    ("Keine Schrumpfung", "orange", {"learning_rate": 1.0, "subsample": 1.0}),
    ("learning_rate=0,2", "turquoise", {"learning_rate": 0.2, "subsample": 1.0}),
    ("subsample=0,5", "blue", {"learning_rate": 1.0, "subsample": 0.5}),
    (
        "learning_rate=0,2, subsample=0,5",
        "gray",
        {"learning_rate": 0.2, "subsample": 0.5},
    ),
    (
        "learning_rate=0,2, max_features=2",
        "magenta",
        {"learning_rate": 0.2, "max_features": 2},
    ),
]:
    params = dict(original_params)
    params.update(setting)

    clf = ensemble.GradientBoostingClassifier(**params)
    clf.fit(X_train, y_train)

    ## berechne Testset-Abweichung
    test_deviance = np.zeros((params["n_estimators"],), dtype=np.float64)

    for i, y_proba in enumerate(clf.staged_predict_proba(X_test)):
        test_deviance[i] = 2 * log_loss(y_test, y_proba[:, 1])

    plt.plot(
        (np.arange(test_deviance.shape[0]) + 1)[::5],
        test_deviance[::5],
        "-",
        color=color,
        label=label,
    )

plt.legend(loc="upper right")
plt.xlabel("Boosting-Iterationen")
plt.ylabel("Testset-Abweichung")

plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man verschiedene Regularisierungstrategien für Gradient Boosting mit scikit-learn implementiert. Wir haben die binomiale Abweichungsverlustfunktion und den make_hastie_10_2-Datensatz verwendet. Wir haben verschiedene Regularisierungstrategien implementiert, wie z. B. keine Schrumpfung, Lernrate = 0,2, Subsample = 0,5 und maximale Anzahl von Merkmalen = 2. Schließlich haben wir die Testset-Abweichung für jede Regularisierungstrategie geplottet, um deren Leistung zu vergleichen.

Gradient Boosting Regularisierung