scikit-learn · ogrisel · Dec 2, 2020 · Nov 9, 2020 · Nov 9, 2020 · Nov 11, 2020
diff --git a/doc/developers/develop.rst b/doc/developers/develop.rst
@@ -511,12 +511,12 @@ Scikit-learn introduced estimator tags in version 0.21. These are annotations
 of estimators that allow programmatic inspection of their capabilities, such as
 sparse matrix support, supported output types and supported methods. The
 estimator tags are a dictionary returned by the method ``_get_tags()``. These
-tags are used by the common tests and the
-:func:`sklearn.utils.estimator_checks.check_estimator` function to decide what
-tests to run and what input data is appropriate. Tags can depend on estimator
-parameters or even system architecture and can in general only be determined at
-runtime. The default values for the estimator tags are defined in the
-``BaseEstimator`` class.
+tags are used in the common checks run by the
+:func:`~sklearn.utils.estimator_checks.check_estimator` function and the
+:func:`~sklearn.utils.estimator_checks.parametrize_with_checks` decorator.
+Tags determine which checks to run and what input data is appropriate. Tags
+can depend on estimator parameters or even system architecture and can in
+general only be determined at runtime.
 
 The current set of estimator tags are:
 
@@ -618,16 +618,25 @@ X_types (default=['2darray'])
     ``'categorical'`` data. For now, the test for sparse data do not make use
     of the ``'sparse'`` tag.
 
-
-To override the tags of a child class, one must define the `_more_tags()`
-method and return a dict with the desired tags, e.g::
+It is unlikely that the default values for each tag will suit the needs of your
+specific estimator. Additional tags can be created or default tags can be
+overridden by defining a `_more_tags()` method which returns a dict with the
+desired overridden tags or new tags. For example::
 
     class MyMultiOutputEstimator(BaseEstimator):
 
         def _more_tags(self):
             return {'multioutput_only': True,
                     'non_deterministic': True}
 
+Any tag that is not in `_more_tags()` will just fall-back to the default values
+documented above.
+
+Even if it is not recommended, it is possible to override the method
+`_get_tags()`. Note however that **all tags must be present in the dict**. If
+any of the keys documented above is not present in the output of `_get_tags()`,
+an error will occur.
+
 In addition to the tags, estimators also need to declare any non-optional
 parameters to ``__init__`` in the ``_required_parameters`` class attribute,
 which is a list or tuple.  If ``_required_parameters`` is only

diff --git a/sklearn/base.py b/sklearn/base.py
@@ -15,32 +15,15 @@
 from . import __version__
 from ._config import get_config
 from .utils import _IS_32BIT
+from .utils._tags import (
+    _DEFAULT_TAGS,
+    _safe_tags,
+)
 from .utils.validation import check_X_y
 from .utils.validation import check_array
 from .utils._estimator_html_repr import estimator_html_repr
 from .utils.validation import _deprecate_positional_args
 
-_DEFAULT_TAGS = {
-    'non_deterministic': False,
-    'requires_positive_X': False,
-    'requires_positive_y': False,
-    'X_types': ['2darray'],
-    'poor_score': False,
-    'no_validation': False,
-    'multioutput': False,
-    "allow_nan": False,
-    'stateless': False,
-    'multilabel': False,
-    '_skip_test': False,
-    '_xfail_checks': False,
-    'multioutput_only': False,
-    'binary_only': False,
-    'requires_fit': True,
-    'preserves_dtype': [np.float64],
-    'requires_y': False,
-    'pairwise': False,
-    }
-
 
 @_deprecate_positional_args
 def clone(estimator, *, safe=True):
@@ -858,11 +841,7 @@ def _is_pairwise(estimator):
         warnings.filterwarnings('ignore', category=FutureWarning)
         has_pairwise_attribute = hasattr(estimator, '_pairwise')
         pairwise_attribute = getattr(estimator, '_pairwise', False)
-
-    if hasattr(estimator, '_get_tags') and callable(estimator._get_tags):
-        pairwise_tag = estimator._get_tags().get('pairwise', False)
-    else:
-        pairwise_tag = False
+    pairwise_tag = _safe_tags(estimator, key="pairwise")
 
     if has_pairwise_attribute:
         if pairwise_attribute != pairwise_tag:

