SVM, kernel methods, feature engineering: l'era dominante 1995-2010

Per circa quindici anni, dal 1995 al 2010 abbondante, la Support Vector Machine è stata il classificatore di default in machine learning applicato. Aveva teoria solida, convergenza affidabile, una scatola degli attrezzi (i kernel) per attaccare quasi ogni dominio. Il vero lavoro si era spostato fuori dall’algoritmo: nella progettazione manuale delle feature di input. AlexNet 2012 chiude un’era e ne apre un’altra; capire perché le SVM dominavano e perché poi non bastarono insegna molto sul ruolo di rappresentazione, scala e transferibilita nei modelli moderni.

Perché questo capitolo

Quando AlexNet vince la ImageNet Challenge 2012 con un margine di oltre 10 punti percentuali sul secondo classificato, sta rovesciando un equilibrio. Per quindici anni, la pipeline canonica di un task di classificazione era stata: prendi i dati, costruisci feature manuali con expertise di dominio, addestra una Support Vector Machine, valida con cross-validation. Il “secondo classificato” del 2012 era esattamente questo: feature SIFT/HOG estratte a mano, codebook bag-of-visual-words, SVM con kernel RBF, tuning attento. Era la ricetta dominante. Sotto AlexNet, è diventata storia.

Capire l’era SVM serve per due motivi pratici. Primo, per leggere correttamente il salto del deep learning. Non è un salto da “AI simbolica” a “reti profonde”: è un salto da “ML statistico con feature engineering manuale” a “representation learning end-to-end”. L’avversario battuto da AlexNet non era un sistema esperto degli anni Ottanta; era una pipeline scientifica matura, ben tarata, con bound teorici di generalizzazione in tasca. Capire la potenza di quella pipeline, e i suoi limiti specifici, fa apprezzare perché il deep learning sia stato così disruptive proprio dove è stato disruptive (vision, speech, NLP semantica) e non altrove (tabular data, dataset piccoli, biotech con poche etichette, dove ancora oggi SVM e gradient boosting reggono).

Secondo, perché molte intuizioni dell’era SVM sopravvivono come principi generali nelle architetture posteriori: il prodotto interno come misura di similarità, il principio di massimo margine come idea di robustezza geometrica, la statistical learning theory di Vapnik-Chervonenkis come cornice concettuale per parlare di generalizzazione. La filiazione tecnica puntuale fra SVM e tecniche contemporanee è discussa nelle “Applicazioni pratiche”; va trattata con cautela, perché il rischio di leggere ogni componente moderna come “discendente” di un antenato SVM porta a confondere analogia e filiazione.

C’è una terza ragione, più strategica. L’era SVM è un caso studio di cosa accade quando una comunità scientifica trova un algoritmo “abbastanza buono per quasi tutto” e si adagia. Per quindici anni, lo schema “feature engineering + SVM” era il default sicuro. Il passaggio al deep learning è avvenuto lentamente, contro la resistenza di chi aveva investito una carriera in expertise di feature design. Riconoscere questo pattern aiuta a vedere quando, nel proprio settore, il default sicuro sta diventando un soffitto.

Contesto

Questo capitolo si appoggia su due capitoli che lo precedono. Da rinascita-statistica-90 ricordiamo il quadro generale: dopo il secondo inverno (vedi secondo-inverno-ai), l’AI accademica e industriale rinasce nel paradigma statistico. Bayesian networks, HMM, ensemble di alberi, kernel methods, reinforcement learning iniziale costituiscono insieme il nuovo mainstream. Da reti-neurali-80-90 ricordiamo che le reti neurali, nello stesso periodo, sopravvivono in una nicchia minoritaria — la “Canadian Mafia” di Hinton-LeCun-Bengio — finanziata in modo discontinuo, con pochi successi spettacolari prima del 2012. Questo capitolo racconta la “altra meta del campo”: il paradigma di maggioranza, quello che dominava la pratica industriale e accademica di tutti i giorni.

La storia ha un epicentro geografico preciso: i Bell Labs di Holmdel, nel New Jersey. Nel 1990, dopo la dissoluzione dell’URSS, Vladimir Vapnik (matematico russo-americano, 1936-, prima all’Istituto di Scienze del Controllo di Mosca) si trasferisce a Bell Labs. Le sue idee sulla statistical learning theory, sviluppate dagli anni Sessanta in collaborazione con Alexey Chervonenkis (matematico russo, 1938-2014, annegato durante un’escursione a Mosca), erano fino ad allora pubblicate prevalentemente in russo e quasi sconosciute in occidente. Bell Labs offre la cornice perfetta: una concentrazione unica di matematici, fisici e informatici, libera dalla pressione accademica della pubblicazione veloce.

Nello stesso periodo, ai Bell Labs lavorano anche Yann LeCun (informatico francese, 1960-, futuro premio Turing 2018), che porta avanti la famiglia LeNet di reti convoluzionali per riconoscere cifre scritte a mano, e Bernhard Boser (ingegnere elettronico, attivo poi a Berkeley), Isabelle Guyon (informatica francese, 1961-, futura figura centrale di NeurIPS competition tracks), Larry Jackel, Leon Bottou, Patrice Simard, Corinna Cortes (informatica danese-americana, futuro capo di Google Research New York). Negli stessi corridoi, due paradigmi rivali dell’apprendimento automatico crescono in parallelo: il filone neurale di LeCun e il filone kernel di Vapnik. Bell Labs li ospita entrambi, e per anni li mette in dialogo amichevole ma competitivo.

Il primo risultato concreto del filone kernel arriva nel 1992. Boser, Guyon e Vapnik presentano al COLT (Computational Learning Theory, conferenza annuale di teoria dell’apprendimento) di Pittsburgh il paper “A training algorithm for optimal margin classifiers”. È il battesimo delle Support Vector Machine moderne. Tre anni dopo, nel 1995, Cortes e Vapnik pubblicano su Machine Learning “Support-vector networks”, introducendo il soft margin che rende SVM applicabile a dati reali, non perfettamente separabili. Lo stesso anno, Vapnik pubblica per Springer “The Nature of Statistical Learning Theory”, che diventa il libro di riferimento.

Da quel momento, la diffusione è rapida. Nel 1998 John Platt (informatico statunitense a Microsoft Research) inventa SMO (Sequential Minimal Optimization), l’algoritmo che rende SVM scalabile su decine di migliaia di esempi. Lo stesso anno Thorsten Joachims (informatico tedesco-americano, professor a Cornell) pubblica all’ECML “Text categorization with Support Vector Machines”, lanciando SVM come standard per la classificazione di testo. Dal 2000-2001 in poi, Chih-Chung Chang e Chih-Jen Lin (informatici a National Taiwan University) sviluppano LIBSVM, la libreria di riferimento che porta SVM in C, Python, R, Matlab, Java. Quando nel 2007 lo scikit-learn project parte come Google Summer of Code, il suo SVM è un wrapper di LIBSVM. La diffusione è pervasiva.

Bell Labs come culla, COLT come prima pubblicazione, Microsoft Research come laboratorio dell’algoritmo scalabile, Taiwan come fucina della libreria più diffusa, NeurIPS come arena di crescita: la geografia di SVM è globale fin dall’inizio. È un campo che nasce già internazionale, prima che internazionale fosse standard.

Vale la pena soffermarsi un momento sulla figura di Vapnik. Nato a Tashkent nel 1936, formato in matematica all’Università Statale di Mosca, lavora per oltre venti anni all’Istituto di Scienze del Controllo dell’Accademia Sovietica delle Scienze. La statistical learning theory che sviluppa con Chervonenkis nasce in un contesto culturale molto diverso da quello occidentale: la matematica sovietica del periodo è fortemente teorica, con tradizione di lavorare su problemi profondi senza pressione di applicazione immediata. Il risultato è che la teoria di Vapnik-Chervonenkis è insolitamente solida e generale rispetto a quanto era abituale in machine learning occidentale degli anni Ottanta. Quando Vapnik approda a Bell Labs, porta con se vent’anni di lavoro teorico inutilizzato in pratica, che incontra finalmente l’hardware e i dati per farsi algoritmo. La SVM è la traduzione operativa di una teoria che era sostanzialmente pronta da molto prima.

