Classification SVM

Découvrez comment mettre en œuvre les SVM pour la classification de données en utilisant Python 🐍

Introduction aux Support Vector Machines (SVM)

Les Support Vector Machines (SVM) sont des algorithmes de classification supervisée très puissants utilisés dans la data science et le machine learning. Ils sont capables de gérer des problèmes de classification linéaires et non linéaires en haute dimension. Inventés par Vladimir Vapnik en 1963, les SVM sont devenus populaires grâce à leur capacité à généraliser bien au-delà des ensembles de données d'entraînement.

Qu'est-ce que les Support Vector Machines?

Les SVM sont basés sur le concept de maximisation de la marge. Pour une tâche de classification binaire, l'objectif est de trouver un hyperplan qui sépare les points de deux classes distinctes avec la plus grande marge possible. La marge est définie comme la distance entre l'hyperplan et les points de données les plus proches des deux classes, appelés vecteurs de support.

Classification Linéaire avec SVM

Pour une classification linéaire, un hyperplan en dimension 2 peut être représenté par une droite.

Exemple de code en Python

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

# Chargement d'un jeu de données iris
iris = datasets.load_iris()
X = iris.data[:, :2]  # Nous n'utilisons que deux caractéristiques pour simplifier
y = iris.target

# Division des données en ensembles de formation et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Création du modèle SVM linéaire
svc_model = SVC(kernel='linear')

# Entraînement du modèle
svc_model.fit(X_train, y_train)

Ce code crée et entraîne un modèle SVM linéaire sur le jeu de données Iris. Nous utilisons seulement deux caractéristiques pour mieux visualiser l'hyperplan séparateur.

Classification Non-Linéaire avec SVM

Quand les données ne peuvent être séparées linéairement, les SVM utilisent une méthode appelée le "noyau" pour transformer les données dans un espace de dimension supérieure où elles deviennent linéairement séparables. Quelques noyaux couramment utilisés sont le noyau polynomial, le noyau gaussien (RBF), et le noyau sigmoïdal.

Exemple de code en Python pour un noyau RBF

# Création du modèle SVM avec noyau gaussien (RBF)
svc_model_rbf = SVC(kernel='rbf')

# Entraînement du modèle
svc_model_rbf.fit(X_train, y_train)

Avantages des SVM

  1. Efficacité: Fonctionne bien dans des espaces de dimension élevée.
  2. Capacité de généralisation: Robuste contre le surajustement, surtout en présence d'un grand nombre de caractéristiques.
  3. Flexibilité: Peut être utilisé pour la classification et la régression en ajustant les hyperparamètres.

Inconvénients des SVM

  1. Complexité: L'entraînement peut être lent sur de grands ensembles de données.
  2. Dépendance au choix du noyau: La performance peut fortement varier en fonction du noyau et des paramètres choisis.

Les Support Vector Machines sont donc une méthode de classification robuste et flexible. Ils jouent un rôle crucial dans diverses applications de data science, allant de la reconnaissance d'images à la bioinformatique.

Dans l'étape suivante, nous aborderons le prétraitement des données, une étape cruciale avant l'entraînement de tout modèle SVM.


Prétraitement des Données

Le prétraitement des données est une étape cruciale dans toute tâche de machine learning, y compris lorsqu'on utilise des Support Vector Machines (SVM). Cette étape permet de préparer les données de manière à optimiser les performances du modèle, tout en réduisant les risques de surajustement et d'erreurs de classification.

Pourquoi le Prétraitement est-il Important ?

  1. Qualité des données: Des données mal préparées peuvent contenir des valeurs manquantes, des outliers ou des inconsistances.
  2. Normalisation: Les SVM sont sensibles aux échelles des caractéristiques. Il est donc souvent nécessaire de normaliser ou standardiser les données.
  3. Réduction de la dimension: L'élimination de caractéristiques non pertinentes peut améliorer les performances et réduire le temps de calcul.

Etapes du Prétraitement des Données

1. Nettoyage des Données

Le nettoyage des données est la première étape du prétraitement. Il s'agit de détecter et corriger (ou supprimer) les données corrompues ou incomplètes.

Voici un exemple en Python pour identifier et traiter les valeurs manquantes:

import pandas as pd
import numpy as np

# Chargement des données
df = pd.read_csv('votre_fichier.csv')

# Détection des valeurs manquantes
missing_values = df.isnull().sum()

