scikit-learn · amueller · Jul 2, 2019 · Jul 2, 2019 · Jul 2, 2019 · Jul 2, 2019
diff --git a/sklearn/base.py b/sklearn/base.py
@@ -6,6 +6,7 @@
 import copy
 import warnings
 from collections import defaultdict
+import numbers
 import platform
 import inspect
 import re
@@ -555,6 +556,33 @@ def fit_transform(self, X, y=None, **fit_params):
             # fit method of arity 2 (supervised transformation)
             return self.fit(X, y, **fit_params).transform(X)
 
+    @property
+    def n_features_out_(self):
+        return self._n_features_out
+
+    @n_features_out_.setter
+    def n_features_out_(self, val):
+        self._n_features_out = val
+
+
+class ComponentsMixin:
+    @property
+    def n_features_out_(self):
+        if hasattr(self, 'n_components_'):
+            # n_components could be auto or None
+            # this is more likely to be an int
+            n_features = self.n_components_
+        elif hasattr(self, 'components_'):
+            n_features = self.components_.shape[0]
+        elif (hasattr(self, 'n_components')
+              and isinstance(self.n_components, numbers.Integral)):
+            n_features = self.n_components
+        else:
+            raise AttributeError(
+                "{} has no attribute 'n_features_out_'".format(
+                    type(self).__name__))
+        return n_features
+
 
 class DensityMixin:
     """Mixin class for all density estimators in scikit-learn."""

diff --git a/sklearn/cluster/birch.py b/sklearn/cluster/birch.py
@@ -493,6 +493,8 @@ def _fit(self, X):
         self.subcluster_centers_ = centroids
 
         self._global_clustering(X)
+        self.n_features_out_ = self.n_clusters
+
         return self
 
     def _get_leaves(self):

diff --git a/sklearn/cluster/hierarchical.py b/sklearn/cluster/hierarchical.py
@@ -1036,6 +1036,7 @@ def fit(self, X, y=None, **params):
         """
         X = check_array(X, accept_sparse=['csr', 'csc', 'coo'],
                         ensure_min_features=2, estimator=self)
+        self.n_features_out_ = self.n_clusters
         return AgglomerativeClustering.fit(self, X.T, **params)
 
     @property

diff --git a/sklearn/cluster/k_means_.py b/sklearn/cluster/k_means_.py
@@ -839,6 +839,7 @@ def fit(self, X, y=None, sample_weight=None):
         """
         random_state = check_random_state(self.random_state)
 
+        self.n_features_out_ = self.n_clusters
         n_init = self.n_init
         if n_init <= 0:
             raise ValueError("Invalid number of initializations."
@@ -1626,6 +1627,7 @@ def fit(self, X, y=None, sample_weight=None):
         if self.compute_labels:
             self.labels_, self.inertia_ = \
                     self._labels_inertia_minibatch(X, sample_weight)
+        self.n_features_out_ = self.n_clusters
 
         return self
 
@@ -1725,6 +1727,7 @@ def partial_fit(self, X, y=None, sample_weight=None):
         if self.compute_labels:
             self.labels_, self.inertia_ = _labels_inertia(
                 X, sample_weight, x_squared_norms, self.cluster_centers_)
+        self.n_features_out_ = self.n_clusters
 
         return self
 

diff --git a/sklearn/compose/_column_transformer.py b/sklearn/compose/_column_transformer.py
@@ -360,6 +360,18 @@ def get_feature_names(self):
                                   trans.get_feature_names()])
         return feature_names
 
+    @property
+    def n_features_out_(self):
+        n_features_out = 0
+        for name, trans, column, _ in self._iter(fitted=True):
+            if trans == 'drop':
+                continue
+            elif trans == 'passthrough':
+                n_features_out += len(column)
+            else:
+                n_features_out += trans.n_features_out_
+        return n_features_out
+
     def _update_fitted_transformers(self, transformers):
         # transformers are fitted; excludes 'drop' cases
         fitted_transformers = iter(transformers)

diff --git a/sklearn/compose/tests/test_column_transformer.py b/sklearn/compose/tests/test_column_transformer.py
@@ -662,10 +662,12 @@ def test_column_transformer_get_feature_names():
         [('col' + str(i), DictVectorizer(), i) for i in range(2)])
     ct.fit(X)
     assert ct.get_feature_names() == ['col0__a', 'col0__b', 'col1__c']
