Delete convert_synced_h5_to_lerobot.py

convert_synced_h5_to_lerobot.py

@@ -1,288 +0,0 @@
-
-"""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()