NanoForecast v0.5

6.5M-Parameter Time Series Foundation Model — Deploy Anywhere

CPU inference · ONNX · Streaming · Quantile forecasts · Edge/ARM

Built by Eulogik — deployable AI for the real world

What is NanoForecast?

NanoForecast is a 6.5M-parameter time series foundation model that runs inference on CPUs and, via ONNX, on edge/ARM devices and in the browser. It performs zero-shot forecasting on unseen time series without fine-tuning, producing point forecasts with quantile uncertainty bounds (p10–p90).

Unlike 200M+ parameter alternatives (TimesFM, Chronos), NanoForecast is designed for deployment constraints: 19.5ms CPU inference, ONNX export (9.2MB INT8), streaming RNN mode, and Apache 2.0 license. It matches or beats TimesFM on 4 of 6 standard benchmarks at 31x fewer parameters.

Key Features

• Zero-shot forecasting — no training needed for new time series
• Streaming inference — feed one value at a time via stateful DeltaNet RNN (unique to NanoForecast)
• Quantile predictions — p10, p25, p50, p75, p90 with monotonic guarantees
• ONNX export — 9.2MB INT8 / 27.9MB FP32 for edge, IoT, browser deployment
• CPU inference — 19.5ms median latency on Apple M4 (no GPU required)
• Train from CSV — fine-tune on your data in minutes, not days
• Apache 2.0 license — no restrictions on commercial use
• Multi-task heads — point forecast + quantiles + anomaly detection in single forward pass

Benchmark Results

Standard protocol: context 512, horizon 48, non-overlapping test windows, MASE scaled by seasonal-naive in-sample MAE. All models evaluated under identical conditions.

Results: NanoForecast v0.5 beats TimesFM on 4 of 6 benchmarks (ETTh1, ETTh2, ETTm1, exchange_rate) at 31x fewer parameters. TimesFM wins on electricity and traffic.

Parameter Efficiency

NanoForecast achieves 26x better parameter efficiency (MASE$^{-1}$ per parameter) than TimesFM and is 2x more efficient than PatchTST.

Head-to-Head Wins

Training-Pipeline Refinement: v0.3 → v0.5

The same 6.5M-parameter architecture gained 43.8% better MASE through three training-pipeline fixes — no architecture changes.

Quantile Coverage

Measured under the standard protocol (benchmark_standard.py; empirical P(target ≤ predicted quantile), mean across the six datasets):

Honest note: the predicted intervals are narrower than nominal under this protocol — the p10–p90 band covers 51% of held-out values (target 80%). Quantiles are best read as relative uncertainty signals (e.g., ranking steps by uncertainty) rather than calibrated probabilities. Point forecasts (p50) are unaffected and remain the recommended output for accuracy.

Architecture

Raw Context (512 steps)
    → Instance Robust Scaler (median/IQR)
    → Adaptive Patching (patch_size=8)
    → Resolution Prefix Tuning (freq_id → 4 covariates)
    → Sequence Mixing Blocks × 8:
        ├── LongConv (global context, kernel=65)
        ├── DeltaNet RNN (local streaming, state_size=64)
        ├── Gated Router (learned blend)
        └── GatedMLP (expansion=2)
    → Multi-Task Heads:
        ├── Point Forecast (d_model → 1)
        ├── Monotonic Quantiles (p10–p90, 5 quantiles)
        ├── Context Reconstruction (anomaly detection)
        └── Trend / Seasonal Decomposition (3 components)

Deployment Options

FastAPI Server

pip install nanoforecast fastapi uvicorn python-multipart
python3 deploy/fastapi_server.py
# → http://localhost:8000/docs

Docker

docker build -t nanoforecast -f deploy/Dockerfile .
docker run -p 8000:8000 nanoforecast

ONNX (Edge / IoT / Browser)

pip install "nanoforecast[onnx]"
python3 -m nanoforecast.export.onnx_export \
    --checkpoint <checkpoint-dir> \
    --output nanoforecast.onnx

Inference Latency

NanoForecast runs 19.5ms on CPU (PyTorch) and 10.7ms via ONNX — no GPU required.

Live Gradio Demo

Upload a CSV → get a forecast + prediction intervals + decomposition plot. No code required.

Quick Start

Install

pip install nanoforecast

Zero-Shot Forecasting

import numpy as np
from nanoforecast import NanoForecast

model = NanoForecast.from_pretrained("eulogik/nanoforecast-v05")

# Generate context (or load your own time series)
context = np.sin(np.linspace(0, 8*np.pi, 512)) + 0.1 * np.random.randn(512)

# Forecast
result = model.predict(context, horizon=48, freq=1)

print(result["forecast"].shape)     # (48,) point forecast
print(result["quantiles"].shape)    # (5, 48)  p10..p90

Streaming / Online Inference (unique to NanoForecast)

result = model.predict(context, horizon=48, return_state=True)
state = result.pop("state")

# Stream new observations one at a time
for new_val in incoming_stream:
    result = model.predict_step(new_val, state, horizon=48)
    forecast = result["forecast"][0]  # updated forecast instantly

From Your Own CSV

python3 train_from_csv.py --csv sales.csv --target revenue --horizon 48

How Does It Compare?

When to Use NanoForecast

✅ Use when:

• Deploying to edge/IoT devices (Raspberry Pi, ARM, browser)
• Streaming/online inference (feed one value at a time)
• Quantile forecasts with uncertainty estimates
• Training on your own data in minutes
• ONNX export for browser/ARM deployment
• Apache 2.0 license required

❌ Don't use when:

• You need SOTA accuracy on all benchmarks (use TimesFM, Chronos)
• You have massive datasets (100K+ rows) — fine-tune a larger model
• You need multivariate cross-series dependencies

Training

Reproduce on Colab (free T4 GPU, ~12h)

Model Files

Citation

@article{kishore2026nanoforecast,
  title={NanoForecast v0.5: Competitive Time Series Forecasting Through Training Pipeline Optimization},
  author={Kishore, Gautam},
  journal={arXiv preprint arXiv:2609.31669},
  year={2026}
}

Paper: arxiv.org/abs/2609.31669

Links

• GitHub: github.com/eulogik/NanoForecast
• Live Demo: huggingface.co/spaces/eulogik/nanoforecast
• Paper: arxiv.org/abs/2609.31669
• PyPI: pypi.org/project/nanoforecast
• Colab Training: Open in Colab
• Website: eulogik.com
• Other models: eulogik/nanoforecast-v03 · eulogik/nanoforecast-patchtst-baselines · eulogik/nanoforecast-200k

Built by Eulogik — deployable AI for the real world

If you found this useful, please ⭐ the GitHub repo and like this model on Hugging Face!