Upload convert_synced_h5_to_lerobot.py

convert_synced_h5_to_lerobot.py

@@ -0,0 +1,334 @@
+"""Convert one or more synced HDF5 files (output of sync_image_low_dim.py) to a single
+LeRobot v2.1 dataset for OpenPI.
+Input HDF5 layout (produced by sync_image_low_dim.py):
+    data/<demo>/obs/<timestamp_key>           (T,)
+    data/<demo>/obs/<image_key_i>             (T, H, W, 3)  uint8
+    data/<demo>/obs/<lowdim_key_j>            (T, D_j)
+    data/<demo>/actions                       (T, A)         optional
+Output: LeRobot v2.1 dataset written directly into <output-dir>.
+All input files are concatenated as episodes in the order given; feature shapes,
+state/action dims, and source fps are inferred from the first file and validated
+against the rest.
+Example:
+    python convert_synced_h5_to_lerobot.py \\
+        --synced-h5 run1.h5 run2.h5 run3.h5 \\
+        --output-dir /DATA/lerobot/my_dataset \\
+        --fps 10 \\
+        --task "pick up the block" \\
+        --image-map agentview_image:base_rgb wrist_image:wrist_rgb \\
+        --state-keys joint_positions gripper_pos \\
+        --action-source next_state
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import sys
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import h5py
+import numpy as np
+
+try:
+    import cv2
+    _HAS_CV2 = True
+except ImportError:
+    _HAS_CV2 = False
+
+from datasets import Dataset
+
+
+def _free_hf_dataset(dataset) -> None:
+    """Mirror convert_to_lerobot.py: empty hf_dataset between episodes to avoid OOM."""
+    if hasattr(dataset, "hf_dataset") and dataset.hf_dataset is not None:
+        features = dataset.hf_dataset.features
+        cols = dataset.hf_dataset.column_names
+        dataset.hf_dataset = Dataset.from_dict(
+            {c: [] for c in cols}, features=features
+        )
+        gc.collect()
+
+
+def parse_kv_list(items: List[str]) -> Dict[str, str]:
+    out = {}
+    for item in items:
+        if ":" not in item:
+            raise ValueError(f"Expected 'src:dst', got {item!r}")
+        k, v = item.split(":", 1)
+        out[k] = v
+    return out
+
+
+def resize_image(img: np.ndarray, size: Tuple[int, int]) -> np.ndarray:
+    """Resize HxWx3 uint8 to size=(H,W). No-op if shapes already match."""
+    if img.shape[:2] == size:
+        return img
+    if not _HAS_CV2:
+        raise RuntimeError(
+            f"Image shape {img.shape[:2]} != target {size}; install opencv-python to resize."
+        )
+    return cv2.resize(img, (size[1], size[0]), interpolation=cv2.INTER_AREA)
+
+
+def ensure_uint8_rgb(img: np.ndarray) -> np.ndarray:
+    if img.dtype != np.uint8:
+        img = np.clip(img, 0, 255).astype(np.uint8)
+    if img.ndim == 2:
+        img = np.stack([img] * 3, axis=-1)
+    if img.shape[-1] == 4:
+        img = img[..., :3]
+    return img
+
+
+def build_state(obs: h5py.Group, state_keys: List[str]) -> np.ndarray:
+    parts = []
+    for key in state_keys:
+        arr = np.asarray(obs[key][:])
+        if arr.ndim == 1:
+            arr = arr[:, None]
+        parts.append(arr.astype(np.float32))
+    return np.concatenate(parts, axis=1)
+
+
+def build_actions(
+    state: np.ndarray,
+    demo_group: h5py.Group,
+    source: str,
+    stride: int = 1,
+) -> np.ndarray:
+    """Build actions aligned with the (already downsampled) state.
+
+    For ``next_state`` this guarantees ``action[t] == state[t+1]`` in the output.
+    """
+    T = state.shape[0]
+    if source == "hdf5_actions":
+        if "actions" not in demo_group:
+            raise KeyError(f"'actions' missing in {demo_group.name}; cannot use --action-source hdf5_actions")
+        a = np.asarray(demo_group["actions"][:], dtype=np.float32)
+        a = downsample(a, stride)
+        if a.shape[0] != T:
+            raise ValueError(f"actions len {a.shape[0]} != state len {T} in {demo_group.name}")
+        return a
+    if source == "next_state":
+        a = np.empty_like(state)
+        a[:-1] = state[1:]
+        a[-1] = state[-1]
+        return a
+    raise ValueError(f"Unknown --action-source {source!r}")
+
+
+def downsample(arr: np.ndarray, stride: int) -> np.ndarray:
+    if stride <= 1:
+        return arr
+    return arr[::stride]
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument("--synced-h5", required=True, nargs="+",
+                   help="One or more synced HDF5 files; all demos are concatenated as episodes.")
+    p.add_argument("--output-dir", required=True,
+                   help="Local folder to write the LeRobot dataset into (created if missing).")
+    p.add_argument("--repo-id", default=None,
+                   help="HuggingFace repo id 'user/name'. Required only with --push-to-hub; "
+                        "otherwise auto-derived from --output-dir basename.")
+    p.add_argument("--fps", type=int, required=True)
+    p.add_argument("--source-fps", type=int, default=None,
+                   help="Source FPS of the synced HDF5 (estimated from timestamps if omitted).")
+    p.add_argument("--task", required=True, help="Language instruction for all episodes.")
+    p.add_argument("--image-map", nargs="+", required=True,
+                   help="Pairs 'hdf5_key:feature_name', e.g. agentview_image:base_rgb")
+    p.add_argument("--state-keys", nargs="+", required=True,
+                   help="Ordered lowdim datasets to concatenate into 'state'.")
+    p.add_argument("--action-source", choices=["next_state", "hdf5_actions"], default="next_state")
+    p.add_argument("--image-size", type=int, nargs=2, default=None, metavar=("H", "W"),
+                   help="Resize images to (H, W). Omit to keep the native resolution.")
+    p.add_argument("--timestamp-key", default="timestamp")
+    p.add_argument("--robot-type", default="franka research 3")
+    p.add_argument("--image-writer-threads", type=int, default=4)
+    p.add_argument("--push-to-hub", action="store_true")
+    args = p.parse_args()
+
+    image_map = parse_kv_list(args.image_map)
+    img_size = tuple(args.image_size) if args.image_size else None
+
+    try:
+        from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
+    except ImportError:
+        from lerobot.datasets.lerobot_dataset import LeRobotDataset
+
+    synced_files = [Path(p).expanduser().resolve() for p in args.synced_h5]
+    for p_ in synced_files:
+        if not p_.is_file():
+            raise FileNotFoundError(f"--synced-h5 path not found: {p_}")
+
+    out_root = Path(args.output_dir).expanduser().resolve()
+    out_root.parent.mkdir(parents=True, exist_ok=True)
+    if out_root.exists():
+        raise FileExistsError(f"--output-dir {out_root} already exists; remove it or pick a new path")
+    repo_id = args.repo_id or f"local/{out_root.name}"
+    if args.push_to_hub and args.repo_id is None:
+        raise ValueError("--push-to-hub requires --repo-id 'user/name'")
+
+    def _estimate_src_fps(obs_group: h5py.Group, label: str) -> int:
+        ts = np.asarray(obs_group[args.timestamp_key][:], dtype=np.float64)
+        if ts.size < 2:
+            raise ValueError(f"Cannot estimate source fps from {label}: <2 timestamps")
+        dt = np.median(np.diff(ts))
+        return int(round(1.0 / dt))
+
+    # Peek the first file's first demo to fix feature schema + stride.
+    with h5py.File(synced_files[0], "r") as f0:
+        if "data" not in f0:
+            raise KeyError(f"{synced_files[0]}: no top-level 'data' group")
+        demos0 = sorted(f0["data"].keys())
+        if not demos0:
+            raise ValueError(f"{synced_files[0]}: no demos found")
+        first_obs = f0["data"][demos0[0]]["obs"]
+        for src in image_map:
+            if src not in first_obs:
+                raise KeyError(f"Image key {src!r} not in {first_obs.name}")
+        state0 = build_state(first_obs, args.state_keys)
+        state_dim = state0.shape[1]
+
+        if args.action_source == "hdf5_actions":
+            a0 = np.asarray(f0["data"][demos0[0]]["actions"])
+            action_dim = a0.shape[1] if a0.ndim > 1 else 1
+        else:
+            action_dim = state_dim
+
+        if args.source_fps is None:
+            src_fps = _estimate_src_fps(first_obs, f"{synced_files[0].name}::{demos0[0]}")
+            print(f"Estimated source FPS from {synced_files[0].name}: {src_fps}")
+        else:
+            src_fps = args.source_fps
+
+        if src_fps % args.fps != 0:
+            raise ValueError(f"source fps {src_fps} not divisible by target fps {args.fps}")
+        stride = src_fps // args.fps
+
+        if img_size is None:
+            sample_img = np.asarray(first_obs[next(iter(image_map))][0])
+            feat_hw = tuple(sample_img.shape[:2])
+        else:
+            feat_hw = img_size
+
+    features = {}
+    for dst in image_map.values():
+        features[dst] = {
+            "dtype": "image",
+            "shape": (feat_hw[0], feat_hw[1], 3),
+            "names": ["height", "width", "channel"],
+        }
+    features["state"] = {
+        "dtype": "float32",
+        "shape": (state_dim,),
+        "names": {"motors": [f"s{i}" for i in range(state_dim)]},
+    }
+    features["action"] = {
+        "dtype": "float32",
+        "shape": (action_dim,),
+        "names": {"motors": [f"a{i}" for i in range(action_dim)]},
+    }
+
+    dataset = LeRobotDataset.create(
+        repo_id=repo_id,
+        fps=args.fps,
+        robot_type=args.robot_type,
+        features=features,
+        use_videos=False,
+        image_writer_threads=args.image_writer_threads,
+        root=str(out_root),
+    )
+
+    total_frames = 0
+    converted = 0
+    total_demos = 0
+    for file_idx, h5_path in enumerate(synced_files):
+        with h5py.File(h5_path, "r") as f:
+            if "data" not in f:
+                raise KeyError(f"{h5_path}: no top-level 'data' group")
+            demos = sorted(f["data"].keys())
+            if not demos:
+                raise ValueError(f"{h5_path}: no demos found")
+            total_demos += len(demos)
+            print(f"\n[{file_idx + 1}/{len(synced_files)}] {h5_path.name}: {len(demos)} demo(s)")
+
+            # Validate schema on files after the first.
+            if file_idx > 0:
+                peek_obs = f["data"][demos[0]]["obs"]
+                for src in image_map:
+                    if src not in peek_obs:
+                        raise KeyError(f"{h5_path}: image key {src!r} not in {peek_obs.name}")
+                peek_state_dim = build_state(peek_obs, args.state_keys).shape[1]
+                if peek_state_dim != state_dim:
+                    raise ValueError(
+                        f"{h5_path}: state dim {peek_state_dim} != {state_dim} from first file")
+                if args.action_source == "hdf5_actions":
+                    a_peek = np.asarray(f["data"][demos[0]]["actions"])
+                    peek_action_dim = a_peek.shape[1] if a_peek.ndim > 1 else 1
+                    if peek_action_dim != action_dim:
+                        raise ValueError(
+                            f"{h5_path}: action dim {peek_action_dim} != {action_dim} from first file")
+                if args.source_fps is None:
+                    peek_src_fps = _estimate_src_fps(peek_obs, f"{h5_path.name}::{demos[0]}")
+                    if peek_src_fps != src_fps:
+                        raise ValueError(
+                            f"{h5_path}: estimated source fps {peek_src_fps} != {src_fps} "
+                            f"from first file; pass --source-fps explicitly if this is intended")
+
+            for demo in demos:
+                label = f"{h5_path.name}::{demo}"
+                g = f["data"][demo]
+                obs = g["obs"]
+                try:
+                    state = build_state(obs, args.state_keys)
+                    # Downsample state first so next_state actions align with the
+                    # *dataset* timestep (action[t] == state[t+1] in the output).
+                    state = downsample(state, stride)
+                    action = build_actions(state, g, args.action_source, stride)
+
+                    imgs = {}
+                    for src, dst in image_map.items():
+                        raw = np.asarray(obs[src][:])
+                        imgs[dst] = downsample(raw, stride)
+
+                    T = state.shape[0]
+                    if T < 2:
+                        print(f"  Skip {label}: only {T} frame(s) after downsampling")
+                        continue
+
+                    for t in range(T):
+                        frame = {"state": state[t].astype(np.float32),
+                                 "action": action[t].astype(np.float32),
+                                 "task": args.task}
+                        for dst, arr in imgs.items():
+                            img = ensure_uint8_rgb(arr[t])
+                            if img_size is not None:
+                                img = resize_image(img, img_size)
+                            frame[dst] = img
+                        dataset.add_frame(frame)
+
+                    dataset.save_episode()
+                    _free_hf_dataset(dataset)
+                    total_frames += T
+                    converted += 1
+                    print(f"  {label}: {T} frames")
+                except Exception as e:
+                    print(f"  ERROR on {label}: {e}", file=sys.stderr)
+                    raise
+
+    if hasattr(dataset, "finalize"):
+        dataset.finalize()
+
+    print(f"\nConverted {converted}/{total_demos} demos across {len(synced_files)} file(s), "
+          f"{total_frames} frames -> {out_root}")
+
+    if args.push_to_hub:
+        dataset.push_to_hub()
+
+
+if __name__ == "__main__":
+    main()