Continuous inter-point constraints

CHANGELOG.md

@@ -19,6 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `arrays_to_dataframes` decorator to create lookups from array-based callables
 - `DiscreteConstraint.get_valid` to conveniently access valid candidates
 - Functionality for persisting benchmarking results on S3 from a manual pipeline run
+- Continuous inter-point constraints via new `is_interpoint` attribute
 
 ### Changed
 - `SubstanceParameter` encodings are now computed exclusively with the

baybe/constraints/continuous.py

@@ -5,10 +5,11 @@
 import gc
 import math
 from collections.abc import Collection, Sequence
+from itertools import chain, repeat
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
-from attr.validators import in_
+from attr.validators import in_, instance_of
 from attrs import define, field
 
 from baybe.constraints.base import (
@@ -45,6 +46,17 @@ class ContinuousLinearConstraint(ContinuousConstraint):
     rhs: float = field(default=0.0, converter=float, validator=finite_float)
     """Right-hand side value of the in-/equality."""
 
+    is_interpoint: bool = field(
+        alias="interpoint", default=False, validator=instance_of(bool)
+    )
+    """Flag for defining an interpoint constraint.
+
+    While intra-point constraints impose conditions on each individual point of a batch,
+    interpoint constraints do so **across** the points of the batch. That is, an
+    interpoint constraint of the form ``x_1 + x_2 <= 1`` enforces that the sum of all
+    ``x_1`` values plus the sum of all ``x_2`` values in the batch must not exceed 1.
+    """
+
     @coefficients.validator
     def _validate_coefficients(  # noqa: DOC101, DOC103
         self, _: Any, coefficients: list[float]
@@ -98,7 +110,10 @@ def _drop_parameters(
         )
 
     def to_botorch(
-        self, parameters: Sequence[NumericalContinuousParameter], idx_offset: int = 0
+        self,
+        parameters: Sequence[NumericalContinuousParameter],
+        idx_offset: int = 0,
+        batch_size: int | None = None,
     ) -> tuple[Tensor, Tensor, float]:
         """Cast the constraint in a format required by botorch.
 
@@ -108,25 +123,48 @@ def to_botorch(
         Args:
             parameters: The parameter objects of the continuous space.
             idx_offset: Offset to the provided parameter indices.
+            batch_size: The batch size used in the recommendation. Necessary for
+                interpoint constraints, ignored by all others.
 
         Returns:
             The tuple required by botorch.
+
+        Raises:
+            RuntimeError: When the constraint is an interpoint constraint but
+                batch_size is ``None``.
         """
         import torch
 
         from baybe.utils.torch import DTypeFloatTorch
 
         param_names = [p.name for p in parameters]
-        param_indices = [
-            param_names.index(p) + idx_offset
-            for p in self.parameters
-            if p in param_names
-        ]
+        if not self.is_interpoint:
+            param_indices = [
+                param_names.index(p) + idx_offset
+                for p in self.parameters
+                if p in param_names
+            ]
+            coefficients = self.coefficients
+            torch_indices = torch.tensor(param_indices)
+        else:
+            if batch_size is None:
+                raise RuntimeError(
+                    "No `batch_size` set but using interpoint constraints."
+                    "This should nothappen and means that there is a bug in the code."
+                )
+            param_index = {name: param_names.index(name) for name in self.parameters}
+            param_indices_interpoint = [
+                (batch, param_index[name] + idx_offset)
+                for name in self.parameters
+                for batch in range(batch_size)
+            ]
+            coefficients = list(chain(*zip(*repeat(self.coefficients, batch_size))))
+            torch_indices = torch.tensor(param_indices_interpoint)
 
         return (
-            torch.tensor(param_indices),
+            torch_indices,
             torch.tensor(
-                [self._multiplier * c for c in self.coefficients], dtype=DTypeFloatTorch
+                [self._multiplier * c for c in coefficients], dtype=DTypeFloatTorch
             ),
             np.asarray(self._multiplier * self.rhs, dtype=DTypeFloatNumpy).item(),
         )

baybe/constraints/validation.py

@@ -4,7 +4,11 @@
 from itertools import combinations
 
 from baybe.constraints.base import Constraint
-from baybe.constraints.continuous import ContinuousCardinalityConstraint
+from baybe.constraints.continuous import (
+    ContinuousCardinalityConstraint,
+    ContinuousConstraint,
+    ContinuousLinearConstraint,
+)
 from baybe.constraints.discrete import (
     DiscreteDependenciesConstraint,
 )
@@ -36,6 +40,11 @@ def validate_constraints(  # noqa: DOC101, DOC103
     validate_cardinality_constraints_are_nonoverlapping(
         [con for con in constraints if isinstance(con, ContinuousCardinalityConstraint)]
     )
+    validate_no_interpoint_and_cardinality_constraints(
+        constraints=[
+            con for con in constraints if isinstance(con, ContinuousConstraint)
+        ]
+    )
 
     param_names_all = [p.name for p in parameters]
     param_names_discrete = [p.name for p in parameters if p.is_discrete]
@@ -98,3 +107,34 @@ def validate_cardinality_constraints_are_nonoverlapping(
                 f"cannot share the same parameters. Found the following overlapping "
                 f"parameter sets: {s1}, {s2}."
             )
+
+
+def validate_no_interpoint_and_cardinality_constraints(
+    constraints: Collection[ContinuousConstraint],
+):
+    """Validate that cardinality and interpoint constraints are not used together.
+
+    This is a current limitation in our code and might be enabled in the future.
+
+    Args:
+        constraints: A collection of continuous constraints.
+
+    Raises:
+        ValueError: If there are both interpoint and cardinality constraints.
+    """
+    # Check is a bit cumbersome since the is_interpoint field is currently defined
+    # for ContinouosLinearConstraint only as these are the only ones that can
+    # actually be interpoint.
+    has_interpoint = any(
+        c.is_interpoint
+        for c in constraints
+        if isinstance(c, ContinuousLinearConstraint)
+    )
+    has_cardinality = any(
+        isinstance(c, ContinuousCardinalityConstraint) for c in constraints
+    )
+    if has_interpoint and has_cardinality:
+        raise ValueError(
+            f"Cconstraints of type `{ContinuousCardinalityConstraint.__name__}` "
+            "cannot be used together with interpoint constraints."
+        )

baybe/recommenders/pure/bayesian/botorch.py

@@ -185,12 +185,12 @@ def _recommend_continuous(
             num_restarts=self.n_restarts,
             raw_samples=self.n_raw_samples,
             equality_constraints=[
-                c.to_botorch(subspace_continuous.parameters)
+                c.to_botorch(subspace_continuous.parameters, batch_size=batch_size)
                 for c in subspace_continuous.constraints_lin_eq
             ]
             or None,  # TODO: https://github.com/pytorch/botorch/issues/2042
             inequality_constraints=[
-                c.to_botorch(subspace_continuous.parameters)
+                c.to_botorch(subspace_continuous.parameters, batch_size=batch_size)
                 for c in subspace_continuous.constraints_lin_ineq
             ]
             or None,  # TODO: https://github.com/pytorch/botorch/issues/2042
@@ -234,6 +234,11 @@ def _recommend_hybrid(
         Returns:
             The recommended points.
         """
+        if searchspace.continuous.has_interpoint_constraints:
+            raise NotImplementedError(
+                "Interpoint constraints are not available in hybrid spaces."
+            )
+
         # For batch size > 1, this optimizer needs a MC acquisition function
         if batch_size > 1 and not self.acquisition_function.is_mc:
             raise IncompatibleAcquisitionFunctionError(

baybe/searchspace/continuous.py

@@ -20,6 +20,7 @@
 from baybe.constraints.base import ContinuousConstraint, ContinuousNonlinearConstraint
 from baybe.constraints.validation import (
     validate_cardinality_constraints_are_nonoverlapping,
+    validate_no_interpoint_and_cardinality_constraints,
 )
 from baybe.parameters import NumericalContinuousParameter
 from baybe.parameters.base import ContinuousParameter
@@ -83,6 +84,7 @@ def __str__(self) -> str:
         nonlin_constraints_list = [
             constr.summary() for constr in self.constraints_nonlin
         ]
+
         param_df = pd.DataFrame(param_list)
         lin_eq_df = pd.DataFrame(eq_constraints_list)
         lin_ineq_df = pd.DataFrame(ineq_constraints_list)
@@ -173,6 +175,7 @@ def from_product(
     ) -> SubspaceContinuous:
         """See :class:`baybe.searchspace.core.SearchSpace`."""
         constraints = constraints or []
+        validate_no_interpoint_and_cardinality_constraints(constraints)
         return SubspaceContinuous(
             parameters=[p for p in parameters if p.is_continuous],  # type:ignore[misc]
             constraints_lin_eq=[  # type:ignore[attr-misc]
@@ -286,6 +289,24 @@ def comp_rep_bounds(self) -> pd.DataFrame:
             dtype=DTypeFloatNumpy,
         )
 
+    @property
+    def is_constrained(self) -> bool:
+        """Boolean flag indicating whether the subspace is constrained in any way."""
+        return any(
+            (
+                self.constraints_lin_eq,
+                self.constraints_lin_ineq,
+                self.constraints_nonlin,
+            )
+        )
+
+    @property
+    def has_interpoint_constraints(self) -> bool:
+        """Boolean flag indicating whether the space has any interpoint constraints."""
+        return any(
+            c.is_interpoint for c in self.constraints_lin_eq + self.constraints_lin_ineq
+        )
+
     def _drop_parameters(self, parameter_names: Collection[str]) -> SubspaceContinuous:
         """Create a copy of the subspace with certain parameters removed.
 
@@ -391,14 +412,11 @@ def sample_uniform(self, batch_size: int = 1) -> pd.DataFrame:
 
         if not self.parameters:
             return pd.DataFrame(index=pd.RangeIndex(0, batch_size))
-
-        if (
-            len(self.constraints_lin_eq) == 0
-            and len(self.constraints_lin_ineq) == 0
-            and len(self.constraints_cardinality) == 0
-        ):
+        # If the space is completely unconstrained, we can sample from bounds.
+        if not self.is_constrained:
             return self._sample_from_bounds(batch_size, self.comp_rep_bounds.values)
 
+        # If there are no cardinality constraints, we sample directly from the polytope
         if len(self.constraints_cardinality) == 0:
             return self._sample_from_polytope(batch_size, self.comp_rep_bounds.values)
 
@@ -413,22 +431,70 @@ def _sample_from_bounds(self, batch_size: int, bounds: np.ndarray) -> pd.DataFra
         return pd.DataFrame(points, columns=self.parameter_names)
 
     def _sample_from_polytope(
-        self, batch_size: int, bounds: np.ndarray
+        self,
+        batch_size: int,
+        bounds: np.ndarray,
     ) -> pd.DataFrame:
         """Draw uniform random samples from a polytope."""
+        # If the space has interpoint constraints, we need to sample from a larger
+        # searchspace that models the batch size via additional dimension. This is
+        # necessary since `get_polytope_samples` cannot handle interpoint constraints,
+        # see https://github.com/pytorch/botorch/issues/2468
+
         import torch
         from botorch.utils.sampling import get_polytope_samples
 
+        # The number of parameters is needed at some places for adjusting indices
+        num_of_params = len(self.comp_rep_columns)
+
+        eq_constraints, ineq_constraints = [], []
+
+        for c in [*self.constraints_lin_eq, *self.constraints_lin_ineq]:
+            if not c.is_interpoint:
+                param_indices, coefficients, rhs = c.to_botorch(self.parameters)
+                for b in range(batch_size):
+                    botorch_tuple = (
+                        param_indices + b * num_of_params,
+                        coefficients,
+                        rhs,
+                    )
+                    if c.is_eq:
+                        eq_constraints.append(botorch_tuple)
+                    else:
+                        ineq_constraints.append(botorch_tuple)
+            else:
+                # Get the indices of the parameters used in the constraint
+                param_index = {
+                    name: self.parameter_names.index(name) for name in c.parameters
+                }
+                param_indices_list = [
+                    batch * num_of_params + param_index[param]
+                    for param in c.parameters
+                    for batch in range(batch_size)
+                ]
+                _, coefficients, rhs = c.to_botorch(
+                    parameters=self.parameters, batch_size=batch_size
+                )
+                botorch_tuple = (
+                    torch.tensor(param_indices_list),
+                    coefficients,
+                    rhs,
+                )
+                if c.is_eq:
+                    eq_constraints.append(botorch_tuple)
+                else:
+                    ineq_constraints.append(botorch_tuple)
+
+        bounds_joint = torch.cat(
+            [torch.from_numpy(bounds) for _ in range(batch_size)], dim=-1
+        )
         points = get_polytope_samples(
-            n=batch_size,
-            bounds=torch.from_numpy(bounds),
-            equality_constraints=[
-                c.to_botorch(self.parameters) for c in self.constraints_lin_eq
-            ],
-            inequality_constraints=[
-                c.to_botorch(self.parameters) for c in self.constraints_lin_ineq
-            ],
+            n=1,
+            bounds=bounds_joint,
+            equality_constraints=eq_constraints,
+            inequality_constraints=ineq_constraints,
         )
+        points = points.reshape(batch_size, points.shape[-1] // batch_size)
         return pd.DataFrame(points, columns=self.parameter_names)
 
     def _sample_from_polytope_with_cardinality_constraints(

docs/userguide/constraints.md

@@ -79,6 +79,38 @@ ContinuousLinearConstraint(
 A more detailed example can be found
 [here](../../examples/Constraints_Continuous/linear_constraints).
 
+### Interpoint Constraints
+
+The constraints discussed so far all belong to the class of so called "intrapoint constraints".
+That is, they impose conditions on each individual point of a batch.
+In contrast to this, interpoint constraints do so **across** the points of the batch.
+That is, an interpoint constraint of the form ``x_1 + x_2 <= 1`` enforces that the sum of all
+``x_1`` values plus the sum of all ``x_2`` values in the batch must not exceed 1.
+A possible relevant constraint might be that only 100ml of a given solvent are available for 
+a full batch, but there is no limit for the amount of solvent to use for a single experiment
+within that batch.
+
+They can be defined by using the `interpoint` keyword of the [`ContinuousLinearConstraint`](baybe.constraints.continuous.ContinuousLinearConstraint)
+class. 
+```python
+from baybe.constraints import ContinuousLinearConstraint
+
+ContinuousLinearConstraint(
+    parameters=["SolventAmount[ml]"],
+    operator="<=",
+    coefficients=[1.0],
+    rhs=100,
+    interpoint=True,
+)
+
+```
+
+```{admonition} Mixing Interpoint and Cardinality Constraints
+:class: note
+Currently, BayBE does not support to use both interpoint and cardinality constraints
+within the same search space.
+```
+
 ## Conditions
 Conditions are elements used within discrete constraints.
 While discrete constraints can operate on one or multiple parameters, a condition