Traffic-Demand-Bench

How many people will take a bike or a taxi in each part of the city — next hour, next day, next three days?

English | 中文 · Data and code: Hugging Face

Divide a city into zones. For every hour, count how many people take a shared bike or get into a taxi in each zone. That count is demand. Traffic-Demand-Bench is a forecast contest for that number: like a weather forecast, but for how busy each neighborhood will be.

We use the same rules on bike-share and taxi systems in New York, Chicago, the Bay Area, Boston, and Toronto. Public scores use the full half-year July–December 2025. Finished test MAE is in RESULTS.md. To reproduce, start from run.py.

How this differs from earlier tests

1. Older tests show the model too little history, and that does not match a real rollout

A forecast looks at the recent past, then guesses the future. That past stretch is the history window (also called lookback).

On highways the usual setup is: look at the last hour (12 five-minute slices) and predict the next hour. Demand papers often do the same idea with “six hours of history → one hour ahead.” When history is capped that short, a method that only uses the last few points and a method that can use days or weeks of rhythm are scored with the same ruler. The second kind never gets to show what it can do. Winning on a one-hour window does not tell you who wins when history is allowed to grow.

In a real deployment the goal is to be as accurate as possible. Nobody requires the system to look back only one hour or six hours. If operations already have days or weeks of history, the model can use that history. So we set lookback on the wall clock and make it long on purpose: city-trained spatial methods may see 1, 7, or 14 days; city-trained time-series methods may see tens of days; pretrained foundation models use as much history as their authors officially allow.

How far we ask them to look ahead also follows the short / mid / long horizons that show up after a system goes live: short is the next hour, mid is the next day, long is the next three days — not “always the next hour.”

2. Older tests compare too few kinds of method; four families were never on one report card

There are at least four ways to do this job. Earlier boards usually pick one lane:

• City-trained spatiotemporal models use both time and the fact that nearby zones affect each other (STGCN, Graph WaveNet, …).
• City-trained time-series models treat each zone mostly as its own curve (DLinear, PatchTST, …).
• Time-series foundation models are pretrained on huge amounts of other time data, then guess on our cities without (or almost without) extra training (Chronos, TimesFM, TiRex, …).
• Spatiotemporal foundation models already saw space during pretraining (OpenCity, UniST, …).

Toolkits such as LibCity and BasicTS mainly compare the first two “train it on this city” families. TFB and GIFT-Eval compare the third family on generic time series and barely touch city neighborhoods. OpenCity and UniST are model papers, not a shared city-demand exam.

We put all four on the same city, same history, same second-half-of-2025 exam, so a take-it-and-run foundation model and a network trained for one city can be compared for a real rollout.

3. Older work lacks data that is only about traffic demand and that spans many years

Highway boards (often called METR, PEMS, LargeST) measure speed or how many cars pass a roadside sensor. That is not “how many people board in this neighborhood.” Public demand-like sets (early Beijing taxi or New York bike slices) are often only a few months. A few months cannot feed a model that needs long history, and it cannot answer a practical question: if this system stays online for half a year — through seasons, holidays, and weather — does it still work?

We built hourly demand for seven systems from 2013 or 2014 through the first half of 2026, usually more than a hundred months. The public exam is six months in a row. Quiet zones (under one trip per hour on average in that exam) are not scored, so empty cells cannot make the error look better than it is.

Compared with earlier benchmarks:

Name	Paper	What is counted	Where	How long is the data	How far ahead	Who is compared	What is missing
METR-LA / PEMS-BAY	[1]	How fast cars go on a highway	Roadside sensors	4–6 months	Next 15–60 minutes	Spatial nets	Speed, not who boards
PeMSD7	[2]	Same, speed	Sensors	~2 months	Less than an hour	Early spatial nets	Same short-history exam
PEMS03 / 04 / 07 / 08	[4,5]	How many cars pass	Sensors	~2–3 months	Next hour	Almost every later traffic table	Cannot seriously test 1 day / 3 days
TaxiBJ / BikeNYC	[6]	People in a grid cell	City grids	Public scores often a few months	Near / daily / weekly windows	Image-style nets	Right task family, short exam
LargeST	[7]	Highway car counts	Very many sensors	Years of raw data; scores often 1 year	Next hour	Large-graph nets	Scale is more sensors, not years of demand
LibCity	[8]	Several urban forecasts	Mixed	Mixed	Default still the next hour	60+ city-trained models	A toolbox, not this long exam
BasicTS	[9,10]	Many curves + space	Still mostly highway sets	Same	Short spatial + some long series	City-trained time / space models	Almost no take-it-and-run foundation models
DL-Traff	[11]	Grid or road traffic	Mixed	Short	Short	Grid / road nets	Still short-history traffic
TFB / GIFT-Eval	[16,17]	Time series from many fields	Usually no city zones	Many domains	Short and long	Stats, deep nets, time foundation models	Almost no “who affects whom in the city”
UniST / OpenCity	[14,15]	City or traffic foundation models	Many cities	Mixed pretrain data	Each paper its own	One foundation model vs city-trained nets	Model papers, not a shared exam
Traffic-Demand-Bench	this repo	Who boards in which zone, each hour	Active zones in 7 systems	Earliest 2013 through mid-2026	short / mid / long: 1 hour / 1 day / 3 days	All four families, one rulebook	Test is 2025 H2; history length chosen on validation

Which cities

The public score is demand only on these seven systems (how many people board each hour), not highway sensors. Zone boundaries stay fixed. NYC taxi is stored every 30 minutes and summed to the hour when loaded. The spans below are the processed months now on disk.

Code	System	Bike or taxi	How the city is cut	How often we record	Months already on disk	How many months
NYCBIKE	NYC Citi Bike	Bike	200 boxes	Every hour	2014-01 → 2026-06	150
NYCTAXI	NYC yellow taxi (TLC)	Taxi	265 official zones	Stored every 30 min, summed to the hour	2014-01 → 2026-05 (June 2026 not published yet)	148
CHIBIKE	Chicago Divvy	Bike	200 boxes	Every hour	2013-06 → 2026-06	157
CHITAXI	Chicago Taxi	Taxi	171 official zones	Every hour	2013-01 → 2026-06	162
BAYBIKE	Bay Area Ford GoBike / Bay Wheels	Bike	154 boxes	Every hour	2017-06 → 2026-06	108
BOSBIKE	Boston Hubway / Bluebikes	Bike	300 boxes	Every hour	2015-01 → 2026-06	137
TORBIKE	Toronto Bike Share	Bike	204 boxes	Every hour	2017-01 → 2026-06	114

A zone that averages under one trip per hour in the exam half-year is too quiet to score. Models are compared only on the rest. We count boardings / pickups (inflow), not returns.

This repo keeps demand only. Highway flow and speed files are not included. Raw trips under datasets/demand/_raw/ are not uploaded.

How a trip becomes an hourly number (datasets/demand/extend_hourly.py): drop rides shorter than 60 seconds or longer than 6 hours; NYC taxi must have distance > 0; Chicago taxi drops zero-mile trips; bikes count pickups and returns; taxis count pickups and drop-offs (some Chicago months historically have pickups only). A month that is already processed is not downloaded again.

Sources, file layout, and the plotting script are in datasets/README.md (Chinese). The same figures are below.

How the city is cut

Bike systems use a regular lon/lat grid. Taxis follow official zones: NYC TLC Taxi Zones and Chicago census tracts. The New York, Chicago, and Boston maps come from dissertation Appendix A; the Bay Area and Toronto maps are drawn the same way.

NYC Citi Bike, 200 cells:

NYC yellow taxi, official Taxi Zones:

Chicago Divvy, 200 cells:

Chicago taxi, 171 census tracts:

Boston Bluebikes, 300 cells:

Bay Wheels, 154 cells:

Toronto Bike Share, 204 cells:

City-wide use, every day

The light-green line is the city’s daily pickups / boardings. The dark-green line is a 30-day moving average. The dissertation appendix only showed a short slice; these plots use every processed month on disk.