+    assert ct.n_features_out_ == len(ct.get_feature_names())
 
     # passthrough transformers not supported
     ct = ColumnTransformer([('trans', 'passthrough', [0, 1])])
     ct.fit(X)
+    assert ct.n_features_out_ == 2
     assert_raise_message(
         NotImplementedError, 'get_feature_names is not yet supported',
         ct.get_feature_names)
@@ -682,6 +684,7 @@ def test_column_transformer_get_feature_names():
         [('col0', DictVectorizer(), 0), ('col1', 'drop', 1)])
     ct.fit(X)
     assert ct.get_feature_names() == ['col0__a', 'col0__b']
+    assert ct.n_features_out_ == len(ct.get_feature_names())
 
 
 def test_column_transformer_special_strings():

diff --git a/sklearn/decomposition/base.py b/sklearn/decomposition/base.py
@@ -11,13 +11,14 @@
 import numpy as np
 from scipy import linalg
 
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, TransformerMixin, ComponentsMixin
 from ..utils import check_array
 from ..utils.validation import check_is_fitted
 from abc import ABCMeta, abstractmethod
 
 
-class _BasePCA(TransformerMixin, BaseEstimator, metaclass=ABCMeta):
+class _BasePCA(ComponentsMixin, TransformerMixin,
+               BaseEstimator, metaclass=ABCMeta):
     """Base class for PCA methods.
 
     Warning: This class should not be used directly.
@@ -154,6 +155,6 @@ def inverse_transform(self, X):
         """
         if self.whiten:
             return np.dot(X, np.sqrt(self.explained_variance_[:, np.newaxis]) *
-                            self.components_) + self.mean_
+                          self.components_) + self.mean_
         else:
             return np.dot(X, self.components_) + self.mean_
diff --git a/sklearn/decomposition/dict_learning.py b/sklearn/decomposition/dict_learning.py
@@ -13,7 +13,7 @@
 from scipy import linalg
 from joblib import Parallel, delayed, effective_n_jobs
 
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, TransformerMixin, ComponentsMixin
 from ..utils import (check_array, check_random_state, gen_even_slices,
                      gen_batches)
 from ..utils.extmath import randomized_svd, row_norms
