About the problem of building a model in the process of multi-objective optimization

[LiuYang-1997]

Hi,
I want to use botorch for related experiments of multi-objective optimization.
I chose to use FixedNoiseGP as the model and set the kernel function to ScaleKernel and base_kernel to RBFKernel.
After converting the two FixedNoiseGP models to ModelListGP, I converted to BatchedMultiOutputGPyTorchModel using model_list_to_batched(ModelListGP).
After conversion, I found that the base_kernel of the converted model has become MaternKernel, why is this? What should I do to keep the base_kernel unchanged?

import gpytorch.priors
import torch
from botorch.test_functions.multi_objective import BraninCurrin
from botorch.utils import draw_sobol_samples
from botorch.utils.transforms import normalize, unnormalize, standardize
from botorch.models.gp_regression import SingleTaskGP, FixedNoiseGP
from botorch.models.model_list_gp_regression import ModelListGP
from gpytorch.kernels.rbf_kernel import RBFKernel
from gpytorch.kernels.scale_kernel import ScaleKernel
from sklearn.kernel_approximation import RBFSampler
from gpytorch.mlls.sum_marginal_log_likelihood import SumMarginalLogLikelihood
from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood
from botorch import fit_gpytorch_model
from botorch.models.converter import model_list_to_batched, batched_to_model_list
from botorch.acquisition.multi_objective.max_value_entropy_search import qMultiObjectiveMaxValueEntropy


problem = BraninCurrin(negate=True)


train_x = draw_sobol_samples(bounds=problem.bounds, n=6, q=1).squeeze(-2)
train_y = problem(train_x)


def fit_model(train_x, train_y):

    train_x_normalize = normalize(train_x, problem.bounds)
    train_y_standardize = standardize(train_y)

    models = []
    for i in range(train_y.size(dim=-1)):

        train_y_standardize = standardize(train_y[:, i]).unsqueeze(-1)

        model = FixedNoiseGP(
            train_X=train_x_normalize,
            train_Y=train_y_standardize,
            train_Yvar=torch.ones_like(train_y_standardize) * 1e-4,
            covar_module=ScaleKernel(
                base_kernel=RBFKernel(
                    ard_num_dims=train_x_normalize.size(dim=-1),
                    lengthscale_prior=gpytorch.priors.GammaPrior(3.0, 6.0)
                ),
                outputscale_prior=gpytorch.priors.GammaPrior(2.0, 0.15),
            )
        )
        models.append(model)
    modelList = ModelListGP(*models)
    mll = SumMarginalLogLikelihood(modelList.likelihood, modelList)
    fit_gpytorch_model(mll)
    return modelList


model = fit_model(train_x, train_y)
bm = model_list_to_batched(model)
acq = qMultiObjectiveMaxValueEntropy()

[Balandat]

Hmm this is likely a bug on our end. This list-to-batch conversion is pretty brittle and we need to take a more genera look at it.

What is the reason you're using this in the first place rather than just using a multi-output FixedNoiseGP? FixedNoiseGP does support multiple output dimensions out of the box. Or if that doesn't work for you for some reason you could also just work with the ModelListGP directly (this is going to be slightly slower than the batched version but it shouldn't be too bad).

[saitcakmak]

Hi @LiuYang-1997.

        batched_mo_model = (
            model_list_to_batched(model) if isinstance(model, ModelListGP) else model
        )

is equivalent to

if isinstance(model, ModelListGP):
    batched_mo_model = model_list_to_batched(model)
else:
    batched_mo_model = model

So, you can use it with either a ModelListGP or a single batched model.

[LiuYang-1997]

Ok, I will try it, thanks.

[LiuYang-1997]

Here are the steps to build the model in the botorch multi-objective optimization tutorial.

Several models have been established in the tutorial and added to the Model List GP, so should I follow the steps in the tutorial? If I set the kernel function and following the steps in the tutorial and use MESMO, the above problem will be caused.
So should I build a single FixedNoiseGP or a single SingleTaskGP?

[saitcakmak]

If you need to set a custom kernel, then you shouldn't use a ModelListGP until #1411 is resolved. So, you should deviate from the tutorial and construct a single GP model (then you can use any kernel you want).

So should I build a single FixedNoiseGP or a single SingleTaskGP?

It depends. Is your observations (Y) noisy or exact? If there's no observation noise, you can use FixedNoiseGP with an artificially low noise level (e.g., 1e-6) to represent this. If the observations are noisy, do you observe the noise level (Yvar)? If you do, you should use FixedNoiseGP and provide the noise observations. If not, you should use SingleTaskGP and let it infer the noise level from the observations.

Also see the documentation here: https://botorch.org/docs/models.

[LiuYang-1997]

Thank you, I will try it.

[saitcakmak]

Tracking the model_list_to_batched issue in #1411.

[SebastianAment]

@LiuYang-1997 We just merged in this PR, which should take care of the model_list_to_batched issue you encountered.