def test_build_new_GreaterThanFloatCondition(self):
expected = "b integer [0, 10] [5]\n" \
"a real [0.0, 1.0] [0.5]\n\n" \
"a | b > 5"
cs = ConfigurationSpace()
a = UniformFloatHyperparameter("a", 0, 1, 0.5)
b = UniformIntegerHyperparameter("b", 0, 10, 5)
cs.add_hyperparameter(a)
cs.add_hyperparameter(b)
cond = GreaterThanCondition(a, b, 5)
cs.add_condition(cond)
value = pcs_new.write(cs)
self.assertEqual(expected, value)
expected = "b real [0.0, 10.0] [5.0]\n" \
"a real [0.0, 1.0] [0.5]\n\n" \
"a | b > 5"
cs = ConfigurationSpace()
a = UniformFloatHyperparameter("a", 0, 1, 0.5)
b = UniformFloatHyperparameter("b", 0, 10, 5)
cs.add_hyperparameter(a)
cs.add_hyperparameter(b)
cond = GreaterThanCondition(a, b, 5)
cs.add_condition(cond)
value = pcs_new.write(cs)
self.assertEqual(expected, value)
def test_sample_UniformFloatHyperparameter(self):
# This can sample four distributions
def sample(hp):
rs = np.random.RandomState(1)
counts_per_bin = [0 for i in range(21)]
for i in range(100000):
value = hp.sample(rs)
if hp.log:
self.assertLessEqual(value, np.exp(hp._upper))
self.assertGreaterEqual(value, np.exp(hp._lower))
else:
self.assertLessEqual(value, hp._upper)
self.assertGreaterEqual(value, hp._lower)
index = int((value - hp.lower) / (hp.upper - hp.lower) * 20)
counts_per_bin[index] += 1
self.assertIsInstance(value, float)
return counts_per_bin
# Uniform
hp = UniformFloatHyperparameter("ufhp", 0.5, 2.5)
counts_per_bin = sample(hp)
# The 21st bin is only filled if exactly 2.5 is sampled...very rare...
for bin in counts_per_bin[:-1]:
self.assertTrue(5200 > bin > 4800)
self.assertEqual(sample(hp), sample(hp))
# Quantized Uniform
hp = UniformFloatHyperparameter("ufhp", 0.0, 1.0, q=0.1)
counts_per_bin = sample(hp)
for bin in counts_per_bin[::2]:
self.assertTrue(9301 > bin > 8700)
for bin in counts_per_bin[1::2]:
self.assertEqual(bin, 0)
self.assertEqual(sample(hp), sample(hp))
# Log Uniform
hp = UniformFloatHyperparameter("ufhp", 1.0, np.e**2, log=True)
counts_per_bin = sample(hp)
print(counts_per_bin)
self.assertEqual(counts_per_bin, [
14012, 10977, 8809, 7559, 6424, 5706, 5276, 4694, 4328, 3928, 3655,
3386, 3253, 2932, 2816, 2727, 2530, 2479, 2280, 2229, 0
])
self.assertEqual(sample(hp), sample(hp))
# Quantized Log-Uniform
# 7.2 ~ np.round(e * e, 1)
hp = UniformFloatHyperparameter("ufhp", 1.2, 7.2, q=0.6, log=True)
counts_per_bin = sample(hp)
self.assertEqual(counts_per_bin, [
24359, 15781, 0, 11635, 0, 0, 9506, 7867, 0, 0, 6763, 0, 5919,
5114, 0, 4798, 0, 0, 4339, 3919, 0
])
self.assertEqual(sample(hp), sample(hp))
def test_uniformfloat_to_integer(self):
f1 = UniformFloatHyperparameter("param", 1, 10, q=0.1, log=True)
with warnings.catch_warnings():
f2 = f1.to_integer()
warnings.simplefilter("ignore")
# TODO is this a useful rounding?
# TODO should there be any rounding, if e.g. lower=0.1
self.assertEqual(
"param, Type: UniformInteger, Range: [1, 10], "
"Default: 3, on log-scale", str(f2))
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_new_log10(self):
expected = "a real [10.0, 1000.0] [100.0]log"
cs = ConfigurationSpace()
cs.add_hyperparameter(
UniformFloatHyperparameter("a", 10, 1000, log=True))
value = pcs_new.write(cs)
self.assertEqual(expected, value)
def test_write_new_q_float(self):
expected = "Q16_float_a real [16.0, 1024.0] [520.0]"
cs = ConfigurationSpace()
cs.add_hyperparameter(
UniformFloatHyperparameter("float_a", 16, 1024, q=16))
value = pcs_new.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 setUp(self):
self.cs = ConfigurationSpace()
self.cs.add_hyperparameter(UniformFloatHyperparameter(
name="x1", lower=1, upper=10, default_value=2)
)
self.scenario = Scenario({'cs': self.cs, 'run_obj': 'quality',
'output_dir': ''})
self.ta = ExecuteTAFuncDict(lambda x: x["x1"]**2)
def testRandomImputation(self):
rs = numpy.random.RandomState(1)
for i in range(0, 150, 15):
# First random imputation sanity check
num_samples = max(1, i*10)
num_feat = max(1, i)
num_censored = int(num_samples*0.1)
X = rs.rand(num_samples, num_feat)
y = numpy.sin(X[:, 0:1])
cutoff = max(y) * 0.9
y[y > cutoff] = cutoff
# We have some cen data
cen_X = X[:num_censored, :]
cen_y = y[:num_censored]
uncen_X = X[num_censored:, :]
uncen_y = y[num_censored:]
cen_y /= 2
cs = ConfigurationSpace()
for i in range(num_feat):
cs.add_hyperparameter(UniformFloatHyperparameter(
name="a_%d" % i, lower=0, upper=1, default_value=0.5)
)
types, bounds = get_types(cs, None)
print(types)
print(bounds)
print('#'*120)
print(cen_X)
print(uncen_X)
print('~'*120)
self.model = RandomForestWithInstances(types=types, bounds=bounds,
instance_features=None,
seed=1234567980)
imputor = rfr_imputator.RFRImputator(rng=rs,
cutoff=cutoff,
threshold=cutoff*10,
change_threshold=0.01,
max_iter=5,
model=self.model)
imp_y = imputor.impute(censored_X=cen_X, censored_y=cen_y,
uncensored_X=uncen_X,
uncensored_y=uncen_y)
if imp_y is None:
continue
for idx in range(cen_y.shape[0]):
self.assertGreater(imp_y[idx], cen_y[idx])
self.assertTrue(numpy.isfinite(imp_y).all())
def test_write_log_float(self):
import numpy as np
expected = "float_log '--float_log ' r (2.000000, 5.000000)\n"
float_log = UniformFloatHyperparameter("float_log",
np.exp(2),
np.exp(5),
log=True)
cs = ConfigurationSpace()
cs.add_hyperparameter(float_log)
value = irace.write(cs)
self.assertEqual(expected, value)
def test_log_space_conversion(self):
lower, upper = 1e-5, 1e5
hyper = UniformFloatHyperparameter('test',
lower=lower,
upper=upper,
log=True)
self.assertTrue(hyper.is_legal(hyper._transform(1.)))
lower, upper = 1e-10, 1e10
hyper = UniformFloatHyperparameter('test',
lower=lower,
upper=upper,
log=True)
self.assertTrue(hyper.is_legal(hyper._transform(1.)))
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 opt_rosenbrock():
cs = ConfigurationSpace()
cs.add_hyperparameter(
UniformFloatHyperparameter("x1", -5, 5, default_value=-3))
cs.add_hyperparameter(
UniformFloatHyperparameter("x2", -5, 5, default_value=-4))
scenario = Scenario({
"run_obj":
"quality", # we optimize quality (alternatively runtime)
"runcount-limit": 50, # maximum function evaluations
"cs": cs, # configuration space
"deterministic": "true",
"intensification_percentage": 0.000000001
})
smac = SMAC(scenario=scenario,
rng=np.random.RandomState(42),
tae_runner=rosenbrock_2d)
incumbent = smac.optimize()
return incumbent
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 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_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_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_illegal_input(self):
"""
Testing illegal input in smbo
"""
cs = ConfigurationSpace()
cs.add_hyperparameter(UniformFloatHyperparameter('test', 1, 10, 5))
scen = Scenario({'run_obj': 'quality', 'cs': cs})
stats = Stats(scen)
# Recorded runs but no incumbent.
stats.ta_runs = 10
smac = SMAC(scen, stats=stats, rng=np.random.RandomState(42))
self.output_dirs.append(scen.output_dir)
self.assertRaises(ValueError, smac.optimize)
# Incumbent but no recoreded runs.
incumbent = cs.get_default_configuration()
smac = SMAC(scen,
restore_incumbent=incumbent,
rng=np.random.RandomState(42))
self.assertRaises(ValueError, smac.optimize)
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)
#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])
use_degree = InCondition(child=degree, parent=kernel, values=["poly"])
use_coef0 = InCondition(child=coef0, parent=kernel, values=["poly", "sigmoid"])
cs.add_conditions([use_degree, use_coef0])
# This also works for parameters that are a mix of categorical and values from a range of numbers
def get_branin_config_space():
"""TODO"""
cs = ConfigurationSpace()
cs.add_hyperparameter(UniformFloatHyperparameter('x', -5, 10))
cs.add_hyperparameter(UniformFloatHyperparameter('y', 0, 15))
return cs
def test_uniformfloat(self):
# TODO test non-equality
# TODO test sampling from a log-distribution which has a negative
# lower value!
f1 = UniformFloatHyperparameter("param", 0, 10)
f1_ = UniformFloatHyperparameter("param", 0, 10)
self.assertEqual(f1, f1_)
self.assertEqual(
"param, Type: UniformFloat, Range: [0.0, 10.0], "
"Default: 5.0", str(f1))
f2 = UniformFloatHyperparameter("param", 0, 10, q=0.1)
f2_ = UniformFloatHyperparameter("param", 0, 10, q=0.1)
self.assertEqual(f2, f2_)
self.assertEqual(
"param, Type: UniformFloat, Range: [0.0, 10.0], "
"Default: 5.0, Q: 0.1", str(f2))
f3 = UniformFloatHyperparameter("param", 0.00001, 10, log=True)
f3_ = UniformFloatHyperparameter("param", 0.00001, 10, log=True)
self.assertEqual(f3, f3_)
self.assertEqual(
"param, Type: UniformFloat, Range: [1e-05, 10.0], Default: 0.01, "
"on log-scale", str(f3))
f4 = UniformFloatHyperparameter("param", 0, 10, default_value=1.0)
f4_ = UniformFloatHyperparameter("param", 0, 10, default_value=1.0)
# Test that a int default is converted to float
f4__ = UniformFloatHyperparameter("param", 0, 10, default_value=1)
self.assertEqual(f4, f4_)
self.assertEqual(type(f4.default_value), type(f4__.default_value))
self.assertEqual(
"param, Type: UniformFloat, Range: [0.0, 10.0], Default: 1.0",
str(f4))
f5 = UniformFloatHyperparameter("param",
0.1,
10,
q=0.1,
log=True,
default_value=1.0)
f5_ = UniformFloatHyperparameter("param",
0.1,
10,
q=0.1,
log=True,
default_value=1.0)
self.assertEqual(f5, f5_)
self.assertEqual(
"param, Type: UniformFloat, Range: [0.1, 10.0], Default: 1.0, "
"on log-scale, Q: 0.1", str(f5))
self.assertNotEqual(f1, f2)
self.assertNotEqual(f1, "UniformFloat")
# test that meta-data is stored correctly
f_meta = UniformFloatHyperparameter("param",
0.1,
10,
q=0.1,
log=True,
default_value=1.0,
meta=dict(self.meta_data))
self.assertEqual(f_meta.meta, self.meta_data)
from ConfigSpaceNNI.configuration_space import ConfigurationSpace
import ConfigSpaceNNI.read_and_write.pcs as pcs
import ConfigSpaceNNI.read_and_write.pcs_new as pcs_new
from ConfigSpaceNNI.hyperparameters import CategoricalHyperparameter, \
UniformIntegerHyperparameter, UniformFloatHyperparameter, OrdinalHyperparameter
from ConfigSpaceNNI.conditions import EqualsCondition, InCondition, \
AndConjunction, OrConjunction, NotEqualsCondition, \
GreaterThanCondition
from ConfigSpaceNNI.forbidden import ForbiddenInClause, ForbiddenAndConjunction
# More complex search space
classifier = CategoricalHyperparameter("classifier", ["svm", "nn"])
kernel = CategoricalHyperparameter("kernel", ["rbf", "poly", "sigmoid"])
kernel_condition = EqualsCondition(kernel, classifier, "svm")
C = UniformFloatHyperparameter("C", 0.03125, 32768, log=True)
C_condition = EqualsCondition(C, classifier, "svm")
gamma = UniformFloatHyperparameter("gamma", 0.000030518, 8, log=True)
gamma_condition = EqualsCondition(gamma, kernel, "rbf")
degree = UniformIntegerHyperparameter("degree", 1, 5)
degree_condition = InCondition(degree, kernel, ["poly", "sigmoid"])
neurons = UniformIntegerHyperparameter("neurons", 16, 1024)
neurons_condition = EqualsCondition(neurons, classifier, "nn")
lr = UniformFloatHyperparameter("lr", 0.0001, 1.0)
lr_condition = EqualsCondition(lr, classifier, "nn")
preprocessing = CategoricalHyperparameter("preprocessing", ["None", "pca"])
conditional_space = ConfigurationSpace()
conditional_space.add_hyperparameter(preprocessing)
conditional_space.add_hyperparameter(classifier)
conditional_space.add_hyperparameter(kernel)
conditional_space.add_hyperparameter(C)
def test_read_configuration_space_basic(self):
# TODO: what does this test has to do with the PCS converter?
float_a_copy = UniformFloatHyperparameter("float_a", -1.23, 6.45)
a_copy = {"a": float_a_copy, "b": int_a}
a_real = {"b": int_a, "a": float_a}
self.assertDictEqual(a_real, a_copy)
def test_normalfloat_to_uniformfloat(self):
f1 = NormalFloatHyperparameter("param", 0, 10, q=0.1)
f1_expected = UniformFloatHyperparameter("param", -30, 30, q=0.1)
f1_actual = f1.to_uniform()
self.assertEqual(f1_expected, f1_actual)
def test_uniformfloat_is_legal(self):
lower = 0.1
upper = 10
f1 = UniformFloatHyperparameter("param", lower, upper, q=0.1, log=True)
self.assertTrue(f1.is_legal(3.0))
self.assertTrue(f1.is_legal(3))
self.assertFalse(f1.is_legal(-0.1))
self.assertFalse(f1.is_legal(10.1))
self.assertFalse(f1.is_legal("AAA"))
self.assertFalse(f1.is_legal(dict()))
# Test legal vector values
self.assertTrue(f1.is_legal_vector(1.0))
self.assertTrue(f1.is_legal_vector(0.0))
self.assertTrue(f1.is_legal_vector(0))
self.assertTrue(f1.is_legal_vector(0.3))
self.assertFalse(f1.is_legal_vector(-0.1))
self.assertFalse(f1.is_legal_vector(1.1))
self.assertRaises(TypeError, f1.is_legal_vector, "Hahaha")
def test_write_float(self):
expected = "float_a '--float_a ' r (16.000000, 1024.000000)\n"
cs = ConfigurationSpace()
cs.add_hyperparameter(UniformFloatHyperparameter("float_a", 16, 1024))
value = irace.write(cs)
self.assertEqual(expected, value)
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 fmin_smac(func: callable,
x0: list,
bounds: list,
maxfun: int=-1,
maxtime: int=-1,
rng: np.random.RandomState=None):
""" Minimize a function func using the SMAC algorithm.
This function is a convenience wrapper for the SMAC class.
Parameters
----------
func : callable f(x)
Function to minimize.
x0 : list
Initial guess/default configuration.
bounds : list
``(min, max)`` pairs for each element in ``x``, defining the bound on
that parameters.
maxtime : int, optional
Maximum runtime in seconds.
maxfun : int, optional
Maximum number of function evaluations.
rng : np.random.RandomState, optional
Random number generator used by SMAC.
Returns
-------
x : list
Estimated position of the minimum.
f : float
Value of `func` at the minimum.
s : :class:`smac.facade.smac_facade.SMAC`
SMAC objects which enables the user to get
e.g., the trajectory and runhistory.
"""
# create configuration space
cs = ConfigurationSpace()
for idx, (lower_bound, upper_bound) in enumerate(bounds):
parameter = UniformFloatHyperparameter(name="x%d" % (idx + 1),
lower=lower_bound,
upper=upper_bound,
default_value=x0[idx])
cs.add_hyperparameter(parameter)
# Create target algorithm runner
ta = ExecuteTAFuncArray(ta=func)
# create scenario
scenario_dict = {"run_obj": "quality",
"cs": cs,
"deterministic": "true",
"initial_incumbent": "DEFAULT"
}
if maxfun > 0:
scenario_dict["runcount_limit"] = maxfun
if maxtime > 0:
scenario_dict["wallclock_limit"] = maxtime
scenario = Scenario(scenario_dict)
smac = SMAC(scenario=scenario, tae_runner=ta, rng=rng)
smac.logger = logging.getLogger(smac.__module__ + "." + smac.__class__.__name__)
incumbent = smac.optimize()
config_id = smac.solver.runhistory.config_ids[incumbent]
run_key = RunKey(config_id, None, 0)
incumbent_performance = smac.solver.runhistory.data[run_key]
incumbent = np.array([incumbent['x%d' % (idx + 1)]
for idx in range(len(bounds))], dtype=np.float)
return incumbent, incumbent_performance.cost, \
smac