Una nota su Chervonenkis. La sua morte nel 2014 è stata tragica e quasi grottesca: durante un’escursione nei boschi vicino a Mosca, in un’area paludosa coperta di neve, viene sopraffatto dall’ipotermia. Aveva 76 anni. La comunità ML lo ricorda con il workshop annuale “Chervonenkis Workshop on Machine Learning” e con il Chervonenkis Prize istituito presso ICML. Il suo nome resta legato indissolubilmente alla VC dimension, una delle nozioni più generali e fondazionali del campo.

L’intuizione

Angolo geometrico: il margine come tubo più largo

Immagina due nuvole di punti in un piano: cerchi blu e quadrati rossi. Vuoi tracciare una linea retta che li separi. Se sono linearmente separabili, esistono infinite rette che ci riescono. Quale scegliere?

L’intuizione di Vapnik è radicale nella sua semplicita. Tra tutte le rette possibili, scegli quella che lascia il margine più ampio: cioe quella che è più lontana dai punti più vicini di entrambe le classi. Detto in modo visivo: immagina di poter “ingrassare” la linea fino a un tubo, di cui la linea è l’asse. Il tubo si allarga finché non tocca un punto blu da una parte o un punto rosso dall’altra. La linea che produce il tubo più largo è quella ottima.

Perché dovrebbe essere migliore? Per una ragione di robustezza al rumore. Se i tuoi dati di addestramento sono leggermente perturbati — perché misurati con strumenti imperfetti, etichettati da umani che sbagliano, sottoposti a rumore inevitabile — la linea con margine ampio resta corretta anche dopo la perturbazione, perché ha “spazio di manovra” da entrambi i lati. La linea che passa rasente ai punti, invece, si rovina al primo spostamento. Margine ampio significa decisioni che sopravvivono a piccoli errori.

I punti che toccano i bordi del tubo — gli unici che limitano l’espansione — si chiamano support vectors, “vettori di supporto”. Tutti gli altri punti, lontani dal tubo, non contribuiscono alla decisione. Sono spettatori. Questa è una proprieta strutturale notevole: la SVM è definita interamente da una piccola frazione del dataset di addestramento. Su 10000 esempi, i support vectors potrebbero essere solo 200. La predizione su un nuovo punto richiede di confrontarlo solo con questi 200, non con tutti i 10000.

L’intuizione si estende quando i dati non sono perfettamente separabili. Allora si ammettono delle violazioni controllate del margine: alcuni punti possono entrare nel tubo, alcuni possono persino finire dalla parte sbagliata della linea. Si paga una penalita per ogni violazione, regolata da un parametro $C$ . Se $C$ è alto, si tollera poco: il modello cerca un margine più stretto pur di non sbagliare. Se $C$ è basso, si tollera di più: si accettano errori in cambio di un margine più robusto. Il bilanciamento è un tipico trade-off bias-varianza, calibrato con cross-validation.

Angolo funzionale: il kernel come scorciatoia in alta dimensione

Il secondo angolo è meno geometrico e più computazionale. Riguarda cosa succede quando i dati non sono separabili da una retta in nessun modo, neppure con qualche tolleranza.

Esempio canonico: il problema XOR. Quattro punti in un piano: $(0,0)$ e $(1,1)$ etichettati come “negativo”, $(0,1)$ e $(1,0)$ etichettati come “positivo”. Nessuna retta può separarli, perché le due classi sono “incrociate”. Marvin Minsky lo aveva mostrato nel 1969 come limite del percettrone (vedi reti-neurali-80-90).

L’intuizione: e se i dati non sono separabili in dimensione 2, forse lo diventano in dimensione 3, o 100, o un milione. Aggiungi una nuova coordinata che è una funzione delle vecchie — ad esempio, $z = x \cdot y$ — e improvvisamente le classi si separano. Per il problema XOR, la coordinata $z = x_1 \cdot x_2$ vale $0$ per i punti negativi e $0$ per i positivi $(0,1)$ e $(1,0)$ . Hmm, non aiuta. Prova invece $z = (x_1 - x_2)^2$ : vale $0$ per i negativi, $1$ per i positivi. In tre dimensioni, il piano $z = 0.5$ separa perfettamente.

Il problema è computazionale. Se mappi ogni punto in uno spazio di un milione di dimensioni per ottenere separabilita, il costo di calcolare quel milione di coordinate per ogni punto e di lavorare con vettori di un milione di componenti diventa proibitivo. Qui interviene la magia del kernel trick.

Vapnik osserva che la SVM non ha bisogno di sapere le coordinate esplicite dei punti nello spazio mappato. Le serve solo il prodotto interno tra coppie di punti: $\langle \phi(x), \phi(y) \rangle$ , dove $\phi$ è la mappa nello spazio ad alta dimensione. Se esiste una funzione $K(x, y)$ che restituisce direttamente quel prodotto interno senza mai costruire $\phi$ esplicitamente, hai vinto: lavori implicitamente nello spazio ad alta dimensione, ma calcoli solo $K$ sui punti originali, che restano bassi-dimensionali.

L’esempio classico: il kernel polinomiale $K(x, y) = (x^T y + 1)^d$ . Espandendo, questo corrisponde a un prodotto interno in uno spazio di feature i cui assi sono tutti i monomi di grado $\leq d$ delle coordinate originali. Per $d=2$ in due dimensioni, lo spazio implicito ha sei dimensioni: $1, x_1, x_2, x_1^2, x_2^2, x_1 x_2$ . Calcolare $K(x, y)$ richiede una somma e un’elevazione al quadrato. Calcolare esplicitamente le sei coordinate e poi il prodotto interno richiede sei moltiplicazioni. La differenza è minima qui, ma esplode con $d$ maggiore o con più dimensioni di input.

Il kernel più importante in pratica è il Gaussiano o RBF (Radial Basis Function): $K(x, y) = \exp(-\gamma \|x - y\|^2)$ . Lo spazio di feature implicito è di dimensione infinita. Eppure $K$ si calcola con una distanza euclidea e un esponenziale: due righe di codice. Questa è la potenza del trick: lavoro in uno spazio infinito-dimensionale, costo computazionale come se lavorassi in due dimensioni.

L’intuizione complessiva: la SVM separata dal kernel diventa una macchina universale di classificazione. Stessa formulazione matematica, stesso algoritmo di ottimizzazione, stesso codice. Cambia solo la scelta di $K$ e il dominio cambia. Per testo userai un kernel lineare. Per immagini, un kernel RBF. Per sequenze biologiche, uno spectrum kernel. La modularita è totale.

La meccanica

SVM lineare: massimo margine

Partiamo dal caso più semplice. Il dataset di training è $\{(x_i, y_i)\}_{i=1}^{n}$ , dove $x_i \in \mathbb{R}^d$ e $y_i \in \{-1, +1\}$ è l’etichetta. Assumiamo per ora che i dati siano linearmente separabili: esiste un iperpiano che mette tutti i positivi da una parte e tutti i negativi dall’altra.

Un iperpiano in $\mathbb{R}^d$ è un insieme della forma $\{x : w^T x + b = 0\}$ , dove $w \in \mathbb{R}^d$ è un vettore normale all’iperpiano (perpendicolare alla sua superficie) e $b \in \mathbb{R}$ è un offset. La regola di classificazione è: se $w^T x + b > 0$ classifica come $+1$ , altrimenti come $-1$ . In forma compatta, $\hat{y}(x) = \text{sign}(w^T x + b)$ .

Il margine geometrico di un punto $x_i$ è la sua distanza dall’iperpiano, con segno positivo se classificato correttamente: $\gamma_i = y_i (w^T x_i + b) / \|w\|$ . Il margine del dataset è il minimo dei margini dei singoli punti: $\gamma = \min_i \gamma_i$ . Vogliamo massimizzare $\gamma$ .

