Multi-fidelity BO¶

Here we demonstrate how Multi-Fidelity Bayesian Optimization can be used to reduce the computational cost of optimization by using lower fidelity surrogate models. The goal is to learn functional dependance of the objective on input variables at low fidelities (which are cheap to compute) and use that information to quickly find the best objective value at higher fidelities (which are more expensive to compute). This assumes that there is some learnable correlation between the objective values at different fidelities.

Xopt implements the MOMF (https://botorch.org/tutorials/Multi_objective_multi_fidelity_BO) algorithm which can be used to solve both single (this notebook) and multi-objective (see multi-objective BO section) multi-fidelity problems. Under the hood this algorithm attempts to solve a multi-objective optimization problem, where one objective is the function objective and the other is a simple fidelity objective, weighted by the cost_function of evaluating the objective at a given fidelity.

In [1]:

from xopt.generators.bayesian import MultiFidelityGenerator
from xopt import Evaluator, Xopt
from xopt import VOCS
import os

import matplotlib.pyplot as plt
import numpy as np
import math

import pandas as pd


# Ignore all warnings
import warnings

warnings.filterwarnings("ignore")

SMOKE_TEST = os.environ.get("SMOKE_TEST")
N_MC_SAMPLES = 1 if SMOKE_TEST else 128
N_RESTARTS = 1 if SMOKE_TEST else 20


def test_function(input_dict):
    x = input_dict["x"]
    s = input_dict["s"]
    return {"f": np.sin(x + (1.0 - s)) * np.exp((-s + 1) / 2)}


# define vocs


vocs = VOCS(
    variables={
        "x": [0, 2 * math.pi],
    },
    objectives={"f": "MINIMIZE"},
)

from xopt.generators.bayesian import MultiFidelityGenerator from xopt import Evaluator, Xopt from xopt import VOCS import os import matplotlib.pyplot as plt import numpy as np import math import pandas as pd # Ignore all warnings import warnings warnings.filterwarnings("ignore") SMOKE_TEST = os.environ.get("SMOKE_TEST") N_MC_SAMPLES = 1 if SMOKE_TEST else 128 N_RESTARTS = 1 if SMOKE_TEST else 20 def test_function(input_dict): x = input_dict["x"] s = input_dict["s"] return {"f": np.sin(x + (1.0 - s)) * np.exp((-s + 1) / 2)} # define vocs vocs = VOCS( variables={ "x": [0, 2 * math.pi], }, objectives={"f": "MINIMIZE"}, )

plot the test function in input + fidelity space¶

In [2]:

test_x = np.linspace(*vocs.bounds, 1000)
fidelities = [0.0, 0.5, 1.0]

fig, ax = plt.subplots()
for ele in fidelities:
    f = test_function({"x": test_x, "s": ele})["f"]
    ax.plot(test_x, f, label=f"s:{ele}")

ax.legend()

test_x = np.linspace(*vocs.bounds, 1000) fidelities = [0.0, 0.5, 1.0] fig, ax = plt.subplots() for ele in fidelities: f = test_function({"x": test_x, "s": ele})["f"] ax.plot(test_x, f, label=f"s:{ele}") ax.legend()

Out[2]:

<matplotlib.legend.Legend at 0x7fe15e3dc6e0>

In [3]:

# create xopt object
# get and modify default generator options
generator = MultiFidelityGenerator(vocs=vocs)
generator.gp_constructor.use_low_noise_prior = True

# specify a custom cost function based on the fidelity parameter
generator.cost_function = lambda s: s + 0.001

generator.numerical_optimizer.n_restarts = N_RESTARTS
generator.n_monte_carlo_samples = N_MC_SAMPLES

# pass options to the generator
evaluator = Evaluator(function=test_function)

X = Xopt(vocs=vocs, generator=generator, evaluator=evaluator)
X

# create xopt object # get and modify default generator options generator = MultiFidelityGenerator(vocs=vocs) generator.gp_constructor.use_low_noise_prior = True # specify a custom cost function based on the fidelity parameter generator.cost_function = lambda s: s + 0.001 generator.numerical_optimizer.n_restarts = N_RESTARTS generator.n_monte_carlo_samples = N_MC_SAMPLES # pass options to the generator evaluator = Evaluator(function=test_function) X = Xopt(vocs=vocs, generator=generator, evaluator=evaluator) X

Out[3]:

            Xopt
________________________________
Version: 0.1.dev1947+g7831d28.d20250426
Data size: 0
Config as YAML:
dump_file: null
evaluator:
  function: __main__.test_function
  function_kwargs: {}
  max_workers: 1
  vectorized: false
generator:
  computation_time: null
  custom_objective: null
  fixed_features: null
  gp_constructor:
    covar_modules: {}
    custom_noise_prior: null
    mean_modules: {}
    name: standard
    trainable_mean_keys: []
    transform_inputs: true
    use_cached_hyperparameters: false
    use_low_noise_prior: true
  max_travel_distances: null
  model: null
  n_candidates: 1
  n_interpolate_points: null
  n_monte_carlo_samples: 128
  name: multi_fidelity
  numerical_optimizer:
    max_iter: 2000
    max_time: 5.0
    n_restarts: 20
    name: LBFGS
  reference_point:
    f: 100.0
    s: 0.0
  supports_batch_generation: true
  supports_constraints: true
  supports_multi_objective: true
  turbo_controller: null
  use_cuda: false
  use_pf_as_initial_points: false
max_evaluations: null
serialize_inline: false
serialize_torch: false
strict: true
vocs:
  constants: {}
  constraints: {}
  objectives:
    f: MINIMIZE
    s: MAXIMIZE
  observables: []
  variables:
    s:
    - 0
    - 1
    x:
    - 0.0
    - 6.283185307179586

In [4]:

# evaluate initial points at mixed fidelities to seed optimization
X.evaluate_data(
    pd.DataFrame({"x": [math.pi / 4, math.pi / 2.0, math.pi], "s": [0.0, 0.25, 0.0]})
)

# evaluate initial points at mixed fidelities to seed optimization X.evaluate_data( pd.DataFrame({"x": [math.pi / 4, math.pi / 2.0, math.pi], "s": [0.0, 0.25, 0.0]}) )

Out[4]:

	x	s	f	xopt_runtime	xopt_error
0	0.785398	0.00	1.610902	0.000011	False
1	1.570796	0.25	1.064601	0.000004	False
2	3.141593	0.00	-1.387351	0.000003	False

In [5]:

# get the total cost of previous observations based on the cost function
X.generator.calculate_total_cost()

# get the total cost of previous observations based on the cost function X.generator.calculate_total_cost()

Out[5]:

tensor(0.2530, dtype=torch.float64)

In [6]:

# run optimization until the cost budget is exhausted
# we subtract one unit to make sure we don't go over our eval budget
budget = 10
while X.generator.calculate_total_cost() < budget - 1:
    X.step()
    print(
        f"n_samples: {len(X.data)} "
        f"budget used: {X.generator.calculate_total_cost():.4} "
        f"hypervolume: {X.generator.calculate_hypervolume():.4}"
    )

# run optimization until the cost budget is exhausted # we subtract one unit to make sure we don't go over our eval budget budget = 10 while X.generator.calculate_total_cost() < budget - 1: X.step() print( f"n_samples: {len(X.data)} " f"budget used: {X.generator.calculate_total_cost():.4} " f"hypervolume: {X.generator.calculate_hypervolume():.4}" )

n_samples: 4 budget used: 0.579 hypervolume: 32.94

n_samples: 5 budget used: 1.032 hypervolume: 45.71

n_samples: 6 budget used: 1.696 hypervolume: 66.81

n_samples: 7 budget used: 2.689 hypervolume: 99.77

n_samples: 8 budget used: 3.69 hypervolume: 100.5

n_samples: 9 budget used: 4.691 hypervolume: 101.1

n_samples: 10 budget used: 5.177 hypervolume: 101.1

n_samples: 11 budget used: 5.318 hypervolume: 101.2

n_samples: 12 budget used: 6.029 hypervolume: 101.2

n_samples: 13 budget used: 6.874 hypervolume: 101.2

n_samples: 14 budget used: 7.317 hypervolume: 101.2

n_samples: 15 budget used: 7.568 hypervolume: 101.2

n_samples: 16 budget used: 8.134 hypervolume: 101.2

n_samples: 17 budget used: 8.195 hypervolume: 101.3

n_samples: 18 budget used: 8.507 hypervolume: 101.3

n_samples: 19 budget used: 9.432 hypervolume: 101.3

In [7]:

X.data

X.data

Out[7]:

	x	s	f	xopt_runtime	xopt_error
0	0.785398	0.000000	1.610902e+00	0.000011	False
1	1.570796	0.250000	1.064601e+00	0.000004	False
2	3.141593	0.000000	-1.387351e+00	0.000003	False
3	3.798136	0.325014	-1.361506e+00	0.000014	False
4	3.255760	0.451697	-8.090683e-01	0.000013	False
5	0.000000	0.663428	3.907802e-01	0.000012	False
6	0.000000	0.992321	7.708470e-03	0.000013	False
7	6.283185	1.000000	-2.449294e-16	0.000013	False
8	4.465656	1.000000	-9.697155e-01	0.000013	False
9	4.552794	0.484154	-1.212975e+00	0.000013	False
10	3.989904	0.140252	-1.522606e+00	0.000013	False
11	4.398469	0.710273	-1.155543e+00	0.000013	False
12	4.466609	0.843387	-1.077158e+00	0.000014	False
13	4.158095	0.442006	-1.321794e+00	0.000012	False
14	3.967572	0.250155	-1.454860e+00	0.000014	False
15	4.270870	0.565750	-1.242467e+00	0.000014	False
16	3.781260	0.059169	-1.600584e+00	0.000013	False
17	4.026188	0.310961	-1.411306e+00	0.000013	False
18	4.532610	0.924213	-1.033010e+00	0.000015	False

Plot the model prediction and acquisition function inside the optimization space¶

In [8]:

fig, ax = X.generator.visualize_model()

fig, ax = X.generator.visualize_model()

Plot the Pareto front¶

In [9]:

X.data.plot(x="f", y="s", style="o-")

X.data.plot(x="f", y="s", style="o-")

Out[9]:

<Axes: xlabel='f'>

In [10]:

X.data

X.data

Out[10]:

	x	s	f	xopt_runtime	xopt_error
0	0.785398	0.000000	1.610902e+00	0.000011	False
1	1.570796	0.250000	1.064601e+00	0.000004	False
2	3.141593	0.000000	-1.387351e+00	0.000003	False
3	3.798136	0.325014	-1.361506e+00	0.000014	False
4	3.255760	0.451697	-8.090683e-01	0.000013	False
5	0.000000	0.663428	3.907802e-01	0.000012	False
6	0.000000	0.992321	7.708470e-03	0.000013	False
7	6.283185	1.000000	-2.449294e-16	0.000013	False
8	4.465656	1.000000	-9.697155e-01	0.000013	False
9	4.552794	0.484154	-1.212975e+00	0.000013	False
10	3.989904	0.140252	-1.522606e+00	0.000013	False
11	4.398469	0.710273	-1.155543e+00	0.000013	False
12	4.466609	0.843387	-1.077158e+00	0.000014	False
13	4.158095	0.442006	-1.321794e+00	0.000012	False
14	3.967572	0.250155	-1.454860e+00	0.000014	False
15	4.270870	0.565750	-1.242467e+00	0.000014	False
16	3.781260	0.059169	-1.600584e+00	0.000013	False
17	4.026188	0.310961	-1.411306e+00	0.000013	False
18	4.532610	0.924213	-1.033010e+00	0.000015	False

In [11]:

# get optimal value at max fidelity, note that the actual maximum is 4.71
X.generator.get_optimum().to_dict()

# get optimal value at max fidelity, note that the actual maximum is 4.71 X.generator.get_optimum().to_dict()

Out[11]:

{'x': {0: 4.574882715728647}, 's': {0: 1.0}}