ennbo 0.1.2__py3-none-any.whl → 0.1.7__py3-none-any.whl

enn/turbo/morbo_trust_region.py

@@ -2,47 +2,60 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from .tr_helpers import ScalarIncumbentMixin
+
 if TYPE_CHECKING:
     import numpy as np
     from numpy.random import Generator
     from scipy.stats._qmc import QMCEngine
 
-from .turbo_trust_region import TurboTrustRegion
+    from .config.morbo_tr_config import MorboTRConfig
+    from .config.rescalarize import Rescalarize
+
+from .config.enums import CandidateRV, RAASPDriver
 
 
-class MorboTrustRegion:
+class MorboTrustRegion(ScalarIncumbentMixin):
     def __init__(
         self,
+        config: MorboTRConfig,
         num_dim: int,
-        num_arms: int,
-        num_metrics: int,
         *,
         rng: Generator,
+        candidate_rv: CandidateRV = CandidateRV.SOBOL,
     ) -> None:
-        import numpy as np
-
-        self._tr = TurboTrustRegion(num_dim=num_dim, num_arms=num_arms)
+        from .components.incumbent_selector import ChebyshevIncumbentSelector
+        from .config.turbo_tr_config import TurboTRConfig
+        from .turbo_trust_region import TurboTrustRegion
+
+        self._config = config
+        self._candidate_rv = candidate_rv
+        inner_config = TurboTRConfig(length=config.length)
+        self._tr = TurboTrustRegion(
+            config=inner_config,
+            num_dim=num_dim,
+        )
         self._num_dim = int(num_dim)
-        self._num_arms = int(num_arms)
-        self._num_metrics = int(num_metrics)
+        self._num_metrics = int(config.num_metrics)
         if self._num_metrics <= 0:
             raise ValueError(self._num_metrics)
-
-        alpha = np.ones(self._num_metrics, dtype=float)
-        self._weights = np.asarray(rng.dirichlet(alpha), dtype=float)
-        self._alpha = 0.05
-
+        self._alpha = float(config.alpha)
+        self._rescalarize = config.rescalarize
+        self.incumbent_selector = ChebyshevIncumbentSelector(
+            num_metrics=self._num_metrics,
+            alpha=self._alpha,
+            noise_aware=config.noise_aware,
+        )
+        self.incumbent_selector.reset(rng)
+        self._weights = self.incumbent_selector.weights
         self._y_min: np.ndarray | Any | None = None
         self._y_max: np.ndarray | Any | None = None
+        self._incumbent_y_raw: np.ndarray | None = None
 
     @property
     def num_dim(self) -> int:
         return self._num_dim
 
-    @property
-    def num_arms(self) -> int:
-        return self._num_arms
-
     @property
     def num_metrics(self) -> int:
         return self._num_metrics
@@ -55,68 +68,62 @@ class MorboTrustRegion:
     def length(self) -> float:
         return float(self._tr.length)
 
-    def update(self, values: np.ndarray | Any) -> None:
-        raise NotImplementedError(
-            "Use update_xy(x_obs, y_obs) with multi-objective observations."
-        )
+    @property
+    def rescalarize(self) -> Rescalarize:
+        return self._rescalarize
+
+    def resample_weights(self, rng: Generator) -> None:
+        self.incumbent_selector.reset(rng)
+        self._weights = self.incumbent_selector.weights
 
-    def update_xy(
-        self, x_obs: np.ndarray | Any, y_obs: np.ndarray | Any, *, k: Any = None
-    ) -> None:  # noqa: ARG002
+    def _update_ranges(self, y_obs):
+        self._y_min, self._y_max = y_obs.min(axis=0), y_obs.max(axis=0)
+
+    def update(self, y_obs: np.ndarray | Any, y_incumbent: np.ndarray | Any) -> None:
         import numpy as np
 
-        x_obs = np.asarray(x_obs, dtype=float)
         y_obs = np.asarray(y_obs, dtype=float)
-
-        if x_obs.ndim != 2 or x_obs.shape[1] != self._num_dim:
-            raise ValueError(x_obs.shape)
-        if y_obs.ndim != 2 or y_obs.shape[0] != x_obs.shape[0]:
-            raise ValueError((x_obs.shape, y_obs.shape))
-        if y_obs.shape[1] != self._num_metrics:
+        if y_obs.ndim != 2 or y_obs.shape[1] != self._num_metrics:
             raise ValueError((y_obs.shape, self._num_metrics))
