Explorer les paramètres du SVM linéaire

Introduction

Les Machines à Vecteurs de Support (SVM) sont utilisées pour l'analyse de classification et de régression. Les SVM trouvent la meilleure ligne ou hyperplan possible qui sépare les données en différentes classes. La ligne ou hyperplan qui maximise la distance entre les deux points de données les plus proches de classes différentes est appelée la marge. Dans ce laboratoire, nous allons explorer comment le paramètre C affecte la marge dans une SVM linéaire.

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 pour accéder au carnet Jupyter pour la pratique.

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.

Importation des bibliothèques

Nous commençons par importer les bibliothèques nécessaires, y compris numpy, matplotlib et scikit-learn.

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

Générer des données

Nous générons 40 points séparables à l'aide de la fonction random.randn de numpy. Les 20 premiers points ont une moyenne de [-2, -2] et les 20 suivants ont une moyenne de [2, 2]. Nous attribuons ensuite une étiquette de classe 0 aux 20 premiers points et une étiquette de classe 1 aux 20 suivants.

np.random.seed(0)
X = np.r_[np.random.randn(20, 2) - [2, 2], np.random.randn(20, 2) + [2, 2]]
Y = [0] * 20 + [1] * 20

Ajuster le modèle

Nous ajustons le modèle SVM à l'aide de la classe SVC de scikit-learn. Nous définissons le noyau sur linéaire et le paramètre de pénalité C sur 1 pour le cas non régularisé et 0,05 pour le cas régularisé. Nous calculons ensuite l'hyperplan de séparation à l'aide des coefficients et de l'intercept du modèle.

for name, penalty in (("unreg", 1), ("reg", 0.05)):
    clf = svm.SVC(kernel="linear", C=penalty)
    clf.fit(X, Y)

    w = clf.coef_[0]
    a = -w[0] / w[1]
    xx = np.linspace(-5, 5)
    yy = a * xx - (clf.intercept_[0]) / w[1]

Calculer les marges

Nous calculons les marges pour l'hyperplan de séparation. Nous calculons d'abord la distance de la marge à l'aide des coefficients du modèle. Nous calculons ensuite la distance verticale des vecteurs de support à l'hyperplan à l'aide de la pente de l'hyperplan. Enfin, nous traçons la ligne, les points et les vecteurs les plus proches du plan.

margin = 1 / np.sqrt(np.sum(clf.coef_**2))
yy_down = yy - np.sqrt(1 + a**2) * margin
yy_up = yy + np.sqrt(1 + a**2) * margin

plt.plot(xx, yy, "k-")
plt.plot(xx, yy_down, "k--")
plt.plot(xx, yy_up, "k--")

plt.scatter(
    clf.support_vectors_[:, 0],
    clf.support_vectors_[:, 1],
    s=80,
    facecolors="none",
    zorder=10,
    edgecolors="k",
    cmap=plt.get_cmap("RdBu"),
)
plt.scatter(
    X[:, 0], X[:, 1], c=Y, zorder=10, cmap=plt.get_cmap("RdBu"), edgecolors="k"
)

plt.axis("tight")
x_min = -4.8
x_max = 4.2
y_min = -6
y_max = 6

Tracer le contour

Nous traçons le contour de la fonction de décision. Nous créons d'abord une grille de maillage à l'aide des tableaux xx et yy. Nous redimensionnons ensuite la grille de maillage en un tableau 2D et appliquons la méthode decision_function de la classe SVC pour obtenir les valeurs prédites. Nous traçons ensuite le contour à l'aide de la méthode contourf.

YY, XX = np.meshgrid(yy, xx)
xy = np.vstack([XX.ravel(), YY.ravel()]).T
Z = clf.decision_function(xy).reshape(XX.shape)

plt.contourf(XX, YY, Z, cmap=plt.get_cmap("RdBu"), alpha=0.5, linestyles=["-"])

plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)

plt.xticks(())
plt.yticks(())

Afficher les graphiques

Nous affichons les graphiques pour les cas non régularisé et régularisé.

plt.show()

Sommaire

Dans ce laboratoire, nous avons exploré la manière dont le paramètre C affecte la marge dans un SVM linéaire. Nous avons généré des données, ajusté le modèle, calculé les marges et tracé les résultats. Nous avons ensuite affiché les graphiques pour les cas non régularisé et régularisé.