kiruluta/Hilbert-Operator-Intelligence

Hilbert Operator Intelligence — Scaling Benchmark

This repository turns Operator-Based Machine Intelligence: A Hilbert Space Framework for Spectral Learning and Symbolic Reasoning into a contributor-oriented scaling benchmark. The research program represents inputs in Hilbert spaces, learns regularized task/reasoning operators, and uses spectral bases and modulation rather than treating every transformation as an opaque dense layer.

Why this benchmark exists

The original reproducibility code is intentionally CPU-sized (sklearn Digits). The next scientific question is scaling: do structured spectral operators retain accuracy/efficiency advantages as width, depth, data, and GPU compute increase? This repo gives contributors one command, fixed configs, machine-readable metrics, and a common result schema so runs on larger GPUs can be compared.

Benchmark task

The primary public benchmark is CIFAR-10, with CIFAR-100 available as a harder extension. synthetic is included only as an offline smoke test. The model lifts images into a channel-valued function space, applies repeated truncated 2-D Fourier operators, adds a local residual nonlinearity, and classifies the pooled representation. Low-rank factorization is supported for the spectral operator tensor.

Tier	Width	Depth	Modes	Spectral rank	Intended use
tiny	32	2	8	full	laptop / smoke
small	64	4	12	16	single consumer GPU
base	128	6	16	32	high-memory GPU
large	256	8	16	64	contributor scaling run

The table defines benchmark configurations, not claimed performance. Contributors should submit the generated JSON/CSV results rather than hand-editing numbers.

Quick start

python -m venv .venv
source .venv/bin/activate
pip install -e '.[benchmark]'
pytest -q

# Offline smoke test
python benchmarks/train_image.py --config configs/tiny.json --dataset synthetic \
  --epochs 1 --train-samples 256 --test-samples 128 --image-size 16 \
  --output results/smoke.json

# Standard GPU run
python benchmarks/train_image.py --config configs/base.json --dataset cifar10 \
  --seed 7 --amp --output results/cifar10_base_s7.json

For a three-seed sweep:

DATASET=cifar10 ./scripts/run_scaling_sweep.sh

What to contribute

We are specifically seeking contributors with substantial GPU compute to run base/large and larger variants, repeat runs across seeds, and test scaling laws over width/depth/modes/rank. Useful contributions include multi-GPU training, larger image datasets, optimized FFT kernels, low-rank/structured operator parameterizations, learned bases/wavelet packets, and fair Transformer/CNN/FNO baselines under matched parameter/FLOP budgets.

Please preserve the benchmark protocol and submit: config, seed, commit hash, hardware/GPU model, PyTorch/CUDA versions, wall-clock training time, peak GPU memory, throughput, parameter count, test accuracy and NLL. See CONTRIBUTING.md and docs/SCALING_PROTOCOL.md.

Scientific hypotheses to test

1. Spectral scaling: increasing retained modes improves accuracy until task-relevant bandwidth saturates.
2. Structured efficiency: low-rank spectral operators improve accuracy per parameter and per GPU-byte at larger width.
3. Depth/composition: deeper operator composition improves representation without requiring quadratic token attention.
4. Hardware fit: FFT-heavy implementations become increasingly attractive on GPUs as spatial resolution grows.

These are hypotheses, not established results. Negative results are welcome and should be reported.

Relationship to the manuscript

The manuscript formulates supervised learning as regularized operator estimation between Hilbert spaces, develops Fourier/wavelet spectral representations and learnable spectral modulation, and frames reasoning as operator composition. It also explicitly identifies high-dimensional scalability and GPU-friendly FFT/DWT implementations as open work. This benchmark focuses on that unresolved scaling question.

Hugging Face collaboration call

Call for GPU Scaling Contributors — Hilbert Operator Intelligence. We invite researchers and engineers with high-end GPUs or clusters to run the standardized scaling matrix, add matched baselines, and explore larger operator models. The goal is a transparent community scaling study: every result should be reproducible, hardware-labeled, and accompanied by the exact config. Open an Issue titled Scaling run: <GPU> / <tier> / <dataset> or submit a PR containing result JSON files plus any reproducibility notes.

Citation

See the manuscript supplied with the project and the original implementation referenced there. If you build on this benchmark, cite the manuscript and clearly distinguish new community scaling results from the manuscript's reported/comparative results.