Upload convert_synced_h5_to_lerobot.py with huggingface_hub

convert_synced_h5_to_lerobot.py

@@ -0,0 +1,288 @@
+
+"""Convert a synced HDF5 (output of sync_image_low_dim.py) to LeRobot v2.1 format 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>.
+
+Example:
+    python convert_synced_h5_to_lerobot.py \\
+        --synced-h5 synced.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,
+) -> np.ndarray:
+    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)
+        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)
+    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="ur5e")
+    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
+
+    with h5py.File(args.synced_h5, "r") as f:
+        if "data" not in f:
+            raise KeyError("Input HDF5 has no top-level 'data' group")
+        demos = sorted(f["data"].keys())
+        if not demos:
+            raise ValueError("No demos found")
+
+        # Peek first demo to infer feature shapes + action dim.
+        first_obs = f["data"][demos[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(f["data"][demos[0]]["actions"])
+            action_dim = a0.shape[1] if a0.ndim > 1 else 1
+        else:
+            action_dim = state_dim
+
+        # Estimate source FPS from first demo timestamps if not provided.
+        if args.source_fps is None:
+            ts = np.asarray(first_obs[args.timestamp_key][:], dtype=np.float64)
+            if ts.size < 2:
+                raise ValueError("Cannot estimate source fps: first demo has <2 timestamps")
+            dt = np.median(np.diff(ts))
+            src_fps = int(round(1.0 / dt))
+            print(f"Estimated source FPS: {src_fps} (dt={dt:.4f}s)")
+        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])
+            native_hw = sample_img.shape[:2]
+            feat_hw = native_hw
+        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)]},
+        }
+
+        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'")
+        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
+        for demo in demos:
+            g = f["data"][demo]
+            obs = g["obs"]
+            try:
+                state = build_state(obs, args.state_keys)
+                action = build_actions(state, g, args.action_source)
+
+                imgs = {}
+                for src, dst in image_map.items():
+                    raw = np.asarray(obs[src][:])
+                    imgs[dst] = raw
+
+                # Downsample all arrays consistently.
+                state = downsample(state, stride)
+                action = downsample(action, stride)
+                for k in list(imgs):
+                    imgs[k] = downsample(imgs[k], stride)
+
+                T = state.shape[0]
+                if T < 2:
+                    print(f"  Skip {demo}: 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"  {demo}: {T} frames")
+            except Exception as e:
+                print(f"  ERROR on {demo}: {e}", file=sys.stderr)
+                raise
+
+        if hasattr(dataset, "finalize"):
+            dataset.finalize()
+
+    print(f"\nConverted {converted}/{len(demos)} demos, {total_frames} frames -> {out_root}")
+
+    if args.push_to_hub:
+        dataset.push_to_hub()
+
+
+if __name__ == "__main__":
+    main()