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 0x7fb6462b3f50>

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(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(generator=generator, evaluator=evaluator) X

Out[3]:

            Xopt
________________________________
Version: 0.1.dev1+g46cc86a6b
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
    train_config: null
    train_kwargs: null
    train_method: lbfgs
    train_model: true
    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:
    discrete_max_batch_size: 2048
    discrete_max_choices: 4096
    max_iter: 1000
    max_time: 5.0
    mixed_max_discrete_configurations: 512
    n_restarts: 20
    name: LBFGS
  reference_point:
    f: 100.0
    s: 0.0
  returns_id: false
  supports_batch_generation: true
  supports_constraints: true
  supports_contextual_variables: true
  supports_discrete_variables: true
  supports_multi_objective: true
  supports_no_objective: true
  turbo_controller: null
  use_cuda: false
  use_pf_as_initial_points: false
  vocs:
    constants: {}
    constraints: {}
    objectives:
      f:
        dtype: null
        type: MinimizeObjective
      s:
        dtype: null
        type: MaximizeObjective
    observables: {}
    variables:
      s:
        default_value: null
        domain:
        - 0.0
        - 1.0
        dtype: null
        type: ContinuousVariable
      x:
        default_value: null
        domain:
        - 0.0
        - 6.283185307179586
        dtype: null
        type: ContinuousVariable
serialize_inline: false
serialize_torch: false
stopping_condition: null
strict: true

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.000010	False
1	1.570796	0.25	1.064601	0.000003	False
2	3.141593	0.00	-1.387351	0.000002	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)

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.get_pareto_front_and_hypervolume()[-1]:.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.get_pareto_front_and_hypervolume()[-1]:.4}" )

n_samples: 4 budget used: 0.5784 hypervolume: 32.84

n_samples: 5 budget used: 1.029 hypervolume: 45.51

n_samples: 6 budget used: 1.695 hypervolume: 66.87

n_samples: 7 budget used: 2.678 hypervolume: 98.69

n_samples: 8 budget used: 3.679 hypervolume: 100.5

n_samples: 9 budget used: 4.68 hypervolume: 101.1

n_samples: 10 budget used: 4.73 hypervolume: 101.1

n_samples: 11 budget used: 5.731 hypervolume: 101.1

n_samples: 12 budget used: 6.139 hypervolume: 101.1

n_samples: 13 budget used: 6.799 hypervolume: 101.2

n_samples: 14 budget used: 7.003 hypervolume: 101.2

n_samples: 15 budget used: 8.004 hypervolume: 101.2

n_samples: 16 budget used: 8.825 hypervolume: 101.2

n_samples: 17 budget used: 9.826 hypervolume: 101.2

In [7]:

X.data

X.data

Out[7]:

	x	s	f	xopt_runtime	xopt_error
0	0.785398	0.000000	1.610902e+00	0.000010	False
1	1.570796	0.250000	1.064601e+00	0.000003	False
2	3.141593	0.000000	-1.387351e+00	0.000002	False
3	3.537761	0.324375	-1.230932e+00	0.000009	False
4	3.395867	0.449924	-9.484387e-01	0.000011	False
5	0.000000	0.664400	3.895059e-01	0.000009	False
6	0.000000	0.981807	1.835812e-02	0.000025	False
7	6.283185	1.000000	-2.449294e-16	0.000010	False
8	4.464427	1.000000	-9.694147e-01	0.000011	False
9	3.904126	0.049989	-1.591896e+00	0.000010	False
10	0.000000	1.000000	0.000000e+00	0.000009	False
11	4.246943	0.406435	-1.334495e+00	0.000009	False
12	4.448581	0.659175	-1.182279e+00	0.000025	False
13	3.965219	0.202461	-1.488101e+00	0.000009	False
14	4.835559	1.000000	-9.924242e-01	0.000008	False
15	4.589002	0.820055	-1.092395e+00	0.000010	False
16	6.283185	1.000000	-2.449294e-16	0.000008	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.000010	False
1	1.570796	0.250000	1.064601e+00	0.000003	False
2	3.141593	0.000000	-1.387351e+00	0.000002	False
3	3.537761	0.324375	-1.230932e+00	0.000009	False
4	3.395867	0.449924	-9.484387e-01	0.000011	False
5	0.000000	0.664400	3.895059e-01	0.000009	False
6	0.000000	0.981807	1.835812e-02	0.000025	False
7	6.283185	1.000000	-2.449294e-16	0.000010	False
8	4.464427	1.000000	-9.694147e-01	0.000011	False
9	3.904126	0.049989	-1.591896e+00	0.000010	False
10	0.000000	1.000000	0.000000e+00	0.000009	False
11	4.246943	0.406435	-1.334495e+00	0.000009	False
12	4.448581	0.659175	-1.182279e+00	0.000025	False
13	3.965219	0.202461	-1.488101e+00	0.000009	False
14	4.835559	1.000000	-9.924242e-01	0.000008	False
15	4.589002	0.820055	-1.092395e+00	0.000010	False
16	6.283185	1.000000	-2.449294e-16	0.000008	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.698953629222721}, 's': {0: 1.0}}