def test_batch_monte_carlo_expected_improvement_raises_for_model_with_wrong_event_shape() -> None:
builder = BatchMonteCarloExpectedImprovement(100)
data = mk_dataset([(0.0, 0.0)], [(0.0, 0.0)])
matern52 = tfp.math.psd_kernels.MaternFiveHalves(
amplitude=tf.cast(2.3, tf.float64), length_scale=tf.cast(0.5, tf.float64)
)
model = GaussianProcess([lambda x: branin(x), lambda x: quadratic(x)], [matern52, rbf()])
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
builder.prepare_acquisition_function(data, model)
def test_batch_monte_carlo_expected_improvement_raises_for_model_with_wrong_event_shape() -> None:
builder = BatchMonteCarloExpectedImprovement(100)
data = mk_dataset([[0.0, 0.0]], [[0.0, 0.0]])
model = _dim_two_gp()
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
builder.prepare_acquisition_function(data, model)
def test_batch_monte_carlo_expected_improvement_raises_for_empty_data() -> None:
builder = BatchMonteCarloExpectedImprovement(100)
data = Dataset(tf.zeros([0, 2]), tf.zeros([0, 1]))
model = QuadraticMeanAndRBFKernel()
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
builder.prepare_acquisition_function(data, model)
def test_batch_monte_carlo_expected_improvement_raises_for_invalid_jitter() -> None:
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
BatchMonteCarloExpectedImprovement(100, jitter=-1.0)
def test_batch_monte_carlo_expected_improvement_raises_for_invalid_sample_size(
sample_size: int,
) -> None:
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
BatchMonteCarloExpectedImprovement(sample_size)
num_observations = 30
# Batch size of the acquisition function. We will wait for that many workers to return before launching a new batch
batch_size = 2
# Set this flag to False to disable sleep delays in case you want the notebook to execute quickly
enable_sleep_delays = True
# %% [markdown]
# Now we are ready to define the optimizer. Notice how we set the acquisition function to be `BatchMonteCarloExpectedImprovement`. It is also the default function used by the `AsynchronousOptimization` rule, but here we specify it explicitly for clarity. We also set the batch size.
# %%
from trieste.acquisition.rule import AsynchronousOptimization
from trieste.acquisition.function import BatchMonteCarloExpectedImprovement
from trieste.ask_tell_optimization import AskTellOptimizer
model = build_model(initial_data)
acquisition_function = BatchMonteCarloExpectedImprovement(sample_size=10000)
async_rule = AsynchronousOptimization(
acquisition_function, num_query_points=batch_size) # type: ignore
async_bo = AskTellOptimizer(search_space, initial_data, model, async_rule)
# %% [markdown]
# Initialize Ray. This line will output the dashboard URL, which you can open in a separate tab to watch workers doing observations.
# %%
ray.init(ignore_reinit_error=True)
# %% [markdown]
# Here is the main optimization loop. First we ask for several batches of points to make sure all allocated workers are busy. Then we keep waiting for the workers to complete their tasks. Whenever `batch_size` of tasks came back, we tell Trieste new observations and ask for another batch of points.
# %%
points_observed = 0
from trieste.bayesian_optimizer import BayesianOptimizer
from trieste.data import Dataset
from trieste.models import GaussianProcessRegression
from trieste.space import Box
from trieste.utils.objectives import BRANIN_MINIMIZERS, BRANIN_MINIMUM, branin, mk_observer
@random_seed
@pytest.mark.parametrize(
"num_steps, acquisition_rule",
[
(20, EfficientGlobalOptimization()),
(
15,
EfficientGlobalOptimization(
BatchMonteCarloExpectedImprovement(sample_size=500).using(OBJECTIVE),
num_query_points=2,
),
),
(15, TrustRegion()),
(17, ThompsonSampling(500, 3)),
],
)
def test_optimizer_finds_minima_of_the_branin_function(
num_steps: int, acquisition_rule: AcquisitionRule
) -> None:
search_space = Box([0, 0], [1, 1])
def build_model(data: Dataset) -> GaussianProcessRegression:
variance = tf.math.reduce_variance(data.observations)
kernel = gpflow.kernels.Matern52(variance, tf.constant([0.2, 0.2], tf.float64))