Finding p(θ|D) in bo torch

[MatthewCulbert343]

Hello, I am very new to Bayesian optimization. I am trying to sample the posterior probability distribution of a set of hyperparameters for some given data {p(θ|D) where θ is the hyperparameters of the model and D is the training data}. From my understanding: p(θ|D) = p(D|θ)p(θ). Where p(D|θ) is the likelihood function given by ExactMarginalLogLikelihood on a single task GP model and p(θ) is some prior (I am using a uniform distribution). My sampler is exhibiting some strange behavior, so I wanted to check if there were issues with my botorch code snippet. Does the following code setup the p(θ|D) distribution correctly? If not, what should I change?

#model to use with hyperparameters
base_kernel = RBFKernel(ard_num_dims=functiondim) 
scaled_kernel= ScaleKernel(base_kernel)
model = SingleTaskGP(Train_X, Train_Y, covar_module=scaled_kernel)
mll = ExactMarginalLogLikelihood(model.likelihood, model)
 
def torchlog_likelihood(theta, train_x, train_y):
    Lengthscale = torch.empty(len(theta)-2)
    for i in range(0,len(theta)-2):
        Lengthscale[i] = theta[i]
    Lengthscale = Lengthscale.unsqueeze(0)
    outputscale = theta[-2]
    noise = theta[-1]
    model.covar_module.base_kernel.lengthscale = Lengthscale
    model.covar_module.outputscale = outputscale
    model.likelihood.noise = noise
    output = model(train_x)
    loss = mll(output, train_y.squeeze()) 
    return loss

 
#Posterior
def log_posterior(theta, train_x, train_y):
    lp = log_prior(theta)
    if not torch.isfinite(torch.Tensor([lp])):
        return -torch.inf
    ll = torchlog_likelihood(theta, train_x, train_y)
    post = (lp + ll)
    return post.detach().numpy()

[Balandat]

Sorry about the late response here. What is the strange behavior that your sampler exhibits?

One thing to note is that SingleTaskGP by default applies a Standardize outcome transform (

botorch/botorch/models/gp_regression.py

Lines 147 to 153 in e7fef3b

	outcome_transform: An outcome transform that is applied to the
	training data during instantiation and to the posterior during
	inference (that is, the `Posterior` obtained by calling
	`.posterior` on the model will be on the original scale). We use a
	`Standardize` transform if no `outcome_transform` is specified.
	Pass down `None` to use no outcome transform. Note that `.train()` will
	be called on the outcome transform during instantiation of the model.

), so model(train_x) returns the posterior distribution in the transformed rather than the original space.

You can either use model.posterior(train_x) to compute the posterior in the untransformed space, or you can construct the model without a Standardize transform by setting outcome_transform=None when instantiating the SingleTaskGP object.