Datasets:
You need to agree to share your Hugging Face information to access this dataset
This repository is publicly accessible, but you have to accept the conditions to access its files and content.
The NativeCodec repositories use manual approval. The dataset archive and videos are available after your access request is approved. Please describe your intended use; this dataset card remains readable without approval.
Log in or Sign Up to review the conditions and access this dataset content.
BallBench
A high-frame-rate benchmark for identity reasoning in videos.
BallBench asks what happens when appearance cannot tell objects apart. Inside a square box, 4 to 10 visually identical balls move and collide. A clip starts with two seconds during which every ball shows a number, then the labels disappear. The question refers to a ball by its initial number and asks for the final label it carries at the end of the clip. Answering requires following trajectories through collisions, and collisions can happen in a single frame at the 30 fps recording rate: sparse frame sampling loses exactly the evidence the question is about.
The validation split has 70 episodes and 490 questions (7 per episode). A uniform guess over the number of balls yields 13.9% accuracy. The training split has 6,000 episodes and 30,000 questions and can be used to fine-tune models on the task.
This dataset accompanies NativeCodec, and the benchmark appears in its comparisons. The two aligned models are NativeCodec-4B-PredLen and NativeCodec-4B-FixedRatio.
Access request
This repository is public but gated with manual approval. Anonymous visitors can read this card and see the file list. Downloading the archive or any video requires approval.
To request access, open the dataset page, sign in, click Agree and access repository / Request access, and submit the form. Access is granted to individual users, not to organizations. Requests are reviewed manually by the maintainers without an automatic approval or a published turnaround guarantee; the Hub notifies you when a decision is made. A rejected request cannot be resubmitted from the same account on the Hub.
After approval, download the dataset with an authenticated session:
hf auth login
hf download Tennineee/NativeCodec-BallBench --repo-type dataset --local-dir NativeCodec-BallBench
The dataset is distributed as one archive, data/ballbench_data.tar (about 4.0 GB, 3,975,144,296 bytes of unpacked files), so a single download and extraction gives the full public tree. Set HF_ENDPOINT=https://hf-mirror.com for the download if huggingface.co is unreachable; the login flow itself must run against huggingface.co.
tar -xf data/ballbench_data.tar -C .
# the archive keeps the original relative paths, so files land under data/new_train_x20/public/ and data/new_valid/public/
A SHA256SUMS file at the repository root lists the archive checksum. After download, verify it with sha256sum -c SHA256SUMS (on macOS use shasum -a 256 -c SHA256SUMS).
Files
| Path | Files | Content |
|---|---|---|
data/ballbench_data.tar |
1 | public splits: videos and QA files listed below, with their original relative paths |
benchmarks/ |
10 | benchmark generation code, prompts and configs |
SHA256SUMS |
1 | checksum of the archive (added by the maintainers after upload) |
README.md |
1 | this card |
Inside data/ballbench_data.tar:
| Path | Files | Content |
|---|---|---|
data/new_train_x20/public/qa.jsonl |
1 | 30,000 training QA rows, one JSON object per line |
data/new_train_x20/public/videos/ |
6,000 | training clips, MP4, 30 fps |
data/new_train_x20/public/qa_parts/ |
6,000 | the same training QA split into one file per episode |
data/new_valid/public/qa.jsonl |
1 | 490 validation QA rows |
data/new_valid/public/videos/ |
70 | validation clips, MP4, 30 fps |
All videos are rendered at 30 fps with a 512-pixel long side. Episode content varies: ball count from 4 to 10, collision setup and labels drawn per episode with a fixed seed recorded in the generation config. Training episodes use seeds from benchmarks/config_train_x20.yaml (per-class seeds and the per_class_episodes: 2000 setting), validation episodes from benchmarks/config_valid.yaml.
Source layout and scale
The full source tree of BallBench, before packaging, contains 24,226 files and 4,660,381,124 bytes. new_train_x20 holds 12,001 public files and 12,000 internal files; new_valid holds 71 public and 140 internal files; four generation metadata JSON files sit at the data root; and benchmarks/ adds 10 files. The published archive contains the public splits only, 12,072 files and 3,975,144,296 bytes unpacked, plus the benchmark code as a separate directory. Internal frames, per-episode trajectory reports and the generation metadata are excluded because they carry generation-environment paths and are not needed for evaluation; every video and QA row used by the benchmark is in the public splits. The full-tree figure is recorded here for provenance.
QA format
{
"query_id": "newtrain20_000000_identity_01",
"episode_id": "newtrain20_000000",
"video": "videos/newtrain20_000000.mp4",
"split": "train",
"question": "Which final label corresponds to ball 1 from the beginning?",
"gt": 3,
"user_prompt": "The video shows several balls inside a square box, and it has three consecutive phases: ..."
}
| Field | Meaning |
|---|---|
query_id |
unique question id |
episode_id |
episode id; its video is at videos/<episode_id>.mp4 |
video |
path of the clip relative to the split directory |
split |
train or valid |
question |
the short question form, always asking for the final label of one ball |
gt |
integer ground-truth label of that ball at the end of the clip |
user_prompt |
the full prompt used at evaluation time, including the phase description |
Evaluation
Evaluate multiple-choice style by comparing the predicted final label with gt; accuracy is the metric. Models receive a video and the user_prompt, and the question count per video is fixed, so the score is the mean accuracy over all questions.
The benchmark is designed for frame-rate sensitivity. The NativeCodec model card reports accuracy at 16, 8, 4 and 2 fps: with the incremental encoder every frame is encoded, while sparse-sampling baselines degrade. The evaluation code that produced the leaderboard is part of the NativeCodec code repository (stage4_benchmark_eval/).
For reproducibility, the generation scripts in benchmarks/ are included: generate_episode.py (physics and rendering), physics.py (collision simulation), prompts_new.py (prompt templates, version v5.1), generate_new.py (split driver), and the two config files. Regenerating a split requires the same seeds and the rendering dependencies of the original pipeline.
Terms of use
The upstream license and the copyright status of the underlying video clips have not been verified. The dataset is provided for research evaluation and benchmarking. Redistribution and commercial use are not granted here. If you plan to use it beyond research evaluation, check with the maintainers and with the owners of the source material first.
Citation
A technical report is not published yet. If you use BallBench, cite the announcement of the NativeCodec release (2026/09/23) and link this dataset card.
NativeCodec Team
- Downloads last month
- -