diff --git a/sklearn/feature_selection/_base.py b/sklearn/feature_selection/_base.py
@@ -12,9 +12,12 @@
 from scipy.sparse import issparse, csc_matrix
 
 from ..base import TransformerMixin
-from ..utils import check_array
-from ..utils import safe_mask
-from ..utils import safe_sqr
+from ..utils import (
+    check_array,
+    safe_mask,
+    safe_sqr,
+)
+from ..utils._tags import _safe_tags
 
 
 class SelectorMixin(TransformerMixin, metaclass=ABCMeta):
@@ -74,9 +77,14 @@ def transform(self, X):
         X_r : array of shape [n_samples, n_selected_features]
             The input samples with only the selected features.
         """
-        tags = self._get_tags()
-        X = check_array(X, dtype=None, accept_sparse='csr',
-                        force_all_finite=not tags.get('allow_nan', True))
+        # note: we use _safe_tags instead of _get_tags because this is a
+        # public Mixin.
+        X = check_array(
+            X,
+            dtype=None,
+            accept_sparse="csr",
+            force_all_finite=not _safe_tags(self, key="allow_nan"),
+        )
         mask = self.get_support()
         if not mask.any():
             warn("No features were selected: either the data is"

diff --git a/sklearn/feature_selection/_from_model.py b/sklearn/feature_selection/_from_model.py
@@ -7,6 +7,7 @@
 from ._base import SelectorMixin
 from ._base import _get_feature_importances
 from ..base import BaseEstimator, clone, MetaEstimatorMixin
+from ..utils._tags import _safe_tags
 from ..utils.validation import check_is_fitted
 
 from ..exceptions import NotFittedError
@@ -283,5 +284,6 @@ def n_features_in_(self):
         return self.estimator_.n_features_in_
 
     def _more_tags(self):
-        estimator_tags = self.estimator._get_tags()
-        return {'allow_nan': estimator_tags.get('allow_nan', True)}
+        return {
+            'allow_nan': _safe_tags(self.estimator, key="allow_nan")
+        }
diff --git a/sklearn/feature_selection/_rfe.py b/sklearn/feature_selection/_rfe.py
@@ -10,8 +10,10 @@
 import numbers
 from joblib import Parallel, effective_n_jobs
 
+
 from ..utils.metaestimators import if_delegate_has_method
 from ..utils.metaestimators import _safe_split
+from ..utils._tags import _safe_tags
 from ..utils.validation import check_is_fitted
 from ..utils.validation import _deprecate_positional_args
 from ..utils.fixes import delayed
@@ -191,7 +193,7 @@ def _fit(self, X, y, step_score=None):
         X, y = self._validate_data(
             X, y, accept_sparse="csc",
             ensure_min_features=2,
-            force_all_finite=not tags.get('allow_nan', True),
+            force_all_finite=not tags.get("allow_nan", True),
             multi_output=True
         )
         error_msg = ("n_features_to_select must be either None, a "
@@ -371,11 +373,11 @@ def predict_log_proba(self, X):
         return self.estimator_.predict_log_proba(self.transform(X))
 
     def _more_tags(self):
-        estimator_tags = self.estimator._get_tags()
-        return {'poor_score': True,
-                'allow_nan': estimator_tags.get('allow_nan', True),
-                'requires_y': True,
-                }
+        return {
+            'poor_score': True,
+            'allow_nan': _safe_tags(self.estimator, key='allow_nan'),
+            'requires_y': True,
+        }
 
 
 class RFECV(RFE):

diff --git a/sklearn/feature_selection/_sequential.py b/sklearn/feature_selection/_sequential.py
@@ -7,6 +7,7 @@
 
 from ._base import SelectorMixin
 from ..base import BaseEstimator, MetaEstimatorMixin, clone
+from ..utils._tags import _safe_tags
 from ..utils.validation import check_is_fitted
 from ..model_selection import cross_val_score
 
@@ -128,12 +129,11 @@ def fit(self, X, y):
         -------
         self : object
         """
