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)