Introduzione: Comprimere i Dati Senza Perdere Informazione
I dataset reali hanno spesso centinaia o migliaia di feature. Molte di queste sono ridondanti o correlate tra loro. La riduzione dimensionale permette di comprimere i dati in uno spazio a dimensionalità inferiore mantenendo la maggior parte dell'informazione utile. L'algoritmo più usato e la PCA (Principal Component Analysis), che si basa interamente su autovalori e autovettori della matrice di covarianza.
Cosa Imparerai
- La maledizione della dimensionalità e perchè ridurla
- Matrice di covarianza: capire le correlazioni
- PCA: trovare le direzioni di massima varianza
- Varianza spiegata e scelta del numero di componenti
- t-SNE e UMAP per visualizzazione non-lineare
- Implementazione completa in NumPy e scikit-learn
La Maledizione della Dimensionalità
In spazi ad alta dimensionalità, i dati diventano sparsi: tutti i punti sono approssimativamente equidistanti. Questo rende le metriche di distanza meno utili e causa overfitting nei modelli. La PCA combatte questo problema proiettando i dati nelle direzioni più informative.
Matrice di Covarianza
La matrice di covarianza \\mathbf{C} cattura le correlazioni tra tutte le coppie di feature. Per un dataset centrato (media zero) \\mathbf{X} \\in \\mathbb{R}^{n \\times d}:
Ogni elemento C_{ij} e la covarianza tra feature i e j:
La diagonale contiene le varianze di ogni feature, gli elementi fuori diagonale le covarianze. Se C_{ij} > 0, le feature sono correlate positivamente; se C_{ij} = 0, sono non correlate.
PCA: Derivazione Matematica
PCA cerca le direzioni lungo le quali i dati hanno massima varianza. La prima componente principale \\mathbf{w}_1 e il vettore unitario che massimizza la varianza della proiezione:
Usando i moltiplicatori di Lagrange, si dimostra che la soluzione e l'autovettore corrispondente al più grande autovalore di \\mathbf{C}:
dove \\lambda_1 \\geq \\lambda_2 \\geq \\cdots \\geq \\lambda_d \\geq 0 sono gli autovalori ordinati. L'autovalore \\lambda_i e esattamente la varianza catturata dalla i-esima componente principale.
Proiezione e Ricostruzione
Per ridurre a k dimensioni, proiettiamo sui primi k autovettori:
La ricostruzione approssimata e:
Varianza Spiegata
La varianza spiegata dalle prime k componenti e:
In pratica, si sceglie k tale da mantenere il 95% o 99% della varianza totale.
import numpy as np
# Dataset sintetico: 200 campioni, 5 feature (correlate)
np.random.seed(42)
n, d = 200, 5
X = np.random.randn(n, 2) @ np.array([[2, 1, 0.5, 0.3, 0.1],
[0.5, 1.5, 1, 0.2, 0.8]])
X += np.random.randn(n, d) * 0.3 # Rumore
# PCA da zero
# 1. Centrare i dati
X_centered = X - X.mean(axis=0)
# 2. Matrice di covarianza
C = np.cov(X_centered, rowvar=False)
print(f"Matrice di covarianza:\n{np.round(C, 3)}\n")
# 3. Autovalori e autovettori
eigenvalues, eigenvectors = np.linalg.eigh(C)
# Ordinare in ordine decrescente
idx = np.argsort(eigenvalues)[::-1]
eigenvalues = eigenvalues[idx]
eigenvectors = eigenvectors[:, idx]
print(f"Autovalori: {np.round(eigenvalues, 4)}")
# 4. Varianza spiegata
var_explained = eigenvalues / eigenvalues.sum()
cumulative = np.cumsum(var_explained)
for i in range(d):
print(f"PC{i+1}: {var_explained[i]*100:.1f}% (cumulativa: {cumulative[i]*100:.1f}%)")
# 5. Proiezione a 2D
k = 2
W_k = eigenvectors[:, :k]
Z = X_centered @ W_k
print(f"\nShape originale: {X.shape} -> Ridotta: {Z.shape}")
# 6. Errore di ricostruzione
X_reconstructed = Z @ W_k.T + X.mean(axis=0)
reconstruction_error = np.mean((X - X_reconstructed)**2)
print(f"Errore di ricostruzione (MSE): {reconstruction_error:.6f}")
PCA con Scikit-Learn
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import numpy as np
# Standardizzazione (importante! PCA e sensibile alla scala)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# PCA automatica
pca = PCA(n_components=0.95) # Mantieni 95% varianza
X_pca = pca.fit_transform(X_scaled)
print(f"Componenti selezionate: {pca.n_components_}")
print(f"Varianza spiegata: {pca.explained_variance_ratio_}")
print(f"Shape: {X.shape} -> {X_pca.shape}")
Oltre PCA: t-SNE e UMAP
PCA e limitata a trasformazioni lineari. Per strutture non-lineari nei dati, si usano metodi come t-SNE e UMAP.
t-SNE
t-SNE (t-distributed Stochastic Neighbor Embedding) preserva le distanze locali: punti vicini nello spazio originale restano vicini nella rappresentazione 2D. Minimizza la KL divergence tra le distribuzioni di similarità nello spazio originale e in quello ridotto:
UMAP
UMAP (Uniform Manifold Approximation and Projection) e più veloce di t-SNE e preserva meglio la struttura globale. E basato sulla topologia algebrica e sulla teoria dei grafi fuzzy.
Quando usare quale: PCA per preprocessing (ridurre dimensioni prima di un classificatore, denoising); t-SNE/UMAP per visualizzazione in 2D/3D (esplorare cluster, outlier). PCA e invertibile e interpretabile, t-SNE/UMAP no.
Applicazione: PCA per Preprocessing nel ML
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import numpy as np
# Dataset digits: 1797 immagini 8x8 = 64 feature
digits = load_digits()
X, y = digits.data, digits.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Senza PCA (64 feature)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)
clf_full = LogisticRegression(max_iter=5000)
clf_full.fit(X_train_s, y_train)
acc_full = clf_full.score(X_test_s, y_test)
# Con PCA (mantieni 95% varianza)
pca = PCA(n_components=0.95)
X_train_pca = pca.fit_transform(X_train_s)
X_test_pca = pca.transform(X_test_s)
clf_pca = LogisticRegression(max_iter=5000)
clf_pca.fit(X_train_pca, y_train)
acc_pca = clf_pca.score(X_test_pca, y_test)
print(f"Senza PCA: {X_train_s.shape[1]} feature, Accuracy: {acc_full:.4f}")
print(f"Con PCA: {X_train_pca.shape[1]} feature, Accuracy: {acc_pca:.4f}")
print(f"Riduzione: {(1 - X_train_pca.shape[1]/X_train_s.shape[1])*100:.0f}% delle feature")
Riepilogo e Connessioni con il ML
Punti Chiave da Ricordare
- PCA: proietta sui primi k autovettori della matrice di covarianza
- Autovalori \\lambda_i: varianza catturata da ogni componente
- Varianza spiegata: scegli k per mantenere il 95%+ della varianza
- Standardizzazione: fondamentale prima di PCA (sensibile alla scala)
- t-SNE/UMAP: per visualizzazione non-lineare in 2D/3D
- PCA per preprocessing: riduce overfitting e accelera il training
Nel Prossimo Articolo: esploreremo le funzioni di perdita nel dettaglio. MSE, Cross-Entropy, Focal Loss, Hinge Loss e come sceglierne e crearne di personalizzate.