Support Vector Machine ou SVM est l'un des algorithmes d'apprentissage supervisé les plus populaires, utilisé pour les problèmes de classification et de régression. Cependant, il est principalement utilisé pour les problèmes de classification dans l’apprentissage automatique.
L'objectif de l'algorithme SVM est de créer la meilleure ligne ou limite de décision capable de séparer l'espace à n dimensions en classes afin que nous puissions facilement placer le nouveau point de données dans la bonne catégorie à l'avenir. Cette meilleure limite de décision est appelée un hyperplan.
SVM choisit les points/vecteurs extrêmes qui aident à créer l'hyperplan. Ces cas extrêmes sont appelés vecteurs de support, et par conséquent l'algorithme est appelé machine à vecteurs de support. Considérez le diagramme ci-dessous dans lequel il existe deux catégories différentes classées à l'aide d'une limite de décision ou d'un hyperplan :
Exemple: SVM peut être compris avec l'exemple que nous avons utilisé dans le classificateur KNN. Supposons que nous voyons un chat étrange qui présente également certaines caractéristiques des chiens, donc si nous voulons un modèle capable d'identifier avec précision s'il s'agit d'un chat ou d'un chien, un tel modèle peut être créé en utilisant l'algorithme SVM. Nous allons d'abord entraîner notre modèle avec de nombreuses images de chats et de chiens afin qu'il puisse découvrir différentes caractéristiques des chats et des chiens, puis nous le testerons avec cette étrange créature. Ainsi, lorsque le vecteur de support crée une frontière de décision entre ces deux données (chat et chien) et choisit des cas extrêmes (vecteurs de support), il verra le cas extrême du chat et du chien. Sur la base des vecteurs supports, il le classera comme chat. Considérez le diagramme ci-dessous :
L'algorithme SVM peut être utilisé pour Détection de visage, classification d'images, catégorisation de texte, etc.
exemples de code c#
Types de SVM
SVM peut être de deux types :
Hyperplan et vecteurs de support dans l'algorithme SVM :
Hyperplan : Il peut y avoir plusieurs lignes/limites de décision pour séparer les classes dans un espace à n dimensions, mais nous devons trouver la meilleure limite de décision qui aide à classer les points de données. Cette meilleure frontière est connue sous le nom d’hyperplan de SVM.
Les dimensions de l'hyperplan dépendent des entités présentes dans l'ensemble de données, ce qui signifie que s'il y a 2 entités (comme indiqué dans l'image), alors l'hyperplan sera une ligne droite. Et s’il y a 3 entités, alors l’hyperplan sera un plan à 2 dimensions.
Nous créons toujours un hyperplan qui a une marge maximale, c'est-à-dire la distance maximale entre les points de données.
Vecteurs de support :
Les points de données ou vecteurs les plus proches de l'hyperplan et qui affectent la position de l'hyperplan sont appelés vecteur de support. Puisque ces vecteurs supportent l’hyperplan, on les appelle donc vecteur de support.
Comment fonctionne SVM ?
SVM linéaire :
Le fonctionnement de l'algorithme SVM peut être compris à l'aide d'un exemple. Supposons que nous ayons un ensemble de données comportant deux balises (verte et bleue) et que l'ensemble de données comporte deux fonctionnalités x1 et x2. Nous voulons un classificateur capable de classer la paire (x1, x2) de coordonnées en vert ou en bleu. Considérez l'image ci-dessous :
Ainsi, comme il s’agit d’un espace à 2 dimensions, en utilisant simplement une ligne droite, nous pouvons facilement séparer ces deux classes. Mais plusieurs lignes peuvent séparer ces classes. Considérez l'image ci-dessous :
Par conséquent, l’algorithme SVM aide à trouver la meilleure ligne ou limite de décision ; cette meilleure frontière ou région est appelée hyperplan . L'algorithme SVM trouve le point le plus proche des lignes des deux classes. Ces points sont appelés vecteurs de support. La distance entre les vecteurs et l’hyperplan est appelée marge . Et le but de SVM est de maximiser cette marge. Le hyperplan avec une marge maximale est appelé le hyperplan optimal .
SVM non linéaire :
Si les données sont disposées linéairement, nous pouvons les séparer en utilisant une ligne droite, mais pour les données non linéaires, nous ne pouvons pas tracer une seule ligne droite. Considérez l'image ci-dessous :
Donc, pour séparer ces points de données, nous devons ajouter une dimension supplémentaire. Pour les données linéaires, nous avons utilisé deux dimensions x et y, donc pour les données non linéaires, nous ajouterons une troisième dimension z. Il peut être calculé comme suit :
z=x<sup>2</sup> +y<sup>2</sup>
En ajoutant la troisième dimension, l'espace échantillon deviendra comme dans l'image ci-dessous :
Alors maintenant, SVM divisera les ensembles de données en classes de la manière suivante. Considérez l'image ci-dessous :
Puisque nous sommes dans l’espace 3D, cela ressemble donc à un plan parallèle à l’axe des x. Si nous le convertissons dans l’espace 2D avec z=1, alors cela deviendra :
syndicat contre syndicat tous
On obtient donc une circonférence de rayon 1 dans le cas de données non linéaires.
Implémentation Python de la machine à vecteurs de support
Nous allons maintenant implémenter l'algorithme SVM en utilisant Python. Ici, nous utiliserons le même ensemble de données données d'utilisateur , que nous avons utilisé dans la régression logistique et la classification KNN.
Jusqu'à l'étape de prétraitement des données, le code restera le même. Ci-dessous le code :
#Data Pre-processing Step # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
Après avoir exécuté le code ci-dessus, nous prétraiterons les données. Le code donnera l'ensemble de données comme :
La sortie mise à l'échelle pour l'ensemble de test sera :
Ajustement du classificateur SVM à l'ensemble de formation :
L’ensemble de formation sera désormais adapté au classificateur SVM. Pour créer le classificateur SVM, nous importerons SVC classe de Sklearn.svm bibliothèque. Ci-dessous le code correspondant :
from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train)
Dans le code ci-dessus, nous avons utilisé noyau='linéaire' , car ici nous créons SVM pour des données linéairement séparables. Cependant, nous pouvons le modifier pour des données non linéaires. Et puis nous avons adapté le classificateur à l'ensemble de données d'entraînement (x_train, y_train)
Sortir:
Out[8]: SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='auto_deprecated', kernel='linear', max_iter=-1, probability=False, random_state=0, shrinking=True, tol=0.001, verbose=False)
Les performances du modèle peuvent être modifiées en modifiant la valeur de C (facteur de régularisation), gamma et noyau .
Maintenant, nous allons prédire le résultat de l'ensemble de test. Pour cela, nous allons créer un nouveau vecteur y_pred. Ci-dessous le code correspondant :
#Predicting the test set result y_pred= classifier.predict(x_test)
Après avoir obtenu le vecteur y_pred, nous pouvons comparer le résultat de y_pred et y_test pour vérifier la différence entre la valeur réelle et la valeur prédite.
Sortir: Vous trouverez ci-dessous le résultat de la prédiction de l'ensemble de test :
tranche java
Nous allons maintenant voir les performances du classificateur SVM et le nombre de prédictions incorrectes par rapport au classificateur de régression logistique. Pour créer la matrice de confusion, nous devons importer le matrice_de confusion fonction de la bibliothèque sklearn. Après avoir importé la fonction, nous l'appellerons en utilisant une nouvelle variable cm . La fonction prend deux paramètres, principalement y_vrai (les valeurs réelles) et y_pred (la valeur ciblée renvoyée par le classificateur). Ci-dessous le code correspondant :
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Sortir:
Comme nous pouvons le voir dans l'image de sortie ci-dessus, il y a 66+24= 90 prédictions correctes et 8+2= 10 prédictions correctes. Nous pouvons donc dire que notre modèle SVM s'est amélioré par rapport au modèle de régression logistique.
Nous allons maintenant visualiser le résultat de l'ensemble d'entraînement, vous trouverez ci-dessous le code correspondant :
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red', 'green'))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Sortir:
En exécutant le code ci-dessus, nous obtiendrons le résultat suivant :
Comme nous pouvons le voir, le résultat ci-dessus semble similaire au résultat de la régression logistique. Dans le résultat, nous avons la ligne droite comme hyperplan car nous avons utilisé un noyau linéaire dans le classificateur . Et nous avons également discuté ci-dessus que pour l'espace 2D, l'hyperplan dans SVM est une ligne droite.
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Sortir:
En exécutant le code ci-dessus, nous obtiendrons le résultat suivant :
Comme nous pouvons le voir dans l'image de sortie ci-dessus, le classificateur SVM a divisé les utilisateurs en deux régions (Acheté ou Non acheté). Les utilisateurs qui ont acheté le SUV se trouvent dans la région rouge avec les points de dispersion rouges. Et les utilisateurs qui n’ont pas acheté le SUV se trouvent dans la zone verte avec des points de dispersion verts. L'hyperplan a divisé les deux classes en variables achetées et non achetées.