Increasing the accuracy of botorch

[A-ep93]

Hello all,
I have a problem with 3 input parameters and 1 output. I have written a code to use botorch based on the tutorials. However, currently, the accuracy is not very high. I have about 1000 number of runs, but still the results of the optimziation are not very accurate. I appreciate if you can give me some tips to increae the accuracy of bayesian optimziation in my code.
Here is my code:

import os
import torch
from botorch.models.gp_regression import SingleTaskGP
from botorch.models.transforms.outcome import Standardize
from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood
from botorch.utils.transforms import unnormalize
from botorch.utils.sampling import draw_sobol_samples
from botorch.models import ModelListGP
from gpytorch.mlls.sum_marginal_log_likelihood import SumMarginalLogLikelihood
from botorch.models.transforms.input import Normalize
from botorch import fit_gpytorch_model
from botorch.acquisition.monte_carlo import qExpectedImprovement, qNoisyExpectedImprovement
from botorch.optim import optimize_acqf

tkwargs = {
    "dtype": torch.double,
    "device": torch.device("cuda" if torch.cuda.is_available() else "cpu"),
}


def problem(input):
    # This is the black box function that I want to optimize.
    return torch.tensor(result,**tkwargs)



bounds=torch.tensor([[-1,-1,-1],[1,1,1]],**tkwargs)

def generate_initial_data(n=6):
    # generate training data
    train_x = draw_sobol_samples(
        bounds=bounds,n=1, q=n, seed=torch.randint(1000000, (1,)).item()
    ).squeeze(0)
    train_obj = problem(train_x)
    best=train_obj.max()
    return train_x, train_obj, best



def get_next_points(train_x, train_obj, best, bounds, n_points):
    models =SingleTaskGP(train_x,train_obj)
    mll = ExactMarginalLogLikelihood(models.likelihood, models)
    fit_gpytorch_model(mll)
    EI=qExpectedImprovement(
        model=models,
        best_f=best)
    candidate, _ =optimize_acqf(
        acq_function=EI,
        bounds=bounds,
        q=n_points,
        num_restarts=200,
        raw_samples=512,
        )
    return candidate


n_runs=1000
train_x, train_obj, best=generate_initial_data(100)
# train_obj=train_obj[:,:,0]

for i in range(n_runs):
    new_candidate=get_next_points(train_x, train_obj, best, bounds, 1)
    new_results=problem(new_candidate)
    train_x=torch.cat([train_x,new_candidate])
    train_obj=torch.cat([train_obj,new_results])
    best=train_obj.max()
    location=train_x[torch.argmax(train_obj)]
    print({i})
    print({location})
    print({train_obj[torch.argmax(train_obj)]})
    
    
    

[saitcakmak]

On a quick look, your code seems fine. Given that you're using 1000 points in a 3d input space, I'd expect highly accurate results. It's possible that the range of your function output does not play well with the priors for the GP hyper parameters. You could try replacing
models =SingleTaskGP(train_x,train_obj) with models =SingleTaskGP(train_x,train_obj, outcome_transform=Standardize(m=1)) and see if that helps.

[A-ep93]

Thank you for your suggestion @saitcakmak. I will surely try your suggestion to see whether it helps. Can I have a method to control escaping from the local optimum in botorch? I think having such an option can also increase the accuracy of my model.
Also, do you suggest using other types of acquisition functions of botorch?

[saitcakmak]

Can I have a method to control escaping from the local optimum in botorch?

The acquisition functions, e.g., EI, "should" achieve this by default. In general, they're designed to balance the exploration-exploitation trade-off. They typically avoid evaluating near the previously evaluated points unless the uncertainty about the rest of the search space is low enough. This leads to escaping from the local optimum after making a few evaluations unless the model is somewhat confident that there isn't a better local optimum out there.

That being said, EI is known to be a bit greedy, so it may be a bit more likely than others, such as KnowledgeGradient, to be stuck in local optima. Maybe you can give another acquisition function a try to see if that works better on your problem. With KG, the optimization time may increase, so I'd recommend using a smaller num_restarts, something around 20, to speed things up.

[A-ep93]

Thanks for your response @saitcakmak. There is an implementation of EI in the Bayesian optimization command of MATLAB that manages to escape local optimums. They called it EI PLUS. Here is the link for more details. They define a ExplorationRatio for this aim.
Do we have something like that in the EI function (qExpectedImprovement) of botorch?

[Balandat]

I don't think we have this as part of EI. From a quick glance at that Matlab documentation it seems more involved than just making a new acquisition function since apparently the model is modified as part of the process.