☼ HyperionAI

The Titan of light for your data. A universal, self-tuning AutoML engine — point it at a dataset and it reads the task, adapts to your machine, builds models, and writes a submission.

CLI · Web console (localhost:6767) Tabular · Time-series · Multi-output · Vision · ARC · Agents

---

Why HyperionAI

• Universal router. Give it a folder, a .csv, or a .zip. A classifier + execution policy decide the task type (tabular, time-series, vision, ARC, agent/RL, …) and route to the right engine — or honestly report when a task can't be supported on your hardware.
• Self-tuning to your machine. On startup HyperionAI inspects the host — CPU cores, RAM, GPU/VRAM, even AC vs battery — and automatically sets parallelism, memory caps, CSV chunking, time budgets, and the model roster. A 6 GB laptop stays cool and safe; a workstation gets turned loose.
• Validation you can trust. Genuine temporal columns trigger purged time-series CV (whole-period folds with a purge gap — no future or same-period leakage); otherwise grouped or stratified K-fold. Local CV is built to track the leaderboard and minimise shake.
• Strong ensembling. OOF-weighted blending, rank averaging, and simple mean are all scored out-of-fold; the winner is chosen on a leaderboard proxy with a stability tie-break, and never ships an ensemble worse than the best single model.
• Quality presets. fast / balanced / thorough scale folds, HPO trials, the model zoo and ensembling — thorough unleashes the full zoo for maximum strength (slower).
• Multi-output competitions. Several prediction columns (multi-output regression / multilabel) are modelled per-target and merged into one wide submission — every column gets the full pipeline.
• Honest by design. No fake implementations. Negative results are reported. Heavy backends (boosters, GPU deep learning) are optional and behind graceful fallbacks — the scikit-learn spine always runs.

Install

git clone https://github.com/nactttch/HyperionAI.git
cd HyperionAI
pip install -e .            # core only (numpy/pandas/scikit-learn/scipy/psutil)
pip install -e ".[boosters,hpo,fast]"   # optional accelerators

Quick start

Web console — the nicest way

hyperion --web                 # -> http://localhost:6767
# or:  python -m hyperion.web

An ancient-Greek themed dashboard with drag-and-drop / file-picker upload, a live progress bar, current stage, elapsed timer, streaming metrics, a quality selector, and a one-click submission download. Stdlib only — no extra deps.

Command line

hyperion --path ./my_competition --quality thorough               # universal auto-router
hyperion --train train.csv --test test.csv --sample sample.csv    # classic tabular

Python

from hyperion.universal import run_universal
detection, result = run_universal("./my_competition")
print(result.best_method, result.best_metric, result.submission_path)

Hardware auto-configuration

from hyperion.system import detect_hardware, apply_hardware_autoconfig
from hyperion.config import Config

print(detect_hardware().summary())   # "LAPTOP · 8c/16t · 16GB · RTX 4050 6GB · AC"
cfg = Config()
profile = apply_hardware_autoconfig(cfg)     # mutates cfg to fit the machine
for change in profile.notes:
    print("·", change)

Tiers (tiny / laptop / workstation / server) scale time budgets, and parallelism leaves headroom so a laptop never pins every core. Disable with --no-autoconfig or cfg.resources.hardware_autoconfig = False.

Architecture

input -> Competition Classifier -> Execution Policy -> Adaptive Capability Layer
      -> Router -> Engine (Tabular / Vision / ARC / Agent / ...) -> submission + report

Tabular spine: load -> analyze -> fingerprint -> memory-brain -> CV -> CV-safe feature engineering -> model zoo + tuning -> OOF ensemble -> submission. A SQLite benchmark registry remembers per-fingerprint results and the best blend strategy across runs (opt-in).

Tested

The scikit-learn spine and every engine are unit-tested (~200 tests), including purged time-series validation, ensemble selection, hardware auto-config, and the web console (routing + a real loopback HTTP run).

PYTHONPATH=.:tests python tests/test_validation_time.py
PYTHONPATH=.:tests python tests/test_hardware.py
PYTHONPATH=.:tests python tests/test_web.py

Honesty notes

• GPU deep learning (CNN transfer learning, transformer fine-tuning, deep RL with a live simulator) is exposed through device='cuda' hooks but requires a real GPU + torch; it is not faked.
• Optional libraries (LightGBM/XGBoost/CatBoost/Optuna/torch) are detected at runtime; without them HyperionAI still runs on the core stack.

License

MIT — see LICENSE.

_{HYPERION AI · forged in marble & gold ☼}