Tracer la classification NCA

Introduction

Ce laboratoire montrera comment comparer la classification par plus proches voisins avec et sans Analyse des Composantes du Voisinage (NCA). Nous tracerons les limites de décision de classe données par un classifieur des plus proches voisins lorsqu'on utilise la distance euclidienne sur les caractéristiques d'origine, par rapport à l'utilisation de la distance euclidienne après la transformation apprise par l'Analyse des Composantes du Voisinage. Ce dernier vise à trouver une transformation linéaire qui maximise la précision de classification par plus proches voisins (stochastique) sur l'ensemble d'entraînement. Nous utiliserons le jeu de données Iris qui contient 3 classes de 50 instances chacune.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour la pratique.

Parfois, vous devrez attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites du carnet Jupyter.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous réglerons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

Nous commencerons par importer les bibliothèques nécessaires. Nous utiliserons scikit-learn pour effectuer la classification par plus proches voisins et l'analyse NCA. Nous utiliserons matplotlib pour tracer les limites de décision de classe.

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

Charger et préparer les données

Ensuite, nous allons charger et préparer les données. Nous chargerons le jeu de données Iris à l'aide de scikit-learn et ne sélectionnerons que deux caractéristiques. Nous diviserons ensuite les données en un ensemble d'entraînement et un ensemble de test.

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
)

Créer des cartes de couleurs

Nous allons maintenant créer des cartes de couleurs pour tracer les limites de décision de classe. Nous utiliserons des couleurs claires pour l'arrière-plan et des couleurs vives pour les couleurs des classes.

h = 0.05  ## pas dans la grille

## Créer des cartes de couleurs
cmap_light = ListedColormap(["#FFAAAA", "#AAFFAA", "#AAAAFF"])
cmap_bold = ListedColormap(["#FF0000", "#00FF00", "#0000FF"])

Définir des classifieurs

Nous allons définir deux classifieurs : l'un utilisant le KNN et l'autre utilisant l'NCA et le KNN. Nous utiliserons des pipelines pour mettre à l'échelle les données et appliquer les classifieurs.

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)),
        ]
    ),
]

Entraîner et tester les classifieurs

Nous allons maintenant entraîner et tester les classifieurs. Nous allons parcourir les classifieurs et les ajuster aux données d'entraînement. Nous tracerons ensuite les limites de décision de classe et calculerons le score sur les données de test.

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()

Sommaire

Dans ce laboratoire, nous avons comparé la classification par plus proches voisins avec et sans Analyse des Composantes du Voisinage (NCA en anglais). Nous avons utilisé le jeu de données Iris pour tracer les limites de décision de classe données par un classifieur de plus proches voisins lorsqu'on utilise la distance euclidienne sur les caractéristiques d'origine, par rapport à l'utilisation de la distance euclidienne après la transformation apprise par l'NCA. Nous avons utilisé scikit-learn pour effectuer la classification par plus proches voisins et l'NCA. Nous avons également utilisé matplotlib pour tracer les limites de décision de classe. Nous avons constaté que l'NCA a amélioré la précision de classification.