def test_expected_hypervolume_improvement(self):
tkwargs = {"device": self.device}
for dtype in (torch.float, torch.double):
ref_point = [0.0, 0.0]
tkwargs["dtype"] = dtype
pareto_Y = torch.tensor(
[[4.0, 5.0], [5.0, 5.0], [8.5, 3.5], [8.5, 3.0], [9.0, 1.0]],
**tkwargs)
partitioning = NondominatedPartitioning(
ref_point=torch.tensor(ref_point, **tkwargs))
# the event shape is `b x q x m` = 1 x 1 x 1
mean = torch.zeros(1, 1, 2, **tkwargs)
variance = torch.zeros(1, 1, 2, **tkwargs)
mm = MockModel(MockPosterior(mean=mean, variance=variance))
# test error if there is not pareto_Y initialized in partitioning
with self.assertRaises(BotorchError):
ExpectedHypervolumeImprovement(model=mm,
ref_point=ref_point,
partitioning=partitioning)
partitioning.update(Y=pareto_Y)
# test error if ref point has wrong shape
with self.assertRaises(ValueError):
ExpectedHypervolumeImprovement(model=mm,
ref_point=ref_point[:1],
partitioning=partitioning)
with self.assertRaises(ValueError):
# test error if no pareto_Y point is better than ref_point
ExpectedHypervolumeImprovement(model=mm,
ref_point=[10.0, 10.0],
partitioning=partitioning)
X = torch.zeros(1, 1, **tkwargs)
# basic test
acqf = ExpectedHypervolumeImprovement(model=mm,
ref_point=ref_point,
partitioning=partitioning)
res = acqf(X)
self.assertEqual(res.item(), 0.0)
# check ref point
self.assertTrue(
torch.equal(acqf.ref_point, torch.tensor(ref_point,
**tkwargs)))
# check bounds
self.assertTrue(hasattr(acqf, "cell_lower_bounds"))
self.assertTrue(hasattr(acqf, "cell_upper_bounds"))
# check cached indices
expected_indices = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]],
dtype=torch.long,
device=self.device)
self.assertTrue(
torch.equal(acqf._cross_product_indices, expected_indices))
def test_constrained_q_expected_hypervolume_improvement(self):
for dtype in (torch.float, torch.double):
tkwargs = {"device": self.device, "dtype": dtype}
ref_point = [0.0, 0.0]
t_ref_point = torch.tensor(ref_point, **tkwargs)
pareto_Y = torch.tensor(
[[4.0, 5.0], [5.0, 5.0], [8.5, 3.5], [8.5, 3.0], [9.0, 1.0]],
**tkwargs)
partitioning = NondominatedPartitioning(ref_point=t_ref_point)
partitioning.update(Y=pareto_Y)
# test q=1
# the event shape is `b x q x m` = 1 x 1 x 2
samples = torch.tensor([[[6.5, 4.5]]], **tkwargs)
mm = MockModel(MockPosterior(samples=samples))
sampler = IIDNormalSampler(num_samples=1)
X = torch.zeros(1, 1, **tkwargs)
# test zero slack
for eta in (1e-1, 1e-2):
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
constraints=[lambda Z: torch.zeros_like(Z[..., -1])],
eta=eta,
)
res = acqf(X)
self.assertAlmostEqual(res.item(), 0.5 * 1.5, places=4)
# test feasible
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
constraints=[lambda Z: -100.0 * torch.ones_like(Z[..., -1])],
eta=1e-3,
)
res = acqf(X)
self.assertAlmostEqual(res.item(), 1.5, places=4)
# test infeasible
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
constraints=[lambda Z: 100.0 * torch.ones_like(Z[..., -1])],
eta=1e-3,
)
res = acqf(X)
self.assertAlmostEqual(res.item(), 0.0, places=4)
def _torch_optimize_qehvi_and_get_observation(self):
torch_anti_ideal_point = torch.tensor(
self._transformed_anti_ideal_point, dtype=torch.double)
qehvi_partitioning = NondominatedPartitioning(
ref_point=torch_anti_ideal_point,
Y=torch.stack(self._torch_model.train_targets, dim=1))
qehvi_sampler = SobolQMCNormalSampler(num_samples=MC_SAMPLES)
self._acquisition = qExpectedHypervolumeImprovement(
model=self._torch_model,
ref_point=self._transformed_anti_ideal_point,
partitioning=qehvi_partitioning,
sampler=qehvi_sampler)
# these options all come from the tutorial
# and likely need a serious review
candidates, _ = optimize_acqf(
acq_function=self._acquisition,
bounds=self._botorch_domain,
q=BATCH_SIZE,
num_restarts=NUM_RESTARTS,
raw_samples=RAW_SAMPLES, # used for intialization heuristic
options={
"batch_limit": 5,
"maxiter": 200,
"nonnegative": True
},
sequential=True,
)
# is unnormalize necessary here?
# we are providing the same bounds here and in optimizer
new_x = unnormalize(candidates.detach(), bounds=self._botorch_domain)
transformed_eps, transformed_err = self._optimization_handler(new_x)
return new_x, transformed_eps, transformed_err
def construct_inputs_EHVI(
model: Model,
training_data: TrainingData,
objective_thresholds: Tensor,
objective: Optional[AnalyticMultiOutputObjective] = None,
**kwargs: Any,
) -> Dict[str, Any]:
r"""Construct kwargs for `ExpectedHypervolumeImprovement` constructor."""
num_objectives = objective_thresholds.shape[0]
if kwargs.get("outcome_constraints") is not None:
raise NotImplementedError(
"EHVI does not yet support outcome constraints.")
X_observed = training_data.X
alpha = kwargs.get(
"alpha",
get_default_partitioning_alpha(num_objectives=num_objectives),
)
# This selects the objectives (a subset of the outcomes) and set each
# objective threhsold to have the proper optimization direction.
if objective is None:
objective = IdentityAnalyticMultiOutputObjective()
ref_point = objective(objective_thresholds)
# Compute posterior mean (for ref point computation ref pareto frontier)
# if one is not provided among arguments.
Y_pmean = kwargs.get("Y_pmean")
if Y_pmean is None:
with torch.no_grad():
Y_pmean = model.posterior(X_observed).mean
if alpha > 0:
partitioning = NondominatedPartitioning(
ref_point=ref_point,
Y=objective(Y_pmean),
alpha=alpha,
)
else:
partitioning = FastNondominatedPartitioning(
ref_point=ref_point,
Y=objective(Y_pmean),
)
return {
"model": model,
"ref_point": ref_point,
"partitioning": partitioning,
"objective": objective,
}
def test_acquisition_functions(self):
tkwargs = {"device": self.device, "dtype": torch.double}
train_X, train_Y, train_Yvar, model = self._get_data_and_model(
infer_noise=True, **tkwargs
)
fit_fully_bayesian_model_nuts(
model, warmup_steps=8, num_samples=5, thinning=2, disable_progbar=True
)
sampler = IIDNormalSampler(num_samples=2)
acquisition_functions = [
ExpectedImprovement(model=model, best_f=train_Y.max()),
ProbabilityOfImprovement(model=model, best_f=train_Y.max()),
PosteriorMean(model=model),
UpperConfidenceBound(model=model, beta=4),
qExpectedImprovement(model=model, best_f=train_Y.max(), sampler=sampler),
qNoisyExpectedImprovement(model=model, X_baseline=train_X, sampler=sampler),
qProbabilityOfImprovement(
model=model, best_f=train_Y.max(), sampler=sampler
),
qSimpleRegret(model=model, sampler=sampler),
qUpperConfidenceBound(model=model, beta=4, sampler=sampler),
qNoisyExpectedHypervolumeImprovement(
model=ModelListGP(model, model),
X_baseline=train_X,
ref_point=torch.zeros(2, **tkwargs),
sampler=sampler,
),
qExpectedHypervolumeImprovement(
model=ModelListGP(model, model),
ref_point=torch.zeros(2, **tkwargs),
sampler=sampler,
partitioning=NondominatedPartitioning(
ref_point=torch.zeros(2, **tkwargs), Y=train_Y.repeat([1, 2])
),
),
]
for acqf in acquisition_functions:
for batch_shape in [[5], [6, 5, 2]]:
test_X = torch.rand(*batch_shape, 1, 4, **tkwargs)
self.assertEqual(acqf(test_X).shape, torch.Size(batch_shape))
def test_non_dominated_partitioning(self):
tkwargs = {"device": self.device}
for dtype, partitioning_class in product(
(torch.float, torch.double),
(NondominatedPartitioning, FastNondominatedPartitioning),
):
tkwargs["dtype"] = dtype
ref_point = torch.zeros(2, **tkwargs)
partitioning = partitioning_class(ref_point=ref_point)
# assert error is raised if pareto_Y has not been computed
with self.assertRaises(BotorchError):
partitioning.pareto_Y
partitioning = partitioning_class(ref_point=ref_point)
# test _reset_pareto_Y
Y = torch.ones(1, 2, **tkwargs)
partitioning.update(Y=Y)
partitioning._neg_Y = -Y
partitioning.batch_shape = torch.Size([])
self.assertFalse(partitioning._reset_pareto_Y())
# test m=2
arange = torch.arange(3, 9, **tkwargs)
pareto_Y = torch.stack([arange, 11 - arange], dim=-1)
Y = torch.cat(
[
pareto_Y,
torch.tensor(
[[8.0, 2.0], [7.0, 1.0]], **tkwargs
), # add some non-pareto elements
],
dim=0,
)
partitioning = partitioning_class(ref_point=ref_point, Y=Y)
sorting = torch.argsort(pareto_Y[:, 0], descending=True)
self.assertTrue(torch.equal(pareto_Y[sorting], partitioning.pareto_Y))
inf = float("inf")
expected_cell_bounds = torch.tensor(
[
[
[8.0, 0.0],
[7.0, 3.0],
[6.0, 4.0],
[5.0, 5.0],
[4.0, 6.0],
[3.0, 7.0],
[0.0, 8.0],
],
[
[inf, inf],
[8.0, inf],
[7.0, inf],
[6.0, inf],
[5.0, inf],
[4.0, inf],
[3.0, inf],
],
],
**tkwargs,
)
cell_bounds = partitioning.get_hypercell_bounds()
num_matches = (
(cell_bounds.unsqueeze(0) == expected_cell_bounds.unsqueeze(1))
.all(dim=-1)
.any(dim=0)
.sum()
)
self.assertTrue(num_matches, 7)
# test compute hypervolume
hv = partitioning.compute_hypervolume()
self.assertEqual(hv.item(), 49.0)
# test no pareto points better than the reference point
partitioning = partitioning_class(
ref_point=pareto_Y.max(dim=-2).values + 1, Y=Y
)
self.assertTrue(torch.equal(partitioning.pareto_Y, Y[:0]))
self.assertEqual(partitioning.compute_hypervolume().item(), 0)
Y = torch.rand(3, 10, 2, **tkwargs)
if partitioning_class == NondominatedPartitioning:
# test batched m=2, no pareto points better than the reference point
partitioning = partitioning_class(
ref_point=Y.max(dim=-2).values + 1, Y=Y
)
self.assertTrue(torch.equal(partitioning.pareto_Y, Y[:, :0]))
self.assertTrue(
torch.equal(
partitioning.compute_hypervolume(),
torch.zeros(3, dtype=Y.dtype, device=Y.device),
)
)
# test batched, m=2 basic
partitioning = partitioning_class(ref_point=ref_point, Y=Y)
cell_bounds = partitioning.get_hypercell_bounds()
partitionings = []
for i in range(Y.shape[0]):
partitioning_i = partitioning_class(ref_point=ref_point, Y=Y[i])
partitionings.append(partitioning_i)
# check pareto_Y
pareto_set1 = {tuple(x) for x in partitioning_i.pareto_Y.tolist()}
pareto_set2 = {tuple(x) for x in partitioning.pareto_Y[i].tolist()}
self.assertEqual(pareto_set1, pareto_set2)
expected_cell_bounds_i = partitioning_i.get_hypercell_bounds()
# remove padding
no_padding_cell_bounds_i = cell_bounds[:, i][
:, ((cell_bounds[1, i] - cell_bounds[0, i]) != 0).all(dim=-1)
]
self.assertTrue(
torch.equal(expected_cell_bounds_i, no_padding_cell_bounds_i)
)
# test batch ref point
partitioning = NondominatedPartitioning(
ref_point=ref_point.unsqueeze(0).expand(3, *ref_point.shape), Y=Y
)
cell_bounds2 = partitioning.get_hypercell_bounds()
self.assertTrue(torch.equal(cell_bounds, cell_bounds2))
# test improper Y shape (too many batch dims)
with self.assertRaises(NotImplementedError):
NondominatedPartitioning(ref_point=ref_point, Y=Y.unsqueeze(0))
# test batched compute_hypervolume, m=2
hvs = partitioning.compute_hypervolume()
hvs_non_batch = torch.stack(
[
partitioning_i.compute_hypervolume()
for partitioning_i in partitionings
],
dim=0,
)
self.assertTrue(torch.allclose(hvs, hvs_non_batch))
# test batched m>2
ref_point = torch.zeros(3, **tkwargs)
with self.assertRaises(NotImplementedError):
partitioning_class(
ref_point=ref_point, Y=torch.cat([Y, Y[..., :1]], dim=-1)
)
# test batched, where some batches are have pareto points and
# some batches have empty pareto sets
partitioning = partitioning_class(
ref_point=pareto_Y.max(dim=-2).values,
Y=torch.stack(
[pareto_Y, pareto_Y + pareto_Y.max(dim=-2).values], dim=0
),
)
hv = partitioning.compute_hypervolume()
self.assertEqual(hv[0].item(), 0.0)
self.assertEqual(hv[1].item(), 49.0)
cell_bounds = partitioning.get_hypercell_bounds()
self.assertEqual(cell_bounds.shape, torch.Size([2, 2, 7, 2]))
# test m=3
pareto_Y = torch.tensor(
[[1.0, 6.0, 8.0], [2.0, 4.0, 10.0], [3.0, 5.0, 7.0]], **tkwargs
)
ref_point = torch.tensor([-1.0, -2.0, -3.0], **tkwargs)
partitioning = partitioning_class(ref_point=ref_point, Y=pareto_Y)
if partitioning_class == NondominatedPartitioning:
sorting = torch.argsort(pareto_Y[:, 0], descending=True)
self.assertTrue(torch.equal(pareto_Y[sorting], partitioning.pareto_Y))
else:
self.assertTrue(torch.equal(pareto_Y, partitioning.pareto_Y))
cell_bounds = partitioning.get_hypercell_bounds()
if partitioning_class == NondominatedPartitioning:
expected_cell_bounds = torch.tensor(
[
[
[1.0, 4.0, 7.0],
[-1.0, -2.0, 10.0],
[-1.0, 4.0, 8.0],
[1.0, -2.0, 10.0],
[1.0, 4.0, 8.0],
[-1.0, 6.0, -3.0],
[1.0, 5.0, -3.0],
[-1.0, 5.0, 8.0],
[2.0, -2.0, 7.0],
[2.0, 4.0, 7.0],
[3.0, -2.0, -3.0],
[2.0, -2.0, 8.0],
[2.0, 5.0, -3.0],
],
[
[2.0, 5.0, 8.0],
[1.0, 4.0, inf],
[1.0, 5.0, inf],
[2.0, 4.0, inf],
[2.0, 5.0, inf],
[1.0, inf, 8.0],
[2.0, inf, 8.0],
[2.0, inf, inf],
[3.0, 4.0, 8.0],
[3.0, 5.0, 8.0],
[inf, 5.0, 8.0],
[inf, 5.0, inf],
[inf, inf, inf],
],
],
**tkwargs,
)
# cell bounds can have different order
num_matches = (
(cell_bounds.unsqueeze(0) == expected_cell_bounds.unsqueeze(1))
.all(dim=-1)
.any(dim=0)
.sum()
)
self.assertTrue(num_matches, 9)
# test compute hypervolume
hv = partitioning.compute_hypervolume()
self.assertEqual(hv.item(), 358.0)
# test no pareto points better than the reference point, non-batched
partitioning = partitioning_class(
ref_point=pareto_Y.max(dim=-2).values + 1, Y=pareto_Y
)
self.assertTrue(torch.equal(partitioning.pareto_Y, pareto_Y[:0]))
self.assertEqual(
partitioning.get_hypercell_bounds().shape,
torch.Size([2, 1, pareto_Y.shape[-1]]),
)
self.assertEqual(partitioning.compute_hypervolume().item(), 0)
def get_acquisition_function(
acquisition_function_name: str,
model: Model,
objective: MCAcquisitionObjective,
X_observed: Tensor,
X_pending: Optional[Tensor] = None,
constraints: Optional[List[Callable[[Tensor], Tensor]]] = None,
mc_samples: int = 500,
qmc: bool = True,
seed: Optional[int] = None,
**kwargs,
) -> monte_carlo.MCAcquisitionFunction:
r"""Convenience function for initializing botorch acquisition functions.
Args:
acquisition_function_name: Name of the acquisition function.
model: A fitted model.
objective: A MCAcquisitionObjective.
X_observed: A `m1 x d`-dim Tensor of `m1` design points that have
already been observed.
X_pending: A `m2 x d`-dim Tensor of `m2` design points whose evaluation
is pending.
constraints: A list of callables, each mapping a Tensor of dimension
`sample_shape x batch-shape x q x m` to a Tensor of dimension
`sample_shape x batch-shape x q`, where negative values imply
feasibility. Used when constraint_transforms are not passed
as part of the objective.
mc_samples: The number of samples to use for (q)MC evaluation of the
acquisition function.
qmc: If True, use quasi-Monte-Carlo sampling (instead of iid).
seed: If provided, perform deterministic optimization (i.e. the
function to optimize is fixed and not stochastic).
Returns:
The requested acquisition function.
Example:
>>> model = SingleTaskGP(train_X, train_Y)
>>> obj = LinearMCObjective(weights=torch.tensor([1.0, 2.0]))
>>> acqf = get_acquisition_function("qEI", model, obj, train_X)
"""
# initialize the sampler
if qmc:
sampler = SobolQMCNormalSampler(num_samples=mc_samples, seed=seed)
else:
sampler = IIDNormalSampler(num_samples=mc_samples, seed=seed)
# instantiate and return the requested acquisition function
if acquisition_function_name == "qEI":
best_f = objective(model.posterior(X_observed).mean).max().item()
return monte_carlo.qExpectedImprovement(
model=model,
best_f=best_f,
sampler=sampler,
objective=objective,
X_pending=X_pending,
)
elif acquisition_function_name == "qPI":
best_f = objective(model.posterior(X_observed).mean).max().item()
return monte_carlo.qProbabilityOfImprovement(
model=model,
best_f=best_f,
sampler=sampler,
objective=objective,
X_pending=X_pending,
tau=kwargs.get("tau", 1e-3),
)
elif acquisition_function_name == "qNEI":
return monte_carlo.qNoisyExpectedImprovement(
model=model,
X_baseline=X_observed,
sampler=sampler,
objective=objective,
X_pending=X_pending,
prune_baseline=kwargs.get("prune_baseline", False),
)
elif acquisition_function_name == "qSR":
return monte_carlo.qSimpleRegret(model=model,
sampler=sampler,
objective=objective,
X_pending=X_pending)
elif acquisition_function_name == "qUCB":
if "beta" not in kwargs:
raise ValueError("`beta` must be specified in kwargs for qUCB.")
return monte_carlo.qUpperConfidenceBound(
model=model,
beta=kwargs["beta"],
sampler=sampler,
objective=objective,
X_pending=X_pending,
)
elif acquisition_function_name == "qEHVI":
# pyre-fixme [16]: `Model` has no attribute `train_targets`
try:
ref_point = kwargs["ref_point"]
except KeyError:
raise ValueError(
"`ref_point` must be specified in kwargs for qEHVI")
try:
Y = kwargs["Y"]
except KeyError:
raise ValueError("`Y` must be specified in kwargs for qEHVI")
# get feasible points
if constraints is not None:
feas = torch.stack([c(Y) <= 0 for c in constraints],
dim=-1).all(dim=-1)
Y = Y[feas]
obj = objective(Y)
partitioning = NondominatedPartitioning(
ref_point=torch.as_tensor(ref_point,
dtype=Y.dtype,
device=Y.device),
Y=obj,
alpha=kwargs.get("alpha", 0.0),
)
return moo_monte_carlo.qExpectedHypervolumeImprovement(
model=model,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
objective=objective,
constraints=constraints,
X_pending=X_pending,
)
raise NotImplementedError(
f"Unknown acquisition function {acquisition_function_name}")
def _instantiate_acqf(
self,
model: Model,
objective: AcquisitionObjective,
model_dependent_kwargs: Dict[str, Any],
objective_thresholds: Optional[Tensor] = None,
X_pending: Optional[Tensor] = None,
X_baseline: Optional[Tensor] = None,
) -> None:
# Extract model dependent kwargs
outcome_constraints = model_dependent_kwargs.pop("outcome_constraints")
# Replicate `get_EHVI` transformation code
X_observed = X_baseline
if X_observed is None:
raise ValueError("There are no feasible observed points.")
if objective_thresholds is None:
raise ValueError("Objective Thresholds required")
with torch.no_grad():
Y = model.posterior(X_observed).mean
# For EHVI acquisition functions we pass the constraint transform directly.
if outcome_constraints is None:
cons_tfs = None
else:
cons_tfs = get_outcome_constraint_transforms(outcome_constraints)
num_objectives = objective_thresholds.shape[0]
mc_samples = self.options.get("mc_samples", DEFAULT_EHVI_MC_SAMPLES)
qmc = self.options.get("qmc", True)
alpha = self.options.get(
"alpha",
get_default_partitioning_alpha(num_objectives=num_objectives),
)
# this selects the objectives (a subset of the outcomes) and set each
# objective threhsold to have the proper optimization direction
ref_point = objective(objective_thresholds).tolist()
# initialize the sampler
seed = int(torch.randint(1, 10000, (1,)).item())
if qmc:
sampler = SobolQMCNormalSampler(num_samples=mc_samples, seed=seed)
else:
sampler = IIDNormalSampler(
num_samples=mc_samples, seed=seed
) # pragma: nocover
if not ref_point:
raise ValueError(
"`ref_point` must be specified in kwargs for qEHVI"
) # pragma: nocover
# get feasible points
if cons_tfs is not None:
# pyre-ignore [16]: `Tensor` has no attribute `all`.
feas = torch.stack([c(Y) <= 0 for c in cons_tfs], dim=-1).all(dim=-1)
Y = Y[feas]
obj = objective(Y)
partitioning = NondominatedPartitioning(
ref_point=torch.as_tensor(ref_point, dtype=Y.dtype, device=Y.device),
Y=obj,
alpha=alpha,
)
self.acqf = self._botorch_acqf_class( # pyre-ignore[28]: Some kwargs are
# not expected in base `AcquisitionFunction` but are expected in
# its subclasses.
model=model,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
objective=objective,
constraints=cons_tfs,
X_pending=X_pending,
)
def __init__(
self,
model: Model,
ref_point: Union[List[float], Tensor],
partitioning: NondominatedPartitioning,
sampler: Optional[MCSampler] = None,
objective: Optional[MCMultiOutputObjective] = None,
constraints: Optional[List[Callable[[Tensor], Tensor]]] = None,
X_pending: Optional[Tensor] = None,
eta: float = 1e-3,
) -> None:
r"""q-Expected Hypervolume Improvement supporting m>=2 outcomes.
See [Daulton2020qehvi]_ for details.
Example:
>>> model = SingleTaskGP(train_X, train_Y)
>>> ref_point = [0.0, 0.0]
>>> qEHVI = qExpectedHypervolumeImprovement(model, ref_point, partitioning)
>>> qehvi = qEHVI(test_X)
Args:
model: A fitted model.
ref_point: A list or tensor with `m` elements representing the reference
point (in the outcome space) w.r.t. to which compute the hypervolume.
This is a reference point for the objective values (i.e. after
applying`objective` to the samples).
partitioning: A `NondominatedPartitioning` module that provides the non-
dominated front and a partitioning of the non-dominated space in hyper-
rectangles. If constraints are present, this partitioning must only
include feasible points.
sampler: The sampler used to draw base samples. Defaults to
`SobolQMCNormalSampler(num_samples=128, collapse_batch_dims=True)`.
objective: The MCMultiOutputObjective under which the samples are evaluated.
Defaults to `IdentityMultiOutputObjective()`.
constraints: A list of callables, each mapping a Tensor of dimension
`sample_shape x batch-shape x q x m` to a Tensor of dimension
`sample_shape x batch-shape x q`, where negative values imply
feasibility. The acqusition function will compute expected feasible
hypervolume.
X_pending: A `batch_shape x m x d`-dim Tensor of `m` design points that have
points that have been submitted for function evaluation but have not yet
been evaluated. Concatenated into `X` upon forward call. Copied and set
to have no gradient.
eta: The temperature parameter for the sigmoid function used for the
differentiable approximation of the constraints.
"""
if len(ref_point) != partitioning.num_outcomes:
raise ValueError(
"The length of the reference point must match the number of outcomes. "
f"Got ref_point with {len(ref_point)} elements, but expected "
f"{partitioning.num_outcomes}.")
ref_point = torch.as_tensor(
ref_point,
dtype=partitioning.pareto_Y.dtype,
device=partitioning.pareto_Y.device,
)
super().__init__(
model=model,
sampler=sampler,
objective=objective,
constraints=constraints,
X_pending=X_pending,
)
self.eta = eta
self.register_buffer("ref_point", ref_point)
cell_bounds = partitioning.get_hypercell_bounds()
self.register_buffer("cell_lower_bounds", cell_bounds[0])
self.register_buffer("cell_upper_bounds", cell_bounds[1])
self.q_out = -1
self.q_subset_indices = BufferDict()
def test_q_expected_hypervolume_improvement(self):
tkwargs = {"device": self.device}
for dtype in (torch.float, torch.double):
tkwargs["dtype"] = dtype
ref_point = [0.0, 0.0]
t_ref_point = torch.tensor(ref_point, **tkwargs)
pareto_Y = torch.tensor(
[[4.0, 5.0], [5.0, 5.0], [8.5, 3.5], [8.5, 3.0], [9.0, 1.0]],
**tkwargs)
partitioning = NondominatedPartitioning(ref_point=t_ref_point)
# the event shape is `b x q x m` = 1 x 1 x 2
samples = torch.zeros(1, 1, 2, **tkwargs)
mm = MockModel(MockPosterior(samples=samples))
# test error if there is not pareto_Y initialized in partitioning
with self.assertRaises(BotorchError):
qExpectedHypervolumeImprovement(model=mm,
ref_point=ref_point,
partitioning=partitioning)
partitioning.update(Y=pareto_Y)
# test error if ref point has wrong shape
with self.assertRaises(ValueError):
qExpectedHypervolumeImprovement(model=mm,
ref_point=ref_point[:1],
partitioning=partitioning)
X = torch.zeros(1, 1, **tkwargs)
# basic test
sampler = IIDNormalSampler(num_samples=1)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 0.0)
# check ref point
self.assertTrue(
torch.equal(acqf.ref_point, torch.tensor(ref_point,
**tkwargs)))
# check cached indices
self.assertTrue(hasattr(acqf, "q_subset_indices"))
self.assertIn("q_choose_1", acqf.q_subset_indices)
self.assertTrue(
torch.equal(
acqf.q_subset_indices["q_choose_1"],
torch.tensor([[0]], device=self.device),
))
# test q=2
X2 = torch.zeros(2, 1, **tkwargs)
samples2 = torch.zeros(1, 2, 2, **tkwargs)
mm2 = MockModel(MockPosterior(samples=samples2))
acqf.model = mm2
res = acqf(X2)
self.assertEqual(res.item(), 0.0)
# check cached indices
self.assertTrue(hasattr(acqf, "q_subset_indices"))
self.assertIn("q_choose_1", acqf.q_subset_indices)
self.assertTrue(
torch.equal(
acqf.q_subset_indices["q_choose_1"],
torch.tensor([[0], [1]], device=self.device),
))
self.assertIn("q_choose_2", acqf.q_subset_indices)
self.assertTrue(
torch.equal(
acqf.q_subset_indices["q_choose_2"],
torch.tensor([[0, 1]], device=self.device),
))
self.assertNotIn("q_choose_3", acqf.q_subset_indices)
# now back to 1 and sure all caches were cleared
acqf.model = mm
res = acqf(X)
self.assertNotIn("q_choose_2", acqf.q_subset_indices)
self.assertIn("q_choose_1", acqf.q_subset_indices)
self.assertTrue(
torch.equal(
acqf.q_subset_indices["q_choose_1"],
torch.tensor([[0]], device=self.device),
))
X = torch.zeros(1, 1, **tkwargs)
samples = torch.zeros(1, 1, 2, **tkwargs)
mm = MockModel(MockPosterior(samples=samples))
# basic test, no resample
sampler = IIDNormalSampler(num_samples=2, seed=12345)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 0.0)
self.assertEqual(acqf.sampler.base_samples.shape,
torch.Size([2, 1, 1, 2]))
bs = acqf.sampler.base_samples.clone()
res = acqf(X)
self.assertTrue(torch.equal(acqf.sampler.base_samples, bs))
# basic test, qmc, no resample
sampler = SobolQMCNormalSampler(num_samples=2)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 0.0)
self.assertEqual(acqf.sampler.base_samples.shape,
torch.Size([2, 1, 1, 2]))
bs = acqf.sampler.base_samples.clone()
acqf(X)
self.assertTrue(torch.equal(acqf.sampler.base_samples, bs))
# basic test, qmc, resample
sampler = SobolQMCNormalSampler(num_samples=2, resample=True)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 0.0)
self.assertEqual(acqf.sampler.base_samples.shape,
torch.Size([2, 1, 1, 2]))
bs = acqf.sampler.base_samples.clone()
acqf(X)
self.assertFalse(torch.equal(acqf.sampler.base_samples, bs))
# basic test for X_pending and warning
acqf.set_X_pending()
self.assertIsNone(acqf.X_pending)
acqf.set_X_pending(None)
self.assertIsNone(acqf.X_pending)
acqf.set_X_pending(X)
self.assertEqual(acqf.X_pending, X)
res = acqf(X)
X2 = torch.zeros(1, 1, 1, requires_grad=True, **tkwargs)
with warnings.catch_warnings(
record=True) as ws, settings.debug(True):
acqf.set_X_pending(X2)
self.assertEqual(acqf.X_pending, X2)
self.assertEqual(len(ws), 1)
self.assertTrue(issubclass(ws[-1].category, BotorchWarning))
# test objective
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
objective=IdentityMCMultiOutputObjective(),
)
res = acqf(X)
self.assertEqual(res.item(), 0.0)
# Test that the hypervolume improvement is correct for given sample
# test q = 1
X = torch.zeros(1, 1, **tkwargs)
# basic test
samples = torch.tensor([[[6.5, 4.5]]], **tkwargs)
mm = MockModel(MockPosterior(samples=samples))
sampler = IIDNormalSampler(num_samples=1)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 1.5)
# test q = 1, does not contribute
samples = torch.tensor([0.0, 1.0], **tkwargs).view(1, 1, 2)
sampler = IIDNormalSampler(1)
mm = MockModel(MockPosterior(samples=samples))
acqf.model = mm
res = acqf(X)
self.assertEqual(res.item(), 0.0)
# test q = 2, both points contribute
X = torch.zeros(2, 1, **tkwargs)
samples = torch.tensor([[6.5, 4.5], [7.0, 4.0]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf.model = mm
res = acqf(X)
self.assertEqual(res.item(), 1.75)
# test q = 2, only 1 point contributes
samples = torch.tensor([[6.5, 4.5], [6.0, 4.0]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf.model = mm
res = acqf(X)
self.assertEqual(res.item(), 1.5)
# test q = 2, neither contributes
samples = torch.tensor([[2.0, 2.0], [0.0, 0.1]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf.model = mm
res = acqf(X)
self.assertEqual(res.item(), 0.0)
# test q = 2, test point better than current best second objective
samples = torch.tensor([[6.5, 4.5], [6.0, 6.0]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf.model = mm
res = acqf(X)
self.assertEqual(res.item(), 8.0)
# test q = 2, test point better than current-best first objective
samples = torch.tensor([[6.5, 4.5], [9.0, 2.0]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 2.0)
# test q = 3, all contribute
X = torch.zeros(3, 1, **tkwargs)
samples = torch.tensor([[6.5, 4.5], [9.0, 2.0], [7.0, 4.0]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 2.25)
# test q = 3, not all contribute
samples = torch.tensor([[6.5, 4.5], [9.0, 2.0], [7.0, 5.0]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 3.5)
# test q = 3, none contribute
samples = torch.tensor([[0.0, 4.5], [1.0, 2.0], [3.0, 0.0]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 0.0)
# test m = 3, q=1
pareto_Y = torch.tensor(
[[4.0, 2.0, 3.0], [3.0, 5.0, 1.0], [2.0, 4.0, 2.0],
[1.0, 3.0, 4.0]],
**tkwargs,
)
ref_point = [-1.0] * 3
t_ref_point = torch.tensor(ref_point, **tkwargs)
partitioning = NondominatedPartitioning(ref_point=t_ref_point,
Y=pareto_Y)
samples = torch.tensor([[1.0, 2.0, 6.0]], **tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
X = torch.zeros(1, 2, **tkwargs)
res = acqf(X)
self.assertEqual(res.item(), 12.0)
# change reference point
ref_point = [0.0] * 3
t_ref_point = torch.tensor(ref_point, **tkwargs)
partitioning = NondominatedPartitioning(ref_point=t_ref_point,
Y=pareto_Y)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 4.0)
# test m = 3, no contribution
ref_point = [1.0] * 3
t_ref_point = torch.tensor(ref_point, **tkwargs)
partitioning = NondominatedPartitioning(ref_point=t_ref_point,
Y=pareto_Y)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
res = acqf(X)
self.assertEqual(res.item(), 0.0)
# test m = 3, q = 2
pareto_Y = torch.tensor(
[[4.0, 2.0, 3.0], [3.0, 5.0, 1.0], [2.0, 4.0, 2.0]], **tkwargs)
samples = torch.tensor([[1.0, 2.0, 6.0], [1.0, 3.0, 4.0]],
**tkwargs).unsqueeze(0)
mm = MockModel(MockPosterior(samples=samples))
ref_point = [-1.0] * 3
t_ref_point = torch.tensor(ref_point, **tkwargs)
partitioning = NondominatedPartitioning(ref_point=t_ref_point,
Y=pareto_Y)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
X = torch.zeros(2, 2, **tkwargs)
res = acqf(X)
self.assertEqual(res.item(), 22.0)
# test batched model
pareto_Y = torch.tensor(
[[4.0, 2.0, 3.0], [3.0, 5.0, 1.0], [2.0, 4.0, 2.0]], **tkwargs)
samples = torch.tensor([[1.0, 2.0, 6.0], [1.0, 3.0, 4.0]],
**tkwargs).unsqueeze(0)
samples = torch.stack([samples, samples + 1], dim=1)
mm = MockModel(MockPosterior(samples=samples))
ref_point = [-1.0] * 3
t_ref_point = torch.tensor(ref_point, **tkwargs)
partitioning = NondominatedPartitioning(ref_point=t_ref_point,
Y=pareto_Y)
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
X = torch.zeros(2, 2, **tkwargs)
res = acqf(X)
self.assertTrue(
torch.equal(
res,
# batch_shape x model_batch_shape
torch.tensor([[22.0, 60.0]], **tkwargs),
))
# test batched model with batched partitioning with multiple batch dims
pareto_Y = torch.tensor(
[[4.0, 5.0], [5.0, 5.0], [8.5, 3.5], [8.5, 3.0], [9.0, 1.0]],
**tkwargs)
pareto_Y = torch.stack(
[
pareto_Y,
pareto_Y + 0.5,
],
dim=0,
)
samples = torch.tensor([[6.5, 4.5], [7.0, 4.0]],
**tkwargs).unsqueeze(0)
samples = torch.stack([samples, samples + 1], dim=1)
mm = MockModel(MockPosterior(samples=samples))
ref_point = [-1.0] * 2
t_ref_point = torch.tensor(ref_point, **tkwargs)
partitioning = FastNondominatedPartitioning(ref_point=t_ref_point,
Y=pareto_Y)
cell_bounds = partitioning.get_hypercell_bounds().unsqueeze(1)
with mock.patch.object(partitioning,
"get_hypercell_bounds",
return_value=cell_bounds):
acqf = qExpectedHypervolumeImprovement(
model=mm,
ref_point=ref_point,
partitioning=partitioning,
sampler=sampler,
)
# test multiple batch dims
self.assertEqual(acqf.cell_lower_bounds.shape,
torch.Size([1, 2, 4, 2]))
self.assertEqual(acqf.cell_upper_bounds.shape,
torch.Size([1, 2, 4, 2]))
X = torch.zeros(2, 2, **tkwargs)
res = acqf(X)
self.assertTrue(
torch.equal(
res,
# batch_shape x model_batch_shape
torch.tensor([[1.75, 3.5]],
dtype=samples.dtype,
device=samples.device),
))