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_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 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
# We can also visualize how a performance metric evolved with respect to the number of BO iterations.
# 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.