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))