Working with Xopt generators¶

In [1]:

# Import the class
from xopt.generators import generators, get_generator
from xopt.vocs import VOCS
from xopt import Xopt, Evaluator, Generator

import math
import numpy as np

# Import the class from xopt.generators import generators, get_generator from xopt.vocs import VOCS from xopt import Xopt, Evaluator, Generator import math import numpy as np

In [2]:

# named generators
generators.keys()

# named generators generators.keys()

Out[2]:

dict_keys(['random'])

In [3]:

# get default options for the upper confidence bound generator
generator_type = get_generator("upper_confidence_bound")

# get default options for the upper confidence bound generator generator_type = get_generator("upper_confidence_bound")

/home/runner/work/Xopt/Xopt/.venv/lib/python3.12/site-packages/pyro/ops/stats.py:527: SyntaxWarning: invalid escape sequence '\g'
  we have :math:`ES^{*}(P,Q) \ge ES^{*}(Q,Q)` with equality holding if and only if :math:`P=Q`, i.e.

In [4]:

# define vocs for the problem

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

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

In [5]:

# define a test function to optimize


def test_function(input_dict):
    return {"f": np.sin(input_dict["x"])}

# define a test function to optimize def test_function(input_dict): return {"f": np.sin(input_dict["x"])}

In [6]:

evaluator = Evaluator(function=test_function)
generator = generator_type(vocs=vocs)
X = Xopt(generator=generator, evaluator=evaluator)
X

evaluator = Evaluator(function=test_function) generator = generator_type(vocs=vocs) X = Xopt(generator=generator, evaluator=evaluator) X

Out[6]:

            Xopt
________________________________
Version: 0.1.dev1+gb834d2348
Data size: 0
Config as YAML:
dump_file: null
evaluator:
  function: __main__.test_function
  function_kwargs: {}
  max_workers: 1
  vectorized: false
generator:
  beta: 2.0
  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: false
  max_travel_distances: null
  model: null
  n_candidates: 1
  n_interpolate_points: null
  n_monte_carlo_samples: 128
  name: upper_confidence_bound
  numerical_optimizer:
    max_iter: 2000
    max_time: 5.0
    n_restarts: 20
    name: LBFGS
  returns_id: false
  shift: 0.0
  supports_batch_generation: true
  supports_constraints: true
  supports_single_objective: true
  turbo_controller: null
  use_cuda: false
  vocs:
    constants: {}
    constraints: {}
    objectives:
      f:
        dtype: null
        type: MinimizeObjective
    observables: {}
    variables:
      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 [7]:

# run the optimization for a couple of iterations (see bayes_opt folder for
# more examples of ucb)
X.random_evaluate(2)
for i in range(4):
    X.step()

# run the optimization for a couple of iterations (see bayes_opt folder for # more examples of ucb) X.random_evaluate(2) for i in range(4): X.step()

In [8]:

X.data

X.data

Out[8]:

	x	f	xopt_runtime	xopt_error
0	2.444284	6.421567e-01	0.000010	False
1	0.347844	3.408715e-01	0.000003	False
2	6.283185	-2.449294e-16	0.000005	False
3	5.251479	-8.581764e-01	0.000005	False
4	4.647519	-9.978967e-01	0.000008	False
5	4.644765	-9.977143e-01	0.000005	False

Write your own generator¶

Here we write a generator that generates the same point every time.

In [9]:

class MyGenerator(Generator):
    supports_single_objective: bool = True

    def generate(self, n_candidates) -> list[dict]:
        points = [{"x": 1.0}] * n_candidates
        return points


my_generator = MyGenerator(vocs=vocs)
X2 = Xopt(evaluator=evaluator, generator=my_generator)

for i in range(4):
    X2.step()

class MyGenerator(Generator): supports_single_objective: bool = True def generate(self, n_candidates) -> list[dict]: points = [{"x": 1.0}] * n_candidates return points my_generator = MyGenerator(vocs=vocs) X2 = Xopt(evaluator=evaluator, generator=my_generator) for i in range(4): X2.step()

In [10]:

X2.data

X2.data

Out[10]:

	x	f	xopt_runtime	xopt_error
0	1.0	0.841471	0.000005	False
1	1.0	0.841471	0.000004	False
2	1.0	0.841471	0.000003	False
3	1.0	0.841471	0.000004	False