Classification binaire des fleurs Iris à l'aide de SVM

Introduction

Ce tutoriel vous guidera tout au long du processus d'utilisation de différents noyaux SVM pour la classification. Nous utiliserons le jeu de données Iris, qui contient des mesures de fleurs. Ce jeu de données a trois classes, mais nous n'en utiliserons que deux pour la classification binaire.

Conseils sur la machine virtuelle

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

Parfois, vous devrez peut-être 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 limitations 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.

Charger les données

Nous commencerons par charger le jeu de données Iris et en sélectionnant seulement les deux premières caractéristiques à des fins de visualisation.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets, svm

iris = datasets.load_iris()
X = iris.data
y = iris.target

X = X[y!= 0, :2]
y = y[y!= 0]

Préparer les données

Ensuite, nous allons préparer les données pour l'entraînement et les tests. Nous allons diviser les données en 90 % pour l'entraînement et 10 % pour les tests.

n_sample = len(X)

np.random.seed(0)
order = np.random.permutation(n_sample)
X = X[order]
y = y[order].astype(float)

X_train = X[: int(0.9 * n_sample)]
y_train = y[: int(0.9 * n_sample)]
X_test = X[int(0.9 * n_sample) :]
y_test = y[int(0.9 * n_sample) :]

Entraîner le modèle avec différents noyaux

Nous allons maintenant entraîner le modèle SVM en utilisant trois noyaux différents : linéaire, rbf et poly. Pour chaque noyau, nous allons ajuster le modèle aux données d'entraînement, tracer la frontière de décision et montrer la précision sur les données de test.

## ajuster le modèle
for kernel in ("linear", "rbf", "poly"):
    clf = svm.SVC(kernel=kernel, gamma=10)
    clf.fit(X_train, y_train)

    plt.figure()
    plt.clf()
    plt.scatter(
        X[:, 0], X[:, 1], c=y, zorder=10, cmap=plt.cm.Paired, edgecolor="k", s=20
    )

    ## Circuler les données de test
    plt.scatter(
        X_test[:, 0], X_test[:, 1], s=80, facecolors="none", zorder=10, edgecolor="k"
    )

    plt.axis("tight")
    x_min = X[:, 0].min()
    x_max = X[:, 0].max()
    y_min = X[:, 1].min()
    y_max = X[:, 1].max()

    XX, YY = np.mgrid[x_min:x_max:200j, y_min:y_max:200j]
    Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])

    ## Mettre le résultat dans un graphique en couleur
    Z = Z.reshape(XX.shape)
    plt.pcolormesh(XX, YY, Z > 0, cmap=plt.cm.Paired)
    plt.contour(
        XX,
        YY,
        Z,
        colors=["k", "k", "k"],
        linestyles=["--", "-", "--"],
        levels=[-0.5, 0, 0.5],
    )

    plt.title(kernel)
    plt.show()

    print(f"Précision avec le noyau {kernel} : {clf.score(X_test, y_test)}")

Interpréter les résultats

On peut voir que le noyau linéaire produit une frontière de décision linéaire, tandis que les noyaux rbf et poly produisent des frontières plus complexes. La précision sur les données de test est la plus élevée avec le noyau rbf, suivie du noyau poly puis du noyau linéaire.

Sommaire

Dans ce tutoriel, nous avons appris à utiliser différents noyaux SVM pour la classification. Nous avons entraîné un modèle SVM avec trois noyaux différents et visualisé les frontières de décision pour chacun d'entre eux. Nous avons également calculé la précision sur les données de test pour chaque noyau. Nous avons constaté que le noyau rbf a produit les meilleurs résultats pour le jeu de données Iris.