julearn 0.3.2.dev57__tar.gz → 0.3.2.dev78__tar.gz

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: julearn
-Version: 0.3.2.dev57
+Version: 0.3.2.dev78
 Summary: Juelich Machine Learning Library
 Author-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Sami Hamdan <s.hamdan@fz-juelich.de>
 Maintainer-email: Sami Hamdan <s.hamdan@fz-juelich.de>
@@ -41,6 +41,8 @@ Requires-Dist: sphinx_copybutton<0.6,>=0.5.0; extra == "docs"
 Requires-Dist: numpydoc<1.6,>=1.5.0; extra == "docs"
 Requires-Dist: towncrier<24; extra == "docs"
 Requires-Dist: scikit-optimize<0.11,>=0.10.0; extra == "docs"
+Requires-Dist: optuna<3.7,>=3.6.0; extra == "docs"
+Requires-Dist: optuna_integration<3.7,>=3.6.0; extra == "docs"
 Provides-Extra: deslib
 Requires-Dist: deslib<0.4,>=0.3.5; extra == "deslib"
 Provides-Extra: viz
@@ -49,8 +51,11 @@ Requires-Dist: bokeh>=3.0.0; extra == "viz"
 Requires-Dist: param>=2.0.0; extra == "viz"
 Provides-Extra: skopt
 Requires-Dist: scikit-optimize<0.11,>=0.10.0; extra == "skopt"
+Provides-Extra: optuna
+Requires-Dist: optuna<3.7,>=3.6.0; extra == "optuna"
+Requires-Dist: optuna_integration<3.7,>=3.6.0; extra == "optuna"
 Provides-Extra: all
-Requires-Dist: julearn[skopt,viz]; extra == "all"
+Requires-Dist: julearn[optuna,skopt,viz]; extra == "all"
 
 # julearn
 

julearn-0.3.2.dev78/docs/changes/newsfragments/262.doc

@@ -0,0 +1 @@
+Update documentation on Hyperparameter Tuning by `Fede Raimondo`_

julearn-0.3.2.dev78/docs/changes/newsfragments/262.enh

@@ -0,0 +1 @@
+Refactor how hyperparmeters' distributions are specified by `Fede Raimondo`_

julearn-0.3.2.dev78/docs/changes/newsfragments/262.feature

@@ -0,0 +1 @@
+Add :class:`~optuna_integration.sklearn.OptunaSearchCV` to the list of available searchers as ``optuna`` by `Fede Raimondo`_

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/docs/conf.py

@@ -161,6 +161,11 @@ intersphinx_mapping = {
     "joblib": ("https://joblib.readthedocs.io/en/latest/", None),
     "scipy": ("https://docs.scipy.org/doc/scipy/", None),
     "skopt": ("https://scikit-optimize.readthedocs.io/en/latest", None),
+    "optuna": ("https://optuna.readthedocs.io/en/stable", None),
+    "optuna_integration": (
+        "https://optuna-integration.readthedocs.io/en/stable",
+        None,
+    ),
 }
 
 

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/docs/links.inc

@@ -41,3 +41,4 @@
 
 .. _`DESlib`: https://github.com/scikit-learn-contrib/DESlib
 .. _`scikit-optimize`: https://scikit-optimize.readthedocs.io/en/stable/
+.. _`Optuna`: https://optuna.org

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/examples/99_docs/run_hyperparameters_docs.py

@@ -253,8 +253,9 @@ pprint(model_tuned.best_params_)
 # hyperparameters values.
 #
 # Other searchers that ``julearn`` provides are the
-# :class:`~sklearn.model_selection.RandomizedSearchCV` and
-# :class:`~skopt.BayesSearchCV`.
+# :class:`~sklearn.model_selection.RandomizedSearchCV`, 
+# :class:`~skopt.BayesSearchCV` and
+# :class:`~optuna_integration.sklearn.OptunaSearchCV`.
 #
 # The randomized searcher
 # (:class:`~sklearn.model_selection.RandomizedSearchCV`) is similar to the
@@ -274,6 +275,12 @@ pprint(model_tuned.best_params_)
 # :class:`~skopt.BayesSearchCV` documentation, including how to specify
 # the prior distributions of the hyperparameters.
 #
