def test_async_greedy_raises_for_incorrect_query_points() -> None: with pytest.raises(ValueError): AsynchronousGreedy( builder=_GreedyBatchModelMinusMeanMaximumSingleBuilder(), num_query_points=0 ) with pytest.raises(ValueError): AsynchronousGreedy( builder=_GreedyBatchModelMinusMeanMaximumSingleBuilder(), num_query_points=-5 )
def test_async_ego_keeps_track_of_pending_points() -> None: search_space = Box(tf.constant([-2.2, -1.0]), tf.constant([1.3, 3.3])) acq = _GreedyBatchModelMinusMeanMaximumSingleBuilder() async_rule: AsynchronousGreedy[Box] = AsynchronousGreedy(acq) dataset = Dataset(tf.zeros([0, 2]), tf.zeros([0, 1])) state_fn = async_rule.acquire_single(search_space, dataset, QuadraticMeanAndRBFKernel()) state, point1 = state_fn(None) state, point2 = state_fn(state) assert state is not None assert len(state.pending_points) == 2 # let's pretend we saw observations for the first point new_observations = Dataset( query_points=point1, observations=tf.constant([[1]], dtype=tf.float32), ) state_fn = async_rule.acquire_single( search_space, dataset + new_observations, QuadraticMeanAndRBFKernel() ) state, point3 = state_fn(state) assert state is not None assert len(state.pending_points) == 2 # two points from the first batch and all points from second npt.assert_allclose(state.pending_points, tf.concat([point2, point3], axis=0))
(15, False, lambda: TrustRegion()), (15, True, lambda: TrustRegion()), ( 10, False, lambda: EfficientGlobalOptimization( LocalPenalizationAcquisitionFunction( BRANIN_SEARCH_SPACE, ).using(OBJECTIVE), num_query_points=3, ), ), ( 30, False, lambda: AsynchronousGreedy( LocalPenalizationAcquisitionFunction( BRANIN_SEARCH_SPACE, ).using(OBJECTIVE), ), ), ], ), ) def test_ask_tell_optimization_finds_minima_of_the_scaled_branin_function( num_steps: int, reload_state: bool, acquisition_rule_fn: Callable[[], AcquisitionRule[TensorType, SearchSpace]] | Callable[[], AcquisitionRule[State[TensorType, AsynchronousGreedy.State | TrustRegion.State], Box], ], ) -> None: # For the case when optimization state is saved and reload on each iteration # we need to use new acquisition function object to imitate real life usage # hence acquisition rule factory method is passed in, instead of a rule object itself
def test_async_greedy_raises_for_non_greedy_function() -> None: non_greedy_function_builder = NegativeLowerConfidenceBound() with pytest.raises(NotImplementedError): # we are deliberately passing in wrong object # hence type ignore AsynchronousGreedy(non_greedy_function_builder) # type: ignore
dataset: Optional[Dataset] = None, pending_points: Optional[TensorType] = None, new_optimization_step: bool = True, ) -> AcquisitionFunction: self._update_count += 1 return self.prepare_acquisition_function( model, dataset=dataset, pending_points=pending_points ) @random_seed @pytest.mark.parametrize( "rule_fn", [ lambda acq, batch_size: EfficientGlobalOptimization(acq, num_query_points=batch_size), lambda acq, batch_size: AsynchronousGreedy(acq, num_query_points=batch_size), ], ) # As a side effect, this test ensures and EGO and AsynchronousGreedy # behave similarly in sync mode def test_greedy_batch_acquisition_rule_acquire( rule_fn: Callable[ # callable input type(s) [_GreedyBatchModelMinusMeanMaximumSingleBuilder, int], # callable output type AcquisitionRule[TensorType, Box] | AcquisitionRule[State[TensorType, AsynchronousRuleState], Box], ] ) -> None: search_space = Box(tf.constant([-2.2, -1.0]), tf.constant([1.3, 3.3])) num_query_points = 4
function: Optional[AcquisitionFunction], dataset: Dataset, model: ProbabilisticModel, pending_points: Optional[TensorType] = None, new_optimization_step: bool = True, ) -> AcquisitionFunction: self._update_count += 1 return self.prepare_acquisition_function(dataset, model, pending_points) @random_seed @pytest.mark.parametrize( "rule_fn, num_query_points", [ (lambda acq: EfficientGlobalOptimization(acq, num_query_points=4), 4), (lambda acq: AsynchronousGreedy(acq), 1), ], ) # As a side effect, this test ensures and EGO and AsynchronousGreedy # behave similarly in sync mode def test_greedy_batch_acquisition_rule_acquire( rule_fn: Callable[ # callable input type(s) [_GreedyBatchModelMinusMeanMaximumSingleBuilder], # callable output type AcquisitionRule[TensorType, Box] | AcquisitionRule[State[TensorType, AsynchronousGreedy.State], Box], ], num_query_points: int, ) -> None: search_space = Box(tf.constant([-2.2, -1.0]), tf.constant([1.3, 3.3]))
), (12, AsynchronousOptimization(num_query_points=3)), ( 10, EfficientGlobalOptimization( LocalPenalizationAcquisitionFunction( BRANIN_SEARCH_SPACE, ).using(OBJECTIVE), num_query_points=3, ), ), ( 10, AsynchronousGreedy( LocalPenalizationAcquisitionFunction( BRANIN_SEARCH_SPACE, ).using(OBJECTIVE), num_query_points=3, ), ), ( 10, EfficientGlobalOptimization( GIBBON( BRANIN_SEARCH_SPACE, ).using(OBJECTIVE), num_query_points=2, ), ), (15, TrustRegion()), ( 15,