Xopt

https://github.com/xopt-org/xopt
Admin
Xopt provides flexible optimization of arbitrary problems in Python, enabling users to connect...
Tokens:55,568
Snippets:414
Trust Score:4.1
License:Apache-2.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Cloning Xopt Repository for Development (Shell)

Source: https://github.com/xopt-org/xopt/blob/main/docs/installation.md

This command clones the official Xopt Git repository from GitHub to your local machine. It is the first step for developers who wish to contribute to or modify the Xopt source code.

```shell
git clone https://github.com/xopt-org/xopt.git
```

--------------------------------

### Searching Xopt Versions on Conda-Forge (Shell)

Source: https://github.com/xopt-org/xopt/blob/main/docs/installation.md

This command lists all available versions of the Xopt package on the 'conda-forge' channel. It is useful for checking package availability and specific version numbers before installation.

```shell
conda search xopt --channel conda-forge
```

--------------------------------

### Activating and Installing Xopt in Development Mode (Shell)

Source: https://github.com/xopt-org/xopt/blob/main/docs/installation.md

These commands first activate the 'xopt-dev' Conda environment, then install the Xopt package in editable mode (`-e .`) without its dependencies (as they are already handled by Conda). This allows developers to make changes to the source code and see them reflected without reinstallation.

```shell
conda activate xopt-dev
pip install --no-dependencies -e .
```

--------------------------------

### Installing Xopt Package via Conda (Shell)

Source: https://github.com/xopt-org/xopt/blob/main/docs/installation.md

This command installs the Xopt package from the configured Conda channels. It will resolve and install all necessary dependencies, making Xopt available in your current Conda environment.

```shell
conda install xopt
```

--------------------------------

### Installing Xopt via Conda

Source: https://github.com/xopt-org/xopt/blob/main/README.md

After adding the `conda-forge` channel, this command installs the `xopt` package and its dependencies into your current Conda environment. This is the primary method for setting up Xopt for use.

```shell
conda install xopt
```

--------------------------------

### Importing Xopt Components

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Imports necessary classes from the `xopt` library, including `Evaluator`, `VOCS`, `Xopt`, and utilities for generators. Also imports the `math` module for mathematical operations.

```python
from xopt import Evaluator
from xopt import VOCS
from xopt import Xopt
from xopt.generators import list_available_generators
from xopt.generators import get_generator
import math
```

--------------------------------

### Inspecting Xopt Object State

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Prints the `Xopt` object, which provides a convenient string representation of its current state, including its configured `vocs`, `generator`, `evaluator`, and any accumulated data. This is useful for debugging and understanding the optimization setup.

```python
X
```

--------------------------------

### Defining Xopt Configuration via YAML String

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Defines a multi-line YAML string that specifies the `evaluator` function, the `generator` name ('random'), and the `vocs` (variables, objectives, constraints). This YAML string provides an alternative, declarative way to configure an Xopt optimization problem, mirroring the Python-based setup.

```python
YAML = """
evaluator:
    function: __main__.evaluate_function

generator:
    name: random

vocs:
    variables:
        x1: [0, 3.14159]
        x2: [0, 3.14159]
    objectives: {f: MINIMIZE}
    constraints:
        g: [LESS_THAN, 0]

"""
```

--------------------------------

### Creating Xopt Development Environment (Shell)

Source: https://github.com/xopt-org/xopt/blob/main/docs/installation.md

This command creates a new Conda environment named 'xopt-dev' based on the specifications in the `environment.yml` file. This environment includes all necessary dependencies for Xopt development.

```shell
conda env create -f environment.yml
```

--------------------------------

### Creating Xopt Object from YAML Configuration

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Constructs an `Xopt` object directly from a YAML string using the `Xopt.from_yaml()` class method. This demonstrates an alternative initialization method, allowing for external configuration of the optimization problem.

```python
X_from_yaml = Xopt.from_yaml(YAML)
```

--------------------------------

### Listing Available Xopt Generators

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Calls `list_available_generators()` to display all pre-defined generator types available within the Xopt library. This helps in selecting an appropriate strategy for generating new points during optimization.

```python
list_available_generators()
```

--------------------------------

### Setting Up Parallel Execution Helpers and Environment

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Imports necessary modules for parallel execution (multiprocessing, concurrent.futures, dask.distributed) and data handling (pandas, matplotlib). It also determines the number of available CPU cores and creates a temporary directory for storing optimization output.

```python
# Helpers for this notebook
import multiprocessing
from concurrent.futures import ProcessPoolExecutor
from dask.distributed import Client

import matplotlib.pyplot as plt

import pandas as pd
from concurrent.futures import ThreadPoolExecutor

import os


# Notebook printing output
# from xopt import output_notebook
# output_notebook()

N_CPUS = multiprocessing.cpu_count()
N_CPUS

# directory for data.
os.makedirs("temp", exist_ok=True)
```

--------------------------------

### Combining Components into Xopt Object

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Instantiates the main `Xopt` object by combining the previously defined `vocs` (variables, objectives, constraints, statics), `generator`, and `evaluator` components. This `Xopt` object serves as the central orchestrator for the optimization process.

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

--------------------------------

### Installing Pre-commit Hooks for Xopt

Source: https://github.com/xopt-org/xopt/blob/main/README.md

This shell command installs the pre-commit hooks configured for the Xopt repository. These hooks automate code formatting and style checks (like `ufmt` and `flake8`) before each commit, helping maintain code quality and consistency.