+# The Optuna searcher (:class:`~optuna_integration.sklearn.OptunaSearchCV`)
+# uses the Optuna library to find the best hyperparameter set. Optuna is a
+# hyperparameter optimization framework that has several algorithms to find
+# the best hyperparameter set. For more information, see the
+# `Optuna`_ documentation.
+#
 # We can specify the kind of searcher and its parametrization, by setting the
 # ``search_params`` parameter in the :func:`.run_cross_validation` function.
 # For example, we can use the
@@ -369,6 +376,140 @@ print(
 )
 pprint(model_tuned.best_params_)
 
+###############################################################################
+# An example using optuna searcher is shown below. The searcher is specified
+# as ``"optuna"`` and the hyperparameters are specified as a dictionary with
+# the hyperparameters to tune and their distributions as for the bayesian
+# searcher. However, the optuna searcher behaviour is controlled by a
+# :class:`~optuna.study.Study` object. This object can be passed to the
+# searcher using the ``study`` parameter in the ``search_params`` dictionary.
+# 
+# .. important::
+#    The optuna searcher requires that all the hyperparameters are specified
+#    as distributions, even the categorical ones. 
+#
+# We first modify the pipeline creator so the ``select_k`` parameter is
+# specified as a distribution. We exemplarily use a categorical distribution
+# for the ``class_weight`` hyperparameter, trying the ``"balanced"`` and 
+# ``None`` values.
+
+creator = PipelineCreator(problem_type="classification")
+creator.add("zscore")
+creator.add("select_k", k=(2, 4, "uniform"))
+creator.add(
+    "svm",
+    C=(0.01, 10, "log-uniform"),
+    gamma=(1e-3, 1e-1, "log-uniform"),
+    class_weight=("balanced", None, "categorical")
+)
+print(creator)
+
+###############################################################################
+# We can now use the optuna searcher with 10 trials and 3-fold cross-validation.
+
+import optuna
+
+study = optuna.create_study(
+    direction="maximize",
+    study_name="optuna-concept",
+    load_if_exists=True,
+)
+
+search_params = {
+    "kind": "optuna",
+    "study": study,
+    "cv": 3,
+}
+scores_tuned, model_tuned = run_cross_validation(
+    X=X,
+    y=y,
+    data=df,
+    X_types=X_types,
+    model=creator,
+    return_estimator="all",
+    search_params=search_params,
+)
+
+print(
+    "Scores with best hyperparameter using 10 iterations of "
+    f"optuna and 3-fold CV: {scores_tuned['test_score'].mean()}"
+)
+pprint(model_tuned.best_params_)
+
+###############################################################################
+#
+# Specifying distributions
+# ~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# The hyperparameters can be specified as distributions for the randomized
+# searcher, bayesian searcher and optuna searcher. The distributions are
+# either specified toolbox-specific method or  a tuple convention with the
+# following format: ``(low, high, distribution)`` where the distribution can
+# be either ``"log-uniform"`` or ``"uniform"`` or 
+# ``(a, b, c, d, ..., "categorical")`` where ``a``, ``b``, ``c``, ``d``, etc.
+# are the possible categorical values for the hyperparameter.
+#
+# For example, we can specify the ``C`` and ``gamma`` hyperparameters of the 
+# :class:`~sklearn.svm.SVC` as  log-uniform distributions, while keeping 
+# the ``with_mean`` parameter of the
+# :class:`~sklearn.preprocessing.StandardScaler` as a categorical parameter
+# with two options.
+
+
+creator = PipelineCreator(problem_type="classification")
+creator.add("zscore", with_mean=(True, False, "categorical"))
+creator.add(
+    "svm",
+    C=(0.01, 10, "log-uniform"),
+    gamma=(1e-3, 1e-1, "log-uniform"),
+)
+print(creator)
+
+###############################################################################
+# While this will work for any of the ``random``, ``bayes`` or ``optuna``
+# searcher options, it is important to note that both ``bayes`` and ``optuna``
+# searchers accept further parameters to specify distributions. For example,
+# the ``bayes`` searcher distributions are defined using the 
+# :class:`~skopt.space.space.Categorical`, :class:`~skopt.space.space.Integer`
+# and :class:`~skopt.space.space.Real`.
+#
+# For example, we can define a log-uniform distribution with base 2 for the
+# ``C`` hyperparameter of the :class:`~sklearn.svm.SVC` model:
+from skopt.space import Real
+creator = PipelineCreator(problem_type="classification")
+creator.add("zscore", with_mean=(True, False, "categorical"))
+creator.add(
+    "svm",
+    C=Real(0.01, 10, prior="log-uniform", base=2),
+    gamma=(1e-3, 1e-1, "log-uniform"),
+)
+print(creator)
+
+###############################################################################
+# For the optuna searcher, the distributions are defined using the
+# :class:`~optuna.distributions.CategoricalDistribution`,
+# :class:`~optuna.distributions.FloatDistribution` and
+# :class:`~optuna.distributions.IntDistribution`.
+#
+#
+# For example, we can define a uniform distribution from 0.5 to 0.9 with a 0.05
+# step for the ``n_components`` of a :class:`~sklearn.decomposition.PCA` 
+# transformer, while keeping a log-uniform distribution for the ``C`` and
+# ``gamma`` hyperparameters of the :class:`~sklearn.svm.SVC` model.
+from optuna.distributions import FloatDistribution
+creator = PipelineCreator(problem_type="classification")
+creator.add("zscore")
+creator.add(
+    "pca",
+    n_components=FloatDistribution(0.5, 0.9, step=0.05),
+)
+creator.add(
+    "svm",
+    C=FloatDistribution(0.01, 10, log=True),
+    gamma=(1e-3, 1e-1, "log-uniform"),
+)
+print(creator)
+
 
 ###############################################################################
 #

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.2.dev57'
-__version_tuple__ = version_tuple = (0, 3, 2, 'dev57')
+__version__ = version = '0.3.2.dev78'
+__version_tuple__ = version_tuple = (0, 3, 2, 'dev78')

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/api.py

