quelle est la différence entre 'transform' et 'fit_transform' dans sklearn


117

Dans la boîte à outils sklearn-python, il y a deux fonctions transformet fit_transformenviron sklearn.decomposition.RandomizedPCA. La description de deux fonctions est la suivante

entrez la description de l'image ici entrez la description de l'image ici

Mais quelle est la différence entre eux?


5
est.fit_transform(X)est toujours équivalent à est.fit(X).transform(X), mais généralement plus rapide.
Fred Foo

Réponses:


22

Voici la différence, vous ne pouvez utiliser pca.transform que si vous avez déjà calculé PCA sur une 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]])

si vous souhaitez l'utiliser, .transformvous devez enseigner la règle de transformation à votre PCA

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

En particulier, la transformée PCA applique le changement de base obtenu avec la décomposition PCA de la matrice X à la matrice Z.


J'ai modifié ma question. Les deux fonctions renvoient le même type de valeurs.
tqjustc

2
voulez-vous dire que fit_transformc'est la combinaison de deux fonctions fitet transform?
tqjustc

6
Si vous utilisez ajustement et transformation sur la même matrice, oui. Pas si vous ajustez la matrice x puis transformez la matrice z
Donbeo

Line In [14] dit "ftransform", qu'est-ce que c'est?
Rajdeep Biswas le

97

Dans l' API d'estimation scikit-learn ,

fit() : utilisé pour générer des paramètres de modèle d'apprentissage à partir de données d'entraînement

transform(): paramètres générés à partir de la fit()méthode, appliqués sur le modèle pour générer un ensemble de données transformé.

fit_transform(): combinaison de fit()et transform()api sur le même jeu de données

entrez la description de l'image ici

Consultez le chapitre 4 de ce livre et la réponse de stackexchange pour plus de clarté


54

Ces méthodes sont utilisées pour centrer / mettre à l'échelle les caractéristiques d'une donnée donnée. Cela aide essentiellement à normaliser les données dans une plage particulière

Pour cela, nous utilisons la méthode du Z-score.

Score Z

Nous faisons cela sur l'ensemble de données d'apprentissage.

1. Fit (): La méthode calcule les paramètres μ et σ et les enregistre en tant qu'objets internes.

2. Transform (): La méthode utilisant ces paramètres calculés applique la transformation à un ensemble de données particulier.

3. Fit_transform (): joint les méthodes fit () et transform () pour la transformation du jeu de données.

Extrait de code pour la mise à l'échelle / la normalisation des fonctionnalités (après train_test_split).

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

Nous appliquons la même transformation de paramètre (ensemble d'entraînement, les deux mêmes paramètres μ et σ (valeurs)) sur notre ensemble de test.


1
Merci pour cette explication. J'étais curieux de savoir si les valeurs «fit» se maintenaient et cela a aidé!
Adib

2
+1 pour l'exemple de code. Je ne savais pas si vous pouviez utiliser fit_transform sur un train, puis transformer l'ensemble de test, ou si vous aviez besoin d'un ajustement séparé sur le train
Vivek

2
fit_tranform (..) ne peut pas être utilisé pour X_test car le test test doit utiliser les μ et σ calculés à partir de l'ensemble de données X_train. fit_tranform (..) ne peut être utilisé que sur l'ensemble de données d'entraînement. Veuillez corriger ma compréhension.
daya

1
Oui vous avez raison. Seule la transformation (..) peut être utilisée sur le test car elle utilise les paramètres appris de X_train pour standardiser les données
X_test

7

Différence générique entre les méthodes:

  • fit (raw_documents [, y]): Apprenez un dictionnaire de vocabulaire de tous les jetons dans les documents bruts.
  • fit_transform (raw_documents [, y]): Apprenez le dictionnaire de vocabulaire et renvoyez la matrice terme-document. Cela équivaut à l'ajustement suivi de la transformation, mais implémenté plus efficacement.
  • transform (raw_documents): Transforme les documents en matrice de termes de document. Extraire les décomptes de jetons des documents texte bruts en utilisant le vocabulaire équipé de fit ou celui fourni au constructeur.

Fit_transform et transform retournent tous deux la même matrice Document-term.

La source


4

Voici la différence fondamentale entre .fit()& .fit_transform():

.en forme():

est utilisé dans l'apprentissage supervisé ayant deux objet / paramètre (x, y) pour ajuster le modèle et faire le modèle à exécuter, où nous savons que ce que nous allons prédire

.fit_transform ():

est utilisé dans l'apprentissage non supervisé ayant un objet / paramètre (x), où nous ne savons pas, ce que nous allons prédire.


Ce n'est pas très précis; fit () peut également être utilisé dans l'apprentissage non supervisé. Mais si vous essayez de simplifier à l'extrême juste par souci de brièveté, c'est un bon moyen de l'expliquer à un débutant.
Rajdeep Biswas le

3

En termes simples, fit_transform signifie faire un calcul puis effectuer une transformation (par exemple, calculer la moyenne des colonnes à partir de certaines données, puis remplacer les valeurs manquantes). Donc, pour l'ensemble d'entraînement, vous devez à la fois calculer et effectuer une transformation.

Mais pour l'ensemble de test, l'apprentissage automatique applique la prédiction en fonction de ce qui a été appris pendant l'ensemble d'entraînement et il n'a donc pas besoin de calculer, il effectue simplement la transformation.


1

Pourquoi et quand utiliser chacun d'eux:

Toutes les réponses sont assez bonnes, mais je mettrais l'accent sur POURQUOI et QUAND utiliser chaque méthode.

fit (), transform (), fit_transform ()

Habituellement, nous avons un problème d'apprentissage supervisé avec (X, y) comme ensemble de données, et nous le divisons en données d'entraînement et données de 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)

Imaginez que nous installions un tokenizer, si nous ajustons X, nous incluons des données de test dans le tokenizer, mais j'ai vu cette erreur plusieurs fois!

Le correct est de s'adapter UNIQUEMENT à X_train , car vous ne connaissez pas "vos futures données", vous ne pouvez donc pas utiliser les données X_test pour ajuster quoi que ce soit!

Ensuite, vous pouvez transformer vos données de test, mais séparément, c'est pourquoi il existe différentes méthodes.

Dernier conseil: X_train_transformed = model.fit_transform(X_train)équivaut à:, X_train_transformed = model.fit(X_train).transform(X_train)mais le premier est plus rapide.

Notez que ce que j'appelle "modèle" sera généralement un scaler, un transformateur tfidf, un autre type de vectoriseur, un tokenizer ...

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.