gimai/RoboChrono-GIM

RoboChrono — GIM

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.

This repository holds 15 scenarios · 776 episodes · 15,204 questions · 42.5 GB. Every scenario here is gim.

The complete benchmark

RoboChrono is published as two dataset repositories. Together they hold 39 scenarios and 34,713 questions.

Repository	Scenarios	Questions	Size
gimai/RoboChrono-GIM (this one)	15	15,204	42.5 GB
gimai/RoboChrono-Tianji	24	19,509	31.5 GB

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.

<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.

Download

The supported way is the downloader in the evaluation repository. It works out which of the two repositories holds each scenario, unpacks the archives into the layout the questions reference, and ends with the same sweep robochrono validate-data runs, so "it downloaded" and "it is usable" never get confused. Both repositories are public; no account or token is needed.

git clone https://github.com/mfan-res/ROBOCHRONO
cd ROBOCHRONO
python3 tools/download_data.py --all                      # all 39 scenarios, ~74 GB
python3 tools/download_data.py bag_toy_gim
python3 tools/download_data.py --all --qa-only            # questions only, ~50 MB
python3 tools/download_data.py bag_toy_gim --media-types clips,frames

An interrupted download resumes: rerun the same command.

Fetching it by hand

The repository is an ordinary Hugging Face dataset, so the CLI works too — at the cost of unpacking and validating yourself. Everything:

huggingface-cli download gimai/RoboChrono-GIM --repo-type=dataset --local-dir robochrono

One scenario:

huggingface-cli download gimai/RoboChrono-GIM --repo-type=dataset \
    --include "bag_toy_gim/*" --local-dir robochrono

Questions only, no video — a few megabytes, enough to inspect the format, count the questions, or check a scenario's hash:

huggingface-cli download gimai/RoboChrono-GIM --repo-type=dataset \
    --include "*/qa/*" --include "*/manifest.json" --local-dir robochrono

Unpacking

The archives extract relative to their scenario directory, so run tar inside it:

cd robochrono/bag_toy_gim
for t in media/*.tar; do tar xf "$t"; done
rm media/*.tar          # optional, once extraction succeeded

Or for every scenario at once:

cd robochrono
for d in */; do (cd "$d" && for t in media/*.tar; do tar xf "$t"; done); done

The result is the layout the questions refer to:

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 is at github.com/mfan-res/ROBOCHRONO, which also specifies this format in full in docs/DATA_FORMAT.md. Every command there reads a pool directory holding scenario directories, named by --data-root (default scenarios/). Unpack wherever is convenient and point at the parent:

pool/
├── <scenario_id>/{manifest.json, qa/, media/}
└── <scenario_id>/…

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.