-
-        n = int(x_obs.shape[0])
+        n = int(y_obs.shape[0])
         if n == 0:
-            self._y_min = None
-            self._y_max = None
+            self._y_min, self._y_max = None, None
+            self._incumbent_y_raw = None
             self._tr.restart()
             return
-
         prev_n = int(self._tr.prev_num_obs)
         if n < prev_n:
             raise ValueError((n, prev_n))
-
-        y_min_all = y_obs.min(axis=0)
-        y_max_all = y_obs.max(axis=0)
-        y_min_prev = y_obs[:prev_n].min(axis=0) if prev_n > 0 else y_min_all
-        y_max_prev = y_obs[:prev_n].max(axis=0) if prev_n > 0 else y_max_all
-
-        self._y_min = y_min_all
-        self._y_max = y_max_all
-
+        self._y_min, self._y_max = y_obs.min(axis=0), y_obs.max(axis=0)
+        y_incumbent = np.asarray(y_incumbent, dtype=float).reshape(1, -1)
+        if y_incumbent.shape != (1, self._num_metrics):
+            raise ValueError(
+                f"y_incumbent must have shape (1, {self._num_metrics}), got {y_incumbent.shape}"
+            )
         if prev_n == 0:
-            values = np.asarray(self.scalarize(y_obs, clip=True), dtype=float)
-            if values.shape != (n,):
-                raise RuntimeError((values.shape, n))
-            self._tr.update(values)
+            self._handle_initial_update(y_incumbent, n)
             return
-
-        if not np.isfinite(self._tr.best_value):
-            raise RuntimeError(self._tr.best_value)
-
-        values_old = self._scalarize_with_ranges(
-            y_obs, y_min=y_min_prev, y_max=y_max_prev, clip=True
-        )
-        values_old = np.asarray(values_old, dtype=float)
-        if values_old.shape != (n,):
-            raise RuntimeError((values_old.shape, n))
-
-        incumbent_old = float(np.max(values_old[:prev_n]))
-        self._tr.best_value = incumbent_old
-        if prev_n == n:
+        if self._incumbent_y_raw is None:
+            self._handle_initial_update(y_incumbent, n)
             return
+        scores = self.scalarize(
+            np.vstack([self._incumbent_y_raw, y_incumbent]), clip=True
+        )
+        old_score = float(scores[0])
+        new_score = float(scores[1])
+        self._tr.best_value = old_score
+        dummy_y_obs = np.zeros((n, 1))
+        self._tr.update(dummy_y_obs, np.array([new_score]))
+        if new_score > old_score:
+            self._incumbent_y_raw = y_incumbent.copy()
+
+    def _handle_initial_update(self, y_incumbent: np.ndarray, n: int) -> None:
+        import numpy as np
 
-        self._tr.update(values_old)
+        self._incumbent_y_raw = y_incumbent.copy()
+        score = self.scalarize(y_incumbent, clip=True)
+        dummy_y_obs = np.zeros((n, 1))
+        self._tr.update(dummy_y_obs, score)
 
     def scalarize(self, y: np.ndarray | Any, *, clip: bool) -> np.ndarray:
         import numpy as np
@@ -126,7 +133,6 @@ class MorboTrustRegion:
             raise ValueError(y.shape)
         if self._y_min is None or self._y_max is None:
             raise RuntimeError("scalarize called before any observations")
-
         return self._scalarize_with_ranges(
             y, y_min=self._y_min, y_max=self._y_max, clip=clip
         )
@@ -148,7 +154,6 @@ class MorboTrustRegion:
         y_max = np.asarray(y_max, dtype=float).reshape(-1)
         if y_min.shape != (self._num_metrics,) or y_max.shape != (self._num_metrics,):
             raise ValueError((y_min.shape, y_max.shape, self._num_metrics))
-
         denom = y_max - y_min
         is_deg = denom <= 0.0
         denom_safe = np.where(is_deg, 1.0, denom)
@@ -163,10 +168,15 @@ class MorboTrustRegion:
     def needs_restart(self) -> bool:
         return self._tr.needs_restart()
 
-    def restart(self) -> None:
+    def restart(self, rng: Generator | None = None) -> None:
+        from .config.rescalarize import Rescalarize
+
         self._y_min = None
         self._y_max = None
+        self._incumbent_y_raw = None
         self._tr.restart()
