MNT n_features_in_ consistency in decomposition (scikit-learn#18557)

Co-authored-by: Nicolas Hug <[email protected]>

Author: ogrisel

sklearn/decomposition/_base.py

@@ -12,7 +12,6 @@
 from scipy import linalg
 
 from ..base import BaseEstimator, TransformerMixin
-from ..utils import check_array
 from ..utils.validation import check_is_fitted
 from abc import ABCMeta, abstractmethod
 
@@ -124,7 +123,7 @@ def transform(self, X):
         """
         check_is_fitted(self)
 
-        X = check_array(X)
+        X = self._validate_data(X, dtype=[np.float64, np.float32], reset=False)
         if self.mean_ is not None:
             X = X - self.mean_
         X_transformed = np.dot(X, self.components_.T)

sklearn/decomposition/_dict_learning.py

@@ -907,7 +907,7 @@ def __init__(self, transform_algorithm, transform_n_nonzero_coefs,
     def _transform(self, X, dictionary):
         """Private method allowing to accomodate both DictionaryLearning and
         SparseCoder."""
-        X = check_array(X)
+        X = self._validate_data(X, reset=False)
 
         code = sparse_encode(
             X, dictionary, algorithm=self.transform_algorithm,
@@ -1622,14 +1622,14 @@ def partial_fit(self, X, y=None, iter_offset=None):
         """
         if not hasattr(self, 'random_state_'):
             self.random_state_ = check_random_state(self.random_state)
-        X = check_array(X)
         if hasattr(self, 'components_'):
             dict_init = self.components_
         else:
             dict_init = self.dict_init
         inner_stats = getattr(self, 'inner_stats_', None)
         if iter_offset is None:
             iter_offset = getattr(self, 'iter_offset_', 0)
+        X = self._validate_data(X, reset=(iter_offset == 0))
         U, (A, B) = dict_learning_online(
             X, self.n_components, alpha=self.alpha,
             n_iter=1, method=self.fit_algorithm,

sklearn/decomposition/_factor_analysis.py

@@ -26,7 +26,7 @@
 
 
 from ..base import BaseEstimator, TransformerMixin
-from ..utils import check_array, check_random_state
+from ..utils import check_random_state
 from ..utils.extmath import fast_logdet, randomized_svd, squared_norm
 from ..utils.validation import check_is_fitted, _deprecate_positional_args
 from ..exceptions import ConvergenceWarning
@@ -279,7 +279,7 @@ def transform(self, X):
         """
         check_is_fitted(self)
 
-        X = check_array(X)
+        X = self._validate_data(X, reset=False)
         Ih = np.eye(len(self.components_))
 
         X_transformed = X - self.mean_
@@ -350,7 +350,7 @@ def score_samples(self, X):
             Log-likelihood of each sample under the current model
         """
         check_is_fitted(self)
-
+        X = self._validate_data(X, reset=False)
         Xr = X - self.mean_
         precision = self.get_precision()
         n_features = X.shape[1]

sklearn/decomposition/_fastica.py

@@ -584,15 +584,16 @@ def transform(self, X, copy=True):
             and n_features is the number of features.
 
         copy : bool, default=True
-            If False, data passed to fit are overwritten. Defaults to True.
+            If False, data passed to fit can be overwritten. Defaults to True.
 
         Returns
         -------
         X_new : ndarray of shape (n_samples, n_components)
         """
         check_is_fitted(self)
 
-        X = check_array(X, copy=copy, dtype=FLOAT_DTYPES)
+        X = self._validate_data(X, copy=(copy and self.whiten),
+                                dtype=FLOAT_DTYPES, reset=False)
         if self.whiten:
             X -= self.mean_
 

sklearn/decomposition/_incremental_pca.py

@@ -8,7 +8,7 @@
 from scipy import linalg, sparse
 
 from ._base import _BasePCA
-from ..utils import check_array, gen_batches
+from ..utils import gen_batches
 from ..utils.extmath import svd_flip, _incremental_mean_and_var
 from ..utils.validation import _deprecate_positional_args
 
@@ -234,15 +234,18 @@ def partial_fit(self, X, y=None, check_input=True):
         self : object
             Returns the instance itself.
         """
+        first_pass = not hasattr(self, "components_")
         if check_input:
             if sparse.issparse(X):
                 raise TypeError(
                     "IncrementalPCA.partial_fit does not support "
                     "sparse input. Either convert data to dense "
                     "or use IncrementalPCA.fit to do so in batches.")
-            X = check_array(X, copy=self.copy, dtype=[np.float64, np.float32])
+            X = self._validate_data(
+                X, copy=self.copy, dtype=[np.float64, np.float32],
+                reset=first_pass)
         n_samples, n_features = X.shape
-        if not hasattr(self, 'components_'):
+        if first_pass:
             self.components_ = None
 
         if self.n_components is None:

sklearn/decomposition/_kernel_pca.py

@@ -331,6 +331,7 @@ def transform(self, X):
         X_new : ndarray of shape (n_samples, n_components)
         """
         check_is_fitted(self)
+        X = self._validate_data(X, accept_sparse='csr', reset=False)
 
         # Compute centered gram matrix between X and training data X_fit_
         K = self._centerer.transform(self._get_kernel(X, self.X_fit_))

sklearn/decomposition/_lda.py

@@ -509,17 +509,9 @@ def partial_fit(self, X, y=None):
         """
         self._check_params()
         first_time = not hasattr(self, 'components_')
-
-        # In theory reset should be equal to `first_time`, but there are tests
-        # checking the input number of feature and they expect a specific
-        # string, which is not the same one raised by check_n_features. So we
-        # don't check n_features_in_ here for now (it's done with adhoc code in
-        # the estimator anyway).
-        # TODO: set reset=first_time when addressing reset in
-        # predict/transform/etc.
-        reset_n_features = True
-        X = self._check_non_neg_array(X, reset_n_features,
-                                      "LatentDirichletAllocation.partial_fit")
+        X = self._check_non_neg_array(
+            X, reset_n_features=first_time,
+            whom="LatentDirichletAllocation.partial_fit")
         n_samples, n_features = X.shape
         batch_size = self.batch_size
 
@@ -663,6 +655,10 @@ def transform(self, X):
         doc_topic_distr : ndarray of shape (n_samples, n_components)
             Document topic distribution for X.
         """
+        check_is_fitted(self)
+        X = self._check_non_neg_array(
+            X, reset_n_features=False,
+            whom="LatentDirichletAllocation.transform")
         doc_topic_distr = self._unnormalized_transform(X)
         doc_topic_distr /= doc_topic_distr.sum(axis=1)[:, np.newaxis]
         return doc_topic_distr
@@ -758,7 +754,8 @@ def score(self, X, y=None):
         score : float
             Use approximate bound as score.
         """
-        X = self._check_non_neg_array(X, reset_n_features=True,
+        check_is_fitted(self)
+        X = self._check_non_neg_array(X, reset_n_features=False,
                                       whom="LatentDirichletAllocation.score")
 
         doc_topic_distr = self._unnormalized_transform(X)

sklearn/decomposition/_nmf.py

@@ -1299,6 +1299,8 @@ def fit_transform(self, X, y=None, W=None, H=None):
         X = self._validate_data(X, accept_sparse=('csr', 'csc'),
                                 dtype=[np.float64, np.float32])
 
+        # XXX: input data validation is performed again in
+        # non_negative_factorization.
         W, H, n_iter_ = non_negative_factorization(
             X=X, W=W, H=H, n_components=self.n_components, init=self.init,
             update_H=True, solver=self.solver, beta_loss=self.beta_loss,
@@ -1347,7 +1349,12 @@ def transform(self, X):
             Transformed data.
         """
         check_is_fitted(self)
+        X = self._validate_data(X, accept_sparse=('csr', 'csc'),
+                                dtype=[np.float64, np.float32],
+                                reset=False)
 
+        # XXX: input data validation is performed again in
+        # non_negative_factorization.
         W, _, n_iter_ = non_negative_factorization(
             X=X, W=None, H=self.components_, n_components=self.n_components_,
             init=self.init, update_H=False, solver=self.solver,

sklearn/decomposition/_pca.py

@@ -21,7 +21,6 @@
 
 from ._base import _BasePCA
 from ..utils import check_random_state
-from ..utils import check_array
 from ..utils.extmath import fast_logdet, randomized_svd, svd_flip
 from ..utils.extmath import stable_cumsum
 from ..utils.validation import check_is_fitted
@@ -583,7 +582,7 @@ def score_samples(self, X):
         """
         check_is_fitted(self)
 
-        X = check_array(X)
+        X = self._validate_data(X, dtype=[np.float64, np.float32], reset=False)
         Xr = X - self.mean_
         n_features = X.shape[1]
         precision = self.get_precision()

sklearn/decomposition/_sparse_pca.py

@@ -4,7 +4,7 @@
 
 import numpy as np
 
-from ..utils import check_random_state, check_array
+from ..utils import check_random_state
 from ..utils.validation import check_is_fitted
 from ..utils.validation import _deprecate_positional_args
 from ..linear_model import ridge_regression
@@ -197,7 +197,7 @@ def transform(self, X):
         """
         check_is_fitted(self)
 
-        X = check_array(X)
+        X = self._validate_data(X, reset=False)
         X = X - self.mean_
 
         U = ridge_regression(self.components_.T, X.T, self.ridge_alpha,