Accueil › Glossaire › SVM

SVM (Support Vector Machine)

Un SVM (Support Vector Machine, ou machine à vecteurs de support) est un algorithme de machine learning supervisé qui trouve l’hyperplan optimal séparant les classes de données avec la marge maximale. Grâce au kernel trick, il peut traiter des problèmes non linéaires en projetant implicitement les données dans un espace de dimension supérieure.

Le principe fondamental : marge maximale

L’idée centrale d’un SVM est simple : étant donné un jeu de données avec deux classes, il existe une infinité d’hyperplans (droites en 2D, plans en 3D, hyperplans en dimension supérieure) capables de séparer les deux classes. Le SVM cherche celui qui maximise la marge, c’est-à-dire la distance entre l’hyperplan et les points les plus proches de chaque classe.

Ces points les plus proches sont les vecteurs de support (support vectors). Ils sont les seuls à influencer la position de l’hyperplan. Tous les autres points du dataset pourraient disparaître sans changer le modèle. C’est ce qui rend le SVM économe en mémoire : la fonction de décision ne dépend que d’un sous-ensemble des données d’entraînement.

Maximiser la marge a un effet direct sur la généralisation : un hyperplan éloigné des points les plus proches est plus robuste face à des données nouvelles légèrement différentes des données d’entraînement. C’est l’un des fondements théoriques de la puissance des SVM.

Marge dure vs marge souple

La version originale de Vapnik (1963) cherche un hyperplan qui sépare parfaitement les classes, soit une marge dure (hard margin). En pratique, les données réelles contiennent du bruit et des chevauchements entre classes.

La marge souple (soft margin), introduite par Cortes et Vapnik en 1995, autorise certains points à franchir la marge, voire à être mal classés. Le paramètre C contrôle ce compromis : un C élevé pénalise fortement les erreurs (frontière complexe, risque de surapprentissage), un C faible accepte plus d’erreurs (frontière plus lisse, meilleure généralisation).

Le kernel trick : la force du SVM

Beaucoup de problèmes réels ne sont pas linéairement séparables : aucun hyperplan ne peut séparer proprement les classes dans l’espace d’origine. Le kernel trick (astuce du noyau) résout ce problème de manière élégante.

L’idée : projeter les données dans un espace de dimension beaucoup plus grande (parfois infinie) où elles deviennent linéairement séparables, puis trouver l’hyperplan optimal dans cet espace. La magie du kernel trick est que cette projection n’est jamais calculée explicitement. Le SVM n’a besoin que du produit scalaire entre les points dans l’espace transformé, et ce produit scalaire est calculé directement par une fonction noyau (kernel) appliquée aux données originales.

Résultat : le SVM travaille « comme si » les données étaient dans un espace de très haute dimension, sans payer le coût computationnel de cette transformation.

Les principaux kernels

Le paramètre gamma

Pour le kernel RBF, gamma (γ) contrôle la portée d’influence de chaque point d’entraînement. Un gamma élevé signifie que chaque point n’influence que ses voisins très proches (frontière complexe, risque de surapprentissage). Un gamma faible signifie que chaque point influence une zone large (frontière lisse, risque de sous-apprentissage).

L’interaction entre C et gamma est cruciale : les deux doivent être optimisés conjointement, typiquement par grid search avec validation croisée.

Implémentation avec scikit-learn

scikit-learn (version 1.8.0 en mars 2026) fournit trois classes SVM principales pour la classification :

SVC : implémentation complète basée sur libsvm. Supporte tous les kernels, les vecteurs de support, les probabilités calibrées. Complexité O(n²) à O(n³), donc limité à quelques dizaines de milliers d’échantillons.
LinearSVC : implémentation basée sur liblinear, optimisée pour le kernel linéaire. Supporte la pénalisation L1 et L2. Scale bien à des centaines de milliers d’échantillons.
NuSVC : variante de SVC avec un paramètre nu (ν) au lieu de C, qui contrôle directement la fraction de vecteurs de support.