Taxi use collapsed in 2020 and stayed far below the pre-COVID level. Bike-share mostly kept growing, with a summer peak and a winter trough. The Bay Area has a near-empty stretch in 2020; Toronto spikes in 2025 and then drops, which is exactly the public exam half-year. That is why the scorecard has two training settings: A uses only post-COVID data through 2025 H1; B also adds the pre-COVID years.

The busiest zone, one month, every hour

For each system we pick the zone with the most boardings in a 30-day window and plot every hour. The default window is September 2025. Toronto is almost empty that month, so we use 2–31 March 2026 instead.

System	Busiest zone in this window	Window	About trips / hour
NYC bike	#53	2025-09	155
NYC taxi	#236	2025-09	254
Chicago bike	#37	2025-09	24
Chicago taxi	#19	2025-09	36
Bay Area bike	#71	2025-09	13
Boston bike	#174	2025-09	27
Toronto bike	#94	2026-03-02 → 03-31	15

The busiest NYC cell can reach a few hundred trips in a day, with clear morning and evening peaks. The other cities are about an order of magnitude smaller, but they still have weekday peaks and near-zero nights. A model has to follow both this daily rhythm and the year-scale drift above.

How we score

For every zone that is busy enough: look at how many people boarded in the recent past, then guess the future. The tasks follow the short / mid / long horizons that show up after a rollout —

Task	Range	How far ahead	How often we ask	About how many asks in six months
1h	Short	Next hour	Every clock hour	~4300
1d	Mid	Next day	Once a day	~180
3d	Long	Next three days	Also once a day (not once every three days)	about the same as the 1-day task

How often we ask is not the same as how far we guess. For the three-day question we still ask every day, so the half-year is fully covered and the number of questions is not cut to one third. The ask must sit inside the exam half-year; the history we look back on may reach earlier days. Every scheduled ask in the exam is used — we do not pick a handful of dates.

Train / validation / test

The calendar is split in three:

• Train: the model is fit on these days.
• Validation: history length and when to stop are chosen only here, not on the test months.
• Test: the only place we report a final score. Public numbers always use July–December 2025.

run.py --setting picks one of the three calendars in eval_tsfm/protocol.py.

Setting	Train	Validation	Test	Role
A (after COVID)	2021-01-01 → 2025-06-30	June 2025	2025-07-01 → 2025-12-31	Public table
B (plus years before COVID)	earliest month in that city → 2025-06-30	June 2025	the same second half of 2025	Does the extra early history help 2025?
legacy	2021-01-01 → 2022-11-30	December 2022	2023-01-01 → 2023-06-30	Used to debug the pipeline before 2026 data existed

How far we look back, which training round we keep, and which weights we report are chosen only by mean absolute error on validation. Each “method × city × how far ahead” is reported once on test. Many rows now in results/ are still legacy and are not the public second-half-of-2025 scores.

How far back a model may look

Different methods can digest different amounts of history. We do not force one length on everyone:

Kind of method	History lengths we try	In days
City-trained, also uses nearby zones (STGCN and similar)	1 / 7 / 14 days; keep the best on validation	24 / 168 / 336 hours
City-trained, mainly one curve per zone (DLinear and similar)	256 / 512 / 1024 / 2048 hours	about 11 / 21 / 43 / 85 days
Pretrained time-series foundation models	As long as the authors officially allow (common caps 2048 / 8192 / 15360 hours)	as long as that checkpoint allows
OpenCity-Plus	Official 1-day window	1-hour task uses the first hour; 3-day task rolls out three 1-day forecasts

Errors

All three are smaller is better:

• Mean absolute error (MAE): how many people we miss on average. This is the number we use to pick a model.
• Root mean squared error (RMSE): large misses are penalized more.
• Mean absolute percentage error (MAPE): how many percent we are off. Cells whose true count is near zero are left out, so the percent does not blow up.

The public-protocol random seed is written as 2025. With the same seed, each “model × city × horizon × lookback” re-seeds initialization, batch order, and dropout so that cell can be reproduced; a mid-run resume stores the RNG in the checkpoint.

Models

We use the implementations from each paper’s repository rather than rewriting them. Each trainable model has a YAML that names the paper and the file the hyperparameters came from: spatiotemporal models in eval_stnn/configs/, time-series models in eval_tsfm/configs/. Longer notes: eval_stnn/docs/, eval_tsfm/docs/. python run.py --list prints the catalog again.

