hyperactive.opt.gfo.hillclimbing

Complexity

Total Complexity

5

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	HillClimbing.__init__()	0	32	2
A	HillClimbing.get_search_config()	0	11	1
A	HillClimbing._run()	0	16	2

"""Hill climbing optimizer from gfo."""

from gradient_free_optimizers import HillClimbingOptimizer
from hyperactive.base import BaseOptimizer
from skbase.utils.stdout_mute import StdoutMute


class HillClimbing(BaseOptimizer):
    """Hill climbing optimizer.

    Parameters
    ----------
    experiment : BaseExperiment, optional
        The experiment to optimize parameters for.
        Optional, can be passed later in ``add_search``.
    random_state : None, int, default=None
        If None, create a new random state. If int, create a new random state
        seeded with the value.
    rand_rest_p : float, default=0.1
        The probability of a random iteration during the the search process.
    epsilon : float, default=0.01
        The step-size for the climbing.
    distribution : str, default="normal"
        The type of distribution to sample from.
    n_neighbours : int, default=10
        The number of neighbours to sample and evaluate before moving to the best
        of those neighbours.
    search_space : dict[str, list]
        The search space to explore. A dictionary with parameter
        names as keys and a numpy array as values.
        Optional, can be passed later in ``add_search``.
    initialize : dict[str, int], default={"grid": 4, "random": 2, "vertices": 4}
        The method to generate initial positions. A dictionary with
        the following key literals and the corresponding value type:
        {"grid": int, "vertices": int, "random": int, "warm_start": list[dict]}
    constraints : list[callable], default=[]
        A list of constraints, where each constraint is a callable.
        The callable returns `True` or `False` dependend on the input parameters.
    n_iter : int, default=100
        The number of iterations to run the optimizer.
    verbose : bool, default=False
        If True, print the progress of the optimization process.

    Examples
    --------
    Hill climbing applied to scikit-learn parameter tuning:

    1. defining the experiment to optimize:
    >>> from hyperactive.experiment.integrations import SklearnCvExperiment
    >>> from sklearn.datasets import load_iris
    >>> from sklearn.svm import SVC
    >>>
    >>> X, y = load_iris(return_X_y=True)
    >>>
    >>> sklearn_exp = SklearnCvExperiment(
    ...     estimator=SVC(),
    ...     X=X,
    ...     y=y,
    ... )

    2. setting up the hill climbing optimizer:
    >>> from hyperactive.opt import HillClimbing
    >>> import numpy as np
    >>> 
    >>> hillclimbing_config = {
    ...     "search_space": {
    ...         "C": np.array([0.01, 0.1, 1, 10]),
    ...         "gamma": np.array([0.0001, 0.01, 0.1, 1, 10]),
    ...     },
    ...     "n_iter": 100,
    ... }
    >>> hillclimbing = HillClimbing(sklearn_exp, **hillclimbing_config)

    3. running the hill climbing search:
    >>> best_params = hillclimbing.run()

    Best parameters can also be accessed via the attributes:
    >>> best_params = hillclimbing.best_params_
    """

    def __init__(
        self,
        experiment=None,
        random_state=None,
        rand_rest_p=0.1,
        epsilon=0.01,
        distribution="normal",
        n_neighbours=10,
        search_space=None,
        initialize=None,
        constraints=None,
        n_iter=100,
        verbose=False,
    ):
        self.random_state = random_state
        self.rand_rest_p = rand_rest_p
        self.epsilon = epsilon
        self.distribution = distribution
        self.n_neighbours = n_neighbours
        self.search_space = search_space
        self.initialize = initialize
        self.constraints = constraints
        self.n_iter = n_iter
        self.experiment = experiment
        self.verbose = verbose

        super().__init__()

        if initialize is None:
            self._initialize = {"grid": 4, "random": 2, "vertices": 4}
        else:
            self._initialize = initialize

    def get_search_config(self):
        """Get the search configuration.

        Returns
        -------
        dict with str keys
            The search configuration dictionary.
        """
        search_config = super().get_search_config()
        search_config["initialize"] = self._initialize
        return search_config

    def _run(self, experiment, **search_config):
        """Run the optimization search process."""
        n_iter = search_config.pop("n_iter", 100)
        max_time = search_config.pop("max_time", None)

        hcopt = HillClimbingOptimizer(**search_config)

        with StdoutMute(active=not self.verbose):
            hcopt.search(
                objective_function=experiment.score,
                n_iter=n_iter,
                max_time=max_time,
            )
        self.best_params_ = hcopt.best_para

        return self.best_params_