Fix kernel translation

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Parameter.is_numeric` has been replaced with `Parameter.is_numerical`
 - `DiscreteParameter.transform_rep_exp2comp` has been replaced with
   `DiscreteParameter.transform` 
+- `filter_attributes` has been replaced with `match_attributes`
 
 ### Added
 - `Surrogate` base class now exposes a `to_botorch` method
@@ -38,6 +39,8 @@ _ `_optional` subpackage for managing optional dependencies
 - `DiscreteParameter.to_subspace`, `ContinuousParameter.to_subspace` and
   `Parameter.to_searchspace` convenience constructors
 - Utilities for permutation and dependency data augmentation
+- Validation and translation tests for kernels
+- `BasicKernel` and `CompositeKernel` base classes
 
 ### Changed
 - Passing an `Objective` to `Campaign` is now optional
@@ -58,6 +61,10 @@ _ `_optional` subpackage for managing optional dependencies
 - Serialization bug related to class layout of `SKLearnClusteringRecommender`
 - `MetaRecommender`s no longer trigger warnings about non-empty objectives or
   measurements when calling a `NonPredictiveRecommender`
+- Bug introduced in 0.9.0 (PR #221, commit 3078f3), where arguments to `to_gpytorch` 
+  are not passed on to the GPyTorch kernels
+- Positive-valued kernel attributes are now correctly handled by validators
+  and hypothesis strategies
 
 ### Deprecations
 - `SequentialGreedyRecommender` class replaced with `BotorchRecommender`

baybe/acquisition/acqfs.py

@@ -11,6 +11,7 @@
 
 from baybe.acquisition.base import AcquisitionFunction
 from baybe.searchspace import SearchSpace
+from baybe.utils.basic import classproperty
 from baybe.utils.sampling_algorithms import (
     DiscreteSamplingMethod,
     sample_numerical_df,
@@ -65,6 +66,15 @@ def _validate_sampling_fraction(self, attr, value) -> None:
                 f"be specified at the same time."
             )
 
+    @classproperty
+    def _non_botorch_attrs(cls) -> tuple[str, ...]:
+        flds = fields(qNegIntegratedPosteriorVariance)
+        return (
+            flds.sampling_n_points.name,
+            flds.sampling_method.name,
+            flds.sampling_fraction.name,
+        )
+
     def get_integration_points(self, searchspace: SearchSpace) -> pd.DataFrame:
         """Sample points from a search space for integration purposes.
 

baybe/acquisition/base.py

@@ -18,7 +18,7 @@
 )
 from baybe.serialization.mixin import SerialMixin
 from baybe.surrogates.base import Surrogate
-from baybe.utils.basic import classproperty, filter_attributes
+from baybe.utils.basic import classproperty, match_attributes
 from baybe.utils.boolean import is_abstract
 from baybe.utils.dataframe import to_tensor
 
@@ -35,6 +35,11 @@ def is_mc(cls) -> bool:
         """Flag indicating whether this is a Monte-Carlo acquisition function."""
         return cls.abbreviation.startswith("q")
 
+    @classproperty
+    def _non_botorch_attrs(cls) -> tuple[str, ...]:
+        """Names of attributes that are not passed to the BoTorch constructor."""
+        return ()
+
     def to_botorch(
         self,
         surrogate: Surrogate,
@@ -45,9 +50,15 @@ def to_botorch(
         """Create the botorch-ready representation of the function."""
         import botorch.acquisition as botorch_acqf_module
 
+        # Retrieve corresponding botorch class
         acqf_cls = getattr(botorch_acqf_module, self.__class__.__name__)
-        params_dict = filter_attributes(object=self, callable_=acqf_cls.__init__)
 
+        # Match relevant attributes
+        params_dict = match_attributes(
+            self, acqf_cls.__init__, ignore=self._non_botorch_attrs
+        )[0]
+
+        # Collect remaining (context-specific) parameters
         signature_params = signature(acqf_cls).parameters
         additional_params = {}
         if "model" in signature_params:

baybe/exceptions.py

@@ -59,3 +59,7 @@ class DeprecationError(Exception):
 
 class UnidentifiedSubclassError(Exception):
     """A specified subclass cannot be found in the given class hierarchy."""
+
+
+class UnmatchedAttributeError(Exception):
+    """An attribute cannot be matched against a certain callable signature."""

baybe/kernels/base.py

@@ -3,18 +3,19 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from attrs import define
 
+from baybe.exceptions import UnmatchedAttributeError
 from baybe.priors.base import Prior
 from baybe.serialization.core import (
     converter,
     get_base_structure_hook,
     unstructure_base,
 )
 from baybe.serialization.mixin import SerialMixin
-from baybe.utils.basic import filter_attributes, get_baseclasses
+from baybe.utils.basic import get_baseclasses, match_attributes
 
 if TYPE_CHECKING:
     import torch
@@ -42,38 +43,57 @@ def to_gpytorch(
         """Create the gpytorch representation of the kernel."""
         import gpytorch.kernels
 
-        # Fetch the necessary gpytorch constructor parameters of the kernel.
-        # NOTE: In gpytorch, some attributes (like the kernel lengthscale) are handled
-        # via the `gpytorch.kernels.Kernel` base class. Hence, it is not sufficient to
-        # just check the fields of the actual class, but also those of the base class.
+        # Extract keywords with non-default values. This is required since gpytorch
+        # makes use of kwargs, i.e. differentiates if certain keywords are explicitly
+        # passed or not. For instance, `ard_num_dims = kwargs.get("ard_num_dims", 1)`
+        # fails if we explicitly pass `ard_num_dims=None`.
+        kw: dict[str, Any] = dict(
+            ard_num_dims=ard_num_dims, batch_shape=batch_shape, active_dims=active_dims
+        )
+        kw = {k: v for k, v in kw.items() if v is not None}
+
+        # Get corresponding gpytorch kernel class and its base classes
         kernel_cls = getattr(gpytorch.kernels, self.__class__.__name__)
         base_classes = get_baseclasses(kernel_cls, abstract=True)
-        fields_dict = {}
+
+        # Fetch the necessary gpytorch constructor parameters of the kernel.
+        # NOTE: In gpytorch, some attributes (like the kernel lengthscale) are handled
+        #   via the `gpytorch.kernels.Kernel` base class. Hence, it is not sufficient to
+        #   just check the fields of the actual class, but also those of its base
+        #   classes.
+        kernel_attrs: dict[str, Any] = {}
+        unmatched_attrs: dict[str, Any] = {}
         for cls in [kernel_cls, *base_classes]:
-            fields_dict.update(filter_attributes(object=self, callable_=cls.__init__))
+            matched, unmatched = match_attributes(self, cls.__init__, strict=False)
+            kernel_attrs.update(matched)
+            unmatched_attrs.update(unmatched)
+
+        # Sanity check: all attributes of the BayBE kernel need a corresponding match
+        # in the gpytorch kernel (otherwise, the BayBE kernel class is misconfigured).
+        # Exception: initial values are not used during construction but are set
+        # on the created object (see code at the end of the method).
+        missing = set(unmatched) - set(kernel_attrs)
+        if leftover := {m for m in missing if not m.endswith("_initial_value")}:
+            raise UnmatchedAttributeError(leftover)
 
         # Convert specified priors to gpytorch, if provided
         prior_dict = {
             key: value.to_gpytorch()
-            for key, value in fields_dict.items()
+            for key, value in kernel_attrs.items()
             if isinstance(value, Prior)
         }
 
         # Convert specified inner kernels to gpytorch, if provided
         kernel_dict = {
-            key: value.to_gpytorch(
-                ard_num_dims=ard_num_dims,
-                batch_shape=batch_shape,
-                active_dims=active_dims,
-            )
-            for key, value in fields_dict.items()
+            key: value.to_gpytorch(**kw)
+            for key, value in kernel_attrs.items()
             if isinstance(value, Kernel)
         }
 
         # Create the kernel with all its inner gpytorch objects
-        fields_dict.update(kernel_dict)
-        fields_dict.update(prior_dict)
-        gpytorch_kernel = kernel_cls(**fields_dict)
+        kernel_attrs.update(kernel_dict)
+        kernel_attrs.update(prior_dict)
+        gpytorch_kernel = kernel_cls(**kernel_attrs, **kw)
 
         # If the kernel has a lengthscale, set its initial value
         if kernel_cls.has_lengthscale:
@@ -94,6 +114,16 @@ def to_gpytorch(
         return gpytorch_kernel
 
 
+@define(frozen=True)
+class BasicKernel(Kernel, ABC):
+    """Abstract base class for all basic kernels."""
+
+
+@define(frozen=True)
+class CompositeKernel(Kernel, ABC):
+    """Abstract base class for all composite kernels."""
+
+
 # Register de-/serialization hooks
 converter.register_structure_hook(Kernel, get_base_structure_hook(Kernel))
 converter.register_unstructure_hook(Kernel, unstructure_base)

baybe/kernels/basic.py

@@ -3,17 +3,17 @@
 
 from attrs import define, field
 from attrs.converters import optional as optional_c
-from attrs.validators import ge, in_, instance_of
+from attrs.validators import ge, gt, in_, instance_of
 from attrs.validators import optional as optional_v
 
-from baybe.kernels.base import Kernel
+from baybe.kernels.base import BasicKernel
 from baybe.priors.base import Prior
 from baybe.utils.conversion import fraction_to_float
 from baybe.utils.validation import finite_float
 
 
 @define(frozen=True)
-class LinearKernel(Kernel):
+class LinearKernel(BasicKernel):
     """A linear kernel."""
 
     variance_prior: Prior | None = field(
@@ -22,7 +22,9 @@ class LinearKernel(Kernel):
     """An optional prior on the kernel variance parameter."""
 
     variance_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel variance parameter."""
 
@@ -41,7 +43,7 @@ def to_gpytorch(self, *args, **kwargs):  # noqa: D102
 
 
 @define(frozen=True)
-class MaternKernel(Kernel):
+class MaternKernel(BasicKernel):
     """A Matern kernel using a smoothness parameter."""
 
     nu: float = field(
@@ -58,13 +60,15 @@ class MaternKernel(Kernel):
     """An optional prior on the kernel lengthscale."""
 
     lengthscale_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel lengthscale."""
 
 
 @define(frozen=True)
-class PeriodicKernel(Kernel):
+class PeriodicKernel(BasicKernel):
     """A periodic kernel."""
 
     lengthscale_prior: Prior | None = field(
@@ -73,7 +77,9 @@ class PeriodicKernel(Kernel):
     """An optional prior on the kernel lengthscale."""
 
     lengthscale_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel lengthscale."""
 
@@ -83,7 +89,9 @@ class PeriodicKernel(Kernel):
     """An optional prior on the kernel period length."""
 
     period_length_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel period length."""
 
@@ -104,7 +112,7 @@ def to_gpytorch(self, *args, **kwargs):  # noqa: D102
 
 
 @define(frozen=True)
-class PiecewisePolynomialKernel(Kernel):
+class PiecewisePolynomialKernel(BasicKernel):
     """A piecewise polynomial kernel."""
 
     q: int = field(validator=in_([0, 1, 2, 3]), default=2)
@@ -116,13 +124,15 @@ class PiecewisePolynomialKernel(Kernel):
     """An optional prior on the kernel lengthscale."""
 
     lengthscale_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel lengthscale."""
 
 
 @define(frozen=True)
-class PolynomialKernel(Kernel):
+class PolynomialKernel(BasicKernel):
     """A polynomial kernel."""
 
     power: int = field(validator=[instance_of(int), ge(0)])
@@ -134,7 +144,9 @@ class PolynomialKernel(Kernel):
     """An optional prior on the kernel offset."""
 
     offset_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel offset."""
 
@@ -151,7 +163,7 @@ def to_gpytorch(self, *args, **kwargs):  # noqa: D102
 
 
 @define(frozen=True)
-class RBFKernel(Kernel):
+class RBFKernel(BasicKernel):
     """A radial basis function (RBF) kernel."""
 
     lengthscale_prior: Prior | None = field(
@@ -160,13 +172,15 @@ class RBFKernel(Kernel):
     """An optional prior on the kernel lengthscale."""
 
     lengthscale_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel lengthscale."""
 
 
 @define(frozen=True)
-class RFFKernel(Kernel):
+class RFFKernel(BasicKernel):
     """A random Fourier features (RFF) kernel."""
 
     num_samples: int = field(validator=[instance_of(int), ge(1)])
@@ -178,13 +192,15 @@ class RFFKernel(Kernel):
     """An optional prior on the kernel lengthscale."""
 
     lengthscale_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel lengthscale."""
 
 
 @define(frozen=True)
-class RQKernel(Kernel):
+class RQKernel(BasicKernel):
     """A rational quadratic (RQ) kernel."""
 
     lengthscale_prior: Prior | None = field(
@@ -193,6 +209,8 @@ class RQKernel(Kernel):
     """An optional prior on the kernel lengthscale."""
 
     lengthscale_initial_value: float | None = field(
-        default=None, converter=optional_c(float), validator=optional_v(finite_float)
+        default=None,
+        converter=optional_c(float),
+        validator=optional_v([finite_float, gt(0.0)]),
     )
     """An optional initial value for the kernel lengthscale."""