Merge branch 'main' into submodule

Author: adam2392

.github/workflows/publish_pypi.yml

@@ -13,6 +13,9 @@ on:
 jobs:
   publish:
     runs-on: ubuntu-latest
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
     steps:
     - uses: actions/checkout@v3
     - uses: actions/setup-python@v4
@@ -35,15 +38,10 @@ jobs:
       run: |
         python build_tools/github/check_wheels.py
     - name: Publish package to TestPyPI
-      uses: pypa/gh-action-pypi-publish@v1.4.1
+      uses: pypa/gh-action-pypi-publish@v1.8.5
       with:
-        user: __token__
-        password: ${{ secrets.TEST_PYPI_TOKEN }}
         repository_url: https://test.pypi.org/legacy/
       if: ${{ github.event.inputs.pypi_repo == 'testpypi' }}
     - name: Publish package to PyPI
-      uses: pypa/gh-action-pypi-publish@v1.4.1
-      with:
-        user: __token__
-        password: ${{ secrets.PYPI_TOKEN }}
+      uses: pypa/gh-action-pypi-publish@v1.8.5
       if: ${{ github.event.inputs.pypi_repo == 'pypi' }}

doc/modules/impute.rst

@@ -226,8 +226,8 @@ neighbors of samples with missing values::
       Missing value estimation methods for DNA microarrays, BIOINFORMATICS
       Vol. 17 no. 6, 2001 Pages 520-525.
 
-Keeping the number of features constants
-========================================
+Keeping the number of features constant
+=======================================
 
 By default, the scikit-learn imputers will drop fully empty features, i.e.
 columns containing only missing values. For instance::

doc/modules/model_evaluation.rst

@@ -115,17 +115,11 @@ Usage examples:
     >>> clf = svm.SVC(random_state=0)
     >>> cross_val_score(clf, X, y, cv=5, scoring='recall_macro')
     array([0.96..., 0.96..., 0.96..., 0.93..., 1.        ])
-    >>> model = svm.SVC()
-    >>> cross_val_score(model, X, y, cv=5, scoring='wrong_choice')
-    Traceback (most recent call last):
-    ValueError: 'wrong_choice' is not a valid scoring value. Use
-    sklearn.metrics.get_scorer_names() to get valid options.
 
 .. note::
 
-    The values listed by the ``ValueError`` exception correspond to the
-    functions measuring prediction accuracy described in the following
-    sections. You can retrieve the names of all available scorers by calling
+    If a wrong scoring name is passed, an ``InvalidParameterError`` is raised.
+    You can retrieve the names of all available scorers by calling
     :func:`~sklearn.metrics.get_scorer_names`.
 
 .. currentmodule:: sklearn.metrics

sklearn/calibration.py

@@ -7,7 +7,7 @@
 #
 # License: BSD 3 clause
 
-from numbers import Integral
+from numbers import Integral, Real
 import warnings
 from inspect import signature
 from functools import partial
@@ -35,7 +35,13 @@
 
 from .utils.multiclass import check_classification_targets
 from .utils.parallel import delayed, Parallel
