Proiettare i dati e ricostruirli dalle componenti
Imparerete a trasformare un dataset nello spazio delle componenti principali, visualizzare la proiezione 2D e ricostruire le feature originali per quantificare la perdita di informazioni.
Proiettare i dati e ricostruirli dalle componenti è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Machine Learning Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Machine Learning Academy include 4 lezioni in totale.
Proiezione: dall’alta dimensionalità alla bassa dimensionalità
Dopo che PCA ha individuato i componenti principali, la proiezione trasforma ogni punto dati nel nuovo spazio dei componenti. Le coordinate proiettate sono chiamate score. Se si conservano solo 2 componenti delle 64 caratteristiche originali, ogni punto a 64 dimensioni diventa uno score a 2 dimensioni. Questo risultato si ottiene moltiplicando la matrice dei dati centrati per la matrice degli autovettori (la matrice dei caricamenti).
Il metodo transform in sklearn
In scikit-learn, pca.fit(X) apprende i componenti e pca.transform(X) proietta i dati. Il metodo di utilità pca.fit_transform(X) esegue entrambe le operazioni in un’unica chiamata. Il risultato è una matrice di forma (n_samples, n_components): ogni riga rappresenta un punto nello spazio ridotto.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
X, y = load_digits(return_X_y=True) # 1797 x 64
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=10)
X_reduced = pca.fit_transform(X_scaled)
print('Original shape:', X_scaled.shape)
print('Reduced shape:', X_reduced.shape)
print('Variance retained:', pca.explained_variance_ratio_.sum().round(4))Visualizzazione della proiezione 2D
La proiezione su 2 componenti produce uno scatter plot in cui la separazione tra le classi è spesso visibile, anche se le etichette non sono mai state utilizzate durante PCA. Si tratta di un importante strumento esplorativo: se le classi sono ben separate nello spazio PCA 2D, un semplice classificatore lineare potrebbe ottenere buoni risultati nello spazio completo.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
X, y = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca2 = PCA(n_components=2)
X_2d = pca2.fit_transform(X_scaled)
plt.figure(figsize=(8, 6))
for digit in range(10):
mask = y == digit
plt.scatter(X_2d[mask, 0], X_2d[mask, 1], label=str(digit), s=10, alpha=0.6)
plt.legend(title='Digit', bbox_to_anchor=(1, 1))
plt.title('MNIST digits in 2D PCA space')
plt.tight_layout()
plt.show()Ricostruzione: ritorno allo spazio originale
La ricostruzione inverte la proiezione: si moltiplicano gli score ridotti per la trasposta della matrice dei caricamenti e si riaggiunge la media. Il risultato è un’approssimazione dei dati originali nello spazio delle caratteristiche originale. Una ricostruzione perfetta è possibile solo conservando tutti i componenti; conservarne un numero inferiore introduce un errore di ricostruzione.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
import numpy as np
X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=20)
X_reduced = pca.fit_transform(X_scaled)
# Reconstruct back to 64 dimensions
X_reconstructed = pca.inverse_transform(X_reduced)
print('Reconstruction shape:', X_reconstructed.shape)
# Mean squared reconstruction error
mse = np.mean((X_scaled - X_reconstructed) ** 2)
print(f'MSE: {mse:.4f}')Visualizzazione della qualità della ricostruzione
Per i dati delle immagini, è possibile visualizzare affiancate le immagini originali e quelle ricostruite. Conservando più componenti, la ricostruzione appare più nitida. Con pochissimi componenti, le cifre diventano macchie sfocate. Questo confronto visivo è un efficace strumento di comunicazione per mostrare agli stakeholder il compromesso tra compressione e perdita di informazioni.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
fig, axes = plt.subplots(3, 5, figsize=(12, 7))
component_counts = [1, 2, 5, 10, 30]
for col, nc in enumerate(component_counts):
pca = PCA(n_components=nc)
X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
# Un-standardise for display (approximate)
axes[0, col].imshow(X[0].reshape(8, 8), cmap='gray')
axes[0, col].set_title(f'Original' if col == 0 else '')
axes[1, col].imshow(X_r[0].reshape(8, 8), cmap='gray')
axes[1, col].set_title(f'n={nc}')
plt.tight_layout()
plt.show()Errore di ricostruzione rispetto al numero di componenti
Tracci il MSE di ricostruzione rispetto al numero di componenti per visualizzare la curva della perdita di informazioni. Questa è la versione quantitativa del confronto visivo. Una forte diminuzione del MSE quando si aggiungono i primi componenti rispecchia lo scree plot e conferma che la maggior parte delle informazioni risiede in un sottospazio di piccole dimensioni.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
import numpy as np
X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
components = [1, 2, 5, 10, 20, 30, 40, 50, 64]
mse_values = []
for nc in components:
pca = PCA(n_components=nc)
X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
mse_values.append(np.mean((X_scaled - X_r) ** 2))
plt.plot(components, mse_values, marker='o')
plt.xlabel('Number of components')
plt.ylabel('Reconstruction MSE')
plt.title('Information Loss vs Compression')
plt.show()Interpretazione dell’errore di ricostruzione
Con zero componenti, l’errore di ricostruzione è uguale alla varianza totale dei dati. Con tutti i componenti, l’errore è zero. Il rapporto 1 - explained_variance_ratio.sum() indica la frazione di varianza scartata. Nella maggior parte delle pipeline di ML pratiche, conservare il 95–99% della varianza (e scartare l’1–5%) comporta una perdita molto ridotta di segnale predittivo, riducendo significativamente il numero di caratteristiche e il tempo di addestramento.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
for nc in [5, 10, 20, 30, 40]:
pca = PCA(n_components=nc)
pca.fit(X_scaled)
retained = pca.explained_variance_ratio_.sum()
print(f'n_components={nc:2d} retained={retained:.3f} discarded={1-retained:.3f}')Uso pratico di inverse_transform
pca.inverse_transform(X_reduced) è un metodo dell’oggetto PCA su cui è stato eseguito il fit. Restituisce i dati nello spazio delle caratteristiche originale, ma con le informazioni dei componenti scartati azzerate. È utile per il rilevamento delle anomalie: si ricostruiscono i dati di addestramento e si segnalano come outlier i punti con un errore di ricostruzione elevato, che il modello PCA non è riuscito a rappresentare bene.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import numpy as np
# Simulated normal vs anomalous points
X_normal = np.random.randn(100, 10)
X_anomaly = np.random.randn(5, 10) * 10 # far from origin
X_all = np.vstack([X_normal, X_anomaly])
X_scaled = StandardScaler().fit_transform(X_all)
pca = PCA(n_components=5)
X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
errors = np.mean((X_scaled - X_r) ** 2, axis=1)
print('Max error index:', np.argmax(errors), '(anomalies start at index 100)')Whitening: componenti decorrelati con varianza unitaria
Impostando PCA(whiten=True) si ridimensionano gli score proiettati affinché ogni componente abbia varianza unitaria. In questo modo si rimuovono le correlazioni tra i componenti e si possono migliorare le prestazioni di algoritmi come SVM o reti neurali, sensibili alla scala delle caratteristiche. Il whitening è un preprocessing standard prima dell’addestramento su caratteristiche ridotte tramite PCA.
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
import numpy as np
X, _ = load_iris(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca_white = PCA(n_components=3, whiten=True)
X_w = pca_white.fit_transform(X_scaled)
print('Component variances (should be 1.0):', np.var(X_w, axis=0).round(4))Limiti di PCA sui dati non lineari
PCA individua solo proiezioni lineari. Se i dati si trovano su una superficie curva, come un rotolo svizzero, PCA li proietta su un piano piatto, distruggendo la struttura della varietà. In questi casi, consideri Kernel PCA con un kernel RBF oppure alternative non lineari come t-SNE o UMAP per l’esplorazione. Per il preprocessing dei modelli, tuttavia, PCA lineare è generalmente sufficiente e molto più veloce.
Proiezione e ricostruzione: procedura completa
Una pipeline PCA ben strutturata segue sempre lo stesso schema: standardizzare, eseguire il fit di PCA sui dati di addestramento, trasformare separatamente i dati di addestramento e di test e, facoltativamente, ricostruire i dati per verificarne la qualità.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits
import numpy as np
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test) # use train scaler
pca = PCA(n_components=0.95)
X_train_r = pca.fit_transform(X_train_s) # fit only on train
X_test_r = pca.transform(X_test_s) # transform test
print(f'Reduced: {X_train_r.shape[1]} components from 64 features')Verifica rapida
Verifichi la Sua comprensione della proiezione e della ricostruzione con PCA in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: pca.transform proietta i dati nello spazio dei componenti con forma (n_samples, n_components), pca.inverse_transform ricostruisce i dati nello spazio delle caratteristiche originale, con perdita delle informazioni dei componenti scartati, e l’errore di ricostruzione quantifica la perdita di informazioni e può segnalare anomalie. Nel prossimo argomento esploreremo t-SNE, una tecnica non lineare per la visualizzazione 2D di dati ad alta dimensionalità.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Proiettare i dati e ricostruirli dalle componenti» è gratuita?
Sì — il testo completo di «Proiettare i dati e ricostruirli dalle componenti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Machine Learning Academy, passa a CoddyKit PRO. Il corso Machine Learning Academy include 4 lezioni in totale.
Cosa imparerò in «Proiettare i dati e ricostruirli dalle componenti»?
Imparerete a trasformare un dataset nello spazio delle componenti principali, visualizzare la proiezione 2D e ricostruire le feature originali per quantificare la perdita di informazioni. Eserciti Machine Learning Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Machine Learning Academy?
Non è richiesta alcuna esperienza precedente. Machine Learning Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Proiettare i dati e ricostruirli dalle componenti»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Machine Learning Academy?
Sì. Ogni lezione Machine Learning Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- PCA: varianza, autovettori e componenti principali
- Proiettare i dati e ricostruirli dalle componenti
- t-SNE: preservare i vicinati per la visualizzazione
- PCA come preprocessing: velocità e riduzione del rumore nelle pipeline