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

ennbo-0.1.7.dist-info/RECORD

@@ -0,0 +1,111 @@
+enn/__init__.py,sha256=Iv1cXM6xUCjGDN2x7qj-A9DFy92-6iXQOJke-7_DBbQ,1465
+enn/benchmarks/__init__.py,sha256=50yqq29luUZQmH618jLq006MwimJBYCvlR9PMSs97MM,79
+enn/benchmarks/ackley.py,sha256=LMx_8C4swL3oKbzm70S8wHe_fp7Z0JCbyoi4kx2E9YY,163
+enn/benchmarks/ackley_class.py,sha256=AwLwopw7bUQ0QaN1yFmVdNPZdL4948lqGfKIvyXk7Os,519
+enn/benchmarks/ackley_core.py,sha256=zIGlZuIkzfv2OLLU_R7hSSYnm0TCm7G7Nt7KlDXuu5k,328
+enn/benchmarks/double_ackley.py,sha256=IXZntZ1byJxIlFh3aj3Rzw_2cnjih8c9nyKTt_iM0P8,766
+enn/enn/candidates.py,sha256=axVT0bs0dt4ZEXmy_d540U1h0JJ-YIAqYFaUPaiXwa0,276
+enn/enn/conditional_posterior_draw_internals.py,sha256=Rr9sntjci85ke-LEoZPbxq4le7yKK1qKsOnrSfwA7Jw,317
+enn/enn/draw_internals.py,sha256=o0MEpVV03x8WNdKmOq4yDTerDmxaDc7jeo17b1XxvAo,297
+enn/enn/enn.py,sha256=JNrvi6wDLvYDEVaQ5d94M9uGgBdZWgT49rausgIABOA,358
+enn/enn/enn_class.py,sha256=BAzPZMpaink-ddfRD0N_vZTM1IyVJL7Y6cNe_0Xs_ps,15131
+enn/enn/enn_conditional.py,sha256=rDR3NJq0JHnKUqRu7sma7XR8g1PPeUAJUlbt-iI63YI,10535
+enn/enn/enn_fit.py,sha256=hNAG1FHMbZNBeq0T4CIXp-1aiGKRbupL2nnnlQ4fb0A,4573
+enn/enn/enn_hash.py,sha256=yk8N8EAf-IXsXS_NkoyTtlW0SyxJqzdl6Y8dinB2JYo,3151
+enn/enn/enn_index.py,sha256=nWuWhuA-MqyPZmTAAwJLB4sdv1n7jMmRBuRTS5LzZjI,3060
+enn/enn/enn_like_protocol.py,sha256=bzRvvE-ggqB0CqpdshZb2JJPzyV-BKNYZOjalX54ufQ,925
+enn/enn/enn_normal.py,sha256=MOPsoC3KUCNQ_UMd_Ynkpyg9KSWNdRibaqIyAXdj4yo,661
+enn/enn/enn_params.py,sha256=9NfT2mX3xbXBfPrdKNgVwsu6zWLBNXO0h1IF9NDpfQI,127
+enn/enn/enn_params_class.py,sha256=hfzU2ftyRXMTDTW3euK-v-2ir--fjRXdoh6OYN1c1bo,854
+enn/enn/enn_util.py,sha256=YWJjtbIPpEBN4wJ5EaTrvJB686BKkDxTykewhslzJe8,4543
+enn/enn/neighbor_data.py,sha256=K8Djik2kCfsHSlG8RSvpcudRVmm6l78QXUj1V2_pwMc,272
+enn/enn/neighbors.py,sha256=PUEqtgwUYk7mPD8Gm6RtW3yfDp9J6DNlnuMzYz-XHHI,275
+enn/enn/posterior_flags.py,sha256=La3ZdSy9ZoXtaR4P2D2MOQdaZJ1Vfaz5xK_Jy_-2wWE,187
+enn/enn/weighted_stats.py,sha256=mrghm8hrfrxrQ-jTSrakUjJ5iIdeD7Ilx2H31KaTU50,277
+enn/turbo/hypervolume.py,sha256=lMTA9LlBXNo9kt83POfI4DfcAuvzYD3MgcN8AjIFVQM,910
+enn/turbo/impl_helpers.py,sha256=hlfNBqWMzCJi6PtP8hJ8jlZNv68HIIBSVfsJXQQYgJM,1695
+enn/turbo/morbo_trust_region.py,sha256=AUDeGsnljIYhCflPtPlQTe3TuEIHvWeNp_i07M4mCzQ,8690
+enn/turbo/no_trust_region.py,sha256=3OKAzYrn_F8jXrZyE9LiYHIzJqEl6byjXeuzszwzm5s,1679
+enn/turbo/optimizer.py,sha256=wCTV7a2nwejSgQTw4D2eKWcqTqgZMz_UnxmwshZ2HoU,11146
+enn/turbo/optimizer_config.py,sha256=nIEu-e2rRk0XbEbiC8WkOsTk36go0ocdKsAOjAWD3mI,174
+enn/turbo/proposal.py,sha256=00SHsdgFXi8_d734kpXadOBC6Hz0HO9Pqo4tWuqoKlw,4430
+enn/turbo/sampling.py,sha256=y1ivaEwOYPTo8LVIyMUJ4J5mb6XGXn1EuhSwTYsqvGU,662
+enn/turbo/tr_helpers.py,sha256=KsQBFq9uykeBPuPVpBAhEyZcO1HotbWFkKmKca2zCk0,5417
+enn/turbo/turbo_gp.py,sha256=PY_R4YNPtH7-d2MR2M2eoRnlTgSAkT3Bv1hLGzs7IcQ,1068
+enn/turbo/turbo_gp_base.py,sha256=EtFp6yUber1EIOsKjdNPBjjG6gg3jy-EZHgN4GAseDA,637
+enn/turbo/turbo_gp_fit.py,sha256=JGcDP36DL1-lj93INHjyWCc0EqnhJh1psLPNLiMMy_w,5916
+enn/turbo/turbo_gp_noisy.py,sha256=SCcZPRM5G8kZHdUjHE6whoobOVXOwSZRB6YwlwWFBCg,1079
+enn/turbo/turbo_optimizer_utils.py,sha256=Pl_i5aN3pAT9l4u_0HabJyHo1wBIWvcE3qaSqeAz4QU,3349
+enn/turbo/turbo_trust_region.py,sha256=sNMXYsPbFRfmYxHRUWz8604G3T_mKtJN0WYFTiw_DPg,6608
+enn/turbo/turbo_utils.py,sha256=DPUoaCSAHU2WYSLGh29rREIgYpj2rEir95UBx0w-yVI,7788
+enn/turbo/components/__init__.py,sha256=xDYcJhyIbnaTC2nw84Zt0Y_kKNU7Z1k1DFdQXhrgC68,906
+enn/turbo/components/acquisition.py,sha256=IyBWLG2QyLPduW1wW4LA37iW3XSCp0Z_m259yeMjMnk,398
+enn/turbo/components/acquisition_optimizer_protocol.py,sha256=_PC4ngQbacB8otvPZroCsx5wWZK1PfRjo_bl6aqWPLI,454
+enn/turbo/components/builder.py,sha256=BrhhhkP1k_XjVJt7pnlhHVsnA1En77RBu-vqvffJNvY,822
+enn/turbo/components/chebyshev_incumbent_selector.py,sha256=nJNPAMBIafkL09BzeFPecA5LrUvi13xjJnzGmd71qdo,2453
+enn/turbo/components/enn_surrogate.py,sha256=9_UgTJ3Lk3hsbcdsbUXegRTDQtQa41cFca_ttRFEy7k,4598
+enn/turbo/components/gp_surrogate.py,sha256=yvLknU_NE7S4qrPcDBniB9UYtebvS9_ak5VlUqfzU9A,6012
+enn/turbo/components/hnr_acq_optimizer.py,sha256=wfmJjA9D98HjOyybvlvERru_pVvWTD1QV1REyI2CeBU,2836
+enn/turbo/components/incumbent_selector.py,sha256=mPwtqGdG22b_ZiNinpV4dxKm3Vkvcl4MeYwo9vAVRlg,378
+enn/turbo/components/incumbent_selector_protocol.py,sha256=5LVVsLvCmOeJ9vTIxQ3g59m-15fEZvkL22yzg8abfHM,379
+enn/turbo/components/no_incumbent_selector.py,sha256=toLi-DxPRIlEqCtCOFkq5na626NZRkFnH3tb81e6FXo,429
+enn/turbo/components/no_surrogate.py,sha256=7I6A4ceMhOU5y50blPTM3KgUtzFZyJsxKUVOr9bifmk,1777
+enn/turbo/components/pareto_acq_optimizer.py,sha256=cPXjAtYf3P_xOCYF9ga8FIcLSEoTJ6_VUQjAOJ9TSIs,1853
+enn/turbo/components/posterior_result.py,sha256=LM3ZeE1eT-8gyOhkpa3PF0THXRKH0URTQO0ija1eMbc,235
+enn/turbo/components/protocols.py,sha256=Rwpln-22_9TS1PB5XFYG-B_wqUOOgfaW54tdZbW6nv4,371
+enn/turbo/components/random_acq_optimizer.py,sha256=TEMclz-zQ0ncccmxj58dfxW1kwEwUFfEJG2DzV1gkII,514
+enn/turbo/components/scalar_incumbent_selector.py,sha256=YXdpH9eLwZlYBOyroAyiuQPvJfj9G4jn_wKGEk0PkVk,1092
+enn/turbo/components/surrogate_protocol.py,sha256=kXoeyrdX005yUS-ObaVzx_PeyCV6gLHsnOC36_tHMBY,985
+enn/turbo/components/surrogate_result.py,sha256=ax_y4qZ2a99XdwAbLqHjYAY0ck607oDUFonOtGwgLGU,243
+enn/turbo/components/surrogates.py,sha256=RxEl4VeIaFlLEwas3S3XZ3scxIjuS70Fa0Q8cGrm6LU,174
+enn/turbo/components/thompson_acq_optimizer.py,sha256=Eb_3KPrZRyMBTfgO9OmUQnkXNxcsBZdcb6ecmbpNm4Q,1847
+enn/turbo/components/trust_region_protocol.py,sha256=X8RCN8FtrWpua9VRGHZtSz_wNMxqBdqopULZyopLdPk,879
+enn/turbo/components/ucb_acq_optimizer.py,sha256=RO_9HGCVb6xAGDL8iFJqF4ZkapPbG7tWCvGhLh2C7es,1797
+enn/turbo/config/__init__.py,sha256=dH8GVPL0MJuCdyA_Mo1v__tlLtjd1G2Se3yM8UGIP1Q,1924
+enn/turbo/config/acq_type.py,sha256=P89H41Xt26pCfCt1ODByRDv-TU-Zb5XKlgLcFHb-cpo,144
+enn/turbo/config/acquisition.py,sha256=cPb6PrF6cgcr4c57ylPAspGb-ScDZflyKamnohc_R2c,891
+enn/turbo/config/base.py,sha256=LhX0siqu7YbJ9BxDqC0MujupYwM-B6RLPg2NjdF7Owc,137
+enn/turbo/config/candidate_gen_config.py,sha256=g5OzuMLfDoU-htcjdI4N5V5fnhXdQa_drNF5Ee7ws3o,1507
+enn/turbo/config/candidate_rv.py,sha256=dQumGSHF3uE4HTC0Ix3yzmmsAaLsSs_m8NB93Kpji6g,128
+enn/turbo/config/draw_acquisition_config.py,sha256=nIg6jlWjgjoNyHMKBI5i3zMxu4-WQSitEQGy3h6cUQQ,386
+enn/turbo/config/enn_index_driver.py,sha256=qDrNXatK4nMvUi8h_rkg9Uv_M9WfLdlsTHTP4X3COjE,94
+enn/turbo/config/enn_surrogate_config.py,sha256=dsvDkgPVm5qv8zhE3AvUN9yX37cyGrno0E0GNwodXoY,1269
+enn/turbo/config/enums.py,sha256=nlxqrB3sivvs2_1fMTLGCg0MfoSQ0ZUG8kREM3raSfY,274
+enn/turbo/config/factory.py,sha256=eZNw6Zao7zrKeQHaeLRVDP2tdqsVguSZFoBiW31UkUI,4458
+enn/turbo/config/gp_surrogate_config.py,sha256=tXSF4XPrvNfmZvEHJavGK5AaJ7ZyWWjV105qe4y_DZM,341
+enn/turbo/config/hnr_optimizer_config.py,sha256=oo1Cn0jcaTZXz8L0730KvGVD6m6xiQxmINMVWg6Fj68,130
+enn/turbo/config/init_config.py,sha256=AZhu75v_O-8I3Li6ptgb-uaNv2aP6xX4BF0v58qVS24,610
+enn/turbo/config/morbo_tr_config.py,sha256=RPUEm5wooZja38QwTvMLkA1jRf9cvyBOkMQ-WOVsX8k,2021
+enn/turbo/config/nds_optimizer_config.py,sha256=wuNFqlVVlDLU0tU2XdogLOTMni90-ngLB19nt7XKJ6A,130
+enn/turbo/config/no_surrogate_config.py,sha256=Tf0CXESMbwXlX7l2Tk1HGzH1lNY3c0qk995bHGpZaPk,341
+enn/turbo/config/no_tr_config.py,sha256=5QXJQtjKwNMXs7QqhgLgA3HngCh73g0a-gWzt_OzWNU,789
+enn/turbo/config/optimizer_config.py,sha256=WDYVyAWeX5GTBihlgArJ4XrcZAONw_0QdR2ylHyJUpE,2243
+enn/turbo/config/pareto_acquisition_config.py,sha256=UsH4r4RPWAXgPDgcxlUJ9N0x4u1ZB5Wn3OBDu4Fxg6k,384
+enn/turbo/config/raasp_driver.py,sha256=NY4YZdqhPrusbpPjSLRY2MiDv5_f7CpUXlyVsGx3an8,91
+enn/turbo/config/raasp_optimizer_config.py,sha256=LQUe6nYx8gw3b2OXUGodkK_EK3jvIKSBc9DLhKGOzkM,132
+enn/turbo/config/random_acquisition_config.py,sha256=ktNKCqnAOt69Cbsx9r5pVcgcb1gUYLnRrbureSq4BGA,384
+enn/turbo/config/rescalarize.py,sha256=dB80E62uAGmNRnWrV8aLoTjehFB3pWN1XMkgMh03RAc,144
+enn/turbo/config/surrogate.py,sha256=S1BqKv9Fd-ZmfAXNUKdLFrYhSNY_zdBNL45kvD8jhUo,380
+enn/turbo/config/trust_region.py,sha256=yjDnCq74R81jLu_6e7fCHy5s_m8CZGVABxAPEVUXyTM,769
+enn/turbo/config/turbo_tr_config.py,sha256=5yGVk0_es5yYjYH94GV29q1nWNoY32hed9mmzF0tKkw,2188
+enn/turbo/config/ucb_acquisition_config.py,sha256=00SICPVJZaADCu1Mv0DTDgFfBVeilc5IBzlnjjyb5ko,375
+enn/turbo/config/validation.py,sha256=OCnULdJY6I7QCHqSJWEgURVwcq6CLgu214LTWNWHYiY,1974
+enn/turbo/config/init_strategies/__init__.py,sha256=XgowibgAkggbioBgARZ7LR4y1bUHopZs6luoFMRdgsw,187
+enn/turbo/config/init_strategies/hybrid_init.py,sha256=GDzBMvYXJMfWkaNpnDFNfe8yl7XAhIPaNVS4jkK9nD8,643
+enn/turbo/config/init_strategies/init_strategy.py,sha256=yRKGd9EjMh09rLKejZOkcj7pAL7vnqbpNjr9ax_oLrs,458
+enn/turbo/config/init_strategies/lhd_only_init.py,sha256=84xUlaifq98Vonr0ltEoq8xArS1knRuI0y8qhhNe1QE,638
+enn/turbo/strategies/__init__.py,sha256=PA-p1M-4w8Miv1wLqZF0FODyhyVr3_0vED-qcwiaD8E,251
+enn/turbo/strategies/lhd_only_strategy.py,sha256=nThr0BBHOb0fBialCU7ToYz-BEodS72ZMyHInkiybnc,1154
+enn/turbo/strategies/optimization_strategy.py,sha256=xwiU_P9_1YBt1UaPthNsMo__QvEo9dREc4mJwr05dBA,548
+enn/turbo/strategies/turbo_hybrid_strategy.py,sha256=H-JtlAl3NR0MziiPETCFAY89AusWpObLy-j-xhgWaaU,4567
+enn/turbo/types/__init__.py,sha256=mIP7fNkcgQ1WLPeCSMTzcwbZuNiMlrCt8JLphfml8KU,280
+enn/turbo/types/appendable_array.py,sha256=YAxXuC6QD_52tzYBssJgjP6Dm3rQSYS1NxE3FwKWT4w,2812
+enn/turbo/types/gp_data_prep.py,sha256=KZACZCyqpoDGCMQ4WhRTGAnZhKO-FHtIBB3_dGfAVcc,222
+enn/turbo/types/gp_fit_result.py,sha256=7jvGQxT0XZx8rbOFdmm_nLwV_L3KwybjwEV-uZTLLXM,190
+enn/turbo/types/obs_lists.py,sha256=LytRAkOgRvORMLS-lpP97AvSj2DfrFu2kyHM7JLi7GE,164
+enn/turbo/types/prepare_ask_result.py,sha256=uTFdFZ-e7s1ZmJuyf6l1H4qDTxAmwq5UznP5pVc3r4Y,286
+enn/turbo/types/tell_inputs.py,sha256=OqkkL55MpVVCzhFJuLajYuxrQ6WsJRZ4R521Zn7SBr4,261
+ennbo-0.1.7.dist-info/METADATA,sha256=niGm5jUopcIGOZYrrYyffQk_m3bFaHfGS50YVSy8nRU,6085
+ennbo-0.1.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ennbo-0.1.7.dist-info/licenses/LICENSE,sha256=KTA0NjGalsl_JGrjT_x6SSq9ZYVO3gQ-hLVMEaekc5w,1070
+ennbo-0.1.7.dist-info/RECORD,,

