scikit-learn · glemaitre · Oct 9, 2020 · Oct 9, 2020 · Oct 10, 2020 · Oct 10, 2020
diff --git a/sklearn/ensemble/_stacking.py b/sklearn/ensemble/_stacking.py
@@ -31,6 +31,7 @@
 from ..utils.metaestimators import if_delegate_has_method
 from ..utils.multiclass import check_classification_targets
 from ..utils.validation import check_is_fitted
+from ..utils.validation import _check_response_method
 from ..utils.validation import column_or_1d
 from ..utils.validation import _deprecate_positional_args
 from ..utils.fixes import delayed
@@ -96,18 +97,14 @@ def _concatenate_predictions(self, X, predictions):
     def _method_name(name, estimator, method):
         if estimator == 'drop':
             return None
-        if method == 'auto':
-            if getattr(estimator, 'predict_proba', None):
-                return 'predict_proba'
-            elif getattr(estimator, 'decision_function', None):
-                return 'decision_function'
-            else:
-                return 'predict'
-        else:
-            if not hasattr(estimator, method):
-                raise ValueError('Underlying estimator {} does not implement '
-                                 'the method {}.'.format(name, method))
-            return method
+        method = None if method == "auto" else method
+        try:
+            method_name = _check_response_method(estimator, method).__name__
+        except ValueError as e:
+            raise ValueError(
+                f"stack_method {method} not defined in {name}"
+            ) from e
+        return method_name
 
     def fit(self, X, y, sample_weight=None):
         """Fit the estimators.

diff --git a/sklearn/ensemble/tests/test_stacking.py b/sklearn/ensemble/tests/test_stacking.py
@@ -287,7 +287,7 @@ def fit(self, X, y):
       {'estimators': [('lr', LogisticRegression()),
                       ('svm', SVC(max_iter=5e4))],
        'stack_method': 'predict_proba'},
-      ValueError, 'does not implement the method predict_proba'),
+      ValueError, 'stack_method predict_proba not defined in svm'),
      (y_iris,
       {'estimators': [('lr', LogisticRegression()),
                       ('cor', NoWeightClassifier())]},

diff --git a/sklearn/inspection/_partial_dependence.py b/sklearn/inspection/_partial_dependence.py
@@ -22,7 +22,10 @@
 from ..utils import _get_column_indices
 from ..utils.validation import check_is_fitted
 from ..utils import Bunch
-from ..utils.validation import _deprecate_positional_args
+from ..utils.validation import (
+    _check_response_method,
+    _deprecate_positional_args,
+)
 from ..tree import DecisionTreeRegressor
 from ..ensemble import RandomForestRegressor
 from ..exceptions import NotFittedError
@@ -120,29 +123,7 @@ def _partial_dependence_brute(est, grid, features, X, response_method):
     predictions = []
     averaged_predictions = []
 
-    # define the prediction_method (predict, predict_proba, decision_function).
-    if is_regressor(est):
-        prediction_method = est.predict
-    else:
-        predict_proba = getattr(est, 'predict_proba', None)
-        decision_function = getattr(est, 'decision_function', None)
-        if response_method == 'auto':
-            # try predict_proba, then decision_function if it doesn't exist
-            prediction_method = predict_proba or decision_function
-        else:
-            prediction_method = (predict_proba if response_method ==
-                                 'predict_proba' else decision_function)
-        if prediction_method is None:
-            if response_method == 'auto':
-                raise ValueError(
-                    'The estimator has no predict_proba and no '
-                    'decision_function method.'
-                )
-            elif response_method == 'predict_proba':
-                raise ValueError('The estimator has no predict_proba method.')
-            else:
-                raise ValueError(
-                    'The estimator has no decision_function method.')
+    prediction_method = _check_response_method(est, response_method)
 
     for new_values in grid:
         X_eval = X.copy()
@@ -406,11 +387,15 @@ def partial_dependence(estimator, X, features, *, response_method='auto',
             'response_method {} is invalid. Accepted response_method names '
             'are {}.'.format(response_method, ', '.join(accepted_responses)))
 
-    if is_regressor(estimator) and response_method != 'auto':
-        raise ValueError(
-            "The response_method parameter is ignored for regressors and "
-            "must be 'auto'."
-        )
+    if is_regressor(estimator):
+        if response_method != "auto":
+            raise ValueError(
+                "The response_method parameter is ignored for regressors and "
+                "must be 'auto'."
+            )
+        response_method = "predict"
+    elif response_method == "auto":
+        response_method = ["predict_proba", "decision_function"]
 
     accepted_methods = ('brute', 'recursion', 'auto')
     if method not in accepted_methods:
@@ -454,10 +439,10 @@ def partial_dependence(estimator, X, features, *, response_method='auto',
                 "Only the following estimators support the 'recursion' "
                 "method: {}. Try using method='brute'."
                 .format(', '.join(supported_classes_recursion)))
-        if response_method == 'auto':
+        if isinstance(response_method, list):
             response_method = 'decision_function'
 
-        if response_method != 'decision_function':
+        if is_classifier(estimator) and response_method != 'decision_function':
             raise ValueError(
                 "With the 'recursion' method, the response_method must be "
                 "'decision_function'. Got {}.".format(response_method)

diff --git a/sklearn/inspection/tests/test_partial_dependence.py b/sklearn/inspection/tests/test_partial_dependence.py
@@ -212,8 +212,9 @@ def test_partial_dependence_helpers(est, method, target_feature):
                      [123]])
 
     if method == 'brute':
-        pdp, predictions = _partial_dependence_brute(est, grid, features, X,
-                                                     response_method='auto')
+        pdp, predictions = _partial_dependence_brute(
+            est, grid, features, X, response_method='predict'
+        )
     else:
         pdp = _partial_dependence_recursion(est, grid, features)
 
@@ -415,13 +416,13 @@ def fit(self, X, y):
       'response_method blahblah is invalid. Accepted response_method'),
      (NoPredictProbaNoDecisionFunction(),
       {'features': [0], 'response_method': 'auto'},
-      'The estimator has no predict_proba and no decision_function method'),
+      'response_method predict_proba, decision_function not defined'),
      (NoPredictProbaNoDecisionFunction(),
       {'features': [0], 'response_method': 'predict_proba'},
-      'The estimator has no predict_proba method.'),
+      'response_method predict_proba not defined'),
      (NoPredictProbaNoDecisionFunction(),
       {'features': [0], 'response_method': 'decision_function'},
-      'The estimator has no decision_function method.'),
+      'response_method decision_function not defined'),
      (LinearRegression(),
       {'features': [0], 'method': 'blahblah'},
       'blahblah is invalid. Accepted method names are brute, recursion, auto'),

diff --git a/sklearn/metrics/_plot/base.py b/sklearn/metrics/_plot/base.py
diff --git a/sklearn/metrics/_plot/det_curve.py b/sklearn/metrics/_plot/det_curve.py
@@ -1,11 +1,13 @@
 import scipy as sp
 
-from .base import _get_response
+from ...base import is_classifier
+from ...utils import (
+    check_matplotlib_support,
+    _get_response,
+)
 
 from .. import det_curve
 
-from ...utils import check_matplotlib_support
-
 
 class DetCurveDisplay:
     """DET curve visualization.