```Shell
pre-commit install
```

--------------------------------

### Installing Xopt on NERSC Cori via Conda (Shell)

Source: https://github.com/xopt-org/xopt/blob/main/docs/installation.md

This command installs the Xopt package specifically for the NERSC Cori supercomputer, ensuring compatibility with its environment. It uses the 'conda-forge' channel to fetch the package.

```shell
conda install -c conda-forge xopt
```

--------------------------------

### Adding Conda-Forge Channel for Xopt Installation (Shell)

Source: https://github.com/xopt-org/xopt/blob/main/docs/installation.md

This command adds the 'conda-forge' channel to your Conda configuration, which is necessary to access the Xopt package and its dependencies. It ensures that Conda can find and install packages from this widely used community channel.

```shell
conda config --add channels conda-forge
```

--------------------------------

### Visualizing Xopt Optimization Data (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

This snippet illustrates different ways to visualize Xopt optimization results. It shows how to plot objective values, variable values, and normalized variable values using `X.data.plot()` and `X.vocs.normalize_inputs()` for monitoring and analysis.

```python
# view objective values
X.data.plot(y=X.vocs.objective_names)

# view variables values
X.data.plot(*X.vocs.variable_names, kind="scatter")

# you can also normalize the variables
X.vocs.normalize_inputs(X.data).plot(*X.vocs.variable_names, kind="scatter")
```

--------------------------------

### Executing Xopt Optimization with MPI

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Executes the Xopt optimization using `mpirun` with 8 MPI workers. It leverages `mpi4py.futures` to distribute the workload and directs verbose logging output to an `xopt.log` file, using the `test.yaml` configuration file.

```shell
%%time
!mpirun -n 8 python -m mpi4py.futures -m xopt.mpi.run -vv --logfile xopt.log test.yaml
```

--------------------------------

### Constructing GP Models with StandardModelConstructor (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/gp_model_creation/model_creation.ipynb

This snippet demonstrates two ways to build a GP model using StandardModelConstructor: first, by passing 'vocs' and 'data', and second, by explicitly providing 'input_names', 'outcome_names', and 'data' for more flexibility. It also shows how to get help on the 'build_model' method.

```python
model_constructor = StandardModelConstructor()

# here we build a model from vocs
model = model_constructor.build_model_from_vocs(vocs=vocs, data=data)

# here we build a model from info (more flexible)
model = model_constructor.build_model(
    input_names=["x0", "x1", "x2"], outcome_names=["y"], data=data
)
help(model_constructor.build_model)
```

--------------------------------

### Saving Xopt Configuration to YAML File

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Instantiates an Xopt object using the previously defined YAML configuration. It then saves this configuration to a file named `test.yaml` using `X.dump()`. Finally, it uses the `cat` command to display the contents of the newly created `test.yaml` file.

```python
X = Xopt(YAML)
X.dump("test.yaml")  # Write this input to file
!cat test.yaml
```

--------------------------------

### Searching Available Xopt Versions on Conda-Forge

Source: https://github.com/xopt-org/xopt/blob/main/README.md

This command lists all available versions of the `xopt` package on the `conda-forge` channel for your platform. It's useful for checking compatibility or installing a specific version of the package.

```shell
conda search xopt --channel conda-forge
```

--------------------------------

### Performing Multiple Optimization Steps in Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Executes a loop to perform 10 additional optimization steps. In each step, the generator proposes new points, the evaluator processes them, and the results are appended to the `X.data` attribute, allowing for continuous optimization and data accumulation.

```python
for _ in range(10):
    X.step()
X.data
```

--------------------------------

### Initializing Dask Client and Executor

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Initializes a Dask `Client`, which manages a distributed computing cluster. It then retrieves the default executor associated with this client, preparing it for use by Xopt to distribute evaluation tasks across the Dask cluster.

```python
client = Client()
executor = client.get_executor()
client
```

--------------------------------

### Running RCDS Maximization with Xopt (YAML Method) - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Executes the RCDS maximization process using the `Xopt` object configured via YAML. It first performs one random evaluation to initialize the data, then calls `run()` to start the optimization loop based on the defined `max_evaluations`.

```python
X.random_evaluate(1)
X.run()
```

--------------------------------

### Running Xopt Optimization from YAML Configuration

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/ga/cnsga_tnk.ipynb

This command initiates the Xopt optimization process, which will run according to the parameters defined in the previously loaded YAML configuration. This includes using the population loaded from 'test.csv' as a starting point.

```python
%%time
X.run()
```

--------------------------------

### Importing Asynchronous Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Imports the `AsynchronousXopt` class from the `xopt` library, aliasing it as `Xopt`. This class is designed to support asynchronous and parallel execution of optimization tasks.

```python
from xopt import AsynchronousXopt as Xopt
```

--------------------------------

### Initializing Random Generator in Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Retrieves the documentation for the 'random' generator using `get_generator('random').__doc__` and then initializes an instance of the random number generator. This generator is configured with the previously defined `vocs` object, enabling it to produce points within the specified variable bounds.

```python
print(get_generator("random").__doc__)

generator = get_generator("random")(vocs=vocs)
```

--------------------------------

### Running RCDS Optimization Step-by-Step with Progress Bar (API Method) - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Executes the RCDS optimization process iteratively for 400 steps using a `for` loop and `tqdm` for a progress bar. In each iteration, `X.step()` is called, which proposes a new point, evaluates it, and updates the internal model.

```python
for i in tqdm(range(400)):
    X.step()
```

