def _get_model(self, dtype=torch.float): state_dict = { "mean_module.constant": torch.tensor([-0.0066]), "covar_module.raw_outputscale": torch.tensor(1.0143), "covar_module.base_kernel.raw_lengthscale": torch.tensor([[-0.99]]), "covar_module.base_kernel.lengthscale_prior.concentration": torch.tensor(3.0), "covar_module.base_kernel.lengthscale_prior.rate": torch.tensor(6.0), "covar_module.outputscale_prior.concentration": torch.tensor(2.0), "covar_module.outputscale_prior.rate": torch.tensor(0.1500), } train_x = torch.linspace(0, 1, 10, device=self.device, dtype=dtype).unsqueeze(-1) train_y = torch.sin(train_x * (2 * math.pi)) noise = torch.tensor(NEI_NOISE, device=self.device, dtype=dtype) train_y += noise train_yvar = torch.full_like(train_y, 0.25**2) model = FixedNoiseGP(train_X=train_x, train_Y=train_y, train_Yvar=train_yvar) model.load_state_dict(state_dict) model.to(train_x) model.eval() return model
def initialize_model(train_x, train_obj, state_dict=None): model = FixedNoiseGP(train_x, train_obj, train_yvar.expand_as(train_obj)).to(train_x) mll = ExactMarginalLogLikelihood(model.likelihood, model) # load state dict if it is passed if state_dict is not None: model.load_state_dict(state_dict) return mll, model
def initialize_model_nei(train_x, train_obj, state_dict=None): """ Define model for the objective. :param train_x: input tensor :param train_obj: output tensor -> g(x) + s(x) :param state_dict: optional model parameters :return: """ model = FixedNoiseGP(train_x, train_obj, train_yvar.expand_as(train_obj)).to(train_x) mll = ExactMarginalLogLikelihood(model.likelihood, model) # load state dict if it is passed if state_dict is not None: model.load_state_dict(state_dict) return mll, model
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 _get_model(self, cuda=False, dtype=torch.float): device = torch.device("cuda") if cuda else torch.device("cpu") state_dict = { "mean_module.constant": torch.tensor([-0.0066]), "covar_module.raw_outputscale": torch.tensor(1.0143), "covar_module.base_kernel.raw_lengthscale": torch.tensor([[-0.99]]), "covar_module.base_kernel.lengthscale_prior.concentration": torch.tensor( 3.0 ), "covar_module.base_kernel.lengthscale_prior.rate": torch.tensor(6.0), "covar_module.outputscale_prior.concentration": torch.tensor(2.0), "covar_module.outputscale_prior.rate": torch.tensor(0.1500), } train_x = torch.linspace(0, 1, 10, device=device, dtype=dtype) train_y = torch.sin(train_x * (2 * math.pi)) noise = torch.tensor(NEI_NOISE, device=device, dtype=dtype) train_y += noise train_yvar = torch.full_like(train_y, 0.25 ** 2) train_x = train_x.view(-1, 1) model = FixedNoiseGP(train_X=train_x, train_Y=train_y, train_Yvar=train_yvar) model.load_state_dict(state_dict) model.to(train_x) model.eval() return model
def main( benchmark_name, dataset_name, dimensions, method_name, num_runs, run_start, num_iterations, acquisition_name, # acquisition_optimizer_name, gamma, num_random_init, mc_samples, batch_size, num_fantasies, num_restarts, raw_samples, noise_variance_init, # use_ard, # use_input_warping, standardize_targets, input_dir, output_dir): # TODO(LT): Turn into options # device = "cpu" device = torch.device("cuda" if torch.cuda.is_available() else "cpu") dtype = torch.double benchmark = make_benchmark(benchmark_name, dimensions=dimensions, dataset_name=dataset_name, input_dir=input_dir) name = make_name(benchmark_name, dimensions=dimensions, dataset_name=dataset_name) output_path = Path(output_dir).joinpath(name, method_name) output_path.mkdir(parents=True, exist_ok=True) options = dict(gamma=gamma, num_random_init=num_random_init, acquisition_name=acquisition_name, mc_samples=mc_samples, batch_size=batch_size, num_restarts=num_restarts, raw_samples=raw_samples, num_fantasies=num_fantasies, noise_variance_init=noise_variance_init, standardize_targets=standardize_targets) with output_path.joinpath("options.yaml").open('w') as f: yaml.dump(options, f) config_space = DenseConfigurationSpace(benchmark.get_config_space()) bounds = create_bounds(config_space.get_bounds(), device=device, dtype=dtype) input_dim = config_space.get_dimensions() def func(tensor, *args, **kwargs): """ Wrapper that receives and returns torch.Tensor """ config = dict_from_tensor(tensor, cs=config_space) # turn into maximization problem res = -benchmark.evaluate(config).value return torch.tensor(res, device=device, dtype=dtype) for run_id in trange(run_start, num_runs, unit="run"): run_begin_t = batch_end_t_adj = batch_end_t = datetime.now() frames = [] features = [] targets = [] noise_variance = torch.tensor(noise_variance_init, device=device, dtype=dtype) state_dict = None with trange(num_iterations) as iterations: for batch in iterations: if len(targets) < num_random_init: # click.echo(f"Completed {i}/{num_random_init} initial runs. " # "Suggesting random candidate...") # TODO(LT): support random seed X_batch = torch.rand(size=(batch_size, input_dim), device=device, dtype=dtype) else: # construct dataset X = torch.vstack(features) y = torch.hstack(targets).unsqueeze(axis=-1) y = standardize(y) if standardize_targets else y # construct model # model = FixedNoiseGP(X, standardize(y), noise_variance.expand_as(y), model = FixedNoiseGP(X, y, noise_variance.expand_as(y), input_transform=None).to(X) mll = ExactMarginalLogLikelihood(model.likelihood, model) if state_dict is not None: model.load_state_dict(state_dict) # update model fit_gpytorch_model(mll) # construct acquisition function tau = torch.quantile(y, q=1 - gamma) iterations.set_postfix(tau=tau.item()) if acquisition_name == "q-KG": assert num_fantasies is not None and num_fantasies > 0 acq = qKnowledgeGradient(model, num_fantasies=num_fantasies) elif acquisition_name == "q-EI": assert mc_samples is not None and mc_samples > 0 qmc_sampler = SobolQMCNormalSampler( num_samples=mc_samples) acq = qExpectedImprovement(model=model, best_f=tau, sampler=qmc_sampler) # optimize acquisition function X_batch, b = optimize_acqf(acq_function=acq, bounds=bounds, q=batch_size, num_restarts=num_restarts, raw_samples=raw_samples, options=dict(batch_limit=5, maxiter=200)) state_dict = model.state_dict() # begin batch evaluation batch_begin_t = datetime.now() decision_duration = batch_begin_t - batch_end_t batch_begin_t_adj = batch_end_t_adj + decision_duration eval_end_times = [] # TODO(LT): Deliberately not doing broadcasting for now since # batch sizes are so small anyway. Can revisit later if there # is a compelling reason to do it. rows = [] for j, x_next in enumerate(X_batch): # eval begin time eval_begin_t = datetime.now() # evaluate blackbox objective y_next = func(x_next) # eval end time eval_end_t = datetime.now() # eval duration eval_duration = eval_end_t - eval_begin_t # adjusted eval end time is the duration added to the # time at which batch eval was started eval_end_t_adj = batch_begin_t_adj + eval_duration eval_end_times.append(eval_end_t_adj) elapsed = eval_end_t_adj - run_begin_t # update dataset features.append(x_next) targets.append(y_next) row = dict_from_tensor(x_next, cs=config_space) row["loss"] = -y_next.item() row["cost_eval"] = eval_duration.total_seconds() row["finished"] = elapsed.total_seconds() rows.append(row) batch_end_t = datetime.now() batch_end_t_adj = max(eval_end_times) frame = pd.DataFrame(data=rows) \ .assign(batch=batch, cost_decision=decision_duration.total_seconds()) frames.append(frame) data = pd.concat(frames, axis="index", ignore_index=True) data.to_csv(output_path.joinpath(f"{run_id:03d}.csv")) return 0
def main(benchmark_name, dataset_name, dimensions, method_name, num_runs, run_start, num_iterations, # acquisition_name, # acquisition_optimizer_name, gamma, num_random_init, num_restarts, raw_samples, noise_variance_init, # use_ard, # use_input_warping, standardize_targets, input_dir, output_dir): # TODO(LT): Turn into options # device = "cpu" device = torch.device("cuda" if torch.cuda.is_available() else "cpu") dtype = torch.double benchmark = make_benchmark(benchmark_name, dimensions=dimensions, dataset_name=dataset_name, input_dir=input_dir) name = make_name(benchmark_name, dimensions=dimensions, dataset_name=dataset_name) output_path = Path(output_dir).joinpath(name, method_name) output_path.mkdir(parents=True, exist_ok=True) options = dict(gamma=gamma, num_random_init=num_random_init, num_restarts=num_restarts, raw_samples=raw_samples, noise_variance_init=noise_variance_init, standardize_targets=standardize_targets) with output_path.joinpath("options.yaml").open('w') as f: yaml.dump(options, f) config_space = DenseConfigurationSpace(benchmark.get_config_space()) bounds = create_bounds(config_space.get_bounds(), device=device, dtype=dtype) input_dim = config_space.get_dimensions() def func(tensor, *args, **kwargs): """ Wrapper that receives and returns torch.Tensor """ config = dict_from_tensor(tensor, cs=config_space) # turn into maximization problem res = - benchmark.evaluate(config).value return torch.tensor(res, device=device, dtype=dtype) for run_id in trange(run_start, num_runs, unit="run"): t_start = datetime.now() rows = [] features = [] targets = [] noise_variance = torch.tensor(noise_variance_init, device=device, dtype=dtype) state_dict = None with trange(num_iterations) as iterations: for i in iterations: if len(targets) < num_random_init: # click.echo(f"Completed {i}/{num_random_init} initial runs. " # "Suggesting random candidate...") # TODO(LT): support random seed x_new = torch.rand(size=(input_dim,), device=device, dtype=dtype) else: # construct dataset X = torch.vstack(features) y = torch.hstack(targets).unsqueeze(axis=-1) y = standardize(y) if standardize_targets else y # construct model # model = FixedNoiseGP(X, standardize(y), noise_variance.expand_as(y), model = FixedNoiseGP(X, y, noise_variance.expand_as(y), input_transform=None).to(X) mll = ExactMarginalLogLikelihood(model.likelihood, model) if state_dict is not None: model.load_state_dict(state_dict) # update model fit_gpytorch_model(mll) # construct acquisition function tau = torch.quantile(y, q=1-gamma) iterations.set_postfix(tau=tau.item()) ei = ExpectedImprovement(model=model, best_f=tau) # optimize acquisition function X_batch, b = optimize_acqf(acq_function=ei, bounds=bounds, q=1, num_restarts=num_restarts, raw_samples=raw_samples, options=dict(batch_limit=5, maxiter=200)) x_new = X_batch.squeeze(axis=0) state_dict = model.state_dict() # evaluate blackbox objective # t0 = datetime.now() y_new = func(x_new) t1 = datetime.now() delta = t1 - t_start # update dataset features.append(x_new) targets.append(y_new) row = dict_from_tensor(x_new, cs=config_space) row["loss"] = - y_new.item() row["finished"] = delta.total_seconds() rows.append(row) data = pd.DataFrame(data=rows) data.to_csv(output_path.joinpath(f"{run_id:03d}.csv")) return 0