smac.tae.serial_runner module

class smac.tae.serial_runner.SerialRunner(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)[source]

Bases: smac.tae.base.BaseRunner

Interface to submit and collect a job in a serial fashion.

It dictates what a worker should do to convert a configuration/instance/seed to a result.

This class is expected to be extended via the implementation of a run() method for the desired task.

  • ta (list) – target algorithm command line as list of arguments

  • stats (Stats()) – stats object to collect statistics about runtime and so on

  • run_obj (str) – run objective of SMAC

  • par_factor (int) – penalization factor

  • cost_for_crash (float) – cost that is used in case of crashed runs (including runs that returned NaN or inf)

  • abort_on_first_run_crash (bool) – if true and first run crashes, raise FirstRunCrashedException

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

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 are returned.


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

  • a submitted configuration

num_workers() → int[source]

Total number of workers available.

pending_runs() → bool[source]

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.

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][source]

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

submit_run(run_info: smac.runhistory.runhistory.RunInfo) → None[source]

This function submits a run_info object in a serial fashion.

As there is a single worker for this task, this interface can be considered a wrapper over the run() method.

Both result/exceptions can be completely determined in this step so both lists are properly filled.


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

wait() → None[source]

SMBO/intensifier might need to wait for runs to finish before making a decision. For serial runs, no wait is needed as the result is immediately available.