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_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_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_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 get(self,
num_anchor=5,
duplicate_manager=None,
unique=False,
context_manager=None):
## --- We use the context handler to remove duplicates only over the non-context variables
if context_manager and not self.space._has_bandit():
# print("In AnchorPointsGenerator: ")
# print(" space.config_space_expanded : ", self.space.config_space_expanded)
# print(" context_manager.nocontext_index_obj: ", context_manager.noncontext_bounds)
space_configuration_without_context = [
self.space.config_space_expanded[idx]
for idx in context_manager.nocontext_index_obj
]
space = Design_space(space_configuration_without_context,
context_manager.space.constraints)
add_context = lambda x: context_manager._expand_vector(x)
else:
space = self.space
add_context = lambda x: x
## --- Generate initial design
X = initial_design(self.design_type, space, self.num_samples)
if unique:
sorted_design = sorted(list({tuple(x) for x in X}))
X = space.unzip_inputs(np.vstack(sorted_design))
else:
X = space.unzip_inputs(X)
## --- Add context variables
X = add_context(X)
if duplicate_manager:
is_duplicate = duplicate_manager.is_unzipped_x_duplicate
else:
# In absence of duplicate manager, we never detect duplicates
is_duplicate = lambda _: False
non_duplicate_anchor_point_indexes = [
index for index, x in enumerate(X) if not is_duplicate(x)
]
if not non_duplicate_anchor_point_indexes:
raise FullyExploredOptimizationDomainError(
"No anchor points could be generated ({} used samples, {} requested anchor points)."
.format(self.num_samples, num_anchor))
if len(non_duplicate_anchor_point_indexes) < num_anchor:
# Since logging has not been setup yet, I do not know how to express warnings...I am using standard print for now.
print("Warning: expecting {} anchor points, only {} available.".
format(num_anchor, len(non_duplicate_anchor_point_indexes)))
X = X[non_duplicate_anchor_point_indexes, :]
scores = self.get_anchor_point_scores(X)
anchor_points = X[np.argsort(scores)[:min(len(scores), num_anchor)], :]
return anchor_points