Delete scripts

scripts/convert_to_lerobot.py

@@ -1,444 +0,0 @@
-""" 
-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):
-    """
-    使用 ffmpeg 处理单个视频
-    :param video_path: 输入视频的完整路径
-    """
-    temp_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", temp_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('states', '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:
-            # 使用 imap_unordered 实现多进程和进度条的结合
-            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('states', '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}/states/*/*")
-            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

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