enn/enn/__init__.py

@@ -1,4 +0,0 @@
-from .enn import EpistemicNearestNeighbors
-from .enn_fit import enn_fit
-
-__all__: list[str] = ["EpistemicNearestNeighbors", "enn_fit"]

enn/turbo/__init__.py

@@ -1,11 +0,0 @@
-from .turbo_mode import TurboMode
-from .turbo_optimizer import Telemetry, TurboOptimizer
-
-Turbo = TurboOptimizer
-
-__all__ = [
-    "TurboMode",
-    "TurboOptimizer",
-    "Turbo",
-    "Telemetry",
-]

enn/turbo/base_turbo_impl.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Callable
-
-if TYPE_CHECKING:
-    import numpy as np
-    from numpy.random import Generator
-
-from .turbo_config import TurboConfig
-
-
-class BaseTurboImpl:
-    def __init__(self, config: TurboConfig) -> None:
-        self._config = config
-
-    def get_x_center(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        rng: Generator,
-        tr_state: Any = None,
-    ) -> np.ndarray | None:
-        import numpy as np
-
-        from .turbo_utils import argmax_random_tie
-
-        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)
-
-        # For morbo: scalarize raw y observations
-        if self._config.tr_type == "morbo" and tr_state is not None:
-            if y_array.ndim == 1:
-                y_array = y_array.reshape(-1, tr_state.num_metrics)
-            scalarized = tr_state.scalarize(y_array, clip=True)
-            idx = argmax_random_tie(scalarized, rng=rng)
-        else:
-            idx = argmax_random_tie(y_array, rng=rng)
-
-        return x_array[idx]
-
-    def needs_tr_list(self) -> bool:
-        return False
-
-    def create_trust_region(
-        self,
-        num_dim: int,
-        num_arms: int,
-        rng: Generator,
-        num_metrics: int | None = None,
-    ) -> Any:
-        if self._config.tr_type == "none":
-            from .no_trust_region import NoTrustRegion
-
-            return NoTrustRegion(num_dim=num_dim, num_arms=num_arms)
-        elif self._config.tr_type == "turbo":
-            from .turbo_trust_region import TurboTrustRegion
-
-            return TurboTrustRegion(num_dim=num_dim, num_arms=num_arms)
-        elif self._config.tr_type == "morbo":
-            from .morbo_trust_region import MorboTrustRegion
-
-            effective_num_metrics = num_metrics or self._config.num_metrics
-            if effective_num_metrics is None:
-                raise ValueError("num_metrics required for tr_type='morbo'")
-            return MorboTrustRegion(
-                num_dim=num_dim,
-                num_arms=num_arms,
-                num_metrics=effective_num_metrics,
-                rng=rng,
-            )
-        else:
-            raise ValueError(f"Unknown tr_type: {self._config.tr_type!r}")
-
-    def try_early_ask(
-        self,
-        num_arms: int,
-        x_obs_list: list,
-        draw_initial_fn: Callable[[int], np.ndarray],
-        get_init_lhd_points_fn: Callable[[int], np.ndarray],
-    ) -> np.ndarray | None:
-        return None
-
-    def handle_restart(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        yvar_obs_list: list,
-        init_idx: int,
-        num_init: int,
-    ) -> tuple[bool, int]:
-        if self._config.tr_type == "morbo":
-            x_obs_list.clear()
-            y_obs_list.clear()
-            yvar_obs_list.clear()
-            return True, 0
-        return False, init_idx
-
-    def prepare_ask(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        yvar_obs_list: list,
-        num_dim: int,
-        gp_num_steps: int,
-        rng: Any | None = None,
-    ) -> tuple[Any, float | None, float | None, np.ndarray | None]:
-        return None, None, None, None
-
-    def select_candidates(
-        self,
-        x_cand: np.ndarray,
-        num_arms: int,
-        num_dim: int,
-        rng: Generator,
-        fallback_fn: Callable[[np.ndarray, int], np.ndarray],
-        from_unit_fn: Callable[[np.ndarray], np.ndarray],
-        tr_state: Any = None,
-    ) -> np.ndarray:
-        raise NotImplementedError("Subclasses must implement select_candidates")
-
-    def update_trust_region(
-        self,
-        tr_state: Any,
-        x_obs_list: list,
-        y_obs_list: list,
-        x_center: np.ndarray | None = None,
-        k: int | None = None,
-    ) -> None:
-        import numpy as np
-
-        x_obs_array = np.asarray(x_obs_list, dtype=float)
-        y_obs_array = np.asarray(y_obs_list, dtype=float)
-        if hasattr(tr_state, "update_xy"):
-            tr_state.update_xy(x_obs_array, y_obs_array, k=k)
-        else:
-            tr_state.update(y_obs_array)
-
-    def estimate_y(self, x_unit: np.ndarray, y_observed: np.ndarray) -> np.ndarray:
-        return y_observed
-
-    def get_mu_sigma(self, x_unit: np.ndarray) -> tuple[np.ndarray, np.ndarray] | None:
-        return None

