ennbo 0.0.4__tar.gz

ennbo-0.0.4/.cursorrules

@@ -0,0 +1,54 @@
+# FIRST RULE OF CURSOR - MANDATORY: READ THIS FIRST
+MANDATORY FIRST ACTION: When the user sends their first request in a conversation, you MUST immediately read style.md using the read_file tool BEFORE performing any other action (no searches, no code reading, no tool calls of any kind). This is the absolute first step - do not answer the question, do not search, do not read other files. Read style.md first, then proceed with the user's request.
+
+
+--
+
+### Cursor Rule: Claims vs Hypotheses
+
+- Label uncertain reasoning as Hypothesis; only use Claim with explicit evidence.
+- Claims must cite evidence (code refs, logs, metrics). Otherwise, downgrade to Hypothesis.
+- For each Hypothesis, include:
+  - Hypothesis: concise, falsifiable statement.
+  - Predictions: measurable outcomes if true.
+  - Test: minimal experiment (setup, variables, metrics, pass/fail).
+  - Confounders: likely alternatives and controls.
+- Language:
+  - Hypothesis: “suggests”, “may”, “indicates”.
+  - Claim (with evidence): “shows”, “demonstrates”, “causes”.
+- Trigger this rule when explaining performance differences, algorithm behavior, or proposing changes.
+- Whenever you see an error happen more two or more times in a row, stop, state the problem clearly, then hypothesize the cause.  Then test to determine the cause. Once the cause is determined, fix the problem.
+
+--
+
+When running python code, you'll need to set PYTHONPATH
+
+--
+
+When your write code, always make sure `pytest -sv tests` and `ruff check` pass.
+Iterate until they do.
+
+--
+
+# Debugging process rule
+
+When debugging: run the broken code first to observe the actual failure, write a test that reproduces that exact failure, then fix it. Don't guess—observe empirically. Replicate the exact code path that fails in the test, not a simplified version. The broken code is the source of truth; observe it directly before fixing.
+--
+
+
+Acronyms we can use to make communication more efficient:
+DRY: Don't Repeat Yourself. The user would like you to look for opportunities to factor out common code.
+DCC: Don't Change Code. Repond to the user's query, but don't change *any* code.
+DCT: Don't Change Tests.  Repond to the user's query, but don't change any tests. You may change non-test code, though.
+OCT: *Only* Change Tests. Repond to the user's query, but don't change any non-test code. You may change test code, though.
+RR: Restate my request clearly. Lmk if you have any questions. DCC
+
+--
+
+# Cursor Roles
+The Tester: The Tester writes unit tests but does not implement the code being tested. Tests for unimplemented code should be failing tests.
+The Implementor: The Implementor writes code but does not write or change tests.
+
+--
+
+After every 5th request, `cat .cursorrules`

ennbo-0.0.4/.cursorrules~

@@ -0,0 +1,51 @@
+# FIRST RULE OF CURSOR - MANDATORY: READ THIS FIRST
+MANDATORY FIRST ACTION: When the user sends their first request in a conversation, you MUST immediately read style.md using the read_file tool BEFORE performing any other action (no searches, no code reading, no tool calls of any kind). This is the absolute first step - do not answer the question, do not search, do not read other files. Read style.md first, then proceed with the user's request.
+
+
+--
+
+### Cursor Rule: Claims vs Hypotheses
+
+- Label uncertain reasoning as Hypothesis; only use Claim with explicit evidence.
+- Claims must cite evidence (code refs, logs, metrics). Otherwise, downgrade to Hypothesis.
+- For each Hypothesis, include:
+  - Hypothesis: concise, falsifiable statement.
+  - Predictions: measurable outcomes if true.
+  - Test: minimal experiment (setup, variables, metrics, pass/fail).
+  - Confounders: likely alternatives and controls.
+- Language:
+  - Hypothesis: “suggests”, “may”, “indicates”.
+  - Claim (with evidence): “shows”, “demonstrates”, “causes”.
+- Trigger this rule when explaining performance differences, algorithm behavior, or proposing changes.
+- Whenever you see an error happen more two or more times in a row, stop, state the problem clearly, then hypothesize the cause.  Then test to determine the cause. Once the cause is determined, fix the problem.
+
+--
+
+When running python code, you'll need to set PYTHONPATH
+
+--
+
+When your write code, always make sure `pytest -sv tests` and `ruff check` pass.
+Iterate until they do.
+
+--
+
+# Debugging process rule
+
+When debugging: run the broken code first to observe the actual failure, write a test that reproduces that exact failure, then fix it. Don't guess—observe empirically. Replicate the exact code path that fails in the test, not a simplified version. The broken code is the source of truth; observe it directly before fixing.
+--
+
+
+Acronyms we can use to make communication more efficient:
+DRY: Don't Repeat Yourself. The user would like you to look for opportunities to factor out common code.
+DCC: Don't Change Code. Repond to the user's query, but don't change *any* code.
+DCT: Don't Change Tests.  Repond to the user's query, but don't change any tests. You may change non-test code, though.
+OCT: *Only* Change Tests. Repond to the user's query, but don't change any non-test code. You may change test code, though.
+RR: Restate my request clearly. Lmk if you have any questions. DCC
+
+--
+
+# Cursor Roles
+The Tester: The Tester writes unit tests but does not implement the code being tested. Tests for unimplemented code should be failing tests.
+The Implementor: The Implementor writes code but does not write or change tests.
+