@@ -209,8 +211,16 @@ def plot_det_curve(
     """
     check_matplotlib_support('plot_det_curve')
 
+    if not is_classifier(estimator):
+        raise ValueError(
+            f"{estimator.__class__.__name__} should be a binary classifier."
+        )
+
+    if response_method == "auto":
+        response_method = ["predict_proba", "decision_function"]
+
     y_pred, pos_label = _get_response(
-        X, estimator, response_method, pos_label=pos_label
+        estimator, X, y, response_method, pos_label=pos_label
     )
 
     fpr, fnr, _ = det_curve(

diff --git a/sklearn/metrics/_plot/precision_recall_curve.py b/sklearn/metrics/_plot/precision_recall_curve.py
@@ -1,9 +1,11 @@
-from .base import _get_response
-
 from .. import average_precision_score
 from .. import precision_recall_curve
 
-from ...utils import check_matplotlib_support
+from ...base import is_classifier
+from ...utils import (
+    check_matplotlib_support,
+    _get_response,
+)
 from ...utils.validation import _deprecate_positional_args
 
 
@@ -202,8 +204,17 @@ def plot_precision_recall_curve(estimator, X, y, *,
     """
     check_matplotlib_support("plot_precision_recall_curve")
 
+    if not is_classifier(estimator):
+        raise ValueError(
+            f"{estimator.__class__.__name__} should be a binary classifier."
+        )
+
+    if response_method == "auto":
+        response_method = ["predict_proba", "decision_function"]
+
     y_pred, pos_label = _get_response(
-        X, estimator, response_method, pos_label=pos_label)
+        estimator, X, y, response_method, pos_label=pos_label
+    )
 
     precision, recall, _ = precision_recall_curve(y, y_pred,
                                                   pos_label=pos_label,

diff --git a/sklearn/metrics/_plot/roc_curve.py b/sklearn/metrics/_plot/roc_curve.py
@@ -1,9 +1,11 @@
-from .base import _get_response
-
 from .. import auc
 from .. import roc_curve
 
-from ...utils import check_matplotlib_support
+from ...base import is_classifier
+from ...utils import (
+    check_matplotlib_support,
+    _get_response,
+)
 from ...utils.validation import _deprecate_positional_args
 
 
@@ -209,8 +211,17 @@ def plot_roc_curve(estimator, X, y, *, sample_weight=None,
     """
     check_matplotlib_support('plot_roc_curve')
 
+    if not is_classifier(estimator):
+        raise ValueError(
+            f"{estimator.__class__.__name__} should be a binary classifier."
+        )
+
+    if response_method == "auto":
+        response_method = ["predict_proba", "decision_function"]
+
     y_pred, pos_label = _get_response(
-        X, estimator, response_method, pos_label=pos_label)
+        estimator, X, y, response_method, pos_label=pos_label
+    )
 
     fpr, tpr, _ = roc_curve(y, y_pred, pos_label=pos_label,
                             sample_weight=sample_weight,