Exemple de classification

from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

# Charger les données
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
)

# Pipeline : normalisation + SVM
# La normalisation est CRUCIALE pour les SVM
pipe = make_pipeline(
    StandardScaler(),
    SVC(kernel='rbf')
)

# Grid search pour C et gamma
param_grid = {
    'svc__C': [0.1, 1, 10, 100],
    'svc__gamma': ['scale', 'auto', 0.01, 0.001]
}

search = GridSearchCV(pipe, param_grid, cv=5, scoring='accuracy')
search.fit(X_train, y_train)

print(f"Meilleurs paramètres : {search.best_params_}")
print(f"Score test : {search.score(X_test, y_test):.4f}")

SVM pour la régression (SVR)

Les SVM ne sont pas limités à la classification. Le SVR (Support Vector Regression) utilise la même logique de marge, mais au lieu de séparer des classes, il cherche un tube (epsilon-tube) autour de la fonction de régression. Les points à l’intérieur du tube ne contribuent pas à la loss.

from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

svr = make_pipeline(
    StandardScaler(),
    SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
)
svr.fit(X_train, y_train)
predictions = svr.predict(X_test)

LinearSVC pour les gros datasets

Quand votre dataset dépasse 10 000 échantillons et que vous utilisez un kernel linéaire, LinearSVC est le bon choix. Son implémentation basée sur liblinear a une complexité quasi-linéaire en nombre d’échantillons, contre O(n²) ou O(n³) pour SVC.

from sklearn.svm import LinearSVC

model = make_pipeline(
    StandardScaler(),
    LinearSVC(C=1.0, max_iter=10000, dual='auto')
)
model.fit(X_train, y_train)

Pour les très gros datasets (millions d’échantillons), SGDClassifier avec loss='hinge' est une alternative encore plus rapide qui optimise la même fonction de coût qu’un SVM linéaire par descente de gradient stochastique.

Hyperparamètres et tuning

La méthode standard de tuning est le grid search avec validation croisée 5-fold :

# Grid search typique pour SVM RBF
param_grid = {
    'svc__C': [0.01, 0.1, 1, 10, 100, 1000],
    'svc__gamma': [1, 0.1, 0.01, 0.001, 0.0001, 'scale']
}

# Ou utiliser RandomizedSearchCV pour un espace plus large
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import loguniform

param_dist = {
    'svc__C': loguniform(1e-3, 1e3),
    'svc__gamma': loguniform(1e-5, 1e1)
}

random_search = RandomizedSearchCV(
    pipe, param_dist, n_iter=50, cv=5, random_state=42
)
random_search.fit(X_train, y_train)

Forces et limites

Pourquoi utiliser un SVM

Efficace en haute dimension : les SVM fonctionnent bien même quand le nombre de features dépasse le nombre d’échantillons (cas typique en bioinformatique, analyse de texte, génomique).

Économe en mémoire : la fonction de décision ne dépend que des vecteurs de support, un sous-ensemble des données d’entraînement.

Résistant au bruit : la maximisation de la marge rend le modèle robuste face aux données bruitées et aux outliers (avec un C bien réglé).

Fondements théoriques solides : la théorie de Vapnik-Chervonenkis fournit des garanties de généralisation, ce qui rassure dans les domaines réglementés (finance, santé).

Fonctionne bien avec peu de données : contrairement au deep learning qui a besoin de millions d’exemples, un SVM peut produire d’excellents résultats avec quelques centaines ou milliers de points.

Limites à connaître

Ne scale pas aux gros datasets : la complexité d’entraînement de SVC est O(n²) à O(n³). Au-delà de ~50 000 échantillons, l’entraînement devient prohibitif avec des kernels non linéaires. LinearSVC ou SGDClassifier contournent ce problème pour le cas linéaire.

Pas de probabilités natives : les SVM produisent des scores de décision, pas des probabilités. Le calibrage via Platt scaling est coûteux et imprécis sur les petits datasets.

