def test_write_forbidden(self): cs = ConfigurationSpace() hp1 = CategoricalHyperparameter("parent", [0, 1]) hp2 = UniformIntegerHyperparameter("child", 0, 2) hp3 = UniformIntegerHyperparameter("child2", 0, 2) hp4 = UniformIntegerHyperparameter("child3", 0, 2) hp5 = CategoricalHyperparameter("child4", [4, 5, 6, 7]) cs.add_hyperparameters([hp1, hp2, hp3, hp4, hp5]) forb2 = ForbiddenEqualsClause(hp1, 1) forb3 = ForbiddenInClause(hp2, range(2, 3)) forb4 = ForbiddenInClause(hp3, range(2, 3)) forb5 = ForbiddenInClause(hp4, range(2, 3)) forb6 = ForbiddenInClause(hp5, [6, 7]) and1 = ForbiddenAndConjunction(forb2, forb3) and2 = ForbiddenAndConjunction(forb2, forb4) and3 = ForbiddenAndConjunction(forb2, forb5) cs.add_forbidden_clauses( [forb2, forb3, forb4, forb5, forb6, and1, and2, and3]) value = irace.write(cs) # generates file called forbidden.txt
def test_impute_inactive_hyperparameters(self): cs = smac.configspace.ConfigurationSpace() a = cs.add_hyperparameter(CategoricalHyperparameter('a', [0, 1], default_value=0)) b = cs.add_hyperparameter(CategoricalHyperparameter('b', [0, 1], default_value=1)) cs.add_condition(EqualsCondition(b, a, 1)) cs.seed(1) configs = cs.sample_configuration(size=100) config_array = smac.configspace.convert_configurations_to_array(configs) for line in config_array: if line[0] == 0: self.assertEqual(line[1], 1)
def test_build_new_forbidden(self): expected = "a categorical {a, b, c} [a]\nb categorical {a, b, c} [c]\n\n" \ "{a=a, b=a}\n{a=a, b=b}\n{a=b, b=a}\n{a=b, b=b}\n" cs = ConfigurationSpace() a = CategoricalHyperparameter("a", ["a", "b", "c"], "a") b = CategoricalHyperparameter("b", ["a", "b", "c"], "c") cs.add_hyperparameter(a) cs.add_hyperparameter(b) fb = ForbiddenAndConjunction(ForbiddenInClause(a, ["a", "b"]), ForbiddenInClause(b, ["a", "b"])) cs.add_forbidden_clause(fb) value = pcs_new.write(cs) self.assertEqual(expected, value)
def test_categorical_is_legal(self): f1 = CategoricalHyperparameter("param", ["a", "b"]) self.assertTrue(f1.is_legal("a")) self.assertTrue(f1.is_legal(u"a")) self.assertFalse(f1.is_legal("c")) self.assertFalse(f1.is_legal(3)) # Test is legal vector self.assertTrue(f1.is_legal_vector(1.0)) self.assertTrue(f1.is_legal_vector(0.0)) self.assertTrue(f1.is_legal_vector(0)) self.assertFalse(f1.is_legal_vector(0.3)) self.assertFalse(f1.is_legal_vector(-0.1)) self.assertRaises(TypeError, f1.is_legal_vector, "Hahaha")
def setUp(self): logging.basicConfig(level=logging.DEBUG) self.cs = ConfigurationSpace() self.cs.add_hyperparameter(CategoricalHyperparameter( name="cat_a_b", choices=["a", "b"], default_value="a")) self.cs.add_hyperparameter(UniformFloatHyperparameter( name="float_0_1", lower=0, upper=1, default_value=0.5)) self.cs.add_hyperparameter(UniformIntegerHyperparameter( name='integer_0_100', lower=-10, upper=10, default_value=0)) self.rh = runhistory.RunHistory(aggregate_func=average_cost) rs = numpy.random.RandomState(1) to_count = 0 cn_count = 0 for i in range(500): config, seed, runtime, status, instance_id = \ generate_config(cs=self.cs, rs=rs) if runtime == 40: to_count += 1 if runtime < 40 and status == StatusType.TIMEOUT: cn_count += 1 self.rh.add(config=config, cost=runtime, time=runtime, status=status, instance_id=instance_id, seed=seed, additional_info=None) print("%d TIMEOUTs, %d censored" % (to_count, cn_count)) self.scen = Scen() self.scen.run_obj = "runtime" self.scen.overall_obj = "par10" self.scen.cutoff = 40 types, bounds = get_types(self.cs, None) self.model = RandomForestWithInstances( types=types, bounds=bounds, instance_features=None, seed=1234567980)
def test_write_categorical(self): expected = "cat_a '--cat_a ' c {a,b,c}\n" cs = ConfigurationSpace() cs.add_hyperparameter( CategoricalHyperparameter("cat_a", ["a", "b", "c"])) value = irace.write(cs) self.assertEqual(expected, value)
def _construct_hyperparameter(hyperparameter: Dict) -> Hyperparameter: hp_type = hyperparameter['type'] name = hyperparameter['name'] if hp_type == 'constant': return Constant( name=name, value=hyperparameter['value'], ) elif hp_type == 'unparametrized': return UnParametrizedHyperparameter( name=name, value=hyperparameter['value'], ) elif hp_type == 'uniform_float': return UniformFloatHyperparameter( name=name, log=hyperparameter['log'], lower=hyperparameter['lower'], upper=hyperparameter['upper'], default_value=hyperparameter['default'], ) elif hp_type == 'normal_float': return NormalFloatHyperparameter( name=name, log=hyperparameter['log'], mu=hyperparameter['mu'], sigma=hyperparameter['sigma'], default_value=hyperparameter['default'], ) elif hp_type == 'uniform_int': return UniformIntegerHyperparameter( name=name, log=hyperparameter['log'], lower=hyperparameter['lower'], upper=hyperparameter['upper'], default_value=hyperparameter['default'], ) elif hp_type == 'normal_int': return NormalIntegerHyperparameter( name=name, log=hyperparameter['log'], lower=hyperparameter['lower'], upper=hyperparameter['upper'], default_value=hyperparameter['default'], ) elif hp_type == 'categorical': return CategoricalHyperparameter( name=name, choices=hyperparameter['choices'], default_value=hyperparameter['default'], ) elif hp_type == 'ordinal': return OrdinalHyperparameter( name=name, sequence=hyperparameter['sequence'], default_value=hyperparameter['default'], ) else: raise ValueError(hp_type)
def test_not_equals_condition(self): hp1 = CategoricalHyperparameter("parent", [0, 1]) hp2 = UniformIntegerHyperparameter("child", 0, 10) cond = NotEqualsCondition(hp2, hp1, 0) cond_ = NotEqualsCondition(hp2, hp1, 0) self.assertEqual(cond, cond_) # Test vector value: self.assertEqual(cond.vector_value, hp1._inverse_transform(0)) self.assertEqual(cond.vector_value, cond_.vector_value) cond_reverse = NotEqualsCondition(hp1, hp2, 0) self.assertNotEqual(cond, cond_reverse) self.assertNotEqual(cond, dict()) self.assertEqual("child | parent != 0", str(cond))
def test_get_parents(self): # Necessary because we couldn't call cs.get_parents for # clasp-sat-params-nat.pcs counter = UniformIntegerHyperparameter('bump', 10, 4096, log=True) _1_S_countercond = CategoricalHyperparameter('cony', ['yes', 'no']) _1_0_restarts = CategoricalHyperparameter( 'restarts', ['F', 'L', 'D', 'x', '+', 'no'], default_value='x') condition = EqualsCondition(counter, _1_S_countercond, 'yes') # All conditions inherit get_parents from abstractcondition self.assertEqual([_1_S_countercond], condition.get_parents()) condition2 = InCondition(counter, _1_0_restarts, ['F', 'D', 'L', 'x', '+']) # All conjunctions inherit get_parents from abstractconjunction conjunction = AndConjunction(condition, condition2) self.assertEqual([_1_S_countercond, _1_0_restarts], conjunction.get_parents())
def test_write_AndConjunction_condition(self): expected = "lp '--lp ' c {mi,bo}\nls '--ls ' c {sa,ca,ny}\ntemp '--temp ' r (0.500000, 1.000000)| ls %in% c(sa,ca) && lp %in% c(bo)\n" temp = UniformFloatHyperparameter("temp", 0.5, 1) ls = CategoricalHyperparameter("ls", ["sa", "ca", "ny"], "sa") lp = CategoricalHyperparameter("lp", ["mi", "bo"], "bo") cs = ConfigurationSpace() cs.add_hyperparameter(temp) cs.add_hyperparameter(lp) cs.add_hyperparameter(ls) c1 = InCondition(temp, ls, ['sa', 'ca']) c2 = InCondition(temp, lp, ['bo']) c3 = AndConjunction(c1, c2) cs.add_condition(c3) value = irace.write(cs) self.assertEqual(expected, value)
def test_condition_from_cryptominisat(self): parent = CategoricalHyperparameter('blkrest', ['0', '1'], default_value='1') child = UniformIntegerHyperparameter('blkrestlen', 2000, 10000, log=True) condition = EqualsCondition(child, parent, '1') self.assertFalse(condition.evaluate(dict(blkrest='0'))) self.assertTrue(condition.evaluate(dict(blkrest='1')))
def test_all_components_have_the_same_child(self): hp1 = CategoricalHyperparameter("input1", [0, 1]) hp2 = CategoricalHyperparameter("input2", [0, 1]) hp3 = CategoricalHyperparameter("input3", [0, 1]) hp4 = CategoricalHyperparameter("input4", [0, 1]) hp5 = CategoricalHyperparameter("input5", [0, 1]) hp6 = Constant("AND", "True") cond1 = EqualsCondition(hp1, hp2, 1) cond2 = EqualsCondition(hp1, hp3, 1) cond3 = EqualsCondition(hp1, hp4, 1) cond4 = EqualsCondition(hp6, hp4, 1) cond5 = EqualsCondition(hp6, hp5, 1) AndConjunction(cond1, cond2, cond3) AndConjunction(cond4, cond5) self.assertRaisesRegexp( ValueError, "All Conjunctions and Conditions must have " "the same child.", AndConjunction, cond1, cond4)
def test_in_condition(self): hp1 = CategoricalHyperparameter("parent", list(range(0, 11))) hp2 = UniformIntegerHyperparameter("child", 0, 10) cond = InCondition(hp2, hp1, [0, 1, 2, 3, 4, 5]) cond_ = InCondition(hp2, hp1, [0, 1, 2, 3, 4, 5]) self.assertEqual(cond, cond_) # Test vector value: self.assertEqual( cond.vector_values, [hp1._inverse_transform(i) for i in [0, 1, 2, 3, 4, 5]]) self.assertEqual(cond.vector_values, cond_.vector_values) cond_reverse = InCondition(hp1, hp2, [0, 1, 2, 3, 4, 5]) self.assertNotEqual(cond, cond_reverse) self.assertNotEqual(cond, dict()) self.assertEqual("child | parent in {0, 1, 2, 3, 4, 5}", str(cond))
def test_and_conjunction(self): self.assertRaises(TypeError, AndConjunction, "String1", "String2") hp1 = CategoricalHyperparameter("input1", [0, 1]) hp2 = CategoricalHyperparameter("input2", [0, 1]) hp3 = CategoricalHyperparameter("input3", [0, 1]) hp4 = Constant("And", "True") cond1 = EqualsCondition(hp4, hp1, 1) # Only one condition in an AndConjunction! self.assertRaises(ValueError, AndConjunction, cond1) cond2 = EqualsCondition(hp4, hp2, 1) cond3 = EqualsCondition(hp4, hp3, 1) andconj1 = AndConjunction(cond1, cond2) andconj1_ = AndConjunction(cond1, cond2) self.assertEqual(andconj1, andconj1_) # Test setting vector idx hyperparameter_idx = { hp1.name: 0, hp2.name: 1, hp3.name: 2, hp4.name: 3 } andconj1.set_vector_idx(hyperparameter_idx) self.assertEqual(andconj1.get_parents_vector(), [0, 1]) self.assertEqual(andconj1.get_children_vector(), [3, 3]) andconj2 = AndConjunction(cond2, cond3) self.assertNotEqual(andconj1, andconj2) andconj3 = AndConjunction(cond1, cond2, cond3) self.assertEqual( "(And | input1 == 1 && And | input2 == 1 && And | " "input3 == 1)", str(andconj3)) # Test __eq__ self.assertNotEqual(andconj1, andconj3) self.assertNotEqual(andconj1, "String")
def test_write_equals_condition_numerical(self): expected = "temp '--temp ' i (1, 2)\nls '--ls ' c {sa,ca,ny}| temp==2\n" temp = UniformIntegerHyperparameter("temp", 1, 2) ls = CategoricalHyperparameter("ls", ["sa", "ca", "ny"], "sa") cs = ConfigurationSpace() cs.add_hyperparameter(temp) cs.add_hyperparameter(ls) c1 = EqualsCondition(ls, temp, 2) cs.add_condition(c1) value = irace.write(cs) self.assertEqual(expected, value)
def test_write_in_condition(self): expected = "ls '--ls ' c {sa,ca,ny}\ntemp '--temp ' r (0.500000, 1.000000)| ls %in% c(sa,ca)\n" temp = UniformFloatHyperparameter("temp", 0.5, 1) ls = CategoricalHyperparameter("ls", ["sa", "ca", "ny"], "sa") cs = ConfigurationSpace() cs.add_hyperparameter(temp) cs.add_hyperparameter(ls) c1 = InCondition(temp, ls, ['sa', 'ca']) cs.add_condition(c1) value = irace.write(cs) self.assertEqual(expected, value)
def test_write_OrConjunction_condition(self): import numpy as np expected = "lp '--lp ' c {mi,bo}\ntemp '--temp ' r (2.000000, 5.000000)\nls '--ls ' c {sa,ca,ny}| temp==3.0 || lp %in% c(bo)\n" temp = UniformFloatHyperparameter("temp", np.exp(2), np.exp(5), log=True) ls = CategoricalHyperparameter("ls", ["sa", "ca", "ny"], "sa") lp = CategoricalHyperparameter("lp", ["mi", "bo"], "bo") cs = ConfigurationSpace() cs.add_hyperparameter(temp) cs.add_hyperparameter(lp) cs.add_hyperparameter(ls) c1 = EqualsCondition(ls, temp, np.exp(3)) c2 = InCondition(ls, lp, ['bo']) c3 = OrConjunction(c1, c2) cs.add_condition(c3) value = irace.write(cs) self.assertEqual(expected, value)
def test_categorical(self): # TODO test for inequality f1 = CategoricalHyperparameter("param", [0, 1]) f1_ = CategoricalHyperparameter("param", [0, 1]) self.assertEqual(f1, f1_) self.assertEqual( "param, Type: Categorical, Choices: {0, 1}, Default: 0", str(f1)) f2 = CategoricalHyperparameter("param", list(range(0, 1000))) f2_ = CategoricalHyperparameter("param", list(range(0, 1000))) self.assertEqual(f2, f2_) self.assertEqual( "param, Type: Categorical, Choices: {%s}, Default: 0" % ", ".join([str(choice) for choice in range(0, 1000)]), str(f2)) f3 = CategoricalHyperparameter("param", list(range(0, 999))) self.assertNotEqual(f2, f3) f4 = CategoricalHyperparameter("param_", list(range(0, 1000))) self.assertNotEqual(f2, f4) f5 = CategoricalHyperparameter("param", list(range(0, 999)) + [1001]) self.assertNotEqual(f2, f5) f6 = CategoricalHyperparameter("param", ["a", "b"], default_value="b") f6_ = CategoricalHyperparameter("param", ["a", "b"], default_value="b") self.assertEqual(f6, f6_) self.assertEqual( "param, Type: Categorical, Choices: {a, b}, Default: b", str(f6)) self.assertNotEqual(f1, f2) self.assertNotEqual(f1, "UniformFloat") # test that meta-data is stored correctly f_meta = CategoricalHyperparameter("param", ["a", "b"], default_value="a", meta=dict(self.meta_data)) self.assertEqual(f_meta.meta, self.meta_data)
def test_equals_condition(self): hp1 = CategoricalHyperparameter("parent", [0, 1]) hp2 = UniformIntegerHyperparameter("child", 0, 10) cond = EqualsCondition(hp2, hp1, 0) cond_ = EqualsCondition(hp2, hp1, 0) # Test vector value: self.assertEqual(cond.vector_value, hp1._inverse_transform(0)) self.assertEqual(cond.vector_value, cond_.vector_value) # Test invalid conditions: self.assertRaises(TypeError, EqualsCondition, hp2, "parent", 0) self.assertRaises(TypeError, EqualsCondition, "child", hp1, 0) self.assertRaises(ValueError, EqualsCondition, hp1, hp1, 0) self.assertEqual(cond, cond_) cond_reverse = EqualsCondition(hp1, hp2, 0) self.assertNotEqual(cond, cond_reverse) self.assertNotEqual(cond, dict()) self.assertEqual("child | parent == 0", str(cond))
def setUp(self): current_dir = os.path.dirname(__file__) self.test_files_dir = os.path.join(current_dir, '..', 'test_files') seed = np.random.randint(1, 100000) self.cs = ConfigurationSpace(seed=seed) x1 = UniformFloatHyperparameter("x1", -5, 5, default_value=5) self.cs.add_hyperparameter(x1) x2 = UniformIntegerHyperparameter("x2", -5, 5, default_value=5) self.cs.add_hyperparameter(x2) x3 = CategoricalHyperparameter("x3", [5, 2, 0, 1, -1, -2, 4, -3, 3, -5, -4], default_value=5) self.cs.add_hyperparameter(x3) x4 = UniformIntegerHyperparameter("x4", -5, 5, default_value=5) self.cs.add_hyperparameter(x4)
def test_nested_conjunctions(self): hp1 = CategoricalHyperparameter("input1", [0, 1]) hp2 = CategoricalHyperparameter("input2", [0, 1]) hp3 = CategoricalHyperparameter("input3", [0, 1]) hp4 = CategoricalHyperparameter("input4", [0, 1]) hp5 = CategoricalHyperparameter("input5", [0, 1]) hp6 = Constant("AND", "True") cond1 = EqualsCondition(hp6, hp1, 1) cond2 = EqualsCondition(hp6, hp2, 1) cond3 = EqualsCondition(hp6, hp3, 1) cond4 = EqualsCondition(hp6, hp4, 1) cond5 = EqualsCondition(hp6, hp5, 1) conj1 = AndConjunction(cond1, cond2) conj2 = OrConjunction(conj1, cond3) conj3 = AndConjunction(conj2, cond4, cond5) # TODO: this does not look nice, And should depend on a large # conjunction, there should not be many ANDs inside this string! self.assertEqual( "(((AND | input1 == 1 && AND | input2 == 1) || AND | " "input3 == 1) && AND | input4 == 1 && AND | input5 " "== 1)", str(conj3))
def test_equals_condition_illegal_value(self): epsilon = UniformFloatHyperparameter("epsilon", 1e-5, 1e-1, default_value=1e-4, log=True) loss = CategoricalHyperparameter( "loss", ["hinge", "log", "modified_huber", "squared_hinge", "perceptron"], default_value="hinge") self.assertRaisesRegexp( ValueError, "Hyperparameter 'epsilon' is " "conditional on the illegal value 'huber' of " "its parent hyperparameter 'loss'", EqualsCondition, epsilon, loss, "huber")
def test_and_conjunction(self): hp1 = CategoricalHyperparameter("parent", [0, 1]) hp2 = UniformIntegerHyperparameter("child", 0, 2) hp3 = UniformIntegerHyperparameter("child2", 0, 2) hp4 = UniformIntegerHyperparameter("child3", 0, 2) forb2 = ForbiddenEqualsClause(hp1, 1) forb3 = ForbiddenInClause(hp2, range(2, 3)) forb4 = ForbiddenInClause(hp3, range(2, 3)) forb5 = ForbiddenInClause(hp4, range(2, 3)) and1 = ForbiddenAndConjunction(forb2, forb3) and2 = ForbiddenAndConjunction(forb2, forb4) and3 = ForbiddenAndConjunction(forb2, forb5) total_and = ForbiddenAndConjunction(and1, and2, and3) self.assertEqual( "((Forbidden: parent == 1 && Forbidden: child in {2}) " "&& (Forbidden: parent == 1 && Forbidden: child2 in {2}) " "&& (Forbidden: parent == 1 && Forbidden: child3 in " "{2}))", str(total_and)) results = [ False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, True ] for i, values in enumerate( product(range(2), range(3), range(3), range(3))): is_forbidden = total_and.is_forbidden( { "parent": values[0], "child": values[1], "child2": values[2], "child3": values[3] }, True, ) self.assertEqual(results[i], is_forbidden) self.assertFalse(total_and.is_forbidden({}, strict=False))
def test_with_ordinal(self): cs = smac.configspace.ConfigurationSpace() a = cs.add_hyperparameter( CategoricalHyperparameter('a', [0, 1], default_value=0)) b = cs.add_hyperparameter( OrdinalHyperparameter('b', [0, 1], default_value=1)) b = cs.add_hyperparameter( UniformFloatHyperparameter('c', lower=0., upper=1., default_value=1)) b = cs.add_hyperparameter( UniformIntegerHyperparameter('d', lower=0, upper=10, default_value=1)) cs.seed(1) feat_array = np.array([0, 0, 0]).reshape(1, -1) types, bounds = get_types(cs, feat_array) model = RandomForestWithInstances(types=types, bounds=bounds, instance_features=feat_array, seed=1, ratio_features=1.0, pca_components=9) self.assertEqual(bounds[0][0], 2) self.assertTrue(bounds[0][1] is np.nan) self.assertEqual(bounds[1][0], 0) self.assertEqual(bounds[1][1], 1) self.assertEqual(bounds[2][0], 0.) self.assertEqual(bounds[2][1], 1.) self.assertEqual(bounds[3][0], 0.) self.assertEqual(bounds[3][1], 1.) X = np.array([[0., 0., 0., 0., 0, 0, 0], [0., 0., 1., 0., 0, 0, 0], [0., 1., 0., 9., 0, 0, 0], [0., 1., 1., 4., 0, 0, 0]], dtype=np.float64) y = np.array([0, 1, 2, 3], dtype=np.float64) model.train(np.vstack((X, X, X, X, X, X, X, X, X, X)), np.vstack((y, y, y, y, y, y, y, y, y, y))) mean, _ = model.predict(X) for idx, m in enumerate(mean): self.assertAlmostEqual(y[idx], m, 0.05)
def test_sample_CategoricalHyperparameter(self): hp = CategoricalHyperparameter("chp", [0, 2, "Bla", u"Blub"]) def actual_test(): rs = np.random.RandomState(1) counts_per_bin = defaultdict(int) for i in range(10000): value = hp.sample(rs) counts_per_bin[value] += 1 self.assertEqual({ 0: 2456, 2: 2485, 'Bla': 2550, u'Blub': 2509 }, dict(counts_per_bin.items())) return counts_per_bin self.assertEqual(actual_test(), actual_test())
clf = svm.SVC(**cfg, random_state=42) scores = cross_val_score(clf, iris.data, iris.target, cv=5) return 1 - np.mean(scores) # Minimize! #logger = logging.getLogger("SVMExample") logging.basicConfig(level=logging.INFO) # logging.DEBUG for debug output # Build Configuration Space which defines all parameters and their ranges cs = ConfigurationSpace() # We define a few possible types of SVM-kernels and add them as "kernel" to our cs kernel = CategoricalHyperparameter("kernel", ["linear", "rbf", "poly", "sigmoid"], default_value="poly") cs.add_hyperparameter(kernel) # There are some hyperparameters shared by all kernels C = UniformFloatHyperparameter("C", 0.001, 1000.0, default_value=1.0) shrinking = CategoricalHyperparameter("shrinking", ["true", "false"], default_value="true") cs.add_hyperparameters([C, shrinking]) # Others are kernel-specific, so we can add conditions to limit the searchspace degree = UniformIntegerHyperparameter( "degree", 1, 5, default_value=3) # Only used by kernel poly coef0 = UniformFloatHyperparameter("coef0", 0.0, 10.0, default_value=0.0) # poly, sigmoid cs.add_hyperparameters([degree, coef0])
def test_greater_and_less_condition(self): child = Constant('child', 'child') hp1 = UniformFloatHyperparameter("float", 0, 5) hp2 = UniformIntegerHyperparameter("int", 0, 5) hp3 = OrdinalHyperparameter("ord", list(range(6))) for hp in [hp1, hp2, hp3]: hyperparameter_idx = {child.name: 0, hp.name: 1} gt = GreaterThanCondition(child, hp, 1) gt.set_vector_idx(hyperparameter_idx) self.assertFalse(gt.evaluate({hp.name: 0})) self.assertTrue(gt.evaluate({hp.name: 2})) self.assertFalse(gt.evaluate({hp.name: None})) # Evaluate vector test_value = hp._inverse_transform(2) self.assertFalse(gt.evaluate_vector(np.array([np.NaN, 0]))) self.assertTrue(gt.evaluate_vector(np.array([np.NaN, test_value]))) self.assertFalse(gt.evaluate_vector(np.array([np.NaN, np.NaN]))) lt = LessThanCondition(child, hp, 1) lt.set_vector_idx(hyperparameter_idx) self.assertTrue(lt.evaluate({hp.name: 0})) self.assertFalse(lt.evaluate({hp.name: 2})) self.assertFalse(lt.evaluate({hp.name: None})) # Evaluate vector test_value = hp._inverse_transform(2) self.assertTrue(lt.evaluate_vector(np.array([np.NaN, 0, 0, 0]))) self.assertFalse(lt.evaluate_vector(np.array([np.NaN, test_value]))) self.assertFalse(lt.evaluate_vector(np.array([np.NaN, np.NaN]))) hp4 = CategoricalHyperparameter("cat", list(range(6))) self.assertRaisesRegexp( ValueError, "Parent hyperparameter in a > or < " "condition must be a subclass of " "NumericalHyperparameter or " "OrdinalHyperparameter, but is " "<cdef class 'ConfigSpaceNNI.hyperparameters.CategoricalHyperparameter'>", GreaterThanCondition, child, hp4, 1) self.assertRaisesRegexp( ValueError, "Parent hyperparameter in a > or < " "condition must be a subclass of " "NumericalHyperparameter or " "OrdinalHyperparameter, but is " "<cdef class 'ConfigSpaceNNI.hyperparameters.CategoricalHyperparameter'>", LessThanCondition, child, hp4, 1) hp5 = OrdinalHyperparameter("ord", ['cold', 'luke warm', 'warm', 'hot']) hyperparameter_idx = {child.name: 0, hp5.name: 1} gt = GreaterThanCondition(child, hp5, 'warm') gt.set_vector_idx(hyperparameter_idx) self.assertTrue(gt.evaluate({hp5.name: 'hot'})) self.assertFalse(gt.evaluate({hp5.name: 'cold'})) self.assertTrue(gt.evaluate_vector(np.array([np.NaN, 3]))) self.assertFalse(gt.evaluate_vector(np.array([np.NaN, 0]))) lt = LessThanCondition(child, hp5, 'warm') lt.set_vector_idx(hyperparameter_idx) self.assertTrue(lt.evaluate({hp5.name: 'luke warm'})) self.assertFalse(lt.evaluate({hp5.name: 'warm'})) self.assertTrue(lt.evaluate_vector(np.array([np.NaN, 1]))) self.assertFalse(lt.evaluate_vector(np.array([np.NaN, 2])))
def test_in_condition(self): hp1 = CategoricalHyperparameter("parent", [0, 1, 2, 3, 4]) hp2 = UniformIntegerHyperparameter("child", 0, 10) hp3 = UniformIntegerHyperparameter("child2", 0, 10) hp4 = CategoricalHyperparameter("grandchild", ["hot", "cold", "warm"]) self.assertRaisesRegexp( TypeError, "Argument 'hyperparameter' has incorrect type \(expected ConfigSpaceNNI.hyperparameters.Hyperparameter, got str\)", ForbiddenInClause, "HP1", 1, ) self.assertRaisesRegexp( ValueError, "Forbidden clause must be instantiated with a " "legal hyperparameter value for " "'parent, Type: Categorical, Choices: {0, 1, 2, 3, 4}, " "Default: 0', but got '5'", ForbiddenInClause, hp1, [5], ) forb1 = ForbiddenInClause(hp2, [5, 6, 7, 8, 9]) forb1_ = ForbiddenInClause(hp2, [9, 8, 7, 6, 5]) forb2 = ForbiddenInClause(hp2, [5, 6, 7, 8]) forb3 = ForbiddenInClause(hp3, [5, 6, 7, 8, 9]) forb4 = ForbiddenInClause(hp4, ["hot", "cold"]) forb4_ = ForbiddenInClause(hp4, ["hot", "cold"]) forb5 = ForbiddenInClause(hp1, [3, 4]) forb5_ = ForbiddenInClause(hp1, [3, 4]) self.assertEqual(forb5, forb5_) self.assertEqual(forb4, forb4_) # print("\nTest1:") self.assertEqual(forb1, forb1_) # print("\nTest2:") self.assertNotEqual(forb1, forb2) # print("\nTest3:") self.assertNotEqual(forb1, forb3) # print("\nTest4:") self.assertEqual("Forbidden: child in {5, 6, 7, 8, 9}", str(forb1)) # print("\nTest5:") self.assertRaisesRegexp( ValueError, "Is_forbidden must be called with the " "instanstatiated hyperparameter in the " "forbidden clause; you are missing " "'child'", forb1.is_forbidden, {'parent': 1}, True) # print("\nTest6:") self.assertFalse(forb1.is_forbidden({'parent': 1}, strict=False)) # print("\nTest7:") for i in range(0, 5): self.assertFalse(forb1.is_forbidden({'child': i}, True)) # print("\nTest8:") for i in range(5, 10): self.assertTrue(forb1.is_forbidden({'child': i}, True)) # Test forbidden on vector values hyperparameter_idx = {hp1.name: 0, hp2.name: 1} forb1.set_vector_idx(hyperparameter_idx) # print("\nTest9:") self.assertFalse( forb1.is_forbidden_vector(np.array([np.NaN, np.NaN]), strict=False)) # print("\nTest10:") self.assertFalse( forb1.is_forbidden_vector(np.array([np.NaN, 0]), strict=False)) correct_vector_value = hp2._inverse_transform(6) # print("\nTest11:") print(correct_vector_value, np.array([np.NaN, correct_vector_value])) self.assertTrue( forb1.is_forbidden_vector(np.array([np.NaN, correct_vector_value]), strict=False))
def test_categorical_strings(self): f1 = CategoricalHyperparameter("param", ["a", "b"]) f1_ = CategoricalHyperparameter("param", ["a", "b"]) self.assertEqual(f1, f1_) self.assertEqual( "param, Type: Categorical, Choices: {a, b}, Default: a", str(f1))
def test_forbidden_equals_clause(self): hp1 = CategoricalHyperparameter("parent", [0, 1]) hp2 = UniformIntegerHyperparameter("child", 0, 10) hp3 = CategoricalHyperparameter("grandchild", ["hot", "cold"]) self.assertRaisesRegexp( TypeError, "Argument 'hyperparameter' has incorrect type \(expected ConfigSpaceNNI.hyperparameters.Hyperparameter, got str\)", ForbiddenEqualsClause, "HP1", 1, ) self.assertRaisesRegexp( ValueError, "Forbidden clause must be instantiated with a legal hyperparameter value for " "'parent, Type: Categorical, Choices: \{0, 1\}, Default: 0', but got '2'", ForbiddenEqualsClause, hp1, 2, ) forb1 = ForbiddenEqualsClause(hp1, 1) forb1_ = ForbiddenEqualsClause(hp1, 1) forb1__ = ForbiddenEqualsClause(hp1, 0) forb2 = ForbiddenEqualsClause(hp2, 10) forb3 = ForbiddenEqualsClause(hp3, "hot") forb3_ = ForbiddenEqualsClause(hp3, "hot") self.assertEqual(forb3, forb3_) # print("\eq0:", 1, 1) # self.assertEqual(1, 1) # print("\neq1:", forb1, forb1_) self.assertEqual(forb1, forb1_) # print("\nneq2:", forb1, "forb1") self.assertNotEqual(forb1, "forb1") # print("\nneq3:", forb1, forb2) self.assertNotEqual(forb1, forb2) # print("\nneq4:", forb1_, forb1) self.assertNotEqual(forb1__, forb1) # print("\neq5:", "Forbidden: parent == 1", str(forb1)) self.assertEqual("Forbidden: parent == 1", str(forb1)) # print("\nraisereg6:") self.assertRaisesRegexp( ValueError, "Is_forbidden must be called with the " "instanstatiated hyperparameter in the " "forbidden clause; you are missing " "'parent'", forb1.is_forbidden, {1: hp2}, True) # print("\nneq7:") self.assertFalse(forb1.is_forbidden({'child': 1}, strict=False)) # print("\nneq8:") self.assertFalse(forb1.is_forbidden({'parent': 0}, True)) # print("\nneq9:") self.assertTrue(forb1.is_forbidden({'parent': 1}, True)) # Test forbidden on vector values hyperparameter_idx = {hp1.name: 0, hp2.name: 1} forb1.set_vector_idx(hyperparameter_idx) # print("\nneq10:") self.assertFalse( forb1.is_forbidden_vector(np.array([np.NaN, np.NaN]), strict=False)) # print("\nneq11:") self.assertFalse( forb1.is_forbidden_vector(np.array([0., np.NaN]), strict=False)) # print("\nneq12:") self.assertTrue( forb1.is_forbidden_vector(np.array([1., np.NaN]), strict=False))