Implémentation d'autres saveurs SVM avec Scikit-Learn de Python

Introduction

Ce guide est la troisième et dernière partie de trois guides sur les machines à vecteurs de support (SVM). Dans ce guide, nous continuerons à travailler avec le cas d'utilisation des faux billets de banque, nous ferons un bref récapitulatif de l'idée générale derrière les SVM, nous comprendrons quelle est l'astuce du noyau et nous implémenterons différents types de noyaux non linéaires avec Scikit-Learn.

Dans la série complète de guides SVM, en plus d'apprendre sur d'autres types de SVM, vous découvrirez également les SVM simples, les paramètres prédéfinis SVM, les hyperparamètres C et Gamma et comment ils peuvent être réglés avec la recherche de grille et la validation croisée.

Si vous souhaitez lire les guides précédents, vous pouvez consulter les deux premiers guides ou voir quels sujets vous intéressent le plus. Vous trouverez ci-dessous le tableau des sujets abordés dans chaque guide :

1. Implémenter SVM et Kernel SVM avec Scikit-Learn de Python

• Cas d'utilisation : oubliez les billets de banque
• Contexte des SVM
• Modèle SVM simple (linéaire)
  • À propos de l'ensemble de données
  • Importation du jeu de données
  • Exploration de l'ensemble de données
• Implémentation de SVM avec Scikit-Learn
  • Diviser les données en ensembles d'apprentissage/test
  • Entraîner le modèle
  • Faire des prédictions
  • Évaluation du modèle
  • Interprétation des résultats

2. Comprendre les hyperparamètres SVM

• L'hyperparamètre C
• L'hyperparamètre gamma

3. Implémenter d'autres saveurs SVM avec Scikit-Learn de Python

• L'idée générale des SVM (un récapitulatif)
• SVM du noyau (astuce)
• Implémentation d'un noyau SVM non linéaire avec Scikit-Learn
• Importation de bibliothèques
  • Importation du jeu de données
  • Diviser les données en fonctionnalités (X) et cible (y)
  • Diviser les données en ensembles d'apprentissage/test
  • Entraînement de l'algorithme
• Noyau polynomial
  • Faire des prédictions
  • Évaluation de l'algorithme
• Noyau gaussien
  • Prédiction et évaluation
• Noyau sigmoïde
  • Prédiction et évaluation
• Comparaison des performances du noyau non linéaire

Rappelons-nous ce qu'est SVM avant de voir quelques variations intéressantes du noyau SVM.

L'idée générale des SVM

Dans le cas de données linéairement séparables en deux dimensions (comme illustré à la Fig. 1), l'approche typique de l'algorithme d'apprentissage automatique consisterait à essayer de trouver une limite qui divise les données de manière à minimiser l'erreur de classification erronée. Si vous regardez attentivement la figure 1, notez qu'il peut y avoir plusieurs limites (infinies) qui divisent correctement les points de données. Les deux lignes pointillées ainsi que la ligne continue sont toutes des classifications valides des données.

Fig 1 : Limites de décision multiples

Lorsque SVM choisit le limite de décision, il choisit une frontière qui maximise la distance entre lui-même et les points de données les plus proches des classes. Nous savons déjà que les points de données les plus proches sont les vecteurs de support et que la distance peut être paramétrée à la fois par C et les gamma hyperparamètres.

En calculant cette limite de décision, l'algorithme choisit le nombre de points à considérer et jusqu'où la marge peut aller - cela configure un problème de maximisation de la marge. Pour résoudre ce problème de maximisation de marge, SVM utilise les vecteurs de support (comme le montre la figure 2) et essaie de déterminer quelles sont les valeurs optimales qui maintiennent la distance de marge plus grande, tout en classant correctement plus de points en fonction de la fonction utilisée pour séparer les données.

Fig 2: Limite de décision avec vecteurs de support

C'est pourquoi SVM diffère des autres algorithmes de classification, une fois qu'il ne se contente pas de trouver une frontière de décision, mais qu'il finit par trouver la frontière de décision optimale.

