Upload 2 files

scripts/convert_to_lerobot.py

@@ -0,0 +1,438 @@
+""" 
+This project is built upon the open-source project 🤗 LeRobot: https://github.com/huggingface/lerobot 
+
+We are grateful to the LeRobot team for their outstanding work and their contributions to the community. 
+
+If you find this project useful, please also consider supporting and exploring LeRobot. 
+"""
+
+import os
+import cv2
+import json
+import glob
+import shutil
+import logging
+import argparse
+from pathlib import Path
+from typing import Callable
+from functools import partial
+from math import ceil
+from copy import deepcopy
+import subprocess
+from multiprocessing import Pool, cpu_count
+
+
+import h5py
+import torch
+import einops
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+
+
+HEAD_COLOR = "head.mp4"
+HAND_LEFT_COLOR = "hand_left.mp4"
+HAND_RIGHT_COLOR = "hand_right.mp4"
+HEAD_CENTER_FISHEYE_COLOR = "head_front_fisheye.mp4"
+HEAD_LEFT_FISHEYE_COLOR = "head_left_fisheye.mp4"
+HEAD_RIGHT_FISHEYE_COLOR = "head_right_fisheye.mp4"
+BACK_LEFT_FISHEYE_COLOR = "back_left_fisheye.mp4"
+BACK_RIGHT_FISHEYE_COLOR = "back_right_fisheye.mp4"
+HEAD_DEPTH = "head"
+ALL_VIDEOS = [HEAD_COLOR, HAND_LEFT_COLOR, HAND_RIGHT_COLOR, HEAD_CENTER_FISHEYE_COLOR, HEAD_LEFT_FISHEYE_COLOR, HEAD_RIGHT_FISHEYE_COLOR, BACK_LEFT_FISHEYE_COLOR, BACK_RIGHT_FISHEYE_COLOR]
+
+DEFAULT_IMAGE_PATH = (
+    "images/{image_key}/episode_{episode_index:06d}/frame_{frame_index:06d}.jpg"
+)
+
+FEATURES = {
+    "observation.images.top_head": {
+        "dtype": "video",
+        "shape": [480, 640, 3],
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False,
+        },
+    },
+    "observation.images.cam_top_depth": {
+        "dtype": "image",
+        "shape": [480, 640, 1],
+        "names": ["height", "width", "channel"],
+    },
+    "observation.images.hand_left": {
+        "dtype": "video",
+        "shape": [480, 640, 3],
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False,
+        },
+    },
+    "observation.images.hand_right": {
+        "dtype": "video",
+        "shape": [480, 640, 3],
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False,
+        },
+    },
+    "observation.images.head_center_fisheye": {
+        "dtype": "video",
+        "shape": [748, 960, 3],
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False,
+        },
+    },
+    "observation.images.head_left_fisheye": {
+        "dtype": "video",
+        "shape": [748, 960, 3],
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False,
+        },
+    },
+    "observation.images.head_right_fisheye": {
+        "dtype": "video",
+        "shape": [748, 960, 3],
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False,
+        },
+    },
+    "observation.images.back_left_fisheye": {
+        "dtype": "video",
+        "shape": [748, 960, 3],
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False,
+        },
+    },
+    "observation.images.back_right_fisheye": {
+        "dtype": "video",
+        "shape": [748, 960, 3],
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False,
+        },
+    },
+    "observation.state": {
+        "dtype": "float32",
+        "shape": [22],
+    },
+    "action": {
+        "dtype": "float32",
+        "shape": [22],
+    },
+    "episode_index": {
+        "dtype": "int64",
+        "shape": [1],
+        "names": None,
+    },
+    "frame_index": {
+        "dtype": "int64",
+        "shape": [1],
+        "names": None,
+    },
+    "index": {
+        "dtype": "int64",
+        "shape": [1],
+        "names": None,
+    },
+    "task_index": {
+        "dtype": "int64",
+        "shape": [1],
+        "names": None,
+    },
+}
+
+
+
+
+from modified_lerobot_dataset import AgiBotDataset
+
+
+
+
+def process_video(video_path):
+    output = video_path.replace('.mp4', '_encode.mp4')
+    try:
+        command = [
+            "ffmpeg",
+            "-i", video_path,
+            "-vcodec", "libsvtav1",
+            "-pix_fmt", "yuv420p",
+            "-r", "30",
+            "-g", "2",
+            "-crf", "30",
+            "-vf", "scale=640:360:flags=bicubic",
+            "-loglevel", "error",
+            "-y", output
+        ]
+        subprocess.run(command, check=True)
+
+    except subprocess.CalledProcessError as e:
+        print(f"Video failure: {' '.join(command)}, error: {e}")
+    except Exception as e:
+        print(f"Video unknwon failure: {' '.join(command)}, error: {e}")
+    finally:
+        pass
+
+
+def preprocess_vides(episode_list, debug=False):
+    video_paths = []
+    for episode_path in episode_list:
+        video_dir = episode_path.replace('meta_info', 'observation') + "/video"
+        for file in ALL_VIDEOS:
+            video_path = os.path.join(video_dir, file)
+            video_paths.append(video_path)
+
+    if debug:
+        for video in video_paths:
+            process_video(video)
+    else:
+        with Pool(processes=os.cpu_count() // 2) as pool:
+            for _ in tqdm(pool.imap_unordered(process_video, video_paths), total=len(video_paths), desc="Video preprocessing"):
+                pass
+
+
+def load_depths(root_dir: str, camera_name: str):
+    cam_path = Path(root_dir)
+    all_imgs = sorted(list(cam_path.glob(f"*")), key=lambda x: int(x.stem))
+    return [np.array(Image.open(f"{file}/{camera_name}.png")).astype(np.float32) / 1000 for file in all_imgs]
+
+
+def load_local_dataset(episode_path: str) -> list | None:
+    """Load local dataset and return a dict with observations and actions"""
+    observation_path = episode_path.replace('meta_info', 'observation')
+    with open(f"{episode_path}/task_info.json") as f:
+        task_info = json.load(f)
+        task = task_info['task_name']
+
+    with h5py.File(Path(episode_path) / "aligned_joints.h5") as f:
+        state_joint = np.array(f["state/joint/position"])
+        joint_names = f["state/joint"].attrs['name'].tolist()
+
+    
+    head_joint_names = [
+        "joint_head_yaw",
+        "joint_head_pitch",
+    ]
+    body_joint_names = [
+        "joint_lift_body",
+        "joint_body_pitch",
+    ]
+    arm_joint_names = [
+        "Joint1_l",
+        "Joint1_r",
+        "Joint2_l",
+        "Joint2_r",
+        "Joint3_l",
+        "Joint3_r",
+        "Joint4_l",
+        "Joint4_r",
+        "Joint5_l",
+        "Joint5_r",
+        "Joint6_l",
+        "Joint6_r",
+        "Joint7_l",
+        "Joint7_r",
+    ]
+    effector_joint_names = [
+        "right_Left_1_Joint", 
+        "right_Right_1_Joint",
+        "left_Left_1_Joint", 
+        "left_Right_1_Joint"
+    ]
+
+    # Get indices for arm and effector joints from the first frame
+    head_joint_indices = [joint_names.index(name) for name in head_joint_names]
+    body_joint_indices = [joint_names.index(name) for name in body_joint_names]
+    arm_joint_indices = [joint_names.index(name) for name in arm_joint_names]
+    effector_joint_indices = [joint_names.index(name) for name in effector_joint_names]
+    
+    # Extract joint positions for all frames
+    state_head = state_joint[:, head_joint_indices]
+    state_body = state_joint[:, body_joint_indices]
+    state_arm = state_joint[:, arm_joint_indices]
+    state_effector = state_joint[:, effector_joint_indices]
+
+
+    # Get action from state
+    action_head = state_head[1:] - state_head[:-1]
+    action_body = state_body[1:] - state_body[:-1]
+    action_arm = state_arm[1:] - state_arm[:-1]
+    action_effector = state_effector[1:] - state_effector[:-1]
+    
+    # repeat the last frame of the action
+    action_head = np.concatenate([action_head, action_head[-1:]])
+    action_body = np.concatenate([action_body, action_body[-1:]])
+    action_arm = np.concatenate([action_arm, action_arm[-1:]])
+    action_effector = np.concatenate([action_effector, action_effector[-1:]])
+
+
+        
+    states_value = np.hstack(
+        [state_head, state_body, state_arm, state_effector]
+    ).astype(np.float32)
+    assert (
+        action_arm.shape[0] == action_effector.shape[0]
+    ), f"shape of action_arm:{action_arm.shape};shape of action_effector:{action_effector.shape}"
+    action_value = np.hstack(
+        [action_head, action_body, action_arm, action_effector]
+    ).astype(np.float32)
+    
+    depth_imgs = load_depths(f"{observation_path}/depth", HEAD_DEPTH)
+
+    assert len(depth_imgs) == len(
+        states_value
+    ), f"Number of images and states are not equal"
+    assert len(depth_imgs) == len(
+        action_value
+    ), f"Number of images and actions are not equal"
+    frames = [
+        {
+            "observation.images.cam_top_depth": depth_imgs[i],
+            "observation.state": states_value[i],
+            "action": action_value[i],
+        }
+        for i in range(len(depth_imgs))
+    ]
+
+    v_path = observation_path + "/video"
+    videos = {
+        "observation.images.top_head": f"{v_path}/{HEAD_COLOR}".replace('.mp4', '_encode.mp4'),
+        "observation.images.hand_left": f"{v_path}/{HAND_LEFT_COLOR}".replace('.mp4', '_encode.mp4'),
+        "observation.images.hand_right": f"{v_path}/{HAND_RIGHT_COLOR}".replace('.mp4', '_encode.mp4'),
+        "observation.images.head_center_fisheye": f"{v_path}/{HEAD_CENTER_FISHEYE_COLOR}".replace('.mp4', '_encode.mp4'),
+        "observation.images.head_left_fisheye": f"{v_path}/{HEAD_LEFT_FISHEYE_COLOR}".replace('.mp4', '_encode.mp4'),
+        "observation.images.head_right_fisheye": f"{v_path}/{HEAD_RIGHT_FISHEYE_COLOR}".replace('.mp4', '_encode.mp4'),
+        "observation.images.back_left_fisheye": f"{v_path}/{BACK_LEFT_FISHEYE_COLOR}".replace('.mp4', '_encode.mp4'),
+        "observation.images.back_right_fisheye": f"{v_path}/{BACK_RIGHT_FISHEYE_COLOR}".replace('.mp4', '_encode.mp4'),
+    }
+    return {
+        'frames': frames,
+        'videos': videos,
+        'task': task
+    }
+
+
+
+
+
+def main(
+    src_path: str,
+    tgt_path: str,
+    repo_id: str,
+    preprocess_video: bool = False,
+    debug: bool = True,
+):
+    # remove the existing dataset
+    if os.path.exists(f"{tgt_path}/{repo_id}"):
+        shutil.rmtree(f"{tgt_path}/{repo_id}")
+    dataset = AgiBotDataset.create(
+        repo_id=repo_id,
+        root=f"{tgt_path}/{repo_id}",
+        fps=30,
+        robot_type="a2d",
+        features=FEATURES,
+    )
+
+    episode_list = sorted(
+        [
+            f
+            for f in glob.glob(f"{src_path}/meta_info/*/*")
+            if os.path.isdir(f)
+        ]
+    )
+    
+    # preprocess the videos to avoid encoding error
+    if preprocess_video:
+        preprocess_vides(episode_list, debug)
+
+    # load the raw datasets
+    raw_datasets_before_filter = [
+        load_local_dataset(episode_path)
+        for episode_path in tqdm(episode_list)
+    ]
+
+    # remove the None result from the raw_datasets
+    raw_datasets = [
+        dataset for dataset in raw_datasets_before_filter if dataset is not None
+    ]
+
+    for episode_data in tqdm(raw_datasets, desc="Generating dataset from raw datasets"):
+        for frame in tqdm(episode_data['frames'], desc="Generating dataset from raw dataset"):
+            dataset.add_frame(frame)
+        
+        dataset.save_episode(task=episode_data['task'], videos=episode_data['videos'])
+    dataset.consolidate(run_compute_stats=True)
+
+
+        
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--data_dir",
+        type=str,
+        required=True,
+    )
+    parser.add_argument(
+        "--save_dir",
+        type=str,
+        required=True,
+    )
+    parser.add_argument(
+        "--repo_id",
+        type=str,
+        required=True,
+    )
+    parser.add_argument(
+        "--preprocess_video",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+    )
+    args = parser.parse_args()
+
+
+
+    assert os.path.exists(args.data_dir), f"Cannot find {args.data_dir}."
+    
+
+    main(args.data_dir, args.save_dir, args.repo_id, args.preprocess_video, args.debug)

