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

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

Mais quelle est la différence entre eux?

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.

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

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

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.

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.

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

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.

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.

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 ...