--------------------------------

### Adding Conda-Forge Channel for Xopt Installation

Source: https://github.com/xopt-org/xopt/blob/main/README.md

This command adds the `conda-forge` channel to your Conda configuration, which is a prerequisite for installing the `xopt` package. It ensures that Conda can find and download `xopt` and its dependencies from the community-maintained `conda-forge` repository.

```shell
conda config --add channels conda-forge
```

--------------------------------

### Selecting and Evaluating Best Point in Xopt (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

This snippet demonstrates how to programmatically identify the best objective value and its corresponding parameters from the `X.data` attribute using `X.vocs.select_best()`. After selection, it prints the best value and parameters, then evaluates the best point using `X.evaluate_data()`.

```python
idx, val, params = X.vocs.select_best(X.data)
print(f"best objective value {val}")
print(f"best point {params}")

X.evaluate_data(params)
```

--------------------------------

### Importing OS Module for libomp.dylib Error Fix - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Imports the `os` module, primarily to address a common `libomp.dylib` initialization error by allowing environment variable manipulation. This snippet is a prerequisite for certain library configurations.

```python
# If you encounter the "Initializing libomp.dylib, but found libomp.dylib already initialized." error
# Please run this cell
import os
```

--------------------------------

### Evaluating Initial Data Points in Xopt (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/bayes_exp/bayesian_exploration.ipynb

This code evaluates two initial data points for the exploration. These points are chosen to satisfy the problem's constraints, providing a starting dataset for the Bayesian optimization process.

```python
X.evaluate_data({"x1": [1.0, 0.75], "x2": [0.7, 0.95]})
```

--------------------------------

### Initializing and Configuring NSGA2Generator

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/ga/nsga2.ipynb

This code demonstrates two ways to initialize the `NSGA2Generator`. The first shows default initialization with only `vocs` (Variables, Objectives, Constraints, and Statistics) provided. The second example illustrates how to customize hyperparameters such as `population_size`, and specify custom `mutation_operator` (PolynomialMutation) and `crossover_operator` (SimulatedBinaryCrossover) with their respective parameters, along with enabling `deduplicate_output` for unique candidates.

```python
# Create the NSGA2 generator with default settings
generator = NSGA2Generator(
    vocs=prob_vocs,  # Must provide the problem's details
)

# Let's demonstrate controlling the generator's hyperparameters and settings
generator = NSGA2Generator(
    vocs=prob_vocs,  # Must provide the problem's details
    population_size=50,  # How many individuals in a population
    mutation_operator=PolynomialMutation(
        pm=1 / 30, eta_m=20
    ),  # Can manually specify mutation operator and hyperparameters
    crossover_operator=SimulatedBinaryCrossover(
        delta_1=0.5, delta_2=0.5, eta_c=20
    ),  # Similarly can specify crossover manually
    deduplicate_output=True,  # Performs deduplication of candidate individuals. Ensure unique outputs from generator.
)
```

--------------------------------

### Importing Libraries for Latin Hypercube Sampling in Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/scipy/latin_hypercube.ipynb

This snippet imports necessary modules from `xopt`, `scipy`, `matplotlib`, and `numpy` to set up an optimization problem using the Latin Hypercube Generator and visualize results.

```python
from copy import deepcopy
from xopt import Xopt, Evaluator
from xopt.generators.scipy.latin_hypercube import LatinHypercubeGenerator
from xopt.resources.test_functions.tnk import evaluate_TNK, tnk_vocs
import matplotlib.pyplot as plt
import numpy as np
```

--------------------------------

### Performing a Single Optimization Step in Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Executes one iteration of the optimization process by calling `X.step()`. During this step, the generator proposes new points, the evaluator evaluates them, and the results are automatically added to the `X.data` attribute, advancing the optimization.

```python
X.step()
```

--------------------------------

### Initializing Xopt with Latin Hypercube Generator

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/scipy/latin_hypercube.ipynb

This code initializes the Xopt object with a Latin Hypercube Generator and an Evaluator. It configures the `vocs` (variables, objectives, constraints, and observables) for the TNK test function, setting up the problem for sampling.

```python
# Create the test problem
vocs = deepcopy(tnk_vocs)
vocs.objectives = {}
vocs.observables = ["y1"]
evaluator = Evaluator(function=evaluate_TNK)

# Create the generator and xopt object. Note: the samples are generated in
# batches and the batch size determines the arrangement of points to cover
# the bounded region of the variables.
generator = LatinHypercubeGenerator(vocs=vocs, batch_size=1024)
X = Xopt(generator=generator, evaluator=evaluator, vocs=vocs)
X
```

--------------------------------

### Initializing Xopt with VOCS, Evaluator, and Generator (API Method) - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Initializes the main `Xopt` object by programmatically passing the previously defined `vocs`, `evaluator`, and `generator` objects. This sets up the complete optimization problem ready for execution using the API method.

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

--------------------------------

### Generating and Inspecting Initial Random Points with Xopt in Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/constrained_bo_tutorial.ipynb

This code demonstrates how to generate and evaluate initial random data points using `X.random_evaluate(n_samples)`. It then prints the collected data stored in `X.data`, which serves as the starting dataset for Bayesian optimization.

```python
# call X.random_evaluate(n_samples) to generate + evaluate initial points
X.random_evaluate(n_samples=2)

# inspect the gathered data
X.data
```

--------------------------------