-
         tags = self._get_tags()
         X, y = self._validate_data(
             X, y, accept_sparse="csc",
             ensure_min_features=2,
-            force_all_finite=not tags.get('allow_nan', True),
+            force_all_finite=not tags.get("allow_nan", True),
             multi_output=True
         )
         n_features = X.shape[1]
@@ -207,8 +207,7 @@ def _get_support_mask(self):
         return self.support_
 
     def _more_tags(self):
-        estimator_tags = self.estimator._get_tags()
         return {
-            'allow_nan': estimator_tags.get('allow_nan', True),
+            'allow_nan': _safe_tags(self.estimator, key="allow_nan"),
             'requires_y': True,
         }
diff --git a/sklearn/feature_selection/tests/test_rfe.py b/sklearn/feature_selection/tests/test_rfe.py
@@ -56,8 +56,8 @@ def get_params(self, deep=True):
     def set_params(self, **params):
         return self
 
-    def _get_tags(self):
-        return {}
+    def _more_tags(self):
+        return {"allow_nan": True}
 
 
 def test_rfe_features_importance():
@@ -448,10 +448,7 @@ def test_rfe_importance_getter_validation(importance_getter, err_type,
         model.fit(X, y)
 
 
-@pytest.mark.parametrize("cv", [
-    None,
-    5
-])
+@pytest.mark.parametrize("cv", [None, 5])
 def test_rfe_allow_nan_inf_in_x(cv):
     iris = load_iris()
     X = iris.data

diff --git a/sklearn/linear_model/_glm/tests/test_glm.py b/sklearn/linear_model/_glm/tests/test_glm.py
@@ -419,13 +419,13 @@ def test_tweedie_regression_family(regression_data):
 
 
 @pytest.mark.parametrize(
-        'estimator, value',
-        [
-            (PoissonRegressor(), True),
-            (GammaRegressor(), True),
-            (TweedieRegressor(power=1.5), True),
-            (TweedieRegressor(power=0), False)
-        ],
+    'estimator, value',
+    [
+        (PoissonRegressor(), True),
+        (GammaRegressor(), True),
+        (TweedieRegressor(power=1.5), True),
+        (TweedieRegressor(power=0), False),
+    ],
 )
 def test_tags(estimator, value):
     assert estimator._get_tags()['requires_positive_y'] is value
diff --git a/sklearn/linear_model/tests/test_coordinate_descent.py b/sklearn/linear_model/tests/test_coordinate_descent.py
@@ -300,7 +300,7 @@ def test_lasso_cv_positive_constraint():
      (Lars, {}),
      (LinearRegression, {}),
      (LassoLarsIC, {})]
- )
+)
 def test_model_pipeline_same_as_normalize_true(LinearModel, params):
     # Test that linear models (LinearModel) set with normalize set to True are
     # doing the same as the same linear model preceeded by StandardScaler
@@ -315,7 +315,7 @@ def test_model_pipeline_same_as_normalize_true(LinearModel, params):
         LinearModel(normalize=False, fit_intercept=True, **params)
     )
 
-    is_multitask = model_normalize._get_tags().get("multioutput_only", False)
+    is_multitask = model_normalize._get_tags()["multioutput_only"]
 
     # prepare the data
     n_samples, n_features = 100, 2

diff --git a/sklearn/model_selection/_search.py b/sklearn/model_selection/_search.py
@@ -35,6 +35,7 @@
 from joblib import Parallel
 from ..utils import check_random_state
 from ..utils.random import sample_without_replacement
+from ..utils._tags import _safe_tags
 from ..utils.validation import indexable, check_is_fitted, _check_fit_params
 from ..utils.validation import _deprecate_positional_args
 from ..utils.metaestimators import if_delegate_has_method
@@ -433,9 +434,8 @@ def _estimator_type(self):
 
     def _more_tags(self):
         # allows cross-validation to see 'precomputed' metrics
-        estimator_tags = self.estimator._get_tags()
         return {
-            'pairwise': estimator_tags.get('pairwise', False),
+            'pairwise': _safe_tags(self.estimator, "pairwise"),
             "_xfail_checks": {"check_supervised_y_2d":
                               "DataConversionWarning not caught"},
         }

