AdaBoost Entscheidungsbaumstumpf-Klassifizierung

Einführung

Dies ist ein Schritt-für-Schritt-Labor, das zeigt, wie man AdaBoost verwendet, um einen Entscheidungsbaum zu trainieren und einen zweidimensionalen Datensatz aus zwei Gaussian Quantilen-Clustern zu klassifizieren.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine abgeschlossen ist, klicken Sie in der linken oberen 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 von 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

Importieren der erforderlichen Bibliotheken

In diesem Schritt importieren wir die erforderlichen Bibliotheken für dieses Labor.

import numpy as np
import matplotlib.pyplot as plt

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_gaussian_quantiles
from sklearn.inspection import DecisionBoundaryDisplay

Datensatz erstellen

In diesem Schritt erstellen wir einen nicht-linear trennbaren Klassifizierungsdatensatz, der aus zwei Gaussian Quantilen-Clustern besteht, mithilfe der Funktion make_gaussian_quantiles aus dem Modul sklearn.datasets. Wir verbinden auch die beiden Cluster und weisen ihnen Labels zu.

X1, y1 = make_gaussian_quantiles(
    cov=2.0, n_samples=200, n_features=2, n_classes=2, random_state=1
)
X2, y2 = make_gaussian_quantiles(
    mean=(3, 3), cov=1.5, n_samples=300, n_features=2, n_classes=2, random_state=1
)
X = np.concatenate((X1, X2))
y = np.concatenate((y1, -y2 + 1))

Erstellen und Anpassen eines AdaBoost-verstärkten Entscheidungsbaums

In diesem Schritt erstellen wir einen AdaBoost-verstärkten Entscheidungsbaum mithilfe der Klasse AdaBoostClassifier aus dem Modul sklearn.ensemble. Wir verwenden den Entscheidungsbaum als Basisestimator und setzen den Parameter max_depth auf 1. Wir setzen auch den Parameter algorithm auf "SAMME" und den Parameter n_estimators auf 200. Schließlich passen wir den Klassifizierer an den Datensatz an.

bdt = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=1), algorithm="SAMME", n_estimators=200
)

bdt.fit(X, y)

Die Entscheidungsgrenzen und die Trainingspunkte plotten

In diesem Schritt werden wir die Entscheidungsgrenzen und die Trainingspunkte plotten. Wir erstellen ein DecisionBoundaryDisplay-Objekt mithilfe der Methode from_estimator aus dem Modul sklearn.inspection und übergeben den AdaBoost-Klassifizierer, den Datensatz und andere Parameter. Wir plotten auch die Trainingspunkte mit unterschiedlichen Farben für jede Klasse.

plot_colors = "br"
plot_step = 0.02
class_names = "AB"

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

## Die Entscheidungsgrenzen plotten
ax = plt.subplot(121)
disp = DecisionBoundaryDisplay.from_estimator(
    bdt,
    X,
    cmap=plt.cm.Paired,
    response_method="predict",
    ax=ax,
    xlabel="x",
    ylabel="y",
)
x_min, x_max = disp.xx0.min(), disp.xx0.max()
y_min, y_max = disp.xx1.min(), disp.xx1.max()
plt.axis("tight")

## Die Trainingspunkte plotten
for i, n, c in zip(range(2), class_names, plot_colors):
    idx = np.where(y == i)
    plt.scatter(
        X[idx, 0],
        X[idx, 1],
        c=c,
        cmap=plt.cm.Paired,
        s=20,
        edgecolor="k",
        label="Klasse %s" % n,
    )
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.legend(loc="upper right")

plt.title("Entscheidungsgrenze")

Die Entscheidungs-Scores für die Zwei-Klassen-klassifizierung plotten

In diesem Schritt werden wir die Entscheidungs-Scores für die Zwei-Klassen-klassifizierung plotten. Wir verwenden die Methode decision_function des AdaBoost-Klassifizierers, um die Entscheidungs-Scores für jede Probe im Datensatz zu erhalten. Anschließend plotten wir die Histogramme der Entscheidungs-Scores für jede Klasse.

## Plot the two-class decision scores
twoclass_output = bdt.decision_function(X)
plot_range = (twoclass_output.min(), twoclass_output.max())
plt.subplot(122)
for i, n, c in zip(range(2), class_names, plot_colors):
    plt.hist(
        twoclass_output[y == i],
        bins=10,
        range=plot_range,
        facecolor=c,
        label="Klasse %s" % n,
        alpha=0.5,
        edgecolor="k",
    )
x1, x2, y1, y2 = plt.axis()
plt.axis((x1, x2, y1, y2 * 1.2))
plt.legend(loc="upper right")
plt.ylabel("Samples")
plt.xlabel("Score")
plt.title("Entscheidungs-Scores")

plt.tight_layout()
plt.subplots_adjust(wspace=0.35)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man AdaBoost verwendet, um einen Entscheidungsbaumstumpf zu trainieren und einen zweidimensionalen Datensatz, der aus zwei Gaussian Quantilen-Clustern besteht, zu klassifizieren. Wir haben auch gelernt, wie man die Entscheidungsgrenzen und die Entscheidungs-Scores des Klassifizierers plotten kann.