What is the usage of condition_on_observations?

[Sam4896]

Hi everyone,
I am a novice to the realm of BO and GP. I am leaning how to use BoTorch for the same and have to make my own GP network for my problem. I tried to experiment with the package and also looked into the library. I have two major questions:

According to my understanding after reading the comment in the library and the code, the condition_on_observation function is used to update the model for the new observation.

1. If my understanding is correct, why can't we just do GPmodel(torch.cat([old_y, new_y]), torch.cat([old_y, new_y]))?
2. Why and when is the condition_on_observations?

I would be extremely thankful for any help that can be offered.

I tried doing a small experiment to check it. Why are the results different in CASE 1 and CASE 2?

In CASE 1:

I initially train the GP on a set of data points [0.02, 0.1, 0.15, 0.25, 0.3, 0.35, 0.4, 0.5].
Then I obtain the posterior mean and variance at test point 0.8.
The mean is 0.9179 and the variance is 0.028.

init_x = torch.tensor([0.02, 0.1, 0.15, 0.25, 0.3, 0.35, 0.4, 0.5], dtype=torch.double).unsqueeze(-1)
init_y = target_function(init_x).unsqueeze(-1)
best_init_y = init_y.max().item()

bounds = torch.tensor([[-2.], [10.]]) #bounds for 2D: torch.tensor([[0., 1.], [10.,2.]])

from botorch.models import SingleTaskGP
from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood

single_model = SingleTaskGP(init_x, init_y)
mll = ExactMarginalLogLikelihood(single_model.likelihood, single_model)

from botorch import fit_gpytorch_model
fit_gpytorch_model(mll)

with torch.no_grad():
test_x = torch.tensor([[0.8]], dtype=torch.double)
posterior = single_model.posterior(test_x)

print(f'Mean is: {posterior.mean}')
print(f'Var is: {posterior.variance}')

###########################################################################################

In CASE 2:

I initially train the GP on a set of data points [0.02, 0.1, 0.15, 0.25, 0.3, 0.35].
Then I obtain the posterior mean and variance at test point 0.8.
The mean is 0.9637 and the variance is 0.060.
Then I condition the GP on additional observations at points [0.4, 0.5] using model.condition_on_observations.
Then I obtain the posterior mean and variance at test point 0.8 again.
The mean is 0.9206 and the variance is 0.026.

init_x = torch.tensor([0.02, 0.1, 0.15, 0.25, 0.3, 0.35], dtype=torch.double).unsqueeze(-1)
init_y = target_function(init_x).unsqueeze(-1)
best_init_y = init_y.max().item()

bounds = torch.tensor([[-2.], [10.]]) #bounds for 2D: torch.tensor([[0., 1.], [10.,2.]])

from botorch.models import SingleTaskGP
from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood

single_model = SingleTaskGP(init_x, init_y)
mll = ExactMarginalLogLikelihood(single_model.likelihood, single_model)

single_model.parameters

from botorch import fit_gpytorch_model
fit_gpytorch_model(mll)

with torch.no_grad():
test_x = torch.tensor([[0.8]], dtype=torch.double)
posterior = single_model.posterior(test_x)

print(f'Mean is: {posterior.mean}')
print(f'Var is: {posterior.variance}\n')

extra_x = torch.tensor([0.4, 0.5], dtype=torch.double).unsqueeze(-1)
extra_y = target_function(extra_x).unsqueeze(-1)

model_conditioned = single_model.condition_on_observations(extra_x, extra_y)

with torch.no_grad():
posterior = model_conditioned.posterior(test_x)

print(f'Mean for conditioned_model is: {posterior.mean}')
print(f'Var for conditioned_model is: {posterior.variance}\n')

mll_conditioned = ExactMarginalLogLikelihood(model_conditioned.likelihood, model_conditioned)
fit_gpytorch_model(mll_conditioned)

with torch.no_grad():
posterior = model_conditioned.posterior(test_x)

print(f'Mean for conditioned_model is: {posterior.mean}')
print(f'Var for conditioned_model is: {posterior.variance}\n')

[saitcakmak]

Hi @Sam4896

According to my understanding after reading the comment in the library and the code, the condition_on_observation function is used to update the model for the new observation.

condition_on_observations is primarily used when fantasizing from the model, e.g., when using a knowledge gradient type acquisition function.

If my understanding is correct, why can't we just do GPmodel(torch.cat([old_y, new_y]), torch.cat([old_y, new_y]))?

This is what we typically do. If you check the tutorials on the website, all of them will be doing this rather than using condition_on_observations.

Why and when is the condition_on_observations?

There's the fantasize usage mentioned above. Other than that, if you did not want to re-train the model hyper-parameters but only update its data, you could use condition_on_observations for that. Another difference is that if you train a freshly created model, the training will start from default initial values of the hyper-parameters. If you re-train a model after condition_on_observations, the training will start from the previous hyper-parameter values. As a result, it is possible to end up with slightly different trained models with the two approaches.

[Sam4896]

Hi @saitcakmak

Thanks a lot for the help.