""" Preprocess LIBERO RLDS data for Ctrl-World training. Reads openvla/modified_libero_rlds TFRecords and converts to Ctrl-World format: - Images: 256x256 JPEG → center-crop to 5:3 → resize to 320x192 → SVD VAE encode - States: 8D RLDS observation → 7D absolute [pos(3), axis_angle(3), gripper_width(1)] - Text: language_instruction from RLDS Output: Ctrl-World dataset under dataset_example/libero/ Usage: cd /mnt/filesystem-g0/Dual-Dynamics-Models/Ctrl-World conda activate atm_ati_vdm # Single GPU: python scripts/preprocess_libero.py --svd_path checkpoints/svd # Multi-GPU: accelerate launch --num_processes 8 scripts/preprocess_libero.py --svd_path checkpoints/svd """ import argparse import glob import json import os import sys import cv2 import numpy as np import torch from tqdm import tqdm os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3" sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) SUITES = [ "libero_spatial_no_noops", "libero_goal_no_noops", "libero_object_no_noops", "libero_10_no_noops", ] TARGET_W, TARGET_H = 320, 192 SOURCE_SIZE = 256 CROP_H = round(SOURCE_SIZE * TARGET_H / TARGET_W) # 154 CROP_TOP = (SOURCE_SIZE - CROP_H) // 2 # 51 def parse_rlds_episodes(tfrecord_path): """Parse a TFRecord file into a list of episode dicts.""" import tensorflow as tf raw_ds = tf.data.TFRecordDataset(tfrecord_path) episodes = [] for raw_record in raw_ds: ex = tf.train.SequenceExample() ex.ParseFromString(raw_record.numpy()) ctx = ex.context.feature states = np.array(ctx["steps/observation/state"].float_list.value, dtype=np.float32) actions = np.array(ctx["steps/action"].float_list.value, dtype=np.float32) n_steps = len(ctx["steps/is_first"].int64_list.value) states = states.reshape(n_steps, 8) actions = actions.reshape(n_steps, 7) img_bytes_list = list(ctx["steps/observation/image"].bytes_list.value) wrist_bytes_list = list(ctx["steps/observation/wrist_image"].bytes_list.value) lang = ctx["steps/language_instruction"].bytes_list.value[0].decode("utf-8") file_path = ctx["episode_metadata/file_path"].bytes_list.value[0].decode("utf-8") episodes.append({ "states_8d": states, "actions": actions, "image_bytes": img_bytes_list, "wrist_bytes": wrist_bytes_list, "text": lang, "file_path": file_path, "n_steps": n_steps, }) return episodes def decode_and_resize(jpeg_bytes, tf_module): """Decode JPEG bytes, center-crop to 5:3 aspect, resize to TARGET_W x TARGET_H.""" img = tf_module.io.decode_jpeg(jpeg_bytes).numpy() # (256, 256, 3) cropped = img[CROP_TOP : CROP_TOP + CROP_H, :, :] # (154, 256, 3) resized = cv2.resize(cropped, (TARGET_W, TARGET_H), interpolation=cv2.INTER_CUBIC) return resized def state_8d_to_7d(states_8d): """Convert RLDS 8D state to Ctrl-World 7D. 8D: [ee_pos(3), ee_ori_axisangle(3), gripper_L, gripper_R] 7D: [ee_pos(3), ee_ori_axisangle(3), gripper_width] """ gripper_width = states_8d[:, 6:7] - states_8d[:, 7:8] return np.concatenate([states_8d[:, :6], gripper_width], axis=1) def vae_encode_frames(frames, vae, device, batch_size=32): """Encode (T, H, W, 3) uint8 frames to VAE latents (T, 4, 24, 40).""" x = torch.from_numpy(frames).float().permute(0, 3, 1, 2) / 255.0 * 2 - 1 latents = [] with torch.no_grad(): for i in range(0, len(x), batch_size): batch = x[i : i + batch_size].to(device) z = vae.encode(batch).latent_dist.sample() * vae.config.scaling_factor latents.append(z.cpu()) return torch.cat(latents, dim=0) def process_episode(ep, episode_id, split, output_dir, vae, device, tf_module, vae_batch_size=32): """Process a single RLDS episode into Ctrl-World format.""" latent_check = os.path.join(output_dir, "latent_videos", split, episode_id, "0.pt") if os.path.exists(latent_check): return "skip" T = ep["n_steps"] states_7d = state_8d_to_7d(ep["states_8d"]) agentview_frames = np.zeros((T, TARGET_H, TARGET_W, 3), dtype=np.uint8) wrist_frames = np.zeros((T, TARGET_H, TARGET_W, 3), dtype=np.uint8) for t in range(T): agentview_frames[t] = decode_and_resize(ep["image_bytes"][t], tf_module) wrist_frames[t] = decode_and_resize(ep["wrist_bytes"][t], tf_module) agent_latent = vae_encode_frames(agentview_frames, vae, device, vae_batch_size) wrist_latent = vae_encode_frames(wrist_frames, vae, device, vae_batch_size) zero_latent = torch.zeros_like(agent_latent) latent_dir = os.path.join(output_dir, "latent_videos", split, episode_id) os.makedirs(latent_dir, exist_ok=True) torch.save(agent_latent, os.path.join(latent_dir, "0.pt")) torch.save(zero_latent, os.path.join(latent_dir, "1.pt")) torch.save(wrist_latent, os.path.join(latent_dir, "2.pt")) ann = { "texts": [ep["text"]], "episode_id": episode_id, "video_length": T, "videos": [], "latent_videos": [ {"latent_video_path": f"latent_videos/{split}/{episode_id}/{s}.pt"} for s in [0, 1, 2] ], "states": states_7d.tolist(), "observation.state.cartesian_position": states_7d[:, :6].tolist(), "observation.state.gripper_position": states_7d[:, 6].tolist(), } ann_dir = os.path.join(output_dir, "annotation", split) os.makedirs(ann_dir, exist_ok=True) with open(os.path.join(ann_dir, f"{episode_id}.json"), "w") as f: json.dump(ann, f, indent=2) return "ok" def main(): parser = argparse.ArgumentParser() parser.add_argument("--rlds_dir", default="raw_data/modified_libero_rlds") parser.add_argument("--output_dir", default="dataset_example/libero") parser.add_argument("--svd_path", default="checkpoints/svd") parser.add_argument("--suites", nargs="+", default=None) parser.add_argument("--vae_batch_size", type=int, default=32) parser.add_argument("--val_ratio", type=float, default=0.1) args = parser.parse_args() suites = args.suites or SUITES import tensorflow as tf try: from accelerate import Accelerator accelerator = Accelerator() device = accelerator.device local_rank = accelerator.process_index world_size = accelerator.num_processes is_main = accelerator.is_main_process except Exception: device = torch.device("cuda" if torch.cuda.is_available() else "cpu") local_rank = 0 world_size = 1 is_main = True from diffusers.models import AutoencoderKLTemporalDecoder vae = AutoencoderKLTemporalDecoder.from_pretrained(args.svd_path, subfolder="vae").to(device) vae.eval() vae.requires_grad_(False) if is_main: print(f"VAE loaded on {device}") work = [] for suite in suites: suite_dir = os.path.join(args.rlds_dir, suite) tfrecords = sorted(glob.glob(os.path.join(suite_dir, "1.0.0", "*.tfrecord*"))) if is_main: print(f"Scanning {suite}: {len(tfrecords)} shards") suite_short = suite.replace("_no_noops", "") global_ep_idx = 0 for tfr in tfrecords: episodes = parse_rlds_episodes(tfr) for ep in episodes: work.append((ep, suite_short, global_ep_idx)) global_ep_idx += 1 if is_main: print(f" {suite}: {global_ep_idx} episodes total") n_total = len(work) if is_main: print(f"Total episodes across all suites: {n_total}") ok, skip, err = 0, 0, 0 for idx in tqdm(range(n_total), desc="Processing", disable=not is_main): if idx % world_size != local_rank: continue ep, suite_short, ep_idx = work[idx] n_suite = sum(1 for w in work if w[1] == suite_short) n_val = max(1, int(n_suite * args.val_ratio)) split = "val" if ep_idx >= n_suite - n_val else "train" episode_id = f"{suite_short}_{ep_idx:04d}" try: result = process_episode( ep, episode_id, split, args.output_dir, vae, device, tf, args.vae_batch_size, ) if result == "ok": ok += 1 elif result == "skip": skip += 1 except Exception as e: err += 1 if is_main: print(f" ERROR {episode_id}: {e}") if is_main: print(f"\nDone: {ok} processed, {skip} skipped, {err} errors") sample_latent = glob.glob(os.path.join(args.output_dir, "latent_videos", "train", "*", "0.pt")) if sample_latent: t = torch.load(sorted(sample_latent)[0], map_location="cpu") print(f"Sample latent shape: {t.shape}") sample_ann = glob.glob(os.path.join(args.output_dir, "annotation", "train", "*.json")) if sample_ann: with open(sorted(sample_ann)[0]) as f: ann = json.load(f) print(f"Sample: ep={ann['episode_id']}, T={ann['video_length']}, text='{ann['texts'][0][:50]}'") if __name__ == "__main__": main()