Official scripts live in model_scripts/ under tsfm/, stfm/, ts/, and stnn/. Weights stay in weights/ with the same four folders. Older evals and unused data: D:\traffic-ban-archive.

RNN-backbone spatiotemporal models are not included (DCRNN [1], AGCRN, MegaCRN, …).

Already wired into run.py

Model	How it runs	Family	Paper	Code / config
Last	Closed-form	Baseline	—	Repeat the last observation
WeeklyHA	Closed-form	Baseline	—	Hour-of-week mean; needs ≥ 1 week of context
DLinear	Train per city	TS	Zeng et al., AAAI 2023 [20]	LTSF-Linear; configs/DLinear.yaml ← run_longExp.py
NLinear	Train per city	TS	same [20]	Same repo, NLinear.py
PatchTST	Train per city	TS	Nie et al., ICLR 2023 [21]	yuqinie98/PatchTST; PatchTST.yaml ← traffic.sh
iTransformer	Train per city	TS	Liu et al., ICLR 2024 [22]	thuml/iTransformer; iTransformer.yaml ← PEMS08 96→12
Chronos-2	Load official weights	TSFM	Ansari et al. [18]	amazon/chronos-2, context cap 8192
TimesFM-3	Load weights	TSFM	Das et al., ICML 2024 [19]	google/timesfm-3.0-pytorch, cap 15360
TiRex-2	Load weights	TSFM	NX-AI	NX-AI/TiRex-2, released yaml cap 2048
STGCN	Train per city	ST	Yu et al., IJCAI 2018 [2]	hazdzz/STGCN; STGCN.yaml
Graph WaveNet	Train per city	ST	Wu et al., IJCAI 2019 [3]	nnzhan/Graph-WaveNet; GWNet.yaml
STAEformer	Train per city	ST	Liu et al., CIKM 2023 [12]	XDZhelheim/STAEformer; STAEformer.yaml
PatchSTG	Train per city	ST	Fang et al., KDD 2025 [13]	LMissher/PatchSTG; PatchSTG.yaml ← SD.conf
STID	Train per city	ST	Shao et al., CIKM 2022 [23]	zezhishao/STID; STID.yaml ← PEMS08.py
TimeMixer	Train per city	TS	Wang et al., ICLR 2024 [24]	Time-Series-Library TimeMixer; TimeMixer.yaml ← PEMS short-term
CycleNet	Train per city	TS	Lin et al., NeurIPS 2024 [25]	ACAT-SCUT/CycleNet; hourly cycle=24
TQNet	Train per city	TS	Lin et al., ICML 2025 [34]	ACAT-SCUT/TQNet; TQNet.yaml ← hourly traffic.sh
SOFTS	Train per city	TS	Lu et al., NeurIPS 2024 [35]	Secilia-Cxy/SOFTS; SOFTS.yaml ← Traffic script
SRSNet	Train per city	TS	Wu et al., NeurIPS 2025 Spotlight [36]	decisionintelligence/SRSNet; SRSNet.yaml ← MODEL_HYPER_PARAMS
MTGNN	Train per city	ST	Wu et al., KDD 2020 [26]	nnzhan/MTGNN; MTGNN.yaml ← train_multi_step.py
ST-Norm	Train per city	ST	Deng et al., KDD 2021 [27]	JLDeng/ST-Norm; STNorm.yaml
D2STGNN	Train per city	ST	Shao et al., VLDB 2022 [28]	GestaltCogTeam/D2STGNN; D2STGNN.yaml ← PEMS08
PDFormer	Train per city	ST	Jiang et al., AAAI 2023 [29]	BUAABIGSCity/PDFormer; PDFormer.yaml ← PeMS08.json
BigST	Train per city	ST	Han et al., VLDB 2024 [30]	usail-hkust/BigST; BigST.yaml
RPMixer	Train per city	ST	Yeh et al., KDD 2024 [31]	Paper §4 (no public GitHub); RPMixer.yaml
STDN	Train per city	ST	Cao et al., AAAI 2025 [32]	roarer008/STDN; STDN.yaml ← PEMSD4
UniST	Train per city	ST-FM	Yuan et al., KDD 2024 [14]	tsinghua-fib-lab/UniST size=1 on a 1×N grid
Toto-2.0-2.5B	Load official weights	TSFM	Datadog [33]	toto-2 in venv312 (Python ≥3.12). Small-test uses Toto-2.0-22m
OpenCity-Plus	Load official weights	ST-FM	Wang et al., 2024 [15]	hkuds/OpenCity-Plus; fair zero-shot = the seven demand cities

