def test_zip_and_unzip(self): space = [{ 'name': 'var_1', 'type': 'continuous', 'domain': (-3, 1), 'dimensionality': 1 }, { 'name': 'var_2', 'type': 'discrete', 'domain': (0, 1, 2, 3), 'dimensionality': 1 }, { 'name': 'var_3', 'type': 'categorical', 'domain': (2, 4, 6) }, { 'name': 'var_4', 'type': 'bandit', 'domain': np.array([[-2], [0], [2]]) }] X = np.array([[0.0, 1, 2, -2], [1.5, 3, 2, 2]]) design_space = Design_space(space) unzipped = design_space.unzip_inputs(X) zipped = design_space.zip_inputs(unzipped) self.assertTrue(np.array_equal(X, zipped))
def test_objective_anchor_points_with_duplicate(self): space = [ {'name': 'var_1', 'type': 'discrete', 'domain':(-1,2)}, {'name': 'var_2', 'type': 'discrete', 'domain': (0,1)}, {'name': 'var_3', 'type': 'categorical', 'domain': (0, 1)} ] design_space = Design_space(space) np.random.seed(666) design_type = "random" dummy_objective = lambda X : np.sum(X*X, axis=1) generator = ObjectiveAnchorPointsGenerator(design_space, design_type, dummy_objective, num_samples=1000) initial_points = np.array([[-1, 1, 0],[-1, 1, 1]]) duplicate_manager = DuplicateManager(design_space, initial_points) # There is a total of 2x2x2=8 possible configurations, minus the 2 defined in initial_points solution = np.array([[-1., 0., 1., 0.], [-1., 0., 0., 1.], [ 2., 0., 1., 0.], [ 2., 0., 0., 1.], [ 2., 1., 1., 0.], [ 2., 1., 0., 1.]]) anchor_points = generator.get(num_anchor=6, duplicate_manager=duplicate_manager, unique=True) self.assertTrue(np.all(anchor_points == solution)) all_points = np.vstack((initial_points,design_space.zip_inputs(solution))) duplicate_manager_with_all_points = DuplicateManager(design_space, all_points) # There aren't any more candidates to generate, hence the exception self.assertRaises(Exception, lambda : generator.get(num_anchor=1, duplicate_manager=duplicate_manager_with_all_points, unique=True))
def test_bandit(self): X = np.array([[0, -2, -1], [0, 0, 1], [1, -2, -1], [1, 0, 1], [3, -2, -1], [3, 0, 1]]) space = [{'name': 'var', 'type': 'bandit', 'domain': X}] design_space = Design_space(space) self.assertTrue(design_space._has_bandit()) self.assertTrue(design_space.unzip_inputs(X).all() == X.all()) self.assertTrue(design_space.zip_inputs(X).all() == X.all())
def test_objective_anchor_points_with_duplicate(self): space = [{ 'name': 'var_1', 'type': 'discrete', 'domain': (-1, 2) }, { 'name': 'var_2', 'type': 'discrete', 'domain': (0, 1) }, { 'name': 'var_3', 'type': 'categorical', 'domain': (0, 1) }] design_space = Design_space(space) np.random.seed(666) design_type = "random" dummy_objective = lambda X: np.sum(X * X, axis=1) generator = ObjectiveAnchorPointsGenerator(design_space, design_type, dummy_objective, num_samples=1000) initial_points = np.array([[-1, 1, 0], [-1, 1, 1]]) duplicate_manager = DuplicateManager(design_space, initial_points) # There is a total of 2x2x2=8 possible configurations, minus the 2 defined in initial_points solution = np.array([[-1., 0., 1., 0.], [-1., 0., 0., 1.], [2., 0., 1., 0.], [2., 0., 0., 1.], [2., 1., 1., 0.], [2., 1., 0., 1.]]) anchor_points = generator.get(num_anchor=6, duplicate_manager=duplicate_manager, unique=True) self.assertTrue(np.all(anchor_points == solution)) all_points = np.vstack( (initial_points, design_space.zip_inputs(solution))) duplicate_manager_with_all_points = DuplicateManager( design_space, all_points) # There aren't any more candidates to generate, hence the exception self.assertRaises( Exception, lambda: generator.get(num_anchor=1, duplicate_manager= duplicate_manager_with_all_points, unique=True))
def test_bandit(self): X = np.array([ [0, -2, -1], [ 0, 0, 1], [ 1, -2, -1], [ 1, 0, 1], [ 3, -2, -1], [ 3, 0, 1]]) space = [{'name': 'var', 'type': 'bandit', 'domain':X}] design_space = Design_space(space) self.assertTrue(design_space._has_bandit()) self.assertTrue(design_space.unzip_inputs(X).all()==X.all()) self.assertTrue(design_space.zip_inputs(X).all()==X.all())
def test_zip_and_unzip(self): space = [ {'name': 'var_1', 'type': 'continuous', 'domain':(-3,1), 'dimensionality': 1}, {'name': 'var_2', 'type': 'discrete', 'domain': (0,1,2,3), 'dimensionality': 1}, {'name': 'var_3', 'type': 'categorical', 'domain': (2, 4, 6)} ] X = np.array([ [0.0, 1, 2], [1.5, 3, 2] ]) design_space = Design_space(space) unzipped = design_space.unzip_inputs(X) zipped = design_space.zip_inputs(unzipped) self.assertTrue(np.array_equal(X, zipped))
class FlexibleBayesianOptimization(BO): def __init__( self, f, domain=None, constraints=None, cost_withGradients=None, model_type='GP', X=None, Y=None, initial_design_numdata=5, initial_design_type='random', acquisition_type='EI', normalize_Y=True, exact_feval=False, acquisition_optimizer_type='lbfgs', model_update_interval=1, evaluator_type='sequential', batch_size=1, num_cores=1, verbosity=False, verbosity_model=False, maximize=False, de_duplication=False, **kwargs ): self.modular_optimization = False self.initial_iter = True self.verbosity = verbosity self.verbosity_model = verbosity_model self.model_update_interval = model_update_interval self.de_duplication = de_duplication self.kwargs = kwargs # --- Handle the arguments passed via kwargs self.problem_config = FlexibleArgumentsManager(kwargs) # --- CHOOSE design space self.constraints = constraints self.domain = domain self.space = Design_space(self.domain, self.constraints) # hoge = self.kwargs.get('domain_without_time', []) # import numpy as np # print("domain_without_time = {}".format(np.asarray(hoge))) # print("domain_with_time = {}".format(np.asarray(self.domain))) self.space_without_time = Design_space(self.kwargs.get('domain_without_time', []), self.constraints) # --- CHOOSE objective function self.maximize = maximize if 'objective_name' in kwargs: self.objective_name = kwargs['objective_name'] else: self.objective_name = 'no_name' self.batch_size = batch_size self.num_cores = num_cores if f is not None: self.f = self._sign(f) self.objective = SingleObjective(self.f, self.batch_size, self.objective_name) else: self.f = None self.objective = None # --- CHOOSE the cost model self.cost = CostModel(cost_withGradients) # --- CHOOSE initial design self.X = X self.Y = Y self.initial_design_type = initial_design_type self.initial_design_numdata = initial_design_numdata self._init_design_chooser() # --- CHOOSE the model type. # If an instance of a GPyOpt model is passed (possibly user defined), # it is used. self.model_type = model_type self.exact_feval = exact_feval # note that this 2 options are not used with the predefined model self.normalize_Y = normalize_Y if 'model' in self.kwargs: if isinstance(kwargs['model'], GPyOpt.models.base.BOModel): self.model = kwargs['model'] self.model_type = 'User defined model used.' print('Using a model defined by the used.') else: self.model = self._model_chooser() else: self.model = self._model_chooser() # --- CHOOSE the acquisition optimizer_type # This states how the discrete variables are handled (exact search or rounding) self.acquisition_optimizer_type = acquisition_optimizer_type if 'is_continuous_time_varying' in self.kwargs and self.kwargs['is_continuous_time_varying']: print("is continuous Varying!") self.acquisition_optimizer = FlexibleAcquisitionOptimizer( self.space_without_time, self.acquisition_optimizer_type, model=self.model, ) # more arguments may come here else: self.acquisition_optimizer = FlexibleAcquisitionOptimizer( self.space, self.acquisition_optimizer_type, model=self.model ) # --- CHOOSE acquisition function. # If an instance of an acquisition is passed (possibly user defined), it is used. self.acquisition_type = acquisition_type if 'acquisition' in self.kwargs: if isinstance(kwargs['acquisition'], GPyOpt.acquisitions.AcquisitionBase): self.acquisition = kwargs['acquisition'] self.acquisition_type = 'User defined acquisition used.' print('Using an acquisition defined by the used.') else: self.acquisition = self._acquisition_chooser() else: self.acquisition = self.acquisition = self._acquisition_chooser() # --- CHOOSE evaluator method self.evaluator_type = evaluator_type self.evaluator = self._evaluator_chooser() # --- Create optimization space super(FlexibleBayesianOptimization, self).__init__( model=self.model, space=self.space, objective=self.objective, acquisition=self.acquisition, evaluator=self.evaluator, X_init=self.X, Y_init=self.Y, cost=self.cost, normalize_Y=self.normalize_Y, model_update_interval=self.model_update_interval, de_duplication=self.de_duplication) def _model_chooser(self): return self.problem_config.model_creator( self.model_type, self.exact_feval, self.space) def _acquisition_chooser(self): return self.problem_config.acquisition_creator( self.acquisition_type, self.model, self.space, self.acquisition_optimizer, self.cost.cost_withGradients, **self.kwargs ) def _evaluator_chooser(self): return self.problem_config.evaluator_creator( self.evaluator_type, self.acquisition, self.batch_size, self.model_type, self.model, self.space, self.acquisition_optimizer) def _init_design_chooser(self): """ Initializes the choice of X and Y based on the selected initial design and number of points selected. """ # If objective function was not provided, we require some initial sample data if self.f is None and (self.X is None or self.Y is None): raise InvalidConfigError( "Initial data for both X and Y is required when objective function is not provided") # Case 1: if self.X is None: self.X = initial_design( self.initial_design_type, self.space, self.initial_design_numdata) self.Y, _ = self.objective.evaluate(self.X) # Case 2 elif self.X is not None and self.Y is None: self.Y, _ = self.objective.evaluate(self.X) def _sign(self, f): if self.maximize: f_copy = f def f(x): return -f_copy(x) return f def _delete_time_param_from_space(self): import pprint space = self.space pprint.pprint(space) return space def _compute_next_evaluations(self, pending_zipped_X=None, ignored_zipped_X=None): """ Computes the location of the new evaluation (optimizes the acquisition in the standard case). :param pending_zipped_X: matrix of input configurations that are in a pending state (i.e., do not have an evaluation yet). :param ignored_zipped_X: matrix of input configurations that the user black-lists, i.e., those configurations will not be suggested again. :return: """ ## --- Update the context if any # self.acquisition.optimizer.context_manager = ContextManager(self.space, self.context) ### --- Activate de_duplication if self.de_duplication: duplicate_manager = DuplicateManager(space=self.space, zipped_X=self.X, pending_zipped_X=pending_zipped_X, ignored_zipped_X=ignored_zipped_X) else: duplicate_manager = None ### We zip the value in case there are categorical variables if 'is_continuous_time_varying' in self.kwargs and self.kwargs['is_continuous_time_varying']: ret = self.space_without_time.zip_inputs(self.evaluator.compute_batch( duplicate_manager=duplicate_manager, context_manager=self.acquisition.optimizer.context_manager)) else: ret = self.space.zip_inputs(self.evaluator.compute_batch( duplicate_manager=duplicate_manager, context_manager=self.acquisition.optimizer.context_manager)) return ret