SVM à Noyau RBF : Guide complet — Principes, Exemples et Implémentation Python

Résumé

Le SVM à noyau RBF (Radial Basis Function, fonction à base radiale) est l’une des variantes les plus puissantes et les plus utilisées des machines à vecteurs de support. Contrairement au SVM linéaire qui ne sait tracer que des droites ou des hyperplans de séparation, le SVM RBF est capable de modéliser des frontières de décision hautement non linéaires grâce à l’astuce du noyau (kernel trick). Cette technique projette implicitement les données dans un espace de dimensions infinies où elles deviennent linéairement séparables. L’hyperparamètre gamma contrôle la portée de chaque vecteur de support : un gamma élevé produit des frontières très flexibles (risque de surapprentissage), tandis qu’un gamma faible génère des zones plus lisses. Dans ce guide, nous étudierons les fondements mathématiques du noyau RBF, son intuition visuelle, un exemple complet d’implémentation avec scikit-learn, et quatre cas d’usage concrets.

Principe mathématique du SVM à noyau RBF

L’astuce du noyau (Kernel Trick)

Le problème fondamental du SVM classique est qu’il recherche un hyperplan linéaire séparateur. Lorsque les données ne sont pas linéairement séparables dans l’espace d’origine — ce qui est fréquent dans les applications réelles — le SVM échoue.

L’idée de l’astuce du noyau est géniale dans sa simplicité : plutôt que de calculer explicitement les coordonnées des données dans un espace de plus haute dimension (ce qui serait coûteux, voire impossible), on calcule directement le produit scalaire entre les images des points dans cet espace transformé. Cette quantité s’exprime comme une fonction de noyau K(x, x’) qui opère directement dans l’espace d’origine.

Le noyau RBF : définition

Le noyau RBF, également appelé noyau gaussien, est défini par :

K(x, x') = exp(-γ ||x - x'||²)

où :
– x et x’ sont deux vecteurs d’entrée dans l’espace d’origine,
– ||x – x’||² est le carré de la distance euclidienne entre ces deux points,
– γ (gamma) est un paramètre positif qui contrôle la largeur de la fonction gaussienne.

Ce noyau possède une propriété remarquable : il correspond à un produit scalaire dans un espace de Hilbert à reproduire noyau (RKHS) de dimension infinie. Autrement dit, le noyau RBF projette implicitement chaque point de données dans un espace de features de dimension infinie, sans jamais avoir à calculer ces coordonnées explicitement. C’est la puissance de l’astuce du noyau.

Formulation duale avec le noyau RBF

Le problème d’optimisation dual du SVM s’écrit :

max(α)  Σ αᵢ - ½ ΣΣ αᵢ αⱼ yᵢ yⱼ K(xᵢ, xⱼ)

sous les contraintes 0 ≤ αᵢ ≤ C et Σ αᵢ yᵢ = 0.

Avec le noyau RBF, le terme K(xᵢ, xⱼ) remplace le produit scalaire classique du SVM linéaire. La fonction de décision finale devient :

f(x) = signe( Σ_{i ∈ SV} αᵢ yᵢ exp(-γ ||xᵢ - x||²) + b )

où SV désigne l’ensemble des vecteurs de support (les points pour lesquels αᵢ > 0). Seuls ces points contribuent à la classification, ce qui rend le modèle élégant et efficace.

Intuition : les bulles d’influence

Pour comprendre le noyau RBF de manière intuitive, imaginez que chaque vecteur de support émet une bulle d’influence autour de lui. La forme de cette bulle est gaussienne : l’influence est maximale au centre (sur le vecteur de support lui-même, où K = 1) et décroît exponentiellement avec la distance.

Le paramètre gamma détermine la taille de ces bulles :

• Gamma élevé (γ ≫ 1) : les bulles sont petites et très localisées. Chaque vecteur de support n’influence qu’un voisinage très proche. La frontière de décision devient extrêmement sinueuse, pouvant épouser le moindre détail des données d’entraînement. Risque de surapprentissage élevé.
• Gamma faible (γ ≪ 1) : les bulles sont larges et s’étendent loin. La frontière est plus lisse et plus générale, mais elle peut être trop simple pour capturer la structure réelle des données. Risque de sous-apprentissage.
• Gamma modéré : c’est le « sweet spot ». Les bulles couvrent suffisamment de terrain pour capturer les motifs importants sans se perdre dans le bruit.

On peut aussi interpréter γ comme l’inverse de la variance de la gaussienne : γ = 1/(2σ²). Un grand γ correspond à une variance petite (bulles étroites), un petit γ à une variance grande (bulles larges).

Implémentation Python complète

Configuration de base et génération des données