### Randomly Evaluating Points in Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Instructs the `Xopt` object to generate and evaluate 5 random points. The results of these evaluations are automatically stored in the `X.data` attribute, initializing the optimization's dataset. This is often used for initial exploration or seeding the optimization process.

```python
X.random_evaluate(5)
```

--------------------------------

### Defining VOCS for Xopt Optimization

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Initializes a `VOCS` (Variables, Objectives, Constraints, Statics) object. This defines the input variable ranges (`x1`, `x2`), specifies the objective 'f' for minimization, and sets up the constraint 'g' to be less than or equal to 0. The keys used here must correspond to those in the `evaluate_function`.

```python
vocs = VOCS(
    variables={"x1": [0, math.pi], "x2": [0, math.pi]},
    objectives={"f": "MINIMIZE"},
    constraints={"g": ["LESS_THAN", 0]},
)
```

--------------------------------

### Enabling IPython Autoreload Extension - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Loads and configures the `autoreload` IPython extension, allowing modules to be reloaded automatically before code execution. This is useful during development to avoid manual restarts after code changes.

```python
# Reload packages automatically
%load_ext autoreload
%autoreload 2
```

--------------------------------

### Generating and Evaluating Initial Random Points with Xopt (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/bo_tutorial.ipynb

This snippet uses `X.random_evaluate(2)` to generate and evaluate 2 initial random data points for the optimization process. These points serve as the starting dataset for the Bayesian optimization. The collected data can then be inspected via `X.data`.

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

# inspect the gathered data
X.data
```

--------------------------------

### Viewing MPI Xopt Log File

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Displays the last few lines of the `xopt.log` file, which contains the logging output generated by the MPI-based Xopt optimization run. This helps in monitoring the progress and debugging the distributed execution.

```shell
!tail xopt.log
```

--------------------------------

### Defining Optimization Problem and Initial Data for TuRBO in Xopt (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/trust_region_bo/turbo_basics.ipynb

This snippet defines a 2D sphere objective function compatible with Xopt, creates a `VOCS` (Variables, Objectives, Constraints, and Statistics) object to specify the optimization problem, and generates 10 random initial data points. It prepares the necessary components for initializing a TuRBO controller by providing an objective function and a starting dataset.

```python
import numpy as np
from xopt import VOCS
import pandas as pd


# create evaluation function
def sphere_function(inputs):
    """
    2D Sphere objective function.
    Compatible with Xopt.
    """
    x, y = inputs["x"], inputs["y"]
    return {"f": np.sum(np.square(np.stack([x, y], axis=-1)), axis=-1)}


# create a VOCS object
vocs = VOCS(
    variables={"x": {-5, 5}, "y": {-5, 5}},
    objectives={"f": "MINIMIZE"},
)

# random sample 10 points
x0 = vocs.random_inputs(10)

# evaluate the function at the random points
f = []
for i in range(len(x0)):
    f += [sphere_function(x0[i]) | x0[i]]

# print the results
data = pd.DataFrame(f)
data
```

--------------------------------

### Importing Core Xopt Libraries and Suppressing Warnings - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Imports essential libraries for Xopt, including NumPy, RCDSGenerator, VOCS, Evaluator, and Xopt itself. It also imports `tqdm` for progress bars and `warnings` to suppress non-critical messages, setting an environment variable to handle OpenMP library duplicates.

```python
import numpy as np
from xopt.generators.sequential import RCDSGenerator
from xopt.vocs import VOCS
from xopt.evaluator import Evaluator
from xopt import Xopt
from tqdm.auto import tqdm
import warnings


warnings.filterwarnings("ignore")

os.environ["KMP_DUPLICATE_LIB_OK"] = "True"
```

--------------------------------

### Running Xopt Optimization Sequentially

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Executes the Xopt optimization process using `X.run()` without an explicit executor, which typically defaults to sequential execution. The `%%time` magic command measures the total time taken for the optimization to complete, serving as a baseline for parallel comparisons.

```python
%%time
X.run()
```

--------------------------------

### Seeding Xopt Optimization with Initial Data Points

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/multi_fidelity_simple.ipynb

This code evaluates a set of initial data points at mixed fidelities to seed the Bayesian optimization process. These initial observations provide the `MultiFidelityGenerator` with preliminary data to build its surrogate model before starting the iterative optimization loop.

```python
X.evaluate_data(
    pd.DataFrame({"x": [math.pi / 4, math.pi / 2.0, math.pi], "s": [0.0, 0.25, 0.0]})
)
```

--------------------------------

### Examining Results After Single Xopt Step

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Displays the `data` attribute of the `Xopt` object after a single optimization step. This allows for immediate inspection of the newly generated and evaluated point, along with all previously collected data, to monitor optimization progress.

```python
X.data
```

--------------------------------

### Running Xopt Optimization with ProcessPoolExecutor

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Re-initializes the Xopt object and configures its evaluator to use a `ProcessPoolExecutor`. This sets up parallel execution across multiple CPU processes, with the number of workers determined by `N_CPUS`. The optimization is then run, and the length of the collected data is displayed.

```python
%%time
X = Xopt(YAML)

with ProcessPoolExecutor(max_workers=N_CPUS) as executor:
    X.evaluator.executor = executor
    X.evaluator.max_workers = N_CPUS
    X.run()
