Add the dataset card

README.md

@@ -1,5 +1,5 @@
 ---
-license: other
+license: cc-by-4.0
 task_categories:
 - visual-question-answering
 language:
@@ -7,200 +7,225 @@ language:
 tags:
 - robotics
 - temporal-reasoning
-- video-qa
+- video-question-answering
+- embodied-ai
+size_categories:
+- 10K<n<100K
 ---
 
-# RoboChrono-GIM
+# RoboChrono — GIM
 
-Temporal visual reasoning on robot manipulation video. Each question asks about
-**when** something happens rather than what is in the frame — which action is
-running now, what comes next, which frame came from this clip, what order three
-moments go in.
+RoboChrono asks a vision-language model **when** things happen in a robot
+manipulation recording, rather than what appears in a single frame: which action is
+running now, which one comes next, which still frame belongs to a clip, which camera
+shows the same moment, what order three frames go in, and when a named action occurs.
 
-The repository holds two disjoint subsets, same format, separate manifests:
+This repository holds **15 scenarios · 776 episodes · 15,204 questions · 42.5 GB**.
+Every scenario here is `gim`.
 
-| | where | platform | scenarios | episodes | questions | size |
-| --- | --- | --- | ---: | ---: | ---: | ---: |
-| **GIM** | repository root | industrial dual-arm rig, dark red arms on a green table | 15 | 776 | 15,204 | 42.5 GB |
-| **Tianji** | `Tianji/` | 5 hand + 14 tianji + 5 tianjihand | 24 | 1040 | 19,509 | 31.4 GB |
+## The complete benchmark
 
-    GIM     fingerprint  9cb5dc6353f2
-    Tianji  fingerprint  11c770521a2f
+RoboChrono is published as two dataset repositories. Together they hold
+**39 scenarios and 34,713 questions**.
 
