tactile_tasks/convert_for_dp.py

#!/usr/bin/env python3
"""
Convert tactile_data HDF5 episodes to Diffusion Policy (DP) Zarr format.

Input:  tactile_data/{task}/episode_XX.hdf5  (our format)
Output: policy/DP/data/{task}-{config}-{num}.zarr

DP expects Zarr archive with:
  data/head_camera    [N, 3, H, W] uint8 NCHW
  data/state          [N, state_dim] float32
  data/action         [N, action_dim] float32
  meta/episode_ends   [num_episodes] int64
"""

import os
import sys
import argparse
import numpy as np
import h5py

try:
    import zarr
except ImportError:
    print("Error: zarr not installed. Run: pip install zarr")
    sys.exit(1)


def convert_task(task_name, data_dir, output_dir, config_name="default"):
    """Convert all episodes for a task to a single Zarr archive."""
    task_dir = os.path.join(data_dir, task_name)
    episodes = sorted([f for f in os.listdir(task_dir) if f.endswith(".hdf5")])
    num_episodes = len(episodes)

    all_images = []
    all_states = []
    all_actions = []
    episode_ends = []
    total_steps = 0

    for i, ep_file in enumerate(episodes):
        src_path = os.path.join(task_dir, ep_file)
        with h5py.File(src_path, "r") as f:
            T = f["actions"].shape[0]

            # Image: agentview as head_camera, HWC uint8
            images = f["agentview_image"][:]  # [T, H, W, 3]

            # State: joint_pos(7) + normalized gripper(1) = 8D
            joint_pos = f["joint_pos"][:]          # [T, 7]
            gripper_qpos = f["gripper_qpos"][:]    # [T, 6]
            gripper_norm = gripper_qpos[:, 0:1] / 0.8
            state = np.concatenate([joint_pos, gripper_norm], axis=1).astype(np.float32)

            # Action: 7D OSC_POSE
            actions = f["actions"][:].astype(np.float32)

        # DP uses (T-1) transitions: state[:-1] → action[1:] shift
        # But for simplicity and to match the original code, keep them aligned
        all_images.append(images)
        all_states.append(state)
        all_actions.append(actions)

        total_steps += T
        episode_ends.append(total_steps)

        print(f"  [{i+1}/{num_episodes}] {ep_file}: {T} steps")

    # Stack all episodes
    all_images = np.concatenate(all_images, axis=0)      # [N, H, W, 3]
    all_states = np.concatenate(all_states, axis=0)       # [N, 8]
    all_actions = np.concatenate(all_actions, axis=0)     # [N, 7]
    episode_ends = np.array(episode_ends, dtype=np.int64)

    # Convert images: NHWC → NCHW
    all_images = np.moveaxis(all_images, -1, 1)  # [N, 3, H, W]

    print(f"\nTotal: {total_steps} steps from {num_episodes} episodes")
    print(f"Images: {all_images.shape}, States: {all_states.shape}, Actions: {all_actions.shape}")

    # Save as Zarr
    save_path = os.path.join(output_dir, f"{task_name}-{config_name}-{num_episodes}.zarr")
    if os.path.exists(save_path):
        import shutil
        shutil.rmtree(save_path)

    os.makedirs(output_dir, exist_ok=True)
    zarr_root = zarr.group(save_path)
    zarr_data = zarr_root.create_group("data")
    zarr_meta = zarr_root.create_group("meta")

    compressor = zarr.Blosc(cname="zstd", clevel=3, shuffle=1)

    zarr_data.create_dataset("head_camera", data=all_images,
                             chunks=(100, *all_images.shape[1:]),
                             overwrite=True, compressor=compressor)
    zarr_data.create_dataset("state", data=all_states,
                             chunks=(100, all_states.shape[1]),
                             dtype="float32", overwrite=True, compressor=compressor)
    zarr_data.create_dataset("action", data=all_actions,
                             chunks=(100, all_actions.shape[1]),
                             dtype="float32", overwrite=True, compressor=compressor)
    zarr_meta.create_dataset("episode_ends", data=episode_ends,
                             dtype="int64", overwrite=True, compressor=compressor)

    print(f"Saved to {save_path}")
    return save_path


def main():
    parser = argparse.ArgumentParser(description="Convert tactile data to DP Zarr format")
    parser.add_argument("--data_dir", default="./tactile_data",
                        help="Source data directory")
    parser.add_argument("--output_dir", default="./policy/DP/data",
                        help="Output directory for Zarr files")
    parser.add_argument("--task", default="all",
                        help="Task name or 'all'")
    parser.add_argument("--config_name", default="default")
    args = parser.parse_args()

    tasks = ["precision_grasp", "peg_insertion", "gentle_stack"] if args.task == "all" else [args.task]

    for task in tasks:
        task_dir = os.path.join(args.data_dir, task)
        if not os.path.exists(task_dir):
            print(f"Skipping {task}: no data at {task_dir}")
            continue

        print(f"\n{'='*50}")
        print(f"Converting {task}")
        print(f"{'='*50}")

        zarr_path = convert_task(task, args.data_dir, args.output_dir, args.config_name)

    print("\nDone! To train DP:")
    print(f"  cd policy/DP")
    print(f"  python train.py --config-name=robot_dp_tactile.yaml \\")
    print(f"    task.name={{task}} \\")
    print(f"    task.dataset.zarr_path=data/{{task}}-default-{{num}}.zarr \\")
    print(f"    training.seed=0 training.device=cuda:0")


if __name__ == "__main__":
    main()