scripts/visualize_dataset.py

@@ -0,0 +1,234 @@
+""" 
+This script is adapted from the Hugging Face 🤗 LeRobot project:
+https://github.com/huggingface/lerobot
+
+Original file:
+https://github.com/huggingface/lerobot/blob/main/lerobot/scripts/visualize_dataset.py
+
+The original script was developed as part of the LeRobot project for dataset visualization.
+This version adds support for depth map visualization.
+"""
+
+import argparse
+import gc
+import logging
+import time
+from pathlib import Path
+from typing import Iterator
+
+import numpy as np
+import rerun as rr
+import torch
+import torch.utils.data
+import tqdm
+import matplotlib.pyplot as plt
+
+from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
+
+
+class EpisodeSampler(torch.utils.data.Sampler):
+    def __init__(self, dataset: LeRobotDataset, episode_index: int):
+        from_idx = dataset.episode_data_index["from"][episode_index].item()
+        to_idx = dataset.episode_data_index["to"][episode_index].item()
+        self.frame_ids = range(from_idx, to_idx)
+
+    def __iter__(self) -> Iterator:
+        return iter(self.frame_ids)
+
+    def __len__(self) -> int:
+        return len(self.frame_ids)
+
+
+def to_hwc_uint8_numpy(chw_float32_torch: torch.Tensor) -> np.ndarray:
+    assert chw_float32_torch.dtype == torch.float32
+    assert chw_float32_torch.ndim == 3
+    c, h, w = chw_float32_torch.shape
+    assert c < h and c < w, f"Expect channel first images, but instead {chw_float32_torch.shape}"
+
+    if c == 1:
+        # If depth image, clip and normalize the depth map just for visualization
+        min_depth = 0.4
+        max_depth = 3
+        clipped_depth = torch.clamp(chw_float32_torch, min=min_depth, max=max_depth)
+        normalized_depth = (clipped_depth-min_depth) / (max_depth-min_depth)
+        depth_image = np.sqrt(normalized_depth.squeeze().cpu().numpy())
+
+        colormap = plt.get_cmap('jet')
+        colored_depth_image = colormap(depth_image)
+        hwc_uint8_numpy = (colored_depth_image[:, :, :3] * 255).astype(np.uint8)
+    else:
+        # If RGB image
+        hwc_uint8_numpy = (chw_float32_torch * 255).type(torch.uint8).permute(1, 2, 0).numpy()
+
+    return hwc_uint8_numpy
+
+
+def visualize_dataset(
+    dataset: LeRobotDataset,
+    episode_index: int,
+    batch_size: int = 32,
+    num_workers: int = 0,
+    mode: str = "local",
+    web_port: int = 9090,
+    ws_port: int = 9087,
+    save: bool = False,
+    output_dir: Path | None = None,
+    **kwargs,
+) -> Path | None:
+    if save:
+        assert (
+            output_dir is not None
+        ), "Set an output directory where to write .rrd files with `--output-dir path/to/directory`."
+
+    repo_id = dataset.repo_id
+
+    logging.info("Loading dataloader")
+    episode_sampler = EpisodeSampler(dataset, episode_index)
+    dataloader = torch.utils.data.DataLoader(
+        dataset,
+        num_workers=num_workers,
+        batch_size=batch_size,
+        sampler=episode_sampler,
+    )
+
+    logging.info("Starting Rerun")
+
+    if mode not in ["local", "distant"]:
+        raise ValueError(mode)
+
+    spawn_local_viewer = mode == "local" and not save
+    rr.init(f"{repo_id}/episode_{episode_index}", spawn=spawn_local_viewer)
+
+    # Manually call python garbage collector after `rr.init` to avoid hanging in a blocking flush
+    # when iterating on a dataloader with `num_workers` > 0
+    # TODO(rcadene): remove `gc.collect` when rerun version 0.16 is out, which includes a fix
+    gc.collect()
+
+    if mode == "distant":
+        rr.serve(open_browser=False, web_port=web_port, ws_port=ws_port)
+
+    logging.info("Logging to Rerun")
+
+    for batch in tqdm.tqdm(dataloader, total=len(dataloader)):
+        # iterate over the batch
+        for i in range(len(batch["index"])):
+            rr.set_time_sequence("frame_index", batch["frame_index"][i].item())
+            rr.set_time_seconds("timestamp", batch["timestamp"][i].item())
+
+            # display each camera image
+            for key in dataset.meta.camera_keys:
+                # TODO(rcadene): add `.compress()`? is it lossless?
+                rr.log(key, rr.Image(to_hwc_uint8_numpy(batch[key][i])))
+
+            # display each dimension of action space (e.g. actuators command)
+            if "action" in batch:
+                for dim_idx, val in enumerate(batch["action"][i]):
+                    rr.log(f"action/{dim_idx}", rr.Scalar(val.item()))
+
+            # display each dimension of observed state space (e.g. agent position in joint space)
+            if "observation.state" in batch:
+                for dim_idx, val in enumerate(batch["observation.state"][i]):
+                    rr.log(f"state/{dim_idx}", rr.Scalar(val.item()))
+
+    if mode == "local" and save:
+        # save .rrd locally
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        repo_id_str = repo_id.replace("/", "_")
+        rrd_path = output_dir / f"{repo_id_str}_episode_{episode_index}.rrd"
+        rr.save(rrd_path)
+        return rrd_path
+
+    elif mode == "distant":
+        # stop the process from exiting since it is serving the websocket connection
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            print("Ctrl-C received. Exiting.")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--repo-id",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--episode-index",
+        type=int,
+        nargs="*",
+        default=None,
+        help="Episode indices to visualize (e.g. `0 1 5 6` to load episodes of index 0, 1, 5 and 6). By default loads all episodes.",
+    )
+    parser.add_argument(
+        "--dataset-path",
+        type=Path,
+        default=None,
+        help="Root directory for the converted LeRobot dataset stored locally.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Directory path to write a .rrd file when `--save 1` is set.",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=32,
+        help="Batch size loaded by DataLoader.",
+    )
+    parser.add_argument(
+        "--num-workers",
+        type=int,
+        default=4,
+        help="Number of processes of Dataloader for loading the data.",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        default="local",
+        help=(
+            "Mode of viewing between 'local' or 'distant'. "
+            "'local' requires data to be on a local machine. It spawns a viewer to visualize the data locally. "
+            "'distant' creates a server on the distant machine where the data is stored. "
+            "Visualize the data by connecting to the server with `rerun ws://localhost:PORT` on the local machine."
+        ),
+    )
+    parser.add_argument(
+        "--web-port",
+        type=int,
+        default=9090,
+        help="Web port for rerun.io when `--mode distant` is set.",
+    )
+    parser.add_argument(
+        "--ws-port",
+        type=int,
+        default=9087,
+        help="Web socket port for rerun.io when `--mode distant` is set.",
+    )
+    parser.add_argument(
+        "--save",
+        type=int,
+        default=0,
+        help=(
+            "Save a .rrd file in the directory provided by `--output-dir`. "
+            "It also deactivates the spawning of a viewer. "
+            "Visualize the data by running `rerun path/to/file.rrd` on your local machine."
+        ),
+    )
+
+    args = parser.parse_args()
+    kwargs = vars(args)
+    root = f"{kwargs.pop('dataset_path')}/{args.repo_id}"
+
+    logging.info("Loading dataset")
+    dataset = LeRobotDataset(args.repo_id, root=root, local_files_only=True)
+
+    visualize_dataset(dataset, **vars(args))
+
+if __name__ == "__main__":
+    main()