PCA: varianza, autovettori e componenti principali
Imparerete ad applicare PCA a un dataset ad alta dimensionalità, esaminare i rapporti di varianza spiegata e scegliere il numero di componenti che conserva il 95% della varianza totale.
PCA: varianza, autovettori e componenti principali è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 1 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.
Il problema dei dati ad alta dimensionalità
All'aumentare del numero di caratteristiche, i dataset diventano sempre più sparsi: è la maledizione della dimensionalità. Molte caratteristiche sono ridondanti o correlate e contengono informazioni sovrapposte. La Principal Component Analysis (PCA) risolve questo problema individuando un nuovo insieme più piccolo di assi (componenti principali) che catturano la massima varianza dei dati con il minor numero di dimensioni.
Varianza: che cosa massimizza PCA
PCA cerca nello spazio delle caratteristiche le direzioni lungo le quali i dati variano maggiormente. Una direzione con varianza elevata cattura informazioni ricche; una direzione con varianza prossima a zero è essenzialmente rumore. La prima componente principale (PC1) è la direzione di massima varianza, PC2 è ortogonale a PC1 e presenta la varianza successiva più elevata, e così via.
Matrice di covarianza e autovettori
PCA opera sulla matrice di covarianza dei dati centrati. Gli autovettori di questa matrice indicano le direzioni di massima varianza, mentre i corrispondenti autovalori misurano quanta varianza cattura ciascuna direzione. Gli autovettori sono le componenti principali; ordinarli per autovalore decrescente produce PC1, PC2, ... PCn.
import numpy as np
X = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9],
[1.9, 2.2], [3.1, 3.0], [2.3, 2.7]])
# Centre the data
X_centered = X - X.mean(axis=0)
# Compute covariance matrix
cov = np.cov(X_centered.T)
print('Covariance matrix:\n', cov)
# Eigenvectors and eigenvalues
eigenvalues, eigenvectors = np.linalg.eigh(cov)
idx = np.argsort(eigenvalues)[::-1]
print('Eigenvalues:', eigenvalues[idx])
print('PC1 direction:', eigenvectors[:, idx[0]])Rapporto di varianza spiegata
Il rapporto di varianza spiegata di ciascuna componente è il suo autovalore diviso per la somma di tutti gli autovalori. Se PC1 spiega il 90% della varianza e PC2 l'8%, le prime due componenti insieme conservano il 98% di tutte le informazioni. Questo rapporto guida la scelta del numero di componenti da mantenere; una soglia comune è il 95%.
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True) # 64 features
pca = PCA()
pca.fit(X)
cumulative_variance = pca.explained_variance_ratio_.cumsum()
n_95 = (cumulative_variance < 0.95).sum() + 1
print(f'Components to retain 95% variance: {n_95}')
print(f'Explained by first 10 components: {cumulative_variance[9]:.3f}')Scelta di n_components
Imposti n_components come numero intero (ad esempio PCA(n_components=10)) per mantenere esattamente 10 componenti, oppure come valore decimale compreso tra 0 e 1 (ad esempio PCA(n_components=0.95)) per mantenere automaticamente un numero sufficiente di componenti a spiegare quella frazione della varianza. Quest'ultimo approccio è il più semplice nelle pipeline in cui desidera una riduzione basata sulla varianza senza conoscere in anticipo il numero di componenti.
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True)
# Retain 95% of variance automatically
pca = PCA(n_components=0.95)
pca.fit(X)
print('Number of components chosen:', pca.n_components_)
print('Total variance retained:', pca.explained_variance_ratio_.sum().round(4))Il grafico scree
Un grafico scree mostra il rapporto di varianza spiegata (o l'autovalore) sull'asse y e l'indice della componente sull'asse x. In genere il grafico mostra una brusca diminuzione seguita da un plateau piatto. Il gomito, cioè il punto in cui la diminuzione diventa graduale, è un'altra euristica per determinare il numero di componenti da mantenere, simile al metodo del gomito in K-Means.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine
X, _ = load_wine(return_X_y=True)
pca = PCA()
pca.fit(X)
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.bar(range(1, 14), pca.explained_variance_ratio_)
plt.xlabel('Component')
plt.ylabel('Explained variance ratio')
plt.title('Scree Plot')
plt.subplot(1, 2, 2)
plt.plot(pca.explained_variance_ratio_.cumsum(), marker='o')
plt.axhline(0.95, color='red', linestyle='--')
plt.xlabel('Number of components')
plt.ylabel('Cumulative variance')
plt.tight_layout()
plt.show()Centratura e ridimensionamento prima di PCA
PCA è sensibile alla scala delle caratteristiche. Una caratteristica misurata in migliaia dominerà la matrice di covarianza. Applichi sempre la standardizzazione con StandardScaler prima di PCA per assegnare a ogni caratteristica una varianza unitaria. La centratura (media zero) è essenziale: PCA la esegue implicitamente, ma se utilizza una Pipeline, lo scaler dovrebbe comparire per primo, così PCA opera su caratteristiche già centrate e con la stessa scala.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine
X, _ = load_wine(return_X_y=True)
pipe = Pipeline([
('scaler', StandardScaler()),
('pca', PCA(n_components=0.95))
])
pipe.fit(X)
print('Original shape:', X.shape)
print('Reduced shape:', pipe.transform(X).shape)Che cosa rappresentano le componenti principali?
Ogni componente principale è una combinazione lineare delle caratteristiche originali, ovvero una somma pesata. Esaminando i coefficienti di caricamento dei componenti (i coefficienti), è possibile capire quali caratteristiche originali contribuiscono maggiormente a ciascun PC. Tuttavia, i componenti spesso non sono direttamente interpretabili perché combinano tra loro diverse caratteristiche. PCA è principalmente uno strumento di compressione, non di selezione delle caratteristiche.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_wine
import pandas as pd
X, _ = load_wine(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=2)
pca.fit(X_scaled)
feature_names = load_wine().feature_names
loadings = pd.DataFrame(pca.components_.T, index=feature_names,
columns=['PC1', 'PC2'])
print(loadings.round(2))SVD: l’implementazione efficiente
Nella pratica, scikit-learn calcola PCA tramite la decomposizione ai valori singolari (SVD) invece di eseguire esplicitamente la decomposizione agli autovalori della matrice di covarianza, perché SVD è numericamente più stabile e opera direttamente sulla matrice dei dati senza costruire la matrice di covarianza. Il risultato è matematicamente identico. Per dataset molto grandi, PCA(svd_solver='randomized') utilizza una SVD randomizzata approssimata per aumentare la velocità.
PCA è lineare e ortogonale
Limitazioni importanti: PCA individua solo relazioni lineari tra le caratteristiche. Se la struttura significativa dei dati si trova su una varietà curva (ad esempio, un rotolo svizzero), PCA non la individuerà efficacemente: kernel PCA o t-SNE sono alternative migliori. Inoltre, i componenti di PCA sono ortogonali per costruzione, il che può non essere adatto se i fattori sottostanti sono correlati.
PCA su un dataset reale: procedura completa rapida
Ecco il flusso di lavoro completo: ridimensionare i dati, applicare PCA per ridurli a 2D e creare uno scatter plot con colori diversi per le classi, per verificare se lo spazio ridotto continua a separare visivamente le classi. Si tratta di un passaggio esplorativo standard prima di addestrare un classificatore sull’intero insieme di caratteristiche.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
X, y = load_iris(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X_scaled)
plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set1', s=30)
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%} var)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%} var)')
plt.title('Iris in PCA space')
plt.colorbar(label='Class')
plt.show()Verifica rapida
Verifichi la Sua comprensione di PCA in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: PCA individua le direzioni di massima varianza tramite gli autovettori della matrice di covarianza, il rapporto di varianza spiegata indica quanti componenti conservare (in genere si punta al 95%) e occorre standardizzare sempre le caratteristiche prima di applicare PCA, affinché le differenze di scala non influenzino i componenti. Nel prossimo argomento proietteremo i dati nello spazio dei componenti principali e li ricostruiremo per quantificare la perdita di informazioni.
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 «PCA: varianza, autovettori e componenti principali» è gratuita?
Sì — il testo completo di «PCA: varianza, autovettori e componenti principali» è 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 «PCA: varianza, autovettori e componenti principali»?
Imparerete ad applicare PCA a un dataset ad alta dimensionalità, esaminare i rapporti di varianza spiegata e scegliere il numero di componenti che conserva il 95% della varianza totale. 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 1 di 4.
Quanto tempo richiede la lezione «PCA: varianza, autovettori e componenti principali»?
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