Nca-Klassifikation plotten

Einführung

In diesem Lab wird gezeigt, wie die Klassifizierung mit nächsten Nachbarn mit und ohne Neighborhood Components Analysis (NCA) verglichen werden kann. Wir werden die Klassifizierungsgrenzen, die von einem nächsten Nachbarn-Klassifizierer angegeben werden, bei der Verwendung der euklidischen Distanz auf den ursprünglichen Merkmalen und bei der Verwendung der euklidischen Distanz nach der durch Neighborhood Components Analysis gelernten Transformation, darstellen. Letzteres zielt darauf ab, eine lineare Transformation zu finden, die die (stochastische) Genauigkeit der nächsten-Nachbarn-Klassifizierung auf dem Trainingssatz maximiert. Wir werden den Iris-Datensatz verwenden, der 3 Klassen mit jeweils 50 Instanzen enthält.

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 nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von 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

Wir beginnen mit dem Import der erforderlichen Bibliotheken. Wir werden scikit-learn verwenden, um die Klassifizierung mit nächsten Nachbarn und NCA durchzuführen. Wir werden matplotlib verwenden, um die Klassifizierungsgrenzen zu plotten.

import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier, NeighborhoodComponentsAnalysis
from sklearn.pipeline import Pipeline
from sklearn.inspection import DecisionBoundaryDisplay

Daten laden und vorbereiten

Als nächstes laden und bereiten wir die Daten vor. Wir laden den Iris-Datensatz mit scikit-learn und wählen nur zwei Merkmale aus. Anschließend teilen wir die Daten in einen Trainingssatz und einen Testsatz auf.

n_neighbors = 1

dataset = datasets.load_iris()
X, y = dataset.data, dataset.target

## we only take two features. We could avoid this ugly
## slicing by using a two-dim dataset
X = X[:, [0, 2]]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, stratify=y, test_size=0.7, random_state=42
)

Farbskalen erstellen

Wir werden nun Farbskalen erstellen, um die Klassifizierungsgrenzen zu plotten. Wir werden helle Farben für den Hintergrund und fette Farben für die Klassenfarben verwenden.

h = 0.05  ## Schrittweite im Gitter

## Farbskalen erstellen
cmap_light = ListedColormap(["#FFAAAA", "#AAFFAA", "#AAAAFF"])
cmap_bold = ListedColormap(["#FF0000", "#00FF00", "#0000FF"])

Klassifizierer definieren

Wir werden zwei Klassifizierer definieren: Einen, der KNN verwendet, und einen anderen, der NCA und KNN verwendet. Wir werden Pipelines verwenden, um die Daten zu skalieren und die Klassifizierer anzuwenden.

names = ["KNN", "NCA, KNN"]

classifiers = [
    Pipeline(
        [
            ("scaler", StandardScaler()),
            ("knn", KNeighborsClassifier(n_neighbors=n_neighbors)),
        ]
    ),
    Pipeline(
        [
            ("scaler", StandardScaler()),
            ("nca", NeighborhoodComponentsAnalysis()),
            ("knn", KNeighborsClassifier(n_neighbors=n_neighbors)),
        ]
    ),
]

Klassifizierer trainieren und testen

Wir werden nun die Klassifizierer trainieren und testen. Wir werden über die Klassifizierer iterieren und sie auf die Trainingsdaten anpassen. Anschließend werden wir die Klassifizierungsgrenzen plotten und die Genauigkeit auf den Testdaten berechnen.

for name, clf in zip(names, classifiers):
    clf.fit(X_train, y_train)
    score = clf.score(X_test, y_test)

    _, ax = plt.subplots()
    DecisionBoundaryDisplay.from_estimator(
        clf,
        X,
        cmap=cmap_light,
        alpha=0.8,
        ax=ax,
        response_method="predict",
        plot_method="pcolormesh",
        shading="auto",
    )

    ## Plot also the training and testing points
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_bold, edgecolor="k", s=20)
    plt.title("{} (k = {})".format(name, n_neighbors))
    plt.text(
        0.9,
        0.1,
        "{:.2f}".format(score),
        size=15,
        ha="center",
        va="center",
        transform=plt.gca().transAxes,
    )

plt.show()

Zusammenfassung

In diesem Lab haben wir die Klassifikation mit den nächsten Nachbarn mit und ohne Neighborhood Components Analysis (NCA) verglichen. Wir haben den Iris-Datensatz verwendet, um die Klassifizierungsgrenzen zu plotten, die von einem Klassifizierer mit den nächsten Nachbarn gegeben werden, wenn der euklidische Abstand auf den ursprünglichen Merkmalen verwendet wird, im Vergleich zu der Verwendung des euklidischen Abstands nach der von NCA gelernten Transformation. Wir haben scikit-learn verwendet, um die Klassifikation mit den nächsten Nachbarn und NCA durchzuführen. Wir haben auch matplotlib verwendet, um die Klassifizierungsgrenzen zu plotten. Wir haben festgestellt, dass NCA die Klassifikationsgenauigkeit verbessert hat.