Nous utiliserons des données make_moons pour illustrer la supériorité du noyau RBF face à un SVM linéaire sur des problèmes non linéairement séparables.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.datasets import make_moons, make_circles
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.metrics import classification_report, accuracy_score
from sklearn.preprocessing import StandardScaler

# --- Génération des données ---
X, y = make_moons(n_samples=500, noise=0.15, random_state=42)

# Division entraînement / test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Standardisation (recommandée pour le SVM RBF)
scaler = StandardScaler()
X_train_sc = scaler.fit_transform(X_train)
X_test_sc = scaler.transform(X_test)

La standardisation est cruciale pour le SVM à noyau RBF. Puisque le noyau repose sur la distance euclidienne, des features sur des échelles différentes fausseraient complètement les calculs.

Comparaison : SVM linéaire vs SVM RBF

# SVM linéaire
svm_linear = SVC(kernel='linear', C=1.0, random_state=42)
svm_linear.fit(X_train_sc, y_train)
print(f"SVM Linéaire accuracy : {svm_linear.score(X_test_sc, y_test):.4f}")

# SVM à noyau RBF (paramètres par défaut)
svm_rbf = SVC(kernel='rbf', C=1.0, gamma='scale', random_state=42)
svm_rbf.fit(X_train_sc, y_train)
print(f"SVM RBF accuracy     : {svm_rbf.score(X_test_sc, y_test):.4f}")

Sur des données en forme de demi-lunes (moons), le SVM linéaire atteint typiquement ~85 % de précision car il ne peut tracer qu’une droite. Le SVM RBF, lui, dépasse souvent 95 % en épousant la courbe des données.

Tracé de la frontière de décision

def plot_decision_boundary(model, X, y, title, scaler_obj=None):
    # Trace la frontière de décision d'un classifieur 2D
    # Grille de points
    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
    xx, yy = np.meshgrid(
        np.linspace(x_min, x_max, 300),
        np.linspace(y_min, y_max, 300)
    )
    grid = np.c_[xx.ravel(), yy.ravel()]

    if scaler_obj is not None:
        grid = scaler_obj.transform(grid)

    Z = model.predict(grid).reshape(xx.shape)

    fig, ax = plt.subplots(figsize=(8, 6))
    ax.contourf(xx, yy, Z, levels=[-0.5, 0.5, 1.5],
                colors=['#66c2a5', '#fc8d62'], alpha=0.3)
    ax.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm',
               edgecolors='k', s=30, alpha=0.8)

    # Vecteurs de support
    sv = model.support_vectors_
    if scaler_obj is not None:
        sv = scaler_obj.inverse_transform(sv)
    ax.scatter(sv[:, 0], sv[:, 1], facecolors='none',
               edgecolors='gold', s=120, linewidths=1.5,
               label=f'Vecteurs de support ({len(sv)})')

    ax.set_title(title, fontsize=14, fontweight='bold')
    ax.set_xlabel('Feature 1')
    ax.set_ylabel('Feature 2')
    ax.legend()
    plt.tight_layout()
    plt.show()

# Visualisation
plot_decision_boundary(svm_linear, X_test, y_test,
                        'SVM Linéaire', scaler_obj=scaler)
plot_decision_boundary(svm_rbf, X_test, y_test,
                        'SVM à Noyau RBF', scaler_obj=scaler)

Optimisation des hyperparamètres par Grid Search

# Recherche sur grille de (C, gamma)
param_grid = {
    'C': [0.1, 1, 10, 100],
    'gamma': ['scale', 'auto', 0.01, 0.1, 1, 10]
}

