Best practice for using singleTaskGP to model deterministic problems

[kentwar]

Hi,

I'm developing some implementations for Quality-Diversity algorithms and I'm having some difficulties running singleTaskGP to model a toy problem with no noise. This makes some sense (It will try to optimise the 0 noise parameter which will be both a waste of compute and potentially numerically problematic), but it's not immediately clear whether I should be using another Botorch method to model such a problem or is there a constant noise likelihood parameter?

So far I'm trying a (slightly tweaked) fix from the BOTorch docs with :

    noise_prior = GammaPrior(0.1, 0.05)
    noise_prior_mode = (noise_prior.concentration - 1) / noise_prior.rate
    MIN_INFERRED_NOISE_LEVEL = 1e-5
    likelihood = GaussianLikelihood(
    noise_prior=noise_prior,
    noise_constraint=GreaterThan(
        MIN_INFERRED_NOISE_LEVEL,
        transform=None,
        initial_value=noise_prior_mode,
        ),
        )
    model = SingleTaskGP(xtrain, ytrain,likelihood = likelihood)
    mll = ExactMarginalLogLikelihood(model.likelihood, model)
    fit_gpytorch_model(mll)

The function I'm trying to model is Mishras constrained Bird problem in 2d over [-10 <x <0, -6<y,<0]

def simple_fitness(X):
    '''Mishra's Bird function - constrained
    '''
    x = (X[0]-1)*10
    y = (X[1] -1)*6
    fit = np.sin(y)*np.exp((1-np.cos(x))**2)+np.cos(x)*np.exp((1-np.sin(y))**2)+(x-y)**2 
    return(fit )

It feels like the sort of thing a GP should be able to model well, but I seem to hit a cholesky decomposition error frequently. I'm implementing a variation on an Expected Improvement acquisition related to some previous work called BOP-Elites.

I have tried raising the minimum noise floor, it even fails as high as 1E-3

Botorch 0.2.1
Gpytorch 1.0.1
torch 1.4.0

[saitcakmak]

Hi @kentwar. You're using a very old version of botorch (and dependencies). I'd highly recommend that you upgrade to the current version.

Since you're trying to model a noise-free function, you may want to use FixedNoiseGP with a small noise value (to avoid numerical issues). You can do this with model = FixedNoiseGP(train_X, train_Y, train_Yvar = torch.full_like(train_Y, 1e-4).
In addition, since you're running into numerical issues with Cholesky, you're likely using a large number of training points, or have training points clustered closely in the input space (leading to numerically singular covariance matrices). In this case, I'd recommend using dtype=torch.double. You need to be consistent and have all your tensors be double, which you can do by passing it in like my_tensor = torch.rand(5, dtype=torch.double) every time you're creating a new tensor from scratch.

[kentwar]

Thanks,

Yes, Changing the dtype to double has saved the day here.

I can now upgrade my versions, though previously I was more directly connecting with gpytorch packages and when I upgraded it broke lots of my code and so to avoid the headache of retrofitting old code I kept the versions static. Happily botorch does a great job at wrapping around the gpytorch functions and I'm happy with what it's doing.

I shall experiment with the FixedNoiseGP. Thanks for the comprehensive answer.

Paul