def test_duplicate(self):
space = [
{'name': 'var_1', 'type': 'continuous', 'domain':(-3,1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'discrete', 'domain': (0,1,2,3)},
{'name': 'var_3', 'type': 'categorical', 'domain': (0, 1)}
]
design_space = Design_space(space)
np.random.seed(666)
number_points = 5
zipped_X = initial_design("random",design_space,number_points)
d = DuplicateManager(design_space, zipped_X)
duplicate = np.atleast_2d(zipped_X[0,:].copy())
assert d.is_zipped_x_duplicate(duplicate)
assert d.is_unzipped_x_duplicate(design_space.unzip_inputs(duplicate))
non_duplicate = np.array([[-2.5, 2., 0.]])
for x in zipped_X:
assert not np.all(non_duplicate==x)
assert not d.is_zipped_x_duplicate(non_duplicate)
assert not d.is_unzipped_x_duplicate(design_space.unzip_inputs(non_duplicate))
def test_duplicate_with_ignored_and_pending(self):
space = [
{'name': 'var_1', 'type': 'continuous', 'domain':(-3,1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'discrete', 'domain': (0,1,2,3)},
{'name': 'var_3', 'type': 'categorical', 'domain': (0, 1)}
]
design_space = Design_space(space)
np.random.seed(666)
number_points = 5
zipped_X = initial_design("random",design_space,number_points)
pending_zipped_X = initial_design("random", design_space, number_points)
ignored_zipped_X = initial_design("random", design_space, number_points)
d = DuplicateManager(design_space, zipped_X, pending_zipped_X, ignored_zipped_X)
duplicate_in_pending_state = np.atleast_2d(pending_zipped_X[0,:].copy())
assert d.is_zipped_x_duplicate(duplicate_in_pending_state)
assert d.is_unzipped_x_duplicate(design_space.unzip_inputs(duplicate_in_pending_state))
duplicate_in_ignored_state = np.atleast_2d(ignored_zipped_X[0,:].copy())
assert d.is_zipped_x_duplicate(duplicate_in_ignored_state)
assert d.is_unzipped_x_duplicate(design_space.unzip_inputs(duplicate_in_ignored_state))
def test_zip_and_unzip(self):
space = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 1
}, {
'name': 'var_2',
'type': 'discrete',
'domain': (0, 1, 2, 3),
'dimensionality': 1
}, {
'name': 'var_3',
'type': 'categorical',
'domain': (2, 4, 6)
}, {
'name': 'var_4',
'type': 'bandit',
'domain': np.array([[-2], [0], [2]])
}]
X = np.array([[0.0, 1, 2, -2], [1.5, 3, 2, 2]])
design_space = Design_space(space)
unzipped = design_space.unzip_inputs(X)
zipped = design_space.zip_inputs(unzipped)
self.assertTrue(np.array_equal(X, zipped))
def test_bounds(self):
space = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 1
}, {
'name': 'var_3',
'type': 'discrete',
'domain': (0, 1, 2, 3)
}, {
'name': 'var_3',
'type': 'categorical',
'domain': (2, 4)
}, {
'name': 'var_4',
'type': 'bandit',
'domain': np.array([[-2], [0], [2]])
}]
design_space = Design_space(space)
bounds = design_space.get_bounds()
# Countinuous variable bound
self.assertIn((-3, 1), bounds)
# Discrete variable bound
self.assertIn((0, 3), bounds)
# Bandit variable bound
self.assertIn((-2, 2), bounds)
# Categorical variable bound
self.assertIn((0, 1), bounds)
def test_create_continuous_variable(self):
space = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 1
}]
design_space = Design_space(space)
self.assertEqual(len(design_space.space_expanded), 1)
self.assertIsInstance(design_space.space_expanded[0],
ContinuousVariable)
space = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 2
}]
design_space = Design_space(space)
self.assertEqual(len(design_space.space_expanded), 2)
self.assertTrue(
all(
isinstance(var, ContinuousVariable)
for var in design_space.space_expanded))
def test_subspace(self):
space = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-1, 1),
'dimensionality': 2
}, {
'name': 'var_2',
'type': 'categorical',
'domain': ('r', 'g', 'b')
}, {
'name': 'var_3',
'type': 'discrete',
'domain': (0, 1, 2, 3)
}]
dims = [0, 2, 5]
design_space = Design_space(space)
subspace = design_space.get_subspace(dims)
self.assertEqual(len(subspace), 3)
self.assertTrue(
any(v for v in subspace if isinstance(v, ContinuousVariable)))
self.assertTrue(
any(v for v in subspace if isinstance(v, DiscreteVariable)))
self.assertTrue(
any(v for v in subspace if isinstance(v, CategoricalVariable)))
class TestOptimizerCreation(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(TestOptimizerCreation, self).__init__(*args, **kwargs)
self.space = [
{'name': 'var_1', 'type': 'continuous', 'domain': (-1, 1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'continuous', 'domain': (-1, 1), 'dimensionality': 1}
]
self.design_space = Design_space(self.space)
self.f = lambda x: np.sum(np.sin(x))
def test_invalid_optimizer_name_raises_error(self):
self.assertRaises(InvalidVariableNameError,
choose_optimizer, 'asd', None)
def test_create_lbfgs_optimizer(self):
optimizer = choose_optimizer('lbfgs', self.design_space.get_bounds())
self.assertIsNotNone(optimizer)
def test_create_direct_optimizer(self):
optimizer = choose_optimizer('DIRECT', self.design_space.get_bounds())
self.assertIsNotNone(optimizer)
def test_create_cma_optimizer(self):
optimizer = choose_optimizer('CMA', self.design_space.get_bounds())
self.assertIsNotNone(optimizer)
def test_dimensionality(self):
space = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 2
}, {
'name': 'var_3',
'type': 'discrete',
'domain': (0, 1, 2, 3)
}, {
'name': 'var_3',
'type': 'categorical',
'domain': (2, 4)
}]
design_space = Design_space(space)
self.assertEqual(len(design_space.space_expanded),
design_space.dimensionality)
space = [{
'name': 'var_1',
'type': 'bandit',
'domain': np.array([[-2, 2], [0, 1], [2, 3]])
}]
design_space = Design_space(space)
self.assertEqual(len(design_space.space_expanded), 1)
self.assertEqual(design_space.dimensionality, 2)
def test_objective_anchor_points_with_duplicate(self):
space = [
{'name': 'var_1', 'type': 'discrete', 'domain':(-1,2)},
{'name': 'var_2', 'type': 'discrete', 'domain': (0,1)},
{'name': 'var_3', 'type': 'categorical', 'domain': (0, 1)}
]
design_space = Design_space(space)
np.random.seed(666)
design_type = "random"
dummy_objective = lambda X : np.sum(X*X, axis=1)
generator = ObjectiveAnchorPointsGenerator(design_space, design_type, dummy_objective, num_samples=1000)
initial_points = np.array([[-1, 1, 0],[-1, 1, 1]])
duplicate_manager = DuplicateManager(design_space, initial_points)
# There is a total of 2x2x2=8 possible configurations, minus the 2 defined in initial_points
solution = np.array([[-1., 0., 1., 0.], [-1., 0., 0., 1.], [ 2., 0., 1., 0.], [ 2., 0., 0., 1.], [ 2., 1., 1., 0.], [ 2., 1., 0., 1.]])
anchor_points = generator.get(num_anchor=6, duplicate_manager=duplicate_manager, unique=True)
self.assertTrue(np.all(anchor_points == solution))
all_points = np.vstack((initial_points,design_space.zip_inputs(solution)))
duplicate_manager_with_all_points = DuplicateManager(design_space, all_points)
# There aren't any more candidates to generate, hence the exception
self.assertRaises(Exception, lambda : generator.get(num_anchor=1, duplicate_manager=duplicate_manager_with_all_points, unique=True))
def test_create_constraints(self):
space = [{'name': 'var_1', 'type': 'continuous', 'domain':(-1,1), 'dimensionality': 2}]
constraints = [ {'name': 'const_1', 'constraint': 'x[:,0]**2 + x[:,1]**2 - 1'}]
design_space = Design_space(space, constraints=constraints)
self.assertEqual(len(design_space.space_expanded), 2)
self.assertTrue(design_space.has_constraints())
def test_bandit_bounds(self):
space = [{'name': 'var_4', 'type': 'bandit', 'domain': np.array([[-2],[0],[2]])}]
design_space = Design_space(space)
bounds = design_space.get_bounds()
# Bandit variable bound
self.assertIn((-2, 2), bounds)
def test_create_constraints(self):
space = [{'name': 'var_1', 'type': 'continuous', 'domain':(-1,1), 'dimensionality': 2}]
constraints = [ {'name': 'const_1', 'constrain': 'x[:,0]**2 + x[:,1]**2 - 1'}]
design_space = Design_space(space, constraints=constraints)
self.assertEqual(len(design_space.space_expanded), 2)
self.assertTrue(design_space.has_constrains())
def test_invalid_constraint(self):
space = [{'name': 'var_1', 'type': 'continuous', 'domain':(-5, 5), 'dimensionality': 1}]
constraints = [{'name': 'const_1', 'constraint': 'x[:,20]**2 - 1'}]
x = np.array([[0]])
design_space = Design_space(space, constraints=constraints)
with self.assertRaises(Exception):
design_space.indicator_constraints(x)
def test_invalid_constraint(self):
space = [{'name': 'var_1', 'type': 'continuous', 'domain':(-5, 5), 'dimensionality': 1}]
constraints = [{'name': 'const_1', 'constrain': 'x[:,20]**2 - 1'}]
x = np.array([[0]])
design_space = Design_space(space, constraints=constraints)
with self.assertRaises(Exception):
design_space.indicator_constraints(x)
def test_indicator_constraints(self):
space = [{'name': 'var_1', 'type': 'continuous', 'domain':(-5, 5), 'dimensionality': 1}]
constraints = [ {'name': 'const_1', 'constraint': 'x[:,0]**2 - 1'}]
x = np.array([[0], [0.5], [4], [-0.2], [-5]])
expected_indicies = np.array([[1], [1], [0], [1], [0]])
design_space = Design_space(space, constraints=constraints)
I_x = design_space.indicator_constraints(x)
self.assertTrue(np.array_equal(expected_indicies, I_x))
def test_indicator_constraints(self):
space = [{'name': 'var_1', 'type': 'continuous', 'domain':(-5, 5), 'dimensionality': 1}]
constraints = [ {'name': 'const_1', 'constrain': 'x[:,0]**2 - 1'}]
x = np.array([[0], [0.5], [4], [-0.2], [-5]])
expected_indicies = np.array([[1], [1], [0], [1], [0]])
design_space = Design_space(space, constraints=constraints)
I_x = design_space.indicator_constraints(x)
self.assertTrue(np.array_equal(expected_indicies, I_x))
def test_bandit(self):
X = np.array([[0, -2, -1], [0, 0, 1], [1, -2, -1], [1, 0, 1],
[3, -2, -1], [3, 0, 1]])
space = [{'name': 'var', 'type': 'bandit', 'domain': X}]
design_space = Design_space(space)
self.assertTrue(design_space._has_bandit())
self.assertTrue(design_space.unzip_inputs(X).all() == X.all())
self.assertTrue(design_space.zip_inputs(X).all() == X.all())
def test_objective_anchor_points_with_duplicate(self):
space = [{
'name': 'var_1',
'type': 'discrete',
'domain': (-1, 2)
}, {
'name': 'var_2',
'type': 'discrete',
'domain': (0, 1)
}, {
'name': 'var_3',
'type': 'categorical',
'domain': (0, 1)
}]
design_space = Design_space(space)
np.random.seed(666)
design_type = "random"
dummy_objective = lambda X: np.sum(X * X, axis=1)
generator = ObjectiveAnchorPointsGenerator(design_space,
design_type,
dummy_objective,
num_samples=1000)
initial_points = np.array([[-1, 1, 0], [-1, 1, 1]])
duplicate_manager = DuplicateManager(design_space, initial_points)
# There is a total of 2x2x2=8 possible configurations, minus the 2 defined in initial_points
solution = np.array([[-1., 0., 1., 0.], [-1., 0., 0., 1.],
[2., 0., 1., 0.], [2., 0., 0., 1.],
[2., 1., 1., 0.], [2., 1., 0., 1.]])
anchor_points = generator.get(num_anchor=6,
duplicate_manager=duplicate_manager,
unique=True)
self.assertTrue(np.all(anchor_points == solution))
all_points = np.vstack(
(initial_points, design_space.zip_inputs(solution)))
duplicate_manager_with_all_points = DuplicateManager(
design_space, all_points)
# There aren't any more candidates to generate, hence the exception
self.assertRaises(
Exception, lambda: generator.get(num_anchor=1,
duplicate_manager=
duplicate_manager_with_all_points,
unique=True))
def test_bandit_bounds(self):
space = [{
'name': 'var_4',
'type': 'bandit',
'domain': np.array([[-2], [0], [2]])
}]
design_space = Design_space(space)
bounds = design_space.get_bounds()
# Bandit variable bound
self.assertIn((-2, 2), bounds)
def test_subspace(self):
space = [
{'name': 'var_1', 'type': 'continuous', 'domain':(-1,1), 'dimensionality': 2},
{'name': 'var_2', 'type': 'categorical', 'domain': ('r', 'g', 'b')},
{'name': 'var_3', 'type': 'discrete', 'domain': (0,1,2,3)}
]
dims = [0, 2, 5]
design_space = Design_space(space)
subspace = design_space.get_subspace(dims)
self.assertEqual(len(subspace), 3)
self.assertTrue(any(v for v in subspace if isinstance(v, ContinuousVariable)))
self.assertTrue(any(v for v in subspace if isinstance(v, DiscreteVariable)))
self.assertTrue(any(v for v in subspace if isinstance(v, CategoricalVariable)))
def test_bounds(self):
space = [
{'name': 'var_1', 'type': 'continuous', 'domain':(-3,1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'discrete', 'domain': (0,1,2,3)},
{'name': 'var_3', 'type': 'categorical', 'domain': (2, 4)}
]
design_space = Design_space(space)
bounds = design_space.get_bounds()
# Countinuous variable bound
self.assertIn((-3, 1), bounds)
# Discrete variable bound
self.assertIn((0, 3), bounds)
# Categorical variable bound
self.assertIn((0, 1), bounds)
def test_zip_and_unzip(self):
space = [
{'name': 'var_1', 'type': 'continuous', 'domain':(-3,1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'discrete', 'domain': (0,1,2,3), 'dimensionality': 1},
{'name': 'var_3', 'type': 'categorical', 'domain': (2, 4, 6)}
]
X = np.array([
[0.0, 1, 2],
[1.5, 3, 2]
])
design_space = Design_space(space)
unzipped = design_space.unzip_inputs(X)
zipped = design_space.zip_inputs(unzipped)
self.assertTrue(np.array_equal(X, zipped))
def test_bandit(self):
X = np.array([
[0, -2, -1],
[ 0, 0, 1],
[ 1, -2, -1],
[ 1, 0, 1],
[ 3, -2, -1],
[ 3, 0, 1]])
space = [{'name': 'var', 'type': 'bandit', 'domain':X}]
design_space = Design_space(space)
self.assertTrue(design_space._has_bandit())
self.assertTrue(design_space.unzip_inputs(X).all()==X.all())
self.assertTrue(design_space.zip_inputs(X).all()==X.all())
def test_rand_anchor_points_without_duplicate(self):
space = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 1
}, {
'name': 'var_2',
'type': 'discrete',
'domain': (0, 1, 2, 3)
}, {
'name': 'var_3',
'type': 'categorical',
'domain': (0, 1)
}]
design_space = Design_space(space)
np.random.seed(666)
design_type = "random"
generator = RandomAnchorPointsGenerator(design_space,
design_type,
num_samples=10)
scores = generator.get_anchor_point_scores(np.arange(3).reshape(3, 1))
assert np.linalg.norm(scores - np.array([0., 1., 2.])) < tolerance
assert np.linalg.norm(
generator.get(num_anchor=2) -
np.array([[-2.19900984, 0., 0., 1.], [-0.02338332, 2., 1., 0.]])
) < tolerance
def get_subspace(space, subspace_idx):
subspace_domain = [
dim for idx, dim in enumerate(space.config_space)
if idx in subspace_idx
]
# Todo: constraints
return Design_space(space=subspace_domain, constraints=None)
def setUp(self):
kwargs = {
'n_samples': 1000,
'n_burnin': 100,
'subsample_interval': 5,
'step_size': 1e-1,
'leapfrog_steps': 20,
'optimize_restarts': 10,
'num_inducing': 15,
'acquisition_transformation': 'softplus',
'acquisition_jitter': 0.02,
'acquisition_weight': 2.5,
'acquisition_transformation': 'softplus'
}
## --- Defaults for some of the tests
self.space = Design_space(space=[{
'name': 'var1',
'type': 'continuous',
'domain': (-10, 10),
'dimensionality': 2
}])
self.cost = CostModel(None)
self.arguments_manager = ArgumentsManager(kwargs)
self.model = self.arguments_manager.model_creator(model_type='GP',
exact_feval=True,
space=self.space)
self.acquisition_optimizer = AcquisitionOptimizer(self.space)
self.acquisition = self.arguments_manager.acquisition_creator(
'EI', self.model, self.space, self.acquisition_optimizer,
self.cost)
def __init__(self, *args, **kwargs):
super(TestOptimizerCreation, self).__init__(*args, **kwargs)
self.space = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-1, 1),
'dimensionality': 1
}, {
'name': 'var_2',
'type': 'continuous',
'domain': (-1, 1),
'dimensionality': 1
}]
self.design_space = Design_space(self.space)
self.f = lambda x: np.sum(np.sin(x))
def get_params(self, init_point_num):
from GPyOpt.core.task.space import Design_space
from GPyOpt.experiment_design import LatinDesign
self.get_params_visit += 1
np.random.seed(self.sample * 10 + self.get_params_visit)
space = Design_space(self.domain)
paramsDesign = LatinDesign(space)
if self.if_constraint:
PTS_X = None
while True:
pts_x = paramsDesign.get_samples(int(init_point_num * 2.5))
pts_x_fit = None
for pt_x in pts_x:
if pt_x[0] <= pt_x[2]:
if pts_x_fit is None: pts_x_fit = pt_x
else: pts_x_fit = np.vstack((pts_x_fit, pt_x))
if PTS_X is None: PTS_X = pts_x_fit
else: PTS_X = np.vstack((PTS_X, pts_x_fit))
if PTS_X.shape[0] >= init_point_num:
PTS_X = PTS_X[np.random.choice(
PTS_X.shape[0], init_point_num, replace=False), :]
break
else:
PTS_X = paramsDesign.get_samples(init_point_num)
return PTS_X
def setUp(self):
self.mock_model = Mock()
self.mock_optimizer = Mock()
domain = [{'name': 'var_1', 'type': 'continuous', 'domain': (-5,5), 'dimensionality': 2}]
self.space = Design_space(domain, None)
self.mpi_acquisition = AcquisitionMPI(self.mock_model, self.space, self.mock_optimizer)
def test_create_continuous_by_default(self):
space = [{'domain':(-1,1)}]
design_space = Design_space(space)
self.assertEqual(len(design_space.space_expanded), 1)
self.assertIsInstance(design_space.space_expanded[0], ContinuousVariable)
def setUp(self):
self.space = [
{'name': 'var_1', 'type': 'continuous', 'domain':(-3,1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'discrete', 'domain': (0,1,2,3)},
{'name': 'var_3', 'type': 'categorical', 'domain': (0,1,2)}
]
self.design_space = Design_space(self.space)
def setUp(self):
np.random.seed(123)
domain = [{'name': 'var1', 'type': 'continuous', 'domain': (-5, 5), 'dimensionality': 5}]
space = Design_space(domain)
func = alpine1(input_dim=5, bounds=space.get_bounds())
bo = BayesianOptimization(f=func.f, domain=domain)
context = {'var1_1': 0.3, 'var1_2': 0.4}
context_manager = ContextManager(space, context)
x0 = np.array([[0, 0, 0, 0, 0]])
# initialize the model in a least intrusive way possible
bo.suggest_next_locations()
f = bo.acquisition.acquisition_function
f_df = bo.acquisition.acquisition_function_withGradients
self.problem_with_context = OptimizationWithContext(x0=x0, f=f, df=None, f_df=f_df, context_manager=context_manager)
self.x = np.array([[3, -3, 3]])
def initialize_space(domain, constraints):
if not isinstance(domain, list):
raise ValueError('domain has to be a list')
for idx, dim in enumerate(domain):
dim['name'] = str(idx)
return Design_space(space=domain, constraints=constraints)
def test_random_design_with_bandit_only(self):
space = [self.bandit_variable]
self.design_space = Design_space(space)
initial_points_count = 3
samples = initial_design('random', self.design_space, initial_points_count)
self.assertEqual(len(samples), initial_points_count)
def test_invalid_bandit_config(self):
space = [{
'name': 'var_1',
'type': 'bandit',
'domain': np.array([[-1, 1], [1]])
}]
with self.assertRaises(InvalidConfigError):
design_space = Design_space(space)
def test_random_design_with_constrains(self):
constraints = [{'name': 'const_1', 'constrain': 'x[:,0]**2 - 1'}]
self.design_space = Design_space(self.space, constraints=constraints)
initial_points_count = 10
samples = initial_design('random', self.design_space, initial_points_count)
self.assert_samples_against_space(samples)
self.assertTrue((samples[:,0]**2 - 1 < 0).all())
def setUp(self):
self.space = [
{'name': 'var_1', 'type': 'continuous', 'domain':(-3,1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'discrete', 'domain': (0,1,2,3)},
{'name': 'var_3', 'type': 'categorical', 'domain': (0,1,2)}
]
self.design_space = Design_space(self.space)
self.bandit_variable = {'name': 'stations', 'type': 'bandit', 'domain': np.array([[1, 1], [2, 2], [3, 3], [4, 4]])}
def test_input_dimensions(self):
space = [
{'name': 'var_1', 'type': 'continuous', 'domain':(-3,1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'discrete', 'domain': (0,1,2,3), 'dimensionality': 1},
{'name': 'var_3', 'type': 'categorical', 'domain': (2, 4, 6)}
]
design_space = Design_space(space)
self.assertEqual(design_space.input_dim(), 2)
space[0]['dimensionality'] = 3
design_space = Design_space(space)
self.assertEqual(design_space.input_dim(), 4)
def __init__(self, *args, **kwargs):
super(TestOptimizerCreation, self).__init__(*args, **kwargs)
self.space = [
{'name': 'var_1', 'type': 'continuous', 'domain': (-1, 1), 'dimensionality': 1},
{'name': 'var_2', 'type': 'continuous', 'domain': (-1, 1), 'dimensionality': 1}
]
self.design_space = Design_space(self.space)
self.f = lambda x: np.sum(np.sin(x))
def get_GP_optimum(obj):
"""
Finds the optimal design by maximising the mean of the surrogate
probabilistic GP model.
Parameters
----------
obj: GPyOpt object
The GPyOpt object with a surrogate probabilistic model.
"""
# Define space
space = Design_space(obj.domain, obj.constraints)
bounds = space.get_bounds()
# Specify Optimizer --- L-BFGS
optimizer = OptLbfgs(space.get_bounds(), maxiter=1000)
# Do the optimisation
x, _ = optimizer.optimize(
x0=obj.x_opt,
f=lambda d: fun_dfun(obj, space, d)[0],
f_df=lambda d: fun_dfun(obj, space, d),
)
# TODO: MULTIPLE RE-STARTS FROM PREVIOUS BEST POINTS
# Round values if space is discrete
xtest = space.round_optimum(x)[0]
if space.indicator_constraints(xtest):
opt = xtest
else:
# Rounding mixed things up, so need to look at neighbours
# Compute neighbours to optimum
idx_comb = np.array(
list(itertools.product([-1, 0, 1], repeat=len(bounds))))
opt_combs = idx_comb + xtest
# Evaluate
GP_evals = list()
combs = list()
for idx, d in enumerate(opt_combs):
cons_check = space.indicator_constraints(d)[0][0]
bounds_check = indicator_boundaries(bounds, d)[0][0]
if cons_check * bounds_check == 1:
pred = obj.model.predict(d)[0][0][0]
GP_evals.append(pred)
combs.append(d)
else:
pass
idx_opt = np.where(GP_evals == np.min(GP_evals))[0][0]
opt = combs[idx_opt]
return opt
def test_create_bandit_variable(self):
space = [{
'name': 'var_1',
'type': 'bandit',
'domain': np.array([[-1], [0], [1]])
}]
design_space = Design_space(space)
self.assertEqual(len(design_space.space_expanded), 1)
self.assertIsInstance(design_space.space_expanded[0], BanditVariable)
def test_create_categorical_variable(self):
space = [{
'name': 'var_3',
'type': 'categorical',
'domain': (0, 1, 2, 3)
}]
design_space = Design_space(space)
self.assertEqual(len(design_space.space_expanded), 1)
self.assertIsInstance(design_space.space_expanded[0],
CategoricalVariable)
def test_round_optimum_shapes(self):
space = [{'name': 'var1', 'type': 'continuous', 'domain':(-1,1), 'dimensionality': 1}]
with self.assertRaises(ValueError):
design_space = Design_space(space)
design_space.round_optimum([[[0.0]]])
with self.assertRaises(ValueError):
design_space = Design_space(space)
design_space.round_optimum(np.array([[[0.0]]]))
with self.assertRaises(ValueError):
design_space = Design_space(space)
design_space.round_optimum(np.array([[0.0], [2.0]]))
# Next couple of tests are intentionally very simple
# as they just verify that exception is not thrown for the given input shape
design_space = Design_space(space)
rounded = design_space.round_optimum([0.0])
self.assertEqual(rounded[0], 0.0)
rounded = design_space.round_optimum(np.array([0.0]))
self.assertEqual(rounded[0], 0.0)
rounded = design_space.round_optimum([[0.0]])
self.assertEqual(rounded[0], 0.0)
rounded = design_space.round_optimum(np.array([[0.0]]))
self.assertEqual(rounded[0], 0.0)
def assert_round_optimum(self, space, test_cases):
design_space = Design_space(space)
for test_case in test_cases:
rounded = design_space.round_optimum(np.array(test_case['in']))
self.assertTrue(np.array_equal(rounded, np.array(test_case['out'])))
