Predicted target values (non-scaled) for a Gaussian Process model

[inogueroles]

Hello, I am working on an active learning project using the BayBE library (GP surrogate model + Bayesian optimization) and have a few questions about retrieving the predicted target values from the Gaussian Process model. Briefly, our model has eight inputs (x1-x8) and one target. The active learning loop recommends 10 experiments per cycle to help minimize the target.

We would like to obtain the predicted target values to compare these with the experimental results. It looks like BayBE performs internal scaling/normalization because negative values are obtained for "Predicted_target", even though the target only has positive values in the dataset (it is typically between 0.5 and 5). I tried to reverse the scaling by multiplying by the standard deviation and adding the mean of the initial dataset but am not sure if this is the correct approach. Although this gives positive values now, we get the same value for "REAL_Predicted_target" across all ten recommended experiments (see image attached). Therefore, I am not sure if this is the right way to de-scale the predictions.

Could you please help us obtain the non-scaled predicted values which we can use for comparing the predicted vs actual target?

Thank you in advance for your help!

Code:

# Define the optimization objective
target_name = "Target"
target_mode = "MIN"
target = NumericalTarget(name=target_name, mode=target_mode, bounds=(-5,5))
objective = SingleTargetObjective(target=target)

# Define the parameters for the search space and their bounds 
parameters = [NumericalContinuousParameter(name="x1", bounds=(0,100),),
    NumericalContinuousParameter(name="x2", bounds=(0,100),),
    NumericalContinuousParameter(name="x3", bounds=(0,100),),
    NumericalContinuousParameter(name="x4", bounds=(0,100),),
    NumericalContinuousParameter(name="x5", bounds=(553,613),),
    NumericalContinuousParameter(name="x6", bounds=(10,50),),
    NumericalContinuousParameter(name="x7", bounds=(12000,192000),),
    NumericalContinuousParameter(name="x8", bounds=(1.5,4),),]

# Define the constraints: Sum of x1-x4 must be equal to 100
constraint = ContinuousLinearConstraint(parameters=["x1", "x2", "x3", "x4"], operator="=", coefficients=[1.0, 1.0, 1.0, 1.0], rhs=100,)

# Import the search space
searchspace = SearchSpace.from_product(parameters=parameters, constraints=[constraint])

# Create the recommender and campaign
acquisition_function = "qLogEI"
recommender = BotorchRecommender(surrogate_model=GaussianProcessSurrogate(), acquisition_function=acquisition_function,)
campaign = Campaign(searchspace=searchspace, objective=objective, recommender=recommender,)

campaign.add_measurements(df)

# Get recommendations
import time
start_time = time.time()
recommendation = campaign.recommend(batch_size=10)
print(recommendation.round(2))
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Execution time: {elapsed_time:.2f} seconds")

# Retrieve the surrogate model
surrogate_model = campaign.recommender.get_surrogate(searchspace=campaign.searchspace, objective=campaign.objective, measurements=campaign.measurements)

recommendation_df = pd.DataFrame(recommendation)

# Get posterior from the surrogate model
recommendation_df_copy = recommendation_df.copy()
posterior = surrogate_model.posterior(recommendation_df_copy)

# Extract the mean as the predicted target
predicted_targets = posterior.mean.detach().numpy().flatten()
predicted_targets_stddev = posterior.stddev.detach().numpy().flatten()

# Add predicted target values to the DataFrame
recommendation_df["Predicted_target"] = predicted_targets
recommendation_df["Predicted_stddev"] = predicted_targets_stddev
recommendation_df["Predicted_min"] = recommendation_df["Predicted_target"] - recommendation_df["Predicted_stddev"]
recommendation_df["Predicted_max"] = recommendation_df["Predicted_target"] + recommendation_df["Predicted_stddev"]

# Adjust the normalized model outputs (predicted target values) to get the non-scaled predicted target
y_mean = df['Target'].mean()
y_std = df['Target'].std()
predicted_target_real = predicted_targets * y_std + y_mean
recommendation_df["REAL_Predicted_target"] = predicted_target_real
recommendation_df["REAL_min"] = recommendation_df["Predicted_min"] * y_std + y_mean
recommendation_df["REAL_max"] = recommendation_df["Predicted_max"] * y_std + y_mean
recommendation_df["REAL_stddev"] = recommendation_df["Predicted_stddev"] * y_std

# Display the recommended experiments and predicted targets
display(recommendation_df.round(2))

[AdrianSosic]

Hi @inogueroles,

let me keep it short but with all necessary info:

