BoFire Refactoring

[jduerholt]

BoFire - refactoring

In the last 2 weeks, mainly @evo-bschiller performed a major refactoring of the whole bofire code base and also wrote this documentation. Our goal was to improve the overall structure, readability, and usability of bofire's components. Most importantly, we separated data models from functionality.

In the following, we list the most important changes:

• renamed Model to Surrogate
• added a common base class for all data models (bofire.data_models.base.DataModel)
• moved all (pydantic) data models to bofire.data_models.<entity>
  • each entity is defined in its own package, e.g.: domain, kernels, features, objectives
  • entity subclasses are moved to their own module
  • each entity provides all relevant imports via api.py
• moved functionality from data models of surrogates and strategies to
  • bofire.surrogates
  • bofire.strategies
  • all relevant imports are provided via api.py
• AnyX type unions are available from bofire.data_models.api
  • also from bofire.data_model.<entity>.api

data models vs. functional components

All data models in bofire.data_models, are specified as pydantic models and inherit from bofire.data_models.base.BaseModel. These data models can be (de)serialized via .dict() and .json() (provided by pydantic). A json schema of each data model can be obtained using .schema().

The data models of most entities have not been changed. We only moved their definitions to the respective package in bofire.data_models.<entity>, split the class definitions into multiple modules, and added api.py.

For surrogates and strategies, we removed the functional parts from the data models and moved them to bofire.surrogates and bofire.strategies. These functionalities include the ask and tell as well as fit and predict methods. All class attributes (used by these method) are also removed from the data models. Each functional entity is initialized using the corresponding data model. As an example, consider the following data model of a RandomStrategy:

import bofire.data_models.domain.api as dm_domain
import bofire.data_models.features.api as dm_features
import bofire.data_models.strategies.api as dm_strategies

in1 = dm_features.ContinuousInput(key="in1", lower_bound=0.0, upper_bound=1.0)
in2 = dm_features.ContinuousInput(key="in2", lower_bound=0.0, upper_bound=2.0)
in3 = dm_features.ContinuousInput(key="in3", lower_bound=0.0, upper_bound=3.0)

out1 = dm_features.ContinuousOutput(key="out1")

input_features = dm_domain.Inputs(features=[in1, in2, in3])
output_features = dm_domain.Outputs(features=[out1])
constraints = dm_domain.Constraints()

domain = dm_domain.Domain(
    input_features=input_features,
    output_features=output_features,
    constraints=constraints,
)

data_model = dm_strategies.RandomStrategy(domain=domain)

Such a data model can be (de)serialized as follows:

import json
from pydantic import parse_obj_as
from bofire.data_models.strategies.api import AnyStrategy

serialized = data_model.json()
data = json.loads(serialized)
# alternative: data = data_model.dict()
data_model_ = parse_obj_as(AnyStrategy, data)
assert data_model_ == data_model

Using this data model of a strategy, we can create an instance of a (functional) strategy:

import bofire.strategies.api as strategies
strategy = strategies.RandomStrategy(data_model=data_model)

As each strategy data model should be mapped to a specific (functional) strategy, we provide such a mapping:

strategy = strategies.map(data_model)

Surrogates (formerly known as models) have been split in the same manner into data models (bofire.data_models.surrogates) and functional components (bofire.surrogates).