Costruire la prima pipeline: scaler più classificatore
Imparerete a concatenare StandardScaler e LogisticRegression in una Pipeline, chiamare fit e predict e verificare che lo scaler sia stato addestrato solo sui dati di training.
Costruire la prima pipeline: scaler più classificatore è 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.
Che cos'è una Pipeline di scikit-learn?
Una Pipeline concatena più passaggi di elaborazione in un unico oggetto estimator. Ogni passaggio, tranne l'ultimo, deve implementare fit e transform; l'ultimo deve implementare solo fit e predict. La chiamata a pipeline.fit(X, y) esegue tutti i passaggi in sequenza, mentre pipeline.predict(X) fa passare i dati attraverso tutte le trasformazioni prima di classificarli. In questo modo si eliminano gli errori di gestione manuale e si previene il data leakage.
Perché le pipeline prevengono il leakage
Se si esegue il fit di uno StandardScaler sull'intero dataset e poi si esegue la suddivisione in train e test, lo scaler ha già visto le statistiche del set di test: questo è data leakage. Una Pipeline risolve automaticamente il problema: quando si passa una Pipeline a cross_val_score o GridSearchCV, l'intera pipeline, scaler incluso, viene sottoposta nuovamente a fit da zero su ogni fold di addestramento, quindi il fold di test non influenza i parametri dello scaler.
Costruire la prima Pipeline
Crei una Pipeline passando un elenco di tuple (name, estimator). I nomi sono stringhe arbitrarie scelte da Lei e servono per fare riferimento ai passaggi in un secondo momento, ad esempio per gli iperparametri della ricerca su griglia. La pipeline iniziale più comune è composta da uno scaler seguito da un classificatore.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(C=1.0, max_iter=200))
])
print('Steps:', [name for name, _ in pipe.steps])
print('Named steps:', list(pipe.named_steps.keys()))Eseguire il fit e fare previsioni
Dopo la costruzione, utilizzi la Pipeline esattamente come qualsiasi estimator di sklearn: esegua fit sui dati di addestramento, predict sui dati di test e score per calcolare l'accuratezza. Internamente, fit chiama fit_transform su tutti i passaggi intermedi e fit sull'estimator finale.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(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()),
('clf', LogisticRegression(max_iter=300))
])
pipe.fit(X_train, y_train)
print('Test accuracy:', pipe.score(X_test, y_test).round(4))
y_pred = pipe.predict(X_test)
print('Predictions[:5]:', y_pred[:5])Verificare che lo scaler esegua il fit solo sui dati di addestramento
Dopo aver eseguito il fit della Pipeline sui dati di addestramento, è possibile esaminare i parametri appresi da ciascun passaggio. Lo scaler interno alla pipeline avrà gli attributi mean_ e scale_ calcolati esclusivamente sul set di addestramento, non sull'intero dataset. Questo conferma che la pipeline funziona correttamente.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression(max_iter=300))])
pipe.fit(X_train, y_train)
# Scaler mean from pipeline vs computed from X_train
print('Pipeline scaler mean[0]:', pipe.named_steps['sc'].mean_[0].round(4))
print('Direct train mean[0]: ', X_train[:, 0].mean().round(4))Accedere agli output intermedi
Per ottenere l'output trasformato di un passaggio specifico, utilizzi pipeline[:-1].transform(X) oppure acceda ai singoli passaggi tramite pipeline.named_steps['step_name']. È anche possibile chiamare pipeline[:'step_name'] usando la sintassi delle slice di Python, per ottenere una sottopipeline fino a quel passaggio incluso. È utile per il debugging o per esaminare l'aspetto dei dati dopo la scalatura.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
pipe.fit(X, y)
# Get scaled output (all steps except the last)
X_scaled = pipe[:-1].transform(X)
print('After scaling — mean per feature:', X_scaled.mean(axis=0).round(4))
print('After scaling — std per feature:', X_scaled.std(axis=0).round(4))make_pipeline: una scorciatoia
make_pipeline crea una Pipeline senza richiedere di specificare manualmente i nomi dei passaggi: genera i nomi a partire dai nomi delle classi, convertiti in minuscolo. È comodo per gli esperimenti rapidi, ma meno leggibile nel codice di produzione, dove i nomi espliciti aiutano a identificare i passaggi nelle stringhe dei parametri della ricerca su griglia.
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_iris(return_X_y=True)
# Auto-names: 'minmaxscaler' and 'kneighborsclassifier'
pipe = make_pipeline(MinMaxScaler(), KNeighborsClassifier(n_neighbors=5))
print('Step names:', list(pipe.named_steps.keys()))
print('CV accuracy:', cross_val_score(pipe, X, y, cv=5).mean().round(4))Pipeline con previsioni di probabilità
Se l'estimator finale supporta predict_proba, anche la Pipeline lo espone. Ciò consente di utilizzare una Pipeline con qualsiasi funzione che richieda output probabilistici, come il calcolo ROC-AUC, le curve di calibrazione o la regolazione della soglia, senza dover applicare manualmente il preprocessing prima di chiamare il modello.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression(max_iter=300))])
pipe.fit(X_train, y_train)
proba = pipe.predict_proba(X_test)[:, 1]
print('ROC-AUC:', roc_auc_score(y_test, proba).round(4))Impostare i parametri dopo la costruzione
È possibile aggiornare il parametro di qualsiasi passaggio dopo aver creato la Pipeline, usando set_params(step__param=value) con il separatore costituito dal doppio underscore. Questa è la stessa sintassi usata in GridSearchCV. È utile quando si desidera sperimentare impostazioni diverse senza ricostruire da zero l'intera pipeline.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
# Change C and max_iter after construction
pipe.set_params(lr__C=10.0, lr__max_iter=500)
print('C after set_params:', pipe.named_steps['lr'].C)Serializzare e condividere le pipeline
Una Pipeline sottoposta a fit è un singolo oggetto Python che può essere serializzato con pickle o joblib. Condividere la pipeline in un unico file garantisce che al momento delle previsioni vengano applicati esattamente gli stessi passaggi di preprocessing, con gli stessi identici parametri dello scaler, eliminando i problemi di coerenza tra gli ambienti di addestramento e di serving.
import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
pipe.fit(X, y)
# Save and reload
joblib.dump(pipe, '/tmp/iris_pipeline.pkl')
loaded_pipe = joblib.load('/tmp/iris_pipeline.pkl')
print('Predictions match:', (pipe.predict(X) == loaded_pipe.predict(X)).all())Best practice per la convalida incrociata delle pipeline
Inserisca sempre la Pipeline in cross_val_score, anziché eseguire manualmente un ciclo sui fold. In questo modo lo scaler viene sottoposto nuovamente a fit su ogni fold di addestramento e non entra mai in contatto con il fold di validazione, fornendo una stima affidabile delle prestazioni di generalizzazione.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
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()),
('svm', SVC(kernel='rbf', C=5.0, gamma='scale'))
])
scores = cross_val_score(pipe, X, y, cv=5, n_jobs=-1)
print(f'CV accuracy: {np.mean(scores):.4f} +/- {np.std(scores):.4f}')Verifica rapida
Verifichi la Sua comprensione delle Pipeline di scikit-learn illustrate in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: una Pipeline concatena i passaggi in un unico estimator, prevenendo il leakage eseguendo il fit di ogni passaggio solo sui dati di addestramento disponibili; make_pipeline offre scorciatoie con nomi automatici, mentre i nomi espliciti migliorano la leggibilità della ricerca su griglia; infine, una Pipeline sottoposta a fit può essere serializzata con pickle e condivisa come un singolo artefatto, per garantire un preprocessing coerente al momento del serving. Ora inseriremo ColumnTransformer in una Pipeline per gestire dati numerici e categorici misti.
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 «Costruire la prima pipeline: scaler più classificatore» è gratuita?
Sì — il testo completo di «Costruire la prima pipeline: scaler più classificatore» è 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 «Costruire la prima pipeline: scaler più classificatore»?
Imparerete a concatenare StandardScaler e LogisticRegression in una Pipeline, chiamare fit e predict e verificare che lo scaler sia stato addestrato solo sui dati di training. 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 «Costruire la prima pipeline: scaler più classificatore»?
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
- Costruire la prima pipeline: scaler più classificatore
- ColumnTransformer all’interno di una pipeline
- Cross-validation e grid search di una pipeline completa
- Salvare e caricare una pipeline con joblib