Sensible au prétraitement : la normalisation est obligatoire, le choix du kernel et le tuning de C/gamma sont critiques. Un SVM mal paramétré peut être nettement moins bon qu’un modèle plus simple.

Multiclasse par contournement : les SVM sont nativement binaires. Pour K classes, scikit-learn utilise une stratégie one-vs-one (K*(K-1)/2 classifieurs) qui multiplie le temps de calcul.

Pas de gestion native des catégorielles : contrairement à CatBoost ou LightGBM, les SVM nécessitent un encodage numérique de toutes les features.

SVM vs les alternatives modernes

Verdict : quand utiliser un SVM

Les SVM restent pertinents en 2026, mais leur niche s’est réduite. Utilisez un SVM quand :

Votre dataset est petit à moyen (moins de 50 000 échantillons) et que les données sont structurées. C’est le terrain de jeu naturel du SVM.
Vous avez plus de features que d’échantillons : bioinformatique, génomique, analyse de texte avec TF-IDF. Le SVM linéaire excelle dans ce cas.
Vous avez besoin de garanties théoriques : dans les domaines réglementés (finance, santé), la base théorique solide du SVM est un atout.
Les données sont bien séparées avec un peu de bruit : le SVM est naturellement robuste aux outliers grâce à la marge souple.

Ne l’utilisez pas pour des images (utilisez un CNN ou un Vision Transformer), du texte libre au-delà du TF-IDF (utilisez un LLM ou un BERT), ni pour des données tabulaires massives (utilisez XGBoost, LightGBM ou CatBoost).

Cas d’usage concrets

Classification de texte et spam : le SVM linéaire sur des features TF-IDF est un classique qui reste compétitif. La haute dimensionnalité du texte vectorisé joue en faveur du SVM.

Bioinformatique et génomique : classification de protéines, prédiction de structures, analyse d’expression génique. Les datasets sont petits mais en très haute dimension, ce qui correspond exactement au profil idéal du SVM.

Détection de fraude financière : sur des datasets structurés de taille modérée, le SVM avec kernel RBF fournit des modèles robustes et interprétables, un critère important dans le secteur bancaire.

Détection d’intrusion réseau : les SVM sont utilisés pour classifier le trafic réseau comme normal ou suspect, en exploitant leur résistance au bruit et leur efficacité en haute dimension.

Reconnaissance d’écriture manuscrite : historiquement l’un des premiers succès des SVM, ce cas d’usage reste un benchmark classique même si les CNN dominent désormais sur les datasets plus larges.

Imagerie médicale : pour la classification de petits datasets annotés (quelques centaines d’images), un SVM sur des features extraites par un réseau pré-entraîné (transfer learning + SVM) reste une approche efficace et rapide.

Bonnes pratiques

Normalisez systématiquement. Utilisez StandardScaler dans un Pipeline scikit-learn pour éviter les fuites de données entre train et test. C’est non négociable.

Commencez par le kernel RBF. C’est le défaut de scikit-learn pour une bonne raison : il est polyvalent et gère la non-linéarité. Ne changez que si vous avez une raison précise.

Optimisez C et gamma ensemble. Ces deux paramètres interagissent fortement. Un grid search sur des puissances de 10 (C de 0.01 à 1000, gamma de 0.0001 à 10) avec validation croisée 5-fold est la méthode standard.

Utilisez LinearSVC ou SGDClassifier pour les gros volumes. Si votre dataset dépasse 10 000 échantillons et que le kernel linéaire suffit, SVC(kernel='linear') est un mauvais choix : LinearSVC est des ordres de grandeur plus rapide.

Gérez les classes déséquilibrées. Le paramètre class_weight='balanced' ajuste automatiquement les poids en fonction de la fréquence des classes. Indispensable pour la détection de fraude ou le diagnostic médical.

N’activez probability=True que si nécessaire. Le calibrage de probabilités via Platt scaling ajoute un coût significatif (cross-validation 5-fold interne) et peut ralentir l’entraînement de manière importante.