Add synchronized robot perception states

Adds a separate `robot_states` configuration for the 50 RoboInter/DROID and 25 RoboCOIN/Galaxea benchmark episodes.

The sidecar preserves named source-native joint, EEF, and gripper channels; pins all upstream revisions; includes SHA-256 provenance and a reproducible builder; and intentionally leaves HomER video-only.

Validation: 75/75 state IDs match the default benchmark, 30,494 synchronized frames pass frame-count/channel-length checks, and the compressed sidecar is 1.5 MB.

README.md

@@ -23,6 +23,10 @@ configs:
   data_files:
   - split: train
     path: data/annotations.parquet
+- config_name: robot_states
+  data_files:
+  - split: train
+    path: robot_states/perception_states.parquet
 ---
 
 # WGO-Bench: What's Going On Benchmark
@@ -44,6 +48,7 @@ Each row contains one video episode, a high-level task instruction, and gold sub
 | Source families | 3 |
 | Format | Parquet |
 | Video storage | MP4 bytes embedded in each row |
+| Robot-state coverage | 75 robotic episodes; HomER is video-only |
 
 ## Sources
 
@@ -55,6 +60,8 @@ Each row contains one video episode, a high-level task instruction, and gold sub
 
 ## Schema
 
+### `default`
+
 | Column | Type | Description |
 | --- | --- | --- |
 | `id` | string | Stable episode identifier. |
@@ -63,6 +70,30 @@ Each row contains one video episode, a high-level task instruction, and gold sub
 | `segments` | list | Gold `{start_sec, end_sec, subtask}` annotations. |
 | `metadata` | string | JSON metadata with source-specific fields. |
 
+### `robot_states`
+
+The optional `robot_states` configuration contains synchronized proprioception
+for the 50 RoboInter/DROID and 25 RoboCOIN/Galaxea episodes. HomER has no robot
+telemetry and is intentionally absent rather than filled with synthetic zeros.
+
+| Column | Type | Description |
+| --- | --- | --- |
+| `bench_id` | string | Stable episode identifier matching `id` in `default`. |
+| `robot_family` | string | `droid` or `galaxea`. |
+| `source_dataset` | string | Official upstream dataset repository. |
+| `source_revision` | string | Immutable upstream Git revision. |
+| `source_episode_index` | integer | Episode index in the upstream dataset. |
+| `fps` | float | State sampling rate. |
+| `num_frames` | integer | Number of synchronized state/video frames. |
+| `frame_index` | list | Ordered frame indices. |
+| `timestamp_sec` | list | Ordered timestamps in seconds. |
+| `primary_channel` | string | Main source-native proprioception column. |
+| `channels` | list | Named state channels with semantic value names and per-frame values. |
+
+DROID retains EEF position, rotation, and gripper state. Galaxea retains
+bilateral arm joints and grippers plus its available EEF- and gripper-derived
+channels. Actions are not included.
+
 ## Quick Start
 
 ```python
@@ -75,6 +106,22 @@ print(example["instruction"])
 print(example["segments"])
 ```
 
+Load robot states separately and join them on `id == bench_id`:
+
+```python
+from datasets import load_dataset
+
+episodes = load_dataset("macrodata/WGO-Bench", "default", split="train")
+robot_states = load_dataset("macrodata/WGO-Bench", "robot_states", split="train")
+
+state_by_id = {row["bench_id"]: row for row in robot_states}
+episode = next(row for row in episodes if row["id"] in state_by_id)
+state = state_by_id[episode["id"]]
+
+print(state["primary_channel"])
+print(state["channels"][0]["value_names"])
+```
+
 To use the parquet directly:
 
 ```python
@@ -83,6 +130,23 @@ import pandas as pd
 df = pd.read_parquet("hf://datasets/macrodata/WGO-Bench/data/annotations.parquet")
 ```
 