C’è una scala libera nella scelta di $w$ e $b$ : se moltiplichi entrambi per una costante positiva, l’iperpiano resta lo stesso. Si normalizza fissando $\min_i y_i (w^T x_i + b) = 1$ . Sotto questa normalizzazione, il margine geometrico del support vector più vicino è esattamente $1/\|w\|$ , e il margine totale (la “larghezza del tubo”) è $2/\|w\|$ . Massimizzare il margine equivale a minimizzare $\|w\|$ , o equivalentemente $\frac{1}{2}\|w\|^2$ per comodità (la derivata è più pulita).

La forma primale del problema di ottimizzazione è:

$\min_{w, b} \frac{1}{2} \|w\|^2 \quad \text{soggetto a} \quad y_i(w^T x_i + b) \geq 1 \text{ per ogni } i = 1, \ldots, n$

In parole povere: trova il vettore di pesi più corto possibile (margine più ampio possibile) tale che ogni esempio sia classificato correttamente con margine almeno 1. È un problema di ottimizzazione convesso quadratico: la funzione obiettivo è una quadratica, i vincoli sono lineari, esiste un unico minimo globale.

La forma duale, ottenuta via Lagrangiani (non sviluppiamo il calcolo qui, basta sapere che è una trasformazione standard di ottimizzazione vincolata), è:

$\max_{\alpha} \sum_{i=1}^{n} \alpha_i - \frac{1}{2} \sum_{i=1}^{n} \sum_{j=1}^{n} \alpha_i \alpha_j y_i y_j (x_i^T x_j) \quad \text{con} \quad \alpha_i \geq 0, \sum_i \alpha_i y_i = 0$

Dove $\alpha_i$ sono i moltiplicatori di Lagrange associati ai vincoli del primale. La forma duale ha due proprieta che cambiano tutto.

Primo: dipende dai dati solo tramite il prodotto interno $x_i^T x_j$ . Le coordinate esplicite dei punti non compaiono mai. Compare solo la matrice $n \times n$ dei prodotti interni a coppie. Questo è il pre-requisito per il kernel trick: se sostituisci $x_i^T x_j$ con $K(x_i, x_j)$ , ottieni una SVM nello spazio di feature implicito di $K$ , senza modificare niente altro.

Secondo: la soluzione è sparsa. Le condizioni di Karush-Kuhn-Tucker (KKT, condizioni di ottimalita per problemi vincolati) implicano che $\alpha_i > 0$ solo per i punti che giacciono esattamente sul margine ( $y_i(w^T x_i + b) = 1$ ): i support vectors. Per tutti gli altri punti, $\alpha_i = 0$ . La predizione su un nuovo punto $x$ è:

$\hat{y}(x) = \text{sign}\left( \sum_{i \in SV} \alpha_i y_i (x_i^T x) + b \right)$

dove $SV$ è l’insieme degli indici dei support vectors. La somma scorre solo su quei pochi punti, non su tutti. Predizione veloce, modello compatto.

Soft-margin: tolleranza agli outlier

I dati reali raramente sono linearmente separabili. C’è sempre rumore, etichette sbagliate, casi di confine. Cortes e Vapnik nel 1995 estendono la formulazione introducendo le variabili slack $\xi_i \geq 0$ , una per ogni esempio. Il vincolo diventa $y_i(w^T x_i + b) \geq 1 - \xi_i$ : il punto può violare il margine di una quantità $\xi_i$ , ma quella violazione viene penalizzata nella funzione obiettivo. La formulazione soft margin è:

$\min_{w, b, \xi} \frac{1}{2}\|w\|^2 + C \sum_{i=1}^{n} \xi_i \quad \text{s.t.} \quad y_i(w^T x_i + b) \geq 1 - \xi_i, \xi_i \geq 0$

Il parametro $C > 0$ controlla il trade-off tra ampiezza del margine ( $\|w\|^2$ piccolo) e numero di violazioni tollerate ( $\sum \xi_i$ piccolo). $C$ alto significa “punisci severamente le violazioni”: il modello stringe il margine pur di evitare errori. $C$ basso significa “tollera violazioni”: il modello allarga il margine accettando più errori. È un classico trade-off bias-varianza: $C$ alto rischia overfit, $C$ basso rischia underfit. La scelta giusta si trova con cross-validation.

La forma duale del soft margin è quasi identica al caso separabile, con un solo cambiamento: $\alpha_i$ ora è vincolato $0 \leq \alpha_i \leq C$ invece che $\alpha_i \geq 0$ . Il tetto $C$ impedisce a un singolo outlier di dominare la soluzione. L’esistenza di una formulazione duale così simile è la ragione per cui il soft margin si è affermato così rapidamente: una piccola modifica al codice esistente, e SVM diventa applicabile a dati reali.

Il kernel trick in dettaglio

Sostituire $x_i^T x_j$ con $K(x_i, x_j)$ nella forma duale è formalmente legittimo se e solo se $K$ è un kernel valido: cioe se esiste una mappa $\phi$ in qualche spazio di Hilbert tale che $K(x, y) = \langle \phi(x), \phi(y) \rangle$ . Il teorema di Mercer (Mercer 1909, riscoperto e applicato in ML negli anni Sessanta-Novanta) caratterizza i kernel validi: $K$ deve essere simmetrico e la matrice di Gram $K_{ij} = K(x_i, x_j)$ deve essere semi-definita positiva per ogni scelta di $\{x_1, \ldots, x_n\}$ .

La cornice matematica generale è la teoria dei Reproducing Kernel Hilbert Space (RKHS), formalizzata da Nachman Aronszajn (matematico polacco, 1907-1980) nel 1950 in un paper sui Transactions of the American Mathematical Society. Gli RKHS sono spazi di funzioni dove la valutazione in un punto è un’operazione continua, e ogni kernel valido determina univocamente uno spazio di Hilbert di funzioni. La teoria è tecnica ma il succo applicativo è semplice: i kernel sono il modo giusto di estendere prodotti interni a spazi anche infinito-dimensionali.

I kernel più usati nella pratica:

Lineare: $K(x, y) = x^T y$ . Equivalente a SVM lineare standard. Usato per testo (alta dimensionalita, sparsity), feature già “buone”.
Polinomiale: $K(x, y) = (x^T y + c)^d$ . Mappa nello spazio dei monomi di grado $\leq d$ . Adatto a problemi con interazioni di grado limitato. Usato in NLP (per modelli di sintassi) e vision (su feature low-level).
RBF (Gaussiano): $K(x, y) = \exp(-\gamma \|x - y\|^2)$ . Spazio di feature implicito di dimensione infinita. Il più universale: dato abbastanza tempo di tuning, RBF compete con qualsiasi altro kernel in quasi ogni dominio. Il parametro $\gamma$ controlla quanto “localmente” si comporta: $\gamma$ grande significa kernel concentrato (modello complesso), $\gamma$ piccolo significa kernel diffuso (modello più lineare).
Sigmoidale: $K(x, y) = \tanh(\kappa x^T y + c)$ . Imita la non linearità di un percettrone. Non sempre valido (matrice di Gram non sempre semi-definita positiva), ma usato come euristica.
String kernels (per sequenze): contano sottosequenze comuni. Usati in bioinformatics per proteine e DNA, in NLP per testo.

Algoritmi e librerie

La forma duale è un problema di quadratic programming (QP) con $n$ variabili e $n$ vincoli. I solver QP generici (interior point, active set) hanno complessità asintotica $O(n^3)$ in tempo e $O(n^2)$ in memoria — la matrice di Gram è $n \times n$ . Su decine di migliaia di esempi, è praticabile ma lento. Su centinaia di migliaia, impraticabile.

John Platt a Microsoft Research nel 1998 inventa SMO (Sequential Minimal Optimization). L’idea: ad ogni iterazione, scegli due moltiplicatori $\alpha_i, \alpha_j$ (i più “violanti” delle condizioni di KKT), tieni fissi tutti gli altri, e risolvi analiticamente il sotto-problema a due variabili. Niente solver QP esterno: il sotto-problema a due variabili ha una soluzione in forma chiusa, calcolabile in poche operazioni aritmetiche. La convergenza è empirica (nessun bound rigoroso sul numero di iterazioni nel caso generale), ma in pratica è veloce e l’implementazione è compatta. SMO diventa la base di tutte le librerie SVM efficienti che seguono.