enn/turbo/lhd_only_impl.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Callable
-
-if TYPE_CHECKING:
-    import numpy as np
-    from numpy.random import Generator
-
-from .base_turbo_impl import BaseTurboImpl
-from .turbo_config import LHDOnlyConfig
-
-
-class LHDOnlyImpl(BaseTurboImpl):
-    def __init__(self, config: LHDOnlyConfig) -> None:
-        super().__init__(config)
-
-    def get_x_center(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        rng: Generator,
-        tr_state: Any = None,
-    ) -> np.ndarray | None:
-        return None
-
-    def select_candidates(
-        self,
-        x_cand: np.ndarray,
-        num_arms: int,
-        num_dim: int,
-        rng: Generator,
-        fallback_fn: Callable[[np.ndarray, int], np.ndarray],
-        from_unit_fn: Callable[[np.ndarray], np.ndarray],
-        tr_state: Any = None,  # noqa: ARG002
-    ) -> np.ndarray:
-        from .turbo_utils import latin_hypercube
-
-        unit = latin_hypercube(num_arms, num_dim, rng=rng)
-        return from_unit_fn(unit)
-
-    def update_trust_region(
-        self,
-        tr_state: Any,
-        x_obs_list: list,
-        y_obs_list: list,
-        x_center: np.ndarray | None = None,
-        k: int | None = None,
-    ) -> None:
-        pass

