def one_step_acquisition_gp(oracle, full_train_X, full_train_Y, acq, q, bounds, dim, domain, domain_image, state_dict=None, plot_stuff=False): model = SingleTaskGP(full_train_X, full_train_Y) mll = ExactMarginalLogLikelihood(model.likelihood, model) if state_dict is not None: model.load_state_dict(state_dict) fit_gpytorch_model(mll) candidate, EI = get_candidate(model, acq, full_train_Y, q, bounds, dim) if acq == 'EI' and dim == 1 and plot_stuff: plot_util(oracle, model, EI, domain, domain_image, None, full_train_X, full_train_Y, candidate) candidate_image = oracle(candidate) full_train_X = torch.cat([full_train_X, candidate]) full_train_Y = torch.cat([full_train_Y, candidate_image]) state_dict = model.state_dict() return full_train_X, full_train_Y, model, candidate, candidate_image, state_dict
def fit(self, train_x, train_y): n = train_y.shape[0] self.mll = gpytorch.mlls.VariationalELBO(self.likelihood, self.model, n) self.model.train() self.model.set_train_data(train_x, train_y) fit_gpytorch_model(self.mll)
def run(self): self._previous_hyperparams = None self._optimization_point_number = 0 # this basically implements Bayes Opt loop, closely following # https://botorch.org/tutorials/multi_objective_bo for iteration in range(1, self._num_instances + 1): fit_gpytorch_model(self._torch_mll) ########################### params_set, transformed_eps, transformed_err = self._torch_optimize_qehvi_and_get_observation( ) ############################## # Update privacy and utility GPs with new data # In BoTorch example they actualy define new GP objects on each iteration # let's try that too train_x = torch.cat([self._privacy_gp.train_inputs[0], params_set]) train_privacy_y = torch.cat( [self._privacy_gp.train_targets, transformed_eps]) train_utility_y = torch.cat( [self._utility_gp.train_targets, transformed_err]) self._create_models(train_x, train_privacy_y, train_utility_y) # Post final run tasks hypervolume = self.get_untransformed_hypervolume() self._saved_hypervolumes.append(hypervolume) print("Hypervolume is: {}".format(hypervolume)) self._estimate_last_point() self._plot_and_save()
def fit_uncertainty_estimator(self, features=None, targets=None): if self.no_deup: return None self.e_predictor = SingleTaskGP(features, targets) mll = ExactMarginalLogLikelihood(self.e_predictor.likelihood, self.e_predictor) fit_gpytorch_model(mll)
def argmax_posterior_mean(cands: to.Tensor, cands_values: to.Tensor, ddp_space: BoxSpace, num_restarts: int, num_samples: int) -> to.Tensor: """ Compute the GP input with the maximal posterior mean. :param cands: candidates a.k.a. x :param cands_values: observed values a.k.a. y :param ddp_space: space of the domain distribution parameters, indicates the lower and upper bound :param num_restarts: number of restarts for the optimization of the acquisition function :param num_samples: number of samples for the optimization of the acquisition function :return: un-normalized candidate with maximum posterior value a.k.a. x """ if not isinstance(cands, to.Tensor): raise pyrado.TypeErr(given=cands, expected_type=to.Tensor) if not isinstance(cands_values, to.Tensor): raise pyrado.TypeErr(given=cands_values, expected_type=to.Tensor) if not isinstance(ddp_space, BoxSpace): raise pyrado.TypeErr(given=ddp_space, expected_type=BoxSpace) # Normalize the input data and standardize the output data uc_projector = UnitCubeProjector( to.from_numpy(ddp_space.bound_lo).to(dtype=to.get_default_dtype()), to.from_numpy(ddp_space.bound_up).to(dtype=to.get_default_dtype()), ) cands_norm = uc_projector.project_to(cands) cands_values_stdized = standardize(cands_values) if cands_norm.shape[0] > cands_values.shape[0]: print_cbt( f"There are {cands.shape[0]} candidates but only {cands_values.shape[0]} evaluations. Ignoring " f"the candidates without evaluation for computing the argmax.", "y", ) cands_norm = cands_norm[:cands_values.shape[0], :] # Create and fit the GP model gp = SingleTaskGP(cands_norm, cands_values_stdized) gp.likelihood.noise_covar.register_constraint("raw_noise", GreaterThan(1e-5)) mll = ExactMarginalLogLikelihood(gp.likelihood, gp) fit_gpytorch_model(mll) # Find position with maximal posterior mean cand_norm, _ = optimize_acqf( acq_function=PosteriorMean(gp), bounds=to.stack( [to.zeros(ddp_space.flat_dim), to.ones(ddp_space.flat_dim)]).to(dtype=to.float32), q=1, num_restarts=num_restarts, raw_samples=num_samples, ) cand_norm = cand_norm.to(dtype=to.get_default_dtype()) cand = uc_projector.project_back(cand_norm.detach()) print_cbt(f"Converged to argmax of the posterior mean: {cand.numpy()}", "g", bright=True) return cand
def fit(self): if not self.fitted: mll = ExactMarginalLogLikelihood(self.gp_model.likelihood, self.gp_model) fit_gpytorch_model(mll) if self.domain is not None and self.postprocessor is not None: self.fit_postprocessor_on_domain(self.domain)
def get_map_model( train_X: Tensor, train_Y: Tensor, train_Yvar: Tensor, decomposition: Dict[str, List[int]], train_embedding: bool = True, cat_feature_dict: Optional[Dict] = None, embs_feature_dict: Optional[Dict] = None, embs_dim_list: Optional[List[int]] = None, context_weight_dict: Optional[Dict] = None, ) -> Tuple[LCEAGP, ExactMarginalLogLikelihood]: """Obtain MAP fitting of Latent Context Embedding Additive (LCE-A) GP.""" # assert train_X is non-batched assert train_X.dim() < 3, "Don't support batch training" model = LCEAGP( train_X=train_X, train_Y=train_Y, train_Yvar=train_Yvar, decomposition=decomposition, train_embedding=train_embedding, embs_dim_list=embs_dim_list, cat_feature_dict=cat_feature_dict, embs_feature_dict=embs_feature_dict, context_weight_dict=context_weight_dict, ) mll = ExactMarginalLogLikelihood(model.likelihood, model) fit_gpytorch_model(mll) return model, mll
def optimize_EI(gp, best_f, n_dim): """ Reference: https://botorch.org/api/optim.html bounds: 2d-ndarray (2, D) The values of lower and upper bound of each parameter. q: int The number of candidates to sample num_restarts: int The number of starting points for multistart optimization. raw_samples: int The number of initial points. Returns for joint_optimize is (num_restarts, q, D) """ mll = ExactMarginalLogLikelihood(gp.likelihood, gp) fit_gpytorch_model(mll) ei = ExpectedImprovement(gp, best_f=best_f, maximize=False) bounds = torch.from_numpy(np.array([[0.] * n_dim, [1.] * n_dim])) x = joint_optimize(ei, bounds=bounds, q=1, num_restarts=3, raw_samples=15) return np.array(x[0])
def _setUp(self, double=False): dtype = torch.double if double else torch.float train_x = torch.linspace(0, 1, 10, device=self.device, dtype=dtype).unsqueeze(-1) train_y = torch.sin(train_x * (2 * math.pi)) train_yvar = torch.tensor(0.1**2, device=self.device) noise = torch.tensor(NOISE, device=self.device, dtype=dtype) self.train_x = train_x self.train_y = train_y + noise self.train_yvar = train_yvar self.bounds = torch.tensor([[0.0], [1.0]], device=self.device, dtype=dtype) model_st = SingleTaskGP(self.train_x, self.train_y) self.model_st = model_st.to(device=self.device, dtype=dtype) self.mll_st = ExactMarginalLogLikelihood(self.model_st.likelihood, self.model_st) with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=OptimizationWarning) self.mll_st = fit_gpytorch_model(self.mll_st, options={"maxiter": 5}, max_retries=1) model_fn = FixedNoiseGP(self.train_x, self.train_y, self.train_yvar.expand_as(self.train_y)) self.model_fn = model_fn.to(device=self.device, dtype=dtype) self.mll_fn = ExactMarginalLogLikelihood(self.model_fn.likelihood, self.model_fn) with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=OptimizationWarning) self.mll_fn = fit_gpytorch_model(self.mll_fn, options={"maxiter": 5}, max_retries=1)
def _setUp(self, double=False, cuda=False): device = torch.device("cuda") if cuda else torch.device("cpu") dtype = torch.double if double else torch.float train_x = torch.linspace(0, 1, 10, device=device, dtype=dtype).unsqueeze(-1) train_y = torch.sin(train_x * (2 * math.pi)).squeeze(-1) train_yvar = torch.tensor(0.1 ** 2, device=device) noise = torch.tensor(NOISE, device=device, dtype=dtype) self.train_x = train_x self.train_y = train_y + noise self.train_yvar = train_yvar self.bounds = torch.tensor([[0.0], [1.0]], device=device, dtype=dtype) model_st = SingleTaskGP(self.train_x, self.train_y) self.model_st = model_st.to(device=device, dtype=dtype) self.mll_st = ExactMarginalLogLikelihood( self.model_st.likelihood, self.model_st ) self.mll_st = fit_gpytorch_model(self.mll_st, options={"maxiter": 5}) model_fn = FixedNoiseGP( self.train_x, self.train_y, self.train_yvar.expand_as(self.train_y) ) self.model_fn = model_fn.to(device=device, dtype=dtype) self.mll_fn = ExactMarginalLogLikelihood( self.model_fn.likelihood, self.model_fn ) self.mll_fn = fit_gpytorch_model(self.mll_fn, options={"maxiter": 5})
def fit( self, training_data: TrainingData, bounds: List[Tuple[float, float]], task_features: List[int], feature_names: List[str], metric_names: List[str], fidelity_features: List[int], target_fidelities: Optional[Dict[int, float]] = None, candidate_metadata: Optional[List[List[TCandidateMetadata]]] = None, state_dict: Optional[Dict[str, Tensor]] = None, refit: bool = True, ) -> None: if self._model is None or self._should_reconstruct: self.construct( training_data=training_data, fidelity_features=fidelity_features, # Kwargs below are unused in base `Surrogate`, but used in subclasses. metric_names=metric_names, task_features=task_features, ) if state_dict is not None: self.model.load_state_dict(state_dict) if state_dict is None or refit: # pyre-ignore[16]: Model has no attribute likelihood. # All BoTorch `Model`-s expected to work with this setup have likelihood. mll = self.mll_class(self.model.likelihood, self.model) fit_gpytorch_model(mll)
def get_gpr_model(X, y, model=None): """ Fit a gpr model to the data or update the model to new data Params :: X: (sx1) Tensor: Covariates y: (sx1) Tensor: Observations model: PyTorch SingleTaskGP model: If model is passed, X and y are used to update it. If None then model is trained on X and y. Default is None Return :: model: PyTorch SingleTaskGP model: Trained or updated model. Returned in train mode mll: PyTorch MarginalLogLikelihood object: Returned in train mode """ if model is None: # set up model model = SingleTaskGP(X, y) else: # update model with new observations model = model.condition_on_observations(X, y) mll = ExactMarginalLogLikelihood(model.likelihood, model).to(X) # begin training model.train() mll.train() fit_gpytorch_model(mll) return model, mll
def CreateModel(xtrain, ytrain): ''' Creates and trains a GpyTorch GP model. ''' model = SingleTaskGP(xtrain, ytrain) mll = ExactMarginalLogLikelihood(model.likelihood, model) fit_gpytorch_model(mll); return(model)
def fit( self, training_data: TrainingData, search_space_digest: SearchSpaceDigest, metric_names: List[str], candidate_metadata: Optional[List[List[TCandidateMetadata]]] = None, state_dict: Optional[Dict[str, Tensor]] = None, refit: bool = True, ) -> None: """Fits the underlying BoTorch ``Model`` to ``m`` outcomes. NOTE: ``state_dict`` and ``refit`` keyword arguments control how the undelying BoTorch ``Model`` will be fit: whether its parameters will be reoptimized and whether it will be warm-started from a given state. There are three possibilities: * ``fit(state_dict=None)``: fit model from stratch (optimize model parameters and set its training data used for inference), * ``fit(state_dict=some_state_dict, refit=True)``: warm-start refit with a state dict of parameters (still re-optimize model parameters and set the training data), * ``fit(state_dict=some_state_dict, refit=False)``: load model parameters without refitting, but set new training data (used in cross-validation, for example). Args: training data: BoTorch ``TrainingData`` container with Xs, Ys, and possibly Yvars, to be passed to ``Model.construct_inputs`` in BoTorch. search_space_digest: A SearchSpaceDigest object containing metadata on the features in the trainig data. metric_names: Names of each outcome Y in Ys. candidate_metadata: Model-produced metadata for candidates, in the order corresponding to the Xs. state_dict: Optional state dict to load. refit: Whether to re-optimize model parameters. """ if self._constructed_manually: logger.debug( "For manually constructed surrogates (via `Surrogate.from_botorch`), " "`fit` skips setting the training data on model and only reoptimizes " "its parameters if `refit=True`." ) else: self.construct( training_data=training_data, metric_names=metric_names, **dataclasses.asdict(search_space_digest) ) if state_dict: # pyre-fixme[6]: Expected `OrderedDict[typing.Any, typing.Any]` for 1st # param but got `Dict[str, Tensor]`. self.model.load_state_dict(not_none(state_dict)) if state_dict is None or refit: mll = self.mll_class(self.model.likelihood, self.model, **self.mll_options) fit_gpytorch_model(mll)
def get_fitted_model(x, obj, state_dict=None): # initialize and fit model fitted_model = SingleTaskGP(train_X=x, train_Y=obj) if state_dict is not None: fitted_model.load_state_dict(state_dict) mll = ExactMarginalLogLikelihood(fitted_model.likelihood, fitted_model) mll.to(x) fit_gpytorch_model(mll) return fitted_model
def _initialize_model(self, num_init_samples: int) -> None: """ initialize the GP model with num_init_samples of initial samples """ self.train_X = torch.rand((num_init_samples, self.dim)) self.train_Y = self._function_call(self.train_X) self.model = SingleTaskGP( self.train_X, self.train_Y, outcome_transform=Standardize(m=1) ) mll = ExactMarginalLogLikelihood(self.model.likelihood, self.model) fit_gpytorch_model(mll)
def _update_model(self, new_sample: Tensor, new_observation: Tensor) -> None: """ Update the GP model with the new observation(s) :param new_sample: sampled point :param new_observation: observed function value """ self.train_X = torch.cat((self.train_X, new_sample), 0) self.train_Y = torch.cat((self.train_Y, new_observation), 0) self.model = self.model.condition_on_observations(new_sample, new_observation) if self.retrain_gp: mll = ExactMarginalLogLikelihood(self.model.likelihood, self.model) fit_gpytorch_model(mll)
def initialize_model(): # generate synthetic data X = torch.rand(20, 2) Y = torch.stack([torch.sin(X[:, 0]), torch.cos(X[:, 1])], -1) # construct and fit the multi-output model gp = SingleTaskGP(X, Y) mll = ExactMarginalLogLikelihood(gp.likelihood, gp) fit_gpytorch_model(mll); return gp
def fit(self, x_train, y_train): # normalize parameter (=input) data x_train_norm = self.param_normalizer.project_to(x_train) # normalize the data y_train_norm = self.data_normalizer.standardize(y_train) self.gp = SingleTaskGP(x_train_norm, y_train_norm) self.gp.likelihood.noise_covar.register_constraint( "raw_noise", GreaterThan(1e-5)) mll = ExactMarginalLogLikelihood(self.gp.likelihood, self.gp) fit_gpytorch_model(mll) return self.gp
def get_and_fit_model( self, Xs: List[Tensor], Ys: List[Tensor], Yvars: List[Tensor], task_features: List[int], fidelity_features: List[int], metric_names: List[str], state_dict: Optional[Dict[str, Tensor]] = None, fidelity_model_id: Optional[int] = None, **kwargs: Any, ) -> ModelListGP: """Get a fitted multi-task contextual GP model for each outcome. Args: Xs: List of X data, one tensor per outcome. Ys: List of Y data, one tensor per outcome. Yvars:List of Noise variance of Yvar data, one tensor per outcome. Returns: Fitted multi-task contextual GP model. """ models = [] for i, X in enumerate(Xs): # validate input Yvars Yvar = Yvars[i].clamp_min_(MIN_OBSERVED_NOISE_LEVEL) is_nan = torch.isnan(Yvar) all_nan_Yvar = torch.all(is_nan) if all_nan_Yvar: gp_m = LCEMGP( train_X=X, train_Y=Ys[i], task_feature=task_features[i], context_cat_feature=self.context_cat_feature, context_emb_feature=self.context_emb_feature, embs_dim_list=self.embs_dim_list, ) else: gp_m = FixedNoiseLCEMGP( train_X=X, train_Y=Ys[i], train_Yvar=Yvar, task_feature=task_features[i], context_cat_feature=self.context_cat_feature, context_emb_feature=self.context_emb_feature, embs_dim_list=self.embs_dim_list, ) models.append(gp_m) # Use a ModelListGP model = ModelListGP(*models) model.to(Xs[0]) mll = SumMarginalLogLikelihood(model.likelihood, model) fit_gpytorch_model(mll) return model
def select_next_points_botorch(observed_X: List[List[float]], observed_y: List[float]) -> np.ndarray: """Generate the next sample to evaluate with XTB Uses BOTorch to pick the next sample using Expected Improvement Args: observed_X: Observed coordinates observed_y: Observed energies Returns: Next coordinates to try """ # Clip the energies if needed observed_y = np.clip(observed_y, -np.inf, 2 + np.log10(np.clip(observed_y, 1, np.inf))) # Convert inputs to torch arrays train_X = torch.tensor(observed_X, dtype=torch.float) train_y = torch.tensor(observed_y, dtype=torch.float) train_y = train_y[:, None] train_y = standardize(-1 * train_y) # Make the GP gp = SingleTaskGP(train_X, train_y, covar_module=gpykernels.ScaleKernel( gpykernels.ProductStructureKernel( num_dims=train_X.shape[1], base_kernel=gpykernels.PeriodicKernel( period_length_prior=NormalPrior(360, 0.1))))) mll = ExactMarginalLogLikelihood(gp.likelihood, gp) fit_gpytorch_model(mll) # Solve the optimization problem # Following boss, we use Eq. 5 of https://arxiv.org/pdf/1012.2599.pdf with delta=0.1 n_sampled, n_dim = train_X.shape kappa = np.sqrt( 2 * np.log10(np.power(n_sampled, n_dim / 2 + 2) * np.pi**2 / (3.0 * 0.1))) # Results in more exploration over time ei = UpperConfidenceBound(gp, kappa) bounds = torch.zeros(2, train_X.shape[1]) bounds[1, :] = 360 candidate, acq_value = optimize_acqf(ei, bounds=bounds, q=1, num_restarts=64, raw_samples=64) return candidate.detach().numpy()[0, :]
def CreateModel(xtrain, ytrain): ''' Creates and trains a GpyTorch GP model. ''' # model = SingleTaskGP(xtrain, ytrain) # mll = ExactMarginalLogLikelihood(model.likelihood, model) # fit_gpytorch_model(mll); model = FixedNoiseGP(xtrain, ytrain, train_Yvar=torch.full_like(ytrain, 1e-4)) mll = ExactMarginalLogLikelihood(model.likelihood, model) fit_gpytorch_model(mll) return (model)
def test_optimize_pytorch(dim): train_x, train_yl = get_initial_evaluations(dim=dim) Neval = train_x.shape[0] dim = train_x.shape[1] gpcr = GPCRmodel(train_x=train_x, train_yl=train_yl, noise_std=0.01) mll = MLLGPCR_pytorch(likelihood=None,model=gpcr) mll(None,None) fit_gpytorch_model(mll,max_retries=10) # See https://botorch.org/api/_modules/botorch/optim/utils.html#sample_all_priors
def update_hyperparameters(self): print("\n") self.my_print("Fitting model...") self.my_print("----------------") mll = ExactMarginalLogLikelihood(self.likelihood, self) fit_gpytorch_model(mll,max_retries=10) # See https://botorch.org/api/_modules/botorch/optim/utils.html#sample_all_priors # max_retries: https://botorch.org/api/_modules/botorch/fit.html#fit_gpytorch_model # Sometimes fit_gpytorch_model fails: if torch.any(self.covar_module.base_kernel.lengthscale > 2.0): self.covar_module.base_kernel.lengthscale[:] = 2.0 if torch.any(self.covar_module.outputscale > 2.0): self.covar_module.outputscale[:] = 2.0 self.update_hyperparameters_of_model_grad()
def fit_gp_model(self, arm: int, alternative: int = None, update: bool = False) -> None: """ Fits a GP model to the given arm :param arm: Arm index :param alternative: Last sampled arm alternative. Used when adding samples without refitting :param update: Forces GP to be fitted. Otherwise, it is fitted every self.gp_update_freq samples. :return: None """ arm_sample_count = sum([len(e) for e in self.observations[arm]]) if update or arm_sample_count % self.gp_update_freq == 0: train_X_list = list() train_Y_list = list() for j in range(len(self.alternative_points[arm])): for k in range(len(self.observations[arm][j])): train_X_list.append( self.alternative_points[arm][j].unsqueeze(-2)) train_Y_list.append( self.observations[arm][j][k].unsqueeze(-2)) train_X = torch.cat(train_X_list, dim=0) train_Y = torch.cat(train_Y_list, dim=0) if self.noise_std is None: model = SingleTaskGP(train_X, train_Y, outcome_transform=Standardize(m=1)) else: model = FixedNoiseGP( train_X, train_Y, train_Yvar=torch.tensor([self.noise_std**2 ]).expand_as(train_Y), outcome_transform=Standardize(m=1), ) mll = ExactMarginalLogLikelihood(model.likelihood, model) fit_gpytorch_model(mll) self.models[arm] = model else: last_point = self.alternative_points[arm][alternative].reshape( 1, -1) last_observation = self.observations[arm][alternative][-1].reshape( 1, -1) self.models[arm].condition_on_observations(last_point, last_observation, noise=self.noise_std**2)
def test_FixedNoiseMultiTaskGP_single_output(self): for dtype in (torch.float, torch.double): tkwargs = {"device": self.device, "dtype": dtype} model = _get_fixed_noise_model_single_output(**tkwargs) self.assertIsInstance(model, FixedNoiseMultiTaskGP) self.assertEqual(model.num_outputs, 1) self.assertIsInstance(model.likelihood, FixedNoiseGaussianLikelihood) self.assertIsInstance(model.mean_module, ConstantMean) self.assertIsInstance(model.covar_module, ScaleKernel) matern_kernel = model.covar_module.base_kernel self.assertIsInstance(matern_kernel, MaternKernel) self.assertIsInstance(matern_kernel.lengthscale_prior, GammaPrior) self.assertIsInstance(model.task_covar_module, IndexKernel) self.assertEqual(model._rank, 2) self.assertEqual( model.task_covar_module.covar_factor.shape[-1], model._rank ) # test model fitting mll = ExactMarginalLogLikelihood(model.likelihood, model) with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=OptimizationWarning) mll = fit_gpytorch_model(mll, options={"maxiter": 1}, max_retries=1) # test posterior test_x = torch.rand(2, 1, **tkwargs) posterior_f = model.posterior(test_x) self.assertIsInstance(posterior_f, GPyTorchPosterior) self.assertIsInstance(posterior_f.mvn, MultivariateNormal) # test posterior (batch eval) test_x = torch.rand(3, 2, 1, **tkwargs) posterior_f = model.posterior(test_x) self.assertIsInstance(posterior_f, GPyTorchPosterior) self.assertIsInstance(posterior_f.mvn, MultivariateNormal)
def _setUp(self, double=False, cuda=False, expand=False): device = torch.device("cuda") if cuda else torch.device("cpu") dtype = torch.double if double else torch.float train_x = torch.linspace(0, 1, 10, device=device, dtype=dtype).unsqueeze(-1) train_y = torch.sin(train_x * (2 * math.pi)) noise = torch.tensor(NOISE, device=device, dtype=dtype) self.train_x = train_x self.train_y = train_y + noise if expand: self.train_x = self.train_x.expand(-1, 2) ics = torch.tensor([[0.5, 1.0]], device=device, dtype=dtype) else: ics = torch.tensor([[0.5]], device=device, dtype=dtype) self.initial_conditions = ics self.f_best = self.train_y.max().item() model = SingleTaskGP(self.train_x, self.train_y) self.model = model.to(device=device, dtype=dtype) self.mll = ExactMarginalLogLikelihood(self.model.likelihood, self.model) with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=OptimizationWarning) self.mll = fit_gpytorch_model(self.mll, options={"maxiter": 1}, max_retries=1)
def get_fitted_model(train_X, train_Y, train_Yvar, state_dict=None): """ Get a single task GP. The model will be fit unless a state_dict with model hyperparameters is provided. """ Y_mean = train_Y.mean(dim=-2, keepdim=True) Y_std = train_Y.std(dim=-2, keepdim=True) model = FixedNoiseGP(train_X, (train_Y - Y_mean) / Y_std, train_Yvar) model.Y_mean = Y_mean model.Y_std = Y_std if state_dict is None: mll = ExactMarginalLogLikelihood(model.likelihood, model).to(train_X) fit_gpytorch_model(mll) else: model.load_state_dict(state_dict) return model
def fit( self, train_x: torch.Tensor, train_y: torch.Tensor, warmstart_hyperparams: bool = False, warmstart_induc: bool = False, **kwargs, ) -> None: """Fit underlying model. Args: train_x (torch.Tensor): Inputs. train_y (torch.LongTensor): Responses. warmstart_hyperparams (bool): Whether to reuse the previous hyperparameters (True) or fit from scratch (False). Defaults to False. warmstart_induc (bool): Whether to reuse the previous inducing points or fit from scratch (False). Defaults to False. """ self.set_train_data(train_x, train_y) # by default we reuse the model state and likelihood. If we # want a fresh fit (no warm start), copy the state from class initialization. if not warmstart_hyperparams: self._reset_hyperparameters() if not warmstart_induc: self._reset_variational_strategy() n = train_y.shape[0] mll = gpytorch.mlls.VariationalELBO(self.likelihood, self, n) self.train() if self.max_fit_time is not None: # figure out how long evaluating a single samp starttime = time.time() _ = mll(self(train_x), train_y) single_eval_time = time.time() - starttime n_eval = self.max_fit_time // single_eval_time options = {"maxfun": n_eval} logger.info(f"fit maxfun is {n_eval}") else: options = {} logger.info("Starting fit...") starttime = time.time() fit_gpytorch_model(mll, options=options, **kwargs) logger.info(f"Fit done, time={time.time()-starttime}")
def propose_candidates(args, prev_res): ## train a surrogate model gp = SingleTaskGP(prev_res['hparams'], prev_res['acc']) mll = ExactMarginalLogLikelihood(gp.likelihood, gp) fit_gpytorch_model(mll) ## construct an acquisition function and optimize it UCB = UpperConfidenceBound(gp, beta=0.1) candidates, acq_value = optimize_acqf(UCB, bounds=bounds, q=args.n_cand, num_restarts=5, raw_samples=20) return candidates
def _setUp(self, double=False, cuda=False, expand=False): device = torch.device("cuda") if cuda else torch.device("cpu") dtype = torch.double if double else torch.float train_x = torch.linspace(0, 1, 10, device=device, dtype=dtype).unsqueeze(-1) train_y = torch.sin(train_x * (2 * math.pi)).squeeze(-1) noise = torch.tensor(NOISE, device=device, dtype=dtype) self.train_x = train_x self.train_y = train_y + noise if expand: self.train_x = self.train_x.expand(-1, 2) ics = torch.tensor([[0.5, 1.0]], device=device, dtype=dtype) else: ics = torch.tensor([[0.5]], device=device, dtype=dtype) self.initial_conditions = ics self.f_best = self.train_y.max().item() model = SingleTaskGP(self.train_x, self.train_y) self.model = model.to(device=device, dtype=dtype) self.mll = ExactMarginalLogLikelihood(self.model.likelihood, self.model) self.mll = fit_gpytorch_model(self.mll, options={"maxiter": 1})