¿Cuál es la diferencia entre 'transform' y 'fit_transform' en sklearn

En la caja de herramientas sklearn-python, hay dos funciones transformy fit_transformabout sklearn.decomposition.RandomizedPCA. La descripción de dos funciones es la siguiente

Pero, ¿cuál es la diferencia entre ellos?

Aquí la diferencia que puede usar pca.transform solo si ya ha calculado PCA en una matriz

   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 quieres usar .transformnecesitas enseñar la regla de transformación a tu 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 particular, la transformada PCA aplica el cambio de base obtenido con la descomposición PCA de la matriz X a la matriz Z.

En la api del estimador de scikit-learn ,

fit() : utilizado para generar parámetros del modelo de aprendizaje a partir de datos de entrenamiento

transform(): parámetros generados a partir del fit()método, aplicados al modelo para generar un conjunto de datos transformado.

fit_transform(): combinación de fit()y transform()api en el mismo conjunto de datos

Consulte el Capítulo 4 de este libro y la respuesta de stackexchange para obtener más claridad

Estos métodos se utilizan para centrar / caracterizar la escala de un dato dado. Básicamente, ayuda a normalizar los datos dentro de un rango particular.

Para ello, utilizamos el método Z-score.

Hacemos esto en el conjunto de datos de entrenamiento.

1. Fit (): El método calcula los parámetros μ y σ y los guarda como objetos internos.

2. Transform (): el método que utiliza estos parámetros calculados aplica la transformación a un conjunto de datos en particular.

3. Fit_transform (): une el método fit () y transform () para la transformación del conjunto de datos.

Fragmento de código para escalamiento / estandarización de funciones (después de train_test_split).

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

Aplicamos la misma transformación de parámetros (conjunto de entrenamiento con los mismos dos parámetros μ y σ (valores)) en nuestro conjunto de pruebas.

Diferencia genérica entre los métodos:

• fit (raw_documents [, y]): aprenda un diccionario de vocabulario de todos los tokens en los documentos sin procesar.
• fit_transform (raw_documents [, y]): aprende el diccionario de vocabulario y devuelve la matriz término-documento. Esto es equivalente a ajustar seguido de la transformación, pero implementado de manera más eficiente.
• transform (raw_documents): Transforma documentos en una matriz de documentos y términos. Extraiga los recuentos de tokens de los documentos de texto sin formato utilizando el vocabulario ajustado con ajuste o el proporcionado al constructor.

Tanto fit_transform como transform devuelven la misma matriz de documentos y términos.

Fuente

Aquí la diferencia básica entre .fit()& .fit_transform():

.ajuste():

Se usa en el aprendizaje supervisado tener dos objetos / parámetros (x, y) para ajustar el modelo y hacer el modelo para ejecutar, donde sabemos que lo que vamos a predecir

.fit_transform ():

Se usa en el aprendizaje no supervisado que tiene un objeto / parámetro (x), donde no sabemos, qué vamos a predecir.

En términos simples, fit_transform significa hacer algunos cálculos y luego hacer una transformación (digamos, calcular las medias de las columnas a partir de algunos datos y luego reemplazar los valores faltantes). Entonces, para el conjunto de entrenamiento, debe calcular y hacer la transformación.

Pero para el conjunto de pruebas, el aprendizaje automático aplica la predicción basada en lo que se aprendió durante el conjunto de entrenamiento y, por lo tanto, no necesita calcular, solo realiza la transformación.

Por qué y cuándo usar cada uno:

Todas las respuestas son bastante buenas, pero haría énfasis en POR QUÉ y CUÁNDO usar cada método.

ajustar (), transformar (), ajustar_transformar ()

Por lo general, tenemos un problema de aprendizaje supervisado con (X, y) como conjunto de datos, y lo dividimos en datos de entrenamiento y datos de prueba:

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)

Imagine que estamos ajustando un tokenizador, si ajustamos X, estamos incluyendo datos de prueba en el tokenizador, ¡pero he visto este error muchas veces!

Lo correcto es encajar ÚNICAMENTE con X_train , porque no conoce "sus datos futuros", por lo que no puede usar los datos de X_test para ajustar nada.

Luego, puede transformar sus datos de prueba, pero por separado, por eso existen diferentes métodos.

Consejo final: X_train_transformed = model.fit_transform(X_train)equivale a:, X_train_transformed = model.fit(X_train).transform(X_train)pero el primero es más rápido.

Tenga en cuenta que lo que llamo "modelo" normalmente será un escalador, un transformador tfidf, otro tipo de vectorizador, un tokenizador ...