def __init__(self,
challengers,
configuration_space,
random_configuration_chooser=ChooserNoCoolDown(2.0)):
self.challengers = challengers
self.configuration_space = configuration_space
self._index = 0
self._iteration = 1 # 1-based to prevent from starting with a random configuration
self.random_configuration_chooser = random_configuration_chooser
def __init__(
self,
challengers: List[Configuration],
configuration_space: ConfigurationSpace,
random_configuration_chooser: Optional[
RandomConfigurationChooser] = ChooserNoCoolDown(2.0),
):
self.challengers = challengers
self.configuration_space = configuration_space
self._index = 0
self._iteration = 1 # 1-based to prevent from starting with a random configuration
self.random_configuration_chooser = random_configuration_chooser
def __init__(
self,
challenger_callback: Callable,
configuration_space: ConfigurationSpace,
random_configuration_chooser: Optional[
RandomConfigurationChooser] = ChooserNoCoolDown(2.0),
):
self.challengers_callback = challenger_callback
self.challengers = None # type: Optional[List[Configuration]]
self.configuration_space = configuration_space
self._index = 0
self._iteration = 1 # 1-based to prevent from starting with a random configuration
self.random_configuration_chooser = random_configuration_chooser
def __init__(self,
scenario: Scenario,
stats: Stats,
runhistory: RunHistory,
runhistory2epm: AbstractRunHistory2EPM,
model: RandomForestWithInstances,
acq_optimizer: AcquisitionFunctionMaximizer,
acquisition_func: AbstractAcquisitionFunction,
rng: np.random.RandomState,
restore_incumbent: Configuration = None,
random_configuration_chooser: typing.
Union[RandomConfigurationChooser] = ChooserNoCoolDown(2.0),
predict_x_best: bool = True,
min_samples_model: int = 1):
self.logger = logging.getLogger(self.__module__ + "." +
self.__class__.__name__)
self.incumbent = restore_incumbent
self.scenario = scenario
self.stats = stats
self.runhistory = runhistory
self.rh2EPM = runhistory2epm
self.model = model
self.acq_optimizer = acq_optimizer
self.acquisition_func = acquisition_func
self.rng = rng
self.random_configuration_chooser = random_configuration_chooser
self._random_search = RandomSearch(
acquisition_func,
self.scenario.cs, # type: ignore[attr-defined] # noqa F821
rng,
)
self.initial_design_configs = [] # type: typing.List[Configuration]
self.predict_x_best = predict_x_best
self.min_samples_model = min_samples_model
self.currently_considered_budgets = [
0.0,
]
def test_no_cool_down(self):
c = ChooserNoCoolDown(rng=np.random.RandomState(), modulus=3.0)
self.assertFalse(c.check(1))
self.assertFalse(c.check(2))
self.assertTrue(c.check(3))
self.assertFalse(c.check(4))
self.assertFalse(c.check(5))
self.assertTrue(c.check(6))
self.assertTrue(c.check(30))
c.next_smbo_iteration()
self.assertFalse(c.check(1))
self.assertFalse(c.check(2))
self.assertTrue(c.check(3))
self.assertFalse(c.check(4))
self.assertFalse(c.check(5))
self.assertTrue(c.check(6))
self.assertTrue(c.check(30))
c = ChooserNoCoolDown(rng=np.random.RandomState(), modulus=1.0)
self.assertTrue(c.check(1))
self.assertTrue(c.check(2))
c.next_smbo_iteration()
self.assertTrue(c.check(1))
self.assertTrue(c.check(2))
def __init__(self,
scenario: Scenario,
stats: Stats,
runhistory: RunHistory,
runhistory2epm: AbstractRunHistory2EPM,
model: RandomForestWithInstances,
acq_optimizer: AcquisitionFunctionMaximizer,
acquisition_func: AbstractAcquisitionFunction,
rng: np.random.RandomState,
restore_incumbent: Configuration = None,
random_configuration_chooser: typing.
Union[RandomConfigurationChooser] = ChooserNoCoolDown(2.0),
predict_x_best: bool = True,
min_samples_model: int = 1):
"""
Interface to train the EPM and generate next configurations
Parameters
----------
scenario: smac.scenario.scenario.Scenario
Scenario object
stats: smac.stats.stats.Stats
statistics object with configuration budgets
runhistory: smac.runhistory.runhistory.RunHistory
runhistory with all runs so far
model: smac.epm.rf_with_instances.RandomForestWithInstances
empirical performance model (right now, we support only
RandomForestWithInstances)
acq_optimizer: smac.optimizer.ei_optimization.AcquisitionFunctionMaximizer
Optimizer of acquisition function.
restore_incumbent: Configuration
incumbent to be used from the start. ONLY used to restore states.
rng: np.random.RandomState
Random number generator
random_configuration_chooser:
Chooser for random configuration -- one of
* ChooserNoCoolDown(modulus)
* ChooserLinearCoolDown(start_modulus, modulus_increment, end_modulus)
predict_x_best: bool
Choose x_best for computing the acquisition function via the model instead of via the observations.
min_samples_model: int
Minimum number of samples to build a model
"""
self.logger = logging.getLogger(self.__module__ + "." +
self.__class__.__name__)
self.incumbent = restore_incumbent
self.scenario = scenario
self.stats = stats
self.runhistory = runhistory
self.rh2EPM = runhistory2epm
self.model = model
self.acq_optimizer = acq_optimizer
self.acquisition_func = acquisition_func
self.rng = rng
self.random_configuration_chooser = random_configuration_chooser
self._random_search = RandomSearch(
acquisition_func,
self.scenario.cs, # type: ignore[attr-defined] # noqa F821
rng,
)
self.initial_design_configs = [] # type: typing.List[Configuration]
self.predict_x_best = predict_x_best
self.min_samples_model = min_samples_model
self.currently_considered_budgets = [
0.0,
]
def __init__(
self,
scenario: Scenario,
stats: Stats,
initial_design: InitialDesign,
runhistory: RunHistory,
runhistory2epm: AbstractRunHistory2EPM,
intensifier: AbstractRacer,
num_run: int,
model: AbstractEPM,
acq_optimizer: AcquisitionFunctionMaximizer,
acquisition_func: AbstractAcquisitionFunction,
rng: np.random.RandomState,
tae_runner: BaseRunner,
restore_incumbent: Configuration = None,
random_configuration_chooser:
RandomConfigurationChooser = ChooserNoCoolDown(2.0),
predict_x_best: bool = True,
min_samples_model: int = 1,
):
self.logger = logging.getLogger(self.__module__ + "." +
self.__class__.__name__)
self.incumbent = restore_incumbent
self.scenario = scenario
self.config_space = scenario.cs # type: ignore[attr-defined] # noqa F821
self.stats = stats
self.initial_design = initial_design
self.runhistory = runhistory
self.intensifier = intensifier
self.num_run = num_run
self.rng = rng
self._min_time = 10**-5
self.tae_runner = tae_runner
self.initial_design_configs = [] # type: typing.List[Configuration]
# TODO: consider if we need an additional EPMChooser for multi-objective optimization
self.epm_chooser = EPMChooser(
scenario=scenario,
stats=stats,
runhistory=runhistory,
runhistory2epm=runhistory2epm,
model=model, # type: ignore
acq_optimizer=acq_optimizer,
acquisition_func=acquisition_func,
rng=rng,
restore_incumbent=restore_incumbent,
random_configuration_chooser=random_configuration_chooser,
predict_x_best=predict_x_best,
min_samples_model=min_samples_model,
)
# Internal variable - if this is set to True it will gracefully stop SMAC
self._stop = False
# Callbacks. All known callbacks have a key. If something does not have a key here, there is
# no callback available.
self._callbacks = {
"_incorporate_run_results": list()
} # type: typing.Dict[str, typing.List[typing.Callable]]
self._callback_to_key = {
IncorporateRunResultCallback: "_incorporate_run_results",
} # type: typing.Dict[typing.Type, str]
def __init__(self,
scenario: Scenario,
stats: Stats,
initial_design: InitialDesign,
runhistory: RunHistory,
runhistory2epm: AbstractRunHistory2EPM,
intensifier: Intensifier,
aggregate_func: callable,
num_run: int,
model: RandomForestWithInstances,
acq_optimizer: AcquisitionFunctionMaximizer,
acquisition_func: AbstractAcquisitionFunction,
rng: np.random.RandomState,
restore_incumbent: Configuration = None,
random_configuration_chooser: typing.Union[
ChooserNoCoolDown,
ChooserLinearCoolDown] = ChooserNoCoolDown(2.0),
predict_incumbent: bool = True):
"""
Interface that contains the main Bayesian optimization loop
Parameters
----------
scenario: smac.scenario.scenario.Scenario
Scenario object
stats: Stats
statistics object with configuration budgets
initial_design: InitialDesign
initial sampling design
runhistory: RunHistory
runhistory with all runs so far
runhistory2epm : AbstractRunHistory2EPM
Object that implements the AbstractRunHistory2EPM to convert runhistory
data into EPM data
intensifier: Intensifier
intensification of new challengers against incumbent configuration
(probably with some kind of racing on the instances)
aggregate_func: callable
how to aggregate the runs in the runhistory to get the performance of a
configuration
num_run: int
id of this run (used for pSMAC)
model: RandomForestWithInstances
empirical performance model (right now, we support only
RandomForestWithInstances)
acq_optimizer: AcquisitionFunctionMaximizer
Optimizer of acquisition function.
acquisition_function : AcquisitionFunction
Object that implements the AbstractAcquisitionFunction (i.e., infill
criterion for acq_optimizer)
restore_incumbent: Configuration
incumbent to be used from the start. ONLY used to restore states.
rng: np.random.RandomState
Random number generator
random_configuration_chooser
Chooser for random configuration -- one of
* ChooserNoCoolDown(modulus)
* ChooserLinearCoolDown(start_modulus, modulus_increment, end_modulus)
predict_incumbent: bool
Use predicted performance of incumbent instead of observed performance
"""
self.logger = logging.getLogger(self.__module__ + "." +
self.__class__.__name__)
self.incumbent = restore_incumbent
self.scenario = scenario
self.config_space = scenario.cs
self.stats = stats
self.initial_design = initial_design
self.runhistory = runhistory
self.rh2EPM = runhistory2epm
self.intensifier = intensifier
self.aggregate_func = aggregate_func
self.num_run = num_run
self.model = model
self.acq_optimizer = acq_optimizer
self.acquisition_func = acquisition_func
self.rng = rng
self.random_configuration_chooser = random_configuration_chooser
self._random_search = RandomSearch(acquisition_func, self.config_space,
rng)
self.predict_incumbent = predict_incumbent
def __init__(self,
scenario: Scenario,
stats: Stats,
initial_design: InitialDesign,
runhistory: RunHistory,
runhistory2epm: AbstractRunHistory2EPM,
intensifier: AbstractRacer,
num_run: int,
model: RandomForestWithInstances,
acq_optimizer: AcquisitionFunctionMaximizer,
acquisition_func: AbstractAcquisitionFunction,
rng: np.random.RandomState,
tae_runner: BaseRunner,
restore_incumbent: Configuration = None,
random_configuration_chooser: typing.
Union[RandomConfigurationChooser] = ChooserNoCoolDown(2.0),
predict_x_best: bool = True,
min_samples_model: int = 1):
"""
Interface that contains the main Bayesian optimization loop
Parameters
----------
scenario: smac.scenario.scenario.Scenario
Scenario object
stats: Stats
statistics object with configuration budgets
initial_design: InitialDesign
initial sampling design
runhistory: RunHistory
runhistory with all runs so far
runhistory2epm : AbstractRunHistory2EPM
Object that implements the AbstractRunHistory2EPM to convert runhistory
data into EPM data
intensifier: Intensifier
intensification of new challengers against incumbent configuration
(probably with some kind of racing on the instances)
num_run: int
id of this run (used for pSMAC)
model: RandomForestWithInstances
empirical performance model (right now, we support only RandomForestWithInstances)
acq_optimizer: AcquisitionFunctionMaximizer
Optimizer of acquisition function.
acquisition_func : AcquisitionFunction
Object that implements the AbstractAcquisitionFunction (i.e., infill criterion for acq_optimizer)
restore_incumbent: Configuration
incumbent to be used from the start. ONLY used to restore states.
rng: np.random.RandomState
Random number generator
tae_runner : smac.tae.base.BaseRunner Object
target algorithm run executor
random_configuration_chooser
Chooser for random configuration -- one of
* ChooserNoCoolDown(modulus)
* ChooserLinearCoolDown(start_modulus, modulus_increment, end_modulus)
predict_x_best: bool
Choose x_best for computing the acquisition function via the model instead of via the observations.
min_samples_model: int
Minimum number of samples to build a model.
"""
self.logger = logging.getLogger(self.__module__ + "." +
self.__class__.__name__)
self.incumbent = restore_incumbent
self.scenario = scenario
self.config_space = scenario.cs # type: ignore[attr-defined] # noqa F821
self.stats = stats
self.initial_design = initial_design
self.runhistory = runhistory
self.intensifier = intensifier
self.num_run = num_run
self.rng = rng
self._min_time = 10**-5
self.tae_runner = tae_runner
self.initial_design_configs = [] # type: typing.List[Configuration]
# initialize the chooser to get configurations from the EPM
self.epm_chooser = EPMChooser(
scenario=scenario,
stats=stats,
runhistory=runhistory,
runhistory2epm=runhistory2epm,
model=model,
acq_optimizer=acq_optimizer,
acquisition_func=acquisition_func,
rng=rng,
restore_incumbent=restore_incumbent,
random_configuration_chooser=random_configuration_chooser,
predict_x_best=predict_x_best,
min_samples_model=min_samples_model)
# Internal variable - if this is set to True it will gracefully stop SMAC
self._stop = False
# Callbacks. All known callbacks have a key. If something does not have a key here, there is
# no callback available.
self._callbacks = {
'_incorporate_run_results': list()
} # type: typing.Dict[str, typing.List[typing.Callable]]
self._callback_to_key = {
IncorporateRunResultCallback: '_incorporate_run_results',
} # type: typing.Dict[typing.Type, str]
def __init__(self,
scenario: Scenario,
stats: Stats,
initial_design: InitialDesign,
runhistory: RunHistory,
runhistory2epm: AbstractRunHistory2EPM,
intensifier: AbstractRacer,
num_run: int,
model: RandomForestWithInstances,
acq_optimizer: AcquisitionFunctionMaximizer,
acquisition_func: AbstractAcquisitionFunction,
rng: np.random.RandomState,
restore_incumbent: Configuration = None,
random_configuration_chooser: typing.Union[RandomConfigurationChooser] = ChooserNoCoolDown(2.0),
predict_x_best: bool = True,
min_samples_model: int = 1):
"""
Interface that contains the main Bayesian optimization loop
Parameters
----------
scenario: smac.scenario.scenario.Scenario
Scenario object
stats: Stats
statistics object with configuration budgets
initial_design: InitialDesign
initial sampling design
runhistory: RunHistory
runhistory with all runs so far
runhistory2epm : AbstractRunHistory2EPM
Object that implements the AbstractRunHistory2EPM to convert runhistory
data into EPM data
intensifier: Intensifier
intensification of new challengers against incumbent configuration
(probably with some kind of racing on the instances)
num_run: int
id of this run (used for pSMAC)
model: RandomForestWithInstances
empirical performance model (right now, we support only RandomForestWithInstances)
acq_optimizer: AcquisitionFunctionMaximizer
Optimizer of acquisition function.
acquisition_func : AcquisitionFunction
Object that implements the AbstractAcquisitionFunction (i.e., infill criterion for acq_optimizer)
restore_incumbent: Configuration
incumbent to be used from the start. ONLY used to restore states.
rng: np.random.RandomState
Random number generator
random_configuration_chooser
Chooser for random configuration -- one of
* ChooserNoCoolDown(modulus)
* ChooserLinearCoolDown(start_modulus, modulus_increment, end_modulus)
predict_x_best: bool
Choose x_best for computing the acquisition function via the model instead of via the observations.
min_samples_model: int
- Minimum number of samples to build a model
"""
self.logger = logging.getLogger(
self.__module__ + "." + self.__class__.__name__)
self.incumbent = restore_incumbent
self.scenario = scenario
self.config_space = scenario.cs # type: ignore[attr-defined] # noqa F821
self.stats = stats
self.initial_design = initial_design
self.runhistory = runhistory
self.intensifier = intensifier
self.num_run = num_run
self.rng = rng
self.initial_design_configs = [] # type: typing.List[Configuration]
# initialize the chooser to get configurations from the EPM
self.epm_chooser = EPMChooser(scenario=scenario,
stats=stats,
runhistory=runhistory,
runhistory2epm=runhistory2epm,
model=model,
acq_optimizer=acq_optimizer,
acquisition_func=acquisition_func,
rng=rng,
restore_incumbent=restore_incumbent,
random_configuration_chooser=random_configuration_chooser,
predict_x_best=predict_x_best,
min_samples_model=min_samples_model)