Cosa Sono le Support Vector Machines
Le Support Vector Machines (SVM) sono algoritmi di ML supervisionato estremamente potenti per la classificazione e la regressione. L'idea centrale è trovare l'iperpiano che separa le classi con il margine massimo possibile. I punti più vicini all'iperpiano, chiamati support vectors, sono quelli che definiscono il confine decisionale: tutto il resto dei dati è irrilevante per la posizione dell'iperpiano.
Questa proprietà rende le SVM particolarmente robuste: il modello dipende solo da un piccolo sottoinsieme dei dati di training. Inoltre, grazie al kernel trick, le SVM possono gestire separazioni non lineari proiettando i dati in spazi ad alta dimensione dove diventano linearmente separabili.
Cosa Imparerai in Questo Articolo
- Il concetto di iperpiano e margine massimo
- Hard margin vs soft margin: tolleranza agli errori
- Il kernel trick per separazioni non lineari
- Iperparametri C e gamma: come tunarli
- SVM multiclass con one-vs-rest
- Implementazione pratica con scikit-learn
Margine Massimo e Support Vectors
In un problema di classificazione binaria, esistono infiniti iperpiani che possono separare due classi. La SVM sceglie quello con il margine massimo: la distanza tra l'iperpiano e i punti più vicini di ciascuna classe. Massimizzare il margine migliora la generalizzazione del modello su dati mai visti. I punti che giacciono esattamente sul margine sono i support vectors.
L'hard margin SVM richiede che nessun punto cada dentro il margine o dalla parte sbagliata. Questo funziona solo con dati perfettamente separabili. Il soft margin SVM introduce il parametro C che controlla il tradeoff tra massimizzare il margine e minimizzare le violazioni: un C alto penalizza severamente le violazioni (margine stretto), un C basso tollera più errori (margine ampio, più regolarizzazione).
from sklearn.svm import SVC, LinearSVC
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, classification_report
from sklearn.pipeline import Pipeline
# Dataset
data = load_breast_cancer()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# Pipeline con scaling (FONDAMENTALE per SVM!)
svm_pipeline = Pipeline([
('scaler', StandardScaler()),
('svm', SVC(kernel='linear', C=1.0, random_state=42))
])
svm_pipeline.fit(X_train, y_train)
y_pred = svm_pipeline.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.3f}")
print(f"\n{classification_report(y_test, y_pred, target_names=data.target_names)}")
# Numero di support vectors per classe
svm_model = svm_pipeline.named_steps['svm']
print(f"Support vectors per classe: {svm_model.n_support_}")
print(f"Totale support vectors: {sum(svm_model.n_support_)} su {len(X_train)} campioni")Il Kernel Trick: Separazioni Non Lineari
Quando i dati non sono linearmente separabili, il kernel trick proietta i dati in uno spazio a dimensione superiore dove diventano separabili. Il trucco è che questa proiezione avviene implicitamente attraverso una funzione kernel, senza mai calcolare esplicitamente le coordinate nello spazio ad alta dimensione.
I kernel più comuni sono: RBF (Radial Basis Function), il più versatile, che misura la similarità tra punti come una gaussiana; Polynomial, che cattura interazioni tra feature fino a un certo grado; Sigmoid, simile a una rete neurale a un livello. La scelta del kernel dipende dalla geometria dei dati.
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.datasets import make_moons
import numpy as np
# Dataset non linearmente separabile
X, y = make_moons(n_samples=500, noise=0.2, random_state=42)
# Confronto kernel
kernels = {
'linear': {'svm__C': [0.1, 1, 10]},
'rbf': {'svm__C': [0.1, 1, 10], 'svm__gamma': ['scale', 'auto', 0.1, 1]},
'poly': {'svm__C': [0.1, 1, 10], 'svm__degree': [2, 3, 4]}
}
for kernel, params in kernels.items():
pipeline = Pipeline([
('scaler', StandardScaler()),
('svm', SVC(kernel=kernel, random_state=42))
])
grid = GridSearchCV(pipeline, params, cv=5, scoring='accuracy', n_jobs=-1)
grid.fit(X, y)
print(f"Kernel {kernel:<8s} - Best accuracy: {grid.best_score_:.3f}")
print(f" Best params: {grid.best_params_}")Tuning degli Iperparametri
Le SVM hanno due iperparametri cruciali: C (regolarizzazione) e gamma (per kernel RBF e poly). C controlla il tradeoff margine/errori: valori alti di C cercano di classificare correttamente ogni punto di training (rischio overfitting), valori bassi tollerano più errori per un margine più ampio (rischio underfitting).
Gamma controlla il raggio di influenza di ogni support vector: un gamma alto rende il modello sensibile a punti singoli (overfitting), un gamma basso rende il decision boundary più smooth (underfitting). La combinazione ottimale di C e gamma si trova con Grid Search o Random Search con cross-validation.
Scaling obbligatorio: Le SVM sono sensibili alla scala delle feature. Se una feature va da 0 a 1 e un'altra da 0 a 1000, la seconda dominerà il calcolo delle distanze. Usa sempre StandardScaler o MinMaxScaler prima della SVM. Questo è l'errore più comune con le SVM.
SVM Multiclass e Regressione
Le SVM sono nativamente binarie, ma scikit-learn supporta la classificazione multiclass tramite la strategia one-vs-rest (OvR): per N classi si addestrano N classificatori, ognuno che distingue una classe da tutte le altre. La classe predetta è quella con il punteggio più alto.
Per la regressione, SVR (Support Vector Regression) usa lo stesso principio ma cerca un tubo (epsilon-tube) che contenga il maggior numero di punti. I punti fuori dal tubo diventano i support vectors. Anche qui il kernel trick permette regressioni non lineari.
Quando Usare le SVM
Le SVM eccellono con dataset di dimensione media (fino a decine di migliaia di campioni), in spazi ad alta dimensione, e quando le classi sono ben separate con margini netti. Sono meno adatte per dataset molto grandi (la complessità di training scala quadraticamente), per dataset molto rumorosi e quando servono probabilità calibrate (la SVM nativa non le produce, serve un'ulteriore calibrazione).
Punti Chiave
- Le SVM trovano l'iperpiano con margine massimo tra le classi
- I support vectors sono i punti che definiscono il confine decisionale
- Il kernel trick gestisce separazioni non lineari senza calcoli espliciti nello spazio ad alta dimensione
- C controlla il tradeoff margine/errori, gamma il raggio di influenza dei support vectors
- Lo scaling delle feature è obbligatorio prima di usare le SVM
- Grid Search con cross-validation è il modo standard per trovare i migliori iperparametri