“Train per city”: fit on that city’s setting A or B with the official optimizer and width. “Load weights”: no further training on our cities.

Open-source, not wired yet

TabPFN-TS needs the Prior-Labs/tabpfn_3 license accepted first. TimeMixer++ (ICLR 2025) official code is not cleanly released. SparseTSF (ICML 2024 Oral) needs seq_len and pred_len both divisible by period_len, which does not fit the 1h horizon. New models still come in as the official repo plus a YAML.

How to run

Windows PowerShell treats 1h / 1d / 3d as time spans, so quote those arguments. The default environment is venv311 (Python 3.11, torch cu118). Toto-2 uses a separate venv312 (Python 3.12.10 at D:\traffic-ban\venv312). If Hugging Face is unreachable, set HF_ENDPOINT=https://hf-mirror.com.

$env:PYTHONPATH = "D:\traffic-ban"

python run.py --list
python run.py --small-test
python scripts/small_test_models.py   # TimeMixer / CycleNet / TQNet / SOFTS / SRSNet / ST extras

# Toto-2 lives in venv312
D:\traffic-ban\venv312\Scripts\python.exe scripts\small_test_toto.py
D:\traffic-ban\venv312\Scripts\python.exe run.py --mode zero-shot --models toto-2 --datasets BAYBIKE --horizons "1h" --lookbacks 2048 --device cuda:0

# Zero-shot / closed-form
python run.py --mode zero-shot --models last,weeklyha --datasets BAYBIKE --horizons "1h" --lookbacks 168 --setting legacy --seed 2025
python run.py --mode zero-shot --models chronos-2 --datasets BAYBIKE --horizons "1h" --lookbacks 2048 --device cuda:0

# Train per city (hparams live in the YAML)
python run.py --mode train --models DLinear,NLinear --datasets BAYBIKE --horizons "1h" --lookbacks 168 --setting A --seed 2025
python run.py --mode train --models STGCN,STID --datasets BAYBIKE --horizons "1h" --lookbacks "1d,7d" --device cuda:0 --setting A

