Can PosteriorTransform convert a multi-output GP to a SingleTaskGP object?

[r-ashwin]

I am currently working on a model which requires scalarized posterior of a multi-output GP model. The existing PosteriorTransform implementation is neat. However, it does the transform to the posterior at a given candidate set X, while computing acquisition functions. Instead, what I want is to obtain another SingleTaskGPModel module subclass as the result of the ScalarizedPosteriorTransform. That is

multiout_model = SingleTaskGP(X, Y,) # mean mu and covar E
singleout_model = ScalarizeGP(multiout_model, weights=w) # with mean w^T mu and covar w^T E w

Why?

• This significantly reduces computations while optimizing certain acquisition functions. For example, the qNegativeIntegratedPosteriorVariance will have to compute o x mc_points fantasy models while taking the Monte Carlo average. With a single task GP, it only needs to compute mc_points fantasy models.
• SingleTaskGP is more efficient when using q>1 in optimizing acquisition functions.

I am working on this implementation but suggestions from the dev team would be greatly appreciated. Thanks.

[saitcakmak]

it does the transform to the posterior at a given candidate set X

Yeah, that's pretty much what it is designed for.

I want is to obtain another SingleTaskGPModel module subclass as the result of the ScalarizedPosteriorTransform.

I think this would require you to transform the prior functions, i.e. the mean_module and the covar_module, and to transform them as functions rather than point-wise as is done with ScalarizedPosteriorTransform. One hacky way to do it (which is again point-wise) would be to simply apply the ScalarizedPosteriorTransform at the forward call. I am not sure how well this would work, and if you do this, it wouldn't work with fantasize. So, probably not a great idea overall.

compute o x mc_points fantasy models

Regarding the fantasy models, if you have a transformed model of expectation, it will use a fantasy observation of the expectation to compute the fantasy models. You won't be able to update each model independently here (because you don't have individual fantasized observations). So, there may be some information loss there.

How can you actually implement this:
I am just speculating here, so take it with a grain of salt. You can fit the individual models for each outcome (or just a multi-outcome model) and take the hyper-parameters of the mean_module (which by default is just a constant) and the covar_module (which will be length-scale and output-scale). For mean_module, combination is simple, just set the constant of the new mean_module as w^T old_constants. For covar_module, combining them in the same way as the mean_module may work, but I'd verify the math before attempting to implement.
Once you have the hyper-parameters for the expectation model, you can initialize a new SingleTaskGP model with the train_X and train_Y = w^T multi_output_train_Y, and use the load_state_dict utility to set the hyper-parameters to the ones you calculated from the multi-output model. I don't know if it would work better than just training the model of expectation by itself, but it might. Let us know how it goes!

[r-ashwin]

While working on this, I ran into an issue. What is the right way to perform a scalar multiple of the covar_module(x), which produces a lazy tensor? For instance, when I do the following:

covar_x = self.covar_module(x).mul(torch.tensor(0.))
for i in range(self.n_outputs):
    covar_x += covar_x.mul(weights[i] ** 2)

I get the following error

RuntimeError: Only Tensors created explicitly by the user (graph leaves) support the deepcopy protocol at the moment

[saitcakmak]

I believe the issue is that you're trying to increment covar_x in-place, i.e. via covar_x += ... rather than doing covar_x = covar_x + .... Autograd does not like in-place operations.

[saitcakmak]

And regarding the lazy tensor, you can do from gpytorch.lazy import lazify and lazify it as covar_x = lazify(covar_x).