def run_roar(python_path, w_dir, n_iter=5, input_file='../rawAllx1000.json', seeds=[1], task_ids=None, max_tries=10): from smac.configspace import ConfigurationSpace from ConfigSpace.hyperparameters import UniformIntegerHyperparameter from smac.scenario.scenario import Scenario from smac.facade.roar_facade import ROAR def test_func(cutoff): cutoff = cutoff.get('x1') print(cutoff) result = find_cut_off.main(python_path=python_path, w_dir=w_dir, iter=n_iter, input_file=input_file, cutoffs=[cutoff], seeds=seeds, task_ids=task_ids) cleaned = [x[1] for x in result if 0.0 < x[1] < 1.0] mean = np.mean(cleaned) if cleaned else 0.0 mean = mean if mean != 1.0 else 0.0 return 1.0 - mean cs = ConfigurationSpace() cutoff_parameter = UniformIntegerHyperparameter('x1', 1, 99, default_value=50) cs.add_hyperparameter(cutoff_parameter) scenario = Scenario({ "run_obj": "quality", # we optimize quality (alternatively runtime) "runcount-limit": max_tries, # maximum function evaluations "cs": cs, # configuration space "deterministic": "true", "abort_on_first_run_crash": "false", }) roar = ROAR(scenario=scenario, tae_runner=test_func, rng=1234) x = roar.optimize() cost = test_func(x) return x, cost, roar
def opt_rosenbrock(): cs = ConfigurationSpace() cs.add_hyperparameter(UniformFloatHyperparameter("x1", -5, 5, default_value=-3)) cs.add_hyperparameter(UniformFloatHyperparameter("x2", -5, 5, default_value=-4)) scenario = Scenario({"run_obj": "quality", # we optimize quality (alternatively runtime) "runcount-limit": 50, # maximum function evaluations "cs": cs, # configuration space "deterministic": "true", "intensification_percentage": 0.000000001 }) roar = ROAR(scenario=scenario, rng=np.random.RandomState(42), tae_runner=rosenbrock_2d) incumbent = roar.optimize() return incumbent, roar.scenario.output_dir
'instance_order': 'shuffle_once' } # To optimize, we pass the function to the SMAC-object smac = ROAR(scenario=scenario, rng=np.random.RandomState(42), tae_runner=mlp_from_cfg, intensifier=SuccessiveHalving, intensifier_kwargs=intensifier_kwargs, initial_design=RandomConfigurations, n_jobs=4) # Example call of the function with default values # It returns: Status, Cost, Runtime, Additional Infos def_value = smac.get_tae_runner().run( config=cs.get_default_configuration(), instance='1', budget=25, seed=0)[1] print("Value for default configuration: %.4f" % def_value) # Start optimization try: incumbent = smac.optimize() finally: incumbent = smac.solver.incumbent inc_value = smac.get_tae_runner().run(config=incumbent, instance='1', budget=25, seed=0)[1] print("Optimized Value: %.4f" % inc_value)
def main_cli( self, commandline_arguments: typing.Optional[typing.List[str]] = None ) -> 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:\t%(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) restore_state = main_args_.restore_state rh, stats, traj_list_aclib, traj_list_old = self.restore_state( scen, restore_state) 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: rh = RunHistory() 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, # type: ignore[attr-defined] # noqa F821 ) if main_args_.warmstart_incumbent: initial_configs = [scen.cs.get_default_configuration() ] # type: ignore[attr-defined] # noqa F821 for traj_fn in main_args_.warmstart_incumbent: trajectory = TrajLogger.read_traj_aclib_format( fn=traj_fn, cs=scen.cs, # type: ignore[attr-defined] # noqa F821 ) initial_configs.append(trajectory[-1]["incumbent"]) if main_args_.mode == "SMAC4AC": optimizer = SMAC4AC(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 == "SMAC4HPO": optimizer = SMAC4HPO(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 == "SMAC4BB": optimizer = SMAC4BB(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 == "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)