Upload folder using huggingface_hub

inference_eval.py

@@ -0,0 +1,237 @@
+import json
+import os
+import tqdm
+import numpy as np
+import torch
+from diffusers import (AutoencoderKL, CogVideoXDDIMScheduler, DDIMScheduler,
+    DPMSolverMultistepScheduler,
+    EulerAncestralDiscreteScheduler, EulerDiscreteScheduler,
+    PNDMScheduler)
+from transformers import T5EncoderModel, T5Tokenizer
+from omegaconf import OmegaConf
+from PIL import Image
+import torch.nn.functional as F
+from einops import rearrange
+import cv2
+import decord
+
+from robomaster.models.transformer3d import CogVideoXTransformer3DModel
+from robomaster.models.autoencoder_magvit import AutoencoderKLCogVideoX
+from robomaster.pipeline.pipeline_cogvideox_inpaint import CogVideoX_Fun_Pipeline_Inpaint
+from robomaster.utils.utils import get_image_to_video_latent, save_videos_grid
+from utils import *
+
+# Low gpu memory mode, this is used when the GPU memory is under 16GB
+low_gpu_memory_mode = False
+
+# Model path
+model_name              = "ckpts/CogVideoX-Fun-V1.5-5b-InP"
+transformer_path        = "ckpts/RoboMaster"
+
+# Choose the sampler in "Euler" "Euler A" "DPM++" "PNDM" "DDIM_Cog" and "DDIM_Origin"
+sampler_name            = "DDIM_Origin"
+
+# If you want to generate ultra long videos, please set partial_video_length as the length of each sub video segment
+partial_video_length    = None
+overlap_video_length    = 4
+
+# Use torch.float16 if GPU does not support torch.bfloat16
+# ome graphics cards, such as v100, 2080ti, do not support torch.bfloat16
+weight_dtype            = torch.bfloat16
+
+# Configs
+negative_prompt         = "The video is not of a high quality, it has a low resolution. Watermark present in each frame. The background is solid. Strange body and strange trajectory. Distortion. "
+guidance_scale          = 6.0
+seed                    = 43
+num_inference_steps     = 50
+video_length            = 37
+fps                     = 12
+validation_image_path   = "eval_metrics/results/bridge_eval_gt"
+save_path               = "samples/bridge_eval_ours"
+
+# Get Transformer
+transformer = CogVideoXTransformer3DModel.from_pretrained_2d(
+    transformer_path,
+    low_cpu_mem_usage=True,
+    finetune_init=False,
+).to(weight_dtype)
+
+# Get Vae
+vae = AutoencoderKLCogVideoX.from_pretrained(
+    model_name, 
+    subfolder="vae"
+).to(weight_dtype)
+
+text_encoder = T5EncoderModel.from_pretrained(
+    model_name, subfolder="text_encoder", torch_dtype=weight_dtype
+)
+
+# Get Scheduler
+Choosen_Scheduler = scheduler_dict = {
+    "Euler": EulerDiscreteScheduler,
+    "Euler A": EulerAncestralDiscreteScheduler,
+    "DPM++": DPMSolverMultistepScheduler, 
+    "PNDM": PNDMScheduler,
+    "DDIM_Cog": CogVideoXDDIMScheduler,
+    "DDIM_Origin": DDIMScheduler,
+}[sampler_name]
+scheduler = Choosen_Scheduler.from_pretrained(
+    model_name, 
+    subfolder="scheduler"
+)
+
+pipeline = CogVideoX_Fun_Pipeline_Inpaint.from_pretrained(
+    model_name,
+    vae=vae,
+    text_encoder=text_encoder,
+    transformer=transformer,
+    scheduler=scheduler,
+    torch_dtype=weight_dtype
+)
+
+if low_gpu_memory_mode:
+    pipeline.enable_sequential_cpu_offload()
+else:
+    pipeline.enable_model_cpu_offload()
+
+# If you want to generate from text, please set the validation_image_start = None and validation_image_end = None
+validation_images = [validation_image for validation_image in sorted(os.listdir(validation_image_path)) if validation_image.endswith('.png')]
+vae_scale_factor_spatial = (2 ** (len(vae.config.block_out_channels) - 1) if vae is not None else 8)
+if not os.path.exists(save_path):
+    os.makedirs(save_path, exist_ok=True)
+generator = torch.Generator(device="cuda").manual_seed(seed)
+
+for validation_image in tqdm.tqdm(validation_images):
+
+    if os.path.exists(os.path.join(save_path, validation_image.replace('.png','.mp4'))):
+        continue
+
+    validation_image_start  = os.path.join(validation_image_path, validation_image)
+    validation_image_end    = None
+    image                   = Image.open(validation_image_start).convert("RGB")
+    sample_size_ori         = (image.size[1], image.size[0])
+    sample_size             = (round(image.size[1]/8)*8, round(image.size[0]/8)*8)
+    image                   = image.resize(sample_size)
+    prompt_path             = validation_image_start.replace('.png', '.txt')
+    with open(prompt_path, 'r') as file: prompt = file.readline().strip()
+    obj_tracking_path     = os.path.join(validation_image_path, validation_image.replace('.png', '_obj.npy'))
+    robot_tracking_path     = os.path.join(validation_image_path, validation_image.replace('.png', '_robot.npy'))
+    
+    video_length = int((video_length - 1) // vae.config.temporal_compression_ratio * vae.config.temporal_compression_ratio) + 1 if video_length != 1 else 1
+    latent_frames = (video_length - 1) // vae.config.temporal_compression_ratio + 1
+    if video_length != 1 and transformer.config.patch_size_t is not None and latent_frames % transformer.config.patch_size_t != 0:
+        additional_frames = transformer.config.patch_size_t - latent_frames % transformer.config.patch_size_t
+        video_length += additional_frames * vae.config.temporal_compression_ratio
+    input_video, input_video_mask, clip_image = get_image_to_video_latent(validation_image_start, validation_image_end, video_length=video_length, sample_size=sample_size)
+
+    points_obj = process_traj(obj_tracking_path, video_length, [sample_size_ori[0], sample_size_ori[1]])
+    points_obj = torch.tensor(points_obj)
+    points_obj = (points_obj / vae_scale_factor_spatial).int()
+
+    points_robot = process_traj(robot_tracking_path, video_length, [sample_size_ori[0], sample_size_ori[1]])
+    points_robot = torch.tensor(points_robot)
+    points_robot = (points_robot / vae_scale_factor_spatial).int()
+
+    mask_obj = torch.from_numpy(np.load(os.path.join(validation_image_path, validation_image.replace('.png', '_obj_mask.npy'))))
+    diameter_obj = max(int(torch.sqrt(mask_obj.sum()) / vae_scale_factor_spatial), 2)
+
+    with torch.no_grad():        
+        
+        latents_obj = vae.encode((input_video[:,:,0].unsqueeze(2)*2-1).to(dtype=weight_dtype, device='cuda'))[0]
+        latents_obj = latents_obj.sample()
+        latents_obj = latents_obj * vae.config.scaling_factor
+
+        mask_obj = F.interpolate(
+            mask_obj[None, None, None].float(),
+            size=latents_obj.shape[2:],
+            mode='trilinear',
+            align_corners=False
+        )
+
+        ground_sam_robot_path = './robot'
+        latents_robot = torch.load(os.path.join(ground_sam_robot_path, 'bridge.pth'))
+        mask_robot = torch.from_numpy(np.load(os.path.join(ground_sam_robot_path, 'bridge_mask.npy')))
+        diameter_robot = max(int(torch.sqrt(mask_robot.sum()) / 2 / vae_scale_factor_spatial), 2)
+        latents_robot = latents_robot.to(device=latents_obj.device, dtype=weight_dtype)
+        mask_robot = F.interpolate(
+            mask_robot[None, None, None].float(),
+            size=latents_robot.shape[2:],
+            mode='trilinear',
+            align_corners=False
+        )
+
+        transit_start, transit_end = np.load(os.path.join(validation_image_path, validation_image.replace('.png', '_transit.npy')))
+        video_path = os.path.join(validation_image_path, validation_image.replace('.png', '.mp4'))
+        cap = cv2.VideoCapture(video_path)
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        ctx = decord.cpu(0)
+        reader = decord.VideoReader(video_path, ctx=ctx, height=height, width=width)
+        transit_start = int(transit_start * video_length / len(reader))
+        transit_end = int(transit_end * video_length / len(reader))
+        transit_start_latent = transit_start // vae.config.temporal_compression_ratio
+        transit_end_latent = transit_end // vae.config.temporal_compression_ratio
+        if transit_end >= (video_length - 3):
+            transit_end_latent = latent_frames
+
+        # pre-interaction
+        flow_latents = sample_flowlatents(
+            latents_robot, 
+            torch.zeros_like(latents_obj).repeat(1,1,latent_frames,1,1),
+            mask_robot,
+            points_robot,
+            diameter_robot,
+            0,
+            transit_start_latent,
+        )
+
+        # interaction
+        flow_latents = sample_flowlatents(
+            latents_obj, 
+            flow_latents,
+            mask_obj,
+            points_obj,
+            diameter_obj,
+            transit_start_latent,
+            transit_end_latent,
+        )
+
+        # post-interaction
+        flow_latents = sample_flowlatents(
+            latents_robot, 
+            flow_latents,
+            mask_robot,
+            points_robot,
+            diameter_robot,
+            transit_end_latent,
+            latent_frames,
+        )
+
+        flow_latents = rearrange(flow_latents, "b c f h w -> b f c h w")
+
+        sample = pipeline(
+            prompt, 
+            num_frames = video_length,
+            negative_prompt = negative_prompt,
+            height      = sample_size[0],
+            width       = sample_size[1],
+            generator   = generator,
+            guidance_scale = guidance_scale,
+            num_inference_steps = num_inference_steps,
+            video        = input_video,
+            mask_video   = input_video_mask,
+            flow_latents = flow_latents,
+        ).videos
+
+    sample = F.interpolate(
+        sample, 
+        size=torch.Size([video_length, sample_size_ori[0], sample_size_ori[1]]), 
+        mode='trilinear', 
+        align_corners=False
+    )
+
+    # save files
+    video_chunk = (rearrange(sample[0], "c f h w -> f h w c").numpy()*255).astype(np.uint8)
+    save_video_name = os.path.join(save_path, os.path.basename(validation_image_start).split('.png')[0])
+    save_images2video(video_chunk, save_video_name, fps=12) 
+    os.system(f'cp -r {prompt_path} {save_path}')