Deterministic transformation of the first objective's GP model's posterior as a model for the second objective in a qNEHVI multi-objective optimization setting

[talesa]

Hello!

Thanks for a great library!

As per the title, I would like to perform a multi-objective optimization over 2 objectives.
The first objective is modelled using a SingleTaskGP, that's easy.
I know that the second objective is a deterministic (affine) transformation of the first objective's value.
I would like to incorporate this knowledge into my model.

I am aware of the DeterministicModel class, but that yields a zero-variance posterior which is a deterministic function of the tensor x (inputs to the GP surrogate of the first objective).
In contrast, I want to specify the posterior over the second objective as a deterministic transformation of the first objective's GP posterior distribution (or actually only samples from that posterior since I'm using qNEHVI, am I right?)
Also, for whoever's reading this, these are somewhat relevant: #1064, #543.

I am a newcomer to botorch so I would like to ask for pointers on how to assemble the right elements of botorch API to build such a model 🙏

I started exploring the API and the pseudo-code below is my attempt to both describe what I am trying to achieve and sketch my current the approach. Is this the right way to go? Do you have any comments or pointers on how to achieve this?
At the very bottom of this post I include my current naive solution with two independent GPs.

models = [
    SingleTaskGP(x, y[:, 0:1]),
]

mll = MarginalLogLikelihood(models[0].likelihood, models[0])
fit_gpytorch_model(mll)

transform_func = lambda sample: sample * 0.5 * torch.ones_like(y[:, 0:1])
models.append(
    # class definitions at the end of the snippet
    DeterminisitcallyTransformedSampledModel(
        transform_func=transform_func, gp_model=models[0])
)

model = ModelList(*models)

acq_func = qNoisyExpectedHypervolumeImprovement(model=model, ...)


class DeterminisitcallyTransformedSampledModel(Model):
    def __init__(self, transform_func, gp_model):
        self.transform_func = transform_func
        self.gp_model = gp_model

    def posterior(self, x):
        return DeterminisitcallyTransformedSampledPosterior(x, self.transform_func, self.gp_model)

# I anticipate there would be some Tensor shape fiddling and handling normalization/unnormalization
class DeterminisitcallyTransformedSampledPosterior(Posterior):
    def __init__(self, x, transform_func, gp_model):
        self.transform_func = transform_func
        self.gp_model_posterior = gp_model.posterior(x)

    def rsample(self, sample_shape, base_samples):
        sample = self.gp_model_posterior.rsample(sample_shape, base_samples)
        # The essence of what I want to achieve is for the posterior of models[1] to be a deterministic transformation
        #  of models[0]'s posterior
        sample = self.transform_func(sample)
        return sample

Slightly unrelevant but possibly further clarifying: at the moment, I'm using a naive solution where I model both of the objectives independently using seperate GPs

models = [
    SingleTaskGP(x, y[:, 0:1]),
    SingleTaskGP(x, y[:, 1:2])
]
model = ModelListGP(*models)

mll = SumMarginalLogLikelihood(model.likelihood, model)
fit_gpytorch_model(mll)

acq_func = qNoisyExpectedHypervolumeImprovement(model=model, ...)

[saitcakmak]

Hi @talesa! If your focus is strictly on the affine transforms, do you really need to do multi-objective optimization? The two objectives will be perfectly correlated, so the maximizer of one will be the maximizer or minimizer of the other. (If the correlation is negative, there may still be some form of a Pareto front, I haven't thought too much about that case).

Going back to the original question, I am not aware of previous work considering a model being direct transform of the other. Regardless, I think you should be able to achieve this using an MCObjective or a PosteriorTransform, without having to define a second model.

If you use an MCObjective, you would directly transform the samples from the posterior. Something like:

class MyMcObj(MCMultiOutputObjective):
    def forward(self, samples: Tensor, X: Optional[Tensor] = None, **kwargs) -> Tensor:
        # samples are from single output GP, so batch x q x 1, repeat to make batch x q x 2
        samples = samples.repeat(*[1]*(samples.dim() - 1), 2)
        # Apply the affine transform to 2nd output dimension
        samples[..., 1] = constant + multiplier * samples[..., 1]
        return samples

which would take in samples from the original posterior and transform them (keeping the originals as well in the process). PosteriorTransform would analytically transform the Posterior (rather than the samples), where you could add the second outcome. Support for PosteriorTransform is not implemented for multi-objective acquisition functions, but it should be as simple as accepting the argument in __init__ and passing it in model.posterior calls.

[talesa]

Thanks a lot for such a quick and comprehensive answer!
Sorry, I made a mistake in specifying the problem - the multiplier should actually be a function of X inside MyMcObj.forward, so it ends up multiplier(X) * samples[..., 1] and it seems this approach will solve my case. I'll fix the description of the problem in my original post later.