xopt 2.2.1__tar.gz → 2.2.3__tar.gz

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

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

{xopt-2.2.1 → xopt-2.2.3}/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.1 → xopt-2.2.3}/tests/generators/bayesian/test_bax.py

@@ -2,11 +2,15 @@ import pickle
 from copy import deepcopy
 from unittest.mock import patch
 
+import pytest
+
 import torch
 from botorch.models import SingleTaskGP
 from botorch.models.model import ModelList
 from botorch.models.transforms import Normalize, Standardize
 
+from pydantic import ValidationError
+
 from xopt.base import Xopt
 from xopt.evaluator import Evaluator
 from xopt.generators.bayesian.bax.algorithms import (
@@ -21,9 +25,12 @@ from xopt.resources.testing import TEST_VOCS_BASE, TEST_VOCS_DATA, xtest_callabl
 class TestBaxGenerator:
     @patch.multiple(Algorithm, __abstractmethods__=set())
     def test_init(self):
+        test_vocs = deepcopy(TEST_VOCS_BASE)
+        test_vocs.objectives = {}
+        test_vocs.observables = ["y1"]
         alg = Algorithm()
         bax_gen = BaxGenerator(
-            vocs=deepcopy(TEST_VOCS_BASE),
+            vocs=test_vocs,
             algorithm=alg,
         )
         bax_gen.model_dump()
@@ -110,6 +117,8 @@ class TestBaxGenerator:
 
         # test w/o constraints
         test_vocs = deepcopy(TEST_VOCS_BASE)
+        test_vocs.objectives = {}
+        test_vocs.observables = ["y1"]
         test_vocs.constraints = {}
         gen = BaxGenerator(
             vocs=test_vocs,
@@ -123,6 +132,8 @@ class TestBaxGenerator:
 
         # test w/ constraints
         test_vocs = deepcopy(TEST_VOCS_BASE)
+        test_vocs.objectives = {}
+        test_vocs.observables = ["y1"]
         gen = BaxGenerator(
             vocs=test_vocs,
             algorithm=alg,
@@ -135,8 +146,11 @@ class TestBaxGenerator:
 
     def test_cuda(self):
         alg = GridMinimize()
+        test_vocs = deepcopy(TEST_VOCS_BASE)
+        test_vocs.objectives = {}
+        test_vocs.observables = ["y1"]
         gen = BaxGenerator(
-            vocs=TEST_VOCS_BASE,
+            vocs=test_vocs,
             algorithm=alg,
         )
 
@@ -151,13 +165,16 @@ class TestBaxGenerator:
         evaluator = Evaluator(function=xtest_callable)
         alg = GridMinimize()
 
+        test_vocs = deepcopy(TEST_VOCS_BASE)
+        test_vocs.objectives = {}
+        test_vocs.observables = ["y1"]
         gen = BaxGenerator(
-            vocs=TEST_VOCS_BASE,
+            vocs=test_vocs,
             algorithm=alg,
         )
         gen.numerical_optimizer.n_restarts = 1
 
-        xopt = Xopt(generator=gen, evaluator=evaluator, vocs=TEST_VOCS_BASE)
+        xopt = Xopt(generator=gen, evaluator=evaluator, vocs=test_vocs)
 
         # initialize with single initial candidate
         xopt.random_evaluate(3)
@@ -167,12 +184,13 @@ class TestBaxGenerator:
         evaluator = Evaluator(function=xtest_callable)
         alg = GridMinimize()
 
-        gen = BaxGenerator(
-            vocs=TEST_VOCS_BASE, algorithm=alg, algorithm_results_file="test"
-        )
+        test_vocs = deepcopy(TEST_VOCS_BASE)
+        test_vocs.objectives = {}
+        test_vocs.observables = ["y1"]
+        gen = BaxGenerator(vocs=test_vocs, algorithm=alg, algorithm_results_file="test")
         gen.numerical_optimizer.n_restarts = 1
 
-        xopt = Xopt(generator=gen, evaluator=evaluator, vocs=TEST_VOCS_BASE)
+        xopt = Xopt(generator=gen, evaluator=evaluator, vocs=test_vocs)
 
         # initialize with single initial candidate
         xopt.random_evaluate(3)
@@ -191,3 +209,10 @@ class TestBaxGenerator:
 
         os.remove("test_1.pkl")
         os.remove("test_2.pkl")
+
+    def test_vocs_validation(self):
+        test_vocs = deepcopy(TEST_VOCS_BASE)
+        alg = GridMinimize()
+
+        with pytest.raises(ValidationError):
+            BaxGenerator(vocs=test_vocs, algorithm=alg)

{xopt-2.2.1 → xopt-2.2.3}/tests/generators/bayesian/test_bayesian_exploration.py

@@ -1,5 +1,9 @@
 from copy import deepcopy
 
+import pytest
+
+from pydantic import ValidationError
+
 from xopt.base import Xopt
 from xopt.evaluator import Evaluator
 from xopt.generators.bayesian.bayesian_exploration import BayesianExplorationGenerator
@@ -76,3 +80,9 @@ class TestBayesianExplorationGenerator:
         X.step()
         X.step()
         assert len(X.data) == 20
+
+    def test_vocs_validation(self):
+        test_vocs = deepcopy(TEST_VOCS_BASE)
+
+        with pytest.raises(ValidationError):
+            BayesianExplorationGenerator(vocs=test_vocs)

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

@@ -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.1 → xopt-2.2.3}/tests/generators/bayesian/test_model_constructor.py

@@ -13,6 +13,7 @@ from botorch.models.transforms import Normalize, Standardize
 from gpytorch import ExactMarginalLogLikelihood
 from gpytorch.kernels import PeriodicKernel, PolynomialKernel, ScaleKernel
 from gpytorch.likelihoods import GaussianLikelihood
+from gpytorch.means import ConstantMean
 from gpytorch.priors import GammaPrior
 from pydantic import ValidationError
 
@@ -437,6 +438,23 @@ class TestModelConstructor:
             assert torch.allclose(generated_pred, benchmark_pred, rtol=1e-3)
             assert ~torch.allclose(generated_pred, old_prediction, rtol=1e-3)
 
+    def test_unused_modules_warning(self):
+        test_vocs = deepcopy(TEST_VOCS_BASE)
+        test_data = deepcopy(TEST_VOCS_DATA)
+
+        # test unused covariance or mean module
+        kwargs_covar = {"covar_modules": {"faulty_output_name": PeriodicKernel()}}
+        kwargs_mean = {"mean_modules": {"faulty_output_name": ConstantMean()}}
+
+        for kwargs in [kwargs_covar, kwargs_mean]:
+            gp_constructor = StandardModelConstructor(**kwargs)
+            generator = ExpectedImprovementGenerator(
+                vocs=test_vocs, gp_constructor=gp_constructor
+            )
+            generator.add_data(test_data)
+            with pytest.warns(UserWarning):
+                _ = generator.train_model()
+
     def test_heteroskedastic(self):
         test_data = deepcopy(TEST_VOCS_DATA)
         test_vocs = deepcopy(TEST_VOCS_BASE)
@@ -487,6 +505,22 @@ class TestModelConstructor:
             posterior.variance[..., 0].flatten(), bposterior.variance.flatten()
         )
 
+    def test_custom_noise_prior(self):
+        test_data = deepcopy(TEST_VOCS_DATA)
+        test_vocs = deepcopy(TEST_VOCS_BASE)
+
+        noise_prior = GammaPrior(1.0, 1000.0)
+
+        gp_constructor = StandardModelConstructor(custom_noise_prior=noise_prior)
+        model = gp_constructor.build_model_from_vocs(test_vocs, test_data)
+
+        # check if created models have the correct noise priors
+        assert model.models[0].likelihood.noise_covar.noise_prior.rate == 1000.0
+        assert model.models[0].likelihood.noise_covar.noise_prior.concentration == 1.0
+
+        assert model.models[1].likelihood.noise_covar.noise_prior.rate == 1000.0
+        assert model.models[1].likelihood.noise_covar.noise_prior.concentration == 1.0
+
     @pytest.fixture(autouse=True)
     def clean_up(self):
         yield

{xopt-2.2.1 → xopt-2.2.3}/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.1 → xopt-2.2.3}/tests/generators/test_neldermead.py