• The scaling you observe is exactly one of the confusing / unintended side-effects that you get by providing target bounds using our old target interface, which I mentioned in my answer to your other thread. As explained there, the bounds probably don't do what you think they do, and you should likely just remove them.
• In fact, I recommend you upgrade to the newer (ideally the latest) version, where we've cleanup up the design and also introduce many more convenience functionality like the posterior_stats method, which exactly does the job for you. Have a look here
• If you really want to perform optimization on a bounded / scaled transformation of your target (which I guess is not the case here), have a look at our new transformations user guide

Here a condensed version of your code that does what you are looking for:

import pandas as pd

from baybe.campaign import Campaign
from baybe.constraints import ContinuousLinearConstraint
from baybe.parameters import NumericalContinuousParameter
from baybe.searchspace import SearchSpace
from baybe.targets import NumericalTarget
from baybe.utils.dataframe import create_fake_input

objective = NumericalTarget(name="Target", minimize=True).to_objective()
parameters = [
    NumericalContinuousParameter(name="x1", bounds=(0, 100)),
    NumericalContinuousParameter(name="x2", bounds=(0, 100)),
    NumericalContinuousParameter(name="x3", bounds=(0, 100)),
    NumericalContinuousParameter(name="x4", bounds=(0, 100)),
    NumericalContinuousParameter(name="x5", bounds=(553, 613)),
    NumericalContinuousParameter(name="x6", bounds=(10, 50)),
    NumericalContinuousParameter(name="x7", bounds=(12000, 192000)),
    NumericalContinuousParameter(name="x8", bounds=(1.5, 4)),
]
constraint = ContinuousLinearConstraint(
    parameters=["x1", "x2", "x3", "x4"],
    operator="=",
    coefficients=[1.0, 1.0, 1.0, 1.0],
    rhs=100,
)
searchspace = SearchSpace.from_product(parameters=parameters, constraints=[constraint])
campaign = Campaign(searchspace=searchspace, objective=objective)

# >>>>> Added by me because I don't have your data
df = create_fake_input(campaign.parameters, campaign.targets, n_rows=5)
campaign.add_measurements(df)
# <<<<<

print("Posterior statistics evaluated at the campaign measurements (for comparison):")
print(pd.concat([campaign.measurements, campaign.posterior_stats()], axis=1))

print("Posterior statistics evaluated at the recommendations:")
recommendations = campaign.recommend(5)
print(pd.concat([recommendations, campaign.posterior_stats(recommendations)], axis=1))

Let me know if you need more help 👍🏼

[inogueroles]

Dear @AdrianSosic and @Scienfitz,

Thank you both for your help and I am sorry for the delay. It is nice to see that the new code and baybe documentation removes the target bounds to avoid confusion. I have tried the campaign.posterior_stats(recommendations) code you suggested. When removing the target bounds, it indeed directly gives an target_mean and target_std on the original scale which seem reasonable. This is indeed exactly what we would need! However, the recommended experiments are not the same with and without the target bounds.

Unfortunately, I already did the optimization last year and performed experiments recommended by the model. This means that I cannot remove the target bounds anymore because the recommended experiments would change and therefore do not match the experiments we did. We ran the new experiments, added those results to the initial dataset and then ran the model again to give new recommendations based on the updated dataset (done for three cycles). This is also why we were calling it active learning, even though we have focused on optimization/exploitation with the Expected Improvement acquisition function. Is this alright or would it be better to completely remove the term active learning throughout the publication and only say machine learning optimization?

Since I am stuck with the original code that has the target bounds, I cannot use the posterior_stats code to get the untransformed targets. When I tried, the target_mean values are the same scaled, negative values as what I got originally for Predicted_target.