LIBSVM di Chih-Chung Chang e Chih-Jen Lin a National Taiwan University, sviluppata dal 2000 in poi e documentata definitivamente nel paper del 2011 (“LIBSVM: A library for support vector machines”, ACM TIST), è la libreria standard. Implementa SMO con caching della matrice di Gram (calcolare $K(x_i, x_j)$ ripetutamente sarebbe sprecato), gestisce C-SVM, nu-SVM, one-class SVM per anomaly detection, support vector regression. Bindings disponibili praticamente per ogni linguaggio: C, Python (è il backend di scikit-learn SVC), Java, R, Matlab, Perl. Il paper Chang-Lin 2011 è tra i più citati di tutta l’informatica, con decine di migliaia di citazioni.

Per kernel lineare specificamente, esiste una specializzazione ulteriore: LIBLINEAR (Fan, Chang, Hsieh, Wang, Lin, 2008). Sui kernel lineari, la formulazione primale ammette solver con coordinate descent o trust region che scalano a milioni di esempi e milioni di feature. È la libreria di scelta per text classification con vocabolari grossi (decine di migliaia di parole), dove SVM lineare batte SVM con kernel non lineari sia in performance sia in tempo di addestramento.

Esempio di codice in scikit-learn (Python), pipeline canonica per classificazione binaria:

from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("svm", SVC(kernel="rbf"))
])

grid = {
    "svm__C": [0.1, 1, 10, 100],
    "svm__gamma": [0.001, 0.01, 0.1, 1]
}

cv = GridSearchCV(pipe, grid, cv=5, n_jobs=-1)
cv.fit(X_train, y_train)

best = cv.best_estimator_
test_acc = best.score(X_test, y_test)

Tre passaggi sono caratteristici. Primo, la standardizzazione dei dati: SVM con RBF è molto sensibile alla scala delle feature, perché il kernel dipende da distanze euclidee. Senza standardizzazione, una feature con valori grandi domina su tutte le altre. Secondo, la grid search su $C$ e $\gamma$ : i due iperparametri principali. Tipicamente si cerca su una griglia logaritmica (potenze di 10), con cross-validation 5-fold o 10-fold. Terzo, il modello finale retrieved come best_estimator_ viene valutato su un test set separato, mai visto durante grid search.

Statistical learning theory in pillole

La cornice teorica che giustifica le SVM è la statistical learning theory di Vapnik-Chervonenkis. L’idea centrale: dato un classificatore $f$ in una famiglia $\mathcal{H}$ , voglio bound l’errore vero $R(f)$ (errore atteso su nuovi dati estratti dalla stessa distribuzione) in termini dell’errore empirico $R_{\text{emp}}(f)$ (errore misurato sul dataset di training).

La VC dimension $d_{\text{VC}}(\mathcal{H})$ è una misura della capacità di $\mathcal{H}$ . Formalmente: il più grande numero $d$ di punti che $\mathcal{H}$ può “shatterare”, cioe etichettare in tutti i $2^d$ modi possibili. Esempio: in $\mathbb{R}^2$ , l’insieme delle rette ha VC dimension 3 (può separare 3 punti non collineari in tutti gli 8 modi possibili) ma non 4 (esistono 4 punti che nessuna retta può separare in tutti i 16 modi). Reti neurali con $W$ parametri hanno VC dimension grossolanamente proporzionale a $W$ .

Il bound classico (Vapnik 1971-1995): con probabilita $1 - \delta$ rispetto al campionamento del training set,

$R(f) \leq R_{\text{emp}}(f) + \sqrt{\frac{d_{\text{VC}}(\mathcal{H}) \log(2n / d_{\text{VC}}) + \log(4/\delta)}{n}}$

In parole povere: l’errore vero è al più l’errore empirico più un termine di “complessità” che cresce con la VC dimension e decresce come $1/\sqrt{n}$ con il numero di esempi. Modello molto espressivo (alta VC dimension) richiede molti dati per essere fidato. Modello semplice (bassa VC dimension) può essere fidato anche con pochi dati, purche l’errore empirico sia basso.

Il principio di structural risk minimization (SRM): non minimizzare solo $R_{\text{emp}}$ , ma una combinazione di $R_{\text{emp}}$ e termine di complessità. Le SVM massimizzando il margine, e quindi minimizzando $\|w\|$ , stanno operativamente facendo SRM: il margine grande corrisponde a una sotto-famiglia di classificatori meno “espressivi” (con bound migliori). C’è una versione più raffinata del bound, che dipende dal margine $\rho$ piuttosto che dalla VC dimension:

$R(f) \leq R_{\text{emp}}(f) + O\left(\frac{R^2}{\rho^2 n}\right)$

dove $R$ è il raggio della sfera che contiene tutti i dati nello spazio di feature. Margine grande implica bound migliori, indipendentemente dalla dimensionalita ambiente. Questo è il giustificativo teorico del principio “massimizza il margine”.

Nota onesta: questi bound sono spesso pessimistici nella pratica. Per modelli iperparametrizzati (reti profonde), risultano addirittura vacui (predicono errore vero superiore a 1). La teoria classica resta utile come cornice qualitativa, ma non come predittore numerico stretto. I bound moderni (PAC-Bayes, compression bounds, stability bounds) cercano di fare meglio; nessuno è ancora soddisfacente per il deep learning. Ma negli anni Novanta, il fatto che SVM avesse bound formali — anche pessimistici — era un argomento culturalmente decisivo. Le reti neurali del periodo non avevano niente di paragonabile.

Feature engineering come paradigma

Il punto più importante per capire l’era SVM non è tecnico, è culturale. SVM fissa l’algoritmo: dato un dataset con feature numeriche, troverai sempre l’iperpiano di massimo margine (eventualmente in uno spazio di kernel). Ma l’algoritmo da solo non fa miracoli: la qualità del classificatore finale dipende soprattutto da quanto bene sono progettate le feature di input.

Il workflow tipico di un machine learning practitioner del 2005:

Acquisizione dati: raccogliere il dataset. Se serve annotazione, organizzarla (con annotatori umani, eventualmente con accordo inter-annotatore misurato).
Pulizia dati: missing values, outliers, normalizzazione, deduplicazione.
Feature engineering: il vero lavoro. Un domain expert (biologo, linguista, radiologo, finanziere) collabora con un data scientist per progettare feature significative.
Feature selection: chi-squared, mutual information, L1 regularization, recursive feature elimination. Riduce la dimensionalita e mitiga la curse of dimensionality.
Scelta del modello: SVM (linear o RBF), random forest, gradient boosting, logistic regression.
Tuning iperparametri: grid search su $C$ , $\gamma$ , eventualmente grado del polinomio. Cross-validation k-fold.
Valutazione: accuracy, precision/recall, F1, AUC, confusion matrix.
Deploy: serializzazione del modello, servizio batch o online.

Nei punti 3 e 4 si concentrava la maggior parte del tempo umano. Costruire feature buone era un’arte. Esempi concreti per dominio:

Testo: tokenization (separare le parole), stemming (ridurre “running”, “ran”, “runs” alla radice “run”), stop word removal (filtrare “il”, “di”, “and”, “the”), TF-IDF (term frequency-inverse document frequency: bilancia frequenza locale e rarita globale di un termine), n-grammi (bi-grammi e tri-grammi catturano collocazioni: “New York”, “machine learning”), POS tags (part of speech: noun, verb, adjective).
Immagini: SIFT (Scale-Invariant Feature Transform, David Lowe 1999): descrittori locali invarianti a scala e rotazione, estratti attorno a keypoint salienti. HOG (Histogram of Oriented Gradients, Navneet Dalal e Bill Triggs 2005): istogrammi di direzioni del gradiente in celle dell’immagine, pensati per rilevare pedoni. LBP (Local Binary Patterns): pattern di confronto locale per texture. Color histograms, Haar features (per face detection), Gabor filters.
Audio: MFCC (Mel-Frequency Cepstral Coefficients): coefficienti di una trasformata pensata per imitare la percezione uditiva umana, standard per speech recognition dagli anni Ottanta. Spectrograms (visualizzazioni 2D di intensità per frequenza e tempo), pitch contours, formants, zero-crossing rate.
Biosequenze: k-mer counting (frequenze di sottosequenze di lunghezza $k$ ), spectrum kernels per proteine, position-specific scoring matrices (PSSM) per allineamenti.
Tabular data: derivate (differenze tra colonne, ratio, prodotti), encoding di categoriche (one-hot, target encoding, frequency encoding), binning di continue, time-based features (giorno della settimana, mese, ora).

