Qu'est-ce qu'une machine à vecteurs de support ?

Support Vector Machine est un autre algorithme simple qui fonctionne relativement bien avec moins de coûts de calcul. En régression, SVM fonctionne en trouvant un hyperplan dans un espace à N dimensions (N nombre de caractéristiques) qui s'adapte aux données multidimensionnelles tout en considérant une marge. En classification, le même hyperplan est calculé mais pour classer à nouveau distinctement les points de données tout en considérant une marge. Il peut y avoir de nombreux hyperplans possibles qui pourraient être sélectionnés. Cependant, l'objectif est de trouver l'hyperplan avec la marge maximale, c'est-à-dire la distance maximale entre les classes cibles.

SVM peut être utilisé à la fois pour les problèmes de régression et de classification, mais il est largement utilisé pour la classification.

Expliquons quelques termes avant d'aller plus loin.

Le noyau est la fonction utilisée pour convertir les données en dimension supérieure.

L' hyperplan est la ligne séparant les classes (pour les problèmes de classification). Pour la régression, c'est la ligne que nous ajustons à nos données pour prédire les valeurs de résultat continues.

Les lignes de délimitation sont les lignes qui forment la zone avec l'erreur que nous avons mentionnée précédemment. Ce sont les deux lignes autour de l'hyperplan qui représentent la marge.

Les vecteurs de support sont les points de données les plus proches de ces lignes de démarcation.

Noyau

Nous avons mentionné que le noyau est la fonction permettant de convertir nos données en dimensions supérieures. Eh bien, en quoi cela nous est-il utile ?

Parfois, les données sont distribuées d'une manière telle qu'il est impossible d'obtenir un ajustement précis en utilisant une ligne linéaire (séparateur). SVR peut gérer des données hautement non linéaires à l'aide de la fonction noyau. La fonction mappe implicitement les caractéristiques à des dimensions plus élevées, ce qui signifie un espace de caractéristiques plus élevé. Cela nous permet de le décrire également à l'aide d'un hyperplan linéaire.

Les trois noyaux les plus utilisés sont :

• Noyau linéaire
• Noyau polynomial :
• Fonction de base radiale (RBF) - Bon pour traiter les données qui se chevauchent

Prise en charge de la régression vectorielle (SVR)

Semblable aux modèles de régression linéaire, SVR essaie également de trouver une courbe qui correspond le mieux à l'ensemble de données. Rappel de notre équation pour l'ensemble de données avec une caractéristique de la régression linéaire :

y=w1x1+c

Considérant le SVR pour un jeu de données également avec une caractéristique, l'équation semble similaire mais en tenant compte d'une erreur.

−e≤y−(w1x1+c)≤e

En regardant l'équation, il est clair que seuls les points en dehors de la zone d'erreur e seront pris en compte dans le calcul des coûts.

Le SVR peut bien sûr également être utilisé pour des ensembles de données complexes avec plus de caractéristiques en utilisant des termes de caractéristiques de dimension supérieure similaires à ceux de la régression polynomiale.