# Imputation des valeurs manquantes avec la moyenne des colonnes
df.fillna(df.mean(), inplace=True)

2. Encodage des Variables Catégorielles

De nombreux jeux de données incluent des variables catégorielles qui doivent être converties en valeurs numériques avant d'être utilisées avec des SVM.

Exemple en Python avec la méthode pd.get_dummies de pandas:

# Encodage des variables catégorielles
df_encoded = pd.get_dummies(df, drop_first=True)

3. Normalisation et Standardisation

La normalisation et la standardisation permettent de s'assurer que les caractéristiques sont sur une même échelle. La normalisation met les valeurs dans un intervalle [0, 1], tandis que la standardisation les ramène à une distribution normale avec une moyenne de 0 et un écart-type de 1.

Exemple en Python utilisant StandardScaler de Sklearn:

from sklearn.preprocessing import StandardScaler

# Initialisation du standard scaler
scaler = StandardScaler()

# Application du scaler sur les données
X_scaled = scaler.fit_transform(df_encoded)

4. Réduction de la Dimensionnalité

Réduire le nombre de dimensions peut aider à diminuer la complexité de calcul et améliorer la performance du modèle. Une méthode courante est l'Analyse en Composantes Principales (PCA).

Exemple en Python utilisant PCA de Sklearn:

from sklearn.decomposition import PCA

# Initialisation du PCA
pca = PCA(n_components=2)

# Application du PCA sur les données normalisées
X_pca = pca.fit_transform(X_scaled)

Préparation des Données d'Entraînement et de Test

Enfin, il est important de diviser les données en ensembles d'entraînement et de test pour évaluer les performances du modèle de manière impartiale.

Exemple en Python avec train_test_split de Sklearn:

from sklearn.model_selection import train_test_split

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

Visualisation des Données Prétraitées

Avant de passer au modèle SVM, il est souvent utile de visualiser les données prétraitées pour s'assurer qu'elles sont correctement préparées.

Exemple de visualisation en Python avec matplotlib:

import matplotlib.pyplot as plt

# Visualisation des deux premières composantes principales
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis')
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.title('Visualisation des Données après PCA')
plt.show()

Le prétraitement des données est une étape essentielle qui influence grandement la performance des SVM. Assurez-vous de suivre ces étapes pour préparer vos données de manière optimale avant de passer à l'étape suivante: l'entraînement du modèle SVM.


Entraînement du modèle SVM

Une fois les données prétraitées, l'étape suivante consiste à entraîner le modèle Support Vector Machine (SVM). Le processus d'entraînement implique l'ajustement des paramètres du modèle pour minimiser les erreurs de classification sur l'ensemble d'entraînement. Dans cette section, nous explorerons comment créer, entraîner et comprendre les modèles SVM en utilisant des exemples de code en Python.

Création et Initialisation du Modèle SVM

La bibliothèque scikit-learn fournit une interface simple pour créer et entraîner des modèles SVM. Les principales options de noyau sont linéaire, polynomial, radial basis function (RBF), et sigmoïdal.

Exemple de création d'un modèle SVM linéaire:

from sklearn.svm import SVC

# Initialisation du modèle SVM avec noyau linéaire
svc_model_linear = SVC(kernel='linear')

Entraînement du Modèle

L'entraînement d'un modèle SVM se fait en ajustant les paramètres à partir de l'ensemble de données d'entraînement que nous avons préparé. La méthode fit de l'objet SVM de scikit-learn s'occupe de cet ajustement.

# Entraînement du modèle SVM linéaire
svc_model_linear.fit(X_train, y_train)

Pour un modèle non-linéaire avec noyau RBF:

# Initialisation du modèle SVM avec noyau gaussien (RBF)
svc_model_rbf = SVC(kernel='rbf')

# Entraînement du modèle SVM RBF
svc_model_rbf.fit(X_train, y_train)

Compréhension des Paramètres

  1. C (Regularization Parameter): Ce paramètre contrôle le compromis entre maximiser la marge et minimiser l'erreur de classification. Une petite valeur de C donne lieu à une marge plus large et peut tolérer plus de points mal classifiés, tandis qu'une grande valeur de C essaie de classer chaque point correctement.

  2. Gamma: Pertinent pour les noyaux non linéaires comme RBF. Il définit l'influence d'un seul exemple d'entraînement. Bas gamma signifie une large influence, haut gamma signifie une influence réduite.