L’arte era nel feature engineering. Lo stesso classificatore (SVM RBF, random forest, gradient boosting) poteva produrre risultati ottimi o mediocri a seconda di quanto bene erano progettate le feature di input. Una pipeline tipica del 2007 per spam filter aziendale: 50000 email annotate, tokenizzazione + lemmatizzazione, calcolo TF-IDF sui top 20000 termini, aggiunta di feature meta (numero di link, presenza di header sospetti, mittente noto/sconosciuto), feature selection con chi-squared a 5000 feature, SVM lineare con $C=1$ , accuracy 97-98% su test set. Tempo umano: tre settimane per il primo deploy. Tempo macchina: 15 minuti su una workstation Pentium 4.

Il declino: 2012-2015

Per quindici anni, la pipeline SVM + feature engineering ha dominato. Il declino è stato rapido e brutale, in tre o quattro anni concentrati.

L’evento spartiacque è la ImageNet Large Scale Visual Recognition Challenge del 2012. Alex Krizhevsky, Ilya Sutskever e Geoffrey Hinton presentano AlexNet, una CNN profonda con 8 layer (5 convoluzionali + 3 fully connected), addestrata su due GPU NVIDIA GTX 580. Il dataset ha 1.2 milioni di immagini etichettate in 1000 classi. Il top-5 error di AlexNet è 15.3%. Il secondo classificato — basato su feature SIFT e Fisher vectors con SVM — è al 26.2%. Un margine di oltre 10 punti percentuali su un benchmark serio. Il messaggio è inequivocabile: con abbastanza dati e abbastanza compute, le CNN profonde imparano feature migliori di quelle ingegnerizzate a mano da decenni di esperti.

Da quel momento, in computer vision, SVM esce dai task con dati abbondanti. Nel 2013, Mikolov et al. rilasciano word2vec: embedding di parole appresi da grandi corpus. Su task di analogie semantiche e similarita, word2vec batte feature TF-IDF + SVM. Nel 2014, Sutskever et al. introducono sequence-to-sequence con LSTM per machine translation: supera systemi basati su SVM con kernel su feature di allineamento. Nel 2012, Hinton et al. mostrano che reti profonde superano GMM-HMM (con o senza SVM rescoring) su speech recognition large-vocabulary. Entro il 2015, in tutti i domini “grandi” (vision, speech, NLP semantica, traduzione), il deep learning supera SVM.

Le ragioni del sorpasso sono strutturali, non casuali.

Primo, scalabilità. SVM con kernel non lineari ha complessità di addestramento $O(n^2)$ - $O(n^3)$ in numero di esempi e memoria $O(n^2)$ per la matrice di Gram. SMO mitiga ma non risolve. Su milioni di esempi diventa impraticabile. Le reti profonde scalano meglio: la complessità di una passata di backprop è $O(W)$ in numero di parametri, e si parallelizza bene su GPU. Aggiungere dati a una CNN profonda migliora monotonamente le performance; aggiungere dati a una SVM con RBF satura e diventa lento.

Secondo, representation learning. Le CNN imparano feature gerarchiche end-to-end: i primi layer rilevano edge e texture, i layer intermedi rilevano parti (occhi, ruote), i layer profondi rilevano oggetti completi. Niente più feature engineering manuale per ogni dominio. Le rappresentazioni emergono dai dati. SVM, invece, è un classificatore puro: la rappresentazione è tutta nella scelta del kernel, fissato a mano. Cambia dominio, cambia kernel, ricominci.

Terzo, transfer learning. Le rappresentazioni apprese da una CNN su ImageNet trasferiscono notevolmente bene ad altri task di vision: rilevamento oggetti, segmentazione, classificazione fine-grained. Pre-addestri su ImageNet, fine-tunni sul tuo task specifico, riduci il dataset necessario di ordini di grandezza. SVM con kernel custom non transferiva: feature ingegnerizzate per testo non funzionano per immagini, e viceversa. Reinventare ogni dominio era la norma.

Quarto, multi-class nativo. Le reti softmax-output gestiscono multi-class nativamente con un singolo modello. SVM è nativamente binario; multi-class si fa con strategie one-vs-rest (un classifier per classe) o one-vs-one (un classifier per coppia di classi), che scalano male con il numero di classi e non sono ottime in confidenza.

Quinto, dati abbondano. Negli anni Duemiladieci, internet, smartphone, social media, IoT, generano dati a un ritmo senza precedenti. Imagenet (1.2M immagini) era impensabile nel 1995; nel 2009 è realtà. Common Crawl (decine di terabyte di testo web) è realtà dal 2008. In questo regime, il vantaggio teorico delle SVM su dataset piccoli (con bound formali) diventa irrilevante: il bound conta poco quando hai $10^7$ esempi, dove anche i bound naive sono buoni.

Entro il 2015, SVM è relegata a domini di nicchia. Non sparisce, ma non è più il default.

Aneddoti culturali del periodo

Vapnik vs LeCun a Bell Labs: nei corridoi di Holmdel, Vapnik insisteva che le reti neurali funzionavano “per caso”, senza giustificazione teorica solida. LeCun rispondeva che SVM erano “shallow” e non avrebbero mai catturato gerarchie di rappresentazione complesse. Entrambi avevano ragione su parti del quadro. Bell Labs li aveva entrambi nella stessa stanza, e il dialogo (talvolta acceso) tra i due paradigmi era una caratteristica unica di quel laboratorio.

Mantra del periodo: “all you need is a good kernel”. Una variante ironica che circolava nelle conversazioni informali alle conferenze: “kernels are the only thing that matters”. Riflesso del fatto che, scelto SVM come algoritmo, il vero lavoro era nella progettazione del kernel — analogo del feature engineering nei metodi non-kernel. Questo mantra è rimasto nelle slide e nei lucidi degli anni 2000-2010.

Andrew Ng Coursera 2012: il corso “Machine Learning” che lancia la piattaforma Coursera nell’autunno 2011 (e che diventa virale nel 2012 con centinaia di migliaia di iscritti) presenta SVM come tecnica centrale, quasi al pari di regressione logistica e reti neurali. Riflesso fedele dello stato del campo prima di AlexNet. Il corso rimane praticamente identico per anni. Una intera generazione di praticanti ha imparato ML prima da Ng e poi ha scoperto il deep learning come “nuova frontiera”.

LIBSVM dominante in Kaggle iniziale: i primi contest di Kaggle (fondata nel 2010) erano vinti spesso da team che combinavano feature engineering accurato e SVM o ensemble di alberi. Solo dal 2014, con l’avvento di XGBoost (Chen-Guestrin 2016), il gradient boosting su feature ingegnerizzate diventa la nuova ricetta dominante. Il deep learning su Kaggle decolla solo verso 2016-2017, e per tabular data non si è mai veramente affermato come default.

Esempi

Esempio numerico: SVM lineare su quattro punti

Considera quattro punti in $\mathbb{R}^2$ : $x_1 = (1, 1), y_1 = +1$ ; $x_2 = (2, 2), y_2 = +1$ ; $x_3 = (-1, -1), y_3 = -1$ ; $x_4 = (-2, -2), y_4 = -1$ . Le due classi sono perfettamente separabili: i positivi stanno nel quadrante in alto a destra, i negativi in basso a sinistra.

