Skip to content

Local search

LocalSearch #

LocalSearch(
    configspace: ConfigurationSpace,
    acquisition_function: (
        AbstractAcquisitionFunction | None
    ) = None,
    challengers: int = 5000,
    max_steps: int | None = None,
    n_steps_plateau_walk: int = 10,
    vectorization_min_obtain: int = 2,
    vectorization_max_obtain: int = 64,
    seed: int = 0,
    n_jobs: int = 1,
    stdev_init: float = 0.05,
    stdev_min: float = 0.005,
    stdev_max: float | None = None,
    upscale_thresh: int = 3,
    downscale_interval: int = 3,
)

Bases: AbstractAcquisitionMaximizer

Implementation of SMAC's local search.

PARAMETER DESCRIPTION
configspace

TYPE: ConfigurationSpace

acquisition_function

TYPE: AbstractAcquisitionFunction DEFAULT: None

challengers

Number of challengers.

TYPE: int, defaults to 5000 DEFAULT: 5000

max_steps

Maximum number of iterations that the local search will perform.

TYPE: int | None DEFAULT: None

n_steps_plateau_walk

Number of steps during a plateau walk before local search terminates.

TYPE: int DEFAULT: 10

vectorization_min_obtain

Minimal number of neighbors to obtain at once for each local search for vectorized calls. Can be tuned to reduce the overhead of SMAC.

TYPE: int, defaults to 2 DEFAULT: 2

vectorization_max_obtain

Maximal number of neighbors to obtain at once for each local search for vectorized calls. Can be tuned to reduce the overhead of SMAC.

TYPE: int, defaults to 64 DEFAULT: 64

seed

TYPE: int, defaults to 0 DEFAULT: 0

n_jobs

Number of parallel workers to use for local search evaluation.

TYPE: int DEFAULT: 1

stdev_init

Initial standard deviation used when sampling neighbors for continuous hyperparameters during local search.

TYPE: float DEFAULT: 0.05

stdev_min

Minimum allowed standard deviation for neighborhood sampling.

TYPE: float DEFAULT: 0.005

stdev_max

Maximum allowed standard deviation for neighborhood sampling. If None, the value is automatically set to stdev_init * 2**downscale_interval.

TYPE: float | None DEFAULT: None

upscale_thresh

Number of consecutive improvements required before increasing the standard deviation.

TYPE: int DEFAULT: 3

downscale_interval

Number of plateau walk steps between reductions of the standard deviation.

TYPE: int DEFAULT: 3

Source code in smac/acquisition/maximizer/local_search.py 
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
def __init__(
    self,
    configspace: ConfigurationSpace,
    acquisition_function: AbstractAcquisitionFunction | None = None,
    challengers: int = 5000,
    max_steps: int | None = None,
    n_steps_plateau_walk: int = 10,
    vectorization_min_obtain: int = 2,
    vectorization_max_obtain: int = 64,
    seed: int = 0,
    n_jobs: int = 1,
    stdev_init: float = 0.05,
    stdev_min: float = 5e-3,
    stdev_max: float | None = None,
    upscale_thresh: int = 3,
    downscale_interval: int = 3,
) -> None:
    super().__init__(
        configspace,
        acquisition_function,
        challengers=challengers,
        seed=seed,
    )

    self._max_steps = max_steps
    self._n_steps_plateau_walk = n_steps_plateau_walk
    self._vectorization_min_obtain = vectorization_min_obtain
    self._vectorization_max_obtain = vectorization_max_obtain
    self.n_jobs = n_jobs
    self._stdev_init = stdev_init
    self._stdev_min = stdev_min
    self._stdev_max = stdev_max
    self._upscale_thresh = upscale_thresh
    self._downscale_interval = downscale_interval

acquisition_function property writable #

acquisition_function: AbstractAcquisitionFunction | None

The acquisition function used for maximization.

maximize #

maximize(
    previous_configs: list[Configuration],
    n_points: int | None = None,
    random_design: AbstractRandomDesign | None = None,
) -> Iterator[Configuration]

Maximize acquisition function using _maximize, implemented by a subclass.

PARAMETER DESCRIPTION
previous_configs

Previous evaluated configurations.

TYPE: list[Configuration]

n_points

Number of points to be sampled & number of configurations to be returned. If n_points is not specified, self._challengers is used. Semantics depend on concrete implementation.

TYPE: int | None DEFAULT: None

random_design

Part of the returned ChallengerList such that we can interleave random configurations by a scheme defined by the random design. The method random_design.next_iteration() is called at the end of this function.

TYPE: AbstractRandomDesign | None DEFAULT: None

RETURNS DESCRIPTION
challengers

An iterable consisting of configurations.

TYPE: Iterator[Configuration]

Source code in smac/acquisition/maximizer/abstract_acquisition_maximizer.py 
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
def maximize(
    self,
    previous_configs: list[Configuration],
    n_points: int | None = None,
    random_design: AbstractRandomDesign | None = None,
) -> Iterator[Configuration]:
    """Maximize acquisition function using `_maximize`, implemented by a subclass.

    Parameters
    ----------
    previous_configs: list[Configuration]
        Previous evaluated configurations.
    n_points: int, defaults to None
        Number of points to be sampled & number of configurations to be returned. If `n_points` is not specified,
        `self._challengers` is used. Semantics depend on concrete implementation.
    random_design: AbstractRandomDesign, defaults to None
        Part of the returned ChallengerList such that we can interleave random configurations
        by a scheme defined by the random design. The method `random_design.next_iteration()`
        is called at the end of this function.

    Returns
    -------
    challengers : Iterator[Configuration]
        An iterable consisting of configurations.
    """
    if n_points is None:
        n_points = self._challengers

    def next_configs_by_acquisition_value() -> list[Configuration]:
        assert n_points is not None
        # since maximize returns a tuple of acquisition value and configuration,
        # and we only need the configuration, we return the second element of the tuple
        # for each element in the list
        return [t[1] for t in self._maximize(previous_configs, n_points)]

    challengers = ChallengerList(
        self._configspace,
        next_configs_by_acquisition_value,
        random_design,
    )

    if random_design is not None:
        random_design.next_iteration()

    return challengers