L'hyperplan est le meilleur ajustement aux données lorsqu'il coïncide avec le nombre maximum de points possible. Nous déterminons les lignes de délimitation (la valeur de e qui est la distance à l'hyperplan) de sorte que les points les plus proches de l'hyperplan se trouvent à l'intérieur des lignes de délimitation.

Gardez à l'esprit que la marge (entre les lignes de démarcation) sera tolérée, elle ne sera pas calculée comme une erreur. Je suppose que vous pouvez déjà imaginer comment ce terme nous permettra d'ajuster la complexité de notre modèle (sous-ajustement/surajustement).

 import numpy as np from sklearn.svm import SVR import matplotlib.pyplot as plt np.random.seed(5) X = np.sort(5 * np.random.rand(40, 1), axis=0) T = np.linspace(0, 5, 5)[:, np.newaxis] y = np.sin(X).ravel() # Add noise to targets y[::5] += 1 * (0.5 - np.random.rand(8)) # Fit regression model SVR_rbf = SVR(kernel='rbf' ) SVR_lin = SVR(kernel='linear') SVR_poly = SVR(kernel='poly') y_rbf = SVR_rbf.fit(X, y).predict(X) y_lin = SVR_lin.fit(X, y).predict(X) y_poly = SVR_poly.fit(X, y).predict(X) # look at the results plt.scatter(X, y, c='k', label='data') plt.plot(X, y_rbf, c='b', label='RBF') plt.plot(X, y_lin, c='r',label='Linear') plt.plot(X, y_poly, c='g',label='Polynomial') plt.xlabel('data') plt.ylabel('outcome') plt.title('Support Vector Regression') plt.legend() plt.show()

Soutenir les machines vectorielles pour la classification

Nous avons déjà vu comment l'algorithme "Support Vector Machines (SVM)" fonctionne pour la régression. Pour la classification, l'idée est en fait presque la même. En fait, SVM est principalement utilisé pour des problèmes de classification. Je crois que vous pouvez déjà imaginer pourquoi…

Pour la régression, nous avons mentionné que SVM essaie de trouver une courbe qui correspond le mieux à l'ensemble de données, puis de faire une prédiction pour un nouveau point en utilisant cette courbe. Eh bien, la même courbe peut facilement être utilisée pour classer les données dans deux classes différentes. Pour un espace multidimensionnel à n dimensions (c'est-à-dire des données avec un nombre n d'entités), le modèle correspond à un hyperplan (également appelé frontière de décision) qui différencie le mieux les deux classes. Se souvenir de l'image de la section de régression où nous avons expliqué le noyau…

La marge est l'écart entre les deux points les plus proches de chaque classe qui est la distance de l'hyperplan aux points les plus proches (vecteurs de support). L'hyperplan qui s'adapte le mieux aux données, c'est-à-dire qui sépare le mieux les deux classes, est l'hyperplan avec la marge maximale possible. Par conséquent, l'algorithme SVM recherche l'hyperplan avec la marge maximale (distance aux points les plus proches).

Comme nous l'avons déjà mentionné dans la section de régression, certains ensembles de données ne conviennent tout simplement pas pour être classés par un hyperplan linéaire… Dans ce cas, encore une fois, le "truc du noyau" vient à notre secours en mappant implicitement les données à des dimensions plus élevées, permettant ainsi à les données à classer par un hyperplan linéaire. Puisque nous avons déjà discuté des types de noyau et de leur fonctionnement, je vais continuer avec un exemple d'implémentation…

Continuons à utiliser l'ensemble de données sur le cancer de la bibliothèque scikit learn :

 from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split X, y = load_breast_cancer(return_X_y = True) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) X_sub = X[:, 0:2] # create a mesh to plot in x_min, x_max = X_sub[:, 0].min() - 1, X_sub[:, 0].max() + 1 y_min, y_max = X_sub[:, 1].min() - 1, X_sub[:, 1].max() + 1 h = (x_max / x_min)/100 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) #import the SVM model from sklearn import svm C = 1.0 # SVM regularization parameter svc = svm.SVC(kernel='linear').fit(X_sub, y) #play with this, change kernel to rbf plt.subplot(1, 1, 1) Z = svc.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) plt.contourf(xx, yy, Z, cmap=plt.cm.Paired, alpha=0.8) plt.scatter(X_sub[:, 0], X_sub[:, 1], c=y, cmap=plt.cm.Paired) plt.scatter(X_sub[svc.support_, 0], X_sub[svc.support_, 1],c='k', cmap=plt.cm.Paired) plt.xlabel('Sepal length') plt.ylabel('Sepal width') plt.xlim(xx.min(), xx.max()) plt.title('SVC with linear kernel') plt.show()

 #Create and instance of the classifier model with a linear kernel lsvm = svm.SVC(kernel="linear") #fit the model to our train split from previous example lsvm.fit(X_train,y_train) #Make predictions using the test split so we can evaluate its performance y_pred = lsvm.predict(X_test)

Comparons les performances du modèle en comparant les prédictions aux valeurs réelles de l'ensemble de test…

 from sklearn import metrics print("Accuracy:",metrics.accuracy_score(y_test, y_pred)) print("Precision:",metrics.precision_score(y_test, y_pred)) print("Recall:",metrics.recall_score(y_test, y_pred))

Nous avons pu atteindre une précision de 95,6% ce qui est très bon. Comparons les scores d'entraînement et de test pour vérifier le surajustement…

 print("training set score: %f" % lsvm.score(X_train, y_train)) print("test set score: %f" % lsvm.score(X_test, y_test))

Le score d'entraînement semble être un peu plus élevé que le score du test. Nous pouvons dire que le modèle est sur-ajusté, mais pas beaucoup.

Si vous aimez cela, n'hésitez pas à me suivre pour plus de tutoriels et de cours d'apprentissage automatique gratuits !