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 __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_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 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 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_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 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_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_random_design_with_constraints(self):
constraints = [{'name': 'const_1', 'constraint': '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 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_nonrandom_designs_with_constrains(self):
constraints = [{'name': 'const_1', 'constraint': 'x[:,0]**2 - 1'}]
self.design_space = Design_space(self.space, constraints=constraints)
initial_points_count = 10
with self.assertRaises(InvalidConfigError):
initial_design('grid', self.design_space, initial_points_count)
with self.assertRaises(InvalidConfigError):
initial_design('latin', self.design_space, initial_points_count)
with self.assertRaises(InvalidConfigError):
initial_design('sobol', self.design_space, initial_points_count)
def setUp(self):
self.mock_model = Mock()
self.mock_optimizer = Mock()
domain = [{'name': 'var_1', 'type': 'categorical', 'domain': (0, 1)}, {'name': 'var_2', 'type': 'continuous', 'domain': (-5,5), 'dimensionality': 2}]
# con_1: if var_1 is 0, var_2_1 must be <= -1
# con_2: 3 * (var_2_1 + var_2_2) <= 24
constraints = [{'name': 'con_1', 'constraint': '(x[:,0] == 0) * (x[:,1] + 1)'},
{'name': 'con_2', 'constraint': ' 3 * (x[:,1] + x[:,2]) - 24'}]
self.space = Design_space(domain, constraints)
self.ei_acquisition = AcquisitionEI(self.mock_model, self.space, self.mock_optimizer)
self.ei_acquisition._compute_acq = Mock()
self.ei_acquisition._compute_acq_withGradients = Mock()
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 setUp(self):
self.mock_model = Mock()
self.mock_optimizer = Mock()
self.expected_optimum_position = [[0, 0]]
self.mock_optimizer.optimize.return_value = self.expected_optimum_position, self.expected_optimum_position
domain = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-5, 5),
'dimensionality': 2
}]
self.space = Design_space(domain, None)
self.mock_optimizer.context_manager = ContextManager(self.space)
self.ei_acquisition = AcquisitionEI(self.mock_model, self.space,
self.mock_optimizer)
self.random_batch = RandomBatch(self.ei_acquisition, 10)
def test_input_warping_model(self):
config1 = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 2
}, {
'name': 'var_2',
'type': 'discrete',
'domain': (-3, 1),
'dimensionality': 1
}]
space1 = Design_space(config1)
m = InputWarpedGPModel(space1)
np.random.seed(0)
X = np.random.randn(50, 3)
Y = np.sum(np.sin(X), 1).reshape(50, 1)
m._create_model(X, Y)
def test_latin_design_with_multiple_continuous_variables(self):
self.space.extend([{
'name': 'var_5',
'type': 'continuous',
'domain': (0, 5),
'dimensionality': 2
}, {
'name': 'var_6',
'type': 'continuous',
'domain': (-5, 5),
'dimensionality': 1
}])
self.design_space = Design_space(self.space)
init_points_count = 10
samples = initial_design('latin', self.design_space, init_points_count)
self.assertEqual(len(samples), init_points_count)
self.assert_samples_against_space(samples)
def test_ts_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"
# We mock a model
class dummy_model:
def predict(self, X):
n = X.shape[0]
return np.zeros(n), np.ones(n)
generator = ThompsonSamplingAnchorPointsGenerator(design_space,
design_type,
dummy_model(),
num_samples=10)
scores = generator.get_anchor_point_scores(np.arange(3).reshape(3, 1))
assert np.linalg.norm(
scores - np.array([0.82418808, 0.479966, 1.17346801])) < tolerance
assert np.linalg.norm(
generator.get(num_anchor=2) -
np.array([[-2.54856939, 2., 1., 0.], [0.09791782, 1., 1., 0.]])
) < tolerance
def setUp(self):
np.random.seed(1)
X = np.array([[-1.5, -1], [1, 1.5], [3, 3]])
y = 2 * -np.array([[-0.1], [.3], [.9]])
bounds = [(-5, 5)]
input_dim = X.shape[1]
kern = GPy.kern.RBF(input_dim, variance=1., lengthscale=1.)
self.model = GPModel(kern,
noise_var=0.0,
max_iters=0,
optimize_restarts=0)
self.model.updateModel(X, y, None, None)
domain = [{
'name': 'var_1',
'type': 'continuous',
'domain': bounds[0],
'dimensionality': 2
}]
self.space = Design_space(domain)
self.mock_optimizer = Mock()
def test_gpmodel_predict_covariance(self):
config = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-1, 1),
'dimensionality': 1
}, {
'name': 'var_2',
'type': 'continuous',
'domain': (-1, 1),
'dimensionality': 1
}]
space = Design_space(config)
model = GPModel(space)
mock_mean = np.array([[2.0], [-2.0]])
mock_variance = np.array([[4.0, 3.0], [4.5, 9.0]])
model.model = Mock()
model.model.predict.return_value = (mock_mean, mock_variance)
v = model.predict_covariance(np.ones((2, 2)))
assert_allclose(v, mock_variance, atol=1e-5)
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_objective_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"
dummy_objective = lambda X: np.sum(X * X, axis=1)
generator = ObjectiveAnchorPointsGenerator(design_space,
design_type,
dummy_objective,
num_samples=10)
assert np.all(
generator.get_anchor_point_scores(np.arange(3).reshape(3, 1)) ==
np.array([0.0, 1.0, 4.0]))
assert np.linalg.norm(
generator.get(num_anchor=2) -
np.array([[-0.02338332, 2., 1., 0.], [0.09791782, 2., 1., 0.]])
) < tolerance
def test_context_hadler(self):
space = [{
'name': 'var1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 3
}, {
'name': 'var2',
'type': 'discrete',
'domain': (0, 1, 2, 3)
}, {
'name': 'var3',
'type': 'continuous',
'domain': (-5, 5)
}, {
'name': 'var4',
'type': 'categorical',
'domain': (0, 1)
}]
context = {'var1_1': 0.45, 'var3': 0.52}
design_space = Design_space(space)
np.random.seed(666)
self.context_manager = ContextManager(space=design_space,
context=context)
noncontext_bounds = [(-3, 1), (-3, 1), (0, 3), (0, 1), (0, 1)]
noncontext_index = [1, 2, 3, 5, 6]
expanded_vector = np.array([[0.45, 0., 0., 0., 0.52, 0., 0.]])
assert np.all(
noncontext_bounds == self.context_manager.noncontext_bounds)
assert np.all(
noncontext_index == self.context_manager.noncontext_index)
assert np.all(expanded_vector == self.context_manager._expand_vector(
np.array([[0, 0, 0, 0, 0]])))
def test_input_warping_indices(self):
config1 = [{
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 2
}, {
'name': 'var_2',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 1
}]
warp_ind1 = [0, 1, 2]
space1 = Design_space(config1)
m1 = InputWarpedGPModel(space1)
self.assertEqual(m1.warping_indices, warp_ind1)
config2 = [{
'name': 'var_1',
'type': 'categorical',
'domain': (0, 1, 2, 3)
}, {
'name': 'var_2',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 1
}]
warp_ind2 = [1]
space2 = Design_space(config2)
m2 = InputWarpedGPModel(space2)
self.assertEqual(m2.warping_indices, warp_ind2)
config3 = [{
'name': 'var_1',
'type': 'categorical',
'domain': (0, 1, 2, 3)
}, {
'name': 'var_2',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 1
}]
warp_ind3 = [1]
space3 = Design_space(config3)
m3 = InputWarpedGPModel(space3)
self.assertEqual(m3.warping_indices, warp_ind3)
config4 = [{
'name': 'var_3',
'type': 'discrete',
'domain': (0, 1, 2, 3)
}, {
'name': 'var_3',
'type': 'continuous',
'domain': (2, 4),
'dimensionality': 2
}, {
'name': 'var_1',
'type': 'continuous',
'domain': (-3, 1),
'dimensionality': 1
}]
warp_ind4 = [0, 1, 2, 3]
space4 = Design_space(config4)
m4 = InputWarpedGPModel(space4)
self.assertEqual(m4.warping_indices, warp_ind4)
config5 = [{
'name': 'var_4',
'type': 'bandit',
'domain': np.array([[-2, -1], [0, 1]])
}]
warp_ind5 = []
space5 = Design_space(config5)
m5 = InputWarpedGPModel(space5)
self.assertEqual(m5.warping_indices, warp_ind5)