enn/turbo/turbo_config.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Literal
-
-
-@dataclass(frozen=True)
-class TurboConfig:
-    k: int | None = None
-    num_candidates: int | None = None
-    num_init: int | None = None
-
-    # Experimental
-    trailing_obs: int | None = None
-    tr_type: Literal["turbo", "morbo", "none"] = "turbo"
-    num_metrics: int | None = None
-
-    def __post_init__(self) -> None:
-        if self.tr_type not in ["turbo", "morbo", "none"]:
-            raise ValueError(
-                f"tr_type must be 'turbo', 'morbo', or 'none', got {self.tr_type!r}"
-            )
-        if self.num_metrics is not None and self.num_metrics < 1:
-            raise ValueError(f"num_metrics must be >= 1, got {self.num_metrics}")
-        if self.tr_type == "turbo":
-            if self.num_metrics is not None and self.num_metrics != 1:
-                raise ValueError(
-                    f"num_metrics must be 1 for tr_type='turbo', got {self.num_metrics}"
-                )
-        if self.tr_type == "none":
-            if self.num_metrics is not None and self.num_metrics != 1:
-                raise ValueError(
-                    f"num_metrics must be 1 for tr_type='none', got {self.num_metrics}"
-                )
-
-
-@dataclass(frozen=True)
-class TurboOneConfig(TurboConfig):
-    pass
-
-
-@dataclass(frozen=True)
-class TurboZeroConfig(TurboConfig):
-    pass
-
-
-@dataclass(frozen=True)
-class LHDOnlyConfig(TurboConfig):
-    pass
-
-
-@dataclass(frozen=True)
-class TurboENNConfig(TurboConfig):
-    acq_type: Literal["thompson", "pareto", "ucb"] = "pareto"
-    num_fit_samples: int | None = None
-    num_fit_candidates: int | None = None
-    scale_x: bool = False
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        if self.acq_type not in ["thompson", "pareto", "ucb"]:
-            raise ValueError(
-                f"acq_type must be 'thompson', 'pareto', or 'ucb', got {self.acq_type!r}"
-            )
-        if self.num_fit_samples is None and self.acq_type != "pareto":
-            raise ValueError(f"num_fit_samples required for acq_type={self.acq_type!r}")
-        if self.num_fit_samples is not None and int(self.num_fit_samples) <= 0:
-            raise ValueError(f"num_fit_samples must be > 0, got {self.num_fit_samples}")
-        if self.num_fit_candidates is not None and int(self.num_fit_candidates) <= 0:
-            raise ValueError(
-                f"num_fit_candidates must be > 0, got {self.num_fit_candidates}"
-            )

