Quando le feature sono troppe e in gran parte ridondanti
Un dataset di immagini 8×8 ha 64 feature, uno di sensori o di testi ne ha migliaia, e molte sono copie sfocate delle altre: pixel vicini, misure correlate, parole che compaiono insieme. L'analisi delle componenti principali (PCA) trova le poche direzioni lungo cui i dati variano di più e li riscrive in quelle coordinate. La costruzione è algebra lineare pura, e usa tutto ciò che c'è nell'articolo sull'algebra lineare: la covarianza, i suoi autovalori e la decomposizione ai valori singolari. In questo articolo la derivi, la calcoli a mano su quattro punti, la verifichi con NumPy e con scikit-learn, e misuri su dati reali quando serve e quando no: il risultato su un classificatore, ottenuto in questa esecuzione, non è quello che molti tutorial promettono.
Notazione della serie: \mathbf{X} \in \mathbb{R}^{n \times d} è la matrice dei dati, con n campioni sulle righe e d feature sulle colonne, \mathbf{C} la covarianza, \lambda_i gli autovalori in ordine decrescente.
La maledizione della dimensionalità, misurata
In molte dimensioni la nozione di «vicino» si indebolisce: le distanze fra punti casuali tendono ad avere quasi lo stesso valore. Lo si verifica con un esperimento. Si estraggono 2000 punti uniformi in un cubo [0,1]^d e si misura, da un punto di interrogazione, il rapporto (d_{\max} - d_{\min})/d_{\min} fra la distanza massima e quella minima. Se il rapporto è molto più grande di uno, il più vicino è chiaramente più vicino degli altri; se tende a zero, tutti i punti sono quasi equidistanti e un metodo basato sulla distanza (k-NN, clustering) perde potere discriminante.
import numpy as np
rng = np.random.default_rng(0)
print(" d distanza minima massima (max - min) / min")
for d in (2, 10, 100, 1000):
X = rng.random((2000, d)) # 2000 punti uniformi nel cubo [0,1]^d
q = rng.random(d) # un punto di interrogazione
dist = np.linalg.norm(X - q, axis=1)
print(f"{d:4d} {dist.min():14.3f} {dist.max():7.3f} {(dist.max() - dist.min()) / dist.min():10.2f}")
# Output:
# d distanza minima massima (max - min) / min
# 2 0.003 0.765 266.64
# 10 0.529 2.089 2.95
# 100 3.224 4.846 0.50
# 1000 12.028 13.452 0.12
Il rapporto scende da 266 in due dimensioni a 2{,}95 con d = 10, 0{,}50 con d = 100 e 0{,}12 con d = 1000: a mille dimensioni il punto più lontano è appena il 12% più lontano del più vicino. Il valore a d = 2 è dominato dal caso (un punto molto vicino), quindi conta la tendenza, non la cifra. Va detto che questi punti sono uniformi e indipendenti; i dati reali stanno spesso vicino a un sottospazio di dimensione molto più bassa, ed è precisamente la struttura che la PCA cerca di sfruttare.
Derivazione: la direzione di massima varianza è un autovettore
Si parte da dati centrati (media zero per colonna) e dalla covarianza \mathbf{C} = \frac{1}{n-1}\mathbf{X}^T\mathbf{X}. Proiettare i dati su una direzione unitaria \mathbf{w} dà i numeri \mathbf{X}\mathbf{w}, la cui varianza è \mathbf{w}^T\mathbf{C}\mathbf{w}. La prima componente principale è la direzione che massimizza questa quantità con il vincolo \|\mathbf{w}\| = 1. Con un moltiplicatore di Lagrange si cerca il punto stazionario di \mathbf{w}^T\mathbf{C}\mathbf{w} - \lambda(\mathbf{w}^T\mathbf{w} - 1); derivando rispetto a \mathbf{w} si ottiene \mathbf{C}\mathbf{w} = \lambda\mathbf{w}. La direzione cercata è dunque un autovettore di \mathbf{C}, e poiché la varianza lungo di essa è \mathbf{w}^T\mathbf{C}\mathbf{w} = \lambda\,\mathbf{w}^T\mathbf{w} = \lambda, il massimo si ottiene scegliendo l'autovalore più grande. La seconda componente è il secondo autovettore, ortogonale alla prima, e così via (Deisenroth, Faisal e Ong, cap. 10).
Con k componenti la riduzione è \mathbf{Z} = \mathbf{X}\mathbf{W}_k, dove \mathbf{W}_k \in \mathbb{R}^{d \times k} ha per colonne i primi k autovettori, e la ricostruzione approssimata è \hat{\mathbf{X}} = \mathbf{Z}\mathbf{W}_k^T. La frazione di varianza conservata è \sum_{i \leq k}\lambda_i / \sum_{i \leq d}\lambda_i. Una conseguenza utile: l'errore quadratico di ricostruzione è la somma degli autovalori scartati (moltiplicata per n-1 con la normalizzazione scelta), quindi scegliere quante componenti tenere è decidere quanto errore accettare.
I passi, nell'ordine in cui vanno eseguiti, sono quattro:
- centrare i dati sottraendo la media di ogni colonna (e standardizzarli se le feature hanno unità diverse)
- calcolare la covarianza \mathbf{C} oppure, equivalentemente, la SVD della matrice centrata
- ordinare gli autovalori in ordine decrescente e scegliere k
- proiettare con \mathbf{Z} = \mathbf{X}\mathbf{W}_k, tenendo media e componenti per applicare la stessa trasformazione ai dati nuovi
L'ordine conta: senza centratura la prima «componente» punta verso la media dei dati e non verso la direzione di massima variazione, e gli autovalori vanno ordinati prima di scegliere k, perché np.linalg.eigh li restituisce in ordine crescente. L'ultimo passo è quello che si dimentica: la media e la matrice \mathbf{W}_k calcolate sul training set vanno riusate sul test set, mai ricalcolate.
Un esempio svolto a mano su quattro punti
Quattro campioni, due feature, già centrati: (2, 2), (0, 1), (-1, -1), (-1, -2). Con n = 4, \mathbf{X}^T\mathbf{X} = \begin{pmatrix} 6 & 7 \\ 7 & 10 \end{pmatrix} e dividendo per n - 1 = 3 si ha \mathbf{C} = \begin{pmatrix} 2 & 7/3 \\ 7/3 & 10/3 \end{pmatrix}. La traccia vale 16/3 \approx 5{,}3333 e il determinante 20/3 - 49/9 = 11/9, quindi gli autovalori risolvono \lambda^2 - \tfrac{16}{3}\lambda + \tfrac{11}{9} = 0: \lambda_1 \approx 5{,}0934 e \lambda_2 \approx 0{,}2400. La prima componente spiega il 5{,}0934/5{,}3333 \approx 95{,}5\% della varianza. L'autovettore per \lambda_1 risolve (2 - \lambda_1)v_1 + \tfrac{7}{3}v_2 = 0, cioè v_2 \approx 1{,}3257\,v_1, e normalizzato dà \mathbf{w}_1 \approx (0{,}6022;\ 0{,}7983). Il primo punto si proietta in 2 \cdot 0{,}6022 + 2 \cdot 0{,}7983 \approx 2{,}801, e l'errore di ricostruzione complessivo sui quattro punti è (n-1)\lambda_2 = 3 \cdot 0{,}24 = 0{,}72.
import numpy as np
from sklearn.decomposition import PCA
X = np.array([[ 2.0, 2.0],
[ 0.0, 1.0],
[-1.0, -1.0],
[-1.0, -2.0]]) # 4 campioni, 2 feature, gia' centrati
n = len(X)
C = X.T @ X / (n - 1)
print("C =\n", np.round(C, 4))
vals, vecs = np.linalg.eigh(C)
vals, vecs = vals[::-1], vecs[:, ::-1] # ordine decrescente
print("autovalori:", np.round(vals, 4), " traccia =", round(np.trace(C), 4))
print("varianza spiegata:", np.round(vals / vals.sum(), 4))
w1 = vecs[:, 0] * np.sign(vecs[0, 0])
print("prima componente w1 =", np.round(w1, 4))
z = X @ w1 # proiezione a 1 dimensione
X_hat = np.outer(z, w1) # ricostruzione
print("proiezioni z =", np.round(z, 4))
print(f"errore di ricostruzione (somma dei quadrati) = {np.sum((X - X_hat) ** 2):.4f} (n - 1) * lambda_2 = {(n - 1) * vals[1]:.4f}")
# Stesso risultato dalla SVD di X, senza formare mai la covarianza
U, s, Vt = np.linalg.svd(X, full_matrices=False)
print("sigma^2 / (n - 1):", np.round(s ** 2 / (n - 1), 4))
pca = PCA(n_components=1).fit(X)
print("scikit-learn: varianza spiegata =", np.round(pca.explained_variance_, 4), " componente =", np.round(pca.components_[0] * np.sign(pca.components_[0][0]), 4))
# Output:
# C =
# [[2. 2.3333]
# [2.3333 3.3333]]
# autovalori: [5.0934 0.24 ] traccia = 5.3333
# varianza spiegata: [0.955 0.045]
# prima componente w1 = [0.6022 0.7983]
# proiezioni z = [ 2.8011 0.7983 -1.4005 -2.1989]
# errore di ricostruzione (somma dei quadrati) = 0.7199 (n - 1) * lambda_2 = 0.7199
# sigma^2 / (n - 1): [5.0934 0.24 ]
# scikit-learn: varianza spiegata = [5.0934] componente = [0.6022 0.7983]
Il listato riproduce i conti: stessi autovalori, stessa componente \mathbf{w}_1, e la somma dei quadrati degli errori di ricostruzione coincide con (n-1)\lambda_2 = 0{,}7199 (il 0{,}72 del conto a mano, con le cifre non arrotondate). La parte più importante è la seconda: la SVD della matrice dei dati, senza mai formare la covarianza, dà gli stessi numeri con la regola \lambda_i = \sigma_i^2/(n-1). È la strada che usa scikit-learn (la documentazione di PCA dice che applica la SVD ai dati centrati) ed è numericamente più stabile: formare \mathbf{X}^T\mathbf{X} eleva al quadrato il condizionamento della matrice. Il segno di un autovettore è arbitrario, ed è per questo che il listato lo normalizza prima di confrontare.
La scala delle feature cambia il risultato
La PCA cerca la varianza, e la varianza dipende dall'unità di misura: una feature espressa in grammi ha varianza un milione di volte maggiore dello stesso valore in chilogrammi. Se le feature non sono nella stessa scala, la componente principale punta alla feature con i numeri più grandi, non a quella più informativa. Nel dataset dei vini di scikit-learn (178 campioni, 13 proprietà chimiche) la feature proline ha varianza dell'ordine di centomila contro centesimi per altre.
import numpy as np
from sklearn.datasets import load_wine
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
wine = load_wine()
X = wine.data # 178 campioni, 13 feature in unita' diverse
var = X.var(axis=0, ddof=1)
big = var.argmax()
print(f"feature con varianza massima: {wine.feature_names[big]} (varianza {var[big]:.0f}); minima: {var.min():.4f}")
raw = PCA().fit(X).explained_variance_ratio_
std = PCA().fit(StandardScaler().fit_transform(X)).explained_variance_ratio_
print("senza standardizzare: PC1 =", round(raw[0], 4), " PC2 =", round(raw[1], 4))
print("dopo la standardizzazione: PC1 =", round(std[0], 4), " PC2 =", round(std[1], 4))
print("peso della feature dominante sulla PC1 (senza standardizzare):", round(abs(PCA().fit(X).components_[0][big]), 4))
# Output:
# feature con varianza massima: proline (varianza 99167); minima: 0.0155
# senza standardizzare: PC1 = 0.9981 PC2 = 0.0017
# dopo la standardizzazione: PC1 = 0.362 PC2 = 0.1921
# peso della feature dominante sulla PC1 (senza standardizzare): 0.9998
Senza standardizzare, la prima componente spiega il 99{,}8\% della varianza ma coincide praticamente con una sola feature (il suo peso è 0{,}9998): la PCA ha ridescritto il dataset con la sua colonna più grande. Dopo la standardizzazione (media 0, varianza 1 per colonna) la prima componente spiega il 36{,}2\% e la seconda il 19{,}2\%: la varianza è distribuita fra più direzioni, e le componenti mescolano davvero le feature. Standardizzare non è però sempre giusto: se le feature sono già nella stessa unità e la differenza di varianza è informativa, standardizzare la cancella. È una decisione da prendere guardando i dati.
Quante componenti tenere, e che cosa guadagna un classificatore
Il criterio più comune è la frazione cumulata di varianza spiegata: si sceglie il più piccolo k che supera una soglia, di solito 90–99\%. La soglia è una convenzione, non una verità, e l'utilità effettiva di k si valuta sul compito finale. Il listato lo fa sul dataset digits (1797 immagini 8×8, 64 feature). Scikit-learn permette di indicare direttamente la soglia (n_components=0.95); qui si usa un intero per vedere l'effetto di ogni k. Standardizzazione e PCA stanno dentro un Pipeline, in modo che entrambe vengano apprese sul solo training set.
import numpy as np
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
X, y = load_digits(return_X_y=True) # 1797 immagini 8x8 = 64 feature
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
full = PCA().fit(StandardScaler().fit_transform(X_tr))
cum = np.cumsum(full.explained_variance_ratio_)
for target in (0.80, 0.90, 0.95, 0.99):
print(f"componenti per spiegare il {target:.0%} della varianza: {int(np.searchsorted(cum, target) + 1)} su 64")
base = make_pipeline(StandardScaler(), LogisticRegression(max_iter=5000))
base.fit(X_tr, y_tr)
print(f"\nsenza PCA (64 feature): accuracy sul test = {base.score(X_te, y_te):.4f}")
for k in (10, 20, 40):
m = make_pipeline(StandardScaler(), PCA(n_components=k), LogisticRegression(max_iter=5000))
m.fit(X_tr, y_tr)
print(f"con PCA, k = {k:2d}: accuracy sul test = {m.score(X_te, y_te):.4f}")
# Output:
# componenti per spiegare il 80% della varianza: 21 su 64
# componenti per spiegare il 90% della varianza: 31 su 64
# componenti per spiegare il 95% della varianza: 40 su 64
# componenti per spiegare il 99% della varianza: 54 su 64
#
# senza PCA (64 feature): accuracy sul test = 0.9722
# con PCA, k = 10: accuracy sul test = 0.8778
# con PCA, k = 20: accuracy sul test = 0.9417
# con PCA, k = 40: accuracy sul test = 0.9528
Servono 21 componenti su 64 per il 80\% della varianza, 31 per il 90\%, 40 per il 95\% e 54 per il 99\%: nonostante le correlazioni fra pixel vicini, in queste immagini la varianza è distribuita su molte direzioni. Il risultato sul classificatore è contro l'intuizione dei tutorial: la regressione logistica sulle 64 feature raggiunge 0{,}9722 di accuratezza sul test, con la PCA a 40 componenti (il 95\%) scende a 0{,}9528, con 20 a 0{,}9417, con 10 a 0{,}8778. La PCA non ha migliorato la generalizzazione. Il motivo è che la regressione logistica non soffre di molte feature quanto un metodo basato sulle distanze, e le direzioni a bassa varianza che la PCA scarta contengono ancora informazione sulla classe: la varianza non è la stessa cosa del potere discriminante. Il guadagno atteso della PCA è altrove: meno memoria, meno tempo, visualizzazione, e metodi sensibili alla dimensione. Con una sola partizione e un solo seme la differenza fra 0{,}9722 e 0{,}9528 (7 immagini su 360) non è comunque una misura precisa.
Oltre la PCA: t-SNE e UMAP servono a guardare, non a trasformare
La PCA è lineare. Quando i dati stanno su una superficie curva, per visualizzarli si usano metodi non lineari. t-SNE (van der Maaten e Hinton, 2008) costruisce probabilità di vicinanza fra punti nello spazio originale e in quello ridotto e minimizza la KL divergence fra le due, concetto trattato nell'articolo sulla teoria dell'informazione. UMAP (McInnes e altri, 2018) parte da un quadro teorico di geometria riemanniana e topologia algebrica e, secondo i suoi autori, è competitivo con t-SNE per qualità di visualizzazione, con tempi migliori e, a loro giudizio, con più struttura globale preservata. UMAP non è installato nell'ambiente usato per questo articolo, quindi non è stato eseguito.
import numpy as np
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE, trustworthiness
from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsClassifier
X, y = load_digits(return_X_y=True)
emb = {"PCA": PCA(n_components=2).fit_transform(X),
"t-SNE": TSNE(n_components=2, perplexity=30, init="pca", random_state=0).fit_transform(X)}
for name, Z in emb.items():
acc = cross_val_score(KNeighborsClassifier(5), Z, y, cv=5).mean()
tw = trustworthiness(X, Z, n_neighbors=10)
print(f"{name:6s} 2D: accuratezza 5-NN (5 fold) = {acc:.3f} trustworthiness = {tw:.3f}")
# Output:
# PCA 2D: accuratezza 5-NN (5 fold) = 0.603 trustworthiness = 0.830
# t-SNE 2D: accuratezza 5-NN (5 fold) = 0.976 trustworthiness = 0.993
Sulle stesse 1797 cifre il listato proietta in 2 dimensioni con PCA e con t-SNE e misura due cose: l'accuratezza di un 5-NN a 5 fold sulle coordinate 2D, e la trustworthiness, la frazione di vicini conservati (da 0 a 1). La PCA 2D conserva poco (0{,}603 e 0{,}830), t-SNE molto di più (0{,}976 e 0{,}993): i vicini locali sono preservati. Ma la guida di Wattenberg, Viégas e Johnson (How to Use t-SNE Effectively) mette in guardia su ciò che il grafico non dice: le dimensioni dei cluster in un grafico t-SNE non hanno significato, le distanze fra cluster possono non significare nulla, e il risultato dipende dalla perplexity, per la quale occorre guardare più valori. Inoltre t-SNE non produce una trasformazione applicabile a dati nuovi. Per questo la PCA resta lo strumento di preprocessing (è invertibile e interpretabile) e t-SNE e UMAP quello di esplorazione.
Che cosa sai fare adesso
Sai derivare la PCA come problema di massimo vincolato e riconoscere in \lambda_i la varianza della componente i. Sai calcolarla a mano su pochi punti, verificarla con NumPy sia dalla covarianza sia dalla SVD, e decidere se standardizzare guardando le scale. Sai scegliere il numero di componenti dalla varianza cumulata e, soprattutto, sai che il valore va confermato sul compito finale: su digits la PCA ha ridotto l'accuratezza della regressione logistica invece di migliorarla. L'articolo seguente cambia argomento ma non il filo: le funzioni di perdita sono ciò che il gradiente dell'ottimizzatore riduce.
Fonti
- Deisenroth, Faisal, Ong, Mathematics for Machine Learning (2020), capitolo 10 (Dimensionality Reduction with PCA) - §10.2 e §10.3: derivazione come massimizzazione della varianza, varianza persa pari alla somma degli autovalori scartati (equazione 10.25), prospettiva dell'errore di ricostruzione; PDF letto, consultata il 2026-11-12
- scikit-learn: sklearn.decomposition.PCA - la classe centra ma non scala i dati e usa la SVD; pagina letta, consultata il 2026-11-12
- McInnes, Healy, Melville, UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction (arXiv 1802.03426) - affermazioni degli autori su UMAP (struttura globale e tempi); abstract letto, consultata il 2026-11-12
- Wattenberg, Viégas, Johnson, How to Use t-SNE Effectively, Distill 2016 - dimensioni e distanze dei cluster in t-SNE e effetto della perplexity; articolo letto, consultata il 2026-11-12
- van der Maaten, Hinton, Visualizing Data using t-SNE, JMLR 9, 2008 - articolo originale di t-SNE; pagina raggiunta, testo non letto, consultata il 2026-11-12

Commenti
Caricamento commenti...
Accedi per commentare