Machine à vecteurs de support

La machine à vecteurs de support (SVM) est un algorithme d'apprentissage supervisé principalement utilisé pour les problèmes de classification et de régression.

L'idée centrale du SVM est de trouver un hyperplan optimal qui sépare les données de différentes classes. Cet hyperplan doit non seulement classer correctement les données, mais aussi maximiser la marge entre les deux classes.

Hyperplan：

  • Dans un espace bidimensionnel, l'hyperplan est une droite.
  • Dans un espace tridimensionnel, l'hyperplan est un plan.
  • Dans un espace de dimension supérieure, l'hyperplan est un hyperplan qui divise l'espace.

Vecteurs de support：

  • Les vecteurs de support sont les points d'échantillon les plus proches de l'hyperplan. Ces vecteurs de support sont essentiels pour définir l'hyperplan.
  • Le SVM sélectionne l'hyperplan optimal en maximisant la distance entre les vecteurs de support et l'hyperplan (c'est-à-dire en maximisant la marge).

Marge maximale：

  • L'objectif du SVM est de maximiser la marge de classification, en gardant la frontière de décision aussi éloignée que possible des points de données des deux classes. Cela peut effectivement réduire l'erreur de généralisation du modèle.

Astuce du noyau：

  • Pour les données non linéairement séparables, SVM utilise des fonctions noyau pour projeter les données dans un espace de dimension supérieure, dans lequel les données peuvent être linéairement séparables.
  • Les fonctions noyau couramment utilisées comprennent : le noyau linéaire, le noyau polynomial, le noyau à base radiale (RBF), etc.

Processus de classification SVM

  1. Sélectionner un hyperplan: Trouver un hyperplan qui maximise la marge de classification.
  2. Entraîner les vecteurs de support: Grâce à l'algorithme SVM, sélectionner les points d'échantillon les plus proches de l'hyperplan comme vecteurs de support.
  3. Trouver l'hyperplan optimal en maximisant la marge: Sélectionner un hyperplan optimal qui maximise la marge.
  4. Utiliser des fonctions noyau pour traiter les problèmes non linéaires: Projeter les données dans un espace de grande dimension à l'aide de fonctions noyau pour résoudre les problèmes de séparabilité non linéaire.

Implémentation de SVM avec Python

Ensuite, nous utiliserons la bibliothèque de Pythonscikit-learnbibliothèque pour implémenter un classificateur SVM simple.

1. Installer les bibliothèques requises

Tout d'abord, assurez-vous d'avoir installé lascikit-learnbibliothèque. Si elle n'est pas installée, vous pouvez utiliser la commande suivante pour l'installer :

pip install scikit-learn

2. Importer les bibliothèques

Exemple

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

3. Charger le jeu de données

Nous allons utiliser lescikit-learnjeu de données Iris intégré.

Exemple

# Charger le jeu de données Iris
iris = datasets.load_iris()
X = iris.data[:, :2]  # Utiliser uniquement les deux premières caractéristiques
y = iris.target

4. Diviser les ensembles d'entraînement et de test

Exemple

# Diviser le jeu de données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

5. Entraîner le modèle SVM

Exemple

# Créer un classifieur SVM
clf = svm.SVC(kernel='linear')  # Utiliser la fonction noyau linéaire

# Entraîner le modèle
clf.fit(X_train, y_train)

6. Prédiction et évaluation

Exemple

# Faire des prédictions sur l'ensemble de test
y_pred = clf.predict(X_test)

# Calculer la précision
accuracy = accuracy_score(y_test, y_pred)
print(f"Exactitude du modèle : {accuracy:.2f}")

7. Visualiser les résultats

Exemple

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Charger le jeu de données Iris
iris = datasets.load_iris()
X = iris.data[:, :2]  # Utiliser uniquement les deux premières caractéristiques
y = iris.target

# Diviser le jeu de données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Créer un classifieur SVM
clf = svm.SVC(kernel='linear')  # Utiliser la fonction noyau linéaire

# Entraîner le modèle
clf.fit(X_train, y_train)

# Faire des prédictions sur l'ensemble de test
y_pred = clf.predict(X_test)

# Calculer la précision
accuracy = accuracy_score(y_test, y_pred)
print(f"Exactitude du modèle : {accuracy:.2f}")

# Tracer la frontière de décision
def plot_decision_boundary(X, y, model):
    h = .02  # Taille du pas de grille
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, alpha=0.8)
    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', marker='o')
    plt.xlabel('Longueur du sépale')
    plt.ylabel('Largeur du sépale')
    plt.title('Frontière de décision SVM')
    plt.show()

plot_decision_boundary(X_train, y_train, clf)

Exécutez le code ci-dessus, la sortie est :

模型准确率: 0.80

L'image s'affiche comme suit :

Autres extensions