enn/turbo/turbo_enn_impl.py

@@ -1,201 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Callable
-
-if TYPE_CHECKING:
-    import numpy as np
-    from numpy.random import Generator
-
-from .base_turbo_impl import BaseTurboImpl
-from .turbo_config import TurboENNConfig
-
-
-class TurboENNImpl(BaseTurboImpl):
-    def __init__(self, config: TurboENNConfig) -> None:
-        super().__init__(config)
-        self._enn: Any | None = None
-        self._fitted_params: Any | None = None
-        self._fitted_n_obs: int = 0
-
-    def get_x_center(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        rng: Generator,
-        tr_state: Any = None,
-    ) -> np.ndarray | None:
-        import numpy as np
-
-        from .turbo_utils import argmax_random_tie
-
-        if len(y_obs_list) == 0:
-            return None
-        if self._enn is None or self._fitted_params is None:
-            return super().get_x_center(x_obs_list, y_obs_list, rng, tr_state)
-        if self._fitted_n_obs != len(x_obs_list):
-            raise RuntimeError(
-                f"ENN fitted on {self._fitted_n_obs} obs but get_x_center called with {len(x_obs_list)}"
-            )
-
-        y_array = np.asarray(y_obs_list, dtype=float)
-        x_array = np.asarray(x_obs_list, dtype=float)
-        k = self._config.k if self._config.k is not None else 10
-
-        # For morbo: top-k per metric → union → scalarize mu
-        if self._config.tr_type == "morbo" and tr_state is not None:
-            if y_array.ndim == 1:
-                y_array = y_array.reshape(-1, tr_state.num_metrics)
-            num_metrics = y_array.shape[1]
-
-            # Find top-k indices for each metric and take union
-            union_indices = set()
-            for m in range(num_metrics):
-                num_top = min(k, len(y_array))
-                top_m = np.argpartition(-y_array[:, m], num_top - 1)[:num_top]
-                union_indices.update(top_m.tolist())
-            union_indices = np.array(sorted(union_indices), dtype=int)
-
-            x_union = x_array[union_indices]
-            posterior = self._enn.posterior(x_union, params=self._fitted_params)
-            mu = posterior.mu  # (len(union), num_metrics)
-
-            scalarized = tr_state.scalarize(mu, clip=False)
-            best_idx_in_union = argmax_random_tie(scalarized, rng=rng)
-            return x_union[best_idx_in_union]
-        else:
-            # Single-objective: original logic
-            num_top = min(k, len(y_array))
-            top_indices = np.argpartition(-y_array, num_top - 1)[:num_top]
-
-            x_top = x_array[top_indices]
-            posterior = self._enn.posterior(x_top, params=self._fitted_params)
-            mu = posterior.mu[:, 0]
-
-            best_idx_in_top = argmax_random_tie(mu, rng=rng)
-            return x_top[best_idx_in_top]
-
-    def needs_tr_list(self) -> bool:
-        return True
-
-    def handle_restart(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        yvar_obs_list: list,
-        init_idx: int,
-        num_init: int,
-    ) -> tuple[bool, int]:
-        x_obs_list.clear()
-        y_obs_list.clear()
-        yvar_obs_list.clear()
-        return True, 0
-
-    def prepare_ask(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        yvar_obs_list: list,
-        num_dim: int,
-        gp_num_steps: int,
-        rng: Any | None = None,
-    ) -> tuple[Any, float | None, float | None, np.ndarray | None]:
-        from .proposal import mk_enn
-
-        k = self._config.k if self._config.k is not None else 10
-        self._enn, self._fitted_params = mk_enn(
-            x_obs_list,
-            y_obs_list,
-            yvar_obs_list=yvar_obs_list,
-            k=k,
-            num_fit_samples=self._config.num_fit_samples,
-            num_fit_candidates=self._config.num_fit_candidates,
-            scale_x=self._config.scale_x,
-            rng=rng,
-            params_warm_start=self._fitted_params,
-        )
-        self._fitted_n_obs = len(x_obs_list)
-        return None, None, None, None
-
-    def select_candidates(
-        self,
-        x_cand: np.ndarray,
-        num_arms: int,
-        num_dim: int,
-        rng: Generator,
-        fallback_fn: Callable[[np.ndarray, int], np.ndarray],
-        from_unit_fn: Callable[[np.ndarray], np.ndarray],
-        tr_state: Any = None,  # noqa: ARG002
-    ) -> np.ndarray:
-        import numpy as np
-
-        from enn.enn.enn_params import ENNParams
-
-        acq_type = self._config.acq_type
-        k = self._config.k
-
-        if self._enn is None:
-            return fallback_fn(x_cand, num_arms)
-
-        if self._fitted_params is not None:
-            params = self._fitted_params
-        else:
-            k_val = k if k is not None else 10
-            params = ENNParams(k=k_val, epi_var_scale=1.0, ale_homoscedastic_scale=0.0)
-
-        posterior = self._enn.posterior(x_cand, params=params)
-        mu = posterior.mu[:, 0]
-        se = posterior.se[:, 0]
-
-        if acq_type == "pareto":
-            from enn.enn.enn_util import arms_from_pareto_fronts
-
-            x_arms = arms_from_pareto_fronts(x_cand, mu, se, num_arms, rng)
-        elif acq_type == "ucb":
-            scores = mu + se
-            shuffled_indices = rng.permutation(len(scores))
-            shuffled_scores = scores[shuffled_indices]
-            top_k_in_shuffled = np.argpartition(-shuffled_scores, num_arms - 1)[
-                :num_arms
-            ]
-            idx = shuffled_indices[top_k_in_shuffled]
-            x_arms = x_cand[idx]
-        elif acq_type == "thompson":
-            samples = posterior.sample(num_samples=1, rng=rng)
-            scores = samples[:, 0, 0]
-            shuffled_indices = rng.permutation(len(scores))
-            shuffled_scores = scores[shuffled_indices]
-            top_k_in_shuffled = np.argpartition(-shuffled_scores, num_arms - 1)[
-                :num_arms
-            ]
-            idx = shuffled_indices[top_k_in_shuffled]
-            x_arms = x_cand[idx]
-        else:
-            raise ValueError(f"Unknown acq_type: {acq_type}")
-
-        return from_unit_fn(x_arms)
-
-    def estimate_y(self, x_unit: np.ndarray, y_observed: np.ndarray) -> np.ndarray:
-        if self._enn is None or self._fitted_params is None:
-            return y_observed
-        posterior = self._enn.posterior(x_unit, params=self._fitted_params)
-        # For multi-metric (morbo), return full mu; for single-metric, return 1D
-        if posterior.mu.shape[1] > 1:
-            return posterior.mu
-        return posterior.mu[:, 0]
-
-    def get_mu_sigma(self, x_unit: np.ndarray) -> tuple[np.ndarray, np.ndarray] | None:
-        if self._enn is None:
-            return None
-        k = self._config.k if self._config.k is not None else 10
-        from enn.enn.enn_params import ENNParams
-
-        params = (
-            self._fitted_params
-            if self._fitted_params is not None
-            else ENNParams(k=k, epi_var_scale=1.0, ale_homoscedastic_scale=0.0)
-        )
-        posterior = self._enn.posterior(x_unit, params=params, observation_noise=False)
-        # For multi-metric (morbo), return full mu/sigma; for single-metric, return 1D
-        if posterior.mu.shape[1] > 1:
-            return posterior.mu, posterior.se
-        return posterior.mu[:, 0], posterior.se[:, 0]