len(X.data)
```

--------------------------------

### Generating Initial Random Samples (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/fixed_features.ipynb

This code generates 10 initial random samples in the 2D input space using the configured `Xopt` object. These samples serve as a starting point for the Bayesian optimization process.

```python
X.random_evaluate(10)
```

--------------------------------

### Evaluating Initial Data Points in Xopt (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/bayes_exp/bayesian_exploration_w_interpolation.ipynb

This code evaluates two initial data points for the `Xopt` object. These points are chosen to satisfy known constraints, providing a starting dataset for the Bayesian exploration process. The `evaluate_data` method adds the specified input values to the internal data store and runs the evaluation function.

```python
X.evaluate_data({"x1": [1.0, 0.75], "x2": [0.7, 0.95]})
```

--------------------------------

### Swapping PrgEnv-gnu Module on NERSC Cori (Shell)

Source: https://github.com/xopt-org/xopt/blob/main/docs/installation.md

This command is a workaround for a bug in Jupyterhub terminals on NERSC Cori, ensuring the C compiler is properly activated. It swaps the programming environment module to resolve compilation issues.

```shell
module swap PrgEnv-gnu PrgEnv-gnu
```

--------------------------------

### Running Xopt Optimization Iterations (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_generator.ipynb

This snippet executes the optimization process using the initialized `Xopt` object. It starts by performing 2 random evaluations to seed the optimization, then runs 4 iterative steps. Each step involves the generator proposing new points, the evaluator computing results, and the data being updated.

```python
X.random_evaluate(2)
for i in range(4):
    X.step()
```

--------------------------------

### Initializing Xopt with Evaluator, Generator, and VOCS (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_generator.ipynb

This snippet initializes an `Evaluator` with the `test_function`, and a `generator` using the previously defined `generator_type` and `vocs`. Finally, it creates an `Xopt` object, integrating the generator, evaluator, and VOCS to set up the complete optimization problem instance.

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

--------------------------------

### Running RCDS Optimization with Xopt (YAML Method) - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Executes the RCDS optimization process using the `Xopt` object configured via YAML. It first performs one random evaluation to initialize the data, then calls `run()` to start the optimization loop based on the defined `max_evaluations`.

```python
X.random_evaluate(1)
X.run()
```

--------------------------------

### Evaluating Initial Data Points in Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/bayes_exp/bayesian_exploration_with_nans.ipynb

This snippet uses the `evaluate_data` method of the `Xopt` instance to add initial data points to the exploration. It provides two known points (`x1`, `x2`) that are expected to satisfy the constraints, serving as a starting set for the Bayesian exploration process.

```python
X.evaluate_data(pd.DataFrame({"x1": [1.0, 0.75], "x2": [0.7, 0.95]}))
```

--------------------------------

### Importing Xopt and Utility Modules for NSGA2

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/ga/nsga2.ipynb

This snippet imports necessary modules for setting up and running the NSGA2 multi-objective optimization algorithm using Xopt. It includes standard libraries like `json`, `logging`, `matplotlib`, `os`, `pandas`, `shutil`, `tempfile`, and specific components from `xopt` such as `NSGA2Generator`, `PolynomialMutation`, `SimulatedBinaryCrossover`, `construct_zdt` for test functions, and core `Xopt`, `Evaluator`, `VOCS` classes.

```python
import json
import logging
import matplotlib.pyplot as plt
import os
import pandas as pd
import shutil
import tempfile

from xopt.generators.ga.nsga2 import (
    NSGA2Generator,
    PolynomialMutation,
    SimulatedBinaryCrossover,
)
from xopt.resources.test_functions.zdt import construct_zdt
from xopt import Xopt, Evaluator, VOCS
```

--------------------------------

### Running Xopt Optimization with Dask Executor

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Re-initializes the Xopt object and configures its evaluator to use the Dask executor obtained from the `Client`. It sets the maximum number of workers to `N_CPUS` for Dask-based parallel execution. The optimization is then run, and the total number of data points collected is displayed.

```python
%%time
X = Xopt(YAML)
X.evaluator.executor = executor
X.evaluator.max_workers = N_CPUS
X.run()
len(X.data)
```

--------------------------------

### Configuring Xopt for RCDS Maximization via YAML - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Defines an Xopt configuration in YAML format for RCDS optimization, setting `max_evaluations` to 400, specifying `rcds` as the generator with noise and step parameters, linking to the `f_test` function, and defining `p0`, `p1` variables with `f` as a maximization objective. It then initializes an `Xopt` object from this YAML string.

```python
YAML = """
max_evaluations: 400
generator:
    name: rcds
    x0: null
    init_mat: null
    noise: 1e-8
    step: 0.01
evaluator:
    function: __main__.f_test
vocs:
    variables:
        p0: [1, 3]
        p1: [-4, 2]
    objectives:
        f: MAXIMIZE
"""

X = Xopt.from_yaml(YAML)
X
```

--------------------------------

### Optional Dask Distributed Executor Configuration

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_evaluator.ipynb

This commented-out snippet provides an example of how to configure a Dask distributed client as an executor. Dask can be used for more advanced distributed computing setups, allowing evaluations to be scaled across a cluster. It demonstrates importing `Client` and setting up a Dask executor, with logging silenced for cleaner output.

```python
# Dask (Optional)
# from dask.distributed import Client
# import logging
# client = Client( silence_logs=logging.ERROR)
# executor = client.get_executor()
# client
```

--------------------------------

### Initializing and Training ExpectedImprovementGenerator in Xopt (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/trust_region_bo/turbo_basics.ipynb

This code initializes an `ExpectedImprovementGenerator` using the previously defined `VOCS` object, configures it to use a low-noise prior for the Gaussian Process. It then adds the initial dataset to the generator and trains the underlying surrogate model, which is crucial for guiding the Bayesian optimization process.

```python
from xopt.generators.bayesian import ExpectedImprovementGenerator

