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

enn/turbo/config/optimizer_config.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+from .candidate_gen_config import CandidateGenConfig
+from .init_config import InitConfig
+from .surrogate import NoSurrogateConfig, SurrogateConfig
+from .trust_region import TrustRegionConfig, TurboTRConfig
+
+if TYPE_CHECKING:
+    from .acquisition import AcqOptimizerConfig, AcquisitionConfig
+    from .enums import CandidateRV, RAASPDriver
+
+
+@dataclass(frozen=True)
+class ObservationHistoryConfig:
+    trailing_obs: int | None = None
+
+    def __post_init__(self) -> None:
+        if self.trailing_obs is not None and self.trailing_obs <= 0:
+            raise ValueError(f"trailing_obs must be > 0, got {self.trailing_obs}")
+
+
+def _default_acquisition():
+    from .acquisition import RandomAcquisitionConfig
+
+    return RandomAcquisitionConfig()
+
+
+def _default_acq_optimizer():
+    from .acquisition import RAASPOptimizerConfig
+
+    return RAASPOptimizerConfig()
+
+
+@dataclass(frozen=True)
+class OptimizerConfig:
+    trust_region: TrustRegionConfig = TurboTRConfig()
+    candidates: CandidateGenConfig = CandidateGenConfig()
+    init: InitConfig = InitConfig()
+    surrogate: SurrogateConfig = NoSurrogateConfig()
+    acquisition: AcquisitionConfig = field(default_factory=_default_acquisition)
+    acq_optimizer: AcqOptimizerConfig = field(default_factory=_default_acq_optimizer)
+    observation_history: ObservationHistoryConfig = ObservationHistoryConfig()
+
+    def __post_init__(self) -> None:
+        from .validation import validate_optimizer_config
+
+        validate_optimizer_config(self)
+
+    @property
+    def num_metrics(self) -> int | None:
+        from .morbo_tr_config import MorboTRConfig
+
+        if isinstance(self.trust_region, MorboTRConfig):
+            return self.trust_region.num_metrics
+        return None
+
+    @property
+    def candidate_rv(self) -> CandidateRV:
+        return self.candidates.candidate_rv
+
+    @property
+    def raasp_driver(self) -> RAASPDriver:
+        return self.candidates.raasp_driver
+
+    @property
+    def num_candidates(self):
+        return self.candidates.num_candidates
+
+    @property
+    def trailing_obs(self) -> int | None:
+        return self.observation_history.trailing_obs

enn/turbo/config/pareto_acquisition_config.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..components.protocols import AcquisitionOptimizer
+
+
+@dataclass(frozen=True)
+class ParetoAcquisitionConfig:
+    def build(self) -> AcquisitionOptimizer:
+        from ..components.acquisition import ParetoAcqOptimizer
+
+        return ParetoAcqOptimizer()

enn/turbo/config/raasp_driver.py

@@ -0,0 +1,6 @@
+from enum import Enum, auto
+
+
+class RAASPDriver(Enum):
+    ORIG = auto()
+    FAST = auto()

enn/turbo/config/raasp_optimizer_config.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RAASPOptimizerConfig:
+    pass

enn/turbo/config/random_acquisition_config.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..components.protocols import AcquisitionOptimizer
+
+
+@dataclass(frozen=True)
+class RandomAcquisitionConfig:
+    def build(self) -> AcquisitionOptimizer:
+        from ..components.acquisition import RandomAcqOptimizer
+
+        return RandomAcqOptimizer()

enn/turbo/config/rescalarize.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class Rescalarize(Enum):
+    ON_RESTART = "on_restart"
+    ON_PROPOSE = "on_propose"

enn/turbo/config/surrogate.py

@@ -0,0 +1,12 @@
+from .enn_surrogate_config import ENNFitConfig, ENNSurrogateConfig
+from .gp_surrogate_config import GPSurrogateConfig
+from .no_surrogate_config import NoSurrogateConfig
+
+SurrogateConfig = NoSurrogateConfig | GPSurrogateConfig | ENNSurrogateConfig
+__all__ = [
+    "ENNFitConfig",
+    "ENNSurrogateConfig",
+    "GPSurrogateConfig",
+    "NoSurrogateConfig",
+    "SurrogateConfig",
+]

