Use botorch.utils.containers.TrainingData method to standardize training data

[takafusui]

Hi,

I want to standardize training data on which I construct a GP surrogate model.
I found botorch.utils.containers.TrainingData which looks exactly what I am seeking.
Are there example documents available?

I am also particularly interested in how the output is scaled as we standardize the train_y label.

Thank you in advance for your help.

[Balandat]

You can use the InputTransform and OutputTransform abstractions to do this automatically. E.g Normalize will normalize the features (X) to the unit cube, and Standardize will standardize the outcomes (Y, possibly Yvar) to zero mean and unit variance.

I am also particularly interested in how the output is scaled as we standardize the train_y label.

If you manually standardize your data your model will make all the predictions in the standardized space and you'll have to unstandardize the results yourself. If you use the transform abstractions this happens automatically during the posterior call.

TrainingData is really just a container for data to simplify some APIs (esp. when hooking BoTorch models up in other libraries, namely Ax), and has nothing to do with transforming/standardizing data. One thing to note is that botorch.utils.containers.TrainingData recently has been replaced by a more general API using Container and Datasetabstractions: #1205. This will be part of the next release, if you want to use it now you'll need to work off the main branch.

[takafusui]

Hi, thank you very much for your very prompt answer!
It is very helpful!!

How can I call Standardize option property, for instance, from SingleTaskGP?

[Balandat]

To use Standardize with SingleTaskGP modeling a single output you can construct the model as follows:

model = SingleTaskGP(train_x, train_y, outcome_transform=Standardize(m=1))

m here is the number of outputs, if you are modeling multiple outcomes in a batched model you'll need to adjust that accordingly.

[takafusui]

Thank you.
When I define the model using:
gp = SingleTaskGP(train_X, train_y, likelihood=likelihood, outcome_transform=Standardize(m=1))
The outcome from posterior looks in the standardized space...
Maybe am I missing something?
Should I define input_transform or something above?

[saitcakmak]

The outcome from posterior looks in the standardized space...

How are you accessing the posterior? If you use gp.posterior(X) (which is the only supported way), then the posterior should be in the original space since the posterior gets untransformed here. If you are instead trying gp(X) or gp.forward(X), those do not produce the correct posterior and should not be used.

[takafusui]

Hi,
thanks a lot for your comment. Indeed I used likelihood(gp(test_X)) to generate points from the posterior. When I use gp.posterior(test_X), the generated points from the posterior are in the original space.
So basically whenever we use the botorch's routine, we should draw from the posterior using gp.posterior(X)?

One more clarifying question:
When I define:
gp = SingleTaskGP(train_X, train_y, likelihood=likelihood, outcome_transform=Standardize(m=1))
The GP surrogate model is trained on the standardized data, and the output is internally unstandardized.
Given this, when and for which purpose should we only set input_transform option in SingleTaskGP method?

[saitcakmak]

So basically whenever we use the botorch's routine, we should draw from the posterior using gp.posterior(X)?

Yes. This is the only correct way to access posterior in botorch.

If you wanted to add the observation noise to the posterior (which you were doing with likelihood(gp(test_X))), you can specify this via gp.posterior(X, observation_noise=True).

Given this, when and for which purpose should we only set input_transform option in SingleTaskGP method?

So, outcome_transform only applies to the outcomes, i.e., Y (and Yvar if using FixedNoiseGP). input_transform works with inputs X. So, if your original input space is [-10, 10]^d and you wanted this to get normalized to [0, 1]^d internally (which is recommended), then you can pass input_transform=Normalize(d=d). It also more advanced uses such as input warping and robust optimization.

[takafusui]

Thank you for your comment!!

I prefer to standardize the training data so first I import:
from botorch.models.transforms.outcome import Standardize
and
from botorch.models.transforms.input import InputStandardize
then call the SingleTaskGP method
gp = SingleTaskGP(train_X, train_y, likelihood=likelihood, input_transform=InputStandardize(d=train_X_dim), outcome_transform=Standardize(m=train_y_dim))
then draw from the posterior
pred_test_X = gp.posterior(test_X)
I think with the above, I can get much much better results.

Thank you again for your help. Please close this issue if you have nothing to add.

[bojana-rankovic]

you can specify this via gp.posterior(X, observation_noise=True)

Should this also be called in the acquisition function forward call? For example, AnalyticAcquisitionFunction has a _get_posterior method that calls the model.posterior and is used in all child classes, but there isn't an option to set the observation_noise argument.

[saitcakmak]

Should this also be called in the acquisition function forward call?

Generally, no. Many acquisition functions use the latent posterior (i.e., posterior without noise), since that is generally what they try to optimize.

AnalyticAcquisitionFunction has a _get_posterior method

The _get_posterior method was removed in #1073. There has been a number of BoTorch releases since, with various bug-fixes, new features, and other improvements, so I'd recommend upgrading to the latest version.

[bojana-rankovic]

Thanks! I'm actually debugging a case where BO performs better when the output is not standardized. Do you have any suggestions why that would be the case? I've checked the GP model, and on the regression task it's better to standardize the output, but once I have it plugged in the BO loop, I reach the optimum faster with unstandardized output.

I use SingleTaskGP with outcome_transform=Standardize and UpperConfidenceBound as the acquisition function.

[Balandat]

on the regression task it's better to standardize the output, but once I have it plugged in the BO loop, I reach the optimum faster with unstandardized output.

This seems odd. Sometimes improving the model doesn't help all that much , but it's very rare to see a better model result in worse performance, at least if the problem is well specified. Did you run a number of replicates from different seeds to understand whether this behavior is consistent? Or was this just anecdotal or a single occurrence?