def test_pareto_hypercell_bounds_raises_for_front_below_anti_reference_point(
anti_reference: list[float],
) -> None:
pareto = Pareto(tf.constant([[-1.0, -0.6], [-0.8, -0.7], [-0.6, -1.1]]))
with pytest.raises(tf.errors.InvalidArgumentError):
pareto.hypercell_bounds(tf.constant(anti_reference), tf.constant([10.0, 10.0]))
def test_pareto_hypervolume_indicator_raises_for_reference_below_anti_ideal_point(
reference: list[float],
) -> None:
pareto = Pareto(tf.constant([[-1.0, -0.6], [-0.8, -0.7], [-0.6, -1.1]]))
with pytest.raises(tf.errors.InvalidArgumentError):
pareto.hypervolume_indicator(tf.constant(reference))
def test_pareto_hypercell_bounds_raises_for_anti_reference_with_invalid_shape(
anti_reference: SequenceN[float],
) -> None:
pareto = Pareto(tf.constant([[-1.0, -0.6], [-0.8, -0.7], [-0.6, -1.1]]))
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
pareto.hypercell_bounds(tf.constant(anti_reference), tf.constant([0.0, 0.0]))
def test_pareto_hypervolume_indicator_raises_for_reference_with_invalid_shape(
reference: SequenceN[float],
) -> None:
pareto = Pareto(tf.constant([[-1.0, -0.6], [-0.8, -0.7], [-0.6, -1.1]]))
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
pareto.hypervolume_indicator(tf.constant(reference))
def test_expected_hypervolume_improvement(
input_dim: int,
num_samples_per_point: int,
existing_observations: tf.Tensor,
obj_num: int,
variance_scale: float,
) -> None:
# Note: the test data number grows exponentially with num of obj
data_num_seg_per_dim = 2 # test data number per input dim
N = data_num_seg_per_dim**input_dim
xs = tf.convert_to_tensor(
list(
itertools.product(
*[list(tf.linspace(-1, 1, data_num_seg_per_dim))] *
input_dim)))
xs = tf.cast(xs, dtype=existing_observations.dtype)
model = _mo_test_model(obj_num, *[variance_scale] * obj_num)
mean, variance = model.predict(xs)
predict_samples = tfp.distributions.Normal(mean, tf.sqrt(variance)).sample(
num_samples_per_point # [f_samples, batch_size, obj_num]
)
_pareto = Pareto(existing_observations)
ref_pt = get_reference_point(_pareto.front)
lb_points, ub_points = _pareto.hypercell_bounds(
tf.constant([-math.inf] * ref_pt.shape[-1]), ref_pt)
# calc MC approx EHVI
splus_valid = tf.reduce_all(
tf.tile(ub_points[tf.newaxis, :, tf.newaxis, :],
[num_samples_per_point, 1, N, 1]) > tf.expand_dims(
predict_samples, axis=1),
axis=-1, # can predict_samples contribute to hvi in cell
) # [f_samples, num_cells, B]
splus_idx = tf.expand_dims(tf.cast(splus_valid, dtype=ub_points.dtype), -1)
splus_lb = tf.tile(lb_points[tf.newaxis, :, tf.newaxis, :],
[num_samples_per_point, 1, N, 1])
splus_lb = tf.maximum( # max of lower bounds and predict_samples
splus_lb, tf.expand_dims(predict_samples, 1))
splus_ub = tf.tile(ub_points[tf.newaxis, :, tf.newaxis, :],
[num_samples_per_point, 1, N, 1])
splus = tf.concat( # concatenate validity labels and possible improvements
[splus_idx, splus_ub - splus_lb],
axis=-1)
# calculate hyper-volume improvement over the non-dominated cells
ehvi_approx = tf.transpose(
tf.reduce_sum(tf.reduce_prod(splus, axis=-1), axis=1, keepdims=True))
ehvi_approx = tf.reduce_mean(ehvi_approx,
axis=-1) # average through mc sample
ehvi = expected_hv_improvement(model, _pareto,
ref_pt)(tf.expand_dims(xs, -2))
npt.assert_allclose(ehvi, ehvi_approx, rtol=0.01, atol=0.01)
def test_pareto_hypercell_bounds(
objectives: SequenceN[float],
anti_reference: list[float],
reference: list[float],
expected: SequenceN[float],
):
pareto = Pareto(tf.constant(objectives))
npt.assert_allclose(
pareto.hypercell_bounds(tf.constant(anti_reference), tf.constant(reference))[0],
tf.constant(expected[0]),
)
npt.assert_allclose(
pareto.hypercell_bounds(tf.constant(anti_reference), tf.constant(reference))[1],
tf.constant(expected[1]),
)
def test_pareto_2d_bounds() -> None:
objectives = tf.constant(
[
[0.9575, 0.4218],
[0.9649, 0.9157],
[0.1576, 0.7922],
[0.9706, 0.9595],
[0.9572, 0.6557],
[0.4854, 0.0357],
[0.8003, 0.8491],
[0.1419, 0.9340],
]
)
pareto_2d = Pareto(objectives)
npt.assert_array_equal(
pareto_2d._bounds.lower_idx, tf.constant([[0, 0], [1, 0], [2, 0], [3, 0]])
)
npt.assert_array_equal(
pareto_2d._bounds.upper_idx, tf.constant([[1, 4], [2, 1], [3, 2], [4, 3]])
)
npt.assert_allclose(
pareto_2d.front, tf.constant([[0.1419, 0.9340], [0.1576, 0.7922], [0.4854, 0.0357]])
)
def test_pareto_divide_conquer_nd_three_dimension_case() -> None:
objectives = tf.constant(
[
[9.0, 0.0, 1.0],
[10.0, 4.0, 7.0],
[4.0, 3.0, 3.0],
[7.0, 6.0, 0.0],
[10.0, 0.0, 2.0],
[0.0, 2.0, 1.0],
]
)
pareto = Pareto(objectives)
npt.assert_array_equal(
pareto._bounds.lower_idx,
tf.constant(
[
[3, 2, 0],
[3, 1, 0],
[2, 2, 0],
[2, 1, 0],
[3, 0, 1],
[2, 0, 1],
[2, 0, 0],
[0, 1, 1],
[0, 1, 0],
[0, 0, 0],
]
),
)
npt.assert_array_equal(
pareto._bounds.upper_idx,
tf.constant(
[
[4, 4, 2],
[4, 2, 1],
[3, 4, 2],
[3, 2, 1],
[4, 3, 4],
[3, 1, 4],
[4, 1, 1],
[1, 4, 4],
[2, 4, 1],
[2, 1, 4],
]
),
)
npt.assert_allclose(
pareto.front,
tf.constant(
[
[0.0, 2.0, 1.0],
[7.0, 6.0, 0.0],
[9.0, 0.0, 1.0],
]
),
)
def test_multi_objective_optimizer_finds_pareto_front_of_the_VLMOP2_function(
num_steps: int, acquisition_rule: AcquisitionRule) -> None:
search_space = Box([-2, -2], [2, 2])
def build_stacked_independent_objectives_model(
data: Dataset) -> ModelStack:
gprs = []
for idx in range(2):
single_obj_data = Dataset(
data.query_points, tf.gather(data.observations, [idx], axis=1))
variance = tf.math.reduce_variance(single_obj_data.observations)
kernel = gpflow.kernels.Matern52(
variance, tf.constant([0.2, 0.2], tf.float64))
gpr = gpflow.models.GPR(single_obj_data.astuple(),
kernel,
noise_variance=1e-5)
gpflow.utilities.set_trainable(gpr.likelihood, False)
gprs.append((GaussianProcessRegression(gpr), 1))
return ModelStack(*gprs)
observer = mk_observer(VLMOP2().objective(), OBJECTIVE)
initial_query_points = search_space.sample(10)
initial_data = observer(initial_query_points)
model = build_stacked_independent_objectives_model(initial_data[OBJECTIVE])
dataset = (BayesianOptimizer(observer, search_space).optimize(
num_steps, initial_data, {
OBJECTIVE: model
}, acquisition_rule).try_get_final_datasets()[OBJECTIVE])
# A small log hypervolume difference corresponds to a succesful optimization.
ref_point = get_reference_point(dataset.observations)
obs_hv = Pareto(dataset.observations).hypervolume_indicator(ref_point)
ideal_pf = tf.cast(VLMOP2().gen_pareto_optimal_points(100),
dtype=tf.float64)
ideal_hv = Pareto(ideal_pf).hypervolume_indicator(ref_point)
assert tf.math.log(ideal_hv - obs_hv) < -3.5
def test_ehvi_raises_for_invalid_batch_size(at: TensorType) -> None:
num_obj = 2
train_x = tf.constant([[-2.0], [-1.5], [-1.0], [0.0], [0.5], [1.0], [1.5], [2.0]])
model = _mo_test_model(num_obj, *[None] * num_obj)
model_pred_observation = model.predict(train_x)[0]
_prt = Pareto(model_pred_observation)
ehvi = expected_hv_improvement(model, _prt, get_reference_point(_prt.front))
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
ehvi(at)
def test_ehvi_builder_builds_expected_hv_improvement_using_pareto_from_model() -> None:
num_obj = 2
train_x = tf.constant([[-2.0], [-1.5], [-1.0], [0.0], [0.5], [1.0], [1.5], [2.0]])
dataset = Dataset(
train_x,
tf.tile(
tf.constant([[4.1], [0.9], [1.2], [0.1], [-8.8], [1.1], [2.1], [3.9]]), [1, num_obj]
),
)
model = _mo_test_model(num_obj, *[None] * num_obj)
acq_fn = ExpectedHypervolumeImprovement().prepare_acquisition_function(dataset, model)
model_pred_observation = model.predict(train_x)[0]
_prt = Pareto(model_pred_observation)
xs = tf.linspace([[-10.0]], [[10.0]], 100)
expected = expected_hv_improvement(model, _prt, get_reference_point(_prt.front))(xs)
npt.assert_allclose(acq_fn(xs), expected)
def log_hv(observations):
obs_hv = Pareto(observations).hypervolume_indicator(ref_point)
return math.log10(idea_hv - obs_hv)
# First, we need to define a performance metric. Many metrics have been considered for multi-objective optimization. Here, we use the log hypervolume difference, defined as the difference between the hypervolume of the actual Pareto front and the hypervolume of the approximate Pareto front based on the bo-obtained data.
# %% [markdown]
#
# $$
# log_{10}\ \text{HV}_{\text{diff}} = log_{10}(\text{HV}_{\text{actual}} - \text{HV}_{\text{bo-obtained}})
# $$
#
# %% [markdown]
# First we need to calculate the $\text{HV}_{\text{actual}}$ based on the actual Pareto front. For some multi-objective synthetic functions like VLMOP2, the actual Pareto front has a clear definition, thus we could use `gen_pareto_optimal_points` to near uniformly sample on the actual Pareto front. And use these generated Pareto optimal points to (approximately) calculate the hypervolume of the actual Pareto frontier:
# %%
actual_pf = VLMOP2().gen_pareto_optimal_points(100) # gen 100 pf points
ref_point = get_reference_point(data_observations)
idea_hv = Pareto(tf.cast(
actual_pf, dtype=data_observations.dtype)).hypervolume_indicator(ref_point)
# %% [markdown]
# Then we define the metric function:
# %%
def log_hv(observations):
obs_hv = Pareto(observations).hypervolume_indicator(ref_point)
return math.log10(idea_hv - obs_hv)
# %% [markdown]
# Finally, we can plot the convergence of our performance metric over the course of the optimization.
# The blue vertical line in the figure denotes the time after which BO starts.
def test_pareto_hypervolume_indicator(
objectives: list[list[float]], reference: list[float], expected: float
) -> None:
pareto = Pareto(tf.constant(objectives))
npt.assert_allclose(pareto.hypervolume_indicator(tf.constant(reference)), expected)