enn/turbo/config/trust_region.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+from .morbo_tr_config import MorboTRConfig, MultiObjectiveConfig, RescalePolicyConfig
+from .no_tr_config import NoTRConfig
+from .turbo_tr_config import TRLengthConfig, TurboTRConfig
+
+if TYPE_CHECKING:
+    from numpy.random import Generator
+
+    from ..components.protocols import TrustRegion
+    from .enums import CandidateRV
+
+
+class TrustRegionConfig(Protocol):
+    def build(
+        self,
+        *,
+        num_dim: int,
+        rng: Generator,
+        candidate_rv: CandidateRV,
+    ) -> TrustRegion: ...
+
+
+__all__ = [
+    "MorboTRConfig",
+    "MultiObjectiveConfig",
+    "NoTRConfig",
+    "RescalePolicyConfig",
+    "TRLengthConfig",
+    "TrustRegionConfig",
+    "TurboTRConfig",
+]

enn/turbo/config/turbo_tr_config.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from numpy.random import Generator
+
+    from ..components.protocols import TrustRegion
+    from .enums import CandidateRV
+
+
+@dataclass(frozen=True)
+class TRLengthConfig:
+    length_init: float = 0.8
+    length_min: float = 0.5**7
+    length_max: float = 1.6
+
+    def __post_init__(self) -> None:
+        if self.length_init <= 0:
+            raise ValueError(f"length_init must be > 0, got {self.length_init}")
+        if self.length_min <= 0:
+            raise ValueError(f"length_min must be > 0, got {self.length_min}")
+        if self.length_max <= 0:
+            raise ValueError(f"length_max must be > 0, got {self.length_max}")
+        if self.length_min >= self.length_max:
+            raise ValueError(
+                f"length_min must be < length_max, got {self.length_min} >= {self.length_max}"
+            )
+        if self.length_init > self.length_max:
+            raise ValueError(
+                f"length_init must be <= length_max, got {self.length_init} > {self.length_max}"
+            )
+        if self.length_min > self.length_init:
+            raise ValueError(
+                f"length_min must be <= length_init, got {self.length_min} > {self.length_init}"
+            )
+
+
+@dataclass(frozen=True)
+class TurboTRConfig:
+    length: TRLengthConfig = TRLengthConfig()
+    noise_aware: bool = False
+
+    @property
+    def length_init(self) -> float:
+        return self.length.length_init
+
+    @property
+    def length_min(self) -> float:
+        return self.length.length_min
+
+    @property
+    def length_max(self) -> float:
+        return self.length.length_max
+
+    def build(
+        self,
+        *,
+        num_dim: int,
+        rng: Generator,
+        candidate_rv: CandidateRV | None = None,
+    ) -> TrustRegion:
+        from ..components.incumbent_selector import ScalarIncumbentSelector
+        from ..turbo_trust_region import TurboTrustRegion
+
+        return TurboTrustRegion(
+            config=self,
+            num_dim=num_dim,
+            incumbent_selector=ScalarIncumbentSelector(noise_aware=self.noise_aware),
+        )

enn/turbo/config/ucb_acquisition_config.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..components.protocols import AcquisitionOptimizer
+
+
+@dataclass(frozen=True)
+class UCBAcquisitionConfig:
+    def build(self) -> AcquisitionOptimizer:
+        from ..components.acquisition import UCBAcqOptimizer
+
+        return UCBAcqOptimizer()

