Support Vector Machines (SVM) en python

Un Support Vector Machines (SVM) est un modèle de machine learning très puissant et polyvalent, capable d’effectuer une classification linéaire ou non linéaire, une régression et même une détection des outliers. C’est l’un des modèles les plus populaires de l’apprentissage automatique et toute personne intéressée par l’apprentissage automatique devrait l’avoir dans sa boîte à outils. Dans cet article, nous ferons une introduction aux SVM et implémenterons un SVM en python.

Support Vector Machines a.k.a. SVM, Kezako ?

Comme présenté en introduction, le SVM est un modèle d’apprentissage automatique supervisé qui est principalement utilisé pour les classifications (mais il peut aussi être utilisé pour la régression !). L’intuition derrière les Support Vector Machines est de simplement séparer des données en les délimitant (créer des frontières ) afin de créer des groupes. Exemple :

A brief introduction to Support Vector Machine | by Sweet A.I. | Medium
source : https://medium.com/@sweetai/a-brief-introduction-to-support-vector-machine-ba2ae5ea1d4e

En d’autres termes, les SVM visent à résoudre les problèmes de classification en trouvant de bonnes frontières de décision (voir figure ci-dessous) entre deux ensembles de points appartenant à deux catégories différentes. Une frontière de décision peut être considérée comme une ligne ou une surface séparant vos données d’apprentissage en deux espaces correspondant à deux catégories. Pour classer de nouveaux points de données, il suffit de vérifier de quel côté de la frontière de décision ils se trouvent.
Les SVM procèdent à la recherche de ces frontières en deux étapes :

  1. Les données sont mises en correspondance avec une nouvelle représentation à haute dimension où la frontière de décision peut être exprimée sous la forme d’un hyperplan (si les données étaient bidimensionnelles, comme dans la figure ci-dessous, un hyperplan serait une ligne droite).
  2. Une bonne limite de décision (un hyperplan de séparation) est calculée en essayant de maximiser la distance entre l’hyperplan et les points de données les plus proches de chaque classe, une étape appelée maximisation de la marge. Cela permet à la frontière de bien s’adapter à de nouveaux échantillons en dehors de l’ensemble de données d’apprentissage.
Exemple : Frontière de décision

Cette technique utilisée par les Support Vector Machines est appelée « kernel trick« . Elle permet de transformer les données, puis, sur la base de ces transformations, il trouve une limite optimale entre les résultats possibles. En d’autres termes, il effectue des transformations de données extrêmement complexes, puis détermine comment séparer les données en fonction des labels que vous avez définis.

Vu que nous avons présenté rapidement le principe, un exemple concret s’impose.

Les SVM en python


On importe le dataset que nous utiliserons dans ce tutoriel.

#Import du data set et des libs
%matplotlib inline
from sklearn import datasets
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
#chargement du jeu de donnees
wine_dataset = datasets.load_wine()

Exploration des données

Après avoir importé notre jeu de données, nous allons essayer de l’explorer et le visualiser afin d’avoir le maximum d’informations pour notre modélisation

#On a un dictionnaire python  dont les différentes clés sont
# 'data', 'target', 'target_names', 'DESCR', 'feature_names'
print(wine_dataset.keys())
[Output]

dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])

# les features
print("Features: ", wine_dataset.feature_names)
[Output]

Features:  ['alcohol', 'malic_acid', 'ash', 'alcalinity_of_ash', 'magnesium', 'total_phenols', 'flavanoids', 'nonflavanoid_phenols', 'proanthocyanins', 'color_intensity', 'hue', 'od280/od315_of_diluted_wines', 'proline']
#les labels
print("Labels: ", wine_dataset.target_names)
[Output]
Labels:  ['class_0' 'class_1' 'class_2']

On voit donc qu’on a 3 labels ce qui pourrait dire qu’on a affaire à différentes catégories de vin. Allez, transformons tout ça en un dataFrame Pandas.

wine_dataframe = pd.DataFrame(data=wine_dataset['data'],columns=wine_dataset['feature_names'])
#On ajoute la colonne target ensuite
wine_dataframe['target'] = wine_dataset['target']
# Puis le nom des targets
wine_dataframe['class']=wine_dataframe['target'].map(lambda target_name: wine_dataset['target_names'][target_name])

À ce niveau on peut faire un head() et un describe() pour mieux appréhender le dataFrame que nous venons de créer.

