qual é a diferença entre 'transform' e 'fit_transform' no sklearn

Na caixa de ferramentas sklearn-python, existem duas funções transforme fit_transformsobre sklearn.decomposition.RandomizedPCA. A descrição de duas funções é a seguinte

Mas qual é a diferença entre eles?

Aqui, a diferença que você pode usar pca.transform apenas se você já tiver calculado o PCA em uma 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]])

se você quiser usar .transformvocê precisa ensinar a regra de transformação para o seu 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]: 

Em particular, a transformada PCA aplica a mudança de base obtida com a decomposição PCA da matriz X para a matriz Z.

Na API do estimador scikit-learn ,

fit() : usado para gerar parâmetros de modelo de aprendizagem a partir de dados de treinamento

transform(): parâmetros gerados a partir do fit()método, aplicados no modelo para gerar o conjunto de dados transformado.

fit_transform(): combinação de fit()e transform()api no mesmo conjunto de dados

Verifique o Capítulo 4 deste livro e responda pelo stackexchange para obter mais clareza

Esses métodos são usados ​​para centralizar / dimensionar recursos de um dado dado. Basicamente, ajuda a normalizar os dados dentro de um determinado intervalo

Para isso, usamos o método Z-score.

Fazemos isso no conjunto de dados de treinamento.

1. Fit (): o método calcula os parâmetros μ e σ e os salva como objetos internos.

2. Transform (): o método que usa esses parâmetros calculados aplica a transformação a um conjunto de dados específico.

3. Fit_transform (): junta o método fit () e transform () para a transformação do conjunto de dados.

Fragmento de código para escalonamento / padronização de recursos (após train_test_split).

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

Aplicamos a mesma transformação de parâmetro (conjunto de treinamento com os mesmos dois parâmetros μ e σ (valores)) em nosso conjunto de teste.

Diferença genérica entre os métodos:

• fit (raw_documents [, y]): aprende um dicionário de vocabulário de todos os tokens nos documentos brutos.
• fit_transform (raw_documents [, y]): aprende o dicionário de vocabulário e retorna a matriz do termo-documento. Isso é equivalente ao ajuste seguido pela transformação, mas implementado de forma mais eficiente.
• transform (raw_documents): Transforme documentos em uma matriz de termos de documentos. O token de extração conta a partir de documentos de texto bruto usando o vocabulário adequado ou aquele fornecido ao construtor.

Ambos fit_transform e transform retornam a mesma matriz Document-term.

Fonte

Aqui, a diferença básica entre .fit()& .fit_transform():

.em forma():

é utilizado na aprendizagem supervisionada tendo dois objetos / parâmetros (x, y) para ajustar o modelo e fazer o modelo rodar, onde sabemos que o que vamos predizer

.fit_transform ():

é usado na Aprendizagem Não Supervisionada tendo um objeto / parâmetro (x), onde não sabemos, o que iremos prever.

Em termos gerais, fit_transform significa fazer alguns cálculos e, em seguida, fazer a transformação (digamos, calcular a média das colunas de alguns dados e, em seguida, substituir os valores ausentes). Portanto, para o conjunto de treinamento, você precisa calcular e fazer a transformação.

Mas, para o conjunto de teste, o aprendizado de máquina aplica a previsão com base no que foi aprendido durante o conjunto de treinamento e, portanto, não precisa fazer cálculos, apenas realiza a transformação.

Por que e quando usar cada um:

Todas as respostas são muito boas, mas eu enfatizaria POR QUE e QUANDO usar cada método.

fit (), transform (), fit_transform ()

Normalmente, temos um problema de aprendizado supervisionado com (X, y) como conjunto de dados e o dividimos em dados de treinamento e dados de teste:

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 um tokenizer; se ajustarmos X, estaremos incluindo dados de teste no tokenizer, mas já vi esse erro muitas vezes!

O correto é ajustar SOMENTE com o X_train , porque você não conhece "seus dados futuros", então você não pode usar os dados do X_test para ajustar qualquer coisa!

Então você pode transformar seus dados de teste, mas separadamente, é por isso que existem métodos diferentes.

Dica final: X_train_transformed = model.fit_transform(X_train)equivale a:, X_train_transformed = model.fit(X_train).transform(X_train)mas a primeira é mais rápida.

Observe que o que eu chamo de "modelo" normalmente será um scaler, um transformador tfidf, outro tipo de vetorizador, um tokenizer ...