Two processes must not write the same results/*.csv at the same time.

datasets/demand/       hourly demand and zone boundaries
eval_tsfm/protocol.py  train / validation / test dates, how far ahead, how often we ask
eval_stnn/             city-trained spatiotemporal models
eval_tsfm/             city-trained time-series models and pretrained time foundation models
eval_stfm/             OpenCity-Plus
run.py / catalog.py    one entry point and the model list

Processed hourly arrays, zone boundaries, code, and finished scores are on Hugging Face tjtrans/Traffic-Demand-Bench. Raw trips and model weights are not uploaded.

References

1. Li, Y., Yu, R., Shahabi, C., & Liu, Y. (2018). Diffusion convolutional recurrent neural network: Data-driven traffic forecasting. ICLR.
2. Yu, B., Yin, H., & Zhu, Z. (2018). Spatio-temporal graph convolutional networks: A deep learning framework for traffic forecasting. IJCAI.
3. Wu, Z., Pan, S., Long, G., Jiang, J., & Zhang, C. (2019). Graph WaveNet for deep spatial-temporal graph modeling. IJCAI.
4. Guo, S., Lin, Y., Feng, N., Song, C., & Wan, H. (2019). Attention based spatial-temporal graph convolutional networks for traffic flow forecasting. AAAI.
5. Song, C., Lin, Y., Guo, S., & Wan, H. (2020). Spatial-temporal synchronous graph convolutional networks. AAAI.
6. Zhang, J., Zheng, Y., & Qi, D. (2017). Deep spatio-temporal residual networks for citywide crowd flows prediction. AAAI.
7. Liu, X., Xia, Y., Liang, Y., et al. (2023). LargeST: A benchmark dataset for large-scale traffic forecasting. NeurIPS Datasets and Benchmarks.
8. Wang, J., Jiang, J., Jiang, W., Li, C., & Zhao, W. X. (2021). LibCity: An open library for traffic prediction. SIGSPATIAL.
9. Shao, Z., et al. (2023). BasicTS: An open source fair multivariate time series prediction benchmark. ADMA.
10. Shao, Z., et al. (2024). Exploring progress in multivariate time series forecasting: Comprehensive benchmarking and heterogeneity analysis. IEEE TKDE.
11. Jiang, R., et al. (2021). DL-Traff: Survey and benchmark of deep learning models for urban traffic prediction. CIKM.
12. Liu, H., Dong, Z., Jiang, R., et al. (2023). Spatio-temporal adaptive embedding makes vanilla transformer SOTA for traffic forecasting. CIKM.
13. Fang, T., et al. (2025). Efficient large-scale traffic forecasting with transformers: A spatial data management perspective. KDD.
14. Yuan, Y., et al. (2024). UniST: A prompt-empowered universal model for urban spatio-temporal prediction. KDD.
15. Wang, Z., et al. (2024). OpenCity: Open spatio-temporal foundation models for traffic prediction. arXiv:2408.10269.
16. Qiu, X., et al. (2024). TFB: Towards comprehensive and fair benchmarking of time series forecasting. VLDB.
17. Aksu, T., et al. (2024). GIFT-Eval: A benchmark for general time series forecasting model evaluation. arXiv:2410.10393.
18. Ansari, A. F., et al. Chronos / Chronos-2. Amazon Science.
19. Das, A., et al. (2024). A decoder-only foundation model for time-series forecasting (TimesFM). ICML.
20. Zeng, A., Chen, M., Zhang, L., & Xu, Q. (2023). Are transformers effective for time series forecasting? AAAI.
21. Nie, Y., Nguyen, N. H., Sinthong, P., & Kalagnanam, J. (2023). A time series is worth 64 words. ICLR.
22. Liu, Y., et al. (2024). iTransformer: Inverted transformers are effective for time series forecasting. ICLR.
23. Shao, Z., et al. (2022). Spatial-temporal identity: A simple yet effective baseline for multivariate time series forecasting. CIKM.
24. Wang, S., et al. (2024). TimeMixer: Decomposable multiscale mixing for time series forecasting. ICLR.
25. Lin, S., et al. (2024). CycleNet: Enhancing time series forecasting through modeling periodic patterns. NeurIPS.
26. Wu, Z., et al. (2020). Connecting the dots: Multivariate time series forecasting with graph neural networks. KDD.
27. Deng, J., et al. (2021). ST-Norm: Spatial and temporal normalization for multi-variate time series forecasting. KDD.
28. Shao, Z., et al. (2022). Decoupled dynamic spatial-temporal graph neural network for traffic forecasting. VLDB.
29. Jiang, J., et al. (2023). PDFormer: Propagation delay-aware dynamic long-range transformer for traffic flow prediction. AAAI.
30. Han, J., et al. (2024). BigST: Linear complexity spatio-temporal graph neural network for traffic forecasting on large-scale road networks. VLDB.
31. Yeh, C.-C. M., et al. (2024). RPMixer: Shaking up time series forecasting with random projections for large spatial-temporal data. KDD.
32. Cao et al. (2025). Spatiotemporal-aware Trend-Seasonality Decomposition Network for Traffic Flow Forecasting. AAAI.
33. Datadog. Toto-2. Datadog/Toto-2.0-2.5B.
34. Lin, S., et al. (2025). Temporal Query Network for Efficient Multivariate Time Series Forecasting. ICML.
35. Lu, H., et al. (2024). SOFTS: Efficient Multivariate Time Series Forecasting with Series-Core Fusion. NeurIPS.
36. Wu, X., et al. (2025). Enhancing Time Series Forecasting through Selective Representation Spaces: A Patch Perspective. NeurIPS.