Interpolated optimization

Bayesian Optimization w/ Interpolated Samples¶

In some situations, the process of evaluating objectives and constraints consumes fewer resources compared to the computational demands associated with Bayesian Optimization (BO) decision-making. Particularly, when making subtle changes to parameters during optimization, the cost of assessing objectives becomes notably more affordable.

Consider a practical example: the optimization of magnet parameters in an accelerator with the goal of either minimizing the beam spot size on a screen or maximizing the Free Electron Laser (FEL) pulse energy. In such cases, where adjustments to accelerator parameters are frequent, it proves beneficial to augment the dataset by implementing multiple smaller changes to the parameters. These adjustments are followed by quick measurements of the objective in between the parameter changes guided by BO.

This approach, although introducing a slight slowdown to the BO process due to the addition of extra training points, it will expedite convergence for most problems. It offers a more efficient alternative compared to the strategy of measuring the same points multiple times in noisy environments. The rationale here is that the exploration of a broader parameter space through numerous smaller changes enhances the overall understanding of the system's behavior, potentially leading to a more efficient and effective optimization process.

NOTE: This only works for serialized problems.

WARNING: The interpolated points may violate constraints! Do not use this feature in problems where safety is critical.

Define the test problem¶

Here we define a simple optimization problem, where we attempt to minimize the sphere function.

In [1]:

from xopt.vocs import VOCS

# define variables and function objectives
vocs = VOCS(
    variables={"x1": [-1, 1], "x2": [-1, 1]},
    objectives={"f": "MINIMIZE"},
)

from xopt.vocs import VOCS # define variables and function objectives vocs = VOCS( variables={"x1": [-1, 1], "x2": [-1, 1]}, objectives={"f": "MINIMIZE"}, )

In [2]:

# define a test function to optimize

def sphere_function(input_dict):
    return {"f": input_dict["x1"]**2 + input_dict["x2"]**2}

# define a test function to optimize def sphere_function(input_dict): return {"f": input_dict["x1"]**2 + input_dict["x2"]**2}

Create Xopt objects¶

Create the evaluator to evaluate our test function and create a generator that uses the Upper Confidence Bound acquisition function to perform Bayesian Optimization. We additionally specify n_interpolate_points to be non-zero such that the generator proposes interpolated points during generation.

In [3]:

from xopt.evaluator import Evaluator
from xopt.generators.bayesian import ExpectedImprovementGenerator
from xopt import Xopt

# define a generator that uses 5 interpolation points during sampling
generator = ExpectedImprovementGenerator(vocs=vocs, n_interpolate_points=5)
generator.gp_constructor.use_low_noise_prior = True


evaluator = Evaluator(function=sphere_function)
X = Xopt(evaluator=evaluator, generator=generator, vocs=vocs)

from xopt.evaluator import Evaluator from xopt.generators.bayesian import ExpectedImprovementGenerator from xopt import Xopt # define a generator that uses 5 interpolation points during sampling generator = ExpectedImprovementGenerator(vocs=vocs, n_interpolate_points=5) generator.gp_constructor.use_low_noise_prior = True evaluator = Evaluator(function=sphere_function) X = Xopt(evaluator=evaluator, generator=generator, vocs=vocs)

Generate and evaluate initial points¶

To begin optimization, we must generate some random initial data points. The first call to X.step() will generate and evaluate a number of randomly points specified by the generator. Note that if we add data to xopt before calling X.step() by assigning the data to X.data, calls to X.step() will ignore the random generation and proceed to generating points via Bayesian optimization.

In [4]:

# call X.random_evaluate() to generate + evaluate initial points
X.random_evaluate(2)

# inspect the gathered data
X.data

# call X.random_evaluate() to generate + evaluate initial points X.random_evaluate(2) # inspect the gathered data X.data

Out[4]:

	x1	x2	f	xopt_runtime	xopt_error
0	-0.697131	-0.191400	0.522626	2.208020e-06	False
1	0.736646	0.060323	0.546286	9.170035e-07	False

Do bayesian optimization steps¶

To perform optimization we simply call X.step() in a loop. This allows us to do intermediate tasks in between optimization steps, such as examining the model and acquisition function at each step (as we demonstrate here).

In [5]:

X.generator.train_model()
X.generator.visualize_model(n_grid=50)

n_steps = 5
for i in range(n_steps):
    print(i)
    # do the optimization step
    X.step()

    # train the model and visualize
    X.generator.train_model()
    fig,ax = X.generator.visualize_model(n_grid=50)

    # add the ground truth minimum location
    for a in ax.flatten()[:-1]:
        a.plot(0, 0, "x", c="red", ms=10)

X.generator.train_model() X.generator.visualize_model(n_grid=50) n_steps = 5 for i in range(n_steps): print(i) # do the optimization step X.step() # train the model and visualize X.generator.train_model() fig,ax = X.generator.visualize_model(n_grid=50) # add the ground truth minimum location for a in ax.flatten()[:-1]: a.plot(0, 0, "x", c="red", ms=10)

0
1
2
3
4

In [6]:

# access the collected data
X.data

# access the collected data X.data

Out[6]:

	x1	x2	f	xopt_runtime	xopt_error
0	-0.697131	-0.191400	0.522626	2.208020e-06	False
1	0.736646	0.060323	0.546286	9.170035e-07	False
2	0.389316	-0.120088	0.165988	1.625012e-06	False
3	0.041987	-0.300499	0.092063	7.080089e-07	False
4	-0.305342	-0.480911	0.324509	4.169997e-07	False
5	-0.652671	-0.661322	0.863326	2.910092e-07	False
6	-1.000000	-0.841733	1.708515	4.169997e-07	False
7	-0.811772	-0.636729	1.064397	4.417001e-06	False
8	-0.623543	-0.431725	0.575192	5.830079e-07	False
9	-0.435315	-0.226720	0.240901	2.919987e-07	False
10	-0.247086	-0.021716	0.061523	4.580070e-07	False
11	-0.058858	0.183288	0.037059	3.340247e-07	False
12	-0.046883	0.145340	0.023322	2.082990e-06	False
13	-0.034908	0.107391	0.012751	5.839975e-07	False
14	-0.022933	0.069442	0.005348	2.909801e-07	False
15	-0.010959	0.031493	0.001112	4.169997e-07	False
16	0.001016	-0.006456	0.000043	2.919987e-07	False
17	-0.104660	0.194836	0.048915	1.750013e-06	False
18	-0.210337	0.396127	0.201158	4.169997e-07	False
19	-0.316013	0.597418	0.456772	6.250048e-07	False
20	-0.421689	0.798709	0.815758	2.910092e-07	False
21	-0.527366	1.000000	1.278115	3.750029e-07	False
22	-0.221893	0.600000	0.409236	1.999986e-06	False
23	0.083580	0.200000	0.046986	6.669725e-07	False
24	0.389054	-0.200000	0.191363	4.580070e-07	False
25	0.694527	-0.600000	0.842368	3.330060e-07	False
26	1.000000	-1.000000	2.000000	3.329769e-07	False

Getting the optimization result¶

To get the best point (without evaluating it) we ask the generator to predict the optimum based on the posterior mean.

In [7]:

X.generator.get_optimum()

X.generator.get_optimum()

Out[7]:

	x1	x2
0	-0.000051	0.000449