generator = ExpectedImprovementGenerator(vocs=vocs)  # create the generator
generator.gp_constructor.use_low_noise_prior = True
generator.add_data(data)  # add the data to the generator
generator.train_model()  # train the model
```

--------------------------------

### Evaluating Specific Data Points in Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_basic.ipynb

Evaluates a set of explicitly defined data points. The `points` dictionary contains lists of values for 'x1' and 'x2'. The results of these evaluations are added to the `Xopt` object's internal data store, `X.data`, alongside any previously generated data.

```python
points = {"x1": [1.0, 0.5, 2.25], "x2": [0, 1.75, 0.6]}
X.evaluate_data(points)
```

--------------------------------

### Configuring Xopt for RCDS Minimization via YAML - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Defines an Xopt configuration in YAML format for RCDS optimization, setting `max_evaluations` to 100, specifying `rcds` as the generator with noise and step parameters, linking to the `f_test` function, and defining `p0`, `p1` variables with `f` as a minimization objective. It then initializes an `Xopt` object from this YAML string.

```python
YAML = """
max_evaluations: 100
generator:
    name: rcds
    x0: null
    init_mat: null
    noise: 0.00001
    step: 0.01
evaluator:
    function: __main__.f_test
vocs:
    variables:
        p0: [0, 1]
        p1: [0, 1]
    objectives:
        f: MINIMIZE
"""

X = Xopt.from_yaml(YAML)
X
```

--------------------------------

### Performing Latin Hypercube Sampling with Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/scipy/latin_hypercube.ipynb

This snippet executes 1024 sampling steps using the configured Xopt object, generating data points based on the Latin Hypercube method. It then displays the head of the collected data, showing the sampled `x1`, `x2`, and `y1` values.

```python
# Sample the function a number of times using latin hypercube points
for _ in range(1024):
    X.step()
X.data.head()
```

--------------------------------

### Installing Xopt in Editable Mode

Source: https://github.com/xopt-org/xopt/blob/main/README.md

These shell commands activate the `xopt-dev` Conda environment and then install Xopt in editable mode. The `-e .` flag allows for direct modifications to the source code without needing to reinstall, while `--no-dependencies` prevents re-downloading already managed Conda dependencies.

```Shell
conda activate xopt-dev
pip install --no-dependencies -e .
```

--------------------------------

### Importing Libraries for Extremum Seeking Optimization (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/extremum_seeking.ipynb

Imports necessary libraries for numerical operations (numpy), Xopt components (ExtremumSeekingGenerator, VOCS, Evaluator, Xopt), progress tracking (tqdm), system interaction (os), data handling (pandas), and plotting (matplotlib). Warnings are also ignored for cleaner output.

```python
import numpy as np
from xopt.generators.sequential.extremumseeking import ExtremumSeekingGenerator
from xopt.vocs import VOCS
from xopt.evaluator import Evaluator
from xopt import Xopt
from tqdm.auto import tqdm
import os

import pandas as pd

import matplotlib.pyplot as plt

import warnings

warnings.filterwarnings("ignore")
```

--------------------------------

### Defining Xopt Optimization Configuration with YAML

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Defines a multi-line YAML string that specifies the configuration for an Xopt optimization run. This includes the maximum number of evaluations, generator settings (CNSGA), evaluator function (TNK test function with sleep parameters), and VOCS (Variables, Objectives, Constraints, Constants). The YAML is then used to instantiate an `Xopt` object.

```python
# Make a proper input file.
YAML = """

max_evaluations: 1000

generator:
  name: cnsga
  output_path: temp
  population_size:  64
  
evaluator:
  function: xopt.resources.test_functions.tnk.evaluate_TNK
  function_kwargs:
    sleep: 0
    random_sleep: 0.1
  
vocs:
  variables:
    x1: [0, 3.14159]
    x2: [0, 3.14159]
  objectives: {y1: MINIMIZE, y2: MINIMIZE}
  constraints:
    c1: [GREATER_THAN, 0]
    c2: [LESS_THAN, 0.5]
  constants: {a: dummy_constant}

"""
X = Xopt(YAML)
X
```

--------------------------------

### Cleaning Up Temporary Files and Directories

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Removes temporary files and directories created during the Xopt runs, including `dask-worker-space`, `temp`, `xopt.log*`, and `test.yaml`. This command ensures a clean environment after the demonstrations.

```shell
# Cleanup
#!rm -r dask-worker-space
!rm -r temp
!rm xopt.log*
!rm test.yaml
```

--------------------------------

### Cleaning Up Generated Files

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/ga/cnsga_tnk.ipynb

This snippet executes shell commands to remove all temporary files generated during the Xopt runs. It deletes all files starting with 'cnsga_population', 'cnsga_offspring', and the 'test.csv' file.

```python
!rm cnsga_population*
!rm cnsga_offspring*
!rm test.csv
```

--------------------------------

### Initializing Xopt and Collecting Data with RandomGenerator (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/gp_model_creation/model_creation.ipynb

This snippet initializes an Xopt object with a RandomGenerator and an Evaluator for the 3D Rosenbrock function. It then collects 15 data points using random sampling, setting up the environment for GP model construction. It also includes environment variable checks for smoke tests and warning suppression.

```python
# set values if testing
import os