Il existe des mathématiques complexes dérivées des statistiques et des méthodes de calcul impliquées dans la recherche des vecteurs de support, le calcul de la marge entre la frontière de décision et les vecteurs de support et la maximisation de cette marge. Cette fois, nous n'entrerons pas dans les détails du fonctionnement des mathématiques.

Il est toujours important de plonger plus profondément et de s'assurer que les algorithmes d'apprentissage automatique ne sont pas une sorte de sort mystérieux, bien que le fait de ne pas connaître tous les détails mathématiques à ce moment-là ne vous empêche pas et ne vous empêchera pas d'être en mesure d'exécuter l'algorithme et d'obtenir des résultats.

SVM du noyau (astuce)

Dans la section précédente, nous avons rappelé et organisé l'idée générale de SVM - en voyant comment elle peut être utilisée pour trouver la limite de décision optimale pour des données linéairement séparables. Cependant, dans le cas de données non linéairement séparables, telles que celle représentée sur la figure 3, nous savons déjà qu'une ligne droite ne peut pas être utilisée comme frontière de décision.

Fig 3: Données non linéairement séparables

Nous pouvons plutôt utiliser la version modifiée de SVM dont nous avions parlé au début, appelée Kernel SVM.

Fondamentalement, ce que le noyau SVM fera est de projeter les données non linéairement séparables de dimensions inférieures vers leur forme correspondante dans des dimensions supérieures. C'est une astuce, car lors de la projection de données non linéairement séparables dans des dimensions supérieures, la forme des données change de telle manière qu'elle devient séparable. Par exemple, en pensant à 3 dimensions, les points de données de chaque classe pourraient finir par être attribués dans une dimension différente, ce qui la rend séparable. Une façon d'augmenter les dimensions des données peut être de les exponentieller. Encore une fois, cela implique des mathématiques complexes, mais vous n'avez pas à vous en soucier pour utiliser SVM. Au lieu de cela, nous pouvons utiliser la bibliothèque Scikit-Learn de Python pour implémenter et utiliser les noyaux non linéaires de la même manière que nous avons utilisé le linéaire.

Implémentation d'un noyau SVM non linéaire avec Scikit-Learn

Dans cette section, nous utiliserons le même ensemble de données pour prédire si un billet de banque est réel ou falsifié selon les quatre caractéristiques que nous connaissons déjà.

Vous verrez que le reste des étapes sont des étapes typiques d'apprentissage automatique et nécessitent très peu d'explications jusqu'à ce que nous atteignions la partie où nous formons nos SVM à noyau non linéaire.

Importation de bibliothèques

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split

Importation du jeu de données

data_link = "https://archive.ics.uci.edu/ml/machine-learning-databases/00267/data_banknote_authentication.txt"
col_names = ["variance", "skewness", "curtosis", "entropy", "class"] bankdata = pd.read_csv(data_link, names=col_names, sep=",", header=None)
bankdata.head()mes)

Diviser les données en fonctionnalités (X) et cible (y)

X = bankdata.drop('class', axis=1)
y = bankdata['class']

Diviser les données en ensembles d'apprentissage/test

SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

Entraînement de l'algorithme

Pour former le noyau SVM, nous utiliserons le même SVC classe du Scikit-Learn's svm bibliothèque. La différence réside dans la valeur du paramètre kernel du SVC classe.

Dans le cas du SVM simple, nous avons utilisé "linéaire" comme valeur pour le paramètre du noyau. Cependant, comme nous l'avons mentionné précédemment, pour le noyau SVM, nous pouvons utiliser des noyaux gaussiens, polynomiaux, sigmoïdes ou calculables. Nous implémenterons des noyaux polynomiaux, gaussiens et sigmoïdes et examinerons ses métriques finales pour voir laquelle semble correspondre à nos classes avec une métrique plus élevée.

1. Noyau polynomial

En algèbre, un polynôme est une expression de la forme :

$$
2a*b^3 + 4a – 9
$$

