xopt 2.2.2__tar.gz → 2.3.0__tar.gz

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

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

{xopt-2.2.2 → xopt-2.3.0}/requirements.txt

@@ -2,7 +2,7 @@ deap
 numpy
 pyyaml
 torch
-botorch>=0.9.2
+botorch>=0.9.2,<=0.10.0
 gpytorch
 pandas
 pydantic>=2.3

{xopt-2.2.2 → 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)
 
@@ -239,3 +239,12 @@ class TestBayesianGenerator(TestCase):
             model.models[0].input_transform.bounds,
             torch.tensor(((0, 0), (1, 10))).double(),
         )
+
+        # test bad fixed feature name
+        gen = BayesianGenerator(vocs=TEST_VOCS_BASE)
+        gen.fixed_features = {"bad_name": 3.0}
+        data = deepcopy(TEST_VOCS_DATA)
+        gen.add_data(data)
+
+        with pytest.raises(KeyError):
+            gen.train_model()

{xopt-2.2.2 → 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.2 → 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.2 → xopt-2.3.0}/tests/generators/bayesian/test_utils.py

@@ -10,7 +10,7 @@ class TestUtils:
     def test_mobo_objective(self):
         test_vocs_copy = deepcopy(TEST_VOCS_BASE)
         test_vocs_copy.objectives["y2"] = "MAXIMIZE"
-        obj = create_mobo_objective(test_vocs_copy, tkwargs={})
+        obj = create_mobo_objective(test_vocs_copy)
 
         # test large sample shape
         test_samples = torch.randn(3, 4, 5, 3).double()

{xopt-2.2.2 → xopt-2.3.0}/tests/test_evaluator.py

@@ -3,7 +3,8 @@ from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
 import numpy as np
 import pandas as pd
 
-from xopt import Evaluator
+from xopt import Evaluator, Xopt
+from xopt.generators import RandomGenerator
 from xopt.vocs import VOCS
 
 
@@ -135,3 +136,29 @@ class TestEvaluator:
         executor = ProcessPoolExecutor(max_workers=MAX_WORKERS)
         ev = Evaluator(function=self.f, executor=executor, max_workers=MAX_WORKERS)
         ev.evaluate_data(in10)
+
+    def test_evaluate_return_types(self):
+        def a(input):
+            return {"f": 1.0}
+
+        def b(input):
+            return {"f": [1.0]}
+
+        def c(input):
+            return {"f": np.array(1.0)}
+
+        def d(input):
+            return {"f": [1.0, 1.0]}
+
+        def e(input):
+            return {"f": np.ones(3)}
+
+        vocs = VOCS(variables={"x": [0, 1]}, objectives={"f": "MINIMIZE"})
+
+        for func in [a, b, c, d, e]:
+            evaluator = Evaluator(function=func)
+            generator = RandomGenerator(vocs=vocs)
+
+            X = Xopt(evaluator=evaluator, generator=generator, vocs=vocs)
+
+            X.random_evaluate(5)

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

@@ -1,3 +1,4 @@
+import warnings
 from copy import deepcopy
 
 import numpy as np
@@ -22,11 +23,25 @@ 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]},
         )
 
+    def test_output_names(self):
+        test_vocs = VOCS(
+            variables={"x": [0, 1]},
+            objectives={"y1": "MINIMIZE"},
+            constraints={"c1": ["GREATER_THAN", 0], "c2": ["LESS_THAN", 0]},
+        )
+        assert test_vocs.output_names == ["y1", "c1", "c2"]
+
     def test_constraint_specification(self):
         good_constraint_list = [
             ["LESS_THAN", 0],
@@ -117,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"]
@@ -234,6 +270,14 @@ class TestVOCS(object):
         assert idx == 1
         assert val == 0.1
 
+        # test error handling
+        with pytest.raises(RuntimeError):
+            vocs.select_best(pd.DataFrame())
+
+        vocs.constraints = {"c1": ["GREATER_THAN", 10.5]}
+        with pytest.raises(RuntimeError):
+            vocs.select_best(pd.DataFrame())
+
     @pytest.mark.filterwarnings("ignore: All-NaN axis encountered")
     def test_cumulative_optimum(self):
         vocs = deepcopy(TEST_VOCS_BASE)

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-04-15T14:51:35-0400",
+ "date": "2024-06-18T12:58:34-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "a613b00abdb1ff1809a10b82096947803834cec5",
- "version": "2.2.2"
+ "full-revisionid": "b83cda7ec8623f60a26a37a522e8933ed2895b84",
+ "version": "2.3.0"
 }
 '''  # END VERSION_JSON
 

{xopt-2.2.2 → 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.2 → 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.2 → 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.2 → xopt-2.3.0}/xopt/generators/bayesian/bayesian_exploration.py

@@ -13,7 +13,6 @@ from xopt.generators.bayesian.bayesian_generator import (
     BayesianGenerator,
     formatted_base_docstring,
 )
-from xopt.generators.bayesian.objectives import create_exploration_objective
 
 
 class BayesianExplorationGenerator(BayesianGenerator):
@@ -38,12 +37,6 @@ class BayesianExplorationGenerator(BayesianGenerator):
 
         return qPV
 
-    def _get_objective(self):
-        """return exploration objective, which only captures the output of the first
-        model output"""
-
-        return create_exploration_objective(self.vocs, self._tkwargs)
-
 
 class qPosteriorVariance(MCAcquisitionFunction):
     def __init__(

{xopt-2.2.2 → 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
@@ -375,6 +380,11 @@ class BayesianGenerator(Generator, ABC):
             # get bounds for each fixed_feature (vocs bounds take precedent)
             for key in self.fixed_features:
                 if key not in variable_bounds:
+                    if key not in data:
+                        raise KeyError(
+                            "generator data needs to contain fixed feature "
+                            f"column name `{key}`"
+                        )
                     f_data = data[key]
                     bounds = [f_data.min(), f_data.max()]
                     if bounds[1] - bounds[0] < 1e-8:
@@ -545,11 +555,24 @@ class BayesianGenerator(Generator, ABC):
         pass
 
     def _get_objective(self):
-        """return default objective (scalar objective) determined by vocs"""
-        return create_mc_objective(self.vocs, self._tkwargs)
+        """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 self.custom_objective
+        else:
+            return create_mc_objective(self.vocs, self._tkwargs)
 
     def _get_constraint_callables(self):
-        """return default objective (scalar objective) determined by vocs"""
+        """return constratint callable determined by vocs"""
         constraint_callables = create_constraint_callables(self.vocs)
         if len(constraint_callables) == 0:
             constraint_callables = None
@@ -755,7 +778,7 @@ class MultiObjectiveBayesianGenerator(BayesianGenerator, ABC):
 
         n_objectives = self.vocs.n_objectives
         weights = torch.zeros(n_objectives)
-        weights = set_botorch_weights(weights, self.vocs)
+        weights = set_botorch_weights(self.vocs).to(**self._tkwargs)
         objective_data = objective_data * weights
 
         # compute hypervolume