Ship the LeRobot->robomimic converter with the dataset

to_robomimic.py

@@ -0,0 +1,242 @@
+"""Convert either recorded dataset into a robomimic HDF5 for bspline/diffusion training.
+
+Two input formats, two action spaces, one tool — so the crop, the resize and
+the RGB convention are defined in exactly one place for both:
+
+  --from bspline   their episode dirs (`data.pkl` + `<key>.mp4`)
+                   -> obs {arm_pos(3), arm_quat(4), gripper_pos(1), images}
+                      actions (N, 7) = [pos(3), rotvec(3), gripper(1)]
+                   Their dataset class turns the rotvec into rotation_6d, so
+                   the trained action is 10-dim: their `single_yam_rot6d`.
+
+  --from lerobot   a LeRobot v3 dataset with 7-dim joint state/action
+                   -> obs {joint_pos(7), images}
+                      actions (N, 7) = [joint1..6 (rad), gripper]
+                   Their `single_yam_joint` format: no rotation conversion and
+                   no IK at deploy.
+
+With no --crop the bspline path is byte-identical to their
+`convert_to_robomimic_hdf5.py`; this tool adds cropping and the joint-space
+input.
+
+Cropping happens here rather than at record time on purpose: the recorded mp4s
+stay full-resolution, so a crop can be retuned and the HDF5 rebuilt without
+re-recording. Whatever rectangle you pick MUST also be applied to the
+observation at deployment, or the policy sees a distribution it never trained
+on. Crops are stored in the HDF5 attrs so the choice travels with the data.
+
+    python tools/to_robomimic.py --from bspline \\
+        --input-dir data/demos-ee-pick-duster \\
+        --output-path ~/bspline-policy/data/yam_ee.hdf5 \\
+        --crop top_image=42,28,598,414
+
+    python tools/to_robomimic.py --from lerobot \\
+        --repo-id Dimios45/yam-pick-duster --root data/lerobot-pick-duster \\
+        --output-path ~/bspline-policy/data/yam_joint.hdf5 \\
+        --crop top_image=42,28,598,414
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import cv2
+import h5py
+import numpy as np
+
+DEFAULT_BSPLINE_REPO = Path.home() / "bspline-policy/real_env/yam_teleop"
+# Their constants.POLICY_IMAGE_WIDTH / HEIGHT — what the policy server feeds
+# the network at inference, so the dataset must match.
+POLICY_IMAGE_SIZE = 84
+
+# LeRobot camera key -> the obs key their configs expect.
+LEROBOT_IMAGE_KEYS = {
+    "observation.images.right_wrist": "wrist_image",
+    "observation.images.left_wrist": "wrist_image",
+    "observation.images.top": "top_image",
+}
+
+
+def _parse_crop(spec: str):
+    cam, _, rect = spec.partition("=")
+    parts = [int(v) for v in rect.split(",")]
+    if len(parts) != 4:
+        raise argparse.ArgumentTypeError(f"--crop {spec!r} must be <image_key>=x,y,w,h")
+    return cam.strip(), tuple(parts)
+
+
+def _prepare(img: np.ndarray, key: str, crops: dict, size: int) -> np.ndarray:
+    """Crop (optional) then resize to the policy's input size. RGB uint8 in and out."""
+    if key in crops:
+        x, y, w, h = crops[key]
+        ih, iw = img.shape[:2]
+        w = w or (iw - x)
+        h = h or (ih - y)
+        if x < 0 or y < 0 or x + w > iw or y + h > ih:
+            raise SystemExit(f"crop {x},{y},{w},{h} for {key} does not fit in {iw}x{ih}")
+        img = img[y:y + h, x:x + w]
+    return cv2.resize(img, (size, size))
+
+
+def _quat_xyzw_to_rotvec(quat_xyzw: np.ndarray) -> np.ndarray:
+    """Axis-angle from an xyzw quaternion — matches scipy's `as_rotvec`, which
+    is what their converter uses, without taking a scipy dependency."""
+    q = np.asarray(quat_xyzw, dtype=np.float64)
+    q = q / np.linalg.norm(q)
+    if q[3] < 0.0:  # shortest rotation
+        q = -q
+    angle = 2.0 * np.arccos(np.clip(q[3], -1.0, 1.0))
+    s = np.sqrt(max(0.0, 1.0 - q[3] * q[3]))
+    if s < 1e-12:  # tiny angle: axis is ill-conditioned, series expansion instead
+        return 2.0 * q[:3]
+    return (angle / s) * q[:3]
+
+
+def convert_bspline(args, crops: dict) -> tuple[int, int, dict]:
+    sys.path.insert(0, str(Path(args.bspline_repo)))
+    try:
+        from episode_storage import EpisodeReader  # their code, unmodified
+    except ImportError as e:
+        raise SystemExit(f"cannot import their episode_storage from {args.bspline_repo}: {e}")
+
+    root = Path(args.input_dir)
+    episode_dirs = sorted(d for d in root.iterdir() if d.is_dir())
+    if args.max_episodes:
+        episode_dirs = episode_dirs[:args.max_episodes]
+    if not episode_dirs:
+        raise SystemExit(f"no episode dirs under {root}")
+
+    n_frames = 0
+    obs_keys: dict = {}
+    with h5py.File(args.output_path, "w") as f:
+        data = f.create_group("data")
+        for idx, ep in enumerate(episode_dirs):
+            r = EpisodeReader(ep)
+            obs: dict[str, list] = {}
+            for o in r.observations:
+                for k, v in o.items():
+                    v = np.asarray(v)
+                    if v.ndim == 3:
+                        v = _prepare(v, k, crops, args.image_size)
+                    obs.setdefault(k, []).append(v)
+            actions = [np.concatenate((
+                np.asarray(a["arm_pos"], dtype=np.float64),
+                _quat_xyzw_to_rotvec(a["arm_quat"]),
+                np.asarray(a["gripper_pos"], dtype=np.float64),
+            )) for a in r.actions]
+
+            g = data.create_group(f"demo_{idx}")
+            for k, v in obs.items():
+                g.create_dataset(f"obs/{k}", data=np.array(v))
+            g.create_dataset("actions", data=np.array(actions))
+            n_frames += len(r)
+            obs_keys = {k: np.array(v).shape[1:] for k, v in obs.items()}
+            print(f"  demo_{idx:<3d} {len(r):4d} frames  {ep.name}")
+        _stamp(f, args, crops, "bspline", "single_yam_rot6d")
+    return len(episode_dirs), n_frames, obs_keys
+
+
+def convert_lerobot(args, crops: dict) -> tuple[int, int, dict]:
+    from lerobot.datasets.lerobot_dataset import LeRobotDataset
+
+    ds = LeRobotDataset(args.repo_id, root=args.root)
+    state_dim = ds.meta.features["observation.state"]["shape"][0]
+    if state_dim != 7:
+        raise SystemExit(
+            f"expected a 7-dim joint state (joint1..6 + gripper), got {state_dim}. "
+            "This path is for single-arm joint-space datasets.")
+
+    episode_index = np.array(ds.hf_dataset["episode_index"])
+    n_eps = ds.num_episodes if not args.max_episodes else min(args.max_episodes, ds.num_episodes)
+
+    n_frames = 0
+    obs_keys: dict = {}
+    with h5py.File(args.output_path, "w") as f:
+        data = f.create_group("data")
+        for idx in range(n_eps):
+            rows = np.flatnonzero(episode_index == idx)
+            joint_pos, actions = [], []
+            images: dict[str, list] = {}
+            for row in rows:
+                item = ds[int(row)]
+                joint_pos.append(item["observation.state"].numpy().astype(np.float64))
+                actions.append(item["action"].numpy().astype(np.float64))
+                for cam_key, out_key in LEROBOT_IMAGE_KEYS.items():
+                    if cam_key not in item:
+                        continue
+                    # LeRobot hands back CHW float32 in [0, 1], RGB.
+                    img = (item[cam_key].numpy().transpose(1, 2, 0) * 255.0)
+                    img = np.clip(img, 0, 255).astype(np.uint8)
+                    images.setdefault(out_key, []).append(
+                        _prepare(img, out_key, crops, args.image_size))
+
+            g = data.create_group(f"demo_{idx}")
+            g.create_dataset("obs/joint_pos", data=np.array(joint_pos))
+            for k, v in images.items():
+                g.create_dataset(f"obs/{k}", data=np.array(v))
+            g.create_dataset("actions", data=np.array(actions))
+            n_frames += len(rows)
+            obs_keys = {"joint_pos": (7,), **{k: np.array(v).shape[1:] for k, v in images.items()}}
+            print(f"  demo_{idx:<3d} {len(rows):4d} frames")
+        _stamp(f, args, crops, "lerobot", "single_yam_joint")
+    return n_eps, n_frames, obs_keys
+
+
+def _stamp(f, args, crops: dict, source: str, action_format: str) -> None:
+    """Record how this HDF5 was built, so the deployment side can reproduce the
+    exact image pipeline instead of relying on someone's memory."""
+    f.attrs["source_format"] = source
+    f.attrs["action_format"] = action_format
+    f.attrs["image_size"] = args.image_size
+    f.attrs["crops"] = json.dumps({k: list(v) for k, v in crops.items()})
+    f.attrs["gripper_convention"] = "0=open, 1=closed"
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--from", dest="source", choices=("bspline", "lerobot"), required=True)
+    ap.add_argument("--output-path", required=True)
+    ap.add_argument("--crop", action="append", default=[], type=_parse_crop,
+                    help="<image_key>=x,y,w,h, e.g. top_image=42,28,598,414 (repeatable)")
+    ap.add_argument("--image-size", type=int, default=POLICY_IMAGE_SIZE,
+                    help=f"square size fed to the policy (default: {POLICY_IMAGE_SIZE})")
+    ap.add_argument("--max-episodes", type=int, default=0, help="0 = all")
+    # bspline source
+    ap.add_argument("--input-dir", help="[--from bspline] directory of episode dirs")
+    ap.add_argument("--bspline-repo", default=str(DEFAULT_BSPLINE_REPO))
+    # lerobot source
+    ap.add_argument("--repo-id", help="[--from lerobot] dataset repo id")
+    ap.add_argument("--root", help="[--from lerobot] local dataset root")
+    args = ap.parse_args()
+
+    crops = dict(args.crop)
+    Path(args.output_path).parent.mkdir(parents=True, exist_ok=True)
+
+    if args.source == "bspline":
+        if not args.input_dir:
+            raise SystemExit("--from bspline needs --input-dir")
+        n_eps, n_frames, obs_keys = convert_bspline(args, crops)
+    else:
+        if not args.repo_id:
+            raise SystemExit("--from lerobot needs --repo-id (and usually --root)")
+        n_eps, n_frames, obs_keys = convert_lerobot(args, crops)
+
+    size_mb = Path(args.output_path).stat().st_size / 1e6
+    print(f"\n{n_eps} demos, {n_frames} frames -> {args.output_path} ({size_mb:.0f} MB)")
+    print("obs keys:", {k: tuple(v) for k, v in obs_keys.items()})
+    print("crops   :", {k: list(v) for k, v in crops.items()} or "none")
+    print("\nshape_meta for the task yaml:")
+    for k, shape in obs_keys.items():
+        if len(shape) == 3:
+            print(f"    {k}:\n      shape: [3, {shape[0]}, {shape[1]}]\n      type: rgb")
+        else:
+            print(f"    {k}:\n      shape: [{shape[0]}]")
+    print("  action:")
+    print(f"    shape: [{10 if args.source == 'bspline' else 7}]")
+
+
+if __name__ == "__main__":
+    main()