xopt 2.2.2__tar.gz → 2.2.3__tar.gz

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

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

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

@@ -27,6 +27,14 @@ 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],
@@ -234,6 +242,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.2.3}/xopt/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-04-15T14:51:35-0400",
+ "date": "2024-05-07T12:53:58-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "a613b00abdb1ff1809a10b82096947803834cec5",
- "version": "2.2.2"
+ "full-revisionid": "2a01895f05a19d2a26b527c4c47baaf099cd0110",
+ "version": "2.2.3"
 }
 '''  # END VERSION_JSON
 

{xopt-2.2.2 → 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):
@@ -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.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.2 → xopt-2.2.3}/xopt/generators/bayesian/expected_improvement.py

@@ -36,8 +36,7 @@ class ExpectedImprovementGenerator(BayesianGenerator):
             )
         else:
             # analytic acquisition function for single candidate generation
-            weights = torch.zeros(self.vocs.n_outputs).to(**self._tkwargs)
-            weights = set_botorch_weights(weights, self.vocs)
+            weights = set_botorch_weights(self.vocs).to(**self._tkwargs)
             posterior_transform = ScalarizedPosteriorTransform(weights)
             acq = ExpectedImprovement(
                 model, best_f=best_f, posterior_transform=posterior_transform

{xopt-2.2.2 → xopt-2.2.3}/xopt/generators/bayesian/mggpo.py

@@ -61,7 +61,7 @@ class MGGPOGenerator(MultiObjectiveBayesianGenerator):
         return acq
 
     def _get_objective(self):
-        return create_mobo_objective(self.vocs, self._tkwargs)
+        return create_mobo_objective(self.vocs)
 
     def _get_acquisition(self, model):
         # get reference point from data

{xopt-2.2.2 → xopt-2.2.3}/xopt/generators/bayesian/mobo.py

@@ -15,7 +15,7 @@ class MOBOGenerator(MultiObjectiveBayesianGenerator):
             Hypervolume Improvement acquisition function"""
 
     def _get_objective(self):
-        return create_mobo_objective(self.vocs, self._tkwargs)
+        return create_mobo_objective(self.vocs)
 
     def get_acquisition(self, model):
         """

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

@@ -41,7 +41,7 @@ def constraint_function(Z, vocs, name):
 
 def create_constraint_callables(vocs):
     if vocs.constraints is not None:
-        constraint_names = list(vocs.constraints.keys())
+        constraint_names = vocs.constraint_names
         constraint_callables = []
         for name in constraint_names:
             constraint_callables += [
@@ -62,10 +62,7 @@ def create_mc_objective(vocs, tkwargs):
     create the objective object
 
     """
-    n_outputs = vocs.n_outputs
-    weights = torch.zeros(n_outputs).to(**tkwargs)
-
-    weights = set_botorch_weights(weights, vocs)
+    weights = set_botorch_weights(vocs)
 
     def obj_callable(Z, X=None):
         return torch.matmul(Z, weights.reshape(-1, 1)).squeeze(-1)
@@ -73,26 +70,15 @@ def create_mc_objective(vocs, tkwargs):
     return GenericMCObjective(obj_callable)
 
 
-def create_exploration_objective(vocs, tkwargs):
-    n_outputs = vocs.n_outputs
-    weights = torch.zeros(n_outputs).to(**tkwargs)
-    weights[0] = 1.0
-
-    def obj_callable(Z, X=None):
-        return torch.matmul(Z, weights.reshape(-1, 1)).squeeze(-1)
-
-    return GenericMCObjective(obj_callable)
-
-
-def create_mobo_objective(vocs, tkwargs):
+def create_mobo_objective(vocs):
     """
     botorch assumes maximization so we need to negate any objectives that have
     minimize keyword and zero out anything that is a constraint
     """
-    n_objectives = vocs.n_objectives
-    weights = torch.zeros(n_objectives).to(**tkwargs)
-    weights = set_botorch_weights(weights, vocs)
+    output_names = vocs.output_names
+    objective_indicies = [output_names.index(name) for name in vocs.objectives]
+    weights = set_botorch_weights(vocs)[objective_indicies]
 
     return WeightedMCMultiOutputObjective(
-        weights, outcomes=list(range(vocs.n_objectives)), num_outcomes=vocs.n_objectives
+        weights, outcomes=objective_indicies, num_outcomes=vocs.n_objectives
     )

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

@@ -1,6 +1,5 @@
 import warnings
 
-import torch
 from botorch.acquisition import (
     qUpperConfidenceBound,
     ScalarizedPosteriorTransform,
@@ -62,8 +61,7 @@ beta : float, default 2.0
             )
         else:
             # analytic acquisition function for single candidate generation
-            weights = torch.zeros(self.vocs.n_outputs).to(**self._tkwargs)
-            weights = set_botorch_weights(weights, self.vocs)
+            weights = set_botorch_weights(self.vocs)
             posterior_transform = ScalarizedPosteriorTransform(weights)
             acq = UpperConfidenceBound(
                 model, beta=self.beta, posterior_transform=posterior_transform

{xopt-2.2.2 → xopt-2.2.3}/xopt/generators/bayesian/utils.py

@@ -65,13 +65,26 @@ def get_training_data(
     return train_X, train_Y, train_Yvar
 
 
-def set_botorch_weights(weights, vocs: VOCS):
-    """set weights to multiply xopt objectives for botorch objectives"""
-    for idx, ele in enumerate(vocs.objective_names):
-        if vocs.objectives[ele] == "MINIMIZE":
-            weights[idx] = -1.0
-        elif vocs.objectives[ele] == "MAXIMIZE":
-            weights[idx] = 1.0
+def set_botorch_weights(vocs: VOCS):
+    """set weights to multiply xopt objectives or observables for botorch objectives"""
+    output_names = vocs.output_names
+
+    weights = torch.zeros(len(output_names), dtype=torch.double)
+
+    if vocs.n_objectives > 0:
+        # if objectives exist this is an optimization problem
+        # set weights according to the index of the models -- corresponds to the
+        # ordering of output names
+        for objective_name in vocs.objective_names:
+            if vocs.objectives[objective_name] == "MINIMIZE":
+                weights[output_names.index(objective_name)] = -1.0
+            elif vocs.objectives[objective_name] == "MAXIMIZE":
+                weights[output_names.index(objective_name)] = 1.0
+    if vocs.n_objectives == 0:
+        # if no objectives exist this may be an exploration problem, weight each
+        # observable by 1.0
+        for observable_name in vocs.observables:
+            weights[output_names.index(observable_name)] = 1.0
 
     return weights