def get_hyperparameter_search_space(dataset_properties=None):
#n_estimators = UniformIntegerHyperparameter(
# "n_estimators", 10, 100, default=10)
n_estimators = Constant("n_estimators", 100)
criterion = CategoricalHyperparameter("criterion", ["gini", "entropy"],
default="gini")
#max_features = UniformFloatHyperparameter(
# "max_features", 0.01, 0.5, default=0.2)
max_features = UniformFloatHyperparameter("max_features",
0.5,
5,
default=1)
max_depth = UnParametrizedHyperparameter("max_depth", "None")
min_samples_split = UniformIntegerHyperparameter("min_samples_split",
2,
20,
default=2)
min_samples_leaf = UniformIntegerHyperparameter("min_samples_leaf",
1,
20,
default=1)
max_leaf_nodes = UnParametrizedHyperparameter("max_leaf_nodes", "None")
bootstrap = CategoricalHyperparameter("bootstrap", ["True", "False"],
default="True")
cs = ConfigurationSpace()
cs.add_hyperparameter(n_estimators)
cs.add_hyperparameter(criterion)
cs.add_hyperparameter(max_features)
cs.add_hyperparameter(max_depth)
cs.add_hyperparameter(min_samples_split)
cs.add_hyperparameter(min_samples_leaf)
cs.add_hyperparameter(max_leaf_nodes)
cs.add_hyperparameter(bootstrap)
return cs
def get_hyperparameter_search_space(dataset_properties=None):
loss = CategoricalHyperparameter(
"loss",
["hinge", "log", "modified_huber", "squared_hinge", "perceptron"],
default="hinge")
penalty = CategoricalHyperparameter("penalty",
["l1", "l2", "elasticnet"],
default="l2")
alpha = UniformFloatHyperparameter("alpha",
10**-7,
10**-1,
log=True,
default=0.0001)
l1_ratio = UniformFloatHyperparameter("l1_ratio", 0, 1, default=0.15)
fit_intercept = UnParametrizedHyperparameter("fit_intercept", "True")
n_iter = UniformIntegerHyperparameter("n_iter", 5, 1000, default=20)
epsilon = UniformFloatHyperparameter("epsilon",
1e-5,
1e-1,
default=1e-4,
log=True)
learning_rate = CategoricalHyperparameter(
"learning_rate", ["optimal", "invscaling", "constant"],
default="optimal")
eta0 = UniformFloatHyperparameter("eta0", 10**-7, 0.1, default=0.01)
power_t = UniformFloatHyperparameter("power_t", 1e-5, 1, default=0.5)
# This does not allow for other resampling methods!
class_weight = CategoricalHyperparameter("class_weight",
["None", "auto"],
default="None")
cs = ConfigurationSpace()
cs.add_hyperparameter(loss)
cs.add_hyperparameter(penalty)
cs.add_hyperparameter(alpha)
cs.add_hyperparameter(l1_ratio)
cs.add_hyperparameter(fit_intercept)
cs.add_hyperparameter(n_iter)
cs.add_hyperparameter(epsilon)
cs.add_hyperparameter(learning_rate)
cs.add_hyperparameter(eta0)
cs.add_hyperparameter(power_t)
cs.add_hyperparameter(class_weight)
# 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_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_)
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_hyperparameter_search_space(dataset_properties=None):
n_neighbors = UniformIntegerHyperparameter(name="n_neighbors",
lower=1,
upper=100,
default=1)
weights = CategoricalHyperparameter(name="weights",
choices=["uniform", "distance"],
default="uniform")
metric = UnParametrizedHyperparameter(name="metric", value="minkowski")
algorithm = Constant(name='algorithm', value="auto")
p = CategoricalHyperparameter(name="p", choices=[1, 2, 5], default=2)
leaf_size = Constant(name="leaf_size", value=30)
# Unparametrized
# TODO: If we further parametrize 'metric' we need more metric params
metric = UnParametrizedHyperparameter(name="metric", value="minkowski")
cs = ConfigurationSpace()
cs.add_hyperparameter(n_neighbors)
cs.add_hyperparameter(weights)
cs.add_hyperparameter(metric)
cs.add_hyperparameter(algorithm)
cs.add_hyperparameter(p)
cs.add_hyperparameter(leaf_size)
# Conditions
metric_p = EqualsCondition(parent=metric, child=p, value="minkowski")
cs.add_condition(metric_p)
return cs
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_estimators = cs.add_hyperparameter(Constant("n_estimators", 100))
criterion = cs.add_hyperparameter(
CategoricalHyperparameter("criterion", ["gini", "entropy"],
default="gini"))
max_features = cs.add_hyperparameter(
UniformFloatHyperparameter("max_features", 0.5, 5, default=1))
max_depth = cs.add_hyperparameter(
UnParametrizedHyperparameter(name="max_depth", value="None"))
min_samples_split = cs.add_hyperparameter(
UniformIntegerHyperparameter("min_samples_split", 2, 20,
default=2))
min_samples_leaf = cs.add_hyperparameter(
UniformIntegerHyperparameter("min_samples_leaf", 1, 20, default=1))
min_weight_fraction_leaf = cs.add_hyperparameter(
Constant('min_weight_fraction_leaf', 0.))
bootstrap = cs.add_hyperparameter(
CategoricalHyperparameter("bootstrap", ["True", "False"],
default="False"))
return cs
def test_add_forbidden(self):
m = numpy.ones([2, 3])
preprocessors_list = ['pa', 'pb']
classifier_list = ['ca', 'cb', 'cc']
cs = ConfigurationSpace()
preprocessor = CategoricalHyperparameter(name='preprocessor',
choices=preprocessors_list)
classifier = CategoricalHyperparameter(name='classifier',
choices=classifier_list)
cs.add_hyperparameter(preprocessor)
cs.add_hyperparameter(classifier)
new_cs = autosklearn.pipeline.create_searchspace_util.add_forbidden(
conf_space=cs, node_0_list=preprocessors_list,
node_1_list=classifier_list, matches=m,
node_0_name='preprocessor', node_1_name="classifier")
self.assertEqual(len(new_cs.forbidden_clauses), 0)
self.assertIsInstance(new_cs, ConfigurationSpace)
m[1, 1] = 0
new_cs = autosklearn.pipeline.create_searchspace_util.add_forbidden(
conf_space=cs, node_0_list=preprocessors_list,
node_1_list=classifier_list, matches=m,
node_0_name='preprocessor', node_1_name="classifier")
self.assertEqual(len(new_cs.forbidden_clauses), 1)
self.assertEqual(new_cs.forbidden_clauses[0].components[0].value, 'cb')
self.assertEqual(new_cs.forbidden_clauses[0].components[1].value, 'pb')
self.assertIsInstance(new_cs, ConfigurationSpace)
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
n_neighbors = cs.add_hyperparameter(UniformIntegerHyperparameter(
name="n_neighbors", lower=1, upper=100, log=True, default=1))
weights = cs.add_hyperparameter(CategoricalHyperparameter(
name="weights", choices=["uniform", "distance"], default="uniform"))
p = cs.add_hyperparameter(CategoricalHyperparameter(
name="p", choices=[1, 2], default=2))
return cs
def get_hyperparameter_search_space(dataset_properties=None):
# More than degree 3 is too expensive!
degree = UniformIntegerHyperparameter("degree", 2, 3, 2)
interaction_only = CategoricalHyperparameter("interaction_only",
["False", "True"], "False")
include_bias = CategoricalHyperparameter("include_bias",
["True", "False"], "True")
cs = ConfigurationSpace()
cs.add_hyperparameter(degree)
cs.add_hyperparameter(interaction_only)
cs.add_hyperparameter(include_bias)
return cs
def test_illegal_default_configuration(self):
cs = ConfigurationSpace()
hp1 = CategoricalHyperparameter("loss", ["l1", "l2"], default='l1')
hp2 = CategoricalHyperparameter("penalty", ["l1", "l2"], default='l1')
cs.add_hyperparameter(hp1)
cs.add_hyperparameter(hp2)
forb1 = ForbiddenEqualsClause(hp1, "l1")
forb2 = ForbiddenEqualsClause(hp2, "l1")
forb3 = ForbiddenAndConjunction(forb1, forb2)
# cs.add_forbidden_clause(forb3)
self.assertRaisesRegexp(
ValueError, "Configuration:\n"
" loss, Value: l1\n penalty, Value: l1\n"
"violates forbidden clause \(Forbidden: loss == l1 && Forbidden: "
"penalty == l1\)", cs.add_forbidden_clause, forb3)
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
n_components = cs.add_hyperparameter(UniformIntegerHyperparameter(
"n_components", 10, 2000, default=100))
algorithm = cs.add_hyperparameter(CategoricalHyperparameter('algorithm',
['parallel', 'deflation'], 'parallel'))
whiten = cs.add_hyperparameter(CategoricalHyperparameter('whiten',
['False', 'True'], 'False'))
fun = cs.add_hyperparameter(CategoricalHyperparameter(
'fun', ['logcosh', 'exp', 'cube'], 'logcosh'))
cs.add_condition(EqualsCondition(n_components, whiten, "True"))
return cs
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
# base_estimator = Constant(name="base_estimator", value="None")
n_estimators = cs.add_hyperparameter(
UniformIntegerHyperparameter(name="n_estimators",
lower=50,
upper=500,
default=50,
log=False))
learning_rate = cs.add_hyperparameter(
UniformFloatHyperparameter(name="learning_rate",
lower=0.0001,
upper=2,
default=0.1,
log=True))
algorithm = cs.add_hyperparameter(
CategoricalHyperparameter(name="algorithm",
choices=["SAMME.R", "SAMME"],
default="SAMME.R"))
max_depth = cs.add_hyperparameter(
UniformIntegerHyperparameter(name="max_depth",
lower=1,
upper=10,
default=1,
log=False))
return cs
def get_hyperparameter_search_space(dataset_properties=None):
criterion = Constant(name="criterion", value="mse")
# Copied from classification/random_forest.py
#n_estimators = UniformIntegerHyperparameter(
# name="n_estimators", lower=10, upper=100, default=10, log=False)
n_estimators = Constant("n_estimators", 100)
max_features = UniformFloatHyperparameter(
"max_features", 0.5, 5, default=1)
max_depth = UnParametrizedHyperparameter("max_depth", "None")
min_samples_split = UniformIntegerHyperparameter(
name="min_samples_split", lower=2, upper=20, default=2, log=False)
min_samples_leaf = UniformIntegerHyperparameter(
name="min_samples_leaf", lower=1, upper=20, default=1, log=False)
bootstrap = CategoricalHyperparameter(
name="bootstrap", choices=["True", "False"], default="True")
cs = ConfigurationSpace()
cs.add_hyperparameter(n_estimators)
cs.add_hyperparameter(max_features)
cs.add_hyperparameter(max_depth)
cs.add_hyperparameter(min_samples_split)
cs.add_hyperparameter(min_samples_leaf)
cs.add_hyperparameter(bootstrap)
cs.add_hyperparameter(criterion)
return cs
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
penalty = cs.add_hyperparameter(Constant("penalty", "l1"))
loss = cs.add_hyperparameter(
CategoricalHyperparameter("loss", ["hinge", "squared_hinge"],
default="squared_hinge"))
dual = cs.add_hyperparameter(Constant("dual", "False"))
# This is set ad-hoc
tol = cs.add_hyperparameter(
UniformFloatHyperparameter("tol",
1e-5,
1e-1,
default=1e-4,
log=True))
C = cs.add_hyperparameter(
UniformFloatHyperparameter("C",
0.03125,
32768,
log=True,
default=1.0))
multi_class = cs.add_hyperparameter(Constant("multi_class", "ovr"))
# These are set ad-hoc
fit_intercept = cs.add_hyperparameter(Constant("fit_intercept",
"True"))
intercept_scaling = cs.add_hyperparameter(
Constant("intercept_scaling", 1))
penalty_and_loss = ForbiddenAndConjunction(
ForbiddenEqualsClause(penalty, "l1"),
ForbiddenEqualsClause(loss, "hinge"))
cs.add_forbidden_clause(penalty_and_loss)
return cs
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 invalid conditions:
self.assertRaisesRegexp(
ValueError, "Argument 'parent' is not an "
"instance of HPOlibConfigSpace.hyperparameter."
"Hyperparameter.", EqualsCondition, hp2, "parent", 0)
self.assertRaisesRegexp(
ValueError, "Argument 'child' is not an "
"instance of HPOlibConfigSpace.hyperparameter."
"Hyperparameter.", EqualsCondition, "child", hp1, 0)
self.assertRaisesRegexp(
ValueError, "The child and parent hyperparameter "
"must be different hyperparameters.", 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 get_hyperparameter_search_space(dataset_properties=None):
# TODO add replace by zero!
strategy = CategoricalHyperparameter(
"strategy", ["mean", "median", "most_frequent"], default="mean")
cs = ConfigurationSpace()
cs.add_hyperparameter(strategy)
return cs
def get_hyperparameter_search_space(dataset_properties=None):
# TODO add replace by zero!
strategy = CategoricalHyperparameter("strategy", ["none", "weighting"],
default="none")
cs = ConfigurationSpace()
cs.add_hyperparameter(strategy)
return cs
def get_hyperparameter_search_space(dataset_properties=None):
n_components = UniformIntegerHyperparameter("n_components",
10,
2000,
default=100)
kernel = CategoricalHyperparameter(
'kernel', ['poly', 'rbf', 'sigmoid', 'cosine'], 'rbf')
degree = UniformIntegerHyperparameter('degree', 2, 5, 3)
gamma = UniformFloatHyperparameter("gamma",
3.0517578125e-05,
8,
log=True,
default=1.0)
coef0 = UniformFloatHyperparameter("coef0", -1, 1, default=0)
cs = ConfigurationSpace()
cs.add_hyperparameter(n_components)
cs.add_hyperparameter(kernel)
cs.add_hyperparameter(degree)
cs.add_hyperparameter(gamma)
cs.add_hyperparameter(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_condition(degree_depends_on_poly)
cs.add_condition(coef0_condition)
cs.add_condition(gamma_condition)
return cs
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
C = cs.add_hyperparameter(UniformFloatHyperparameter(
"C", 0.03125, 32768, log=True, default=1.0))
loss = cs.add_hyperparameter(CategoricalHyperparameter(
"loss", ["epsilon_insensitive", "squared_epsilon_insensitive"],
default="squared_epsilon_insensitive"))
# Random Guess
epsilon = cs.add_hyperparameter(UniformFloatHyperparameter(
name="epsilon", lower=0.001, upper=1, default=0.1, log=True))
dual = cs.add_hyperparameter(Constant("dual", "False"))
# These are set ad-hoc
tol = cs.add_hyperparameter(UniformFloatHyperparameter(
"tol", 1e-5, 1e-1, default=1e-4, log=True))
fit_intercept = cs.add_hyperparameter(Constant("fit_intercept", "True"))
intercept_scaling = cs.add_hyperparameter(Constant(
"intercept_scaling", 1))
dual_and_loss = ForbiddenAndConjunction(
ForbiddenEqualsClause(dual, "False"),
ForbiddenEqualsClause(loss, "epsilon_insensitive")
)
cs.add_forbidden_clause(dual_and_loss)
return cs
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
loss = cs.add_hyperparameter(CategoricalHyperparameter("loss",
["squared_loss", "huber", "epsilon_insensitive", "squared_epsilon_insensitive"],
default="squared_loss"))
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.01))
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.5))
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 = InCondition(epsilon, loss,
["huber", "epsilon_insensitive", "squared_epsilon_insensitive"])
# 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 get_hyperparameter_search_space(dataset_properties=None):
C = UniformFloatHyperparameter("C",
0.03125,
32768,
log=True,
default=1.0)
# No linear kernel here, because we have liblinear
kernel = CategoricalHyperparameter(name="kernel",
choices=["rbf", "poly", "sigmoid"],
default="rbf")
degree = UniformIntegerHyperparameter("degree", 1, 5, default=3)
gamma = UniformFloatHyperparameter("gamma",
3.0517578125e-05,
8,
log=True,
default=0.1)
# TODO this is totally ad-hoc
coef0 = UniformFloatHyperparameter("coef0", -1, 1, default=0)
# probability is no hyperparameter, but an argument to the SVM algo
shrinking = CategoricalHyperparameter("shrinking", ["True", "False"],
default="True")
tol = UniformFloatHyperparameter("tol",
1e-5,
1e-1,
default=1e-4,
log=True)
# cache size is not a hyperparameter, but an argument to the program!
max_iter = UnParametrizedHyperparameter("max_iter", -1)
cs = ConfigurationSpace()
cs.add_hyperparameter(C)
cs.add_hyperparameter(kernel)
cs.add_hyperparameter(degree)
cs.add_hyperparameter(gamma)
cs.add_hyperparameter(coef0)
cs.add_hyperparameter(shrinking)
cs.add_hyperparameter(tol)
cs.add_hyperparameter(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_condition_from_cryptominisat(self):
parent = CategoricalHyperparameter('blkrest', ['0', '1'], default='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):
keep_variance = UniformFloatHyperparameter(
"keep_variance", 0.5, 0.9999, default=0.9999)
whiten = CategoricalHyperparameter(
"whiten", ["False", "True"], default="False")
cs = ConfigurationSpace()
cs.add_hyperparameter(keep_variance)
cs.add_hyperparameter(whiten)
return cs
def test_hyperparameters_with_valid_condition(self):
cs = ConfigurationSpace()
hp1 = CategoricalHyperparameter("parent", [0, 1])
cs.add_hyperparameter(hp1)
hp2 = UniformIntegerHyperparameter("child", 0, 10)
cs.add_hyperparameter(hp2)
cond = EqualsCondition(hp2, hp1, 0)
cs.add_condition(cond)
self.assertEqual(len(cs._hyperparameters), 2)
def test_add_second_condition_wo_conjunction(self):
hp1 = CategoricalHyperparameter("input1", [0, 1])
hp2 = CategoricalHyperparameter("input2", [0, 1])
hp3 = Constant("And", "True")
cond1 = EqualsCondition(hp3, hp1, 1)
cond2 = EqualsCondition(hp3, hp2, 1)
cs = ConfigurationSpace()
cs.add_hyperparameter(hp1)
cs.add_hyperparameter(hp2)
cs.add_hyperparameter(hp3)
cs.add_condition(cond1)
self.assertRaisesRegexp(
ValueError, "Adding a second condition \(different\) for a "
"hyperparameter is ambigouos and "
"therefore forbidden. Add a conjunction "
"instead!", cs.add_condition, cond2)
def test_get_hyperparameter_search_space_include_exclude_models(self):
cs = SimpleClassificationPipeline.get_hyperparameter_search_space(
include={'classifier': ['libsvm_svc']})
self.assertEqual(cs.get_hyperparameter('classifier:__choice__'),
CategoricalHyperparameter('classifier:__choice__', ['libsvm_svc']))
cs = SimpleClassificationPipeline.get_hyperparameter_search_space(
exclude={'classifier': ['libsvm_svc']})
self.assertNotIn('libsvm_svc', str(cs))
cs = SimpleClassificationPipeline.get_hyperparameter_search_space(
include={'preprocessor': ['select_percentile_classification']})
self.assertEqual(cs.get_hyperparameter('preprocessor:__choice__'),
CategoricalHyperparameter('preprocessor:__choice__',
['select_percentile_classification']))
cs = SimpleClassificationPipeline.get_hyperparameter_search_space(
exclude={'preprocessor': ['select_percentile_classification']})
self.assertNotIn('select_percentile_classification', str(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 test_get_conditions(self):
cs = ConfigurationSpace()
hp1 = CategoricalHyperparameter("parent", [0, 1])
cs.add_hyperparameter(hp1)
hp2 = UniformIntegerHyperparameter("child", 0, 10)
cs.add_hyperparameter(hp2)
self.assertEqual([], cs.get_conditions())
cond1 = EqualsCondition(hp2, hp1, 0)
cs.add_condition(cond1)
self.assertEqual([cond1], cs.get_conditions())
def test_get_hyperparameter_search_space_include_exclude_models(self):
cs = ParamSklearnRegressor.get_hyperparameter_search_space(
include={'regressor': ['random_forest']})
self.assertEqual(cs.get_hyperparameter('regressor:__choice__'),
CategoricalHyperparameter('regressor:__choice__', ['random_forest']))
# TODO add this test when more than one regressor is present
cs = ParamSklearnRegressor.get_hyperparameter_search_space(
exclude={'regressor': ['random_forest']})
self.assertNotIn('random_forest', str(cs))
cs = ParamSklearnRegressor.get_hyperparameter_search_space(
include={'preprocessor': ['pca']})
self.assertEqual(cs.get_hyperparameter('preprocessor:__choice__'),
CategoricalHyperparameter('preprocessor:__choice__', ['pca']))
cs = ParamSklearnRegressor.get_hyperparameter_search_space(
exclude={'preprocessor': ['no_preprocessing']})
self.assertNotIn('no_preprocessing', str(cs))
def get_hyperparameter_search_space(dataset_properties=None):
cs = ConfigurationSpace()
n_clusters = cs.add_hyperparameter(
UniformIntegerHyperparameter("n_clusters", 2, 400, 25))
affinity = cs.add_hyperparameter(
CategoricalHyperparameter("affinity",
["euclidean", "manhattan", "cosine"],
"euclidean"))
linkage = cs.add_hyperparameter(
CategoricalHyperparameter("linkage",
["ward", "complete", "average"], "ward"))
pooling_func = cs.add_hyperparameter(
CategoricalHyperparameter("pooling_func",
["mean", "median", "max"]))
affinity_and_linkage = ForbiddenAndConjunction(
ForbiddenInClause(affinity, ["manhattan", "cosine"]),
ForbiddenEqualsClause(linkage, "ward"))
cs.add_forbidden_clause(affinity_and_linkage)
return cs
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))
