From 3fb54734b9207f4e9f9bd0efa2eddf89320de2ff Mon Sep 17 00:00:00 2001 From: Sam Daulton Date: Mon, 18 Sep 2023 13:09:46 -0700 Subject: [PATCH 1/2] Fix fantasization with FixedNoiseGP and outcome transforms and use FantasizeMixin (#2011) Summary: Pull Request resolved: https://github.com/pytorch/botorch/pull/2011 This fixes fantasization with FixedNoiseGP when using outcome transforms----previously, already-transformed noise was transformed again during fantasization. This also improves the fantasization for batched and batched multi-output models to use the average noise for each batch and output. This also removes repeated code and uses the logic in `FantasizeMixin.fantasize` for handling `X` with size 0 on the -2 dimension. This also deprecates the use of `observation_noise` as a boolean argument to fantasize. Differential Revision: https://internalfb.com/D49200325 fbshipit-source-id: 686663284452f02114695d1bb2da973a16c3267e --- botorch/acquisition/active_learning.py | 3 +- botorch/acquisition/knowledge_gradient.py | 9 +- .../acquisition/max_value_entropy_search.py | 3 +- .../max_value_entropy_search.py | 3 +- botorch/acquisition/multi_step_lookahead.py | 3 +- botorch/models/gp_regression.py | 50 ++++---- botorch/models/gpytorch.py | 32 ++++-- botorch/models/model.py | 57 +++++++-- botorch/utils/testing.py | 1 + test/models/test_gp_regression.py | 64 ++++++++++- test/models/test_gp_regression_fidelity.py | 2 - test/models/test_gp_regression_mixed.py | 2 - test/models/test_gpytorch.py | 20 ++-- test/models/test_model_list_gp_regression.py | 108 ++++++++++++------ test/models/test_pairwise_gp.py | 2 - 15 files changed, 259 insertions(+), 100 deletions(-) diff --git a/botorch/acquisition/active_learning.py b/botorch/acquisition/active_learning.py index 10e7183f8d..3830f692a8 100644 --- a/botorch/acquisition/active_learning.py +++ b/botorch/acquisition/active_learning.py @@ -93,7 +93,8 @@ def forward(self, X: Tensor) -> Tensor: # Construct the fantasy model (we actually do not use the full model, # this is just a convenient way of computing fast posterior covariances fantasy_model = self.model.fantasize( - X=X, sampler=self.sampler, observation_noise=True + X=X, + sampler=self.sampler, ) bdims = tuple(1 for _ in X.shape[:-2]) diff --git a/botorch/acquisition/knowledge_gradient.py b/botorch/acquisition/knowledge_gradient.py index 9155440693..eec1f1b925 100644 --- a/botorch/acquisition/knowledge_gradient.py +++ b/botorch/acquisition/knowledge_gradient.py @@ -184,7 +184,8 @@ def forward(self, X: Tensor) -> Tensor: # construct the fantasy model of shape `num_fantasies x b` fantasy_model = self.model.fantasize( - X=X_actual, sampler=self.sampler, observation_noise=True + X=X_actual, + sampler=self.sampler, ) # get the value function @@ -233,7 +234,8 @@ def evaluate(self, X: Tensor, bounds: Tensor, **kwargs: Any) -> Tensor: # construct the fantasy model of shape `num_fantasies x b` fantasy_model = self.model.fantasize( - X=X, sampler=self.sampler, observation_noise=True + X=X, + sampler=self.sampler, ) # get the value function @@ -451,7 +453,8 @@ def forward(self, X: Tensor) -> Tensor: # construct the fantasy model of shape `num_fantasies x b` # expand X (to potentially add trace observations) fantasy_model = self.model.fantasize( - X=self.expand(X_eval), sampler=self.sampler, observation_noise=True + X=self.expand(X_eval), + sampler=self.sampler, ) # get the value function value_function = _get_value_function( diff --git a/botorch/acquisition/max_value_entropy_search.py b/botorch/acquisition/max_value_entropy_search.py index 56805c26fe..eb03e02801 100644 --- a/botorch/acquisition/max_value_entropy_search.py +++ b/botorch/acquisition/max_value_entropy_search.py @@ -389,7 +389,8 @@ def set_X_pending(self, X_pending: Optional[Tensor] = None) -> None: if X_pending is not None: # fantasize the model and use this as the new model self.model = init_model.fantasize( - X=X_pending, sampler=self.fantasies_sampler, observation_noise=True + X=X_pending, + sampler=self.fantasies_sampler, ) else: self.model = init_model diff --git a/botorch/acquisition/multi_objective/max_value_entropy_search.py b/botorch/acquisition/multi_objective/max_value_entropy_search.py index 9c4da13744..56dbb1092e 100644 --- a/botorch/acquisition/multi_objective/max_value_entropy_search.py +++ b/botorch/acquisition/multi_objective/max_value_entropy_search.py @@ -146,7 +146,8 @@ def set_X_pending(self, X_pending: Optional[Tensor] = None) -> None: if X_pending is not None: # fantasize the model fantasy_model = self._init_model.fantasize( - X=X_pending, sampler=self.fantasies_sampler, observation_noise=True + X=X_pending, + sampler=self.fantasies_sampler, ) self.mo_model = fantasy_model # convert model to batched single outcome model. diff --git a/botorch/acquisition/multi_step_lookahead.py b/botorch/acquisition/multi_step_lookahead.py index 8744962665..1145965bc8 100644 --- a/botorch/acquisition/multi_step_lookahead.py +++ b/botorch/acquisition/multi_step_lookahead.py @@ -399,7 +399,7 @@ def _step( # construct fantasy model (with batch shape f_{j+1} x ... x f_1 x batch_shape) prop_grads = step_index > 0 # need to propagate gradients for steps > 0 fantasy_model = model.fantasize( - X=X, sampler=samplers[0], observation_noise=True, propagate_grads=prop_grads + X=X, sampler=samplers[0], propagate_grads=prop_grads ) # augment sample weights appropriately @@ -585,7 +585,6 @@ def _get_induced_fantasy_model( fantasy_model = model.fantasize( X=Xs[0], sampler=samplers[0], - observation_noise=True, ) return _get_induced_fantasy_model( diff --git a/botorch/models/gp_regression.py b/botorch/models/gp_regression.py index 9ca5e7853f..f69b50f08e 100644 --- a/botorch/models/gp_regression.py +++ b/botorch/models/gp_regression.py @@ -30,15 +30,14 @@ from __future__ import annotations -from typing import Any, List, NoReturn, Optional, Union +from typing import Any, List, NoReturn, Optional import torch -from botorch import settings from botorch.models.gpytorch import BatchedMultiOutputGPyTorchModel from botorch.models.model import FantasizeMixin from botorch.models.transforms.input import InputTransform from botorch.models.transforms.outcome import Log, OutcomeTransform -from botorch.models.utils import fantasize as fantasize_flag, validate_input_scaling +from botorch.models.utils import validate_input_scaling from botorch.models.utils.gpytorch_modules import ( get_gaussian_likelihood_with_gamma_prior, get_matern_kernel_with_gamma_prior, @@ -164,7 +163,7 @@ def forward(self, x: Tensor) -> MultivariateNormal: return MultivariateNormal(mean_x, covar_x) -class FixedNoiseGP(BatchedMultiOutputGPyTorchModel, ExactGP): +class FixedNoiseGP(BatchedMultiOutputGPyTorchModel, ExactGP, FantasizeMixin): r"""A single-task exact GP model using fixed noise levels. A single-task exact GP that uses fixed observation noise levels, differing from @@ -270,7 +269,7 @@ def fantasize( self, X: Tensor, sampler: MCSampler, - observation_noise: Union[bool, Tensor] = True, + observation_noise: Optional[Tensor] = None, **kwargs: Any, ) -> FixedNoiseGP: r"""Construct a fantasy model. @@ -290,29 +289,32 @@ def fantasize( `batch_shape` is the batch shape (must be compatible with the batch shape of the model). sampler: The sampler used for sampling from the posterior at `X`. - observation_noise: If True, include the mean across the observation - noise in the training data as observation noise in the posterior - from which the samples are drawn. If a Tensor, use it directly - as the specified measurement noise. + observation_noise: The noise level for fantasization if + provided. If `None`, the mean across the observation + noise in the training data is used as observation noise in + the posterior from which the samples are drawn and + the fantasized noise level. If observation noise is + provided, it is assumed to be in the outcome-transformed + space, if an outcome transform is used. Returns: The constructed fantasy model. """ - propagate_grads = kwargs.pop("propagate_grads", False) - with fantasize_flag(): - with settings.propagate_grads(propagate_grads): - post_X = self.posterior( - X, observation_noise=observation_noise, **kwargs - ) - Y_fantasized = sampler(post_X) # num_fantasies x batch_shape x n' x m - # Use the mean of the previous noise values (TODO: be smarter here). - # noise should be batch_shape x q x m when X is batch_shape x q x d, and - # Y_fantasized is num_fantasies x batch_shape x q x m. - noise_shape = Y_fantasized.shape[1:] - noise = self.likelihood.noise.mean().expand(noise_shape) - return self.condition_on_observations( - X=self.transform_inputs(X), Y=Y_fantasized, noise=noise - ) + # self.likelihood.noise is an `batch_shape x n x s(m)`-dimensional tensor + if observation_noise is None: + if self.num_outputs > 1: + # make noise ... x n x m + observation_noise = self.likelihood.noise.transpose(-1, -2) + else: + observation_noise = self.likelihood.noise.unsqueeze(-1) + observation_noise = observation_noise.mean(dim=-2, keepdim=True) + + return super().fantasize( + X=X, + sampler=sampler, + observation_noise=observation_noise, + **kwargs, + ) def forward(self, x: Tensor) -> MultivariateNormal: # TODO: reduce redundancy with the 'forward' method of diff --git a/botorch/models/gpytorch.py b/botorch/models/gpytorch.py index 955ee6c2c9..9cab0f20d8 100644 --- a/botorch/models/gpytorch.py +++ b/botorch/models/gpytorch.py @@ -159,7 +159,9 @@ def posterior( jointly. observation_noise: If True, add the observation noise from the likelihood to the posterior. If a Tensor, use it directly as the - observation noise (must be of shape `(batch_shape) x q`). + observation noise (must be of shape `(batch_shape) x q`). It is + assumed to be in the outcome-transformed space if an outcome + transform is used. posterior_transform: An optional PosteriorTransform. Returns: @@ -223,7 +225,8 @@ def condition_on_observations(self, X: Tensor, Y: Tensor, **kwargs: Any) -> Mode # pass the transformed data to get_fantasy_model below # (unless we've already trasnformed if BatchedMultiOutputGPyTorchModel) if not isinstance(self, BatchedMultiOutputGPyTorchModel): - Y, Yvar = self.outcome_transform(Y, Yvar) + # `noise` is assumed to already be outcome-transformed. + Y, _ = self.outcome_transform(Y, Yvar) # validate using strict=False, since we cannot tell if Y has an explicit # output dimension self._validate_tensor_args(X=X, Y=Y, Yvar=Yvar, strict=False) @@ -373,6 +376,12 @@ def posterior( ) mvn = self(X) if observation_noise is not False: + if self._num_outputs > 1: + noise_shape = X.shape[:-3] + torch.Size( + [self._num_outputs, X.shape[-2]] + ) + else: + noise_shape = X.shape[:-1] if torch.is_tensor(observation_noise): # TODO: Validate noise shape # make observation_noise `batch_shape x q x n` @@ -380,11 +389,19 @@ def posterior( obs_noise = observation_noise.transpose(-1, -2) else: obs_noise = observation_noise.squeeze(-1) - mvn = self.likelihood(mvn, X, noise=obs_noise) + mvn = self.likelihood( + mvn, + X, + noise=obs_noise.expand(noise_shape), + ) elif isinstance(self.likelihood, FixedNoiseGaussianLikelihood): # Use the mean of the previous noise values (TODO: be smarter here). - noise = self.likelihood.noise.mean().expand(X.shape[:-1]) - mvn = self.likelihood(mvn, X, noise=noise) + observation_noise = self.likelihood.noise.mean(dim=-1, keepdim=True) + mvn = self.likelihood( + mvn, + X, + noise=observation_noise.expand(noise_shape), + ) else: mvn = self.likelihood(mvn, X) if self._num_outputs > 1: @@ -443,8 +460,9 @@ def condition_on_observations( """ noise = kwargs.get("noise") if hasattr(self, "outcome_transform"): - # we need to apply transforms before shifting batch indices around - Y, noise = self.outcome_transform(Y, noise) + # We need to apply transforms before shifting batch indices around. + # `noise` is assumed to already be outcome-transformed. + Y, _ = self.outcome_transform(Y) self._validate_tensor_args(X=X, Y=Y, Yvar=noise, strict=False) inputs = X if self._num_outputs > 1: diff --git a/botorch/models/model.py b/botorch/models/model.py index dae237c8d3..92a95d4c91 100644 --- a/botorch/models/model.py +++ b/botorch/models/model.py @@ -33,7 +33,11 @@ import numpy as np import torch from botorch import settings -from botorch.exceptions.errors import BotorchTensorDimensionError, InputDataError +from botorch.exceptions.errors import ( + BotorchTensorDimensionError, + DeprecationError, + InputDataError, +) from botorch.logging import shape_to_str from botorch.models.utils.assorted import fantasize as fantasize_flag from botorch.posteriors import Posterior, PosteriorList @@ -83,7 +87,7 @@ def posterior( self, X: Tensor, output_indices: Optional[List[int]] = None, - observation_noise: bool = False, + observation_noise: Union[bool, Tensor] = False, posterior_transform: Optional[PosteriorTransform] = None, **kwargs: Any, ) -> Posterior: @@ -102,7 +106,12 @@ def posterior( Can be used to speed up computation if only a subset of the model's outputs are required for optimization. If omitted, computes the posterior over all model outputs. - observation_noise: If True, add observation noise to the posterior. + observation_noise: For models with an inferred noise level, if True, + include observation noise. For models with an observed noise level, + this must be a `model_batch_shape x 1 x m`-dim tensor or + a `model_batch_shape x n' x m`-dim tensor containing the average + noise for each batch and output. `noise` must be in the + outcome-transformed space if an outcome transform is used. posterior_transform: An optional PosteriorTransform. Returns: @@ -310,7 +319,7 @@ def fantasize( # TODO: see if any of these can be imported only if TYPE_CHECKING X: Tensor, sampler: MCSampler, - observation_noise: bool = True, + observation_noise: Optional[Tensor] = None, **kwargs: Any, ) -> TFantasizeMixin: r"""Construct a fantasy model. @@ -328,12 +337,21 @@ def fantasize( `batch_shape` is the batch shape (must be compatible with the batch shape of the model). sampler: The sampler used for sampling from the posterior at `X`. - observation_noise: If True, include observation noise. + observation_noise: A `model_batch_shape x 1 x m`-dim tensor or + a `model_batch_shape x n' x m`-dim tensor containing the average + noise for each batch and output, where `m` is the number of outputs. + `noise` must be in the outcome-transformed space if an outcome + transform is used. If None, then the noise will be the inferred + noise level. kwargs: Will be passed to `model.condition_on_observations` Returns: The constructed fantasy model. """ + if not isinstance(observation_noise, Tensor) and observation_noise is not None: + raise DeprecationError( + "`fantasize` no longer accepts a boolean for `observation_noise`." + ) # if the inputs are empty, expand the inputs if X.shape[-2] == 0: output_shape = ( @@ -350,8 +368,15 @@ def fantasize( propagate_grads = kwargs.pop("propagate_grads", False) with fantasize_flag(): with settings.propagate_grads(propagate_grads): - post_X = self.posterior(X, observation_noise=observation_noise) + post_X = self.posterior( + X, + observation_noise=True + if observation_noise is None + else observation_noise, + ) Y_fantasized = sampler(post_X) # num_fantasies x batch_shape x n' x m + if observation_noise is not None: + kwargs["noise"] = observation_noise.expand(Y_fantasized.shape[1:]) return self.condition_on_observations( X=self.transform_inputs(X), Y=Y_fantasized, **kwargs ) @@ -434,7 +459,9 @@ def posterior( respective likelihoods to the posterior. If a Tensor of shape `(batch_shape) x q x m`, use it directly as the observation noise (with `observation_noise[...,i]` added to the posterior - of the `i`-th model). + of the `i`-th model). `observation_noise` is assumed + to be in the outcome-transformed space, if an outcome transform + is used by the model. posterior_transform: An optional PosteriorTransform. Returns: @@ -553,7 +580,7 @@ def fantasize( self, X: Tensor, sampler: MCSampler, - observation_noise: bool = True, + observation_noise: Optional[Tensor] = None, evaluation_mask: Optional[Tensor] = None, **kwargs: Any, ) -> Model: @@ -573,7 +600,12 @@ def fantasize( batch shape of the model). sampler: The sampler used for sampling from the posterior at `X`. If evaluation_mask is not None, this must be a `ListSampler`. - observation_noise: If True, include observation noise. + observation_noise: A `model_batch_shape x 1 x m`-dim tensor or + a `model_batch_shape x n' x m`-dim tensor containing the average + noise for each batch and output, where `m` is the number of outputs. + `noise` must be in the outcome-transformed space if an outcome + transform is used. If None, then the noise will be the inferred + noise level. evaluation_mask: A `n' x m`-dim tensor of booleans indicating which outputs should be fantasized for a given design. This uses the same evaluation mask for all batches. @@ -595,6 +627,8 @@ def fantasize( fant_models = [] X_i = X + if observation_noise is None: + observation_noise_i = observation_noise for i in range(self.num_outputs): # get the inputs to fantasize at for output i if evaluation_mask is not None: @@ -604,12 +638,15 @@ def fantasize( # samples from a single Sobol sequence or consider requiring that the # sampling is IID to ensure good coverage. sampler_i = sampler.samplers[i] + if observation_noise is not None: + observation_noise_i = observation_noise[..., mask_i, i : i + 1] else: sampler_i = sampler + fant_model = self.models[i].fantasize( X=X_i, sampler=sampler_i, - observation_noise=observation_noise, + observation_noise=observation_noise_i, **kwargs, ) fant_models.append(fant_model) diff --git a/botorch/utils/testing.py b/botorch/utils/testing.py index 3ef838fb40..6ed7d37e0e 100644 --- a/botorch/utils/testing.py +++ b/botorch/utils/testing.py @@ -375,6 +375,7 @@ def _get_random_data( [torch.linspace(0, 0.95, n, **tkwargs) for _ in range(d)], dim=-1 ) train_x = train_x + 0.05 * torch.rand_like(train_x).repeat(rep_shape) + train_x[0] += 0.02 # modify the first batch train_y = torch.sin(train_x[..., :1] * (2 * math.pi)) train_y = train_y + 0.2 * torch.randn(n, m, **tkwargs).repeat(rep_shape) return train_x, train_y diff --git a/test/models/test_gp_regression.py b/test/models/test_gp_regression.py index 2ac4f8f835..3e400a8354 100644 --- a/test/models/test_gp_regression.py +++ b/test/models/test_gp_regression.py @@ -318,8 +318,6 @@ def test_fantasize(self): sampler = SobolQMCNormalSampler(sample_shape=torch.Size([3])) fm = model.fantasize(X=X_f, sampler=sampler) self.assertIsInstance(fm, model.__class__) - fm = model.fantasize(X=X_f, sampler=sampler, observation_noise=False) - self.assertIsInstance(fm, model.__class__) # check that input transforms are applied to X. tkwargs = {"device": self.device, "dtype": torch.float} @@ -456,6 +454,68 @@ def test_construct_inputs(self): self.assertTrue(Y.equal(data_dict["train_Y"])) self.assertTrue(Yvar.equal(data_dict["train_Yvar"])) + def test_fantasized_noise(self): + for batch_shape, m, dtype, use_octf in itertools.product( + (torch.Size(), torch.Size([2])), + (1, 2), + (torch.float, torch.double), + (False, True), + ): + tkwargs = {"device": self.device, "dtype": dtype} + octf = Standardize(m=m, batch_shape=batch_shape) if use_octf else None + model, _ = self._get_model_and_data( + batch_shape=batch_shape, m=m, outcome_transform=octf, **tkwargs + ) + # fantasize + X_f = torch.rand(torch.Size(batch_shape + torch.Size([4, 1])), **tkwargs) + sampler = SobolQMCNormalSampler(sample_shape=torch.Size([3])) + fm = model.fantasize(X=X_f, sampler=sampler) + noise = ( + model.likelihood.noise.unsqueeze(-1) + if m == 1 + else model.likelihood.noise.transpose(-1, -2) + ) + avg_noise = noise.mean(dim=-2, keepdim=True) + fm_noise = ( + fm.likelihood.noise.unsqueeze(-1) + if m == 1 + else fm.likelihood.noise.transpose(-1, -2) + ) + + self.assertTrue((fm_noise[..., -4:, :] == avg_noise).all()) + # pass tensor of noise + # noise is assumed to be outcome transformed + # batch shape x n' x m + obs_noise = torch.full( + X_f.shape[:-1] + torch.Size([m]), 0.1, dtype=dtype, device=self.device + ) + fm = model.fantasize(X=X_f, sampler=sampler, observation_noise=obs_noise) + fm_noise = ( + fm.likelihood.noise.unsqueeze(-1) + if m == 1 + else fm.likelihood.noise.transpose(-1, -2) + ) + self.assertTrue((fm_noise[..., -4:, :] == obs_noise).all()) + # test batch shape x 1 x m + obs_noise = torch.full( + X_f.shape[:-2] + torch.Size([1, m]), + 0.1, + dtype=dtype, + device=self.device, + ) + fm = model.fantasize(X=X_f, sampler=sampler, observation_noise=obs_noise) + fm_noise = ( + fm.likelihood.noise.unsqueeze(-1) + if m == 1 + else fm.likelihood.noise.transpose(-1, -2) + ) + self.assertTrue( + ( + fm_noise[..., -4:, :] + == obs_noise.expand(X_f.shape[:-1] + torch.Size([m])) + ).all() + ) + class TestHeteroskedasticSingleTaskGP(TestSingleTaskGP): def _get_model_and_data( diff --git a/test/models/test_gp_regression_fidelity.py b/test/models/test_gp_regression_fidelity.py index 778a829b5b..512d67617c 100644 --- a/test/models/test_gp_regression_fidelity.py +++ b/test/models/test_gp_regression_fidelity.py @@ -362,8 +362,6 @@ def test_fantasize(self): sampler = SobolQMCNormalSampler(sample_shape=torch.Size([3])) fm = model.fantasize(X=X_f, sampler=sampler) self.assertIsInstance(fm, model.__class__) - fm = model.fantasize(X=X_f, sampler=sampler, observation_noise=False) - self.assertIsInstance(fm, model.__class__) def test_subset_model(self): for (iteration_fidelity, data_fidelities) in self.FIDELITY_TEST_PAIRS: diff --git a/test/models/test_gp_regression_mixed.py b/test/models/test_gp_regression_mixed.py index d7dda8319d..58afb16957 100644 --- a/test/models/test_gp_regression_mixed.py +++ b/test/models/test_gp_regression_mixed.py @@ -236,8 +236,6 @@ def test_fantasize(self): sampler = SobolQMCNormalSampler(sample_shape=torch.Size([3])) fm = model.fantasize(X=X_f, sampler=sampler) self.assertIsInstance(fm, model.__class__) - fm = model.fantasize(X=X_f, sampler=sampler, observation_noise=False) - self.assertIsInstance(fm, model.__class__) def test_subset_model(self): d, m = 3, 2 diff --git a/test/models/test_gpytorch.py b/test/models/test_gpytorch.py index f527ceb0d4..020f3a63a1 100644 --- a/test/models/test_gpytorch.py +++ b/test/models/test_gpytorch.py @@ -15,7 +15,7 @@ BotorchTensorDimensionError, BotorchTensorDimensionWarning, ) -from botorch.exceptions.errors import InputDataError +from botorch.exceptions.errors import DeprecationError, InputDataError from botorch.fit import fit_gpytorch_mll from botorch.models.gpytorch import ( BatchedMultiOutputGPyTorchModel, @@ -208,11 +208,6 @@ def test_gpytorch_model(self): cm = model.fantasize(torch.rand(2, 1, **tkwargs), sampler=sampler) self.assertIsInstance(cm, SimpleGPyTorchModel) self.assertEqual(cm.train_targets.shape, torch.Size([2, 7])) - cm = model.fantasize( - torch.rand(2, 1, **tkwargs), sampler=sampler, observation_noise=True - ) - self.assertIsInstance(cm, SimpleGPyTorchModel) - self.assertEqual(cm.train_targets.shape, torch.Size([2, 7])) cm = model.fantasize( torch.rand(2, 1, **tkwargs), sampler=sampler, @@ -220,6 +215,14 @@ def test_gpytorch_model(self): ) self.assertIsInstance(cm, SimpleGPyTorchModel) self.assertEqual(cm.train_targets.shape, torch.Size([2, 7])) + # test that boolean observation noise is deprecated + msg = "`fantasize` no longer accepts a boolean for `observation_noise`." + with self.assertRaisesRegex(DeprecationError, msg): + model.fantasize( + torch.rand(2, 1, **tkwargs), + sampler=sampler, + observation_noise=True, + ) def test_validate_tensor_args(self) -> None: n, d = 3, 2 @@ -386,11 +389,6 @@ def test_batched_multi_output_gpytorch_model(self): cm = model.fantasize(torch.rand(2, 1, **tkwargs), sampler=sampler) self.assertIsInstance(cm, SimpleBatchedMultiOutputGPyTorchModel) self.assertEqual(cm.train_targets.shape, torch.Size([2, 2, 7])) - cm = model.fantasize( - torch.rand(2, 1, **tkwargs), sampler=sampler, observation_noise=True - ) - self.assertIsInstance(cm, SimpleBatchedMultiOutputGPyTorchModel) - self.assertEqual(cm.train_targets.shape, torch.Size([2, 2, 7])) cm = model.fantasize( torch.rand(2, 1, **tkwargs), sampler=sampler, diff --git a/test/models/test_model_list_gp_regression.py b/test/models/test_model_list_gp_regression.py index 232a36a8bc..fb9c80c535 100644 --- a/test/models/test_model_list_gp_regression.py +++ b/test/models/test_model_list_gp_regression.py @@ -379,38 +379,82 @@ def test_transform_revert_train_inputs(self): self.assertTrue(torch.equal(m._original_train_inputs, org_inputs[i])) def test_fantasize(self): - m1 = SingleTaskGP(torch.rand(5, 2), torch.rand(5, 1)).eval() - m2 = SingleTaskGP(torch.rand(5, 2), torch.rand(5, 1)).eval() - modellist = ModelListGP(m1, m2) - fm = modellist.fantasize( - torch.rand(3, 2), sampler=IIDNormalSampler(sample_shape=torch.Size([2])) - ) - self.assertIsInstance(fm, ModelListGP) - for i in range(2): - fm_i = fm.models[i] - self.assertIsInstance(fm_i, SingleTaskGP) - self.assertEqual(fm_i.train_inputs[0].shape, torch.Size([2, 8, 2])) - self.assertEqual(fm_i.train_targets.shape, torch.Size([2, 8])) - - # test decoupled - sampler1 = IIDNormalSampler(sample_shape=torch.Size([2])) - sampler2 = IIDNormalSampler(sample_shape=torch.Size([2])) - eval_mask = torch.tensor( - [[1, 0], [0, 1], [1, 0]], - dtype=torch.bool, - ) - fm = modellist.fantasize( - torch.rand(3, 2), - sampler=ListSampler(sampler1, sampler2), - evaluation_mask=eval_mask, - ) - self.assertIsInstance(fm, ModelListGP) - for i in range(2): - fm_i = fm.models[i] - self.assertIsInstance(fm_i, SingleTaskGP) - num_points = 7 - i - self.assertEqual(fm_i.train_inputs[0].shape, torch.Size([2, num_points, 2])) - self.assertEqual(fm_i.train_targets.shape, torch.Size([2, num_points])) + for model_cls in (SingleTaskGP, FixedNoiseGP): + x1 = torch.rand(5, 2) + y1 = torch.rand(5, 1) + x2 = torch.rand(5, 2) + y2 = torch.rand(5, 1) + m1_kwargs = {} + m2_kwargs = {} + if model_cls is FixedNoiseGP: + m1_kwargs = {"train_Yvar": torch.full_like(y1, 0.1)} + m2_kwargs = {"train_Yvar": torch.full_like(y2, 0.2)} + m1 = model_cls(x1, y1, **m1_kwargs).eval() + m2 = model_cls(x2, y2, **m2_kwargs).eval() + modellist = ModelListGP(m1, m2) + fm = modellist.fantasize( + torch.rand(3, 2), sampler=IIDNormalSampler(sample_shape=torch.Size([2])) + ) + self.assertIsInstance(fm, ModelListGP) + for i in range(2): + fm_i = fm.models[i] + self.assertIsInstance(fm_i, model_cls) + self.assertEqual(fm_i.train_inputs[0].shape, torch.Size([2, 8, 2])) + self.assertEqual(fm_i.train_targets.shape, torch.Size([2, 8])) + + # test decoupled + sampler1 = IIDNormalSampler(sample_shape=torch.Size([2])) + sampler2 = IIDNormalSampler(sample_shape=torch.Size([2])) + eval_mask = torch.tensor( + [[1, 0], [0, 1], [1, 0]], + dtype=torch.bool, + ) + num_designs_per_output = eval_mask.sum(dim=0) + fm = modellist.fantasize( + torch.rand(3, 2), + sampler=ListSampler(sampler1, sampler2), + evaluation_mask=eval_mask, + ) + self.assertIsInstance(fm, ModelListGP) + for i in range(2): + fm_i = fm.models[i] + self.assertIsInstance(fm_i, model_cls) + num_points = 7 - i + self.assertEqual( + fm_i.train_inputs[0].shape, torch.Size([2, num_points, 2]) + ) + self.assertEqual(fm_i.train_targets.shape, torch.Size([2, num_points])) + # test decoupled with observation_noise + if model_cls is FixedNoiseGP: + # already transformed + observation_noise = torch.full( + (3, 2), 0.3, dtype=x1.dtype, device=x1.device + ) + observation_noise[:, 1] = 0.4 + fm = modellist.fantasize( + torch.rand(3, 2), + sampler=ListSampler(sampler1, sampler2), + evaluation_mask=eval_mask, + observation_noise=observation_noise, + ) + self.assertIsInstance(fm, ModelListGP) + for i in range(2): + fm_i = fm.models[i] + self.assertIsInstance(fm_i, model_cls) + num_points = 7 - i + self.assertEqual( + fm_i.train_inputs[0].shape, torch.Size([2, num_points, 2]) + ) + self.assertEqual( + fm_i.train_targets.shape, torch.Size([2, num_points]) + ) + # check observation_noise + self.assertTrue( + torch.equal( + fm_i.likelihood.noise[..., -num_designs_per_output[i] :], + observation_noise[-num_designs_per_output[i] :, i], + ) + ) def test_fantasize_with_outcome_transform(self) -> None: """ diff --git a/test/models/test_pairwise_gp.py b/test/models/test_pairwise_gp.py index a4b8c7167a..d0e0b3dac6 100644 --- a/test/models/test_pairwise_gp.py +++ b/test/models/test_pairwise_gp.py @@ -382,8 +382,6 @@ def test_fantasize(self) -> None: sampler = PairwiseSobolQMCNormalSampler(sample_shape=torch.Size([3])) fm = model.fantasize(X=X_f, sampler=sampler) self.assertIsInstance(fm, model.__class__) - fm = model.fantasize(X=X_f, sampler=sampler, observation_noise=False) - self.assertIsInstance(fm, model.__class__) def test_load_state_dict(self) -> None: model, _ = self._get_model_and_data(batch_shape=[]) From 15b7861ae4f2ed5ed6e13ad415c01f2836cdbe82 Mon Sep 17 00:00:00 2001 From: Sam Daulton Date: Mon, 18 Sep 2023 13:10:00 -0700 Subject: [PATCH 2/2] fix plotting with > 1-d tensors in tutorials with py3.9 (#2013) Summary: Pull Request resolved: https://github.com/pytorch/botorch/pull/2013 see title. This is causing a failure in the tutorials on https://github.com/pytorch/botorch/pull/2011 Reviewed By: Balandat Differential Revision: D49382057 fbshipit-source-id: 04ba98192b26117c762b4188fae454dca3f8899f --- ...N_for_efficient_batch_entropy_search.ipynb | 926 +++++----- tutorials/constraint_active_search.ipynb | 1456 ++++++++------- tutorials/saasbo.ipynb | 1558 ++++++++--------- 3 files changed, 1967 insertions(+), 1973 deletions(-) diff --git a/tutorials/GIBBON_for_efficient_batch_entropy_search.ipynb b/tutorials/GIBBON_for_efficient_batch_entropy_search.ipynb index 8a4f529a0f..8835b0491c 100644 --- a/tutorials/GIBBON_for_efficient_batch_entropy_search.ipynb +++ b/tutorials/GIBBON_for_efficient_batch_entropy_search.ipynb @@ -1,476 +1,476 @@ { - "metadata": { - "kernelspec": { - "display_name": "python3", - "language": "python", - "name": "python3", - "metadata": { - "kernel_name": "bento_kernel_ae", - "nightly_builds": false, - "fbpkg_supported": true, - "cinder_runtime": false, - "is_prebuilt": true, - "download_status": "downloaded" - } - }, - "last_server_session_id": "e8e47d75-78e3-4016-9af5-0d7a3b435ef3", - "last_kernel_id": "f6b0044f-755d-4e30-bf26-d8ccc7ba6803", - "last_base_url": "https://0022.od.fbinfra.net/", - "last_msg_id": "3657368c-a0e27618ad2cbb9edcdc74b0_53", - "outputWidgetContext": {} - }, - "nbformat": 4, - "nbformat_minor": 2, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "originalKey": "ee765c8b-00fd-46de-baa3-4c1dca928015" - }, - "source": [ - "## The GIBBON (General-purpose Information-Based Bayesian OptimisatioN) acquisition function\n", - "\n", - "A particularly intuitive and empirically effective class of acquisition functions has arisen based on information theory. Information-theoretic Bayesian Optimisation (BO) seeks to reduce uncertainty in the location of high-performing areas of the search space, as measured in terms of differential entropy. BoTorch already supports information-theoretic BO through an implementation of the Max-value Entropy Search (MES) acquisition function [1] (see the [Max-Value Entropy tutorial](./max_value_entropy) for details), which makes evaluations that reduce uncertainty in the maximum value attained by the objective function. However, in order to support batch and multi-fidelity BO, our implementation of MES employs numerical integrations and fantasy observations (i. e., we generate one point each time and when we try to generate the 𝑖-th point of a batch, we condition the models on the 𝑖−1 points generated prior to this). Unfortunately, Each of these calculations can can add significantly to the computational overhead incurred by BO.\n", - "\n", - "In this notebook, we provide an information-theoretic acquisition function for tasks where objective function query costs are not large enough to overshadow significant optimisation overheads known as General-purpose Information-Based Bayesian OptimisatioN (GIBBON) [2]. In this tutorial, we present a very high-level overview of GIBBON and demonstrate its use within BoTorch.\n", - "\n", - "### Calculating GIBBON\n", - "\n", - "Following a principled information-theoretic construction, the GIBBON acquisition function measures the utility of evaluating a candidate batch of $B$ points $\\{\\textbf{x}\\}_{i=1}^B$ as\n", - "\\begin{align}\n", - " \\alpha_{\\text{GIBBON}}(\\{\\textbf{x}\\}_{i=1}^B)\n", - " &= \\frac{1}{2}\\log |C| + \\sum_{i=1}^B \\hat{\\alpha}_{\\text{MES}}(\\textbf{x}_i)\n", - "\\end{align}\n", - "where $|C|$ is the determinant of the $B\\times B$ correlation matrix between the batch elements and $\\hat{\\alpha}_{\\text{MES}}$ is an analytical approximation of the standard (non-batch) MES acquisition function. The GIBBON acquisition function forms a lower bound on the exact (but intractable) batch MES function and is consequently referred to as the `qLowerBoundMaxValueEntropy` in BoTorch. Crucially, GIBBON can be computed in closed-form and so incurs substantially lower overheads than batch MES via fantasies.\n", - "\n", - "### Interpretating GIBBON\n", - "Note that the above decomposition of GIBBON has two terms and each has a helpful intuitive justification. In particular, the first term encourages diversity within the batch (achieving high values for points with low predictive correlation), whereas the second term ensures that evaluations are targeted in areas of the search space that provide large amounts of information about the maximum value attained by the objective function.\n", - "\n", - "\n", - "
\n", - "__References__\n", - "\n", - "\n", - "[1] [Wang, Z., Jegelka, S., _Max-value Entropy Search for Efficient Bayesian Optimization._ arXiv:1703.01968v3, 2018](https://arxiv.org/abs/1703.01968)\n", - "\n", - "[2] [Moss, M., et al., _GIBBON: General-purpose Information-Based Bayesian Optimisation._ arXiv:2102.03324, 2020](https://arxiv.org/abs/2102.03324)\n", - "" - ] - }, - { - "cell_type": "code", - "metadata": { - "originalKey": "4c523820-69ed-467b-9a22-3f8f9a42c056", - "collapsed": false, - "requestMsgId": "07db8b0d-d844-4283-8e5c-895f7d2271cb", - "executionStartTime": 1648577014199, - "executionStopTime": 1648577014323 - }, - "source": [ - "import os\n", - "\n", - "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")" - ], - "execution_count": 1, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "c597f1b7-7841-4058-9773-dfff42267a26" - }, - "source": [ - "### 1. Setting up a toy model\n", - "We will fit a standard SingleTaskGP model on noisy observations of the synthetic 2D SixHumpCamel function." - ] - }, - { - "cell_type": "code", - "metadata": { - "originalKey": "8900645e-ef50-4d4d-b4ae-9b0f4152aff0", - "collapsed": false, - "requestMsgId": "8d7262fb-6bfe-454f-b465-478d269c184f", - "executionStartTime": 1648577014352, - "executionStopTime": 1648577015895 - }, - "source": [ - "import math\n", - "import torch\n", - "\n", - "from botorch.test_functions import SixHumpCamel\n", - "from botorch.fit import fit_gpytorch_mll\n", - "from botorch.models import SingleTaskGP\n", - "from botorch.utils.transforms import standardize, normalize\n", - "from gpytorch.mlls import ExactMarginalLogLikelihood\n", - "\n", - "torch.manual_seed(123456)\n", - "\n", - "bounds = torch.tensor(SixHumpCamel._bounds).T\n", - "bounds_norm = torch.tensor([[0.0, 0.0], [1.0, 1.0]])\n", - "train_X = bounds[0] + (bounds[1] - bounds[0]) * torch.rand(5, 2)\n", - "train_Y = SixHumpCamel(negate=True)(train_X).unsqueeze(-1)\n", - "\n", - "train_X = normalize(train_X, bounds=bounds)\n", - "train_Y = standardize(train_Y + 0.05 * torch.randn_like(train_Y))\n", - "\n", - "model = SingleTaskGP(train_X, train_Y)\n", - "mll = ExactMarginalLogLikelihood(model.likelihood, model)\n", - "fit_gpytorch_mll(mll, max_attempts=10);" - ], - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "1b900ec1-ec7a-4330-bf79-d16b72e53304" - }, - "source": [ - "### 2. Defining the GIBBON acquisition function\n", - "\n", - "GIBBON is implemented in BoTorch as `qLowerBoundMaxValueEntropy` and supports pending points through its `X_pending` argument. Required arguments for the constructor are `model` and `candidate_set` (the discretized candidate points in the design space that will be used to draw max value samples). There are also other optional parameters, such as number of max value samples. Just like in our implementation of MES, two different sampling algorithms are supported for the max value samples: discretized Thompson sampling and Gumbel sampling (the default choice). \n", - " " - ] - }, - { - "cell_type": "code", - "metadata": { - "originalKey": "a01d0c4a-583a-4791-9259-02609b02d6d6", - "collapsed": false, - "requestMsgId": "ad226a16-8b53-418e-bfb2-d3460b270acd", - "executionStartTime": 1648577015914, - "executionStopTime": 1648577016144 - }, - "source": [ - "from botorch.acquisition.max_value_entropy_search import qLowerBoundMaxValueEntropy\n", - "\n", - "candidate_set_size = 1000 if not SMOKE_TEST else 5\n", - "candidate_set = torch.rand(\n", - " candidate_set_size, bounds_norm.size(1), device=bounds.device, dtype=bounds.dtype\n", - ")\n", - "qGIBBON = qLowerBoundMaxValueEntropy(model, candidate_set)" - ], - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "d7ad6371-414c-4daa-b00a-253c7dbf0dd0" - }, - "source": [ - "### 3. Optimizing the GIBBON acquisition function to get the next candidate points\n", - "\n", - "In order to obtain the next candidate point(s) to query, we need to optimize the acquisition function over the design space. For $q=1$ case, we can simply call the `optimize_acqf` function in the library. For $q>1$, we greedily build batches using sequential optimization. \n", - "" - ] - }, - { - "cell_type": "code", - "metadata": { - "originalKey": "6b2f24f7-93cb-419b-a36a-626e48077b6c", - "collapsed": false, - "requestMsgId": "dd3c847a-3bca-439f-bc9a-2acb698068a7", - "executionStartTime": 1648577016206, - "executionStopTime": 1648577016782 - }, - "source": [ - "from botorch.optim import optimize_acqf\n", - "\n", - "NUM_RESTARTS = 10 if not SMOKE_TEST else 2\n", - "RAW_SAMPLES = 512 if not SMOKE_TEST else 4\n", - "\n", - "# for q = 1\n", - "candidates, acq_value = optimize_acqf(\n", - " acq_function=qGIBBON,\n", - " bounds=bounds,\n", - " q=1,\n", - " num_restarts=NUM_RESTARTS,\n", - " raw_samples=RAW_SAMPLES,\n", - ")\n", - "candidates, acq_value" - ], - "execution_count": 4, - "outputs": [ + "cells": [ { - "output_type": "execute_result", - "data": { - "text/plain": "(tensor([[ 0.1199, -0.0158]]), tensor(0.0085))" - }, - "metadata": { - "bento_obj_id": "140516803885120" - }, - "execution_count": 4 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "originalKey": "7ffdf144-60eb-4980-b387-5c03762a1f91", - "collapsed": false, - "requestMsgId": "270506a8-d7dc-42d6-a6f5-b54f77746900", - "executionStartTime": 1648577016794, - "executionStopTime": 1648577017848 - }, - "source": [ - "from botorch.optim import optimize_acqf\n", - "\n", - "# for q = 2, sequential optimsiation\n", - "candidates, acq_value = optimize_acqf(\n", - " acq_function=qGIBBON,\n", - " bounds=bounds,\n", - " q=2,\n", - " num_restarts=NUM_RESTARTS,\n", - " raw_samples=RAW_SAMPLES,\n", - " sequential=True,\n", - ")\n", - "candidates, acq_value" - ], - "execution_count": 5, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "originalKey": "ee765c8b-00fd-46de-baa3-4c1dca928015" + }, + "source": [ + "## The GIBBON (General-purpose Information-Based Bayesian OptimisatioN) acquisition function\n", + "\n", + "A particularly intuitive and empirically effective class of acquisition functions has arisen based on information theory. Information-theoretic Bayesian Optimisation (BO) seeks to reduce uncertainty in the location of high-performing areas of the search space, as measured in terms of differential entropy. BoTorch already supports information-theoretic BO through an implementation of the Max-value Entropy Search (MES) acquisition function [1] (see the [Max-Value Entropy tutorial](./max_value_entropy) for details), which makes evaluations that reduce uncertainty in the maximum value attained by the objective function. However, in order to support batch and multi-fidelity BO, our implementation of MES employs numerical integrations and fantasy observations (i. e., we generate one point each time and when we try to generate the 𝑖-th point of a batch, we condition the models on the 𝑖−1 points generated prior to this). Unfortunately, Each of these calculations can can add significantly to the computational overhead incurred by BO.\n", + "\n", + "In this notebook, we provide an information-theoretic acquisition function for tasks where objective function query costs are not large enough to overshadow significant optimisation overheads known as General-purpose Information-Based Bayesian OptimisatioN (GIBBON) [2]. In this tutorial, we present a very high-level overview of GIBBON and demonstrate its use within BoTorch.\n", + "\n", + "### Calculating GIBBON\n", + "\n", + "Following a principled information-theoretic construction, the GIBBON acquisition function measures the utility of evaluating a candidate batch of $B$ points $\\{\\textbf{x}\\}_{i=1}^B$ as\n", + "\\begin{align}\n", + " \\alpha_{\\text{GIBBON}}(\\{\\textbf{x}\\}_{i=1}^B)\n", + " &= \\frac{1}{2}\\log |C| + \\sum_{i=1}^B \\hat{\\alpha}_{\\text{MES}}(\\textbf{x}_i)\n", + "\\end{align}\n", + "where $|C|$ is the determinant of the $B\\times B$ correlation matrix between the batch elements and $\\hat{\\alpha}_{\\text{MES}}$ is an analytical approximation of the standard (non-batch) MES acquisition function. The GIBBON acquisition function forms a lower bound on the exact (but intractable) batch MES function and is consequently referred to as the `qLowerBoundMaxValueEntropy` in BoTorch. Crucially, GIBBON can be computed in closed-form and so incurs substantially lower overheads than batch MES via fantasies.\n", + "\n", + "### Interpretating GIBBON\n", + "Note that the above decomposition of GIBBON has two terms and each has a helpful intuitive justification. In particular, the first term encourages diversity within the batch (achieving high values for points with low predictive correlation), whereas the second term ensures that evaluations are targeted in areas of the search space that provide large amounts of information about the maximum value attained by the objective function.\n", + "\n", + "\n", + "
\n", + "__References__\n", + "\n", + "\n", + "[1] [Wang, Z., Jegelka, S., _Max-value Entropy Search for Efficient Bayesian Optimization._ arXiv:1703.01968v3, 2018](https://arxiv.org/abs/1703.01968)\n", + "\n", + "[2] [Moss, M., et al., _GIBBON: General-purpose Information-Based Bayesian Optimisation._ arXiv:2102.03324, 2020](https://arxiv.org/abs/2102.03324)\n" + ] + }, { - "output_type": "execute_result", - "data": { - "text/plain": "(tensor([[ 0.1194, -0.0160],\n [ 1.4241, 0.4417]]),\n tensor([0.0085, 0.0104]))" - }, - "metadata": { - "bento_obj_id": "140516803794560" - }, - "execution_count": 5 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "5e590a09-d151-4578-8558-79a9d9aa20d6" - }, - "source": [ - "### 4. Comparing GIBBON with other acquisition functions\n", - "\n", - "We now perform an illustrative comparison between GIBBON and the other low-cost acquisition functions implemented in BoTorch. We plot points chosen by each of the acquisition functions, each acquisition function's surface.\n", - "" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "669f1fbe-f713-4158-a10a-9fa70ce3f14f" - }, - "source": [ - "#### Sequential BO (q=1)\n", - "\n", - "Firstly, we investigate GIBBON in the purely sequential case, comparing agaisnt MES, Expected Improvement (EI) and Probability of Improvement (PI). We see that GIBBON provides a very high-quality approximation of MES, choosing essentially the same location.\n", - "" - ] - }, - { - "cell_type": "code", - "metadata": { - "originalKey": "5a4c0f2d-7bd3-4173-9e61-207b02591da7", - "code_folding": [], - "hidden_ranges": [], - "collapsed": false, - "requestMsgId": "e7a1e4c6-cec0-4168-b47a-e0634a7959e8", - "executionStartTime": 1648577017895, - "executionStopTime": 1648577020377 - }, - "source": [ - "from botorch.acquisition import (\n", - " ExpectedImprovement,\n", - " ProbabilityOfImprovement,\n", - " qMaxValueEntropy,\n", - ")\n", - "import matplotlib.pyplot as plt\n", - "\n", - "%matplotlib inline\n", - "\n", - "# prep different acqusition functions\n", - "acqs = {}\n", - "candidate_set = torch.rand(\n", - " 10000, bounds.size(1), device=bounds.device, dtype=bounds.dtype\n", - ")\n", - "acqs[\"GIBBON\"] = qLowerBoundMaxValueEntropy(model, candidate_set)\n", - "acqs[\"MES\"] = qMaxValueEntropy(model, candidate_set)\n", - "acqs[\"EI\"] = ExpectedImprovement(model, best_f=train_Y.max())\n", - "acqs[\"PI\"] = ProbabilityOfImprovement(model, best_f=train_Y.max())\n", - "\n", - "# prep grid to evaluate acq functions\n", - "n = 100 if not SMOKE_TEST else 2\n", - "xv, yv = torch.meshgrid([torch.linspace(0, 1, n), torch.linspace(0, 1, n)])\n", - "test_x = torch.stack([xv.reshape(n * n, 1), yv.reshape(n * n, 1)], -1)\n", - "\n", - "# eval and maximise acq functions\n", - "evals = {}\n", - "candidates = {}\n", - "for acq in acqs.keys():\n", - " evals[acq] = acqs[acq](test_x).detach().reshape(n, n)\n", - " candidates[acq], _ = optimize_acqf(\n", - " acq_function=acqs[acq], bounds=bounds_norm, q=1, num_restarts=5, raw_samples=100\n", - " )\n", - "\n", - "# plot acqusition function values and chosen points\n", - "fig, (ax1, ax2, ax3, ax4) = plt.subplots(\n", - " nrows=1, ncols=4, sharex=True, sharey=True, figsize=(10, 5)\n", - ")\n", - "ax1.contourf(xv, yv, evals[\"GIBBON\"], levels=20)\n", - "ax1.scatter(candidates[\"GIBBON\"][:, 0], candidates[\"GIBBON\"][:, 1], marker=\"X\", c=\"r\")\n", - "ax1.set_title(\"GIBBON\")\n", - "ax2.contourf(xv, yv, evals[\"MES\"], levels=20)\n", - "ax2.scatter(candidates[\"MES\"][:, 0], candidates[\"MES\"][:, 1], marker=\"X\", c=\"r\")\n", - "ax2.set_title(\"MES\")\n", - "ax3.contourf(xv, yv, evals[\"EI\"], levels=20)\n", - "ax3.scatter(candidates[\"EI\"][:, 0], candidates[\"EI\"][:, 1], marker=\"X\", c=\"r\")\n", - "ax3.set_title(\"EI\")\n", - "ax4.contourf(xv, yv, evals[\"PI\"], levels=20)\n", - "ax4.scatter(candidates[\"PI\"][:, 0], candidates[\"PI\"][:, 1], marker=\"X\", c=\"r\")\n", - "ax4.set_title(\"PI\")\n", - "fig.text(0.5, -0.1, \"x_1\", ha=\"center\")\n", - "fig.text(-0.1, 0.5, \"x_2\", va=\"center\")" - ], - "execution_count": 6, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "executionStartTime": 1648577014199, + "executionStopTime": 1648577014323, + "originalKey": "4c523820-69ed-467b-9a22-3f8f9a42c056", + "requestMsgId": "07db8b0d-d844-4283-8e5c-895f7d2271cb" + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")" + ] + }, { - "output_type": "execute_result", - "data": { - "text/plain": "Text(-0.1, 0.5, 'x_2')" - }, - "metadata": { - "bento_obj_id": "140516721571968" - }, - "execution_count": 6 + "cell_type": "markdown", + "metadata": { + "originalKey": "c597f1b7-7841-4058-9773-dfff42267a26" + }, + "source": [ + "### 1. Setting up a toy model\n", + "We will fit a standard SingleTaskGP model on noisy observations of the synthetic 2D SixHumpCamel function." + ] }, { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAukAAAGNCAYAAACsSe/aAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3de5QdV30n+q9a6m5L6ofessGWscEGJgwBhyTGmfC4oQxUAjM1YBLGDAMiBM8Fsqw4GC6ExyU3GOI4HkKukyFYJCHEARIqIbgI1I1tYp42HlhkELYxNuLh+KG3Wpa6W+q+f2iXVF1dj72r9q7au+r7Weus7j6nTp06p0ut7/md3957xeLiIoiIiIiIyB4jXR8AEREREREtxZBORERERGQZhnQiIiIiIsswpBMRERERWYYhnYiIiIjIMgzpRERERESWYUgnIiIiIrIMQzoRERERkWVWdX0ARDp4fjAKIADwSwAuBrAVwHoAiwAOAvgBgDsB/COAOI7ChZJ9/QDAuQB+Ekfh2SW3F3kMwH4A9wH4FwB/GUfhfRKPp2V/Oft/EoDLADwXwJMBbACwBsAMgN0A7gJwM4DPxFF4vGJffw7gv4kffwDgaXEUHpE4hucBuFX8eF4chT+QPX7XeX7wHgDvTl31sjgKP61w/4vE7yjxF3EUviZ1+2sAfLTBIQZxFP59wWM/BcArAfyiOHfWARgHcBTAwwDuBXALgI/FUfhwg2OgluScj6qeGUfht7D83/XvxVH4O3qOkmwneR7NAzgA4Lvi78SNcRT+OGdfPI8KsJJOzvP84LUA7gfwCQC/AeDpIqSfADAGYAuAnwPwRgD/BODbnh9crOGhkzcA2csogMeLUPxOAHd7fvDOtvfn+cFWzw/+BsA9AN4H4IUAngBgrfjjuQ7ATwPYDuDvADzg+cGvKTz/J4j9kprfUNz+9QrbHi04h8ou89mdeH4w5vnBDQC+A+BdAJ4P4HGisDMHYALAEwG8GMC1AO73/GC74vOi7h2pcb6c6PqgyTpF59EigM0AngPgPQDu8fzgDV0frEtYSSdneX4wAuBGAElVcQ+AD4qq8K44CmdFhf1MAC8Q2z0HwE8BuM3zg5fHUfjZBofwYF6lXRzb2QBeAuC9ADYBeK/nB3fHUfipNvbn+cHPAPiMCFYAcBuA/wngiwAeiqNw0fODNQB+BsDLALwBwNkAbvL84DkA3hhH4aLEa/Amzw8+EUfhVyS2HboZ8QbJ8/zgCTKfJnh+sFpUshfFf4QTFXf5zTgKP6LhWG8E8Crx/dcA/AGAf4mj8FFxXGsBXCiO7UrxycxHPD/YH0dhqOHxqR3/KY7C/6/rgyDnFZ5Hnh88HsBLRdV9K4A/9fxgJo7Cj7d/mO5hSCeXXZsK6J8H8KtxFB5MbxBH4TyAH4l2gI96frADwHXiI/u/9vzg6SZaL8RHen/i+cG3AXxJXP16AGUhXcv+RKD/rHhzMgvg1+Mo/KucfT4G4HYAt3t+kLy5eSqA/w5gr6jaF7kTwEYA5wO40fODZ8RROFvnuQ3IXgC7xKc6vw5A5iPdVwCYBvC/xOtdFdIb8/zg36cC+j8DeGEchUuqp6LF6ZsAvun5wRfEv78RAB/0/OAz2e2JaJjiKPyJ+L/rCwC+Jf6GXSeKO6XtlcR2F3KUaFf5LfHjNwC8JBvQ88RReD2A/wFgQQSmp5k8zjgKvyz6yVHRd65zfzeIgA4Ar8sL6Dn7fQDA80SfMQD8X54fPLPkLo+l2jCeIloiqNrfia+v9fxgpcT2vy6+/oPBY8p6bur7/1kVuEUFbaf4lOYfxSc9RESnxFH4fQAfEz9uFcUKqsCQTq5KV3l/Q1TMZb0NwJY4Ci9u2O5SSbTkjIkfHzW9PxGsXyJ+/LzKR4pxFD4CYIf4cSWAt1dsfwuApLXias8PniH7WAP2SfH1cQB+pWxDzw+eDOA/ZO7XhnS1Xur/iDgKXx9H4fPiKHwjB5ASUYF/TX3/hA6PwxkM6eQczw8mAFwqfvxqHIXfVLl/HIVzcRTuNXN0y7xM9CEDwN+2sL+Xp77/oxr7/xSAfxPfv0S81mV+G8CDonVup+cHbKErIVqrvip+rBpAmlTR74yj8G7Dh5Z2T+r7K0X/ORFRU+lPD1UKa4PFkE4u+oXUeIpbK7ZtnecHKzw/OM/zg7cC+Atx9d8B+OMW9vc88fW4aD9QInoEbxM/jgP4+YrtD4oedgB4JoC3qD7mACWfPrzI84Nz8jYQA55fLX68sb1DAwB8TkzNCTGd6bc9P3iD5wdbWz4OIuqXn019/90Oj8MZrHqRi7alvt/V4XE8zvODAznXrxHTJgLAlwF8JI7CP29pf8lHiLtl5i8v8K9i1g6IGTz+uWzjOAo/4/nBJ8Ugx3d5fvDpOArvKbvPwP0NgOsBTAF4nZiaLOulYurQxwDcpLDvP/P84M8Utt8RR+H/SF8RR+Exzw9eJsL6ZjE4+E/FrAy7AHxFzPjylTgK+R+t22LPD1S2L5xTn6iM5wc/DeBXxY//Gkfh/+74kJzASjq5aGPq+/0l25m2Qsy8kb2MprZ5BoBf8/zgxS3tL3lt9jV4Xun7rpe8z5vF7CVniNle+LelgJhV56/Fj68rGECatLp8Ko7CQwq7V50nPXdGnjgK7wLw78WnNTOpm/6dOLaPANjl+cFPPD/4sJjyk9yjOk86WxRImucH454fPNnzg6vFQnzj4m/OFV0fmytYSScXrUh9X3oOe37wcQC/XLG/p8dR+MMax1G0IumoqED+rPhj9CIAL/T84Lo4Cn/b8P6S16bJv+10aJSaSi+Owkc8P7hSjN7/BbFw1IcaHEPffVj8Ls8WCwKdGsAsWmCSMReqrS665kmHGAD6ZtFm9UsA/g8AzxZtTcng5ceJWX5e7/lBCGB7HIV5nwaRnThPOukg+4nMvwF4NdfVkMdqF7koPeizarq3tQXV6fRF67+DOArn4yh8MI7Cf4ij8MVigSUAuMrzg1cY3l/y2mxEfRty9idznH8FIBI/vs/zg8ZTTvaVGOx8l/gxO4B0uzgn742j8PYODm+JOAofi6PwH+Mo3BFH4cWiTecXALxDtL0kAgD/IhZgIqLhKPpEZi+A+8TCev8ngAv5plANK+nkonQf7EVijuZccRT+p7zrPT94j1gBrQ1vF9XGNWJ1xqbT6ZXt77sAzgKwzfODTXEU7qmx/6envlft+b9CLCU/KarFL6zx+EPxYbEKrO/5wePjKPyJaBN6rbi97QGjUsSiVV8Rl/d5fvBsAJ8AcI5okXld3UHSROQkfiJjCCvp5KI7xDt3AHix7f3Pogf5O+LHsgWCdOzvttT3Mn3wS4jWmueIHw+JlUVVju1HAN4qfrzU84PXVtxlyG4S/d4rRfUcAF4gFqk6nprJx2pxFH41NRMNRGsMERE1ZHW4IcojKnmfEj+eL+YOt92KzFdT+/trsZoqAOyo8QbmFWI1OAC4SXGRqMSfikFCEMs/n1mx/SDFUXhYzPSC1Gw6SVj/bFeLAnl+sNrzg5/z/GDZ+IgS6baXSQOHRUQ0OAzp5Kr3pWam+FCNILjGwDHl8vxgHMBTxY8PmNyfWHo5mTnkmWJ1Vdn9bgbwB+LHxwC8v87xxVG4KGYAOSZmh7mhzn4G4sPi61PFFGXJKqRaBn+q8vzAB3AYwNcV28HSqwfWGYRNREQZDOnkpDgKvwfgavHjVgC3i2XUS3l+sMbzg/cCuEpctShaC0y6WvOqo1X7+y0APxLf/z+eH1zt+UFpBV8M8rwFQPJmZ4dYHbMW8ftJQl6QWQmVhDgK7wTwLfHjB8Tv9ScA/qmjQ7oNQFLB3+75wX+uuoNokbomdVXTMRdERMSBo+SyOAr/yPODaQDvBfAksTLiTtEKc0cchTMinK4XA0w90U6QzAjzKIDXxFH4Y93HJoLL0wG8ITXn9fcB/L7p/cVR+KjnBy8UQW+bCH+v8Pzgj8TCRA/GUbjo+cEa8br8ZzHgc7V40/L2OAo/vPwolF0n2md+Rozsp3x/BuD/TQ2y/fM4CqWmvtQtjsLHPD94jZgScgzA33p+8DcA/hLAnXEU7oVYBVcMFH2+GLz8DLGLj8dR2NUbDCKiXmFIJ6fFUfi7nh98XUxL+BQRNq/AySBxTJzj2fP8gOibvj6OwkcaPHzRCqEjoiKa/qTqywB+TfQhG99fHIXfFQvMXAfgVSIoJwMRT3h+MCdCedrdAN6sa5R+HIUnPD/YDuAbmQWZaKmPA7hWtGAtls1WJOGPPD/4A4nt0n4YR+GpGX3iKIw9P/glMbvMhaJf/pU4+W9qFsCcONb0fPrHRKtUWzMmkR5/7/mB6ieJX4qj8FcktiOihhjSyXlxFH7B84N/JxaAeSmAnxMDSidFoHhQfIT/dfFx/ufjKJyR2HWVZIXQrEUxa8ePxewonwDwOdGr3dr+xPSL/01MN/lKAM8TveybRJX0gOhpvwPAPwD4J4ljVBJH4bc9P/gAgN/Rud8+iaPwoOcHnwTwGgC3xlF4f4Pdrc5581VlKueYvuT5wVMB+GIxsIsAnCe2XSPGLDwspuj8ZwCfjKPwoQbHTd1YK7FN1oSB4yCiHCsWF7X+n0xERERERA1x4CgRERERkWXY7kKNeH5wHoCPAngugPPKZgQRy4VfC+Ay8bH5dwBcHUfhLe0eNREREZHdWEmn2jw/CMQiJrsl73KDWFHx+aIv+iYAN3t+cIHhQyUiIiJyCivp1MQGsYT8OZllwZfx/GCDmGXk5XEU7hJXX+f5weViNparyu5PRERENCQM6VRbHIU34mQAP0di84vE+XZn5vo7AFxs5giJiIiI3MSQTm3ZIr7uzVy/J7XKZa4XPus9S6YgGtl7KHe7hUezu6a2jGzemHv9wsZls/thbsPSGQJn1538M/SVT15VuipqUy9c++rFkQ3rle+3uH7SyPHQSSv2ly0doOZzP/qg0XPop6+8ftl0aGOH8mdIGz+4sPy6/fPLrlu1/1ju/Uf25/+dSyzs2Vd6u21GNm0ovG1h/fK/E8fXn7Hsutn1S5dbmJ1e2rE7N7X01z+X8093Pue641NL1w77wRW/bfQ8euYbl55HY4eLZ9kbP1i8rtnoweXnEwCM7j9aeB+Zf28Le7s/t0Y2Fp8vKPi7PL8+f/bZ+enly3TMTq9cdt3cZPGvPe9cWvIYmYlJ7/2dHVrOIfakU9dWiHnAiWiA+CaIiLJseKMgKxvQdWJIp7YkC51szly/JXUbERH1kGuV/6FyKRzLyKuiq6qqopvEkE5tuUus/vnszPWXiCXuyWFFrUZFrUlEfZFtsWgDAy+VKWr7IPewJ52M8fzgGgDb4ii8XCx9fiOAazw/2CWmbbwKwLliakYiIqJWZfvRbTM7vbK0L53U5fWj24ohnWrz/OAeEbKTT2Tu8fxgEcDH4ih8PYCzxO2JHQA+AOBWAJMAvgXg0jgKZedZJ2oV+6Xbsbh+UusAUiKiNpjsRwdDOjURR+GTK25/TebnWQBXigsRERFG9h/KneFFt7yZXcheC3v3Vc7y0nfsSSeiVo3tK54ejIhoaMqm/qN2FP0Ouhw0CoZ0IiIiIvfomLmE7MaQTkRa1F1MavzAce3HQu5xof+/66oaEdnDdD86GNKJiIioDZw6kkgNQzoRGcW50omKHV9/RteH0At15qu3ffpFIoZ0IiKiBvIC4uz08v9eZ9ezh1iXvNc3rU+tSTrn9XahrcykvNeyzqDRNlpdwJBOREREtmv6Bsf26Rc5wwvlYUgnIiIruFDl61OFlpZbMTnf9SFoMb9+ddeH0Lk+zH7DkE5EneMML0RE6voQRG1kQ6sLGNKJSKe60zAS0VJlK3CObBr2KoxEQ8GQTkSt46qjRNSlvJldbG510Tl4lE6zfSwAQzoREVnDhb70PLIzvBAVsT0w2kymB1/HGx2ZVpfjk4uNHyfBvyBENAgjG9Z3fQjUE00Gj+bNUsK50vUa2uDeor70ouBa9kZ4ZCNbqWw6fxjSqTdGNm/s+hCoABc0IqIiZf33MqoWMrJ9+kXqD51VdDCkExER0dDZ0o9e1vLCvnR5MrPeqLYXtTmrS4IhnZyzsLFZ1YWGaWHf/q4PgSS52peuW9MKc1817fXPGzRK7qjz90H2DY5NrS5gSCciItKjzcGjnIaR0lT70kk/3a0uYEgnIt1snSudA0dJJw4ebU/e6zVUulpeOHhUTRetLmBIJyIiIps0ecOSffMkM2jUln70BKdiVFPn04K817jJG28TVXQwpBMRkY3Yl35Sn/rSbWjRsaEf3VTfs8xgySHQ/Tp0VUUHQzoRUbEV+w93fQhksbywxUWN2lU1/aKrdM7yUme+dBvoarsxPSuOqSo6GNKJaCg4uwvZREdfug2VaeqnPvelq7S6dFlFB0M6EbUlu6DR2L6jnR0LEblJ96cSXfWjs+WlHtuq/yar6GBIp77hqqNE1DXdLS996ktvk+srjbLlpVr2eWXfpJhsdTEd0MGQTi6Y27D8jwsXNCLqPxcCRNdTMbre8qLzDUjV78KGQaNpti2ck9XHlheXWl3AkE5ERES2Gvoc6XWq6aoLG7nwZtg2bVTRwZBORCbYuqARURMq7RO6Zx0ZSsuLyicJTV9jG+ZHZzXdrsdN2FBFB0M6EQ0FVxx1kwtVPtmgldeXPpSWFxeOsU9Uq+kuyP4tUO1H17WAUVtVdDCkExERyXN9MKLLVAbfZn9Psv3oE5PHVA/LOJ0DSIuUvRnuuqrdNluq6GBIJ1fkDR4lIrJFGwsbDaXlpQ7ViqgNrS6JtqdjdLmarpPtVXQwpJPLimZ44TSMpBNXHXWDC20xRYbS8pJl25sOG6voiSFV0/Meq+rfd51Wl9z9WFRFB0M6ERHZzrYA3mXLi23B1qSymV10D8ztGqvparo4/rar6GBIJyIi19kS4pu0vAy1mp6m+nyL1O1Ht90QqultVezz/q2WVdFVAvqJyeM1j2o5hnQiIiJFHEAqT8ebh7Jefh396Da0usg8j67nTbdxEKmuVhcddAZ0MKSTSzh41H0jew91fQjkKFuq5VV0V9PzlLW8uF5NHzrb503vQtXUi6pMVdF1B3QwpJPrOHjUXlzQiNrgSnivS1cLiG3a6q3vS6tLWl+r6Tr222UV3QSGdCIickI2OHQd0JuuQGpqOsY+VNPrDhqt+p3Y2uqSZssgUhvaXlRndaniUhUdDOlE1KWxfUe7PgRyTNfBXEaTkKUygNSFoC57HHU/MRhqe0gbg0ir6Azqsvtqc1aXrgM6GNKJiMg1i+snrQnrXVbTh8Lka2RbFT3hwiBSaArqRftQ/Tde1eqiWkWXYTKggyGdXMPBo9QFLmhEqlhN7162H92mVUZluND2goZBXeW+2eNTbXVRIVNFNx3QAWCV8Ueg3vL8YDWAawFcBmAKwHcAXB1H4S0F2z8FwO8DuATAKIC7Abw3jsKbmxzHwsap3FlDRjZv5OBFIjJufhIYlXwfNze1AmOHlgaA2ekRjB9cWHrd+lGM718aKo+vPwOr9qtVfkc2bcDCnn1K99Gl6E1C1aBRU/3ofTQ3uQJjh/MD5ez0SowfzB84Oz89itGDy9+0zK9fjdH9y9sQF9dPlhYrkrC9sFf+XCsL6F1W0W0J6GAlnRq6AcALADwfwCYANwG42fODC7Iben6wAsDnARwG8ESx/ccB/L0I70REVlOdKaStfmnXVyHtqh+9q1YXlRYLU20vdcgEZ9nKuGr1vc0quk0Y0qkWzw82AHgVgLfGUbgrjsIjcRReB+C7AK7IucsWANsA/HUchQfjKJwHcKP4NOenO3gKRETKioK6id50l9tedD1m3X5021tdbAjqqm0vUAjqyUXm+jqPkdbXKjoY0qmBi0TAvjNz/R0ALs5uHEfhwwC+CGC75webPD8YB/AGAHsB3KbywOxLJyJX2DL7iC396aaq/i62uugO6mXaDuoJ2WBetu+2qui2BXQwpFMDW8TXbNP3HgBnFtznFQCeAOBRAEcBvA3Ay0WAN4KLGhGRbqrVdN2rkNappqPFoN7kcer2o6sqanXZNDGj7TF0qwrqdRfuMR3UTWpzRpe2AzoY0smAFQCWvR31/GBM9KTfC2ArgAkA7wbwj54fPK1sh7Prqsc3F608SqQLZ3ihrrgY1GWZ6Eev2+rSRUBvOgVgVt3+9LpBXWdYb6OKXrfNpYuADoZ0auAh8XVz5votqdvSXgDgGQB2xFH4SByFj8VR+CcAHgCwvYXjJSLSps1qum4mg3rZvlVbXYYyh7wN/emoGdShoapeFParHrdOFT2PrQEdDOnUwF0A5gA8O3P9JQC+XHK/7F+PVXmV9yrsS3cDp8CkIbJ5EGnCRFA3Gf51Tr2Y1+rSdZuLC0HdRFW96D55j2Wqil6my4AOzpNOdcVReNDzgxsBXOP5wS4AuwFcBeBcMTUjPD+4BsC2OAovB/AVUWF/v+cHVwI4ImaHebIYQFpqdt0qjB/o9h8LEVHa8akTWHVIfoq7uUlgrEHXlMrc6QvrpzCyf/n6EWk651CvCuh5bxyybzLK+tHrsm1WlzLzE8Co5HsFmXNJ9xzqKJlHPZEO3UUtgnXCfDagq1bR67S5dB3QwUo6NbQDwGcB3CoGg74IwKVxFO4Wt58lQjviKDwA4IUANoq+9EcB/HcAl8VReLuOgynqS+fgUSIyxYa2l6YV9aYVcBMV9LLnr9KPntXV3Oiy2q6oq876AomqeiKprmcvZfL2XVVBN9Hm0iSgj07M1b5vFivpVFschbMArhSXvNtfk/n52wB+pbUDJNJsxf7D1sxqQPZrayVSNKyoIxW0VSvrMgFdpopel46pF7tudclqs6KOkqp6Eo7rVtVVyQR/1FigKe+Nj8x0i6p0hvMEK+nkLPalE5ENTK5EKtufXkZlwKZsZV1HBT7NxNSLLrW6ZLVZUUfNPnUoVNWrFO3DVJtLmTpVdBMBHaykk0vYl05EtirqTy+qpudVQPOq6UVU+tOhUFFP6Arguhcv0t3qYlsVPc2Wijokq+oJ2ep6VbhvGtCL6GxzMRXOEwzp1CsLG6cwsnf5f0QjmzdyphFLjOw9xHntaVBMtL2gZlAHoBTWmygK6FUDRmX78V1cZVSValAHysN6EmzLBpQCqB3WodC2Unj/nMq9aosLarS52BbQwXYXIiIiOSsm50tbKHS1vZgaSJrQXd02+Ri6Wl1cq6KnqbZsmG5/gQjSTadELNqvzLHUaXPRFdBHJ+ZaCehgSCfXsS+diGyiY7aXIir96V0G9bJ9Vx2XqVldXGcqqNed/eXUcWkK60X7qRPQVakG9DYxpJNTZtexQ4uIulV3QGLTaRlRI6iXheKF9VPaw7pqQK87N/oQWl2y5if0DyiFZFVdNqyrhPaq7esGdJUqumxAb7N6nsaQTr3D+dKJyLS6bS9NVyNFjRlfZKrqOsK69kGikq0u2de7SavLtokDSsfYBdWgrqOqDsmwnsiG9ryL6uN0GdC7wpBORKSgaBU9ojST/ekwENSRCusqYVv2PjJV9LqtLq7RMUd3nfYX3WG9zmBOmf3KHFMbAb2r6nkaewfIOdmpGOc2rMbYPn0LKhARyVgxOY/FwyXBWMO0jNAwNeOp4xFBuWj2lzSdVfE6CxeVVdHLPo1wpYp+fHIRqw7XGxSbSEKp7OwvkJyqERKzwCTSobpoRhjZ+5cdx9Lrlm9nIqDbgCGdrDe7bgTjB5ZPP0ZE1LUug3pSec5blRRAaViXCeo6FAV0XVV0lweMJiFSR1hXDeqomKrx9LZyYR01p0msetzl1y+/rq8BHWx3ob5iXzoRtaWNgaRQbH2BRPtLnQq3CtmAnlW3ii7Dhip6lq72F1MtMEi1nFS1wjRV9himA7oN7S1ZDOnkhNl1PFWJyF66B5K2EdRhKKyX7TPveFTmgF/yODUGjOaxYbDo8clFJ8I6MoFdR2iv2lfR8ekO6DZiuws5iX3pRGSbstaXorYXaOxRL1uZFCXtL8hUveu2wugI+9k3IToHjLqweJGOXnU06FdPyLTCnL6fmep60e++6E1I3wI6GNKpzxY2TmFkbzvLXxMRVekyqKNiUOmS48wJ23nBXTWUN62iNx0wmseGKnqWrl511AzraBDYm6p6U6YzoNsczhMM6TQ4I5s3YuHRvV0fBrVscf0kp0+kRiYmj2HmcHkwrTuQFC0GdVRU1XOPu0GVvKjlJhvQVaroqgNGXaiiZ9kQ1pHze9Ad2mU+LRlS9TyNIZ2cwVleqCkGdWrKdFAvUieoI2fml1O31wzrqmQDepWhVNHzmAjrqBnYIRGq0+dp03alsv76LgP69GQ77bUM6eQs9qVTHQzq1JTJoF5UTUfNedTLqurIhGidgb1swGpeQGcVvVo6lNoS2POYDOaomA3HVHtLW6E8iyGdiAaHQZ2asjGoA6hVVT+1XSZYq4b2qplkIBnQs4ZcRS+is7qOnGCsM7SrPG6ZuuEcNQN6V8E8jSGdeq1o8Cj70omoKdNBHVDrUYdEVR0SYf3U9hKhW4Vsiwur6PJ0V9cTReG5TnhXnRIyrWpayr6G8wRDOjmFfenuK1poqm2sppMOtg0mRUVQR42wrkNRQK9qc1FZvGgoVfQipgJ7WpPALUtmvnjd4dymYJ7GkE5OY186NcGgTjp0GdRRMNtGWftLIh2cTQX2suq5aptL1eJFWXWq6Oet2aN8Hxtlg66p0N6U6gJOQwnnCYZ0Iho0BnXSoaugDomqOirCOjQHdpm2lryArjLg0EQvel8Cep6uQ3uT1VSrgjkUw7ntwTyNIZ2sNzcFjKXaylVbXtiXTlVUgvrieo1LIFKv2BrUIdECk6Y6PaIqmYBeVUWvolpF73NAz1MVmlVCfJMAnkcmlCf6Gs4TDOlERKyoO+/E1OquDwGwIKijZLGZdDiWDew6FbW3qE7ZN9QZXdqkO3gXUQnkib61tJRhSCfnsS+ddGFQJx26DOqQqKpDoQ1Gh7Le87yAbqKKPtQ2F5vUCeSJIQXzNIZ0ckK25YXIlLKgzlYXktVGUEfBFI2QqKqf2i4ToHWF9qpBoagZ0OtW0Yt0EdDzwurKw/2KY20G8kRfgnlav84KGgxdfelEeVhRpzxJhRinLO0AACAASURBVHbPjNw8dEmALAvrSegsCutlQR2SVXVIhPVT20uEax1kAnodqlV0W7ga3JuE8YSLK4G2xf4zgMggDh4djhNTq7HykPwf9KRqnoR1VtEpsWliRjqoQ0NVPakm121/QY2wbkpR/3leQO9jFV2FTABuI8jrCOKJJoEcAwjlWQzp5Iyylhf2pbtpbkO7g/1UgzoYzqlA20EdDdtfEl2F9bLBoXUCeh5Xq+hN6AzQJthWJd+ytvkKtI8caWFFJ4EhnYiInNbVzC512l9MBnVIVtWRCc0mArvsjC0yAT1P36voLqsTzG0N5FX7NR3YGdLJWap96USoWU0nKqNSVW8rqEOiqp6oCtS5K5o2/ICpqP88L6DLtLmoVNEZ0PXqOpSbCuMqj20qrDOkE5ExI5s3dn0IRK3oIqijpE8dNcJ6kaaBPKtJQM8zxDaXrrU9JWKXQVyGqbDOkE5OUelLz+IML5RgNZ1MUA3qaDjzCySq6tAY1puomrlFNqCzzaUbbU2LaHsYr7Jl7YzWoM6QTkREpImNfeqJtsO67JSKTQI6q+hmtDXg0/VQnkfnc2JIp96SneGF0zAOE6vpZJKN7S+JbHhuGtrrzm+uupJoVl5ALyNTRX/i+MMNjshdbU6N2MdgbgpDOllvbhoYO5h/GwePUhMM6u7ramYXGW0HdShU1dN0LCKkqiigF/Wgy7a5NBksOqSA3jSUJ2TDedNgfs6a5p+O/OixdY330TaGdCIiIkNU2l90BnVIVtXbVFU5Vwnouttc+hzQdQXyNFPhXEcYV923zeGdIZ2c02TwKA3X3PQoxg4uDwGsplMbZKvqugaUwpKwLtvS0jSglxnaYFEToTyhO5ybDOWykmOwMawzpJMTylpeVHCGFyKqa9vEAfxwpv5/5F20v6DlsF6nz7xpiwsG3uZiMpTDQL+5DcE8j41hnSGdek128Ci1Y2HjVKePz2o6NZWEwbphvYv2l4SusN50wGeibA70ooCuWkWv4lpANx3I04YSzrNsCusM6VSb5werAVwL4DIAUwC+A+DqOApvKbnPdgBvBXAugAcBfCiOwuubHAcHjxJR23SE9S6COnJCdl5o1xXE81QtUKQa0Pu+smibwRwG5jZXDefnrlafbW33Uf0L59kQ1kc6e2TqgxsAvADA8wFsAnATgJs9P7ggb2PPD34VwLsAvBrANIA3A7jC84OfVX3guW4LsuSwuen8MGPzLCFkryaDFWWrwjJtHysm56VW58xzfOrEsosJMseoK6DLsLWKPjoxt+TSlunJo8rV87KAfs6aA9IB/dzVe09d6kjfv+4+inT5CQAr6VSL5wcbALwKwMvjKNwlrr7O84PLAVwB4Kqcu70bwFviKPy6+PlmcSEiUmbLG6smVXWdFXXUqKqbpPqmQWeLS1UV3baA3na1PM3EqqAywVZ3mC7at44q+zlrDnRSUWdIp7ouEufPnZnr7wBwcXZjzw/OAvBUACs9P/gGgCcDuB/A78VR+EmZB5QdPFpnhhcuaDQs7E0nE+qGddk+dduDet1KvsoA0bQ+tLm4FM6hqbXFZDgve7ymYb2LoM52F6pri/ia/de2B8CZOdtvE1+vAPBKsc1OAJ/w/OC5ho+ViKg1dVswZCrGE5PHjLe/yEoeo8ljVT2XPra5dNHKkqba1gKJ1hZIBHQTrSgqdDx+260vrKSTbisALOZcn5xr/3cchd8T339QtMe8FsAXmzwoB4+SKlbTyaQmVXWb2190BX+ZNxp1ArprbS5tqlM5h6b2lrrh+Emp39d9s1tr7SPvWEwMNDWBIZ3qekh83Qzgx6nrt6RuS0v+cu7PXH8/gLPqHEDZokZLtstMw8i50omoLXXmVjcR1CGx+FHV/XWQbW3RPdXikNUN59AQ0GXD+ZMk3jzlbVM3uDcJ6m22vbDdheq6C8AcgGdnrr8EwJdztr9PBPWfz1z/JAAPyD7o3HS9g6X2jWwu/wM4t6HdQX9z03YtkU7DsW3igHJ7hs6ZXxIqbSlN21jSkhYdHQGdVXR5ddpaErLtLU0D+pPGH5YK6Cbu36T1pa22F1bSqZY4Cg96fnAjgGs8P9gFYLeY0eVcMTUjPD+4BsC2OAovj6PwhOcHfwjg3Z4ffBPAtwG8HsAzxVei1rHlhdqkWlXXXVFPmO5VR4PBoKYC+tB0WT2HRABuEszL9qdaWbe99YUhnZrYAeADAG4FMAngWwAujaNwt7j9LBHaE+8Xn978LYCNAO4G8JI4Cr9Z9iDz0wsYPcgPfai5uemVGDtobpEWoiq2BHUT6gZztNDeMpQqepNwDkcDet6+VcJ63aDeRtsLQzrVFkfhLIArxSXv9tdkfl4E8HviYlSdaRhpmFhNp7apDiq1Pag3CeeQDOisopdrI5yjYUA3Gc7zHquNoG4ay5PktPTKo7PreDpTNfamky1U+tRN9Kg3pdJnnmfTxEzjgC6j71V0BvTuHtN0bzpTDTmHg0eJyJbVRptyMag3DedQeC5Vr8/Qq+gM6OVUHrvLOdyLsN2FnMC+dDKJLS8kIx0IH3hsk7b9qvSpd9360lY416WvVfSm4RwKAb2KjoB+/tijUtvdP7dZ+rjqsK3thamHiAaHLS/U1Hlr9py66GCioq5TW60taayi52s7oNedZlEmoJ8/9qh0QK+zvexxNGGy5YUhnQah7Tm5yT1z0/pWZaRh0RXWdQd1XW0vbYdzaOhDR0+r6DYF9DKyAb0u1bDeZctNEwzpRDQIs5P1/tz1pfeZzNMR1nWE07SmQb3JfOcmK/6mqugXjtkb5mwL6E16uJsEdBP7SbOpN50hnZyUHjxaNMPL7LriIRcLG6cKb6NhYMsLmdI0rMsGddMDSU0sSCRD9xsVWQzop5kcKGoiWMswWU031fLCkE7OmJ9eMLr/qmXsyX1V1XS2vJBOTcJ610G9TkDXUT3XFdD71OrCgF6uq9DfBoZ0Ihos2Wo6W16oCdeCet2A3hYTrS62VtFtmsWlKZNhWve+bWl5YUgnIiIyrG5V3USPelEIrzuDi66A3lWbi626COimqui2VLtdG0DKkE5Eg1J3ACmRDqaCumpQTgdyHYsTkV42BvQyNgT0rt8ImOhL5/9WRDRo2ZYX9qWTabYEdVi0OFGXVXTbWl10BHRVMgHTlhaQIWFIJ6ekB48WzfBShHOlUxPsSyeddC6E1JUuFlWS4fKgUV0Bvc0+dBuq6CbY8KaEIZ2stzB1XGn79DSMRHnY8kK2UAnqpqrpLnH9jU2ZrgJ6n6roMm8KXOpL5/9U1Gtlc6XTsMxPFN/GlhfqkotBve9vBlxlooJeN6C7XEW3BRMMERFRx85bswcPPLap68OgjnTRhw4Ngx11VaUvWHUi9/rvHR/2onOspNNgcdXR4UlX0+u0vLAvnUySrajbUk0nPWxuc2lDUUCvum0IGNLJCem+9KLBo0RNyC5sRGSSzqBuSpdvAPhpQz5TA0VNz4s+9BBehSGdekNmhpcqI5s36jgU6gH2pVNXdA2OZDXdfq62ubRpyEGeIZ2IBqVpywuRLfrU9vLDmXVdH0LrbJ9u0fSMLunwPbbzMMZ2Hl72/dBx4Cj10uy6EYwfWFh2/dyG1Rjb103lgvrhxNRqrDzEc4jMkh1Ium3iQGXA3TQxgz0zJdMbKXAl9FMxHVV0nXOjj+08jDOuPwQAGL19Fiu/MXvqtrntkw2O0n0M6eSMhanjGDmkfsrOrluF8QNqc63TMM1Nr8TYwROpn0cxdnC+02Mie8gskvP92a3aHo8zvtTz/dmt1i9oZHsVvQsj+xYx8oWTK+AubFjR9eFYgZ/1kpPSg0eJVLHlhUx54vjDpy46yPSnt9X2YrqKPsSWF1u1uXjR3PZJnHjW+JLrTjxrfPBVdDCkUx80meGF0zAOR9liRkQm6AzrVfrSny4T1F3/dKHLKrqNA0bHdh5e0uICACu/Mcu+dF3tLp4fPB7ARwGMAzgB4FVxFD6oY99EKuamgLFDXR8FuSzb8pKHfemkIgnqdVthdLa96OxPp2HStYBR1sKGFTjxrPFlgV33gkb3aWxJM01XJf13AXwkjsLnAvhbAL+lab9Etc2uq3d6cxpGPRYebe/jUlnparpsywunYiRdmlTVdbW9oGZFvc0qPNteqpmsorfZ6gLR7nJsxxSO7ZjCkY9uOvV9nXaX++c2GznGrpSmGM8P3uX5wVXi+3d6fvC2gk1/E8Cnxfd7ALCHgIwoWtRIxdwGrhpJRN1o0gKjO6jLBm8b22SqPllQ+dTi3jl3Kqu2U53ZJTG3ffJUKE9/36XdR7sv2FW1u7wfwO2eH3wewC8D+MW8jeIonMHJIL8SwBsBvMfI0dIgjU/NYvbQuMSWxTjDC+nGlhdq4onjD2udCaauJIDntcB0Gc5/OLOu01VVyQ66W11cU1pJj6NwDsA7AHwJwFviKCyci0wE9I8BuC2OwluNHC1RgSaDR2lYZFpe5qaH/R8DtaNORV1nNT0tqaynL11j20u+vgwYrQrgQw/okOxJ3wpgP4CzK7b7KIAfxFH4bk3HRlTLnGKzFWd4oSrsSydTbArqrnF9lhcbtd2PXhTE6wR0mX50lwaNQqInfRrAlQAuBnC1+Dlvu8sBLMRR+HZjR0okpPvSiYhcZ2qaxj4E9SbVdBvaiaja946vXHahk6oq6e8D8IdxFD4M4EPi5zxvBPB0zw9uE5cbDBwrDdj41Gzu9VWDRznDi73G9rXbz318YvHU90UtL2kyLS8npjgIuSt9Gw+gGtRlqunoSVBvgyuDR7teYdTU9ItN6Z7Vpc6g0R89pr89q3TgaByFb0x9vxPAzoLtLtF+ZESK5qaBsYPFt6cHj85tWN16SCT7zU6OYPxw/hu/uelRjB0sHJZD1JjqYFKd86ebUjQnu0rPe9kg0gce2yT9hmWo2uxHv39uc+0ZXkxzrdUFKosZeX6wDcBf5tz0RfahE5ELjk8sYtXMiq4Pg6iQiaC+beJA64MwqxZMSm63YYAqua1vc6OnSYf0OAp/COB5Zg+HSA/VlUcXNk5hZC+XKh2S+QlgdGb596o4FSPp5npQV1nRVDas152S8fuzW6Vbie6d24oLx+xs52hD24NG26RSRbdhfvSErhVHiYxL96WrLGrEvnRSwakYyQYmBpNumzhgvEddJaDruB8GNMtL1/3oNupzFR0M6TQ0s+tOf3jElUeHKT2AVBWnYqQ2qQR1lb5sWweTVgV1zptOdbTRi25i0CgY0qlvuKgRqZCZ5YWoS0ML6iaotA65MsuLLBsXMdLFRBXdplYXMKRTn+lY1IgtL/1xfKK8LSpNteWFUzGSSSaDus6w3qRlpek+htLy4oI2WlBkH8PFGV3SGNLJKW33pVM/Fc2ZLoMtL9QFU0EdFlbVy4L6UFte2I9+mqk3AbZV0aEyuwtRlucHqwFcC+AyAFMAvgPg6jgKb5G47y8A+BcAvxtH4XvKtt00eQR7Dq+VPi7Ol051cZYXspnKrC+qc6h3MU0juee+2a1SCxrZMF96W1V0U/3oYCWdGroBwAsAPB/AJgA3AbjZ84MLyu4kwv1HAVhXGshreaH+SLe8VA0g5SwvZCPTFXVbqup12l7K3pSo9KWTvUy1udhYRQdDOtXl+cEGAK8C8NY4CnfFUXgkjsLrAHwXwBUVd38fgLsBfLPOYxe1vORR7UvPw770/mPLC/VVndU4bQnqRVjxd4PutpS+T7eYhyGd6rpItEvdmbn+DgAXF93J84P/AOC/AniDyoNtmjxSuY1KXzqnYhyuqgGkTWZ54QBSaoPqHOquBnUdA1GpH1QCeptVdJOtLmBIpwa2iK/ZJcr2ADgz7w6eH6wRbS5XxlH4byYPrslUjJzlZTjY8kKuGkpQJ7c1rX7fP7fZ2oDeBoZ00m0FgKLk8z4Au+Io/Ks2D0hHywv1wER5axRbXsg1QwjqRdX0opYX9qXbp25QV71f29Mtmq6igyGdGnhIfM3+K9qSuu0U0ebyX1TbXNLSLS+6p2Jky8uw1G154ZzpJOPCsYdzLyYMIaiTXeqEYZXArVo9r3tMtlfRwSkYqYG7AMwBeDaAT6WuvwTAZ3O2f52YpvF/e36QXDcN4Oc8P3hpHIUX6T5AlakYsxY2TmFk76El141s3oiFR7PdPeS64xOLWDWzovD22ckRjB/OD/Vz06MYOzhv8OjIFTIhPL2NzpUtVaZmRCqocwEgN/RljvR08M5Oz9j2oFAXAjoY0qmuOAoPen5wI4BrPD/YBWA3gKsAnCumZoTnB9cA2BZH4eUAfgvAOzO7+RSArwL4fdPHOzcFjB2S2JD6beI4MHPyz97xiQWsmln6yUqTedLTOGf6cNStkCf30xXWVYM6FOdS5zzqpJPOUN5FH3obrS5gSKeGdgD4AIBbAUwC+BaAS+Mo3C1uP0uEdsRRuB/A/vSdPT+YBXAojsJl7TEyxqdmMXtoHBAtLyOH5E7n2XUjGD+wvDIqs7ARq+n62NRilFdNTwf2dDV9bnolxg6e6OIwyTI6Wlh0hvWug/qmiRkjM7LsmZnApol+VJNJr7b70NvGkE61xVE4C+BKccm7/TUV93+e6mPKrD46P72A0YNywy1UW16oB1LV9Dyq1XS2vAyT7h5zXWE96VFXbX/povVl5vAZmJg8Vvv+P5xZl9sv/8Bjmwp7778/u1W5j38odh/diHNXyxWhZFceNamrPvS2qujgwFHqu/RUjLpmeeF0jP3BOdOpDlODQHXu29SAUl2DSGcOn6FlPzRMfR0omsWQTtY7e6J49KfK6qNpsgsb5c2ZTm5aPXH6XMmbjrHJnOmcjpF00jUbTBszvzTFsO6urlpNugzobVbRwZBOLlJdfbTJwkZFWE3vj7xqepMKehqr6f1jsopu4rFMBPWyarps73iTNhcariEFdDCkkyvKqukqZFpeWE3XQ+WNTPrTDJOWVNNz5FXT04Gd1fRhazOg63xMWyvqE5PHGNYd12Y1fSgtLmkM6eQk3Qsb1QmJrKY7LtXywmo62UxH+wsHS57GlUfd03VA76KKDoZ0GgrVlhdW04erqpqeJrMCKRjUSZM2g3pVNZ2rkPZTnWBrupo+1IAOhnRyiYmWF1bTh6dqAGlaXjhPt7xkseWFTLMpqBfhnObDYyqodx3Qu8aQTs7S0fJSRraazqAux/ZPI+pOxyjbm85qOunStP1FV+sLq+mUpjuo27BQUZdVdDCk05AUzZnetJpOzbT1mq9be3o1WZ3TMRJ1pY2g7mo1vYvFmfqiSSVaV7Cuu5++tLkk+D8NOcXEnOllWE0flqoBpKymk21sDuo0TE2C+n2zWxnQUxjSyWlN5kzXXU1nUJeXffPTFlbT+4NveE7rsvWFLS926ypsqobtJuEcPQ3oAMDP9sk5Z08cxI9nDKxQVGBuw2qM7Tsd7hY2TmFk76HWHt9FLr9hOT6xgFUzSwP4/AQwWvHp/dz0SowdPJH6eRRjB+eXbXdiajVWHjq67HqiJpKgfu+cetB54vjDldMSnrdmj3ILyaaJGeyZaT6XadetM1175MgEtqxt9zXYfXQjzl29t/F+2ugr72tAByvp5ILz1pZ/1Ko6gFRmOsaqajrbXtzVtJpetLiRClaByZS6VfUmFXVW06krfQ7oYEinoStqeVm2nUJ7BoO6+0z3phOZZGpl1Dq96bZWwbmgEaXZGNDBkE6uyFbT6wwglammq/Sml00pyKC+lG3TL9rQm85qOplUJ6ibqqY3Ceq2hvwhsH2+cV3HZ2tAB0M69YXMANIic5L5Ma+ablv4pGJnrj2stH0b1XQGdTLJRFB3ZaYXV46zDTaH0LpsfwOhC0M6OUtnNV12phe2vVSret7p17DteenTQb3NajrbXszja5zPVOtLHt3V9Kr7sBfePBvDcN/70NMY0skZKgNIdWLby3CpVNPTQT1bTS/DajqZphrUTVXT2briJpuC+pACOhjSaSiaVNOzVNteGNTtYqqansW2F3P4eqnTHdSLVFW3ZYM6Az2Z5EJAB0M6uaZqAGnRdIxNybS9MKjnP0/X+/brVtPzMKhTl3S2vjTp+d40MVMYwstuG7JHjjSbb75pKLWhmj6EgaJZDOk0GDqr6XUMJai7QEc1vWjgaJpK2wtRG1SCuqlqeiIJ5OmL7scgfboM6kMM6GBIJxe1WU1XHUTqetXYtC4HjZZJB/U8edX0tLJqOtteyDa6KuqcQYXaMNSADoZ0GhrVanoW216KNXluuj+1yHP26qWVt6IpGetW09n2Qi6RDeqmq+m27bvPdITUtqvpQw7oYEgnV9Vd3EhWWdsLg7o82z5ZyAb1tMK2FyFdTW86iBQM6rXlvTacfrE7ZdX0rsI0K/xmtRXUhx7QwZBOLrjwjIeU71M2HaPqKqSoWellULef1AJHqWp6k0Gkqv3pDOpkmulqOlj11qrp4FFoDKymg7rLAV3H7ynBkE69oaM3XWfbCwYU1GWeS9Fr1EarS1pZ24vuQaRNFzliUCfTdPSnt1m5Zui3x+6jG7WHdRP7dBlDOjkhr5petbhRmaJqepk6bS9V+hTUs8reoHQ9aLSs7aWKyiDSLNW2F1qKb1q6Y0M1nQHdTrpCte5w7noVHQzp1Dd1q+myg0irqr51ZnxxPai7fvwwUE1XbXthf3p9fJPTXBvV9KYBW/b+7EevZiK8NqmAm6ie9yGggyGdXKKjmp4O6ulqehmVthcMNKhXqfMpg2kmBpGyP536rEk1HZZVwps+F8qXBO6y4C2zTRMuDxTNYkgn56nMm54lO4hUZbYXDCioFx2zbKtLm/3o564uf0OnYxBpGfank83a6k3fNnFAKayrbt93uqq1bQXZbCDva7+5iSo6GNLJNXVmesmqM4g0Syao5+ljUHdJNqibHkSquz99yEF9yM/dJlUVaNl2E5ngrRrO2epCfWlzSTCkUy+YqKZDsT9dx4wvcCioy1bRbWx1SdM1iLSN/nQwrC7BfnS9dK1EKiupkqer5dmfyZw+tYWgh88HDOnkItPV9LLZXsr60zHAoK6qq1aXNJW2F5lqetO2FwZ1co2uanpWk2A+pCq6ycotqTH9u2BIp95QraaXDSKt25+ep49BvU4vepmqNz+6dd32wqCuRua5qg7GpXy6qulDCs0u60v1uW9tLgmGdHKSbDW9bttLVtP+9D4FdZVjsr3VJa3NthdqbmitLk8anT91sYFNs6PwDUEzrgf1vgZ0MKSTy3RPyZil0vYytKCep+p5FLW6tF1FT5hse2F/uj5DeI5l8oK56cDe92q6TW8w6mLLy0muv8GowpBOvddG2wtaCOo2hPW+VdFNtb3IYlCnMjIhvMvqukzYNR3UbX0j4Jq+h12d2nyDxJBOTtNRTc9SaXtpM6ij46p62WOrVNG7cv7YI1Lbtd32wqCuLvt6sB9dLtCr0DnTi6kgzYCul2tBvc9tLgmGdLLeU8YfVL5Pk0GkUJiWETVmfIGDQV31Mcuq6Da0uqR13fYCBvVCfXxOsuqE7i4q6rKtIwzU+pkIjK4E9SEEdDCkkyvKgrquQaQq/ekqA0lhKKi3FdarHqfujC5dKKqm62570TGQlEGd6tAZ1GWr6V0E9br76kM/+tANJaCDIZ36THfbS5OBpDAQ1GG4qi7zRiDvOLPPyYa50dPqBvW0wqCuqGwgaZGhBPWi58FWF7fpCOqsyp82tGq6zcdmQveNouQszw9WA7gWwGUApgB8B8DVcRTeUrD9VgAfAPAiAKvF9m+Po/A2mcd7yviDuHv2cbm3XXjGQ7j32JmV+zh74iB+PHO6DL5p8gj2HF576ufxqVnMHho/9fPC1HGMHMr/ZzI3DYylivNzU8DYodM/z64bwfiBpcF+dt0qjB9YGv7nNqzG2L6jyFrYOIWRvYeWXZ+VBOmFR/dWbitLJvw3raB32epy/tgjuH9ui9J9zlx7GA8dmSzfaOI4MHPyfDk+sYBVMyPi+0WsmlkBiGA+OnP6LumfZydHMH44PVh5JcYOnlj2MHPToxg7WFwxPTG1GisPLT+nXNGXNxpdedLoPO6b1zNF5YVjD+Peua2V2z1x/GF8f7Z6O6RC9gOPbVI6Fobz9vzosXU4Z41dq752FdC7nEmn+7IWuewGAC8A8HwAmwDcBOBmzw8uKNj+HwBsBfAM8fWLAD7r+UF+8s6h2vaSV01vsz+9rYo6NLXANN1HWRW99H4l7UNt6qLtJUumP11GH4Pu0OZG77vz1uyRCt6y21Vhq4sam6rWQwzoYEinujw/2ADgVQDeGkfhrjgKj8RReB2A7wK4Imf7pNK+I47Ch+IoPCaq6msBXGzyWGXaXsoWOcqyOagjFbRVwrbq9jJtLllFA0a7Cug296frGEgKR4O6yjGnXxfZdqGhsHkQaVYSwosuVM5kkLQhqA81oIMhnRq4SLRL3Zm5/o680B1H4aE4Cl8XR+HdqavPF1+Vpm8xMYg0q6yaDk1BPU9ZUK/TXpIO7GUXFbLHYcO0i1V09KenMaibwyp6d1SmY2S1un9+9Ni6zoLykAM6GNKpgaShN9sIvQdAZXO4qKx/FMDNcRR+TeeBtdH2Ag1BvSjEllWku55Jpejxq9pcbJt2MU12/vS0omp6HQzqp9Wtog/R+M4ZjO+cWfZ9WleLHNmo728e2giVbQbmLt8Y2BLQwZBOBqwAsFi2gecH5wL4sgj0r6zzIDrmTs/TRVBXaX1Bh0FdNqCrsKUXPS+ot9X2kmViakY4ENTLjq/q+Q2t1WV85wzWXH8Ia64/hInX7j31fV5Q14XVdEJL4dmGFhtbDOsvG+mUlKs3Z67fkrptGc8Pfla0xHwZwIviKDxctG2VNtpeIBHUVTXtUUeD9pc6yh4r7xhdqqKn1QnqaToHklZNzdi3oK56XEOvoidG9i1i/AvHMLKvtC7SCZuCuk3HYlKbFWATYb3L6nnCpio6GNKpgbsAcHtwaAAAF0xJREFUzAF4dub6S0QAX8bzg6cB+CcA74uj8Io4Clv/LLZO20uVOiuS6gjqaCGsl+1bNaAvu78lVXRV6aCerqaDQb2WquMZahW9bArF2e0TmH/W+JLr5p81jtntywMGW17IJB3B2oZwDgsDOhjSqa44Cg8CuBHANZ4f/JTnBxOeH7wbwLliakZ4fnCN5wcfF9+vBPAXAG6Io/CDuo6jTjXdhv50KAb1tsO6ifBfVkUvWyhKlyeMVs8jL1NNz8oG9UKap2ZEj4K6ClbRT7a7jH5j6d+k0W/MGm13gWLLCyypYNtwDG3qKmgmQbsqcGe3syGcw9KADi5mRA3tENMo3gpgEsC3AFwaR+FucftZIrRDVNwvAvA0zw/ektnPx+IofH3dg9CxyFEe1YWO5qcXMHow1dpRsdgRFBY8QsmiR2lJsJZZBKns/mWK3jDUraK3EdATSVD/wXzxjDZ5Cx2du3oPdh89vfDK2asP4MdHT//nkl7oaN3aozhw5ORrtHpiFkdnllY88xQtdpRd+Ci72FGRqsWOkArqXS561LSKPnQLG1Zg/lnjywK7TVQWOaL+sCV8y7A1oAPAisVF+3rZiNK+svv8ypO0KKQn8oL6A0eWr3aXXo00kQ7qAJYEdQDLViRNB3VgaVAHlgd1AMuC+snr8nvfq4J6nrLQrlIxrxvQs1X0vJB+/29etUL6QGr4Xz/ctuQ8KgvqAHJXJE0HdQBLgjqAJSuSJkEdwNKgPnP6tUpWJD35/dKnnw7no5kCaTao561KevJ6uVaHtoO6TCU/L6Bnq+jpTxfmJ4B/vW6H0XPo67vPa/0/zKJ2laRqPrt9Ysn3eXStPpqQWYE0q4ugXreK/l8v+JrR8+hnPvcO4+fRlrVmP1XpC1MB/a4X/56Wc4jtLtQLumZ70TGQ1GTrCyTbX7KS9pW8iyzZgF65H0t60avaX7ocSAoNUzNCoRJ9Ymp1ay0wLrfa2GR2+8SpUJ7+3lZtt50Mrc0ly+bqMMljSKfeaKs/HRYEddQM63WpBPSqKnpam60ueWT61KuYGkiaZTqoo4UALbv/OlX0vtJdBddBtTc9MfTgTHZx4Y0MQzoNhuy0jHlkZnwxGdS7Cutl+64T0G2poqeVBXXdA0l1zvgCg0Fdd1hX2adqQCe3tBHUbX8zcPBwO8UVF0JoV1x5bfiXjnrFZNtL1YwveXQFdUi0legM61X7kgnoy/aZee5dV9HTmgZ12YWOlmk5qNcJ600Cu+r96wwU7XMVPWFjNb0JkyHa9oDeNlfCaJtcek0Y0sl6Tx6dU9reVNsLakzNCANBXTasqwZ22fvJBnSVNpemC0Tp0FZQX1JNL2EiqKNmEJYN7Ont1Bcoyj8uVtHtVLflJWEiTDOgUxWXAjoY0skVQwjq2VA7u26kdlX91H5TwbvqIkP6cRXaXGwI6AndQT1NtT8dlgX1RDaI66i4ywb0rCFU0RN9q6ZDhGpdwdq1gN5WywscDKamuPg6MKSTM1SDepmmQT1LR1CHgaq6LmWPpdqHblObSx6dQb3pQNKsqlCqGtRtmIdc5RjKquhtBPY6Uw/qZFtQb1pNTzQJ6zqDfp+5GFB1cvX5M6RTb9XpTy+iY8YXGAjqMBzWq8K5ykwueWyqoqfpmPUloXMgKSqmZkRBUDdVVW+q7LGr2lyGVEVPUw3qtgX7MiqBuw/hvM1qOhwOqk25/LwZ0skpXbW95OkiqLcV1qv2VTVINOFaFV2G7oGkbQR1GGx/qUsloFcZWmB3KXjXkQTwsguRDJcDOhjSyUU2tb20HdQhEZCTgK0a2mXvU/T4qm0utlbREzbP+AJDQb2NsF71OHnHaFMVveuWl8R986OlYb3qdl10tbxQO1wPrSr68FwZ0slJKkG9qu3F9qBep6q+dNtVUpfq/RQ/pgvzodfR2YwvHQV1GAzrMvutE9CHVkXPSsJ49kJuaLvlBT0Jr1X68hwZ0slZfQ3qqlV12bDeRFk4lwnoVVV0mTnnu9LJjC8ZJoK6bFhvGthl9yET0LOGHtBtwWq6e/oSYvP06bkxpNNgmBxIipqrkqKgT1ulqg6DYV2lel7E5YCeUA3qWU1nfMnKBvU02aAOhd5v1cCuvr3ccZSF8rLXRDdbWl6oH7qopqNnYTbRt+fEkE5O63Igad1VSZsEdVSE4yRUNwnsMvsoOoY+DhRNqMz4kq2mZ+mYmlFlDnVUBHWVgZrpAF50kd9X8WOzzYXIvD6F2j49lwRDOjmvq4Gk6DioV1Wy02G7KHTLbCPzuHltOnnPx8UqelpRUG/an57VdlBHjRlVmioL56oBvc0qeoLV9KXY8tJMV9V09CTc9uE55GFIp17oqj+9iO6g3iSsp6kE8rzHyr1ecpCo7bO5yDIV1OtMzQiJoJ63MqmuqnodKtVzSFTMuwjoRH3zyJEJZ4Ouq8ctgyGdBsn0QNI8TYI6KsKwalhXUbbvomOSmW7RtSp6WltBfYmaQb3ouqqquu6wXrXPqkGiCba52IvV9Ga6rKYnXAq8Lr+xkMWQTr2hsz+9jM4ZX1AS1FWr6kgF6qaBXWY/sgE9j8sBPaEzqKfVmZoROUFdtv1FJqw3Cewy9y86BhvbXNLY8kJ95ELwdeEYdWBIp15pYyApDAV11ap6VZtJOmhXhXalbUseu4996HUYm/EF8kEdCoMtZarY6cCeF96rbi+iK6BnXwsiF9lQTYflVWpbj8sEhnTqnTYGkkJDUG/a/gLJsH5q26nii6yycC4T0IvITF+p0/mrFpdd6uhkxpeMOkG9TlW9SN1Ke9njuTSTC6vpS7HlpV9sCsQ2v3EwhSGdeqmNgaRFVOZQb9r+klAJ63WoVs+h0IfeRUAvur5OWO96xhfUCOpF16FBWJdVFc5lAjmr6NRntlTTE12H464fv0sM6UQGZnwxEdTRclhP9lW2P9cCuow6Yb3rGV/QIKhXhXVdgb1qX7LHZ2NAZzWdhqDtsDzkcJ5gSKfe0j2QtIugXhbWy6QDtnQ7jMJ9yt4s2BzQVcL3UIJ62fWJuoFd9n6y7Sw2BnRaji0vzdlWTU9LwrOJAG1y3y5iSKdeszWoyw4oRYOqelo2gOddZJU9Zt+mWjQZ1LNkZ3yBhqCuWlVPSwfvqksVlWPpeiaXKqym0xClQ3WdYN30/n3HkE69p3MgaRmVoA6FmV9QMQBTJaw3UVU9VwnoNra5FKk7qHTZfjJBvclAUjQM6qioqpseqFn2GHnX5x3/sir6RD8WyyJK2FxNL5IN3VUXKseQToPQ1kBSXUFdtf0FqRCtM7DL7LPomPoQ0BMqQb3JjC9VA0llFzuCQlBvM6xX7bN2QLcEq+mnseVFDxeDOunDkE6D4VJQR0VVvWpqw3S4Vg3tKvcbQkBPqAwoNTnji+wc6igI6ipVdaSCdd3QLnPfotulAzqr6ERkCZ1vrBjSiQrYHNQhGdYT2dBedpFR9tiqAf3siYOFr4tu9x9f0Xgfrgd11Kiq520ne5HZXx5XAzqr6aQbq+nu0P27YkinQWlrICk0B3VdYb2pqsfqYwW9CZ0DSZsGdZWqehuLB5U9jqsBncgUBnX7mfgdMaTT4LgY1CExS4rJsC6z7zoBva0Kum66BpOm5Q0krb3YEfIDrGxVHZJtKnVU7bMPAZ3VdKJhMfUmiiGdBsn2oF63qo5UoG4S2lX2UXZMfQzoiTbaXqqUzvgCEWQl21/KpjhsGthl7l90DLIBfdlz7xiDOgeP6sZq+vAwpNNg6Z6aUWdQh0RVXXb+8WzglrnIKjuGPgf0hG396SgKqxLtL5AI66jRk14V7Mse09ZZXIi6wqBuH5O/E4Z0IklV1XS0HNShGNZ1qnpcmwO6jsGjaa4GdZSEYJmwrkPZYxQGdAeq6AlW04n6zfSbJoZ0GjTdbS9oENTrtL8k2grrMo9jc0A3xUSPepbJoN5mWE/2WVY970NATzCok26sptuhjd8DQzoNnomgXqYoqKNhVR2pEK0zsKvsc4gBXUXT/vQ6QV1mQCkqWkvSwbpOaJe9b2k4dzCgE5nCoN6ttl5/hnSilgeSomFQl53OMB2uVUJ7nftVHVdVQC97PUzQ3fKCFgeS1lmVVGZAKaqq2Eu2W1S6VO9PrXqe+5wsxmo6mcCg3o02X3eGdCLBtqCuK6wnsuG76KJC5jhsC+gmNW17qTvjS62gjvKqehuDNisfpwcBPcGgTiYwqLer7debIZ0oxaagDomAWyes6yLzuH0J6GM7D2Ns5+Fl39dVVE0vUjWQFE2DekVY1x3YpfapGNDzni8RkS5dvCFiSCcyzHRQR4thPXmcPgR02ZaXsZ2Hccb1h3DG9Yew9rV7Tn1fFNRNtL3k0RrUUR7WkQnsqqFd6b4lx+FiBT2N1XQygdV087p6jRnSiTLanvEFkkFdJazrDuwq+5Q51q4Deh0j+xYx+oVjGNlXHcK76k9HQVCXGlCakFzJMxu8yy5SKt4klAV0l6roDOpkAoO6OV2+tqs6e2RynucHqwFcC+AyAFMAvgPg6jgKb9GxfZeePDqHe+bHpLd/yviDuHv2caXbXHjGQ7j32JmFtyfB9YEjmwq3ScLvj2emK48pL1TvOby28n5F95Uh80bCpoB+//EVlYF6bvskRm+fxcgXjp267sSzxjG3fdLosZ0/9gjun9uy5LpzV+/B7qNLz4+zVx/Aj4+uW3LdmWsP46EjS49v3dqjOHBk6X82qydmcXRmfPmDp8PyjOH/JiTeFPQloCfundvK1ThJu4OHV2N60r1/Dzbr+s0PK+nUxA0AXgDg+QA2AbgJwM2eH1ygaftc4ztnML5zZtn3unVRUYdkiK07nWG60l52USVb6bcpoMsa23kYK7+xNCSu/MZsZV9602p6kboVdZS0v5S2kVRUuGuT2G/VsbkY0BNDqKgP4TnaputQ2Sc2vJYM6VSL5wcbALwKwFvjKNwVR+GROAqvA/BdAFc03b7I+M4ZrLn+ENZcfwgTr9176vuhBnUb5h6XPQYXA3rawoYVmL/0DCxs0D99o2p/uu6gDpWw3iS0K9y/qv/c5YCeYIglE2wIl66z5TVkuwvVdZE4f+7MXH8HgIs1bF9qZN8ixkX7gYnQ1IRs6wuAxu0vyIRkmTYYXVTeINgc0KtaXtJtLXPbJ09V0GXaXc5ftdh4Tva8tpciKq0vAJa1v6CsBSbLRHVdcnBoHwJ6gq0vZAJbX+qzJaCDIZ0aSFJDtgS4B0Be8lTdPtfs9gmM3j57KqADwPyzxjG7fUJ2F6SBDRV8nVSDOpFODOpkAoO6GpvCeYIhnXRbAUBlRZfK7RdH7sCmM0Vl+o//GLjrPQBOh/Txu9Zi/NNvA970ptoHXeaSlu6TtuehB08/Z9Ji29jXOnlNL9K8nSyeQ/q9ePLTg3tNm5xHP6/9aPrha8/ZzvOIpLAnnepKGqs3Z67fkrqtyfblNm4EXvrSk1+JiIiIeoaVdKrrLgBzAJ4N4FOp6y8B8FkN2+dLV8vf9KaTlfXs9URERESOY0inWuIoPOj5wY0ArvH8YBeA3QCuAnCumGoRnh9cA2BbHIWXy2wvLRvUiYiIiHqG7S7UxA5RBb8VwKMAXgTg0jgKd4vbzxIhXHZ7IiIiIgKwYnFRZYwfUfv2PPTg4tAGnAx0kI3RuTSHdh7xHNJvaOcQeB4ZwfNoELScQ6ykExERERFZhiGdiIiIiMgyDOlERERERJZhSCciIiIisgxDOhERERGRZRjSiYiIiIgsw5BORERERGQZhnQiIiIiIsswpBMRERERWYYrjhIRERERWYaVdCIiIiIiyzCkExERERFZhiGdiIiIiMgyDOlERERERJZhSCciIiIisgxDOhERERGRZVZ1fQA0bJ4frAZwLYDLAEwB+A6Aq+MovEXH9jaq8Zx/AODxAE5kbnp6HIX3tnPUzXh+cB6AjwJ4LoDz4ij8Qcm2yr/joZ1HQzyHYPg8Gto5hIGeR/xbpNcQzyG0cB4lWEmnrt0A4AUAng9gE4CbANzs+cEFmra3UZ3n8Po4Cs/IXJz4g+b5QQDgawB2S96lzusztPNoUOcQ2jmPhnYOYWjnEf8WGTGocwjtnUcAK+nUJc8PNgB4FYCXx1G4S1x9necHlwO4AsBVTba3UR+eQw0bADwHwDkAXl22YZ3XZ2jnkevH34Cx82ho5xB68hxq4N8ijVw//gaMnkdpDOnUpYvEOXhn5vo7AFysYXsb1X0Ol3l+8FYAjwPwPQDviaPws4aPVYs4Cm/EyT9W50hsXuf1Gdp5NLhzCObPo6GdQxjiecS/RdoN7hxCO+fRKWx3oS5tEV/3Zq7fA+BMDdvbqM5z+DaAe8XHZecA+AyAz3h+8GzDx9qFOq/P0M4jnkPVTJ8Trp9D4HlUiX+LqvEcqtbod8xKOtloBYBFg9vbqPA5xFH40sxV7/X84D8C+A0AX23n8DpX53c8tPOI51A10+eE6+cQeB5V4t+iajyHqkn9jllJpy49JL5uzly/JXVbk+1tpOs53AfgLI3HZYs6r8/QziOeQ9VMnxOun0PgeVSJf4uq8Ryq1ug1YkinLt0FYA5A9mOuSwB8WcP2NlJ6Dp4fnOf5wZ94frAuc9NPiV6+vqnzOx7aecRzqJrpc8L1cwg8jyrxb1E1nkPVGv2O2e5CnYmj8KDnBzcCuMbzg11iOqOrAJwrpiyC5wfXANgWR+HlMtvbTvU5i3faLwEw5fnBm8U/9t8GcAGAl3X9fHRo+jse2nnEcyhfk9/x0M4h8DzKxb9FangO5dP5O2Ylnbq2A8BnAdwK4FEALwJwaRyFyfyjZ4mTWXZ7F0g/5zgKj4oBNhOi0vBDAM8D8Lw4Cu/p9mnI8fzgHs8PjgGIxFX3eH5wzPODPxM/6/gdD+08GtQ5hHbOo6GdQxjaecS/RUYM6hxCe+cRAGDF4qLLYxOIiIiIiPqHlXQiIiIiIsswpBMRERERWYYhnYiIiIjIMgzpRERERESWYUgnIiIiIrIMQzoRERERkWUY0omIiIiILMOQTkRERERkGYZ0IiIiIiLLMKQTEREREVmGIZ2IiIiIyDIM6URERERElmFIJyIiIiKyDEM6EREREZFlGNKJiIiIiCzDkE5EREREZBmGdCIiIiIiyzCkExERERFZhiGdiIiIiMgyDOlERERERJZhSCciIiIisgxDOhERERGRZRjSiYiIiIgsw5BORERERGQZhnQiIiIiIsswpBMRERERWYYhnYiIiIjIMgzpRERERESWYUgnIiIiIrIMQzoRERERkWUY0omIiIiILMOQTkRERERkGYZ0IiIiIiLLMKQTEREREVmGIZ2IiIiIyDIM6URERERElmFIJyIiIiKyDEM6EREREZFlGNKJiIiIiCzDkE5EREREZBmGdCIiIiIiyzCkExERERFZhiGdiIiIiMgyDOlERERERJZhSCciIiIisgxDOhERERGRZRjSiYiIiIgsw5BORERERGQZhnQiIiIiIsswpBMRERERWYYhnYiIiIjIMgzpRERERESWYUgnIiIiIrIMQzoRERERkWUY0omIiIiILMOQTkRERERkmVVdHwAREZFJnh+8GcAfAlgfR+FM18dDRCSDlXQiIuotzw9eDeBMAA92fSxERCoY0omIyDmeH7zL84OrxPfv9PzgbQWbhnEUvgPAYrtHSETUDNtdiIjIRe8HcLvnB58H8MsAfjFvozgKD7d/aEREzbGSTkREzomjcA7AOwB8CcBb4iic7/qYiIh0YkgnIiJXbQWwH8DZXR8IEZFuDOlEROQczw+mAVwJ4GIAV4ufiYh6gyGdiIhc9D4AfxhH4cMAPiR+Xsbzg3d4fnCbmOHlc54f/H77h0pEpG7F4iIHvBMRERER2YSzuxARkdM8P9gG4C9zbvpiHIXv7uCQiIgaYyWdiIiIiMgy7EknIiIiIrIMQzoRERERkWUY0omIiIiILMOQTkRERERkGYZ0IiIiIiLL/P/bss39N+UdPgAAAABJRU5ErkJggg==\n" - }, - "metadata": { - "bento_obj_id": "140516819586640", - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "aa853e07-b322-4e26-ad5b-db81b8a47a33" - }, - "source": [ - "#### Batch BO (q=3)\n", - "\n", - "For the batch BO case, GIBBON selects similar points to MES but with an order-of-magnitude lower computational overhead, i.e perfoming information-theoretic BO at the cost of much simpler acqusition functions like EI and PI. We stress that this gap in computational overhead between GIBBON and MES grows substantially as the optimisation progresses (see [2])." - ] - }, - { - "cell_type": "code", - "metadata": { - "originalKey": "31ac3a12-eb78-4226-9170-31a22816f6c5", - "collapsed": false, - "requestMsgId": "a7e5671c-1735-46dc-b2f0-6f8b85a997e6", - "executionStartTime": 1648577020385, - "executionStopTime": 1648577031509 - }, - "source": [ - "from botorch.acquisition import qNoisyExpectedImprovement, qProbabilityOfImprovement\n", - "from time import time\n", - "\n", - "# prep different acqusition functions\n", - "acqs = {}\n", - "candidate_set = torch.rand(\n", - " 10000, bounds.size(1), device=bounds.device, dtype=bounds.dtype\n", - ")\n", - "acqs[\"GIBBON\"] = qLowerBoundMaxValueEntropy(model, candidate_set)\n", - "acqs[\"MES\"] = qMaxValueEntropy(model, candidate_set)\n", - "acqs[\"EI\"] = qNoisyExpectedImprovement(model, train_X)\n", - "acqs[\"PI\"] = qProbabilityOfImprovement(model, best_f=train_Y.max())\n", - "\n", - "# prep grid to evaluate acq functions\n", - "n = 100 if not SMOKE_TEST else 2\n", - "xv, yv = torch.meshgrid([torch.linspace(0, 1, n), torch.linspace(0, 1, n)])\n", - "test_x = torch.stack([xv.reshape(n * n, 1), yv.reshape(n * n, 1)], -1)\n", - "\n", - "# eval and maximise acq functions\n", - "evals = {}\n", - "candidates = {}\n", - "times = {}\n", - "for acq in acqs.keys():\n", - " evals[acq] = acqs[acq](test_x).detach().reshape(n, n)\n", - " t_0 = time()\n", - " candidates[acq], _ = optimize_acqf(\n", - " acq_function=acqs[acq],\n", - " bounds=bounds_norm,\n", - " q=3,\n", - " num_restarts=5,\n", - " raw_samples=100,\n", - " sequential=True,\n", - " )\n", - " times[acq] = time() - t_0\n", - "\n", - "# plot acqusition function values and chosen points\n", - "fig, (ax1, ax2, ax3, ax4) = plt.subplots(\n", - " nrows=1, ncols=4, sharex=True, sharey=True, figsize=(10, 5)\n", - ")\n", - "ax1.contourf(xv, yv, evals[\"GIBBON\"], levels=20)\n", - "ax1.scatter(candidates[\"GIBBON\"][:, 0], candidates[\"GIBBON\"][:, 1], marker=\"X\", c=\"r\")\n", - "ax1.set_title(\"GIBBON\")\n", - "ax2.contourf(xv, yv, evals[\"MES\"], levels=20)\n", - "ax2.scatter(candidates[\"MES\"][:, 0], candidates[\"MES\"][:, 1], marker=\"X\", c=\"r\")\n", - "ax2.set_title(\"MES\")\n", - "ax3.contourf(xv, yv, evals[\"EI\"], levels=20)\n", - "ax3.scatter(candidates[\"EI\"][:, 0], candidates[\"EI\"][:, 1], marker=\"X\", c=\"r\")\n", - "ax3.set_title(\"EI\")\n", - "ax4.contourf(xv, yv, evals[\"PI\"], levels=20)\n", - "ax4.scatter(candidates[\"PI\"][:, 0], candidates[\"PI\"][:, 1], marker=\"X\", c=\"r\")\n", - "ax4.set_title(\"PI\")\n", - "fig.text(0.5, -0.1, \"x_1\", ha=\"center\")\n", - "fig.text(-0.1, 0.5, \"x_2\", va=\"center\")\n", - "\n", - "# plot computational overheads\n", - "plt.figure()\n", - "heights = [times[acq] for acq in acqs.keys()]\n", - "plt.bar(acqs.keys(), heights)\n", - "plt.ylabel(\"Computation Time\")\n", - "plt.xlabel(\"Acquisition Function\")" - ], - "execution_count": 7, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "executionStartTime": 1648577014352, + "executionStopTime": 1648577015895, + "originalKey": "8900645e-ef50-4d4d-b4ae-9b0f4152aff0", + "requestMsgId": "8d7262fb-6bfe-454f-b465-478d269c184f" + }, + "outputs": [], + "source": [ + "import math\n", + "import torch\n", + "\n", + "from botorch.test_functions import SixHumpCamel\n", + "from botorch.fit import fit_gpytorch_mll\n", + "from botorch.models import SingleTaskGP\n", + "from botorch.utils.transforms import standardize, normalize\n", + "from gpytorch.mlls import ExactMarginalLogLikelihood\n", + "\n", + "torch.manual_seed(123456)\n", + "\n", + "bounds = torch.tensor(SixHumpCamel._bounds).T\n", + "bounds_norm = torch.tensor([[0.0, 0.0], [1.0, 1.0]])\n", + "train_X = bounds[0] + (bounds[1] - bounds[0]) * torch.rand(5, 2)\n", + "train_Y = SixHumpCamel(negate=True)(train_X).unsqueeze(-1)\n", + "\n", + "train_X = normalize(train_X, bounds=bounds)\n", + "train_Y = standardize(train_Y + 0.05 * torch.randn_like(train_Y))\n", + "\n", + "model = SingleTaskGP(train_X, train_Y)\n", + "mll = ExactMarginalLogLikelihood(model.likelihood, model)\n", + "fit_gpytorch_mll(mll, max_attempts=10);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "originalKey": "1b900ec1-ec7a-4330-bf79-d16b72e53304" + }, + "source": [ + "### 2. Defining the GIBBON acquisition function\n", + "\n", + "GIBBON is implemented in BoTorch as `qLowerBoundMaxValueEntropy` and supports pending points through its `X_pending` argument. Required arguments for the constructor are `model` and `candidate_set` (the discretized candidate points in the design space that will be used to draw max value samples). There are also other optional parameters, such as number of max value samples. Just like in our implementation of MES, two different sampling algorithms are supported for the max value samples: discretized Thompson sampling and Gumbel sampling (the default choice). \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "executionStartTime": 1648577015914, + "executionStopTime": 1648577016144, + "originalKey": "a01d0c4a-583a-4791-9259-02609b02d6d6", + "requestMsgId": "ad226a16-8b53-418e-bfb2-d3460b270acd" + }, + "outputs": [], + "source": [ + "from botorch.acquisition.max_value_entropy_search import qLowerBoundMaxValueEntropy\n", + "\n", + "candidate_set_size = 1000 if not SMOKE_TEST else 5\n", + "candidate_set = torch.rand(\n", + " candidate_set_size, bounds_norm.size(1), device=bounds.device, dtype=bounds.dtype\n", + ")\n", + "qGIBBON = qLowerBoundMaxValueEntropy(model, candidate_set)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "originalKey": "d7ad6371-414c-4daa-b00a-253c7dbf0dd0" + }, + "source": [ + "### 3. Optimizing the GIBBON acquisition function to get the next candidate points\n", + "\n", + "In order to obtain the next candidate point(s) to query, we need to optimize the acquisition function over the design space. For $q=1$ case, we can simply call the `optimize_acqf` function in the library. For $q>1$, we greedily build batches using sequential optimization. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "executionStartTime": 1648577016206, + "executionStopTime": 1648577016782, + "originalKey": "6b2f24f7-93cb-419b-a36a-626e48077b6c", + "requestMsgId": "dd3c847a-3bca-439f-bc9a-2acb698068a7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[ 0.1199, -0.0158]]), tensor(0.0085))" + ] + }, + "execution_count": 4, + "metadata": { + "bento_obj_id": "140516803885120" + }, + "output_type": "execute_result" + } + ], + "source": [ + "from botorch.optim import optimize_acqf\n", + "\n", + "NUM_RESTARTS = 10 if not SMOKE_TEST else 2\n", + "RAW_SAMPLES = 512 if not SMOKE_TEST else 4\n", + "\n", + "# for q = 1\n", + "candidates, acq_value = optimize_acqf(\n", + " acq_function=qGIBBON,\n", + " bounds=bounds,\n", + " q=1,\n", + " num_restarts=NUM_RESTARTS,\n", + " raw_samples=RAW_SAMPLES,\n", + ")\n", + "candidates, acq_value" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "executionStartTime": 1648577016794, + "executionStopTime": 1648577017848, + "originalKey": "7ffdf144-60eb-4980-b387-5c03762a1f91", + "requestMsgId": "270506a8-d7dc-42d6-a6f5-b54f77746900" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[ 0.1194, -0.0160],\n", + " [ 1.4241, 0.4417]]),\n", + " tensor([0.0085, 0.0104]))" + ] + }, + "execution_count": 5, + "metadata": { + "bento_obj_id": "140516803794560" + }, + "output_type": "execute_result" + } + ], + "source": [ + "from botorch.optim import optimize_acqf\n", + "\n", + "# for q = 2, sequential optimsiation\n", + "candidates, acq_value = optimize_acqf(\n", + " acq_function=qGIBBON,\n", + " bounds=bounds,\n", + " q=2,\n", + " num_restarts=NUM_RESTARTS,\n", + " raw_samples=RAW_SAMPLES,\n", + " sequential=True,\n", + ")\n", + "candidates, acq_value" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "originalKey": "5e590a09-d151-4578-8558-79a9d9aa20d6" + }, + "source": [ + "### 4. Comparing GIBBON with other acquisition functions\n", + "\n", + "We now perform an illustrative comparison between GIBBON and the other low-cost acquisition functions implemented in BoTorch. We plot points chosen by each of the acquisition functions, each acquisition function's surface.\n" + ] + }, { - "output_type": "execute_result", - "data": { - "text/plain": "Text(0.5, 0, 'Acquisition Function')" - }, - "metadata": { - "bento_obj_id": "140516625083456" - }, - "execution_count": 7 + "cell_type": "markdown", + "metadata": { + "originalKey": "669f1fbe-f713-4158-a10a-9fa70ce3f14f" + }, + "source": [ + "#### Sequential BO (q=1)\n", + "\n", + "Firstly, we investigate GIBBON in the purely sequential case, comparing agaisnt MES, Expected Improvement (EI) and Probability of Improvement (PI). We see that GIBBON provides a very high-quality approximation of MES, choosing essentially the same location.\n" + ] }, { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "bento_obj_id": "140516819231504", - "needs_background": "light" - } + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [], + "collapsed": false, + "executionStartTime": 1648577017895, + "executionStopTime": 1648577020377, + "hidden_ranges": [], + "originalKey": "5a4c0f2d-7bd3-4173-9e61-207b02591da7", + "requestMsgId": "e7a1e4c6-cec0-4168-b47a-e0634a7959e8" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(-0.1, 0.5, 'x_2')" + ] + }, + "execution_count": 6, + "metadata": { + "bento_obj_id": "140516721571968" + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140516819586640", + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from botorch.acquisition import (\n", + " ExpectedImprovement,\n", + " ProbabilityOfImprovement,\n", + " qMaxValueEntropy,\n", + ")\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "\n", + "# prep different acqusition functions\n", + "acqs = {}\n", + "candidate_set = torch.rand(\n", + " 10000, bounds.size(1), device=bounds.device, dtype=bounds.dtype\n", + ")\n", + "acqs[\"GIBBON\"] = qLowerBoundMaxValueEntropy(model, candidate_set)\n", + "acqs[\"MES\"] = qMaxValueEntropy(model, candidate_set)\n", + "acqs[\"EI\"] = ExpectedImprovement(model, best_f=train_Y.max())\n", + "acqs[\"PI\"] = ProbabilityOfImprovement(model, best_f=train_Y.max())\n", + "\n", + "# prep grid to evaluate acq functions\n", + "n = 100 if not SMOKE_TEST else 2\n", + "xv, yv = torch.meshgrid([torch.linspace(0, 1, n), torch.linspace(0, 1, n)])\n", + "test_x = torch.stack([xv.reshape(n * n, 1), yv.reshape(n * n, 1)], -1)\n", + "\n", + "# eval and maximise acq functions\n", + "evals = {}\n", + "candidates = {}\n", + "for acq in acqs.keys():\n", + " evals[acq] = acqs[acq](test_x).detach().reshape(n, n)\n", + " candidates[acq], _ = optimize_acqf(\n", + " acq_function=acqs[acq], bounds=bounds_norm, q=1, num_restarts=5, raw_samples=100\n", + " )\n", + "\n", + "# plot acqusition function values and chosen points\n", + "fig, (ax1, ax2, ax3, ax4) = plt.subplots(\n", + " nrows=1, ncols=4, sharex=True, sharey=True, figsize=(10, 5)\n", + ")\n", + "ax1.contourf(xv.numpy(), yv.numpy(), evals[\"GIBBON\"].numpy(), levels=20)\n", + "ax1.scatter(candidates[\"GIBBON\"][:, 0], candidates[\"GIBBON\"][:, 1], marker=\"X\", c=\"r\")\n", + "ax1.set_title(\"GIBBON\")\n", + "ax2.contourf(xv.numpy(), yv.numpy(), evals[\"MES\"].numpy(), levels=20)\n", + "ax2.scatter(candidates[\"MES\"][:, 0], candidates[\"MES\"][:, 1], marker=\"X\", c=\"r\")\n", + "ax2.set_title(\"MES\")\n", + "ax3.contourf(xv.numpy(), yv.numpy(), evals[\"EI\"].numpy(), levels=20)\n", + "ax3.scatter(candidates[\"EI\"][:, 0], candidates[\"EI\"][:, 1], marker=\"X\", c=\"r\")\n", + "ax3.set_title(\"EI\")\n", + "ax4.contourf(xv.numpy(), yv.numpy(), evals[\"PI\"].numpy(), levels=20)\n", + "ax4.scatter(candidates[\"PI\"][:, 0], candidates[\"PI\"][:, 1], marker=\"X\", c=\"r\")\n", + "ax4.set_title(\"PI\")\n", + "fig.text(0.5, -0.1, \"x_1\", ha=\"center\")\n", + "fig.text(-0.1, 0.5, \"x_2\", va=\"center\")" + ] }, { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "bento_obj_id": "140516625042544", - "needs_background": "light" - } + "cell_type": "markdown", + "metadata": { + "originalKey": "aa853e07-b322-4e26-ad5b-db81b8a47a33" + }, + "source": [ + "#### Batch BO (q=3)\n", + "\n", + "For the batch BO case, GIBBON selects similar points to MES but with an order-of-magnitude lower computational overhead, i.e perfoming information-theoretic BO at the cost of much simpler acqusition functions like EI and PI. We stress that this gap in computational overhead between GIBBON and MES grows substantially as the optimisation progresses (see [2])." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "executionStartTime": 1648577020385, + "executionStopTime": 1648577031509, + "originalKey": "31ac3a12-eb78-4226-9170-31a22816f6c5", + "requestMsgId": "a7e5671c-1735-46dc-b2f0-6f8b85a997e6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Acquisition Function')" + ] + }, + "execution_count": 7, + "metadata": { + "bento_obj_id": "140516625083456" + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140516819231504", + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140516625042544", + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from botorch.acquisition import qNoisyExpectedImprovement, qProbabilityOfImprovement\n", + "from time import time\n", + "\n", + "# prep different acqusition functions\n", + "acqs = {}\n", + "candidate_set = torch.rand(\n", + " 10000, bounds.size(1), device=bounds.device, dtype=bounds.dtype\n", + ")\n", + "acqs[\"GIBBON\"] = qLowerBoundMaxValueEntropy(model, candidate_set)\n", + "acqs[\"MES\"] = qMaxValueEntropy(model, candidate_set)\n", + "acqs[\"EI\"] = qNoisyExpectedImprovement(model, train_X)\n", + "acqs[\"PI\"] = qProbabilityOfImprovement(model, best_f=train_Y.max())\n", + "\n", + "# prep grid to evaluate acq functions\n", + "n = 100 if not SMOKE_TEST else 2\n", + "xv, yv = torch.meshgrid([torch.linspace(0, 1, n), torch.linspace(0, 1, n)])\n", + "test_x = torch.stack([xv.reshape(n * n, 1), yv.reshape(n * n, 1)], -1)\n", + "\n", + "# eval and maximise acq functions\n", + "evals = {}\n", + "candidates = {}\n", + "times = {}\n", + "for acq in acqs.keys():\n", + " evals[acq] = acqs[acq](test_x).detach().reshape(n, n)\n", + " t_0 = time()\n", + " candidates[acq], _ = optimize_acqf(\n", + " acq_function=acqs[acq],\n", + " bounds=bounds_norm,\n", + " q=3,\n", + " num_restarts=5,\n", + " raw_samples=100,\n", + " sequential=True,\n", + " )\n", + " times[acq] = time() - t_0\n", + "\n", + "# plot acqusition function values and chosen points\n", + "fig, (ax1, ax2, ax3, ax4) = plt.subplots(\n", + " nrows=1, ncols=4, sharex=True, sharey=True, figsize=(10, 5)\n", + ")\n", + "ax1.contourf(xv.numpy(), yv.numpy(), evals[\"GIBBON\"].numpy(), levels=20)\n", + "ax1.scatter(candidates[\"GIBBON\"][:, 0], candidates[\"GIBBON\"][:, 1], marker=\"X\", c=\"r\")\n", + "ax1.set_title(\"GIBBON\")\n", + "ax2.contourf(xv.numpy(), yv.numpy(), evals[\"MES\"].numpy(), levels=20)\n", + "ax2.scatter(candidates[\"MES\"][:, 0], candidates[\"MES\"][:, 1], marker=\"X\", c=\"r\")\n", + "ax2.set_title(\"MES\")\n", + "ax3.contourf(xv.numpy(), yv.numpy(), evals[\"EI\"].numpy(), levels=20)\n", + "ax3.scatter(candidates[\"EI\"][:, 0], candidates[\"EI\"][:, 1], marker=\"X\", c=\"r\")\n", + "ax3.set_title(\"EI\")\n", + "ax4.contourf(xv.numpy(), yv.numpy(), evals[\"PI\"].numpy(), levels=20)\n", + "ax4.scatter(candidates[\"PI\"][:, 0], candidates[\"PI\"][:, 1], marker=\"X\", c=\"r\")\n", + "ax4.set_title(\"PI\")\n", + "fig.text(0.5, -0.1, \"x_1\", ha=\"center\")\n", + "fig.text(-0.1, 0.5, \"x_2\", va=\"center\")\n", + "\n", + "# plot computational overheads\n", + "plt.figure()\n", + "heights = [times[acq] for acq in acqs.keys()]\n", + "plt.bar(acqs.keys(), heights)\n", + "plt.ylabel(\"Computation Time\")\n", + "plt.xlabel(\"Acquisition Function\")" + ] } - ] - } - ] + ], + "metadata": { + "fileHeader": "", + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 } diff --git a/tutorials/constraint_active_search.ipynb b/tutorials/constraint_active_search.ipynb index 4b9a655ac3..8c36a56c7e 100644 --- a/tutorials/constraint_active_search.ipynb +++ b/tutorials/constraint_active_search.ipynb @@ -1,742 +1,738 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "hidden_ranges": [], - "originalKey": "c31f62e6-7593-4975-ac72-c8d1a59fe3b7", - "showInput": false - }, - "source": [ - "## Constraint Active Search for Multiobjective Experimental Design\n", - "\n", - "In this tutorial we show how to implement the Expected Coverage Improvement (ECI) [1] acquisition function in BoTorch. For a number of outcome constraints, ECI tries to efficiently discover the feasible region and simultaneously sample diverse feasible configurations. Given a user-specified punchout radius $r$, we center a sphere with that radius around each evaluated configuration. The total coverage is now given by the volume of the union of these sphere intersected with the feasible region; see the paper and, in particular, Figure 2 for a full description of how ECI works.\n", - "\n", - "By design, ECI prefers candidates that are in unexplored regions since the candidate's corresponding sphere won't intersect with the spheres around the previously evaluated configurations. On the other hand, ECI also prefers configurations that are likely to satisfy the constraints and to give an improvement in the total coverage. This results in an exploitation-exploration trade-off similar to other acquisition functions.\n", - "\n", - "ECI may be estimated using the following equation:\n", - "$$\n", - "\\text{ECI}(x) = \\sum_{x' \\in \\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)} p(Z(x') = 1 \\;|\\; \\mathcal{D}_t).\n", - "$$\n", - "\n", - "where $\\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)$ a set of points generated via Monte Carlo to be inside a sphere of radius $r$ around $x$, but sufficiently far from the set of known evaluations $X$ (where sufficiently far is defined by the punchout radius $r$). The function $p(Z(x') = 1 \\;|\\; \\mathcal{D}_t)$ is the probability that the GP at $x'$ satisfies a user-specified threshold value, or threshold values in the case of multiple objective functions. \n", - "\n", - "[1]: [Malkomes et al., Beyond the Pareto Efficient Frontier: Constraint Active Search for Multiobjective Experimental Design, Proceedings of the 38th International Conference on Machine Learning, 2021](http://proceedings.mlr.press/v139/malkomes21a/malkomes21a.pdf)." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489228284, - "executionStopTime": 1638489229640, - "hidden_ranges": [], - "originalKey": "9896cb02-0d0e-498f-bdf7-86ea14baaf40", - "requestMsgId": "9896cb02-0d0e-498f-bdf7-86ea14baaf40" - }, - "outputs": [], - "source": [ - "import os\n", - "\n", - "import torch\n", - "from botorch.acquisition.monte_carlo import MCAcquisitionFunction\n", - "from botorch.acquisition.objective import IdentityMCObjective\n", - "from botorch.fit import fit_gpytorch_mll\n", - "from botorch.models import ModelListGP, SingleTaskGP\n", - "from botorch.models.transforms.outcome import Standardize\n", - "from botorch.optim import optimize_acqf\n", - "from botorch.utils.sampling import sample_hypersphere\n", - "from botorch.utils.transforms import t_batch_mode_transform\n", - "from gpytorch.constraints import Interval\n", - "from gpytorch.likelihoods import GaussianLikelihood\n", - "from gpytorch.mlls import ExactMarginalLogLikelihood\n", - "from torch.quasirandom import SobolEngine\n", - "\n", - "\n", - "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489229684, - "executionStopTime": 1638489230490, - "hidden_ranges": [], - "originalKey": "b4b78cb1-b0d4-4203-a97b-7a293ea418d4", - "requestMsgId": "b4b78cb1-b0d4-4203-a97b-7a293ea418d4" - }, - "outputs": [], - "source": [ - "tkwargs = {\n", - " \"device\": torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n", - " \"dtype\": torch.double,\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "hidden_ranges": [], - "originalKey": "e9cecfd7-f548-4b66-8009-c97809afc144", - "showInput": false - }, - "source": [ - "To start, we need to be able to sample points in $\\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)$. We can generate a pool of points and use standard rejection sampling to do so, but this leads to an acquisition function that isn't immediately differentiable; rejection sampling is essentially providing either a binary weight of either 0 or 1 to each point in the sample pool, which is not a differentiable function. \n", - "\n", - "\n", - "In order to make the acquisition function differentiable, we rely on a differentiable approximation of this binary weight function. For example, `smooth_box_mask` is a continuous differentiable approximation of $a < x < b$ (see the plot below for a visualization). A larger value of eps will make the sigmoid less steep and result in a smoother (and easier to optimize) but less accurate acquisition function. " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "executionStartTime": 1638489230493, - "executionStopTime": 1638489230509, - "originalKey": "63c0a300-c3a1-49bb-a6ba-41cf9dfa9632", - "requestMsgId": "63c0a300-c3a1-49bb-a6ba-41cf9dfa9632" - }, - "outputs": [], - "source": [ - "def smooth_mask(x, a, eps=2e-3):\n", - " \"\"\"Returns 0ish for x < a and 1ish for x > a\"\"\"\n", - " return torch.nn.Sigmoid()((x - a) / eps)\n", - "\n", - "\n", - "def smooth_box_mask(x, a, b, eps=2e-3):\n", - " \"\"\"Returns 1ish for a < x < b and 0ish otherwise\"\"\"\n", - " return smooth_mask(x, a, eps) - smooth_mask(x, b, eps)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489230587, - "executionStopTime": 1638489233802, - "hidden_ranges": [], - "originalKey": "7b49f71b-f131-4600-96fd-5aa581212202", - "requestMsgId": "7b49f71b-f131-4600-96fd-5aa581212202" - }, - "outputs": [ + "cells": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "hidden_ranges": [], + "originalKey": "c31f62e6-7593-4975-ac72-c8d1a59fe3b7", + "showInput": false + }, + "source": [ + "## Constraint Active Search for Multiobjective Experimental Design\n", + "\n", + "In this tutorial we show how to implement the Expected Coverage Improvement (ECI) [1] acquisition function in BoTorch. For a number of outcome constraints, ECI tries to efficiently discover the feasible region and simultaneously sample diverse feasible configurations. Given a user-specified punchout radius $r$, we center a sphere with that radius around each evaluated configuration. The total coverage is now given by the volume of the union of these sphere intersected with the feasible region; see the paper and, in particular, Figure 2 for a full description of how ECI works.\n", + "\n", + "By design, ECI prefers candidates that are in unexplored regions since the candidate's corresponding sphere won't intersect with the spheres around the previously evaluated configurations. On the other hand, ECI also prefers configurations that are likely to satisfy the constraints and to give an improvement in the total coverage. This results in an exploitation-exploration trade-off similar to other acquisition functions.\n", + "\n", + "ECI may be estimated using the following equation:\n", + "$$\n", + "\\text{ECI}(x) = \\sum_{x' \\in \\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)} p(Z(x') = 1 \\;|\\; \\mathcal{D}_t).\n", + "$$\n", + "\n", + "where $\\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)$ a set of points generated via Monte Carlo to be inside a sphere of radius $r$ around $x$, but sufficiently far from the set of known evaluations $X$ (where sufficiently far is defined by the punchout radius $r$). The function $p(Z(x') = 1 \\;|\\; \\mathcal{D}_t)$ is the probability that the GP at $x'$ satisfies a user-specified threshold value, or threshold values in the case of multiple objective functions. \n", + "\n", + "[1]: [Malkomes et al., Beyond the Pareto Efficient Frontier: Constraint Active Search for Multiobjective Experimental Design, Proceedings of the 38th International Conference on Machine Learning, 2021](http://proceedings.mlr.press/v139/malkomes21a/malkomes21a.pdf)." ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "%matplotlib inline\n", - "\n", - "\n", - "x = torch.linspace(-2, 2, 500, **tkwargs)\n", - "\n", - "fig, ax = plt.subplots(1, 2, figsize=(8, 4))\n", - "ax[0].plot(x.cpu(), smooth_mask(x, -1).cpu(), \"b\")\n", - "ax[1].plot(x.cpu(), smooth_box_mask(x, -1, 1).cpu(), \"b\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "hidden_ranges": [], - "originalKey": "7ff5ed82-355b-45b8-91f9-823c41c46efc", - "showInput": false - }, - "source": [ - "## Implementation of ECI\n", - "\n", - "Once we have defined our smooth mask functions, we can compute a differentiable approximation of ECI in a straightforward manner using Monte Carlo (MC). We use the popular variance reduction technique of Common random numbers (CRN).\n", - "\n", - "We first use a low discrepancy sequence to generate a set of base samples. We integrate (sum) over these base samples to approximate the ECI acquisition function. Fixing these base samples makes the method deterministic and by using the smooth masks defined earlier, we can filter out infeasible points while still having a differentiable acquisition function.\n", - "\n", - "This implementation assumes that the GP models for the different outputs are independent and that each constraints only affects one output (simple box-constraints like f(x) <= 0.5)." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489233910, - "executionStopTime": 1638489233950, - "hidden_ranges": [], - "originalKey": "5dd0a6af-0bde-4e57-8bdd-d53baea75075", - "requestMsgId": "5dd0a6af-0bde-4e57-8bdd-d53baea75075" - }, - "outputs": [], - "source": [ - "class ExpectedCoverageImprovement(MCAcquisitionFunction):\n", - " def __init__(\n", - " self,\n", - " model,\n", - " constraints,\n", - " punchout_radius,\n", - " bounds,\n", - " num_samples=128,\n", - " **kwargs,\n", - " ):\n", - " \"\"\"Expected Coverage Improvement (q=1 required, analytic)\n", - "\n", - " Right now, we assume that all the models in the ModelListGP have\n", - " the same training inputs.\n", - "\n", - " Args:\n", - " model: A ModelListGP object containing models matching the corresponding constraints.\n", - " All models are assumed to have the same training data.\n", - " constraints: List containing 2-tuples with (direction, value), e.g.,\n", - " [('gt', 3), ('lt', 4)]. It is necessary that\n", - " len(constraints) == model.num_outputs.\n", - " punchout_radius: Positive value defining the desired minimum distance between points\n", - " bounds: torch.tensor whose first row is the lower bounds and second row is the upper bounds\n", - " num_samples: Number of samples for MC integration\n", - " \"\"\"\n", - " super().__init__(model=model, objective=IdentityMCObjective(), **kwargs)\n", - " assert len(constraints) == model.num_outputs\n", - " assert all(direction in (\"gt\", \"lt\") for direction, _ in constraints)\n", - " assert punchout_radius > 0\n", - " self.constraints = constraints\n", - " self.punchout_radius = punchout_radius\n", - " self.bounds = bounds\n", - " self.base_points = self.train_inputs\n", - " self.ball_of_points = self._generate_ball_of_points(\n", - " num_samples=num_samples,\n", - " radius=punchout_radius,\n", - " device=bounds.device,\n", - " dtype=bounds.dtype,\n", - " )\n", - " self._thresholds = torch.tensor(\n", - " [threshold for _, threshold in self.constraints]\n", - " ).to(bounds)\n", - " assert (\n", - " all(ub > lb for lb, ub in self.bounds.T) and len(self.bounds.T) == self.dim\n", - " )\n", - "\n", - " @property\n", - " def num_outputs(self):\n", - " return self.model.num_outputs\n", - "\n", - " @property\n", - " def dim(self):\n", - " return self.train_inputs.shape[-1]\n", - "\n", - " @property\n", - " def train_inputs(self):\n", - " return self.model.models[0].train_inputs[0]\n", - "\n", - " def _generate_ball_of_points(\n", - " self, num_samples, radius, device=None, dtype=torch.double\n", - " ):\n", - " \"\"\"Creates a ball of points to be used for MC.\"\"\"\n", - " tkwargs = {\"device\": device, \"dtype\": dtype}\n", - " z = sample_hypersphere(d=self.dim, n=num_samples, qmc=True, **tkwargs)\n", - " r = torch.rand(num_samples, 1, **tkwargs) ** (1 / self.dim)\n", - " return radius * r * z\n", - "\n", - " def _get_base_point_mask(self, X):\n", - " distance_matrix = self.model.models[0].covar_module.base_kernel.covar_dist(\n", - " X, self.base_points\n", - " )\n", - " return smooth_mask(distance_matrix, self.punchout_radius)\n", - "\n", - " def _estimate_probabilities_of_satisfaction_at_points(self, points):\n", - " \"\"\"Estimate the probability of satisfying the given constraints.\"\"\"\n", - " posterior = self.model.posterior(X=points)\n", - " mus, sigma2s = posterior.mean, posterior.variance\n", - " dist = torch.distributions.normal.Normal(mus, sigma2s.sqrt())\n", - " norm_cdf = dist.cdf(self._thresholds)\n", - " probs = torch.ones(points.shape[:-1]).to(points)\n", - " for i, (direction, _) in enumerate(self.constraints):\n", - " probs = probs * (\n", - " norm_cdf[..., i] if direction == \"lt\" else 1 - norm_cdf[..., i]\n", - " )\n", - " return probs\n", - "\n", - " @t_batch_mode_transform(expected_q=1)\n", - " def forward(self, X):\n", - " \"\"\"Evaluate Expected Improvement on the candidate set X.\"\"\"\n", - " ball_around_X = self.ball_of_points + X\n", - " domain_mask = smooth_box_mask(\n", - " ball_around_X, self.bounds[0, :], self.bounds[1, :]\n", - " ).prod(dim=-1)\n", - " num_points_in_integral = domain_mask.sum(dim=-1)\n", - " base_point_mask = self._get_base_point_mask(ball_around_X).prod(dim=-1)\n", - " prob = self._estimate_probabilities_of_satisfaction_at_points(ball_around_X)\n", - " masked_prob = prob * domain_mask * base_point_mask\n", - " y = masked_prob.sum(dim=-1) / num_points_in_integral\n", - " return y" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489234035, - "executionStopTime": 1638489234089, - "hidden_ranges": [], - "originalKey": "b56e4297-9927-4a5e-aa8f-f5e93181e44d", - "requestMsgId": "b56e4297-9927-4a5e-aa8f-f5e93181e44d" - }, - "outputs": [], - "source": [ - "def get_and_fit_gp(X, Y):\n", - " \"\"\"Simple method for creating a GP with one output dimension.\n", - "\n", - " X is assumed to be in [0, 1]^d.\n", - " \"\"\"\n", - " assert Y.ndim == 2 and Y.shape[-1] == 1\n", - " likelihood = GaussianLikelihood(noise_constraint=Interval(1e-6, 1e-3)) # Noise-free\n", - " octf = Standardize(m=1)\n", - " gp = SingleTaskGP(X, Y, likelihood=likelihood, outcome_transform=octf)\n", - " mll = ExactMarginalLogLikelihood(model=gp, likelihood=gp.likelihood)\n", - " fit_gpytorch_mll(mll)\n", - " return gp" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "hidden_ranges": [], - "originalKey": "e7c7c1b3-249f-4e32-b8b7-3c7e737e82b2", - "showInput": false - }, - "source": [ - "### Simple 1D function\n", - "\n", - "To sanity check things, we consider the ECI acquisition function on a one-dimensional toy problem. " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "executionStartTime": 1638489234145, - "executionStopTime": 1638489234200, - "originalKey": "cc435c3c-c65f-4446-a33e-fd5cda030962", - "requestMsgId": "cc435c3c-c65f-4446-a33e-fd5cda030962" - }, - "outputs": [], - "source": [ - "def yf(x):\n", - " return (1 - torch.exp(-4 * (x[:, 0] - 0.4) ** 2)).unsqueeze(-1)\n", - "\n", - "\n", - "x = torch.tensor([0, 0.15, 0.25, 0.4, 0.8, 1.0], **tkwargs).unsqueeze(-1)\n", - "y = yf(x)\n", - "xx = torch.linspace(0, 1, 200, **tkwargs).unsqueeze(-1)\n", - "yy = yf(xx)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "8bbfe7b8-b758-424a-b6bc-f2c91f8b1e95", - "showInput": false - }, - "source": [ - "### Create an ECI acquisition function\n", - "Our implementation assumes that the GP is passed in as a `ModelListGP` and that the GPs match the corresponding constraints. As an example, assume we have two outputs, represented by `gp1` and `gp2` and two constraints corresponding to output 1 and a third constraint corresponding to output 2. In that case we will create a model list GP as `ModelListGP(gp1, gp1, gp2)` so they match the constraints." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489234253, - "executionStopTime": 1638489235584, - "hidden_ranges": [], - "originalKey": "9efe991c-8256-4c7c-b61f-8abb5d258d40", - "requestMsgId": "9efe991c-8256-4c7c-b61f-8abb5d258d40" - }, - "outputs": [], - "source": [ - "gp = get_and_fit_gp(x, y)\n", - "model_list_gp = ModelListGP(gp, gp)\n", - "constraints = [(\"lt\", 0.3), (\"gt\", 0.05)]\n", - "punchout_radius = 0.03\n", - "bounds = torch.tensor([(0, 1)], **tkwargs).T\n", - "eci = ExpectedCoverageImprovement(\n", - " model=model_list_gp,\n", - " constraints=constraints,\n", - " punchout_radius=punchout_radius,\n", - " bounds=bounds,\n", - " num_samples=128 if not SMOKE_TEST else 4,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "f1cfa2a0-db3f-49a2-b32f-6fad380b0c3e", - "showInput": false - }, - "source": [ - "### Optimize the acquisition function" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489235787, - "executionStopTime": 1638489236864, - "hidden_ranges": [], - "originalKey": "1ae10691-8d4e-40e7-8c32-f15a35ddf590", - "requestMsgId": "1ae10691-8d4e-40e7-8c32-f15a35ddf590", - "showInput": true - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best candidate: 0.617\n" - ] - } - ], - "source": [ - "best_candidate, best_eci_value = optimize_acqf(\n", - " acq_function=eci,\n", - " bounds=torch.tensor([[0.0], [1.0]], **tkwargs),\n", - " q=1,\n", - " num_restarts=10,\n", - " raw_samples=20, # use a small number here to make sure the optimization works\n", - ")\n", - "print(f\"Best candidate: {best_candidate.cpu().item():.3f}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "15a4d7cf-be03-4e52-9792-e3a680f37bb7", - "showInput": false - }, - "source": [ - "### Plot the GP and the ECI acquisition function\n", - "The left plot shows the GP posterior with a 95% confidence interval. The two horizontal lines indicate the feasible region defined by $0.05 \\leq f(x) \\leq 0.3$. These inequality constraints implicitly define a feasible region, outside which ECI has value zero. \n", - "\n", - "We can see in the right plot that ECI indeed has a nonzero value inside the feasible region and a zero value outside. We also optimize the acquisition function and mark its argmax with black star; the argmax is around $x=0.62$. This is reasonable because ECI seeks to select diverse points within the feasible region. $x=0.62$ is far away from other evaluations and thus has the highest diversity. " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489236964, - "executionStopTime": 1638489237535, - "hidden_ranges": [], - "originalKey": "5f5b4b6a-4d53-4528-8420-53e4f9358f5c", - "requestMsgId": "5f5b4b6a-4d53-4528-8420-53e4f9358f5c" - }, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489228284, + "executionStopTime": 1638489229640, + "hidden_ranges": [], + "originalKey": "9896cb02-0d0e-498f-bdf7-86ea14baaf40", + "requestMsgId": "9896cb02-0d0e-498f-bdf7-86ea14baaf40" + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import torch\n", + "from botorch.acquisition.monte_carlo import MCAcquisitionFunction\n", + "from botorch.acquisition.objective import IdentityMCObjective\n", + "from botorch.fit import fit_gpytorch_mll\n", + "from botorch.models import ModelListGP, SingleTaskGP\n", + "from botorch.models.transforms.outcome import Standardize\n", + "from botorch.optim import optimize_acqf\n", + "from botorch.utils.sampling import sample_hypersphere\n", + "from botorch.utils.transforms import t_batch_mode_transform\n", + "from gpytorch.constraints import Interval\n", + "from gpytorch.likelihoods import GaussianLikelihood\n", + "from gpytorch.mlls import ExactMarginalLogLikelihood\n", + "from torch.quasirandom import SobolEngine\n", + "\n", + "\n", + "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")" + ] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489229684, + "executionStopTime": 1638489230490, + "hidden_ranges": [], + "originalKey": "b4b78cb1-b0d4-4203-a97b-7a293ea418d4", + "requestMsgId": "b4b78cb1-b0d4-4203-a97b-7a293ea418d4" + }, + "outputs": [], + "source": [ + "tkwargs = {\n", + " \"device\": torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n", + " \"dtype\": torch.double,\n", + "}" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "with torch.no_grad():\n", - " posterior = gp.posterior(X=xx.unsqueeze(1))\n", - "ymean, yvar = posterior.mean.squeeze(-1), posterior.variance.squeeze(-1)\n", - "eci_vals = eci(xx.unsqueeze(1))\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", - "ax = axes[0]\n", - "ax.plot(xx[:, 0].cpu(), ymean[:, 0].cpu(), \"b\")\n", - "ax.fill_between(\n", - " xx[:, 0].cpu(),\n", - " ymean[:, 0].cpu() - 1.96 * yvar[:, 0].sqrt().cpu(),\n", - " ymean[:, 0].cpu() + 1.96 * yvar[:, 0].sqrt().cpu(),\n", - " alpha=0.1,\n", - " color=\"b\",\n", - ")\n", - "ax.plot(x[:, 0].cpu(), y[:, 0].cpu(), \"or\")\n", - "ax.axhline(0.05, 0, 1)\n", - "ax.axhline(0.3, 0, 1)\n", - "\n", - "ax = axes[1]\n", - "ax.plot(xx[:, 0].cpu(), eci_vals.detach().cpu())\n", - "ax.plot(x[:, 0].cpu(), torch.zeros(len(x), **tkwargs).cpu(), \"or\")\n", - "ax.plot(best_candidate.cpu(), best_eci_value.cpu(), \"*k\", ms=10)\n", - "ax.set_title(\"ECI\", fontsize=14)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "hidden_ranges": [], - "originalKey": "33ea647e-bdaf-4264-ab65-3e6df4ba8c6e", - "showInput": false - }, - "source": [ - "## Full 2D CAS-loop \n", - "This creates a simple function with two outputs that we will consider under the two constraints $f_1(x) \\leq 0.75$ and $f_2(x) \\geq 0.55$. In this particular example, the $f_1(x)$ and $f_2(x)$ are same function for simplicity. \n", - "\n", - "The CAS loop follows the prototypical BO loop: \n", - "1. Given a surrogate model, maximize ECI to select the next evaluation x.\n", - "2. Observe f(x).\n", - "3. Update the surrogate model. " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489237543, - "executionStopTime": 1638489237685, - "hidden_ranges": [], - "originalKey": "691460ed-a2c8-45b5-8dc9-c6d8c87ee9d7", - "requestMsgId": "691460ed-a2c8-45b5-8dc9-c6d8c87ee9d7" - }, - "outputs": [], - "source": [ - "def yf2d(x):\n", - " v = torch.exp(-2 * (x[:, 0] - 0.3) ** 2 - 4 * (x[:, 1] - 0.6) ** 2)\n", - " return torch.stack((v, v), dim=-1)\n", - "\n", - "\n", - "bounds = torch.tensor([[0, 0], [1, 1]], **tkwargs)\n", - "lb, ub = bounds\n", - "dim = len(lb)\n", - "constraints = [(\"lt\", 0.75), (\"gt\", 0.55)]\n", - "punchout_radius = 0.1" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "originalKey": "6f354b25-8703-4156-908d-d53c1c2bbe4a", - "showInput": false - }, - "source": [ - "### CAS loop using 5 initial Sobol points and 15 ECI iterations" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489237803, - "executionStopTime": 1638489266352, - "hidden_ranges": [], - "originalKey": "6d77353b-8dda-4835-9c6a-b0a53fddc67c", - "requestMsgId": "6d77353b-8dda-4835-9c6a-b0a53fddc67c" - }, - "outputs": [], - "source": [ - "num_init_points = 5\n", - "num_total_points = 15 if not SMOKE_TEST else 5\n", - "\n", - "X = lb + (ub - lb) * SobolEngine(dim, scramble=True).draw(num_init_points).to(**tkwargs)\n", - "Y = yf2d(X)\n", - "\n", - "while len(X) < num_total_points:\n", - " # We don't have to normalize X since the domain is [0, 1]^2. Make sure to\n", - " # appropriately adjust the punchout radius if the domain is normalized.\n", - " gp_models = [get_and_fit_gp(X, Y[:, i : i + 1]) for i in range(Y.shape[-1])]\n", - " model_list_gp = ModelListGP(gp_models[0], gp_models[1])\n", - " eci = ExpectedCoverageImprovement(\n", - " model=model_list_gp,\n", - " constraints=constraints,\n", - " punchout_radius=punchout_radius,\n", - " bounds=bounds,\n", - " num_samples=128 if not SMOKE_TEST else 4,\n", - " )\n", - " x_next, _ = optimize_acqf(\n", - " acq_function=eci,\n", - " bounds=bounds,\n", - " q=1,\n", - " num_restarts=10 if not SMOKE_TEST else 2,\n", - " raw_samples=512 if not SMOKE_TEST else 4,\n", - " )\n", - " y_next = yf2d(x_next)\n", - " X = torch.cat((X, x_next))\n", - " Y = torch.cat((Y, y_next))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "hidden_ranges": [], - "originalKey": "255bba4f-4d9a-46cc-aa66-16b90287824a", - "showInput": false - }, - "source": [ - "### Plot the selected points\n", - "We plot the feasible region and the points selected by ECI below. The feasible region is outlined with a black ring, and points selected by ECI are marked in green (feasible) and red (infeasible). By design, observe that ECI selects a diverse i.e., well-spaced set of points inside the feasible region. " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "code_folding": [], - "customInput": null, - "executionStartTime": 1638489266464, - "executionStopTime": 1638489266516, - "hidden_ranges": [], - "originalKey": "6b62af84-01c0-4971-9122-bd5f01b9f31b", - "requestMsgId": "6b62af84-01c0-4971-9122-bd5f01b9f31b", - "showInput": true - }, - "outputs": [ + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/deriksson/opt/anaconda3/lib/python3.9/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/TensorShape.cpp:3191.)\n", - " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" - ] - } - ], - "source": [ - "N1, N2 = 30, 30\n", - "Xplt, Yplt = torch.meshgrid(\n", - " torch.linspace(0, 1, N1, **tkwargs), torch.linspace(0, 1, N2, **tkwargs)\n", - ")\n", - "xplt = torch.stack(\n", - " (\n", - " torch.reshape(Xplt, (Xplt.shape[0] * Xplt.shape[1],)),\n", - " torch.reshape(Yplt, (Yplt.shape[0] * Yplt.shape[1],)),\n", - " ),\n", - " dim=1,\n", - ")\n", - "yplt = yf2d(xplt)\n", - "Zplt = torch.reshape(yplt[:, 0], (N1, N2)) # Since f1(x) = f2(x)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "code_folding": [], - "executionStartTime": 1638489266564, - "executionStopTime": 1638489267143, - "hidden_ranges": [], - "originalKey": "a44c258c-0373-4c68-9887-9ae7a57bcccc", - "requestMsgId": "a44c258c-0373-4c68-9887-9ae7a57bcccc" - }, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "hidden_ranges": [], + "originalKey": "e9cecfd7-f548-4b66-8009-c97809afc144", + "showInput": false + }, + "source": [ + "To start, we need to be able to sample points in $\\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)$. We can generate a pool of points and use standard rejection sampling to do so, but this leads to an acquisition function that isn't immediately differentiable; rejection sampling is essentially providing either a binary weight of either 0 or 1 to each point in the sample pool, which is not a differentiable function. \n", + "\n", + "\n", + "In order to make the acquisition function differentiable, we rely on a differentiable approximation of this binary weight function. For example, `smooth_box_mask` is a continuous differentiable approximation of $a < x < b$ (see the plot below for a visualization). A larger value of eps will make the sigmoid less steep and result in a smoother (and easier to optimize) but less accurate acquisition function. " + ] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 3, + "metadata": { + "executionStartTime": 1638489230493, + "executionStopTime": 1638489230509, + "originalKey": "63c0a300-c3a1-49bb-a6ba-41cf9dfa9632", + "requestMsgId": "63c0a300-c3a1-49bb-a6ba-41cf9dfa9632" + }, + "outputs": [], + "source": [ + "def smooth_mask(x, a, eps=2e-3):\n", + " \"\"\"Returns 0ish for x < a and 1ish for x > a\"\"\"\n", + " return torch.nn.Sigmoid()((x - a) / eps)\n", + "\n", + "\n", + "def smooth_box_mask(x, a, b, eps=2e-3):\n", + " \"\"\"Returns 1ish for a < x < b and 0ish otherwise\"\"\"\n", + " return smooth_mask(x, a, eps) - smooth_mask(x, b, eps)" ] - }, - "metadata": {}, - "output_type": "display_data" + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489230587, + "executionStopTime": 1638489233802, + "hidden_ranges": [], + "originalKey": "7b49f71b-f131-4600-96fd-5aa581212202", + "requestMsgId": "7b49f71b-f131-4600-96fd-5aa581212202" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "\n", + "\n", + "x = torch.linspace(-2, 2, 500, **tkwargs)\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(8, 4))\n", + "ax[0].plot(x.cpu(), smooth_mask(x, -1).cpu(), \"b\")\n", + "ax[1].plot(x.cpu(), smooth_box_mask(x, -1, 1).cpu(), \"b\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "hidden_ranges": [], + "originalKey": "7ff5ed82-355b-45b8-91f9-823c41c46efc", + "showInput": false + }, + "source": [ + "## Implementation of ECI\n", + "\n", + "Once we have defined our smooth mask functions, we can compute a differentiable approximation of ECI in a straightforward manner using Monte Carlo (MC). We use the popular variance reduction technique of Common random numbers (CRN).\n", + "\n", + "We first use a low discrepancy sequence to generate a set of base samples. We integrate (sum) over these base samples to approximate the ECI acquisition function. Fixing these base samples makes the method deterministic and by using the smooth masks defined earlier, we can filter out infeasible points while still having a differentiable acquisition function.\n", + "\n", + "This implementation assumes that the GP models for the different outputs are independent and that each constraints only affects one output (simple box-constraints like f(x) <= 0.5)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489233910, + "executionStopTime": 1638489233950, + "hidden_ranges": [], + "originalKey": "5dd0a6af-0bde-4e57-8bdd-d53baea75075", + "requestMsgId": "5dd0a6af-0bde-4e57-8bdd-d53baea75075" + }, + "outputs": [], + "source": [ + "class ExpectedCoverageImprovement(MCAcquisitionFunction):\n", + " def __init__(\n", + " self,\n", + " model,\n", + " constraints,\n", + " punchout_radius,\n", + " bounds,\n", + " num_samples=128,\n", + " **kwargs,\n", + " ):\n", + " \"\"\"Expected Coverage Improvement (q=1 required, analytic)\n", + "\n", + " Right now, we assume that all the models in the ModelListGP have\n", + " the same training inputs.\n", + "\n", + " Args:\n", + " model: A ModelListGP object containing models matching the corresponding constraints.\n", + " All models are assumed to have the same training data.\n", + " constraints: List containing 2-tuples with (direction, value), e.g.,\n", + " [('gt', 3), ('lt', 4)]. It is necessary that\n", + " len(constraints) == model.num_outputs.\n", + " punchout_radius: Positive value defining the desired minimum distance between points\n", + " bounds: torch.tensor whose first row is the lower bounds and second row is the upper bounds\n", + " num_samples: Number of samples for MC integration\n", + " \"\"\"\n", + " super().__init__(model=model, objective=IdentityMCObjective(), **kwargs)\n", + " assert len(constraints) == model.num_outputs\n", + " assert all(direction in (\"gt\", \"lt\") for direction, _ in constraints)\n", + " assert punchout_radius > 0\n", + " self.constraints = constraints\n", + " self.punchout_radius = punchout_radius\n", + " self.bounds = bounds\n", + " self.base_points = self.train_inputs\n", + " self.ball_of_points = self._generate_ball_of_points(\n", + " num_samples=num_samples,\n", + " radius=punchout_radius,\n", + " device=bounds.device,\n", + " dtype=bounds.dtype,\n", + " )\n", + " self._thresholds = torch.tensor(\n", + " [threshold for _, threshold in self.constraints]\n", + " ).to(bounds)\n", + " assert (\n", + " all(ub > lb for lb, ub in self.bounds.T) and len(self.bounds.T) == self.dim\n", + " )\n", + "\n", + " @property\n", + " def num_outputs(self):\n", + " return self.model.num_outputs\n", + "\n", + " @property\n", + " def dim(self):\n", + " return self.train_inputs.shape[-1]\n", + "\n", + " @property\n", + " def train_inputs(self):\n", + " return self.model.models[0].train_inputs[0]\n", + "\n", + " def _generate_ball_of_points(\n", + " self, num_samples, radius, device=None, dtype=torch.double\n", + " ):\n", + " \"\"\"Creates a ball of points to be used for MC.\"\"\"\n", + " tkwargs = {\"device\": device, \"dtype\": dtype}\n", + " z = sample_hypersphere(d=self.dim, n=num_samples, qmc=True, **tkwargs)\n", + " r = torch.rand(num_samples, 1, **tkwargs) ** (1 / self.dim)\n", + " return radius * r * z\n", + "\n", + " def _get_base_point_mask(self, X):\n", + " distance_matrix = self.model.models[0].covar_module.base_kernel.covar_dist(\n", + " X, self.base_points\n", + " )\n", + " return smooth_mask(distance_matrix, self.punchout_radius)\n", + "\n", + " def _estimate_probabilities_of_satisfaction_at_points(self, points):\n", + " \"\"\"Estimate the probability of satisfying the given constraints.\"\"\"\n", + " posterior = self.model.posterior(X=points)\n", + " mus, sigma2s = posterior.mean, posterior.variance\n", + " dist = torch.distributions.normal.Normal(mus, sigma2s.sqrt())\n", + " norm_cdf = dist.cdf(self._thresholds)\n", + " probs = torch.ones(points.shape[:-1]).to(points)\n", + " for i, (direction, _) in enumerate(self.constraints):\n", + " probs = probs * (\n", + " norm_cdf[..., i] if direction == \"lt\" else 1 - norm_cdf[..., i]\n", + " )\n", + " return probs\n", + "\n", + " @t_batch_mode_transform(expected_q=1)\n", + " def forward(self, X):\n", + " \"\"\"Evaluate Expected Improvement on the candidate set X.\"\"\"\n", + " ball_around_X = self.ball_of_points + X\n", + " domain_mask = smooth_box_mask(\n", + " ball_around_X, self.bounds[0, :], self.bounds[1, :]\n", + " ).prod(dim=-1)\n", + " num_points_in_integral = domain_mask.sum(dim=-1)\n", + " base_point_mask = self._get_base_point_mask(ball_around_X).prod(dim=-1)\n", + " prob = self._estimate_probabilities_of_satisfaction_at_points(ball_around_X)\n", + " masked_prob = prob * domain_mask * base_point_mask\n", + " y = masked_prob.sum(dim=-1) / num_points_in_integral\n", + " return y" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489234035, + "executionStopTime": 1638489234089, + "hidden_ranges": [], + "originalKey": "b56e4297-9927-4a5e-aa8f-f5e93181e44d", + "requestMsgId": "b56e4297-9927-4a5e-aa8f-f5e93181e44d" + }, + "outputs": [], + "source": [ + "def get_and_fit_gp(X, Y):\n", + " \"\"\"Simple method for creating a GP with one output dimension.\n", + "\n", + " X is assumed to be in [0, 1]^d.\n", + " \"\"\"\n", + " assert Y.ndim == 2 and Y.shape[-1] == 1\n", + " likelihood = GaussianLikelihood(noise_constraint=Interval(1e-6, 1e-3)) # Noise-free\n", + " octf = Standardize(m=1)\n", + " gp = SingleTaskGP(X, Y, likelihood=likelihood, outcome_transform=octf)\n", + " mll = ExactMarginalLogLikelihood(model=gp, likelihood=gp.likelihood)\n", + " fit_gpytorch_mll(mll)\n", + " return gp" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "hidden_ranges": [], + "originalKey": "e7c7c1b3-249f-4e32-b8b7-3c7e737e82b2", + "showInput": false + }, + "source": [ + "### Simple 1D function\n", + "\n", + "To sanity check things, we consider the ECI acquisition function on a one-dimensional toy problem. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "executionStartTime": 1638489234145, + "executionStopTime": 1638489234200, + "originalKey": "cc435c3c-c65f-4446-a33e-fd5cda030962", + "requestMsgId": "cc435c3c-c65f-4446-a33e-fd5cda030962" + }, + "outputs": [], + "source": [ + "def yf(x):\n", + " return (1 - torch.exp(-4 * (x[:, 0] - 0.4) ** 2)).unsqueeze(-1)\n", + "\n", + "\n", + "x = torch.tensor([0, 0.15, 0.25, 0.4, 0.8, 1.0], **tkwargs).unsqueeze(-1)\n", + "y = yf(x)\n", + "xx = torch.linspace(0, 1, 200, **tkwargs).unsqueeze(-1)\n", + "yy = yf(xx)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "originalKey": "8bbfe7b8-b758-424a-b6bc-f2c91f8b1e95", + "showInput": false + }, + "source": [ + "### Create an ECI acquisition function\n", + "Our implementation assumes that the GP is passed in as a `ModelListGP` and that the GPs match the corresponding constraints. As an example, assume we have two outputs, represented by `gp1` and `gp2` and two constraints corresponding to output 1 and a third constraint corresponding to output 2. In that case we will create a model list GP as `ModelListGP(gp1, gp1, gp2)` so they match the constraints." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489234253, + "executionStopTime": 1638489235584, + "hidden_ranges": [], + "originalKey": "9efe991c-8256-4c7c-b61f-8abb5d258d40", + "requestMsgId": "9efe991c-8256-4c7c-b61f-8abb5d258d40" + }, + "outputs": [], + "source": [ + "gp = get_and_fit_gp(x, y)\n", + "model_list_gp = ModelListGP(gp, gp)\n", + "constraints = [(\"lt\", 0.3), (\"gt\", 0.05)]\n", + "punchout_radius = 0.03\n", + "bounds = torch.tensor([(0, 1)], **tkwargs).T\n", + "eci = ExpectedCoverageImprovement(\n", + " model=model_list_gp,\n", + " constraints=constraints,\n", + " punchout_radius=punchout_radius,\n", + " bounds=bounds,\n", + " num_samples=128 if not SMOKE_TEST else 4,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "originalKey": "f1cfa2a0-db3f-49a2-b32f-6fad380b0c3e", + "showInput": false + }, + "source": [ + "### Optimize the acquisition function" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489235787, + "executionStopTime": 1638489236864, + "hidden_ranges": [], + "originalKey": "1ae10691-8d4e-40e7-8c32-f15a35ddf590", + "requestMsgId": "1ae10691-8d4e-40e7-8c32-f15a35ddf590", + "showInput": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best candidate: 0.617\n" + ] + } + ], + "source": [ + "best_candidate, best_eci_value = optimize_acqf(\n", + " acq_function=eci,\n", + " bounds=torch.tensor([[0.0], [1.0]], **tkwargs),\n", + " q=1,\n", + " num_restarts=10,\n", + " raw_samples=20, # use a small number here to make sure the optimization works\n", + ")\n", + "print(f\"Best candidate: {best_candidate.cpu().item():.3f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "originalKey": "15a4d7cf-be03-4e52-9792-e3a680f37bb7", + "showInput": false + }, + "source": [ + "### Plot the GP and the ECI acquisition function\n", + "The left plot shows the GP posterior with a 95% confidence interval. The two horizontal lines indicate the feasible region defined by $0.05 \\leq f(x) \\leq 0.3$. These inequality constraints implicitly define a feasible region, outside which ECI has value zero. \n", + "\n", + "We can see in the right plot that ECI indeed has a nonzero value inside the feasible region and a zero value outside. We also optimize the acquisition function and mark its argmax with black star; the argmax is around $x=0.62$. This is reasonable because ECI seeks to select diverse points within the feasible region. $x=0.62$ is far away from other evaluations and thus has the highest diversity. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489236964, + "executionStopTime": 1638489237535, + "hidden_ranges": [], + "originalKey": "5f5b4b6a-4d53-4528-8420-53e4f9358f5c", + "requestMsgId": "5f5b4b6a-4d53-4528-8420-53e4f9358f5c" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with torch.no_grad():\n", + " posterior = gp.posterior(X=xx.unsqueeze(1))\n", + "ymean, yvar = posterior.mean.squeeze(-1), posterior.variance.squeeze(-1)\n", + "eci_vals = eci(xx.unsqueeze(1))\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "ax = axes[0]\n", + "ax.plot(xx[:, 0].cpu(), ymean[:, 0].cpu(), \"b\")\n", + "ax.fill_between(\n", + " xx[:, 0].cpu(),\n", + " ymean[:, 0].cpu() - 1.96 * yvar[:, 0].sqrt().cpu(),\n", + " ymean[:, 0].cpu() + 1.96 * yvar[:, 0].sqrt().cpu(),\n", + " alpha=0.1,\n", + " color=\"b\",\n", + ")\n", + "ax.plot(x[:, 0].cpu(), y[:, 0].cpu(), \"or\")\n", + "ax.axhline(0.05, 0, 1)\n", + "ax.axhline(0.3, 0, 1)\n", + "\n", + "ax = axes[1]\n", + "ax.plot(xx[:, 0].cpu(), eci_vals.detach().cpu())\n", + "ax.plot(x[:, 0].cpu(), torch.zeros(len(x), **tkwargs).cpu(), \"or\")\n", + "ax.plot(best_candidate.cpu(), best_eci_value.cpu(), \"*k\", ms=10)\n", + "ax.set_title(\"ECI\", fontsize=14)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "hidden_ranges": [], + "originalKey": "33ea647e-bdaf-4264-ab65-3e6df4ba8c6e", + "showInput": false + }, + "source": [ + "## Full 2D CAS-loop \n", + "This creates a simple function with two outputs that we will consider under the two constraints $f_1(x) \\leq 0.75$ and $f_2(x) \\geq 0.55$. In this particular example, the $f_1(x)$ and $f_2(x)$ are same function for simplicity. \n", + "\n", + "The CAS loop follows the prototypical BO loop: \n", + "1. Given a surrogate model, maximize ECI to select the next evaluation x.\n", + "2. Observe f(x).\n", + "3. Update the surrogate model. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489237543, + "executionStopTime": 1638489237685, + "hidden_ranges": [], + "originalKey": "691460ed-a2c8-45b5-8dc9-c6d8c87ee9d7", + "requestMsgId": "691460ed-a2c8-45b5-8dc9-c6d8c87ee9d7" + }, + "outputs": [], + "source": [ + "def yf2d(x):\n", + " v = torch.exp(-2 * (x[:, 0] - 0.3) ** 2 - 4 * (x[:, 1] - 0.6) ** 2)\n", + " return torch.stack((v, v), dim=-1)\n", + "\n", + "\n", + "bounds = torch.tensor([[0, 0], [1, 1]], **tkwargs)\n", + "lb, ub = bounds\n", + "dim = len(lb)\n", + "constraints = [(\"lt\", 0.75), (\"gt\", 0.55)]\n", + "punchout_radius = 0.1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "originalKey": "6f354b25-8703-4156-908d-d53c1c2bbe4a", + "showInput": false + }, + "source": [ + "### CAS loop using 5 initial Sobol points and 15 ECI iterations" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489237803, + "executionStopTime": 1638489266352, + "hidden_ranges": [], + "originalKey": "6d77353b-8dda-4835-9c6a-b0a53fddc67c", + "requestMsgId": "6d77353b-8dda-4835-9c6a-b0a53fddc67c" + }, + "outputs": [], + "source": [ + "num_init_points = 5\n", + "num_total_points = 15 if not SMOKE_TEST else 5\n", + "\n", + "X = lb + (ub - lb) * SobolEngine(dim, scramble=True).draw(num_init_points).to(**tkwargs)\n", + "Y = yf2d(X)\n", + "\n", + "while len(X) < num_total_points:\n", + " # We don't have to normalize X since the domain is [0, 1]^2. Make sure to\n", + " # appropriately adjust the punchout radius if the domain is normalized.\n", + " gp_models = [get_and_fit_gp(X, Y[:, i : i + 1]) for i in range(Y.shape[-1])]\n", + " model_list_gp = ModelListGP(gp_models[0], gp_models[1])\n", + " eci = ExpectedCoverageImprovement(\n", + " model=model_list_gp,\n", + " constraints=constraints,\n", + " punchout_radius=punchout_radius,\n", + " bounds=bounds,\n", + " num_samples=128 if not SMOKE_TEST else 4,\n", + " )\n", + " x_next, _ = optimize_acqf(\n", + " acq_function=eci,\n", + " bounds=bounds,\n", + " q=1,\n", + " num_restarts=10 if not SMOKE_TEST else 2,\n", + " raw_samples=512 if not SMOKE_TEST else 4,\n", + " )\n", + " y_next = yf2d(x_next)\n", + " X = torch.cat((X, x_next))\n", + " Y = torch.cat((Y, y_next))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "hidden_ranges": [], + "originalKey": "255bba4f-4d9a-46cc-aa66-16b90287824a", + "showInput": false + }, + "source": [ + "### Plot the selected points\n", + "We plot the feasible region and the points selected by ECI below. The feasible region is outlined with a black ring, and points selected by ECI are marked in green (feasible) and red (infeasible). By design, observe that ECI selects a diverse i.e., well-spaced set of points inside the feasible region. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "code_folding": [], + "customInput": null, + "executionStartTime": 1638489266464, + "executionStopTime": 1638489266516, + "hidden_ranges": [], + "originalKey": "6b62af84-01c0-4971-9122-bd5f01b9f31b", + "requestMsgId": "6b62af84-01c0-4971-9122-bd5f01b9f31b", + "showInput": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/deriksson/opt/anaconda3/lib/python3.9/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/TensorShape.cpp:3191.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ] + } + ], + "source": [ + "N1, N2 = 30, 30\n", + "Xplt, Yplt = torch.meshgrid(\n", + " torch.linspace(0, 1, N1, **tkwargs), torch.linspace(0, 1, N2, **tkwargs)\n", + ")\n", + "xplt = torch.stack(\n", + " (\n", + " torch.reshape(Xplt, (Xplt.shape[0] * Xplt.shape[1],)),\n", + " torch.reshape(Yplt, (Yplt.shape[0] * Yplt.shape[1],)),\n", + " ),\n", + " dim=1,\n", + ")\n", + "yplt = yf2d(xplt)\n", + "Zplt = torch.reshape(yplt[:, 0], (N1, N2)) # Since f1(x) = f2(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "code_folding": [], + "executionStartTime": 1638489266564, + "executionStopTime": 1638489267143, + "hidden_ranges": [], + "originalKey": "a44c258c-0373-4c68-9887-9ae7a57bcccc", + "requestMsgId": "a44c258c-0373-4c68-9887-9ae7a57bcccc" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def identify_samples_which_satisfy_constraints(X, constraints):\n", + " \"\"\"\n", + " Takes in values (a1, ..., ak, o) and returns (a1, ..., ak, o)\n", + " True/False values, where o is the number of outputs.\n", + " \"\"\"\n", + " successful = torch.ones(X.shape).to(X)\n", + " for model_index in range(X.shape[-1]):\n", + " these_X = X[..., model_index]\n", + " direction, value = constraints[model_index]\n", + " successful[..., model_index] = (\n", + " these_X < value if direction == \"lt\" else these_X > value\n", + " )\n", + " return successful\n", + "\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "h1 = ax.contourf(Xplt.cpu().numpy(), Yplt.cpu().numpy(), Zplt.cpu().numpy(), 20, cmap=\"Blues\", alpha=0.6)\n", + "fig.colorbar(h1)\n", + "ax.contour(Xplt.cpu().numpy(), Yplt.cpu().numpy(), Zplt.cpu().numpy(), [0.55, 0.75], colors=\"k\")\n", + "\n", + "feasible_inds = (\n", + " identify_samples_which_satisfy_constraints(Y, constraints)\n", + " .prod(dim=-1)\n", + " .to(torch.bool)\n", + ")\n", + "ax.plot(X[feasible_inds, 0].cpu(), X[feasible_inds, 1].cpu(), \"sg\", label=\"Feasible\")\n", + "ax.plot(\n", + " X[~feasible_inds, 0].cpu(), X[~feasible_inds, 1].cpu(), \"sr\", label=\"Infeasible\"\n", + ")\n", + "\n", + "ax.legend(loc=[0.7, 0.05])\n", + "ax.set_title(\"$f_1(x)$\") # Recall that f1(x) = f2(x)\n", + "ax.set_xlabel(\"$x_1$\")\n", + "ax.set_ylabel(\"$x_2$\")\n", + "ax.set_aspect(\"equal\", \"box\")\n", + "ax.set_xlim([-0.05, 1.05])\n", + "ax.set_ylim([-0.05, 1.05])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "executionStartTime": 1638489267152, + "executionStopTime": 1638489267253, + "originalKey": "0ff4a95d-b556-4a21-b794-184ba4181a49", + "requestMsgId": "0ff4a95d-b556-4a21-b794-184ba4181a49" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "fileHeader": "", + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" } - ], - "source": [ - "def identify_samples_which_satisfy_constraints(X, constraints):\n", - " \"\"\"\n", - " Takes in values (a1, ..., ak, o) and returns (a1, ..., ak, o)\n", - " True/False values, where o is the number of outputs.\n", - " \"\"\"\n", - " successful = torch.ones(X.shape).to(X)\n", - " for model_index in range(X.shape[-1]):\n", - " these_X = X[..., model_index]\n", - " direction, value = constraints[model_index]\n", - " successful[..., model_index] = (\n", - " these_X < value if direction == \"lt\" else these_X > value\n", - " )\n", - " return successful\n", - "\n", - "\n", - "fig, ax = plt.subplots(figsize=(8, 6))\n", - "h1 = ax.contourf(Xplt.cpu(), Yplt.cpu(), Zplt.cpu(), 20, cmap=\"Blues\", alpha=0.6)\n", - "fig.colorbar(h1)\n", - "ax.contour(Xplt.cpu(), Yplt.cpu(), Zplt.cpu(), [0.55, 0.75], colors=\"k\")\n", - "\n", - "feasible_inds = (\n", - " identify_samples_which_satisfy_constraints(Y, constraints)\n", - " .prod(dim=-1)\n", - " .to(torch.bool)\n", - ")\n", - "ax.plot(X[feasible_inds, 0].cpu(), X[feasible_inds, 1].cpu(), \"sg\", label=\"Feasible\")\n", - "ax.plot(\n", - " X[~feasible_inds, 0].cpu(), X[~feasible_inds, 1].cpu(), \"sr\", label=\"Infeasible\"\n", - ")\n", - "\n", - "ax.legend(loc=[0.7, 0.05])\n", - "ax.set_title(\"$f_1(x)$\") # Recall that f1(x) = f2(x)\n", - "ax.set_xlabel(\"$x_1$\")\n", - "ax.set_ylabel(\"$x_2$\")\n", - "ax.set_aspect(\"equal\", \"box\")\n", - "ax.set_xlim([-0.05, 1.05])\n", - "ax.set_ylim([-0.05, 1.05])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "executionStartTime": 1638489267152, - "executionStopTime": 1638489267253, - "originalKey": "0ff4a95d-b556-4a21-b794-184ba4181a49", - "requestMsgId": "0ff4a95d-b556-4a21-b794-184ba4181a49" - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.13" }, - "last_base_url": "https://devbig817.ftw3.facebook.com:8090/", - "last_kernel_id": "ba747f89-a0e6-4fdb-a721-148575d9f682", - "last_msg_id": "9348e824-cc9a852b6869f3ed90e3b43a_20", - "last_server_session_id": "bd522e7f-adef-4216-87c7-6d760f7f96ff", - "outputWidgetContext": {} - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 2 } diff --git a/tutorials/saasbo.ipynb b/tutorials/saasbo.ipynb index 541074a422..d0fc6efe96 100644 --- a/tutorials/saasbo.ipynb +++ b/tutorials/saasbo.ipynb @@ -1,794 +1,792 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "501041cc-0473-4971-bff9-fd6e92e1eae4", - "showInput": false - }, - "source": [ - "## High-Dimensional sample-efficient Bayesian Optimization with SAASBO\n", - "\n", - "This tutorial shows how to use the Sparse Axis-Aligned Subspace Bayesian Optimization (SAASBO) \n", - "method for high-dimensional Bayesian optimization [1]. SAASBO places strong priors on the \n", - "inverse lengthscales to avoid overfitting in high-dimensional spaces. Specifically, SAASBO \n", - "uses a hierarchical sparsity prior consisting of a global shrinkage parameter \n", - "$\\tau \\sim \\mathcal{HC}(\\beta)$ and inverse lengthscales $\\rho_d \\sim \\mathcal{HC}(\\tau)$ \n", - "for $d=1, \\ldots, D$, where $\\mathcal{HC}$ is the half-Cauchy distribution. \n", - "While half-Cauchy priors favor values near zero they also have heavy tails, which allows the \n", - "inverse lengthscales of the most important parameters to escape zero. To perform inference in the \n", - "SAAS model we use Hamiltonian Monte Carlo (HMC) as we found that to outperform MAP inference.\n", - "\n", - "We find that SAASBO performs well on problems with hundreds of dimensions. As we rely on HMC \n", - "and in particular the No-U-Turn-Sampler (NUTS) for inference, the overhead of SAASBO scales \n", - "cubically with the number of datapoints. Depending on the problem, using more than a few hundred\n", - "evaluations may not be feasible as SAASBO is designed for problems with a limited evaluation budget.\n", - "\n", - "In general, we recommend using [Ax](https://ax.dev) for a simple BO setup like this one. See [here](https://ax.dev/tutorials/saasbo.html) for a SAASBO tutorial in Ax, which uses the Noisy Expected Improvement acquisition function. To customize the acquisition function used with SAASBO in Ax, see the [custom acquisition tutorial](./custom_acquisition), where adding `\\\"surrogate\\\": Surrogate(SaasFullyBayesianSingleTaskGP),` to the `model_kwargs` of `BOTORCH_MODULAR` step is sufficient to enable the SAAS model.\n", - "\n", - "[1]: [D. Eriksson, M. Jankowiak. High-Dimensional Bayesian Optimization with Sparse Axis-Aligned Subspaces. Proceedings of the Thirty-Seventh Conference on Uncertainty in Artificial Intelligence, 2021.](https://proceedings.mlr.press/v161/eriksson21a.html)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "code_folding": [], - "customOutput": null, - "executionStartTime": 1668653404823, - "executionStopTime": 1668653404909, - "hidden_ranges": [], - "originalKey": "26933c08-82d6-439d-9fcb-6e358b080ab6", - "requestMsgId": "1806f0c7-d668-4248-a390-14add9bcb451" - }, - "outputs": [], - "source": [ - "import os\n", - "\n", - "import torch\n", - "from torch.quasirandom import SobolEngine\n", - "\n", - "from botorch import fit_fully_bayesian_model_nuts\n", - "from botorch.acquisition import qExpectedImprovement\n", - "from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP\n", - "from botorch.models.transforms import Standardize\n", - "from botorch.optim import optimize_acqf\n", - "from botorch.test_functions import Branin\n", - "\n", - "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653405125, - "executionStopTime": 1668653405130, - "hidden_ranges": [], - "originalKey": "f1e3c7f0-1afc-42e2-af59-5f5fae755ce5", - "requestMsgId": "068ddee5-939e-4f5b-8210-2f6a490f6c4e", - "showInput": true - }, - "outputs": [], - "source": [ - "tkwargs = {\n", - " \"device\": torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\"),\n", - " \"dtype\": torch.double,\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "08a3d790-52a5-4821-af21-1040f1a037f0", - "showInput": false - }, - "source": [ - "The time to fit the SAAS model can be decreased by lowering\n", - "`WARMUP_STEPS` and `NUM_SAMPLES`. \n", - "\n", - "We recommend using 512 warmup steps and 256 samples when\n", - "possible and to not use fewer than 256 warmup steps and 128 samples. By default, we only\n", - "keep each 16th sample which with 256 samples results in 32 hyperparameter samples.\n", - "\n", - "To make this tutorial run faster we use 256 warmup steps and 128 samples. " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653405353, - "executionStopTime": 1668653405445, - "originalKey": "363224de-347c-46a7-9c84-970cbb8e825d", - "requestMsgId": "09e1ff1f-9c11-4053-8123-08aa3397dfc1", - "showInput": true - }, - "outputs": [], - "source": [ - "WARMUP_STEPS = 256 if not SMOKE_TEST else 32\n", - "NUM_SAMPLES = 128 if not SMOKE_TEST else 16\n", - "THINNING = 16" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "af8beafd-352c-421d-8797-7660ddfa39f3", - "showInput": false - }, - "source": [ - "## Simple model fitting\n", - "We generate a simple function that only depends on the first parameter and show that the SAAS\n", - "model sets all other lengthscales to large values." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653405681, - "executionStopTime": 1668653405771, - "hidden_ranges": [], - "originalKey": "f506aa6b-904c-4a7e-8a38-0443e983df06", - "requestMsgId": "a6b6bfcd-c30c-4339-a342-02dd398a8274", - "showInput": true - }, - "outputs": [], - "source": [ - "train_X = torch.rand(10, 4, **tkwargs)\n", - "test_X = torch.rand(5, 4, **tkwargs)\n", - "train_Y = torch.sin(train_X[:, :1])\n", - "test_Y = torch.sin(test_X[:, :1])" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "cc9314b1-f255-4f7d-9f6d-eb349b34805e", - "showInput": false - }, - "source": [ - "By default, we infer the unknown noise variance in the data. You can also pass in a known \n", - "noise variance (`train_Yvar`) for each observation, which may be useful in cases where you for example\n", - "know that the problem is noise-free and can then set the noise variance to a small value such as `1e-6`.\n", - "\n", - "In this case you can construct a model as follows:\n", - "```\n", - "gp = SaasFullyBayesianSingleTaskGP(train_X=train_X, train_Y=train_Y, train_Yvar=torch.full_like(train_Y, 1e-6))\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653406085, - "executionStopTime": 1668653471282, - "hidden_ranges": [], - "originalKey": "148855fb-cf0c-4fc5-8431-06a5e61c5da5", - "requestMsgId": "0c13f0b6-28b9-43ea-8d1b-00871e5e4f02", - "showInput": true - }, - "outputs": [], - "source": [ - "gp = SaasFullyBayesianSingleTaskGP(\n", - " train_X=train_X, \n", - " train_Y=train_Y, \n", - " outcome_transform=Standardize(m=1)\n", - ")\n", - "fit_fully_bayesian_model_nuts(\n", - " gp,\n", - " warmup_steps=WARMUP_STEPS,\n", - " num_samples=NUM_SAMPLES,\n", - " thinning=THINNING,\n", - " disable_progbar=True,\n", - ")\n", - "with torch.no_grad():\n", - " posterior = gp.posterior(test_X)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "5f4fa168-2662-499b-ac82-3ab122dfe2ad", - "showInput": false - }, - "source": [ - "Computing the median lengthscales over the MCMC dimensions makes it clear that the first feature has the smallest lengthscale\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653471605, - "executionStopTime": 1668653471693, - "hidden_ranges": [], - "originalKey": "44a1f7c0-9649-4d89-8226-0405fdf88518", - "requestMsgId": "e815926b-5a2d-4b78-8b89-3c0720e45592", - "showInput": true - }, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([ 1.2600, 22.0002, 19.5355, 21.7929], dtype=torch.float64)\n" - ] - } - ], - "source": [ - "print(gp.median_lengthscale.detach())" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "cf15a6ca-3377-40d1-9821-fad8f6600657", - "showInput": false - }, - "source": [ - "### Make predictions with the model\n", - "\n", - "In the next cell we show how to make predictions with the SAAS model. You compute the mean\n", - "and variance for test points just like for any other BoTorch posteriors. Note that the mean \n", - "and posterior will have an extra batch dimension at -3 that corresponds to the number of MCMC\n", - "samples (which is 8 in this tutorial)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653471916, - "executionStopTime": 1668653472023, - "hidden_ranges": [], - "originalKey": "898039a4-6ec8-46bd-a583-5a1614a3ccf6", - "requestMsgId": "4328636f-fb02-44ee-8c48-842c3845297f", - "showInput": true - }, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "501041cc-0473-4971-bff9-fd6e92e1eae4", + "showInput": false + }, + "source": [ + "## High-Dimensional sample-efficient Bayesian Optimization with SAASBO\n", + "\n", + "This tutorial shows how to use the Sparse Axis-Aligned Subspace Bayesian Optimization (SAASBO) \n", + "method for high-dimensional Bayesian optimization [1]. SAASBO places strong priors on the \n", + "inverse lengthscales to avoid overfitting in high-dimensional spaces. Specifically, SAASBO \n", + "uses a hierarchical sparsity prior consisting of a global shrinkage parameter \n", + "$\\tau \\sim \\mathcal{HC}(\\beta)$ and inverse lengthscales $\\rho_d \\sim \\mathcal{HC}(\\tau)$ \n", + "for $d=1, \\ldots, D$, where $\\mathcal{HC}$ is the half-Cauchy distribution. \n", + "While half-Cauchy priors favor values near zero they also have heavy tails, which allows the \n", + "inverse lengthscales of the most important parameters to escape zero. To perform inference in the \n", + "SAAS model we use Hamiltonian Monte Carlo (HMC) as we found that to outperform MAP inference.\n", + "\n", + "We find that SAASBO performs well on problems with hundreds of dimensions. As we rely on HMC \n", + "and in particular the No-U-Turn-Sampler (NUTS) for inference, the overhead of SAASBO scales \n", + "cubically with the number of datapoints. Depending on the problem, using more than a few hundred\n", + "evaluations may not be feasible as SAASBO is designed for problems with a limited evaluation budget.\n", + "\n", + "In general, we recommend using [Ax](https://ax.dev) for a simple BO setup like this one. See [here](https://ax.dev/tutorials/saasbo.html) for a SAASBO tutorial in Ax, which uses the Noisy Expected Improvement acquisition function. To customize the acquisition function used with SAASBO in Ax, see the [custom acquisition tutorial](./custom_acquisition), where adding `\\\"surrogate\\\": Surrogate(SaasFullyBayesianSingleTaskGP),` to the `model_kwargs` of `BOTORCH_MODULAR` step is sufficient to enable the SAAS model.\n", + "\n", + "[1]: [D. Eriksson, M. Jankowiak. High-Dimensional Bayesian Optimization with Sparse Axis-Aligned Subspaces. Proceedings of the Thirty-Seventh Conference on Uncertainty in Artificial Intelligence, 2021.](https://proceedings.mlr.press/v161/eriksson21a.html)" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([8, 5, 1])\n", - "torch.Size([8, 5, 1])\n" - ] - } - ], - "source": [ - "print(posterior.mean.shape)\n", - "print(posterior.variance.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "02b33f7f-4f31-432a-bac7-8cad1831e9a1", - "showInput": false - }, - "source": [ - "We also provide several convenience methods for computing different statistics over the MCMC samples:\n", - "```\n", - "mixture_mean = posterior.mixture_mean\n", - "mixture_variance = posterior.mixture_variance\n", - "mixture_quantile = posterior.quantile(q=0.95)\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653472240, - "executionStopTime": 1668653472326, - "hidden_ranges": [], - "originalKey": "b387d057-a497-401b-bfc2-ab427669c451", - "requestMsgId": "64e0ee73-6ffd-4ad5-b9b2-bd9ea4e637ee", - "showInput": true - }, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": { + "code_folding": [], + "customOutput": null, + "executionStartTime": 1668653404823, + "executionStopTime": 1668653404909, + "hidden_ranges": [], + "originalKey": "26933c08-82d6-439d-9fcb-6e358b080ab6", + "requestMsgId": "1806f0c7-d668-4248-a390-14add9bcb451" + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import torch\n", + "from torch.quasirandom import SobolEngine\n", + "\n", + "from botorch import fit_fully_bayesian_model_nuts\n", + "from botorch.acquisition import qExpectedImprovement\n", + "from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP\n", + "from botorch.models.transforms import Standardize\n", + "from botorch.optim import optimize_acqf\n", + "from botorch.test_functions import Branin\n", + "\n", + "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ground truth: tensor([0.7808, 0.8300, 0.1289, 0.7994, 0.2237], dtype=torch.float64)\n", - "Mixture mean: tensor([0.7808, 0.8298, 0.1427, 0.7994, 0.2242], dtype=torch.float64)\n" - ] - } - ], - "source": [ - "print(f\"Ground truth: {test_Y.squeeze(-1)}\")\n", - "print(f\"Mixture mean: {posterior.mixture_mean.squeeze(-1)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "executionStartTime": 1644277314184, - "executionStopTime": 1644277314189, - "hidden_ranges": [], - "originalKey": "d9bec8be-2acd-40b8-aebb-612b62bbdfc3", - "requestMsgId": "d9bec8be-2acd-40b8-aebb-612b62bbdfc3", - "showInput": false - }, - "source": [ - "## Optimize Branin embedded in a 30D space\n", - "We take the standard 2D Branin problem and embed it in a 30D space. In particular,\n", - "we let dimensions 0 and 1 correspond to the true dimensions. We will show that\n", - "SAASBO is able to identify the important dimensions and efficiently optimize this function.\n", - "We work with the domain $[0, 1]^d$ and unnormalize the inputs to the true domain of Branin \n", - "before evaluating the function." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653472540, - "executionStopTime": 1668653472545, - "hidden_ranges": [], - "originalKey": "15baa08e-ca35-4da7-a495-c63fe5d5779d", - "requestMsgId": "6c3f8d91-9139-4c07-986f-77629b1887e5", - "showInput": true - }, - "outputs": [], - "source": [ - "branin = Branin().to(**tkwargs)\n", - "\n", - "\n", - "def branin_emb(x):\n", - " \"\"\"x is assumed to be in [0, 1]^d\"\"\"\n", - " lb, ub = branin.bounds\n", - " return branin(lb + (ub - lb) * x[..., :2])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653472768, - "executionStopTime": 1668653472776, - "hidden_ranges": [], - "originalKey": "98b6936b-2f06-4d1f-82c0-2f1bd660d0b2", - "requestMsgId": "1b5baaf2-e690-4b4d-9011-b6124e083410", - "showInput": true - }, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653405125, + "executionStopTime": 1668653405130, + "hidden_ranges": [], + "originalKey": "f1e3c7f0-1afc-42e2-af59-5f5fae755ce5", + "requestMsgId": "068ddee5-939e-4f5b-8210-2f6a490f6c4e", + "showInput": true + }, + "outputs": [], + "source": [ + "tkwargs = {\n", + " \"device\": torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\"),\n", + " \"dtype\": torch.double,\n", + "}" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using a total of 50 function evaluations\n" - ] - } - ], - "source": [ - "DIM = 30 if not SMOKE_TEST else 10\n", - "\n", - "# Evaluation budget\n", - "N_INIT = 10\n", - "N_ITERATIONS = 8 if not SMOKE_TEST else 1\n", - "BATCH_SIZE = 5 if not SMOKE_TEST else 1\n", - "print(f\"Using a total of {N_INIT + BATCH_SIZE * N_ITERATIONS} function evaluations\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "27fd793f-18ee-49cb-9aa5-c8cd78b0b807", - "showInput": false - }, - "source": [ - "### Run the optimization\n", - "We use 10 initial Sobol points followed by 8 iterations of BO using a batch size of 5, \n", - "which results in a total of 50 function evaluations. As our goal is to minimize Branin, we flip\n", - "the sign of the function values before fitting the SAAS model as the BoTorch acquisition\n", - "functions assume maximization." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668653473096, - "executionStopTime": 1668655621405, - "hidden_ranges": [], - "originalKey": "269287e0-500f-474d-891a-5439487e9a77", - "requestMsgId": "5117b535-1fe7-40be-9f68-361db9d9b51b", - "showInput": true - }, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "08a3d790-52a5-4821-af21-1040f1a037f0", + "showInput": false + }, + "source": [ + "The time to fit the SAAS model can be decreased by lowering\n", + "`WARMUP_STEPS` and `NUM_SAMPLES`. \n", + "\n", + "We recommend using 512 warmup steps and 256 samples when\n", + "possible and to not use fewer than 256 warmup steps and 128 samples. By default, we only\n", + "keep each 16th sample which with 256 samples results in 32 hyperparameter samples.\n", + "\n", + "To make this tutorial run faster we use 256 warmup steps and 128 samples. " + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best initial point: 5.322\n", - "3) New best: 1.960 @ [1.000, 0.209]\n", - "4) New best: 1.145 @ [0.532, 0.213]\n", - "5) New best: 0.712 @ [0.136, 0.763]\n", - "6) New best: 0.445 @ [0.539, 0.143]\n", - "7) New best: 0.399 @ [0.542, 0.150]\n", - "8) New best: 0.398 @ [0.962, 0.164]\n" - ] - } - ], - "source": [ - "X = SobolEngine(dimension=DIM, scramble=True, seed=0).draw(N_INIT).to(**tkwargs)\n", - "Y = branin_emb(X).unsqueeze(-1)\n", - "print(f\"Best initial point: {Y.min().item():.3f}\")\n", - "\n", - "for i in range(N_ITERATIONS):\n", - " train_Y = -1 * Y # Flip the sign since we want to minimize f(x)\n", - " gp = SaasFullyBayesianSingleTaskGP(\n", - " train_X=X,\n", - " train_Y=train_Y,\n", - " train_Yvar=torch.full_like(train_Y, 1e-6),\n", - " outcome_transform=Standardize(m=1),\n", - " )\n", - " fit_fully_bayesian_model_nuts(\n", - " gp,\n", - " warmup_steps=WARMUP_STEPS,\n", - " num_samples=NUM_SAMPLES,\n", - " thinning=THINNING,\n", - " disable_progbar=True,\n", - " )\n", - "\n", - " EI = qExpectedImprovement(model=gp, best_f=train_Y.max())\n", - " candidates, acq_values = optimize_acqf(\n", - " EI,\n", - " bounds=torch.cat((torch.zeros(1, DIM), torch.ones(1, DIM))).to(**tkwargs),\n", - " q=BATCH_SIZE,\n", - " num_restarts=10,\n", - " raw_samples=1024,\n", - " )\n", - "\n", - " Y_next = torch.cat([branin_emb(x).unsqueeze(-1) for x in candidates]).unsqueeze(-1)\n", - " if Y_next.min() < Y.min():\n", - " ind_best = Y_next.argmin()\n", - " x0, x1 = candidates[ind_best, :2].tolist()\n", - " print(\n", - " f\"{i + 1}) New best: {Y_next[ind_best].item():.3f} @ \"\n", - " f\"[{x0:.3f}, {x1:.3f}]\"\n", - " )\n", - " X = torch.cat((X, candidates))\n", - " Y = torch.cat((Y, Y_next))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "a9704a99-0712-40bb-a263-6798e0925291", - "showInput": false - }, - "source": [ - "## Plot the results\n", - "\n", - "We can see that we were able to get close to the global optimium of $\\approx 0.398$ after 50 function evaluations.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668655621761, - "executionStopTime": 1668655621936, - "hidden_ranges": [], - "originalKey": "fd0d7aa7-8d55-4942-adc2-de356666ac84", - "requestMsgId": "4024717d-fc5c-4939-90ce-fb24b3e06ea3", - "showInput": true - }, - "outputs": [ + "cell_type": "code", + "execution_count": 3, + "metadata": { + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653405353, + "executionStopTime": 1668653405445, + "originalKey": "363224de-347c-46a7-9c84-970cbb8e825d", + "requestMsgId": "09e1ff1f-9c11-4053-8123-08aa3397dfc1", + "showInput": true + }, + "outputs": [], + "source": [ + "WARMUP_STEPS = 256 if not SMOKE_TEST else 32\n", + "NUM_SAMPLES = 128 if not SMOKE_TEST else 16\n", + "THINNING = 16" + ] + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "af8beafd-352c-421d-8797-7660ddfa39f3", + "showInput": false + }, + "source": [ + "## Simple model fitting\n", + "We generate a simple function that only depends on the first parameter and show that the SAAS\n", + "model sets all other lengthscales to large values." ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "%matplotlib inline\n", - "\n", - "Y_np = Y.cpu().numpy()\n", - "fig, ax = plt.subplots(figsize=(8, 6))\n", - "ax.plot(np.minimum.accumulate(Y_np), color=\"b\", label=\"SAASBO\")\n", - "ax.plot([0, len(Y_np)], [0.398, 0.398], \"--\", c=\"g\", lw=3, label=\"Optimal value\")\n", - "ax.grid(True)\n", - "ax.set_title(f\"Branin, D = {DIM}\", fontsize=20)\n", - "ax.set_xlabel(\"Number of evaluations\", fontsize=20)\n", - "ax.set_xlim([0, len(Y_np)])\n", - "ax.set_ylabel(\"Best value found\", fontsize=20)\n", - "ax.set_ylim([0, 8])\n", - "ax.legend(fontsize=18)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "d81134ff-cec6-45cb-92bf-4170f428af40", - "showInput": false - }, - "source": [ - "## Predict on some test points\n", - "We fit a model using the 50 datapoints collected by SAASBO and predict on 50 test \n", - "points in order to see how well the SAAS model predicts out-of-sample.\n", - "The plot shows the mean and a 95% confidence interval for each test point." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668655622271, - "executionStopTime": 1668655822584, - "hidden_ranges": [], - "originalKey": "970977ea-ee5e-46eb-b500-683673ce723e", - "requestMsgId": "2ae0c053-022f-4902-8bc5-b904bd85f90d", - "showInput": true - }, - "outputs": [], - "source": [ - "train_X = SobolEngine(dimension=DIM, scramble=True, seed=0).draw(50).to(**tkwargs)\n", - "test_X = SobolEngine(dimension=DIM, scramble=True, seed=1).draw(50).to(**tkwargs)\n", - "train_Y = branin_emb(train_X).unsqueeze(-1)\n", - "test_Y = branin_emb(test_X).unsqueeze(-1)\n", - "\n", - "gp = SaasFullyBayesianSingleTaskGP(\n", - " train_X=train_X,\n", - " train_Y=train_Y,\n", - " train_Yvar=torch.full_like(train_Y, 1e-6),\n", - " outcome_transform=Standardize(m=1),\n", - ")\n", - "fit_fully_bayesian_model_nuts(\n", - " gp,\n", - " warmup_steps=WARMUP_STEPS,\n", - " num_samples=NUM_SAMPLES,\n", - " thinning=THINNING,\n", - " disable_progbar=True,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668655921184, - "executionStopTime": 1668655921625, - "hidden_ranges": [], - "originalKey": "25139c91-a34c-4fa8-808f-70c1cf6952fd", - "requestMsgId": "ad9413e7-09aa-47f5-b435-bf37cf0180d1", - "showInput": true - }, - "outputs": [], - "source": [ - "with torch.no_grad():\n", - " posterior = gp.posterior(test_X)\n", - "median = posterior.quantile(value=torch.tensor([0.5], **tkwargs))\n", - "q1 = posterior.quantile(value=torch.tensor([0.025], **tkwargs))\n", - "q2 = posterior.quantile(value=torch.tensor([0.975], **tkwargs))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668655923525, - "executionStopTime": 1668655923743, - "hidden_ranges": [], - "originalKey": "39163b27-e252-4244-9712-f52503e00f74", - "requestMsgId": "7c819fcc-5f74-48b1-9fd4-286839fdd0b6", - "showInput": true - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653405681, + "executionStopTime": 1668653405771, + "hidden_ranges": [], + "originalKey": "f506aa6b-904c-4a7e-8a38-0443e983df06", + "requestMsgId": "a6b6bfcd-c30c-4339-a342-02dd398a8274", + "showInput": true + }, + "outputs": [], + "source": [ + "train_X = torch.rand(10, 4, **tkwargs)\n", + "test_X = torch.rand(5, 4, **tkwargs)\n", + "train_Y = torch.sin(train_X[:, :1])\n", + "test_Y = torch.sin(test_X[:, :1])" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", - "ax.plot([0, 80], [0, 80], \"b--\", lw=2)\n", - "\n", - "yerr1, yerr2 = median - q1, q2 - median\n", - "yerr = torch.cat((yerr1.unsqueeze(0), yerr2.unsqueeze(0)), dim=0).squeeze(-1)\n", - "markers, caps, bars = ax.errorbar(\n", - " test_Y.squeeze(-1).cpu(),\n", - " median.squeeze(-1).cpu(),\n", - " yerr=yerr.cpu(),\n", - " fmt=\".\",\n", - " capsize=4,\n", - " elinewidth=2.0,\n", - " ms=14,\n", - " c=\"k\",\n", - " ecolor=\"gray\",\n", - ")\n", - "ax.set_xlim([0, 80])\n", - "ax.set_ylim([0, 80])\n", - "[bar.set_alpha(0.8) for bar in bars]\n", - "[cap.set_alpha(0.8) for cap in caps]\n", - "ax.set_xlabel(\"True value\", fontsize=20)\n", - "ax.set_ylabel(\"Predicted value\", fontsize=20)\n", - "ax.set_aspect(\"equal\")\n", - "ax.grid(True)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "code_folding": [], - "customInput": null, - "hidden_ranges": [], - "originalKey": "34e976cd-7d09-40d2-8987-aecdefa7c0fd", - "requestMsgId": "34e976cd-7d09-40d2-8987-aecdefa7c0fd", - "showInput": false - }, - "source": [ - "## Look a the lengthscales from the final model\n", - "\n", - "As SAASBO places strong priors on the inverse lengthscales, we only expect parameters \n", - "0 and 1 to be identified as important by the model since the other parameters have no effect.\n", - "We can confirm that this is the case below as the lengthscales of parameters 0 and 1 are \n", - "small with all other lengthscales being large." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "code_folding": [], - "customInput": null, - "customOutput": null, - "executionStartTime": 1668655927129, - "executionStopTime": 1668655927142, - "hidden_ranges": [], - "originalKey": "33147b57-ea6b-4c67-9c7d-796bb54d5c84", - "requestMsgId": "b32e63df-16ee-45f1-af94-7f6f4bb78173", - "showInput": true - }, - "outputs": [ + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "cc9314b1-f255-4f7d-9f6d-eb349b34805e", + "showInput": false + }, + "source": [ + "By default, we infer the unknown noise variance in the data. You can also pass in a known \n", + "noise variance (`train_Yvar`) for each observation, which may be useful in cases where you for example\n", + "know that the problem is noise-free and can then set the noise variance to a small value such as `1e-6`.\n", + "\n", + "In this case you can construct a model as follows:\n", + "```\n", + "gp = SaasFullyBayesianSingleTaskGP(train_X=train_X, train_Y=train_Y, train_Yvar=torch.full_like(train_Y, 1e-6))\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653406085, + "executionStopTime": 1668653471282, + "hidden_ranges": [], + "originalKey": "148855fb-cf0c-4fc5-8431-06a5e61c5da5", + "requestMsgId": "0c13f0b6-28b9-43ea-8d1b-00871e5e4f02", + "showInput": true + }, + "outputs": [], + "source": [ + "gp = SaasFullyBayesianSingleTaskGP(\n", + " train_X=train_X, \n", + " train_Y=train_Y, \n", + " outcome_transform=Standardize(m=1)\n", + ")\n", + "fit_fully_bayesian_model_nuts(\n", + " gp,\n", + " warmup_steps=WARMUP_STEPS,\n", + " num_samples=NUM_SAMPLES,\n", + " thinning=THINNING,\n", + " disable_progbar=True,\n", + ")\n", + "with torch.no_grad():\n", + " posterior = gp.posterior(test_X)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "5f4fa168-2662-499b-ac82-3ab122dfe2ad", + "showInput": false + }, + "source": [ + "Computing the median lengthscales over the MCMC dimensions makes it clear that the first feature has the smallest lengthscale\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653471605, + "executionStopTime": 1668653471693, + "hidden_ranges": [], + "originalKey": "44a1f7c0-9649-4d89-8226-0405fdf88518", + "requestMsgId": "e815926b-5a2d-4b78-8b89-3c0720e45592", + "showInput": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 1.2600, 22.0002, 19.5355, 21.7929], dtype=torch.float64)\n" + ] + } + ], + "source": [ + "print(gp.median_lengthscale.detach())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "cf15a6ca-3377-40d1-9821-fad8f6600657", + "showInput": false + }, + "source": [ + "### Make predictions with the model\n", + "\n", + "In the next cell we show how to make predictions with the SAAS model. You compute the mean\n", + "and variance for test points just like for any other BoTorch posteriors. Note that the mean \n", + "and posterior will have an extra batch dimension at -3 that corresponds to the number of MCMC\n", + "samples (which is 8 in this tutorial)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653471916, + "executionStopTime": 1668653472023, + "hidden_ranges": [], + "originalKey": "898039a4-6ec8-46bd-a583-5a1614a3ccf6", + "requestMsgId": "4328636f-fb02-44ee-8c48-842c3845297f", + "showInput": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([8, 5, 1])\n", + "torch.Size([8, 5, 1])\n" + ] + } + ], + "source": [ + "print(posterior.mean.shape)\n", + "print(posterior.variance.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "02b33f7f-4f31-432a-bac7-8cad1831e9a1", + "showInput": false + }, + "source": [ + "We also provide several convenience methods for computing different statistics over the MCMC samples:\n", + "```\n", + "mixture_mean = posterior.mixture_mean\n", + "mixture_variance = posterior.mixture_variance\n", + "mixture_quantile = posterior.quantile(q=0.95)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653472240, + "executionStopTime": 1668653472326, + "hidden_ranges": [], + "originalKey": "b387d057-a497-401b-bfc2-ab427669c451", + "requestMsgId": "64e0ee73-6ffd-4ad5-b9b2-bd9ea4e637ee", + "showInput": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ground truth: tensor([0.7808, 0.8300, 0.1289, 0.7994, 0.2237], dtype=torch.float64)\n", + "Mixture mean: tensor([0.7808, 0.8298, 0.1427, 0.7994, 0.2242], dtype=torch.float64)\n" + ] + } + ], + "source": [ + "print(f\"Ground truth: {test_Y.squeeze(-1)}\")\n", + "print(f\"Mixture mean: {posterior.mixture_mean.squeeze(-1)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "executionStartTime": 1644277314184, + "executionStopTime": 1644277314189, + "hidden_ranges": [], + "originalKey": "d9bec8be-2acd-40b8-aebb-612b62bbdfc3", + "requestMsgId": "d9bec8be-2acd-40b8-aebb-612b62bbdfc3", + "showInput": false + }, + "source": [ + "## Optimize Branin embedded in a 30D space\n", + "We take the standard 2D Branin problem and embed it in a 30D space. In particular,\n", + "we let dimensions 0 and 1 correspond to the true dimensions. We will show that\n", + "SAASBO is able to identify the important dimensions and efficiently optimize this function.\n", + "We work with the domain $[0, 1]^d$ and unnormalize the inputs to the true domain of Branin \n", + "before evaluating the function." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653472540, + "executionStopTime": 1668653472545, + "hidden_ranges": [], + "originalKey": "15baa08e-ca35-4da7-a495-c63fe5d5779d", + "requestMsgId": "6c3f8d91-9139-4c07-986f-77629b1887e5", + "showInput": true + }, + "outputs": [], + "source": [ + "branin = Branin().to(**tkwargs)\n", + "\n", + "\n", + "def branin_emb(x):\n", + " \"\"\"x is assumed to be in [0, 1]^d\"\"\"\n", + " lb, ub = branin.bounds\n", + " return branin(lb + (ub - lb) * x[..., :2])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653472768, + "executionStopTime": 1668653472776, + "hidden_ranges": [], + "originalKey": "98b6936b-2f06-4d1f-82c0-2f1bd660d0b2", + "requestMsgId": "1b5baaf2-e690-4b4d-9011-b6124e083410", + "showInput": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using a total of 50 function evaluations\n" + ] + } + ], + "source": [ + "DIM = 30 if not SMOKE_TEST else 10\n", + "\n", + "# Evaluation budget\n", + "N_INIT = 10\n", + "N_ITERATIONS = 8 if not SMOKE_TEST else 1\n", + "BATCH_SIZE = 5 if not SMOKE_TEST else 1\n", + "print(f\"Using a total of {N_INIT + BATCH_SIZE * N_ITERATIONS} function evaluations\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "27fd793f-18ee-49cb-9aa5-c8cd78b0b807", + "showInput": false + }, + "source": [ + "### Run the optimization\n", + "We use 10 initial Sobol points followed by 8 iterations of BO using a batch size of 5, \n", + "which results in a total of 50 function evaluations. As our goal is to minimize Branin, we flip\n", + "the sign of the function values before fitting the SAAS model as the BoTorch acquisition\n", + "functions assume maximization." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parameter 0) Median lengthscale = 7.57e-01\n", - "Parameter 1) Median lengthscale = 2.65e+00\n", - "Parameter 24) Median lengthscale = 6.28e+02\n", - "Parameter 7) Median lengthscale = 6.77e+02\n", - "Parameter 29) Median lengthscale = 7.54e+02\n", - "Parameter 19) Median lengthscale = 7.65e+02\n", - "Parameter 16) Median lengthscale = 7.94e+02\n", - "Parameter 27) Median lengthscale = 8.03e+02\n", - "Parameter 15) Median lengthscale = 8.32e+02\n", - "Parameter 26) Median lengthscale = 8.35e+02\n" - ] + "cell_type": "code", + "execution_count": 11, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668653473096, + "executionStopTime": 1668655621405, + "hidden_ranges": [], + "originalKey": "269287e0-500f-474d-891a-5439487e9a77", + "requestMsgId": "5117b535-1fe7-40be-9f68-361db9d9b51b", + "showInput": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best initial point: 5.322\n", + "3) New best: 1.960 @ [1.000, 0.209]\n", + "4) New best: 1.145 @ [0.532, 0.213]\n", + "5) New best: 0.712 @ [0.136, 0.763]\n", + "6) New best: 0.445 @ [0.539, 0.143]\n", + "7) New best: 0.399 @ [0.542, 0.150]\n", + "8) New best: 0.398 @ [0.962, 0.164]\n" + ] + } + ], + "source": [ + "X = SobolEngine(dimension=DIM, scramble=True, seed=0).draw(N_INIT).to(**tkwargs)\n", + "Y = branin_emb(X).unsqueeze(-1)\n", + "print(f\"Best initial point: {Y.min().item():.3f}\")\n", + "\n", + "for i in range(N_ITERATIONS):\n", + " train_Y = -1 * Y # Flip the sign since we want to minimize f(x)\n", + " gp = SaasFullyBayesianSingleTaskGP(\n", + " train_X=X,\n", + " train_Y=train_Y,\n", + " train_Yvar=torch.full_like(train_Y, 1e-6),\n", + " outcome_transform=Standardize(m=1),\n", + " )\n", + " fit_fully_bayesian_model_nuts(\n", + " gp,\n", + " warmup_steps=WARMUP_STEPS,\n", + " num_samples=NUM_SAMPLES,\n", + " thinning=THINNING,\n", + " disable_progbar=True,\n", + " )\n", + "\n", + " EI = qExpectedImprovement(model=gp, best_f=train_Y.max())\n", + " candidates, acq_values = optimize_acqf(\n", + " EI,\n", + " bounds=torch.cat((torch.zeros(1, DIM), torch.ones(1, DIM))).to(**tkwargs),\n", + " q=BATCH_SIZE,\n", + " num_restarts=10,\n", + " raw_samples=1024,\n", + " )\n", + "\n", + " Y_next = torch.cat([branin_emb(x).unsqueeze(-1) for x in candidates]).unsqueeze(-1)\n", + " if Y_next.min() < Y.min():\n", + " ind_best = Y_next.argmin()\n", + " x0, x1 = candidates[ind_best, :2].tolist()\n", + " print(\n", + " f\"{i + 1}) New best: {Y_next[ind_best].item():.3f} @ \"\n", + " f\"[{x0:.3f}, {x1:.3f}]\"\n", + " )\n", + " X = torch.cat((X, candidates))\n", + " Y = torch.cat((Y, Y_next))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "a9704a99-0712-40bb-a263-6798e0925291", + "showInput": false + }, + "source": [ + "## Plot the results\n", + "\n", + "We can see that we were able to get close to the global optimium of $\\approx 0.398$ after 50 function evaluations.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668655621761, + "executionStopTime": 1668655621936, + "hidden_ranges": [], + "originalKey": "fd0d7aa7-8d55-4942-adc2-de356666ac84", + "requestMsgId": "4024717d-fc5c-4939-90ce-fb24b3e06ea3", + "showInput": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "%matplotlib inline\n", + "\n", + "Y_np = Y.cpu().numpy()\n", + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.plot(np.minimum.accumulate(Y_np), color=\"b\", label=\"SAASBO\")\n", + "ax.plot([0, len(Y_np)], [0.398, 0.398], \"--\", c=\"g\", lw=3, label=\"Optimal value\")\n", + "ax.grid(True)\n", + "ax.set_title(f\"Branin, D = {DIM}\", fontsize=20)\n", + "ax.set_xlabel(\"Number of evaluations\", fontsize=20)\n", + "ax.set_xlim([0, len(Y_np)])\n", + "ax.set_ylabel(\"Best value found\", fontsize=20)\n", + "ax.set_ylim([0, 8])\n", + "ax.legend(fontsize=18)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "d81134ff-cec6-45cb-92bf-4170f428af40", + "showInput": false + }, + "source": [ + "## Predict on some test points\n", + "We fit a model using the 50 datapoints collected by SAASBO and predict on 50 test \n", + "points in order to see how well the SAAS model predicts out-of-sample.\n", + "The plot shows the mean and a 95% confidence interval for each test point." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668655622271, + "executionStopTime": 1668655822584, + "hidden_ranges": [], + "originalKey": "970977ea-ee5e-46eb-b500-683673ce723e", + "requestMsgId": "2ae0c053-022f-4902-8bc5-b904bd85f90d", + "showInput": true + }, + "outputs": [], + "source": [ + "train_X = SobolEngine(dimension=DIM, scramble=True, seed=0).draw(50).to(**tkwargs)\n", + "test_X = SobolEngine(dimension=DIM, scramble=True, seed=1).draw(50).to(**tkwargs)\n", + "train_Y = branin_emb(train_X).unsqueeze(-1)\n", + "test_Y = branin_emb(test_X).unsqueeze(-1)\n", + "\n", + "gp = SaasFullyBayesianSingleTaskGP(\n", + " train_X=train_X,\n", + " train_Y=train_Y,\n", + " train_Yvar=torch.full_like(train_Y, 1e-6),\n", + " outcome_transform=Standardize(m=1),\n", + ")\n", + "fit_fully_bayesian_model_nuts(\n", + " gp,\n", + " warmup_steps=WARMUP_STEPS,\n", + " num_samples=NUM_SAMPLES,\n", + " thinning=THINNING,\n", + " disable_progbar=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668655921184, + "executionStopTime": 1668655921625, + "hidden_ranges": [], + "originalKey": "25139c91-a34c-4fa8-808f-70c1cf6952fd", + "requestMsgId": "ad9413e7-09aa-47f5-b435-bf37cf0180d1", + "showInput": true + }, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " posterior = gp.posterior(test_X)\n", + "median = posterior.quantile(value=torch.tensor([0.5], **tkwargs))\n", + "q1 = posterior.quantile(value=torch.tensor([0.025], **tkwargs))\n", + "q2 = posterior.quantile(value=torch.tensor([0.975], **tkwargs))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668655923525, + "executionStopTime": 1668655923743, + "hidden_ranges": [], + "originalKey": "39163b27-e252-4244-9712-f52503e00f74", + "requestMsgId": "7c819fcc-5f74-48b1-9fd4-286839fdd0b6", + "showInput": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", + "ax.plot([0, 80], [0, 80], \"b--\", lw=2)\n", + "\n", + "yerr1, yerr2 = median - q1, q2 - median\n", + "yerr = torch.cat((yerr1.unsqueeze(0), yerr2.unsqueeze(0)), dim=0).squeeze(-1)\n", + "markers, caps, bars = ax.errorbar(\n", + " test_Y.squeeze(-1).cpu().numpy(),\n", + " median.squeeze(-1).cpu().numpy(),\n", + " yerr=yerr.cpu().numpy(),\n", + " fmt=\".\",\n", + " capsize=4,\n", + " elinewidth=2.0,\n", + " ms=14,\n", + " c=\"k\",\n", + " ecolor=\"gray\",\n", + ")\n", + "ax.set_xlim([0, 80])\n", + "ax.set_ylim([0, 80])\n", + "[bar.set_alpha(0.8) for bar in bars]\n", + "[cap.set_alpha(0.8) for cap in caps]\n", + "ax.set_xlabel(\"True value\", fontsize=20)\n", + "ax.set_ylabel(\"Predicted value\", fontsize=20)\n", + "ax.set_aspect(\"equal\")\n", + "ax.grid(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "code_folding": [], + "customInput": null, + "hidden_ranges": [], + "originalKey": "34e976cd-7d09-40d2-8987-aecdefa7c0fd", + "requestMsgId": "34e976cd-7d09-40d2-8987-aecdefa7c0fd", + "showInput": false + }, + "source": [ + "## Look a the lengthscales from the final model\n", + "\n", + "As SAASBO places strong priors on the inverse lengthscales, we only expect parameters \n", + "0 and 1 to be identified as important by the model since the other parameters have no effect.\n", + "We can confirm that this is the case below as the lengthscales of parameters 0 and 1 are \n", + "small with all other lengthscales being large." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "code_folding": [], + "customInput": null, + "customOutput": null, + "executionStartTime": 1668655927129, + "executionStopTime": 1668655927142, + "hidden_ranges": [], + "originalKey": "33147b57-ea6b-4c67-9c7d-796bb54d5c84", + "requestMsgId": "b32e63df-16ee-45f1-af94-7f6f4bb78173", + "showInput": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 0) Median lengthscale = 7.57e-01\n", + "Parameter 1) Median lengthscale = 2.65e+00\n", + "Parameter 24) Median lengthscale = 6.28e+02\n", + "Parameter 7) Median lengthscale = 6.77e+02\n", + "Parameter 29) Median lengthscale = 7.54e+02\n", + "Parameter 19) Median lengthscale = 7.65e+02\n", + "Parameter 16) Median lengthscale = 7.94e+02\n", + "Parameter 27) Median lengthscale = 8.03e+02\n", + "Parameter 15) Median lengthscale = 8.32e+02\n", + "Parameter 26) Median lengthscale = 8.35e+02\n" + ] + } + ], + "source": [ + "median_lengthscales = gp.median_lengthscale\n", + "for i in median_lengthscales.argsort()[:10]:\n", + " print(f\"Parameter {i:2}) Median lengthscale = {median_lengthscales[i].item():.2e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "fileHeader": "", + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" } - ], - "source": [ - "median_lengthscales = gp.median_lengthscale\n", - "for i in median_lengthscales.argsort()[:10]:\n", - " print(f\"Parameter {i:2}) Median lengthscale = {median_lengthscales[i].item():.2e}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "captumWidgetMessage": {}, - "dataExplorerConfig": {}, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.13" }, - "outputWidgetContext": {} - }, - "nbformat": 4, - "nbformat_minor": 2 + "nbformat": 4, + "nbformat_minor": 2 }