| import argparse |
| import numpy as np |
| import imageio |
| import os |
| from omegaconf import OmegaConf |
| import torch |
| from tqdm import tqdm |
| from einops import rearrange |
| from torch_geometric.loader import DataLoader |
| from diffusers import AutoencoderKL, DDIMScheduler |
| from diffusers.utils.import_utils import is_xformers_available |
| from transformers import CLIPTextModel, CLIPTokenizer |
|
|
| from swomo.models.videoldm_unet import VideoLDMUNet3DConditionModel |
| from swomo.models.videoldm_controlnet import ControlNetModel |
| from swomo.pipelines.pipeline_conditional_animation import ConditionalAnimationPipeline |
| from swomo.pipelines.pipeline_controlnet_animation import ControlNetAnimationPipeline |
| from swomo.data.dataset import SurgicalDataset |
| from swomo.graph_encoder.graph_segclip_masked import GraphEncoder |
|
|
| def main(args, config): |
| savedir = f"{config.output_dir}" |
| if not os.path.exists(savedir): |
| os.makedirs(savedir) |
|
|
| class_embeddings_concat = (config.unet_graph_kwargs.get('class_embeddings_concat') if config.unet_graph_kwargs is not None else False) |
| class_embed_type = (config.unet_graph_kwargs.get('class_embed_type') if config.unet_graph_kwargs is not None else None) |
| time_embedding_dim = (config.unet_graph_kwargs.get('time_embedding_dim') if config.unet_graph_kwargs is not None else None) |
| ignore_mismatched_sizes = (config.unet_graph_kwargs.get('ignore_mismatched_sizes') if config.unet_graph_kwargs is not None else False) |
|
|
| |
| noise_scheduler = DDIMScheduler(**OmegaConf.to_container(config.noise_scheduler_kwargs)) |
| tokenizer = CLIPTokenizer.from_pretrained(config.pretrained_model_path, subfolder="tokenizer", use_safetensors=True) |
| text_encoder = CLIPTextModel.from_pretrained(config.pretrained_model_path, subfolder="text_encoder") |
| vae = AutoencoderKL.from_pretrained(config.finetuned_autoencoder_path if config.finetuned_autoencoder_path else config.pretrained_model_path, subfolder="vae", use_safetensors=True) |
| unet = VideoLDMUNet3DConditionModel.from_pretrained( |
| config.pretrained_model_path, |
| subfolder="unet", |
| variant=config.unet_additional_kwargs['variant'], |
| use_temporal=True, |
| temp_pos_embedding=config.unet_additional_kwargs['temp_pos_embedding'], |
| augment_temporal_attention=config.unet_additional_kwargs['augment_temporal_attention'], |
| n_frames=config.sampling_kwargs['n_frames'], |
| n_temp_heads=config.unet_additional_kwargs['n_temp_heads'], |
| first_frame_condition_mode=config.unet_additional_kwargs['first_frame_condition_mode'], |
| use_frame_stride_condition=config.unet_additional_kwargs['use_frame_stride_condition'], |
|
|
| class_embeddings_concat=class_embeddings_concat, |
| class_embed_type=class_embed_type, |
| time_embedding_dim=time_embedding_dim, |
| ignore_mismatched_sizes=ignore_mismatched_sizes, |
| use_safetensors=True |
| ) |
|
|
| if config.controlnet_path is not None: |
| controlnet = ControlNetModel.from_unet(unet) |
|
|
| |
| if config.unet_path is not None: |
| if os.path.isdir(config.unet_path): |
| unet_dict = VideoLDMUNet3DConditionModel.from_pretrained(config.unet_path) |
| m, u = unet.load_state_dict(unet_dict.state_dict(), strict=False) |
| assert len(u) == 0 |
| del unet_dict |
| else: |
| checkpoint_dict = torch.load(config.unet_path, map_location="cpu") |
| state_dict = checkpoint_dict["state_dict"] if "state_dict" in checkpoint_dict else checkpoint_dict |
| if config.unet_ckpt_prefix is not None: |
| state_dict = {k.replace(config.unet_ckpt_prefix, ''): v for k, v in state_dict.items()} |
| m, u = unet.load_state_dict(state_dict, strict=False) |
| assert len(u) == 0 |
|
|
| if config.controlnet_path is not None: |
| if os.path.isdir(config.controlnet_path): |
| controlnet_dict = ControlNetModel.from_pretrained(config.controlnet_path) |
| m, u = controlnet.load_state_dict(controlnet_dict.state_dict(), strict=False) |
| assert len(u) == 0 |
| del controlnet_dict |
|
|
| else: |
| raise NotImplementedError("ControlNet loading from non-directory path is not implemented yet. Please provide a directory path for ControlNet checkpoint.") |
|
|
|
|
| if is_xformers_available() and int(torch.__version__.split(".")[0]) < 2: |
| unet.enable_xformers_memory_efficient_attention() |
| if config.controlnet_path is not None: |
| controlnet.enable_xformers_memory_efficient_attention() |
|
|
| if config.controlnet_path is None: |
| pipeline = ConditionalAnimationPipeline( |
| vae=vae, text_encoder=text_encoder, tokenizer=tokenizer, unet=unet, scheduler=noise_scheduler) |
|
|
| else: |
| pipeline = ControlNetAnimationPipeline( |
| vae=vae, text_encoder=text_encoder, tokenizer=tokenizer, unet=unet, controlnet=controlnet, scheduler=noise_scheduler, |
| ) |
| pipeline.to("cuda") |
|
|
| if config.test_data.return_graph_emb: |
| if 'model_masked' in config.test_data: |
| m_graph_emb_masked = GraphEncoder(config.test_data.graph_input_dim, config.test_data.graph_hidden_dim, |
| config.test_data.graph_embedding_dim, config.test_data.trainable, |
| graph_conv_type = config.test_data.graph_conv_type, |
| graph_norm_type = config.test_data.graph_norm_type, |
| graph_encoder_ckpt = config.test_data.model_masked) |
| m_graph_emb_masked.to("cuda") |
| m_graph_emb_masked.eval() |
| if 'model_segclip' in config.test_data: |
| m_graph_emb_segclip = GraphEncoder(config.test_data.graph_input_dim, config.test_data.graph_hidden_dim, |
| config.test_data.graph_embedding_dim, config.test_data.trainable, |
| graph_conv_type = config.test_data.graph_conv_type, |
| graph_norm_type = config.test_data.graph_norm_type, |
| graph_encoder_ckpt = config.test_data.model_segclip) |
| m_graph_emb_segclip.to("cuda") |
| m_graph_emb_segclip.eval() |
|
|
| def get_embedding(scene_graph, embedding_type): |
| if embedding_type == 'masked': |
| graph_embeddings = m_graph_emb_masked(scene_graph) |
| elif embedding_type == 'segclip': |
| graph_embeddings = m_graph_emb_segclip(scene_graph) |
| elif embedding_type == 'combined': |
| graph_embeddings_masked = m_graph_emb_masked(scene_graph) |
| graph_embeddings_segclip = m_graph_emb_segclip(scene_graph) |
| graph_embeddings = torch.cat((graph_embeddings_masked, graph_embeddings_segclip), dim=-1) |
| return graph_embeddings |
| |
| |
| if config.frameinit_kwargs.enable: |
| pipeline.init_filter( |
| width = config.sampling_kwargs.width, |
| height = config.sampling_kwargs.height, |
| video_length = config.sampling_kwargs.n_frames, |
| filter_params = config.frameinit_kwargs.filter_params, |
| ) |
| |
| |
|
|
| test_dataset = SurgicalDataset(**config.test_data) |
| test_dataloader = DataLoader( |
| test_dataset, |
| shuffle=False, |
| batch_size=1, |
| num_workers=config.num_workers, |
| pin_memory=True, |
| ) |
|
|
| resume_sampling_idx = getattr(config, "resume_sampling", 0) or 0 |
| print(f"Length of test dataloader: {len(test_dataloader)}") |
| print(f"Resuming sampling from index {resume_sampling_idx}") |
|
|
| for idx, batch in tqdm(enumerate(test_dataloader), total=len(test_dataloader), desc="Sampling SWoMo:"): |
| |
| if idx >= resume_sampling_idx: |
| prompt = batch["text"] |
| |
| if config.test_data.return_graph_emb: |
| graph = batch.get('graph').to("cuda") |
| graph_emb = get_embedding(graph, config.test_data.embedding_type) |
| graph_emb = graph_emb.detach().squeeze() |
| else: |
| graph_emb = None |
|
|
| first_frame_paths = None |
| if config.unet_additional_kwargs['first_frame_condition_mode'] != "none": |
| first_frame_paths = batch["first_frame_path"] |
| |
| cond_video_paths = [None] * len(prompt) |
| if config.controlnet_path is not None and config.test_data.return_cond_videos: |
| cond_video_paths = batch["cond_video_path"] |
| cond_video_paths = [[cond_video_paths[i][0] for i in range(len(cond_video_paths))]] |
|
|
| sample = pipeline( |
| prompt, |
| first_frame_paths = first_frame_paths, |
| cond_video_frames_paths = cond_video_paths, |
| num_inference_steps = config.sampling_kwargs.steps, |
| guidance_scale_txt = config.sampling_kwargs.guidance_scale_txt, |
| guidance_scale_img = config.sampling_kwargs.guidance_scale_img, |
| width = config.sampling_kwargs.width, |
| height = config.sampling_kwargs.height, |
| video_length = config.sampling_kwargs.n_frames, |
| noise_sampling_method = config.unet_additional_kwargs['noise_sampling_method'], |
| noise_alpha = float(config.unet_additional_kwargs['noise_alpha']), |
| class_labels = graph_emb, |
| eta = config.sampling_kwargs.ddim_eta, |
| frame_stride = config.sampling_kwargs.frame_stride, |
| guidance_rescale = config.sampling_kwargs.guidance_rescale, |
| num_videos_per_prompt = config.sampling_kwargs.num_videos_per_prompt, |
| use_frameinit = config.frameinit_kwargs.enable, |
| frameinit_noise_level = config.frameinit_kwargs.noise_level, |
| camera_motion = config.frameinit_kwargs.camera_motion, |
| ).videos |
|
|
| current_batch = len(prompt) |
| sample = rearrange(sample, "b c t h w -> b t h w c") |
| |
| for bc in range(current_batch): |
| save_folder = os.path.join(config.output_dir, str(idx + bc).zfill(5)) |
| os.makedirs(save_folder, exist_ok=True) |
| seq = sample[bc] |
|
|
| for i, img in enumerate(seq): |
| img = (img * 255).numpy().astype(np.uint8) |
| imageio.imsave(os.path.join(save_folder, str(i).zfill(2)+".png"), img) |
| else: |
| continue |
|
|
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--inference_config", type=str, default="configs/inference/inference.yaml") |
| parser.add_argument("optional_args", nargs='*', default=[]) |
| args = parser.parse_args() |
|
|
| config = OmegaConf.load(args.inference_config) |
| if args.optional_args: |
| modified_config = OmegaConf.from_dotlist(args.optional_args) |
| config = OmegaConf.merge(config, modified_config) |
|
|
| main(args, config) |
|
|