@@ -138,7 +138,7 @@ class TestNelderMeadGenerator:
         data = X.vocs.variable_data(X.data).to_numpy()
         assert np.array_equal(data, scipy_data)
 
-        idx, best = X.vocs.select_best(X.data)
+        idx, best, _ = X.vocs.select_best(X.data)
         xbest = X.vocs.variable_data(X.data.loc[idx, :]).to_numpy().flatten()
         assert np.array_equal(
             xbest, result.x
@@ -216,7 +216,7 @@ class TestNelderMeadGenerator:
         assert data.shape == scipy_data.shape
         assert np.allclose(data, scipy_data, rtol=0, atol=1e-10)
 
-        idx, best = X.vocs.select_best(X.data)
+        idx, best, _ = X.vocs.select_best(X.data)
         xbest = X.vocs.variable_data(X.data.loc[idx, :]).to_numpy().flatten()
         assert np.array_equal(
             xbest, result.x

{xopt-2.2.1 → xopt-2.2.3}/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.1 → xopt-2.2.3}/tests/test_vocs.py

@@ -3,6 +3,7 @@ from copy import deepcopy
 import numpy as np
 import pandas as pd
 import pytest
+from pydantic import ValidationError
 
 from xopt.resources.testing import TEST_VOCS_BASE, TEST_VOCS_DATA
 from xopt.vocs import ObjectiveEnum, VOCS
@@ -26,6 +27,36 @@ class TestVOCS(object):
             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],