@@ -4,13 +4,13 @@
 #          Sami Hamdan <s.hamdan@fz-juelich.de>
 # License: AGPL
 
-from typing import Dict, Iterable, List, Optional, Union
+from typing import Dict, List, Optional, Union
 
 import numpy as np
 import pandas as pd
+import sklearn
 from sklearn.base import BaseEstimator
 from sklearn.model_selection import (
-    BaseCrossValidator,
     check_cv,
     cross_validate,
 )
@@ -23,6 +23,7 @@ from .pipeline.merger import merge_pipelines
 from .prepare import check_consistency, prepare_input_data
 from .scoring import check_scoring
 from .utils import _compute_cvmdsum, logger, raise_error
+from .utils.typing import CVLike
 
 
 def run_cross_validation(  # noqa: C901
@@ -36,7 +37,7 @@ def run_cross_validation(  # noqa: C901
     return_estimator: Optional[str] = None,
     return_inspector: bool = False,
     return_train_score: bool = False,
-    cv: Optional[Union[int, BaseCrossValidator, Iterable]] = None,
+    cv: Optional[CVLike] = None,
     groups: Optional[str] = None,
     scoring: Union[str, List[str], None] = None,
     pos_labels: Union[str, List[str], None] = None,
@@ -134,9 +135,18 @@ def run_cross_validation(  # noqa: C901
         Additional parameters in case Hyperparameter Tuning is performed, with
         the following keys:
 
-        * 'kind': The kind of search algorithm to use, e.g.:
-            'grid', 'random' or 'bayes'. Can be any valid julearn searcher name
-            or scikit-learn compatible searcher.
+        * 'kind': The kind of search algorithm to use, Valid options are:
+
+          * ``"grid"`` : :class:`~sklearn.model_selection.GridSearchCV`
+          * ``"random"`` :
+            :class:`~sklearn.model_selection.RandomizedSearchCV`
+          * ``"bayes"`` : :class:`~skopt.BayesSearchCV`
+          * ``"optuna"`` :
+            :class:`~optuna_integration.sklearn.OptunaSearchCV`
+          * user-registered searcher name : see
+            :func:`~julearn.model_selection.register_searcher`
+          * ``scikit-learn``-compatible searcher
+
         * 'cv': If a searcher is going to be used, the cross-validation
             splitting strategy to use. Defaults to same CV as for the model
             evaluation.
@@ -357,20 +367,32 @@ def run_cross_validation(  # noqa: C901
 
     # Prepare cross validation
     cv_outer = check_cv(
-        cv, classifier=problem_type == "classification"  # type: ignore
+        cv,  # type: ignore
+        classifier=problem_type == "classification",
     )
     logger.info(f"Using outer CV scheme {cv_outer}")
 
     check_consistency(df_y, cv, groups, problem_type)  # type: ignore
 
     cv_return_estimator = return_estimator in ["cv", "all"]
-    scoring = check_scoring(pipeline, scoring, wrap_score=wrap_score)
+    scoring = check_scoring(
+        pipeline,  # type: ignore
+        scoring,
+        wrap_score=wrap_score,
+    )
 
     cv_mdsum = _compute_cvmdsum(cv_outer)
     fit_params = {}
     if df_groups is not None:
         if isinstance(pipeline, BaseSearchCV):
             fit_params["groups"] = df_groups.values
+
+    _sklearn_deprec_fit_params = {}
+    if sklearn.__version__ >= "1.4.0":
+        _sklearn_deprec_fit_params["params"] = fit_params
+    else:
+        _sklearn_deprec_fit_params["fit_params"] = fit_params
+
     scores = cross_validate(
         pipeline,
         df_X,
@@ -382,7 +404,7 @@ def run_cross_validation(  # noqa: C901
         n_jobs=n_jobs,
         return_train_score=return_train_score,
         verbose=verbose,  # type: ignore
-        fit_params=fit_params,
+        **_sklearn_deprec_fit_params,
     )
 
     n_repeats = getattr(cv_outer, "n_repeats", 1)

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/base/estimators.py

@@ -13,11 +13,11 @@ from sklearn.utils.metaestimators import available_if
 
 
 try:  # sklearn < 1.4.0
-    from sklearn.utils.validation import _check_fit_params
+    from sklearn.utils.validation import _check_fit_params  # type: ignore
 
     fit_params_checker = _check_fit_params
 except ImportError:  # sklearn >= 1.4.0
-    from sklearn.utils.validation import _check_method_params
+    from sklearn.utils.validation import _check_method_params  # type: ignore
 
     fit_params_checker = _check_method_params
 
@@ -180,7 +180,12 @@ class JuTransformer(JuBaseEstimator, TransformerMixin):
         self.row_select_col_type = row_select_col_type
         self.row_select_vals = row_select_vals
 
-    def fit(self, X, y=None, **fit_params):  # noqa: N803
+    def fit(
+        self,
+        X: pd.DataFrame,  # noqa: N803
+        y: Optional[pd.Series] = None,
+        **fit_params,
+    ):
         """Fit the model.
 
         This method will fit the model using only the columns selected by
@@ -217,8 +222,21 @@ class JuTransformer(JuBaseEstimator, TransformerMixin):
             self.row_select_vals = [self.row_select_vals]
         return self._fit(**self._select_rows(X, y, **fit_params))
 
+    def _fit(
+        self,
+        X: pd.DataFrame,  # noqa: N803,
+        y: Optional[pd.Series],
+        **kwargs,
+    ) -> None:
+        raise_error(
+            "This method should be implemented in the concrete class",
+            klass=NotImplementedError,
+        )
+
     def _add_backed_filtered(
-        self, X: pd.DataFrame, X_trans: pd.DataFrame  # noqa: N803
+        self,
+        X: pd.DataFrame,  # noqa: N803
+        X_trans: pd.DataFrame,  # noqa: N803
     ) -> pd.DataFrame:
         """Add the left-out columns back to the transformed data.
 
@@ -301,7 +319,7 @@ class WrapModel(JuBaseEstimator):
 
     def fit(
         self,
-        X: pd.DataFrame,  # noqa: N803
+        X: DataLike,  # noqa: N803
         y: Optional[DataLike] = None,
         **fit_params: Any,
     ) -> "WrapModel":
@@ -312,7 +330,7 @@ class WrapModel(JuBaseEstimator):
 
         Parameters
         ----------
-        X : pd.DataFrame
+        X : DataLike
             The data to fit the model on.
         y : DataLike, optional
             The target data (default is None).
@@ -329,9 +347,9 @@ class WrapModel(JuBaseEstimator):
         if self.needed_types is not None:
             self.needed_types = ensure_column_types(self.needed_types)
 
-        Xt = self.filter_columns(X)
+        Xt = self.filter_columns(X)  # type: ignore
         self.model_ = self.model
-        self.model_.fit(Xt, y, **fit_params)
+        self.model_.fit(Xt, y, **fit_params)  # type: ignore
         return self
 
     def predict(self, X: pd.DataFrame) -> DataLike:  # noqa: N803

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/base/tests/test_base_estimators.py

@@ -110,7 +110,7 @@ def test_WrapModel(
 
     np.random.seed(42)
     lr = model()
-    lr.fit(X_iris_selected, y_iris)
+    lr.fit(X_iris_selected, y_iris)  # type: ignore
     pred_sk = lr.predict(X_iris_selected)
 
     np.random.seed(42)

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/conftest.py

@@ -270,7 +270,7 @@ def search_params(request: FixtureRequest) -> Optional[Dict]:
     scope="function",
 )
 def bayes_search_params(request: FixtureRequest) -> Optional[Dict]:
-    """Return different  search_params argument for BayesSearchCV.
+    """Return different search_params argument for BayesSearchCV.
 
     Parameters
     ----------
@@ -286,6 +286,29 @@ def bayes_search_params(request: FixtureRequest) -> Optional[Dict]:
 
     return request.param
 
+@fixture(
+    params=[
+        {"kind": "optuna", "n_trials": 10, "cv": 3},
+        {"kind": "optuna", "timeout": 20},
+    ],
+    scope="function",
+)
+def optuna_search_params(request: FixtureRequest) -> Optional[Dict]:
+    """Return different search_params argument for OptunaSearchCV.
+
+    Parameters
+    ----------
+    request : pytest.FixtureRequest
+        The request object.
+
+    Returns
+    -------
+    dict or None
+        A dictionary with the search_params argument.
+
+    """
+
+    return request.param
 
 _tuning_params = {
     "zscore": {"with_mean": [True, False]},

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/inspect/_cv.py

@@ -4,13 +4,14 @@
 #          Sami Hamdan <s.hamdan@fz-juelich.de>
 # License: AGPL
 
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 import pandas as pd
 from sklearn.model_selection import BaseCrossValidator, check_cv
 from sklearn.utils.metaestimators import available_if
 
 from ..utils import _compute_cvmdsum, is_nonoverlapping_cv, raise_error
+from ..utils.typing import DataLike
 from ._pipeline import PipelineInspector
 
 
@@ -60,14 +61,13 @@ class FoldsInspector:
     def __init__(
         self,
         scores: pd.DataFrame,
-        cv: BaseCrossValidator,
-        X: Union[str, List[str]],  # noqa: N803
-        y: str,
+        cv: Union[BaseCrossValidator, int],
+        X: DataLike,  # noqa: N803
+        y: pd.Series,
         func: str = "predict",
-        groups: Optional[str] = None,
+        groups: Optional[pd.Series] = None,
     ):
         self._scores = scores
-        self._cv = cv
         self._X = X
         self._y = y
         self._func = func
@@ -92,7 +92,7 @@ class FoldsInspector:
             )
 
         cv = check_cv(cv)
-
+        self._cv = cv
         t_cv_mdsum = _compute_cvmdsum(cv)
         if t_cv_mdsum != cv_mdsums[0]:
             raise_error(
@@ -120,10 +120,16 @@ class FoldsInspector:
 
         predictions = []
         for i_fold, (_, test) in enumerate(
-            self._cv.split(self._X, self._y, groups=self._groups)
+            self._cv.split(
+                self._X,  # type: ignore
+                self._y,
+                groups=self._groups,
+            )
         ):
             t_model = self._scores["estimator"][i_fold]
-            t_values = getattr(t_model, func)(self._X.iloc[test])
+            t_values = getattr(t_model, func)(
+                self._X.iloc[test]  # type: ignore
+            )
             if t_values.ndim == 1:
                 t_values = t_values[:, None]
             column_names = [f"p{i}" for i in range(t_values.shape[1])]
@@ -152,7 +158,7 @@ class FoldsInspector:
                 t_df.columns = [f"fold{i_fold}_{x}" for x in t_df.columns]
         predictions = pd.concat(predictions, axis=1)
         predictions = predictions.sort_index()
-        predictions["target"] = self._y.values
+        predictions["target"] = self._y.values  # type: ignore
         return predictions
 
     def __getitem__(self, key):

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/inspect/_preprocess.py

@@ -53,7 +53,7 @@ def preprocess(
         else:
             raise_error(f"No step named {until} found.")
     df_out = pipeline[:i].transform(_X)
-
+    df_out = df_out.copy()
     if not isinstance(df_out, pd.DataFrame) and with_column_types is False:
         raise_error(
             "The output of the pipeline is not a DataFrame. Cannot remove "

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/inspect/tests/test_cv.py

@@ -3,7 +3,6 @@
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 #          Sami Hamdan <s.hamdan@fz-juelich.de>
 # License: AGPL
-
 import numpy as np
 import pandas as pd
 import pytest
@@ -70,7 +69,10 @@ def scores(df_typed_iris, n_iters=5, mock_model=None):
     if mock_model is None:
         mock_model = MockModelReturnsIndex
 
-    estimators = [WrapModel(mock_model()).fit(X, y) for _ in range(n_iters)]
+    estimators = [
+        WrapModel(mock_model()).fit(X, y)  # type: ignore
+        for _ in range(n_iters)
+    ]
 
     return pd.DataFrame(
         {

{julearn-0.3.2.dev57 → julearn-0.3.2.dev78}/julearn/inspect/tests/test_inspector.py

@@ -18,28 +18,28 @@ if TYPE_CHECKING:
 
 def test_no_cv() -> None:
     """Test inspector with no cross-validation."""
-    inspector = Inspector({})
+    inspector = Inspector({})  # type: ignore
     with pytest.raises(ValueError, match="No cv"):
         _ = inspector.folds
 
 
 def test_no_X() -> None:
     """Test inspector with no features."""
-    inspector = Inspector({}, cv=5)
+    inspector = Inspector({}, cv=5)  # type: ignore
     with pytest.raises(ValueError, match="No X"):
         _ = inspector.folds
 
 
 def test_no_y() -> None:
     """Test inspector with no targets."""
-    inspector = Inspector({}, cv=5, X=[1, 2, 3])
+    inspector = Inspector({}, cv=5, X=[1, 2, 3])  # type: ignore
     with pytest.raises(ValueError, match="No y"):
         _ = inspector.folds
 
 
 def test_no_model() -> None:
     """Test inspector with no model."""
-    inspector = Inspector({})
+    inspector = Inspector({})  # type: ignore
     with pytest.raises(ValueError, match="No model"):
         _ = inspector.model
 
@@ -63,8 +63,11 @@ def test_normal_usage(df_iris: "pd.DataFrame") -> None:
         return_inspector=True,
         problem_type="classification",
     )
-    assert pipe == inspect.model._model
-    for (_, score), inspect_fold in zip(scores.iterrows(), inspect.folds):
+    assert pipe == inspect.model._model  # type: ignore
+    for (_, score), inspect_fold in zip(
+        scores.iterrows(),  # type: ignore
+        inspect.folds,  # type: ignore
+    ):
         assert score["estimator"] == inspect_fold.model._model
 
 
@@ -88,6 +91,6 @@ def test_normal_usage_with_search(df_iris: "pd.DataFrame") -> None:
         return_estimator="all",
         return_inspector=True,
     )
-    assert pipe == inspect.model._model
-    inspect.model.get_fitted_params()
-    inspect.model.get_params()
+    assert pipe == inspect.model._model  # type: ignore
+    inspect.model.get_fitted_params()  # type: ignore
+    inspect.model.get_params()  # type: ignore