hyperactive.integrations.sklearn.opt_cv

Complexity

Total Complexity

8

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	OptCV.score()	0	27	1
A	OptCV.fit()	0	42	2
A	OptCV.__init__()	0	16	1
A	OptCV._refit()	0	7	1
A	OptCV._check_data()	0	8	2
A	OptCV.fit_successful()	0	3	1

# copyright: hyperactive developers, MIT License (see LICENSE file)

from collections.abc import Callable
from typing import Union

from sklearn.base import BaseEstimator, clone
from sklearn.utils.validation import indexable, _check_method_params

from hyperactive.experiment.integrations.sklearn_cv import SklearnCvExperiment
from hyperactive.integrations.sklearn.best_estimator import (
    BestEstimator as _BestEstimator_
)
from hyperactive.integrations.sklearn.checks import Checks


class OptCV(BaseEstimator, _BestEstimator_, Checks):
    """Tuning via any optimizer in the hyperactive API.

    Parameters
    ----------
    estimator : SklearnBaseEstimator
        The estimator to be tuned.
    optimizer : hyperactive BaseOptimizer
        The optimizer to be used for hyperparameter search.
    scoring : callable or str, default = accuracy_score or mean_squared_error
        sklearn scoring function or metric to evaluate the model's performance.
        Default is determined by the type of estimator:
        ``accuracy_score`` for classifiers, and
        ``mean_squared_error`` for regressors, as per sklearn convention
        through the default ``score`` method of the estimator.
    refit: bool, optional, default = True
        Whether to refit the best estimator with the entire dataset.
        If True, the best estimator is refit with the entire dataset after
        the optimization process.
        If False, does not refit, and predict is not available.
    cv : int or cross-validation generator, default = KFold(n_splits=3, shuffle=True)
        The number of folds or cross-validation strategy to be used.
        If int, the cross-validation used is KFold(n_splits=cv, shuffle=True).

    Example
    -------
    Tuning sklearn SVC via grid search

    1. defining the tuned estimator:
    >>> from sklearn.svm import SVC
    >>> from hyperactive.integrations.sklearn import OptCV
    >>> from hyperactive.opt import GridSearch
    >>>
    >>> param_grid = {"kernel": ["linear", "rbf"], "C": [1, 10]}
    >>> tuned_svc = OptCV(SVC(), GridSearch(param_grid))

    2. fitting the tuned estimator:
    >>> from sklearn.datasets import load_iris
    >>> from sklearn.model_selection import train_test_split
    >>> X, y = load_iris(return_X_y=True)
    >>> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    >>>
    >>> tuned_svc.fit(X_train, y_train)
    OptCV(...)
    >>> y_pred = tuned_svc.predict(X_test)

    3. obtaining best parameters and best estimator
    >>> best_params = tuned_svc.best_params_
    >>> best_estimator = tuned_svc.best_estimator_
    """

    _required_parameters = ["estimator", "optimizer"]

    def __init__(
        self,
        estimator,
        optimizer,
        *,
        scoring: Union[Callable, str, None] = None,
        refit: bool = True,
        cv=None,
    ):
        super().__init__()

        self.estimator = estimator
        self.optimizer = optimizer
        self.scoring = scoring
        self.refit = refit
        self.cv = cv

    def _refit(self, X, y=None, **fit_params):
        self.best_estimator_ = clone(self.estimator).set_params(
            **clone(self.best_params_, safe=False)
        )

        self.best_estimator_.fit(X, y, **fit_params)
        return self

    def _check_data(self, X, y):
        X, y = indexable(X, y)
        if hasattr(self, "_validate_data"):
            validate_data = self._validate_data
        else:
            from sklearn.utils.validation import validate_data

        return validate_data(X, y)

    @Checks.verify_fit
    def fit(self, X, y, **fit_params):
        """Fit the model.

        Parameters
        ----------
        X : {array-like, sparse matrix} of shape (n_samples, n_features)
            Training data.

        y : array-like of shape (n_samples,) or (n_samples, n_targets)
            Target values. Will be cast to X's dtype if necessary.

        Returns
        -------
        self : object
            Fitted Estimator.
        """

        X, y = self._check_data(X, y)

        fit_params = _check_method_params(X, params=fit_params)

        experiment = SklearnCvExperiment(
            estimator=self.estimator,
            scoring=self.scoring,
            cv=self.cv,
            X=X,
            y=y,
        )
        self.scorer_ = experiment.scorer_

        optimizer = self.optimizer.clone()
        optimizer.set_params(experiment=experiment)
        best_params = optimizer.run()

        self.best_params_ = best_params
        self.best_estimator_ = clone(self.estimator).set_params(**best_params)

        if self.refit:
            self._refit(X, y, **fit_params)

        return self

    def score(self, X, y=None, **params):
        """Return the score on the given data, if the estimator has been refit.

        This uses the score defined by ``scoring`` where provided, and the
        ``best_estimator_.score`` method otherwise.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            Input data, where `n_samples` is the number of samples and
            `n_features` is the number of features.

        y : array-like of shape (n_samples, n_output) \
            or (n_samples,), default=None
            Target relative to X for classification or regression;
            None for unsupervised learning.

        **params : dict
            Parameters to be passed to the underlying scorer(s).

        Returns
        -------
        score : float
            The score defined by ``scoring`` if provided, and the
            ``best_estimator_.score`` method otherwise.
        """
        return self.scorer_(self.best_estimator_, X, y, **params)

    @property
    def fit_successful(self):
        self._fit_successful