Impara Stimatore finale

Scorri per mostrare il menu

Pipeline è stato precedentemente utilizzato per la pre-elaborazione, ma il suo vero scopo è concatenare la pre-elaborazione con un predittore finale. L'ultimo passaggio in una pipeline può essere qualsiasi stimatore (tipicamente un modello) che produce previsioni.

Nota

Quando si chiama .fit(), ogni trasformatore esegue .fit_transform(). Quando si chiama .predict(), la pipeline utilizza .transform() prima di inviare i dati allo stimatore finale. Questo è necessario perché i nuovi dati devono essere trasformati esattamente come i dati di addestramento.

Perché `.transform()`?

Utilizzare .fit_transform() su nuovi dati potrebbe modificare le codifiche (ad esempio, in OneHotEncoder), creando colonne non corrispondenti e previsioni inaffidabili. .transform() garantisce una pre-elaborazione coerente, ignorando le categorie non viste e mantenendo lo stesso ordine delle colonne.

Ecco il dataset originale prima di qualsiasi trasformazione. Questi dati grezzi rappresentano il punto di partenza per il processo di trasformazione. Non è stata ancora applicata alcuna codifica o pre-elaborazione: ogni riga mostra un'istanza con la sua caratteristica di colore come stringa. Questi sono i dati che verranno trasformati utilizzando i passaggi di pre-elaborazione nella pipeline.

Questa tabella mostra il dataset prima della codifica one-hot. La colonna Color è categorica—contiene valori di tipo stringa invece di numeri. Trasformerai questa colonna in colonne binarie separate nel prossimo passaggio utilizzando la codifica one-hot, che è essenziale affinché la maggior parte dei modelli di machine learning possa elaborare correttamente i dati categorici.

Ecco come appare il set di dati di addestramento dopo la codifica one-hot:

La tabella seguente mostra il dataset dopo l'applicazione della codifica one-hot. La colonna originale Color è stata sostituita da colonne binarie separate—Color_Red, Color_Blue e Color_Green. Ogni colonna indica se l'istanza possiede quel colore specifico (1) o meno (0).

Nota come l'originale singola colonna Color sia stata sostituita da tre colonne separate: Color_Red, Color_Blue e Color_Green. Ogni colonna rappresenta la presenza di uno specifico colore per quell'istanza, utilizzando 1 per sì e 0 per no. Questa trasformazione è chiamata one-hot encoding.

Questo cambiamento è fondamentale per i modelli di machine learning perché la maggior parte degli algoritmi non può lavorare direttamente con dati testuali o categorici. Convertendo le categorie in colonne binarie separate, si forniscono al modello caratteristiche numeriche chiare che può utilizzare per apprendere schemi e fare previsioni. Questo approccio impedisce anche al modello di assumere una relazione ordinale tra le categorie originali, il che potrebbe portare a conclusioni errate.

Ecco le nuove istanze da prevedere:

Ecco i nuovi dati su cui si desidera effettuare la previsione. Questo è il dato grezzo—lo stato 'prima'—così come appare prima di qualsiasi trasformazione o pre-elaborazione. La pipeline trasformerà questi dati per adattarli al formato utilizzato durante l'addestramento prima di effettuare le previsioni.

Il passo successivo consiste nel trasformare queste nuove istanze utilizzando l'encoder precedentemente addestrato. Questo garantisce che i nuovi dati vengano processati nello stesso modo dei dati di addestramento, assicurando coerenza e previsioni affidabili dal modello.

Se .fit_transform() venisse applicato a nuove istanze, il OneHotEncoder potrebbe generare colonne in un ordine diverso o persino introdurne di nuove. Questo porterebbe la nuova trasformazione dei dati a essere incoerente con il set di addestramento, rendendo le predizioni inaffidabili.

Se si utilizza .fit_transform() su nuovi dati invece di .transform(), l'encoder tratterà i nuovi dati come se li vedesse per la prima volta. Questo comporta:

Nuova apprendimento delle categorie dai nuovi dati;
Modifica dell'ordine delle colonne in base al nuovo insieme di categorie;
Aggiunta di una nuova colonna per ogni categoria non vista, come 'Color_Yellow' in questo caso.

Questo crea una discrepanza tra i dati di addestramento e quelli di previsione, rendendo le predizioni inaffidabili e potenzialmente causando errori nella pipeline.

Nota la differenza tra la trasformazione errata e quella corretta. La tabella con la trasformazione errata include una nuova colonna (Color_Yellow) e modifica l'ordine delle colonne rispetto ai dati di addestramento. Questo compromette la coerenza tra addestramento e previsione:

Il modello si aspetta le stesse colonne e lo stesso ordine utilizzati durante l'addestramento;
Colonne nuove o riordinate confondono il modello, portandolo a utilizzare le caratteristiche sbagliate;
Le previsioni diventano inaffidabili perché la struttura dell'input non corrisponde più a quella appresa dal modello.

Assicurarsi sempre che i nuovi dati vengano trasformati con .transform() dopo il fitting, in modo che colonne e ordine rimangano coerenti. Questo è essenziale per ottenere previsioni accurate e affidabili.

Tuttavia, l'utilizzo di .transform() garantisce che i nuovi dati vengano codificati esattamente come i dati di addestramento, ignorando le categorie non viste durante l'addestramento:

Quando si utilizza .transform() su nuovi dati, solo le colonne presenti nell'addestramento vengono incluse nell'output. Qualsiasi categoria non vista durante l'addestramento—come 'Yellow'—viene ignorata. Questo garantisce che i nuovi dati corrispondano alla struttura attesa dal modello, senza colonne extra o mancanti.

Confrontando le tre tabelle:

I dati di addestramento originali (dopo one-hot encoding) presentano colonne per Color_Red, Color_Blue e Color_Green;
I nuovi dati trasformati in modo errato (utilizzando .fit_transform()) aggiungono una colonna Color_Yellow ed eliminano Color_Green, modificando l'ordine e la struttura delle colonne;
I nuovi dati trasformati correttamente (utilizzando .transform()) mantengono le stesse colonne e lo stesso ordine del set di addestramento, con zeri per categorie non viste come Yellow.

L'utilizzo di .transform() è l'approccio corretto perché garantisce che i nuovi dati vengano processati esattamente come quelli di addestramento. Questo assicura che il modello riceva i dati nel formato previsto, prevenendo errori e rendendo affidabili le predizioni.

Aggiunta del modello finale

Aggiunta del modello come ultimo passaggio della pipeline:

pipe = make_pipeline(
    ct,
    SimpleImputer(strategy='most_frequent'),
    StandardScaler(),
    KNeighborsClassifier()
)
pipe.fit(X, y)
pipe.predict(X_new)

Questo consente di eseguire l'intero workflow—preprocessing + predizione—con una sola chiamata.


              12345678910111213141516171819202122232425262728293031323334353637
            
from sklearn.pipeline import make_pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
import pandas as pd

# Example data
data = pd.DataFrame({
    'color': ['red', 'blue', 'green'],
    'value': [1, 2, 3]
})
labels = [0, 1, 0]

# Define a simple column transformer (placeholder for real preprocessing)
ct = ColumnTransformer([
    ('imputer', SimpleImputer(strategy='most_frequent'), ['color'])
])

# --- Before: Pipeline with only preprocessing steps ---
# This pipeline only transforms the data; it cannot make predictions.
pipeline_preprocessing = make_pipeline(
    ct,
    StandardScaler()
)
# pipeline_preprocessing.fit(data)  # Only fits transformers, no estimator at the end

# --- After: Pipeline with a final estimator ---
# Now the pipeline ends with a model, so it can fit and predict.
pipeline_full = make_pipeline(
    ct,
    StandardScaler(),
    KNeighborsClassifier()
)
pipeline_full.fit(data, labels)
predictions = pipeline_full.predict(data)
print("Predictions:", predictions)

Aggiunta dell'estimatore finale come ultimo passaggio trasforma la pipeline in un flusso di lavoro completo end-to-end. Invece di limitarsi a preparare i dati, la pipeline ora gestisce sia la pre-elaborazione che la predizione in un unico oggetto. Questo significa che è possibile chiamare direttamente fit() e predict() sulla pipeline, che applicherà automaticamente tutti i passaggi di pre-elaborazione prima di effettuare le predizioni.

Questo approccio è importante perché:

Garantisce che tutti i dati vengano processati esattamente nello stesso modo sia durante l'addestramento che durante la predizione;
Riduce il rischio di errori, come dimenticare un passaggio di pre-elaborazione quando si fanno predizioni su nuovi dati;
Rende il codice più pulito e facile da mantenere, poiché l'intero flusso di lavoro è gestito in un unico punto.

Collegando pre-elaborazione e modellazione, si garantiscono coerenza, affidabilità e semplicità nei progetti di machine learning.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 5

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Sezione 3. Capitolo 5

Stimatore finale

Perché .transform()?

Aggiunta del modello finale

Perché `.transform()`?