Cela a des variables, telles que a et les b, constantes, dans notre exemple, 9 et des coefficients (constantes accompagnées de variables), tels que 2 et les 4L’ 3 est considéré comme le degré du polynôme.

Il existe des types de données qui peuvent être mieux décrits lors de l'utilisation d'une fonction polynomiale, ici, ce que le noyau fera est de mapper nos données à un polynôme dont nous choisirons le degré. Plus le degré est élevé, plus la fonction essaiera de se rapprocher des données, de sorte que la limite de décision est plus flexible (et plus sujette au surajustement) - plus le degré est faible, moins flexible.

Ainsi, pour la mise en œuvre de la noyau polynomial, en plus de choisir le poly noyau, nous passerons également une valeur pour le degree paramètre de la SVC classe. Ci-dessous le code :

from sklearn.svm import SVC
svc_poly = SVC(kernel='poly', degree=8)
svc_poly.fit(X_train, y_train)

Faire des prédictions

Maintenant, une fois que nous avons entraîné l'algorithme, l'étape suivante consiste à faire des prédictions sur les données de test.

Comme nous l'avons fait auparavant, nous pouvons exécuter le script suivant pour ce faire :

y_pred_poly = svclassifier.predict(X_test)

Évaluation de l'algorithme

Comme d'habitude, la dernière étape consiste à faire des évaluations sur le noyau polynomial. Puisque nous avons répété plusieurs fois le code du rapport de classement et de la matrice de confusion, transformons-le en une fonction qui display_results après avoir reçu les respectifs y_test, y_pred et le titre de la matrice de confusion de Seaborn avec cm_title:

def display_results(y_test, y_pred, cm_title): cm = confusion_matrix(y_test,y_pred) sns.heatmap(cm, annot=True, fmt='d').set_title(cm_title) print(classification_report(y_test,y_pred))

Maintenant, nous pouvons appeler la fonction et regarder les résultats obtenus avec le noyau polynomial :

cm_title_poly = "Confusion matrix with polynomial kernel"
display_results(y_test, y_pred_poly, cm_title_poly)

La sortie ressemble à ceci :

 precision recall f1-score support 0 0.69 1.00 0.81 148 1 1.00 0.46 0.63 127 accuracy 0.75 275 macro avg 0.84 0.73 0.72 275
weighted avg 0.83 0.75 0.73 275

Nous pouvons maintenant répéter les mêmes étapes pour les noyaux gaussiens et sigmoïdes.

2. Noyau gaussien

Pour utiliser le noyau gaussien, il suffit de spécifier 'rbf' comme valeur pour le kernel paramètre de la classe SVC :

svc_gaussian = SVC(kernel='rbf', degree=8)
svc_gaussian.fit(X_train, y_train)

Lorsque vous explorez davantage ce noyau, vous pouvez également utiliser la recherche par grille pour le combiner avec différents C et les gamma valeurs.

Prédiction et évaluation

y_pred_gaussian = svc_gaussian.predict(X_test)

cm_title_gaussian = "Confusion matrix with Gaussian kernel"
display_results(y_test, y_pred_gaussian, cm_title_gaussian)

La sortie de la SVM du noyau gaussien ressemble à ceci :

 precision recall f1-score support 0 1.00 1.00 1.00 148 1 1.00 1.00 1.00 127 accuracy 1.00 275 macro avg 1.00 1.00 1.00 275
weighted avg 1.00 1.00 1.00 275

3. Noyau sigmoïde

Enfin, utilisons un noyau sigmoïde pour implémenter Kernel SVM. Jetez un oeil au script suivant :

svc_sigmoid = SVC(kernel='sigmoid')
svc_sigmoid.fit(X_train, y_train)

Pour utiliser le noyau sigmoïde, vous devez spécifier 'sigmoid' comme valeur pour le kernel paramètre de la SVC classe.

Prédiction et évaluation

y_pred_sigmoid = svc_sigmoid.predict(X_test)

cm_title_sigmoid = "Confusion matrix with Sigmoid kernel"
display_results(y_test, y_pred_sigmoid, cm_title_sigmoid)

