xopt 2.2.3__tar.gz → 2.3.0__tar.gz

{xopt-2.2.3/xopt.egg-info → xopt-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xopt
-Version: 2.2.3
+Version: 2.3.0
 Home-page: https://github.com/ChristopherMayes/xopt
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{xopt-2.2.3 → xopt-2.3.0}/tests/generators/bayesian/test_bayesian_generator.py

@@ -87,13 +87,13 @@ class TestBayesianGenerator(TestCase):
         # try with input data that contains Nans due to xopt raising an error
         # currently we drop all rows containing Nans
         test_data = deepcopy(TEST_VOCS_DATA)
-        test_data["y1"].iloc[5] = np.NaN
+        test_data["y1"].iloc[5] = np.nan
         model = gen.train_model(test_data)
         assert len(model.models[0].train_inputs[0]) == len(test_data) - 1
 
         # test with input data that is only Nans
         test_data = deepcopy(TEST_VOCS_DATA)
-        test_data["y1"].iloc[:] = np.NaN
+        test_data["y1"].iloc[:] = np.nan
         with pytest.raises(ValueError):
             gen.train_model(test_data)
 

{xopt-2.2.3 → xopt-2.3.0}/tests/generators/bayesian/test_expected_improvement.py

@@ -7,6 +7,7 @@ from botorch.acquisition import ExpectedImprovement
 from xopt.base import Xopt
 from xopt.evaluator import Evaluator
 from xopt.generators.bayesian.expected_improvement import ExpectedImprovementGenerator
+from xopt.generators.bayesian.objectives import CustomXoptObjective
 from xopt.resources.testing import TEST_VOCS_BASE, TEST_VOCS_DATA, xtest_callable
 from xopt.vocs import ObjectiveEnum, VOCS
 
@@ -61,6 +62,28 @@ class TestExpectedImprovement:
         for _ in range(1):
             xopt.step()
 
+    def test_custom_objectives(self):
+        train_x = torch.tensor([0.01, 0.3, 0.6, 0.99]).double()
+        train_y = torch.sin(2 * torch.pi * train_x)
+        train_c = torch.cos(2 * torch.pi * train_x)
+        train_data = pd.DataFrame(
+            {"x1": train_x.numpy(), "y1": train_y.numpy(), "c1": train_c.numpy()}
+        )
+        vocs = VOCS(**{"variables": {"x1": [0.0, 1.0]}, "observables": ["y1", "c1"]})
+
+        class MyObjective(CustomXoptObjective):
+            def forward(self, samples, X=None):
+                return samples[..., self.vocs.output_names.index("y1")] ** 2
+
+        generator = ExpectedImprovementGenerator(
+            vocs=vocs, custom_objective=MyObjective(vocs)
+        )
+        generator.add_data(train_data)
+        best_f = generator._get_best_f(generator.data, generator.custom_objective)
+        assert float(best_f) == float(torch.max(train_y**2))
+
+        generator.generate(1)
+
     def test_acquisition_accuracy(self):
         train_x = torch.tensor([0.01, 0.3, 0.6, 0.99]).double()
         train_y = torch.sin(2 * torch.pi * train_x)

{xopt-2.2.3 → xopt-2.3.0}/tests/generators/bayesian/test_time_dependent_bo.py

@@ -32,7 +32,7 @@ class TestTimeDependentBO:
         model = gen.train_model(test_data)
 
         # make sure time data is in the last model
-        assert np.alltrue(
+        assert np.all(
             model.models[-1]
             .input_transform.untransform(model.models[-1].train_inputs[0])[:, -1]
             .numpy()

{xopt-2.2.3 → xopt-2.3.0}/tests/test_vocs.py

@@ -1,3 +1,4 @@
+import warnings
 from copy import deepcopy
 
 import numpy as np
@@ -22,6 +23,12 @@ class TestVOCS(object):
         assert vocs.n_outputs == 1
         assert vocs.n_constraints == 0
 
+    def test_variable_validation(self):
+        with pytest.raises(ValidationError):
+            VOCS(
+                variables={"x": [1, 0]},
+            )
+
     def test_empty_objectives(self):
         VOCS(
             variables={"x": [0, 1]},
@@ -125,18 +132,39 @@ class TestVOCS(object):
         assert vocs.n_outputs == 2
         assert vocs.variable_names == ["x1"]
 
-    def test_custom_bounds(self):
+    def test_random_sampling_custom_bounds(self):
         vocs = deepcopy(TEST_VOCS_BASE)
 
         custom_bounds = {"x1": [0.5, 0.75], "x2": [7.5, 15.0]}
 
-        random_input_data = vocs.random_inputs(100, custom_bounds=custom_bounds)
+        with pytest.warns(RuntimeWarning):
+            random_input_data = vocs.random_inputs(100, custom_bounds=custom_bounds)
+
         random_input_data = pd.DataFrame(random_input_data)
         assert all(random_input_data["x1"] < 0.75)
         assert all(random_input_data["x1"] > 0.5)
         assert all(random_input_data["x2"] > 7.5)
         assert all(random_input_data["x2"] < 10.0)
 
+        # test custom bounds within the vocs domain -- no warnings should be raised
+        in_domain_custom_bounds = {"x1": [0.5, 0.75], "x2": [0.5, 0.75]}
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            vocs.random_inputs(100, custom_bounds=in_domain_custom_bounds)
+
+        # test wrong type
+        with pytest.raises(TypeError):
+            vocs.random_inputs(100, custom_bounds=1)
+
+        # test custom bounds entirely outside the vocs domain or specified incorrectly
+        bad_custom_bounds = [
+            {"x1": [10.0, 10.75], "x2": [7.5, 15.0]},
+            {"x1": [0.75, 0.5], "x2": [7.5, 15.0]},
+        ]
+        for ele in bad_custom_bounds:
+            with pytest.raises(ValueError):
+                vocs.random_inputs(100, custom_bounds=ele)
+
     def test_duplicate_outputs(self):
         vocs = deepcopy(TEST_VOCS_BASE)
         assert vocs.output_names == ["y1", "c1"]

{xopt-2.2.3 → xopt-2.3.0}/xopt/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-05-07T12:53:58-0400",
+ "date": "2024-06-18T12:58:34-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "2a01895f05a19d2a26b527c4c47baaf099cd0110",
- "version": "2.2.3"
+ "full-revisionid": "b83cda7ec8623f60a26a37a522e8933ed2895b84",
+ "version": "2.3.0"
 }
 '''  # END VERSION_JSON
 

{xopt-2.2.3 → xopt-2.3.0}/xopt/generator.py

@@ -42,7 +42,7 @@ class Generator(XoptBaseModel, ABC):
 
     @field_validator("vocs", mode="after")
     def validate_vocs(cls, v, info: ValidationInfo):
-        if v.n_objectives != 1 and not info.data["supports_multi_objective"]:
+        if v.n_objectives > 1 and not info.data["supports_multi_objective"]:
             raise ValueError("this generator only supports single objective")
         return v
 

{xopt-2.2.3 → xopt-2.3.0}/xopt/generators/__init__.py

@@ -76,35 +76,31 @@ def get_generator_dynamic(name: str):
                 "WARNING: `scipy` not found, NelderMeadGenerator and LatinHypercubeGenerator are not available"
             )
     elif name in all_generator_names["bo"]:
-        try:
-            from xopt.generators.bayesian.bayesian_exploration import (
-                BayesianExplorationGenerator,
-            )
-            from xopt.generators.bayesian.expected_improvement import (
-                ExpectedImprovementGenerator,
-            )
-            from xopt.generators.bayesian.mobo import MOBOGenerator
-            from xopt.generators.bayesian.multi_fidelity import MultiFidelityGenerator
-            from xopt.generators.bayesian.upper_confidence_bound import (
-                TDUpperConfidenceBoundGenerator,
-                UpperConfidenceBoundGenerator,
-            )
+        from xopt.generators.bayesian.bayesian_exploration import (
+            BayesianExplorationGenerator,
+        )
+        from xopt.generators.bayesian.expected_improvement import (
+            ExpectedImprovementGenerator,
+        )
+        from xopt.generators.bayesian.mobo import MOBOGenerator
+        from xopt.generators.bayesian.multi_fidelity import MultiFidelityGenerator
+        from xopt.generators.bayesian.upper_confidence_bound import (
+            TDUpperConfidenceBoundGenerator,
+            UpperConfidenceBoundGenerator,
+        )
+
+        registered_generators = [
+            UpperConfidenceBoundGenerator,
+            MOBOGenerator,
+            BayesianExplorationGenerator,
+            TDUpperConfidenceBoundGenerator,
+            ExpectedImprovementGenerator,
+            MultiFidelityGenerator,
+        ]
+        for gen in registered_generators:
+            generators[gen.name] = gen
+        return generators[name]
 
-            registered_generators = [
-                UpperConfidenceBoundGenerator,
-                MOBOGenerator,
-                BayesianExplorationGenerator,
-                TDUpperConfidenceBoundGenerator,
-                ExpectedImprovementGenerator,
-                MultiFidelityGenerator,
-            ]
-            for gen in registered_generators:
-                generators[gen.name] = gen
-            return generators[name]
-        except ModuleNotFoundError:
-            warnings.warn(
-                "WARNING: `botorch` not found, Bayesian generators are not available"
-            )
     elif name in all_generator_names["ga"]:
         try:
             from xopt.generators.ga import CNSGAGenerator

{xopt-2.2.3 → xopt-2.3.0}/xopt/generators/bayesian/bax/algorithms.py

@@ -21,6 +21,24 @@ class Algorithm(XoptBaseModel, ABC):
     ) -> Tuple[Tensor, Tensor, Dict]:
         pass
 
+    @abstractmethod
+    def evaluate_virtual_objective(
+        self,
+        model: Model,
+        x: Tensor,
+        bounds: Tensor,
+        n_samples: int,
+        tkwargs: dict = None,
+    ) -> Tensor:
+        """
+        Evaluates virtual objective at inputs given by x.
+        Inputs:
+            x: tensor, shape `num_points x ndim`
+        Returns:
+            objective_values: tensor, shape `n_samples x num_points x 1`
+        """
+        pass
+
 
 class GridScanAlgorithm(Algorithm, ABC):
     name = "grid_scan_algorithm"
@@ -60,21 +78,40 @@ class GridMinimize(GridScanAlgorithm):
         test_points = self.create_mesh(bounds).to(model.models[0].train_targets)
 
         # get samples of the model posterior at mesh points
-        with torch.no_grad():
-            post = model.posterior(test_points)
-            post_samples = post.rsample(torch.Size([self.n_samples]))
+        posterior_samples = self.evaluate_virtual_objective(
+            model, test_points, bounds, self.n_samples
+        )
 
         # get points that minimize each sample (execution paths)
-        y_min, min_idx = torch.min(post_samples, dim=-2)
+        y_min, min_idx = torch.min(posterior_samples, dim=-2)
         min_idx = min_idx.squeeze()
         x_min = test_points[min_idx]
 
         # collect secondary results in a dict
         results_dict = {
             "test_points": test_points,
-            "posterior_samples": post_samples,
+            "posterior_samples": posterior_samples,
             "execution_paths": torch.hstack((x_min, y_min)),
         }
 
         # return execution paths
         return x_min.unsqueeze(-2), y_min.unsqueeze(-2), results_dict
+
+    def evaluate_virtual_objective(
+        self,
+        model: Model,
+        x: Tensor,
+        bounds: Tensor,
+        n_samples: int,
+        tkwargs: dict = None,
+    ) -> Tensor:
+        """Evaluate virtual objective (samples)"""
+
+        tkwargs = tkwargs if tkwargs else {"dtype": torch.double, "device": "cpu"}
+
+        # get samples of the model posterior at inputs given by x
+        with torch.no_grad():
+            post = model.posterior(x)
+            objective_values = post.rsample(torch.Size([n_samples]))
+
+        return objective_values

xopt-2.3.0/xopt/generators/bayesian/bax/visualize.py

@@ -0,0 +1,171 @@
+import torch
+from matplotlib import pyplot as plt
+
+from xopt.generators.bayesian.visualize import (
+    _generate_input_mesh,
+    _get_reference_point,
+)
+
+
+def visualize_virtual_objective(
+    generator,
+    variable_names: list[str] = None,
+    idx: int = -1,
+    reference_point: dict = None,
+    show_samples: bool = True,
+    n_grid: int = 50,
+    n_samples: int = 100,
+    kwargs: dict = None,
+) -> tuple:
+    """
+    Displays BAX's virtual objective predictions computed from samples drawn
+    from the GP model(s) of the observable(s).
+
+    Parameters
+    ----------
+        generator : Generator
+            Bayesian generator object.
+        variable_names : List[str]
+            The variables with respect to which the GP models are displayed (maximum
+            of 2). Defaults to generator.vocs.variable_names.
+        idx : int
+            Index of the last sample to use. This also selects the point of reference in
+            higher dimensions unless an explicit reference_point is given.
+        reference_point : dict
+            Reference point determining the value of variables in
+            generator.vocs.variable_names, but not in variable_names (slice plots in
+            higher dimensions). Defaults to last used sample.
+        show_samples : bool, optional
+            Whether samples are shown.
+        n_grid : int, optional
+            Number of grid points per dimension used to display the model predictions.
+        n_samples : int, optional
+            Number of virtual objective samples to evaluate for each point in the scan.
+        kwargs : dict, optional
+            Additional keyword arguments for evaluating the virtual objective.
+
+        Returns:
+        --------
+            The matplotlib figure and axes objects.
+    """
+    vocs, data = generator.vocs, generator.data
+    reference_point = _get_reference_point(reference_point, vocs, data, idx)
+    # define output and variable names
+    if variable_names is None:
+        variable_names = vocs.variable_names
+    dim_x = len(variable_names)
+    if dim_x not in [1, 2]:
+        raise ValueError(
+            f"Visualization is only supported with respect to 1 or 2 variables, "
+            f"not {dim_x}. Provide a compatible list of variable names to create "
+            f"slice plots at higher dimensions."
+        )
+
+    # validate variable names
+    invalid = [name not in getattr(vocs, "variable_names") for name in variable_names]
+    if any(invalid):
+        invalid_names = [
+            variable_names[i] for i in range(len(variable_names)) if invalid[i]
+        ]
+        raise ValueError(
+            f"Variable names {invalid_names} are not in generator.vocs.variable_names."
+        )
+
+    # validate reference point keys
+    invalid = [
+        name not in getattr(vocs, "variable_names") for name in [*reference_point]
+    ]
+    if any(invalid):
+        invalid_names = [
+            [*reference_point][i] for i in range(len([*reference_point])) if invalid[i]
+        ]
+        raise ValueError(
+            f"reference_point contains keys {invalid_names}, "
+            f"which are not in generator.vocs.variable_names."
+        )
+
+    x = _generate_input_mesh(vocs, variable_names, reference_point, n_grid)
+
+    # verify model exists
+    if generator.model is None:
+        raise ValueError(
+            "The generator.model doesn't exist, try calling generator.train_model()."
+        )
+
+    # subset bax observable models
+    bax_model_ids = [
+        generator.vocs.output_names.index(name)
+        for name in generator.algorithm.observable_names_ordered
+    ]
+    bax_model = generator.model.subset_output(bax_model_ids)
+
+    # get virtual objective (sample) values
+    bounds = generator._get_optimization_bounds()
+    kwargs = kwargs if kwargs else {}
+    objective_values = generator.algorithm.evaluate_virtual_objective(
+        bax_model, x, bounds, tkwargs=generator._tkwargs, n_samples=n_samples, **kwargs
+    )
+
+    # get sample stats
+    objective_med = objective_values.nanmedian(dim=0)[0].flatten()
+    objective_upper = torch.nanquantile(objective_values, q=0.975, dim=0).flatten()
+    objective_lower = torch.nanquantile(objective_values, q=0.025, dim=0).flatten()
+    objective_std = (objective_upper - objective_lower) / 4
+
+    figsize = (4 * dim_x, 3.7)
+    fig, ax = plt.subplots(
+        nrows=1, ncols=dim_x, sharex=True, sharey=True, figsize=figsize
+    )
+
+    if dim_x == 1:
+        # 1d line plot
+        x_axis = x[:, vocs.variable_names.index(variable_names[0])].squeeze().numpy()
+        ax.plot(x_axis, objective_med, color="C0", label="Median")
+        ax.fill_between(
+            x_axis,
+            objective_lower,
+            objective_upper,
+            color="C0",
+            alpha=0.5,
+            label="95% C.I.",
+        )
+        ax.legend()
+        ax.set_ylabel("Virtual Objective")
+        ax.set_xlabel(variable_names[0])
+    else:
+        # 2d heatmaps
+        for j in [0, 1]:
+            ax_j = ax[j]
+            ax_j.locator_params(axis="both", nbins=5)
+            if j == 0:
+                prediction = objective_med
+                title = "Objective Median"
+                cbar_label = "Objective Median"
+            elif j == 1:
+                prediction = objective_std
+                title = "Objective SD"
+                cbar_label = r"$\sigma\,$[Objective]"
+
+            pcm = ax_j.pcolormesh(
+                x[:, vocs.variable_names.index(variable_names[0])]
+                .reshape(n_grid, n_grid)
+                .numpy(),
+                x[:, vocs.variable_names.index(variable_names[1])]
+                .reshape(n_grid, n_grid)
+                .numpy(),
+                prediction.reshape(n_grid, n_grid),
+                rasterized=True,
+            )
+
+            from mpl_toolkits.axes_grid1 import make_axes_locatable  # lazy import
+
+            divider = make_axes_locatable(ax_j)
+            cax = divider.append_axes("right", size="5%", pad=0.1)
+            cbar = plt.colorbar(pcm, cax=cax)
+            ax_j.set_title(title)
+            ax_j.set_xlabel(variable_names[0])
+            ax_j.set_ylabel(variable_names[1])
+            cbar.set_label(cbar_label)
+
+    fig.tight_layout()
+    return fig, ax

{xopt-2.2.3 → xopt-2.3.0}/xopt/generators/bayesian/bayesian_generator.py

@@ -30,6 +30,7 @@ from xopt.generators.bayesian.models.standard import StandardModelConstructor
 from xopt.generators.bayesian.objectives import (
     create_constraint_callables,
     create_mc_objective,
+    CustomXoptObjective,
 )
 from xopt.generators.bayesian.turbo import (
     OptimizeTurboController,
@@ -160,6 +161,10 @@ class BayesianGenerator(Generator, ABC):
         False,
         description="flag to log transform the acquisition function before optimization",
     )
+    custom_objective: Optional[CustomXoptObjective] = Field(
+        None,
+        description="custom objective for optimization, replaces objective specified by VOCS",
+    )
     n_interpolate_points: Optional[PositiveInt] = None
 
     n_candidates: int = 1
@@ -550,17 +555,21 @@ class BayesianGenerator(Generator, ABC):
         pass
 
     def _get_objective(self):
-        """
-        return default objective (scalar objective) determined by vocs
-
-        If objectives are specified the returned function will weight model
-        by +/- 1.0 according to MAXIMIZE/MINIMIZE keys in vocs.
-
-        If no objectives are specified, the returned function will weight observable
-        models by +1.0. This is used in Bayesian exploration.
+        """return default objective (scalar objective) determined by vocs or if
+        defined in custom_objective"""
+        # check to make sure that if we specify a custom objective that no objectives
+        # are specified in vocs
+        if self.custom_objective is not None:
+            if self.vocs.n_objectives:
+                raise RuntimeError(
+                    "cannot specify objectives in VOCS "
+                    "and a custom objective for the generator at the "
+                    "same time"
+                )
 
-        """
-        return create_mc_objective(self.vocs, self._tkwargs)
+            return self.custom_objective
+        else:
+            return create_mc_objective(self.vocs, self._tkwargs)
 
     def _get_constraint_callables(self):
         """return constratint callable determined by vocs"""

{xopt-2.2.3 → xopt-2.3.0}/xopt/generators/bayesian/expected_improvement.py

@@ -9,6 +9,7 @@ from xopt.generators.bayesian.bayesian_generator import (
     BayesianGenerator,
     formatted_base_docstring,
 )
+from xopt.generators.bayesian.objectives import CustomXoptObjective
 from xopt.generators.bayesian.utils import set_botorch_weights
 
 
@@ -22,20 +23,22 @@ class ExpectedImprovementGenerator(BayesianGenerator):
     )
 
     def _get_acquisition(self, model):
-        objective_data = self.vocs.objective_data(self.data, "").dropna()
-        best_f = -torch.tensor(objective_data.min().values, **self._tkwargs)
+        objective = self._get_objective()
+        best_f = self._get_best_f(self.data, objective)
 
-        if self.n_candidates > 1:
+        if self.n_candidates > 1 or isinstance(objective, CustomXoptObjective):
             # MC sampling for generating multiple candidate points
             sampler = self._get_sampler(model)
             acq = qExpectedImprovement(
                 model,
                 best_f=best_f,
                 sampler=sampler,
-                objective=self._get_objective(),
+                objective=objective,
             )
         else:
-            # analytic acquisition function for single candidate generation
+            # analytic acquisition function for single candidate generation with
+            # basic objective
+            # note that the analytic version cannot handle custom objectives
             weights = set_botorch_weights(self.vocs).to(**self._tkwargs)
             posterior_transform = ScalarizedPosteriorTransform(weights)
             acq = ExpectedImprovement(
@@ -43,3 +46,19 @@ class ExpectedImprovementGenerator(BayesianGenerator):
             )
 
         return acq
+
+    def _get_best_f(self, data, objective):
+        """get best function value for EI based on the objective"""
+        if isinstance(objective, CustomXoptObjective):
+            best_f = objective(
+                torch.tensor(
+                    self.vocs.observable_data(data).to_numpy(), **self._tkwargs
+                )
+            ).max()
+        else:
+            # analytic acquisition function for single candidate generation
+            best_f = -torch.tensor(
+                self.vocs.objective_data(data).min().values, **self._tkwargs
+            )
+
+        return best_f

{xopt-2.2.3 → xopt-2.3.0}/xopt/generators/bayesian/objectives.py

@@ -1,9 +1,14 @@
+from abc import ABC, abstractmethod
 from functools import partial
+from typing import Optional
 
 import torch
-from botorch.acquisition import GenericMCObjective
+from botorch.acquisition import GenericMCObjective, MCAcquisitionObjective
 from botorch.acquisition.multi_objective import WeightedMCMultiOutputObjective
 from botorch.sampling import get_sampler
+from torch import Tensor
+
+from xopt import VOCS
 
 from xopt.generators.bayesian.custom_botorch.constrained_acquisition import (
     FeasibilityObjective,
@@ -11,6 +16,40 @@ from xopt.generators.bayesian.custom_botorch.constrained_acquisition import (
 from xopt.generators.bayesian.utils import set_botorch_weights
 
 
+class CustomXoptObjective(MCAcquisitionObjective, ABC):
+    """
+    Custom objective function wrapper for use in Bayesian generators
+
+    """
+
+    def __init__(self, vocs: VOCS, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.vocs = vocs
+
+    @abstractmethod
+    def forward(self, samples: Tensor, X: Optional[Tensor] = None) -> Tensor:
+        r"""Evaluate the objective on the samples.
+
+        Args:
+            samples: A `sample_shape x batch_shape x q x m`-dim Tensors of
+                samples from a model posterior.
+            X: A `batch_shape x q x d`-dim tensor of inputs. Relevant only if
+                the objective depends on the inputs explicitly.
+
+        Returns:
+            Tensor: A `sample_shape x batch_shape x q`-dim Tensor of objective
+            values (assuming maximization).
+
+        This method is usually not called directly, but via the objectives.
+
+        Example:
+            >>> # `__call__` method:
+            >>> samples = sampler(posterior)
+            >>> outcome = mc_obj(samples)
+        """
+        pass
+
+
 def feasibility(X, model, vocs, posterior_transform=None):
     constraints = create_constraint_callables(vocs)
     posterior = model.posterior(X=X, posterior_transform=posterior_transform)

{xopt-2.2.3 → xopt-2.3.0}/xopt/generators/bayesian/upper_confidence_bound.py

@@ -11,6 +11,7 @@ from xopt.generators.bayesian.bayesian_generator import (
     BayesianGenerator,
     formatted_base_docstring,
 )
+from xopt.generators.bayesian.objectives import CustomXoptObjective
 from xopt.generators.bayesian.time_dependent import TimeDependentBayesianGenerator
 from xopt.generators.bayesian.utils import set_botorch_weights
 
@@ -50,7 +51,8 @@ beta : float, default 2.0
             )
 
     def _get_acquisition(self, model):
-        if self.n_candidates > 1:
+        objective = self._get_objective()
+        if self.n_candidates > 1 or isinstance(objective, CustomXoptObjective):
             # MC sampling for generating multiple candidate points
             sampler = self._get_sampler(model)
             acq = qUpperConfidenceBound(

{xopt-2.2.3 → xopt-2.3.0}/xopt/generators/bayesian/visualize.py

@@ -688,8 +688,12 @@ def _plot2d_prediction(
     kwargs = locals()
     axis.locator_params(axis="both", nbins=5)
     pcm = axis.pcolormesh(
-        input_mesh[:, 0].reshape(n_grid, n_grid).numpy(),
-        input_mesh[:, 1].reshape(n_grid, n_grid).numpy(),
+        input_mesh[:, vocs.variable_names.index(variable_names[0])]
+        .reshape(n_grid, n_grid)
+        .numpy(),
+        input_mesh[:, vocs.variable_names.index(variable_names[1])]
+        .reshape(n_grid, n_grid)
+        .numpy(),
         prediction.reshape(n_grid, n_grid),
         rasterized=True,
     )