Exemple: Entraînement d'un Modèle SVM avec différents noyaux

# Modèle linéaire
svc_linear = SVC(kernel='linear', C=1.0)
svc_linear.fit(X_train, y_train)

# Modèle avec noyau RBF
svc_rbf = SVC(kernel='rbf', gamma=0.5, C=1.0)
svc_rbf.fit(X_train, y_train)

# Modèle avec noyau polynomial
svc_poly = SVC(kernel='poly', degree=3, C=1.0)
svc_poly.fit(X_train, y_train)

Visualisation du Modèle

Une fois le modèle entraîné, il est souvent utile de visualiser la frontière de décision. Pour des jeux de données bidimensionnels, cela peut être fait en utilisant matplotlib.

import numpy as np
import matplotlib.pyplot as plt

# Création de la grille pour visualiser les frontières de décision
h = .02  # Etape de la grille
x_min, x_max = X_train[:, 0].min() - 1, X_train[:, 0].max() + 1
y_min, y_max = X_train[:, 1].min() - 1, X_train[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

# Prédictions du modèle SVM linéaire
Z = svc_model_linear.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Visualisation
plt.contourf(xx, yy, Z, alpha=0.8)
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolors='k', marker='o')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Frontière de Décision du Modèle SVM Linéaire')
plt.show()

Entraînement en utilisant GridSearchCV

GridSearchCV de scikit-learn peut être utilisé pour trouver les meilleures combinaisons d'hyperparamètres. Cela effectuera une recherche exhaustive sur un ensemble de valeurs spécifiées de paramètres.

from sklearn.model_selection import GridSearchCV

# Définir la grille des paramètres
param_grid = {'C': [0.1, 1, 10, 100], 'gamma': [1, 0.1, 0.01, 0.001], 'kernel': ['rbf']}

# Initialisation du GridSearchCV
grid = GridSearchCV(SVC(), param_grid, refit=True, verbose=2)

# Entraînement de GridSearchCV
grid.fit(X_train, y_train)

# Affichage des paramètres optimaux
print("Meilleurs paramètres trouvés : ", grid.best_params_)

En suivant ces étapes, vous pouvez entraîner efficacement un modèle SVM sur vos données. Dans la section suivante, nous aborderons l'évaluation des performances du modèle entraîné.


Évaluation des performances du modèle

Évaluer les performances d'un modèle Support Vector Machine (SVM) est une étape cruciale pour comprendre comment le modèle se comporte face à des données inédites. Cette étape permet de vérifier si le modèle est bien ajusté et s’il généralisera correctement. Dans cette section, nous allons passer en revue diverses techniques d'évaluation des modèles SVM, y compris les métriques de performance, la validation croisée et les courbes ROC.

Séparation des Données

Avant d'évaluer un modèle, il est essentiel de séparer les données en ensembles d’entraînement et de test. Cette étape garantit que l'évaluation reflète le comportement du modèle avec des données inédites.

Exemple de code en Python :

from sklearn.model_selection import train_test_split

# Division des données prétraitées en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.3, random_state=42)

Prédiction sur l'ensemble de test

Après avoir entraîné le modèle SVM, nous utilisons cet ensemble de test pour faire des prédictions.

# Prédiction sur l'ensemble de test
y_pred = svc_model_linear.predict(X_test)

Métriques de Performance

1. Matrice de Confusion

La matrice de confusion est une méthode d'évaluation qui permet de visualiser la performance du modèle en comparant les valeurs réelles et les valeurs prédites.

from sklearn.metrics import confusion_matrix

# Calcul de la matrice de confusion
conf_matrix = confusion_matrix(y_test, y_pred)
print('Matrice de Confusion:\n', conf_matrix)

2. Précision, Rappel et F1-Score

Ces métriques offrent une vue plus détaillée sur les performances du modèle:

  • Précision: Proportion de vraies prédictions positives parmi toutes les prédictions positives.
  • Rappel: Proportion de vraies prédictions positives parmi toutes les véritables instances positives.
  • F1-Score: Moyenne harmonique de la précision et du rappel.
from sklearn.metrics import classification_report

# Rapport de classification
class_report = classification_report(y_test, y_pred)
print('Rapport de Classification:\n', class_report)

3. Exactitude (Accuracy)

L’exactitude est la proportion de vraies prédictions correctes parmi l'ensemble des prédictions.