La sortie du Kernel SVM avec le noyau Sigmoid ressemble à ceci :

 precision recall f1-score support 0 0.67 0.71 0.69 148 1 0.64 0.59 0.61 127 accuracy 0.65 275 macro avg 0.65 0.65 0.65 275
weighted avg 0.65 0.65 0.65 275

Comparaison des performances du noyau non linéaire

Si nous comparons brièvement les performances des différents types de noyaux non linéaires, il peut sembler que le noyau sigmoïde a les métriques les plus basses, donc les moins bonnes performances.

Parmi les noyaux gaussien et polynomial, nous pouvons voir que le noyau gaussien a atteint un taux de prédiction parfait de 100 % - ce qui est généralement suspect et peut indiquer un surajustement, tandis que le noyau polynomial a mal classé 68 instances de classe 1.

Par conséquent, il n'y a pas de règle absolue quant au noyau qui fonctionne le mieux dans chaque scénario ou dans notre scénario actuel sans rechercher davantage d'hyperparamètres, comprendre chaque forme de fonction, explorer les données et comparer les résultats d'entraînement et de test pour voir si l'algorithme se généralise.

Il s'agit de tester tous les noyaux et de sélectionner celui avec la combinaison de paramètres et de préparation des données qui donne les résultats attendus selon le contexte de votre projet.

Aller plus loin – Projet portable de bout en bout

Votre nature curieuse vous donne envie d'aller plus loin ? Nous vous recommandons de consulter notre Projet guidé: "Prévision pratique du prix des maisons - Apprentissage automatique en Python".

Dans ce projet guidé, vous apprendrez à créer de puissants modèles d'apprentissage automatique traditionnels ainsi que des modèles d'apprentissage en profondeur, à utiliser Ensemble Learning et à former des méta-apprenants pour prédire les prix de l'immobilier à partir d'un ensemble de modèles Scikit-Learn et Keras.

À l'aide de Keras, l'API d'apprentissage en profondeur construite sur Tensorflow, nous allons expérimenter des architectures, créer un ensemble de modèles empilés et former un méta-apprenant réseau de neurones (modèle de niveau 1) pour déterminer le prix d'une maison.

L'apprentissage en profondeur est incroyable - mais avant d'y recourir, il est conseillé d'essayer également de résoudre le problème avec des techniques plus simples, comme avec apprentissage superficiel algorithmes. Notre performance de base sera basée sur un Régression forestière aléatoire algorithme. De plus, nous explorerons la création d'ensembles de modèles via Scikit-Learn via des techniques telles que ensachage et les vote.

Il s'agit d'un projet de bout en bout, et comme tous les projets d'apprentissage automatique, nous commencerons par - avec L'analyse exploratoire des données, Suivie par Pré-traitement des données et enfin Bâtiment peu profond et les Modèles d'apprentissage en profondeur pour correspondre aux données que nous avons explorées et nettoyées précédemment.

Conclusion

Dans cet article, nous avons fait un bref récapitulatif sur les SVM, étudié l'astuce du noyau et implémenté différentes versions de SVM non linéaires.

Je vous suggère d'implémenter chaque noyau et d'aller plus loin. Vous pouvez explorer les mathématiques utilisées pour créer chacun des différents noyaux, pourquoi ils ont été créés et les différences concernant leurs hyperparamètres. De cette façon, vous découvrirez les techniques et le type de noyau qu'il est préférable d'appliquer en fonction du contexte et des données disponibles.

Avoir une compréhension claire du fonctionnement de chaque noyau et du moment où les utiliser vous aidera certainement dans votre cheminement. Faites-nous savoir comment les progrès se déroulent et bon codage !

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• Platoblockchain. Intelligence métaverse Web3. Connaissance Amplifiée. Accéder ici.
• Frapper l'avenir avec Adryenn Ashley. Accéder ici.
• La source: https://stackabuse.com/implementing-other-svm-flavors-with-pythons-scikit-learn/