+            ["GREATER_THAN", 0],
+            ["less_than", 0],
+            ["greater_than", 0],
+        ]
+
+        for ele in good_constraint_list:
+            VOCS(variables={"x": [0, 1]}, constraints={"c": ele})
+
+        bad_constraint_list = [
+            ["LESS_THAN"],
+            ["GREATER_TAN", 0],
+            [0, "less_than"],
+            ["greater_than", "ahc"],
+        ]
+
+        for ele in bad_constraint_list:
+            with pytest.raises(ValidationError):
+                VOCS(variables={"x": [0, 1]}, constraints={"c": ele})
+
     def test_from_yaml(self):
         Y = """
         variables:
@@ -63,7 +94,11 @@ class TestVOCS(object):
         data = pd.DataFrame(vocs.random_inputs(n_samples))
         assert data.shape == (n_samples, vocs.n_inputs)
 
-        TEST_VOCS_BASE.random_inputs(5, include_constants=False)
+        test_inputs = TEST_VOCS_BASE.random_inputs(5, include_constants=False)
+        assert len(test_inputs) == 5
+
+        test_inputs = TEST_VOCS_BASE.random_inputs()
+        assert isinstance(test_inputs[0]["x1"], float)
 
     def test_serialization(self):
         vocs = deepcopy(TEST_VOCS_BASE)
@@ -181,32 +216,40 @@ class TestVOCS(object):
 
         # test maximization
         vocs.objectives[vocs.objective_names[0]] = "MAXIMIZE"
-        idx, val = vocs.select_best(test_data)
+        idx, val, _ = vocs.select_best(test_data)
         assert idx == [2]
         assert val == [1.0]
 
         vocs.constraints = {}
-        idx, val = vocs.select_best(test_data)
+        idx, val, _ = vocs.select_best(test_data)
         assert idx == [3]
         assert val == [1.5]
 
         # test returning multiple best values -- sorted by best value
-        idx, val = vocs.select_best(test_data, 2)
+        idx, val, _ = vocs.select_best(test_data, 2)
         assert np.allclose(idx, np.array([3, 2]))
         assert np.allclose(val, np.array([1.5, 1.0]))
 
         # test minimization
         vocs.objectives[vocs.objective_names[0]] = "MINIMIZE"
         vocs.constraints = {"c1": ["GREATER_THAN", 0.5]}
-        idx, val = vocs.select_best(test_data)
+        idx, val, _ = vocs.select_best(test_data)
         assert idx == [0]
         assert val == [0.5]
 
         vocs.constraints = {}
-        idx, val = vocs.select_best(test_data)
+        idx, val, _ = vocs.select_best(test_data)
         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.1 → xopt-2.2.3}/xopt/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-02-08T15:50:49-0800",
+ "date": "2024-05-07T12:53:58-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "27fc0ce1d9c798f72d11e08f673bb7d468ac81b2",
- "version": "2.2.1"
+ "full-revisionid": "2a01895f05a19d2a26b527c4c47baaf099cd0110",
+ "version": "2.2.3"
 }
 '''  # END VERSION_JSON
 

{xopt-2.2.1 → xopt-2.2.3}/xopt/asynchronous.py

@@ -31,7 +31,8 @@ class AsynchronousXopt(Xopt):
         """
         Submit data to evaluator and return futures indexed to internal futures list.
 
