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),
