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

Le svm noyau polynomial généralise le SVM linéaire en projetant les données dans un espace de features polynomial de degré contrôlé. Contrairement au noyau RBF qui crée des bulles locales, le polynomial dessine des frontières courbes globales — idéal quand la relation entre classes suit une géométrie algébrique.

Ce guide explore en profondeur le svm noyau polynomial : de la théorie du kernel polynomial à l’implémentation pratique avec scikit-learn.

Principe mathématique

Le noyau polynomial

Le noyau polynomial est défini par la fonction :

K(x, x') = (γ · x·x' + r)^d

où :
– x·x’ est le produit scalaire entre les vecteurs (similarité linéaire)
– γ (gamma) est un coefficient d’échelle (par défaut 1/n_features)
– r (coef0) est le terme constant — contrôle l’importance relative des termes de degré supérieur vs inférieur
– d (degree) est le degré du polynôme — détermine la complexité des frontières

L’astuce du noyau (kernel trick)

Sous projection explicite dans un espace polynomial de degré d, le nombre de features explose. Par exemple, avec 100 variables et d=3, on obtiendrait C(103,3) = 176 851 features. Le kernel trick calcule les similarités directement dans l’espace d’origine — le calcul reste O(n), pas O(C(n,d)).

Formulation duale

Le problème d’optimisation est identique au SVM linéaire mais avec le kernel polynomial :

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

sous contraintes : 0 ≤ αᵢ ≤ C et Σαᵢyᵢ = 0. La fonction de décision devient :

f(x) = sign(Σ αᵢyᵢK(xᵢ, x) + b)

Le rôle du degré d

• d = 1 : le SVM linéaire (K = γ·x·x’ + r)
• d = 2 : frontières quadratiques (paraboles, ellipses, hyperboles)
• d = 3 : courbes cubiques — flexibilité accrue, risque de surapprentissage
• d ≥ 4 : très haute capacité — souvent excessif sauf motifs très structurés

Le paramètre coef0 (r)

• r = 0 : noy polynomial homogène
• r > 0 : noyau non-homogène — ajoute un biais qui donne plus de poids aux termes de bas degré quand ||x·x’|| est petit

Intuition — Comment le comprendre ?

Le SVM linéaire ne peut tracer qu’une droite. Le noyau polynomial dessine des courbes algébriques dont la forme est contrôlée par le degré :

• Degré 2 : paraboles, cercles, ellipses — souvent suffisant pour les problèmes de type XOR
• Degré 3 : les courbes peuvent s’inverser, créer des S — plus de liberté mais attention au surapprentissage
• Rôle de gamma : un gamma élevé rend les frontières plus serrées, un gamma faible les lisse
• Rôle de coef0 : shift vertical du polynôme — avec r=0, un point à l’origine est toujours du même côté

Comparaison rapide :
– Linéaire : droite — simple, rapide, mais limité
– Polynomial : courbe algébrique de degré fixé — contrôlable, interprétable
– RBF : bulles locales infiniment complexes — puissant mais opaque

Implémentation Python — Exemple complet

Exemple 1 : Classification sur données en cercles

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

# Données non linéairement séparables
X, y = make_circles(n_samples=500, factor=0.3, noise=0.1, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Standardisation essentielle pour les SVM
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# SVM polynomial degré 3
svc_poly = SVC(kernel='poly', degree=3, gamma='scale', coef0=1, C=1.0)
svc_poly.fit(X_train, y_train)

y_pred = svc_poly.predict(X_test)
print(f"Exactitude (poly d=3) : {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=["Interieur", "Exterieur"]))

# Comparaison 3 noyaux
for name, model in [("Lineaire", SVC(kernel='linear', C=1)),
                    ("RBF", SVC(kernel='rbf', gamma='scale', C=1)),
                    ("Poly d=3", svc_poly)]:
    model.fit(X_train, y_train)
    acc = accuracy_score(y_test, model.predict(X_test))
    print(f"{name:15s} -> {acc:.4f}")

Exemple 2 : Impact du degré sur la frontière

degrees = [1, 2, 3, 4, 5, 6]
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
axes = axes.flatten()

for i, d in enumerate(degrees):
    svc = SVC(kernel='poly', degree=d, gamma='scale', coef0=1, C=1.0)
    svc.fit(X_train, y_train)

    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, 200),
                         np.linspace(y_min, y_max, 200))
    Z = svc.decision_function(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)

    axes[i].contourf(xx, yy, Z, levels=20, cmap='RdBu', alpha=0.6)
    axes[i].scatter(X_train[:, 0], X_train[:, 1], c=y_train,
                    cmap='coolwarm', edgecolors='k', s=30)
    tr = accuracy_score(y_train, svc.predict(X_train))
    te = accuracy_score(y_test, svc.predict(X_test))
    axes[i].set_title(f"Degre {d} (train={tr:.0%}, test={te:.0%})")
    axes[i].set_aspect('equal')

plt.suptitle("Impact du degre - SVM polynomial")
plt.tight_layout()
plt.show()

Exemple 3 : Grid Search et surapprentissage

from sklearn.model_selection import GridSearchCV

param_grid = {
    'C': [0.1, 1, 10],
    'degree': [2, 3, 4],
    'gamma': ['scale', 0.1, 1],
    'coef0': [0, 1, 2]
}