enn/turbo/config/validation.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+from typing import Any
+
+
+def validate_optimizer_config(cfg: Any) -> None:
+    from .acquisition import (
+        DrawAcquisitionConfig,
+        HnROptimizerConfig,
+        NDSOptimizerConfig,
+        ParetoAcquisitionConfig,
+        UCBAcquisitionConfig,
+    )
+    from .init_strategies import LHDOnlyInit
+    from .surrogate import GPSurrogateConfig, NoSurrogateConfig
+
+    if isinstance(cfg.init.init_strategy, LHDOnlyInit):
+        if not isinstance(cfg.surrogate, NoSurrogateConfig):
+            raise ValueError(
+                "init_strategy='lhd_only' requires NoSurrogateConfig surrogate"
+            )
+    if isinstance(cfg.surrogate, NoSurrogateConfig):
+        if isinstance(cfg.acquisition, DrawAcquisitionConfig):
+            raise ValueError(
+                "DrawAcquisitionConfig (Thompson sampling) requires a surrogate. "
+                "NoSurrogateConfig is not compatible with DrawAcquisitionConfig."
+            )
+        if isinstance(cfg.acquisition, UCBAcquisitionConfig):
+            raise ValueError(
+                "UCBAcquisitionConfig requires a surrogate. "
+                "NoSurrogateConfig is not compatible with UCBAcquisitionConfig."
+            )
+    if isinstance(cfg.acquisition, ParetoAcquisitionConfig):
+        if not isinstance(cfg.acq_optimizer, NDSOptimizerConfig):
+            raise ValueError("ParetoAcquisitionConfig requires NDSOptimizerConfig")
+    if isinstance(cfg.acq_optimizer, HnROptimizerConfig):
+        if isinstance(cfg.acquisition, ParetoAcquisitionConfig):
+            raise ValueError(
+                "HnROptimizerConfig is not compatible with ParetoAcquisitionConfig"
+            )
+        if isinstance(cfg.surrogate, GPSurrogateConfig) and isinstance(
+            cfg.acquisition, DrawAcquisitionConfig
+        ):
+            raise NotImplementedError(
+                "GP surrogate with DrawAcquisitionConfig and HnROptimizerConfig is not yet implemented"
+            )

enn/turbo/hypervolume.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+import numpy as np
+
+
+def hypervolume_2d_max(y: np.ndarray, ref_point: np.ndarray) -> float:
+    y = np.asarray(y, dtype=float)
+    ref_point = np.asarray(ref_point, dtype=float)
+    if y.size == 0:
+        return 0.0
+    if y.ndim != 2:
+        raise ValueError(y.shape)
+    if y.shape[1] != 2:
+        raise ValueError(y.shape)
+    if ref_point.shape != (2,):
+        raise ValueError(ref_point.shape)
+    mask = (y[:, 0] > ref_point[0]) & (y[:, 1] > ref_point[1])
+    y = y[mask]
+    if y.size == 0:
+        return 0.0
+    order = np.argsort(y[:, 0], kind="mergesort")[::-1]
+    y = y[order]
+    hv = 0.0
+    best_y1 = ref_point[1]
+    for i in range(len(y)):
+        x0, y1 = y[i]
+        if y1 > best_y1:
+            best_y1 = y1
+        x_next = y[i + 1, 0] if i + 1 < len(y) else ref_point[0]
+        hv += (x0 - x_next) * (best_y1 - ref_point[1])
+    return float(hv)

enn/turbo/impl_helpers.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import numpy as np
+    from numpy.random import Generator
+
+
+def get_x_center_fallback(
+    config: Any,
+    x_obs_list: list,
+    y_obs_list: list,
+    rng: Generator,
+    tr_state: Any = None,
+) -> np.ndarray | None:
+    import numpy as np
+    from .components.incumbent_selector import ScalarIncumbentSelector
+
+    y_array = np.asarray(y_obs_list, dtype=float)
+    if y_array.size == 0:
+        return None
+    x_array = np.asarray(x_obs_list, dtype=float)
+    if tr_state is not None and hasattr(tr_state, "incumbent_selector"):
+        selector = tr_state.incumbent_selector
+    else:
+        selector = ScalarIncumbentSelector(noise_aware=False)
+    idx = selector.select(y_array, None, rng)
+    return x_array[idx]
+
+
+def handle_restart_clear_always(
+    x_obs_list: list,
+    y_obs_list: list,
+    yvar_obs_list: list,
+) -> tuple[bool, int]:
+    x_obs_list.clear()
+    y_obs_list.clear()
+    yvar_obs_list.clear()
+    return True, 0
+
+
+def handle_restart_check_multi_objective(
+    tr_state: Any,
+    x_obs_list: list,
+    y_obs_list: list,
+    yvar_obs_list: list,
+    init_idx: int,
+) -> tuple[bool, int]:
+    is_multi = (
+        tr_state is not None
+        and hasattr(tr_state, "num_metrics")
+        and tr_state.num_metrics > 1
+    )
+    if is_multi:
+        x_obs_list.clear()
+        y_obs_list.clear()
+        yvar_obs_list.clear()
+        return True, 0
+    return False, init_idx
+
+
+def estimate_y_passthrough(y_observed: np.ndarray) -> np.ndarray:
+    import numpy as np
+
+    y = np.asarray(y_observed, dtype=float)
+    if y.ndim == 1:
+        return y.reshape(-1, 1)
+    return y