Was ist der Unterschied zwischen 'transform' und 'fit_transform' in sklearn?

In der sklearn-python-Toolbox gibt es zwei Funktionen transformund fit_transformungefähr sklearn.decomposition.RandomizedPCA. Die Beschreibung von zwei Funktionen ist wie folgt

Aber was ist der Unterschied zwischen ihnen?

Hier ist der Unterschied, dass Sie pca.transform nur verwenden können, wenn Sie bereits PCA auf einer Matrix berechnet haben

   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]])

Wenn Sie verwenden möchten, müssen .transformSie Ihrem PC die Transformationsregel beibringen

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]: 

Insbesondere wendet die PCA-Transformation die mit der PCA-Zerlegung der Matrix X erhaltene Basisänderung auf die Matrix Z an.

In der Scikit-Learn Estimator-API ,

fit() : Wird zum Generieren von Lernmodellparametern aus Trainingsdaten verwendet

transform(): Aus der fit()Methode generierte Parameter , die auf das Modell angewendet werden, um einen transformierten Datensatz zu generieren.

fit_transform(): Kombination von fit()und transform()API auf demselben Datensatz

Kasse Kapitel-4 aus diesem Buch und Antwort von Stackexchange für mehr Klarheit

Diese Methoden werden verwendet, um die Skalierung bestimmter Daten zu zentrieren / zu kennzeichnen. Grundsätzlich hilft es, die Daten innerhalb eines bestimmten Bereichs zu normalisieren

Hierfür verwenden wir die Z-Score-Methode.

Wir machen das am Trainingsdatensatz.

1. Fit (): Die Methode berechnet die Parameter μ und σ und speichert sie als interne Objekte.

2. Transform (): Die Methode, die diese berechneten Parameter verwendet, wendet die Transformation auf einen bestimmten Datensatz an.

3. Fit_transform (): Verbindet die Methode fit () und transform () zur Transformation des Datasets.

Code-Snippet für Feature Scaling / Standardization (nach train_test_split).

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

Wir wenden dieselbe (Trainingssatz dieselben zwei Parameter μ und σ (Werte)) Parametertransformation auf unseren Testsatz an.

Allgemeiner Unterschied zwischen den Methoden:

• fit (raw_documents [, y]): Lernen Sie ein Vokabular aller Token in den Rohdokumenten.
• fit_transform (raw_documents [, y]): Lernen Sie das Vokabularwörterbuch und geben Sie die Term-Document-Matrix zurück. Dies entspricht der Anpassung, gefolgt von der Transformation, ist jedoch effizienter implementiert.
• transform (raw_documents): Transformiert Dokumente in eine Dokumenttermmatrix. Extrahieren Sie Token-Zählungen aus Rohtextdokumenten mithilfe des mit fit angepassten Vokabulars oder des dem Konstruktor bereitgestellten Vokabulars.

Sowohl fit_transform als auch transform geben dieselbe Document-Term-Matrix zurück.

Quelle

Hier der grundlegende Unterschied zwischen .fit()& .fit_transform():

.passen():

wird im überwachten Lernen mit zwei Objekten / Parametern (x, y) verwendet, um das Modell anzupassen und das Modell zum Laufen zu bringen, wobei wir wissen, was wir vorhersagen werden

.fit_transform ():

wird beim unbeaufsichtigten Lernen mit einem Objekt / Parameter (x) verwendet, bei dem wir nicht wissen, was wir vorhersagen werden.

Für Laien bedeutet fit_transform, eine Berechnung durchzuführen und dann eine Transformation durchzuführen (z. B. die Mittelwerte von Spalten aus einigen Daten zu berechnen und dann die fehlenden Werte zu ersetzen). Für das Trainingsset müssen Sie also sowohl die Berechnung berechnen als auch durchführen.

Beim Testen des Satzes wendet das maschinelle Lernen eine Vorhersage an, die auf dem basiert, was während des Trainingssatzes gelernt wurde, und muss daher nicht berechnet werden, sondern führt lediglich die Transformation durch.

Warum und wann jeweils verwenden:

Alle Antworten sind recht gut, aber ich möchte betonen, warum und wann jede Methode verwendet wird.

fit (), transform (), fit_transform ()

Normalerweise haben wir ein überwachtes Lernproblem mit (X, y) als Out-Datensatz und teilen es in Trainingsdaten und Testdaten auf:

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)

Stellen Sie sich vor, wir passen einen Tokenizer an. Wenn wir X anpassen, fügen wir Testdaten in den Tokenizer ein, aber ich habe diesen Fehler oft gesehen!

Das Richtige ist, NUR mit X_train zu passen , da Sie "Ihre zukünftigen Daten" nicht kennen und daher X_test-Daten nicht zum Anpassen verwenden können!

Dann können Sie Ihre Testdaten transformieren, aber separat gibt es deshalb verschiedene Methoden.

Letzter Tipp: X_train_transformed = model.fit_transform(X_train)entspricht:, X_train_transformed = model.fit(X_train).transform(X_train)aber der erste ist schneller.

Beachten Sie, dass das, was ich "Modell" nenne, normalerweise ein Skalierer, ein tfidf-Transformator, eine andere Art von Vektorisierer, ein Tokenizer ist ...