grid = GridSearchCV(SVC(kernel='poly'), param_grid, cv=5, n_jobs=-1)
grid.fit(X_train, y_train)
print(f"Meilleurs params: {grid.best_params_}")
print(f"CV accuracy: {grid.best_score_:.4f}")
print(f"Test accuracy: {grid.score(X_test, y_test):.4f}")

# Courbe de surapprentissage par degre
for d in range(1, 11):
    svc = SVC(kernel='poly', degree=d, gamma='scale', coef0=1, C=1.0)
    svc.fit(X_train, y_train)
    tr = accuracy_score(y_train, svc.predict(X_train))
    te = accuracy_score(y_test, svc.predict(X_test))
    print(f"Degre {d:2d} -> train={tr:.4f}, test={te:.4f}")

Hyperparamètres

Guide de choix du degré :
– d = 2 : point de départ, gère XOR et séparations quadratiques
– d = 3 : inversions et courbures complexes
– d ≥ 4 : rarement utile, privilégiez le RBF

Avantages et Limites

Avantages

• Frontières non linéaires contrôlées et interprétables
• Kernel trick évite l’explosion de features
• Bonne alternative au RBF pour les structures géométriques régulières
• Moins sensible au surapprentissage que le RBF pour les petits degrés
• Le degré et coef0 offrent un contrôle intuitif

Limites

• Choix du degré difficile — grid search nécessaire
• Convergence lente pour d ≥ 4
• Moins flexible que le RBF (contraint à la géométrie algébrique)
• Standardisation obligatoire
• Coûteux en mémoire : O(n²) — limite pratique vers 100 000 points

Cas d’usage

1. Reconnaissance de formes géométriques

Quand les données suivent des motifs réguliers (ellipses, paraboles), le svm noyau polynomial de degré 2 est optimal et interprétable.

2. Classification d’images

Les interactions entre descripteurs (couleur × texture) sont naturellement polynomiales. Un degré 2-3 les capture sans calcul explicite.

3. Bioinformatique — interactions protéine-ligand

Les interactions moléculaires ont des dépendances polynomiales entre descripteurs structuraux.

4. Finance — scoring de crédit non linéaire

Quand le risque augmente quadratiquement avec le ratio dettes/revenus, le degré 2 capture cette non-linéarité mieux qu’un modèle linéaire.

Bonnes pratiques

• Standardisez toujours (StandardScaler obligatoire)
• Commencez par d=2 — gère la plupart des cas
• Grid Search sur les 4 paramètres (C, degree, gamma, coef0)
• Surveillez l’écart train/test pour les degrés élevés
• Comparez systématiquement avec le RBF

Voir aussi

• Maîtriser la Logique Circulaire en Python : Guide Complet pour Débutants et Experts
• Maîtriser les Arrangements Maximaux en Python : Guide Complet et Astuces pour Développeurs

Comparaison approfondie : Polynomial vs RBF vs Lineaire

Le choix du noyau est l’une des decisions les plus importantes lorsqu’on utilise un SVM. Voici un guide comparatif detaille pour vous aider a choisir correctement entre les differentes options disponibles dans scikit-learn.

Quand utiliser chaque noyau

Noyau lineaire (kernel=’linear’) :
– Donnees lineairement separables ou presque
– Classification de texte haute dimension (milliers de features)
– Quand l’interpretabilite des coefficients est cruciale
– Gros volumes de donnees (plus de 50 000 echantillons)

Noyau polynomial (kernel=’poly’) :
– Frontieres avec geometrie reguliere (courbes, cercles, ellipses)
– Quand vous voulez controler la complexite via le degre
– Interactions entre features que vous connaissez a priori
– Problemes ou l’interpretabilite du degre a du sens metier

Noyau RBF (kernel=’rbf’) :
– Frontieres complexes et irregulieres
– Pas d’a priori sur la forme geometrique
– Quand la precision prime sur la comprehension
– Donnees de taille moderee (moins de 50 000 echantillons)

Tableau comparatif des performances attendues

Sur le dataset Make_circles (donnees non lineairement separables) :

On observe que le polynomial de degre 2 ou 3 rivalise avec le RBF tout en restant interpretable, alors que les degres trop eleves (d superieur ou egal a 6) surapprennent clairement.

Complexite algorithmique

• Entraînement : O(n au carre multiplie par d) pour le noyau polynomial, ou d est le degre et n le nombre d’echantillons
• Prediction : O(n_sv multiplie par d) ou n_sv est le nombre de vecteurs de support
• Memoire : O(n au carre) pour la matrice de noyau — limite pratique autour de 100 000 echantillons

Bonnes pratiques pour le svm noyau polynomial

1. Standardisez toujours vos donnees avec StandardScaler avant d’entrainer un SVM a noyau polynomial. Les features non standardisees faussent le produit scalaire sous-jacent.
2. Commencez toujours par d=2 : c’est le degre le plus utile en pratique. Il gere la plupart des separations non lineaires simples.
3. Faites une Grid Search obligatoire sur les 4 hyperparametres (C, degree, gamma, coef0). Leur interaction est complexe et contre-intuitive.
4. Surveillez le surapprentissage : l’ecart entre les scores train et test explose pour les degres eleves avec peu de donnees. Utilisez la validation croisee.
5. Comparez systematiquement avec le RBF : incluez toujours SVC(kernel=’rbf’) dans votre benchmark. Le RBF gagnera souvent, mais le polynomial peut etre preferable pour son interpretabilite.
6. Limiter le degree a 5 maximum : au-dela, la convergence devient lente et le surapprentissage quasi certain. Si vous avez besoin de plus de complexite, passez au RBF.