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