Classification des plus proches voisins

Introduction

Dans ce laboratoire, nous utiliserons l'algorithme de classification des plus proches voisins pour classifier des points de données dans un espace bidimensionnel. Nous utiliserons l'ensemble de données Iris, qui est un ensemble de données couramment utilisé en apprentissage automatique. Nous visualiserons les limites de décision pour chaque classe et observerons comment l'algorithme se comporte lorsqu'on utilise différents poids.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour passer à l'onglet Carnet de notes pour accéder au carnet Jupyter Notebook pour pratiquer.

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

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

Skills Graph

Importation des bibliothèques nécessaires

Nous commencerons par importer les bibliothèques nécessaires, qui incluent matplotlib, seaborn, ListedColormap, datasets, neighbors et DecisionBoundaryDisplay de sklearn.

import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.colors import ListedColormap
from sklearn import neighbors, datasets
from sklearn.inspection import DecisionBoundaryDisplay

Charger l'ensemble de données Iris

Nous chargerons ensuite l'ensemble de données Iris à l'aide de la fonction load_iris() du module datasets de sklearn.

iris = datasets.load_iris()

Préparer les données

Nous ne prendrons que les deux premières caractéristiques de l'ensemble de données Iris, qui sont la longueur du sépale et la largeur du sépale. Nous diviserons ensuite les données en matrice de caractéristiques X et vecteur cible y.

X = iris.data[:, :2]
y = iris.target

Définir les cartes de couleurs

Nous définirons les cartes de couleurs qui seront utilisées pour tracer les limites de décision et les points d'entraînement.

cmap_light = ListedColormap(["orange", "cyan", "cornflowerblue"])
cmap_bold = ["darkorange", "c", "darkblue"]

Visualiser les limites de décision

Nous allons parcourir deux valeurs différentes de poids, "uniforme" et "distance", et tracer les limites de décision pour chaque valeur de poids. Nous utiliserons la classe KNeighborsClassifier du module neighbors pour effectuer la classification.

n_neighbors = 15

for weights in ["uniform", "distance"]:
    ## créer une instance du classifieur Neighbours et ajuster les données
    clf = neighbors.KNeighborsClassifier(n_neighbors, weights=weights)
    clf.fit(X, y)

    ## tracer les limites de décision
    _, ax = plt.subplots()
    DecisionBoundaryDisplay.from_estimator(
        clf,
        X,
        cmap=cmap_light,
        ax=ax,
        response_method="predict",
        plot_method="pcolormesh",
        xlabel=iris.feature_names[0],
        ylabel=iris.feature_names[1],
        shading="auto",
    )

    ## tracer les points d'entraînement
    sns.scatterplot(
        x=X[:, 0],
        y=X[:, 1],
        hue=iris.target_names[y],
        palette=cmap_bold,
        alpha=1.0,
        edgecolor="black",
    )
    plt.title(
        "Classification à 3 classes (k = %i, poids = '%s')" % (n_neighbors, weights)
    )

plt.show()

Interpréter les résultats

Nous pouvons observer les limites de décision pour chaque valeur de poids et la performance de l'algorithme dans la classification des points de données. La valeur de poids "uniforme" suppose que tous les voisins ont le même poids, tandis que la valeur de poids "distance" attribue plus de poids aux voisins les plus proches. Nous pouvons voir que les limites de décision sont plus lisses avec la valeur de poids "distance", ce qui indique une classification plus précise.

Sommaire

Dans ce laboratoire, nous avons appris à utiliser l'algorithme de classification des plus proches voisins pour classifier des points de données dans un espace bidimensionnel. Nous avons utilisé l'ensemble de données Iris pour visualiser les limites de décision pour chaque classe et observer comment l'algorithme se comporte lorsqu'on utilise différentes valeurs de poids. Nous avons également appris à interpréter les résultats et avons observé que la valeur de poids "distance" donne de meilleurs résultats dans la classification des points de données.