inheritance from _BasePCA

giorgiop · giorgiop · commit 3125d33a7f69 · 2015-09-30T09:32:15.000+02:00
diff --git a/sklearn/decomposition/pca.py b/sklearn/decomposition/pca.py
@@ -17,11 +17,11 @@
 from scipy import sparse
 from scipy.special import gammaln
 
-from ..base import BaseEstimator, TransformerMixin
+from .base import _BasePCA
 from ..utils import deprecated
 from ..utils import check_random_state
 from ..utils import check_array
-from ..utils.extmath import fast_dot, fast_logdet, randomized_svd, svd_flip
+from ..utils.extmath import fast_logdet, randomized_svd, svd_flip
 from ..utils.validation import check_is_fitted
 
 
@@ -99,7 +99,7 @@ def _infer_dimension_(spectrum, n_samples, n_features):
     return ll.argmax()
 
 
-class PCA(BaseEstimator, TransformerMixin):
+class PCA(_BasePCA):
     """Principal component analysis (PCA)
 
     Linear dimensionality reduction using Singular Value Decomposition of the
@@ -433,26 +433,6 @@ def _fit_truncated(self, X, svd_solver):
 
         return U, S, V
 
-    def get_covariance(self):
-        """Compute data covariance with the generative model.
-
-        ``cov = components_.T * S**2 * components_ + sigma2 * eye(n_features)``
-        where  S**2 contains the explained variances.
-
-        Returns
-        -------
-        cov : array, shape=(n_features, n_features)
-            Estimated covariance of data.
-        """
-        components_ = self.components_
-        exp_var = self.explained_variance_
-        if self.whiten:
-            components_ = components_ * np.sqrt(exp_var[:, np.newaxis])
-        exp_var_diff = np.maximum(exp_var - self.noise_variance_, 0.)
-        cov = np.dot(components_.T * exp_var_diff, components_)
-        cov.flat[::len(cov) + 1] += self.noise_variance_  # modify diag inplace
-        return cov
-
     def get_precision(self):
         """Compute data precision matrix with the generative model.
 
@@ -484,57 +464,6 @@ def get_precision(self):
         precision.flat[::len(precision) + 1] += 1. / self.noise_variance_
         return precision
 
-    def transform(self, X):
-        """Apply the dimensionality reduction on X.
-
-        X is projected on the first principal components previous extracted
-        from a training set.
-
-        Parameters
-        ----------
-        X : array-like, shape (n_samples, n_features)
-            New data, where n_samples is the number of samples
-            and n_features is the number of features.
-
-        Returns
-        -------
-        X_new : array-like, shape (n_samples, n_components)
-
-        """
-        check_is_fitted(self, 'mean_')
-
-        X = check_array(X)
-        if self.mean_ is not None:
-            X = X - self.mean_
-        X_transformed = fast_dot(X, self.components_.T)
-        if self.whiten:
-            X_transformed /= np.sqrt(self.explained_variance_)
-        return X_transformed
-
-    def inverse_transform(self, X):
-        """Transform data back to its original space, i.e.,
-        return an input X_original whose transform would be X
-
-        Parameters
-        ----------
-        X : array-like, shape (n_samples, n_components)
-            New data, where n_samples is the number of samples
-            and n_components is the number of components.
-
-        Returns
-        -------
-        X_original array-like, shape (n_samples, n_features)
-        """
-        check_is_fitted(self, 'mean_')
-
-        if self.whiten:
-            return fast_dot(
-                X,
-                np.sqrt(self.explained_variance_[:, np.newaxis]) *
-                self.components_) + self.mean_
-        else:
-            return fast_dot(X, self.components_) + self.mean_
-
     def score_samples(self, X):
         """Return the log-likelihood of each sample
 
