In the sklearn-python toolbox, there are two functions
sklearn.decomposition.RandomizedPCA. The description of two functions are as follows
But what is the difference between them ?
.transform method is meant for when you have already computed
PCA, i.e. if you have already called its
In : pc2 = RandomizedPCA(n_components=3) In : 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 : pc2.ftransform(X) pc2.fit pc2.fit_transform In : pc2.fit_transform(X) Out: 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]])
So you want to
RandomizedPCA and then
In : pca = RandomizedPCA(n_components=3) In : pca.fit(X) Out: RandomizedPCA(copy=True, iterated_power=3, n_components=3, random_state=None, whiten=False) In : pca.transform(z) Out: 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 :
In particular PCA
.transform applies the change of basis obtained through the PCA decomposition of the matrix
X to the matrix
In scikit-learn estimator api,
fit() : used for generating learning model parameters from training data
parameters generated from
fit() method,applied upon model to generate transformed data set.
transform() api on same data set
These methods are used to center/feature scale of a given data.
It basically helps to normalize the data within a particular range
For this, we use Z-score method.
We do this on the training set of data.
1.Fit(): Method calculates the parameters μ and σ and saves them as internal objects.
2.Transform(): Method using these calculated parameters apply the transformation to a particular dataset.
3.Fit_transform(): joins the fit() and transform() method for transformation of dataset.
Code snippet for Feature Scaling/Standardisation(after train_test_split).
from sklearn.preprocessing import StandardScaler sc = StandardScaler() sc.fit_transform(X_train) sc.transform(X_test)
We apply the same(training set same two parameters μ and σ (values)) parameter transformation on our testing set.
Generic difference between the methods:
Both fit_transform and transform returns the same, Document-term matrix.
Here the basic difference between
.fit()is used in the Supervised learning having two object/parameter (x,y)
to fit model and make model to run, where we know that what we
are going to predict
.fit_transform() is used in Unsupervised Learning having one object/parameter(x),
where we don’t know, what we are going to predict.
Why and When use each one of
Usually we have a supervised learning problem with (X, y) as our dataset, and we split it into training data and test data:
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 we are fitting a tokenizer, if we fit X we are including testing data into the tokenizer, but I have seen this error many times!
The correct is to fit ONLY with X_train, because you don’t know "your future data" so you cannot use X_test data for fitting anything!
Then you can transform your test data, but separately, that’s why there are different methods.
X_train_transformed = model.fit_transform(X_train) is equivalent to:
X_train_transformed = model.fit(X_train).transform(X_train), but the first one is faster.
Note that what I call "model" usually will be a scaler, a tfidf transformer, other kind of vectorizer, a tokenizer…
Remember: X represents the features and y represents the label of each sample.
X is a dataframe and y is a pandas Series object (usually)
In layman’s terms, fit_transform means to do some calculation and then do transformation (say calculating the means of columns from some data and then replacing the missing values). So for training set, you need to both calculate and do transformation.
But for testing set, Machine learning applies prediction based on what was learned during the training set and so it doesn’t need to calculate, it just performs the transformation.
When we have two Arrays with different elements we use ‘fit’ and transform separately, we fit ‘array 1’ base on its internal function such as in MinMaxScaler (internal function is to find mean and standard deviation). For example, if we fit ‘array 1’ based on its mean and transform array 2, then the mean of array 1 will be applied to array 2 which we transformed. In simple words, we transform one array on the basic internal functions of another array.
import numpy as np from sklearn.impute import SimpleImputer imp = SimpleImputer(missing_values=np.nan, strategy='mean') temperature = [32., np.nan, 28., np.nan, 32., np.nan, np.nan, 34., 40.] windspeed = [ 6., 9., np.nan, 7., np.nan, np.nan, np.nan, 8., 12.] n_arr_1 = np.array(temperature).reshape(3,3) print('temperature:n',n_arr_1) n_arr_2 = np.array(windspeed).reshape(3,3) print('windspeed:n',n_arr_2)
temperature: [[32. nan 28.] [nan 32. nan] [nan 34. 40.]] windspeed: [[ 6. 9. nan] [ 7. nan nan] [nan 8. 12.]]
transform seperately, transforming array 2 for fitted (based on mean) array 1:
Check the output below, observe the output based on previos two output you will see the differrence. Basically, on Array 1 it is taking mean of every column and fitting in array 2 according to its column where ever missing value is missed.
array([[ 6., 9., 34.], [ 7., 33., 34.], [32., 8., 12.]])
This is we doing when we want to transform one array based on another array. but when we have an single array and we want to transform it based on its own mean. In this condition, we use fit_transform together.
array([[ 6. , 9. , 12. ], [ 7. , 8.5, 12. ], [ 6.5, 8. , 12. ]])
(Above) Alternativily we doing:
array([[ 6. , 9. , 12. ], [ 7. , 8.5, 12. ], [ 6.5, 8. , 12. ]])
Why we fitting and transforming the the same array seperatly, it takes two line code, why don’t we use simple fit_transform which can fit and transform the same array in one line code. That’s what differrence is between fit and transform and fit_transform.
Below answer is applicable for any kind of sklearn related lib. Before knowing about
fit_transform, let’s see what the fit method is:
fit(X) – Fit the model with X by extracting the first principal components.
fit_transform(X) – Fit the model with X and apply the dimensionality reduction on X.
transform(x) – Apply dimensionality reduction on X.
You can see sklearn randomized PCA doc here for further details.