Mehrklassen AdaBoost-Baummodelle

Einführung

In diesem Lab werden wir untersuchen, wie Boosting die Vorhersagegenauigkeit bei einem Mehrklassenproblem verbessern kann. Wir werden einen Datensatz verwenden, der durch die Verwendung einer zehn-dimensionalen Standardnormalverteilung konstruiert wurde, und drei Klassen definieren, die durch geschachtelte konzentrische zehn-dimensionale Sphären voneinander getrennt sind, sodass in jeder Klasse ungefähr die gleichen Anzahl von Proben vorhanden ist.

Wir werden die Leistung der SAMME- und SAMME.R-Algorithmen vergleichen. SAMME.R verwendet die Wahrscheinlichkeitsschätzungen, um das additive Modell zu aktualisieren, während SAMME nur die Klassifizierungen verwendet.

Tipps für die VM

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 öffnen.

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 während des Lernens 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

Importieren der erforderlichen Bibliotheken

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken, einschließlich make_gaussian_quantiles und accuracy_score aus sklearn.datasets, AdaBoostClassifier, DecisionTreeClassifier aus sklearn.ensemble und matplotlib.pyplot.

import matplotlib.pyplot as plt
from sklearn.datasets import make_gaussian_quantiles
from sklearn.ensemble import AdaBoostClassifier
from sklearn.metrics import accuracy_score
from sklearn.tree import DecisionTreeClassifier

Laden des Datensatzes

Wir werden die Funktion make_gaussian_quantiles aus sklearn.datasets verwenden, um einen Datensatz zu generieren. Diese Funktion erzeugt isotrope Gaussian-Verteilungen und fügt eine Trennung zwischen den Klassen hinzu, um das Problem schwieriger zu gestalten.

X, y = make_gaussian_quantiles(
    n_samples=13000, n_features=10, n_classes=3, random_state=1
)

Teilen des Datensatzes

Wir werden den Datensatz in Trainings- und Testsets aufteilen, wobei die ersten 3000 Proben zum Training und die verbleibenden Proben zum Testen verwendet werden.

n_split = 3000
X_train, X_test = X[:n_split], X[n_split:]
y_train, y_test = y[:n_split], y[n_split:]

Erstellen und Trainieren der Modelle

Wir werden zwei AdaBoost-Modelle erstellen, eines mit SAMME und das andere mit SAMME.R. Beide Modelle werden DecisionTreeClassifier mit einer maximalen Tiefe von 2 und 300 Schätzern verwenden.

bdt_real = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=2), n_estimators=300, learning_rate=1
)

bdt_discrete = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=2),
    n_estimators=300,
    learning_rate=1.5,
    algorithm="SAMME",
)

bdt_real.fit(X_train, y_train)
bdt_discrete.fit(X_train, y_train)

Testen der Modelle

Wir werden die Modelle testen und die Testfehler jedes Modells nach jeder Boosting-Iteration berechnen.

real_test_errors = []
discrete_test_errors = []

for real_test_predict, discrete_test_predict in zip(
    bdt_real.staged_predict(X_test), bdt_discrete.staged_predict(X_test)
):
    real_test_errors.append(1.0 - accuracy_score(real_test_predict, y_test))
    discrete_test_errors.append(1.0 - accuracy_score(discrete_test_predict, y_test))

Zeichnen der Ergebnisse

Wir werden die Testfehler, die Klassifikationsfehler und das Boost-Gewicht jedes Modells zeichnen.

n_trees_discrete = len(bdt_discrete)
n_trees_real = len(bdt_real)

## Boosting kann frühzeitig beendet werden, aber die folgenden Arrays sind immer
## n_estimators lang. Wir schneiden sie hier auf die tatsächliche Anzahl von Bäumen ab:
discrete_estimator_errors = bdt_discrete.estimator_errors_[:n_trees_discrete]
real_estimator_errors = bdt_real.estimator_errors_[:n_trees_real]
discrete_estimator_weights = bdt_discrete.estimator_weights_[:n_trees_discrete]

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

plt.subplot(131)
plt.plot(range(1, n_trees_discrete + 1), discrete_test_errors, c="black", label="SAMME")
plt.plot(
    range(1, n_trees_real + 1),
    real_test_errors,
    c="black",
    linestyle="dashed",
    label="SAMME.R",
)
plt.legend()
plt.ylim(0.18, 0.62)
plt.ylabel("Testfehler")
plt.xlabel("Anzahl der Bäume")

plt.subplot(132)
plt.plot(
    range(1, n_trees_discrete + 1),
    discrete_estimator_errors,
    "b",
    label="SAMME",
    alpha=0.5,
)
plt.plot(
    range(1, n_trees_real + 1), real_estimator_errors, "r", label="SAMME.R", alpha=0.5
)
plt.legend()
plt.ylabel("Fehler")
plt.xlabel("Anzahl der Bäume")
plt.ylim((0.2, max(real_estimator_errors.max(), discrete_estimator_errors.max()) * 1.2))
plt.xlim((-20, len(bdt_discrete) + 20))

plt.subplot(133)
plt.plot(range(1, n_trees_discrete + 1), discrete_estimator_weights, "b", label="SAMME")
plt.legend()
plt.ylabel("Gewicht")
plt.xlabel("Anzahl der Bäume")
plt.ylim((0, discrete_estimator_weights.max() * 1.2))
plt.xlim((-20, n_trees_discrete + 20))

## verhindert überlappende y-Achsenbeschriftungen
plt.subplots_adjust(wspace=0.25)
plt.show()

Zusammenfassung

In diesem Lab haben wir untersucht, wie das Boosting die Vorhersagegenauigkeit bei einem Mehrklassenproblem verbessern kann. Wir haben einen Datensatz verwendet, der durch die Verwendung einer zehn-dimensionalen Standardnormalverteilung konstruiert wurde, und drei Klassen definiert, die durch geschachtelte konzentrische zehn-dimensionale Sphären getrennt sind. Wir haben die Leistung der SAMME- und SAMME.R-Algorithmen verglichen und die Testfehler, die Klassifikationsfehler und das Boost-Gewicht jedes Modells geplottet. Die Ergebnisse zeigten, dass SAMME.R im Allgemeinen schneller konvergiert als SAMME und mit weniger Boosting-Iterationen einen niedrigeren Testfehler erzielt.