PCA come preprocessing: velocità e riduzione del rumore nelle pipeline
Imparerete a inserire PCA in una sklearn Pipeline prima di un classificatore e confrontare tempo di addestramento e accuratezza sul test con e senza riduzione della dimensionalità.
PCA come preprocessing: velocità e riduzione del rumore nelle pipeline è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 4 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.
PCA come fase di preprocessing
Oltre alla visualizzazione, PCA svolge il ruolo pratico di fase di preprocessing che fornisce feature compresse a un classificatore o regressore a valle. Eliminando le componenti a bassa varianza, che spesso codificano il rumore, PCA può velocizzare l'addestramento, ridurre l'utilizzo di memoria e talvolta migliorare la capacità di generalizzazione, soprattutto quando lo spazio delle feature originale ha dimensionalità molto elevata.
Perché PCA può ridurre il rumore
Il rumore casuale di misurazione tende a distribuirsi in molte direzioni nello spazio delle feature, ma la sua varianza è ridotta lungo ogni singola direzione. PCA concentra il segnale significativo nelle componenti principali e lascia il rumore nella coda a bassa varianza. Eliminando questa coda, di fatto si esegue il denoising dei dati. Per questo il pre-processing con PCA talvolta aiuta algoritmi come la regressione logistica, sensibili alle feature correlate o rumorose.
Integrare PCA in una sklearn Pipeline
Il modo più pulito per usare PCA come preprocessing consiste nell'inserirla in una Pipeline. La pipeline garantisce che lo scaler e PCA vengano sottoposti a fit solo sui dati di addestramento e poi applicati in modo coerente ai dati di test. In questo modo si elimina un'intera classe di problemi di data leakage, che si verificano quando si dimentica di applicare la stessa trasformazione PCA al set di test.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
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=42)
pipe = Pipeline([
('scaler', StandardScaler()),
('pca', PCA(n_components=0.95)),
('clf', LogisticRegression(max_iter=500))
])
pipe.fit(X_train, y_train)
print('Test accuracy:', pipe.score(X_test, y_test).round(4))Confrontare il tempo di addestramento con e senza PCA
Nei dataset ad alta dimensionalità, PCA può ridurre drasticamente il tempo di addestramento, perché il classificatore riceve molte meno feature. Eseguiamo un benchmark della regressione logistica sul dataset digits (64 feature), con e senza riduzione preliminare tramite PCA.
import time
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
# Without PCA
t0 = time.time()
pipe_full = Pipeline([('sc', StandardScaler()), ('clf', LogisticRegression(max_iter=1000))])
pipe_full.fit(X_train, y_train)
t_full = time.time() - t0
# With PCA
t0 = time.time()
pipe_pca = Pipeline([('sc', StandardScaler()), ('pca', PCA(n_components=0.95)),
('clf', LogisticRegression(max_iter=500))])
pipe_pca.fit(X_train, y_train)
t_pca = time.time() - t0
print(f'Without PCA: {t_full:.3f}s acc={pipe_full.score(X_test, y_test):.4f}')
print(f'With PCA: {t_pca:.3f}s acc={pipe_pca.score(X_test, y_test):.4f}')Quando PCA è utile e quando non lo è
Il preprocessing con PCA è particolarmente utile quando: il numero di feature è elevato rispetto al numero di campioni (regime ad alta dimensionalità e pochi campioni), le feature sono correlate (informazioni ridondanti) oppure l'algoritmo è lento con molte feature (ad esempio, SVM con kernel RBF). PCA tende invece a NON essere utile quando: il dataset contiene già poche feature informative oppure si utilizzano modelli basati su alberi (random forest, XGBoost), che gestiscono nativamente le feature ridondanti e non traggono vantaggio dalla compressione lineare di PCA.
Regolare n_components con una ricerca su griglia
Poiché PCA è un passaggio all'interno di una Pipeline, è possibile regolare n_components insieme agli iperparametri del classificatore usando GridSearchCV. Utilizzi la notazione con doppio underscore, pca__n_components, per fare riferimento al parametro del passaggio PCA. In questo modo il ciclo di convalida incrociata può trovare simultaneamente il livello di compressione ottimale e la forza di regolarizzazione del modello.
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits
X, y = load_digits(return_X_y=True)
pipe = Pipeline([
('sc', StandardScaler()),
('pca', PCA()),
('clf', LogisticRegression(max_iter=500))
])
param_grid = {
'pca__n_components': [10, 20, 30, 40],
'clf__C': [0.1, 1.0, 10.0]
}
grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
grid.fit(X, y)
print('Best params:', grid.best_params_)
print('Best CV score:', grid.best_score_.round(4))PCA prima di SVM: una combinazione classica
Le SVM con kernel RBF calcolano le distanze a coppie nello spazio delle feature originale, un'operazione costosa per i dati ad alta dimensionalità. Applicare prima PCA riduce le dimensioni conservando il segnale e rende meno oneroso il calcolo delle distanze. Questa combinazione era una pratica standard nelle attività di classificazione delle immagini prima che il deep learning diventasse dominante: si riducevano i pixel dell'immagine con PCA e poi si eseguiva la classificazione con SVM.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.datasets import load_digits
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_digits(return_X_y=True)
pipe = Pipeline([
('sc', StandardScaler()),
('pca', PCA(n_components=30)),
('svm', SVC(kernel='rbf', C=10, gamma='scale'))
])
scores = cross_val_score(pipe, X, y, cv=5)
print(f'Accuracy: {np.mean(scores):.4f} +/- {np.std(scores):.4f}')PCA per la riduzione del rumore: un esempio concreto
Aggiungiamo rumore gaussiano al dataset digits e confrontiamo l'accuratezza del classificatore con e senza denoising tramite PCA. Sui dati rumorosi, PCA migliora spesso l'accuratezza eliminando le componenti a bassa varianza dominate dal rumore.
import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits
from sklearn.model_selection import cross_val_score
X, y = load_digits(return_X_y=True)
X_noisy = X + np.random.randn(*X.shape) * 5.0 # heavy noise
for nc in [None, 10, 20, 30, 40]:
steps = [('sc', StandardScaler())]
if nc:
steps.append(('pca', PCA(n_components=nc)))
steps.append(('clf', LogisticRegression(max_iter=500)))
pipe = Pipeline(steps)
acc = cross_val_score(pipe, X_noisy, y, cv=5).mean()
label = f'PCA({nc})' if nc else 'No PCA'
print(f'{label:10s} acc={acc:.4f}')Eseguire sempre il fit di PCA solo sui dati di addestramento
Una regola fondamentale: non esegua mai il fit della trasformazione PCA sul set di test. Eseguire il fit sui dati di test introduce nelle fasi di preprocessing le statistiche del set di test e produce stime delle prestazioni eccessivamente ottimistiche. L'utilizzo di una Pipeline impone automaticamente questa regola: quando si chiama pipeline.fit(X_train, y_train), ogni passaggio, incluso PCA, viene sottoposto a fit solo sulla suddivisione di addestramento.
Risparmio di memoria con PCA
Nei dataset con milioni di campioni e migliaia di feature (ad esempio, matrici TF-IDF testuali e dati genomici), PCA riduce drasticamente l'occupazione di memoria. Una matrice 1M×5000 in formato float32 occupa 20 GB; applicando PCA fino a 100 componenti si ottiene una matrice 1M×100 da 400 MB, con una riduzione di 50 volte. In questi casi, utilizzi IncrementalPCA di scikit-learn, che esegue il fit di PCA in blocchi e non richiede mai di caricare l'intera matrice nella RAM.
from sklearn.decomposition import IncrementalPCA
import numpy as np
# Simulate large dataset as batches
n_samples, n_features = 10000, 500
n_components = 50
batch_size = 500
ipca = IncrementalPCA(n_components=n_components)
for i in range(0, n_samples, batch_size):
batch = np.random.randn(batch_size, n_features)
ipca.partial_fit(batch)
print('Explained variance ratio sum:', ipca.explained_variance_ratio_.sum().round(4))Combinare PCA con ColumnTransformer
Nei dataset con tipi misti, è possibile applicare PCA solo alle colonne numeriche, codificare separatamente quelle categoriche e poi combinare il tutto con un ColumnTransformer. Si tratta di un approccio avanzato ma realistico per le pipeline di ML in produzione, dove feature di immagini, misurazioni numeriche e indicatori categorici coesistono nella stessa riga.
Verifica rapida
Verifichi la Sua comprensione del preprocessing con PCA nelle pipeline, illustrato in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: PCA all'interno di una Pipeline previene il data leakage, eseguendo il fit della trasformazione solo sui dati di addestramento; PCA può velocizzare l'addestramento e ridurre il rumore, soprattutto per insiemi di feature ad alta dimensionalità o correlate; inoltre, n_components può essere regolato tramite GridSearchCV insieme agli altri iperparametri del modello, usando la notazione con doppio underscore. Ora costruiremo la nostra prima Pipeline completa di scikit-learn, combinando scaler e classificatore.
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 come preprocessing: velocità e riduzione del rumore nelle pipeline» è gratuita?
Sì — il testo completo di «PCA come preprocessing: velocità e riduzione del rumore nelle pipeline» è 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 come preprocessing: velocità e riduzione del rumore nelle pipeline»?
Imparerete a inserire PCA in una sklearn Pipeline prima di un classificatore e confrontare tempo di addestramento e accuratezza sul test con e senza riduzione della dimensionalità. 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 4 di 4.
Quanto tempo richiede la lezione «PCA come preprocessing: velocità e riduzione del rumore nelle pipeline»?
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