kin-zhang/multidata-sf-challenge

AV2 2026 Multi-Dataset Scene Flow Challenge — Test Set

Dataset Description

This is the anonymized test set of the 2026 Multi-Dataset Scene Flow Challenge, a scene flow benchmark for autonomous driving in which one method with one configuration is evaluated on five LiDAR datasets.

The test set aggregates evaluation frames from five diverse LiDAR datasets, covering urban, suburban and highway driving with different sensor configurations, ego-vehicle platforms and geographic regions. All scenes are assigned opaque random identifiers, so a method is never told which source dataset a scene comes from. This design reflects the real-world requirement that a deployed perception system must handle any LiDAR sensor it encounters.

• Leaderboard and submission: sceneflow.kth-rpl.se (challenge details)
• Start here: OpenSceneFlow: data processing, training, evaluation, pre-trained models and one command to write the submission zip
• Curated by: Challenge organizers (RPL, KTH Royal Institute of Technology; Carnegie Mellon University; University of Pennsylvania)
• License: CC BY-NC-SA 4.0, non-commercial use only; individual source datasets retain their original licenses

Note: the previous leaderboard at sceneflow.argoverse.org no longer accepts uploads. Please submit at sceneflow.kth-rpl.se.

---

Dataset Statistics

Source dataset	LiDAR setup	# Scenes	# Eval frames
Argoverse 2	2× 32-beam	150	2,410
nuScenes	32-beam	85	1,981
Waymo	64-beam	100	2,094
TruckScenes	2× 32-beam	58	2,088
Aeva	6× FMCW LiDARs (128-beam)	65	1,040
Total		458	9,613

Every evaluation frame is scored at two distance ranges, 0–35 m and 35–70 m. Evaluation frames are sampled every 5 or 8 frames depending on the dataset, following the protocol of the previous AV2 Scene Flow Challenges, and only frames with ≥ 10,000 non-ground points and valid flow annotations are kept. The scene files contain all 93,547 frames of the 458 scenes, so methods can use multi-frame temporal context.

Download (about 131 GB):

hf download kin-zhang/multidata-sf-challenge --repo-type dataset --local-dir ./challenge_data
# older huggingface_hub versions: huggingface-cli download (same arguments)

---

Dataset Structure

challenge_data/
└── test/
    ├── index_eval.pkl     # the 9,613 (scene_id, timestamp) frames to predict
    ├── index_total.pkl    # all 93,547 (scene_id, timestamp) frames, used by data loaders
    ├── 00ca029d111e42deacecc8f9ed00d125.h5
    └── ...                # 458 scenes, one HDF5 file each

Each scene is a single HDF5 (.h5) file. Its groups are keyed by the timestamp string.

Fields per timestamp group

Field	Shape	dtype	Description
lidar	(N, 3) or (N, 4)	float32	Point cloud: x, y, z in metres. 143 of the 458 scenes add intensity as a 4th column, so use the first three columns.
ground_mask	(N,)	bool	True for ground points, which are excluded from evaluation.
pose	(4, 4)	float32 or float64	Ego-vehicle pose in the world frame (SE3 matrix).

Index file

index_eval.pkl is a Python pickle with the list of (scene_id, timestamp) pairs that need predictions. Both values are strings.

import pickle
with open("challenge_data/test/index_eval.pkl", "rb") as f:
    index = pickle.load(f)   # [('26edc282bf814226a9e0e600adfe537e', '1521738135343166'), ...]

Loading a frame

import pickle
import h5py

root = "challenge_data/test"
with open(f"{root}/index_eval.pkl", "rb") as f:
    index = pickle.load(f)

scene_id, timestamp = index[0]
with h5py.File(f"{root}/{scene_id}.h5", "r") as f:
    frame = f[str(timestamp)]
    pc   = frame["lidar"][:, :3]       # (N, 3) xyz
    gm   = frame["ground_mask"][:]     # (N,) ground mask
    pose = frame["pose"][:]            # (4, 4) ego pose

---

Submission: Quick Start with OpenSceneFlow

The easiest way to train a model and write a valid submission is the OpenSceneFlow codebase, which supports this challenge's data format and submission protocol.

Step 1: Install OpenSceneFlow

git clone https://github.com/KTH-RPL/OpenSceneFlow.git
cd OpenSceneFlow

Then set up the environment as described in the OpenSceneFlow README.

Step 2: Train, or download a pre-trained checkpoint