from xopt import Xopt, Evaluator
from xopt.generators import RandomGenerator
from xopt.resources.test_functions.rosenbrock import (
    evaluate_rosenbrock,
    make_rosenbrock_vocs,
)

from xopt.generators.bayesian.visualize import visualize_model
from xopt.generators.bayesian.models.standard import StandardModelConstructor

# Ignore all warnings
import warnings

warnings.filterwarnings("ignore")


SMOKE_TEST = os.environ.get("SMOKE_TEST")
NUM_MC_SAMPLES = 1 if SMOKE_TEST else 128
NUM_RESTARTS = 1 if SMOKE_TEST else 20

# make rosenbrock function vocs in 3D
vocs = make_rosenbrock_vocs(3)

# collect some data using random sampling
evaluator = Evaluator(function=evaluate_rosenbrock)
generator = RandomGenerator(vocs=vocs)
X = Xopt(generator=generator, evaluator=evaluator, vocs=vocs)
X.random_evaluate(15)
```

--------------------------------

### Plotting Optimization Results - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Generates a plot of the optimization results, specifically plotting the objective function `f` over the course of the optimization. This visualization helps in analyzing the convergence and performance of the RCDS algorithm.

```python
X.data.plot(y="f")
```

--------------------------------

### Displaying RCDS Generator Model Dump - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Calls the `model_dump()` method on the `generator` object to display its internal configuration and parameters. This is useful for debugging and verifying the settings of the RCDS generator before running the optimization.

```python
generator.model_dump()
```

--------------------------------

### Setting Up Output Directory for Xopt in Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/ga/nsga2.ipynb

This snippet creates a temporary directory using `tempfile.mkdtemp()` to store the optimizer's output files. It then prints the path of this directory, which will be used for subsequent data writing operations. This ensures a clean workspace for each optimization run.

```python
output_dir = tempfile.mkdtemp()
print(f'Will write data to "{output_dir}"')
```

--------------------------------

### Displaying VOCS Object Configuration - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Displays the current configuration of the `vocs` object. This is typically used in interactive environments like Jupyter notebooks to inspect the defined variables, objectives, and other VOCS parameters.

```python
vocs
```

--------------------------------

### Importing Libraries and Setting Random Seeds for Reproducibility (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/bax_tutorial.ipynb

This snippet imports necessary libraries for Xopt, Bayesian Optimization, data manipulation (numpy, random), and plotting. It also sets random seeds for `torch`, `numpy`, and `random` to ensure reproducibility of results across different runs, and handles environment variables for `KMP_DUPLICATE_LIB_OK`.

```python
import torch

from xopt import Xopt
from xopt.vocs import VOCS
from xopt.generators.bayesian.bax_generator import BaxGenerator
from xopt.generators.bayesian.bax.algorithms import GridOptimize
from xopt.evaluator import Evaluator
from xopt.generators.bayesian.bax.visualize import visualize_virtual_objective

import numpy as np
import random

import os
import math
import matplotlib.pyplot as plt

# Ignore all warnings
import warnings

warnings.filterwarnings("ignore")


os.environ["KMP_DUPLICATE_LIB_OK"] = "True"

# random seeds for reproducibility
rand_seed = 2

torch.manual_seed(rand_seed)
np.random.seed(rand_seed)
random.seed(rand_seed)
```

--------------------------------

### Loading Xopt from a Checkpoint File

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/checkpointing_and_restarts.ipynb

This Python code demonstrates how to create a new Xopt object by loading its state directly from a previously saved `dump.yml` file. This allows for resuming an optimization run from the exact point it was saved, preserving all data, configuration, and the state of the optimization process.

```python
X2 = Xopt.from_file("dump.yml")
X2
```

--------------------------------

### Initializing Evaluator with Test Function (API Method) - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Initializes an `Evaluator` object, which is responsible for executing the objective function. It is configured to use the previously defined `f_test` function as the target for evaluation during the optimization process.

```python
evaluator = Evaluator(function=f_test)
```

--------------------------------

### Example Output of TNK Test Function

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/ga/cnsga_tnk.ipynb

This snippet demonstrates the output structure of the `evaluate_TNK` function when called with a single input. It highlights that the function returns a dictionary which includes an additional array named `some_array`.

```python
# Notice that this returns `some_array`
evaluate_TNK({"x1": 1, "x2": 1})
```

--------------------------------

### Generating and Evaluating Initial Random Points in Xopt (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/bax_tutorial.ipynb

This snippet initiates the optimization process by instructing Xopt to generate and evaluate 3 random initial data points using `X.random_evaluate(3)`. It then displays the gathered data using `X.data`, which holds the observed inputs and outputs.

```python
# evaluate initial points
X.random_evaluate(3)

# inspect the gathered data
X.data
```

--------------------------------

### Accessing Raw Optimization Data from Xopt

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_parallel.ipynb

Accesses and displays the raw optimization data stored within the `Xopt` object. This data is typically a Pandas DataFrame containing the results of all evaluations performed during the optimization run.

```python
X.data
```

--------------------------------

### Setting Up Environment and Imports for Time-Dependent Optimization in Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/time_dependent_bo.ipynb

This snippet initializes the environment by importing necessary libraries such as `torch`, `matplotlib`, `tqdm`, and Xopt components. It also sets up global flags like `SMOKE_TEST` and parameters for Monte Carlo samples, restarts, and steps, which are used to control the optimization process and reduce computation for testing.

```python
# set values if testing
import os
import time
import warnings
import torch
from matplotlib import pyplot as plt
from tqdm import trange
from xopt.generators.bayesian import TDUpperConfidenceBoundGenerator
from xopt.vocs import VOCS
from xopt.evaluator import Evaluator
from xopt import Xopt