Per simmetria, l’iperpiano di massimo margine è la retta $x_1 + x_2 = 0$ , cioe la bisettrice tra il secondo e il quarto quadrante. Il vettore normale è $w = (1, 1)/\sqrt{2}$ in forma normalizzata, ma usiamo la convenzione SVM con $\min_i y_i(w^T x_i + b) = 1$ . I punti più vicini all’iperpiano sono $x_1$ e $x_3$ , con $w^T x_1 + b = w_1 + w_2 + b$ e $w^T x_3 + b = -w_1 - w_2 + b$ . Per simmetria, $b = 0$ . Imponendo il vincolo: $w_1 + w_2 = 1$ . Per minimizzare $\|w\|^2 = w_1^2 + w_2^2$ sotto il vincolo $w_1 + w_2 = 1$ , ottieni $w_1 = w_2 = 1/2$ . Quindi $w = (1/2, 1/2)$ e $b = 0$ . La larghezza del margine è $2/\|w\| = 2/\sqrt{1/2} = 2\sqrt{2}$ .

I support vectors sono $x_1$ e $x_3$ (gli altri due, $x_2$ e $x_4$ , stanno più lontani dall’iperpiano e non vincolano la soluzione). I moltiplicatori duali $\alpha$ sono diversi da zero solo per $x_1$ e $x_3$ , e dalle condizioni KKT si ricava $\alpha_1 = \alpha_3 = 1/4$ . Verifica della condizione $\sum \alpha_i y_i = 0$ : $1/4 \cdot 1 + 1/4 \cdot (-1) = 0$ . Coerente.

Predizione su un nuovo punto $x = (0.5, 0.5)$ : $w^T x + b = 0.5 \cdot 0.5 + 0.5 \cdot 0.5 = 0.5 > 0$ , quindi classificato come $+1$ . Predizione su $x = (-0.5, 0.5)$ : $0.5 \cdot (-0.5) + 0.5 \cdot 0.5 = 0$ , esattamente sull’iperpiano. Caso ambiguo.

L’esempio è minuscolo, ma illustra tutti gli ingredienti: minimizzazione di $\|w\|^2$ , identificazione dei support vectors, calcolo dei moltiplicatori duali, predizione tramite somma pesata di prodotti interni con i support vectors.

Esempio del kernel: XOR e mappa polinomiale

Quattro punti: $x_1 = (0, 0), y_1 = -1$ ; $x_2 = (1, 1), y_2 = -1$ ; $x_3 = (0, 1), y_3 = +1$ ; $x_4 = (1, 0), y_4 = +1$ . Nessuna retta in $\mathbb{R}^2$ separa le due classi. Verifica visiva: i positivi $(0,1)$ e $(1,0)$ sono diagonalmente opposti, e così i negativi $(0,0)$ e $(1,1)$ . Una retta può separare al più le due diagonali, ma le diagonali si intersecano, quindi nessuna retta funziona.

Applichiamo il kernel polinomiale di grado 2: $K(x, y) = (x^T y + 1)^2$ . La mappa esplicita corrispondente è $\phi(x_1, x_2) = (1, \sqrt{2}x_1, \sqrt{2}x_2, x_1^2, x_2^2, \sqrt{2}x_1 x_2)$ , uno spazio a 6 dimensioni.

Calcoliamo $\phi$ per i quattro punti:

$\phi(0, 0) = (1, 0, 0, 0, 0, 0)$ .
$\phi(1, 1) = (1, \sqrt{2}, \sqrt{2}, 1, 1, \sqrt{2})$ .
$\phi(0, 1) = (1, 0, \sqrt{2}, 0, 1, 0)$ .
$\phi(1, 0) = (1, \sqrt{2}, 0, 1, 0, 0)$ .

Nello spazio 6D, l’ultima coordinata $\sqrt{2}x_1 x_2$ vale $0$ per i positivi e $0, \sqrt{2}$ per i negativi. Non separa direttamente. Ma la combinazione lineare $\phi(x)_4 + \phi(x)_5 - \phi(x)_6$ vale $0+0-0 = 0$ per $(0,0)$ , $1+1-\sqrt{2} \approx 0.59$ per $(1,1)$ , $0+1-0 = 1$ per $(0,1)$ , $1+0-0 = 1$ per $(1,0)$ . I positivi sono entrambi a $1$ , i negativi sono uno a $0$ e uno a $\approx 0.59$ . Non perfettamente separabili da un singolo iperpiano scalare semplice.

Una scelta migliore di iperpiano nello spazio 6D, identificato risolvendo numericamente la SVM, separa le classi correttamente. Senza fare il calcolo qui, l’importante e: la soluzione esiste, perché con grado 2 i monomi catturano la non linearità richiesta. La SVM duale calcolerebbe questo automaticamente, senza che noi dovessimo costruire $\phi$ esplicitamente: bastano i 16 valori $K(x_i, x_j)$ per i, j = 1,…,4.

L’esempio mostra il punto chiave: la scelta del kernel apre o chiude la separabilita. Stesso algoritmo SVM, kernel diverso, problema risolvibile o meno.

Pipeline classificazione testo SPAM 2005

Scenario: una azienda di email vuole filtrare spam. Dataset: 50000 email annotate, 25000 spam e 25000 ham (legittime). Obiettivo: classificatore binario con falsi positivi (ham marcato come spam) inferiore allo 0.1% e accuratezza globale superiore al 97%.

Pipeline tipica del 2005:

# Step 1: tokenization
def tokenize(text):
    text = text.lower()
    tokens = re.findall(r"\b[a-z]+\b", text)
    tokens = [stem(t) for t in tokens if t not in stop_words]
    return tokens

# Step 2: TF-IDF su unigrammi e bigrammi
from sklearn.feature_extraction.text import TfidfVectorizer
vec = TfidfVectorizer(
    tokenizer=tokenize,
    ngram_range=(1, 2),
    max_features=20000,
    min_df=5
)
X = vec.fit_transform(texts) # X è una sparse matrix 50000 x 20000

# Step 3: feature selection per chi-squared
from sklearn.feature_selection import SelectKBest, chi2
selector = SelectKBest(chi2, k=5000)
X_sel = selector.fit_transform(X, y)

# Step 4: SVM lineare
from sklearn.svm import LinearSVC
clf = LinearSVC(C=1.0, class_weight={1: 10}) # peso 10x sui ham per ridurre falsi positivi
clf.fit(X_sel, y)

Il class_weight={1: 10} è il trucco operativo per spostare la frontiera di decisione: penalizza dieci volte di più un errore su un ham (etichetta 1) rispetto a un errore su uno spam (etichetta 0). Questo riduce drasticamente i falsi positivi (essenziale: un ham marcato come spam è un disastro per l’utente; uno spam che passa è solo fastidioso).

Risultati tipici su test set: accuracy 97.8%, precision sullo spam 99.1%, recall 96.2%, falsi positivi 0.07%. Tempo di training: 8 minuti su workstation 2005. Tempo di inferenza per email: 0.5 millisecondi. Modello deployabile su mail server.

Il valore del data scientist non era nel LinearSVC(C=1.0). Era nel pre-processing: scegliere il giusto tokenizer (gestione di URL, header email, character encoding non-ASCII), il giusto range di n-grammi (1-grammi cattura singole parole “Viagra”, 2-grammi cattura collocazioni “make money fast”), il giusto numero di feature (troppo poche = underfit, troppe = overfit + lentezza), il giusto class weight (calibrato sui falsi positivi). Cambia un parametro qui, e l’accuracy scende del 5%. Cambia l’algoritmo a Random Forest, e cambia di mezzo punto. La differenza era nella rappresentazione, non nel classificatore.

Applicazioni pratiche

L’eredità dell’era SVM è viva oggi (2026) in modi diversi.

SVM come default per dataset piccoli. Quando hai meno di 10000 esempi e feature già ragionevolmente buone, SVM con kernel RBF resta una baseline difficilissima da battere con reti profonde. Il deep learning soffre di overfit senza grandi dataset, e tecniche come transfer learning aiutano ma non sempre. SVM con tuning attento di $C$ e $\gamma$ e cross-validation produce risultati robusti e riproducibili. Per molti task scientifici (biomedicina con 500 pazienti, geofisica con 2000 misurazioni, social science con 5000 sondaggi), SVM è ancora il punto di partenza naturale.