ennbo-0.0.4/.pre-commit-config.yaml

@@ -0,0 +1,34 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-json
+      - id: check-added-large-files
+        args: ["--maxkb=500"]
+
+  # Forbid committing binary files and run custom checks
+  - repo: local
+    hooks:
+      - id: forbid-binary
+        name: Forbid committing binary files
+        entry: bash -c 'echo \"Binary files are not allowed in this repository.\"; exit 1'
+        language: system
+        types: [binary]
+
+      - id: find-forgotten-py
+        name: Find forgotten Python files via git status
+        entry: admin/find_forgotten_py.sh
+        language: system
+        pass_filenames: false
+        always_run: true
+
+  # Linting, formatting, and import sorting via Ruff
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.7.0
+    hooks:
+      - id: ruff
+        args: ["--fix"]
+      - id: ruff-format

ennbo-0.0.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 yubo research
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ennbo-0.0.4/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: ennbo
+Version: 0.0.4
+Summary: Epistemic Nearest Neighbors
+Project-URL: Homepage, https://github.com/yubo-research/enn
+Project-URL: Source, https://github.com/yubo-research/enn
+Author-email: YUBO Lab <david.sweet@yu.edu>
+License: MIT License
+        
+        Copyright (c) 2025 yubo research
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.11
+Requires-Dist: faiss==1.9.0
+Requires-Dist: gpytorch==1.13
+Requires-Dist: numpy==1.26.4
+Requires-Dist: scipy==1.15.3
+Requires-Dist: torch==2.5.1
+Description-Content-Type: text/markdown
+
+# enn
+Epistemic Nearest Neighbors
+
+- ENN model
+- TuRBO-ENN optimizer
+
+  

ennbo-0.0.4/README.md

@@ -0,0 +1,7 @@
+# enn
+Epistemic Nearest Neighbors
+
+- ENN model
+- TuRBO-ENN optimizer
+
+  

ennbo-0.0.4/admin/find_forgotten_py.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Run from repo root so paths from git status are correct
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$REPO_ROOT"
+
+echo "Scanning for untracked or modified Python files (git status)..."
+
+status_output="$(git status --porcelain --untracked-files=all)"
+
+if [[ -z "$status_output" ]]; then
+  echo "Working tree clean. No forgotten .py files."
+  exit 0
+fi
+
+# Select only:
+# - untracked files ("??")
+# - or files with unstaged changes (second status column non-space)
+# We parse the raw porcelain line as:
+#   XY <space> PATH
+# where X is index status, Y is work-tree status.
+py_files="$(
+  printf '%s\n' "$status_output" |
+    awk '{
+      line = $0
+      x = substr(line, 1, 1)
+      y = substr(line, 2, 1)
+      path = substr(line, 4)
+      if ((x == "?" && y == "?") || y != " ")
+        print path
+    }' |
+    grep -E '\.py$' || true
+)"
+
+if [[ -z "$py_files" ]]; then
+  echo "No forgotten .py files detected."
+  exit 0
+fi
+
+echo "Potential forgotten Python files:"
+printf "%s\n" "$py_files"
+exit 1

ennbo-0.0.4/examples/demo_enn.ipynb