enn/turbo/turbo_mode.py

@@ -1,10 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum, auto
-
-
-class TurboMode(Enum):
-    TURBO_ONE = auto()
-    TURBO_ZERO = auto()
-    TURBO_ENN = auto()
-    LHD_ONLY = auto()

enn/turbo/turbo_mode_impl.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Callable, Protocol
-
-if TYPE_CHECKING:
-    import numpy as np
-    from numpy.random import Generator
-
-
-class TurboModeImpl(Protocol):
-    def get_x_center(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        rng: Generator,
-        tr_state: Any = None,
-    ) -> np.ndarray | None: ...
-
-    def needs_tr_list(self) -> bool: ...
-
-    def create_trust_region(
-        self,
-        num_dim: int,
-        num_arms: int,
-        rng: Generator,
-        num_metrics: int | None = None,
-    ) -> Any: ...
-
-    def try_early_ask(
-        self,
-        num_arms: int,
-        x_obs_list: list,
-        draw_initial_fn: Callable[[int], np.ndarray],
-        get_init_lhd_points_fn: Callable[[int], np.ndarray],
-    ) -> np.ndarray | None: ...
-
-    def handle_restart(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        yvar_obs_list: list,
-        init_idx: int,
-        num_init: int,
-    ) -> tuple[bool, int]: ...
-
-    def prepare_ask(
-        self,
-        x_obs_list: list,
-        y_obs_list: list,
-        yvar_obs_list: list,
-        num_dim: int,
-        gp_num_steps: int,
-        rng: Generator | Any | None = None,
-    ) -> tuple[Any, float | None, float | None, np.ndarray | None]: ...
-
-    def select_candidates(
-        self,
-        x_cand: np.ndarray,
-        num_arms: int,
-        num_dim: int,
-        rng: Generator,
-        fallback_fn: Callable[[np.ndarray, int], np.ndarray],
-        from_unit_fn: Callable[[np.ndarray], np.ndarray],
-        tr_state: Any = None,
-    ) -> np.ndarray: ...
-
-    def update_trust_region(
-        self,
-        tr_state: Any,
-        x_obs_list: list,
-        y_obs_list: list,
-        x_center: np.ndarray | None = None,
-        k: int | None = None,
-    ) -> None: ...
-
-    def estimate_y(self, x_unit: np.ndarray, y_observed: np.ndarray) -> np.ndarray: ...