hyperactive.opt.gfo.hillclimbing.HillClimbing.get_test_params() - Code Metrics - Inspection of "V5 API rework - experimental" - SimonBlanke/Hyperactive - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#110)

unknown

created 2025-05-05 17:47 UTC

HillClimbing.get_test_params() A

↳ Parent: hyperactive.opt.gfo.hillclimbing

Complexity

Conditions

Size

Total Lines	59
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	20
dl	0
loc	59
rs	9.4
c	0
b	0
f	0
cc	1
nop	2

How to fix Long Method

"""Hill climbing optimizer from gfo."""
# copyright: hyperactive developers, MIT License (see LICENSE file)

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_
    """

    _tags = {
        "python_dependencies": ["gradient-free-optimizers>=1.5.0"],
    }

    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
        del search_config["verbose"]
        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_

    @classmethod
    def get_test_params(cls, parameter_set="default"):
        """Return testing parameter settings for the skbase object.

        ``get_test_params`` is a unified interface point to store
        parameter settings for testing purposes. This function is also
        used in ``create_test_instance`` and ``create_test_instances_and_names``
        to construct test instances.

        ``get_test_params`` should return a single ``dict``, or a ``list`` of ``dict``.

        Each ``dict`` is a parameter configuration for testing,
        and can be used to construct an "interesting" test instance.
        A call to ``cls(**params)`` should
        be valid for all dictionaries ``params`` in the return of ``get_test_params``.

        The ``get_test_params`` need not return fixed lists of dictionaries,
        it can also return dynamic or stochastic parameter settings.

        Parameters
        ----------
        parameter_set : str, default="default"
            Name of the set of test parameters to return, for use in tests. If no
            special parameters are defined for a value, will return `"default"` set.

        Returns
        -------
        params : dict or list of dict, default = {}
            Parameters to create testing instances of the class
            Each dict are parameters to construct an "interesting" test instance, i.e.,
            `MyClass(**params)` or `MyClass(**params[i])` creates a valid test instance.
            `create_test_instance` uses the first (or only) dictionary in `params`
        """
        import numpy as np
        from hyperactive.experiment.integrations import SklearnCvExperiment

        sklearn_exp = SklearnCvExperiment.create_test_instance()
        params_sklearn = {
            "experiment": sklearn_exp,
            "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,
        }

        from hyperactive.experiment.toy import Ackley

        ackley_exp = Ackley.create_test_instance()
        params_ackley = {
            "experiment": ackley_exp,
            "search_space": {
                "x0": np.linspace(-5, 5, 10),
                "x1": np.linspace(-5, 5, 10),
            },
            "n_iter": 100,
        }
        
        return [params_sklearn, params_ackley]


1			"""Hill climbing optimizer from gfo."""
2			# copyright: hyperactive developers, MIT License (see LICENSE file)
3
4			from gradient_free_optimizers import HillClimbingOptimizer
5			from hyperactive.base import BaseOptimizer
6			from skbase.utils.stdout_mute import StdoutMute
7
8
9			class HillClimbing(BaseOptimizer):
10			"""Hill climbing optimizer.
11
12			Parameters
13			----------
14			experiment : BaseExperiment, optional
15			The experiment to optimize parameters for.
16			Optional, can be passed later in ``add_search``.
17			random_state : None, int, default=None
18			If None, create a new random state. If int, create a new random state
19			seeded with the value.
20			rand_rest_p : float, default=0.1
21			The probability of a random iteration during the the search process.
22			epsilon : float, default=0.01
23			The step-size for the climbing.
24			distribution : str, default="normal"
25			The type of distribution to sample from.
26			n_neighbours : int, default=10
27			The number of neighbours to sample and evaluate before moving to the best
28			of those neighbours.
29			search_space : dict[str, list]
30			The search space to explore. A dictionary with parameter
31			names as keys and a numpy array as values.
32			Optional, can be passed later in ``add_search``.
33			initialize : dict[str, int], default={"grid": 4, "random": 2, "vertices": 4}
34			The method to generate initial positions. A dictionary with
35			the following key literals and the corresponding value type:
36			{"grid": int, "vertices": int, "random": int, "warm_start": list[dict]}
37			constraints : list[callable], default=[]
38			A list of constraints, where each constraint is a callable.
39			The callable returns `True` or `False` dependend on the input parameters.
40			n_iter : int, default=100
41			The number of iterations to run the optimizer.
42			verbose : bool, default=False
43			If True, print the progress of the optimization process.
44
45			Examples
46			--------
47			Hill climbing applied to scikit-learn parameter tuning:
48
49			1. defining the experiment to optimize:
50			>>> from hyperactive.experiment.integrations import SklearnCvExperiment
51			>>> from sklearn.datasets import load_iris
52			>>> from sklearn.svm import SVC
53			>>>
54			>>> X, y = load_iris(return_X_y=True)
55			>>>
56			>>> sklearn_exp = SklearnCvExperiment(
57			... estimator=SVC(),
58			... X=X,
59			... y=y,
60			... )
61
62			2. setting up the hill climbing optimizer:
63			>>> from hyperactive.opt import HillClimbing
64			>>> import numpy as np
65			>>>
66			>>> hillclimbing_config = {
67			... "search_space": {
68			... "C": np.array([0.01, 0.1, 1, 10]),
69			... "gamma": np.array([0.0001, 0.01, 0.1, 1, 10]),
70			... },
71			... "n_iter": 100,
72			... }
73			>>> hillclimbing = HillClimbing(sklearn_exp, **hillclimbing_config)
74
75			3. running the hill climbing search:
76			>>> best_params = hillclimbing.run()
77
78			Best parameters can also be accessed via the attributes:
79			>>> best_params = hillclimbing.best_params_
80			"""
81
82			_tags = {
83			"python_dependencies": ["gradient-free-optimizers>=1.5.0"],
84			}
85
86			def __init__(
87			self,
88			experiment=None,
89			random_state=None,
90			rand_rest_p=0.1,
91			epsilon=0.01,
92			distribution="normal",
93			n_neighbours=10,
94			search_space=None,
95			initialize=None,
96			constraints=None,
97			n_iter=100,
98			verbose=False,
99			):
100			self.random_state = random_state
101			self.rand_rest_p = rand_rest_p
102			self.epsilon = epsilon
103			self.distribution = distribution
104			self.n_neighbours = n_neighbours
105			self.search_space = search_space
106			self.initialize = initialize
107			self.constraints = constraints
108			self.n_iter = n_iter
109			self.experiment = experiment
110			self.verbose = verbose
111
112			super().__init__()
113
114			if initialize is None:
115			self._initialize = {"grid": 4, "random": 2, "vertices": 4}
116			else:
117			self._initialize = initialize
118
119			def get_search_config(self):
120			"""Get the search configuration.
121
122			Returns
123			-------
124			dict with str keys
125			The search configuration dictionary.
126			"""
127			search_config = super().get_search_config()
128			search_config["initialize"] = self._initialize
129			del search_config["verbose"]
130			return search_config
131
132			def _run(self, experiment, **search_config):
133			"""Run the optimization search process."""
134			n_iter = search_config.pop("n_iter", 100)
135			max_time = search_config.pop("max_time", None)
136
137			hcopt = HillClimbingOptimizer(**search_config)
138
139			with StdoutMute(active=not self.verbose):
140			hcopt.search(
141			objective_function=experiment.score,
142			n_iter=n_iter,
143			max_time=max_time,
144			)
145			self.best_params_ = hcopt.best_para
146
147			return self.best_params_
148
149			@classmethod
150			def get_test_params(cls, parameter_set="default"):
151			"""Return testing parameter settings for the skbase object.
152
153			``get_test_params`` is a unified interface point to store
154			parameter settings for testing purposes. This function is also
155			used in ``create_test_instance`` and ``create_test_instances_and_names``
156			to construct test instances.
157
158			``get_test_params`` should return a single ``dict``, or a ``list`` of ``dict``.
159
160			Each ``dict`` is a parameter configuration for testing,
161			and can be used to construct an "interesting" test instance.
162			A call to ``cls(**params)`` should
163			be valid for all dictionaries ``params`` in the return of ``get_test_params``.
164
165			The ``get_test_params`` need not return fixed lists of dictionaries,
166			it can also return dynamic or stochastic parameter settings.
167
168			Parameters
169			----------
170			parameter_set : str, default="default"
171			Name of the set of test parameters to return, for use in tests. If no
172			special parameters are defined for a value, will return `"default"` set.
173
174			Returns
175			-------
176			params : dict or list of dict, default = {}
177			Parameters to create testing instances of the class
178			Each dict are parameters to construct an "interesting" test instance, i.e.,
179			`MyClass(params)` or `MyClass(params[i])` creates a valid test instance.
180			`create_test_instance` uses the first (or only) dictionary in `params`
181			"""
182			import numpy as np
183			from hyperactive.experiment.integrations import SklearnCvExperiment
184
185			sklearn_exp = SklearnCvExperiment.create_test_instance()
186			params_sklearn = {
187			"experiment": sklearn_exp,
188			"search_space": {
189			"C": np.array([0.01, 0.1, 1, 10]),
190			"gamma": np.array([0.0001, 0.01, 0.1, 1, 10]),
191			},
192			"n_iter": 100,
193			}
194
195			from hyperactive.experiment.toy import Ackley
196
197			ackley_exp = Ackley.create_test_instance()
198			params_ackley = {
199			"experiment": ackley_exp,
200			"search_space": {
201			"x0": np.linspace(-5, 5, 10),
202			"x1": np.linspace(-5, 5, 10),
203			},
204			"n_iter": 100,
205			}
206
207			return [params_sklearn, params_ackley]
208

SimonBlanke / Hyperactive

Pull Request — master (#110)

HillClimbing.get_test_params() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like