def _main_cli(self):
"""Main function of SMAC for CLI interface
Returns
-------
instance
optimizer
"""
self.logger.info("SMAC call: %s" % (" ".join(sys.argv)))
cmd_reader = CMDReader()
args, _ = cmd_reader.read_cmd()
root_logger = logging.getLogger()
root_logger.setLevel(args.verbose_level)
logger_handler = logging.StreamHandler(stream=sys.stdout)
if root_logger.level >= logging.INFO:
formatter = logging.Formatter("%(levelname)s:\t%(message)s")
else:
formatter = logging.Formatter(
"%(asctime)s:%(levelname)s:%(name)s:%(message)s",
"%Y-%m-%d %H:%M:%S")
logger_handler.setFormatter(formatter)
root_logger.addHandler(logger_handler)
# remove default handler
root_logger.removeHandler(root_logger.handlers[0])
# Create defaults
rh = None
initial_configs = None
stats = None
incumbent = None
# Create scenario-object
scen = Scenario(args.scenario_file, [])
if args.mode == "SMAC":
optimizer = SMAC(scenario=scen,
rng=np.random.RandomState(args.seed),
runhistory=rh,
initial_configurations=initial_configs,
stats=stats,
restore_incumbent=incumbent,
run_id=args.seed)
elif args.mode == "ROAR":
optimizer = ROAR(scenario=scen,
rng=np.random.RandomState(args.seed),
runhistory=rh,
initial_configurations=initial_configs,
run_id=args.seed)
elif args.mode == "EPILS":
optimizer = EPILS(scenario=scen,
rng=np.random.RandomState(args.seed),
runhistory=rh,
initial_configurations=initial_configs,
run_id=args.seed)
else:
optimizer = None
return optimizer
class CMDReaderTest(unittest.TestCase):
def setUp(self):
logging.basicConfig()
self.logger = logging.getLogger(self.__module__ + "." + self.__class__.__name__)
self.logger.setLevel(logging.DEBUG)
self.cr = CMDReader()
self.current_dir = os.getcwd()
base_directory = os.path.split(__file__)[0]
base_directory = os.path.abspath(os.path.join(base_directory, '..',
'..', '..'))
os.chdir(base_directory)
def tearDown(self):
os.chdir(self.current_dir)
def test_check_args_exception(self): # Tests if the Exception is correctly raised
targs = TestArgs('.', 1234, 2, 'DEBUG')
with self.assertRaises(SystemExit):
self.cr.read_cmd(targs.cmdline())
def test_check_args(self): # Tests if no Exception is raised
targs = TestArgs('test/test_files/scenario_test/scenario.txt', 1234, 2, 'DEBUG')
self.cr.read_cmd(targs.cmdline())
def test_doc_files(self):
self.cr.write_main_options_to_doc(path="test.rst")
self.cr.write_smac_options_to_doc(path="test.rst")
self.cr.write_scenario_options_to_doc(path="test.rst")
os.remove("./test.rst")
class CMDReaderTest(unittest.TestCase):
def setUp(self):
logging.basicConfig()
self.logger = logging.getLogger(self.__module__ + "." +
self.__class__.__name__)
self.logger.setLevel(logging.DEBUG)
self.cr = CMDReader()
self.current_dir = os.getcwd()
base_directory = os.path.split(__file__)[0]
base_directory = os.path.abspath(
os.path.join(base_directory, '..', '..', '..'))
os.chdir(base_directory)
def tearDown(self):
os.chdir(self.current_dir)
def test_check_args_exception(
self): # Tests if the Exception is correctly raised
targs = TestArgs('.', 1234, 2, 'DEBUG')
with self.assertRaises(ValueError):
self.cr._check_args(targs)
def test_check_args(self): # Tests if no Exception is raised
targs = TestArgs('test/test_files/scenario_test/scenario.txt', 1234, 2,
'DEBUG')
self.cr._check_args(targs)
def main_cli(self):
'''
main function of SMAC for CLI interface
'''
cmd_reader = CMDReader()
args_, misc_args = cmd_reader.read_cmd()
logging.basicConfig(level=args_.verbose_level)
root_logger = logging.getLogger()
root_logger.setLevel(args_.verbose_level)
scen = Scenario(args_.scenario_file, misc_args)
try:
smbo = SMBO(scenario=scen, rng=np.random.RandomState(args_.seed))
smbo.run(max_iters=args_.max_iterations)
finally:
smbo.stats.print_stats()
self.logger.info("Final Incumbent: %s" % (smbo.incumbent))
smbo.runhistory.save_json(
fn=os.path.join(scen.output_dir, "runhistory.json"))
def setUp(self):
logging.basicConfig()
self.logger = logging.getLogger(self.__module__ + "." + self.__class__.__name__)
self.logger.setLevel(logging.DEBUG)
self.cr = CMDReader()
self.current_dir = os.getcwd()
base_directory = os.path.split(__file__)[0]
base_directory = os.path.abspath(os.path.join(base_directory, '..',
'..', '..'))
os.chdir(base_directory)
def main_cli(self):
'''
main function of SMAC for CLI interface
'''
cmd_reader = CMDReader()
args_, misc_args = cmd_reader.read_cmd()
logging.basicConfig(level=args_.verbose_level)
root_logger = logging.getLogger()
root_logger.setLevel(args_.verbose_level)
scen = Scenario(args_.scenario_file, misc_args)
rh = None
if args_.warmstart_runhistory:
aggregate_func = average_cost
rh = RunHistory(aggregate_func=aggregate_func)
scen, rh = merge_foreign_data_from_file(
scenario=scen,
runhistory=rh,
in_scenario_fn_list=args_.warmstart_scenario,
in_runhistory_fn_list=args_.warmstart_runhistory,
cs=scen.cs,
aggregate_func=aggregate_func)
initial_configs = None
if args_.warmstart_incumbent:
initial_configs = [scen.cs.get_default_configuration()]
for traj_fn in args_.warmstart_incumbent:
trajectory = TrajLogger.read_traj_aclib_format(fn=traj_fn,
cs=scen.cs)
initial_configs.append(trajectory[-1]["incumbent"])
if args_.modus == "SMAC":
optimizer = SMAC(scenario=scen,
rng=np.random.RandomState(args_.seed),
runhistory=rh,
initial_configurations=initial_configs)
elif args_.modus == "ROAR":
optimizer = ROAR(scenario=scen,
rng=np.random.RandomState(args_.seed),
runhistory=rh,
initial_configurations=initial_configs)
try:
optimizer.optimize()
finally:
# ensure that the runhistory is always dumped in the end
if scen.output_dir is not None:
optimizer.solver.runhistory.save_json(
fn=os.path.join(scen.output_dir, "runhistory.json"))
def main_cli(self):
'''
main function of SMAC for CLI interface
'''
self.logger.info("SMAC call: %s" % (" ".join(sys.argv)))
cmd_reader = CMDReader()
args_, misc_args = cmd_reader.read_cmd()
logging.basicConfig(level=args_.verbose_level)
root_logger = logging.getLogger()
root_logger.setLevel(args_.verbose_level)
scen = Scenario(args_.scenario_file, misc_args, run_id=args_.seed)
rh = None
if args_.warmstart_runhistory:
aggregate_func = average_cost
rh = RunHistory(aggregate_func=aggregate_func)
scen, rh = merge_foreign_data_from_file(
scenario=scen,
runhistory=rh,
in_scenario_fn_list=args_.warmstart_scenario,
in_runhistory_fn_list=args_.warmstart_runhistory,
cs=scen.cs,
aggregate_func=aggregate_func)
initial_configs = None
if args_.warmstart_incumbent:
initial_configs = [scen.cs.get_default_configuration()]
for traj_fn in args_.warmstart_incumbent:
trajectory = TrajLogger.read_traj_aclib_format(fn=traj_fn,
cs=scen.cs)
initial_configs.append(trajectory[-1]["incumbent"])
if args_.modus == "SMAC":
optimizer = SMAC(scenario=scen,
rng=np.random.RandomState(args_.seed),
runhistory=rh,
initial_configurations=initial_configs)
elif args_.modus == "ROAR":
optimizer = ROAR(scenario=scen,
rng=np.random.RandomState(args_.seed),
runhistory=rh,
initial_configurations=initial_configs)
try:
optimizer.optimize()
except (TAEAbortException, FirstRunCrashedException) as err:
self.logger.error(err)
def __init__(
self,
scenario: Union[str, Dict, None] = None,
cmd_options: Optional[Dict] = None,
):
self.logger = logging.getLogger(self.__module__ + '.' +
self.__class__.__name__)
self.PCA_DIM = 7
self.in_reader = InputReader()
self.out_writer = OutputWriter()
self.output_dir_for_this_run = None # type: Optional[str]
self._arguments = {} # type: Dict[str, Any]
self._arguments.update(CMDReader().scen_cmd_actions)
if scenario is None:
scenario = {}
if isinstance(scenario, str):
scenario_fn = scenario
scenario = {}
if cmd_options:
scenario.update(cmd_options)
cmd_reader = CMDReader()
self.logger.info("Reading scenario file: %s", scenario_fn)
smac_args_, scen_args_ = cmd_reader.read_smac_scenario_dict_cmd(
scenario, scenario_fn)
scenario = {}
scenario.update(vars(smac_args_))
scenario.update(vars(scen_args_))
elif isinstance(scenario, dict):
scenario = copy.copy(scenario)
if cmd_options:
scenario.update(cmd_options)
cmd_reader = CMDReader()
smac_args_, scen_args_ = cmd_reader.read_smac_scenario_dict_cmd(
scenario)
scenario = {}
scenario.update(vars(smac_args_))
scenario.update(vars(scen_args_))
else:
raise TypeError(
"Wrong type of scenario (str or dict are supported)")
for arg_name, arg_value in scenario.items():
setattr(self, arg_name, arg_value)
self._transform_arguments()
self.logger.debug("SMAC and Scenario Options:")
if cmd_options:
for arg_name, arg_value in cmd_options.items():
if isinstance(arg_value, (int, str, float)):
self.logger.debug("%s = %s" % (arg_name, arg_value))
def __init__(self, scenario=None, cmd_options: dict = None):
""" Creates a scenario-object. The output_dir will be
"output_dir/run_id/" and if that exists already, the old folder and its
content will be moved (without any checks on whether it's still used by
another process) to "output_dir/run_id.OLD". If that exists, ".OLD"s
will be appended until possible.
Parameters
----------
scenario : str or dict or None
If str, it will be interpreted as to a path a scenario file
If dict, it will be directly to get all scenario related information
If None, only cmd_options will be used
cmd_options : dict
Options from parsed command line arguments
"""
self.logger = logging.getLogger(self.__module__ + '.' +
self.__class__.__name__)
self.PCA_DIM = 7
self.in_reader = InputReader()
self.out_writer = OutputWriter()
self.output_dir_for_this_run = None
self._arguments = {}
self._arguments.update(CMDReader().scen_cmd_actions)
if scenario is None:
scenario = {}
if isinstance(scenario, str):
scenario_fn = scenario
scenario = {}
if cmd_options:
scenario.update(cmd_options)
cmd_reader = CMDReader()
self.logger.info("Reading scenario file: %s", scenario_fn)
smac_args_, scen_args_ = cmd_reader.read_smac_scenario_dict_cmd(
scenario, scenario_fn)
scenario = {}
scenario.update(vars(smac_args_))
scenario.update(vars(scen_args_))
elif isinstance(scenario, dict):
scenario = copy.copy(scenario)
if cmd_options:
scenario.update(cmd_options)
cmd_reader = CMDReader()
smac_args_, scen_args_ = cmd_reader.read_smac_scenario_dict_cmd(
scenario)
scenario = {}
scenario.update(vars(smac_args_))
scenario.update(vars(scen_args_))
else:
raise TypeError(
"Wrong type of scenario (str or dict are supported)")
for arg_name, arg_value in scenario.items():
setattr(self, arg_name, arg_value)
self._transform_arguments()
self.logger.debug("SMAC and Scenario Options:")
if cmd_options:
for arg_name, arg_value in cmd_options.items():
if isinstance(arg_value, (int, str, float)):
self.logger.debug("%s = %s" % (arg_name, arg_value))
def main_cli(self, commandline_arguments: typing.List[str] = None):
"""Main function of SMAC for CLI interface"""
self.logger.info("SMAC call: %s" % (" ".join(sys.argv)))
cmd_reader = CMDReader()
kwargs = {}
if commandline_arguments:
kwargs['commandline_arguments'] = commandline_arguments
main_args_, smac_args_, scen_args_ = cmd_reader.read_cmd(**kwargs)
root_logger = logging.getLogger()
root_logger.setLevel(main_args_.verbose_level)
logger_handler = logging.StreamHandler(stream=sys.stdout)
if root_logger.level >= logging.INFO:
formatter = logging.Formatter("%(levelname)s:\t%(message)s")
else:
formatter = logging.Formatter(
"%(asctime)s:%(levelname)s:%(name)s:%(message)s",
"%Y-%m-%d %H:%M:%S")
logger_handler.setFormatter(formatter)
root_logger.addHandler(logger_handler)
# remove default handler
if len(root_logger.handlers) > 1:
root_logger.removeHandler(root_logger.handlers[0])
# Create defaults
rh = None
initial_configs = None
stats = None
incumbent = None
# Create scenario-object
scenario = {}
scenario.update(vars(smac_args_))
scenario.update(vars(scen_args_))
scen = Scenario(scenario=scenario)
# Restore state
if main_args_.restore_state:
root_logger.debug("Restoring state from %s...",
main_args_.restore_state)
rh, stats, traj_list_aclib, traj_list_old = self.restore_state(
scen, main_args_)
scen.output_dir_for_this_run = create_output_directory(
scen,
main_args_.seed,
root_logger,
)
scen.write()
incumbent = self.restore_state_after_output_dir(
scen, stats, traj_list_aclib, traj_list_old)
if main_args_.warmstart_runhistory:
aggregate_func = average_cost
rh = RunHistory(aggregate_func=aggregate_func)
scen, rh = merge_foreign_data_from_file(
scenario=scen,
runhistory=rh,
in_scenario_fn_list=main_args_.warmstart_scenario,
in_runhistory_fn_list=main_args_.warmstart_runhistory,
cs=scen.cs,
aggregate_func=aggregate_func)
if main_args_.warmstart_incumbent:
initial_configs = [scen.cs.get_default_configuration()]
for traj_fn in main_args_.warmstart_incumbent:
trajectory = TrajLogger.read_traj_aclib_format(fn=traj_fn,
cs=scen.cs)
initial_configs.append(trajectory[-1]["incumbent"])
if main_args_.mode == "SMAC":
optimizer = SMAC(scenario=scen,
rng=np.random.RandomState(main_args_.seed),
runhistory=rh,
initial_configurations=initial_configs,
stats=stats,
restore_incumbent=incumbent,
run_id=main_args_.seed)
elif main_args_.mode == "BORF":
optimizer = BORF(scenario=scen,
rng=np.random.RandomState(main_args_.seed),
runhistory=rh,
initial_configurations=initial_configs,
stats=stats,
restore_incumbent=incumbent,
run_id=main_args_.seed)
elif main_args_.mode == "BOGP":
optimizer = BOGP(scenario=scen,
rng=np.random.RandomState(main_args_.seed),
runhistory=rh,
initial_configurations=initial_configs,
stats=stats,
restore_incumbent=incumbent,
run_id=main_args_.seed)
elif main_args_.mode == "ROAR":
optimizer = ROAR(scenario=scen,
rng=np.random.RandomState(main_args_.seed),
runhistory=rh,
initial_configurations=initial_configs,
run_id=main_args_.seed)
elif main_args_.mode == "EPILS":
optimizer = EPILS(scenario=scen,
rng=np.random.RandomState(main_args_.seed),
runhistory=rh,
initial_configurations=initial_configs,
run_id=main_args_.seed)
elif main_args_.mode == "Hydra":
optimizer = Hydra(
scenario=scen,
rng=np.random.RandomState(main_args_.seed),
runhistory=rh,
initial_configurations=initial_configs,
stats=stats,
restore_incumbent=incumbent,
run_id=main_args_.seed,
random_configuration_chooser=main_args_.
random_configuration_chooser,
n_iterations=main_args_.hydra_iterations,
val_set=main_args_.hydra_validation,
incs_per_round=main_args_.hydra_incumbents_per_round,
n_optimizers=main_args_.hydra_n_optimizers)
elif main_args_.mode == "PSMAC":
optimizer = PSMAC(
scenario=scen,
rng=np.random.RandomState(main_args_.seed),
run_id=main_args_.seed,
shared_model=smac_args_.shared_model,
validate=main_args_.psmac_validate,
n_optimizers=main_args_.hydra_n_optimizers,
n_incs=main_args_.hydra_incumbents_per_round,
)
try:
optimizer.optimize()
except (TAEAbortException, FirstRunCrashedException) as err:
self.logger.error(err)
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
# Show init as well as moduledoc
autoclass_content = 'both'
cmd_reader = CMDReader()
cmd_reader.write_main_options_to_doc()
cmd_reader.write_smac_options_to_doc()
cmd_reader.write_scenario_options_to_doc()
# Sphinx-gallery configuration.
sphinx_gallery_conf = {
# disable mini galleries clustered by the used functions
'backreferences_dir': False,
# path to the examples
'examples_dirs': '../examples',
# path where to save gallery generated examples
'gallery_dirs': 'examples',
# compile execute examples in the examples dir
'filename_pattern': '.*example.py$|.*tutorial.py$',
# TODO: fix back/forward references for the examples.
def main_cli(self):
"""Main function of SMAC for CLI interface"""
self.logger.info("SMAC call: %s" % (" ".join(sys.argv)))
cmd_reader = CMDReader()
args_, misc_args = cmd_reader.read_cmd()
root_logger = logging.getLogger()
root_logger.setLevel(args_.verbose_level)
logger_handler = logging.StreamHandler(
stream=sys.stdout)
if root_logger.level >= logging.INFO:
formatter = logging.Formatter(
"%(levelname)s:\t%(message)s")
else:
formatter = logging.Formatter(
"%(asctime)s:%(levelname)s:%(name)s:%(message)s",
"%Y-%m-%d %H:%M:%S")
logger_handler.setFormatter(formatter)
root_logger.addHandler(logger_handler)
# remove default handler
root_logger.removeHandler(root_logger.handlers[0])
scen = Scenario(args_.scenario_file, misc_args,
run_id=args_.seed)
rh = None
if args_.warmstart_runhistory:
aggregate_func = average_cost
rh = RunHistory(aggregate_func=aggregate_func)
scen, rh = merge_foreign_data_from_file(
scenario=scen,
runhistory=rh,
in_scenario_fn_list=args_.warmstart_scenario,
in_runhistory_fn_list=args_.warmstart_runhistory,
cs=scen.cs,
aggregate_func=aggregate_func)
initial_configs = None
if args_.warmstart_incumbent:
initial_configs = [scen.cs.get_default_configuration()]
for traj_fn in args_.warmstart_incumbent:
trajectory = TrajLogger.read_traj_aclib_format(
fn=traj_fn, cs=scen.cs)
initial_configs.append(trajectory[-1]["incumbent"])
if args_.mode == "SMAC":
optimizer = SMAC(
scenario=scen,
rng=np.random.RandomState(args_.seed),
runhistory=rh,
initial_configurations=initial_configs)
elif args_.mode == "ROAR":
optimizer = ROAR(
scenario=scen,
rng=np.random.RandomState(args_.seed),
runhistory=rh,
initial_configurations=initial_configs)
elif args_.mode == "EPILS":
optimizer = EPILS(
scenario=scen,
rng=np.random.RandomState(args_.seed),
runhistory=rh,
initial_configurations=initial_configs)
try:
optimizer.optimize()
except (TAEAbortException, FirstRunCrashedException) as err:
self.logger.error(err)