from sklearn.metrics import accuracy_score

# Calcul de l'exactitude
accuracy = accuracy_score(y_test, y_pred)
print('Exactitude: {:.2f}%'.format(accuracy * 100))

Validation Croisée

La validation croisée est une technique avancée pour évaluer un modèle. Elle permet de s'assurer que le modèle généralise bien en utilisant plusieurs partitions des données.

Exemple en Python:

from sklearn.model_selection import cross_val_score

# Validation croisée sur 5 plis
cross_val_scores = cross_val_score(svc_model_linear, X, y, cv=5)

print('Scores de Validation Croisée:', cross_val_scores)
print('Moyenne des Scores de Validation Croisée: {:.2f}%'.format(cross_val_scores.mean() * 100))

Courbe ROC et AUC

La courbe ROC (Receiver Operating Characteristic) et son aire sous la courbe (AUC) sont particulièrement intéressantes pour évaluer les modèles de classification binaire. La courbe ROC est un graphique montrant la performance d'un modèle à différents seuils de classification.

Exemple de code en Python:

from sklearn.metrics import roc_curve, roc_auc_score
import matplotlib.pyplot as plt

# Probabilités de prédiction pour la classe positive
y_prob = svc_model_linear.decision_function(X_test)

# Calcul des courbes ROC
fpr, tpr, thresholds = roc_curve(y_test, y_prob)

# Calcul de l'AUC
roc_auc = roc_auc_score(y_test, y_prob)

# Tracé de la courbe ROC
plt.figure()
plt.plot(fpr, tpr, color='darkorange', lw=2, label='Courbe ROC (AUC = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Taux de Faux Positifs')
plt.ylabel('Taux de Vrais Positifs')
plt.title('Courbe ROC')
plt.legend(loc="lower right")
plt.show()

Evaluation à l’aide de la Validation Croisée avec GridSearchCV

Utiliser GridSearchCV pour hyperparamètres optimal et le valider avec la validation croisée améliore encore la fiabilité de l’évaluation.

from sklearn.model_selection import GridSearchCV

# Définir la grille des hyperparamètres
param_grid = {'C': [0.1, 1, 10, 100], 'gamma': [1, 0.1, 0.01, 0.001], 'kernel': ['rbf']}

# Initialisation du GridSearchCV
grid_search = GridSearchCV(SVC(), param_grid, refit=True, verbose=2, cv=5)

# Entraînement de GridSearchCV
grid_search.fit(X_train, y_train)

# Meilleur score de validation croisée
print('Meilleur score de validation croisée: {:.2f}%'.format(grid_search.best_score_ * 100))

En utilisant ces techniques et métriques, vous pouvez obtenir une compréhension complète des performances de votre modèle SVM. Dans l'étape suivante, nous examinerons l'optimisation des hyperparamètres pour améliorer encore les performances du modèle.


Optimisation des Hyperparamètres

L'optimisation des hyperparamètres est une étape essentielle dans le processus de machine learning, notamment lorsqu'on utilise des Support Vector Machines (SVM). Une bonne sélection des hyperparamètres peut considérablement améliorer les performances d'un modèle. Les hyperparamètres sont des paramètres qui ne sont pas appris directement à partir des données pendant l'entraînement mais qui doivent être définis avant de lancer le processus d'entraînement.

Pourquoi Optimiser les Hyperparamètres?

  1. Performance: Des hyperparamètres optimaux peuvent améliorer la précision, le rappel et d’autres métriques de performance.
  2. Généralisation: Une bonne sélection peut aider le modèle à mieux généraliser sur de nouvelles données, réduisant ainsi les risques de surajustement.
  3. Efficacité: Certains hyperparamètres peuvent réduire le temps d'entraînement tout en maintenant ou en améliorant les performances.

Hyperparamètres Clés pour les SVM

  1. C (Paramètre de Régularisation): Contrôle la marge d'erreur des erreurs de classification.
  2. Gamma: Influence la flexibilité de la frontière de décision dans les noyaux non linéaires comme RBF.
  3. Noyau (Kernel): Détermine le type de transformation appliquée aux données (linéaire, polynomial, RBF, sigmoïdal).

Techniques d'Optimisation des Hyperparamètres

1. Recherche en Grille (Grid Search)

La recherche en grille (GridSearchCV) essaie toutes les combinaisons possibles d’hyperparamètres dans une grille définie.

