Embed synchronized perception states in benchmark rows

README.md

@@ -44,6 +44,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
 
@@ -62,6 +63,12 @@ Each row contains one video episode, a high-level task instruction, and gold sub
 | `instruction` | string | High-level task instruction for the episode. |
 | `segments` | list | Gold `{start_sec, end_sec, subtask}` annotations. |
 | `metadata` | string | JSON metadata with source-specific fields. |
+| `perception_state` | struct or null | Synchronized, named robot-state channels for DROID/Galaxea; null for HomER. |
+
+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. HomER has no robot telemetry, so its rows
+contain `null` rather than synthetic zeros.
 
 ## Quick Start
 
@@ -73,6 +80,7 @@ example = dataset[0]
 
 print(example["instruction"])
 print(example["segments"])
+print(example["perception_state"])
 ```
 
 To use the parquet directly:
@@ -83,6 +91,25 @@ 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 enriched table from the original
+annotations Parquet:
+
+```bash
+python scripts/embed_perception_states.py \
+  data/annotations.original.parquet \
+  data/annotations.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 enriched Parquet. Hugging Face
+caches all state sources; pass `--cache-dir` to use a shared cache. The DROID
+state data comes from one roughly 241 MB upstream tar archive. The embedded
+state payload adds roughly 1.5 MB before Parquet-level recompression.
+
 ## 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.

data/annotations.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3b4320b76c1b1fb6150bf2d192343dc62eed39db54a89584b7c6f31f511e73d4
-size 1398832242
+oid sha256:24c6c23447753385b9cea0d17f17d7a8aa74131d800d9bc9ab74d7669d7404ab
+size 1401440590

data/annotations.parquet.provenance.json

@@ -0,0 +1,38 @@
+{
+  "schema_version": 1,
+  "artifact": "annotations.parquet",
+  "input_sha256": "3b4320b76c1b1fb6150bf2d192343dc62eed39db54a89584b7c6f31f511e73d4",
+  "output_sha256": "24c6c23447753385b9cea0d17f17d7a8aa74131d800d9bc9ab74d7669d7404ab",
+  "source_lock": "perception_sources.lock.json",
+  "source_lock_sha256": "0a7da2033dc2007207c9dc77e5e36172ec01fe2ed2a286501b48e169ce6dce8b",
+  "rows": 100,
+  "robot_state_rows": 75,
+  "video_only_rows": 25,
+  "video_only_ids": [
+    "homer_1",
+    "homer_2",
+    "homer_3",
+    "homer_4",
+    "homer_5",
+    "homer_7",
+    "homer_9",
+    "homer_10",
+    "homer_11",
+    "homer_12",
+    "homer_15",
+    "homer_29",
+    "homer_33",
+    "homer_37",
+    "homer_38",
+    "homer_39",
+    "homer_40",
+    "homer_41",
+    "homer_48",
+    "homer_50",
+    "homer_52",
+    "homer_53",
+    "homer_56",
+    "homer_59",
+    "homer_60"
+  ]
+}

scripts/embed_perception_states.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from perception_states import (
+    LOCK_PATH,
+    _load_episode,
+    discover_robot_episodes,
+    load_source_lock,
+    normalize_episode,
+)
+
+
+def state_type() -> pa.DataType:
+    return pa.struct(
+        [
+            ("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 collect_states(lock_path: Path, cache_dir: Path | None) -> dict[str, dict[str, Any]]:
+    lock = load_source_lock(lock_path)
+    states: dict[str, dict[str, Any]] = {}
+    for episode in discover_robot_episodes(lock, cache_dir):
+        table, feature_info = _load_episode(episode, cache_dir)
+        row = normalize_episode(table, episode, feature_info)
+        bench_id = row.pop("bench_id")
+        states[bench_id] = row
+    return states
+
+
+def embed_perception_states(
+    input_path: Path,
+    output_path: Path,
+    *,
+    lock_path: Path = LOCK_PATH,
+    cache_dir: Path | None = None,
+) -> dict[str, Any]:
+    if input_path.resolve() == output_path.resolve():
+        raise ValueError("Input and output paths must differ")
+
+    states = collect_states(lock_path, cache_dir)
+    source = pq.ParquetFile(input_path)
+    if "perception_state" in source.schema_arrow.names:
+        raise ValueError("Input already contains perception_state")
+    if source.metadata.num_rows != 100:
+        raise ValueError(f"Expected 100 benchmark rows, found {source.metadata.num_rows}")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_schema = source.schema_arrow.append(pa.field("perception_state", state_type()))
+    matched: set[str] = set()
+    video_only: list[str] = []
+    with pq.ParquetWriter(output_path, output_schema, compression="zstd") as writer:
+        for batch in source.iter_batches(batch_size=1):
+            table = pa.Table.from_batches([batch])
+            bench_id = str(table["id"][0].as_py())
+            state = states.get(bench_id)
+            if state is None:
+                video_only.append(bench_id)
+            else:
+                matched.add(bench_id)
+            enriched = table.append_column(
+                "perception_state", pa.array([state], type=state_type())
+            )
+            writer.write_table(enriched, row_group_size=1)
+
+    missing = set(states) - matched
+    if missing:
+        output_path.unlink(missing_ok=True)
+        raise ValueError(f"State IDs absent from benchmark: {sorted(missing)}")
+    if len(matched) != 75 or len(video_only) != 25:
+        output_path.unlink(missing_ok=True)
+        raise ValueError(
+            f"Expected 75 state rows and 25 video-only rows, got {len(matched)} and {len(video_only)}"
+        )
+
+    provenance = {
+        "schema_version": 1,
+        "artifact": output_path.name,
+        "input_sha256": _sha256(input_path),
+        "output_sha256": _sha256(output_path),
+        "source_lock": lock_path.name,
+        "source_lock_sha256": _sha256(lock_path),
+        "rows": source.metadata.num_rows,
+        "robot_state_rows": len(matched),
+        "video_only_rows": len(video_only),
+        "video_only_ids": video_only,
+    }
+    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 _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Embed pinned robot proprioception into existing WGO-Bench rows."
+    )
+    parser.add_argument("input", type=Path)
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--lock", type=Path, default=LOCK_PATH)
+    parser.add_argument("--cache-dir", type=Path)
+    args = parser.parse_args()
+    result = embed_perception_states(
+        args.input,
+        args.output,
+        lock_path=args.lock,
+        cache_dir=args.cache_dir,
+    )
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

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()