-        Args:
+        Parameters
+        ----------
             input_data: dataframe containing input data
 
         """

{xopt-2.2.1 → xopt-2.2.3}/xopt/base.py

@@ -405,7 +405,12 @@ class Xopt(XoptBaseModel):
         else:
             return new_data
 
-    def random_evaluate(self, n_samples=1, seed=None, **kwargs):
+    def random_evaluate(
+        self,
+        n_samples=None,
+        seed=None,
+        custom_bounds: dict = None,
+    ):
         """
         Convenience method to generate random inputs using VOCs and evaluate them.
 
@@ -419,8 +424,9 @@ class Xopt(XoptBaseModel):
             The number of random samples to generate.
         seed : int, optional
             The random seed for reproducibility.
-        **kwargs
-            Additional keyword arguments for generating random inputs.
+        custom_bounds : dict, optional
+            Dictionary of vocs-like ranges for random sampling
+
 
         Returns
         -------
@@ -428,7 +434,9 @@ class Xopt(XoptBaseModel):
             The results of the evaluations added to the internal DataFrame.
 
         """
-        random_inputs = self.vocs.random_inputs(n_samples, seed=seed, **kwargs)
+        random_inputs = self.vocs.random_inputs(
+            n_samples, seed=seed, custom_bounds=custom_bounds, include_constants=True
+        )
         result = self.evaluate_data(random_inputs)
         return result
 

{xopt-2.2.1 → xopt-2.2.3}/xopt/evaluator.py

@@ -37,7 +37,9 @@ class Evaluator(XoptBaseModel):
     executor : NormalExecutor
         NormalExecutor or any instantiated Executor object
     vectorized : bool, default=False
-        If true,
+        If true, lists of evaluation points will be sent to the evaluator
+        function to be processed in parallel instead of evaluated seperately via
+        mapping.
     """
 
     function: Callable

{xopt-2.2.1 → xopt-2.2.3}/xopt/generators/bayesian/bax/acquisition.py