Train on any combination of supported datasets following the OpenSceneFlow README, or start from the pre-trained checkpoints on Hugging Face. Optimization-based methods need no training.

Rules

• Use one configuration for all scenes of all datasets: a single checkpoint for learned models, or the same hyper-parameters for optimization-based methods. No per-dataset models or tuning.
• Do not train on any validation set of any dataset.
• Test-time (per-scene) optimization is allowed but must be declared in the submission notes.

Step 3: Run inference on the challenge test set

Set dataset_path to the folder that contains test/, plus leaderboard_version=3 and save_res=True:

python eval.py \
  checkpoint=/path/to/your/model.ckpt \
  data_mode=test \
  dataset_path=/path/to/challenge_data \
  leaderboard_version=3 \
  save_res=True

Example output:

Model: DeltaFlow, Checkpoint from: /path/to/your/model.ckpt
Test results saved in: /path/to/results/deltaflow-xxx-test-v3, Please run submit command and upload to online leaderboard for results.

curl -O https://sceneflow.kth-rpl.se/download/sceneflow_submit.sh
export SCENEFLOW_API_KEY=your_api_key
bash sceneflow_submit.sh /path/to/results/deltaflow-xxx-test-v3.zip --method-name deltaflow-xxx-test-v3 --wait

The predictions are packaged into the correct zip layout automatically:

deltaflow-xxx-test-v3.zip
└── {scene_id}/
    ├── {timestamp_0}.feather
    ├── {timestamp_1}.feather
    └── ...

Step 4: Submit

1. Register your team, confirm your e-mail and wait for an organizer to approve the account.
2. Create an API key on your profile page.
3. Upload from a terminal. The uploader needs only bash and curl (Linux, macOS, WSL), no Python environment, and resumes interrupted uploads when you run the same command again:

curl -O https://sceneflow.kth-rpl.se/download/sceneflow_submit.sh
export SCENEFLOW_API_KEY=sfk_xxxxx
bash sceneflow_submit.sh --status    # check the key and today's quota

bash sceneflow_submit.sh submission.zip --method-name "MyMethod" --training-data multi \
  --project-url "https://github.com/user/repo" --notes "training data, backbone, ..." --wait

# a real example:
bash sceneflow_submit.sh /home/kin/results/deltaflow-891323-e21-test-v3-SynFlow.zip --method-name SynFlow-4k --wait

Option	Meaning
--training-data single or multi	Trained on one dataset only (e.g. only AV2), or on several datasets (list them in --notes). Shown as a label on the leaderboard.
--long-range	Also publish the 35–70 m results and enter the overall 0–70 m ranking. Leave it off if your model crops the point cloud (e.g. at 51.2 m).
--unsupervised	Unsupervised track: no human labels of any real-world dataset (self-supervised losses, simulated labels and foundation models are allowed).
--private	Keep the result off the public leaderboard (you can publish it later).
--wait	Wait for the evaluation and print the scores.

All options can also be changed later on the website, and bash sceneflow_submit.sh --help lists them. You can also upload in the browser on the Submit page, or use the Python version sceneflow_submit.py (standard library only, same options). Each team can submit 10 times per 24 hours, and one submission is evaluated at a time; results usually appear within 10 minutes under My submissions.

The old single-request curl -X POST .../submissions/upload command no longer works, because files over 100 MB cannot pass the proxy.

---

Submission Format (manual)

If you do not use OpenSceneFlow, predict the per-point flow for every (scene_id, timestamp) in index_eval.pkl in ego-motion-removed (relative) form and save each frame as an Apache Feather file:

import pandas as pd
from pathlib import Path

# final_absolute_flow = pred_flow + pose_flow  ->  submit pred_flow, NOT the absolute flow
# pred_flow: (N, 3) float32 numpy array, N = number of points in lidar (ground points included; they are masked on the server)
out_dir = Path("submission") / scene_id
out_dir.mkdir(parents=True, exist_ok=True)
pd.DataFrame({
    "flow_tx_m": pred_flow[:, 0],
    "flow_ty_m": pred_flow[:, 1],
    "flow_tz_m": pred_flow[:, 2],
}).to_feather(out_dir / f"{timestamp}.feather")   # file name = the exact timestamp from index_eval.pkl

Then zip the contents of submission/, so the scene folders are at the top level of the zip, and upload it as in Step 4:

cd submission && zip -r -0 ../submission.zip .

---

Evaluation Metric