+## Rebuilding Robot States
+
+`scripts/perception_sources.lock.json` pins both annotation maps and all 26
+upstream robot-dataset revisions. Rebuild the sidecar without downloading the
+embedded benchmark videos:
+
+```bash
+python scripts/perception_states.py robot_states/perception_states.parquet
+```
+
+Requirements are Python 3.11+, `huggingface_hub`, and `pyarrow`. The exporter
+validates episode coverage, frame counts, channel widths, and timestamp order,
+then writes a SHA-256 provenance file next to the Parquet. Hugging Face caches
+all source files; pass `--cache-dir` to use a shared cache. The DROID state data
+comes from one roughly 241 MB upstream tar archive, while the generated
+Zstandard-compressed sidecar is roughly 1.5 MB.
+
 ## Annotation Policy
 
 Segments are intended to describe completed manipulation events, not every small pose adjustment. A new segment should generally correspond to a visible state change such as picking up, placing, opening, closing, moving, pouring, wiping, cutting, or transferring an object.

robot_states/perception_states.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:979135afc50e826fef887e7ed4c30ed15bbc08e6ae17ebbb18fa8b48032d933e
+size 1609505

robot_states/perception_states.parquet.provenance.json

@@ -0,0 +1,86 @@
+{
+  "schema_version": 1,
+  "artifact": "perception_states.parquet",
+  "sha256": "979135afc50e826fef887e7ed4c30ed15bbc08e6ae17ebbb18fa8b48032d933e",
+  "episodes": 75,
+  "bench_ids": [
+    "galaxea_002",
+    "galaxea_007",
+    "galaxea_009",
+    "galaxea_011",
+    "galaxea_013",
+    "galaxea_028",
+    "galaxea_033",
+    "galaxea_037",
+    "galaxea_039",
+    "galaxea_041",
+    "galaxea_043",
+    "galaxea_045",
+    "galaxea_047",
+    "galaxea_049",
+    "galaxea_050",
+    "galaxea_052",
+    "galaxea_058",
+    "galaxea_060",
+    "galaxea_062",
+    "galaxea_065",
+    "galaxea_067",
+    "galaxea_069",
+    "galaxea_071",
+    "galaxea_073",
+    "galaxea_075",
+    "robointer_droid_000001",
+    "robointer_droid_000002",
+    "robointer_droid_000003",
+    "robointer_droid_000004",
+    "robointer_droid_000005",
+    "robointer_droid_000006",
+    "robointer_droid_000007",
+    "robointer_droid_000008",
+    "robointer_droid_000009",
+    "robointer_droid_000010",
+    "robointer_droid_000011",
+    "robointer_droid_000012",
+    "robointer_droid_000013",
+    "robointer_droid_000014",
+    "robointer_droid_000015",
+    "robointer_droid_000016",
+    "robointer_droid_000017",
+    "robointer_droid_000019",
+    "robointer_droid_000021",
+    "robointer_droid_000022",
+    "robointer_droid_000023",
+    "robointer_droid_000024",
+    "robointer_droid_000025",
+    "robointer_droid_000027",
+    "robointer_droid_000028",
+    "robointer_droid_000029",
+    "robointer_droid_000030",
+    "robointer_droid_000032",
+    "robointer_droid_000033",
+    "robointer_droid_000034",
+    "robointer_droid_000035",
+    "robointer_droid_000036",
+    "robointer_droid_000037",
+    "robointer_droid_000038",
+    "robointer_droid_000039",
+    "robointer_droid_000042",
+    "robointer_droid_000043",
+    "robointer_droid_000044",
+    "robointer_droid_000045",
+    "robointer_droid_000046",
+    "robointer_droid_000047",
+    "robointer_droid_000050",
+    "robointer_droid_000055",
+    "robointer_droid_000056",
+    "robointer_droid_000057",
+    "robointer_droid_000058",
+    "robointer_droid_000059",
+    "robointer_droid_000060",
+    "robointer_droid_000061",
+    "robointer_droid_000062"
+  ],
+  "source_lock": "perception_sources.lock.json",
+  "source_lock_sha256": "0a7da2033dc2007207c9dc77e5e36172ec01fe2ed2a286501b48e169ce6dce8b",
+  "video_only_episodes": 25
+}