+        if rng is not None and self._rescalarize == Rescalarize.ON_RESTART:
+            self.resample_weights(rng)
 
     def validate_request(self, num_arms: int, *, is_fallback: bool = False) -> None:
         return self._tr.validate_request(num_arms, is_fallback=is_fallback)
@@ -183,7 +193,58 @@ class MorboTrustRegion:
         num_candidates: int,
         rng: Generator,
         sobol_engine: QMCEngine,
+        raasp_driver: RAASPDriver = RAASPDriver.ORIG,
+        num_pert: int = 20,
     ) -> np.ndarray:
-        return self._tr.generate_candidates(
-            x_center, lengthscales, num_candidates, rng, sobol_engine
+        from .tr_helpers import generate_tr_candidates
+
+        return generate_tr_candidates(
+            self._tr.compute_bounds_1d,
+            x_center,
+            lengthscales,
+            num_candidates,
+            rng=rng,
+            candidate_rv=self._candidate_rv,
+            sobol_engine=sobol_engine,
+            raasp_driver=raasp_driver,
+            num_pert=num_pert,
         )
+
+    def get_incumbent_indices(
+        self,
+        y: np.ndarray | Any,
+        rng: Generator,
+    ) -> np.ndarray:
+        import numpy as np
+
+        y = np.asarray(y, dtype=float)
+        if y.ndim != 2:
+            raise ValueError(y.shape)
+        n = y.shape[0]
+        if n == 0:
+            return np.array([], dtype=int)
+        from nds import ndomsort
+
+        idx_front = np.array(ndomsort.non_domin_sort(-y, only_front_indices=True))
+        return np.where(idx_front == 0)[0]
+
+    def get_incumbent_value(
+        self,
+        y_obs: np.ndarray | Any,
+        rng: Generator,
+        mu_obs: np.ndarray | None = None,
+    ) -> np.ndarray:
+        import numpy as np
+
+        y_obs = np.asarray(y_obs, dtype=float)
+        if y_obs.ndim != 2 or y_obs.shape[1] != self._num_metrics:
+            raise ValueError((y_obs.shape, self._num_metrics))
+        n = int(y_obs.shape[0])
+        if n == 0:
+            return np.array([], dtype=float)
+        idx = self.get_incumbent_index(y_obs, rng, mu=mu_obs)
+        use_mu = bool(getattr(self.incumbent_selector, "noise_aware", False))
+        values = np.asarray(mu_obs if use_mu else y_obs, dtype=float)
+        if values.ndim != 2 or values.shape[1] != self._num_metrics:
+            raise ValueError((values.shape, self._num_metrics))
+        return values[idx : idx + 1].copy()

enn/turbo/no_trust_region.py

@@ -1,65 +1,58 @@
 from __future__ import annotations
-
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
+from .tr_helpers import ScalarIncumbentMixin
 
 if TYPE_CHECKING:
     import numpy as np
-    from numpy.random import Generator
-    from scipy.stats._qmc import QMCEngine
+    from .components.incumbent_selector import IncumbentSelector
+    from .config.no_tr_config import NoTRConfig
 
 
 @dataclass
-class NoTrustRegion:
+class NoTrustRegion(ScalarIncumbentMixin):
+    config: NoTRConfig
     num_dim: int
-    num_arms: int
-    length: float = 1.0
+    incumbent_selector: IncumbentSelector = field(default=None, repr=False)
+    length: float = field(default=1.0, init=False)
+
+    def __post_init__(self) -> None:
+        from .components.incumbent_selector import ScalarIncumbentSelector
+
+        if self.incumbent_selector is None:
+            self.incumbent_selector = ScalarIncumbentSelector(noise_aware=False)
+
+    @property
+    def num_metrics(self) -> int:
+        return 1
 
-    def update(self, values: np.ndarray | Any) -> None:
+    def update(self, y_obs: np.ndarray | Any, y_incumbent: np.ndarray | Any) -> None:
         return
 
     def needs_restart(self) -> bool:
         return False
 
-    def restart(self) -> None:
+    def restart(self, rng=None) -> None:
         return
 
     def validate_request(self, num_arms: int, *, is_fallback: bool = False) -> None:
-        if is_fallback:
-            if num_arms > self.num_arms:
-                raise ValueError(
-                    f"num_arms {num_arms} > configured num_arms {self.num_arms}"
-                )
-        else:
-            if num_arms != self.num_arms:
-                raise ValueError(
-                    f"num_arms {num_arms} != configured num_arms {self.num_arms}"
-                )
+        pass
 
     def compute_bounds_1d(
-        self, x_center: np.ndarray | Any, lengthscales: np.ndarray | None = None
+        self,
+        x_center: np.ndarray | Any,
+        lengthscales: np.ndarray | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
-        import numpy as np
+        from .tr_helpers import compute_full_box_bounds_1d
 
-        lb = np.zeros_like(x_center, dtype=float)
-        ub = np.ones_like(x_center, dtype=float)
-        return lb, ub
+        return compute_full_box_bounds_1d(x_center)
 
-    def generate_candidates(
+    def get_incumbent_indices(
         self,
-        x_center: np.ndarray,
-        lengthscales: np.ndarray | None,
-        num_candidates: int,
-        rng: Generator,
-        sobol_engine: QMCEngine,
+        y: np.ndarray | Any,
+        rng,
+        mu: np.ndarray | None = None,
     ) -> np.ndarray:
-        from .turbo_utils import generate_trust_region_candidates
+        import numpy as np
 
-        return generate_trust_region_candidates(
-            x_center,
-            lengthscales,
-            num_candidates,
-            compute_bounds_1d=self.compute_bounds_1d,
-            rng=rng,
-            sobol_engine=sobol_engine,
-        )
+        return np.array([self.get_incumbent_index(y, rng, mu=mu)])

enn/turbo/optimizer.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from . import turbo_optimizer_utils, turbo_utils
+from .components import AcquisitionOptimizer, Surrogate
+from .config.enums import CandidateRV
+from .strategies import OptimizationStrategy
+from .types.appendable_array import AppendableArray
+
+if TYPE_CHECKING:
+    from numpy.random import Generator
+
+    from .config.optimizer_config import OptimizerConfig
+
+
+class Optimizer:
+    def __init__(
+        self,
+        *,
+        bounds: np.ndarray,
+        config: OptimizerConfig,
+        rng: Generator,
+        surrogate: Surrogate,
+        acquisition_optimizer: AcquisitionOptimizer,
+        strategy: OptimizationStrategy | None = None,
+    ) -> None:
+        self._config = config
+        bounds = np.asarray(bounds, dtype=float)
+        if bounds.ndim != 2 or bounds.shape[1] != 2:
+            raise ValueError(f"bounds must be (d, 2), got {bounds.shape}")
+        self._bounds = bounds
+        self._num_dim = bounds.shape[0]
+        self._rng = rng
+        self._surrogate = surrogate
+        self._acq_optimizer = acquisition_optimizer
+        self._strategy = (
+            strategy
+            if strategy is not None
+            else config.init.init_strategy.create_runtime_strategy(
+                bounds=self._bounds, rng=self._rng, num_init=config.init.num_init
+            )
+        )
+        self._tr_state = config.trust_region.build(
+            num_dim=self._num_dim,
+            rng=rng,
+            candidate_rv=config.candidate_rv,
+        )
+        self._trailing_obs = (
+            None if config.trailing_obs is None else int(config.trailing_obs)
+        )
+        self._gp_num_steps = 50
+        if self._trailing_obs is not None and self._trailing_obs <= 0:
+            raise ValueError(f"trailing_obs must be > 0, got {self._trailing_obs}")
+        self._x_obs = AppendableArray()
+        self._y_obs = AppendableArray()
+        self._yvar_obs = AppendableArray()
+        self._y_tr_list: list[float] | list[list[float]] = []
+        self._expects_yvar: bool | None = None
+        self._dt_fit = 0.0
+        self._dt_gen = 0.0
+        self._dt_sel = 0.0
+        self._dt_tell = 0.0
+        self._sobol_seed_base = int(rng.integers(2**31 - 1))
+        self._restart_generation = 0
+        self._incumbent_idx: int | None = None
+        self._incumbent_x_unit: np.ndarray | None = None
+        self._incumbent_y_scalar: np.ndarray | None = None
+
+    @property
+    def tr_obs_count(self) -> int:
+        return len(self._y_obs)
+
+    @property
+    def tr_length(self) -> float:
+        return float(self._tr_state.length)
+
+    def telemetry(self) -> turbo_utils.Telemetry:
+        return turbo_utils.Telemetry(
+            dt_fit=self._dt_fit,
+            dt_gen=self._dt_gen,
+            dt_sel=self._dt_sel,
+            dt_tell=self._dt_tell,
+        )
+
+    @property
+    def init_progress(self) -> tuple[int, int] | None:
+        return self._strategy.init_progress()
+
+    def ask(self, num_arms: int) -> np.ndarray:
+        num_arms = int(num_arms)
+        if num_arms <= 0:
+            raise ValueError(num_arms)
+        turbo_optimizer_utils.reset_timing(self)
+        return self._strategy.ask(self, num_arms)
+
+    def _ask_normal(self, num_arms: int, *, is_fallback: bool = False) -> np.ndarray:
+        self._tr_state.validate_request(num_arms, is_fallback=is_fallback)
+        self._maybe_resample_weights()
+        x_center = self._incumbent_x_unit
+        if x_center is None:
+            if len(self._y_obs) == 0:
+                raise RuntimeError("no observations")
+            x_center = np.full(self._num_dim, 0.5)
+        t0 = time.perf_counter()
+        lengthscales = self._surrogate.lengthscales
+        x_cand = self._generate_candidates(x_center, lengthscales, num_arms=num_arms)
+        self._dt_gen = time.perf_counter() - t0
+        t0 = time.perf_counter()
+        selected = self._acq_optimizer.select(
+            x_cand,
+            num_arms,
+            self._surrogate,
+            self._rng,
+            tr_state=self._tr_state,
+        )
+        self._dt_sel = time.perf_counter() - t0
+        return turbo_utils.from_unit(selected, self._bounds)
+
+    def _find_x_center(self, x_obs: np.ndarray, y_obs: np.ndarray) -> np.ndarray | None:
+        return self._incumbent_x_unit
+
+    def _maybe_resample_weights(self) -> None:
+        from .config.rescalarize import Rescalarize
+
+        if hasattr(self._tr_state, "rescalarize"):
+            if self._tr_state.rescalarize == Rescalarize.ON_PROPOSE:
+                self._tr_state.resample_weights(self._rng)
+
+    def _generate_candidates(
+        self,
+        x_center: np.ndarray,
+        lengthscales: np.ndarray | None,
+        *,
+        num_arms: int,
+    ) -> np.ndarray:
+        from . import tr_helpers
+
+        if lengthscales is not None:
+            lengthscales = np.asarray(lengthscales, dtype=float).reshape(-1)
+            if not np.all(np.isfinite(lengthscales)):
+                raise ValueError("lengthscales must be finite")
+        num_candidates = int(
+            self._config.candidates.num_candidates(
+                num_dim=self._num_dim, num_arms=num_arms
+            )
+        )
+        if num_candidates <= 0:
+            raise ValueError(num_candidates)
+        candidate_rv = self._config.candidate_rv
+        if candidate_rv == CandidateRV.SOBOL:
+            from scipy.stats import qmc
+
+            sobol_seed = turbo_optimizer_utils.sobol_seed_for_state(
+                self._sobol_seed_base,
+                restart_generation=self._restart_generation,
+                n_obs=len(self._x_obs),
+                num_arms=num_arms,
+            )
+            sobol_engine = qmc.Sobol(d=self._num_dim, scramble=True, seed=sobol_seed)
+        else:
+            sobol_engine = None
+        if getattr(self._tr_state, "uses_custom_candidate_gen", False):
+            return self._tr_state.generate_candidates(
+                x_center,
+                lengthscales,
+                num_candidates,
+                rng=self._rng,
+                sobol_engine=sobol_engine,
+                raasp_driver=self._config.raasp_driver,
+                num_pert=20,
+            )
+        return tr_helpers.generate_tr_candidates(
+            self._tr_state.compute_bounds_1d,
+            x_center,
+            lengthscales,
+            num_candidates,
+            rng=self._rng,
+            candidate_rv=candidate_rv,
+            sobol_engine=sobol_engine,
+            raasp_driver=self._config.raasp_driver,
+            num_pert=20,
+        )
+
+    def _validate_tell_inputs(
+        self, x: np.ndarray, y: np.ndarray, y_var: np.ndarray | None
+    ) -> turbo_optimizer_utils.TellInputs:
+        inputs = turbo_optimizer_utils.validate_tell_inputs(x, y, y_var, self._num_dim)
+        tr_num_metrics = getattr(self._tr_state, "num_metrics", 1)
+        if inputs.num_metrics != tr_num_metrics:
+            raise ValueError(
+                f"y has {inputs.num_metrics} metrics but trust region expects {tr_num_metrics}"
+            )
+        if self._expects_yvar is None:
+            self._expects_yvar = inputs.y_var is not None
+        if (inputs.y_var is not None) != bool(self._expects_yvar):
+            raise ValueError(
+                f"y_var must be {'provided' if self._expects_yvar else 'omitted'} on every tell()"
+            )
+        return inputs
+
+    def _update_incumbent(self) -> None:
+        if len(self._y_obs) == 0:
+            self._incumbent_idx = None
+            self._incumbent_x_unit = None
+            self._incumbent_y_scalar = None
+            return
+        x_obs = self._x_obs.view()
+        y_obs = self._y_obs.view()
+        candidate_indices = self._surrogate.get_incumbent_candidate_indices(y_obs)
+        x_cand = x_obs[candidate_indices]
+        y_cand = y_obs[candidate_indices]
+        mu_cand = None
+        noise_aware = False
+        if hasattr(self._tr_state, "incumbent_selector"):
+            noise_aware = getattr(
+                self._tr_state.incumbent_selector, "noise_aware", False
+            )
+        elif hasattr(self._tr_state, "config"):
+            noise_aware = getattr(self._tr_state.config, "noise_aware", False)
+        if noise_aware:
+            try:
+                mu_cand = self._surrogate.predict(x_cand).mu
+            except RuntimeError:
+                mu_cand = None
+        idx_in_cand = self._tr_state.get_incumbent_index(y_cand, self._rng, mu=mu_cand)
+        self._incumbent_idx = int(candidate_indices[idx_in_cand])
+        self._incumbent_x_unit = x_obs[self._incumbent_idx]
+        if noise_aware and mu_cand is not None:
+            self._incumbent_y_scalar = mu_cand[idx_in_cand : idx_in_cand + 1].copy()
+        else:
+            self._incumbent_y_scalar = y_cand[idx_in_cand : idx_in_cand + 1].copy()
+
+    def _trim_trailing_obs(self) -> None:
+        incumbent_indices = np.array([self._incumbent_idx], dtype=int)
+        obs = turbo_optimizer_utils.trim_trailing_observations(
+            self._x_obs.view().tolist(),
+            self._y_obs.view().tolist(),
+            self._y_tr_list,
+            self._yvar_obs.view().tolist() if len(self._yvar_obs) > 0 else [],
+            trailing_obs=self._trailing_obs,
+            incumbent_indices=incumbent_indices,
+        )
+        self._x_obs = AppendableArray()
+        for x in obs.x_obs:
+            self._x_obs.append(np.array(x))
+        self._y_obs = AppendableArray()
+        for y in obs.y_obs:
+            self._y_obs.append(np.array(y))
+        self._yvar_obs = AppendableArray()
+        if obs.yvar_obs:
+            for yvar in obs.yvar_obs:
+                self._yvar_obs.append(np.array(yvar))
+        self._y_tr_list = obs.y_tr
+
+    def _update_best_value_if_needed(self) -> None:
+        pass
+
+    def tell(
+        self, x: np.ndarray, y: np.ndarray, y_var: np.ndarray | None = None
+    ) -> np.ndarray:
+        with turbo_utils.record_duration(
+            lambda dt: setattr(self, "_dt_tell", float(dt))
+        ):
+            inputs = self._validate_tell_inputs(x, y, y_var)
+            if inputs.x.shape[0] == 0:
+                return (
+                    np.array([], dtype=float)
+                    if inputs.num_metrics == 1
+                    else np.empty((0, inputs.num_metrics), dtype=float)
+                )
+            x_unit = turbo_utils.to_unit(inputs.x, self._bounds)
+            for i in range(inputs.x.shape[0]):
+                self._x_obs.append(x_unit[i])
+                self._y_obs.append(inputs.y[i])
+                if inputs.y_var is not None:
+                    self._yvar_obs.append(inputs.y_var[i])
+            return self._strategy.tell(self, inputs, x_unit=x_unit)
+
+
+def create_optimizer(
+    *,
+    bounds: np.ndarray,
+    config: OptimizerConfig,
+    rng: Generator,
+) -> Optimizer:
+    from .components.builder import build_acquisition_optimizer, build_surrogate
+
+    surrogate = build_surrogate(config)
+    acq_optimizer = build_acquisition_optimizer(config)
+    return Optimizer(
+        bounds=bounds,
+        config=config,
+        rng=rng,
+        surrogate=surrogate,
+        acquisition_optimizer=acq_optimizer,
+    )

enn/turbo/optimizer_config.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+from . import config as _config
+
+__all__ = list(_config.__all__)
+
+
+def __getattr__(name: str) -> object:
+    return getattr(_config, name)