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 get_hyperparameter_search_space(dataset_properties=None):
n_components = UniformIntegerHyperparameter("n_components",
10,
2000,
default_value=100)
kernel = CategoricalHyperparameter(
'kernel', ['poly', 'rbf', 'sigmoid', 'cosine'], 'rbf')
gamma = UniformFloatHyperparameter(
"gamma",
3.0517578125e-05,
8,
log=True,
default_value=1.0,
)
degree = UniformIntegerHyperparameter('degree', 2, 5, 3)
coef0 = UniformFloatHyperparameter("coef0", -1, 1, default_value=0)
cs = ConfigurationSpace()
cs.add_hyperparameters([n_components, kernel, degree, gamma, coef0])
degree_depends_on_poly = EqualsCondition(degree, kernel, "poly")
coef0_condition = InCondition(coef0, kernel, ["poly", "sigmoid"])
gamma_condition = InCondition(gamma, kernel, ["poly", "rbf"])
cs.add_conditions(
[degree_depends_on_poly, coef0_condition, gamma_condition])
return cs
def get_hyperparameter_search_space(dataset_properties=None, optimizer='smac'):
if dataset_properties is not None and \
(dataset_properties.get("sparse") is True or
dataset_properties.get("signed") is False):
allow_chi2 = False
else:
allow_chi2 = True
possible_kernels = ['poly', 'rbf', 'sigmoid', 'cosine']
if allow_chi2:
possible_kernels.append("chi2")
kernel = CategoricalHyperparameter('kernel', possible_kernels, 'rbf')
n_components = UniformIntegerHyperparameter(
"n_components", 50, 5000, default_value=100, log=True)
gamma = UniformFloatHyperparameter("gamma", 3.0517578125e-05, 8,
log=True, default_value=0.1)
degree = UniformIntegerHyperparameter('degree', 2, 5, 3)
coef0 = UniformFloatHyperparameter("coef0", -1, 1, default_value=0)
cs = ConfigurationSpace()
cs.add_hyperparameters([kernel, degree, gamma, coef0, n_components])
degree_depends_on_poly = EqualsCondition(degree, kernel, "poly")
coef0_condition = InCondition(coef0, kernel, ["poly", "sigmoid"])
gamma_kernels = ["poly", "rbf", "sigmoid"]
if allow_chi2:
gamma_kernels.append("chi2")
gamma_condition = InCondition(gamma, kernel, gamma_kernels)
cs.add_conditions([degree_depends_on_poly, coef0_condition, gamma_condition])
return cs
def get_hyperparameter_search_space(**kwargs):
n_components_factor = UniformFloatHyperparameter("n_components_factor",
0.,
1.,
default_value=1.)
kernel = CategoricalHyperparameter(
'kernel', ['poly', 'rbf', 'sigmoid', 'cosine'], 'rbf')
gamma = UniformFloatHyperparameter("gamma",
3.0517578125e-05,
8,
log=True,
default_value=1.0)
degree = UniformIntegerHyperparameter('degree', 2, 5, 3)
coef0 = UniformFloatHyperparameter("coef0", -1., 1., default_value=0.)
cs = ConfigurationSpace()
cs.add_hyperparameters(
[n_components_factor, kernel, degree, gamma, coef0])
degree_depends_on_poly = EqualsCondition(degree, kernel, "poly")
coef0_condition = InCondition(coef0, kernel, ["poly", "sigmoid"])
gamma_condition = InCondition(gamma, kernel, ["poly", "rbf"])
cs.add_conditions(
[degree_depends_on_poly, coef0_condition, gamma_condition])
return cs
def get_cs():
C = UniformFloatHyperparameter("C", 0.03125, 32768, log=True,
default_value=1.0)
# No linear kernel here, because we have liblinear
kernel = CategoricalHyperparameter(name="kernel",
choices=["rbf", "poly", "sigmoid"],
default_value="rbf")
degree = UniformIntegerHyperparameter("degree", 2, 5, default_value=3)
gamma = UniformFloatHyperparameter("gamma", 3.0517578125e-05, 8,
log=True, default_value=0.1)
coef0 = UniformFloatHyperparameter("coef0", -1, 1, default_value=0)
shrinking = CategoricalHyperparameter("shrinking", ["True", "False"],
default_value="True")
tol = UniformFloatHyperparameter("tol", 1e-5, 1e-1, default_value=1e-3,
log=True)
# cache size is not a hyperparameter, but an argument to the program!
max_iter = UnParametrizedHyperparameter("max_iter", 10000)
cs = ConfigurationSpace()
cs.add_hyperparameters([C, kernel, degree, gamma, coef0, shrinking,
tol, max_iter])
degree_depends_on_poly = EqualsCondition(degree, kernel, "poly")
coef0_condition = InCondition(coef0, kernel, ["poly", "sigmoid"])
cs.add_condition(degree_depends_on_poly)
cs.add_condition(coef0_condition)
return cs
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 condition_specification(child_name, condition, configuration_space):
# specifies the condition type
child = configuration_space.get_hyperparameter(child_name)
parent_name = condition[0]
parent = configuration_space.get_hyperparameter(parent_name)
operation = condition[1]
if operation == 'in':
restrictions = condition[3:-1:2]
for i in range(len(restrictions)):
if isinstance(parent, FloatHyperparameter):
restrictions[i] = float(restrictions[i])
elif isinstance(parent, IntegerHyperparameter):
restrictions[i] = int(restrictions[i])
if len(restrictions) == 1:
condition = EqualsCondition(child, parent, restrictions[0])
else:
condition = InCondition(child, parent, values=restrictions)
return condition
else:
restrictions = condition[2]
if isinstance(parent, FloatHyperparameter):
restrictions = float(restrictions)
elif isinstance(parent, IntegerHyperparameter):
restrictions = int(restrictions)
if operation == '==':
condition = EqualsCondition(child, parent, restrictions)
elif operation == '!=':
condition = NotEqualsCondition(child, parent, restrictions)
else:
if isinstance(parent, FloatHyperparameter):
restrictions = float(restrictions)
elif isinstance(parent, IntegerHyperparameter):
restrictions = int(restrictions)
elif isinstance(parent, OrdinalHyperparameter):
pass
else:
raise ValueError('The parent of a conditional hyperparameter '
'must be either a float, int or ordinal '
'hyperparameter, but is %s.' % type(parent))
if operation == '<':
condition = LessThanCondition(child, parent, restrictions)
elif operation == '>':
condition = GreaterThanCondition(child, parent, restrictions)
return condition
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
loss = CategoricalHyperparameter("loss",
["hinge", "log", "modified_huber", "squared_hinge", "perceptron"],
default_value="log")
penalty = CategoricalHyperparameter(
"penalty", ["l1", "l2", "elasticnet"], default_value="l2")
alpha = UniformFloatHyperparameter(
"alpha", 1e-7, 1e-1, log=True, default_value=0.0001)
l1_ratio = UniformFloatHyperparameter(
"l1_ratio", 1e-9, 1, log=True, default_value=0.15)
fit_intercept = UnParametrizedHyperparameter("fit_intercept", "True")
tol = UniformFloatHyperparameter("tol", 1e-5, 1e-1, log=True,
default_value=1e-4)
epsilon = UniformFloatHyperparameter(
"epsilon", 1e-5, 1e-1, default_value=1e-4, log=True)
learning_rate = CategoricalHyperparameter(
"learning_rate", ["optimal", "invscaling", "constant"],
default_value="invscaling")
eta0 = UniformFloatHyperparameter(
"eta0", 1e-7, 1e-1, default_value=0.01, log=True)
power_t = UniformFloatHyperparameter("power_t", 1e-5, 1,
default_value=0.5)
average = CategoricalHyperparameter(
"average", ["False", "True"], default_value="False")
cs.add_hyperparameters([loss, penalty, alpha, l1_ratio, fit_intercept,
tol, epsilon, learning_rate, eta0, power_t,
average])
# TODO add passive/aggressive here, although not properly documented?
elasticnet = EqualsCondition(l1_ratio, penalty, "elasticnet")
epsilon_condition = EqualsCondition(epsilon, loss, "modified_huber")
power_t_condition = EqualsCondition(power_t, learning_rate,
"invscaling")
# eta0 is only relevant if learning_rate!='optimal' according to code
# https://github.com/scikit-learn/scikit-learn/blob/0.19.X/sklearn/
# linear_model/sgd_fast.pyx#L603
eta0_in_inv_con = InCondition(eta0, learning_rate, ["invscaling",
"constant"])
cs.add_conditions([elasticnet, epsilon_condition, power_t_condition,
eta0_in_inv_con])
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 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='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 get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
loss = CategoricalHyperparameter("loss", ["least_squares"],
default_value="least_squares")
learning_rate = UniformFloatHyperparameter(name="learning_rate",
lower=0.01,
upper=1,
default_value=0.1,
log=True)
min_samples_leaf = UniformIntegerHyperparameter(
name="min_samples_leaf",
lower=1,
upper=200,
default_value=20,
log=True)
max_depth = UnParametrizedHyperparameter(name="max_depth",
value="None")
max_leaf_nodes = UniformIntegerHyperparameter(name="max_leaf_nodes",
lower=3,
upper=2047,
default_value=31,
log=True)
max_bins = Constant("max_bins", 255)
l2_regularization = UniformFloatHyperparameter(
name="l2_regularization",
lower=1E-10,
upper=1,
default_value=1E-10,
log=True)
early_stop = CategoricalHyperparameter(
name="early_stop",
choices=["off", "valid", "train"],
default_value="off")
tol = UnParametrizedHyperparameter(name="tol", value=1e-7)
scoring = UnParametrizedHyperparameter(name="scoring", value="loss")
n_iter_no_change = UniformIntegerHyperparameter(
name="n_iter_no_change", lower=1, upper=20, default_value=10)
validation_fraction = UniformFloatHyperparameter(
name="validation_fraction",
lower=0.01,
upper=0.4,
default_value=0.1)
cs.add_hyperparameters([
loss, learning_rate, min_samples_leaf, max_depth, max_leaf_nodes,
max_bins, l2_regularization, early_stop, tol, scoring,
n_iter_no_change, validation_fraction
])
n_iter_no_change_cond = InCondition(n_iter_no_change, early_stop,
["valid", "train"])
validation_fraction_cond = EqualsCondition(validation_fraction,
early_stop, "valid")
cs.add_conditions([n_iter_no_change_cond, validation_fraction_cond])
return cs
def _construct_eq_condition(
condition: Dict,
cs: ConfigurationSpace,
) -> EqualsCondition:
return EqualsCondition(
child=cs.get_hyperparameter(condition['child']),
parent=cs.get_hyperparameter(condition['parent']),
value=condition['value'],
)
def add_optional_hyperparameter(self: ConfigurationSpace,
hyperparam: Hyperparameter,
is_enabled_default=False):
enable_param = CategoricalHyperparameter(hyperparam.name + '__enable',
[True, False],
default_value=is_enabled_default)
self.add_hyperparameters([enable_param, hyperparam])
self.add_condition(EqualsCondition(hyperparam, enable_param, True))
return hyperparam
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
loss = cs.add_hyperparameter(CategoricalHyperparameter("loss",
["hinge", "log", "modified_huber", "squared_hinge", "perceptron"],
default="log"))
penalty = cs.add_hyperparameter(CategoricalHyperparameter(
"penalty", ["l1", "l2", "elasticnet"], default="l2"))
alpha = cs.add_hyperparameter(UniformFloatHyperparameter(
"alpha", 10e-7, 1e-1, log=True, default=0.0001))
l1_ratio = cs.add_hyperparameter(UniformFloatHyperparameter(
"l1_ratio", 1e-9, 1, log=True, default=0.15))
fit_intercept = cs.add_hyperparameter(UnParametrizedHyperparameter(
"fit_intercept", "True"))
n_iter = cs.add_hyperparameter(UniformIntegerHyperparameter(
"n_iter", 5, 1000, log=True, default=20))
epsilon = cs.add_hyperparameter(UniformFloatHyperparameter(
"epsilon", 1e-5, 1e-1, default=1e-4, log=True))
learning_rate = cs.add_hyperparameter(CategoricalHyperparameter(
"learning_rate", ["optimal", "invscaling", "constant"],
default="optimal"))
eta0 = cs.add_hyperparameter(UniformFloatHyperparameter(
"eta0", 10**-7, 0.1, default=0.01))
power_t = cs.add_hyperparameter(UniformFloatHyperparameter(
"power_t", 1e-5, 1, default=0.25))
average = cs.add_hyperparameter(CategoricalHyperparameter(
"average", ["False", "True"], default="False"))
# TODO add passive/aggressive here, although not properly documented?
elasticnet = EqualsCondition(l1_ratio, penalty, "elasticnet")
epsilon_condition = EqualsCondition(epsilon, loss, "modified_huber")
# eta0 seems to be always active according to the source code; when
# learning_rate is set to optimial, eta0 is the starting value:
# https://github.com/scikit-learn/scikit-learn/blob/0.15.X/sklearn/linear_model/sgd_fast.pyx
#eta0_and_inv = EqualsCondition(eta0, learning_rate, "invscaling")
#eta0_and_constant = EqualsCondition(eta0, learning_rate, "constant")
#eta0_condition = OrConjunction(eta0_and_inv, eta0_and_constant)
power_t_condition = EqualsCondition(power_t, learning_rate, "invscaling")
cs.add_condition(elasticnet)
cs.add_condition(epsilon_condition)
cs.add_condition(power_t_condition)
return cs
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 get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
use_minimum_fraction = CategoricalHyperparameter(
"use_minimum_fraction", ["True", "False"], default_value="True")
minimum_fraction = UniformFloatHyperparameter(
"minimum_fraction", lower=.0001, upper=0.5, default_value=0.01, log=True)
cs.add_hyperparameters([use_minimum_fraction, minimum_fraction])
cs.add_condition(EqualsCondition(minimum_fraction,
use_minimum_fraction, 'True'))
return cs
def get_libsvm_svc_default_search_space():
classif_prefix = "classifier:libsvm_svc:"
model_type = CategoricalHyperparameter('classifier:__choice__',
['libsvm_svc'])
imputation = CategoricalHyperparameter('imputation:strategy',
['mean', 'median', 'most_frequent'])
C = UniformFloatHyperparameter(classif_prefix + "C",
0.03125,
32768,
log=True,
default_value=1.0)
# No linear kernel here, because we have liblinear
kernel = CategoricalHyperparameter(name=classif_prefix + "kernel",
choices=["rbf", "poly", "sigmoid"],
default_value="rbf")
degree = UniformIntegerHyperparameter(classif_prefix + "degree",
2,
5,
default_value=3)
gamma = UniformFloatHyperparameter(classif_prefix + "gamma",
3.0517578125e-05,
8,
log=True,
default_value=0.1)
# TODO this is totally ad-hoc
coef0 = UniformFloatHyperparameter(classif_prefix + "coef0",
-1,
1,
default_value=0)
# probability is no hyperparameter, but an argument to the SVM algo
shrinking = CategoricalHyperparameter(classif_prefix + "shrinking",
["True", "False"],
default_value="True")
tol = UniformFloatHyperparameter(classif_prefix + "tol",
1e-5,
1e-1,
default_value=1e-3,
log=True)
# cache size is not a hyperparameter, but an argument to the program!
max_iter = UnParametrizedHyperparameter(classif_prefix + "max_iter", -1)
cs = ConfigurationSpace()
cs.add_hyperparameters([
model_type, imputation, C, kernel, degree, gamma, coef0, shrinking,
tol, max_iter
])
degree_depends_on_poly = EqualsCondition(degree, kernel, "poly")
coef0_condition = InCondition(coef0, kernel, ["poly", "sigmoid"])
cs.add_condition(degree_depends_on_poly)
cs.add_condition(coef0_condition)
return cs
def get_hyperparameter_search_space(dataset_properties=None, optimizer='tpe'):
method = CategoricalHyperparameter("method", ['average', 'weighted'], default_value='weighted')
alpha = UniformFloatHyperparameter("alpha", 1e-5, 1e-3, log=True, default_value=1e-4)
cs = ConfigurationSpace()
cs.add_hyperparameters([method, alpha])
alpha_cond = EqualsCondition(alpha, method, 'weighted')
cs.add_conditions([alpha_cond])
return cs
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
shrinkage = CategoricalHyperparameter(
"shrinkage", ["None", "auto", "manual"], default_value="None")
shrinkage_factor = UniformFloatHyperparameter(
"shrinkage_factor", 0., 1., 0.5)
tol = UniformFloatHyperparameter("tol", 1e-5, 1e-1, default_value=1e-4, log=True)
cs.add_hyperparameters([shrinkage, shrinkage_factor, tol])
cs.add_condition(EqualsCondition(shrinkage_factor, shrinkage, "manual"))
return cs
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 get_cs():
cs = ConfigurationSpace()
shrinkage = CategoricalHyperparameter(
"shrinkage", ["None", "auto", "manual"], default_value="None")
shrinkage_factor = UniformFloatHyperparameter(
"shrinkage_factor", 0., 1., 0.5)
n_components = UniformIntegerHyperparameter('n_components', 1, 250, default_value=10)
tol = UniformFloatHyperparameter("tol", 1e-5, 1e-1, default_value=1e-4, log=True)
cs.add_hyperparameters([shrinkage, shrinkage_factor, n_components, tol])
cs.add_condition(EqualsCondition(shrinkage_factor, shrinkage, "manual"))
return cs
def load_primitive_configspace(configspace, primitive_name):
default_configspace = load_default_configspace(primitive_name)
all_hyperparameters = load_hyperparameters(primitive_name)
default_hyperparameters = set(
default_configspace.get_hyperparameter_names())
casted_hyperparameters = []
union_conditions = []
for hp_name in all_hyperparameters:
new_hp_name = primitive_name + '|' + hp_name
if not isinstance(all_hyperparameters[hp_name], Union):
new_hp = default_configspace.get_hyperparameter(new_hp_name) if new_hp_name in default_hyperparameters \
else None
casted_hp = cast_hyperparameter(all_hyperparameters[hp_name],
new_hp_name)
if casted_hp is not None:
if new_hp is not None and casted_hp.is_legal(
new_hp.default_value):
casted_hyperparameters.append(new_hp)
else:
casted_hyperparameters.append(casted_hp)
elif isinstance(all_hyperparameters[hp_name], Union):
hyperparameter_class = all_hyperparameters[hp_name]
add_case = False
case_choices = []
cases_param_space = []
for case, case_class in hyperparameter_class.configuration.items():
new_hp = None
if new_hp_name + '|' + case in default_hyperparameters:
new_hp = default_configspace.get_hyperparameter(
new_hp_name + '|' + case)
casted_hp = cast_hyperparameter(case_class,
new_hp_name + '|' + case)
if casted_hp is not None:
add_case = True
case_choices.append(case)
if new_hp is not None and casted_hp.is_legal(
new_hp.default_value):
casted_hyperparameters.append(new_hp)
cases_param_space.append(new_hp)
else:
casted_hyperparameters.append(casted_hp)
cases_param_space.append(casted_hp)
if add_case:
case_hyperparameter = CategoricalHyperparameter(
name=new_hp_name + '|case',
choices=case_choices,
default_value=case_choices[0])
for i in range(len(case_choices)):
union_conditions.append(
EqualsCondition(cases_param_space[i],
case_hyperparameter, case_choices[i]))
casted_hyperparameters.append(case_hyperparameter)
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_equals_condition_categorical(self):
expected = "ls '--ls ' c {sa,ca,ny}\ntemp '--temp ' r (0.500000, 1.000000)| ls==sa\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 = EqualsCondition(temp, ls, 'sa')
cs.add_condition(c1)
value = irace.write(cs)
self.assertEqual(expected, value)
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
shrinkage = cs.add_hyperparameter(CategoricalHyperparameter(
"shrinkage", ["None", "auto", "manual"], default="None"))
shrinkage_factor = cs.add_hyperparameter(UniformFloatHyperparameter(
"shrinkage_factor", 0., 1., 0.5))
n_components = cs.add_hyperparameter(UniformIntegerHyperparameter(
'n_components', 1, 250, default=10))
tol = cs.add_hyperparameter(UniformFloatHyperparameter(
"tol", 1e-5, 1e-1, default=1e-4, log=True))
cs.add_condition(EqualsCondition(shrinkage_factor, shrinkage, "manual"))
return cs
def add_component_deepcopy(config_space, prefix, component_space):
# We have to retrieve the configuration space every time because
# we change the objects it returns. If we reused it, we could not
# retrieve the conditions further down
# TODO implement copy for hyperparameters and forbidden and
# conditions!
component = config_space.get_hyperparameter("__choice__")
for parameter in component_space.get_hyperparameters():
new_parameter = copy.deepcopy(parameter)
new_parameter.name = "%s:%s" % (prefix,
new_parameter.name)
config_space.add_hyperparameter(new_parameter)
# We must only add a condition if the hyperparameter is not
# conditional on something else
if len(component_space.get_parents_of(parameter)) == 0:
condition = EqualsCondition(new_parameter, component,
prefix)
config_space.add_condition(condition)
space_copy = copy.deepcopy(component_space)
for condition in space_copy.get_conditions():
dlcs = condition.get_descendant_literal_conditions()
for dlc in dlcs:
if not dlc.child.name.startswith(prefix):
dlc.child.name = "%s:%s" % (
prefix, dlc.child.name)
if not dlc.parent.name.startswith(prefix):
dlc.parent.name = "%s:%s" % (
prefix, dlc.parent.name)
config_space.add_condition(condition)
space_copy = copy.deepcopy(component_space)
for forbidden_clause in space_copy.forbidden_clauses:
dlcs = forbidden_clause.get_descendant_literal_clauses()
for dlc in dlcs:
if not dlc.hyperparameter.name.startswith(prefix):
dlc.hyperparameter.name = "%s:%s" % (prefix,
dlc.hyperparameter.name)
config_space.add_forbidden_clause(forbidden_clause)
return config_space
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_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_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 __condition(self, item: Dict, store: Dict):
child = item["_child"]
child = store[child]
parent = item["_parent"]
parent = store[parent]
value = (item["_values"])
if (isinstance(value, list) and len(value) == 1):
value = value[0]
if isinstance(value, list):
cond = InCondition(child, parent, list(map(smac_hdl._encode,
value)))
else:
cond = EqualsCondition(child, parent, smac_hdl._encode(value))
return cond
def get_hyperparameter_search_space(dataset_properties=None, optimizer='smac'):
if optimizer == 'smac':
C = UniformFloatHyperparameter("C", 0.03125, 32768, log=True,
default_value=1.0)
# No linear kernel here, because we have liblinear
kernel = CategoricalHyperparameter(name="kernel",
choices=["rbf", "poly", "sigmoid"],
default_value="rbf")
degree = UniformIntegerHyperparameter("degree", 2, 5, default_value=3)
gamma = UniformFloatHyperparameter("gamma", 3.0517578125e-05, 8,
log=True, default_value=0.1)
coef0 = UniformFloatHyperparameter("coef0", -1, 1, default_value=0)
shrinking = CategoricalHyperparameter("shrinking", ["True", "False"],
default_value="True")
tol = UniformFloatHyperparameter("tol", 1e-5, 1e-1, default_value=1e-3,
log=True)
# cache size is not a hyperparameter, but an argument to the program!
max_iter = UnParametrizedHyperparameter("max_iter", 2000)
cs = ConfigurationSpace()
cs.add_hyperparameters([C, kernel, degree, gamma, coef0, shrinking,
tol, max_iter])
degree_depends_on_poly = EqualsCondition(degree, kernel, "poly")
coef0_condition = InCondition(coef0, kernel, ["poly", "sigmoid"])
cs.add_condition(degree_depends_on_poly)
cs.add_condition(coef0_condition)
return cs
elif optimizer == 'tpe':
coef0 = hp.uniform("libsvm_coef0", -1, 1)
space = {'C': hp.loguniform('libsvm_C', np.log(0.03125), np.log(32768)),
'gamma': hp.loguniform('libsvm_gamma', np.log(3.0517578125e-5), np.log(8)),
'shrinking': hp.choice('libsvm_shrinking', ["True", "False"]),
'tol': hp.loguniform('libsvm_tol', np.log(1e-5), np.log(1e-1)),
'max_iter': hp.choice('libsvm_max_iter', [2000]),
'kernel': hp.choice('libsvm_kernel',
[("poly", {'degree': hp.randint('libsvm_degree', 4) + 2, 'coef0': coef0}),
("rbf", {}),
("sigmoid", {'coef0': coef0})])}
init_trial = {'C': 1,
'gamma': 0.1,
'shrinking': "True",
'tol': 1e-3,
'max_iter': 2000,
'kernel': ("rbf", {})}
return space
def test_or_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("Or", "True")
cond1 = EqualsCondition(hp4, hp1, 1)
self.assertRaises(ValueError, OrConjunction, cond1)
cond2 = EqualsCondition(hp4, hp2, 1)
cond3 = EqualsCondition(hp4, hp3, 1)
andconj1 = OrConjunction(cond1, cond2)
andconj1_ = OrConjunction(cond1, cond2)
self.assertEqual(andconj1, andconj1_)
andconj2 = OrConjunction(cond2, cond3)
self.assertNotEqual(andconj1, andconj2)
andconj3 = OrConjunction(cond1, cond2, cond3)
self.assertEqual("(Or | input1 == 1 || Or | input2 == 1 || Or | "
"input3 == 1)", str(andconj3))
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
n_components = UniformIntegerHyperparameter(
"n_components", 10, 2000, default_value=100)
algorithm = CategoricalHyperparameter('algorithm',
['parallel', 'deflation'], 'parallel')
whiten = CategoricalHyperparameter('whiten',
['False', 'True'], 'False')
fun = CategoricalHyperparameter(
'fun', ['logcosh', 'exp', 'cube'], 'logcosh')
cs.add_hyperparameters([n_components, algorithm, whiten, fun])
cs.add_condition(EqualsCondition(n_components, whiten, "True"))
return cs
def get_hyperparameter_search_space(cls, dataset_properties=None,
default=None,
include=None,
exclude=None):
cs = ConfigurationSpace()
# Compile a list of legal preprocessors for this problem
available_preprocessors = cls.get_available_components(
data_prop=dataset_properties,
include=include, exclude=exclude)
if len(available_preprocessors) == 0:
raise ValueError(
"No rescaling algorithm found.")
if default is None:
defaults = ['min/max', 'standardize', 'none', 'normalize']
for default_ in defaults:
if default_ in available_preprocessors:
default = default_
break
preprocessor = CategoricalHyperparameter('__choice__',
list(
available_preprocessors.keys()),
default=default)
cs.add_hyperparameter(preprocessor)
for name in available_preprocessors:
preprocessor_configuration_space = available_preprocessors[name]. \
get_hyperparameter_search_space(dataset_properties)
for parameter in preprocessor_configuration_space.get_hyperparameters():
new_parameter = copy.deepcopy(parameter)
new_parameter.name = "%s:%s" % (name, new_parameter.name)
cs.add_hyperparameter(new_parameter)
# We must only add a condition if the hyperparameter is not
# conditional on something else
if len(preprocessor_configuration_space.
get_parents_of(parameter)) == 0:
condition = EqualsCondition(new_parameter, preprocessor,
name)
cs.add_condition(condition)
for condition in available_preprocessors[name]. \
get_hyperparameter_search_space(
dataset_properties).get_conditions():
if not isinstance(condition, AbstractConjunction):
dlcs = [condition]
else:
dlcs = condition.get_descendent_literal_conditions()
for dlc in dlcs:
if not dlc.child.name.startswith(name):
dlc.child.name = "%s:%s" % (name, dlc.child.name)
if not dlc.parent.name.startswith(name):
dlc.parent.name = "%s:%s" % (name, dlc.parent.name)
cs.add_condition(condition)
for forbidden_clause in available_preprocessors[name]. \
get_hyperparameter_search_space(
dataset_properties).forbidden_clauses:
dlcs = forbidden_clause.get_descendant_literal_clauses()
for dlc in dlcs:
if not dlc.hyperparameter.name.startswith(name):
dlc.hyperparameter.name = "%s:%s" % (name,
dlc.hyperparameter.name)
cs.add_forbidden_clause(forbidden_clause)
return cs
def get_hyperparameter_search_space(cls, dataset_properties,
default=None,
include=None,
exclude=None):
if include is not None and exclude is not None:
raise ValueError("The argument include and exclude cannot be used together.")
cs = ConfigurationSpace()
# Compile a list of all estimator objects for this problem
available_estimators = cls.get_available_components(
data_prop=dataset_properties,
include=include,
exclude=exclude)
if len(available_estimators) == 0:
raise ValueError("No regressors found")
if default is None:
defaults = ['random_forest', 'support_vector_regression'] + \
list(available_estimators.keys())
for default_ in defaults:
if default_ in available_estimators:
if include is not None and default_ not in include:
continue
if exclude is not None and default_ in exclude:
continue
default = default_
break
estimator = CategoricalHyperparameter('__choice__',
list(available_estimators.keys()),
default=default)
cs.add_hyperparameter(estimator)
for estimator_name in available_estimators.keys():
# We have to retrieve the configuration space every time because
# we change the objects it returns. If we reused it, we could not
# retrieve the conditions further down
# TODO implement copy for hyperparameters and forbidden and
# conditions!
estimator_configuration_space = available_estimators[
estimator_name]. \
get_hyperparameter_search_space(dataset_properties)
for parameter in estimator_configuration_space.get_hyperparameters():
new_parameter = copy.deepcopy(parameter)
new_parameter.name = "%s:%s" % (
estimator_name, new_parameter.name)
cs.add_hyperparameter(new_parameter)
# We must only add a condition if the hyperparameter is not
# conditional on something else
if len(estimator_configuration_space.
get_parents_of(parameter)) == 0:
condition = EqualsCondition(new_parameter, estimator,
estimator_name)
cs.add_condition(condition)
for condition in available_estimators[estimator_name]. \
get_hyperparameter_search_space(
dataset_properties).get_conditions():
dlcs = condition.get_descendant_literal_conditions()
for dlc in dlcs:
if not dlc.child.name.startswith(estimator_name):
dlc.child.name = "%s:%s" % (
estimator_name, dlc.child.name)
if not dlc.parent.name.startswith(estimator_name):
dlc.parent.name = "%s:%s" % (
estimator_name, dlc.parent.name)
cs.add_condition(condition)
for forbidden_clause in available_estimators[estimator_name]. \
get_hyperparameter_search_space(
dataset_properties).forbidden_clauses:
dlcs = forbidden_clause.get_descendant_literal_clauses()
for dlc in dlcs:
if not dlc.hyperparameter.name.startswith(estimator_name):
dlc.hyperparameter.name = "%s:%s" % (estimator_name,
dlc.hyperparameter.name)
cs.add_forbidden_clause(forbidden_clause)
return cs
