GraphCanon updated 2w · GitHub synced 2w
Decision brief
hypertunity is a Python library that facilitates black-box hyperparameter optimisation using techniques such as Bayesian Optimization.
Good fit when
- When you are working with complex objective functions that are expensive to evaluate, and you need an automated way to optimize your model parameters.
- If you prefer tools that integrate well with Python's ecosystem and you are looking for visual feedback on optimization progress through Tensorboard.
Avoid when
- When the objective function evaluation is inexpensive or fast because hypertunity shines in scenarios where evaluations are costly, offering less benefit if evaluations can be easily repeated.
- If your project does not require advanced techniques such as Bayesian Optimization and you seek a simpler method with fewer dependencies.
- Requirements:
- Min 2 GB RAM; Support for SLURM is indicated in the topics, useful for HPC cluster management but not a hard requirement.
Observed Jul 17, 2026 · Source: enrich:decision_facts
Verify the decision
Maintenance and security
Full trust report- Maintenance
- Dormant (2381d since push)
- As of 2w
- Provenance
- Not a fork · Personal account
- As of 2w
- Security (OSV)
- No lockfile
- As of 1mo
Public GitHub metadata and optional OSV scans. Signals, not a guarantee. Trust methodology.
Install
pip install hypertunity PyPISimilar tools
Same-category neighbours. No typed graph edges are catalogued for this tool yet.
Evidence and technical details
Sourced facts, taxonomy, compatibility claims, README excerpt, and machine-readable endpoints.
Overview
hypertunity is a Python library focused on automating the optimization of hyperparameters using techniques like Bayesian Optimization.
Capability facts
- Languages
- python
Source: github.language · Aug 4, 2026
Categories
Compatibility
Sourced claims from the README excerpt - not unsourced marketing copy.
Source: README excerpt (regex_v1, Aug 4, 2026)
```python import hypertunity as htSource link
Tags
README
Quick start
Define the objective function to optimise. For example, it can take the hyperparameters params as input and
return a raw value score as output:
import hypertunity as ht
def foo(**params) -> float:
# do some very costly computations
...
return score
To define the valid ranges for the values of params we create a Domain object:
domain = ht.Domain({
"x": [-10., 10.], # continuous variable within the interval [-10., 10.]
"y": {"opt1", "opt2"}, # categorical variable from the set {"opt1", "opt2"}
"z": set(range(4)) # discrete variable from the set {0, 1, 2, 3}
})
Then we set up the optimiser:
bo = ht.BayesianOptimisation(domain=domain)
And we run the optimisation for 10 steps. Each result is used to update the optimiser so that informed domain samples are drawn:
n_steps = 10
for i in range(n_steps):
samples = bo.run_step(batch_size=2, minimise=True) # suggest next samples
evaluations = [foo(**s.as_dict()) for s in samples] # evaluate foo
bo.update(samples, evaluations) # update the optimiser
Finally, we visualise the results in Tensorboard:
import hypertunity.reports.tensorboard as tb
results = tb.Tensorboard(domain=domain, metrics=["score"], logdir="path/to/logdir")
results.from_history(bo.history)
For agents
This page has a .md twin and JSON over the API.