SMOKE_TEST = os.environ.get("SMOKE_TEST")
N_MC_SAMPLES = 1 if SMOKE_TEST else 128
NUM_RESTARTS = 1 if SMOKE_TEST else 20
N_STEPS = 1 if SMOKE_TEST else 250
warnings.filterwarnings("ignore")
```

--------------------------------

### Initializing Xopt Components for TNK Problem (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/multi_objective_bayes_opt/multi_fidelity_mobo.ipynb

This snippet imports necessary libraries for Xopt, defines environment variables for testing, and initializes an `Evaluator` object for the TNK function. It also prints the VOCS (Variables, Objectives, Constraints, and Statistics) dictionary for the TNK problem, which outlines the problem's structure.

```python
# set values if testing
import os
from copy import deepcopy

import pandas as pd
import numpy as np
import torch

from xopt import Xopt, Evaluator
from xopt.generators.bayesian import MultiFidelityGenerator
from xopt.resources.test_functions.tnk import evaluate_TNK, tnk_vocs

import matplotlib.pyplot as plt

# Ignore all warnings
import warnings

warnings.filterwarnings("ignore")

SMOKE_TEST = os.environ.get("SMOKE_TEST")
N_MC_SAMPLES = 1 if SMOKE_TEST else 128
NUM_RESTARTS = 1 if SMOKE_TEST else 20
BUDGET = 0.02 if SMOKE_TEST else 10

evaluator = Evaluator(function=evaluate_TNK)
print(tnk_vocs.dict())
```

--------------------------------

### Creating Conda Development Environment for Xopt

Source: https://github.com/xopt-org/xopt/blob/main/README.md

This shell command creates a new Conda environment named `xopt-dev` based on the `environment.yml` file. This environment will contain all the necessary dependencies for Xopt development, ensuring a consistent setup.

```Shell
conda env create -f environment.yml
```

--------------------------------

### Initializing RCDS Generator (API Method) - Python

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/rcds.ipynb

Initializes an `RCDSGenerator` object, which implements the RCDS optimization algorithm. It is configured with the previously defined `vocs` object, providing the generator with information about the problem's variables and objectives.

```python
generator = RCDSGenerator(vocs=vocs)
```

--------------------------------

### Continuing Xopt Optimization from Checkpoint

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/checkpointing_and_restarts.ipynb

This snippet continues the optimization process using the Xopt object (`X2`) that was loaded from the checkpoint file. It performs an additional 10 steps, demonstrating that the optimization can seamlessly resume from its last saved state, including its internal data and generator state, without losing progress.

```python
for _ in range(10):
    X2.step()

X2.data
```

--------------------------------

### Displaying VOCS Object Configuration (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/sequential/extremum_seeking.ipynb

Outputs the vocs object, which encapsulates the problem's variables and objectives. This allows for inspection of the defined search space and optimization goals before proceeding with the evaluator and generator setup.

```python
vocs
```

--------------------------------

### Re-initializing VOCS for Error Handling Context (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/xopt_vocs.ipynb

Re-initializes the `VOCS` object from the same YAML string as before. This snippet serves as a setup for demonstrating error handling or specific data manipulations that might follow.

```python
Y = """
variables:
  a: [0, 1e3] # Note that 1e3 usually parses as a str with YAML. 
  b: [-1, 1]
objectives:
  c: maximize
  d: minimize 
constraints:
  e: ['Less_than', 2]
  f: ['greater_than', 0]
constants:
  g: 1234

"""

vocs = VOCS.from_yaml(Y)
```

--------------------------------

### Initializing Xopt Components for Bayesian Optimization (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/noisy_bo_tutorial.ipynb

This snippet initializes the core components of Xopt: an `Evaluator` to run the `sin_function`, a `StandardModelConstructor` for the Gaussian Process model, and an `UpperConfidenceBoundGenerator` which uses the UCB acquisition function. Finally, it instantiates the main `Xopt` object, linking the evaluator, generator, and VOCS definition.

```python
evaluator = Evaluator(function=sin_function)
gp_constructor = StandardModelConstructor(use_low_noise_prior=False)
generator = UpperConfidenceBoundGenerator(vocs=vocs, gp_constructor=gp_constructor)
X = Xopt(evaluator=evaluator, generator=generator, vocs=vocs)
```

--------------------------------

### Running Xopt Optimization with Checkpointing

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/basic/checkpointing_and_restarts.ipynb

This Python snippet initializes an Xopt object using the previously defined YAML configuration. It then executes 10 optimization steps, demonstrating how Xopt automatically saves its state and data to the specified `dump_file` after each step, enabling continuous checkpointing for robust optimization runs.

```python
# create Xopt object.
X = Xopt.from_yaml(YAML)

# take 10 steps and view data
for _ in range(10):
    X.step()

X.data
```

--------------------------------

### Inspecting and Customizing Xopt Generator Options (Python)

Source: https://github.com/xopt-org/xopt/blob/main/docs/examples/single_objective_bayes_opt/heteroskedastic_noise_tutorial.ipynb

This snippet illustrates how to view the current configuration options of the Xopt generator. Calling `X.generator.dict()` returns a dictionary of the generator's settings, which can be modified to customize its optimization behavior.

```python
X.generator.dict()
```
Tokens:
Raw