grid = GridSearchCV(
    SVC(kernel='rbf', random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)
grid.fit(X_train_sc, y_train)

print(f"Meilleurs paramètres : {grid.best_params_}")
print(f"Meilleure accuracy CV  : {grid.best_score_:.4f}")

# Évaluation finale
best_model = grid.best_estimator_
test_acc = best_model.score(X_test_sc, y_test)
print(f"Accuracy test          : {test_acc:.4f}")

# Rapport détaillé
y_pred = best_model.predict(X_test_sc)
print("\nRapport de classification :")
print(classification_report(y_test, y_pred, target_names=['Classe 0', 'Classe 1']))

Le grid search explore systématiquement toutes les combinaisons de C et γ et retient celle qui maximise la performance en validation croisée à 5 plis. Cette approche est fortement recommandée en pratique.

Exemple avec make_circles

Le dataset make_circles offre un test encore plus visuel : deux cercles concentriques, impossibles à séparer linéairement.

X_circ, y_circ = make_circles(
    n_samples=600, noise=0.08, factor=0.4, random_state=42
)
Xc_train, Xc_test, yc_train, yc_test = train_test_split(
    X_circ, y_circ, test_size=0.3, random_state=42, stratify=y_circ
)

scaler_c = StandardScaler()
Xc_train_sc = scaler_c.fit_transform(Xc_train)
Xc_test_sc = scaler_c.transform(Xc_test)

svm_circles = SVC(kernel='rbf', C=10, gamma=1.0, random_state=42)
svm_circles.fit(Xc_train_sc, yc_train)
print(f"Cercles - accuracy test : {svm_circles.score(Xc_test_sc, yc_test):.4f}")

plot_decision_boundary(svm_circles, Xc_test, yc_test,
                        'SVM RBF sur Cercles Concentriques', scaler_obj=scaler_c)

Nombre de vecteurs de support

Un indicateur utile du comportement du SVM RBF est le nombre de vecteurs de support :

n_sv = svm_rbf.n_support_
print(f"Vecteurs de support par classe : {n_sv}")
print(f"Total : {n_sv.sum()}")
print(f"Proportion : {n_sv.sum() / len(X_train_sc):.2%}")

Un pourcentage très élevé (> 60 %) suggère que le modèle mémorise les données (surapprentissage). Un pourcentage très faible peut indiquer un sous-apprentissage.

Hyperparamètres du SVM RBF

C : paramètre de régularisation

C contrôle le compromis entre une marge large et un faible nombre d’erreurs de classification sur l’ensemble d’entraînement.

Gamma : portée d’influence

Valeurs spéciales dans scikit-learn :
– 'scale' (défaut) : γ = 1 / (n_features × Var(X))
– 'auto' : γ = 1 / n_features

Autres paramètres pertinents

• degree : non utilisé avec le noyau RBF (pertinent uniquement pour le noyau polynomial).
• kernel : doit être 'rbf' dans notre cas.
• max_iter : nombre maximal d’itérations de l’optimiseur SMO. La valeur -1 (absence de limite) est recommandée.

Avantages et limites du SVM à noyau RBF

Avantages

• Puissance expressive : grâce à la projection en dimension infinie, le SVM RBF peut approximer n’importe quelle frontière de décision continue avec une précision arbitraire (théorème de Stone-Weierstrass généralisé).
• Robustesse au surapprentissage : malgré sa flexibilité, le principe de maximisation de la marge et la régularisation par C offrent une bonne généralisation.
• Efficace en haute dimension : performant même lorsque le nombre de features excède le nombre d’échantillons.
• Pas d’hypothèse sur la distribution : méthode non paramétrique, aucune hypothèse de normalité nécessaire.
• Solution globale : le problème d’optimisation est convexe, garantissant l’atteinte du minimum global (contrairement aux réseaux de neurones).

Limitations

• Coût computationnel : la complexité d’entraînement est en O(n²) à O(n³), où n est le nombre d’échantillons. Impraticable au-delà de ~50 000 échantillons.
• Sensibilité au scaling : nécessite une standardisation rigoureuse des features.
• Difficile à interpréter : la frontière de décision dans l’espace original n’est pas directement lisible.
• Pas de probabilités natives : les scores de décision ne sont pas des probabilités (bien que predict_proba soit disponible via calibrage Platt).
• Sensible aux outliers : les points aberrants peuvent devenir des vecteurs de support et déformer la frontière.

4 cas d’usage concrets

1. Diagnostic médical

Classification de tumeurs bénignes vs malignes à partir de caractéristiques morphologiques de cellules (dataset Breast Cancer de Wisconsin). Les relations entre features sont souvent non linéaires, ce qui rend le noyau RBF particulièrement adapté pour capturer ces interactions complexes.

2. Reconnaissance d’écriture manuscrite

Distinction entre chiffres manuscrits (dataset digits de scikit-learn ou MNIST). Chaque pixel est une feature, et les patterns visuels créent des frontières hautement non linéaires dans l’espace des pixels. Le SVM RBF atteint des performances compétitives sur ces tâches.

3. Détection de fraude financière

Identification de transactions frauduleuses parmi des millions d’opérations légitimes. Les signaux de fraude sont subtils et non linéaires : montants inhabituels, horaires atypiques, combinaisons de caractéristiques géographiques. Le SVM RBF modélise bien ces interactions complexes.

4. Classification de texte (catégorisation)

Affectation de documents à des catégories thématiques (sport, politique, technologie…) à partir de représentations TF-IDF ou bag-of-words. Avec des milliers de features creuses, le SVM RBF offre une bonne capacité de généralisation et est souvent le modèle de référence en classification de texte avant l’avènement des transformers.

Voir aussi

• Somme des Chemins en Python : Quatre Méthodes Incontournables pour Maîtriser l’Algorithme
• Démystifier la Constante de Champernowne en Python : Guide Complet et Tutoriel Pratique