-Together they are every scenario the source project has: 39 in all, each
-taken whole from one upstream build.
+| Repository | Scenarios | Questions | Size |
+| --- | ---: | ---: | ---: |
+| `gimai/RoboChrono-GIM` (this one) | 15 | 15,204 | 42.5 GB |
+| [`gimai/RoboChrono-Tianji`](https://huggingface.co/datasets/gimai/RoboChrono-Tianji) | 24 | 19,509 | 31.5 GB |
 
-## Quickstart
+Scenario count and size run in opposite directions between the two, so neither number
+predicts the other: this repository has fewer scenarios but more data. Read both columns before deciding what to fetch.
+
+## Question dimensions
+
+Every scenario carries the same seven. Six are four-way multiple choice scored by
+accuracy; `action_time` is temporal grounding scored by tIoU@0.5.
+
+| Dimension | What it asks | The model sees | Options | Metric |
+| --- | --- | --- | --- | --- |
+| `current_action` | which action is happening now | one action clip | four action descriptions | accuracy |
+| `next_action` | which action comes next | one action clip | four action descriptions | accuracy |
+| `next_action_with_goal` | which action comes next, given the task goal | one action clip | four action descriptions | accuracy |
+| `frame_match` | which still frame came from this clip | one action clip | four images | accuracy |
+| `view_match` | which wrist camera shows the moment the head camera shows | one frame | four images | accuracy |
+| `frame_order` | the chronological order of three frames | three frames | four orderings | accuracy |
+| `action_time` | when a named action occurs | the full episode | free-form interval | tIoU@0.5 |
+
+A question stores the **identifier** of the action it is about, not the sentence. The
+sentence is in `qa/subtasks.json` and the phrasing of the question in
+`qa/dimensions.json`; rendering one from the other is what turns a stored question
+into the text a model is shown.
+
+## Layout
+
+Each scenario is a self-contained directory. Nothing outside it is needed to load it.
 
-```bash
-pip install -U huggingface_hub
-hf download gimai/RoboChrono-GIM --repo-type=dataset --include "prepare.sh" --local-dir robochrono-gim
-cd robochrono-gim && bash prepare.sh --dir .
 ```
+<scenario_id>/
+├── manifest.json                 what the scenario contains, and its content hash
+├── qa/
+│   ├── current_action.json       one file per dimension, seven in all
+│   ├── next_action.json
+│   ├── next_action_with_goal.json
+│   ├── frame_match.json
+│   ├── view_match.json
+│   ├── frame_order.json
+│   ├── action_time.json
+│   ├── subtasks.json             the action descriptions the questions refer to
+│   ├── scenarios.json            the task goal and the recording metadata
+│   └── dimensions.json           the phrasing template of each dimension
+└── media/
+    ├── clips.tar                 one clip per action segment, per camera
+    ├── episodes.tar              whole episodes, per camera
+    └── frames.tar                the still frames the questions offer
+```
+
+`manifest.json` and `qa/` stay loose, so they render on the Hub and can be fetched
+without the video. Media travels as one uncompressed archive per kind — the payload is
+already H.264 and JPEG, and three archives keep each kind separately downloadable.
 
-`prepare.sh` downloads, unpacks the archives, deletes them, and checks that every
-media file the questions refer to is on disk. Then:
+## Download
+
+Everything:
 
 ```bash
-python3 robochrono.py -n 1                    # a GIM question, as a model sees it
-python3 robochrono.py --root Tianji -n 1      # the same for the Tianji half
-python3 robochrono.py --check                 # re-verify all 19,933 GIM media files
+huggingface-cli download gimai/RoboChrono-GIM --repo-type=dataset --local-dir robochrono
 ```
 
-Other subsets and partial downloads:
+One scenario:
 
 ```bash
-bash prepare.sh --dir . --subset tianji            # the Tianji half, 31.4 GB
-bash prepare.sh --dir . --subset all               # both, 74.0 GB
-bash prepare.sh --dir . --no-episodes              # 14.3 GB, covers 6 of the 7 dimensions
-bash prepare.sh --dir . --scenario cap_pen_gim     # one scenario, all dimensions
+huggingface-cli download gimai/RoboChrono-GIM --repo-type=dataset \
+    --include "bag_toy_gim/*" --local-dir robochrono
 ```
 
-## What you get
+**Questions only, no video** — a few megabytes, enough to inspect the format, count the
+questions, or check a scenario's hash:
 
-```
-manifest.json                          the GIM half: what is in it, and where it came from
-qa/
-├── scenarios.json                     each scenario's goal, camera and action-order statistics
-├── subtasks.json                      the actions, grouped by scenario
-├── dimensions.json                    how each dimension words its question
-└── <scenario>/<dimension>.json
-media/
-├── clips/<scenario>/<episode>@<camera>@<start>-<end>.mp4
-├── episodes/<scenario>/<episode>@<camera>.mp4
-└── frames/<scenario>/<episode>@<camera>@<frame>.jpg
-Tianji/                                the same four, for the non-GIM platforms
-robochrono.py                          loader; standard library only
-prepare.sh                             the command above
+```bash
+huggingface-cli download gimai/RoboChrono-GIM --repo-type=dataset \
+    --include "*/qa/*" --include "*/manifest.json" --local-dir robochrono
 ```
 
-Before `prepare.sh` runs, `media/<kind>/` holds `<scenario>.tar` instead of
-`<scenario>/`. The media is **19,933 files** in the GIM half alone; shipping them
-individually would turn every full download into an hour of round trips, so each
-scenario travels as one archive that unpacks in place — `media/clips/cap_pen_gim.tar`
-becomes `media/clips/cap_pen_gim/`, exactly the path the questions already name.
-Nothing is renamed or rewritten on the way out.
-
-| | archives | unpacked files | size |
-| --- | ---: | ---: | ---: |
-| `media/clips/` | 18 | 2,994 | 13.75 GB |
-| `media/episodes/` | 18 | 776 | 28.20 GB |
-| `media/frames/` | 15 | 16,163 | 0.57 GB |
+## Unpacking
 
-`pack_aidkit_gim` is the one scenario whose clips and episodes are split across
-four shards (`.part_a` … `.part_d`); `prepare.sh` unpacks all of them.
+The archives extract relative to their scenario directory, so run `tar` inside it:
 
-## Reading a question
+```bash
+cd robochrono/bag_toy_gim
+for t in media/*.tar; do tar xf "$t"; done
+rm media/*.tar          # optional, once extraction succeeded
+```
 
-**A stored question holds the id of the action it is about, not the sentence.**
-This is the one thing to get right. The sentence lives in `qa/subtasks.json`,
-the shape of the question in `qa/dimensions.json`, and loading a question means
-rendering one from the other:
+Or for every scenario at once:
 
-```json
-// qa/cap_pen_gim/next_action_with_goal.json
-{"id": "cap_pen_gim/file-000/s00@next_action_with_goal", "subtask": "pick_pen",
- "input": {"clip_path": "media/clips/cap_pen_gim/file-000@main@000166-000351.mp4"},
- "options": [{"id": "A", "subtask": "put_pen_in_pen_box"}, ...], "answer": "C"}
+```bash
+cd robochrono
+for d in */; do (cd "$d" && for t in media/*.tar; do tar xf "$t"; done); done
 ```
 
-`robochrono.py` does that for you, with the same code the dataset was built and
-fingerprinted with:
+The result is the layout the questions refer to:
 
-```python
-import robochrono
-qs = robochrono.load(".", scenarios=["cap_pen_gim"], dimensions=["next_action_with_goal"])
-print(qs[0]["question"], qs[0]["answer"], qs[0]["media"])
 ```
+bag_toy_gim/
+├── manifest.json
+├── qa/…
+└── media/
+    ├── clips/bag_toy_gim/<episode>@<camera>@<start>-<end>.mp4
+    ├── episodes/bag_toy_gim/<episode>@<camera>.mp4
+    └── frames/bag_toy_gim/<episode>@<camera>@<frame>.jpg
+```
+
+Media paths inside a question are relative to the scenario directory, so they resolve
+against this tree unchanged.
+## manifest.json
+
+| Field | Meaning |
+| --- | --- |
+| `schema` | version of this manifest format |
+| `scenario_id` | the directory name, and how a suite refers to the scenario |
+| `embodiment` | what performed the task; see below |
+| `hash` | SHA-256 over what the model is asked — the question items, the action wording, the goal, and the phrasing templates. Recording metadata and media bytes are excluded, so reformatting a JSON file does not move it. See *What the hash does and does not cover* below |
+| `questions` | total across the seven dimensions |
+| `dimensions` | question count per dimension; all seven keys are always present |
+| `episodes` | recordings the questions draw on |
+| `camera` | resolution, frame rate and the camera views available |
+| `counts` | episodes, annotated action segments, and distinct actions |
+| `next_action` | how predictable the action order is: transition count, the share of actions with a single observed successor, and the conditional entropy of the successor |
+| `media` | file count, total bytes, and a `path`/`bytes` entry for every media file — the inventory of the **unpacked** directory, so it matches after the archives are extracted |
+
+### What the hash does and does not cover
+
+The hash covers **the questions and their answers**. If it matches, nobody has altered
+what is asked, which options are offered, or which option is correct.
+
+It does **not** cover the media. Video and image bytes are outside it by design, so that
+reformatting a JSON file does not invalidate a scenario — but the consequence is worth
+stating plainly: **a scenario whose videos were re-encoded, truncated or replaced still
+passes the hash check, while a model watching it sees something different and scores
+differently.** The hash cannot tell you about that.
+
+What guards the media is the weak check in `manifest.json`: `media.files`,
+`media.bytes`, and a `path`/`bytes` entry per file. Preflight compares the unpacked
+directory against that inventory, so a missing or truncated file is caught. Two files of
+identical length are not distinguished — no per-file content hash is recorded.
+
+So: `--verify` passing means **the questions are unmodified and every media file is
+present at its declared length**. It does not certify that the media is bit-for-bit what
+was published. If you are reporting scores, re-download rather than repair a directory
+that failed either check.
+
+`embodiment` records what performed the task at recording time:
+
+| Value | Meaning |
+| --- | --- |
+| `gim` | the GIM platform |
+| `tianji` | the Tianji platform with a parallel gripper |
+| `tianjihand` | the Tianji platform with a dexterous hand |
+| `hand` | a human hand, recorded from a head-mounted camera |
+
+## Using it with the evaluation code
+
+The evaluation code reads a **pool directory** holding scenario directories, named by
+`--data-root`. Unpack wherever is convenient and point at the parent:
 
 ```
-The overall task is capping a pen and putting it into its box. Based on the
-current visual state, what should happen next?
-Options:
-A. Put the pen in the pen box.
-B. Put the cap on the pen.
-C. Pick the cap.
-D. Put the cap in the pen box.
-
-C {'clip': '/abs/path/media/clips/cap_pen_gim/file-000@main@000166-000351.mp4'}
+pool/
+├── <scenario_id>/{manifest.json, qa/, media/}
+└── <scenario_id>/…
 ```
 
-An action is described in exactly one place, so rewording it changes every
-question that uses it and cannot leave some behind. Reimplementing the renderer
-risks scoring a model on a different question than the one this dataset claims to
-ask, which is why the loader ships with the data.
-
-**Options are text for four dimensions and images for two.** `current_action`,
-`next_action`, `next_action_with_goal` and `frame_order` already have their
-options written into `question`; do not append them again. `frame_match` and
-`view_match` have image options, which `question` does not mention because there
-is nothing to write — attach them as images, in stored order. The loader marks
-which is which in `option_kind`, and puts the image paths in `media["options"]`.
-`action_time` has no options at all; its answer is a time range.
-
-## Scenarios (GIM)
-
-| scenario | goal | episodes | questions | from |
-| --- | --- | ---: | ---: | --- |
-| `bag_toy_gim` | puting a toy into a deliver bag | 41 | 697 | v22 |
-| `box_shoes_gim` | putting the shoe into the box | 49 | 833 | v22 |
-| `brew_teabag_gim` | brewing a pot of tea with a tea bag | 44 | 924 | v23 |
-| `cap_pen_gim` | capping a pen and putting it into its box | 60 | 1200 | vqa_2 |
-| `make_tea_gim` | brewing tea in a kettle with a tea bag | 52 | 1092 | v22 |
-| `pack_aidkit_gim` | packing a first aid kit | 50 | 1050 | vqa_2 |
-| `pack_airpods_gim` | putting the earphones into their case | 18 | 378 | v23 |
-| `pack_gift_gim` | putting a toy car into a gift box | 50 | 1050 | v22 |
-| `slip_tshirt_gim` | slipping a T-shirt over a board | 48 | 960 | v23 |
-| `sort_cubes_gim` | putting the cubes into boxes of the same color | 59 | 1239 | v23 |
-| `stack_cubes_gim` | stacking cubes | 50 | 1050 | vqa_2 |
-| `tidy_stationery_gim` | capping a pen and putting it into its box | 108 | 1836 | v23 |
-| `wash_dishes_gim` | cleaning the bowl and plates | 49 | 1029 | v23 |
-| `wipe_plate_gim` | wiping the plates | 50 | 1050 | v23 |
-| `zip_pouch_gim` | zipping a pouch and putting it away | 48 | 816 | v23 |
-
-The Tianji half's scenarios are listed in `Tianji/README.md`.
-
-## Dimensions (GIM)
-
-| dimension | questions |
-| --- | ---: |
-| `current_action` | 2328 |
-| `next_action` | 2082 |
-| `next_action_with_goal` | 2082 |
-| `frame_match` | 2328 |
-| `view_match` | 2328 |
-| `frame_order` | 1728 |
-| `action_time` | 2328 |
-
-Only `action_time` reads `media/episodes/`, which is 28 GB of the 43 GB.
-
-## Provenance
-
-Assembled from `GIM-RoboLab/robochrono`, which publishes RoboChrono as several
-separate builds. Each scenario is taken **whole** from one build — no scenario
-mixes episodes across builds:
-
-- `vqa_2` — RoboChrono 2.0, fingerprint `64fbe7657d0d`
-- `v22` — RoboChrono 2.2, fingerprint `6e046cffefee`
-- `v23` — RoboChrono 2.3, fingerprint `b8e4bb924b91`
-
-Three GIM scenarios existed in more than one build. Each resolves to the newer one:
-
-| scenario | kept | dropped | why |
-| --- | --- | --- | --- |
-| `pack_gift_gim` | v22, 50 episodes | vqa_2, 25 episodes | v22 is a full regeneration after supplementary data |
-| `wipe_plate_gim` | v23, 50 episodes | vqa_2, 50 episodes | same episode count, newer pipeline |
-| `slip_tshirt_gim` | v23, 48 episodes | vqa_2, 49 episodes | one episode fewer, kept so every v23 scenario comes from one pipeline version |
-
-The builds word their questions identically (`qa/dimensions.json` is semantically
-equal across all of them), which is what makes merging their questions under one
-fingerprint meaningful.
-
-`fingerprint` follows the same rule the source manifests use — a hash of the
-questions **as they are asked**, not as they are stored. It is therefore not
-comparable to any source manifest's value, because no source build covers this
-set of scenarios.
-
-The upstream repository has one further directory, `vqa/`, which is not
-represented here: it is the v1 vendor build, its questions use a different schema
-entirely, and all six of its families are superseded by the builds above.
+Preflight recomputes each scenario's hash from its `qa/` and compares it with
+`manifest.json`, and checks that every media path a question refers to is present. A
+scenario that fails either check is refused rather than scored, so an incomplete
+download cannot quietly become a lower score.
+
+Both repositories unpack into the same shape, so a pool may hold scenarios from either
+or from both.
+
+## Scenarios
+
+| Scenario | Embodiment | Episodes | Questions | Size | Task |
+| --- | --- | ---: | ---: | ---: | --- |
+| `bag_toy_gim` | `gim` | 41 | 697 | 1.16 | puting a toy into a deliver bag |
+| `box_shoes_gim` | `gim` | 49 | 833 | 1.04 | putting the shoe into the box |
+| `brew_teabag_gim` | `gim` | 44 | 924 | 3.78 | brewing a pot of tea with a tea bag |
+| `cap_pen_gim` | `gim` | 60 | 1,200 | 2.51 | capping a pen and putting it into its box |
+| `make_tea_gim` | `gim` | 52 | 1,092 | 4.07 | brewing tea in a kettle with a tea bag |
+| `pack_aidkit_gim` | `gim` | 50 | 1,050 | 14.16 | packing a first aid kit |
+| `pack_airpods_gim` | `gim` | 18 | 378 | 0.80 | putting the earphones into their case |
+| `pack_gift_gim` | `gim` | 50 | 1,050 | 0.95 | putting a toy car into a gift box |
+| `slip_tshirt_gim` | `gim` | 48 | 960 | 1.80 | slipping a T-shirt over a board |
+| `sort_cubes_gim` | `gim` | 59 | 1,239 | 1.13 | putting the cubes into boxes of the same color |
+| `stack_cubes_gim` | `gim` | 50 | 1,050 | 2.41 | stacking cubes |
+| `tidy_stationery_gim` | `gim` | 108 | 1,836 | 1.92 | capping a pen and putting it into its box |
+| `wash_dishes_gim` | `gim` | 49 | 1,029 | 3.17 | cleaning the bowl and plates |
+| `wipe_plate_gim` | `gim` | 50 | 1,050 | 2.34 | wiping the plates |
+| `zip_pouch_gim` | `gim` | 48 | 816 | 1.29 | zipping a pouch and putting it away |
+## License
+
+CC-BY-4.0.
+
+## Citation
+
+A paper describing this benchmark is in preparation.