scripts/perception_sources.lock.json

@@ -0,0 +1,49 @@
+{
+  "schema_version": 1,
+  "coverage": {
+    "benchmark_episodes": 100,
+    "robot_episodes": 75,
+    "video_only_episodes": 25,
+    "video_only_subset": "HomER"
+  },
+  "annotation_sources": {
+    "droid": {
+      "repo_id": "macrodata/robointer-droid-50-subtask-annotations",
+      "revision": "39342b5e3a7603748d97fbfe25aa0e54e6b45326",
+      "parquet_path": "data/annotations.parquet"
+    },
+    "galaxea": {
+      "repo_id": "macrodata/robocoin-galaxea-head-25-subtask-annotations",
+      "revision": "e974f9bd6c6cb46289fd54586c10385f43f0ec6e",
+      "parquet_path": "data/annotations.parquet"
+    }
+  },
+  "upstream_revisions": {
+    "InternRobotics/RoboInter-Data": "0208b79c34eca4d214cdb5d07f5ae0f7cc634340",
+    "RoboCOIN/Galaxea_R1_Lite_change_baai_into_brain": "98393798142b2b99a386d9bbc8ca9a6a8cdd5d5c",
+    "RoboCOIN/Galaxea_R1_Lite_classify_object_four": "1b8fbd8d24b9ca70476b2945e8bd61b8a3ab2ad2",
+    "RoboCOIN/Galaxea_R1_Lite_classify_object_green_tablecloth": "e99edefc3df9f0864d1cadc81af60e916b8dcf74",
+    "RoboCOIN/Galaxea_R1_Lite_classify_object_six": "ffcb9eba5977763d6bc0ddfca6f99e4213d42ad4",
+    "RoboCOIN/Galaxea_R1_Lite_classify_object_three": "cd40bb70b6d943c644f643fbe9fabefedee24e69",
+    "RoboCOIN/Galaxea_R1_Lite_mix_color_small_test_tube": "03649ca80d0349b7369f0ed2b3c225eb3959d35d",
+    "RoboCOIN/Galaxea_R1_Lite_mix_red_blue_left_large_test_tube": "6257a59fc9b74059295460f8c00cba3d21bcfe74",
+    "RoboCOIN/Galaxea_R1_Lite_mix_red_yellow_large_test_tube": "a7eae049447f13ecf936305460feabb120b033bb",
+    "RoboCOIN/Galaxea_R1_Lite_mix_red_yellow_left_large_test_tube": "f32383071e90569802df0ac52de690d4908c4e64",
+    "RoboCOIN/Galaxea_R1_Lite_mix_red_yellow_right": "696a2d3a867ccc3a7cef7eb0d12924b8737ee297",
+    "RoboCOIN/Galaxea_R1_Lite_move_mouse": "cc841d0478cb2b95ea41396b93b17310f74d341c",
+    "RoboCOIN/Galaxea_R1_Lite_pour_liquid_mrable_bar_counter": "879dcddeccf12315577791bfff24f585eb2efdda",
+    "RoboCOIN/Galaxea_R1_Lite_pour_powder_marble_bar_counter": "e76ae5ae555f30b2cf79e4fec049c1101ec81c14",
+    "RoboCOIN/Galaxea_R1_Lite_pour_solid": "5e856053cd65e3c383cbb3c96a4ace230399073b",
+    "RoboCOIN/Galaxea_R1_Lite_pour_solid_marble_bar_counter": "28958bd97ad782a850d3282b3a7535ce9809fbed",
+    "RoboCOIN/Galaxea_R1_Lite_pour_water_black_tablecloth": "e67c5774c4b961393ade0769ec8072e7cab76f8d",
+    "RoboCOIN/Galaxea_R1_Lite_storage_object_brown_bowl": "d518e4efd84024e20a8108ec40ab668c47e6b277",
+    "RoboCOIN/Galaxea_R1_Lite_storage_object_brown_plate": "4acca05909f7d52845c0569bf699b77de30b820a",
+    "RoboCOIN/Galaxea_R1_Lite_storage_object_dish": "39525f063a9b1b158f8b7152be76b3d6cad1935d",
+    "RoboCOIN/Galaxea_R1_Lite_storage_object_gray_plate": "88bd99242337b756f1ebb9ccb4d363731abf8576",
+    "RoboCOIN/Galaxea_R1_Lite_storage_object_pink_bowl": "eaad5ed3a6087907d2d64495b437ff7911314b51",
+    "RoboCOIN/Galaxea_R1_Lite_storage_object_white_box": "817a191f19f6c9bdc64f620869d10b7343f240d0",
+    "RoboCOIN/Galaxea_R1_Lite_storage_object_yellow_basket": "d12c143bf81dd56a535ef5e2483c50712463cae5",
+    "RoboCOIN/Galaxea_R1_Lite_toggle_drawer_red": "bd2fb11362203299f0b95aa07e33975e3141cd04",
+    "RoboCOIN/Galaxea_R1_Lite_toggle_drawer_yellow": "1676795e4c0bb4ce786243a6711a1b3dc4f7346f"
+  }
+}