The primary metric is Dynamic Bucket-Normalized EPE (Khatri et al., ECCV 2024; lower is better), the metric of the previous AV2 Scene Flow Challenges. It is class-aware and speed-normalized, so slow pedestrians and fast vehicles count fairly. Mean Static EPE, the classic Threeway EPE and per-class EPE are reported as well. Distances are Chebyshev distances in XY (max(|x|, |y|)):

Range	Description
0–35 m	Near range, same as the previous challenges; every entry is evaluated here
35–70 m	Long range, following the range-wise evaluation of SSF; optional (--long-range)

The leaderboard has three rankings, all by mean Dynamic averaged over the five datasets:

• Overview 0–70 m (default): mean of both ranges, for entries that evaluate 35–70 m
• 0–35 m: every entry
• 35–70 m: entries that evaluate 35–70 m

Entries without 35–70 m are listed below the Overview and 35–70 m rankings instead of being compared, and their 35–70 m numbers stay private. Every entry is shown in the Supervised or Unsupervised track and labelled single-dataset or multi-dataset; per-dataset and per-range breakdowns are in each entry's details.

---

Uses

Intended Use

This dataset is intended for the 2026 Multi-Dataset Scene Flow Challenge. It benchmarks the ability of one method with one configuration to estimate LiDAR scene flow across diverse sensors and driving scenarios without knowing the source dataset.

Participants should use the test set only for generating challenge submissions. No validation set of any of the five source datasets may be used for training.

Out-of-Scope Use

• Training or fine-tuning models on this test set (declared per-scene test-time optimization is allowed)
• Any commercial application
• Any use that violates the license terms of the individual source datasets

---

Dataset Creation

Curation Rationale

Prior scene flow benchmarks evaluate models on a single dataset and sensor. This dataset was created to measure zero-shot cross-domain generalization, a property that becomes more important as autonomous systems are deployed across diverse hardware platforms and geographic regions.

The scene anonymization ensures that leaderboard rankings reflect genuine multi-sensor generalization rather than dataset-specific tuning.

Source Data

Frames are selected from five publicly available autonomous driving datasets: the Argoverse 2 scenes come from the sensor test split, and the other four datasets from their validation splits. Frames are filtered to keep only those with sufficient non-ground point density and valid flow ground-truth annotations. Ground-truth flow is derived from 3D bounding-box tracks with rigid-body point assignment, following Khatri et al. (2024).

Scene IDs are replaced with random 32-character hex strings before public release. A private server-side mapping links each anonymous ID to the source dataset and real scene for per-dataset scoring.

Personal and Sensitive Information

All point clouds were collected from ego-vehicles in public road environments. Individual source datasets apply face and license-plate blurring where applicable. No personally identifiable information is present in the LiDAR point clouds.

---

Bias, Risks, and Limitations

• Geographic coverage is limited to North America, Europe and Singapore (urban and highway driving).
• Sensor diversity covers spinning mechanical LiDARs (32- and 64-beam) and FMCW LiDARs; other modalities are not represented.
• Ground-truth flow is derived from 3D bounding-box annotations, which may miss unlabeled or partially visible objects.
• Evaluation covers non-ground points only; ground-level motion (e.g., debris) is not measured.
• The anonymization prevents dataset-specific debugging; participants must rely on their own held-out data for ablations.

---

Citation

If you take part in the challenge or use this dataset, please cite the OpenSceneFlow works and the evaluation metric:

@inproceedings{zhang2024deflow,
  author={Zhang, Qingwen and Yang, Yi and Fang, Heng and Geng, Ruoyu and Jensfelt, Patric},
  booktitle={2024 IEEE International Conference on Robotics and Automation (ICRA)},
  title={{DeFlow}: Decoder of Scene Flow Network in Autonomous Driving},
  year={2024},
  pages={2105-2111},
  doi={10.1109/ICRA57147.2024.10610278}
}
@inproceedings{zhang2024seflow,
  author={Zhang, Qingwen and Yang, Yi and Li, Peizheng and Andersson, Olov and Jensfelt, Patric},
  title={{SeFlow}: A Self-Supervised Scene Flow Method in Autonomous Driving},
  booktitle={European Conference on Computer Vision (ECCV)},
  year={2024},
  pages={353–369},
  organization={Springer},
  doi={10.1007/978-3-031-73232-4_20},
}
@inproceedings{zhang2025deltaflow,
  title={{DeltaFlow}: An Efficient Multi-frame Scene Flow Estimation Method},
  author={Zhang, Qingwen and Zhu, Xiaomeng and Zhang, Yushan and Cai, Yixi and Andersson, Olov and Jensfelt, Patric},
  booktitle={The Thirty-ninth Annual Conference on Neural Information Processing Systems},
  year={2025},
  url={https://openreview.net/forum?id=T9qNDtvAJX}
}
@article{zhang2025himo,
  title={{HiMo}: High-Speed Objects Motion Compensation in Point Cloud},
  author={Zhang, Qingwen and Khoche, Ajinkya and Yang, Yi and Ling, Li and Mansouri, Sina Sharif and Andersson, Olov and Jensfelt, Patric},
  journal={IEEE Transactions on Robotics},
  year={2025},
  volume={41},
  pages={5896-5911},
  doi={10.1109/TRO.2025.3619042}
}
@inproceedings{zhang2026teflow,
  title = {{TeFlow}: Enabling Multi-frame Supervision for Self-Supervised Feed-forward Scene Flow Estimation},
  author = {Zhang, Qingwen and Jiang, Chenhan and Zhu, Xiaomeng and Miao, Yunqi and Zhang, Yushan and Andersson, Olov and Jensfelt, Patric},
  year = {2026},
  booktitle = {Proceedings of the IEEE/CVF conference on computer vision and pattern recognition},
  pages = {3667-3676},
}
@article{zhang2026synflow,
  title={{SynFlow}: Scaling Up LiDAR Scene Flow Estimation with Synthetic Data},
  author={Zhang, Qingwen and Zhu, Xiaomeng and Jiang, Chenhan and Jensfelt, Patric},
  journal={arXiv preprint arXiv:2604.09411},
  year={2026}
}
@inproceedings{khoche2025ssf,
  title={{SSF}: Sparse Long-Range Scene Flow for Autonomous Driving},
  author={Khoche, Ajinkya and Zhang, Qingwen and Sanchez, Laura Pereira and Asefaw, Aron and Mansouri, Sina Sharif and Jensfelt, Patric},
  booktitle={2025 IEEE International Conference on Robotics and Automation (ICRA)},
  year={2025},
  pages={6394-6400},
  doi={10.1109/ICRA55743.2025.11128770}
}
@inproceedings{khatri2024trackflow,
  author    = {Khatri, Ishan and Vedder, Kyle and Peri, Neehar and Ramanan, Deva and Hays, James},
  title     = {I Can't Believe It's Not Scene Flow!},
  booktitle = {European Conference on Computer Vision (ECCV)},
  year      = {2024}
}

Other methods in OpenSceneFlow (collaborators)

@article{li2025uniflow,
  title={{UniFlow}: Zero-Shot {LiDAR} Scene Flow for Autonomous Vehicles},
  author={Li, Siyi and Zhang, Qingwen and Khatri, Ishan and Vedder, Kyle and Eaton, Eric and Ramanan, Deva and Peri, Neehar},
  journal={arXiv preprint arXiv:2511.18254},
  year={2025}
}
@article{khoche2026dogflow,
  author={Khoche, Ajinkya and Zhang, Qingwen and Cai, Yixi and Mansouri, Sina Sharif and Jensfelt, Patric},
  journal = {IEEE Robotics and Automation Letters},
  title = {{DoGFlow}: Self-Supervised LiDAR Scene Flow via Cross-Modal Doppler Guidance},
  year = {2026},
  volume = {11},
  number = {3},
  pages = {3836-3843},
  doi = {10.1109/LRA.2026.3662592},
}
@article{kim2025flow4d,
  author={Kim, Jaeyeul and Woo, Jungwan and Shin, Ukcheol and Oh, Jean and Im, Sunghoon},
  journal={IEEE Robotics and Automation Letters},
  title={Flow4D: Leveraging 4D Voxel Network for LiDAR Scene Flow Estimation},
  year={2025},
  volume={10},
  number={4},
  pages={3462-3469},
  doi={10.1109/LRA.2025.3542327}
}
@inproceedings{lin2025voteflow,
  title={VoteFlow: Enforcing Local Rigidity in Self-Supervised Scene Flow},
  author={Lin, Yancong and Wang, Shiming and Nan, Liangliang and Kooij, Julian and Caesar, Holger},
  booktitle={CVPR},
  year={2025},
}

---

Dataset Card Contact

Please open an issue on OpenSceneFlow, or contact the challenge organizers. Challenge details and the leaderboard: sceneflow.kth-rpl.se.