def prepare(self, pipeline_elements: list, maximize_metric: bool): self.hyperparameter_list = [] # build space self.space = ConfigurationSpace() for element in pipeline_elements: # check if Switch object if isinstance(element, Switch): algorithm_options = { } # mapping algorithm name with their child hyper params for algo in element.elements: algo_params = [] # hyper params corresponding to "algo" for name, value in algo.hyperparameters.items(): smac_param = self._convert_PHOTON_to_smac_space( value, (element.name + "__" + name)) # or element.name__algo.name__name ??? algo_params.append(smac_param) algorithm_options[(element.name + "__" + algo.name)] = algo_params algos = CategoricalHyperparameter( name=element.name + "__algos", choices=algorithm_options.keys()) self.space.add_hyperparameter(algos) for algo, params in algorithm_options.items(): for param in params: cond = InCondition(child=param, parent=algos, values=[algo]) self.space.add_hyperparameter(param) self.space.add_condition(cond) else: for name, value in element.hyperparameters.items(): smac_param = self._convert_PHOTON_to_smac_space( value, name) if smac_param is not None: self.space.add_hyperparameter(smac_param) self.scenario = Scenario({ "run_obj": self.run_obj, "cutoff_time": self.cutoff_time, "runcount_limit": self.runcount_limit, "tuner-timeout": self.tuner_timeout, "wallclock_limit": self.wallclock_limit, "cs": self.space, "deterministic": "true" }) self.smac = SMAC4BO(scenario=self.scenario, rng=np.random.RandomState(42)) self.optimizer = self.smac.solver self.optimizer.stats.start_timing() self.optimizer.incumbent = self.get_default_incumbent() self.flag = False # False: compute performance of challenger, True: compute performance of incumbent self.ask = self.ask_generator()
def setUp(self): self.cs = ConfigurationSpace() self.cs.add_hyperparameter( UniformFloatHyperparameter("x", lower=MIN_V, upper=MAX_V)) # Scenario object self.scenario = Scenario({ "run_obj": "quality", # we optimize quality (alternatively runtime) "runcount-limit": 50, # max. number of function evaluations "cs": self.cs, # configuration space "deterministic": True, "multi_objectives": "metric1, metric2", "limit_resources": False, }) self.facade_kwargs = { "scenario": self.scenario, "rng": np.random.RandomState(5), "tae_runner": tae, } self.parego_facade_kwargs = { "scenario": self.scenario, "rng": np.random.RandomState(5), "tae_runner": tae, "multi_objective_algorithm": ParEGO, "multi_objective_kwargs": { "rho": 0.05 }, }
def _get_cfg(self): cs = ConfigurationSpace() max_depth = UniformIntegerHyperparameter("max_depth", 3, 16, default_value=3) min_child_weight = UniformIntegerHyperparameter("min_child_weight", 1, 15, default_value=1) gamma = UniformFloatHyperparameter("gamma", 0.0, 0.4, default_value=0.0) subsample = UniformFloatHyperparameter("subsample", 0.6, 0.9, default_value=0.6) colsample_bytree = UniformFloatHyperparameter("colsample_bytree", 0.6, 0.9, default_value=0.6) cs.add_hyperparameters( [max_depth, min_child_weight, gamma, subsample, colsample_bytree]) return cs
def getPCS(self): ''' maxDepth :[3,12] 树深度 默认5 minInstancesPerNode:[1,100] 默认10 minInfoGain:[0,0.1] 默认0 impurity :["gini", "entropy"],默认”gini” ''' # Build Configuration Space which defines all parameters and their # ranges cs = ConfigurationSpace() maxDepth = UniformIntegerHyperparameter("maxDepth", 3, 12, default_value=5) minInstancesPerNode = UniformIntegerHyperparameter( "minInstancesPerNode", 1, 100, default_value=10) minInfoGain = UniformFloatHyperparameter("minInfoGain", 1e-06, 1e-01, default_value=1e-06) impurity = CategoricalHyperparameter("impurity", ["gini", "entropy"], default_value="gini") cs.add_hyperparameters( [maxDepth, minInstancesPerNode, minInfoGain, impurity]) return cs
def smac_em(self): clu_cs = ConfigurationSpace() n_init = UniformIntegerHyperparameter("n_init", 1, 15) n_com = UniformIntegerHyperparameter("n_components", 2, 10) reg_c = UniformFloatHyperparameter("min_covar", 1e-6, 0.1) max_iter = UniformIntegerHyperparameter("n_iters", 10, 1000) tr = UniformFloatHyperparameter("threshold", 1e-6, 0.1) clu_cs.add_hyperparameters([n_init, tr, reg_c, n_com, max_iter]) clu_scenario = Scenario({ "run_obj": "quality", # we optimize quality (alternatively runtime) # "runcount-limit": Constants.num_eval, # maximum function evaluations "cs": clu_cs, # configuration space "deterministic": "true", "tuner-timeout": constants.em_timeout, "wallclock_limit": constants.em_timeout, "cutoff_time": constants.em_timeout, "runcount-limit": 1 }) print('Run EM SMAC ' + self.name) smac = SMAC(scenario=clu_scenario, tae_runner=self.run_em) parameters = smac.optimize() value = smac.get_runhistory().get_cost(parameters) return value, parameters
class TestMultiInitialDesign(unittest.TestCase): def setUp(self): self.cs = ConfigurationSpace() self.cs.add_hyperparameter(UniformFloatHyperparameter( name="x1", lower=1, upper=10, default_value=2) ) self.scenario = Scenario({'cs': self.cs, 'run_obj': 'quality', 'output_dir': ''}) self.ta = ExecuteTAFuncDict(lambda x: x["x1"]**2) def test_multi_config_design(self): stats = Stats(scenario=self.scenario) stats.start_timing() self.ta.stats = stats tj = TrajLogger(output_dir=None, stats=stats) rh = RunHistory(aggregate_func=average_cost) self.ta.runhistory = rh rng = np.random.RandomState(seed=12345) intensifier = Intensifier(tae_runner=self.ta, stats=stats, traj_logger=tj, rng=rng, instances=[None], run_obj_time=False) configs = [Configuration(configuration_space=self.cs, values={"x1":4}), Configuration(configuration_space=self.cs, values={"x1":2})] dc = MultiConfigInitialDesign(tae_runner=self.ta, scenario=self.scenario, stats=stats, traj_logger=tj, runhistory=rh, rng=rng, configs=configs, intensifier=intensifier, aggregate_func=average_cost) inc = dc.run() self.assertTrue(stats.ta_runs==2) self.assertTrue(len(rh.data)==2) self.assertTrue(rh.get_cost(inc) == 4)
def get_depth(self, cs: ConfigurationSpace, param: str): """ Get depth in configuration space of a given parameter name breadth search until reaching a leaf for the first time Parameters ---------- cs: ConfigurationSpace ConfigurationSpace to get parents of a parameter param: str name of parameter to inspect """ parents = cs.get_parents_of(param) if not parents: return 1 new_parents = parents d = 1 while new_parents: d += 1 old_parents = new_parents new_parents = [] for p in old_parents: pp = cs.get_parents_of(p) if pp: new_parents.extend(pp) else: return d
def getPCS(self): ''' maxDepth [3,12] 默认5 minInstancesPerNode:[1,100] 默认10 minInfoGain=:[0,0.1] 默认0 subsamplingRate=[0.01,1], 默认1 numTrees:[1,100] 默认 50 ''' # Build Configuration Space which defines all parameters and their # ranges cs = ConfigurationSpace() maxDepth = UniformIntegerHyperparameter("maxDepth", 3, 12, default_value=5) minInstancesPerNode = UniformIntegerHyperparameter( "minInstancesPerNode", 1, 100, default_value=10) minInfoGain = UniformFloatHyperparameter("minInfoGain", 1e-06, 1e-01, default_value=1e-06) numTrees = UniformIntegerHyperparameter("numTrees", 1, 100, default_value=50) cs.add_hyperparameters( [maxDepth, minInstancesPerNode, minInfoGain, numTrees]) return cs
class SchafferTest(unittest.TestCase): def setUp(self): self.cs = ConfigurationSpace() self.cs.add_hyperparameter( UniformFloatHyperparameter("x", lower=MIN_V, upper=MAX_V)) # Scenario object self.scenario = Scenario({ "run_obj": "quality", # we optimize quality (alternatively runtime) "runcount-limit": 50, # max. number of function evaluations "cs": self.cs, # configuration space "deterministic": True, "multi_objectives": "metric1, metric2", "limit_resources": False, }) self.facade_kwargs = { "scenario": self.scenario, "rng": np.random.RandomState(0), "tae_runner": tae, } def test_AC(self): smac = SMAC4AC(**self.facade_kwargs) incumbent = smac.optimize() f1_inc, f2_inc = schaffer(incumbent["x"]) f1_opt, f2_opt = get_optimum() f2_inc = f2_inc / UPSCALING_FACTOR self.assertAlmostEqual(f1_inc + f2_inc, f1_opt + f2_opt, places=1) return smac
def getPCS(self): ''' maxDepth [3,12] 默认5 minInstancesPerNode:[1,100] 默认10 minInfoGain=:[0,0.1] 默认0 maxIter=[ 1,50] ,默认20 stepSize [0.001,1]默认0.1 ''' # Build Configuration Space which defines all parameters and their # ranges cs = ConfigurationSpace() maxDepth = UniformIntegerHyperparameter("maxDepth", 3, 12, default_value=5) maxIter = UniformIntegerHyperparameter("maxIter", 1, 50, default_value=20) minInstancesPerNode = UniformIntegerHyperparameter( "minInstancesPerNode", 1, 100, default_value=10) minInfoGain = UniformFloatHyperparameter("minInfoGain", 1e-06, 1e-01, default_value=1e-06) stepSize = UniformFloatHyperparameter("stepSize", 0.001, 1, default_value=0.1) cs.add_hyperparameters( [maxDepth, maxIter, minInstancesPerNode, minInfoGain, stepSize]) return cs
def test_facade(self): config_space = ConfigurationSpace() n_components = UniformIntegerHyperparameter( "PCA__n_components", 5, 30) config_space.add_hyperparameter(n_components) scenario_dict = { "run_obj": "quality", "deterministic": "true", "cs": config_space, "wallclock_limit": 60 } with self.assertRaises(ValueError): SMACOptimizer(facade="SMAC4BOO", scenario_dict=scenario_dict) with self.assertRaises(ValueError): facade = SMAC4BO(scenario=Scenario(scenario_dict)) SMACOptimizer(facade=facade, scenario_dict=scenario_dict) facades = [ "SMAC4BO", SMAC4BO, "SMAC4AC", SMAC4AC, "SMAC4HPO", SMAC4HPO, "BOHB4HPO", BOHB4HPO ] for facade in facades: SMACOptimizer(facade=facade, scenario_dict=scenario_dict)
def rf_reg_configs(): def run(dataset, seed, cfg): cfg = {k: cfg[k] for k in cfg} cfg["criterion"] = criterion[cfg["criterion"]] clf = RandomForestRegressor(random_state=seed, **cfg) scores = cross_val_score(clf, dataset.data, dataset.target, cv=5, scoring="r2") cfg = {k: cfg[k] for k in cfg} return 1 - np.mean(scores) criterion = ["mse", "mae"] cs = ConfigurationSpace() cs.add_hyperparameters([ UniformIntegerHyperparameter("n_estimators", 1, 200), UniformIntegerHyperparameter("criterion", 0, 1), UniformIntegerHyperparameter("max_depth", 10, 1000), UniformIntegerHyperparameter("min_samples_leaf", 1, 200), UniformIntegerHyperparameter("min_samples_split", 2, 100), UniformFloatHyperparameter("min_weight_fraction_leaf", 0.0, 0.5), UniformFloatHyperparameter("min_impurity_decrease", 0.0, 0.9), ]) return (cs, run, "Random Forest")
def mlp_configs(): def run(dataset, seed, cfg): cfg = {k: cfg[k] for k in cfg} cfg["activation"] = activation[cfg["activation"]] cfg["solver"] = solver[cfg["solver"]] clf = MLPRegressor(random_state=seed, **cfg) scores = cross_val_score(clf, dataset.data, dataset.target, cv=5, scoring="r2") cfg = {k: cfg[k] for k in cfg} return 1 - np.mean(scores) activation = ["identity", "logistic", "tanh", "relu"] solver = ["lbfgs", "sgd", "adam"] cs = ConfigurationSpace() cs.add_hyperparameters([ UniformIntegerHyperparameter("activation", 0, 3), UniformIntegerHyperparameter("solver", 0, 2), UniformFloatHyperparameter("tol", 1e-7, 1e-1), UniformFloatHyperparameter("alpha", 1e-7, 1e-1), UniformIntegerHyperparameter("max_iter", 10, 1000), ]) return (cs, run, "MLP")
def _set_param_space(self, param_space): self.param_space = param_space from ConfigSpace.hyperparameters import UniformFloatHyperparameter from smac.configspace import ConfigurationSpace from smac.optimizer.objective import average_cost from smac.runhistory.runhistory import RunHistory from smac.scenario.scenario import Scenario from smac.stats.stats import Stats from smac.utils.io.traj_logging import TrajLogger self.cs = ConfigurationSpace() for param in param_space: if param.type == 'continuous': var = UniformFloatHyperparameter(param.name, param.low, param.high) self.cs.add_hyperparameter(var) self.runhistory = RunHistory(aggregate_func=average_cost) self.scenario = Scenario({ 'run_obj': 'quality', 'runcount-limit': self.budget, 'cs': self.cs }) self.stats = Stats(self.scenario) self.traj_logger = TrajLogger(output_dir=__scratch__, stats=self.stats)
def setUp(self): self.cs = ConfigurationSpace() self.cs.add_hyperparameter( UniformFloatHyperparameter(name="x1", lower=1, upper=10, default=2)) self.scenario = Scenario({'cs': self.cs, 'run_obj': 'quality'}) self.ta = ExecuteTAFuncDict(lambda x: x["x1"]**2)
def impute_default_values(configuration_space: ConfigurationSpace, configs_array: np.ndarray) -> np.ndarray: """Impute inactive hyperparameters in configuration array with their default. Necessary to apply an EPM to the data. Parameters ---------- configuration_space : ConfigurationSpace configs_array : np.ndarray Array of configurations. Returns ------- np.ndarray Array with configuration hyperparameters. Inactive values are imputed with their default value. """ for hp in configuration_space.get_hyperparameters(): default = hp.normalized_default_value idx = configuration_space.get_idx_by_hyperparameter_name(hp.name) nonfinite_mask = ~np.isfinite(configs_array[:, idx]) configs_array[nonfinite_mask, idx] = default return configs_array
def smac(): # Build Configuration Space which defines all parameters and their ranges configuration_space = ConfigurationSpace() #Define initial ranges num_of_hidden_nodes = UniformIntegerHyperparameter("num_of_hidden_nodes", 1, max_hidden_nodes, default_value=1) decay = UniformFloatHyperparameter("decay", 0, 0.1, default_value=0) configuration_space.add_hyperparameters([num_of_hidden_nodes, decay]) # creating the scenario object scenario = Scenario({ "run_obj": "quality", "runcount-limit": hyperparameter_tuning_configs.SMAC_RUNCOUNT_LIMIT, "cs": configuration_space, "deterministic": "true", "abort_on_first_run_crash": "false" }) # optimize using an SMAC object smac = SMAC(scenario=scenario, rng=np.random.RandomState(1), tae_runner=train_model) incumbent = smac.optimize() return incumbent.get_dictionary()
def test_save_load_configspace(self): """Check if inputreader can load different config-spaces""" cs = ConfigurationSpace() hyp = UniformFloatHyperparameter('A', 0.0, 1.0, default_value=0.5) cs.add_hyperparameters([hyp]) output_writer = OutputWriter() input_reader = InputReader() # pcs_new output_writer.save_configspace(cs, self.pcs_fn, 'pcs_new') restored_cs = input_reader.read_pcs_file(self.pcs_fn) self.assertEqual(cs, restored_cs) restored_cs = input_reader.read_pcs_file(self.pcs_fn, self.logger) self.assertEqual(cs, restored_cs) # json output_writer.save_configspace(cs, self.json_fn, 'json') restored_cs = input_reader.read_pcs_file(self.json_fn) self.assertEqual(cs, restored_cs) restored_cs = input_reader.read_pcs_file(self.json_fn, self.logger) self.assertEqual(cs, restored_cs) # pcs with open(self.pcs_fn, 'w') as fh: fh.write(pcs.write(cs)) restored_cs = input_reader.read_pcs_file(self.pcs_fn) self.assertEqual(cs, restored_cs) restored_cs = input_reader.read_pcs_file(self.pcs_fn) self.assertEqual(cs, restored_cs) restored_cs = input_reader.read_pcs_file(self.pcs_fn, self.logger) self.assertEqual(cs, restored_cs)
class TestSingleInitialDesign(unittest.TestCase): def setUp(self): self.cs = ConfigurationSpace() self.cs.add_hyperparameter( UniformFloatHyperparameter(name="x1", lower=1, upper=10, default=2)) self.scenario = Scenario({ 'cs': self.cs, 'run_obj': 'quality', 'output_dir': '' }) self.ta = ExecuteTAFuncDict(lambda x: x["x1"]**2) def test_single_default_config_design(self): stats = Stats(scenario=self.scenario) stats.start_timing() self.ta.stats = stats tj = TrajLogger(output_dir=None, stats=stats) rh = RunHistory(aggregate_func=average_cost) dc = DefaultConfiguration(tae_runner=self.ta, scenario=self.scenario, stats=stats, traj_logger=tj, rng=np.random.RandomState(seed=12345)) inc = dc.run() self.assertTrue(stats.ta_runs == 1) self.assertTrue(len(rh.data) == 0)
def smac_gm(self): clu_cs = ConfigurationSpace() cov_t = CategoricalHyperparameter( "covariance_type", ["full", "tied", "diag", "spherical"]) tol = UniformFloatHyperparameter("tol", 1e-6, 0.1) reg_c = UniformFloatHyperparameter("reg_covar", 1e-10, 0.1) n_com = UniformIntegerHyperparameter("n_components", 2, 10) max_iter = UniformIntegerHyperparameter("max_iter", 10, 1000) clu_cs.add_hyperparameters([cov_t, tol, reg_c, n_com, max_iter]) clu_scenario = Scenario({ "run_obj": "quality", # we optimize quality (alternatively runtime) # "runcount-limit": Constants.num_eval, # maximum function evaluations "cs": clu_cs, # configuration space "deterministic": "true", "tuner-timeout": constants.timeout, "wallclock_limit": constants.timeout, "cutoff_time": constants.timeout }) print('Run GM SMAC ' + self.name) smac = SMAC(scenario=clu_scenario, tae_runner=self.run_gm) parameters = smac.optimize() value = smac.get_runhistory().get_cost(parameters) return value, parameters
def _get_cfg(self): n_features = self.X_train.shape[1] cs = ConfigurationSpace() max_features = UniformIntegerHyperparameter("max_features", 1, n_features, default_value=1) min_samples_split = UniformIntegerHyperparameter("min_samples_split", 2, 50, default_value=2) min_samples_leaf = UniformIntegerHyperparameter("min_samples_leaf", 1, 50, default_value=1) min_weight_fraction_leaf = UniformFloatHyperparameter( "min_weight_fraction_leaf", 0.0, 0.5, default_value=0.0) max_leaf_nodes = UniformIntegerHyperparameter("max_leaf_nodes", 10, 1000, default_value=100) cs.add_hyperparameters([ max_features, min_samples_split, min_samples_leaf, min_weight_fraction_leaf, max_leaf_nodes ]) return cs
def getPCS(self): ''' maxIter: [1,100]最大迭代次数,默认50 regParam :[0,0.2] 正则化参数,默认0 tol:[1e-6,1e-1] 迭代算法收敛性,默认 1e-6 ''' # Build Configuration Space which defines all parameters and their # ranges cs = ConfigurationSpace() maxIter = UniformIntegerHyperparameter("maxIter", 1, 100, default_value=50) regParam = UniformFloatHyperparameter("regParam", 0, 0.4, default_value=1e-04) tol = UniformFloatHyperparameter("tol", 1e-06, 1e-01, default_value=1e-06) cs.add_hyperparameters([maxIter, regParam, tol]) return cs
def addSearchSpaceGrid( hp: SearchSpaceGrid, disc: int, parent_disc: Hyperparameter, cs: ConfigurationSpace ) -> None: smac = SearchSpaceGridtoSMAC(hp, disc) for hyp in smac: cs.add_hyperparameter(hyp) cs.add_condition(EqualsCondition(child=hyp, parent=parent_disc, value=disc))
def get_smac_func_and_space(func, cp_domain): """ Returns a function to be passed to SMAC. """ from smac.configspace import ConfigurationSpace from ConfigSpace.hyperparameters import CategoricalHyperparameter, \ UniformFloatHyperparameter, UniformIntegerHyperparameter smac_configs = [] num_dims_per_domain = [] disc_spaces = [] cp_dom_types = [] # Iterate through each domain counter = 0 for dom in cp_domain.list_of_domains: dom_type = dom.get_type() cp_dom_types.append(dom_type) if dom_type == 'euclidean': num_dims_per_domain.append(dom.get_dim()) for bds in dom.bounds: disc_spaces.append(None) counter, var_label = _get_var_label_with_counter(counter) smac_configs.append( UniformFloatHyperparameter( var_label, bds[0], bds[1], default_value=(bds[0] + bds[1]) / 2)) elif dom_type == 'integral': num_dims_per_domain.append(dom.get_dim()) for bds in dom.bounds: disc_spaces.append(None) counter, var_label = _get_var_label_with_counter(counter) smac_configs.append( UniformIntegerHyperparameter( var_label, bds[0], bds[1], default_value=(bds[0] + bds[1]) // 2)) elif dom_type in ['prod_discrete', 'prod_discrete_numeric']: num_dims_per_domain.append(dom.get_dim()) for lois in dom.list_of_list_of_items: curr_disc_to_idx_converter = DiscItemsToIndexConverter(lois) disc_spaces.append(curr_disc_to_idx_converter) counter, var_label = _get_var_label_with_counter(counter) smac_configs.append( CategoricalHyperparameter( var_label, curr_disc_to_idx_converter.indices, default_value=curr_disc_to_idx_converter.indices[0])) smac_space = ConfigurationSpace() smac_space.add_hyperparameters(smac_configs) # The convert back function smac_convert_pt_back = lambda x: _convert_alphabetical_dict_repr_to_cp_domain_repr( x, num_dims_per_domain, cp_dom_types, disc_spaces) # Then the function smac_func_to_min = lambda x: -func(smac_convert_pt_back(x))[0] return smac_func_to_min, smac_space, smac_convert_pt_back
def _create_config_space(self): self.cs = ConfigurationSpace() for var_index, var_dict in enumerate(self.param_dict['variables']): variable = var_dict[self.var_names[var_index]] if variable['type'] == 'float': param = UniformFloatHyperparameter( 'x%d' % var_index, variable['low'], variable['high'] ) #, default = np.random.uniform(low = variable['low'], high = variable['high'], size = variable['size'])) else: raise NotImplementedError() self.cs.add_hyperparameter(param)
def _get_cfg(self): n_features = self.X_train.shape[1] cs = ConfigurationSpace() max_depth = UniformIntegerHyperparameter("max_depth", 5, 16, default_value=5) min_samples_split = UniformIntegerHyperparameter("min_samples_split", 200, 1000, default_value=200) min_samples_leaf = UniformIntegerHyperparameter("min_samples_leaf", 30, 70, default_value=30) max_features = UniformIntegerHyperparameter("max_features", 1, n_features, default_value=1) subsample = UniformFloatHyperparameter("subsample", 0.6, 0.9, default_value=0.6) cs.add_hyperparameters([max_depth, min_samples_split, min_samples_leaf, max_features, subsample]) return cs
def get_gp(n_dimensions, rs, noise=1e-3, normalize_y=True, average_samples=False, n_iter=50): from smac.epm.gp_kernels import ConstantKernel, Matern, WhiteKernel cov_amp = ConstantKernel( 2.0, constant_value_bounds=(1e-10, 2), prior=LognormalPrior(mean=0.0, sigma=1.0, rng=rs), ) exp_kernel = Matern( np.ones([n_dimensions]), [(np.exp(-10), np.exp(2)) for _ in range(n_dimensions)], nu=2.5, prior=None, ) noise_kernel = WhiteKernel( noise_level=noise, noise_level_bounds=(1e-10, 2), prior=HorseshoePrior(scale=0.1, rng=rs), ) kernel = cov_amp * exp_kernel + noise_kernel n_mcmc_walkers = 3 * len(kernel.theta) if n_mcmc_walkers % 2 == 1: n_mcmc_walkers += 1 bounds = [(0., 1.) for _ in range(n_dimensions)] types = np.zeros(n_dimensions) configspace = ConfigurationSpace() for i in range(n_dimensions): configspace.add_hyperparameter( UniformFloatHyperparameter('x%d' % i, 0, 1)) model = GaussianProcessMCMC( configspace=configspace, types=types, bounds=bounds, kernel=kernel, n_mcmc_walkers=n_mcmc_walkers, chain_length=n_iter, burnin_steps=n_iter, normalize_y=normalize_y, seed=rs.randint(low=1, high=10000), mcmc_sampler='emcee', average_samples=average_samples, ) return model
def test_initializations(self): cs = ConfigurationSpace() for i in range(40): cs.add_hyperparameter(UniformFloatHyperparameter('x%d' % (i + 1), 0, 1)) scenario = Scenario({'cs': cs, 'run_obj': 'quality'}) hb_kwargs = {'initial_budget': 1, 'max_budget': 3} facade = HB4AC(scenario=scenario, intensifier_kwargs=hb_kwargs) self.assertIsInstance(facade.solver.initial_design, RandomConfigurations) self.assertIsInstance(facade.solver.epm_chooser.model, RandomEPM) self.assertIsInstance(facade.solver.intensifier, Hyperband) self.assertEqual(facade.solver.intensifier.min_chall, 1) self.output_dirs.append(scenario.output_dir)
def _create_config_space(dict_hyperparams): """Create the hyperparameters hyperspace.""" config_space = ConfigurationSpace() if not isinstance(dict_hyperparams, dict): raise TypeError('Hyperparams must be a dictionary.') for name, hyperparam in dict_hyperparams.items(): hp_type = hyperparam['type'] if hp_type == 'int': hp_range = hyperparam.get('range') or hyperparam.get('values') hp_min = min(hp_range) hp_max = max(hp_range) hp_default = hyperparam.get('default') or hp_min config_space.add_hyperparameter( hp.UniformIntegerHyperparameter(name, hp_min, hp_max, default_value=hp_default)) elif hp_type == 'float': hp_range = hyperparam.get('range') or hyperparam.get('values') hp_min = min(hp_range) hp_max = max(hp_range) hp_default = hyperparam.get('default') or hp_min config_space.add_hyperparameter( hp.UniformFloatHyperparameter(name, hp_min, hp_max, default_value=hp_default)) elif hp_type == 'bool': hp_default = bool(hyperparam.get('default')) config_space.add_hyperparameter( hp.CategoricalHyperparameter(name, ['true', 'false'], default_value=hp_default)) elif hp_type == 'str': hp_range = hyperparam.get('range') or hyperparam.get('values') hp_range = [_NONE if hp is None else hp for hp in hp_range] hp_default = hyperparam.get('default') or hp_range[0] hp_default = _NONE if hp_default is None else hp_default config_space.add_hyperparameter( hp.CategoricalHyperparameter(name, hp_range, default_value=hp_default)) return config_space
def getPCS(self): ''' smoothing: [0.01,100] 默认1 ''' # Build Configuration Space which defines all parameters and their # ranges cs = ConfigurationSpace() smoothing = UniformFloatHyperparameter( "smoothing", 0.01, 100, default_value=1) cs.add_hyperparameters( [smoothing]) return cs
from ConfigSpace.hyperparameters import UniformFloatHyperparameter from fanova import fANOVA import fanova.visualizer import os path = os.path.dirname(os.path.realpath(__file__)) # get sample data from online lda X = np.loadtxt(path + '/example_data/online_lda/online_lda_features.csv', delimiter=",") Y = np.loadtxt(path + '/example_data/online_lda/online_lda_responses.csv', delimiter=",") # setting up config space: param_file = path + '/example_data/online_lda/param-file.txt' f = open(param_file, 'rb') cs = ConfigurationSpace() for row in f: cs.add_hyperparameter(UniformFloatHyperparameter("%s" %row[0:4].decode('utf-8'), np.float(row[6:9]), np.float(row[10:13]),np.float(row[18:21]))) param = cs.get_hyperparameters() # create an instance of fanova with data for the random forest and the configSpace f = fANOVA(X = X, Y = Y, config_space = cs) # marginal for first parameter p_list = (0, ) res = f.quantify_importance(p_list) print(res) p2_list = ('Col1', 'Col2') res2 = f.quantify_importance(p2_list)