import copy import os import re import torch, os, imageio, argparse, imageio_ffmpeg from torchvision.transforms import v2 from einops import rearrange import lightning as pl import pandas as pd from diffsynth import WanVideoPipeline, ModelManager, load_state_dict import torchvision from PIL import Image import numpy as np import random import json import torch.nn as nn import torch.nn.functional as F import shutil import open3d as o3d import h5py import cv2 import math from robotwin_utils import rgbd_to_pointcloud, image_to_float_array, sample_frame_indices, get_instructions, find_data class TextVideoDataset(torch.utils.data.Dataset): def __init__(self, base_path, metadata_path, max_num_frames=81, frame_interval=1, num_frames=81, height=240, width=320, is_i2v=False): # metadata = pd.read_csv(metadata_path) # self.path = [os.path.join(base_path, "train", file_name) for file_name in metadata["file_name"]] # self.text = metadata["text"].to_list() self.data_list = find_data(base_path) self.max_num_frames = max_num_frames self.frame_interval = frame_interval self.num_frames = num_frames self.height = height self.width = width self.is_i2v = is_i2v self.frame_process = v2.Compose([ # v2.CenterCrop(size=(height, width)), # v2.Resize(size=(height, width), antialias=True), v2.ToTensor(), v2.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), ]) def __getitem__(self, data_id): data_dict = self.data_list[data_id] instructions_file_path = data_dict["instructions_path"] instructions_list = get_instructions(instructions_file_path, num=3) text = instructions_list[0] # video_path = os.path.join(data_dict["data_path"], data_dict["episode_name"]) # text = self.text[data_id] # path = self.data_list[data_id] # print(1) metadata = pd.read_json(os.path.join(data_dict["data_path"], f"{data_dict['episode_name']}.json")) out_dict=dict() out_dict["cache_path"] = data_dict["cache_path"] out_dict["text"] = text out_dict["cam"] = dict() num_frames = int(metadata[list(metadata.keys())[0]]["num_frames"]) # index_list = sample_frame_indices(num_frames, self.num_frames) # index_list= np.arange(0, self.num_frames, self.frame_interval) index_list = list(range(0, self.num_frames, self.frame_interval)) jointdata = np.load(data_dict["jointdata_path"], allow_pickle=True) joint_action = jointdata["joint_action"].item() left_arm = np.stack(joint_action["left_arm"], axis=0).astype(np.float32) left_gripper = np.stack(joint_action["left_gripper"], axis=0).astype(np.float32)[..., None] right_arm = np.stack(joint_action["right_arm"], axis=0).astype(np.float32) right_gripper = np.stack(joint_action["right_gripper"], axis=0).astype(np.float32)[..., None] action = np.concatenate([left_arm, left_gripper, right_arm, right_gripper], axis=-1) action = action[index_list] out_dict["action"] = action for cam_name, cam_data in metadata.items(): # if cam_name == "surround_camera_11": intrinsic_cv = np.array(cam_data["intrinsic_cv"]).reshape(3, 3) extrinsic_cv = np.eye(4, dtype=np.float64) extrinsic_cv[:3,:] = np.array(cam_data["extrinsic_cv"])[:3,:] rgb_mp4_path = os.path.join(data_dict["data_path"], data_dict["episode_name"], f"{cam_name}.mp4") depth_mp4_path = os.path.join(data_dict["data_path"], data_dict["episode_name"], f"{cam_name}_depth.mp4") if not os.path.exists(rgb_mp4_path) or not os.path.exists(depth_mp4_path): print(f"RGBD video path {rgb_mp4_path} or {depth_mp4_path} does not exist, skip.") raise FileNotFoundError(f"RGBD video path {rgb_mp4_path} or {depth_mp4_path} does not exist, skip.") # import time # start_time = time.time() # input_params = [ # "-hwaccel", "cuvid", # "-c:v", "h264_cuvid" # ] input_params = [] # rgb_reader = imageio.get_reader(rgb_mp4_path, 'ffmpeg') rgb_reader = imageio_ffmpeg.read_frames(rgb_mp4_path, input_params=input_params) # depth_reader = imageio.get_reader(depth_mp4_path, 'ffmpeg') depth_reader = imageio_ffmpeg.read_frames(depth_mp4_path, input_params=input_params) rgb_frames = np.zeros((self.num_frames, self.height, self.width, 3), dtype=np.float32) depth_frames = np.zeros((self.num_frames, self.height, self.width, 3), dtype=np.float32) rgb_meta, depth_meta = next(rgb_reader), next(depth_reader) # print(rgb_meta, depth_meta) # {'ffmpeg_version': '7.0.2-static https://johnvansickle.com/ffmpeg/ built with gcc 8 (Debian 8.3.0-6)', 'codec': 'h264', 'pix_fmt': 'yuv420p(progressive)', 'fps': 30.0, 'source_size': (832, 480), 'size': (832, 480), 'rotate': 0, 'duration': 4.73} rgb_size = (rgb_meta["size"][1], rgb_meta["size"][0], 3) depth_size = (depth_meta["size"][1], depth_meta["size"][0], 3) assert rgb_size == (self.height, self.width, 3), f"RGB size {rgb_size} does not match expected size {(self.height, self.width, 3)}" assert depth_size == (self.height, self.width, 3), f"Depth size {depth_size} does not match expected size {(self.height, self.width, 3)}" for rgb_frame, depth_frame, i in zip(rgb_reader, depth_reader, range(num_frames)): # read frame from the generator # print(rgb_frame) if i in index_list: select_idx = index_list.index(i) rgb_frames[select_idx] = np.frombuffer(rgb_frame, dtype=np.uint8).reshape(rgb_size) depth_frames[select_idx] = np.frombuffer(depth_frame, dtype=np.uint8).reshape(depth_size) # end_time = time.time() # print(f"Reading frames time: {end_time - start_time:.5f}s") rgb_first_frame = rgb_frames[0].copy().astype(np.uint8) # H W C rgb_frames = torch.from_numpy(rgb_frames).float().permute(0, 3, 1, 2) # T H W C -> T C H W rgb_frames /= 255.0 rgb_frames = self.frame_process(rgb_frames) # Normalize rgb_frames = rgb_frames.permute(1, 0, 2, 3) # T C H W -> C T H W depth_frames = image_to_float_array(depth_frames, scale_factor=256000.0) depth_frames = torch.from_numpy(depth_frames).unsqueeze(0) # T H W -> 1 T H W # break cam_dict = dict() cam_dict["intrinsic"] = intrinsic_cv cam_dict["extrinsic"] = extrinsic_cv ## used to load original rgb and depth when testing ## cam_dict["rgb_mp4_path"] = rgb_mp4_path cam_dict["depth_mp4_path"] = depth_mp4_path cam_dict["num_frames"] = int(self.num_frames) cam_dict["frame_interval"] = int(self.frame_interval) cam_dict["rgb"] = rgb_frames cam_dict["rgb_first_frame"] = rgb_first_frame cam_dict["depth"] = depth_frames # [1, 81, 480, 832] # print(type(depth_frames), depth_frames.shape, depth_frames.min(), depth_frames.max()) # assert 0 out_dict["cam"][cam_name] = cam_dict return out_dict def __len__(self): return len(self.data_list) def robust_depth_range(depth_tensor: torch.Tensor, q_low=1.0, q_high=99.0): depth_tensor = depth_tensor.to(torch.float32) valid = depth_tensor[depth_tensor > 1e-6] if valid.numel() == 0: return 1e-3, 1.0 lo = torch.nanquantile(valid, q_low / 100.0).item() hi = torch.nanquantile(valid, q_high / 100.0).item() if hi - lo < 1e-6: hi = lo + 1e-3 return max(lo, 1e-4), max(hi, lo + 1e-3) class LightningModelForDataProcess(pl.LightningModule): def __init__(self, text_encoder_path, vae_path, image_encoder_path=None, tiled=False, tile_size=(34, 34), tile_stride=(18, 16), overwrite=True): super().__init__() model_path = [text_encoder_path, vae_path] if image_encoder_path is not None: model_path.append(image_encoder_path) model_manager = ModelManager(torch_dtype=torch.bfloat16, device="cpu") model_manager.load_models(model_path) self.pipe = WanVideoPipeline.from_model_manager(model_manager) self.pipe.torch_dtype = model_manager.torch_dtype self.pipe.vae.dtype = model_manager.torch_dtype self.pipe.vae.to(model_manager.device) print(f"Loaded pipeline to {model_manager.device} with dtype {model_manager.torch_dtype}") # assert 0 self.overwrite = overwrite self.tiler_kwargs = {"tiled": tiled, "tile_size": tile_size, "tile_stride": tile_stride} self.debug_flag = True def test_step(self, batch, batch_idx): self.pipe.device = self.device # print(f"batch.keys() {batch.keys()}") # batch.keys() dict_keys(['cache_path', 'text', 'cam']) # for key, value in batch.items(): # print(f"{key}: {type(value)}") # cache_path: # text: # cam: text = batch["text"][0] cam = batch["cam"] cache_path = batch["cache_path"][0] action = batch["action"] # data/pp_tasks_/place_a2b_left/ARX-X5+ARX-X5/demo_randomized/cache/episode0/ to data/pp_tasks_/place_a2b_left/ARX-X5+ARX-X5/demo_randomized/cache_wan2_2/episode0/ cache_path = cache_path.replace("/cache/episode", "/cache_wan2_2/episode") if self.debug_flag: print(f"Processing data for text: {text}, cache_path: {cache_path}") os.makedirs(cache_path, exist_ok=True) prompt_emb_pth_path = os.path.join(cache_path, "prompt_emb.pth") # if not os.path.exists(prompt_emb_pth_path): # prompt # delete the torch.save file if exists if self.overwrite and os.path.exists(prompt_emb_pth_path): os.remove(prompt_emb_pth_path) prompt_emb = self.pipe.encode_prompt(text) torch.save(prompt_emb, prompt_emb_pth_path) depth_min = 0.3328 #3327 depth_max = 3.0000 log_depth_bounds = (math.log(depth_min), math.log(depth_max)) for cam_name, cam_data in cam.items(): cam_emb_pth_path = os.path.join(cache_path, f"{cam_name}_emb.pth") if self.overwrite and os.path.exists(cam_emb_pth_path): os.remove(cam_emb_pth_path) if not os.path.exists(cam_emb_pth_path): # video video = cam_data["rgb"] print("video shape : ", video.shape) rgb_mp4_path = cam_data["rgb_mp4_path"] depth_mp4_path = cam_data["depth_mp4_path"] num_frames = cam_data["num_frames"] frame_interval = cam_data["frame_interval"] video = video.to(dtype=self.pipe.torch_dtype, device=self.pipe.device) #### encode videos #### video_frames = video[0] # [3, T, H, W] num_frames = video_frames.shape[1] height, width = video_frames.shape[2], video_frames.shape[3] rgb_latent = self.pipe.vae.encode(videos=[video_frames])[0] depth_videos = cam_data["depth"].to(dtype=self.pipe.torch_dtype, device=self.pipe.device) # [1, 1, T, H, W] depth_frames = depth_videos.squeeze(0).clamp_min(1e-4) log_depth = torch.log(depth_frames) log_depth = torch.clamp(log_depth, min=log_depth_bounds[0], max=log_depth_bounds[1]) denom = (log_depth_bounds[1] - log_depth_bounds[0]) + 1e-6 depth_norm = (log_depth - log_depth_bounds[0]) / denom depth_norm = depth_norm * 2 - 1 # assert 0 depth_video_frames = depth_norm.repeat(3, 1, 1, 1) # [3, T, H, W] # print(depth_video_frames.shape) # print(depth_video_frames.min()) # print(depth_video_frames.max()) # assert 0 # def decode_video(latent, to_numpy=True): # frames = self.pipe.decode_video(latent) # # if self. # # print(f"Decoded frames shape (C H W T): {frames.shape}") # frames = rearrange(frames, "N C T H W -> N T C H W") # frames = ((frames.float() + 1) * 127.5).clip(0, 255) # if to_numpy: # frames = frames.cpu().numpy().astype(np.uint8) # return frames depth_latent = self.pipe.vae.encode(videos=[depth_video_frames])[0] # print("depth_latent.shape : ",depth_latent.shape) # 48 21 15 20 # depth_recon = decode_video([depth_latent]) # # print(depth_recon.shape) # # print(depth_video_frames.shape) # # assert 0 # # def tensor_to_uint8(img_tensor): # # img_tensor = img_tensor.detach().cpu().float() # # img_tensor = (img_tensor + 1) / 2 # back to [0,1] # # img_tensor = img_tensor.clamp(0, 1) # # return (img_tensor * 255).byte() # print(" depth video frames shape ", depth_video_frames.shape) # print("depth_recon : ", depth_recon.shape) # def save_depth_video(tensor_frames, name, fps=5): # frames = tensor_frames.float().cpu().numpy() # T H W C # # input() # video_path = os.path.join(f"{name}.mp4") # imageio.mimwrite(video_path, frames, fps=fps) # save_depth_video(depth_video_frames.permute(1,2,3,0), "depth_input") # save_depth_video(torch.tensor(depth_recon).squeeze(0).permute(0,2,3,1), "depth_recon") # assert 0 data = { "rgb_latent": rgb_latent, # [C_vace, T_latent, H_latent, W_latent] "depth_latent": depth_latent, # [C_vace, T_latent, H_latent, W_latent] # "rgb_original": video_frames, # 3, T, H, W # "depth_original": depth_videos, # 1, T , H, W before log norm "rgb_mp4_path":rgb_mp4_path, "depth_mp4_path":depth_mp4_path, "num_frames": num_frames, "frame_interval": frame_interval, "intrinsic": cam_data["intrinsic"][0], # [3, 3] "extrinsic": cam_data["extrinsic"][0], # [4, 4] "log_depth_bounds": log_depth_bounds, # tuple "action": action } if self.debug_flag == True: for key, value in data.items(): if isinstance(value, torch.Tensor): print(f"{key}: type {type(value)}, shape {value.shape}, dtype {value.dtype}, device {value.device}") else: print(f"{key}: type {type(value)}, value {value}") self.debug_flag = False # assert 0 torch.save(data, cam_emb_pth_path) else: print(f"File {cam_emb_pth_path} already exists, skipping.") class Camera(object): def __init__(self, c2w): c2w_mat = np.array(c2w).reshape(4, 4) self.c2w_mat = c2w_mat self.w2c_mat = np.linalg.inv(c2w_mat) if __name__ == "__main__": import argparse parser = argparse.ArgumentParser( description="Preprocess RobotWin (depth) videos into Wan2.2 latent cache (*.pth).") parser.add_argument("--data_dir", required=True, help="Extracted dataset root for this source (see the dataset README).") parser.add_argument("--model_dir", default="./model_weights/Wan-AI/Wan2.2-TI2V-5B", help="Dir holding Wan2.2 VAE (Wan2.2_VAE.pth), the T5 text encoder " "(models_t5_umt5-xxl-enc-bf16.safetensors or .pth) and the " "google/umt5-xxl/ tokenizer folder. Download from Wan-AI/Wan2.2-TI2V-5B.") parser.add_argument("--num_frames", type=int, default=81) parser.add_argument("--height", type=int, default=240) parser.add_argument("--width", type=int, default=320) parser.add_argument("--num_workers", type=int, default=2) args = parser.parse_args() # locate the T5 text-encoder weight (.safetensors preferred, .pth fallback) text_encoder_path = None for _name in ("models_t5_umt5-xxl-enc-bf16.safetensors", "models_t5_umt5-xxl-enc-bf16.pth"): _p = os.path.join(args.model_dir, _name) if os.path.exists(_p): text_encoder_path = _p break if text_encoder_path is None: raise FileNotFoundError(f"T5 text encoder not found under {args.model_dir}") vae_path = os.path.join(args.model_dir, "Wan2.2_VAE.pth") text_video_dataset = TextVideoDataset( base_path=args.data_dir, metadata_path="", max_num_frames=args.num_frames, frame_interval=1, num_frames=args.num_frames, height=args.height, width=args.width, is_i2v=False, ) text_video_dataloader = torch.utils.data.DataLoader( text_video_dataset, shuffle=False, batch_size=1, num_workers=args.num_workers, prefetch_factor=1, pin_memory=True, pin_memory_device="cuda", ) data_preprocess_model = LightningModelForDataProcess( text_encoder_path=text_encoder_path, vae_path=vae_path, image_encoder_path=None, ) trainer = pl.Trainer( accelerator="gpu", devices="auto", default_root_dir=args.data_dir, ) trainer.test(data_preprocess_model, text_video_dataloader)