xopt 2.2.0__tar.gz → 2.2.2__tar.gz

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

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

{xopt-2.2.0 → xopt-2.2.2}/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.0 → xopt-2.2.2}/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.0 → xopt-2.2.2}/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.0 → xopt-2.2.2}/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.0 → xopt-2.2.2}/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,28 @@ class TestVOCS(object):
             variables={"x": [0, 1]},
         )
 
+    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 +86,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)
@@ -149,7 +176,7 @@ class TestVOCS(object):
             vocs.convert_dataframe_to_inputs(test_data)
 
         res = vocs.convert_dataframe_to_inputs(test_data[vocs.variable_names])
-        assert "cnt1" in res
+        assert "constant1" in res
 
     def test_validate_input_data(self):
         test_vocs = deepcopy(TEST_VOCS_BASE)
@@ -181,29 +208,29 @@ 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
 

{xopt-2.2.0 → xopt-2.2.2}/tests/test_xopt.py

@@ -208,7 +208,7 @@ class TestXopt:
         xopt = Xopt(generator=generator, evaluator=evaluator, vocs=test_vocs)
 
         test_vocs.variables = {"x2": [0, 1]}
-        test_vocs.constants = {"x1": 2.0}
+        test_vocs.constants["x1"] = 2.0
 
         out = xopt.evaluate({"x2": 0.2})
         assert isinstance(out, dict)
@@ -259,7 +259,7 @@ class TestXopt:
         val = str(xopt)
         assert "Data size: 2" in val
         assert (
-            "vocs:\n  constants:\n    cnt1: 1.0\n  constraints:\n    c1:\n    - "
+            "vocs:\n  constants:\n    constant1: 1.0\n  constraints:\n    c1:\n    - "
             "GREATER_THAN\n    - 0.5\n  objectives:\n" in val
         )
 

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-01-31T21:53:10-0600",
+ "date": "2024-04-15T14:51:35-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "6cb0704de59be6542d9889f1f931e2d29a4a2512",
- "version": "2.2.0"
+ "full-revisionid": "a613b00abdb1ff1809a10b82096947803834cec5",
+ "version": "2.2.2"
 }
 '''  # END VERSION_JSON
 

{xopt-2.2.0 → xopt-2.2.2}/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
 
         """
@@ -69,6 +70,10 @@ class AsynchronousXopt(Xopt):
         """
         input_data = pd.DataFrame(input_data, copy=True)  # copy for reindexing
 
+        # add constants to input data
+        for name, value in self.vocs.constants.items():
+            input_data[name] = value
+
         # Reindex input dataframe
         input_data.index = np.arange(
             self._ix_last + 1, self._ix_last + 1 + len(input_data)

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

@@ -25,7 +25,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):
@@ -55,7 +55,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 +80,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.0 → xopt-2.2.2}/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.0 → xopt-2.2.2}/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

{xopt-2.2.0 → xopt-2.2.2}/xopt/generators/bayesian/custom_botorch/identity.py

@@ -11,10 +11,13 @@ class Identity(AcquisitionFunction):
     @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.0 → xopt-2.2.2}/xopt/generators/bayesian/custom_botorch/proximal.py

@@ -55,7 +55,8 @@ class ProximalAcquisitionFunction(AcquisitionFunction):
         r"""Derived Acquisition Function weighted by proximity to recently
         observed point.
 
-        Args:
+        Parameters
+        ----------
             acq_function: The base acquisition function, operating on input tensors
                 of feature dimension `d`.
             proximal_weights: A `d` dim tensor used to bias locality
@@ -89,10 +90,12 @@ class ProximalAcquisitionFunction(AcquisitionFunction):
     def forward(self, X: Tensor) -> Tensor:
         r"""Evaluate base acquisition function with proximal weighting.
 
-        Args:
+        Parameters
+        ----------
             X: Input tensor of feature dimension `d` .
 
-        Returns:
+        Returns
+        -------
             Base acquisition function evaluated on tensor `X` multiplied by proximal
             weighting.
         """
@@ -143,7 +146,8 @@ def _validate_model(model: Model, proximal_weights: Tensor) -> None:
     Perform vaidation checks on model used in base acquisition function to make sure
     it is compatible with proximal weighting.
 
-    Args:
+    Parameters
+    ----------
         model: Model associated with base acquisition function to be validated.
         proximal_weights: A `d` dim tensor used to bias locality
                 along each axis.

{xopt-2.2.0 → xopt-2.2.2}/xopt/generators/bayesian/models/prior_mean.py

@@ -14,7 +14,8 @@ class CustomMean(Mean):
     ):
         """Custom prior mean for a GP based on an arbitrary model.
 
-        Args:
+        Parameters
+        ----------
             model: Representation of the model.
             input_transformer: Module used to transform inputs in the GP.
             outcome_transformer: Module used to transform outcomes in the GP.