Kernel methods nei modelli moderni. La famiglia dei kernel methods non si limita a SVM. Gaussian Processes (GP), formalizzati per machine learning da Rasmussen e Williams nel libro del 2006 “Gaussian Processes for Machine Learning” (MIT Press), sono modelli di regressione bayesiana basati su kernel, con incertezza quantificata. Largamente usati in Bayesian optimization (per hyperparameter tuning automatico) e in active learning. Kernel ridge regression e kernel PCA sono varianti di tecniche classiche estese con il trick. Multiple kernel learning (Lanckriet et al. 2004) impara una combinazione lineare di kernel, automatizzando parte della scelta del kernel.

Statistical learning theory come lente concettuale. Va distinto su due piani. Sul piano del vocabolario tecnico c’è filiazione diretta: la distinzione tra rischio empirico e rischio vero, il concetto di capacità di una famiglia di modelli (VC dimension), l’idea della regolarizzazione come controllo della complessità sono nati nella statistical learning theory di Vapnik-Chervonenkis e da li sono passati al machine learning generale. Quando un praticante dice “questo modello generalizza bene perché regolarizzato”, sta usando termini coniati in quella tradizione. Sul piano dell’applicabilità ai modelli moderni il rapporto è invece analogico: i bound classici di VC falliscono per reti iperparametrizzate (un transformer ha più parametri che esempi di training), e i risultati teorici originali non si trasferiscono. Quel che si trasferisce è l’impalcatura concettuale — pensare in termini di rischio, capacità, regolarizzazione — non i teoremi specifici. Confondere i due piani porta a citare Vapnik come se i suoi bound spiegassero perché GPT generalizza: non lo fanno.

Lezione del primato della rappresentazione. La lezione meta dell’era SVM è che, dato un algoritmo decente, la qualità finale dipende soprattutto dalla rappresentazione di input. Il deep learning ha automatizzato la rappresentazione per molti domini (vision, NLP), ma il principio resta universalmente vero. Anche oggi, in pipeline LLM, il modo in cui pre-processi documenti, scegli la chunking strategy, costruisci embeddings, organizzi prompt e contesto è una forma di feature engineering. Cambia lo strato dove avviene il design — si è spostato in alto, dal pixel al prompt — ma il principio di “fai bene la rappresentazione” è più vivo che mai.

Feature engineering ancora vivo per tabular data. Sui dati tabulari (rows con feature numeriche e categoriche), il deep learning non ha mai veramente vinto. Modelli tabular-specific come TabNet, NODE, FT-Transformer sono validi ma raramente superano in modo decisivo gradient boosting (XGBoost, LightGBM, CatBoost) con feature engineering accurato. Le competizioni Kaggle su tabular data sono ancora dominate da team che fanno feature engineering pesante e poi addestrano gradient boosting con tuning estensivo. SVM lineare con $L_1$ regularization è una baseline classica che spesso sorprende.

Eredità in computer vision specialistica. SIFT, HOG e altre feature engineerizzate non sono morte: vivono in robotica (per SLAM con dati limitati), in computer vision embedded (per microcontroller), in scenari dove il training di una CNN profonda non è giustificato. OpenCV continua a includere queste feature come strumenti standard.

Eredità in bioinformatics. Per task con dati scarsi e domain knowledge ricca (predizione di struttura proteica con poche centinaia di esempi annotati di una famiglia, prediction di splice site su organismi non-modello), kernel SVM con string kernels resta competitivo. AlphaFold ha cambiato il panorama per protein structure, ma in molti micro-task SVM regge ancora.

One-class SVM per anomaly detection. Una variante meno nota è la one-class SVM (Scholkopf et al. 2001), che impara a riconoscere “il normale” senza esempi negativi. Utile per fraud detection, intrusion detection, manufacturing quality control, dove i casi anomali sono rari ma quelli normali abbondano. È ancora una baseline canonica in molti sistemi di anomaly detection produttivi.

Support Vector Regression (SVR). La controparte regressione di SVM, introdotta da Vapnik nello stesso periodo, usa una “epsilon-insensitive loss” (errori inferiori a $\epsilon$ ignorati, errori maggiori penalizzati linearmente). Adatta a regressione robusta su dati con outlier. Usata in finance per previsione di serie temporali, in chimica per predizione di proprieta molecolari (QSAR), in geofisica per regressione su dati di sensori. Anche qui, soppiantata da reti profonde su dataset grandi, ma resta solida su dataset piccoli e medi.

Dove si rompe

”SVM è morto”

Falso. SVM è stato soppiantato come default in domini con dati abbondanti e benchmark grandi (vision, NLP, speech), ma resta competitivo dove i dati sono scarsi (sotto le 10000 osservazioni), dove la dimensionalita di input è modesta (poche centinaia di feature), dove le baseline robuste contano (paper accademici, sistemi di produzione che richiedono interpretabilità e affidabilità). Dichiarare SVM morto è sintomo di tunnel-vision sui benchmark deep learning. Una buona pratica resta: prima di addestrare una rete profonda, prova SVM e gradient boosting come baseline. Spesso vincono, e ti risparmiano settimane.

”Tutti facevano feature engineering manuale negli anni 2000”

Esagerazione. Già negli anni Novanta esistevano metodi di apprendimento di rappresentazione: PCA (Pearson 1901, applicato a ML negli anni Sessanta), ICA (Independent Component Analysis, Comon 1994), autoencoder (LeCun 1987 nella sua tesi), restricted Boltzmann machines (Smolensky 1986, riprese da Hinton 2002). Word embedding già esistevano in forme primitive: LSA (Latent Semantic Analysis, Deerwester et al. 1990), HAL (Lund-Burgess 1996). Erano metodi marginali, non dominanti, ma esistevano. La differenza con il deep learning post-2012 è di scala e di efficacia, non di principio. Il principio di “imparare la rappresentazione” non è stato inventato nel 2012; è stato realizzato in modo decisivo nel 2012.

”Il deep learning ha invalidato la statistical learning theory”

Falso, ma con sfumatura. La statistical learning theory classica (bound VC, structural risk minimization) produce bound vacui per modelli iperparametrizzati. Una rete con 100 milioni di parametri, addestrata su 1 milione di esempi, dovrebbe overfittare catastroficamente secondo i bound classici. Eppure generalizza. Questo paradosso è tema di ricerca attiva: PAC-Bayes, double descent (Belkin et al. 2019), neural tangent kernel (Jacot et al. 2018), implicit regularization da SGD. La teoria classica resta valida nel suo regime, ma serve teoria nuova per il regime overparameterized. La teoria di Vapnik non è invalidata; è incompleta per fenomeni che non aveva considerato.

”SVM è magia bayesiana”

Confusione comune. SVM non è un metodo bayesiano. Non c’è una distribuzione a priori sui parametri, non c’è una posteriore, non c’è marginalizzazione bayesiana. SVM è un metodo di margine massimo, un’ottimizzazione discriminativa pura. La cornice teorica è la statistical learning theory frequentista di Vapnik, non quella bayesiana di MacKay-Bishop-Murphy. Esiste una connessione tecnica tra SVM e modelli probabilistici (Platt scaling per ottenere probabilita calibrate da SVM scores), ma è una conversione post-hoc, non una equivalenza concettuale. Confondere SVM con Gaussian Processes (che sono bayesiani) è un errore comune ma significativo.

”Il kernel trick funziona sempre”

Falso. Il kernel trick funziona per algoritmi che dipendono dai dati solo tramite prodotti interni (SVM, kernel PCA, kernel ridge regression, GP). Non si applica direttamente ad algoritmi che richiedono esplicitamente le coordinate dei punti nello spazio mappato (decision tree, k-means con distanze euclidee dirette). Inoltre, la scelta del kernel resta un problema. RBF è generalmente buono ma il parametro $\gamma$ richiede tuning attento. Kernel sbagliato = SVM mediocre. Multiple Kernel Learning aiuta ma non risolve completamente.