wine_dataframe.describe()
alcoholmalic_acidashalcalinity_of_ashmagnesiumtotal_phenolsflavanoidsnonflavanoid_phenolsproanthocyaninscolor_intensityhueod280/od315_of_diluted_winesprolinetarget
count178.000000178.000000178.000000178.000000178.000000178.000000178.000000178.000000178.000000178.000000178.000000178.000000178.000000178.000000
mean13.0006182.3363482.36651719.49494499.7415732.2951122.0292700.3618541.5908995.0580900.9574492.611685746.8932580.938202
std0.8118271.1171460.2743443.33956414.2824840.6258510.9988590.1244530.5723592.3182860.2285720.709990314.9074740.775035
min11.0300000.7400001.36000010.60000070.0000000.9800000.3400000.1300000.4100001.2800000.4800001.270000278.0000000.000000
25%12.3625001.6025002.21000017.20000088.0000001.7425001.2050000.2700001.2500003.2200000.7825001.937500500.5000000.000000
50%13.0500001.8650002.36000019.50000098.0000002.3550002.1350000.3400001.5550004.6900000.9650002.780000673.5000001.000000
75%13.6775003.0825002.55750021.500000107.0000002.8000002.8750000.4375001.9500006.2000001.1200003.170000985.0000002.000000
max14.8300005.8000003.23000030.000000162.0000003.8800005.0800000.6600003.58000013.0000001.7100004.0000001680.0000002.000000

Un peu de visualisation…

Le describe() nous montre que la moyenne d’alcool contenu dans les vins est d’envrion 13%. Essayons de visualiser la distribution d’alcool pour chaque catégorie de vin.

for i in wine_dataframe.target.unique():
    sns.distplot(wine_dataframe['alcohol'][wine_dataframe.target==i],
                 kde=1,label='{}'.format(i))

plt.legend()
SVM

On s’aperçoit que les distributions semblent plutôt normales et peuvent être classées en 3 groupes. Les vins faibles en teneur d’alcool, les vins à teneur d’alcool moyenne et les vins forts. On peut s’amuser à analyser d’autres caractéristiques, mais notre objectif dans ce tutoriel est de montrer l’utilisation du SVM.

Création de notre modèle SVM

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = \
    train_test_split(wine_dataset['data'],wine_dataset['target'],
                     test_size=0.2)

Nous pouvons dès à présent créer notre SVM dans sklearn cela consiste à créer un objet SVC (support vector classificator). L’un des paramètres importants est le noyau ‘kernel’, comme présenté plus haut, c’est une fonction qui sert à transformer les données dans une représentation spécifique.
Les SVM utilisent différents types de fonctions noyau. Ces fonctions sont de différents types, par exemple, linéaire, non linéaire, polynomiale, fonction de base radiale (RBF) et sigmoïde.
Il faut donc avoir une attention particulière sur ce paramètre. Je vous laisse la documentation de scikit-learn sur les kernel pour mieux approfondir ce point.
Dans notre cas nous choisirons un kernel linéaire (pourquoi 😉 )

# Fit du  Training set
from sklearn.svm import SVC
classifier = SVC(kernel = 'linear', random_state = 0)
classifier.fit(X_train, y_train)
#Prediction sur le Test set
y_pred = classifier.predict(X_test)
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))

On regarde le rapport de classification pour voir ce que ça donne. Et ça semble pas mal.

              precision    recall  f1-score   support

           0       1.00      1.00      1.00        11
           1       1.00      0.91      0.95        11
           2       0.93      1.00      0.97        14

    accuracy                           0.97        36
   macro avg       0.98      0.97      0.97        36
weighted avg       0.97      0.97      0.97        36

Je me le lien du google colab pour avoir le notebook complet.
Notebook de l’article sur google colab

Sources

Deep Learning with Python, François Cholet, 2017
Scikit-learn Support vector machines (SVMs)

Conclusion

Dans cet article nous avons présenté les Support Vector Machines qui sont des modèles très intéressants dont les principaux points forts sont les suivants :

  • L’efficacité dans les espaces à dimension élevés
  • L’efficacité dans les cas où le nombre de dimensions est supérieur au nombre d’échantillons.
  • L’utilisation d’un sous-ensemble de points d’apprentissage dans la fonction de décision (appelés vecteurs de support), ce qui la rend également efficace en termes de mémoire.
  • La polyvalence/ flexibilité : différentes fonctions de noyau peuvent être spécifiées pour la fonction de décision.

Cependant, il faut faire attention au cas particulier où le nombre de  » features  » est beaucoup plus grand que le nombre d’échantillons, car un mauvais le choix des fonctions de noyau peut entrainer l’over-fitting.
N’hésitez pas à laisser des commentaires pour les questions et suggestions. 

2 commentaires
  1. pierre dit

    Salut,
    Merci pour cet article intéressant et pédagogique. C’est agréable a lire. Je vais m’empresser de rejouer ton code pour comprendre les algos SVM.
    A+
    Pierre

  2. Henri Michel dit

    Salut,
    Merci Pierre, n’hésite à poser des questions dans le besoin.

Laisser un commentaire

Votre adresse email ne sera pas publiée.

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Voulez-vous en savoir plus sur la Data Science ?

Inscrivez-vous alors à notre newsletter et vous receverez gratuitement nos derniers articles et actualités ! 
S'INSCRIRE MAINTENANT 
close-link