@@ -20,7 +20,8 @@ class ModelListExpectedInformationGain(MultiObjectiveAnalyticAcquisitionFunction
         >>> EIG = ExpectedInformationGain(model, algo)
         >>> eig = EIG(test_X)
 
-        Args:
+        Parameters
+        ----------
             model: A fitted independent multi-output (ModelList) model.
     """
 
@@ -62,13 +63,15 @@ class ModelListExpectedInformationGain(MultiObjectiveAnalyticAcquisitionFunction
     def forward(self, X: Tensor) -> Tensor:
         r"""Evaluate Expected Information Gain on the candidate set X.
 
-        Args:
+        Parameters
+        ----------
             X: A `(b1 x ... bk) x 1 x d`-dim batched tensor of `d`-dim design points.
                 Expected Information Gain is computed for each point individually,
                 i.e., what is considered are the marginal posteriors, not the
                 joint.
 
-        Returns:
+        Returns
+        -------
             A `(b1 x ... bk)`-dim tensor of Expected Information Gain values at the
             given design points `X`.
         """

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

@@ -46,7 +46,7 @@ class GridScanAlgorithm(Algorithm, ABC):
 
 
 class GridMinimize(GridScanAlgorithm):
-    model_names_ordered: List[str] = Field(
+    observable_names_ordered: List[str] = Field(
         default=["y1"],
         description="names of observable/objective models used in this algorithm",
     )

{xopt-2.2.1 → xopt-2.2.3}/xopt/generators/bayesian/bax_generator.py

@@ -3,7 +3,8 @@ import pickle
 from copy import deepcopy
 from typing import Dict
 
-from pydantic import Field
+from pydantic import Field, field_validator
+from pydantic_core.core_schema import ValidationInfo
 
 from xopt.generators.bayesian.bax.acquisition import ModelListExpectedInformationGain
 from xopt.generators.bayesian.bax.algorithms import Algorithm
@@ -24,6 +25,12 @@ class BaxGenerator(BayesianGenerator):
 
     _n_calls: int = 0
 
+    @field_validator("vocs", mode="after")
+    def validate_vocs(cls, v, info: ValidationInfo):
+        if v.n_objectives != 0:
+            raise ValueError("this generator only supports observables")
+        return v
+
     def generate(self, n_candidates: int) -> list[dict]:
         self._n_calls += 1
         return super().generate(n_candidates)
@@ -31,7 +38,7 @@ class BaxGenerator(BayesianGenerator):
     def _get_acquisition(self, model):
         bax_model_ids = [
             self.vocs.output_names.index(name)
-            for name in self.algorithm.model_names_ordered
+            for name in self.algorithm.observable_names_ordered
         ]
         bax_model = model.subset_output(bax_model_ids)
         eig = ModelListExpectedInformationGain(

{xopt-2.2.1 → xopt-2.2.3}/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):
@@ -25,7 +24,7 @@ class BayesianExplorationGenerator(BayesianGenerator):
     @field_validator("vocs", mode="after")
     def validate_vocs(cls, v, info: ValidationInfo):
         if v.n_objectives != 0:
-            raise ValueError("this generator only supports zero objectives only")
+            raise ValueError("this generator only supports observables")
         return v
 
     def _get_acquisition(self, model):
@@ -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__(
@@ -55,7 +48,8 @@ class qPosteriorVariance(MCAcquisitionFunction):
         X_pending: Optional[Tensor] = None,
     ) -> None:
         r"""q-Upper Confidence Bound.
-        Args:
+        Parameters
+        ----------
             model: A fitted model.
             sampler: The sampler used to draw base samples. Defaults to
                 `SobolQMCNormalSampler(num_samples=512, collapse_batch_dims=True)`
@@ -79,10 +73,13 @@ class qPosteriorVariance(MCAcquisitionFunction):
     @t_batch_mode_transform()
     def forward(self, X: Tensor) -> Tensor:
         r"""Evaluate qUpperConfidenceBound on the candidate set `X`.
-        Args:
+        Parameters
+        ----------
             X: A `batch_sahpe x q x d`-dim Tensor of t-batches with `q` `d`-dim design
                 points each.
-        Returns:
+
+        Returns
+        -------
             A `batch_shape'`-dim Tensor of Upper Confidence Bound values at the given
             design points `X`, where `batch_shape'` is the broadcasted batch shape of
             model and input `X`.

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

@@ -375,6 +375,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 +550,20 @@ class BayesianGenerator(Generator, ABC):
         pass
 
     def _get_objective(self):
-        """return default objective (scalar objective) determined by vocs"""
+        """
+        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 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 +769,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

{xopt-2.2.1 → xopt-2.2.3}/xopt/generators/bayesian/custom_botorch/constrained_acquisition.py

@@ -18,8 +18,8 @@ class FeasibilityObjective(GenericMCObjective):
         infeasible_cost: float = 0.0,
         eta: float = 1e-3,
     ) -> None:
-        def ones_callable(X):
-            return torch.ones(X.shape[:-1])
+        def ones_callable(Z, X=None):
+            return torch.ones(Z.shape[:-1])
 
         super().__init__(objective=ones_callable)
         self.constraints = constraints
@@ -29,7 +29,8 @@ class FeasibilityObjective(GenericMCObjective):
     def forward(self, samples: Tensor, X: Optional[Tensor] = None) -> Tensor:
         r"""Evaluate the feasibility-weighted objective on the samples.
 
-        Args:
+        Parameters
+        ----------
             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

{xopt-2.2.1 → xopt-2.2.3}/xopt/generators/bayesian/custom_botorch/heteroskedastic.py

@@ -38,7 +38,8 @@ class XoptHeteroskedasticSingleTaskGP(BatchedMultiOutputGPyTorchModel, ExactGP):
         to specify mean and covariance modules.
 
 
-        Args:
+        Parameters
+        ----------
             train_X: A `batch_shape x n x d` tensor of training features.
             train_Y: A `batch_shape x n x m` tensor of training observations.
             train_Yvar: A `batch_shape x n x m` tensor of observed measurement