SVM

Fonctions :

SVC()

La fonction SVC() (Support Vector Classification) permet de créer un modèle de classification basé sur les machines à vecteurs de support (SVM). Cette technique est utilisée pour classer des données en trouvant une hyperplan qui sépare au mieux les différentes classes. Elle peut également utiliser des noyaux non linéaires (comme le noyau RBF) pour traiter des problèmes de classification complexes.

Importation :

from sklearn.svm import SVC

Attributs :

Paramètre	Description
`kernel`	Le type de noyau à utiliser. Par défaut, c'est `'rbf'` (Radial Basis Function). D'autres options incluent `'linear'`, `'poly'`, `'sigmoid'` et `'precomputed'`.
`C`	Le paramètre de régularisation. Par défaut, il est égal à `1.0`. Plus il est grand, plus le modèle sera sensible aux erreurs de classification. Un petit `C` permet un modèle plus lisse.
`degree`	Le degré du polynôme pour les noyaux polynomiaux. Par défaut, il est égal à `3`. Il n'a d'impact que si `kernel` est `'poly'`.
`gamma`	Le paramètre gamma pour les noyaux 'rbf', 'poly', et 'sigmoid'. Par défaut, il est égal à `'scale'`, ce qui signifie que `gamma = 1 / (n_features * X.var())`. Si `gamma = 'auto'`, alors `gamma = 1 / n_features`.
`coef0`	Le paramètre indépendant dans les noyaux 'poly' et 'sigmoid'. Par défaut, il est égal à `0.0`.
`probability`	Si `True`, l'algorithme va calculer les probabilités de classe en plus des décisions de classe, ce qui permet d'utiliser `predict_proba()` pour obtenir ces probabilités. Par défaut, il est égal à `False`.
`shrinking`	Si `True`, l'optimisation sera effectuée avec l'algorithme de shrinking, ce qui peut accélérer l'entraînement. Par défaut, il est égal à `True`.
`tol`	Le critère de tolérance pour l'arrêt de l'optimisation. Par défaut, il est égal à `1e-3`.
`max_iter`	Le nombre maximal d'itérations pour l'optimisation. Par défaut, il est égal à `-1`, ce qui signifie qu'il n'y a pas de limite.

Exemple de code :

# Importation de la classe SVC
from sklearn.svm import SVC

# Création du modèle SVM avec un noyau RBF et un paramètre C égal à 1
model = SVC(kernel='rbf', C=1.0, gamma='scale')

# Exemple de données d'entrée (X) et les labels associés (y)
X = [[0, 0], [1, 1], [2, 2], [3, 3]]
y = [0, 1, 1, 0]

# Entraînement du modèle sur les données
model.fit(X, y)

# Prédiction des classes pour de nouvelles données
predictions = model.predict([[1.5, 1.5]])

# Affichage des résultats
print(predictions)

Explication du code :

Création du modèle SVM
model = SVC(kernel='rbf', C=1.0, gamma='scale') crée un modèle SVM avec les paramètres suivants :

kernel='rbf' : le noyau RBF (Radial Basis Function) permet de gérer des frontières de décision non linéaires.

C=1.0 : paramètre de régularisation. Une valeur plus élevée donne plus d’importance à l’exactitude sur les données d'entraînement (moins de marge d’erreur).

gamma='scale' : définit automatiquement la valeur de gamma (contrôle l’influence d’un seul exemple d’entraînement) en fonction des données.

Données d’entrée
X = [[0, 0], [1, 1], [2, 2], [3, 3]] définit les exemples d’entrée avec deux caractéristiques chacun (x₁, x₂).

y = [0, 1, 1, 0] indique les classes associées à chaque exemple (binaire ici : 0 ou 1).

Entraînement du modèle
model.fit(X, y) entraîne le modèle SVM sur les données d’entrée X et les étiquettes y. Le SVM cherche à créer une frontière optimale entre les classes 0 et 1.

Prédiction sur de nouvelles données
predictions = model.predict([[1.5, 1.5]]) utilise le modèle entraîné pour prédire la classe de l’exemple [1.5, 1.5]. Le modèle estime à quelle classe appartient ce point en fonction de la frontière qu’il a apprise.

Affichage des résultats
print(predictions) affiche la classe prédite (0 ou 1) pour l’exemple fourni. Cela permet de vérifier le comportement du modèle sur des données jamais vues.