Datasets:
dataset_id stringlengths 15 31 | name stringlengths 20 33 | domain stringclasses 10
values | frequency stringclasses 9
values | timezone stringclasses 1
value | source stringlengths 9 33 | source_url stringlengths 38 110 | license stringclasses 4
values | observations int64 66 2.74M | latest_event_time stringclasses 10
values | value_kind stringclasses 4
values | availability_basis stringclasses 1
value | context_length int64 30 900 | prediction_length int64 4 72 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
binance_btcusdt_1h | Binance BTC/USDT hourly close | Finance | 1h | UTC | Binance BTC/USDT hourly close | https://data-api.binance.vision/api/v3/klines | See provider terms | 1,760 | 2026-11-06T05:00:00.000000+00:00 | measurement | first_ingestion | 96 | 24 |
binance_btcusdt_1mo | Binance BTC/USDT monthly close | Finance | 1mo | UTC | Binance BTC/USDT monthly close | https://data-api.binance.vision/api/v3/klines | See provider terms | 111 | 2026-10-01T00:00:00.000000+00:00 | measurement | first_ingestion | 60 | 12 |
binance_btcusdt_1s | Binance BTC/USDT one-second close | Finance | 1s | UTC | Binance BTC/USDT one-second close | https://data-api.binance.vision/api/v3/klines | See provider terms | 2,741,851 | 2026-11-06T06:25:01.000000+00:00 | measurement | first_ingestion | 900 | 60 |
coingecko_bitcoin_7d | CoinGecko Bitcoin price | Finance | 1h | UTC | CoinGecko Bitcoin price | https://api.coingecko.com/api/v3/coins/bitcoin/market_chart | See provider terms | 928 | 2026-11-06T05:00:00.000000+00:00 | measurement | first_ingestion | 96 | 24 |
gbfs_citibike_current | Citi Bike W 52 St & 11 Ave | Mobility | 15min | UTC | Citi Bike GBFS | https://gbfs.citibikenyc.com/gbfs/en/station_status.json | See Citi Bike data terms | 6,348 | 2026-11-06T06:24:08.000000+00:00 | reported_count | first_ingestion | 96 | 4 |
nasa_power_shanghai_hourly | NASA POWER Shanghai temperature | Weather-energy | 1h | UTC | NASA POWER Shanghai temperature | https://power.larc.nasa.gov/api/temporal/hourly/point | See provider terms | 1,464 | 2026-11-04T23:00:00.000000+00:00 | model_estimate | first_ingestion | 336 | 24 |
noaa_coops_sf_water_level | NOAA San Francisco water level | Ocean | 6min | UTC | NOAA San Francisco water level | https://api.tidesandcurrents.noaa.gov/api/prod/datagetter | See provider terms | 10,495 | 2026-11-06T06:00:00.000000+00:00 | measurement | first_ingestion | 240 | 60 |
noaa_ndbc_46013_realtime | NDBC buoy 46013 wave height | Ocean | 10min | UTC | NOAA NDBC | https://www.ndbc.noaa.gov/data/realtime2/46013.txt | US government data | 3,341 | 2026-11-06T05:20:00.000000+00:00 | measurement | first_ingestion | 144 | 72 |
nws_ksfo_observations | NWS San Francisco temperature | Weather | 1h | UTC | NWS San Francisco temperature | https://api.weather.gov/stations/KSFO/observations | See provider terms | 877 | 2026-11-06T05:00:00.000000+00:00 | measurement | first_ingestion | 96 | 24 |
open_meteo_shanghai_pm25 | Shanghai hourly PM2.5 | Air Quality | 1h | UTC | Open-Meteo | https://air-quality-api.open-meteo.com/v1/air-quality | CC BY 4.0 | 1,326 | 2026-11-06T05:00:00.000000+00:00 | model_estimate | first_ingestion | 336 | 24 |
open_meteo_shanghai_temperature | Shanghai hourly temperature | Weather | 1h | UTC | Open-Meteo | https://api.open-meteo.com/v1/forecast | CC BY 4.0 | 1,470 | 2026-11-06T05:00:00.000000+00:00 | model_estimate | first_ingestion | 336 | 24 |
usgs_earthquake_all_week_hourly | USGS global earthquake count | Disaster events | 1h | UTC | USGS global earthquake count | https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/all_week.geojson | See provider terms | 1,145 | 2026-11-06T05:00:00.000000+00:00 | reported_count | first_ingestion | 168 | 24 |
usgs_potomac_iv | USGS Potomac discharge | Hydrology | 5min | UTC | USGS Potomac discharge | https://waterservices.usgs.gov/nwis/iv/ | See provider terms | 13,736 | 2026-11-06T05:50:00.000000+00:00 | measurement | first_ingestion | 288 | 72 |
wikimedia_time_series_daily | Wikimedia Time series pageviews | Web attention | 1d | UTC | Wikimedia Time series pageviews | https://wikimedia.org/api/rest_v1/metrics/pageviews/per-article/en.wikipedia/all-access/user/Time_series/daily | See provider terms | 131 | 2026-11-05T00:00:00.000000+00:00 | reported_count | first_ingestion | 30 | 7 |
world_bank_china_annual_macro | World Bank China GDP | Macroeconomy | 1y | UTC | World Bank China GDP | https://api.worldbank.org/v2/country/CHN/indicator/NY.GDP.MKTP.CD | See provider terms | 66 | 2025-01-01T00:00:00.000000+00:00 | reported_statistic | first_ingestion | 40 | 5 |
LiveHouse-TS
A prospective benchmark for univariate time-series forecasting.
Real streams. Predictions frozen in advance. Results as the future unfolds.
Explore the leaderboard ↗ · Submit a model · Public data · Evaluation · Cite
Forecast first. Evaluate later.
LiveHouse-TS asks a simple question: how well does a model predict data that has not arrived yet? Live submissions receive only observations available at the forecast cutoff. Predictions are frozen before the target window begins, then scored once the complete target is available. The accuracy leaderboard also includes audited recoveries computed from the same cutoff-limited inputs. Downloadable results retain the actual computation time and model revision. The ranking trend is recomputed cumulatively for each forecast-window end date, including recovered scores. Archive keeps the original published snapshots. Forecast explorer includes real observations during the lead-in between model input and the scored window. Missing observations appear as breaks in the line. When an original input is incomplete, approved recoveries can reconstruct it from real pre-target observations and record the reconstruction time.
| Observe | Predict | Compare |
|---|---|---|
| Collect public streams across weather, finance, mobility and more. | Give every model the same historical context and freeze its forecast. | Explore point and probabilistic errors, model comparisons and archived results. |
Development preview. The links above point to the personal test environment. Not every source or model is ready for evaluation; incomplete data and invalid forecasts are excluded. See model coverage and data availability for current limitations.
Explore the benchmark
Actual test-site screenshot captured on October 7, 2026. This heatmap is an exploratory error comparison, not an official ranking; values change as new results arrive. The header waveform is decorative, not benchmark data.
Compare datasets by domain, inspect head-to-head results, follow historical ranks, and overlay forecasts with observed outcomes.
Open the explorer → · Browse the archive · Inspect forecasts
Join the benchmark
Wrap → Validate → Submit. Expose your model through the example API, check its response contract, then submit its endpoint and model metadata. Install the SDK with the quick start below.
Participants host their model behind one small HTTP API. Start from
examples/model_api, replace forecast_one, and expose:
GET /health
POST /forecast
The request contains opaque series IDs, historical timestamps and values, frequency, horizon, and requested quantiles. It never contains future targets, private metrics, dataset-internal IDs, or another model's predictions. Remote endpoints must use stable HTTPS.
Each input must have one output with prediction_length finite numeric values
in mean and in each requested quantile (0.1 through 0.9 in steps of 0.1). Quantiles must
be nondecreasing at each time step. Point-only models may repeat their point
forecast at every quantile, as the demo does; this is a degenerate distribution,
not a calibrated uncertainty estimate. Admission and live evaluation apply
the same checks before storing predictions.
The example echoes protocol_version and model at the top level and
series_id on each output. Existing value-only responses still work; if these
fields are returned, they must match the request. Optional output timestamps
must have explicit timezones and follow the context's last timestamp on the
requested grid, including any forecast gap. Shifted timestamps, mismatched
identities and duplicate quantile levels are rejected, not repaired. The
TSFM adapter also checks returned
metadata.item_id and timestamps when present.
Validate an endpoint before submission:
livehouse-ts-validate organization/model https://forecast.example.org/forecast
The command exits zero with status: ok, or exits nonzero with a safe failure
code (for example forecast_misaligned, unexpected_series, or
crossed_quantiles). It does not print provider response bodies. CI exercises
the example over real HTTP through admission, prediction freezing, scoring and
public export, using synthetic test data only.
Submit the following through the GitHub community-model form:
- model ID and display name;
- model card URL;
- public endpoint-code URL;
- stable HTTPS
/forecastURL; - version and organization.
After endpoint validation, maintainers record an admission timestamp. A model is evaluated only on tasks created after admission; no historical backfill is used.
Quick start
git clone https://github.com/ATMSaxon/LiveHouse-TS-test.git
cd LiveHouse-TS-test
python -m venv .venv
source .venv/bin/activate
python -m pip install -e '.[dev,baselines,api]'
pytest -q
Create a schema-v2 database or add the v2 audit tables to an existing v1 database:
from livehouse_ts.data_schema import connect
database = connect("livehouse.sqlite")
Implement DataSource.fetch() to return a normalized DataBatch, then call
collect(source, SQLiteRepository(database)). A data adapter is responsible for
recording event time, public availability time, and ingestion time separately.
Run one cycle against the fourteen currently enabled data streams:
livehouse-ts-cycle private/livehouse.sqlite public
This collects past observations, resolves due tasks, issues dataset-specific
forecasts, and writes public CSV/JSON artifacts. Seasonal Naive is always
included. Add HTTPS models through LIVEHOUSE_MODELS_JSON:
[{"model_id":"organization/model","endpoint_url":"https://forecast.example.org/forecast"}]
Evaluation protocol
For each task, LiveHouse-TS:
- selects context whose
available_timeis no later than the task cutoff; - calls every admitted model with the same context and horizon;
- freezes predictions before
target_start; - waits until the target window ends and every target value is available;
- computes metrics with a recorded metric version;
- publishes only public-format-v1 aggregate results and bounded visual examples.
Old pre-schema results are intentionally excluded from the new leaderboard.
Implementation details, task windows and source availability are documented in the technical reference.
Metrics and ranking
Metric v2 computes MSE, RMSE, MAE and quantile-approximate CRPS using the context population standard deviation only (unit scale for a near-constant context). MAPE uses the median forecast in original units and is omitted near zero targets. CRPS uses the nine equally spaced quantiles 0.1–0.9 from paper Appendix E.
Official ranking follows Appendix E: compare MSE and CRPS separately on shared releases, average the two win/tie/loss outcomes, then macro-average by dataset and eligible opponent. Each pair needs 30 shared releases, five datasets and seven days of target-time span. A model needs three eligible opponents and membership in the largest connected comparison component to receive an official rank. Ties share rank; missing comparisons are not ties. Otherwise status is provisional, awaiting forecasts/scores, or failed.
The lower-is-better normalized composite score remains a diagnostic, not the
official ranking key; zero-error baseline denominators are omitted from this
diagnostic only. Diagnostic Elo starts at 1500, K=16 per shared-task pair, with
simultaneous updates and deterministic target-time/task-ID ordering. It is not
the official rank and the paper does not specify these exact Elo parameters.
Average rank uses tied shared-task composite ranks, macro-averaged by dataset.
RTG is 100*(baseline MSE-model MSE)/(baseline MSE+model MSE), averaged by
dataset (both zero gives zero). Stability is the sample standard deviation of
daily dataset-balanced normalized composite scores. Improvement is Kendall
tau-a of normalized squared errors for repeated predictions of the same target
and truth revision, averaged by target and dataset; fewer than two predictions
gives no value. Coverage uses only reference tasks after the model's admission.
These implementation choices are explicit; this repository does not yet claim full numerical reproduction of every paper table or the original experiment.
Core workflow
public sources -> normalized observations -> frozen forecast
-> future observations arrive -> metrics -> public leaderboard
The public SDK has five modules:
data.py: streaming-data adapters and SQLite ingestion;data_schema.py: canonical objects and SQLite schema v2;models.py: the model protocol, hosted adapters, and four statistical baselines;metrics.py: versioned point and probabilistic metrics;eval.py: forecast freezing, scoring, and public export.
Runtime data, model weights, raw responses, frozen forecasts, and result files are not stored in this Git repository.
LiveHouse series
This repository is intentionally scoped to univariate time series. Future spatio-temporal graph or multivariate benchmarks will use separate LiveHouse projects while sharing versioned concepts such as datasets, entities, variables, tasks, models, and releases.
Update log
October 10, 2026 — focused benchmark explorer
- Put Elo first and Archive last; removed the result-date card and seven redundant or unwanted plots.
- Kept twelve complementary charts; paired win/tie/loss counts now appear in the comparison summary.
- Replaced the multicolored Elo bars with a sorted, single-color dot plot and aligned numeric ratings.
- Kept the scoring, official ranks, archive data and forecasting protocol unchanged.
October 7, 2026 — README refresh
- Added a branded overview, an actual benchmark screenshot and direct participation links.
- Moved operational reference material behind the introductory workflow; evaluation behavior is unchanged.
SQLite schema v2 — audit storage and source completion
- Checked model-response identity, optional forecast timestamps and duplicate quantile levels; added real HTTP endpoint-to-scoring integration coverage.
- Allowed previously captured GBFS periods to settle through a new fetch outage; counted only newly stored observations.
- Used frozen inputs consistently for the Improvement diagnostic as well as scoring and forecast examples.
- Added private exact-response archives and immutable canonical task inputs; migrated v1 without deleting results.
- Implemented all 17 source adapters; enabled hourly NWS aggregation and GBFS snapshot accumulation.
- Added quarter-hour GBFS-only collection without increasing hosted model inference frequency.
- Kept NCEI, NDBC and GDELT disabled pending usable target data; no substitution or gap filling.
0.2.0 — evaluation v2 / metrics v2 (SQLite schema remains v1)
Added Binance hourly/second/monthly, CoinGecko and World Bank streams and exact calendar task grids.
Backfilled due second-level target windows without backdating data availability.
Added isolated hosted-model diagnostics without changing benchmark admission.
Fixed per-dataset issue clocks, reserved inference time, and bounded concurrent model calls.
Added transport-only data retries, safe failure reasons, and partial-run Actions failures.
Added dataset-specific task windows with explicit history warm-up status.
Added NASA POWER UTC parsing and complete-hour USGS earthquake counts.
Kept NCEI daily mean temperature disabled while its target field is absent.
Enforced inference completion deadlines and gap-aware timestamp alignment.
Separated new results from legacy scores without deleting historical data.
Added nine-quantile context-normalized scoring and paper eligibility rules.
Corrected RTG, temporal stability, fixed-target Improvement, and tied ranks.
Kept unscored models visible and labelled data provenance.
Added USGS discharge, NOAA water level and Wikimedia pageviews adapters.
0.1.0 — schema v1
- Reduced the public project to five core modules and one HTTP model example.
- Added canonical SQLite storage with separate event, availability and ingest times.
- Added the
livehouse-ts-v1model and metric protocols. - Added two real Open-Meteo streams and the hourly single-writer operator.
- Added normalized ranking, win rate, Elo, RTG, stability and availability.
- Started a new leaderboard containing only schema-v1 releases.
Future schema, protocol, metric, data-source, or ranking changes receive an explicit version entry here.
Citation
@misc{livehouse_ts,
title = {LiveHouse-TS: A Live Benchmark for Time-Series Forecasting},
author = {ThinkCat Lab},
year = {2026},
url = {https://github.com/Thinkcat-Lab/LiveHouse-TS}
}
Apache-2.0 licensed. LiveHouse-TS builds on the prospective evaluation direction of GIFT-Eval while maintaining its own live-data schema and protocol.
Technical reference
Models · Data streams · Architecture · Evaluation flow · Database fields · Maintainer checklist
Paper model roster
Provider availability, checked 2026-10-24: TSFM.ai no longer offers its hosted forecasting API. The deployed six-model integration now returns HTTP 404; the first observed failure was 2026-10-23 17:17 UTC, after the 48-hour collection window ended. The adapter IDs and admission checks below document the previous integration, not a currently available service. Do not enable or revalidate this provider until a replacement endpoint is approved. Existing predictions and scores remain preserved; model self-hosting and switching providers require a separate decision.
Self-hosting status: the eight foundation models are not yet self-hosted.
The adapters below are optional hosted-provider integrations, not completed
local deployments. GPU/server configuration and actual weight loading remain
deferred. Do not enable paper to claim self-hosted results.
LIVEHOUSE_MODEL_SET=baselines enables Seasonal Naive, Moving Average (24),
ARIMA(1,1,1), and ETS (additive trend, no seasonality).
LIVEHOUSE_MODEL_SET=paper additionally enables all eight foundation models:
LIVEHOUSE_MODEL_SET=tsfm selects the seven TSFM.ai adapters without requiring
the independent TabPFN client. LIVEHOUSE_TSFM_MODELS_JSON can restrict this to
an explicitly validated list of IDs; an empty setting means the complete seven.
In the personal sandbox, the 2026-10-04 synthetic admission check passed Chronos-2,
TiRex, Toto-1.0, Moirai-2.0, Chronos-Bolt and Sundial. TimesFM-2.5 returned crossed
quantiles and is not admitted by that check; predictions are not repaired or
substituted. This is contract validation, not a forecasting-quality result.
The isolated 2026-10-05 recheck found six adjacent-quantile crossings (maximum
0.1061) in the raw six-step synthetic response. TabPFN is absent from the TSFM.ai
catalog checked that day and still requires its own TABPFN_TOKEN.
| Model | Provider / original registry identifier |
|---|---|
| Chronos-2 | TSFM.ai: amazon/chronos-2 |
| TiRex | TSFM.ai: NX-AI/TiRex-1.1-gifteval |
| TimesFM-2.5 | TSFM.ai: google/timesfm-2.5-200m-pytorch |
| Toto-1.0 | TSFM.ai: Datadog/Toto-Open-Base-1.0 |
| Moirai-2.0 | TSFM.ai: Salesforce/moirai-2.0-R-small |
| Chronos-Bolt | TSFM.ai: amazon/chronos-bolt-base |
| Sundial | TSFM.ai: thuml/sundial-base-128m |
| TabPFN-TS | Prior Labs client: priorlabs/tabpfn-ts |
Install .[baselines] for statistical inference and additionally .[tabpfn]
for the paper roster. Core imports remain dependency-light. The TabPFN package
versions match the previous repository's client environment; its hosted
checkpoint is provider-controlled, so this does not establish exact reproduction
of the paper's historical weights. The other hosted model IDs are also not
immutable weight hashes.
Historical admission procedure (blocked for the retired TSFM service):
in Actions, set secrets TSFM_API_KEY and TABPFN_TOKEN, then manually run
Validate paper models with paper. This makes real provider calls on a
synthetic series, uses inference quota, and does not publish benchmark results.
Only after it passes, set repository variable LIVEHOUSE_MODEL_SET=paper to
enable the hourly operator. minimal is the default and keeps the reference
baseline plus explicitly configured HTTPS endpoints. Missing credentials fail
before an operator run can change HF data.
Results come from live submissions and audited frozen-input recoveries, not imported paper scores. Statistical models use a deterministic 200-sample centered residual bootstrap; failed fits are recorded as failures, never silently replaced by a different model. TiRex asks for at least 24 future steps and retains the requested prefix, matching the old registry's hosted-horizon workaround. The persistence demo is not a paper model.
Evaluation implementation and data streams
Live submission in evaluation v2 checks the clock both before and after inference, rejects late responses, verifies regular context/target grids, and forecasts across the gap between the last available context and the future target before slicing out the scored horizon. Context must have both availability and ingestion times no later than cutoff. The CLI does not accept backdated issue times. The first successful scoring of a run is immutable; later source revisions do not replace it.
The operator can import missing forecasts from frozen-input replay after checking
the input hash, cutoff, regular grid, checkpoint revision, output validity and
metric parity. These results enter the same accuracy ranking. Actual computation
times are retained; checkpoint provenance and the previous failed attempt are
stored in forecast_imports. Online submission deadlines remain unchanged.
Approved local replay adapters can apply sort-v1 quantile rearrangement before
validation. Original outputs remain in the private database; downloads identify
the quantile processing version. This does not change point predictions.
The operator now takes a fresh cutoff for each dataset after earlier work has
finished. All models on that task still receive the same context, horizon and
deadline. It chooses the first native-grid timestamp strictly after a reserved
inference budget: max(model timeout) * ceil(model count / workers) + 30 seconds,
with at most four inference workers and a 60-second planning allowance for
local models without a declared timeout. This allowance is not a forced kill
for arbitrary local code: actual late results are still rejected. Forecasting
covers the resulting gap before slicing the target horizon. SQLite reads/writes
stay on the evaluator thread; workers perform only model calls and validation.
Queued calls check the deadline again before contacting a model.
An irregular context grid is reported once under status.json.skipped_tasks
before dispatch, rather than recorded as a failure of every model. No values are
filled, shifted or discarded to make the grid pass. Data GETs retry up to three
times (1/2-second waits) for truncated connections, transport timeouts and
408/502/503/504 responses. Authentication errors, rate limits and malformed JSON
are not retried. Model inference calls are not automatically retried.
NOAA water levels are fetched with explicit UTC begin/end timestamps covering
the last 72 hours, so overlap is requested again and missing original records
can be appended when the provider makes them available. This does not interpolate
gaps or rewrite existing first-ingestion times.
Failures carry safe reason codes such as deadline_before_inference,
deadline_after_inference, context_irregular, invalid_horizon,
missing_quantiles, crossed_quantiles, http_503 or incomplete_response.
Unknown errors expose only their exception class, never response bodies or
tokens. A partial cycle preserves and publishes its valid results, then fails
the Actions job with a summary of affected tasks. A green workflow therefore
no longer silently covers forecast/collection failures. History warm-up remains
a normal pending state. Existing failed runs and scores are not rewritten.
Data coverage
| Enabled stream | Value type | Task frequency | Context / forecast steps |
|---|---|---|---|
| Open-Meteo Shanghai temperature | Model estimate, not station truth | 1h | 336 / 24 |
| Open-Meteo Shanghai PM2.5 | Model estimate, not station truth | 1h | 336 / 24 |
| USGS Potomac discharge | Gauge measurement | 5min (current API; paper lists 15min) | 288 / 72 |
| NOAA San Francisco water level | Station measurement | 6min | 240 / 60 |
| Wikimedia Time series pageviews | Reported count | 1d | 30 / 7 |
| NASA POWER Shanghai temperature | Gridded meteorological model estimate | 1h (explicit UTC) | 336 / 24 |
| USGS global earthquake catalogue counts | Reported event count, complete hours | 1h | 168 / 24 |
| Binance BTC/USDT hourly close | Completed candle closing price | 1h | 96 / 24 |
| Binance BTC/USDT one-second close | Completed candle closing price | 1s | 900 / 60 |
| Binance BTC/USDT monthly close | Completed candle closing price | 1mo | 60 / 12 |
| CoinGecko Bitcoin price | Hourly market price | 1h | 96 / 24 |
| World Bank China GDP | Reported annual statistic, current USD | 1y | 40 / 5 |
| NWS KSFO temperature | Last valid measurement in each completed UTC hour | 1h | 96 / 24 |
| Citi Bike W 52 St & 11 Ave | Last observed report in each completed UTC quarter-hour | 15min | 96 / 4 |
Availability is conservatively recorded at first ingestion, not inferred from
event time. Irregular or missing grids are rejected, not silently filled. These
fourteen streams do not yet reproduce the paper's full 17-dataset inventory.
Window lengths live in data.py and travel with each dataset's metadata. The
operator requires the full configured context; shorter histories appear in
status.json.pending_context and do not create undersized tasks. Unregistered
custom adapters retain the 168/6 default (minimum 24 points). USGS water uses
288/72 to preserve the paper's 24-hour context and six-hour horizon at its
current five-minute cadence. Full evaluation remains hourly; a GBFS-only
collector runs between those evaluations to obtain quarter-hour snapshots.
Exported release rows record actual horizon and frequency.
Earlier six-step tasks keep their original definitions and results; new tasks
have window lengths in their identity, so changing a window never rewrites an
existing task. Aggregates currently include both old and new task windows.
NASA is requested in UTC, not the API's default local solar time, and its fill value is excluded. Its release delay is handled as a forecast gap, not hidden. The earthquake weekly feed usually provides 167 complete hours on first fetch; the 168-step context warms up as subsequent hourly collections accumulate. Zero counts are emitted only inside complete feed coverage, and partial edge hours are excluded. Feed truncation/duplicate event IDs are rejected.
All 17 source adapters are implemented. NCEI USW00014732 still has no TAVG
(0 of 85 returned records on 2026-10-05), and GDELT has returned HTTP 429;
these two sources remain disabled. NDBC 46013 is collected hourly, although
its wave-height observations do not form a continuous 10-minute grid.
NCEI is not replaced by TMAX/TMIN or another station. NDBC keeps actual
timestamps and missing values absent, rather than filling its missing wave
heights. GDELT requests four adjacent 48-hour timelines with no smoothing
and six-second spacing, covering eight days while preserving 15-minute resolution:
the provider changes to hourly resolution at 72 hours, so a 7-day query cannot
be called 15-minute data. API gaps and missing values are never filled.
The operator's check_sources action probes all 17 without writing to HF.
NWS follows pagination until its 96-hour context is covered, selects the last finite measurement per completed UTC hour, rejects MADIS X/Q/B quality flags, and preserves empty hours as gaps. This is an explicit hourly aggregation, not a claim that every native station report is hourly. Raw responses preserve the original measurement times. The 2026-10-05 probe found an entirely missing temperature hour at 2026-10-03 20:00 UTC (the only report had a null temperature). Such a gap prevents task creation until it is repaired by the provider or leaves the 96-hour context. Approved historical recovery can use unflagged NOAA GHCNh METAR records from the same airport (USW00023234 / ICAO-KSFO). Only missing hours are filled, with archive provenance and actual receipt times retained. Archive precision and observation timing can differ from the NWS API.
GBFS fixes station 66db237e-0aca-11e7-82f6-3863bb44ef7c (W 52 St & 11 Ave).
Raw station reports keep their last_reported times in the snapshot variable.
Only completed quarter-hours are aggregated into the univariate target, using
the last actually observed report; no empty bucket is filled. Stale feeds and
inactive stations are rejected. The initial 96-period context takes at least
24 hours to accumulate. GitHub schedules are best-effort: missing intervals
remain gaps until a complete context is available, not manufactured history.
Snapshot-only runs preserve the last full evaluation's health status; a
successful collector cannot clear outstanding model failures.
An upstream fetch failure still closes previously captured, completed GBFS
buckets, so available truth can be scored without another model call. The
failure remains reported; missing buckets are not filled. Operator observation
counts report newly inserted rows, not repeated polls of existing revisions.
The Binance one-second adapter fetches the latest 1,000 candles for context and explicitly backfills each due 60-second target window on the next operator run. Backfilled observations become available at ingestion, not retrospectively at the candle timestamp. This is second-resolution data with hourly task issue, not the paper's every-second evaluation schedule. All Binance adapters use the original candle-open labels and exclude candles whose close time has not passed. CoinGecko's off-grid latest sample is excluded without rounding timestamps or filling gaps. World Bank checks the country, indicator and page completeness, skips missing values and uncompleted years, and labels each annual value at January 1.
Month/year task grids use real calendar boundaries, including leap years, in
context checks, forecast gaps, target construction and scoring. TSFM requests
translate 1mo/1y to month-start/year-start aliases MS/YS. Monthly and
annual tasks will remain pending until the complete future target is published;
historical observations are context, not retroactive live scores.
Storage and deployment
System architecture
The deployment has three boundaries: the evaluator owns private state and credentials; model services receive historical inputs only; the browser reads public exports only. No API keys belong in the Space or public Dataset.
flowchart LR
Sources[Public data APIs] -->|observations| Runner[Single evaluator worker]
Private[(Private HF SQLite)] -->|restore pinned revision| Runner
Runner -->|historical context only| Models[Model endpoints]
Models -->|mean and quantiles| Runner
Runner -->|commit database first| Private
Runner -->|derived CSV and JSON| Public[Public HF Dataset]
Public -->|read-only| Space[HF Space leaderboard]
Public -->|pinned revisions| Archive[Weekly archive]
The Ubuntu operator keeps a persistent private SQLite database. Independent
timers collect GBFS every five minutes, refresh other sources hourly, evaluate
forecasts hourly, and publish a consistent SQLite backup before public artifacts.
The legacy Actions operator restores into an ephemeral directory and is disabled
during Ubuntu operation. HF parent-commit checks
reject conflicting writes. This is not a cross-repository transaction:
private upload may succeed while public upload fails. source_revision.json
identifies the private commit and code revision supporting each public export.
The publisher retains successful private commits if public publication fails;
it does not roll them back. Only one HF publisher should be scheduled.
Evaluation flow
flowchart TD
Restore[Restore private SQLite] --> Collect[Collect and normalize streams]
Collect --> Resolve[Score due runs only when the full target grid exists]
Resolve --> Context{Full causal context available?}
Context -->|No| Wait[Record pending context]
Context -->|Yes| Task[Create future task with dataset-specific window]
Task --> Admission{Model admitted and deadline not reached?}
Admission -->|No| Failure[Record failed model-task pair]
Admission -->|Yes| Infer[Request gap plus target horizon]
Infer --> Validate{Valid output and returned before target start?}
Validate -->|No| Failure
Validate -->|Yes| Freeze[Store target predictions and completion time]
Freeze --> Publish[Upload private state then public exports]
Wait --> Publish
Failure --> Publish
Publish --> Next[Next scheduled cycle resolves pending targets]
Forecast input contains no future labels. Context is selected using both
available_time and ingested_at at the task cutoff. The model predicts the
unobserved gap plus target horizon; gap steps are discarded before storage.
Failures affect one model-task pair, not other models. A task-level status is
only a summary: use forecast_runs and scores to determine each model's state.
SQLite data dictionary (schema v2)
The v1→v2 migration only adds raw-response archives and frozen task inputs. Existing observations, predictions and scores are preserved; evaluation and metric definitions remain v2. The browser/export JSON contract remains v1.
Types below are SQLite types. PK means primary key; FK means foreign key. Unless marked nullable, fields are declared NOT NULL (SQLite TEXT primary keys are an exception in the DDL; the repository always supplies their IDs). All event/cutoff times written by the repository are UTC ISO-8601 with six fractional digits. JSON fields hold objects, not additional relational tables.
| Table | Field | Type | Meaning / constraints |
|---|---|---|---|
| schema_metadata | version | INTEGER | PK; applied migration version, currently 2 |
| schema_metadata | applied_at | TEXT | Schema initialization time |
| sources | source_id | TEXT | PK; provider/source identifier |
| sources | name | TEXT | Human-readable source name |
| sources | url | TEXT | Provider endpoint, no credentials |
| sources | license | TEXT | Attribution/license description; may be unverified provider terms |
| sources | fetch_interval_seconds | INTEGER | Nullable; intended polling interval, not an enforced scheduler |
| datasets | dataset_id | TEXT | PK; benchmark stream identifier |
| datasets | source_id | TEXT | FK → sources.source_id |
| datasets | name | TEXT | Display name |
| datasets | domain | TEXT | Weather, hydrology, ocean, etc.; descriptive category |
| datasets | frequency | TEXT | Task grid step, e.g. 1h, 5min, 1d; aggregation is recorded separately |
| datasets | timezone | TEXT | Default UTC |
| datasets | benchmark_family | TEXT | Default time_series; future series extension point |
| datasets | modality | TEXT | Default univariate; does not implement multivariate evaluation |
| datasets | metadata_json | TEXT | Default {}; context_length, prediction_length, value_kind, availability_basis and source details |
| entities | dataset_id | TEXT | Composite PK and FK → datasets |
| entities | entity_id | TEXT | Composite PK; station, location or series ID within dataset |
| entities | name | TEXT | Entity display name |
| entities | kind | TEXT | Default series; e.g. location |
| entities | latitude | REAL | Nullable; latitude |
| entities | longitude | REAL | Nullable; longitude |
| entities | metadata_json | TEXT | Default {}; entity metadata |
| variables | dataset_id | TEXT | Composite PK and FK → datasets |
| variables | variable_id | TEXT | Composite PK; variable within dataset |
| variables | name | TEXT | Variable display name |
| variables | unit | TEXT | Default empty; measurement unit |
| variables | role | TEXT | CHECK target or covariate; current tasks use target only |
| variables | value_type | TEXT | Default float |
| variables | aggregation | TEXT | Default instantaneous; descriptive aggregation metadata |
| variables | metadata_json | TEXT | Default {}; variable metadata |
| observations | dataset_id | TEXT | Composite PK; part of both entity/variable FKs |
| observations | entity_id | TEXT | Composite PK; FK with dataset_id → entities |
| observations | variable_id | TEXT | Composite PK; FK with dataset_id → variables |
| observations | event_time | TEXT | Composite PK; when the event/sample occurred |
| observations | available_time | TEXT | When this value was first known available; collectors conservatively use ingestion time |
| observations | ingested_at | TEXT | Acquisition time; cannot precede available_time |
| observations | value | REAL | Finite numeric value, validated by repository |
| observations | revision_id | TEXT | Composite PK; default v1; distinguishes changed values |
| observations | quality_flag | TEXT | Default empty; source quality annotation |
| observations | raw_hash | TEXT | SHA-256 key into raw_archives for v2 collections; legacy/custom records may only have a hash or empty value |
| raw_archives | raw_hash | TEXT | PK; SHA-256 of the uncompressed canonical response-bundle JSON |
| raw_archives | dataset_id | TEXT | FK → datasets; source stream |
| raw_archives | fetched_at | TEXT | Receipt time of the last response in this collection |
| raw_archives | responses_zlib | BLOB | Zlib-compressed JSON list of URL, receipt timestamp and base64-encoded exact response bytes; private only |
| models | model_id | TEXT | PK; stable submitted model/version identity |
| models | display_name | TEXT | Display name |
| models | version | TEXT | Declared implementation version; not necessarily a weight hash |
| models | endpoint_url | TEXT | Nullable; server-side endpoint, excluded from public model export |
| models | code_url | TEXT | Nullable; public implementation link |
| models | admitted_at | TEXT | Nullable; first admission cutoff; preserved on metadata update |
| models | enabled | INTEGER | Default 1; CHECK 0 or 1 |
| forecast_tasks | task_id | TEXT | PK; includes evaluation version, stream, target start and window lengths |
| forecast_tasks | dataset_id | TEXT | FK → datasets; part of entity/variable FKs |
| forecast_tasks | entity_id | TEXT | FK with dataset_id → entities |
| forecast_tasks | variable_id | TEXT | FK with dataset_id → variables |
| forecast_tasks | cutoff_time | TEXT | Latest permitted context availability/ingestion time |
| forecast_tasks | context_start | TEXT | Inclusive context start |
| forecast_tasks | context_end | TEXT | Inclusive context end, before target_start |
| forecast_tasks | target_start | TEXT | First scored timestamp; online submissions must finish strictly before it |
| forecast_tasks | target_end | TEXT | Last scored timestamp, inclusive |
| forecast_tasks | horizon | INTEGER | Positive number of target steps |
| forecast_tasks | frequency | TEXT | Frozen task frequency |
| forecast_tasks | status | TEXT | pending, forecasted, scored or failed; coarse task summary |
| forecast_tasks | created_at | TEXT | Task creation cutoff |
| forecast_runs | run_id | TEXT | PK; model execution identifier |
| forecast_runs | task_id | TEXT | FK → forecast_tasks; UNIQUE together with model_id |
| forecast_runs | model_id | TEXT | FK → models; one attempt per model-task pair |
| forecast_runs | created_at | TEXT | Completion time for successful inference; attempt time for failures |
| forecast_runs | protocol_version | TEXT | Historical column name; v2 stores evaluator version, not HTTP protocol version |
| forecast_runs | status | TEXT | CHECK ok or failed; ok means frozen, not necessarily scored |
| forecast_runs | error | TEXT | Default empty; safe failure reason code (legacy rows have exception class), never credentials or provider response |
| forecast_inputs | task_id | TEXT | PK and FK → forecast_tasks; one shared canonical input per task |
| forecast_inputs | input_hash | TEXT | SHA-256 of input_json |
| forecast_inputs | input_json | TEXT | Exact timestamps, values, opaque series ID, frequency, requested quantiles, full prediction length and discarded gap |
| forecast_inputs | created_at | TEXT | Time the input snapshot was recorded: original live freeze or audited import |
| forecast_imports | run_id | TEXT | PK and FK → forecast_runs; audited recovery |
| forecast_imports | model_revision | TEXT | Checkpoint revision used for inference |
| forecast_imports | input_hash | TEXT | Verified frozen-input hash |
| forecast_imports | imported_at | TEXT | Actual import time |
| forecast_imports | settings_json | TEXT | Inference settings and original scoring time |
| forecast_imports | previous_run_json | TEXT | Original failed attempt, when present |
| forecast_raw_outputs | run_id | TEXT | PK and FK → forecast_runs; recovery with quantile processing |
| forecast_raw_outputs | raw_prediction_json | TEXT | Original full-horizon point and quantile forecasts before rearrangement; private only |
| predictions | run_id | TEXT | Composite PK and FK → forecast_runs |
| predictions | step | INTEGER | Composite PK; zero-based target step, CHECK >= 0 |
| predictions | statistic | TEXT | Composite PK; mean or q0.1 … q0.9 |
| predictions | value | REAL | Finite forecast value in source units |
| scores | run_id | TEXT | Composite PK and FK → forecast_runs |
| scores | metric_name | TEXT | Composite PK; MSE, RMSE, MAE, MAPE, CRPS |
| scores | metric_version | TEXT | Composite PK; isolates metric definitions |
| scores | value | REAL | Metric value; undefined MAPE is omitted, not zero |
| scores | scored_at | TEXT | Truth-availability cutoff used for scoring |
| releases | release_id | TEXT | PK; reserved, not populated by current operator |
| releases | schema_version | INTEGER | Reserved release schema version |
| releases | created_at | TEXT | Reserved release creation time |
| releases | public_revision | TEXT | Nullable; reserved public commit reference |
observations uses the five-column primary key
(dataset_id, entity_id, variable_id, event_time, revision_id). Repeated identical
revisions do not overwrite first-ingestion timestamps. Two secondary indexes
cover series/event time and available_time. Foreign keys are enabled per
connection and SQLite uses WAL. New operator collections store original HTTP
response bytes privately, including every page of a paginated retrieval.
Model-neutral canonical inputs are frozen before inference and reused for
scoring normalization and public forecast examples. Adapter-specific wire
encoding remains defined by the pinned code revision. Legacy tasks without an
explicit snapshot retain causal reconstruction from their original observations;
raw bodies that were never saved are not reconstructed or claimed retroactively.
Public releases.csv is a derived join of tasks, runs and scores; it is not an
export of the reserved releases table. models.csv exposes admitted model
metadata but never endpoint credentials. history.json contains daily aggregate
snapshots and pinned public commit IDs. source_revision.json maps each export
to its private SQLite and code commits; database_schema_version is separate
from the public schema_version. Private database downloads require HF
authorization; the browser never receives that token.
Joining the evaluation: participant and maintainer checklist
- Host the model behind the example's HTTPS
POST /forecastcontract. Install.[api]and runuvicorn examples.model_api.app:app --host 0.0.0.0 --port 8000for local development; add HTTPS at your deployment boundary. - Return one output per input, with finite mean and all nine requested quantile arrays of the requested length. A point model must declare and repeat its point predictions across quantiles, not fabricate uncertainty. Never query future observations inside the model service.
- Run
livehouse-ts-validate organization/model-version https://host/forecast. This is a small contract check, not a performance or latency certification. Also test the largest dataset horizon plus publication gap you will serve. - Submit the community-model form with model ID, version/weight revision, model card, code URL, endpoint, owner and declared output type. Use a new model ID when weights change; metadata upsert does not version old runs.
- A maintainer validates the service and adds it to
LIVEHOUSE_MODELS_JSONin the evaluator's repository secrets. The operator records admission on its next run; forecasts are issued only for newly created, eligible tasks. The form is not an automatic registration or approval service. - Wait for targets to arrive. The model first shows awaiting_forecast or awaiting_scores, then provisional. Official ranks require the evidence thresholds documented above; no pre-admission backfill is performed.
For hosted TSFM services, keep TSFM_API_KEY server-side. A successful provider
login or model listing does not establish inference availability: validate the
actual model response, all requested quantiles and deadlines before enabling
recurring evaluation. Provider quotas and billing are separate from HF storage.
The private Hugging Face Dataset contains the canonical SQLite database,
normalized observations, tasks, and frozen forecasts. The public Dataset contains stable CSV,
JSON, and metrics-only release exports. The Hugging Face Space is a read-only
presentation layer with no token or private-data access. The personal test
publisher updates Saxon0520/LiveHouse-TS-test-private-data first, then publishes
derived artifacts to the public Saxon0520/LiveHouse-TS-test Dataset using
optimistic commit checks.
The test environment uses Ubuntu user-systemd jobs; see
deployment and 48-hour acceptance. GitHub Actions retains
the disabled legacy operator for rollback, CI, and manual HF resource/Space
deployment. Ubuntu credentials stay in a private mode-600 file; Actions uses
repository secrets. Optional external models are configured through
LIVEHOUSE_MODELS_JSON. The Static Space itself receives no secret.
Run Verify Hugging Face backup in GitHub Actions to check recovery without changing either Dataset. It restores the private SQLite revision referenced by the public export, checks database integrity and foreign keys, and reproduces the four public CSV tables and leaderboard JSON (except its generation time). The run reports counts only; it does not upload the private database. The public Dataset exposes leaderboard, datasets, models, and releases as separate Dataset Viewer configurations.
Interactive result explorer
The benchmark page follows the subset/explorer approach of TabArena: category
buttons select a domain, a dataset selector narrows to an individual stream,
and model checkboxes control all analysis panels and the detailed table. The
server exports dataset_leaderboards alongside domain aggregates; dataset
selection never reuses global scores. Official eligibility thresholds remain
unchanged, so a single-dataset view has diagnostics but no official rank.
The ranking view contains only Elo and the leaderboard. Compare models shows one matched-task scatter plot after selecting one dataset and two models, with win/tie/loss counts and a guide to reading the diagonal. Forecasts default to one model against observed values, with one optional comparison model. Historical rankings remain in History and Archive is the final page section. Empty charts are hidden, with text explaining the missing evidence. Plotly 4.1.1 is loaded from its official CDN; charts support hover, zoom, legend toggles and PNG export. Tables and data links still work if the chart library is unavailable. Only nonempty selections are plotted. Elo uses an ordered dot plot with a visible numeric axis and aligned ratings; the gray row guides are not confidence intervals. Its displayed axis spans at least 100 Elo points so tiny differences are not stretched across the chart.
analysis.json contains the same already-public scored records as releases.csv
plus schema, metric/evaluation versions and export timestamp. It contains no
private contexts, future targets, endpoint secrets or error bodies. Its timestamp
must match the selected leaderboard; an older archive without this file shows
an unavailable diagnostic state rather than borrowing current releases.
Pair comparisons use only matching dataset/release/metric-version keys. The
paired advantage is 100*(error_B-error_A)/(error_A+error_B) (zero when both are
zero); positive means A is better. The paired scatter's logarithmic mode uses
log10(1+error) and raw-value tick/hover labels, retaining exact zero errors.
The selected pair's comparison does not replace or recompute official ranks.
forecast_examples.json publishes at most one resolved task for each of 20
datasets, with at most 120 context and 120 target points per example. Only
current-version, scored forecasts are included, with the mean and 10/50/90%
quantiles. Models must share the exact task and the same observed truth values
to appear together; different truth revisions are not overlaid. Raw response
archives, unscored predictions and future labels remain private. The gallery
is checked against the selected publication timestamp and metric version;
older snapshots without a gallery retain their original single-example view.
Baseline normalization matches dataset, release and metric version; missing/zero-error references yield missing values, never zero scores. Pair comparisons are descriptive, not significance tests. Historical rank lines are explicitly global. No latency, cost or confidence-interval chart is fabricated where that evidence is not recorded.
The Domain selector recomputes scores, Elo, coverage and failures using only that domain's tasks, then updates the table, comparison charts and dataset list. It does not merely filter globally scored rows. The five-dataset official-rank threshold is unchanged, so small domain slices can stay provisional. Old snapshots without domain exports offer only All domains. Historical rank lines remain global; forecast examples follow dataset and model selections. Display sorting does not change stored official ranks. The Date selector and Latest/Archived status identify the selected snapshot; publication timestamps remain in the downloadable exports rather than a separate result-date card.
Custom website domain (deferred)
Domain binding requires the owner's chosen hostname and DNS access. HF's native
custom-domain feature currently requires PRO or Team/Enterprise and a public or
protected Space. Register the hostname in Space settings, add the CNAME specified
by HF (documented target hf.space), and verify the status becomes ready and
HTTPS works before changing public links. Do not buy a domain or upgrade a plan
without owner approval. See HF custom domain documentation.
The existing HF address remains the working entry point until binding is done.
Historical ranks and Backtesting Archive
The Space includes Elo and composite-score comparison charts, daily rank history, and a version selector that loads the table, datasets, and forecast example from the same pinned public revision. Elo is displayed separately; current primary rank uses eligible pairwise wins. Archived v1 results retain their former composite-score ordering and must not be compared as one ranking regime with evaluation v2.
The hourly publisher adds at most one snapshot per UTC ISO week (Monday–Sunday)
to history.json, using the previously published HF commit. The first captured
version for a week is retained unchanged. Existing daily archives are preserved;
the Archive date-range filters can be expanded when needed. Each archive entry links to that commit's leaderboard,
release scores, forecast example, and private-source revision reference; it
does not publish the private database. These are archived prospective results,
not retrospective inference or imported paper scores. Archiving starts when
this feature is deployed; outages leave gaps instead of fabricated history.
The chart shows the latest 30 archived snapshots; older versions remain selectable
and downloadable. HF commit history must be retained for archive links to work.
- Downloads last month
- 2,668