Exemple de code en Python:

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

# Définir la grille des hyperparamètres
param_grid = {
    'C': [0.1, 1, 10, 100],
    'gamma': [1, 0.1, 0.01, 0.001],
    'kernel': ['linear', 'rbf', 'poly', 'sigmoid']
}

# Initialiser GridSearchCV avec 5 plis de validation croisée
grid_search = GridSearchCV(SVC(), param_grid, refit=True, verbose=2, cv=5)

# Entraîner GridSearchCV
grid_search.fit(X_train, y_train)

# Meilleures hyperparamètres et score associé
print("Meilleurs hyperparamètres:", grid_search.best_params_)
print("Meilleure exactitude de validation croisée: {:.2f}%".format(grid_search.best_score_ * 100))

2. Recherche Aléatoire (Random Search)

La recherche aléatoire (RandomizedSearchCV) utilise un nombre fixe d'itérations pour échantillonner différentes combinaisons d'hyperparamètres. C'est souvent plus rapide que la recherche en grille.

Exemple de code en Python:

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import uniform

# Définir la distribution des hyperparamètres
param_dist = {
    'C': uniform(0.1, 100),
    'gamma': uniform(0.001, 1),
    'kernel': ['linear', 'rbf', 'poly', 'sigmoid']
}

# Initialiser RandomizedSearchCV avec 5 plis de validation croisée
random_search = RandomizedSearchCV(SVC(), param_distributions=param_dist, n_iter=100, cv=5, verbose=2, random_state=42)

# Entraîner RandomizedSearchCV
random_search.fit(X_train, y_train)

# Meilleures hyperparamètres et score associé
print("Meilleurs hyperparamètres:", random_search.best_params_)
print("Meilleure exactitude de validation croisée: {:.2f}%".format(random_search.best_score_ * 100))

Visualisation des Résultats de GridSearchCV

Pour analyser et comparer les résultats de différents ensembles d'hyperparamètres, on peut visualiser les scores de validation croisée.

import matplotlib.pyplot as plt
import seaborn as sns

# Extraction des résultats
results = grid_search.cv_results_
scores = results['mean_test_score']
params = results['params']

# Création d'un dataframe pour visualisation
import pandas as pd
df_results = pd.DataFrame(params)
df_results['Score'] = scores

# Visualisation des résultats
sns.pairplot(df_results, hue='Score', palette='viridis')
plt.show()

Validation Croisée

La validation croisée est utilisée pour évaluer les performances de l'ensemble des hyperparamètres de manière impartiale. Elle divise les données en plusieurs parties et itère à travers ces divisions pour entraîner et tester le modèle.

Exemple utilisant cross_val_score:

from sklearn.model_selection import cross_val_score

# Réexécution de la validation croisée avec les meilleurs paramètres trouvés
best_model = grid_search.best_estimator_
cross_val_scores = cross_val_score(best_model, X, y, cv=5)

print('Scores de Validation Croisée:', cross_val_scores)
print('Moyenne des Scores de Validation Croisée: {:.2f}%'.format(cross_val_scores.mean() * 100))

Test du Modèle sur l'Ensemble de Test

Enfin, nous testons le modèle optimisé sur l'ensemble de test pour évaluer sa performance finale.

# Prédictions sur l'ensemble de test avec le meilleur modèle
y_pred_test = best_model.predict(X_test)

# Evaluations finales
from sklearn.metrics import classification_report, accuracy_score

print('Rapport de Classification:\n', classification_report(y_test, y_pred_test))
print('Exactitude sur l\'ensemble de test: {:.2f}%'.format(accuracy_score(y_test, y_pred_test) * 100))

Reflexions Finales sur l'Optimisation

  • Équilibre: Il est crucial de trouver un équilibre entre la complexité du modèle et sa capacité à généraliser.
  • Itératif: L'optimisation des hyperparamètres est souvent un processus itératif; il est utile de refaire des ajustements fréquents en fonction des résultats.
  • Automatisation: L'utilisation d'outils comme GridSearchCV et RandomizedSearchCV facilite l'automatisation du processus d'optimisation, permettant ainsi de tester un large éventail d'hyperparamètres sans effort manuel excessif.

En appliquant ces techniques d'optimisation des hyperparamètres, vous pouvez améliorer de manière significative les performances de votre modèle SVM.


Classification zéro-shot
Comprendre les bases de la classification zéro-shot