Plotten von Wald Iris

Einführung

In diesem Lab wird gezeigt, wie man die Entscheidungsflächen von Wäldern von randomisierten Bäumen auf dem Iris-Datensatz mit der scikit-learn-Bibliothek in Python darstellt. Der Iris-Datensatz ist ein häufig verwendeter Datensatz für Klassifizierungstasks. In diesem Lab werden wir die von einem Entscheidungsbaum-Klassifizierer, einem Random-Forest-Klassifizierer, einem Extra-Trees-Klassifizierer und einem AdaBoost-Klassifizierer gelernten Entscheidungsflächen vergleichen.

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.

Bibliotheken importieren

In diesem Schritt importieren wir die erforderlichen Bibliotheken, die zur Darstellung der Entscheidungsflächen auf dem Iris-Datensatz benötigt werden.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

from sklearn.datasets import load_iris
from sklearn.ensemble import (
    RandomForestClassifier,
    ExtraTreesClassifier,
    AdaBoostClassifier,
)
from sklearn.tree import DecisionTreeClassifier

Parameter definieren

In diesem Schritt definieren wir die Parameter, die zur Darstellung der Entscheidungsflächen auf dem Iris-Datensatz erforderlich sind.

## Parameters
n_classes = 3
n_estimators = 30
cmap = plt.cm.RdYlBu
plot_step = 0.02  ## feine Schrittweite für die Konturen der Entscheidungsfläche
plot_step_coarser = 0.5  ## Schrittweiten für grobe Klassifizierungsvorhersagen
RANDOM_SEED = 13  ## Fixieren des Zufallsziels bei jeder Iteration

Daten laden

In diesem Schritt laden wir den Iris-Datensatz.

## Load data
iris = load_iris()

Modelle definieren

In diesem Schritt definieren wir die Modelle, die zur Darstellung der Entscheidungsflächen auf dem Iris-Datensatz verwendet werden sollen.

models = [
    DecisionTreeClassifier(max_depth=None),
    RandomForestClassifier(n_estimators=n_estimators),
    ExtraTreesClassifier(n_estimators=n_estimators),
    AdaBoostClassifier(DecisionTreeClassifier(max_depth=3), n_estimators=n_estimators),
]

Entscheidungsflächen darstellen

In diesem Schritt werden wir die Entscheidungsflächen der definierten Modelle auf dem Iris-Datensatz darstellen.

plot_idx = 1

for pair in ([0, 1], [0, 2], [2, 3]):
    for model in models:
        ## Wir nehmen nur die zwei entsprechenden Merkmale
        X = iris.data[:, pair]
        y = iris.target

        ## Mischen
        idx = np.arange(X.shape[0])
        np.random.seed(RANDOM_SEED)
        np.random.shuffle(idx)
        X = X[idx]
        y = y[idx]

        ## Standardisieren
        mean = X.mean(axis=0)
        std = X.std(axis=0)
        X = (X - mean) / std

        ## Trainieren
        model.fit(X, y)

        scores = model.score(X, y)
        ## Erstellen Sie einen Titel für jede Spalte und die Konsole, indem Sie str() verwenden und
        ## abschneiden Sie nutzlose Teile der Zeichenfolge
        model_title = str(type(model)).split(".")[-1][:-2][: -len("Classifier")]

        model_details = model_title
        if hasattr(model, "estimators_"):
            model_details += " mit {} Schätzern".format(len(model.estimators_))
        print(model_details + " mit Merkmalen", pair, "hat einen Score von", scores)

        plt.subplot(3, 4, plot_idx)
        if plot_idx <= len(models):
            ## Fügen Sie einen Titel oben jeder Spalte hinzu
            plt.title(model_title, fontsize=9)

        ## Nun zeichnen Sie die Entscheidungsgrenze mit einem feinen Gitter als Eingabe für eine
        ## gefüllte Konturlinie
        x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
        y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
        xx, yy = np.meshgrid(
            np.arange(x_min, x_max, plot_step), np.arange(y_min, y_max, plot_step)
        )

        ## Zeichnen Sie entweder einen einzelnen DecisionTreeClassifier oder mischen Sie alpha
        ## die Entscheidungsflächen des Ensembles von Klassifizierern
        if isinstance(model, DecisionTreeClassifier):
            Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
            Z = Z.reshape(xx.shape)
            cs = plt.contourf(xx, yy, Z, cmap=cmap)
        else:
            ## Wählen Sie das Alpha-Mischlevel im Bezug auf die Anzahl
            ## der Schätzer
            ## die in Verwendung sind (beachten Sie, dass AdaBoost möglicherweise weniger Schätzer verwenden kann
            ## als sein Maximum, wenn es frühzeitig eine ausreichend gute Anpassung erreicht)
            estimator_alpha = 1.0 / len(model.estimators_)
            for tree in model.estimators_:
                Z = tree.predict(np.c_[xx.ravel(), yy.ravel()])
                Z = Z.reshape(xx.shape)
                cs = plt.contourf(xx, yy, Z, alpha=estimator_alpha, cmap=cmap)

        ## Erstellen Sie ein groberes Gitter, um eine Reihe von Ensemble-Klassifikationen zu zeichnen
        ## um zu zeigen, wie diese sich von dem unterscheiden, was wir in den Entscheidungsflächen sehen
        ## Flächen. Diese Punkte sind regelmäßig verteilt und haben keinen schwarzen Umriss
        xx_coarser, yy_coarser = np.meshgrid(
            np.arange(x_min, x_max, plot_step_coarser),
            np.arange(y_min, y_max, plot_step_coarser),
        )
        Z_points_coarser = model.predict(
            np.c_[xx_coarser.ravel(), yy_coarser.ravel()]
        ).reshape(xx_coarser.shape)
        cs_points = plt.scatter(
            xx_coarser,
            yy_coarser,
            s=15,
            c=Z_points_coarser,
            cmap=cmap,
            edgecolors="none",
        )

        ## Zeichnen Sie die Trainingspunkte, diese sind zusammengefasst und haben einen
        ## schwarzen Umriss
        plt.scatter(
            X[:, 0],
            X[:, 1],
            c=y,
            cmap=ListedColormap(["r", "y", "b"]),
            edgecolor="k",
            s=20,
        )
        plot_idx += 1  ## Gehen Sie zum nächsten Plot in der Sequenz über

plt.suptitle("Klassifizierer auf Merkmalsuntermengen des Iris-Datensatzes", fontsize=12)
plt.axis("tight")
plt.tight_layout(h_pad=0.2, w_pad=0.2, pad=2.5)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die Entscheidungsflächen von Wäldern von randomisierten Bäumen auf dem Iris-Datensatz mit der scikit-learn-Bibliothek in Python darstellt. Wir haben die Entscheidungsflächen eines DecisionTreeClassifier, eines RandomForestClassifier, eines ExtraTreesClassifier und eines AdaBoostClassifier verglichen. Wir haben auch gelernt, wie man Modelle definiert, Entscheidungsflächen darstellt und Daten in Python lädt.