smac.tae.base module

class smac.tae.base.BaseRunner(ta: Union[List[str], Callable], stats: smac.stats.stats.Stats, run_obj: str = 'runtime', par_factor: int = 1, cost_for_crash: float = 2147483647.0, abort_on_first_run_crash: bool = True)

Bases: abc.ABC

Interface class to handle the execution of SMAC’ configurations.

This interface defines how to interact with the SMBO loop. The complexity of running a configuration as well as handling the results is abstracted to the SMBO via a BaseRunner.

From SMBO perspective, launching a configuration follows a submit/collect scheme as follows:

  1. A run is launched via submit_run()

    1. Submit_run internally calls run_wrapper(), a method that contains common processing functions among different runners, for example, handling capping and stats checking.

    2. A class that implements BaseRunner defines run() which is really the algorithm to translate a RunInfo to a RunValue, i.e. a configuration to an actual result.

  2. A completed run is collected via get_finished_runs(), which returns any finished runs, if any.

  3. This interface also offers the method wait() as a mechanism to make sure we have enough data in the next iteration to make a decision. For example, the intensifier might not be able to select the next challenger until more results are available.

_abc_impl = <_abc._abc_data object>
abstract get_finished_runs() List[Tuple[smac.runhistory.runhistory.RunInfo, smac.runhistory.runhistory.RunValue]]

This method returns any finished configuration, and returns a list with the results of exercising the configurations. This class keeps populating results to self.results until a call to get_finished runs is done. In this case, the self.results list is emptied and all RunValues produced by running run() are returned.


  • List[RunInfo, RunValue] (A list of pais RunInfo/RunValues)

  • a submitted configuration

abstract num_workers() int

Return the active number of workers that will execute tae runs.

abstract pending_runs() bool

Whether or not there are configs still running. Generally if the runner is serial, launching a run instantly returns it’s result. On parallel runners, there might be pending configurations to complete.

abstract run(config: ConfigSpace.configuration_space.Configuration, instance: str, cutoff: Optional[float] = None, seed: int = 12345, budget: Optional[float] = None, instance_specific: str = '0') Tuple[smac.tae.StatusType, float, float, Dict]

Runs target algorithm <self.ta> with configuration <config> on instance <instance> with instance specifics <specifics> for at most <cutoff> seconds and random seed <seed>

This method exemplifies how to defined the run() method

  • config (Configuration) – dictionary param -> value

  • instance (string) – problem instance

  • cutoff (float, optional) – Wallclock time limit of the target algorithm. If no value is provided no limit will be enforced.

  • seed (int) – random seed

  • budget (float, optional) – A positive, real-valued number representing an arbitrary limit to the target algorithm. Handled by the target algorithm internally

  • instance_specific (str) – instance specific information (e.g., domain file or solution)


  • status (enum of StatusType (int)) – {SUCCESS, TIMEOUT, CRASHED, ABORT}

  • cost (float) – cost/regret/quality (float) (None, if not returned by TA)

  • runtime (float) – runtime (None if not returned by TA)

  • additional_info (dict) – all further additional run information

run_wrapper(run_info: smac.runhistory.runhistory.RunInfo) Tuple[smac.runhistory.runhistory.RunInfo, smac.runhistory.runhistory.RunValue]

Wrapper around run() to exec and check the execution of a given config file

This function encapsulates common handling/processing, so that run() implementation is simplified.


run_info (RunInfo) – Object that contains enough information to execute a configuration run in isolation.


  • RunInfo – an object containing the configuration launched

  • RunValue – Contains information about the status/performance of config

abstract submit_run(run_info: smac.runhistory.runhistory.RunInfo) None

This function submits a configuration embedded in a RunInfo object, and uses one of the workers to produce a result (such result will eventually be available on the self.results FIFO).

This interface method will be called by SMBO, with the expectation that a function will be executed by a worker.

What will be executed is dictated by run_info, and “how” will it be executed is decided via the child class that implements a run() method.

Because config submission can be a serial/parallel endeavor, it is expected to be implemented by a child class.


run_info (RunInfo) – An object containing the configuration and the necessary data to run it

abstract wait() None

SMBO/intensifier might need to wait for runs to finish before making a decision. This method waits until 1 run completes