Would there be an alternative we can use to get the target predictions on the original (unnormalized and untransformed) scale? I checked the transformations documentation for the target, but am having trouble with how the code should look for the back-transformation that we need. In the old baybe documentation which I used at the time, it was optional to specify a transformation for the target so we did not. I think the default was linear transformation but this is not an option in the new documentation (https://emdgroup.github.io/baybe/stable/userguide/transformations.html).

Thank you in advance for your help!

[AdrianSosic]

Hi @inogueroles

When removing the target bounds, it indeed directly gives an target_mean and target_std on the original scale which seem reasonable. This is indeed exactly what we would need!

Glad this works 🎉

However, the recommended experiments are not the same with and without the target bounds.

Yes, and it's also not expected that the recommendations are the same because – as I tried to explain earlier – the underlying model is a different one and doesn't do what you think it does. In particular, what was called a "linear" transformation (and that is where one big part of the confusion lies) was actually not "linear" but a "clamped linear" transformation. Here the corresponding picture from our former 0.13.2 documentation:

As you can see, it cuts the target values at some minimum and maximum value. However, unless you are in a situation where you need bounded targets (like desirability computation with geometric mean), there is little reason to even apply such a transformation.

I think the default was linear transformation but this is not an option in the new documentation

My text above also explains why you no longer find this in the new doc --> since it is actually a clamped transformation, this now corresponds to the normalized_ramp transformation. The key difference to the old approach is that we've now cleanly encapsulated it as an explicit transformation and the user needs to make a conscious choice to activate it, where previously, this transformation was applied depending on whether or not you provided bounds (which was very unintuitive/confusing)

Would there be an alternative we can use to get the target predictions on the original (unnormalized and untransformed) scale?

In principle, you can undo the legacy transformation to a certain extent (you need to invert the ramp), but you need to keep two things in mind:

• Technically, the transformation is not invertible since it is not injective! Strictly speaking, you can therefore only invert the linear segment of it. But because the BO algorithm saw the clamped values when it ran, you ended up on a different optimization trajectory, which explains why the results differ.
• In the previous version of the code, the transformation was applied as a pre-transformation, while it now properly enters the computational graph using backpropagation. That is, previously the logic was: target values -> transform -> apply GP model. But now we use: target values -> apply GP model -> transform. The consequence is that Gaussianity is assumed on a different level, so your mean and standard variances have different interpretations.

Overall, I would not recommend to follow up on this path of trying to invert the legacy transformation. Mostly because:

Unfortunately, I already did the optimization last year and performed experiments recommended by the model. This means that I cannot remove the target bounds anymore because the recommended experiments would change and therefore do not match the experiments we did.

This actually does not matter. The good part about BO is that it does not matter where and how the measurements originated. In particular, it doesn't matter if measurements coincide with previous recommendations or not. See our FAQ:

So even though your first few rounds of measurements came from the "legacy" code, simply treat them as data and enter it to your "modern" campaign, and continue the BO loop from there 🙃

Is this alright or would it be better to completely remove the term active learning throughout the publication and only say machine learning optimization?

I think there is no clear consensus in the community. All I can say is that we use the two terms because it allows us to cleanly differentiate the two goals that people can have

• Bayesian Optimization: You want to find the optimum of a black box with the least number experiments. You only care about finding the optimum but not how you get there, and in particular, your goal is not to find a good predictive model that works on the entire domain
• Active Learning: You don't care about optimization. You goal is to "understand" the blackbox, i.e. you want to find the best input-output (a.k.a. predictive) model with the least number of experiments. While this also essentially tells you where the optimum lies, you could have gotten there faster with BO, i.e. if you didn't care about regions that are far from it

Makes sense?

[Scienfitz]

@inogueroles
It is already implicitly in Adrians answer, but in case thats not clear to you: you can look at old version of the baybe documentation by selecting the version you used back when you did the work here: https://emdgroup.github.io/baybe/versions

or click the "Version: xyz" button

[inogueroles]

Dear @AdrianSosic,

Thank you for your replies. Indeed, I understood that the model is different with and without the target bounds which leads to different recommendations. It is also clear that the new experiments do not have to match the recommendations exactly (they did not match exactly for us either since we cannot have 100% precision in controlling the inputs x1-x8). The issue is not that the experiments we did do not coincide perfectly with the model recommendations, but that we would like to get the predicted targets for specifically these model recommendations on which we based our experiments. Since the BO loops were already completed for this project, we cannot repeat all cycles again without target bounds.

We are still interested in how to get the predicted targets on the original (unnormalized and untransformed) scale because we would like to be able to compare the predicted vs measured target values across the cycles. Maybe it is more clear with this table from another study as an example:

We would similarly like to report the suggested vs actual input features and the predicted vs measured target. This allows us to see whether the model was generally over/underestimating the target value and if it was still reasonably close. The idea is also to see if the prediction error got smaller as the cycles progressed and we would like to make a scatter plot comparing predicted vs measured target values to get an idea of the prediction accuracy. Would you be able to help us with the code that can retrieve the predicted targets on the original scale (still using the original model with target bounds)? If we would run the model without target bounds, we cannot match the recommended experiment like this with the corresponding actual experiment that we performed in the lab. With eight inputs, it is not possible to match up all of the experiments so that all predicted-actual inputs are within a small difference (e.g., x1-x4 could be 2-3% off but then x5-x8 are very different from the actual inputs). Is this clear?

For the active learning vs Bayesian optimization term, I guess that the optimization might be better for us then since we did not do any exploration, only exploitation. We were mostly interested in reaching a lower target without exploring regions that were very far from it. From previous studies in the group, we had established that the extremes were not favorable so searching closer to the optima made more sense for us.

@Scienfitz: Thank you for commenting about the documentation searching - I was not aware of this.

Thank you in advance for your help!

[AdrianSosic]

Hi @inogueroles, sorry for getting back to you so late, this somehow dropped off my plate.

Would you be able to help us with the code that can retrieve the predicted targets on the original scale (still using the original model with target bounds)?

Note that it is generally difficult for us to provide support for older versions of the code, especially in cases like this one where the previous version was sort of bugged which caused us to change it in the first place. This is also complicated by the fact that I would need to know the exact version of the code you used at that time, including all possible workarounds/hotfixes present at that moment, to perfectly reverse-engineer the required "fix" for your code. So please take the following code a huge grain of salt!! That being said, the logic required to give you the "corrected" (modulo clamping at the boundaries) predictions should roughly be the following:

import pandas as pd
from packaging.version import Version

import baybe
from baybe.campaign import Campaign
from baybe.parameters import NumericalContinuousParameter
from baybe.targets import NumericalTarget
from baybe.targets.enum import TargetMode, TargetTransformation
from baybe.utils.dataframe import create_fake_input
from baybe.utils.random import set_random_seed

set_random_seed(1337)


def undo_linear_pretransformation(
    stats: pd.DataFrame, target: NumericalTarget
) -> pd.DataFrame:
    assert target.transformation == TargetTransformation.LINEAR, (
        "only meant for linear transformations"
    )

    if not target.bounds.is_bounded:
        return stats

    result = stats.copy()
    lower, upper = target.bounds.to_tuple()
    scale = upper - lower
    anchor = upper if target.mode is TargetMode.MIN else lower

    prefix = f"{target.name}_"
    for col in result.columns:
        if not col.startswith(prefix):
            continue
        stat = col[len(prefix) :]
        if stat == "mean":
            result[col] = anchor + result[col] * scale
        elif stat == "std":
            result[col] = result[col] * scale
        else:
            raise NotImplementedError()

    return result


bounds = [2000, 3000]
target = NumericalTarget(
    name="Target", mode="MIN", bounds=bounds, transformation="LINEAR"
)
objective = target.to_objective()
searchspace = NumericalContinuousParameter(name="x1", bounds=(0, 100)).to_searchspace()
campaign = Campaign(searchspace, objective)

# >>>>> Added by me because I don't have your data
df = create_fake_input(campaign.parameters, campaign.targets, n_rows=5)
df = pd.DataFrame(
    {
        "x1": [10, 20, 30, 40, 50],
        "Target": [2186.66, 2472.31, 2585.56, 2799.48, 2793.04],
    }
)
campaign.add_measurements(df)
# <<<<<

stats = campaign.posterior_stats(df)

if Version(baybe.__version__) < Version("0.14"):
    stats = undo_linear_pretransformation(stats, target)
print(pd.concat([df, stats], axis=1))

Gives something like:

   x1   Target  Target_mean  Target_std
0  10  2186.66  2216.047038   51.547480
1  20  2472.31  2430.790549   39.128249
2  30  2585.56  2623.714459   39.592274
3  40  2799.48  2757.868433   39.128249
4  50  2793.04  2808.629466   51.547480

Hopefully, you can work out your way from here. But again, please notice: using such a workaround is only needed if you really insist on using your old BayBE version for whatever reason. If it's only about getting predictions, you are better off by just feeding your collected data into a campaign created with the new code. That is, the With eight inputs, it is not possible to match up all of the experiments-situation you describe is actually not a problem from my perspective --> you don't need to make the recommendations match! Instead, just ask the new model what it thinks about the old recommendations. But the choice is yours!

The idea is also to see if the prediction error got smaller as the cycles progressed

This is a common fallacy and you should not expect this to happen! At it's very heart, Bayesian Optimization is not just about exploiting known relationships also about taking leaps of faith to regions where uncertainty is high, i.e. with common acquisition functions like EI you will always have an exploratory component in the behavior, meaning that you are constantly expanding the regions you've visited in the searchspace. And since this means operating at the boundary to the unknown, there is no reason to expect that that the uncertainty over new recommendations will generally shrink. So be careful with the conclusions here.

This allows us to see whether the model was generally over/underestimating the target value and if it was still reasonably close.

Be aware that there are two kinds of uncertainty associated with the predictions, i.e. including an excluding the measurement noise. So make sure that your conclusions are in line with which of the two you report.