Mito storico: “Vapnik avrebbe potuto inventare deep learning se avesse voluto”

Anti-storia. Vapnik aveva una filosofia precisa: massimizzazione del margine, kernel, rifiuto delle assunzioni distribuzionali forti, preferenza per modelli con bound teorici. Il deep learning viola tutte e quattro queste preferenze: usa loss non-convesse, non usa kernel espliciti, fa assunzioni implicite (architetture specifiche), e per molto tempo non aveva bound teorici. Le due filosofie sono compatibili al limite ma operativamente molto distanti. Vapnik ha contribuito a una direzione, Hinton-LeCun-Bengio a un’altra. Il deep learning non è “SVM con più layer”.

”SMO converge sempre velocemente”

Vero in pratica, falso in teoria. SMO non ha bound rigorosi sul numero di iterazioni nel caso generale. Esistono dataset patologici (high $C$ , kernel mal calibrato) dove SMO è lentissimo. In pratica, con dataset reali e iperparametri ragionevoli, SMO converge in tempo accettabile. Ma fidarsi che “convergerà sempre veloce” è ottimismo: per dataset estremi, conviene usare LIBLINEAR (lineare) o ridurre il dataset con sottocampionamento intelligente.

”SVM funziona bene con qualsiasi feature”

Falso. SVM con RBF è molto sensibile alla scala delle feature (il kernel dipende da distanze euclidee). Senza standardizzazione (mean-centering e scaling a varianza unitaria), una feature con range 0-10000 domina su una con range 0-1, e il modello è inutile. La standardizzazione è un passo obbligatorio nel pipeline. Anche feature con outliers estremi degradano SVM molto più di altri algoritmi (random forest è robusto agli outlier, SVM no).

”Soft margin con $C$ alto = niente overfit”

Sbagliato il senso. $C$ alto significa “punisci severamente le violazioni del margine”, che porta a margini stretti e potenzialmente overfit. $C$ basso permette più violazioni (margini ampi), che generalizza meglio. La direzione è opposta a quella che alcuni studenti immaginano. Il modo giusto di pensarci: $C$ alto = “fitting forte sui dati di training” (rischio overfit). $C$ basso = “regolarizzazione forte” (rischio underfit). Cross-validation per trovare il bilanciamento giusto.

”Multi-class si fa banalmente”

Sottovalutazione. SVM è nativamente binaria. Per multi-class si usano strategie esterne: one-vs-rest (un classifier per ogni classe contro tutte le altre, $K$ modelli per $K$ classi) oppure one-vs-one (un classifier per ogni coppia di classi, $K(K-1)/2$ modelli). One-vs-rest è più rapido in training ma soffre di squilibrio (la classe positiva è minoritaria nel binary task). One-vs-one ha tutti task bilanciati ma costa $O(K^2)$ training. Su task con molte classi (ImageNet 1000 classi), entrambe le strategie sono inefficienti rispetto a una rete softmax a 1000 output. Esistono formulazioni multi-class native di SVM (Crammer-Singer 2001, Weston-Watkins 1998), ma sono più lente e meno usate in pratica.

”Il margine geometrico è sempre interpretabile”

Falso nello spazio di feature kernel. Quando usi un kernel RBF, il margine geometrico è calcolato in uno spazio infinito-dimensionale, e non ha un’interpretazione visiva immediata nello spazio di input originale. La frontiera di decisione nello spazio originale è una curva (o superficie) altamente non lineare, e l’idea intuitiva di “tubo più largo” si applica nello spazio implicito, non visualizzabile. Per aiutare l’intuizione, si possono plottare le isolinee della funzione di decisione nello spazio 2D originale (decision boundary plot), ma il “margine” come tubo concreto vive altrove.

Collegamenti

rinascita-statistica-90 — il quadro generale del paradigma statistico negli anni Novanta. SVM è uno dei pilastri di quella rinascita, accanto a Bayesian networks, ensemble di alberi, HMM, RL.
reti-neurali-80-90 — l’altro filone, sopravvivente in nicchia. Bell Labs come crocevia di entrambi, con LeCun e Vapnik nei corridoi adiacenti.
secondo-inverno-ai — il contesto da cui nasce la rinascita. Senza il fallimento dei sistemi esperti, lo spazio per il paradigma statistico non si sarebbe aperto.
storia-sintesi — la mappa storica complessiva, di cui questo capitolo è un tassello. Utile per ripassare l’ordine cronologico generale.
imagenet-alexnet-2012 (Parte I, slug futuro) — l’evento spartiacque che chiude l’era SVM in computer vision e apre l’era deep learning. Da scrivere subito dopo questo capitolo.
word2vec-2013 (Parte I, slug futuro) — l’evento parallelo che chiude l’era SVM in NLP semantica.
svm (Parte VIII, slug futuro) — il capitolo tecnico-didattico in Machine Learning, che riprendera in profondità la matematica di SVM e kernel come argomento di curriculum, complementare a questo capitolo storico.
feature-engineering (Parte VIII, slug futuro) — capitolo dedicato al tema, di cui qui abbiamo dato un’inquadratura storica. Approfondira tecniche specifiche per dominio.
metriche-classificazione (Parte VIII, slug futuro) — accuracy, precision, recall, F1, ROC, AUC: le metriche con cui si valutavano (e si valutano) classificatori binari come SVM.
vettori-spazi (Parte IV, slug futuro) — fondamenti di algebra lineare necessari per capire iperpiani, prodotti interni, spazi di feature. Prerequisito implicito di questo capitolo.
prodotto-scalare (Parte IV, slug futuro) — il prodotto interno come misura di similarita e proiezione. È il mattone su cui poggiano i kernel.
bias-varianza (Parte IV, slug futuro) — il trade-off bias-varianza, di cui il parametro $C$ in SVM soft margin è un esempio canonico.

Per andare oltre

Cortes, Vapnik (1995), “Support-vector networks”, Machine Learning 20(3). Il paper canonico del soft margin SVM. Lettura obbligata per capire la versione di SVM che si usa nella pratica.
Vapnik (1998), “Statistical Learning Theory”, Wiley. Il libro lungo (700+ pagine) che dettaglia la teoria. Denso ma fondazionale. Per chi vuole capire perché le SVM sono come sono.
Scholkopf, Smola (2001), “Learning with Kernels: Support Vector Machines, Regularization, Optimization, and Beyond”, MIT Press. Il trattato di riferimento sui kernel methods. Equilibrato tra teoria e algoritmi.
Burges (1998), “A Tutorial on Support Vector Machines for Pattern Recognition”, Data Mining and Knowledge Discovery 2(2). Tutorial di Bell Labs, didatticamente eccellente, lettura accessibile per cominciare prima dei libri lunghi.
Hsu, Chang, Lin (2003), “A Practical Guide to Support Vector Classification”, technical guide National Taiwan University, disponibile sul sito di LIBSVM. Guida operativa: come scalare le feature, come scegliere il kernel, come tunare $C$ e $\gamma$ . Una decina di pagine, valgono ore di tentativi.
Chang, Lin (2011), “LIBSVM: A library for support vector machines”, ACM TIST 2(3). Documentazione della libreria standard. Utile per chi vuole capire l’implementazione, e come articolo storico del software più citato di ML.
Boser, Guyon, Vapnik (1992), “A training algorithm for optimal margin classifiers”, COLT 1992. Il paper fondante. Storicamente importante anche se la versione moderna di SVM (con soft margin) viene formalizzata nel 1995.
Joachims (1998), “Text categorization with Support Vector Machines: Learning with many relevant features”, ECML 1998. Il paper che lancia SVM come standard per text classification. Lettura utile per capire l’inizio della pervasivita di SVM in NLP applicato.
Platt (1998), “Sequential Minimal Optimization”, Microsoft Research TR. L’algoritmo che ha reso SVM scalabile. Tecnico ma compatto, utile per chi vuole implementare SVM da zero.
Rasmussen, Williams (2006), “Gaussian Processes for Machine Learning”, MIT Press. Disponibile gratuitamente online. Per chi vuole esplorare i kernel methods bayesiani come parente di SVM.