Remove generic parameter for hyperconfig and add abstract hyperconfig property instead.

Author: Lars Riegsinger

bofire/benchmarks/hyperopt.py

@@ -19,7 +19,7 @@ def __init__(
         show_progress_bar: bool = False,
     ) -> None:
         super().__init__()
-        if surrogate_data.hyperconfig is None:
+        if surrogate_data.hyperconfig_access is None:
             raise ValueError("No hyperoptimization configuration found.")
         self.surrogate_data = surrogate_data
         self.training_data = training_data
@@ -30,11 +30,11 @@ def __init__(
 
     @property
     def domain(self) -> Domain:
-        return self.surrogate_data.hyperconfig.domain  # type: ignore
+        return self.surrogate_data.hyperconfig_access.domain  # type: ignore
 
     @property
     def target_metric(self):
-        return self.surrogate_data.hyperconfig.target_metric  # type: ignore
+        return self.surrogate_data.hyperconfig_access.target_metric  # type: ignore
 
     def _f(self, candidates: pd.DataFrame) -> pd.DataFrame:
         for i, candidate in tqdm(

bofire/data_models/surrogates/bnn.py

@@ -1,8 +1,31 @@
-from typing import Literal
+from typing import Literal, Optional, Type
 
+from pydantic import Field
+
+from bofire.data_models.features.api import AnyOutput
+from bofire.data_models.features.continuous import ContinuousOutput
 from bofire.data_models.kernels.api import InfiniteWidthBNNKernel
-from bofire.data_models.surrogates.single_task_gp import BaseSingleTaskGPSurrogate
+from bofire.data_models.priors.api import HVARFNER_NOISE_PRIOR, AnyPrior
+from bofire.data_models.surrogates.single_task_gp import TrainableBotorchSurrogate
+from bofire.data_models.surrogates.trainable import Hyperconfig
 
 
-class SingleTaskIBNNSurrogate(BaseSingleTaskGPSurrogate[InfiniteWidthBNNKernel]):
+class SingleTaskIBNNSurrogate(TrainableBotorchSurrogate):
     type: Literal["SingleTaskIBNNSurrogate"] = "SingleTaskIBNNSurrogate"
+    kernel: InfiniteWidthBNNKernel = InfiniteWidthBNNKernel()
+    hyperconfig: Optional[Hyperconfig] = None
+    noise_prior: AnyPrior = Field(default_factory=lambda: HVARFNER_NOISE_PRIOR())
+
+    @classmethod
+    def is_output_implemented(cls, my_type: Type[AnyOutput]) -> bool:
+        """Abstract method to check output type for surrogate models
+        Args:
+            my_type: continuous or categorical output
+        Returns:
+            bool: True if the output type is valid for the surrogate chosen, False otherwise
+        """
+        return isinstance(my_type, type(ContinuousOutput))
+
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig

bofire/data_models/surrogates/fully_bayesian.py

@@ -1,4 +1,4 @@
-from typing import Annotated, List, Literal, Type
+from typing import Annotated, List, Literal, Optional, Type
 
 from pydantic import AfterValidator, Field, field_validator, model_validator
 
@@ -8,7 +8,7 @@
 from bofire.data_models.types import make_unique_validator
 
 
-class FullyBayesianSingleTaskGPSurrogate(TrainableBotorchSurrogate[Hyperconfig]):
+class FullyBayesianSingleTaskGPSurrogate(TrainableBotorchSurrogate):
     type: Literal["FullyBayesianSingleTaskGPSurrogate"] = (
         "FullyBayesianSingleTaskGPSurrogate"
     )
@@ -20,6 +20,12 @@ class FullyBayesianSingleTaskGPSurrogate(TrainableBotorchSurrogate[Hyperconfig])
         List[str], AfterValidator(make_unique_validator("Features"))
     ] = []
 
+    hyperconfig: Optional[Hyperconfig] = None
+
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig
+
     @model_validator(mode="after")
     def validate_features_to_warp(self):
         input_keys = self.inputs.get_keys()

bofire/data_models/surrogates/linear.py

@@ -1,4 +1,4 @@
-from typing import Literal, Type
+from typing import Literal, Optional, Type
 
 from pydantic import Field
 
@@ -7,12 +7,19 @@
 from bofire.data_models.kernels.api import LinearKernel
 from bofire.data_models.priors.api import THREESIX_NOISE_PRIOR, AnyPrior
 from bofire.data_models.surrogates.scaler import ScalerEnum
+from bofire.data_models.surrogates.trainable import Hyperconfig
 from bofire.data_models.surrogates.trainable_botorch import TrainableBotorchSurrogate
 
 
 class LinearSurrogate(TrainableBotorchSurrogate):
     type: Literal["LinearSurrogate"] = "LinearSurrogate"
 
+    hyperconfig: Optional[Hyperconfig] = None
+
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig
+
     kernel: LinearKernel = Field(default_factory=lambda: LinearKernel())
     noise_prior: AnyPrior = Field(default_factory=lambda: THREESIX_NOISE_PRIOR())
     scaler: ScalerEnum = ScalerEnum.NORMALIZE

bofire/data_models/surrogates/map_saas.py

@@ -1,6 +1,6 @@
-from typing import Literal, Type
+from typing import Literal, Optional, Type
 
-from pydantic import PositiveInt
+from pydantic import Field, PositiveInt
 
 from bofire.data_models.features.api import AnyOutput, ContinuousOutput
 from bofire.data_models.surrogates.trainable import Hyperconfig
@@ -11,7 +11,7 @@ class TestSurrogate:
     pass
 
 
-class AdditiveMapSaasSingleTaskGPSurrogate(TrainableBotorchSurrogate[Hyperconfig]):
+class AdditiveMapSaasSingleTaskGPSurrogate(TrainableBotorchSurrogate):
     """Additive MAP SAAS single-task GP
 
     Maximum-a-posteriori (MAP) version of the sparse axis-aligned subspace
@@ -26,6 +26,12 @@ class AdditiveMapSaasSingleTaskGPSurrogate(TrainableBotorchSurrogate[Hyperconfig
     )
     n_taus: PositiveInt = 4
 
+    hyperconfig: Optional[Hyperconfig] = Field(default=None)
+
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig
+
     @classmethod
     def is_output_implemented(cls, my_type: Type[AnyOutput]) -> bool:
         """Abstract method to check output type for surrogate models

bofire/data_models/surrogates/mixed_single_task_gp.py

@@ -55,9 +55,7 @@ class MixedSingleTaskGPHyperconfig(Hyperconfig):
     ] = "FractionalFactorialStrategy"
 
 
