leanhebo 0.1.0__tar.gz

leanhebo-0.1.0/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to LeanHEBO will be documented here.
+
+## 0.1.0 - 2026-08-09
+
+- Establish the independent `uv` project and provenance boundary.
+- Implement the initial exact-GP LeanHEBO optimization path.
+- Fit and checkpoint the HEBO-compatible observed-range input scaler used by the exact GP.
+- Preserve append-only observation state, reserved duplicate keys, diagnostics, search history,
+  and exact version counters across safe checkpoints.
+- Raise a typed exhaustion error instead of silently returning duplicate suggestions.
+- Retry numerical fit or posterior failures once with a clean full GP refit.
+- Add a pinned, dependency-locked upstream benchmark environment and a fail-closed paired
+  comparison harness with actual-work checks and bootstrap confidence intervals.

leanhebo-0.1.0/CITATION.cff

@@ -0,0 +1,46 @@
+cff-version: 1.2.0
+message: "If you use LeanHEBO, cite both LeanHEBO and the original HEBO work."
+title: "LeanHEBO"
+type: software
+version: 0.1.0
+date-released: 2026-08-09
+license: MIT
+authors:
+  - name: "LeanHEBO contributors"
+repository-code: "https://github.com/dimitrismoustakas/LeanHEBO"
+references:
+  - type: article
+    title: "HEBO: Pushing the Limits of Sample-Efficient Hyperparameter Optimisation"
+    authors:
+      - family-names: Cowen-Rivers
+        given-names: Alexander I.
+      - family-names: Lyu
+        given-names: Wenlong
+      - family-names: Tutunov
+        given-names: Rasul
+      - family-names: Wang
+        given-names: Zhi
+      - family-names: Grosnit
+        given-names: Antoine
+      - family-names: Griffiths
+        given-names: Ryan-Rhys
+      - family-names: Maravel
+        given-names: Alexandre M.
+      - family-names: Hao
+        given-names: Jianye
+      - family-names: Wang
+        given-names: Jun
+      - family-names: Peters
+        given-names: Jan
+      - family-names: Bou-Ammar
+        given-names: Haitham
+    journal: "Journal of Artificial Intelligence Research"
+    volume: 74
+    year: 2022
+    doi: "10.1613/jair.1.13643"
+  - type: software
+    title: "HEBO"
+    authors:
+      - name: "Huawei Technologies Co., Ltd."
+    repository-code: "https://github.com/huawei-noah/HEBO"
+    version: "ee6112d39d1a9e9703fecaf9057193e1ec9dae72"

leanhebo-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (C) 2019. Huawei Technologies Co., Ltd. All rights reserved.
+Copyright (c) 2026 LeanHEBO contributors
+
+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.

leanhebo-0.1.0/NOTICE.md

@@ -0,0 +1,14 @@
+# Notice
+
+LeanHEBO is an independent implementation derived in part from the HEBO project by
+Huawei Technologies Co., Ltd. It is not affiliated with, sponsored by, or endorsed by
+Huawei.
+
+- Upstream project: <https://github.com/huawei-noah/HEBO>
+- Audited package: `HEBO/`
+- Audited commit: `ee6112d39d1a9e9703fecaf9057193e1ec9dae72`
+- Upstream license: MIT
+
+The HEBO method is described by Cowen-Rivers et al., “HEBO: Pushing the Limits of
+Sample-Efficient Hyperparameter Optimisation,” *Journal of Artificial Intelligence
+Research*, volume 74, 2022.

leanhebo-0.1.0/ORIGIN.md

@@ -0,0 +1,23 @@
+# Code origin
+
+LeanHEBO reimplements the main single-objective exact-GP path of Huawei's HEBO package,
+audited at commit `ee6112d39d1a9e9703fecaf9057193e1ec9dae72`.
+
+## Reimplemented components
+
+- mixed-variable design-space encoding and Sobol sampling;
+- output standardization and Box-Cox/Yeo-Johnson transformation behavior;
+- exact Gaussian-process regression and HEBO-compatible kernel construction;
+- the three-objective MACE acquisition calculation;
+- HEBO-style batch candidate selection.
+
+## Independently implemented components
+
+- immutable compiled-space metadata and `CandidateBatch` boundary;
+- append-only tensor observation storage and incremental duplicate membership;
+- persistent GP/model/optimizer lifecycle;
+- tensor-native mixed-variable NSGA-II;
+- configuration, diagnostics, checkpointing, and optional table adapters.
+
+Files that substantially copy upstream implementation text must retain Huawei copyright
+headers. New implementations use SPDX identifiers and refer to `NOTICE.md`.