@@ -875,7 +875,7 @@ def dict_learning_online(X, n_components=2, alpha=1, n_iter=100,
         return dictionary.T
 
 
-class SparseCodingMixin(TransformerMixin):
+class SparseCodingMixin(ComponentsMixin, TransformerMixin):
     """Sparse coding mixin"""
 
     def _set_sparse_coding_params(self, n_components,

diff --git a/sklearn/decomposition/factor_analysis.py b/sklearn/decomposition/factor_analysis.py
@@ -25,14 +25,14 @@
 from scipy import linalg
 
 
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, ComponentsMixin, TransformerMixin
 from ..utils import check_array, check_random_state
 from ..utils.extmath import fast_logdet, randomized_svd, squared_norm
 from ..utils.validation import check_is_fitted
 from ..exceptions import ConvergenceWarning
 
 
-class FactorAnalysis(TransformerMixin, BaseEstimator):
+class FactorAnalysis(ComponentsMixin, TransformerMixin, BaseEstimator):
     """Factor Analysis (FA)
 
     A simple linear generative model with Gaussian latent variables.

diff --git a/sklearn/decomposition/fastica_.py b/sklearn/decomposition/fastica_.py
@@ -14,7 +14,7 @@
 import numpy as np
 from scipy import linalg
 
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, TransformerMixin, ComponentsMixin
 from ..exceptions import ConvergenceWarning
 
 from ..utils import check_array, as_float_array, check_random_state
@@ -380,7 +380,7 @@ def g(x, fun_args):
                 return None, W, S
 
 
-class FastICA(TransformerMixin, BaseEstimator):
+class FastICA(ComponentsMixin, TransformerMixin, BaseEstimator):
     """FastICA: a fast algorithm for Independent Component Analysis.
 
     Read more in the :ref:`User Guide <ICA>`.

diff --git a/sklearn/decomposition/kernel_pca.py b/sklearn/decomposition/kernel_pca.py
@@ -11,12 +11,12 @@
 from ..utils.extmath import svd_flip
 from ..utils.validation import check_is_fitted, check_array
 from ..exceptions import NotFittedError
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, TransformerMixin, ComponentsMixin
 from ..preprocessing import KernelCenterer
 from ..metrics.pairwise import pairwise_kernels
 
 
-class KernelPCA(TransformerMixin, BaseEstimator):
+class KernelPCA(ComponentsMixin, TransformerMixin, BaseEstimator):
     """Kernel Principal component analysis (KPCA)
 
     Non-linear dimensionality reduction through the use of kernels (see

diff --git a/sklearn/decomposition/nmf.py b/sklearn/decomposition/nmf.py
@@ -14,7 +14,7 @@
 import numpy as np
 import scipy.sparse as sp
 
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, TransformerMixin, ComponentsMixin
 from ..utils import check_random_state, check_array
 from ..utils.extmath import randomized_svd, safe_sparse_dot, squared_norm
 from ..utils.validation import check_is_fitted, check_non_negative
@@ -1070,7 +1070,7 @@ def non_negative_factorization(X, W=None, H=None, n_components=None,
     return W, H, n_iter
 
 
-class NMF(TransformerMixin, BaseEstimator):
+class NMF(ComponentsMixin, TransformerMixin, BaseEstimator):
     r"""Non-Negative Matrix Factorization (NMF)
 
     Find two non-negative matrices (W, H) whose product approximates the non-

diff --git a/sklearn/decomposition/online_lda.py b/sklearn/decomposition/online_lda.py
@@ -16,7 +16,7 @@
 from scipy.special import gammaln
 from joblib import Parallel, delayed, effective_n_jobs
 
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, TransformerMixin, ComponentsMixin
 from ..utils import (check_random_state, check_array,
                      gen_batches, gen_even_slices)
 from ..utils.fixes import logsumexp
@@ -132,7 +132,8 @@ def _update_doc_distribution(X, exp_topic_word_distr, doc_topic_prior,
     return (doc_topic_distr, suff_stats)
 
 
-class LatentDirichletAllocation(TransformerMixin, BaseEstimator):
+class LatentDirichletAllocation(ComponentsMixin, TransformerMixin,
+                                BaseEstimator):
     """Latent Dirichlet Allocation with online variational Bayes algorithm
 
     .. versionadded:: 0.17

diff --git a/sklearn/decomposition/sparse_pca.py b/sklearn/decomposition/sparse_pca.py
@@ -9,7 +9,7 @@
 from ..utils import check_random_state, check_array
 from ..utils.validation import check_is_fitted
 from ..linear_model import ridge_regression
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, TransformerMixin, ComponentsMixin
 from .dict_learning import dict_learning, dict_learning_online
 
 
@@ -29,7 +29,7 @@ def _check_normalize_components(normalize_components, estimator_name):
             )
 
 
-class SparsePCA(TransformerMixin, BaseEstimator):
+class SparsePCA(ComponentsMixin, TransformerMixin, BaseEstimator):
     """Sparse Principal Components Analysis (SparsePCA)
 
     Finds the set of sparse components that can optimally reconstruct

diff --git a/sklearn/decomposition/truncated_svd.py b/sklearn/decomposition/truncated_svd.py
@@ -10,15 +10,15 @@
 import scipy.sparse as sp
 from scipy.sparse.linalg import svds
 
-from ..base import BaseEstimator, TransformerMixin
+from ..base import BaseEstimator, TransformerMixin, ComponentsMixin
 from ..utils import check_array, check_random_state
 from ..utils.extmath import randomized_svd, safe_sparse_dot, svd_flip
 from ..utils.sparsefuncs import mean_variance_axis
 
 __all__ = ["TruncatedSVD"]
 
 
-class TruncatedSVD(TransformerMixin, BaseEstimator):
+class TruncatedSVD(ComponentsMixin, TransformerMixin, BaseEstimator):
     """Dimensionality reduction using truncated SVD (aka LSA).
 
     This transformer performs linear dimensionality reduction by means of

diff --git a/sklearn/discriminant_analysis.py b/sklearn/discriminant_analysis.py
@@ -552,6 +552,11 @@ def predict_log_proba(self, X):
         """
         return np.log(self.predict_proba(X))
 
+    @property
+    def n_features_out_(self):
+        n_components = self.n_components or np.inf
+        return min(self._max_components, n_components)
+
 
 class QuadraticDiscriminantAnalysis(ClassifierMixin, BaseEstimator):
     """Quadratic Discriminant Analysis

diff --git a/sklearn/ensemble/_stacking.py b/sklearn/ensemble/_stacking.py
@@ -458,7 +458,12 @@ def fit(self, X, y, sample_weight=None):
         check_classification_targets(y)
         self._le = LabelEncoder().fit(y)
         self.classes_ = self._le.classes_
-        return super().fit(X, self._le.transform(y), sample_weight)
+        super().fit(X, self._le.transform(y), sample_weight)
+        if len(self.classes_) == 2:
+            self.n_features_out_ = len(self.estimators_)
+        else:
+            self.n_features_out_ = len(self.estimators_) * len(self.classes_)
+        return self
 
     @if_delegate_has_method(delegate='final_estimator_')
     def predict(self, X, **predict_params):
@@ -691,7 +696,9 @@ def fit(self, X, y, sample_weight=None):
         self : object
         """
         y = column_or_1d(y, warn=True)
-        return super().fit(X, y, sample_weight)
+        super().fit(X, y, sample_weight)
+        self.n_features_out_ = len(self.estimators_)
+        return self
 
     def transform(self, X):
         """Return the predictions for X for each estimator.

diff --git a/sklearn/ensemble/forest.py b/sklearn/ensemble/forest.py
@@ -2196,7 +2196,9 @@ def fit_transform(self, X, y=None, sample_weight=None):
         super().fit(X, y, sample_weight=sample_weight)
 
         self.one_hot_encoder_ = OneHotEncoder(sparse=self.sparse_output)
-        return self.one_hot_encoder_.fit_transform(self.apply(X))
+        res = self.one_hot_encoder_.fit_transform(self.apply(X))
+        self.n_features_out_ = res.shape[1]
+        return res
 
     def transform(self, X):
         """Transform dataset.

diff --git a/sklearn/ensemble/voting.py b/sklearn/ensemble/voting.py
@@ -269,7 +269,9 @@ def fit(self, X, y, sample_weight=None):
         self.le_ = LabelEncoder().fit(y)
         self.classes_ = self.le_.classes_
         transformed_y = self.le_.transform(y)
-
+        self.n_features_out_ = len(self.estimators)
+        if self.voting == 'soft':
+            self.n_features_out_ *= len(self.classes_)
         return super().fit(X, transformed_y, sample_weight)
 
     def predict(self, X):
@@ -449,6 +451,7 @@ def fit(self, X, y, sample_weight=None):
         self : object
         """
         y = column_or_1d(y, warn=True)
+        self.n_features_out_ = len(self.estimators)
         return super().fit(X, y, sample_weight)
 
     def predict(self, X):

diff --git a/sklearn/feature_extraction/dict_vectorizer.py b/sklearn/feature_extraction/dict_vectorizer.py
@@ -128,6 +128,7 @@ def fit(self, X, y=None):
             vocab = {f: i for i, f in enumerate(feature_names)}
 
         self.feature_names_ = feature_names
+        self.n_features_out_ = len(self.feature_names_)
         self.vocabulary_ = vocab
 
         return self
@@ -205,6 +206,7 @@ def _transform(self, X, fitting):
         if fitting:
             self.feature_names_ = feature_names
             self.vocabulary_ = vocab
+            self.n_features_out_ = len(self.feature_names_)
 
         return result_matrix
 

diff --git a/sklearn/feature_selection/base.py b/sklearn/feature_selection/base.py
@@ -46,6 +46,10 @@ def get_support(self, indices=False):
         mask = self._get_support_mask()
         return mask if not indices else np.where(mask)[0]
 
+    @property
+    def n_features_out_(self):
+        return self.get_support().sum()
+
     @abstractmethod
     def _get_support_mask(self):
         """