qual è la differenza tra "transform" e "fit_transform" in sklearn

Nella casella degli strumenti sklearn-python, ci sono due funzioni transforme fit_transformabout sklearn.decomposition.RandomizedPCA. La descrizione di due funzioni è la seguente

Ma qual è la differenza tra loro?

Qui la differenza puoi usare pca.transform solo se hai già calcolato PCA su una matrice

   In [12]: pc2 = RandomizedPCA(n_components=3)

    In [13]: pc2.transform(X) # can't transform because it does not know how to do it.
    ---------------------------------------------------------------------------
    AttributeError                            Traceback (most recent call last)
    <ipython-input-13-e3b6b8ea2aff> in <module>()
    ----> 1 pc2.transform(X)

    /usr/local/lib/python3.4/dist-packages/sklearn/decomposition/pca.py in transform(self, X, y)
        714         # XXX remove scipy.sparse support here in 0.16
        715         X = atleast2d_or_csr(X)
    --> 716         if self.mean_ is not None:
        717             X = X - self.mean_
        718 

    AttributeError: 'RandomizedPCA' object has no attribute 'mean_'

    In [14]: pc2.ftransform(X) 
    pc2.fit            pc2.fit_transform  

    In [14]: pc2.fit_transform(X)
    Out[14]: 
    array([[-1.38340578, -0.2935787 ],
           [-2.22189802,  0.25133484],
           [-3.6053038 , -0.04224385],
           [ 1.38340578,  0.2935787 ],
           [ 2.22189802, -0.25133484],
           [ 3.6053038 ,  0.04224385]])

se vuoi usarlo .transformdevi insegnare la regola di trasformazione al tuo pc

In [20]: pca = RandomizedPCA(n_components=3)

In [21]: pca.fit(X)
Out[21]: 
RandomizedPCA(copy=True, iterated_power=3, n_components=3, random_state=None,
       whiten=False)

In [22]: pca.transform(z)
Out[22]: 
array([[ 2.76681156,  0.58715739],
       [ 1.92831932,  1.13207093],
       [ 0.54491354,  0.83849224],
       [ 5.53362311,  1.17431479],
       [ 6.37211535,  0.62940125],
       [ 7.75552113,  0.92297994]])

In [23]: 

In particolare la trasformata PCA applica il cambio di base ottenuto con la decomposizione PCA della matrice X alla matrice Z.

In scikit-learn estimator api ,

fit() : utilizzato per generare i parametri del modello di apprendimento dai dati di addestramento

transform(): parametri generati dal fit()metodo, applicati sul modello per generare set di dati trasformati.

fit_transform(): combinazione di fit()e transform()api sullo stesso set di dati

Controlla il capitolo 4 di questo libro e rispondi a stackexchange per maggiore chiarezza

Questi metodi vengono utilizzati per centrare / caratterizzare la scala di un dato dato. Fondamentalmente aiuta a normalizzare i dati all'interno di un intervallo particolare

Per questo, usiamo il metodo Z-score.

Lo facciamo sul set di dati di addestramento.

1. Adatta (): metodo calcola i parametri μ e σ e li salva come oggetti interni.

2. Transform (): il metodo che utilizza questi parametri calcolati applica la trasformazione a un particolare set di dati.

3. Fit_transform (): unisce i metodi fit () e transform () per la trasformazione del set di dati.

Snippet di codice per il dimensionamento / standardizzazione delle funzionalità (dopo train_test_split).

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
sc.fit_transform(X_train)
sc.transform(X_test)

Applichiamo la stessa trasformazione dei parametri (set di addestramento stessi due parametri μ e σ (valori)) sul nostro set di test.

Differenza generica tra i metodi:

• fit (raw_documents [, y]): impara un dizionario di vocabolario di tutti i token nei documenti raw.
• fit_transform (raw_documents [, y]): impara il dizionario del vocabolario e restituisce la matrice termine-documento. Questo è equivalente all'adattamento seguito dalla trasformazione, ma implementato in modo più efficiente.
• transform (raw_documents): trasforma i documenti nella matrice dei termini del documento. Estrai token conta dai documenti di testo grezzo utilizzando il vocabolario fornito con fit o quello fornito al costruttore.

Sia fit_transform che transform restituiscono la stessa matrice dei termini del documento.

fonte

Ecco la differenza fondamentale tra .fit()& .fit_transform():

.in forma():

è utilizzato nell'apprendimento supervisionato avendo due oggetti / parametri (x, y) per adattare il modello e creare il modello da eseguire, dove sappiamo che ciò che andremo a prevedere

.fit_transform ():

è utilizzato nell'apprendimento non supervisionato con un oggetto / parametro (x), in cui non sappiamo cosa prevedere.

In parole povere, fit_transform significa fare un calcolo e poi fare la trasformazione (ad esempio calcolare la media delle colonne da alcuni dati e quindi sostituire i valori mancanti). Quindi, per il set di allenamento, devi sia calcolare che fare trasformazione.

Ma per il set di test, l'apprendimento automatico applica la previsione basata su ciò che è stato appreso durante il set di addestramento e quindi non ha bisogno di calcolare, esegue solo la trasformazione.

Perché e quando utilizzare ciascuno di essi:

Tutte le risposte sono abbastanza buone, ma vorrei enfatizzare PERCHÉ e QUANDO usano ciascun metodo.

fit (), transform (), fit_transform ()

Di solito abbiamo un problema di apprendimento supervisionato con (X, y) come set di dati esterno e lo suddividiamo in dati di addestramento e dati di test:

import numpy as np
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y)

X_train_vectorized = model.fit_transform(X_train)
X_test_vectorized = model.transform(X_test)

Immagina di inserire un tokenizer, se adattiamo X includiamo i dati di test nel tokenizer, ma ho visto questo errore molte volte!

La cosa corretta è adattarsi SOLO a X_train , perché non conosci i "dati futuri" quindi non puoi utilizzare i dati X_test per adattare qualsiasi cosa!

Quindi puoi trasformare i tuoi dati di test, ma separatamente, ecco perché ci sono metodi diversi.

Suggerimento finale: X_train_transformed = model.fit_transform(X_train)è equivalente a:, X_train_transformed = model.fit(X_train).transform(X_train)ma il primo è più veloce.

Si noti che quello che io chiamo "modello" di solito sarà uno scaler, un trasformatore tfidf, un altro tipo di vettorizzatore, un tokenizer ...