Diskreter vs. reeller AdaBoost

Einführung

In diesem Lab wird der Unterschied in der Leistung zwischen dem diskreten SAMME-Boosting-Algorithmus und dem realen SAMME.R-Boosting-Algorithmus demonstriert. Beide Algorithmen werden in einem binären Klassifizierungstask ausgewertet, wobei das Ziel Y eine nicht-lineare Funktion von 10 Eingabefeatures ist. Das Lab basiert auf Abbildung 10.2 aus Hastie et al 2009.

VM-Tipps

Nachdem die VM gestartet 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 der 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.

Skills Graph

Daten und Baselinemodelle vorbereiten

Wir beginnen mit der Erzeugung des binären Klassifizierungsdatensatzes, der in Hastie et al. 2009, Beispiel 10.2, verwendet wird. Anschließend legen wir die Hyperparameter für unsere AdaBoost-Klassifizierer fest. Wir teilen die Daten in einen Trainings- und einen Testsatz auf. Danach trainieren wir unsere Baselinemodelle, einen DecisionTreeClassifier mit depth=9 und einen "Stumpf" DecisionTreeClassifier mit depth=1, und berechnen den Testfehler.

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

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

n_estimators = 400
learning_rate = 1.0

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=2_000, shuffle=False
)

dt_stump = DecisionTreeClassifier(max_depth=1, min_samples_leaf=1)
dt_stump.fit(X_train, y_train)
dt_stump_err = 1.0 - dt_stump.score(X_test, y_test)

dt = DecisionTreeClassifier(max_depth=9, min_samples_leaf=1)
dt.fit(X_train, y_train)
dt_err = 1.0 - dt.score(X_test, y_test)

Adaboost mit diskreten SAMME und realen SAMME.R

Wir definieren jetzt die diskreten und realen AdaBoost-Klassifizierer und trainieren sie auf dem Trainingssatz.

from sklearn.ensemble import AdaBoostClassifier

ada_discrete = AdaBoostClassifier(
    estimator=dt_stump,
    learning_rate=learning_rate,
    n_estimators=n_estimators,
    algorithm="SAMME",
)
ada_discrete.fit(X_train, y_train)

ada_real = AdaBoostClassifier(
    estimator=dt_stump,
    learning_rate=learning_rate,
    n_estimators=n_estimators,
    algorithm="SAMME.R",
)
ada_real.fit(X_train, y_train)

Testfehler berechnen

Lassen Sie uns jetzt den Testfehler der diskreten und realen AdaBoost-Klassifizierer für jeden neuen Stumpf berechnen, der in n_estimators hinzugefügt wird, um das Ensemble zu bilden.

import numpy as np
from sklearn.metrics import zero_one_loss

ada_discrete_err = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_discrete.staged_predict(X_test)):
    ada_discrete_err[i] = zero_one_loss(y_pred, y_test)

ada_discrete_err_train = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_discrete.staged_predict(X_train)):
    ada_discrete_err_train[i] = zero_one_loss(y_pred, y_train)

ada_real_err = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_real.staged_predict(X_test)):
    ada_real_err[i] = zero_one_loss(y_pred, y_test)

ada_real_err_train = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_real.staged_predict(X_train)):
    ada_real_err_train[i] = zero_one_loss(y_pred, y_train)

Ergebnisse plotten

Schließlich plotten wir die Trainings- und Testfehler unserer Baselinemodelle sowie der diskreten und realen AdaBoost-Klassifizierer.

import matplotlib.pyplot as plt
import seaborn as sns

fig = plt.figure()
ax = fig.add_subplot(111)

ax.plot([1, n_estimators], [dt_stump_err] * 2, "k-", label="Decision Stump Error")
ax.plot([1, n_estimators], [dt_err] * 2, "k--", label="Decision Tree Error")

colors = sns.color_palette("colorblind")

ax.plot(
    np.arange(n_estimators) + 1,
    ada_discrete_err,
    label="Discrete AdaBoost Test Error",
    color=colors[0],
)
ax.plot(
    np.arange(n_estimators) + 1,
    ada_discrete_err_train,
    label="Discrete AdaBoost Train Error",
    color=colors[1],
)
ax.plot(
    np.arange(n_estimators) + 1,
    ada_real_err,
    label="Real AdaBoost Test Error",
    color=colors[2],
)
ax.plot(
    np.arange(n_estimators) + 1,
    ada_real_err_train,
    label="Real AdaBoost Train Error",
    color=colors[4],
)

ax.set_ylim((0.0, 0.5))
ax.set_xlabel("Number of weak learners")
ax.set_ylabel("error rate")

leg = ax.legend(loc="upper right", fancybox=True)
leg.get_frame().set_alpha(0.7)

plt.show()

Zusammenfassung

In diesem Lab haben wir den Unterschied in der Leistung zwischen dem diskreten SAMME-Boosting-Algorithmus und dem realen SAMME.R-Boosting-Algorithmus demonstriert. Wir haben festgestellt, dass die Fehlerrate sowohl für den Trainings- als auch für den Testsatz des realen AdaBoost niedriger ist als die des diskreten AdaBoost.