scripts/perception_states.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import tarfile
+from pathlib import Path
+from typing import Any, Iterable
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+from huggingface_hub import hf_hub_download
+
+
+LOCK_PATH = Path(__file__).with_name("perception_sources.lock.json")
+PRIMARY_STATE_COLUMNS = ("observation.state", "state")
+
+
+def load_source_lock(path: Path = LOCK_PATH) -> dict[str, Any]:
+    lock = json.loads(path.read_text(encoding="utf-8"))
+    if lock.get("schema_version") != 1:
+        raise ValueError(f"Unsupported perception-source lock schema: {lock.get('schema_version')!r}")
+    return lock
+
+
+def discover_robot_episodes(lock: dict[str, Any], cache_dir: Path | None = None) -> list[dict[str, Any]]:
+    episodes: list[dict[str, Any]] = []
+    for source_name, source in lock["annotation_sources"].items():
+        parquet_path = _download(
+            source["repo_id"], source["revision"], source["parquet_path"], cache_dir
+        )
+        for row in pq.read_table(parquet_path).to_pylist():
+            if source_name == "droid":
+                repo_id = row["source_dataset"]
+                episode_index = int(row["episode_index"])
+                episodes.append(
+                    {
+                        "bench_id": row["bench_id"],
+                        "robot_family": "droid",
+                        "repo_id": repo_id,
+                        "revision": lock["upstream_revisions"][repo_id],
+                        "episode_index": episode_index,
+                        "fps": float(row["fps"]),
+                        "expected_num_frames": int(row["num_frames"]),
+                        "source_subset": row["source_subset"],
+                        "data_path": f"{row['source_subset']}/data/chunk-000.tar",
+                        "tar_member": f"chunk-000/episode_{episode_index:06d}.parquet",
+                        "info_path": f"{row['source_subset']}/meta/info.json",
+                    }
+                )
+            elif source_name == "galaxea":
+                repo_id = row["source_dataset"]
+                episode_index = int(row["source_episode_index"])
+                episodes.append(
+                    {
+                        "bench_id": row["bench_id"],
+                        "robot_family": "galaxea",
+                        "repo_id": repo_id,
+                        "revision": lock["upstream_revisions"][repo_id],
+                        "episode_index": episode_index,
+                        "fps": float(row["fps"]),
+                        "expected_num_frames": int(row["num_frames"]),
+                        "data_path": f"data/chunk-000/episode_{episode_index:06d}.parquet",
+                        "info_path": "meta/info.json",
+                    }
+                )
+            else:
+                raise ValueError(f"Unknown annotation source {source_name!r}")
+
+    episodes.sort(key=lambda item: item["bench_id"])
+    bench_ids = [item["bench_id"] for item in episodes]
+    if len(bench_ids) != len(set(bench_ids)):
+        raise ValueError("Duplicate bench_id in robotic source mappings")
+    expected = int(lock["coverage"]["robot_episodes"])
+    if len(episodes) != expected:
+        raise ValueError(f"Expected {expected} robotic episodes, found {len(episodes)}")
+    return episodes
+
+
+def normalize_episode(
+    table: pa.Table,
+    episode: dict[str, Any],
+    feature_info: dict[str, Any],
+) -> dict[str, Any]:
+    columns = set(table.column_names)
+    primary = next((name for name in PRIMARY_STATE_COLUMNS if name in columns), None)
+    if primary is None:
+        raise ValueError(f"{episode['bench_id']} has no supported proprioception column")
+    if "frame_index" not in columns or "timestamp" not in columns:
+        raise ValueError(f"{episode['bench_id']} is missing frame_index or timestamp")
+
+    frame_index = [int(_scalar(value)) for value in table["frame_index"].to_pylist()]
+    timestamps = [float(_scalar(value)) for value in table["timestamp"].to_pylist()]
+    if frame_index != sorted(frame_index) or timestamps != sorted(timestamps):
+        raise ValueError(f"{episode['bench_id']} state rows are not ordered")
+    if len(frame_index) != episode["expected_num_frames"]:
+        raise ValueError(
+            f"{episode['bench_id']} expected {episode['expected_num_frames']} frames, "
+            f"found {len(frame_index)} state rows"
+        )
+
+    channel_names = [primary]
+    channel_names.extend(
+        sorted(name for name in columns if name.endswith("_state") and name != primary)
+    )
+    channels = []
+    for name in channel_names:
+        values = [_vector(value) for value in table[name].to_pylist()]
+        names = list((feature_info.get(name) or {}).get("names") or [])
+        width = len(values[0]) if values else 0
+        if any(len(value) != width for value in values):
+            raise ValueError(f"{episode['bench_id']} channel {name!r} changes width")
+        if names and len(names) != width:
+            raise ValueError(f"{episode['bench_id']} channel {name!r} names do not match width")
+        if not names:
+            names = [f"value_{index}" for index in range(width)]
+        channels.append({"name": name, "value_names": names, "values": values})
+
+    return {
+        "bench_id": episode["bench_id"],
+        "robot_family": episode["robot_family"],
+        "source_dataset": episode["repo_id"],
+        "source_revision": episode["revision"],
+        "source_episode_index": episode["episode_index"],
+        "fps": episode["fps"],
+        "num_frames": len(frame_index),
+        "frame_index": frame_index,
+        "timestamp_sec": timestamps,
+        "primary_channel": primary,
+        "channels": channels,
+    }
+
+
+def export_perception_states(
+    output_path: Path,
+    *,
+    lock_path: Path = LOCK_PATH,
+    cache_dir: Path | None = None,
+    bench_ids: Iterable[str] | None = None,
+) -> dict[str, Any]:
+    lock = load_source_lock(lock_path)
+    episodes = discover_robot_episodes(lock, cache_dir)
+    selected = set(bench_ids or [])
+    if selected:
+        known = {episode["bench_id"] for episode in episodes}
+        unknown = selected - known
+        if unknown:
+            raise ValueError(f"Unknown robotic bench IDs: {sorted(unknown)}")
+        episodes = [episode for episode in episodes if episode["bench_id"] in selected]
+
+    rows = []
+    for episode in episodes:
+        table, feature_info = _load_episode(episode, cache_dir)
+        rows.append(normalize_episode(table, episode, feature_info))
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.Table.from_pylist(rows, schema=perception_schema())
+    pq.write_table(table, output_path, compression="zstd")
+    digest = hashlib.sha256(output_path.read_bytes()).hexdigest()
+    provenance = {
+        "schema_version": 1,
+        "artifact": output_path.name,
+        "sha256": digest,
+        "episodes": len(rows),
+        "bench_ids": [row["bench_id"] for row in rows],
+        "source_lock": lock_path.name,
+        "source_lock_sha256": hashlib.sha256(lock_path.read_bytes()).hexdigest(),
+        "video_only_episodes": lock["coverage"]["video_only_episodes"],
+    }
+    provenance_path = output_path.with_suffix(output_path.suffix + ".provenance.json")
+    provenance_path.write_text(json.dumps(provenance, indent=2) + "\n", encoding="utf-8")
+    return provenance
+
+
+def perception_schema() -> pa.Schema:
+    return pa.schema(
+        [
+            ("bench_id", pa.string()),
+            ("robot_family", pa.string()),
+            ("source_dataset", pa.string()),
+            ("source_revision", pa.string()),
+            ("source_episode_index", pa.int64()),
+            ("fps", pa.float64()),
+            ("num_frames", pa.int64()),
+            ("frame_index", pa.list_(pa.int64())),
+            ("timestamp_sec", pa.list_(pa.float64())),
+            ("primary_channel", pa.string()),
+            (
+                "channels",
+                pa.list_(
+                    pa.struct(
+                        [
+                            ("name", pa.string()),
+                            ("value_names", pa.list_(pa.string())),
+                            ("values", pa.list_(pa.list_(pa.float64()))),
+                        ]
+                    )
+                ),
+            ),
+        ]
+    )
+
+
+def _load_episode(episode: dict[str, Any], cache_dir: Path | None) -> tuple[pa.Table, dict[str, Any]]:
+    info_path = _download(
+        episode["repo_id"], episode["revision"], episode["info_path"], cache_dir
+    )
+    feature_info = json.loads(info_path.read_text(encoding="utf-8")).get("features", {})
+    data_path = _download(
+        episode["repo_id"], episode["revision"], episode["data_path"], cache_dir
+    )
+    if episode.get("tar_member"):
+        with tarfile.open(data_path) as archive:
+            member = archive.extractfile(episode["tar_member"])
+            if member is None:
+                raise FileNotFoundError(episode["tar_member"])
+            table = pq.read_table(io.BytesIO(member.read()))
+    else:
+        table = pq.read_table(data_path)
+    return table, feature_info
+
+
+def _download(repo_id: str, revision: str, filename: str, cache_dir: Path | None) -> Path:
+    return Path(
+        hf_hub_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            revision=revision,
+            filename=filename,
+            cache_dir=str(cache_dir) if cache_dir else None,
+        )
+    )
+
+
+def _scalar(value: Any) -> Any:
+    if isinstance(value, (list, tuple)):
+        if len(value) != 1:
+            raise ValueError(f"Expected a scalar or one-element sequence, got {value!r}")
+        return value[0]
+    return value
+
+
+def _vector(value: Any) -> list[float]:
+    if value is None:
+        return []
+    if not isinstance(value, (list, tuple)):
+        value = [value]
+    return [float(item) for item in value]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Export pinned proprioception sidecars for WGO-Bench robotic episodes."
+    )
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--lock", type=Path, default=LOCK_PATH)
+    parser.add_argument("--cache-dir", type=Path)
+    parser.add_argument("--bench-id", action="append", default=[])
+    args = parser.parse_args()
+    result = export_perception_states(
+        args.output,
+        lock_path=args.lock,
+        cache_dir=args.cache_dir,
+        bench_ids=args.bench_id,
+    )
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()