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 }) smac = SMAC4AC(scenario=scenario, rng=np.random.RandomState(42), tae_runner=rosenbrock_2d) incumbent = smac.optimize() return incumbent, smac.scenario.output_dir
def test_construct_intensifier(self): class DummyIntensifier(Intensifier): pass rng = np.random.RandomState(42) smbo = SMAC4AC(self.scenario) self.assertIsInstance(smbo.solver.intensifier, Intensifier) self.assertIsNot(smbo.solver.intensifier.rs, rng) smbo = SMAC4AC(self.scenario, rng=rng) self.assertIsInstance(smbo.solver.intensifier, Intensifier) self.assertIs(smbo.solver.intensifier.rs, rng) smbo = SMAC4AC(self.scenario, intensifier_kwargs={"maxR": 987}) self.assertEqual(smbo.solver.intensifier.maxR, 987) smbo = SMAC4AC( self.scenario, intensifier=DummyIntensifier, intensifier_kwargs={"maxR": 987}, ) self.assertIsInstance(smbo.solver.intensifier, DummyIntensifier) self.assertEqual(smbo.solver.intensifier.maxR, 987) dummy_intensifier = DummyIntensifier( stats=None, traj_logger=None, rng=rng, instances=self.scenario.train_insts ) smbo = SMAC4AC(self.scenario, intensifier=dummy_intensifier) self.assertEqual(smbo.solver.intensifier, dummy_intensifier) # Assert that minR, maxR and use_ta_time propagate from scenario to the default intensifier. for scenario_dict in [ {}, { "minR": self.scenario.minR + 1, "maxR": self.scenario.maxR + 1, "use_ta_time": not self.scenario.use_ta_time, }, ]: for k, v in self.scenario_dict_default.items(): if k not in scenario_dict: scenario_dict[k] = v scenario = Scenario(scenario_dict) smac = SMAC4AC(scenario=scenario) self.assertEqual(scenario.minR, smac.solver.intensifier.minR) self.assertEqual(scenario.maxR, smac.solver.intensifier.maxR) self.assertEqual( scenario.use_ta_time, smac.solver.intensifier.use_ta_time_bound )
def test_generate_challenger(self): """ test generate_challenger() """ # test get generator from a list of challengers intensifier = Intensifier(tae_runner=None, stats=self.stats, traj_logger=None, rng=np.random.RandomState(12345), instances=[1], deterministic=True) gen = intensifier._generate_challengers( challengers=[self.config1, self.config2], chooser=None) self.assertEqual(next(gen), self.config1) self.assertEqual(next(gen), self.config2) self.assertRaises(StopIteration, next, gen) # test get generator from a chooser - would return only 1 configuration intensifier = Intensifier(tae_runner=None, stats=self.stats, traj_logger=None, rng=np.random.RandomState(12345), instances=[1], deterministic=True) chooser = SMAC4AC(self.scen, rng=1).solver.epm_chooser gen = intensifier._generate_challengers(challengers=None, chooser=chooser) self.assertEqual(next(gen).get_dictionary(), {'a': 24, 'b': 68}) self.assertRaises(StopIteration, next, gen) # when both are none, raise error with self.assertRaisesRegex(ValueError, "No configurations/chooser provided"): intensifier._generate_challengers(challengers=None, chooser=None)
def test_stop_smbo(self, patch): def target(x): return 5 # should raise an error if abort_on_first_run_crash is True patch.return_value = StatusType.STOP, 0.5, 0.5, {} scen = Scenario({ "cs": test_helpers.get_branin_config_space(), "run_obj": "quality", "output_dir": "data-test_smbo-abort", "abort_on_first_run_crash": True, "deterministic": False, "limit_resources": True, }) self.output_dirs.append(scen.output_dir) smbo = SMAC4AC(scen, tae_runner=target, rng=1) self.assertFalse(smbo.solver._stop) smbo.optimize() self.assertEqual(len(smbo.runhistory.data), 1) # After an optimization, we expect no running instances. self.assertEqual( list(smbo.runhistory.data.values())[0].status, StatusType.STOP) self.assertTrue(smbo.solver._stop)
def test_init_EIPS_as_arguments(self): for objective in ['runtime', 'quality']: self.scenario.run_obj = objective smbo = SMAC4AC( self.scenario, model=UncorrelatedMultiObjectiveRandomForestWithInstances, model_kwargs={ 'target_names': ['a', 'b'], 'rf_kwargs': { 'seed': 1 } }, acquisition_function=EIPS, runhistory2epm=RunHistory2EPM4EIPS, ).solver self.assertIsInstance( smbo.epm_chooser.model, UncorrelatedMultiObjectiveRandomForestWithInstances) self.assertIsInstance(smbo.epm_chooser.acquisition_func, EIPS) self.assertIsInstance( smbo.epm_chooser.acquisition_func.model, UncorrelatedMultiObjectiveRandomForestWithInstances) self.assertIsInstance(smbo.epm_chooser.rh2EPM, RunHistory2EPM4EIPS)
def test_construct_epm(self): rng = np.random.RandomState(42) smbo = SMAC4AC(self.scenario) self.assertIsInstance(smbo.solver.model, RandomForestWithInstances) smbo = SMAC4AC(self.scenario, rng=rng) self.assertIsInstance(smbo.solver.model, RandomForestWithInstances) self.assertEqual(smbo.solver.model.seed, 1935803228) smbo = SMAC4AC(self.scenario, model_kwargs={'seed': 2}) self.assertIsInstance(smbo.solver.model, RandomForestWithInstances) self.assertEqual(smbo.solver.model.seed, 2) smbo = SMAC4AC(self.scenario, model_kwargs={'num_trees': 20}) self.assertIsInstance(smbo.solver.model, RandomForestWithInstances) self.assertEqual(smbo.solver.model.rf_opts.num_trees, 20) smbo = SMAC4AC(self.scenario, model=RandomEPM, model_kwargs={'seed': 2}) self.assertIsInstance(smbo.solver.model, RandomEPM) self.assertEqual(smbo.solver.model.seed, 2) # Check for construction failure on wrong argument with self.assertRaisesRegex(Exception, 'got an unexpected keyword argument'): SMAC4AC(self.scenario, model_kwargs={'dummy': 0.1})
def test_construct_random_configuration_chooser(self): rng = np.random.RandomState(42) smbo = SMAC4AC(self.scenario) self.assertIsInstance(smbo.solver.random_configuration_chooser, ChooserProb) self.assertIsNot(smbo.solver.random_configuration_chooser, rng) smbo = SMAC4AC(self.scenario, rng=rng) self.assertIsInstance(smbo.solver.random_configuration_chooser, ChooserProb) self.assertIs(smbo.solver.random_configuration_chooser.rng, rng) smbo = SMAC4AC(self.scenario, random_configuration_chooser_kwargs={'rng': rng}) self.assertIsInstance(smbo.solver.random_configuration_chooser, ChooserProb) self.assertIs(smbo.solver.random_configuration_chooser.rng, rng) smbo = SMAC4AC(self.scenario, random_configuration_chooser_kwargs={'prob': 0.1}) self.assertIsInstance(smbo.solver.random_configuration_chooser, ChooserProb) self.assertEqual(smbo.solver.random_configuration_chooser.prob, 0.1) smbo = SMAC4AC( self.scenario, random_configuration_chooser=ChooserCosineAnnealing, random_configuration_chooser_kwargs={'prob_max': 1, 'prob_min': 0.1, 'restart_iteration': 10}, ) self.assertIsInstance(smbo.solver.random_configuration_chooser, ChooserCosineAnnealing) # Check for construction failure on wrong argument with self.assertRaisesRegex(Exception, 'got an unexpected keyword argument'): SMAC4AC(self.scenario, random_configuration_chooser_kwargs={'dummy': 0.1})
def optimize(self) -> typing.List[Configuration]: """ Optimizes the algorithm provided in scenario (given in constructor) Returns ------- portfolio : typing.List[Configuration] Portfolio of found configurations """ # Setup output directory self.portfolio = [] portfolio_cost = np.inf if self.output_dir is None: self.top_dir = "hydra-output_%s" % ( datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d_%H:%M:%S_%f')) self.scenario.output_dir = os.path.join( self.top_dir, "psmac3-output_%s" % (datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d_%H:%M:%S_%f'))) self.output_dir = create_output_directory(self.scenario, run_id=self.run_id, logger=self.logger) scen = copy.deepcopy(self.scenario) scen.output_dir_for_this_run = None scen.output_dir = None # parent process SMAC only used for validation purposes self.solver = SMAC4AC(scenario=scen, tae_runner=self._tae, rng=self.rng, run_id=self.run_id, **self.kwargs) for i in range(self.n_iterations): self.logger.info("=" * 120) self.logger.info("Hydra Iteration: %d", (i + 1)) if i == 0: tae = self._tae tae_kwargs = self._tae_kwargs else: tae = ExecuteTARunHydra if self._tae_kwargs: tae_kwargs = self._tae_kwargs else: tae_kwargs = {} tae_kwargs['cost_oracle'] = self.cost_per_inst self.optimizer = PSMAC( scenario=self.scenario, run_id=self.run_id, rng=self.rng, tae=tae, tae_kwargs=tae_kwargs, shared_model=False, validate=True if self.val_set else False, n_optimizers=self.n_optimizers, val_set=self.val_set, n_incs=self. n_optimizers, # return all configurations (unvalidated) **self.kwargs) self.optimizer.output_dir = self.output_dir incs = self.optimizer.optimize() cost_per_conf_v, val_ids, cost_per_conf_e, est_ids = self.optimizer.get_best_incumbents_ids( incs) if self.val_set: to_keep_ids = val_ids[:self.incs_per_round] else: to_keep_ids = est_ids[:self.incs_per_round] config_cost_per_inst = {} incs = incs[to_keep_ids] self.logger.info('Kept incumbents') for inc in incs: self.logger.info(inc) config_cost_per_inst[inc] = cost_per_conf_v[ inc] if self.val_set else cost_per_conf_e[inc] cur_portfolio_cost = self._update_portfolio( incs, config_cost_per_inst) if portfolio_cost <= cur_portfolio_cost: self.logger.info( "No further progress (%f) --- terminate hydra", portfolio_cost) break else: portfolio_cost = cur_portfolio_cost self.logger.info("Current pertfolio cost: %f", portfolio_cost) self.scenario.output_dir = os.path.join( self.top_dir, "psmac3-output_%s" % (datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d_%H:%M:%S_%f'))) self.output_dir = create_output_directory(self.scenario, run_id=self.run_id, logger=self.logger) read(self.rh, os.path.join(self.top_dir, 'psmac3*', 'run_' + str(MAXINT)), self.scenario.cs, self.logger) self.rh.save_json(fn=os.path.join( self.top_dir, 'all_validated_runs_runhistory.json'), save_external=True) with open(os.path.join(self.top_dir, 'portfolio.pkl'), 'wb') as fh: pickle.dump(self.portfolio, fh) self.logger.info("~" * 120) self.logger.info('Resulting Portfolio:') for configuration in self.portfolio: self.logger.info(str(configuration)) self.logger.info("~" * 120) return self.portfolio
def test_init_only_scenario_quality(self): smbo = SMAC4AC(self.scenario).solver self.assertIsInstance(smbo.model, RandomForestWithInstances) self.assertIsInstance(smbo.rh2EPM, RunHistory2EPM4Cost) self.assertIsInstance(smbo.acquisition_func, EI)
__license__ = "3-clause BSD" if "__main__" == __name__: # Initialize scenario, using runcount_limit as budget. original_scenario_dict = { "algo": "python examples/commandline/branin.py", "paramfile": "examples/commandline/branin/configspace.pcs", "run_obj": "quality", "runcount_limit": 25, "deterministic": True, "output_dir": "restore_me", } original_scenario = Scenario(original_scenario_dict) smac = SMAC4AC(scenario=original_scenario, run_id=1) smac.optimize() print("\nBudget exhausted! Starting restoring optimization ...\n") # Now the output is in the folder 'restore_me/run_1' (or whatever run_id has # been passed to the SMAC-object above) old_output_dir = os.path.join(original_scenario.output_dir, "run_1") # We could simply modify the scenario-object, stored in # 'smac.solver.scenario' and start optimization again: # smac.solver.scenario.ta_run_limit = 50 # smac.optimize() # Or, to show the whole process of recovering a SMAC-run from the output
def test_check_random_states(self, patch): patch.return_value = None smac = SMAC4AC() smac.logger = unittest.mock.MagicMock() # Check some properties # Check whether different seeds give different random states _, rng_1 = get_rng(1) _, rng_2 = get_rng(2) self.assertNotEqual(sum(rng_1.get_state()[1] - rng_2.get_state()[1]), 0) # Check whether no seeds gives different random states _, rng_1 = get_rng(logger=smac.logger) self.assertEqual(smac.logger.debug.call_count, 1) _, rng_2 = get_rng(logger=smac.logger) self.assertEqual(smac.logger.debug.call_count, 2) self.assertNotEqual(sum(rng_1.get_state()[1] - rng_2.get_state()[1]), 0) # Check whether the same int seeds give the same random states _, rng_1 = get_rng(1) _, rng_2 = get_rng(1) self.assertEqual(sum(rng_1.get_state()[1] - rng_2.get_state()[1]), 0) # Check all execution paths self.assertRaisesRegex( TypeError, "Argument rng accepts only arguments of type None, int or np.random.RandomState, " "you provided <class 'str'>.", get_rng, rng='ABC', ) self.assertRaisesRegex( TypeError, "Argument run_id accepts only arguments of type None, int, you provided <class 'str'>.", get_rng, run_id='ABC') run_id, rng_1 = get_rng(rng=None, run_id=None, logger=smac.logger) self.assertIsInstance(run_id, int) self.assertIsInstance(rng_1, np.random.RandomState) self.assertEqual(smac.logger.debug.call_count, 3) run_id, rng_1 = get_rng(rng=None, run_id=1, logger=smac.logger) self.assertEqual(run_id, 1) self.assertIsInstance(rng_1, np.random.RandomState) run_id, rng_1 = get_rng(rng=1, run_id=None, logger=smac.logger) self.assertEqual(run_id, 1) self.assertIsInstance(rng_1, np.random.RandomState) run_id, rng_1 = get_rng(rng=1, run_id=1337, logger=smac.logger) self.assertEqual(run_id, 1337) self.assertIsInstance(rng_1, np.random.RandomState) rs = np.random.RandomState(1) run_id, rng_1 = get_rng(rng=rs, run_id=None, logger=smac.logger) self.assertIsInstance(run_id, int) self.assertIs(rng_1, rs) run_id, rng_1 = get_rng(rng=rs, run_id=2505, logger=smac.logger) self.assertEqual(run_id, 2505) self.assertIs(rng_1, rs)
def test_smbo_cs(self): seed = 42 smbo = SMAC4AC(self.scenario, rng=seed).solver cs = smbo._get_acm_cs()
def get_smac_object( scenario_dict, seed, ta, ta_kwargs, backend, metalearning_configurations, ): from smac.facade.smac_ac_facade import SMAC4AC from smac.intensification.successive_halving import SuccessiveHalving from smac.intensification.hyperband import Hyperband from smac.runhistory.runhistory2epm import RunHistory2EPM4LogCost from smac.scenario.scenario import Scenario scenario_dict['input_psmac_dirs'] = backend.get_smac_output_glob( smac_run_id=seed if not scenario_dict['shared-model'] else '*', ) scenario = Scenario(scenario_dict) lock.acquire() try: global CALLBACK_COUNTER if CALLBACK_COUNTER.value == 0: initial_configurations = [ Configuration(configuration_space=scenario.cs, values=member) for member in portfolio.values() ] else: initial_configurations = [ scenario.cs.sample_configuration(size=1) ] CALLBACK_COUNTER.value += 1 finally: lock.release() rh2EPM = RunHistory2EPM4LogCost ta_kwargs['budget_type'] = budget_type if bandit_strategy == 'sh': bandit = SuccessiveHalving elif bandit_strategy == 'hb': bandit = Hyperband else: raise ValueError(bandit_strategy) smac4ac = SMAC4AC( scenario=scenario, rng=seed, runhistory2epm=rh2EPM, tae_runner=ta, tae_runner_kwargs=ta_kwargs, initial_configurations=initial_configurations, run_id=seed, intensifier=bandit, intensifier_kwargs={ 'initial_budget': initial_budget, 'max_budget': 100, 'eta': eta, 'min_chall': 1 }, ) smac4ac.solver.epm_chooser.min_samples_model = int( len(scenario.cs.get_hyperparameters()) / 2) return smac4ac
"'--generate' will generate suitable test-cases using SMAC-optimization \n" "'--cave' will analyze the results of the generate-option using cave \n" "'--clean' will delete previous results \n" "'--firefox' will open all reports in firefox.") if __name__ == '__main__': logging.basicConfig(level=logging.DEBUG) #logging.basicConfig(level=logging.INFO) if len(sys.argv) < 2: print_help() elif sys.argv[1] == '--generate': generate_bohb_data() for scen in get_scenarios(): scenario = Scenario(scen) smac = SMAC4AC(scenario=scenario, rng=np.random.RandomState(42)) smac.optimize() elif sys.argv[1] == '--cave': failed = [] for scen in get_scenarios(): try: folder = [f for f in os.listdir(scen['output_dir']) if f.startswith('run')][0] cave = CAVE([os.path.join(scen['output_dir'], folder)], os.path.join(scen['output_dir'], 'CAVE_RESULT'), ta_exec_dir=['.'], validation_method='validation') cave.analyze({'fANOVA' : False, 'number_quantiles' : 2}) except: raise failed.append(scen['output_dir']) print("Failed: %s" % (str(failed))) elif sys.argv[1] == '--firefox':
def test_update_intensification_percentage(self): """ This test checks the intensification time bound is updated in subsequent iterations as long as num_runs of the intensifier is not reset to zero. """ def target(x): return 5 scen = Scenario( { "cs": test_helpers.get_branin_config_space(), "run_obj": "quality", "output_dir": "data-test_smbo-intensification", "save_instantly": False, "deterministic": False, "limit_resources": True, }, ) self.output_dirs.append(scen.output_dir) solver = SMAC4AC(scen, tae_runner=target, rng=1).solver solver.stats.is_budget_exhausted = unittest.mock.Mock() solver.stats.is_budget_exhausted.side_effect = tuple(([False] * 10) + [True] * 8) solver._get_timebound_for_intensification = unittest.mock.Mock( wraps=solver._get_timebound_for_intensification) class SideEffect: def __init__(self, intensifier, get_next_run): self.intensifier = intensifier self.get_next_run = get_next_run self.counter = 0 def __call__(self, *args, **kwargs): self.counter += 1 if self.counter % 4 == 0: self.intensifier.num_run = 0 return self.get_next_run(*args, **kwargs) solver.intensifier.get_next_run = unittest.mock.Mock( side_effect=SideEffect(solver.intensifier, solver.intensifier.get_next_run)) solver.run() get_timebound_mock = solver._get_timebound_for_intensification self.assertEqual(get_timebound_mock.call_count, 6) self.assertFalse(get_timebound_mock.call_args_list[0][1]["update"]) self.assertFalse(get_timebound_mock.call_args_list[1][1]["update"]) self.assertTrue(get_timebound_mock.call_args_list[2][1]["update"]) self.assertFalse(get_timebound_mock.call_args_list[3][1]["update"]) self.assertTrue(get_timebound_mock.call_args_list[4][1]["update"]) self.assertTrue(get_timebound_mock.call_args_list[5][1]["update"]) self.assertGreater( get_timebound_mock.call_args_list[2][0][0], get_timebound_mock.call_args_list[1][0][0], ) self.assertLess( get_timebound_mock.call_args_list[3][0][0], get_timebound_mock.call_args_list[2][0][0], ) self.assertGreater( get_timebound_mock.call_args_list[4][0][0], get_timebound_mock.call_args_list[3][0][0], ) self.assertGreater( get_timebound_mock.call_args_list[5][0][0], get_timebound_mock.call_args_list[4][0][0], )
logging.basicConfig(level=20) # 10: debug; 20: info scenario = Scenario('scenario.txt') # provide arguments for the intensifier like this intensifier_kwargs = { 'n_seeds': 2, # specify the number of seeds to evaluate for a # non-deterministic target algorithm 'initial_budget': 1, 'eta': 3, 'min_chall': 1 # because successive halving cannot handle min_chall > 1 } smac = SMAC4AC( scenario=scenario, # scenario object intensifier_kwargs= intensifier_kwargs, # arguments for Successive Halving intensifier= SuccessiveHalving, # change intensifier to successive halving by passing the class. run_id=1, # it must implement `AbstractRacer` ) # Start optimization try: incumbent = smac.optimize() finally: incumbent = smac.solver.incumbent print("Optimized configuration %s" % str(incumbent))
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)
def main(self): ''' main method ''' reader = CMDReader() args_, scen_opts = reader.read_cmd() # change log level logging.basicConfig(level=args_.verbose_level) root_logger = logging.getLogger() root_logger.setLevel(args_.verbose_level) scen = Scenario(scen_opts) tae_args = { "ta_bin": args_.binary, "runsolver_bin": args_.runsolver, "memlimit": args_.memlimit, "run_obj": args_.run_obj, "par_factor": args_.par_factor, "misc": args_.tae_args } if args_.tae_class: spec = importlib.util.spec_from_file_location( "tae", args_.tae_class) tae_module = importlib.util.module_from_spec(spec) spec.loader.exec_module(tae_module) tae_class = inspect.getmembers(tae_module, inspect.isclass)[0][1] else: tae_class = ClaspTAE smac = SMAC4AC(scenario=scen, rng=args_.seed, tae_runner=tae_class, tae_runner_kwargs=tae_args) conf = smac.optimize() print("\n") config = extract_configs.parse_options_from_folder( smac.output_dir, add_defaults=False, thread_separator=" || ", hydra=False) matches = re.findall(r"\|\|", config) if len(matches) == 2: print( "Best configuration as a clingo readable command line (folder ; command line):\n" ) print(config.replace("||", "")) elif len(matches) > 2: print( "Best configuration with || as thread separator (folder ; preprocess options || options for thread 1 || thread 2 || ... :\n" ) print(config)
'feats_multivalact.csv', 'train_insts.txt') elif 'feats_multiactmultivalact.csv' in args.inst_feats: scenario_dict['instance_file'] = args.inst_feats.replace( 'feats_multiactmultivalact.csv', 'train_insts.txt') else: raise NotImplementedError scenario_dict['instance_file'] = scenario_dict[ 'instance_file'].replace('test_', '') print(scenario_dict) tae = partial(smac_env_cfg, smac_env=env) scenario = Scenario(scenario_dict) # Optimize the Configuration if not args.valbo: smac = SMAC4AC( scenario=scenario, rng=np.random.RandomState(args.seed), # SMAC4AC tae_runner=tae) incumbent = smac.optimize() print(incumbent) # Validate given SMAC trajectory else: import json as j cs = ConfigurationSpace() try: range_ = env._ms except AttributeError: range_ = env.n_steps for idx in range(range_): cs.add_hyperparameter( CategoricalHyperparameter( '{:d}'.format(idx),