diff --git a/sklearn/model_selection/tests/test_search.py b/sklearn/model_selection/tests/test_search.py
@@ -13,21 +13,26 @@
 import scipy.sparse as sp
 import pytest
 
-from sklearn.utils._testing import assert_raises
-from sklearn.utils._testing import assert_warns
-from sklearn.utils._testing import assert_warns_message
-from sklearn.utils._testing import assert_raise_message
-from sklearn.utils._testing import assert_array_equal
-from sklearn.utils._testing import assert_array_almost_equal
-from sklearn.utils._testing import assert_allclose
-from sklearn.utils._testing import assert_almost_equal
-from sklearn.utils._testing import ignore_warnings
+from sklearn.utils._testing import (
+    assert_raises,
+    assert_warns,
+    assert_warns_message,
+    assert_raise_message,
+    assert_array_equal,
+    assert_array_almost_equal,
+    assert_allclose,
+    assert_almost_equal,
+    ignore_warnings,
+    MinimalClassifier,
+    MinimalRegressor,
+    MinimalTransformer,
+)
 from sklearn.utils._mocking import CheckingClassifier, MockDataFrame
 
 from scipy.stats import bernoulli, expon, uniform
 
 from sklearn.base import BaseEstimator, ClassifierMixin
-from sklearn.base import clone
+from sklearn.base import clone, is_classifier
 from sklearn.exceptions import NotFittedError
 from sklearn.datasets import make_classification
 from sklearn.datasets import make_blobs
@@ -63,6 +68,7 @@
 from sklearn.metrics import make_scorer
 from sklearn.metrics import roc_auc_score
 from sklearn.metrics import confusion_matrix
+from sklearn.metrics import r2_score
 from sklearn.metrics.pairwise import euclidean_distances
 from sklearn.impute import SimpleImputer
 from sklearn.pipeline import Pipeline
@@ -2079,3 +2085,35 @@ def _fit_param_callable():
         'scalar_param': 42,
     }
     model.fit(X_train, y_train, **fit_params)
+
+
+# FIXME: Replace this test with a full `check_estimator` once we have API only
+# checks.
+@pytest.mark.filterwarnings("ignore:The total space of parameters 4 is")
+@pytest.mark.parametrize("SearchCV", [GridSearchCV, RandomizedSearchCV])
+@pytest.mark.parametrize("Predictor", [MinimalRegressor, MinimalClassifier])
+def test_search_cv_using_minimal_compatible_estimator(SearchCV, Predictor):
+    # Check that third-party library can run tests without inheriting from
+    # BaseEstimator.
+    rng = np.random.RandomState(0)
+    X, y = rng.randn(25, 2), np.array([0] * 5 + [1] * 20)
+
+    model = Pipeline([
+        ("transformer", MinimalTransformer()), ("predictor", Predictor())
+    ])
+
+    params = {
+        "transformer__param": [1, 10], "predictor__parama": [1, 10],
+    }
+    search = SearchCV(model, params, error_score="raise")
+    search.fit(X, y)
+
+    assert search.best_params_.keys() == params.keys()
+
+    y_pred = search.predict(X)
+    if is_classifier(search):
+        assert_array_equal(y_pred, 1)
+        assert search.score(X, y) == pytest.approx(accuracy_score(y, y_pred))
+    else:
+        assert_allclose(y_pred, y.mean())
+        assert search.score(X, y) == pytest.approx(r2_score(y, y_pred))
diff --git a/sklearn/model_selection/tests/test_validation.py b/sklearn/model_selection/tests/test_validation.py
@@ -1985,15 +1985,3 @@ def _more_tags(self):
            "Set the estimator tags of your estimator instead")
     with pytest.warns(FutureWarning, match=msg):
         cross_validate(svm, linear_kernel, y, cv=2)
-
-    # the _pairwise attribute is present and set to True while the pairwise
-    # tag is not present
-    class NoEstimatorTagSVM(SVC):
-        def _get_tags(self):
-            tags = super()._get_tags()
-            del tags['pairwise']
-            return tags
-
-    svm = NoEstimatorTagSVM(kernel='precomputed')
-    with pytest.warns(FutureWarning, match=msg):
-        cross_validate(svm, linear_kernel, y, cv=2)