-from .utils._param_validation import StrOptions, HasMethods, Hidden
+from .utils._param_validation import (
+    StrOptions,
+    HasMethods,
+    Hidden,
+    validate_params,
+    Interval,
+)
 from .utils._plotting import _BinaryClassifierCurveDisplayMixin
 from .utils.validation import (
     _check_fit_params,
@@ -903,6 +909,15 @@ def predict(self, T):
         return expit(-(self.a_ * T + self.b_))
 
 
+@validate_params(
+    {
+        "y_true": ["array-like"],
+        "y_prob": ["array-like"],
+        "pos_label": [Real, str, "boolean", None],
+        "n_bins": [Interval(Integral, 1, None, closed="left")],
+        "strategy": [StrOptions({"uniform", "quantile"})],
+    }
+)
 def calibration_curve(
     y_true,
     y_prob,
@@ -928,7 +943,7 @@ def calibration_curve(
     y_prob : array-like of shape (n_samples,)
         Probabilities of the positive class.
 
-    pos_label : int or str, default=None
+    pos_label : int, float, bool or str, default=None
         The label of the positive class.
 
         .. versionadded:: 1.1
@@ -1042,7 +1057,7 @@ class CalibrationDisplay(_BinaryClassifierCurveDisplayMixin):
     estimator_name : str, default=None
         Name of estimator. If None, the estimator name is not shown.
 
-    pos_label : str or int, default=None
+    pos_label : int, float, bool or str, default=None
         The positive class when computing the calibration curve.
         By default, `estimators.classes_[1]` is considered as the
         positive class.
@@ -1208,7 +1223,7 @@ def from_estimator(
             - `'quantile'`: The bins have the same number of samples and depend
               on predicted probabilities.
 
-        pos_label : str or int, default=None
+        pos_label : int, float, bool or str, default=None
             The positive class when computing the calibration curve.
             By default, `estimators.classes_[1]` is considered as the
             positive class.
@@ -1326,7 +1341,7 @@ def from_predictions(
             - `'quantile'`: The bins have the same number of samples and depend
               on predicted probabilities.
 
-        pos_label : str or int, default=None
+        pos_label : int, float, bool or str, default=None
             The positive class when computing the calibration curve.
             By default, `estimators.classes_[1]` is considered as the
             positive class.

sklearn/datasets/_base.py

@@ -1275,6 +1275,11 @@ def load_sample_images():
     return Bunch(images=images, filenames=filenames, DESCR=descr)
 
 
+@validate_params(
+    {
+        "image_name": [StrOptions({"china.jpg", "flower.jpg"})],
+    }
+)
 def load_sample_image(image_name):
     """Load the numpy array of a single sample image.
 

sklearn/datasets/tests/test_base.py

@@ -222,12 +222,6 @@ def test_load_sample_image():
         warnings.warn("Could not load sample images, PIL is not available.")
 
 
-def test_load_missing_sample_image_error():
-    pytest.importorskip("PIL")
-    with pytest.raises(AttributeError):
-        load_sample_image("blop.jpg")
-
-
 def test_load_diabetes_raw():
     """Test to check that we load a scaled version by default but that we can
     get an unscaled version when setting `scaled=False`."""

sklearn/feature_selection/_sequential.py

@@ -39,8 +39,8 @@ class SequentialFeatureSelector(SelectorMixin, MetaEstimatorMixin, BaseEstimator
     n_features_to_select : "auto", int or float, default='warn'
         If `"auto"`, the behaviour depends on the `tol` parameter:
 
-        - if `tol` is not `None`, then features are selected until the score
-          improvement does not exceed `tol`.
+        - if `tol` is not `None`, then features are selected while the score
+          change does not exceed `tol`.
         - otherwise, half of the features are selected.
 
         If integer, the parameter is the absolute number of features to select.
@@ -53,7 +53,7 @@ class SequentialFeatureSelector(SelectorMixin, MetaEstimatorMixin, BaseEstimator
            The default changed from `None` to `"warn"` in 1.1 and will become
            `"auto"` in 1.3. `None` and `'warn'` will be removed in 1.3.
            To keep the same behaviour as `None`, set
-           `n_features_to_select="auto" and `tol=None`.
+           `n_features_to_select="auto"` and `tol=None`.
 
     tol : float, default=None
         If the score is not incremented by at least `tol` between two

sklearn/inspection/_partial_dependence.py

@@ -22,6 +22,13 @@
 from ..utils import _get_column_indices
 from ..utils.validation import check_is_fitted
 from ..utils import Bunch
+from ..utils._param_validation import (
+    HasMethods,
+    Integral,
+    Interval,
+    StrOptions,
+    validate_params,
+)
 from ..tree import DecisionTreeRegressor
 from ..ensemble import RandomForestRegressor
 from ..exceptions import NotFittedError
@@ -223,6 +230,24 @@ def _partial_dependence_brute(est, grid, features, X, response_method):
     return averaged_predictions, predictions
 
 
+@validate_params(
+    {
+        "estimator": [
+            HasMethods(["fit", "predict"]),
+            HasMethods(["fit", "predict_proba"]),
+            HasMethods(["fit", "decision_function"]),
+        ],
+        "X": ["array-like", "sparse matrix"],
+        "features": ["array-like", Integral, str],
+        "categorical_features": ["array-like", None],
+        "feature_names": ["array-like", None],
+        "response_method": [StrOptions({"auto", "predict_proba", "decision_function"})],
+        "percentiles": [tuple],
+        "grid_resolution": [Interval(Integral, 1, None, closed="left")],
+        "method": [StrOptions({"auto", "recursion", "brute"})],
+        "kind": [StrOptions({"average", "individual", "both"})],
+    }
+)
 def partial_dependence(
     estimator,
     X,
@@ -268,13 +293,13 @@ def partial_dependence(
         :term:`predict_proba`, or :term:`decision_function`.
         Multioutput-multiclass classifiers are not supported.
 
-    X : {array-like or dataframe} of shape (n_samples, n_features)
+    X : {array-like, sparse matrix or dataframe} of shape (n_samples, n_features)
         ``X`` is used to generate a grid of values for the target
         ``features`` (where the partial dependence will be evaluated), and
         also to generate values for the complement features when the
         `method` is 'brute'.
 
-    features : array-like of {int, str}
+    features : array-like of {int, str, bool} or int or str
         The feature (e.g. `[0]`) or pair of interacting features
         (e.g. `[(0, 1)]`) for which the partial dependency should be computed.
 
@@ -425,27 +450,12 @@ def partial_dependence(
     if not (hasattr(X, "__array__") or sparse.issparse(X)):
         X = check_array(X, force_all_finite="allow-nan", dtype=object)
 
-    accepted_responses = ("auto", "predict_proba", "decision_function")
-    if response_method not in accepted_responses:
-        raise ValueError(
-            "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'."
         )
 
-    accepted_methods = ("brute", "recursion", "auto")
-    if method not in accepted_methods:
-        raise ValueError(
-            "method {} is invalid. Accepted method names are {}.".format(
-                method, ", ".join(accepted_methods)
-            )
-        )
-
     if kind != "average":
         if method == "recursion":
             raise ValueError(

sklearn/inspection/_plot/tests/test_plot_partial_dependence.py

@@ -611,16 +611,6 @@ def test_plot_partial_dependence_dataframe(pyplot, clf_diabetes, diabetes):
             {"features": [1], "categorical_features": [1], "kind": "individual"},
             "It is not possible to display individual effects",
         ),
-        (
-            dummy_classification_data,
-            {"features": [1], "kind": "foo"},
-            "Values provided to `kind` must be one of",
-        ),
-        (
-            dummy_classification_data,
-            {"features": [0, 1], "kind": ["foo", "individual"]},
-            "Values provided to `kind` must be one of",
-        ),
     ],
 )
 def test_plot_partial_dependence_error(pyplot, data, params, err_msg):

sklearn/inspection/tests/test_partial_dependence.py

@@ -510,31 +510,6 @@ def fit(self, X, y):
             {"features": [0], "response_method": "predict_proba", "method": "auto"},
             "'recursion' method, the response_method must be 'decision_function'",
         ),
-        (
-            GradientBoostingClassifier(random_state=0),
-            {"features": [0], "response_method": "blahblah"},
-            "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",
-        ),
-        (
-            NoPredictProbaNoDecisionFunction(),
-            {"features": [0], "response_method": "predict_proba"},
-            "The estimator has no predict_proba method.",
-        ),
-        (
-            NoPredictProbaNoDecisionFunction(),
-            {"features": [0], "response_method": "decision_function"},
-            "The estimator has no decision_function method.",
-        ),
-        (
-            LinearRegression(),
-            {"features": [0], "method": "blahblah"},
-            "blahblah is invalid. Accepted method names are brute, recursion, auto",
-        ),
         (
             LinearRegression(),
             {"features": [0], "method": "recursion", "kind": "individual"},
@@ -560,24 +535,6 @@ def test_partial_dependence_error(estimator, params, err_msg):
         partial_dependence(estimator, X, **params)
 
 
-@pytest.mark.parametrize(
-    "with_dataframe, err_msg",
-    [
-        (True, "Only array-like or scalar are supported"),
-        (False, "Only array-like or scalar are supported"),
-    ],
-)
-def test_partial_dependence_slice_error(with_dataframe, err_msg):
-    X, y = make_classification(random_state=0)
-    if with_dataframe:
-        pd = pytest.importorskip("pandas")
-        X = pd.DataFrame(X)
-    estimator = LogisticRegression().fit(X, y)
-
-    with pytest.raises(TypeError, match=err_msg):
-        partial_dependence(estimator, X, features=slice(0, 2, 1))
-
-
 @pytest.mark.parametrize(
     "estimator", [LinearRegression(), GradientBoostingClassifier(random_state=0)]
 )