-class MixedSingleTaskGPSurrogate(
-    TrainableBotorchSurrogate[MixedSingleTaskGPHyperconfig]
-):
+class MixedSingleTaskGPSurrogate(TrainableBotorchSurrogate):
     type: Literal["MixedSingleTaskGPSurrogate"] = "MixedSingleTaskGPSurrogate"
     continuous_kernel: AnyContinuousKernel = Field(
         default_factory=lambda: RBFKernel(
@@ -76,6 +74,10 @@ class MixedSingleTaskGPSurrogate(
         default_factory=lambda: MixedSingleTaskGPHyperconfig(),
     )
 
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig
+
     @classmethod
     def _default_categorical_encodings(
         cls,
@@ -145,8 +147,7 @@ def is_output_implemented(cls, my_type: Type[AnyOutput]) -> bool:
             bool: True if the output type is valid for the surrogate chosen, False otherwise
         """
         return isinstance(my_type, type(ContinuousOutput))
-    
-    
+
     def update_hyperparameters(
         self,
         hyperparameters: pd.Series,
@@ -194,4 +195,3 @@ def update_hyperparameters(
 
         else:
             raise ValueError(f"Kernel {hyperparameters.kernel} not known.")
-

bofire/data_models/surrogates/mlp.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import Annotated, Literal, Type
+from typing import Annotated, Literal, Optional, Type
 
 from pydantic import Field
 
@@ -9,11 +9,18 @@
     ContinuousOutput,
 )
 from bofire.data_models.surrogates.scaler import ScalerEnum
+from bofire.data_models.surrogates.trainable import Hyperconfig
 from bofire.data_models.surrogates.trainable_botorch import TrainableBotorchSurrogate
 
 
 class MLPEnsemble(TrainableBotorchSurrogate):
     type: Literal["MLPEnsemble"] = "MLPEnsemble"
+    hyperconfig: Optional[Hyperconfig] = None
+
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig
+
     n_estimators: Annotated[int, Field(ge=1)] = 5
     hidden_layer_sizes: Sequence = (100,)
     activation: Literal["relu", "logistic", "tanh"] = "relu"

bofire/data_models/surrogates/multi_task_gp.py

@@ -45,7 +45,7 @@ class MultiTaskGPHyperconfig(Hyperconfig):
     ] = "FractionalFactorialStrategy"
 
 
-class MultiTaskGPSurrogate(TrainableBotorchSurrogate[MultiTaskGPHyperconfig]):
+class MultiTaskGPSurrogate(TrainableBotorchSurrogate):
     type: Literal["MultiTaskGPSurrogate"] = "MultiTaskGPSurrogate"
     kernel: AnyKernel = Field(
         default_factory=lambda: MaternKernel(
@@ -60,6 +60,10 @@ class MultiTaskGPSurrogate(TrainableBotorchSurrogate[MultiTaskGPHyperconfig]):
         default_factory=lambda: MultiTaskGPHyperconfig(),
     )
 
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig
+
     @classmethod
     def _default_categorical_encodings(
         cls,
@@ -118,7 +122,7 @@ def validate_encoding(cls, v, info):
     def update_hyperparameters(
         self,
         hyperparameters: pd.Series,
-    ):    
+    ):
         super().update_hyperparameters(hyperparameters)
 
         def matern_25(ard: bool, lengthscale_prior: AnyPrior) -> MaternKernel:

bofire/data_models/surrogates/polynomial.py

@@ -1,16 +1,22 @@
-from typing import Literal, Type
+from typing import Literal, Optional, Type
 
 from pydantic import Field
 
 from bofire.data_models.domain.api import Inputs, Outputs
 from bofire.data_models.features.api import AnyOutput, ContinuousOutput
 from bofire.data_models.kernels.api import PolynomialKernel
 from bofire.data_models.priors.api import THREESIX_NOISE_PRIOR, AnyPrior
+from bofire.data_models.surrogates.trainable import Hyperconfig
 from bofire.data_models.surrogates.trainable_botorch import TrainableBotorchSurrogate
 
 
 class PolynomialSurrogate(TrainableBotorchSurrogate):
     type: Literal["PolynomialSurrogate"] = "PolynomialSurrogate"
+    hyperconfig: Optional[Hyperconfig] = None
+
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig
 
     kernel: PolynomialKernel = Field(default_factory=lambda: PolynomialKernel(power=2))
     noise_prior: AnyPrior = Field(default_factory=lambda: THREESIX_NOISE_PRIOR())

bofire/data_models/surrogates/random_forest.py

@@ -7,9 +7,15 @@
 from bofire.data_models.surrogates.trainable_botorch import TrainableBotorchSurrogate
 
 
-class RandomForestSurrogate(TrainableBotorchSurrogate[Hyperconfig]):
+class RandomForestSurrogate(TrainableBotorchSurrogate):
     type: Literal["RandomForestSurrogate"] = "RandomForestSurrogate"
 
+    hyperconfig: Optional[Hyperconfig] = None
+
+    @property
+    def hyperconfig_access(self) -> Optional[Hyperconfig]:
+        return self.hyperconfig
+
     # hyperparams passed down to `RandomForestRegressor`
     n_estimators: int = 100
     criterion: Literal[