def test_local_search_acquisition_optimizer_neighbours(): np.random.seed(0) space = ParameterSpace([ CategoricalParameter('a', OneHotEncoding([1, 2, 3])), CategoricalParameter('b', OrdinalEncoding([0.1, 1, 2])), CategoricalParameter('c', OrdinalEncoding([0.1, 1, 2])), DiscreteParameter('d', [0.1, 1.2, 2.3]), ContinuousParameter('e', 0, 100), DiscreteParameter('no_neighbours', [1]), DiscreteParameter('f', [0.1, 1.2, 2.3]), ]) x = np.array([1, 0, 0, 1.6, 2.9, 0.1, 50, 1.2, 1.]) optimizer = LocalSearchAcquisitionOptimizer(space, 1000, 3, num_continuous=1) neighbourhood = optimizer._neighbours_per_parameter(x, space.parameters) assert_equal(np.array([[0, 1, 0], [0, 0, 1]]), neighbourhood[0]) assert_equal(np.array([[1], [3]]), neighbourhood[1]) assert_equal(np.array([[2]]), neighbourhood[2]) assert_equal(np.array([[1.2]]), neighbourhood[3]) assert_almost_equal(np.array([[53.5281047]]), neighbourhood[4]) assert_equal(np.empty((0, 1)), neighbourhood[5]) assert_equal(np.array([[0.1], [2.3]]), neighbourhood[6]) neighbours = optimizer._neighbours(x, space.parameters) assert_almost_equal(np.array([ [0, 1, 0, 2., 3., 0.1, 50., 1., 1.2], [0, 0, 1, 2., 3., 0.1, 50., 1., 1.2], [1, 0, 0, 1., 3., 0.1, 50., 1., 1.2], [1, 0, 0, 3., 3., 0.1, 50., 1., 1.2], [1, 0, 0, 2., 2., 0.1, 50., 1., 1.2], [1, 0, 0, 2., 3., 1.2, 50., 1., 1.2], [1, 0, 0, 2., 3., 0.1, 50.80031442, 1., 1.2], [1, 0, 0, 2., 3., 0.1, 50., 1., 0.1], [1, 0, 0, 2., 3., 0.1, 50., 1., 2.3], ]), space.round(neighbours))
def test_categorical_variables(): np.random.seed(123) def objective(x): return np.array(np.sum(x, axis=1).reshape(-1, 1)) carol_spirits = ["past", "present", "yet to come"] encoding = OneHotEncoding(carol_spirits) parameter_space = ParameterSpace([ ContinuousParameter("real_param", 0.0, 1.0), CategoricalParameter("categorical_param", encoding) ]) x_init = parameter_space.sample_uniform(10) assert x_init.shape == (10, 4) assert np.all(np.logical_or(x_init[:, 1:3] == 0.0, x_init[:, 1:3] == 1.0)) y_init = objective(x_init) gpy_model = GPy.models.GPRegression(x_init, y_init) gpy_model.Gaussian_noise.fix(1) model = GPyModelWrapper(gpy_model) acquisition = ExpectedImprovement(model) loop = BayesianOptimizationLoop(parameter_space, model, acquisition) loop.run_loop(objective, 5) assert len(loop.loop_state.Y) == 15 assert np.all( np.logical_or(loop.loop_state.X[:, 1:3] == 0.0, loop.loop_state.X[:, 1:3] == 1.0))
def test_check_in_domain_with_bandit_parameter(): mixed_space_with_bandit = ParameterSpace([ ContinuousParameter("c", 1.0, 5.0), DiscreteParameter("d", [0, 1, 2]), CategoricalParameter("cat", OneHotEncoding(["blue", "red"])), BanditParameter("bandit", np.array([[0, 1], [1, 1], [1.0, 0]])), ]) x_test = np.array([[1.5, 0, 1.0, 0.0, 0, 1], [1.5, 0, 1.0, 0.0, 0.0, 0.0]]) in_domain = mixed_space_with_bandit.check_points_in_domain(x_test) assert np.array_equal(in_domain, np.array([True, False]))
def test_check_in_domain_with_bandit_parameter(): mixed_space_with_bandit = ParameterSpace([ ContinuousParameter('c', 1.0, 5.0), DiscreteParameter('d', [0, 1, 2]), CategoricalParameter('cat', OneHotEncoding(['blue', 'red'])), BanditParameter('bandit', np.array([[0, 1], [1, 1], [1., 0]])) ]) x_test = np.array([[1.5, 0, 1., 0., 0, 1], [1.5, 0, 1., 0., 0., 0.]]) in_domain = mixed_space_with_bandit.check_points_in_domain(x_test) assert np.array_equal(in_domain, np.array([True, False]))
def catg_space(): return ParameterSpace([ ContinuousParameter("x1", 0, 15), CategoricalParameter("x2", OneHotEncoding(["A", "B", "C", "D"])), CategoricalParameter("x3", OneHotEncoding([1, 2, 3, 4, 5])), ContinuousParameter("x4", -2, 3), ])
def space(): space = ParameterSpace([ ContinuousParameter("x1", 0, 1), ContinuousParameter("x2", 0, 1), ContinuousParameter("x3", 0, 1) ]) return space
def test_local_search_acquisition_optimizer(simple_square_acquisition): space = ParameterSpace( [CategoricalParameter("x", OrdinalEncoding(np.arange(0, 100)))]) optimizer = LocalSearchAcquisitionOptimizer(space, 1000, 3) opt_x, opt_val = optimizer.optimize(simple_square_acquisition) # ordinal encoding is as integers 1, 2, ... np.testing.assert_array_equal(opt_x, np.array([[1.0]])) np.testing.assert_array_equal(opt_val, np.array([[0.0]])) class UnknownParameter(Parameter): def __init__(self, name: str): self.name = name def sample_uniform(num_points): return np.random.randint(0, 1, (num_points, 1)) space.parameters.append(UnknownParameter("y")) with pytest.raises(TypeError): optimizer.optimize(simple_square_acquisition) space.parameters.pop() class UnknownEncoding(Encoding): def __init__(self): super().__init__([1], [[1]]) space.parameters.append(CategoricalParameter("y", UnknownEncoding())) with pytest.raises(TypeError): optimizer.optimize(simple_square_acquisition) space.parameters.pop()
def multi_source_optimizer(): mock_acquisition_optimizer = mock.create_autospec(AcquisitionOptimizer) mock_acquisition_optimizer.optimize.return_value = (np.array([[0.]]), None) space = ParameterSpace( [ContinuousParameter('x', 0, 1), InformationSourceParameter(2)]) return MultiSourceAcquisitionOptimizer(mock_acquisition_optimizer, space)
def branin_function(): """ Two-dimensional Branin, often used as an optimization benchmark. Based on: https://www.sfu.ca/~ssurjano/branin.html .. math:: f(\mathbf{x}) = (x_2 - b x_1 ^ 2 + c x_1 - r) ^ 2 + s(1 - t) \cos(x_1) + s where: .. math:: b = 5.1 / (4 \pi ^ 2) c = 5 /\pi r = 6 s = 10 t = 1 / (8\pi) """ parameter_space = ParameterSpace( [ContinuousParameter("x1", -5, 10), ContinuousParameter("x2", 0, 15)]) return _branin, parameter_space
def space(): space = ParameterSpace([ ContinuousParameter('x1', 0, 1), ContinuousParameter('x2', 0, 1), ContinuousParameter('x3', 0, 1) ]) return space
def get_next_memory_windows(trace_file, cache_type, cache_size, n_early_stop, seq_start, parameters, args_global): # use 80% warmup, manually check for unimodal behavior n_warmup = int(0.8 * n_early_stop) # per cache size parameters overwrite other parameters df = database.load_reports( trace_file=trace_file, cache_type=cache_type, cache_size=str(cache_size), seq_start=str(seq_start), n_early_stop=str(n_early_stop), n_warmup=n_warmup, version=parameters['version'], # use version as a strong key dburi=parameters["dburi"], dbcollection=parameters["dbcollection"], ) if len(df) == 0: next_windows = np.linspace(1, int(0.4 * n_early_stop), args_global['n_beam'] + 1, dtype=int)[1:] else: # window at most 40% of length parameter_space = ParameterSpace( [ContinuousParameter('x', 1, int(0.4 * n_early_stop))]) bo = GPBayesianOptimization( variables_list=parameter_space.parameters, X=df['memory_window'].values.reshape(-1, 1), Y=df['byte_miss_ratio'].values.reshape(-1, 1), batch_size=args_global['n_beam']) next_windows = bo.suggest_new_locations().reshape(-1).astype(int) return next_windows
def test_montecarlo_sensitivity(): ishigami = Ishigami(a=5, b=0.1) space = ParameterSpace([ ContinuousParameter('x1', -np.pi, np.pi), ContinuousParameter('x2', -np.pi, np.pi), ContinuousParameter('x3', -np.pi, np.pi) ]) num_mc = 1000 np.random.seed(0) senstivity_ishigami = MonteCarloSensitivity(ishigami.fidelity1, space) senstivity_ishigami.generate_samples(1) main_sample = np.array([[3.10732573, -1.25504469, -2.66820221], [-1.32105416, -1.45224686, -2.06642419], [2.41144646, -1.98949844, 1.66646315]]) fixing_sample = np.array([[-2.93034587, -2.62148462, 1.71694805], [-2.70120457, 2.60061313, 3.00826754], [-2.56283615, 2.53817347, -1.00496868]]) main_effects, total_effects, total_variance = senstivity_ishigami.compute_effects( main_sample=main_sample, fixing_sample=fixing_sample, num_monte_carlo_points=num_mc) keys = space.parameter_names assert (all(k in main_effects for k in keys)) assert (all(k in total_effects for k in keys))
def get_validation_tasks_per_cache_size(trace_file, cache_type, cache_size, parameters, args_global, df): n_req = parameters['n_req'] n_validation = int(n_req * args_global['ratio_validation']) n_iteration = args_global['n_iteration'] n_beam = args_global['n_beam'] if len(df) == 0 or len(df[df['cache_size'] == cache_size]) == 0: # init value next_windows = np.linspace(1, int(0.4 * n_validation), args_global['n_beam'] + 1, dtype=int)[1:] tasks = [] for memory_window in next_windows: # override n_early stop task = _get_task(trace_file, cache_type, cache_size, parameters, n_validation, memory_window) tasks.append(task) return tasks # as emukit output is random, don't assume same points each time, as long as # point is enough df1 = df[df['cache_size'] == cache_size] if len(df1) >= n_iteration * n_beam: return [] # next round # window at most 40% of length # add xs, ys in a consistent order otherwise the results will be difference parameter_space = ParameterSpace([ContinuousParameter('x', 1, int(0.4 * n_validation))]) bo = GPBayesianOptimization(variables_list=parameter_space.parameters, X=df1['memory_window'].values.reshape(-1, 1), Y=df1['byte_miss_ratio'].values.reshape(-1, 1), batch_size=args_global['n_beam']) next_windows = bo.suggest_new_locations().reshape(-1).astype(int) tasks = [] for memory_window in next_windows: task = _get_task(trace_file, cache_type, cache_size, parameters, n_validation, memory_window) tasks.append(task) return tasks
def Intervention_function(*interventions, model, target_variable, min_intervention, max_intervention): num_samples = 100000 assert len(min_intervention) == len(interventions[0]) assert len(max_intervention) == len(interventions[0]) def compute_target_function_fcn(value): num_interventions = len(interventions[0]) for i in range(num_interventions): interventions[0][list(interventions[0].keys())[i]] = value[0, i] mutilated_model = intervene_dict(model, **interventions[0]) np.random.seed(1) samples = [ sample_from_model(mutilated_model) for _ in range(num_samples) ] samples = pd.DataFrame(samples) return np.asarray(np.mean(samples['Y']))[np.newaxis, np.newaxis] ## Define parameter space list_parameter = [None] * len(interventions[0]) for i in range(len(interventions[0])): list_parameter[i] = ContinuousParameter( list(interventions[0].keys())[i], min_intervention[i], max_intervention[i]) return (compute_target_function_fcn, ParameterSpace(list_parameter))
def catg_space(): return ParameterSpace([ ContinuousParameter('x1', 0, 15), CategoricalParameter('x2', OneHotEncoding([0, 1, 2, 3])), CategoricalParameter('x3', OneHotEncoding([1, 2, 3, 4, 5])), ContinuousParameter('x4', -2, 3) ])
def bayesian_opt(): # 2. ranges of the synth parameters syn1 = syn2 = syn3 = syn4 = syn5 = np.arange(158) syn6 = np.arange(6000) syn7 = np.arange(1000) syn8 = np.arange(700) # 2. synth paramters ranges into an 8D parameter space # parameter_space = ParameterSpace( # [ContinuousParameter('x1', 0., 157.)]) # parameter_space = ParameterSpace( # [DiscreteParameter('x8', syn8)]) parameter_space = ParameterSpace( [ContinuousParameter('x1', 0., 157.), ContinuousParameter('x2', 0., 157.), ContinuousParameter('x3', 0., 157.), ContinuousParameter('x4', 0., 157.), ContinuousParameter('x5', 0., 157.), ContinuousParameter('x6', 0., 5999.), ContinuousParameter('x7', 0., 999.), ContinuousParameter('x8', 0., 699.)]) # parameter_space = ParameterSpace( # [DiscreteParameter('x1', syn1), DiscreteParameter('x2', syn2), DiscreteParameter('x3', syn3), # DiscreteParameter('x4', syn4), DiscreteParameter('x5', syn5), DiscreteParameter('x6', syn6), # DiscreteParameter('x7', syn1), DiscreteParameter('x8', syn8)]) # 3. collect random points design = RandomDesign(parameter_space) X = design.get_samples(num_data_points) # X is a numpy array print("X=", X) # [is the below needed?] # UserFunction.evaluate(training_function, X) # I put UserFunctionWrapper in line 94 # 4. define training_function as Y Y = training_function(X) # [is this needed?] # loop_state = create_loop_state(X, Y) # 5. train and wrap the model in Emukit model_gpy = GPRegression(X, Y, normalizer=True) model_emukit = GPyModelWrapper(model_gpy) expected_improvement = ExpectedImprovement(model=model_emukit) bayesopt_loop = BayesianOptimizationLoop(model=model_emukit, space=parameter_space, acquisition=expected_improvement, batch_size=5) max_iterations = 15 bayesopt_loop.run_loop(training_function, max_iterations) model_gpy.plot() plt.show() results = bayesopt_loop.get_results() # bayesopt_loop.loop_state.X print("X: ", bayesopt_loop.loop_state.X) print("Y: ", bayesopt_loop.loop_state.Y) print("cost: ", bayesopt_loop.loop_state.cost)
def multi_fidelity_borehole_function(high_noise_std_deviation=0, low_noise_std_deviation=0): """ Two level borehole function. The Borehole function models water flow through a borehole. Its simplicity and quick evaluation makes it a commonly used function for testing a wide variety of methods in computer experiments. See reference for equations: https://www.sfu.ca/~ssurjano/borehole.html :param high_noise_std_deviation: Standard deviation of Gaussian observation noise on high fidelity observations. Defaults to zero. :param low_noise_std_deviation: Standard deviation of Gaussian observation noise on low fidelity observations. Defaults to zero. :return: Tuple of user function object and parameter space """ parameter_space = ParameterSpace([ ContinuousParameter('borehole_radius', 0.05, 0.15), ContinuousParameter('radius_of_influence', 100, 50000), ContinuousParameter('upper_aquifer_transmissivity', 63070, 115600), ContinuousParameter('upper_aquifer_head', 990, 1110), ContinuousParameter('lower_aquifer_transmissivity', 63.1, 116), ContinuousParameter('lower_aquifer_head', 700, 820), ContinuousParameter('borehole_length', 1120, 1680), ContinuousParameter('hydraulic_conductivity', 9855, 12045), InformationSourceParameter(2)]) user_function = MultiSourceFunctionWrapper([ lambda x: borehole_low(x, low_noise_std_deviation), lambda x: borehole_high(x, high_noise_std_deviation)]) return user_function, parameter_space
def multi_fidelity_forrester_function(high_fidelity_noise_std_deviation=0, low_fidelity_noise_std_deviation=0): """ Two-level multi-fidelity forrester function where the high fidelity is given by: .. math:: f(x) = (6x - 2)^2 \sin(12x - 4) and the low fidelity approximation given by: .. math:: f_{low}(x) = 0.5 f_{high}(x) + 10 (x - 0.5) + 5 :param high_fidelity_noise_std_deviation: Standard deviation of observation noise on high fidelity observations. Defaults to zero. :param low_fidelity_noise_std_deviation: Standard deviation of observation noise on low fidelity observations. Defaults to zero. :return: Tuple of user function object and parameter space object """ parameter_space = ParameterSpace([ContinuousParameter("x", 0, 1), InformationSourceParameter(2)]) user_function = MultiSourceFunctionWrapper( [ lambda x: forrester_low(x, low_fidelity_noise_std_deviation), lambda x: forrester(x, high_fidelity_noise_std_deviation), ] ) return user_function, parameter_space
def multi_source_entropy_search_acquisition(gpy_model): space = ParameterSpace( [ContinuousParameter("x1", 0, 1), InformationSourceParameter(2)]) return MultiInformationSourceEntropySearch(gpy_model, space, num_representer_points=10)
def test_loop(): n_iterations = 5 x_init = np.random.rand(5, 1) y_init, y_constraint_init = f(x_init) # Make GPy objective model gpy_model = GPy.models.GPRegression(x_init, y_init) model = GPyModelWrapper(gpy_model) # Make GPy constraint model gpy_constraint_model = GPy.models.GPRegression(x_init, y_init) constraint_model = GPyModelWrapper(gpy_constraint_model) space = ParameterSpace([ContinuousParameter("x", 0, 1)]) acquisition = ExpectedImprovement(model) # Make loop and collect points bo = UnknownConstraintBayesianOptimizationLoop( model_objective=model, space=space, acquisition=acquisition, model_constraint=constraint_model ) bo.run_loop( UserFunctionWrapper(f, extra_output_names=["Y_constraint"]), FixedIterationsStoppingCondition(n_iterations) ) # Check we got the correct number of points assert bo.loop_state.X.shape[0] == n_iterations + 5
def Hartmann3(): parameter_space = ParameterSpace([ ContinuousParameter('x1', 0, 1), ContinuousParameter('x2', 0, 1), ContinuousParameter('x3', 0, 1) ]) return _Hartmann3, parameter_space
def test_iteration_end_event(): space = ParameterSpace([ContinuousParameter('x', 0, 1)]) def user_function(x): return x x_test = np.linspace(0, 1)[:, None] y_test = user_function(x_test) x_init = np.linspace(0, 1, 5)[:, None] y_init = user_function(x_init) gpy_model = GPy.models.GPRegression(x_init, y_init) model = GPyModelWrapper(gpy_model) mse = [] def compute_mse(self, loop_state): mse.append(np.mean(np.square(model.predict(x_test)[0] - y_test))) loop_state = create_loop_state(x_init, y_init) acquisition = ModelVariance(model) acquisition_optimizer = AcquisitionOptimizer(space) candidate_point_calculator = SequentialPointCalculator( acquisition, acquisition_optimizer) model_updater = FixedIntervalUpdater(model) loop = OuterLoop(candidate_point_calculator, model_updater, loop_state) loop.iteration_end_event.append(compute_mse) loop.run_loop(user_function, 5) assert len(mse) == 5
def initialize(self): parameter_space = ParameterSpace([ ContinuousParameter("x%d" % index, bounds[0], bounds[1]) for index, bounds in enumerate(self.problem.bounds) ] + [InformationSourceParameter(len(self.problem.fidelities))]) # Obtain initial sample design = LatinDesign(parameter_space) initial_parameters = design.get_samples(self.initial_sample_count) initial_response = self._evaluate_batch(initial_parameters) kernels = [GPy.kern.RBF(1)] * len(self.problem.fidelities) kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel(kernels) model = GPyLinearMultiFidelityModel( initial_parameters, initial_response, kernel, n_fidelities = len(self.problem.fidelities) ) model = GPyMultiOutputWrapper(model, len(self.problem.fidelities)) acquisition = NegativeLowerConfidenceBound(model) self.loop = BayesianOptimizationLoop( model = model, space = parameter_space, acquisition = acquisition, batch_size = self.batch_size )
def test_categorical_variables(): np.random.seed(123) def objective(x): return np.array(np.sum(x, axis=1).reshape(-1, 1)) carol_spirits = ['past', 'present', 'yet to come'] encoding = OneHotEncoding(carol_spirits) parameter_space = ParameterSpace([ ContinuousParameter('real_param', 0.0, 1.0), CategoricalParameter('categorical_param', encoding) ]) random_design = LatinDesign(parameter_space) x_init = random_design.get_samples(10) assert x_init.shape == (10, 4) assert np.all(np.logical_or(x_init[:, 1:3] == 0.0, x_init[:, 1:3] == 1.0)) y_init = objective(x_init) gpy_model = GPy.models.GPRegression(x_init, y_init) gpy_model.Gaussian_noise.fix(1) model = GPyModelWrapper(gpy_model) loop = ExperimentalDesignLoop(parameter_space, model) loop.run_loop(objective, 5) assert len(loop.loop_state.Y) == 15 assert np.all(np.logical_or(loop.loop_state.X[:, 1:3] == 0.0, loop.loop_state.X[:, 1:3] == 1.0))
def multi_fidelity_non_linear_sin(high_fidelity_noise_std_deviation=0, low_fidelity_noise_std_deviation=0): """ Two level non-linear sin function where high fidelity is given by: .. math:: f_{high}(x) = (x - \sqrt{2}) f_{low}(x)^2 and the low fidelity is: .. math:: f_{low}(x) = \sin(8 \pi x) Reference: Nonlinear information fusion algorithms for data-efficient multi-fidelity modelling. P. Perdikaris, M. Raissi, A. Damianou, N. D. Lawrence and G. E. Karniadakis (2017) http://web.mit.edu/parisp/www/assets/20160751.full.pdf """ parameter_space = ParameterSpace( [ContinuousParameter("x1", -5, 10), InformationSourceParameter(2)]) user_function = MultiSourceFunctionWrapper([ lambda x: nonlinear_sin_low(x, low_fidelity_noise_std_deviation), lambda x: nonlinear_sin_high(x, high_fidelity_noise_std_deviation), ]) return user_function, parameter_space
def test_continuous_entropy_search(): rng = np.random.RandomState(42) x_init = rng.rand(5, 1) s_min = 10 s_max = 10000 s = np.random.uniform(s_min, s_max, x_init.shape[0]) x_init = np.concatenate((x_init, s[:, None]), axis=1) y_init = rng.rand(5, 1) model = FabolasModel(X_init=x_init, Y_init=y_init, s_min=s_min, s_max=s_max) space = ParameterSpace([ ContinuousParameter("x", 0, 1), ContinuousParameter("s", np.log(s_min), np.log(s_max)) ]) es = ContinuousFidelityEntropySearch(model, space, num_representer_points=10) es.update_pmin() assert np.all(es.representer_points[:, -1] == np.log(s_max))
def test_random_design_returns_correct_number_of_points(): p = ContinuousParameter('c', 1.0, 5.0) space = ParameterSpace([p]) points_count = 5 points = RandomDesign(space).get_samples(points_count) assert points_count == len(points)
def create_bayesian_optimization_loop( gpy_model: ComparisonGP, lims: np.array, batch_size: int, acquisition: AcquisitionFunction) -> BayesianOptimizationLoop: """ Creates Bayesian optimization loop for Bayesian neural network or random forest models. :param gpy_model: the GPy model used in optimization :param lims: Optimization limits for the inputs :param batch_size: number of observations used in batch :param acquisition: acquisition function used in the bayesian optimization :return: emukit BO loop """ # Create model model = ComparisonGPEmukitWrapper(gpy_model, batch_size) # Create acquisition emukit_acquisition = EmukitAcquisitionFunctionWrapper(model, acquisition) if type(emukit_acquisition.acquisitionFunction) is ThompsonSampling: parameter_space = [] for j in range(len(lims)): parameter_space += [ ContinuousParameter("x{}".format(j), lims[j][0], lims[j][1]) ] parameter_space = ParameterSpace(parameter_space) acquisition_optimizer = SequentialGradientAcquisitionOptimizer( parameter_space, batch_size) else: parameter_space = [] for k in range(batch_size): for j in range(len(lims)): parameter_space += [ ContinuousParameter("x{}{}".format(k, j), lims[j][0], lims[j][1]) ] parameter_space = ParameterSpace(parameter_space) acquisition_optimizer = GradientAcquisitionOptimizer(parameter_space) bo = BayesianOptimizationLoop(model=model, space=parameter_space, acquisition=emukit_acquisition) return BayesianOptimizationLoop( model=model, space=parameter_space, acquisition=emukit_acquisition, acquisition_optimizer=acquisition_optimizer)
def test_random_sampling_with_context(): space = ParameterSpace([ContinuousParameter("x", 0, 1), ContinuousParameter("y", 0, 1)]) rs = RandomSampling(space) loop_state_mock = mock.create_autospec(LoopState) next_points = rs.compute_next_points(loop_state_mock, context={"x": 0.25}) assert len(next_points) == 1 # Context value should be what we set assert np.isclose(next_points[0, 0], 0.25)
def test_random_sampling_without_context(): space = ParameterSpace( [ContinuousParameter('x', 0, 1), ContinuousParameter('y', 0, 1)]) rs = RandomSampling(space) loop_state_mock = mock.create_autospec(LoopState) next_points = rs.compute_next_points(loop_state_mock) assert (len(next_points) == 1)