@@ -0,0 +1,133 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "534cb992",
+   "metadata": {},
+   "source": [
+    "# Epistemic Nearest Neighbors (ENN)\n",
+    "\n",
+    "ENN is a non-parametric surrogate with $O(N)$ computation-time scaling, where $N$ is the number of observations in the data set. ENN can be used in Bayesian optimization as a scalable alternative to a GP (which scales as $O(N^2)$.)\n",
+    "\n",
+    "**Sweet, D., & Jadhav, S. A. (2025).** Taking the GP Out of the Loop. *arXiv preprint arXiv:2506.12818*.  \n",
+    "   https://arxiv.org/abs/2506.12818\n",
+    "\n",
+    "   ---"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8792c830",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "from enn import EpistemicNearestNeighbors, enn_fit\n",
+    "\n",
+    "\n",
+    "def plot_enn_demo(ax, num_samples: int, k: int, noise: float, m: int = 1) -> None:\n",
+    "    x = np.random.rand(num_samples)\n",
+    "    eps = np.random.randn(num_samples)\n",
+    "    y = np.sin(2 * m * np.pi * x) + noise * eps\n",
+    "    yvar = (noise**2) * np.ones_like(y)\n",
+    "    train_x = x[:, None]\n",
+    "    train_y = y[:, None]\n",
+    "    train_yvar = yvar[:, None]\n",
+    "    model = EpistemicNearestNeighbors(train_x, train_y, train_yvar, hnsw_threshold=None)\n",
+    "    rng = np.random.default_rng(0)\n",
+    "    result = enn_fit(\n",
+    "        model,\n",
+    "        num_fit_candidates=30,\n",
+    "        num_fit_samples=min(10, num_samples),\n",
+    "        rng=rng,\n",
+    "    )\n",
+    "    print(result)\n",
+    "    params = result\n",
+    "    x_hat = np.linspace(0.0, 1.0, 30)\n",
+    "    x_hat_2d = x_hat[:, None]\n",
+    "    posterior = model.posterior(x_hat_2d, params=params, exclude_nearest=False)\n",
+    "    mu = posterior.mu[:, 0]\n",
+    "    se = posterior.se[:, 0]\n",
+    "    marker_size = 3 if num_samples >= 100 else 15\n",
+    "    ax.scatter(x, y, s=marker_size, color=\"black\", alpha=0.5)\n",
+    "    ax.plot(x_hat, mu, linestyle=\"--\", color=\"tab:blue\", alpha=0.7)\n",
+    "    ax.fill_between(x_hat, mu - 2 * se, mu + 2 * se, color=\"tab:blue\", alpha=0.2)\n",
+    "    ax.set_ylim(-5, 5)\n",
+    "    ax.set_title(f\"n={num_samples}, noise={noise}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "992d16f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "k = 5\n",
+    "fig, axes = plt.subplots(2, 3, figsize=(9, 6), sharex=True, sharey=True)\n",
+    "num_samples_list = [5, 10]\n",
+    "noise_list = [0.0, 0.1, 0.3]\n",
+    "for row_idx, num_samples in enumerate(num_samples_list):\n",
+    "    for col_idx, noise in enumerate(noise_list):\n",
+    "        ax = axes[row_idx, col_idx]\n",
+    "        np.random.seed(1)\n",
+    "        plot_enn_demo(ax, num_samples=num_samples, k=k, noise=noise)\n",
+    "for ax in axes[-1, :]:\n",
+    "    ax.set_xlabel(\"x\")\n",
+    "for ax in axes[:, 0]:\n",
+    "    ax.set_ylabel(\"y\")\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84968071",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "np.random.seed(1)\n",
+    "fig, ax = plt.subplots(figsize=(5, 3))\n",
+    "t_0 = time.time()\n",
+    "plot_enn_demo(ax, num_samples=1_000_000, k=5, noise=0.3, m=3)\n",
+    "t_1 = time.time()\n",
+    "print(f\"Time taken: {t_1 - t_0:.2f} seconds\")\n",
+    "ax.set_xlabel(\"x\")\n",
+    "ax.set_ylabel(\"y\")\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7f4a8ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8f018dc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

ennbo-0.0.4/examples/demo_turbo_enn.ipynb

@@ -0,0 +1,223 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TuRBO-ENN\n",
+    "\n",
+    "This code implements TuRBO [1], a SOTA Bayesian optimization algorithm.\n",
+    "\n",
+    "The optimization class, `Turbo`, supports four modes of operation.\n",
+    "\n",
+    "**LHD_ONLY**  \n",
+    "Generate a Latin Hypercube Design (LHD) for every batch of arms. This is included as a simple baseline.\n",
+    "\n",
+    "**TURBO_ZERO**  \n",
+    "Initialze with LHD. Afterward, sample near the best-so-far x value, x_best. Samples are \"near\" x_best in two senses: (i) They are in a trust region, an adaptively-sized box around x_best, and (ii) They perturb only a small number of dimensions using RAASP sampling [2]. Other dimensions take the same value as in x_best. The num_arms proposals are chosen randomly from RAASP candidates inside the trust region.\n",
+    "\n",
+    "This is included to help differentiate the impact of the trust region from the impact of the surrogate. Notice (below) that the trust region has high impact.\n",
+    "\n",
+    "**TURBO_ONE**  \n",
+    "This adds a GP surrogate to TURBO_ZERO. The num_arms proposals are chosen via Thompson sampling from RAASP candidates inside the trust region. Occasionally, the trust region adapter resets and (i) discards all observations, and (ii) begins anew with and LHD design.\n",
+    "\n",
+    "This is the standard SOTA method. It should match the TuRBO reference [implementation](https://github.com/uber-research/TuRBO). \n",
+    "\n",
+    "**TURBO_ENN**  \n",
+    "This replaces the GP surrogate with a simpler, more scalable surrogate called Epistemic Nearest Neighbors (ENN). ENN's proposal time scales as $O(N)$ rather than the $O(N^2)$ of a GP surrogate. [3]\n",
+    "\n",
+    "\n",
+    "## References\n",
+    "\n",
+    "1. **Eriksson, D., Pearce, M., Gardner, J. R., Turner, R., & Poloczek, M. (2020).** Scalable Global Optimization via Local Bayesian Optimization. *Advances in Neural Information Processing Systems, 32*.  \n",
+    "   https://arxiv.org/abs/1910.01739\n",
+    "\n",
+    "2. **Rashidi, B., Johnstonbaugh, K., & Gao, C. (2024).** Cylindrical Thompson Sampling for High-Dimensional Bayesian Optimization. *Proceedings of The 27th International Conference on Artificial Intelligence and Statistics* (pp. 3502–3510). PMLR.  \n",
+    "   https://proceedings.mlr.press/v238/rashidi24a.html\n",
+    "\n",
+    "3. **Sweet, D., & Jadhav, S. A. (2025).** Taking the GP Out of the Loop. *arXiv preprint arXiv:2506.12818*.  \n",
+    "   https://arxiv.org/abs/2506.12818\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "class Ackley:\n",
+    "    def __init__(self):\n",
+    "        self.a = 20.0\n",
+    "        self.b = 0.2\n",
+    "        self.c = 2 * np.pi\n",
+    "        self.bounds = [-32.768, 32.768]\n",
+    "\n",
+    "    def __call__(self, x):\n",
+    "        x = np.asarray(x, dtype=float)\n",
+    "        if x.ndim == 1:\n",
+    "            x = x[None, :]\n",
+    "        x = x - 1\n",
+    "        y = (\n",
+    "            -self.a * np.exp(-self.b * np.sqrt((x**2).mean(axis=1)))\n",
+    "            - np.exp(np.cos(self.c * x).mean(axis=1))\n",
+    "            + self.a\n",
+    "            + np.e\n",
+    "        )\n",
+    "        result = -y\n",
+    "        return result if result.ndim > 0 else float(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "from enn import TurboMode, Turbo\n",
+    "\n",
+    "\n",
+    "def run_optimization(turbo_mode: TurboMode):\n",
+    "    num_dim = 100\n",
+    "    num_iterations = 100\n",
+    "    num_arms = 100\n",
+    "\n",
+    "    objective = Ackley()\n",
+    "    bounds = np.array([objective.bounds] * num_dim, dtype=float)\n",
+    "\n",
+    "    rng = np.random.default_rng(42)\n",
+    "    optimizer = Turbo(\n",
+    "        bounds=bounds,\n",
+    "        mode=turbo_mode,\n",
+    "        num_arms=num_arms,\n",
+    "        rng=rng,\n",
+    "        k=10,\n",
+    "    )\n",
+    "\n",
+    "    best_values = []\n",
+    "    proposal_times = []\n",
+    "    best_y = -np.inf\n",
+    "\n",
+    "    for iteration in range(num_iterations):\n",
+    "        t_0 = time.time()\n",
+    "        x_candidates = optimizer.ask(num_arms=num_arms)\n",
+    "        t_1 = time.time()\n",
+    "        proposal_times.append(t_1 - t_0)\n",
+    "\n",
+    "        y_values = objective(x_candidates)\n",
+    "\n",
+    "        optimizer.tell(x_candidates, y_values)\n",
+    "\n",
+    "        current_best = float(np.max(y_values))\n",
+    "        if current_best > best_y:\n",
+    "            best_y = current_best\n",
+    "        best_values.append(best_y)\n",
+    "        if iteration % 10 == 0:\n",
+    "            print(f\"Iteration {iteration} best value: {best_y}\")\n",
+    "\n",
+    "    evals = num_arms * np.arange(len(best_values))\n",
+    "    return best_values, proposal_times, evals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# TURBO_ONE is too slow for my patience right now.\n",
+    "# It's now an exercise for the reader.\n",
+    "RUN_TURBO_ONE = False\n",
+    "\n",
+    "best_values_zero, proposal_times_zero, evals_zero = run_optimization(\n",
+    "    TurboMode.TURBO_ZERO\n",
+    ")\n",
+    "if RUN_TURBO_ONE:\n",
+    "    best_values_one, proposal_times_one, evals_one = run_optimization(\n",
+    "        TurboMode.TURBO_ONE\n",
+    "    )\n",
+    "best_values_enn, proposal_times_enn, evals_enn = run_optimization(TurboMode.TURBO_ENN)\n",
+    "best_values_lhd, proposal_times_lhd, evals_lhd = run_optimization(TurboMode.LHD_ONLY)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(evals_zero, best_values_zero, linewidth=2, label=\"TURBO_ZERO\")\n",
+    "plt.plot(evals_enn, best_values_enn, linewidth=2, label=\"TURBO_ENN\")\n",
+    "plt.plot(evals_lhd, best_values_lhd, linewidth=2, label=\"LHD_ONLY\")\n",
+    "if RUN_TURBO_ONE:\n",
+    "    plt.plot(evals_one, best_values_one, linewidth=2, label=\"TURBO_ONE\")\n",
+    "plt.xlabel(\"Function Evaluations\")\n",
+    "plt.ylabel(\"Best Function Value\")\n",
+    "plt.title(\"Convergence Comparison: All Turbo Modes\")\n",
+    "plt.legend()\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(evals_zero, proposal_times_zero, linewidth=2, label=\"TURBO_ZERO\")\n",
+    "plt.plot(evals_enn, proposal_times_enn, linewidth=2, label=\"TURBO_ENN\")\n",
+    "plt.plot(evals_lhd, proposal_times_lhd, linewidth=2, label=\"LHD_ONLY\")\n",
+    "if RUN_TURBO_ONE:\n",
+    "    plt.plot(evals_one, proposal_times_one, linewidth=2, label=\"TURBO_ONE\")\n",
+    "plt.xlabel(\"Function Evaluations\")\n",
+    "plt.ylabel(\"Proposal Time (seconds)\")\n",
+    "plt.title(\"Proposal Time vs Function Evaluations: All Turbo Modes\")\n",
+    "# c = plt.axis()\n",
+    "# plt.axis([c[0], c[1], 0, 5])\n",
+    "plt.legend()\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

ennbo-0.0.4/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ennbo"
+version = "0.0.4"
+description = "Epistemic Nearest Neighbors"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE" }
+authors = [
+  { name = "YUBO Lab", email = "david.sweet@yu.edu" },
+]
+dependencies = [
+    "numpy==1.26.4",
+    "torch==2.5.1",
+    "gpytorch==1.13",
+    "faiss==1.9.0",
+    "scipy==1.15.3",
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://github.com/yubo-research/enn"
+Source = "https://github.com/yubo-research/enn"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/enn"]

ennbo-0.0.4/requirements.md

@@ -0,0 +1,15 @@
+
+YOU MAY NOT ALTER THIS DOCUMENT.
+
+# REQUIREMENTS
+- Follow ../bbo/turbo_m_ref/gp.py for the GP. Use GPyTorch and Adam.
+- Use ExactGP.posterior().sample() for Thompson sampling. You need to take a joint sample for TS to work.
+- No comments or docstrings.
+- All code should take a user-defined rng. Take torch.Generator and/or np.random.generator objects.
+- Only one class per file. MyClass -> my_class.py.
+- The surrogate (GP or ENN) should be refit for *every* proposal (ask()).
+- Use lazy importing: If at all possible, do not import at the module level. This helps keep imports fast. `if TYPE_CHECKING:` is your friend.
+- Optimizer parameter defaults should follow ../bbo/turbo_ref/*.py
+- There should be at least one unit test for each new function. Make it a good one.
+
+YOU MAY NOT ALTER THIS DOCUMENT.