leanhebo-0.1.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: leanhebo
+Version: 0.1.0
+Summary: A tensor-native, low-latency implementation of the HEBO method
+Keywords: bayesian-optimization,gaussian-process,hebo,pytorch
+Author: LeanHEBO contributors
+License-Expression: MIT
+License-File: LICENSE
+License-File: NOTICE.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: gpytorch>=1.14
+Requires-Dist: numpy>=2.0
+Requires-Dist: torch>=2.5
+Requires-Dist: pandas>=2.2 ; extra == 'pandas'
+Requires-Dist: polars>=1.0 ; extra == 'polars'
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/dimitrismoustakas/LeanHEBO
+Project-URL: Repository, https://github.com/dimitrismoustakas/LeanHEBO
+Project-URL: Issues, https://github.com/dimitrismoustakas/LeanHEBO/issues
+Project-URL: Changelog, https://github.com/dimitrismoustakas/LeanHEBO/blob/main/CHANGELOG.md
+Provides-Extra: pandas
+Provides-Extra: polars
+Description-Content-Type: text/markdown
+
+# LeanHEBO
+
+LeanHEBO is a tensor-native, low-latency implementation of the established HEBO Bayesian
+optimization strategy. It focuses on the single-objective exact-GP path, persistent model
+state, mixed-variable search, and explicit CPU or CUDA execution.
+
+LeanHEBO is an independent project. It is not affiliated with or endorsed by Huawei and
+does not claim a new optimization algorithm. See
+[NOTICE.md](https://github.com/dimitrismoustakas/LeanHEBO/blob/main/NOTICE.md) and
+[ORIGIN.md](https://github.com/dimitrismoustakas/LeanHEBO/blob/main/ORIGIN.md) for provenance.
+
+The package is under active initial development. Its first release targets continuous,
+log-continuous, integer, stepped-integer, power/exponent-integer, Boolean, and categorical
+variables; batch and contextual suggestions; HEBO output warping; MACE acquisition; and a
+tensor-native NSGA-II search.
+
+## Installation
+
+LeanHEBO requires Python 3.11 or newer; the initial release is tested on Python 3.11 through
+3.13. Install the released package with either pip or uv:
+
+```console
+python -m pip install leanhebo
+```
+
+```console
+uv add leanhebo
+```
+
+Pandas and Polars adapters are optional extras:
+
+```console
+python -m pip install "leanhebo[pandas,polars]"
+# or: uv add "leanhebo[pandas,polars]"
+```
+
+CPU is the primary supported path for the initial alpha release. CUDA execution is available,
+but accelerator support depends on the Torch build and the local CUDA stack. Install the
+appropriate Torch build using the [PyTorch installation guide](https://pytorch.org/get-started/locally/)
+before installing LeanHEBO; the package does not silently switch between CPU and CUDA.
+
+## Quick start
+
+LeanHEBO minimizes the objective values supplied to `observe`. This complete example optimizes
+a small mixed-variable loss:
+
+```python
+import numpy as np
+
+from leanhebo import LeanHEBO
+from leanhebo.config import GPConfig, LeanHEBOConfig, RuntimeConfig, SearchConfig
+from leanhebo.space import Bool, Categorical, Float, Integer, Space
+
+
+def objective(row: dict[str, object]) -> float:
+    """Return a loss: LeanHEBO minimizes the values passed to observe."""
+    x = float(row["x"])
+    depth = int(row["depth"])
+    activation_penalty = 0.0 if row["activation"] == "gelu" else 0.25
+    bias_penalty = 0.0 if bool(row["use_bias"]) else 0.1
+    return (x - 0.3) ** 2 + (depth - 6) ** 2 / 25 + activation_penalty + bias_penalty
+
+
+space = Space(
+    Float("x", -2.0, 2.0),
+    Integer("depth", 1, 12),
+    Categorical("activation", ("relu", "gelu", "silu")),
+    Bool("use_bias"),
+)
+config = LeanHEBOConfig(
+    runtime=RuntimeConfig(seed=7),
+    # Small settings keep this example quick; use the defaults for real optimization.
+    gp=GPConfig(initial_steps=15, update_steps=3),
+    search=SearchConfig(population_size=32, generations=15),
+)
+optimizer = LeanHEBO(space, config=config)
+
+for _ in range(3):
+    candidates = optimizer.suggest(3)
+    losses = np.asarray([objective(row) for row in candidates.to_records()])
+    optimizer.observe(candidates, losses)
+
+print(optimizer.best_x.to_records()[0], optimizer.best_y)
+```
+
+Passing the original `CandidateBatch` to `observe` avoids re-encoding; the observation store takes
+one owned tensor snapshot so later caller mutation cannot rewrite history. Records, NumPy arrays,
+Pandas DataFrames, and Polars DataFrames are also accepted at the boundary and encoded once.
+
+Contextual values are fixed without a DataFrame round trip:
+
+```python
+candidates = optimizer.suggest(8, fix_input={"use_bias": True})
+```
+
+```python
+candidates = optimizer.suggest(3)
+frame = candidates.to_polars()  # or candidates.to_pandas()
+losses = np.asarray([objective(row) for row in candidates.to_records()])
+optimizer.observe(frame, losses)
+```
+
+## Runtime behavior
+
+Runtime code keeps encoded observations, transforms, GP state, acquisition evaluation, random
+streams, and evolutionary populations in Torch. NumPy and optional table libraries are boundary
+formats only. The GP and likelihood survive ordinary updates; new training data are installed
+with GPyTorch's persistent exact-GP API and receive the configured short update schedule.
+
+CPU is the default. CUDA is selected explicitly with `RuntimeConfig(device="cuda")`; LeanHEBO
+does not silently move work between devices. Both `float32` and `float64` are supported. The
+project is currently alpha software: CPU behavior receives the broadest release validation,
+while CUDA compatibility can vary across Torch, driver, and device combinations.
+
+Importing LeanHEBO does not change Torch or BLAS thread counts. Applications that want an
+explicit process-wide policy should call the startup helper before other Torch work:
+
+```python
+from leanhebo.runtime import configure_process
+
+configure_process(torch_num_threads=1, torch_num_interop_threads=1)
+```
+
+Every configuration group has one documented set of defaults and serializes with
+`optimizer.config.to_dict()`. There are no hidden execution modes or preset profiles.
+
+## Checkpointing
+
+```python
+optimizer.save("run.leanhebo")
+restored = LeanHEBO.load("run.leanhebo", map_location="cpu")
+```
+
+The versioned checkpoint contains only LeanHEBO-defined state, tensors, and primitive schema
+values. It restores observations, transforms, model and likelihood parameters, optimizer state,
+Sobol progress, and independent Torch generator states. User functions are never pickled.
+
+## Scope
+
+The initial implementation is intentionally narrow: one user objective, an exact Gaussian
+process, MACE, and mixed-variable NSGA-II. Random forests, CatBoost, neural ensembles, sparse
+GPs, constrained user objectives, and general multi-objective user objectives are not part of
+the first release.
+
+No performance or quality claim should be made without the pinned, matched-work benchmark and
+multi-seed quality suite described in
+[benchmarks/README.md](https://github.com/dimitrismoustakas/LeanHEBO/blob/main/benchmarks/README.md).
+
+## Development
+
+```console
+uv sync --all-groups --all-extras
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy src/leanhebo
+uv build
+```
+
+The repository uses Python 3.11+, a `src/` layout, the pure-Python `uv_build` backend, and a
+committed CPU development lock. Optional accelerator environments should override only the
+explicit Torch package index.

leanhebo-0.1.0/README.md

@@ -0,0 +1,162 @@
+# LeanHEBO
+
+LeanHEBO is a tensor-native, low-latency implementation of the established HEBO Bayesian
+optimization strategy. It focuses on the single-objective exact-GP path, persistent model
+state, mixed-variable search, and explicit CPU or CUDA execution.
+
+LeanHEBO is an independent project. It is not affiliated with or endorsed by Huawei and
+does not claim a new optimization algorithm. See
+[NOTICE.md](https://github.com/dimitrismoustakas/LeanHEBO/blob/main/NOTICE.md) and
+[ORIGIN.md](https://github.com/dimitrismoustakas/LeanHEBO/blob/main/ORIGIN.md) for provenance.
+
+The package is under active initial development. Its first release targets continuous,
+log-continuous, integer, stepped-integer, power/exponent-integer, Boolean, and categorical
+variables; batch and contextual suggestions; HEBO output warping; MACE acquisition; and a
+tensor-native NSGA-II search.
+
+## Installation
+
+LeanHEBO requires Python 3.11 or newer; the initial release is tested on Python 3.11 through
+3.13. Install the released package with either pip or uv:
+
+```console
+python -m pip install leanhebo
+```
+
+```console
+uv add leanhebo
+```
+
+Pandas and Polars adapters are optional extras:
+
+```console
+python -m pip install "leanhebo[pandas,polars]"
+# or: uv add "leanhebo[pandas,polars]"
+```
+
+CPU is the primary supported path for the initial alpha release. CUDA execution is available,
+but accelerator support depends on the Torch build and the local CUDA stack. Install the
+appropriate Torch build using the [PyTorch installation guide](https://pytorch.org/get-started/locally/)
+before installing LeanHEBO; the package does not silently switch between CPU and CUDA.
+
+## Quick start
+
+LeanHEBO minimizes the objective values supplied to `observe`. This complete example optimizes
+a small mixed-variable loss:
+
+```python
+import numpy as np
+
+from leanhebo import LeanHEBO
+from leanhebo.config import GPConfig, LeanHEBOConfig, RuntimeConfig, SearchConfig
+from leanhebo.space import Bool, Categorical, Float, Integer, Space
+
+
+def objective(row: dict[str, object]) -> float:
+    """Return a loss: LeanHEBO minimizes the values passed to observe."""
+    x = float(row["x"])
+    depth = int(row["depth"])
+    activation_penalty = 0.0 if row["activation"] == "gelu" else 0.25
+    bias_penalty = 0.0 if bool(row["use_bias"]) else 0.1
+    return (x - 0.3) ** 2 + (depth - 6) ** 2 / 25 + activation_penalty + bias_penalty
+
+
+space = Space(
+    Float("x", -2.0, 2.0),
+    Integer("depth", 1, 12),
+    Categorical("activation", ("relu", "gelu", "silu")),
+    Bool("use_bias"),
+)
+config = LeanHEBOConfig(
+    runtime=RuntimeConfig(seed=7),
+    # Small settings keep this example quick; use the defaults for real optimization.
+    gp=GPConfig(initial_steps=15, update_steps=3),
+    search=SearchConfig(population_size=32, generations=15),
+)
+optimizer = LeanHEBO(space, config=config)
+
+for _ in range(3):
+    candidates = optimizer.suggest(3)
+    losses = np.asarray([objective(row) for row in candidates.to_records()])
+    optimizer.observe(candidates, losses)
+
+print(optimizer.best_x.to_records()[0], optimizer.best_y)
+```
+
+Passing the original `CandidateBatch` to `observe` avoids re-encoding; the observation store takes
+one owned tensor snapshot so later caller mutation cannot rewrite history. Records, NumPy arrays,
+Pandas DataFrames, and Polars DataFrames are also accepted at the boundary and encoded once.
+
+Contextual values are fixed without a DataFrame round trip:
+
+```python
+candidates = optimizer.suggest(8, fix_input={"use_bias": True})
+```
+
+```python
+candidates = optimizer.suggest(3)
+frame = candidates.to_polars()  # or candidates.to_pandas()
+losses = np.asarray([objective(row) for row in candidates.to_records()])
+optimizer.observe(frame, losses)
+```
+
+## Runtime behavior
+
+Runtime code keeps encoded observations, transforms, GP state, acquisition evaluation, random
+streams, and evolutionary populations in Torch. NumPy and optional table libraries are boundary
+formats only. The GP and likelihood survive ordinary updates; new training data are installed
+with GPyTorch's persistent exact-GP API and receive the configured short update schedule.
+
+CPU is the default. CUDA is selected explicitly with `RuntimeConfig(device="cuda")`; LeanHEBO
+does not silently move work between devices. Both `float32` and `float64` are supported. The
+project is currently alpha software: CPU behavior receives the broadest release validation,
+while CUDA compatibility can vary across Torch, driver, and device combinations.
+
+Importing LeanHEBO does not change Torch or BLAS thread counts. Applications that want an
+explicit process-wide policy should call the startup helper before other Torch work:
+
+```python
+from leanhebo.runtime import configure_process
+
+configure_process(torch_num_threads=1, torch_num_interop_threads=1)
+```
+
+Every configuration group has one documented set of defaults and serializes with
+`optimizer.config.to_dict()`. There are no hidden execution modes or preset profiles.
+
+## Checkpointing
+
+```python
+optimizer.save("run.leanhebo")
+restored = LeanHEBO.load("run.leanhebo", map_location="cpu")
+```
+
+The versioned checkpoint contains only LeanHEBO-defined state, tensors, and primitive schema
+values. It restores observations, transforms, model and likelihood parameters, optimizer state,
+Sobol progress, and independent Torch generator states. User functions are never pickled.
+
+## Scope
+
+The initial implementation is intentionally narrow: one user objective, an exact Gaussian
+process, MACE, and mixed-variable NSGA-II. Random forests, CatBoost, neural ensembles, sparse
+GPs, constrained user objectives, and general multi-objective user objectives are not part of
+the first release.
+
+No performance or quality claim should be made without the pinned, matched-work benchmark and
+multi-seed quality suite described in
+[benchmarks/README.md](https://github.com/dimitrismoustakas/LeanHEBO/blob/main/benchmarks/README.md).
+
+## Development
+
+```console
+uv sync --all-groups --all-extras
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy src/leanhebo
+uv build
+```
+
+The repository uses Python 3.11+, a `src/` layout, the pure-Python `uv_build` backend, and a
+committed CPU development lock. Optional accelerator environments should override only the
+explicit Torch package index.

leanhebo-0.1.0/examples/adapters.py

@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: MIT
+
+"""Optional table adapters remain outside the optimization hot path."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from leanhebo import LeanHEBO
+from leanhebo.config import LeanHEBOConfig, RuntimeConfig
+from leanhebo.space import Categorical, Float, Space
+
+space = Space(Float("x", -1.0, 1.0), Categorical("kind", ("left", "right")))
+optimizer = LeanHEBO(space, config=LeanHEBOConfig(runtime=RuntimeConfig(seed=3)))
+
+candidates = optimizer.suggest(4)
+pandas_frame = candidates.to_pandas()
+polars_frame = candidates.to_polars()
+assert pandas_frame.shape == polars_frame.shape
+
+values = np.square(pandas_frame["x"].to_numpy())
+optimizer.observe(candidates, values)  # reuses CandidateBatch tensors

leanhebo-0.1.0/examples/basic.py

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: MIT
+
+"""A small mixed-variable LeanHEBO loop."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from leanhebo import LeanHEBO
+from leanhebo.config import GPConfig, LeanHEBOConfig, RuntimeConfig, SearchConfig
+from leanhebo.space import Bool, Categorical, Float, Integer, Space
+
+
+def objective(row: dict[str, object]) -> float:
+    x = float(row["x"])
+    depth = int(row["depth"])
+    category_penalty = 0.0 if row["activation"] == "gelu" else 0.25
+    bias_penalty = 0.0 if bool(row["use_bias"]) else 0.1
+    return (x - 0.3) ** 2 + (depth - 6) ** 2 / 25 + category_penalty + bias_penalty
+
+
+space = Space(
+    Float("x", -2.0, 2.0),
+    Integer("depth", 1, 12),
+    Categorical("activation", ("relu", "gelu", "silu")),
+    Bool("use_bias"),
+)
+config = LeanHEBOConfig(
+    runtime=RuntimeConfig(seed=7),
+    gp=GPConfig(initial_steps=30, update_steps=5),
+    search=SearchConfig(population_size=64, generations=30),
+)
+optimizer = LeanHEBO(space, config=config)
+
+for _ in range(12):
+    batch = optimizer.suggest(3)
+    y = np.asarray([objective(record) for record in batch.to_records()])
+    optimizer.observe(batch, y)
+
+print(optimizer.best_x.to_records()[0], optimizer.best_y)

leanhebo-0.1.0/examples/contextual_checkpoint.py

@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: MIT
+
+"""Contextual suggestions and deterministic checkpoint continuation."""
+
+from __future__ import annotations
+
+from leanhebo import LeanHEBO
+from leanhebo.config import LeanHEBOConfig, RuntimeConfig
+from leanhebo.space import Categorical, Float, Space
+
+space = Space(Float("dose", 0.0, 1.0), Categorical("site", ("north", "south")))
+optimizer = LeanHEBO(space, config=LeanHEBOConfig(runtime=RuntimeConfig(seed=19)))
+
+south_batch = optimizer.suggest(4, fix_input={"site": "south"})
+assert all(record["site"] == "south" for record in south_batch.to_records())
+
+optimizer.save("contextual.leanhebo")
+restored = LeanHEBO.load("contextual.leanhebo", map_location="cpu")
+next_batch = restored.suggest(2, fix_input={"site": "south"})
+print(next_batch.to_records())

leanhebo-0.1.0/pyproject.toml

@@ -0,0 +1,120 @@
+[project]
+name = "leanhebo"
+version = "0.1.0"
+description = "A tensor-native, low-latency implementation of the HEBO method"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = [
+    "LICENSE",
+    "NOTICE.md",
+]
+keywords = [
+    "bayesian-optimization",
+    "gaussian-process",
+    "hebo",
+    "pytorch",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "gpytorch>=1.14",
+    "numpy>=2.0",
+    "torch>=2.5",
+]
+
+[[project.authors]]
+name = "LeanHEBO contributors"
+
+[project.urls]
+Homepage = "https://github.com/dimitrismoustakas/LeanHEBO"
+Repository = "https://github.com/dimitrismoustakas/LeanHEBO"
+Issues = "https://github.com/dimitrismoustakas/LeanHEBO/issues"
+Changelog = "https://github.com/dimitrismoustakas/LeanHEBO/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+pandas = ["pandas>=2.2"]
+polars = ["polars>=1.0"]
+
+[dependency-groups]
+dev = [
+    "hypothesis>=6.100",
+    "mypy>=1.11",
+    "pandas>=2.2",
+    "polars>=1.0",
+    "pre-commit>=3.7",
+    "pymoo>=0.6",
+    "pytest>=8",
+    "pytest-cov>=5",
+    "ruff>=0.6",
+    "scikit-learn>=1.5",
+    "scipy>=1.14",
+]
+bench = [
+    "asv>=0.6",
+    "psutil>=6",
+    "py-spy>=0.4",
+    "pytest-benchmark>=4",
+]
+
+[build-system]
+requires = ["uv_build>=0.12.0,<0.13"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "leanhebo"
+module-root = "src"
+source-include = [
+    "CHANGELOG.md",
+    "CITATION.cff",
+    "ORIGIN.md",
+    "examples/**",
+]
+
+[tool.pytest.ini_options]
+addopts = "-ra --strict-config --strict-markers"
+testpaths = ["tests"]
+markers = [
+    "gpu: requires a CUDA-capable Torch installation",
+    "performance: structural or timing performance tests",
+]
+
+[tool.coverage.run]
+branch = true
+source = ["leanhebo"]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+    "UP",
+    "B",
+    "SIM",
+    "RUF",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_unreachable = true
+packages = ["leanhebo"]
+mypy_path = "src"