Add files using upload-large-folder tool

exp_code/1_benchmark/CausVid/causvid/bidirectional_trajectory_pipeline.py

@@ -0,0 +1,47 @@
+from causvid.models.model_interface import (
+    InferencePipelineInterface,
+    DiffusionModelInterface,
+    TextEncoderInterface
+)
+from causvid.scheduler import SchedulerInterface
+from typing import List
+import torch
+
+
+class BidirectionalInferenceWrapper(InferencePipelineInterface):
+    def __init__(self, denoising_step_list: List[int],
+                 scheduler: SchedulerInterface,
+                 generator: DiffusionModelInterface, **kwargs):
+        super().__init__()
+        self.scheduler = scheduler
+        self.generator = generator
+        self.denoising_step_list = denoising_step_list
+
+    def inference_with_trajectory(self, noise: torch.Tensor, conditional_dict: dict) -> torch.Tensor:
+        output_list = [noise]
+
+        # initial point
+        noisy_image_or_video = noise
+
+        # use the last n-1 timesteps to simulate the generator's input
+        for index, current_timestep in enumerate(self.denoising_step_list[:-1]):
+            pred_image_or_video = self.generator(
+                noisy_image_or_video=noisy_image_or_video,
+                conditional_dict=conditional_dict,
+                timestep=torch.ones(
+                    noise.shape[:2], dtype=torch.long, device=noise.device) * current_timestep
+            )  # [B, F, C, H, W]
+
+            # TODO: Change backward simulation for causal video
+            next_timestep = self.denoising_step_list[index + 1] * torch.ones(
+                noise.shape[:2], dtype=torch.long, device=noise.device)
+            noisy_image_or_video = self.scheduler.add_noise(
+                pred_image_or_video.flatten(0, 1),
+                torch.randn_like(pred_image_or_video.flatten(0, 1)),
+                next_timestep.flatten(0, 1)
+            ).unflatten(0, noise.shape[:2])
+            output_list.append(noisy_image_or_video)
+
+        # [B, T, F, C, H, W]
+        output = torch.stack(output_list, dim=1)
+        return output

exp_code/1_benchmark/CausVid/causvid/data.py

@@ -0,0 +1,74 @@
+from causvid.ode_data.create_lmdb_iterative import get_array_shape_from_lmdb, retrieve_row_from_lmdb
+from torch.utils.data import Dataset
+import numpy as np
+import torch
+import lmdb
+
+
+class TextDataset(Dataset):
+    def __init__(self, data_path):
+        self.texts = []
+        with open(data_path, "r") as f:
+            for line in f:
+                self.texts.append(line.strip())
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        return self.texts[idx]
+
+
+class ODERegressionDataset(Dataset):
+    def __init__(self, data_path, max_pair=int(1e8)):
+        self.data_dict = torch.load(data_path, weights_only=False)
+        self.max_pair = max_pair
+
+    def __len__(self):
+        return min(len(self.data_dict['prompts']), self.max_pair)
+
+    def __getitem__(self, idx):
+        """
+        Outputs:
+            - prompts: List of Strings
+            - latents: Tensor of shape (num_denoising_steps, num_frames, num_channels, height, width). It is ordered from pure noise to clean image.
+        """
+        return {
+            "prompts": self.data_dict['prompts'][idx],
+            "ode_latent": self.data_dict['latents'][idx].squeeze(0),
+        }
+
+
+class ODERegressionLMDBDataset(Dataset):
+    def __init__(self, data_path: str, max_pair: int = int(1e8)):
+        self.env = lmdb.open(data_path, readonly=True,
+                             lock=False, readahead=False, meminit=False)
+
+        self.latents_shape = get_array_shape_from_lmdb(self.env, 'latents')
+        self.max_pair = max_pair
+
+    def __len__(self):
+        return min(self.latents_shape[0], self.max_pair)
+
+    def __getitem__(self, idx):
+        """
+        Outputs:
+            - prompts: List of Strings
+            - latents: Tensor of shape (num_denoising_steps, num_frames, num_channels, height, width). It is ordered from pure noise to clean image.
+        """
+        latents = retrieve_row_from_lmdb(
+            self.env,
+            "latents", np.float16, idx, shape=self.latents_shape[1:]
+        )
+
+        if len(latents.shape) == 4:
+            latents = latents[None, ...]
+
+        prompts = retrieve_row_from_lmdb(
+            self.env,
+            "prompts", str, idx
+        )
+        return {
+            "prompts": prompts,
+            "ode_latent": torch.tensor(latents, dtype=torch.float32)
+        }

exp_code/1_benchmark/CausVid/causvid/dmd.py

@@ -0,0 +1,497 @@
+from causvid.models.model_interface import InferencePipelineInterface
+from causvid.models import (
+    get_diffusion_wrapper,
+    get_text_encoder_wrapper,
+    get_vae_wrapper,
+    get_inference_pipeline_wrapper
+)
+from causvid.loss import get_denoising_loss
+import torch.nn.functional as F
+from typing import Tuple
+from torch import nn
+import torch
+
+
+class DMD(nn.Module):
+    def __init__(self, args, device):
+        """
+        Initialize the DMD (Distribution Matching Distillation) module.
+        This class is self-contained and compute generator and fake score losses
+        in the forward pass.
+        """
+        super().__init__()
+
+        # Step 1: Initialize all models
+
+        self.generator_model_name = getattr(
+            args, "generator_name", args.model_name)
+        self.real_model_name = getattr(args, "real_name", args.model_name)
+        self.fake_model_name = getattr(args, "fake_name", args.model_name)
+
+        self.generator_task_type = getattr(
+            args, "generator_task_type", args.generator_task)
+        self.real_task_type = getattr(
+            args, "real_task_type", args.generator_task)
+        self.fake_task_type = getattr(
+            args, "fake_task_type", args.generator_task)
+
+        self.generator = get_diffusion_wrapper(
+            model_name=self.generator_model_name)()
+        self.generator.set_module_grad(
+            module_grad=args.generator_grad
+        )
+
+        if getattr(args, "generator_ckpt", False):
+            print(f"Loading pretrained generator from {args.generator_ckpt}")
+            state_dict = torch.load(args.generator_ckpt, map_location="cpu")[
+                'generator']
+            self.generator.load_state_dict(
+                state_dict, strict=True
+            )
+
+        self.num_frame_per_block = getattr(args, "num_frame_per_block", 1)
+
+        if self.num_frame_per_block > 1:
+            self.generator.model.num_frame_per_block = self.num_frame_per_block
+
+        self.real_score = get_diffusion_wrapper(
+            model_name=self.real_model_name)()
+        self.real_score.set_module_grad(
+            module_grad=args.real_score_grad
+        )
+
+        self.fake_score = get_diffusion_wrapper(
+            model_name=self.fake_model_name)()
+        self.fake_score.set_module_grad(
+            module_grad=args.fake_score_grad
+        )
+
+        if args.gradient_checkpointing:
+            self.generator.enable_gradient_checkpointing()
+            self.fake_score.enable_gradient_checkpointing()
+
+        self.text_encoder = get_text_encoder_wrapper(
+            model_name=args.model_name)()
+        self.text_encoder.requires_grad_(False)
+
+        self.vae = get_vae_wrapper(model_name=args.model_name)()
+        self.vae.requires_grad_(False)
+
+        # this will be init later with fsdp-wrapped modules
+        self.inference_pipeline: InferencePipelineInterface = None
+
+        # Step 2: Initialize all dmd hyperparameters
+
+        self.denoising_step_list = torch.tensor(
+            args.denoising_step_list, dtype=torch.long, device=device)
+        self.num_train_timestep = args.num_train_timestep
+        self.min_step = int(0.02 * self.num_train_timestep)
+        self.max_step = int(0.98 * self.num_train_timestep)
+        self.real_guidance_scale = args.real_guidance_scale
+        self.timestep_shift = getattr(args, "timestep_shift", 1.0)
+
+        self.args = args
+        self.device = device
+        self.dtype = torch.bfloat16 if args.mixed_precision else torch.float32
+        self.scheduler = self.generator.get_scheduler()
+        self.denoising_loss_func = get_denoising_loss(
+            args.denoising_loss_type)()
+
+        if args.warp_denoising_step:  # Warp the denoising step according to the scheduler time
+            timesteps = torch.cat((self.scheduler.timesteps.cpu(), torch.tensor([0], dtype=torch.float32))).cuda().cuda()
+            self.denoising_step_list = timesteps[1000 - self.denoising_step_list]
+
+        if getattr(self.scheduler, "alphas_cumprod", None) is not None:
+            self.scheduler.alphas_cumprod = self.scheduler.alphas_cumprod.to(
+                device)
+        else:
+            self.scheduler.alphas_cumprod = None
+
+    def _process_timestep(self, timestep: torch.Tensor, type: str) -> torch.Tensor:
+        """
+        Pre-process the randomly generated timestep based on the generator's task type.
+        Input:
+            - timestep: [batch_size, num_frame] tensor containing the randomly generated timestep.
+            - type: a string indicating the type of the current model (image, bidirectional_video, or causal_video).
+        Output Behavior:
+            - image: check that the second dimension (num_frame) is 1.
+            - bidirectional_video: broadcast the timestep to be the same for all frames.
+            - causal_video: broadcast the timestep to be the same for all frames **in a block**.
+        """
+        if type == "image":
+            assert timestep.shape[1] == 1
+            return timestep
+        elif type == "bidirectional_video":
+            for index in range(timestep.shape[0]):
+                timestep[index] = timestep[index, 0]
+            return timestep
+        elif type == "causal_video":
+            # make the noise level the same within every motion block
+            timestep = timestep.reshape(timestep.shape[0], -1, self.num_frame_per_block)
+            timestep[:, :, 1:] = timestep[:, :, 0:1]
+            timestep = timestep.reshape(timestep.shape[0], -1)
+            return timestep
+        else:
+            raise NotImplementedError("Unsupported model type {}".format(type))
+
+    def _compute_kl_grad(
+        self, noisy_image_or_video: torch.Tensor,
+        estimated_clean_image_or_video: torch.Tensor,
+        timestep: torch.Tensor,
+        conditional_dict: dict, unconditional_dict: dict,
+        normalization: bool = True
+    ) -> Tuple[torch.Tensor, dict]:
+        """
+        Compute the KL grad (eq 7 in https://arxiv.org/abs/2311.18828).
+        Input:
+            - noisy_image_or_video: a tensor with shape [B, F, C, H, W] where the number of frame is 1 for images.
+            - estimated_clean_image_or_video: a tensor with shape [B, F, C, H, W] representing the estimated clean image or video.
+            - timestep: a tensor with shape [B, F] containing the randomly generated timestep.
+            - conditional_dict: a dictionary containing the conditional information (e.g. text embeddings, image embeddings).
+            - unconditional_dict: a dictionary containing the unconditional information (e.g. null/negative text embeddings, null/negative image embeddings).
+            - normalization: a boolean indicating whether to normalize the gradient.
+        Output:
+            - kl_grad: a tensor representing the KL grad.
+            - kl_log_dict: a dictionary containing the intermediate tensors for logging.
+        """
+        # Step 1: Compute the fake score
+        pred_fake_image = self.fake_score(
+            noisy_image_or_video=noisy_image_or_video,
+            conditional_dict=conditional_dict,
+            timestep=timestep
+        )
+
+        # Step 2: Compute the real score
+        # We compute the conditional and unconditional prediction
+        # and add them together to achieve cfg (https://arxiv.org/abs/2207.12598)
+        pred_real_image_cond = self.real_score(
+            noisy_image_or_video=noisy_image_or_video,
+            conditional_dict=conditional_dict,
+            timestep=timestep
+        )
+
+        pred_real_image_uncond = self.real_score(
+            noisy_image_or_video=noisy_image_or_video,
+            conditional_dict=unconditional_dict,
+            timestep=timestep
+        )
+
+        pred_real_image = pred_real_image_cond + (
+            pred_real_image_cond - pred_real_image_uncond
+        ) * self.real_guidance_scale
+
+        # Step 3: Compute the DMD gradient (DMD paper eq. 7).
+        grad = (pred_fake_image - pred_real_image)
+
+        # TODO: Change the normalizer for causal teacher
+        if normalization:
+            # Step 4: Gradient normalization (DMD paper eq. 8).
+            p_real = (estimated_clean_image_or_video - pred_real_image)
+            normalizer = torch.abs(p_real).mean(dim=[1, 2, 3, 4], keepdim=True)
+            grad = grad / normalizer
+        grad = torch.nan_to_num(grad)
+
+        return grad, {
+            "dmdtrain_clean_latent": estimated_clean_image_or_video.detach(),
+            "dmdtrain_noisy_latent": noisy_image_or_video.detach(),
+            "dmdtrain_pred_real_image": pred_real_image.detach(),
+            "dmdtrain_pred_fake_image": pred_fake_image.detach(),
+            "dmdtrain_gradient_norm": torch.mean(torch.abs(grad)).detach(),
+            "timestep": timestep.detach()
+        }
+
+    def compute_distribution_matching_loss(
+        self, image_or_video: torch.Tensor, conditional_dict: dict,
+        unconditional_dict: dict, gradient_mask: torch.Tensor = None
+    ) -> Tuple[torch.Tensor, dict]:
+        """
+        Compute the DMD loss (eq 7 in https://arxiv.org/abs/2311.18828).
+        Input:
+            - image_or_video: a tensor with shape [B, F, C, H, W] where the number of frame is 1 for images.
+            - conditional_dict: a dictionary containing the conditional information (e.g. text embeddings, image embeddings).
+            - unconditional_dict: a dictionary containing the unconditional information (e.g. null/negative text embeddings, null/negative image embeddings).
+            - gradient_mask: a boolean tensor with the same shape as image_or_video indicating which pixels to compute loss .
+        Output:
+            - dmd_loss: a scalar tensor representing the DMD loss.
+            - dmd_log_dict: a dictionary containing the intermediate tensors for logging.
+        """
+        original_latent = image_or_video
+
+        batch_size, num_frame = image_or_video.shape[:2]
+
+        with torch.no_grad():
+            # Step 1: Randomly sample timestep based on the given schedule and corresponding noise
+            timestep = torch.randint(
+                0,
+                self.num_train_timestep,
+                [batch_size, num_frame],
+                device=self.device,
+                dtype=torch.long
+            )
+
+            timestep = self._process_timestep(
+                timestep, type=self.real_task_type)
+
+            # TODO: Add timestep warping
+            if self.timestep_shift > 1:
+                timestep = self.timestep_shift * \
+                    (timestep / 1000) / \
+                    (1 + (self.timestep_shift - 1) * (timestep / 1000)) * 1000
+            timestep = timestep.clamp(self.min_step, self.max_step)
+
+            noise = torch.randn_like(image_or_video)
+            noisy_latent = self.scheduler.add_noise(
+                image_or_video.flatten(0, 1),
+                noise.flatten(0, 1),
+                timestep.flatten(0, 1)
+            ).detach().unflatten(0, (batch_size, num_frame))
+
+            # Step 2: Compute the KL grad
+            grad, dmd_log_dict = self._compute_kl_grad(
+                noisy_image_or_video=noisy_latent,
+                estimated_clean_image_or_video=original_latent,
+                timestep=timestep,
+                conditional_dict=conditional_dict,
+                unconditional_dict=unconditional_dict
+            )
+
+        if gradient_mask is not None:
+            dmd_loss = 0.5 * F.mse_loss(original_latent.double()[gradient_mask], (original_latent.double() - grad.double()).detach()[gradient_mask], reduction="mean")
+        else:
+            dmd_loss = 0.5 * F.mse_loss(original_latent.double(), (original_latent.double() - grad.double()).detach(), reduction="mean")
+        return dmd_loss, dmd_log_dict
+
+    def _initialize_inference_pipeline(self):
+        """
+        Lazy initialize the inference pipeline during the first backward simulation run.
+        Here we encapsulate the inference code with a model-dependent outside function.
+        We pass our FSDP-wrapped modules into the pipeline to save memory.
+        """
+        self.inference_pipeline = get_inference_pipeline_wrapper(
+            self.generator_model_name,
+            denoising_step_list=self.denoising_step_list,
+            scheduler=self.scheduler,
+            generator=self.generator,
+            num_frame_per_block=self.num_frame_per_block
+        )
+
+    @torch.no_grad()
+    def _consistency_backward_simulation(self, noise: torch.Tensor, conditional_dict: dict) -> torch.Tensor:
+        """
+        Simulate the generator's input from noise to avoid training/inference mismatch.
+        See Sec 4.5 of the DMD2 paper (https://arxiv.org/abs/2405.14867) for details.
+        Here we use the consistency sampler (https://arxiv.org/abs/2303.01469)
+        Input:
+            - noise: a tensor sampled from N(0, 1) with shape [B, F, C, H, W] where the number of frame is 1 for images.
+            - conditional_dict: a dictionary containing the conditional information (e.g. text embeddings, image embeddings).
+        Output:
+            - output: a tensor with shape [B, T, F, C, H, W].
+            T is the total number of timesteps. output[0] is a pure noise and output[i] and i>0
+            represents the x0 prediction at each timestep.
+        """
+        if self.inference_pipeline is None:
+            self._initialize_inference_pipeline()
+
+        return self.inference_pipeline.inference_with_trajectory(noise=noise, conditional_dict=conditional_dict)
+
+    def _run_generator(self, image_or_video_shape, conditional_dict: dict, unconditional_dict: dict, clean_latent: torch.tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Optionally simulate the generator's input from noise using backward simulation
+        and then run the generator for one-step.
+        Input:
+            - image_or_video_shape: a list containing the shape of the image or video [B, F, C, H, W].
+            - conditional_dict: a dictionary containing the conditional information (e.g. text embeddings, image embeddings).
+            - unconditional_dict: a dictionary containing the unconditional information (e.g. null/negative text embeddings, null/negative image embeddings).
+            - clean_latent: a tensor containing the clean latents [B, F, C, H, W]. Need to be passed when no backward simulation is used.
+        Output:
+            - pred_image: a tensor with shape [B, F, C, H, W].
+        """
+        # Step 1: Sample noise and backward simulate the generator's input
+        if getattr(self.args, "backward_simulation", True):
+            simulated_noisy_input = self._consistency_backward_simulation(
+                noise=torch.randn(image_or_video_shape,
+                                  device=self.device, dtype=self.dtype),
+                conditional_dict=conditional_dict
+            )
+        else:
+            simulated_noisy_input = []
+            for timestep in self.denoising_step_list:
+                noise = torch.randn(
+                    image_or_video_shape, device=self.device, dtype=self.dtype)
+
+                noisy_timestep = timestep * torch.ones(
+                    image_or_video_shape[:2], device=self.device, dtype=torch.long)
+
+                if timestep != 0:
+                    noisy_image = self.scheduler.add_noise(
+                        clean_latent.flatten(0, 1),
+                        noise.flatten(0, 1),
+                        noisy_timestep.flatten(0, 1)
+                    ).unflatten(0, image_or_video_shape[:2])
+                else:
+                    noisy_image = clean_latent
+
+                simulated_noisy_input.append(noisy_image)
+
+            simulated_noisy_input = torch.stack(simulated_noisy_input, dim=1)
+
+        # Step 2: Randomly sample a timestep and pick the corresponding input
+        index = torch.randint(0, len(self.denoising_step_list), [image_or_video_shape[0], image_or_video_shape[1]], device=self.device, dtype=torch.long)
+        index = self._process_timestep(index, type=self.generator_task_type)
+
+        # select the corresponding timestep's noisy input from the stacked tensor [B, T, F, C, H, W]
+        noisy_input = torch.gather(
+            simulated_noisy_input, dim=1,
+            index=index.reshape(index.shape[0], 1, index.shape[1], 1, 1, 1).expand(
+                -1, -1, -1, *image_or_video_shape[2:])
+        ).squeeze(1)
+
+        timestep = self.denoising_step_list[index]
+
+        pred_image_or_video = self.generator(
+            noisy_image_or_video=noisy_input,
+            conditional_dict=conditional_dict,
+            timestep=timestep
+        )
+
+        gradient_mask = None  # timestep != 0
+
+        # pred_image_or_video = noisy_input * \
+        #     (1-gradient_mask.float()).reshape(*gradient_mask.shape, 1, 1, 1) + \
+        #     pred_image_or_video * gradient_mask.float().reshape(*gradient_mask.shape, 1, 1, 1)
+
+        pred_image_or_video = pred_image_or_video.type_as(noisy_input)
+
+        return pred_image_or_video, gradient_mask
+
+    def generator_loss(self, image_or_video_shape, conditional_dict: dict, unconditional_dict: dict, clean_latent: torch.Tensor) -> Tuple[torch.Tensor, dict]:
+        """
+        Generate image/videos from noise and compute the DMD loss.
+        The noisy input to the generator is backward simulated.
+        This removes the need of any datasets during distillation.
+        See Sec 4.5 of the DMD2 paper (https://arxiv.org/abs/2405.14867) for details.
+        Input:
+            - image_or_video_shape: a list containing the shape of the image or video [B, F, C, H, W].
+            - conditional_dict: a dictionary containing the conditional information (e.g. text embeddings, image embeddings).
+            - unconditional_dict: a dictionary containing the unconditional information (e.g. null/negative text embeddings, null/negative image embeddings).
+            - clean_latent: a tensor containing the clean latents [B, F, C, H, W]. Need to be passed when no backward simulation is used.
+        Output:
+            - loss: a scalar tensor representing the generator loss.
+            - generator_log_dict: a dictionary containing the intermediate tensors for logging.
+        """
+        # Step 1: Run generator on backward simulated noisy input
+        pred_image, gradient_mask = self._run_generator(
+            image_or_video_shape=image_or_video_shape,
+            conditional_dict=conditional_dict,
+            unconditional_dict=unconditional_dict,
+            clean_latent=clean_latent
+        )
+
+        # Step 2: Compute the DMD loss
+        dmd_loss, dmd_log_dict = self.compute_distribution_matching_loss(
+            image_or_video=pred_image,
+            conditional_dict=conditional_dict,
+            unconditional_dict=unconditional_dict,
+            gradient_mask=gradient_mask
+        )
+
+        # Step 3: TODO: Implement the GAN loss
+
+        return dmd_loss, dmd_log_dict
+
+    def critic_loss(self, image_or_video_shape, conditional_dict: dict, unconditional_dict: dict, clean_latent: torch.Tensor) -> Tuple[torch.Tensor, dict]:
+        """
+        Generate image/videos from noise and train the critic with generated samples.
+        The noisy input to the generator is backward simulated.
+        This removes the need of any datasets during distillation.
+        See Sec 4.5 of the DMD2 paper (https://arxiv.org/abs/2405.14867) for details.
+        Input:
+            - image_or_video_shape: a list containing the shape of the image or video [B, F, C, H, W].
+            - conditional_dict: a dictionary containing the conditional information (e.g. text embeddings, image embeddings).
+            - unconditional_dict: a dictionary containing the unconditional information (e.g. null/negative text embeddings, null/negative image embeddings).
+            - clean_latent: a tensor containing the clean latents [B, F, C, H, W]. Need to be passed when no backward simulation is used.
+        Output:
+            - loss: a scalar tensor representing the generator loss.
+            - critic_log_dict: a dictionary containing the intermediate tensors for logging.
+        """
+
+        # Step 1: Run generator on backward simulated noisy input
+        with torch.no_grad():
+            generated_image, _ = self._run_generator(
+                image_or_video_shape=image_or_video_shape,
+                conditional_dict=conditional_dict,
+                unconditional_dict=unconditional_dict,
+                clean_latent=clean_latent
+            )
+
+        # Step 2: Compute the fake prediction
+        critic_timestep = torch.randint(
+            0,
+            self.num_train_timestep,
+            image_or_video_shape[:2],
+            device=self.device,
+            dtype=torch.long
+        )
+        critic_timestep = self._process_timestep(
+            critic_timestep, type=self.fake_task_type)
+
+        # TODO: Add timestep warping
+        if self.timestep_shift > 1:
+            critic_timestep = self.timestep_shift * \
+                (critic_timestep / 1000) / (1 + (self.timestep_shift - 1) * (critic_timestep / 1000)) * 1000
+
+        critic_timestep = critic_timestep.clamp(self.min_step, self.max_step)
+
+        critic_noise = torch.randn_like(generated_image)
+        noisy_generated_image = self.scheduler.add_noise(
+            generated_image.flatten(0, 1),
+            critic_noise.flatten(0, 1),
+            critic_timestep.flatten(0, 1)
+        ).unflatten(0, image_or_video_shape[:2])
+
+        pred_fake_image = self.fake_score(
+            noisy_image_or_video=noisy_generated_image,
+            conditional_dict=conditional_dict,
+            timestep=critic_timestep
+        )
+
+        # Step 3: Compute the denoising loss for the fake critic
+        if self.args.denoising_loss_type == "flow":
+            assert "wan" in self.args.model_name
+            from causvid.models.wan.wan_wrapper import WanDiffusionWrapper
+            flow_pred = WanDiffusionWrapper._convert_x0_to_flow_pred(
+                scheduler=self.scheduler,
+                x0_pred=pred_fake_image.flatten(0, 1),
+                xt=noisy_generated_image.flatten(0, 1),
+                timestep=critic_timestep.flatten(0, 1)
+            )
+            pred_fake_noise = None
+        else:
+            flow_pred = None
+            pred_fake_noise = self.scheduler.convert_x0_to_noise(
+                x0=pred_fake_image.flatten(0, 1),
+                xt=noisy_generated_image.flatten(0, 1),
+                timestep=critic_timestep.flatten(0, 1)
+            ).unflatten(0, image_or_video_shape[:2])
+
+        denoising_loss = self.denoising_loss_func(
+            x=generated_image.flatten(0, 1),
+            x_pred=pred_fake_image.flatten(0, 1),
+            noise=critic_noise.flatten(0, 1),
+            noise_pred=pred_fake_noise,
+            alphas_cumprod=self.scheduler.alphas_cumprod,
+            timestep=critic_timestep.flatten(0, 1),
+            flow_pred=flow_pred
+        )
+
+        # Step 4: TODO: Compute the GAN loss
+
+        # Step 5: Debugging Log
+        critic_log_dict = {
+            "critictrain_latent": generated_image.detach(),
+            "critictrain_noisy_latent": noisy_generated_image.detach(),
+            "critictrain_pred_image": pred_fake_image.detach(),
+            "critic_timestep": critic_timestep.detach()
+        }
+
+        return denoising_loss, critic_log_dict

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/clip_features.py

@@ -0,0 +1,38 @@
+# pip install git+https://github.com/openai/CLIP.git
+import pdb
+from PIL import Image
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+import clip
+from causvid.evaluation.coco_eval.cleanfid.fid import compute_fid
+
+
+def img_preprocess_clip(img_np):
+    x = Image.fromarray(img_np.astype(np.uint8)).convert("RGB")
+    T = transforms.Compose([
+        transforms.Resize(
+            224, interpolation=transforms.InterpolationMode.BICUBIC),
+        transforms.CenterCrop(224),
+    ])
+    return np.asarray(T(x)).clip(0, 255).astype(np.uint8)
+
+
+class CLIP_fx():
+    def __init__(self, name="ViT-B/32", device="cuda"):
+        self.model, _ = clip.load(name, device=device)
+        self.model.eval()
+        self.name = "clip_" + name.lower().replace("-", "_").replace("/", "_")
+
+    def __call__(self, img_t):
+        img_x = img_t / 255.0
+        T_norm = transforms.Normalize(
+            (0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))
+        img_x = T_norm(img_x)
+        assert torch.is_tensor(img_x)
+        if len(img_x.shape) == 3:
+            img_x = img_x.unsqueeze(0)
+        B, C, H, W = img_x.shape
+        with torch.no_grad():
+            z = self.model.encode_image(img_x)
+        return z

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/downloads_helper.py

@@ -0,0 +1,73 @@
+import os
+import urllib.request
+import requests
+import shutil
+
+
+inception_url = "https://nvlabs-fi-cdn.nvidia.com/stylegan2-ada-pytorch/pretrained/metrics/inception-2015-12-05.pt"
+
+
+"""
+Download the pretrined inception weights if it does not exists
+ARGS:
+    fpath - output folder path
+"""
+
+
+def check_download_inception(fpath="./"):
+    inception_path = os.path.join(fpath, "inception-2015-12-05.pt")
+    if not os.path.exists(inception_path):
+        # download the file
+        with urllib.request.urlopen(inception_url) as response, open(inception_path, 'wb') as f:
+            shutil.copyfileobj(response, f)
+    return inception_path
+
+
+"""
+Download any url if it does not exist
+ARGS:
+    local_folder - output folder path
+    url - the weburl to download
+"""
+
+
+def check_download_url(local_folder, url):
+    name = os.path.basename(url)
+    local_path = os.path.join(local_folder, name)
+    if not os.path.exists(local_path):
+        os.makedirs(local_folder, exist_ok=True)
+        print(f"downloading statistics to {local_path}")
+        with urllib.request.urlopen(url) as response, open(local_path, 'wb') as f:
+            shutil.copyfileobj(response, f)
+    return local_path
+
+
+"""
+Download a file from google drive
+ARGS:
+    file_id - id of the google drive file
+    out_path - output folder path
+"""
+
+
+def download_google_drive(file_id, out_path):
+    def get_confirm_token(response):
+        for key, value in response.cookies.items():
+            if key.startswith('download_warning'):
+                return value
+        return None
+
+    URL = "https://drive.google.com/uc?export=download"
+    session = requests.Session()
+    response = session.get(URL, params={'id': file_id}, stream=True)
+    token = get_confirm_token(response)
+
+    if token:
+        params = {'id': file_id, 'confirm': token}
+        response = session.get(URL, params=params, stream=True)
+
+    CHUNK_SIZE = 32768
+    with open(out_path, "wb") as f:
+        for chunk in response.iter_content(CHUNK_SIZE):
+            if chunk:
+                f.write(chunk)

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/features.py

@@ -0,0 +1,85 @@
+"""
+helpers for extracting features from image
+"""
+import os
+import platform
+import numpy as np
+import torch
+import causvid.evaluation.coco_eval.cleanfid
+from causvid.evaluation.coco_eval.cleanfid.downloads_helper import check_download_url
+from causvid.evaluation.coco_eval.cleanfid.inception_pytorch import InceptionV3
+from causvid.evaluation.coco_eval.cleanfid.inception_torchscript import InceptionV3W
+
+
+"""
+returns a functions that takes an image in range [0,255]
+and outputs a feature embedding vector
+"""
+
+
+def feature_extractor(name="torchscript_inception", device=torch.device("cuda"), resize_inside=False, use_dataparallel=True):
+    if name == "torchscript_inception":
+        path = "./" if platform.system() == "Windows" else "/tmp"
+        model = InceptionV3W(path, download=True, resize_inside=resize_inside).to(device)
+        model.eval()
+        if use_dataparallel:
+            model = torch.nn.DataParallel(model)
+
+        def model_fn(x): return model(x)
+    elif name == "pytorch_inception":
+        model = InceptionV3(output_blocks=[3], resize_input=False).to(device)
+        model.eval()
+        if use_dataparallel:
+            model = torch.nn.DataParallel(model)
+
+        def model_fn(x): return model(x / 255)[0].squeeze(-1).squeeze(-1)
+    else:
+        raise ValueError(f"{name} feature extractor not implemented")
+    return model_fn
+
+
+"""
+Build a feature extractor for each of the modes
+"""
+
+
+def build_feature_extractor(mode, device=torch.device("cuda"), use_dataparallel=True):
+    if mode == "legacy_pytorch":
+        feat_model = feature_extractor(name="pytorch_inception", resize_inside=False, device=device, use_dataparallel=use_dataparallel)
+    elif mode == "legacy_tensorflow":
+        feat_model = feature_extractor(name="torchscript_inception", resize_inside=True, device=device, use_dataparallel=use_dataparallel)
+    elif mode == "clean":
+        feat_model = feature_extractor(name="torchscript_inception", resize_inside=False, device=device, use_dataparallel=use_dataparallel)
+    return feat_model
+
+
+"""
+Load precomputed reference statistics for commonly used datasets
+"""
+
+
+def get_reference_statistics(name, res, mode="clean", model_name="inception_v3", seed=0, split="test", metric="FID"):
+    base_url = "https://www.cs.cmu.edu/~clean-fid/stats/"
+    if split == "custom":
+        res = "na"
+    if model_name == "inception_v3":
+        model_modifier = ""
+    else:
+        model_modifier = "_" + model_name
+    if metric == "FID":
+        rel_path = (f"{name}_{mode}{model_modifier}_{split}_{res}.npz").lower()
+        url = f"{base_url}/{rel_path}"
+        mod_path = os.path.dirname(cleanfid.__file__)
+        stats_folder = os.path.join(mod_path, "stats")
+        fpath = check_download_url(local_folder=stats_folder, url=url)
+        stats = np.load(fpath)
+        mu, sigma = stats["mu"], stats["sigma"]
+        return mu, sigma
+    elif metric == "KID":
+        rel_path = (f"{name}_{mode}{model_modifier}_{split}_{res}_kid.npz").lower()
+        url = f"{base_url}/{rel_path}"
+        mod_path = os.path.dirname(cleanfid.__file__)
+        stats_folder = os.path.join(mod_path, "stats")
+        fpath = check_download_url(local_folder=stats_folder, url=url)
+        stats = np.load(fpath)
+        return stats["feats"]

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/fid.py

@@ -0,0 +1,635 @@
+import os
+import random
+from tqdm import tqdm
+from glob import glob
+import torch
+import numpy as np
+from PIL import Image
+from scipy import linalg
+import zipfile
+from causvid.evaluation.coco_eval import cleanfid
+from causvid.evaluation.coco_eval.cleanfid.utils import *
+from causvid.evaluation.coco_eval.cleanfid.features import build_feature_extractor, get_reference_statistics
+from causvid.evaluation.coco_eval.cleanfid.resize import *
+
+
+"""
+Numpy implementation of the Frechet Distance.
+The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)
+and X_2 ~ N(mu_2, C_2) is
+        d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).
+Stable version by Danica J. Sutherland.
+Params:
+    mu1   : Numpy array containing the activations of a layer of the
+            inception net (like returned by the function 'get_predictions')
+            for generated samples.
+    mu2   : The sample mean over activations, precalculated on an
+            representative data set.
+    sigma1: The covariance matrix over activations for generated samples.
+    sigma2: The covariance matrix over activations, precalculated on an
+            representative data set.
+"""
+
+
+def frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
+    mu1 = np.atleast_1d(mu1)
+    mu2 = np.atleast_1d(mu2)
+    sigma1 = np.atleast_2d(sigma1)
+    sigma2 = np.atleast_2d(sigma2)
+
+    assert mu1.shape == mu2.shape, \
+        'Training and test mean vectors have different lengths'
+    assert sigma1.shape == sigma2.shape, \
+        'Training and test covariances have different dimensions'
+
+    diff = mu1 - mu2
+
+    # Product might be almost singular
+    covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
+    if not np.isfinite(covmean).all():
+        msg = ('fid calculation produces singular product; '
+               'adding %s to diagonal of cov estimates') % eps
+        print(msg)
+        offset = np.eye(sigma1.shape[0]) * eps
+        covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))
+
+    # Numerical error might give slight imaginary component
+    if np.iscomplexobj(covmean):
+        if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):
+            m = np.max(np.abs(covmean.imag))
+            raise ValueError('Imaginary component {}'.format(m))
+        covmean = covmean.real
+
+    tr_covmean = np.trace(covmean)
+
+    return (diff.dot(diff) + np.trace(sigma1) + np.trace(sigma2) - 2 * tr_covmean)
+
+
+"""
+Compute the KID score given the sets of features
+"""
+
+
+def kernel_distance(feats1, feats2, num_subsets=100, max_subset_size=1000):
+    n = feats1.shape[1]
+    m = min(min(feats1.shape[0], feats2.shape[0]), max_subset_size)
+    t = 0
+    for _subset_idx in range(num_subsets):
+        x = feats2[np.random.choice(feats2.shape[0], m, replace=False)]
+        y = feats1[np.random.choice(feats1.shape[0], m, replace=False)]
+        a = (x @ x.T / n + 1) ** 3 + (y @ y.T / n + 1) ** 3
+        b = (x @ y.T / n + 1) ** 3
+        t += (a.sum() - np.diag(a).sum()) / (m - 1) - b.sum() * 2 / m
+    kid = t / num_subsets / m
+    return float(kid)
+
+
+"""
+Compute the inception features for a batch of images
+"""
+
+
+def get_batch_features(batch, model, device):
+    with torch.no_grad():
+        feat = model(batch.to(device))
+    return feat.detach().cpu().numpy()
+
+
+"""
+Compute the inception features for a list of files
+"""
+
+
+def get_files_features(l_files, model=None, num_workers=12,
+                       batch_size=128, device=torch.device("cuda"),
+                       mode="clean", custom_fn_resize=None,
+                       description="", fdir=None, verbose=True,
+                       custom_image_tranform=None):
+    # wrap the images in a dataloader for parallelizing the resize operation
+    dataset = ResizeDataset(l_files, fdir=fdir, mode=mode)
+    if custom_image_tranform is not None:
+        dataset.custom_image_tranform = custom_image_tranform
+    if custom_fn_resize is not None:
+        dataset.fn_resize = custom_fn_resize
+
+    dataloader = torch.utils.data.DataLoader(dataset,
+                                             batch_size=batch_size, shuffle=False,
+                                             drop_last=False, num_workers=num_workers)
+
+    # collect all inception features
+    l_feats = []
+    if verbose:
+        pbar = tqdm(dataloader, desc=description)
+    else:
+        pbar = dataloader
+
+    for batch in pbar:
+        l_feats.append(get_batch_features(batch, model, device))
+    np_feats = np.concatenate(l_feats)
+    return np_feats
+
+
+"""
+Compute the inception features for a numpy array
+"""
+
+
+def get_array_features(l_array, model=None, num_workers=12,
+                       batch_size=128, device=torch.device("cuda"),
+                       mode="clean", custom_fn_resize=None,
+                       description="", verbose=True,
+                       custom_image_tranform=None):
+    # wrap the images in a dataloader for parallelizing the resize operation
+    dataset = ResizeArrayDataset(l_array, mode=mode)
+    if custom_image_tranform is not None:
+        dataset.custom_image_tranform = custom_image_tranform
+    if custom_fn_resize is not None:
+        dataset.fn_resize = custom_fn_resize
+
+    dataloader = torch.utils.data.DataLoader(dataset,
+                                             batch_size=batch_size, shuffle=False,
+                                             drop_last=False, num_workers=num_workers)
+
+    # collect all inception features
+    l_feats = []
+    if verbose:
+        pbar = tqdm(dataloader, desc=description)
+    else:
+        pbar = dataloader
+
+    for batch in pbar:
+        l_feats.append(get_batch_features(batch, model, device))
+    np_feats = np.concatenate(l_feats)
+    return np_feats
+
+
+"""
+Compute the inception features for a folder of image files
+"""
+
+
+def get_folder_features(fdir, model=None, num_workers=12, num=None,
+                        shuffle=False, seed=0, batch_size=128, device=torch.device("cuda"),
+                        mode="clean", custom_fn_resize=None, description="", verbose=True,
+                        custom_image_tranform=None):
+    # get all relevant files in the dataset
+    if ".zip" in fdir:
+        files = list(set(zipfile.ZipFile(fdir).namelist()))
+        # remove the non-image files inside the zip
+        files = [x for x in files if os.path.splitext(x)[1].lower()[
+            1:] in EXTENSIONS]
+    else:
+        files = sorted([file for ext in EXTENSIONS
+                        for file in glob(os.path.join(fdir, f"**/*.{ext}"), recursive=True)])
+    if verbose:
+        print(f"Found {len(files)} images in the folder {fdir}")
+    # use a subset number of files if needed
+    if num is not None:
+        if shuffle:
+            random.seed(seed)
+            random.shuffle(files)
+        files = files[:num]
+    np_feats = get_files_features(files, model, num_workers=num_workers,
+                                  batch_size=batch_size, device=device, mode=mode,
+                                  custom_fn_resize=custom_fn_resize,
+                                  custom_image_tranform=custom_image_tranform,
+                                  description=description, fdir=fdir, verbose=verbose)
+    return np_feats
+
+
+"""
+Compute the FID score given the inception features stack
+"""
+
+
+def fid_from_feats(feats1, feats2):
+    mu1, sig1 = np.mean(feats1, axis=0), np.cov(feats1, rowvar=False)
+    mu2, sig2 = np.mean(feats2, axis=0), np.cov(feats2, rowvar=False)
+    return frechet_distance(mu1, sig1, mu2, sig2)
+
+
+"""
+Computes the FID score for a folder of images for a specific dataset
+and a specific resolution
+"""
+
+
+def fid_folder(fdir, dataset_name, dataset_res, dataset_split,
+               model=None, mode="clean", model_name="inception_v3", num_workers=12,
+               batch_size=128, device=torch.device("cuda"), verbose=True,
+               custom_image_tranform=None, custom_fn_resize=None):
+    # Load reference FID statistics (download if needed)
+    ref_mu, ref_sigma = get_reference_statistics(dataset_name, dataset_res,
+                                                 mode=mode, model_name=model_name, seed=0, split=dataset_split)
+    fbname = os.path.basename(fdir)
+    # get all inception features for folder images
+    np_feats = get_folder_features(fdir, model, num_workers=num_workers,
+                                   batch_size=batch_size, device=device,
+                                   mode=mode, description=f"FID {fbname} : ", verbose=verbose,
+                                   custom_image_tranform=custom_image_tranform,
+                                   custom_fn_resize=custom_fn_resize)
+    mu = np.mean(np_feats, axis=0)
+    sigma = np.cov(np_feats, rowvar=False)
+    fid = frechet_distance(mu, sigma, ref_mu, ref_sigma)
+    return fid
+
+
+"""
+Compute the FID stats from a generator model
+"""
+
+
+def get_model_features(G, model, mode="clean", z_dim=512,
+                       num_gen=50_000, batch_size=128, device=torch.device("cuda"),
+                       desc="FID model: ", verbose=True, return_z=False,
+                       custom_image_tranform=None, custom_fn_resize=None):
+    if custom_fn_resize is None:
+        fn_resize = build_resizer(mode)
+    else:
+        fn_resize = custom_fn_resize
+
+    # Generate test features
+    num_iters = int(np.ceil(num_gen / batch_size))
+    l_feats = []
+    latents = []
+    if verbose:
+        pbar = tqdm(range(num_iters), desc=desc)
+    else:
+        pbar = range(num_iters)
+    for idx in pbar:
+        with torch.no_grad():
+            z_batch = torch.randn((batch_size, z_dim)).to(device)
+            if return_z:
+                latents.append(z_batch)
+            # generated image is in range [0,255]
+            img_batch = G(z_batch)
+            # split into individual batches for resizing if needed
+            if mode != "legacy_tensorflow":
+                l_resized_batch = []
+                for idx in range(batch_size):
+                    curr_img = img_batch[idx]
+                    img_np = curr_img.cpu().numpy().transpose((1, 2, 0))
+                    if custom_image_tranform is not None:
+                        img_np = custom_image_tranform(img_np)
+                    img_resize = fn_resize(img_np)
+                    l_resized_batch.append(torch.tensor(
+                        img_resize.transpose((2, 0, 1))).unsqueeze(0))
+                resized_batch = torch.cat(l_resized_batch, dim=0)
+            else:
+                resized_batch = img_batch
+            feat = get_batch_features(resized_batch, model, device)
+        l_feats.append(feat)
+    np_feats = np.concatenate(l_feats)[:num_gen]
+    if return_z:
+        latents = torch.cat(latents, 0)
+        return np_feats, latents
+    return np_feats
+
+
+"""
+Computes the FID score for a generator model for a specific dataset
+and a specific resolution
+"""
+
+
+def fid_model(G, dataset_name, dataset_res, dataset_split,
+              model=None, model_name="inception_v3", z_dim=512, num_gen=50_000,
+              mode="clean", num_workers=0, batch_size=128,
+              device=torch.device("cuda"), verbose=True,
+              custom_image_tranform=None, custom_fn_resize=None):
+    # Load reference FID statistics (download if needed)
+    ref_mu, ref_sigma = get_reference_statistics(dataset_name, dataset_res,
+                                                 mode=mode, model_name=model_name,
+                                                 seed=0, split=dataset_split)
+    # Generate features of images generated by the model
+    np_feats = get_model_features(G, model, mode=mode,
+                                  z_dim=z_dim, num_gen=num_gen,
+                                  batch_size=batch_size, device=device, verbose=verbose,
+                                  custom_image_tranform=custom_image_tranform, custom_fn_resize=custom_fn_resize)
+    mu = np.mean(np_feats, axis=0)
+    sigma = np.cov(np_feats, rowvar=False)
+    fid = frechet_distance(mu, sigma, ref_mu, ref_sigma)
+    return fid
+
+
+"""
+Computes the FID score between the two given folders
+"""
+
+
+def compare_folders(fdir1, fdir2, feat_model, mode, num_workers=0,
+                    batch_size=8, device=torch.device("cuda"), verbose=True,
+                    custom_image_tranform=None, custom_fn_resize=None):
+    # get all inception features for the first folder
+    fbname1 = os.path.basename(fdir1)
+    np_feats1 = get_folder_features(fdir1, feat_model, num_workers=num_workers,
+                                    batch_size=batch_size, device=device, mode=mode,
+                                    description=f"FID {fbname1} : ", verbose=verbose,
+                                    custom_image_tranform=custom_image_tranform,
+                                    custom_fn_resize=custom_fn_resize)
+    mu1 = np.mean(np_feats1, axis=0)
+    sigma1 = np.cov(np_feats1, rowvar=False)
+    # get all inception features for the second folder
+    fbname2 = os.path.basename(fdir2)
+    np_feats2 = get_folder_features(fdir2, feat_model, num_workers=num_workers,
+                                    batch_size=batch_size, device=device, mode=mode,
+                                    description=f"FID {fbname2} : ", verbose=verbose,
+                                    custom_image_tranform=custom_image_tranform,
+                                    custom_fn_resize=custom_fn_resize)
+    mu2 = np.mean(np_feats2, axis=0)
+    sigma2 = np.cov(np_feats2, rowvar=False)
+    fid = frechet_distance(mu1, sigma1, mu2, sigma2)
+    return fid
+
+
+"""
+Test if a custom statistic exists
+"""
+
+
+def test_stats_exists(name, mode, model_name="inception_v3", metric="FID"):
+    stats_folder = os.path.join(os.path.dirname(cleanfid.__file__), "stats")
+    split, res = "custom", "na"
+    if model_name == "inception_v3":
+        model_modifier = ""
+    else:
+        model_modifier = "_" + model_name
+    if metric == "FID":
+        fname = f"{name}_{mode}{model_modifier}_{split}_{res}.npz"
+    elif metric == "KID":
+        fname = f"{name}_{mode}{model_modifier}_{split}_{res}_kid.npz"
+    fpath = os.path.join(stats_folder, fname)
+    return os.path.exists(fpath)
+
+
+"""
+Remove the custom FID features from the stats folder
+"""
+
+
+def remove_custom_stats(name, mode="clean", model_name="inception_v3"):
+    stats_folder = os.path.join(os.path.dirname(cleanfid.__file__), "stats")
+    # remove the FID stats
+    split, res = "custom", "na"
+    if model_name == "inception_v3":
+        model_modifier = ""
+    else:
+        model_modifier = "_" + model_name
+    outf = os.path.join(
+        stats_folder, f"{name}_{mode}{model_modifier}_{split}_{res}.npz".lower())
+    if not os.path.exists(outf):
+        msg = f"The stats file {name} does not exist."
+        raise Exception(msg)
+    os.remove(outf)
+    # remove the KID stats
+    outf = os.path.join(
+        stats_folder, f"{name}_{mode}{model_modifier}_{split}_{res}_kid.npz")
+    if not os.path.exists(outf):
+        msg = f"The stats file {name} does not exist."
+        raise Exception(msg)
+    os.remove(outf)
+
+
+"""
+Cache a custom dataset statistics file
+"""
+
+
+def make_custom_stats(name, fdir, num=None, mode="clean", model_name="inception_v3",
+                      num_workers=0, batch_size=64, device=torch.device("cuda"), verbose=True):
+    stats_folder = os.path.join(os.path.dirname(cleanfid.__file__), "stats")
+    os.makedirs(stats_folder, exist_ok=True)
+    split, res = "custom", "na"
+    if model_name == "inception_v3":
+        model_modifier = ""
+    else:
+        model_modifier = "_" + model_name
+    outf = os.path.join(
+        stats_folder, f"{name}_{mode}{model_modifier}_{split}_{res}.npz".lower())
+    # if the custom stat file already exists
+    if os.path.exists(outf):
+        msg = f"The statistics file {name} already exists. "
+        msg += "Use remove_custom_stats function to delete it first."
+        raise Exception(msg)
+    if model_name == "inception_v3":
+        feat_model = build_feature_extractor(mode, device)
+        custom_fn_resize = None
+        custom_image_tranform = None
+    elif model_name == "clip_vit_b_32":
+        from causvid.evaluation.coco_eval.cleanfid.clip_features import CLIP_fx, img_preprocess_clip
+        clip_fx = CLIP_fx("ViT-B/32")
+        feat_model = clip_fx
+        custom_fn_resize = img_preprocess_clip
+        custom_image_tranform = None
+    else:
+        raise ValueError(
+            f"The entered model name - {model_name} was not recognized.")
+
+    # get all inception features for folder images
+    np_feats = get_folder_features(fdir, feat_model, num_workers=num_workers, num=num,
+                                   batch_size=batch_size, device=device, verbose=verbose,
+                                   mode=mode, description=f"custom stats: {os.path.basename(fdir)} : ",
+                                   custom_image_tranform=custom_image_tranform,
+                                   custom_fn_resize=custom_fn_resize)
+
+    mu = np.mean(np_feats, axis=0)
+    sigma = np.cov(np_feats, rowvar=False)
+    print(f"saving custom FID stats to {outf}")
+    np.savez_compressed(outf, mu=mu, sigma=sigma)
+
+    # KID stats
+    outf = os.path.join(
+        stats_folder, f"{name}_{mode}{model_modifier}_{split}_{res}_kid.npz".lower())
+    print(f"saving custom KID stats to {outf}")
+    np.savez_compressed(outf, feats=np_feats)
+
+
+def compute_kid(fdir1=None, fdir2=None, gen=None,
+                mode="clean", num_workers=12, batch_size=32,
+                device=torch.device("cuda"), dataset_name="FFHQ",
+                dataset_res=1024, dataset_split="train", num_gen=50_000, z_dim=512,
+                verbose=True, use_dataparallel=True):
+    # build the feature extractor based on the mode
+    feat_model = build_feature_extractor(
+        mode, device, use_dataparallel=use_dataparallel)
+
+    # if both dirs are specified, compute KID between folders
+    if fdir1 is not None and fdir2 is not None:
+        if verbose:
+            print("compute KID between two folders")
+        # get all inception features for the first folder
+        fbname1 = os.path.basename(fdir1)
+        np_feats1 = get_folder_features(fdir1, feat_model, num_workers=num_workers,
+                                        batch_size=batch_size, device=device, mode=mode,
+                                        description=f"KID {fbname1} : ", verbose=verbose)
+        # get all inception features for the second folder
+        fbname2 = os.path.basename(fdir2)
+        np_feats2 = get_folder_features(fdir2, feat_model, num_workers=num_workers,
+                                        batch_size=batch_size, device=device, mode=mode,
+                                        description=f"KID {fbname2} : ", verbose=verbose)
+        score = kernel_distance(np_feats1, np_feats2)
+        return score
+
+    # compute kid of a folder
+    elif fdir1 is not None and fdir2 is None:
+        if verbose:
+            print(f"compute KID of a folder with {dataset_name} statistics")
+        ref_feats = get_reference_statistics(dataset_name, dataset_res,
+                                             mode=mode, seed=0, split=dataset_split, metric="KID")
+        fbname = os.path.basename(fdir1)
+        # get all inception features for folder images
+        np_feats = get_folder_features(fdir1, feat_model, num_workers=num_workers,
+                                       batch_size=batch_size, device=device, mode=mode,
+                                       description=f"KID {fbname} : ", verbose=verbose)
+        score = kernel_distance(ref_feats, np_feats)
+        return score
+
+    # compute kid for a generator, using images in fdir2
+    elif gen is not None and fdir2 is not None:
+        if verbose:
+            print(f"compute KID of a model, using references in fdir2")
+        # get all inception features for the second folder
+        fbname2 = os.path.basename(fdir2)
+        ref_feats = get_folder_features(fdir2, feat_model, num_workers=num_workers,
+                                        batch_size=batch_size, device=device, mode=mode,
+                                        description=f"KID {fbname2} : ")
+        # Generate test features
+        np_feats = get_model_features(gen, feat_model, mode=mode,
+                                      z_dim=z_dim, num_gen=num_gen, desc="KID model: ",
+                                      batch_size=batch_size, device=device)
+        score = kernel_distance(ref_feats, np_feats)
+        return score
+
+    # compute fid for a generator, using reference statistics
+    elif gen is not None:
+        if verbose:
+            print(
+                f"compute KID of a model with {dataset_name}-{dataset_res} statistics")
+        ref_feats = get_reference_statistics(dataset_name, dataset_res,
+                                             mode=mode, seed=0, split=dataset_split, metric="KID")
+        # Generate test features
+        np_feats = get_model_features(gen, feat_model, mode=mode,
+                                      z_dim=z_dim, num_gen=num_gen, desc="KID model: ",
+                                      batch_size=batch_size, device=device, verbose=verbose)
+        score = kernel_distance(ref_feats, np_feats)
+        return score
+
+    else:
+        raise ValueError(
+            "invalid combination of directories and models entered")
+
+
+"""
+custom_image_tranform:
+    function that takes an np_array image as input [0,255] and
+    applies a custom transform such as cropping
+"""
+
+
+def compute_fid(fdir1=None, fdir2=None, gen=None,
+                mode="clean", model_name="inception_v3", num_workers=12,
+                batch_size=32, device=torch.device("cuda"), dataset_name="FFHQ",
+                dataset_res=1024, dataset_split="train", num_gen=50_000, z_dim=512,
+                custom_feat_extractor=None, verbose=True,
+                custom_image_tranform=None, custom_fn_resize=None,
+                use_dataparallel=True, pred_arr=None
+                ):
+    # build the feature extractor based on the mode and the model to be used
+    if custom_feat_extractor is None and model_name == "inception_v3":
+        feat_model = build_feature_extractor(
+            mode, device, use_dataparallel=use_dataparallel)
+    elif custom_feat_extractor is None and model_name == "clip_vit_b_32":
+        from causvid.evaluation.coco_eval.cleanfid.clip_features import CLIP_fx, img_preprocess_clip
+        clip_fx = CLIP_fx("ViT-B/32", device=device)
+        feat_model = clip_fx
+        custom_fn_resize = img_preprocess_clip
+    else:
+        feat_model = custom_feat_extractor
+
+    # if both dirs are specified, compute FID between folders
+    if fdir1 is not None and fdir2 is not None:
+        if verbose:
+            print("compute FID between two folders")
+        score = compare_folders(fdir1, fdir2, feat_model,
+                                mode=mode, batch_size=batch_size,
+                                num_workers=num_workers, device=device,
+                                custom_image_tranform=custom_image_tranform,
+                                custom_fn_resize=custom_fn_resize,
+                                verbose=verbose)
+        return score
+
+    # compute fid of a folder
+    elif fdir1 is not None and fdir2 is None:
+        if verbose:
+            print(f"compute FID of a folder with {dataset_name} statistics")
+        score = fid_folder(fdir1, dataset_name, dataset_res, dataset_split,
+                           model=feat_model, mode=mode, model_name=model_name,
+                           custom_fn_resize=custom_fn_resize, custom_image_tranform=custom_image_tranform,
+                           num_workers=num_workers, batch_size=batch_size, device=device, verbose=verbose)
+        return score
+
+    # compute fid for a generator, using images in fdir2
+    elif gen is not None and fdir2 is not None:
+        if verbose:
+            print(f"compute FID of a model, using references in fdir2")
+        # get all inception features for the second folder
+        fbname2 = os.path.basename(fdir2)
+        np_feats2 = get_folder_features(fdir2, feat_model, num_workers=num_workers,
+                                        batch_size=batch_size, device=device, mode=mode,
+                                        description=f"FID {fbname2} : ", verbose=verbose,
+                                        custom_fn_resize=custom_fn_resize,
+                                        custom_image_tranform=custom_image_tranform)
+        mu2 = np.mean(np_feats2, axis=0)
+        sigma2 = np.cov(np_feats2, rowvar=False)
+        # Generate test features
+        np_feats = get_model_features(gen, feat_model, mode=mode,
+                                      z_dim=z_dim, num_gen=num_gen,
+                                      custom_fn_resize=custom_fn_resize,
+                                      custom_image_tranform=custom_image_tranform,
+                                      batch_size=batch_size, device=device, verbose=verbose)
+
+        mu = np.mean(np_feats, axis=0)
+        sigma = np.cov(np_feats, rowvar=False)
+        fid = frechet_distance(mu, sigma, mu2, sigma2)
+        return fid
+
+    # compute fid for a generator, using reference statistics
+    elif gen is not None:
+        if verbose:
+            print(
+                f"compute FID of a model with {dataset_name}-{dataset_res} statistics")
+        score = fid_model(gen, dataset_name, dataset_res, dataset_split,
+                          model=feat_model, model_name=model_name, z_dim=z_dim, num_gen=num_gen,
+                          mode=mode, num_workers=num_workers, batch_size=batch_size,
+                          custom_image_tranform=custom_image_tranform, custom_fn_resize=custom_fn_resize,
+                          device=device, verbose=verbose)
+        return score
+
+    elif pred_arr is not None:
+        if verbose:
+            print(f"compute FID of a model, using references in fdir2")
+        # get all inception features for the second folder
+        fbname2 = os.path.basename(fdir2)
+        np_feats2 = get_folder_features(fdir2, feat_model, num_workers=num_workers,
+                                        batch_size=batch_size, device=device, mode=mode,
+                                        description=f"FID {fbname2} : ", verbose=verbose,
+                                        custom_fn_resize=custom_fn_resize,
+                                        custom_image_tranform=custom_image_tranform)
+        mu2 = np.mean(np_feats2, axis=0)
+        sigma2 = np.cov(np_feats2, rowvar=False)
+
+        # compute fid statistcs using the numpy array
+        np_feats = get_array_features(
+            pred_arr, model=feat_model, num_workers=num_workers,
+            batch_size=batch_size, device=device, mode=mode,
+            custom_fn_resize=custom_fn_resize,
+            custom_image_tranform=custom_image_tranform
+        )
+        mu = np.mean(np_feats, axis=0)
+        sigma = np.cov(np_feats, rowvar=False)
+        fid = frechet_distance(mu, sigma, mu2, sigma2)
+        return fid
+        # return fid, np_feats, np_feats2
+    else:
+        raise ValueError(
+            "invalid combination of directories and models entered")

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/inception_pytorch.py

@@ -0,0 +1,332 @@
+"""
+File from: https://github.com/mseitzer/pytorch-fid
+"""
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision
+
+try:
+    from torchvision.models.utils import load_state_dict_from_url
+except ImportError:
+    from torch.utils.model_zoo import load_url as load_state_dict_from_url
+
+# Inception weights ported to Pytorch from
+# http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz
+FID_WEIGHTS_URL = 'https://github.com/mseitzer/pytorch-fid/releases/download/fid_weights/pt_inception-2015-12-05-6726825d.pth'  # noqa: E501
+
+
+class InceptionV3(nn.Module):
+    """Pretrained InceptionV3 network returning feature maps"""
+
+    # Index of default block of inception to return,
+    # corresponds to output of final average pooling
+    DEFAULT_BLOCK_INDEX = 3
+
+    # Maps feature dimensionality to their output blocks indices
+    BLOCK_INDEX_BY_DIM = {
+        64: 0,   # First max pooling features
+        192: 1,  # Second max pooling featurs
+        768: 2,  # Pre-aux classifier features
+        2048: 3  # Final average pooling features
+    }
+
+    def __init__(self,
+                 output_blocks=(DEFAULT_BLOCK_INDEX,),
+                 resize_input=True,
+                 normalize_input=True,
+                 requires_grad=False,
+                 use_fid_inception=True):
+        """Build pretrained InceptionV3
+        Parameters
+        ----------
+        output_blocks : list of int
+            Indices of blocks to return features of. Possible values are:
+                - 0: corresponds to output of first max pooling
+                - 1: corresponds to output of second max pooling
+                - 2: corresponds to output which is fed to aux classifier
+                - 3: corresponds to output of final average pooling
+        resize_input : bool
+            If true, bilinearly resizes input to width and height 299 before
+            feeding input to model. As the network without fully connected
+            layers is fully convolutional, it should be able to handle inputs
+            of arbitrary size, so resizing might not be strictly needed
+        normalize_input : bool
+            If true, scales the input from range (0, 1) to the range the
+            pretrained Inception network expects, namely (-1, 1)
+        requires_grad : bool
+            If true, parameters of the model require gradients. Possibly useful
+            for finetuning the network
+        use_fid_inception : bool
+            If true, uses the pretrained Inception model used in Tensorflow's
+            FID implementation. If false, uses the pretrained Inception model
+            available in torchvision. The FID Inception model has different
+            weights and a slightly different structure from torchvision's
+            Inception model. If you want to compute FID scores, you are
+            strongly advised to set this parameter to true to get comparable
+            results.
+        """
+        super(InceptionV3, self).__init__()
+
+        self.resize_input = resize_input
+        self.normalize_input = normalize_input
+        self.output_blocks = sorted(output_blocks)
+        self.last_needed_block = max(output_blocks)
+
+        assert self.last_needed_block <= 3, \
+            'Last possible output block index is 3'
+
+        self.blocks = nn.ModuleList()
+
+        if use_fid_inception:
+            inception = fid_inception_v3()
+        else:
+            inception = _inception_v3(pretrained=True)
+
+        # Block 0: input to maxpool1
+        block0 = [
+            inception.Conv2d_1a_3x3,
+            inception.Conv2d_2a_3x3,
+            inception.Conv2d_2b_3x3,
+            nn.MaxPool2d(kernel_size=3, stride=2)
+        ]
+        self.blocks.append(nn.Sequential(*block0))
+
+        # Block 1: maxpool1 to maxpool2
+        if self.last_needed_block >= 1:
+            block1 = [
+                inception.Conv2d_3b_1x1,
+                inception.Conv2d_4a_3x3,
+                nn.MaxPool2d(kernel_size=3, stride=2)
+            ]
+            self.blocks.append(nn.Sequential(*block1))
+
+        # Block 2: maxpool2 to aux classifier
+        if self.last_needed_block >= 2:
+            block2 = [
+                inception.Mixed_5b,
+                inception.Mixed_5c,
+                inception.Mixed_5d,
+                inception.Mixed_6a,
+                inception.Mixed_6b,
+                inception.Mixed_6c,
+                inception.Mixed_6d,
+                inception.Mixed_6e,
+            ]
+            self.blocks.append(nn.Sequential(*block2))
+
+        # Block 3: aux classifier to final avgpool
+        if self.last_needed_block >= 3:
+            block3 = [
+                inception.Mixed_7a,
+                inception.Mixed_7b,
+                inception.Mixed_7c,
+                nn.AdaptiveAvgPool2d(output_size=(1, 1))
+            ]
+            self.blocks.append(nn.Sequential(*block3))
+
+        for param in self.parameters():
+            param.requires_grad = requires_grad
+
+    def forward(self, inp):
+        """Get Inception feature maps
+        Parameters
+        ----------
+        inp : torch.autograd.Variable
+            Input tensor of shape Bx3xHxW. Values are expected to be in
+            range (0, 1)
+        Returns
+        -------
+        List of torch.autograd.Variable, corresponding to the selected output
+        block, sorted ascending by index
+        """
+        outp = []
+        x = inp
+
+        if self.resize_input:
+            raise ValueError("should not resize here")
+            x = F.interpolate(x,
+                              size=(299, 299),
+                              mode='bilinear',
+                              align_corners=False)
+
+        if self.normalize_input:
+            x = 2 * x - 1  # Scale from range (0, 1) to range (-1, 1)
+
+        for idx, block in enumerate(self.blocks):
+            x = block(x)
+            if idx in self.output_blocks:
+                outp.append(x)
+
+            if idx == self.last_needed_block:
+                break
+
+        return outp
+
+
+def _inception_v3(*args, **kwargs):
+    """Wraps `torchvision.models.inception_v3`
+    Skips default weight inititialization if supported by torchvision version.
+    See https://github.com/mseitzer/pytorch-fid/issues/28.
+    """
+    try:
+        version = tuple(map(int, torchvision.__version__.split('.')[:2]))
+    except ValueError:
+        # Just a caution against weird version strings
+        version = (0,)
+
+    if version >= (0, 6):
+        kwargs['init_weights'] = False
+
+    return torchvision.models.inception_v3(*args, **kwargs)
+
+
+def fid_inception_v3():
+    """Build pretrained Inception model for FID computation
+    The Inception model for FID computation uses a different set of weights
+    and has a slightly different structure than torchvision's Inception.
+    This method first constructs torchvision's Inception and then patches the
+    necessary parts that are different in the FID Inception model.
+    """
+    inception = _inception_v3(num_classes=1008,
+                              aux_logits=False,
+                              pretrained=False)
+    inception.Mixed_5b = FIDInceptionA(192, pool_features=32)
+    inception.Mixed_5c = FIDInceptionA(256, pool_features=64)
+    inception.Mixed_5d = FIDInceptionA(288, pool_features=64)
+    inception.Mixed_6b = FIDInceptionC(768, channels_7x7=128)
+    inception.Mixed_6c = FIDInceptionC(768, channels_7x7=160)
+    inception.Mixed_6d = FIDInceptionC(768, channels_7x7=160)
+    inception.Mixed_6e = FIDInceptionC(768, channels_7x7=192)
+    inception.Mixed_7b = FIDInceptionE_1(1280)
+    inception.Mixed_7c = FIDInceptionE_2(2048)
+
+    state_dict = load_state_dict_from_url(FID_WEIGHTS_URL, progress=False)
+    inception.load_state_dict(state_dict)
+    return inception
+
+
+class FIDInceptionA(torchvision.models.inception.InceptionA):
+    """InceptionA block patched for FID computation"""
+
+    def __init__(self, in_channels, pool_features):
+        super(FIDInceptionA, self).__init__(in_channels, pool_features)
+
+    def forward(self, x):
+        branch1x1 = self.branch1x1(x)
+
+        branch5x5 = self.branch5x5_1(x)
+        branch5x5 = self.branch5x5_2(branch5x5)
+
+        branch3x3dbl = self.branch3x3dbl_1(x)
+        branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
+        branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl)
+
+        # Patch: Tensorflow's average pool does not use the padded zero's in
+        # its average calculation
+        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,
+                                   count_include_pad=False)
+        branch_pool = self.branch_pool(branch_pool)
+
+        outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool]
+        return torch.cat(outputs, 1)
+
+
+class FIDInceptionC(torchvision.models.inception.InceptionC):
+    """InceptionC block patched for FID computation"""
+
+    def __init__(self, in_channels, channels_7x7):
+        super(FIDInceptionC, self).__init__(in_channels, channels_7x7)
+
+    def forward(self, x):
+        branch1x1 = self.branch1x1(x)
+
+        branch7x7 = self.branch7x7_1(x)
+        branch7x7 = self.branch7x7_2(branch7x7)
+        branch7x7 = self.branch7x7_3(branch7x7)
+
+        branch7x7dbl = self.branch7x7dbl_1(x)
+        branch7x7dbl = self.branch7x7dbl_2(branch7x7dbl)
+        branch7x7dbl = self.branch7x7dbl_3(branch7x7dbl)
+        branch7x7dbl = self.branch7x7dbl_4(branch7x7dbl)
+        branch7x7dbl = self.branch7x7dbl_5(branch7x7dbl)
+
+        # Patch: Tensorflow's average pool does not use the padded zero's in
+        # its average calculation
+        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,
+                                   count_include_pad=False)
+        branch_pool = self.branch_pool(branch_pool)
+
+        outputs = [branch1x1, branch7x7, branch7x7dbl, branch_pool]
+        return torch.cat(outputs, 1)
+
+
+class FIDInceptionE_1(torchvision.models.inception.InceptionE):
+    """First InceptionE block patched for FID computation"""
+
+    def __init__(self, in_channels):
+        super(FIDInceptionE_1, self).__init__(in_channels)
+
+    def forward(self, x):
+        branch1x1 = self.branch1x1(x)
+
+        branch3x3 = self.branch3x3_1(x)
+        branch3x3 = [
+            self.branch3x3_2a(branch3x3),
+            self.branch3x3_2b(branch3x3),
+        ]
+        branch3x3 = torch.cat(branch3x3, 1)
+
+        branch3x3dbl = self.branch3x3dbl_1(x)
+        branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
+        branch3x3dbl = [
+            self.branch3x3dbl_3a(branch3x3dbl),
+            self.branch3x3dbl_3b(branch3x3dbl),
+        ]
+        branch3x3dbl = torch.cat(branch3x3dbl, 1)
+
+        # Patch: Tensorflow's average pool does not use the padded zero's in
+        # its average calculation
+        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,
+                                   count_include_pad=False)
+        branch_pool = self.branch_pool(branch_pool)
+
+        outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]
+        return torch.cat(outputs, 1)
+
+
+class FIDInceptionE_2(torchvision.models.inception.InceptionE):
+    """Second InceptionE block patched for FID computation"""
+
+    def __init__(self, in_channels):
+        super(FIDInceptionE_2, self).__init__(in_channels)
+
+    def forward(self, x):
+        branch1x1 = self.branch1x1(x)
+
+        branch3x3 = self.branch3x3_1(x)
+        branch3x3 = [
+            self.branch3x3_2a(branch3x3),
+            self.branch3x3_2b(branch3x3),
+        ]
+        branch3x3 = torch.cat(branch3x3, 1)
+
+        branch3x3dbl = self.branch3x3dbl_1(x)
+        branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
+        branch3x3dbl = [
+            self.branch3x3dbl_3a(branch3x3dbl),
+            self.branch3x3dbl_3b(branch3x3dbl),
+        ]
+        branch3x3dbl = torch.cat(branch3x3dbl, 1)
+
+        # Patch: The FID Inception model uses max pooling instead of average
+        # pooling. This is likely an error in this specific Inception
+        # implementation, as other Inception models use average pooling here
+        # (which matches the description in the paper).
+        branch_pool = F.max_pool2d(x, kernel_size=3, stride=1, padding=1)
+        branch_pool = self.branch_pool(branch_pool)
+
+        outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]
+        return torch.cat(outputs, 1)

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/inception_torchscript.py

@@ -0,0 +1,57 @@
+import os
+import torch
+import torch.nn as nn
+from causvid.evaluation.coco_eval.cleanfid.downloads_helper import *
+import contextlib
+
+
+@contextlib.contextmanager
+def disable_gpu_fuser_on_pt19():
+    # On PyTorch 1.9 a CUDA fuser bug prevents the Inception JIT model to run. See
+    #   https://github.com/GaParmar/clean-fid/issues/5
+    #   https://github.com/pytorch/pytorch/issues/64062
+    if torch.__version__.startswith('1.9.'):
+        old_val = torch._C._jit_can_fuse_on_gpu()
+        torch._C._jit_override_can_fuse_on_gpu(False)
+    yield
+    if torch.__version__.startswith('1.9.'):
+        torch._C._jit_override_can_fuse_on_gpu(old_val)
+
+
+class InceptionV3W(nn.Module):
+    """
+    Wrapper around Inception V3 torchscript model provided here
+    https://nvlabs-fi-cdn.nvidia.com/stylegan2-ada-pytorch/pretrained/metrics/inception-2015-12-05.pt
+
+    path: locally saved inception weights
+    """
+
+    def __init__(self, path, download=True, resize_inside=False):
+        super(InceptionV3W, self).__init__()
+        # download the network if it is not present at the given directory
+        # use the current directory by default
+        if download:
+            check_download_inception(fpath=path)
+        path = os.path.join(path, "inception-2015-12-05.pt")
+        self.base = torch.jit.load(path).eval()
+        self.layers = self.base.layers
+        self.resize_inside = resize_inside
+
+    """
+    Get the inception features without resizing
+    x: Image with values in range [0,255]
+    """
+
+    def forward(self, x):
+        with disable_gpu_fuser_on_pt19():
+            bs = x.shape[0]
+            if self.resize_inside:
+                features = self.base(x, return_features=True).view((bs, 2048))
+            else:
+                # make sure it is resized already
+                assert (x.shape[2] == 299) and (x.shape[3] == 299)
+                # apply normalization
+                x1 = x - 128
+                x2 = x1 / 128
+                features = self.layers.forward(x2, ).view((bs, 2048))
+            return features

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/leaderboard.py

@@ -0,0 +1,43 @@
+import os
+import csv
+import shutil
+import urllib.request
+
+
+def get_score(model_name=None, dataset_name=None,
+              dataset_res=None, dataset_split=None, task_name=None):
+    # download the csv file from server
+    url = "https://www.cs.cmu.edu/~clean-fid/files/leaderboard.csv"
+    local_path = "/tmp/leaderboard.csv"
+    with urllib.request.urlopen(url) as response, open(local_path, 'wb') as f:
+        shutil.copyfileobj(response, f)
+
+    d_field2idx = {}
+    l_matches = []
+    with open(local_path, 'r') as f:
+        csvreader = csv.reader(f)
+        l_fields = next(csvreader)
+        for idx, val in enumerate(l_fields):
+            d_field2idx[val.strip()] = idx
+        # iterate through all rows
+        for row in csvreader:
+            # skip empty rows
+            if len(row) == 0:
+                continue
+            # skip if the filter doesn't match
+            if model_name is not None and (row[d_field2idx["model_name"]].strip() != model_name):
+                continue
+            if dataset_name is not None and (row[d_field2idx["dataset_name"]].strip() != dataset_name):
+                continue
+            if dataset_res is not None and (row[d_field2idx["dataset_res"]].strip() != dataset_res):
+                continue
+            if dataset_split is not None and (row[d_field2idx["dataset_split"]].strip() != dataset_split):
+                continue
+            if task_name is not None and (row[d_field2idx["task_name"]].strip() != task_name):
+                continue
+            curr = {}
+            for f in l_fields:
+                curr[f.strip()] = row[d_field2idx[f.strip()]].strip()
+            l_matches.append(curr)
+    os.remove(local_path)
+    return l_matches

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/resize.py

@@ -0,0 +1,133 @@
+"""
+Helpers for resizing with multiple CPU cores
+"""
+import os
+import numpy as np
+import torch
+from PIL import Image
+import torch.nn.functional as F
+
+
+def build_resizer(mode):
+    if mode == "clean":
+        return make_resizer("PIL", False, "bicubic", (299, 299))
+    # if using legacy tensorflow, do not manually resize outside the network
+    elif mode == "legacy_tensorflow":
+        return lambda x: x
+    elif mode == "legacy_pytorch":
+        return make_resizer("PyTorch", False, "bilinear", (299, 299))
+    else:
+        raise ValueError(f"Invalid mode {mode} specified")
+
+
+"""
+Construct a function that resizes a numpy image based on the
+flags passed in.
+"""
+
+
+def make_resizer(library, quantize_after, filter, output_size):
+    if library == "PIL" and quantize_after:
+        name_to_filter = {
+            "bicubic": Image.BICUBIC,
+            "bilinear": Image.BILINEAR,
+            "nearest": Image.NEAREST,
+            "lanczos": Image.LANCZOS,
+            "box": Image.BOX
+        }
+
+        def func(x):
+            x = Image.fromarray(x)
+            x = x.resize(output_size, resample=name_to_filter[filter])
+            x = np.asarray(x).clip(0, 255).astype(np.uint8)
+            return x
+    elif library == "PIL" and not quantize_after:
+        name_to_filter = {
+            "bicubic": Image.BICUBIC,
+            "bilinear": Image.BILINEAR,
+            "nearest": Image.NEAREST,
+            "lanczos": Image.LANCZOS,
+            "box": Image.BOX
+        }
+        s1, s2 = output_size
+
+        def resize_single_channel(x_np):
+            img = Image.fromarray(x_np.astype(np.float32), mode='F')
+            img = img.resize(output_size, resample=name_to_filter[filter])
+            return np.asarray(img).clip(0, 255).reshape(s2, s1, 1)
+
+        def func(x):
+            x = [resize_single_channel(x[:, :, idx]) for idx in range(3)]
+            x = np.concatenate(x, axis=2).astype(np.float32)
+            return x
+    elif library == "PyTorch":
+        import warnings
+        # ignore the numpy warnings
+        warnings.filterwarnings("ignore")
+
+        def func(x):
+            x = torch.Tensor(x.transpose((2, 0, 1)))[None, ...]
+            x = F.interpolate(x, size=output_size, mode=filter, align_corners=False)
+            x = x[0, ...].cpu().data.numpy().transpose((1, 2, 0)).clip(0, 255)
+            if quantize_after:
+                x = x.astype(np.uint8)
+            return x
+    elif library == "TensorFlow":
+        import warnings
+        # ignore the numpy warnings
+        warnings.filterwarnings("ignore")
+        import tensorflow as tf
+
+        def func(x):
+            x = tf.constant(x)[tf.newaxis, ...]
+            x = tf.image.resize(x, output_size, method=filter)
+            x = x[0, ...].numpy().clip(0, 255)
+            if quantize_after:
+                x = x.astype(np.uint8)
+            return x
+    elif library == "OpenCV":
+        import cv2
+        name_to_filter = {
+            "bilinear": cv2.INTER_LINEAR,
+            "bicubic": cv2.INTER_CUBIC,
+            "lanczos": cv2.INTER_LANCZOS4,
+            "nearest": cv2.INTER_NEAREST,
+            "area": cv2.INTER_AREA
+        }
+
+        def func(x):
+            x = cv2.resize(x, output_size, interpolation=name_to_filter[filter])
+            x = x.clip(0, 255)
+            if quantize_after:
+                x = x.astype(np.uint8)
+            return x
+    else:
+        raise NotImplementedError('library [%s] is not include' % library)
+    return func
+
+
+class FolderResizer(torch.utils.data.Dataset):
+    def __init__(self, files, outpath, fn_resize, output_ext=".png"):
+        self.files = files
+        self.outpath = outpath
+        self.output_ext = output_ext
+        self.fn_resize = fn_resize
+
+    def __len__(self):
+        return len(self.files)
+
+    def __getitem__(self, i):
+        path = str(self.files[i])
+        img_np = np.asarray(Image.open(path))
+        img_resize_np = self.fn_resize(img_np)
+        # swap the output extension
+        basename = os.path.basename(path).split(".")[0] + self.output_ext
+        outname = os.path.join(self.outpath, basename)
+        if self.output_ext == ".npy":
+            np.save(outname, img_resize_np)
+        elif self.output_ext == ".png":
+            img_resized_pil = Image.fromarray(img_resize_np)
+            img_resized_pil.save(outname)
+        else:
+            raise ValueError("invalid output extension")
+        return 0

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/utils.py

@@ -0,0 +1,98 @@
+import numpy as np
+import torch
+import torchvision
+from PIL import Image
+from causvid.evaluation.coco_eval.cleanfid.resize import build_resizer
+import zipfile
+
+
+class ResizeDataset(torch.utils.data.Dataset):
+    """
+    A placeholder Dataset that enables parallelizing the resize operation
+    using multiple CPU cores
+
+    files: list of all files in the folder
+    fn_resize: function that takes an np_array as input [0,255]
+    """
+
+    def __init__(self, files, mode, size=(299, 299), fdir=None):
+        self.files = files
+        self.fdir = fdir
+        self.transforms = torchvision.transforms.ToTensor()
+        self.size = size
+        self.fn_resize = build_resizer(mode)
+        self.custom_image_tranform = lambda x: x
+        self._zipfile = None
+
+    def _get_zipfile(self):
+        assert self.fdir is not None and '.zip' in self.fdir
+        if self._zipfile is None:
+            self._zipfile = zipfile.ZipFile(self.fdir)
+        return self._zipfile
+
+    def __len__(self):
+        return len(self.files)
+
+    def __getitem__(self, i):
+        path = str(self.files[i])
+        if self.fdir is not None and '.zip' in self.fdir:
+            with self._get_zipfile().open(path, 'r') as f:
+                img_np = np.array(Image.open(f).convert('RGB'))
+        elif ".npy" in path:
+            img_np = np.load(path)
+        else:
+            img_pil = Image.open(path).convert('RGB')
+            img_np = np.array(img_pil)
+
+        # apply a custom image transform before resizing the image to 299x299
+        img_np = self.custom_image_tranform(img_np)
+        # fn_resize expects a np array and returns a np array
+        img_resized = self.fn_resize(img_np)
+
+        # ToTensor() converts to [0,1] only if input in uint8
+        if img_resized.dtype == "uint8":
+            img_t = self.transforms(np.array(img_resized)) * 255
+        elif img_resized.dtype == "float32":
+            img_t = self.transforms(img_resized)
+
+        return img_t
+
+
+EXTENSIONS = {'bmp', 'jpg', 'jpeg', 'pgm', 'png', 'ppm',
+              'tif', 'tiff', 'webp', 'npy', 'JPEG', 'JPG', 'PNG'}
+
+
+class ResizeArrayDataset(torch.utils.data.Dataset):
+    """
+    A placeholder Dataset that enables parallelizing the resize operation
+    using multiple CPU cores
+
+    files: list of all files in the folder
+    fn_resize: function that takes an np_array as input [0,255]
+    """
+
+    def __init__(self, array, mode, size=(299, 299)):
+        self.array = array
+        self.transforms = torchvision.transforms.ToTensor()
+        self.size = size
+        self.fn_resize = build_resizer(mode)
+        self.custom_image_tranform = lambda x: x
+
+    def __len__(self):
+        return len(self.array)
+
+    def __getitem__(self, i):
+        img_np = self.array[i]
+
+        # apply a custom image transform before resizing the image to 299x299
+        img_np = self.custom_image_tranform(img_np)
+        # fn_resize expects a np array and returns a np array
+        img_resized = self.fn_resize(img_np)
+
+        # ToTensor() converts to [0,1] only if input in uint8
+        if img_resized.dtype == "uint8":
+            img_t = self.transforms(np.array(img_resized)) * 255
+        elif img_resized.dtype == "float32":
+            img_t = self.transforms(img_resized)
+
+        return img_t

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/cleanfid/wrappers.py

@@ -0,0 +1,108 @@
+from PIL import Image
+import numpy as np
+import torch
+from causvid.evaluation.coco_eval.cleanfid.features import build_feature_extractor, get_reference_statistics
+from causvid.evaluation.coco_eval.cleanfid.fid import get_batch_features, fid_from_feats
+from causvid.evaluation.coco_eval.cleanfid.resize import build_resizer
+
+
+"""
+A helper class that allowing adding the images one batch at a time.
+"""
+
+
+class CleanFID():
+    def __init__(self, mode="clean", model_name="inception_v3", device="cuda"):
+        self.real_features = []
+        self.gen_features = []
+        self.mode = mode
+        self.device = device
+        if model_name == "inception_v3":
+            self.feat_model = build_feature_extractor(mode, device)
+            self.fn_resize = build_resizer(mode)
+        elif model_name == "clip_vit_b_32":
+            from causvid.evaluation.coco_eval.cleanfid.clip_features import CLIP_fx, img_preprocess_clip
+            clip_fx = CLIP_fx("ViT-B/32")
+            self.feat_model = clip_fx
+            self.fn_resize = img_preprocess_clip
+
+    """
+    Funtion that takes an image (PIL.Image or np.array or torch.tensor)
+    and returns the corresponding feature embedding vector.
+    The image x is expected to be in range [0, 255]
+    """
+
+    def compute_features(self, x):
+        # if x is a PIL Image
+        if isinstance(x, Image.Image):
+            x_np = np.array(x)
+            x_np_resized = self.fn_resize(x_np)
+            x_t = torch.tensor(x_np_resized.transpose((2, 0, 1))).unsqueeze(0)
+            x_feat = get_batch_features(x_t, self.feat_model, self.device)
+        elif isinstance(x, np.ndarray):
+            x_np_resized = self.fn_resize(x)
+            x_t = torch.tensor(x_np_resized.transpose(
+                (2, 0, 1))).unsqueeze(0).to(self.device)
+            # normalization happens inside the self.feat_model, expected image range here is [0,255]
+            x_feat = get_batch_features(x_t, self.feat_model, self.device)
+        elif isinstance(x, torch.Tensor):
+            # pdb.set_trace()
+            # add the batch dimension if x is passed in as C,H,W
+            if len(x.shape) == 3:
+                x = x.unsqueeze(0)
+            b, c, h, w = x.shape
+            # convert back to np array and resize
+            l_x_np_resized = []
+            for _ in range(b):
+                x_np = x[_].cpu().numpy().transpose((1, 2, 0))
+                l_x_np_resized.append(self.fn_resize(x_np)[None,])
+            x_np_resized = np.concatenate(l_x_np_resized)
+            x_t = torch.tensor(x_np_resized.transpose(
+                (0, 3, 1, 2))).to(self.device)
+            # normalization happens inside the self.feat_model, expected image range here is [0,255]
+            x_feat = get_batch_features(x_t, self.feat_model, self.device)
+        else:
+            raise ValueError("image type could not be inferred")
+        return x_feat
+
+    """
+    Extract the faetures from x and add to the list of reference real images
+    """
+
+    def add_real_images(self, x):
+        x_feat = self.compute_features(x)
+        self.real_features.append(x_feat)
+
+    """
+    Extract the faetures from x and add to the list of generated images
+    """
+
+    def add_gen_images(self, x):
+        x_feat = self.compute_features(x)
+        self.gen_features.append(x_feat)
+
+    """
+    Compute FID between the real and generated images added so far
+    """
+
+    def calculate_fid(self, verbose=True):
+        feats1 = np.concatenate(self.real_features)
+        feats2 = np.concatenate(self.gen_features)
+        if verbose:
+            print(f"# real images = {feats1.shape[0]}")
+            print(f"# generated images = {feats2.shape[0]}")
+        return fid_from_feats(feats1, feats2)
+
+    """
+    Remove the real image features added so far
+    """
+
+    def reset_real_features(self):
+        self.real_features = []
+
+    """
+    Remove the generated image features added so far
+    """
+
+    def reset_gen_features(self):
+        self.gen_features = []

exp_code/1_benchmark/CausVid/causvid/evaluation/coco_eval/coco_evaluator.py

@@ -0,0 +1,246 @@
+# Part of this code is modified from GigaGAN: https://github.com/mingukkang/GigaGAN
+# The MIT License (MIT)
+from causvid.evaluation.coco_eval.cleanfid import fid
+from torchvision.transforms import InterpolationMode
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader
+from torch.utils.data import Dataset
+from PIL import Image
+import numpy as np
+import shutil
+import torch
+import time
+import os
+
+resizer_collection = {"nearest": InterpolationMode.NEAREST,
+                      "box": InterpolationMode.BOX,
+                      "bilinear": InterpolationMode.BILINEAR,
+                      "hamming": InterpolationMode.HAMMING,
+                      "bicubic": InterpolationMode.BICUBIC,
+                      "lanczos": InterpolationMode.LANCZOS}
+
+
+class CenterCropLongEdge(object):
+    """
+    this code is borrowed from https://github.com/ajbrock/BigGAN-PyTorch
+    MIT License
+    Copyright (c) 2019 Andy Brock
+    """
+
+    def __call__(self, img):
+        return transforms.functional.center_crop(img, min(img.size))
+
+    def __repr__(self):
+        return self.__class__.__name__
+
+
+@torch.no_grad()
+def compute_fid(fake_arr, gt_dir, device,
+                resize_size=None, feature_extractor="inception",
+                patch_fid=False):
+    center_crop_trsf = CenterCropLongEdge()
+
+    def resize_and_center_crop(image_np):
+        image_pil = Image.fromarray(image_np)
+        if patch_fid:
+            # if image_pil.size[0] != 1024 and image_pil.size[1] != 1024:
+            #     image_pil = image_pil.resize([1024, 1024])
+
+            # directly crop to the 299 x 299 patch expected by the inception network
+            if image_pil.size[0] >= 299 and image_pil.size[1] >= 299:
+                image_pil = transforms.functional.center_crop(image_pil, 299)
+            # else:
+            #     raise ValueError("Image is too small to crop to 299 x 299")
+        else:
+            image_pil = center_crop_trsf(image_pil)
+
+            if resize_size is not None:
+                image_pil = image_pil.resize((resize_size, resize_size),
+                                             Image.LANCZOS)
+        return np.array(image_pil)
+
+    if feature_extractor == "inception":
+        model_name = "inception_v3"
+    elif feature_extractor == "clip":
+        model_name = "clip_vit_b_32"
+    else:
+        raise ValueError(
+            "Unrecognized feature extractor [%s]" % feature_extractor)
+    # fid, fake_feats, real_feats = fid.compute_fid(
+    stat = fid.compute_fid(
+        None,
+        gt_dir,
+        model_name=model_name,
+        custom_image_tranform=resize_and_center_crop,
+        use_dataparallel=False,
+        device=device,
+        pred_arr=fake_arr
+    )
+    # return fid, fake_feats, real_feats
+    return stat
+
+
+def evaluate_model(args, device, all_images, patch_fid=False):
+    fid = compute_fid(
+        fake_arr=all_images,
+        gt_dir=args.ref_dir,
+        device=device,
+        resize_size=args.eval_res,
+        feature_extractor="inception",
+        patch_fid=patch_fid
+    )
+
+    return fid
+
+
+def tensor2pil(image: torch.Tensor):
+    ''' output image : tensor to PIL
+    '''
+    if isinstance(image, list) or image.ndim == 4:
+        return [tensor2pil(im) for im in image]
+
+    assert image.ndim == 3
+    output_image = Image.fromarray(((image + 1.0) * 127.5).clamp(
+        0.0, 255.0).to(torch.uint8).permute(1, 2, 0).detach().cpu().numpy())
+    return output_image
+
+
+class CLIPScoreDataset(Dataset):
+    def __init__(self, images, captions, transform, preprocessor) -> None:
+        super().__init__()
+        self.images = images
+        self.captions = captions
+        self.transform = transform
+        self.preprocessor = preprocessor
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, index):
+        image = self.images[index]
+        image_pil = self.transform(image)
+        image_pil = self.preprocessor(image_pil)
+        caption = self.captions[index]
+        return image_pil, caption
+
+
+@torch.no_grad()
+def compute_clip_score(
+        images, captions, clip_model="ViT-B/32", device="cuda", how_many=30000):
+    print("Computing CLIP score")
+    import clip as openai_clip
+    if clip_model == "ViT-B/32":
+        clip, clip_preprocessor = openai_clip.load("ViT-B/32", device=device)
+        clip = clip.eval()
+    elif clip_model == "ViT-G/14":
+        import open_clip
+        clip, _, clip_preprocessor = open_clip.create_model_and_transforms(
+            "ViT-g-14", pretrained="laion2b_s12b_b42k")
+        clip = clip.to(device)
+        clip = clip.eval()
+        clip = clip.float()
+    else:
+        raise NotImplementedError
+
+    def resize_and_center_crop(image_np, resize_size=256):
+        image_pil = Image.fromarray(image_np)
+        image_pil = CenterCropLongEdge()(image_pil)
+
+        if resize_size is not None:
+            image_pil = image_pil.resize((resize_size, resize_size),
+                                         Image.LANCZOS)
+        return image_pil
+
+    def simple_collate(batch):
+        images, captions = [], []
+        for img, cap in batch:
+            images.append(img)
+            captions.append(cap)
+        return images, captions
+
+    dataset = CLIPScoreDataset(
+        images, captions, transform=resize_and_center_crop,
+        preprocessor=clip_preprocessor
+    )
+    dataloader = DataLoader(
+        dataset, batch_size=64,
+        shuffle=False, num_workers=8,
+        collate_fn=simple_collate
+
+    )
+
+    cos_sims = []
+    count = 0
+    # for imgs, txts in zip(images, captions):
+    for index, (imgs_pil, txts) in enumerate(dataloader):
+        # imgs_pil = [resize_and_center_crop(imgs)]
+        # txts = [txts]
+        # imgs_pil = [clip_preprocessor(img) for img in imgs]
+        imgs = torch.stack(imgs_pil, dim=0).to(device)
+        tokens = openai_clip.tokenize(txts, truncate=True).to(device)
+        # Prepending text prompts with "A photo depicts "
+        # https://arxiv.org/abs/2104.08718
+        prepend_text = "A photo depicts "
+        prepend_text_token = openai_clip.tokenize(prepend_text)[
+            :, 1:4].to(device)
+        prepend_text_tokens = prepend_text_token.expand(tokens.shape[0], -1)
+
+        start_tokens = tokens[:, :1]
+        new_text_tokens = torch.cat(
+            [start_tokens, prepend_text_tokens, tokens[:, 1:]], dim=1)[:, :77]
+        last_cols = new_text_tokens[:, 77 - 1:77]
+        last_cols[last_cols > 0] = 49407  # eot token
+        new_text_tokens = torch.cat(
+            [new_text_tokens[:, :76], last_cols], dim=1)
+
+        img_embs = clip.encode_image(imgs)
+        text_embs = clip.encode_text(new_text_tokens)
+
+        similarities = torch.nn.functional.cosine_similarity(
+            img_embs, text_embs, dim=1)
+        cos_sims.append(similarities)
+        count += similarities.shape[0]
+        if count >= how_many:
+            break
+
+    clip_score = torch.cat(cos_sims, dim=0)[:how_many].mean()
+    clip_score = clip_score.detach().cpu().numpy()
+    return clip_score
+
+
+@torch.no_grad()
+def compute_image_reward(
+    images, captions, device
+):
+    import ImageReward as RM
+    from tqdm import tqdm
+    model = RM.load("ImageReward-v1.0", device=device)
+    rewards = []
+    for image, prompt in tqdm(zip(images, captions)):
+        reward = model.score(prompt, Image.fromarray(image))
+        rewards.append(reward)
+    return np.mean(np.array(rewards))
+
+
+@torch.no_grad()
+def compute_diversity_score(
+    lpips_loss_func, images, device
+):
+    # resize all image to 512 and convert to tensor
+    images = [Image.fromarray(image) for image in images]
+    images = [image.resize((512, 512), Image.LANCZOS) for image in images]
+    images = np.stack([np.array(image) for image in images], axis=0)
+    images = torch.tensor(images).to(device).float() / 255.0
+    images = images.permute(0, 3, 1, 2)
+
+    num_images = images.shape[0]
+    loss_list = []
+
+    for i in range(num_images):
+        for j in range(i + 1, num_images):
+            image1 = images[i].unsqueeze(0)
+            image2 = images[j].unsqueeze(0)
+            loss = lpips_loss_func(image1, image2)
+
+            loss_list.append(loss.item())
+    return np.mean(loss_list)

exp_code/1_benchmark/CausVid/causvid/evaluation/eval_sdxl_coco.py

@@ -0,0 +1,135 @@
+# pip install git+https://github.com/openai/CLIP.git
+# pip install open_clip_torch
+from causvid.evaluation.coco_eval.coco_evaluator import evaluate_model, compute_clip_score
+from diffusers import DiffusionPipeline, LCMScheduler, DDIMScheduler
+from causvid.util import launch_distributed_job
+import torch.distributed as dist
+from tqdm import tqdm
+import numpy as np
+import argparse
+import torch
+import time
+import os
+
+
+def load_generator(checkpoint_path, generator):
+    # sometime the state_dict is not fully saved yet
+    counter = 0
+    while True:
+        try:
+            state_dict = torch.load(checkpoint_path, map_location="cpu")[
+                'generator']
+            break
+        except:
+            print(f"fail to load checkpoint {checkpoint_path}")
+            time.sleep(1)
+
+            counter += 1
+
+            if counter > 100:
+                return None
+
+    state_dict = {k.replace("model.", ""): v for k, v in state_dict.items()}
+    print(generator.load_state_dict(state_dict, strict=True))
+    return generator
+
+
+def sample(pipeline, prompt_list, denoising_step_list, batch_size):
+    num_prompts = len(prompt_list)
+    num_steps = len(denoising_step_list)
+
+    images = []
+    all_prompts = []
+    for i in tqdm(range(0, num_prompts, batch_size)):
+        batch_prompt = prompt_list[i:i + batch_size]
+        timesteps = None if isinstance(
+            pipeline.scheduler, DDIMScheduler) else denoising_step_list
+        batch_images = pipeline(prompt=batch_prompt, num_inference_steps=num_steps, timesteps=timesteps,
+                                guidance_scale=0, output_type='np').images
+        batch_images = (batch_images * 255.0).astype("uint8")
+        images.extend(batch_images)
+        all_prompts.extend(batch_prompt)
+
+        torch.cuda.empty_cache()
+
+    all_images = np.stack(images, axis=0)
+
+    data_dict = {"all_images": all_images, "all_captions": all_prompts}
+
+    return data_dict
+
+
+@torch.no_grad()
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--denoising_step_list", type=int,
+                        nargs="+", required=True)
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--prompt_path", type=str, required=True)
+    parser.add_argument("--checkpoint_path", type=str, required=True)
+    parser.add_argument("--local_rank", type=int, default=-1)
+    parser.add_argument("--ref_dir", type=str, required=True)
+    parser.add_argument("--eval_res", type=int, default=256)
+    parser.add_argument("--scheduler", type=str,
+                        choices=['ddim', 'lcm'], default='lcm')
+
+    args = parser.parse_args()
+
+    # Step 1: Setup the environment
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.set_grad_enabled(False)
+
+    # Step 2: Create the generator
+    launch_distributed_job()
+    device = torch.cuda.current_device()
+
+    pipeline = DiffusionPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float32).to(device)
+    if args.scheduler == "ddim":
+        pipeline.scheduler = DDIMScheduler.from_config(
+            pipeline.scheduler.config, timestep_spacing="trailing")
+    elif args.scheduler == "lcm":
+        pipeline.scheduler = LCMScheduler.from_config(
+            pipeline.scheduler.config)
+    pipeline.set_progress_bar_config(disable=True)
+    pipeline.safety_checker = None
+
+    # Step 3: Generate images
+    prompt_list = []
+    with open(args.prompt_path, "r") as f:
+        for line in f:
+            prompt_list.append(line.strip())
+
+    generator = load_generator(os.path.join(
+        args.checkpoint_path, "model.pt"), pipeline.unet)
+
+    if generator is None:
+        return
+
+    pipeline.unet = generator
+    data_dict = sample(pipeline, prompt_list,
+                       args.denoising_step_list, args.batch_size)
+
+    # Step 4: Evaluate the generated images
+
+    # evaluate and write stats to file
+    if dist.get_rank() == 0:
+        fid = evaluate_model(
+            args, device, data_dict["all_images"], patch_fid=False)
+
+        clip_score = compute_clip_score(
+            images=data_dict["all_images"],
+            captions=data_dict["all_captions"],
+            clip_model="ViT-G/14",
+            device=device,
+            how_many=len(data_dict["all_images"])
+        )
+        print(f"fid {fid} clip score {clip_score}")
+
+        with open(os.path.join(args.checkpoint_path, "eval_stats.txt"), "w") as f:
+            f.write(f"fid {fid} clip score {clip_score}")
+
+
+if __name__ == "__main__":
+    main()

exp_code/1_benchmark/CausVid/causvid/evaluation/inference_sdxl.py

@@ -0,0 +1,146 @@
+# pip install git+https://github.com/openai/CLIP.git
+# pip install open_clip_torch
+from diffusers import StableDiffusionXLPipeline, LCMScheduler, DDIMScheduler
+from causvid.util import launch_distributed_job
+from PIL import Image
+from tqdm import tqdm
+import numpy as np
+import argparse
+import torch
+import time
+import os
+import re
+
+
+def load_generator(checkpoint_path, generator):
+    # sometime the state_dict is not fully saved yet
+    counter = 0
+    while True:
+        try:
+            state_dict = torch.load(checkpoint_path, map_location="cpu")[
+                'generator']
+            break
+        except:
+            print(f"fail to load checkpoint {checkpoint_path}")
+            time.sleep(1)
+
+            counter += 1
+
+            if counter > 100:
+                return None
+
+    state_dict = {k.replace("model.", ""): v for k, v in state_dict.items()}
+    print(generator.load_state_dict(state_dict, strict=True))
+    return generator
+
+
+def sample(pipeline, prompt_list, denoising_step_list, batch_size):
+    num_prompts = len(prompt_list)
+    num_steps = len(denoising_step_list)
+
+    images = []
+    all_prompts = []
+    for i in tqdm(range(0, num_prompts, batch_size)):
+        batch_prompt = prompt_list[i:i + batch_size]
+        timesteps = None if isinstance(
+            pipeline.scheduler, DDIMScheduler) else denoising_step_list
+        batch_images = pipeline(prompt=batch_prompt, num_inference_steps=num_steps, timesteps=timesteps,
+                                guidance_scale=0, output_type='np').images
+        batch_images = (batch_images * 255.0).astype("uint8")
+        images.extend(batch_images)
+        all_prompts.extend(batch_prompt)
+
+        torch.cuda.empty_cache()
+
+    all_images = np.stack(images, axis=0)
+
+    data_dict = {"all_images": all_images, "all_captions": all_prompts}
+
+    return data_dict
+
+
+@torch.no_grad()
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--denoising_step_list", type=int,
+                        nargs="+", required=True)
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--prompt_path", type=str, required=True)
+    parser.add_argument("--checkpoint_path", type=str, required=True)
+    parser.add_argument("--output_dir", type=str, default="./output")
+    parser.add_argument("--local_rank", type=int, default=-1)
+    parser.add_argument("--scheduler", type=str, choices=['ddim', 'lcm'], default='lcm')
+
+    args = parser.parse_args()
+
+    # Step 1: Setup the environment
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.set_grad_enabled(False)
+
+    # Step 2: Create the generator
+    launch_distributed_job()
+    device = torch.cuda.current_device()
+
+    pipeline = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float32).to(device)
+    if args.scheduler == "ddim":
+        pipeline.scheduler = DDIMScheduler.from_config(
+            pipeline.scheduler.config, timestep_spacing="trailing")
+    elif args.scheduler == "lcm":
+        pipeline.scheduler = LCMScheduler.from_config(pipeline.scheduler.config)
+
+    pipeline.set_progress_bar_config(disable=True)
+    pipeline.safety_checker = None
+
+    # Step 3: Generate images
+    prompt_list = []
+    with open(args.prompt_path, "r") as f:
+        for line in f:
+            prompt_list.append(line.strip())
+
+    generator = load_generator(os.path.join(
+        args.checkpoint_path, "model.pt"), pipeline.unet)
+
+    if generator is None:
+        return
+
+    pipeline.unet = generator
+    data_dict = sample(pipeline, prompt_list,
+                       args.denoising_step_list, args.batch_size)
+
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    def sanitize_filename(name):
+        """
+        Remove any characters that are not alphanumeric, spaces, underscores, or hyphens.
+        Then replace spaces with underscores.
+        """
+        # Remove unwanted characters (anything not a word character, space, or hyphen)
+        name = re.sub(r'[^\w\s-]', '', name)
+        # Replace spaces with underscores and strip leading/trailing whitespace
+        return name.strip().replace(' ', '_')
+
+    for idx, (img_array, prompt) in enumerate(zip(data_dict['all_images'], data_dict['all_captions'])):
+        # Split the prompt into words and take the first four words.
+        words = prompt.split()
+        if len(words) >= 10:
+            base_name = ' '.join(words[:10])
+        else:
+            base_name = ' '.join(words)
+
+        # Sanitize the base file name to remove problematic characters.
+        base_name = sanitize_filename(base_name)
+
+        # Append the index to ensure uniqueness (in case two prompts share the same first four words).
+        file_name = f"{base_name}_{idx}.jpg"
+
+        # Create a PIL Image from the numpy array.
+        image = Image.fromarray(img_array)
+
+        # Save the image in the specified folder.
+        image.save(os.path.join(args.output_dir, file_name))
+
+
+if __name__ == "__main__":
+    main()

exp_code/1_benchmark/CausVid/causvid/evaluation/parallel_sdxl_eval.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+
+# ----------------------
+# User-defined variables
+# ----------------------
+CHECKPOINT_DIR="/mnt/localssd/sdxl_logs/2025-01-23-15-16-31.765725_seed228885"
+PROMPT_PATH="captions_coco10k.txt"
+REF_DIR="/mnt/localssd/coco10k/subset/"
+DENOSING_STEPS="999 749 499 249"
+
+# Adjust this if you have a different number of GPUs available
+NUM_GPUS=8
+
+# -------------
+# Main script
+# -------------
+# Grab all checkpoints in the folder
+CHECKPOINTS=(${CHECKPOINT_DIR}/checkpoint_model_*)
+
+# Print how many checkpoints were found
+echo "Found ${#CHECKPOINTS[@]} checkpoints in ${CHECKPOINT_DIR}"
+
+# Loop over each checkpoint and launch a job
+for ((i=0; i<${#CHECKPOINTS[@]}; i++)); do
+  
+  # GPU to use (round-robin assignment)
+  GPU_ID=$(( i % NUM_GPUS ))
+
+  # Pick a unique port for each process. For example, offset from 29500.
+  # Feel free to choose any range that won't collide with other applications.
+  MASTER_PORT=$((29500 + i))
+
+  echo "Launching eval for checkpoint: ${CHECKPOINTS[$i]} on GPU ${GPU_ID}, master_port ${MASTER_PORT}"
+  
+  # Run eval on GPU_ID, put the process in the background
+  CUDA_VISIBLE_DEVICES=$GPU_ID torchrun --nproc_per_node 1 \
+    --master_port ${MASTER_PORT} \
+    causvid/evaluation/eval_sdxl_coco.py \
+      --denoising_step_list $DENOSING_STEPS \
+      --prompt_path "$PROMPT_PATH" \
+      --checkpoint_path "${CHECKPOINTS[$i]}" \
+      --ref_dir "$REF_DIR" &
+
+  # If we've launched as many parallel tasks as GPUs, wait for this batch to finish
+  if (( (i+1) % NUM_GPUS == 0 )); then
+    echo "Waiting for batch of $NUM_GPUS processes to finish..."
+    wait
+  fi
+done
+
+# If there are leftover tasks that didn't perfectly divide into NUM_GPUS, wait again
+wait
+
+echo "All evaluations have completed."

exp_code/1_benchmark/CausVid/causvid/loss.py

@@ -0,0 +1,82 @@
+from abc import ABC, abstractmethod
+import torch
+
+
+class DenoisingLoss(ABC):
+    @abstractmethod
+    def __call__(
+        self, x: torch.Tensor, x_pred: torch.Tensor,
+        noise: torch.Tensor, noise_pred: torch.Tensor,
+        alphas_cumprod: torch.Tensor,
+        timestep: torch.Tensor,
+        **kwargs
+    ) -> torch.Tensor:
+        """
+        Base class for denoising loss.
+        Input:
+            - x: the clean data with shape [B, F, C, H, W]
+            - x_pred: the predicted clean data with shape [B, F, C, H, W]
+            - noise: the noise with shape [B, F, C, H, W]
+            - noise_pred: the predicted noise with shape [B, F, C, H, W]
+            - alphas_cumprod: the cumulative product of alphas (defining the noise schedule) with shape [T]
+            - timestep: the current timestep with shape [B, F]
+        """
+        pass
+
+
+class X0PredLoss(DenoisingLoss):
+    def __call__(
+        self, x: torch.Tensor, x_pred: torch.Tensor,
+        noise: torch.Tensor, noise_pred: torch.Tensor,
+        alphas_cumprod: torch.Tensor,
+        timestep: torch.Tensor,
+        **kwargs
+    ) -> torch.Tensor:
+        return torch.mean((x - x_pred) ** 2)
+
+
+class VPredLoss(DenoisingLoss):
+    def __call__(
+        self, x: torch.Tensor, x_pred: torch.Tensor,
+        noise: torch.Tensor, noise_pred: torch.Tensor,
+        alphas_cumprod: torch.Tensor,
+        timestep: torch.Tensor,
+        **kwargs
+    ) -> torch.Tensor:
+        weights = 1 / \
+            (1 - alphas_cumprod[timestep].reshape(*timestep.shape, 1, 1, 1))
+        return torch.mean(weights * (x - x_pred) ** 2)
+
+
+class NoisePredLoss(DenoisingLoss):
+    def __call__(
+        self, x: torch.Tensor, x_pred: torch.Tensor,
+        noise: torch.Tensor, noise_pred: torch.Tensor,
+        alphas_cumprod: torch.Tensor,
+        timestep: torch.Tensor,
+        **kwargs
+    ) -> torch.Tensor:
+        return torch.mean((noise - noise_pred) ** 2)
+
+
+class FlowPredLoss(DenoisingLoss):
+    def __call__(
+        self, x: torch.Tensor, x_pred: torch.Tensor,
+        noise: torch.Tensor, noise_pred: torch.Tensor,
+        alphas_cumprod: torch.Tensor,
+        timestep: torch.Tensor,
+        **kwargs
+    ) -> torch.Tensor:
+        return torch.mean((kwargs["flow_pred"] - (noise - x)) ** 2)
+
+
+NAME_TO_CLASS = {
+    "x0": X0PredLoss,
+    "v": VPredLoss,
+    "noise": NoisePredLoss,
+    "flow": FlowPredLoss
+}
+
+
+def get_denoising_loss(loss_type: str) -> DenoisingLoss:
+    return NAME_TO_CLASS[loss_type]

exp_code/1_benchmark/CausVid/causvid/models/__init__.py

@@ -0,0 +1,56 @@
+from .wan.wan_wrapper import WanTextEncoder, WanVAEWrapper, WanDiffusionWrapper, CausalWanDiffusionWrapper
+from causvid.bidirectional_trajectory_pipeline import BidirectionalInferenceWrapper
+from .sdxl.sdxl_wrapper import SDXLWrapper, SDXLTextEncoder, SDXLVAE
+from transformers.models.t5.modeling_t5 import T5Block
+
+
+DIFFUSION_NAME_TO_CLASS = {
+    "sdxl": SDXLWrapper,
+    "wan": WanDiffusionWrapper,
+    "causal_wan": CausalWanDiffusionWrapper
+}
+
+
+def get_diffusion_wrapper(model_name):
+    return DIFFUSION_NAME_TO_CLASS[model_name]
+
+
+TEXTENCODER_NAME_TO_CLASS = {
+    "sdxl": SDXLTextEncoder,
+    "wan": WanTextEncoder,
+    "causal_wan": WanTextEncoder
+}
+
+
+def get_text_encoder_wrapper(model_name):
+    return TEXTENCODER_NAME_TO_CLASS[model_name]
+
+
+VAE_NAME_TO_CLASS = {
+    "sdxl": SDXLVAE,
+    "wan": WanVAEWrapper,
+    "causal_wan": WanVAEWrapper   # TODO: Change the VAE to the causal version
+}
+
+
+def get_vae_wrapper(model_name):
+    return VAE_NAME_TO_CLASS[model_name]
+
+
+PIPELINE_NAME_TO_CLASS = {
+    "sdxl": BidirectionalInferenceWrapper,
+    "wan": BidirectionalInferenceWrapper
+}
+
+
+def get_inference_pipeline_wrapper(model_name, **kwargs):
+    return PIPELINE_NAME_TO_CLASS[model_name](**kwargs)
+
+
+BLOCK_NAME_TO_BLOCK_CLASS = {
+    "T5Block": T5Block
+}
+
+
+def get_block_class(model_name):
+    return BLOCK_NAME_TO_BLOCK_CLASS[model_name]

exp_code/1_benchmark/CausVid/causvid/models/model_interface.py

@@ -0,0 +1,114 @@
+from causvid.scheduler import SchedulerInterface
+from abc import abstractmethod, ABC
+from typing import List, Optional
+import torch
+import types
+
+
+class DiffusionModelInterface(ABC, torch.nn.Module):
+    scheduler: SchedulerInterface
+
+    @abstractmethod
+    def forward(
+        self, noisy_image_or_video: torch.Tensor, conditional_dict: dict,
+        timestep: torch.Tensor, kv_cache: Optional[List[dict]] = None,
+        crossattn_cache: Optional[List[dict]] = None,
+        current_start: Optional[int] = None,
+        current_end: Optional[int] = None
+    ) -> torch.Tensor:
+        """
+        A method to run diffusion model.
+        Input:
+            - noisy_image_or_video: a tensor with shape [B, F, C, H, W] where the number of frame is 1 for images.
+            - conditional_dict: a dictionary containing the conditional information (e.g. text embeddings, image embeddings).
+            - timestep: a tensor with shape [B, F]  where the number of frame is 1 for images.
+            all data should be on the same device as the model.
+            - kv_cache: a list of dictionaries containing the key and value tensors for each attention layer.
+            - current_start: the start index of the current frame in the sequence.
+            - current_end: the end index of the current frame in the sequence.
+        Output: a tensor with shape [B, F, C, H, W] where the number of frame is 1 for images.
+        We always expect a X0 prediction form for the output.
+        """
+        pass
+
+    def get_scheduler(self) -> SchedulerInterface:
+        """
+        Update the current scheduler with the interface's static method
+        """
+        scheduler = self.scheduler
+        scheduler.convert_x0_to_noise = types.MethodType(
+            SchedulerInterface.convert_x0_to_noise, scheduler)
+        scheduler.convert_noise_to_x0 = types.MethodType(
+            SchedulerInterface.convert_noise_to_x0, scheduler)
+        scheduler.convert_velocity_to_x0 = types.MethodType(
+            SchedulerInterface.convert_velocity_to_x0, scheduler)
+        self.scheduler = scheduler
+        return scheduler
+
+    def post_init(self):
+        """
+        A few custom initialization steps that should be called after the object is created.
+        Currently, the only one we have is to bind a few methods to scheduler.
+        We can gradually add more methods here if needed.
+        """
+        self.get_scheduler()
+
+    def set_module_grad(self, module_grad: dict) -> None:
+        """
+        Adjusts the state of each module in the object.
+
+        Parameters:
+        - module_grad (dict): A dictionary where each key is the name of a module (as an attribute of the object),
+          and each value is a bool indicating whether the module's parameters require gradients.
+
+        Functionality:
+        For each module name in the dictionary:
+        - Updates whether its parameters require gradients based on 'is_trainable'.
+        """
+        for k, is_trainable in module_grad.items():
+            getattr(self, k).requires_grad_(is_trainable)
+
+    @abstractmethod
+    def enable_gradient_checkpointing(self) -> None:
+        """
+        Activates gradient checkpointing for the current model (may be referred to as *activation checkpointing* or
+        *checkpoint activations* in other frameworks).
+        """
+        pass
+
+
+class VAEInterface(ABC, torch.nn.Module):
+    @abstractmethod
+    def decode_to_pixel(self, latent: torch.Tensor) -> torch.Tensor:
+        """
+        A method to decode a latent representation to an image or video.
+        Input: a tensor with shape [B, F // T, C, H // S, W // S] where T and S are temporal and spatial compression factors.
+        Output: a tensor with shape [B, F, C, H, W] where the number of frame is 1 for images.
+        """
+        pass
+
+
+class TextEncoderInterface(ABC, torch.nn.Module):
+    @abstractmethod
+    def forward(self, text_prompts: List[str]) -> dict:
+        """
+        A method to tokenize text prompts with a tokenizer and encode them into a latent representation.
+        Input: a list of strings.
+        Output: a dictionary containing the encoded representation of the text prompts.
+        """
+        pass
+
+
+class InferencePipelineInterface(ABC):
+    @abstractmethod
+    def inference_with_trajectory(self, noise: torch.Tensor, conditional_dict: dict) -> torch.Tensor:
+        """
+        Run inference with the given diffusion / distilled generators.
+        Input:
+            - noise: a tensor sampled from N(0, 1) with shape [B, F, C, H, W] where the number of frame is 1 for images.
+            - conditional_dict: a dictionary containing the conditional information (e.g. text embeddings, image embeddings).
+        Output:
+            - output: a tensor with shape [B, T, F, C, H, W].
+            T is the total number of timesteps. output[0] is a pure noise and output[i] and i>0
+            represents the x0 prediction at each timestep.
+        """

exp_code/1_benchmark/CausVid/causvid/models/sdxl/sdxl_wrapper.py

@@ -0,0 +1,200 @@
+from causvid.models.model_interface import (
+    DiffusionModelInterface,
+    TextEncoderInterface,
+    VAEInterface
+)
+from diffusers import UNet2DConditionModel, AutoencoderKL, DDIMScheduler
+from transformers import CLIPTextModel, CLIPTextModelWithProjection
+from transformers import AutoTokenizer
+from typing import List
+import torch
+
+
+class SDXLTextEncoder(TextEncoderInterface):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.text_encoder_one = CLIPTextModel.from_pretrained(
+            "stabilityai/stable-diffusion-xl-base-1.0", subfolder="text_encoder", revision=None
+        )
+
+        self.text_encoder_two = CLIPTextModelWithProjection.from_pretrained(
+            "stabilityai/stable-diffusion-xl-base-1.0", subfolder="text_encoder_2", revision=None
+        )
+
+        self.tokenizer_one = AutoTokenizer.from_pretrained(
+            "stabilityai/stable-diffusion-xl-base-1.0", subfolder="tokenizer", revision=None, use_fast=False
+        )
+
+        self.tokenizer_two = AutoTokenizer.from_pretrained(
+            "stabilityai/stable-diffusion-xl-base-1.0", subfolder="tokenizer_2", revision=None, use_fast=False
+        )
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    def _model_forward(self, batch: dict) -> dict:
+        """
+        Processes two sets of input token IDs using two separate text encoders, and returns both
+        concatenated token-level embeddings and pooled sentence-level embeddings.
+
+        Args:
+            batch (dict):
+                A dictionary containing:
+                    - text_input_ids_one (torch.Tensor): The token IDs for the first tokenizer,
+                    of shape [batch_size, num_tokens].
+                    - text_input_ids_two (torch.Tensor): The token IDs for the second tokenizer,
+                    of shape [batch_size, num_tokens].
+
+        Returns:
+            dict: A dictionary with two keys:
+                - "prompt_embeds" (torch.Tensor): Concatenated embeddings from the second-to-last
+                hidden states of both text encoders, of shape [batch_size, num_tokens, hidden_dim * 2].
+                - "pooled_prompt_embeds" (torch.Tensor): Pooled embeddings (final layer output)
+                from the second text encoder, of shape [batch_size, hidden_dim].
+        """
+        text_input_ids_one = batch['text_input_ids_one']
+        text_input_ids_two = batch['text_input_ids_two']
+        prompt_embeds_list = []
+
+        for text_input_ids, text_encoder in zip([text_input_ids_one, text_input_ids_two], [self.text_encoder_one, self.text_encoder_two]):
+            prompt_embeds = text_encoder(
+                text_input_ids.to(self.device),
+                output_hidden_states=True,
+            )
+
+            # We are only interested in the pooled output of the final text encoder
+            pooled_prompt_embeds = prompt_embeds[0]
+
+            prompt_embeds = prompt_embeds.hidden_states[-2]
+            bs_embed, seq_len, _ = prompt_embeds.shape
+            prompt_embeds = prompt_embeds.view(bs_embed, seq_len, -1)
+            prompt_embeds_list.append(prompt_embeds)
+
+        prompt_embeds = torch.cat(prompt_embeds_list, dim=-1)
+        # use the second text encoder's pooled prompt embeds (overwrite in for loop)
+        pooled_prompt_embeds = pooled_prompt_embeds.view(
+            len(text_input_ids_one), -1)
+
+        output_dict = {
+            "prompt_embeds": prompt_embeds,
+            "pooled_prompt_embeds": pooled_prompt_embeds,
+        }
+        return output_dict
+
+    def _encode_prompt(self, prompt_list):
+        """
+        Encodes a list of prompts with two tokenizers and returns a dictionary
+        of the resulting tensors.
+        """
+        text_input_ids_one = self.tokenizer_one(
+            prompt_list,
+            padding="max_length",
+            max_length=self.tokenizer_one.model_max_length,
+            truncation=True,
+            return_tensors="pt"
+        ).input_ids
+
+        text_input_ids_two = self.tokenizer_two(
+            prompt_list,
+            padding="max_length",
+            max_length=self.tokenizer_two.model_max_length,
+            truncation=True,
+            return_tensors="pt"
+        ).input_ids
+
+        prompt_dict = {
+            'text_input_ids_one': text_input_ids_one,
+            'text_input_ids_two': text_input_ids_two
+        }
+        return prompt_dict
+
+    def forward(self, text_prompts: List[str]) -> dict:
+        tokenized_prompts = self._encode_prompt(text_prompts)
+        return self._model_forward(tokenized_prompts)
+
+
+class SDXLVAE(VAEInterface):
+    def __init__(self):
+        super().__init__()
+
+        self.vae = AutoencoderKL.from_pretrained(
+            "stabilityai/stable-diffusion-xl-base-1.0",
+            subfolder="vae"
+        )
+
+    def decode_to_pixel(self, latent: torch.Tensor) -> torch.Tensor:
+        latent = latent.squeeze(1)
+        latent = latent / self.vae.config.scaling_factor
+        # ensure the output is float
+        image = self.vae.decode(latent).sample.float()
+        image = image.unsqueeze(1)
+        return image
+
+
+class SDXLWrapper(DiffusionModelInterface):
+    def __init__(self):
+        super().__init__()
+
+        self.model = UNet2DConditionModel.from_pretrained(
+            "stabilityai/stable-diffusion-xl-base-1.0",
+            subfolder="unet"
+        )
+
+        self.add_time_ids = self._build_condition_input(resolution=1024)
+
+        self.scheduler = DDIMScheduler.from_pretrained(
+            "stabilityai/stable-diffusion-xl-base-1.0",
+            subfolder="scheduler"
+        )
+
+        super().post_init()
+
+    def enable_gradient_checkpointing(self) -> None:
+        self.model.enable_gradient_checkpointing()
+
+    def forward(
+        self, noisy_image_or_video: torch.Tensor, conditional_dict: dict,
+        timestep: torch.Tensor, kv_cache: List[dict] = None, current_start: int = None,
+        current_end: int = None
+    ) -> torch.Tensor:
+        # TODO: Check how to apply gradient checkpointing
+        # [B, 1, C, H, W] -> [B, C, H, W]
+        noisy_image_or_video = noisy_image_or_video.squeeze(1)
+
+        # [B, 1] -> [B]
+        timestep = timestep.squeeze(1)
+
+        added_conditions = {
+            "time_ids": self.add_time_ids.repeat(noisy_image_or_video.shape[0], 1).to(noisy_image_or_video.device),
+            "text_embeds": conditional_dict["pooled_prompt_embeds"]
+        }
+
+        pred_noise = self.model(
+            sample=noisy_image_or_video,
+            timestep=timestep,
+            encoder_hidden_states=conditional_dict['prompt_embeds'],
+            added_cond_kwargs=added_conditions
+        ).sample
+
+        pred_x0 = self.scheduler.convert_noise_to_x0(
+            noise=pred_noise,
+            xt=noisy_image_or_video,
+            timestep=timestep
+        )
+
+        # [B, C, H, W] -> [B, 1, C, H, W]
+        pred_x0 = pred_x0.unsqueeze(1)
+
+        return pred_x0
+
+    @staticmethod
+    def _build_condition_input(resolution):
+        original_size = (resolution, resolution)
+        target_size = (resolution, resolution)
+        crop_top_left = (0, 0)
+
+        add_time_ids = list(original_size + crop_top_left + target_size)
+        add_time_ids = torch.tensor([add_time_ids], dtype=torch.float32)
+        return add_time_ids

exp_code/1_benchmark/CausVid/causvid/models/wan/bidirectional_inference.py

@@ -0,0 +1,69 @@
+from causvid.models import (
+    get_diffusion_wrapper,
+    get_text_encoder_wrapper,
+    get_vae_wrapper
+)
+from typing import List
+import torch
+
+
+class BidirectionalInferencePipeline(torch.nn.Module):
+    def __init__(self, args, device):
+        super().__init__()
+        # Step 1: Initialize all models
+        self.generator_model_name = getattr(
+            args, "generator_name", args.model_name)
+        self.generator = get_diffusion_wrapper(
+            model_name=self.generator_model_name)()
+        self.text_encoder = get_text_encoder_wrapper(
+            model_name=args.model_name)()
+        self.vae = get_vae_wrapper(model_name=args.model_name)()
+
+        # Step 2: Initialize all bidirectional wan hyperparmeters
+        self.denoising_step_list = torch.tensor(
+            args.denoising_step_list, dtype=torch.long, device=device)
+
+        self.scheduler = self.generator.get_scheduler()
+        if args.warp_denoising_step:  # Warp the denoising step according to the scheduler time shift
+            timesteps = torch.cat((self.scheduler.timesteps.cpu(), torch.tensor([0], dtype=torch.float32))).cuda()
+            self.denoising_step_list = timesteps[1000 - self.denoising_step_list]
+
+    def inference(self, noise: torch.Tensor, text_prompts: List[str]) -> torch.Tensor:
+        """
+        Perform inference on the given noise and text prompts.
+        Inputs:
+            noise (torch.Tensor): The input noise tensor of shape
+                (batch_size, num_frames, num_channels, height, width).
+            text_prompts (List[str]): The list of text prompts.
+        Outputs:
+            video (torch.Tensor): The generated video tensor of shape
+                (batch_size, num_frames, num_channels, height, width). It is normalized to be in the range [0, 1].
+        """
+        conditional_dict = self.text_encoder(
+            text_prompts=text_prompts
+        )
+
+        # initial point
+        noisy_image_or_video = noise
+
+        for index, current_timestep in enumerate(self.denoising_step_list):
+            pred_image_or_video = self.generator(
+                noisy_image_or_video=noisy_image_or_video,
+                conditional_dict=conditional_dict,
+                timestep=torch.ones(
+                    noise.shape[:2], dtype=torch.long, device=noise.device) * current_timestep
+            )  # [B, F, C, H, W]
+
+            if index < len(self.denoising_step_list) - 1:
+                next_timestep = self.denoising_step_list[index + 1] * torch.ones(
+                    noise.shape[:2], dtype=torch.long, device=noise.device)
+
+                noisy_image_or_video = self.scheduler.add_noise(
+                    pred_image_or_video.flatten(0, 1),
+                    torch.randn_like(pred_image_or_video.flatten(0, 1)),
+                    next_timestep.flatten(0, 1)
+                ).unflatten(0, noise.shape[:2])
+
+        video = self.vae.decode_to_pixel(pred_image_or_video)
+        video = (video * 0.5 + 0.5).clamp(0, 1)
+        return video

exp_code/1_benchmark/CausVid/causvid/models/wan/causal_inference.py

@@ -0,0 +1,204 @@
+from causvid.models import (
+    get_diffusion_wrapper,
+    get_text_encoder_wrapper,
+    get_vae_wrapper
+)
+from typing import List, Optional
+import torch
+
+
+class InferencePipeline(torch.nn.Module):
+    def __init__(self, args, device):
+        super().__init__()
+        # Step 1: Initialize all models
+        self.generator_model_name = getattr(
+            args, "generator_name", args.model_name)
+        self.generator = get_diffusion_wrapper(
+            model_name=self.generator_model_name)()
+        self.text_encoder = get_text_encoder_wrapper(
+            model_name=args.model_name)()
+        self.vae = get_vae_wrapper(model_name=args.model_name)()
+
+        # Step 2: Initialize all causal hyperparmeters
+        self.denoising_step_list = torch.tensor(
+            args.denoising_step_list, dtype=torch.long, device=device)
+        assert self.denoising_step_list[-1] == 0
+        # remove the last timestep (which equals zero)
+        self.denoising_step_list = self.denoising_step_list[:-1]
+
+        self.scheduler = self.generator.get_scheduler()
+        if args.warp_denoising_step:  # Warp the denoising step according to the scheduler time shift
+            timesteps = torch.cat((self.scheduler.timesteps.cpu(), torch.tensor([0], dtype=torch.float32))).cuda()
+            self.denoising_step_list = timesteps[1000 - self.denoising_step_list]
+
+        self.num_transformer_blocks = 30
+        self.frame_seq_length = 1560
+
+        self.kv_cache1 = None
+        self.kv_cache2 = None
+        self.args = args
+        self.num_frame_per_block = getattr(
+            args, "num_frame_per_block", 1)
+
+        print(f"KV inference with {self.num_frame_per_block} frames per block")
+
+        if self.num_frame_per_block > 1:
+            self.generator.model.num_frame_per_block = self.num_frame_per_block
+
+    def _initialize_kv_cache(self, batch_size, dtype, device):
+        """
+        Initialize a Per-GPU KV cache for the Wan model.
+        """
+        kv_cache1 = []
+
+        for _ in range(self.num_transformer_blocks):
+            kv_cache1.append({
+                "k": torch.zeros([batch_size, 32760, 12, 128], dtype=dtype, device=device),
+                "v": torch.zeros([batch_size, 32760, 12, 128], dtype=dtype, device=device)
+            })
+
+        self.kv_cache1 = kv_cache1  # always store the clean cache
+
+    def _initialize_crossattn_cache(self, batch_size, dtype, device):
+        """
+        Initialize a Per-GPU cross-attention cache for the Wan model.
+        """
+        crossattn_cache = []
+
+        for _ in range(self.num_transformer_blocks):
+            crossattn_cache.append({
+                "k": torch.zeros([batch_size, 512, 12, 128], dtype=dtype, device=device),
+                "v": torch.zeros([batch_size, 512, 12, 128], dtype=dtype, device=device),
+                "is_init": False
+            })
+
+        self.crossattn_cache = crossattn_cache  # always store the clean cache
+
+    def inference(self, noise: torch.Tensor, text_prompts: List[str], start_latents: Optional[torch.Tensor] = None, return_latents: bool = False) -> torch.Tensor:
+        """
+        Perform inference on the given noise and text prompts.
+        Inputs:
+            noise (torch.Tensor): The input noise tensor of shape
+                (batch_size, num_frames, num_channels, height, width).
+            text_prompts (List[str]): The list of text prompts.
+        Outputs:
+            video (torch.Tensor): The generated video tensor of shape
+                (batch_size, num_frames, num_channels, height, width). It is normalized to be in the range [0, 1].
+        """
+        batch_size, num_frames, num_channels, height, width = noise.shape
+        conditional_dict = self.text_encoder(
+            text_prompts=text_prompts
+        )
+
+        output = torch.zeros(
+            [batch_size, num_frames, num_channels, height, width],
+            device=noise.device,
+            dtype=noise.dtype
+        )
+
+        # Step 1: Initialize KV cache
+        if self.kv_cache1 is None:
+            self._initialize_kv_cache(
+                batch_size=batch_size,
+                dtype=noise.dtype,
+                device=noise.device
+            )
+
+            self._initialize_crossattn_cache(
+                batch_size=batch_size,
+                dtype=noise.dtype,
+                device=noise.device
+            )
+        else:
+            # reset cross attn cache
+            for block_index in range(self.num_transformer_blocks):
+                self.crossattn_cache[block_index]["is_init"] = False
+
+        num_input_blocks = start_latents.shape[1] // self.num_frame_per_block if start_latents is not None else 0
+
+        # Step 2: Temporal denoising loop
+        num_blocks = num_frames // self.num_frame_per_block
+        for block_index in range(num_blocks):
+            noisy_input = noise[:, block_index * self.num_frame_per_block:(block_index + 1) * self.num_frame_per_block]
+
+            if start_latents is not None and block_index < num_input_blocks:
+                timestep = torch.ones(
+                    [batch_size, self.num_frame_per_block], device=noise.device, dtype=torch.int64) * 0
+
+                current_ref_latents = start_latents[:, block_index * self.num_frame_per_block:(
+                    block_index + 1) * self.num_frame_per_block]
+                output[:, block_index * self.num_frame_per_block:(
+                    block_index + 1) * self.num_frame_per_block] = current_ref_latents
+
+                self.generator(
+                    noisy_image_or_video=current_ref_latents,
+                    conditional_dict=conditional_dict,
+                    timestep=timestep * 0,
+                    kv_cache=self.kv_cache1,
+                    crossattn_cache=self.crossattn_cache,
+                    current_start=block_index * self.num_frame_per_block * self.frame_seq_length,
+                    current_end=(block_index + 1) *
+                    self.num_frame_per_block * self.frame_seq_length
+                )
+                continue
+
+            # Step 2.1: Spatial denoising loop
+            for index, current_timestep in enumerate(self.denoising_step_list):
+                # set current timestep
+                timestep = torch.ones([batch_size, self.num_frame_per_block], device=noise.device, dtype=torch.int64) * current_timestep
+
+                if index < len(self.denoising_step_list) - 1:
+                    denoised_pred = self.generator(
+                        noisy_image_or_video=noisy_input,
+                        conditional_dict=conditional_dict,
+                        timestep=timestep,
+                        kv_cache=self.kv_cache1,
+                        crossattn_cache=self.crossattn_cache,
+                        current_start=block_index * self.num_frame_per_block * self.frame_seq_length,
+                        current_end=(
+                            block_index + 1) * self.num_frame_per_block * self.frame_seq_length
+                    )
+                    next_timestep = self.denoising_step_list[index + 1]
+                    noisy_input = self.scheduler.add_noise(
+                        denoised_pred.flatten(0, 1),
+                        torch.randn_like(denoised_pred.flatten(0, 1)),
+                        next_timestep *
+                        torch.ones([batch_size], device="cuda",
+                                   dtype=torch.long)
+                    ).unflatten(0, denoised_pred.shape[:2])
+                else:
+                    # for getting real output
+                    denoised_pred = self.generator(
+                        noisy_image_or_video=noisy_input,
+                        conditional_dict=conditional_dict,
+                        timestep=timestep,
+                        kv_cache=self.kv_cache1,
+                        crossattn_cache=self.crossattn_cache,
+                        current_start=block_index * self.num_frame_per_block * self.frame_seq_length,
+                        current_end=(
+                            block_index + 1) * self.num_frame_per_block * self.frame_seq_length
+                    )
+
+            # Step 2.2: rerun with timestep zero to update the cache
+            output[:, block_index * self.num_frame_per_block:(
+                block_index + 1) * self.num_frame_per_block] = denoised_pred
+
+            self.generator(
+                noisy_image_or_video=denoised_pred,
+                conditional_dict=conditional_dict,
+                timestep=timestep * 0,
+                kv_cache=self.kv_cache1,
+                crossattn_cache=self.crossattn_cache,
+                current_start=block_index * self.num_frame_per_block * self.frame_seq_length,
+                current_end=(block_index + 1) *
+                self.num_frame_per_block * self.frame_seq_length
+            )
+
+        # Step 3: Decode the output
+        video = self.vae.decode_to_pixel(output)
+        video = (video * 0.5 + 0.5).clamp(0, 1)
+
+        if return_latents:
+            return video, output
+        else:
+            return video

exp_code/1_benchmark/CausVid/causvid/models/wan/causal_model.py

@@ -0,0 +1,749 @@
+from causvid.models.wan.wan_base.modules.attention import attention
+from causvid.models.wan.wan_base.modules.model import (
+    WanRMSNorm,
+    rope_apply,
+    WanLayerNorm,
+    WAN_CROSSATTENTION_CLASSES,
+    Head,
+    rope_params,
+    MLPProj,
+    sinusoidal_embedding_1d
+)
+from torch.nn.attention.flex_attention import create_block_mask, flex_attention
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from torch.nn.attention.flex_attention import BlockMask
+from diffusers.models.modeling_utils import ModelMixin
+import torch.nn as nn
+import torch
+import math
+
+# wan 1.3B model has a weird channel / head configurations and require max-autotune to work with flexattention
+# see https://github.com/pytorch/pytorch/issues/133254
+# change to default for other models
+flex_attention = torch.compile(
+    flex_attention, dynamic=False, mode="max-autotune")
+
+
+def causal_rope_apply(x, grid_sizes, freqs, start_frame=0):
+    n, c = x.size(2), x.size(3) // 2
+
+    # split freqs
+    freqs = freqs.split([c - 2 * (c // 3), c // 3, c // 3], dim=1)
+
+    # loop over samples
+    output = []
+
+    for i, (f, h, w) in enumerate(grid_sizes.tolist()):
+        seq_len = f * h * w
+
+        # precompute multipliers
+        x_i = torch.view_as_complex(x[i, :seq_len].to(torch.float64).reshape(
+            seq_len, n, -1, 2))
+        freqs_i = torch.cat([
+            freqs[0][start_frame:start_frame + f].view(f, 1, 1, -1).expand(f, h, w, -1),
+            freqs[1][:h].view(1, h, 1, -1).expand(f, h, w, -1),
+            freqs[2][:w].view(1, 1, w, -1).expand(f, h, w, -1)
+        ],
+            dim=-1).reshape(seq_len, 1, -1)
+
+        # apply rotary embedding
+        x_i = torch.view_as_real(x_i * freqs_i).flatten(2)
+        x_i = torch.cat([x_i, x[i, seq_len:]])
+
+        # append to collection
+        output.append(x_i)
+    return torch.stack(output).type_as(x)
+
+
+class CausalWanSelfAttention(nn.Module):
+
+    def __init__(self,
+                 dim,
+                 num_heads,
+                 window_size=(-1, -1),
+                 qk_norm=True,
+                 eps=1e-6):
+        assert dim % num_heads == 0
+        super().__init__()
+        self.dim = dim
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.window_size = window_size
+        self.qk_norm = qk_norm
+        self.eps = eps
+
+        # layers
+        self.q = nn.Linear(dim, dim)
+        self.k = nn.Linear(dim, dim)
+        self.v = nn.Linear(dim, dim)
+        self.o = nn.Linear(dim, dim)
+        self.norm_q = WanRMSNorm(dim, eps=eps) if qk_norm else nn.Identity()
+        self.norm_k = WanRMSNorm(dim, eps=eps) if qk_norm else nn.Identity()
+
+    def forward(self, x, seq_lens, grid_sizes, freqs, block_mask, kv_cache=None, current_start=0, current_end=0):
+        r"""
+        Args:
+            x(Tensor): Shape [B, L, num_heads, C / num_heads]
+            seq_lens(Tensor): Shape [B]
+            grid_sizes(Tensor): Shape [B, 3], the second dimension contains (F, H, W)
+            freqs(Tensor): Rope freqs, shape [1024, C / num_heads / 2]
+            block_mask (BlockMask)
+        """
+        b, s, n, d = *x.shape[:2], self.num_heads, self.head_dim
+
+        # query, key, value function
+        def qkv_fn(x):
+            q = self.norm_q(self.q(x)).view(b, s, n, d)
+            k = self.norm_k(self.k(x)).view(b, s, n, d)
+            v = self.v(x).view(b, s, n, d)
+            return q, k, v
+
+        q, k, v = qkv_fn(x)
+
+        if kv_cache is None:
+            roped_query = rope_apply(q, grid_sizes, freqs).type_as(v)
+            roped_key = rope_apply(k, grid_sizes, freqs).type_as(v)
+
+            padded_length = math.ceil(q.shape[1] / 128) * 128 - q.shape[1]
+            padded_roped_query = torch.cat(
+                [roped_query,
+                 torch.zeros([q.shape[0], padded_length, q.shape[2], q.shape[3]],
+                             device=q.device, dtype=v.dtype)],
+                dim=1
+            )
+
+            padded_roped_key = torch.cat(
+                [roped_key, torch.zeros([k.shape[0], padded_length, k.shape[2], k.shape[3]],
+                                        device=k.device, dtype=v.dtype)],
+                dim=1
+            )
+
+            padded_v = torch.cat(
+                [v, torch.zeros([v.shape[0], padded_length, v.shape[2], v.shape[3]],
+                                device=v.device, dtype=v.dtype)],
+                dim=1
+            )
+
+            # print(q.shape, k.shape, v.shape, padded_roped_query.shape, padded_roped_key.shape, padded_v.shape)
+            x = flex_attention(
+                query=padded_roped_query.transpose(2, 1),
+                key=padded_roped_key.transpose(2, 1),
+                value=padded_v.transpose(2, 1),
+                block_mask=block_mask
+            )[:, :, :-padded_length].transpose(2, 1)
+        else:
+            roped_query = causal_rope_apply(
+                q, grid_sizes, freqs, start_frame=current_start // math.prod(grid_sizes[0][1:]).item()).type_as(v)
+            roped_key = causal_rope_apply(
+                k, grid_sizes, freqs, start_frame=current_start // math.prod(grid_sizes[0][1:]).item()).type_as(v)
+
+            kv_cache["k"][:, current_start:current_end] = roped_key
+            kv_cache["v"][:, current_start:current_end] = v
+
+            x = attention(roped_query, kv_cache["k"][:, :current_end], kv_cache["v"][:, :current_end])
+            
+            # print(x.shape, q.shape, k.shape, v.shape, roped_query.shape, roped_key.shape,  kv_cache["k"][:, :current_end].shape, kv_cache["v"][:, :current_end].shape)
+
+        # output
+        x = x.flatten(2)
+        x = self.o(x)
+        return x
+
+
+class CausalWanAttentionBlock(nn.Module):
+
+    def __init__(self,
+                 cross_attn_type,
+                 dim,
+                 ffn_dim,
+                 num_heads,
+                 window_size=(-1, -1),
+                 qk_norm=True,
+                 cross_attn_norm=False,
+                 eps=1e-6):
+        super().__init__()
+        self.dim = dim
+        self.ffn_dim = ffn_dim
+        self.num_heads = num_heads
+        self.window_size = window_size
+        self.qk_norm = qk_norm
+        self.cross_attn_norm = cross_attn_norm
+        self.eps = eps
+
+        # layers
+        self.norm1 = WanLayerNorm(dim, eps)
+        self.self_attn = CausalWanSelfAttention(dim, num_heads, window_size, qk_norm,
+                                                eps)
+        self.norm3 = WanLayerNorm(
+            dim, eps,
+            elementwise_affine=True) if cross_attn_norm else nn.Identity()
+        self.cross_attn = WAN_CROSSATTENTION_CLASSES[cross_attn_type](dim,
+                                                                      num_heads,
+                                                                      (-1, -1),
+                                                                      qk_norm,
+                                                                      eps)
+        self.norm2 = WanLayerNorm(dim, eps)
+        self.ffn = nn.Sequential(
+            nn.Linear(dim, ffn_dim), nn.GELU(approximate='tanh'),
+            nn.Linear(ffn_dim, dim))
+
+        # modulation
+        self.modulation = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5)
+
+    def forward(
+        self,
+        x,
+        e,
+        seq_lens,
+        grid_sizes,
+        freqs,
+        context,
+        context_lens,
+        block_mask,
+        kv_cache=None,
+        crossattn_cache=None,
+        current_start=0,
+        current_end=0
+    ):
+        r"""
+        Args:
+            x(Tensor): Shape [B, L, C]  # torch.Size([1, 32760, 1536])
+            e(Tensor): Shape [B, F, 6, C]  # torch.Size([1, 21, 6, 1536])
+            seq_lens(Tensor): Shape [B], length of each sequence in batch
+            grid_sizes(Tensor): Shape [B, 3], the second dimension contains (F, H, W)
+            freqs(Tensor): Rope freqs, shape [1024, C / num_heads / 2]
+        """
+        num_frames, frame_seqlen = e.shape[1], x.shape[1] // e.shape[1]  # 21, 32760 / 21 = 1560
+        # assert e.dtype == torch.float32
+        # with amp.autocast(dtype=torch.float32):
+        e = (self.modulation.unsqueeze(1) + e).chunk(6, dim=2)  # [torch.Size([1, 21, 1, 1536]) x 6]
+        # assert e[0].dtype == torch.float32
+
+        # self-attention
+        y = self.self_attn(
+            (self.norm1(x).unflatten(dim=1, sizes=(num_frames, frame_seqlen)) # torch.Size([1, 32760, 1536]) -> torch.Size([1, 21, 1560, 1536]) -> torch.Size([1, 32760, 1536])
+             * (1 + e[1]) + e[0]).flatten(1, 2),
+            seq_lens,    # tensor([32760])
+            grid_sizes,  # tensor([[21, 30, 52]])
+            freqs,       # torch.Size([1024, 64])
+            block_mask,  # (1, 1, 32768, 32768)
+            kv_cache, 
+            current_start, 
+            current_end
+        )
+
+        # with amp.autocast(dtype=torch.float32):
+        x = x + (y.unflatten(dim=1, sizes=(num_frames, frame_seqlen))* e[2]).flatten(1, 2)  # torch.Size([1, 32760, 1536]) -> torch.Size([1, 21, 1560, 1536]) -> torch.Size([1, 32760, 1536])
+
+        # cross-attention & ffn function
+        def cross_attn_ffn(x, context, context_lens, e, crossattn_cache=None):
+            x = x + self.cross_attn(self.norm3(x), context,
+                                    context_lens, crossattn_cache=crossattn_cache)
+            y = self.ffn(
+                (self.norm2(x).unflatten(dim=1, sizes=(num_frames,
+                 frame_seqlen)) * (1 + e[4]) + e[3]).flatten(1, 2)  # torch.Size([1, 32760, 1536]) -> torch.Size([1, 21, 1560, 1536]) -> torch.Size([1, 32760, 1536])
+            )
+            # with amp.autocast(dtype=torch.float32):
+            x = x + (y.unflatten(dim=1, sizes=(num_frames,
+                     frame_seqlen)) * e[5]).flatten(1, 2)  # torch.Size([1, 32760, 1536]) -> torch.Size([1, 21, 1560, 1536]) -> torch.Size([1, 32760, 1536])
+            return x
+
+        x = cross_attn_ffn(x, context, context_lens, e, crossattn_cache)
+        return x
+
+
+class CausalHead(nn.Module):
+
+    def __init__(self, dim, out_dim, patch_size, eps=1e-6):
+        super().__init__()
+        self.dim = dim
+        self.out_dim = out_dim
+        self.patch_size = patch_size
+        self.eps = eps
+
+        # layers
+        out_dim = math.prod(patch_size) * out_dim
+        self.norm = WanLayerNorm(dim, eps)
+        self.head = nn.Linear(dim, out_dim)
+
+        # modulation
+        self.modulation = nn.Parameter(torch.randn(1, 2, dim) / dim**0.5)
+
+    def forward(self, x, e):
+        r"""
+        Args:
+            x(Tensor): Shape [B, L1, C]
+            e(Tensor): Shape [B, F, 1, C]
+        """
+        # assert e.dtype == torch.float32
+        # with amp.autocast(dtype=torch.float32):
+        num_frames, frame_seqlen = e.shape[1], x.shape[1] // e.shape[1]
+        e = (self.modulation.unsqueeze(1) + e).chunk(2, dim=2)
+        x = (self.head(
+            self.norm(x).unflatten(dim=1, sizes=(num_frames, frame_seqlen)) *
+            (1 + e[1]) + e[0]))
+        return x
+
+
+class CausalWanModel(ModelMixin, ConfigMixin):
+    r"""
+    Wan diffusion backbone supporting both text-to-video and image-to-video.
+    """
+
+    ignore_for_config = [
+        'patch_size', 'cross_attn_norm', 'qk_norm', 'text_dim', 'window_size'
+    ]
+    _no_split_modules = ['WanAttentionBlock']
+    _supports_gradient_checkpointing = True
+
+    @register_to_config
+    def __init__(self,
+                 model_type='t2v',
+                 patch_size=(1, 2, 2),
+                 text_len=512,
+                 in_dim=16,
+                 dim=2048,
+                 ffn_dim=8192,
+                 freq_dim=256,
+                 text_dim=4096,
+                 out_dim=16,
+                 num_heads=16,
+                 num_layers=32,
+                 window_size=(-1, -1),
+                 qk_norm=True,
+                 cross_attn_norm=True,
+                 eps=1e-6):
+        r"""
+        Initialize the diffusion model backbone.
+
+        Args:
+            model_type (`str`, *optional*, defaults to 't2v'):
+                Model variant - 't2v' (text-to-video) or 'i2v' (image-to-video)
+            patch_size (`tuple`, *optional*, defaults to (1, 2, 2)):
+                3D patch dimensions for video embedding (t_patch, h_patch, w_patch)
+            text_len (`int`, *optional*, defaults to 512):
+                Fixed length for text embeddings
+            in_dim (`int`, *optional*, defaults to 16):
+                Input video channels (C_in)
+            dim (`int`, *optional*, defaults to 2048):
+                Hidden dimension of the transformer
+            ffn_dim (`int`, *optional*, defaults to 8192):
+                Intermediate dimension in feed-forward network
+            freq_dim (`int`, *optional*, defaults to 256):
+                Dimension for sinusoidal time embeddings
+            text_dim (`int`, *optional*, defaults to 4096):
+                Input dimension for text embeddings
+            out_dim (`int`, *optional*, defaults to 16):
+                Output video channels (C_out)
+            num_heads (`int`, *optional*, defaults to 16):
+                Number of attention heads
+            num_layers (`int`, *optional*, defaults to 32):
+                Number of transformer blocks
+            window_size (`tuple`, *optional*, defaults to (-1, -1)):
+                Window size for local attention (-1 indicates global attention)
+            qk_norm (`bool`, *optional*, defaults to True):
+                Enable query/key normalization
+            cross_attn_norm (`bool`, *optional*, defaults to False):
+                Enable cross-attention normalization
+            eps (`float`, *optional*, defaults to 1e-6):
+                Epsilon value for normalization layers
+        """
+
+        super().__init__()
+
+        assert model_type in ['t2v', 'i2v']
+        self.model_type = model_type
+
+        self.patch_size = patch_size
+        self.text_len = text_len
+        self.in_dim = in_dim
+        self.dim = dim
+        self.ffn_dim = ffn_dim
+        self.freq_dim = freq_dim
+        self.text_dim = text_dim
+        self.out_dim = out_dim
+        self.num_heads = num_heads
+        self.num_layers = num_layers
+        self.window_size = window_size
+        self.qk_norm = qk_norm
+        self.cross_attn_norm = cross_attn_norm
+        self.eps = eps
+
+        # embeddings
+        self.patch_embedding = nn.Conv3d(
+            in_dim, dim, kernel_size=patch_size, stride=patch_size)
+        self.text_embedding = nn.Sequential(
+            nn.Linear(text_dim, dim), nn.GELU(approximate='tanh'),
+            nn.Linear(dim, dim))
+
+        self.time_embedding = nn.Sequential(
+            nn.Linear(freq_dim, dim), nn.SiLU(), nn.Linear(dim, dim))
+        self.time_projection = nn.Sequential(
+            nn.SiLU(), nn.Linear(dim, dim * 6))
+
+        # blocks
+        cross_attn_type = 't2v_cross_attn' if model_type == 't2v' else 'i2v_cross_attn'
+        self.blocks = nn.ModuleList([
+            CausalWanAttentionBlock(cross_attn_type, dim, ffn_dim, num_heads,
+                                    window_size, qk_norm, cross_attn_norm, eps)
+            for _ in range(num_layers)
+        ])
+
+        # head
+        self.head = CausalHead(dim, out_dim, patch_size, eps)
+
+        # buffers (don't use register_buffer otherwise dtype will be changed in to())
+        assert (dim % num_heads) == 0 and (dim // num_heads) % 2 == 0
+        d = dim // num_heads
+        self.freqs = torch.cat([
+            rope_params(1024, d - 4 * (d // 6)),
+            rope_params(1024, 2 * (d // 6)),
+            rope_params(1024, 2 * (d // 6))
+        ],
+            dim=1)
+
+        if model_type == 'i2v':
+            self.img_emb = MLPProj(1280, dim)
+
+        # initialize weights
+        self.init_weights()
+
+        self.gradient_checkpointing = False
+
+        self.block_mask = None
+
+        self.num_frame_per_block = 1
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        self.gradient_checkpointing = value
+
+    @staticmethod
+    def _prepare_blockwise_causal_attn_mask(
+        device: torch.device | str, num_frames: int = 21,
+        frame_seqlen: int = 1560, num_frame_per_block=1
+    ) -> BlockMask:
+        """
+        we will divide the token sequence into the following format
+        [1 latent frame] [1 latent frame] ... [1 latent frame]
+        We use flexattention to construct the attention mask
+        """
+        total_length = num_frames * frame_seqlen
+
+        # we do right padding to get to a multiple of 128
+        padded_length = math.ceil(total_length / 128) * 128 - total_length
+
+        ends = torch.zeros(total_length + padded_length,
+                           device=device, dtype=torch.long)
+
+        # Block-wise causal mask will attend to all elements that are before the end of the current chunk
+        frame_indices = torch.arange(
+            start=0,
+            end=total_length,
+            step=frame_seqlen * num_frame_per_block,
+            device=device
+        )
+
+        for tmp in frame_indices:
+            ends[tmp:tmp + frame_seqlen * num_frame_per_block] = tmp + \
+                frame_seqlen * num_frame_per_block
+
+        def attention_mask(b, h, q_idx, kv_idx):
+            return (kv_idx < ends[q_idx]) | (q_idx == kv_idx)
+            # return ((kv_idx < total_length) & (q_idx < total_length))  | (q_idx == kv_idx) # bidirectional mask
+
+        block_mask = create_block_mask(attention_mask, B=None, H=None, Q_LEN=total_length + padded_length,
+                                       KV_LEN=total_length + padded_length, _compile=False, device=device)
+
+        import torch.distributed as dist
+        if not dist.is_initialized() or dist.get_rank() == 0:
+            print(
+                f" cache a block wise causal mask with block size of {num_frame_per_block} frames")
+            print(block_mask)
+
+        return block_mask
+
+    def _forward_inference(
+        self,
+        x,
+        t,
+        context,
+        seq_len,
+        clip_fea=None,
+        y=None,
+        kv_cache: dict = None,
+        crossattn_cache: dict = None,
+        current_start: int = 0,
+        current_end: int = 0
+    ):
+        r"""
+        Run the diffusion model with kv caching.
+        See Algorithm 2 of CausVid paper https://arxiv.org/abs/2412.07772 for details.
+        This function will be run for num_frame times.
+        Process the latent frames one by one (1560 tokens each)
+
+        Args:
+            x (List[Tensor]):
+                List of input video tensors, each with shape [C_in, F, H, W]
+            t (Tensor):
+                Diffusion timesteps tensor of shape [B]
+            context (List[Tensor]):
+                List of text embeddings each with shape [L, C]
+            seq_len (`int`):
+                Maximum sequence length for positional encoding
+            clip_fea (Tensor, *optional*):
+                CLIP image features for image-to-video mode
+            y (List[Tensor], *optional*):
+                Conditional video inputs for image-to-video mode, same shape as x
+
+        Returns:
+            List[Tensor]:
+                List of denoised video tensors with original input shapes [C_out, F, H / 8, W / 8]
+        """
+        if self.model_type == 'i2v':
+            assert clip_fea is not None and y is not None
+        # params
+        device = self.patch_embedding.weight.device
+        if self.freqs.device != device:
+            self.freqs = self.freqs.to(device)
+
+        if y is not None:
+            x = [torch.cat([u, v], dim=0) for u, v in zip(x, y)]
+
+        # embeddings
+        x = [self.patch_embedding(u.unsqueeze(0)) for u in x]
+        grid_sizes = torch.stack(
+            [torch.tensor(u.shape[2:], dtype=torch.long) for u in x])
+        x = [u.flatten(2).transpose(1, 2) for u in x]
+        seq_lens = torch.tensor([u.size(1) for u in x], dtype=torch.long)
+        assert seq_lens.max() <= seq_len
+        x = torch.cat(x)
+        """
+        torch.cat([
+            torch.cat([u, u.new_zeros(1, seq_len - u.size(1), u.size(2))],
+                      dim=1) for u in x
+        ])
+        """
+
+        # time embeddings
+        # with amp.autocast(dtype=torch.float32):
+        e = self.time_embedding(sinusoidal_embedding_1d(self.freq_dim, t.flatten()).type_as(x))
+        e0 = self.time_projection(e).unflatten(1, (6, self.dim)).unflatten(dim=0, sizes=t.shape)
+        # assert e.dtype == torch.float32 and e0.dtype == torch.float32
+
+        # context
+        context_lens = None
+        context = self.text_embedding(
+            torch.stack([
+                torch.cat(
+                    [u, u.new_zeros(self.text_len - u.size(0), u.size(1))])
+                for u in context
+            ]))
+
+        if clip_fea is not None:
+            context_clip = self.img_emb(clip_fea)  # bs x 257 x dim
+            context = torch.concat([context_clip, context], dim=1)
+
+        # arguments
+        kwargs = dict(
+            e=e0,
+            seq_lens=seq_lens,
+            grid_sizes=grid_sizes,
+            freqs=self.freqs,
+            context=context,
+            context_lens=context_lens,
+            block_mask=self.block_mask
+        )
+
+        def create_custom_forward(module):
+            def custom_forward(*inputs, **kwargs):
+                return module(*inputs, **kwargs)
+            return custom_forward
+
+        for block_index, block in enumerate(self.blocks):
+            if torch.is_grad_enabled() and self.gradient_checkpointing:
+                assert False
+            else:
+                kwargs.update(
+                    {
+                        "kv_cache": kv_cache[block_index],
+                        "crossattn_cache": crossattn_cache[block_index],
+                        "current_start": current_start,
+                        "current_end": current_end
+                    }
+                )
+                x = block(x, **kwargs)
+
+        # head
+        x = self.head(x, e.unflatten(dim=0, sizes=t.shape).unsqueeze(2))
+
+        # unpatchify
+        x = self.unpatchify(x, grid_sizes)
+        return torch.stack(x)
+
+    def _forward_train(
+        self,
+        x,
+        t,
+        context,
+        seq_len,
+        clip_fea=None,
+        y=None,
+    ):
+        r"""
+        Forward pass through the diffusion model
+
+        Args:
+            x (List[Tensor]):
+                List of input video tensors, each with shape [C_in, F, H, W]
+            t (Tensor):
+                Diffusion timesteps tensor of shape [B]
+            context (List[Tensor]):
+                List of text embeddings each with shape [L, C]
+            seq_len (`int`):
+                Maximum sequence length for positional encoding
+            clip_fea (Tensor, *optional*):
+                CLIP image features for image-to-video mode
+            y (List[Tensor], *optional*):
+                Conditional video inputs for image-to-video mode, same shape as x
+
+        Returns:
+            List[Tensor]:
+                List of denoised video tensors with original input shapes [C_out, F, H / 8, W / 8]
+        """
+        if self.model_type == 'i2v':
+            assert clip_fea is not None and y is not None
+        # params
+        device = self.patch_embedding.weight.device
+        if self.freqs.device != device:
+            self.freqs = self.freqs.to(device)
+
+        # Construct blockwise causal attn mask
+        if self.block_mask is None:
+            self.block_mask = self._prepare_blockwise_causal_attn_mask(
+                device, num_frames=x.shape[2],
+                frame_seqlen=x.shape[-2] *
+                x.shape[-1] // (self.patch_size[1] * self.patch_size[2]),
+                num_frame_per_block=self.num_frame_per_block
+            )
+
+        if y is not None:
+            x = [torch.cat([u, v], dim=0) for u, v in zip(x, y)]
+    
+        # embeddings
+        x = [self.patch_embedding(u.unsqueeze(0)) for u in x]
+        grid_sizes = torch.stack(
+            [torch.tensor(u.shape[2:], dtype=torch.long) for u in x])
+        x = [u.flatten(2).transpose(1, 2) for u in x]
+        seq_lens = torch.tensor([u.size(1) for u in x], dtype=torch.long)
+        assert seq_lens.max() <= seq_len
+        x = torch.cat([torch.cat([u, u.new_zeros(1, seq_len - u.size(1), u.size(2))], dim=1) for u in x])
+
+        # time embeddings
+        # with amp.autocast(dtype=torch.float32):
+        e = self.time_embedding(sinusoidal_embedding_1d(self.freq_dim, t.flatten()).type_as(x))  # [1, 21] -> [21, 1536]
+        e0 = self.time_projection(e).unflatten(1, (6, self.dim)).unflatten(dim=0, sizes=t.shape)  # [1, 21, 6, 1536]
+        # assert e.dtype == torch.float32 and e0.dtype == torch.float32
+
+        # context
+        context_lens = None
+        context = self.text_embedding(
+            torch.stack([
+                torch.cat(
+                    [u, u.new_zeros(self.text_len - u.size(0), u.size(1))])
+                for u in context
+            ]))
+
+        if clip_fea is not None:
+            context_clip = self.img_emb(clip_fea)  # bs x 257 x dim
+            context = torch.concat([context_clip, context], dim=1)
+
+        # arguments
+        kwargs = dict(
+            e=e0,
+            seq_lens=seq_lens,
+            grid_sizes=grid_sizes,
+            freqs=self.freqs,
+            context=context,
+            context_lens=context_lens,
+            block_mask=self.block_mask)
+
+        def create_custom_forward(module):
+            def custom_forward(*inputs, **kwargs):
+                return module(*inputs, **kwargs)
+            return custom_forward
+        
+        for block in self.blocks:
+            if torch.is_grad_enabled() and self.gradient_checkpointing:
+                x = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(block),
+                    x, **kwargs,
+                    use_reentrant=False,
+                )
+            else:
+                x = block(x, **kwargs)
+
+        # head
+        x = self.head(x, e.unflatten(dim=0, sizes=t.shape).unsqueeze(2))
+
+        # unpatchify
+        x = self.unpatchify(x, grid_sizes)
+        return torch.stack(x)
+
+    def forward(
+        self,
+        *args,
+        **kwargs
+    ):
+        if kwargs.get('kv_cache', None) is not None:
+            return self._forward_inference(*args, **kwargs)
+        else:
+            return self._forward_train(*args, **kwargs)
+
+    def unpatchify(self, x, grid_sizes):
+        r"""
+        Reconstruct video tensors from patch embeddings.
+
+        Args:
+            x (List[Tensor]):
+                List of patchified features, each with shape [L, C_out * prod(patch_size)]
+            grid_sizes (Tensor):
+                Original spatial-temporal grid dimensions before patching,
+                    shape [B, 3] (3 dimensions correspond to F_patches, H_patches, W_patches)
+
+        Returns:
+            List[Tensor]:
+                Reconstructed video tensors with shape [C_out, F, H / 8, W / 8]
+        """
+
+        c = self.out_dim
+        out = []
+        for u, v in zip(x, grid_sizes.tolist()):
+            u = u[:math.prod(v)].view(*v, *self.patch_size, c)
+            u = torch.einsum('fhwpqrc->cfphqwr', u)
+            u = u.reshape(c, *[i * j for i, j in zip(v, self.patch_size)])
+            out.append(u)
+        return out
+
+    def init_weights(self):
+        r"""
+        Initialize model parameters using Xavier initialization.
+        """
+
+        # basic init
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+
+        # init embeddings
+        nn.init.xavier_uniform_(self.patch_embedding.weight.flatten(1))
+        for m in self.text_embedding.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, std=.02)
+        for m in self.time_embedding.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, std=.02)
+
+        # init output layer
+        nn.init.zeros_(self.head.head.weight)

exp_code/1_benchmark/CausVid/causvid/models/wan/flow_match.py

@@ -0,0 +1,83 @@
+"""
+The following code is copied from https://github.com/modelscope/DiffSynth-Studio/blob/main/diffsynth/schedulers/flow_match.py
+"""
+import torch
+
+
+class FlowMatchScheduler():
+
+    def __init__(self, num_inference_steps=100, num_train_timesteps=1000, shift=3.0, sigma_max=1.0, sigma_min=0.003 / 1.002, inverse_timesteps=False, extra_one_step=False, reverse_sigmas=False):
+        self.num_train_timesteps = num_train_timesteps
+        self.shift = shift
+        self.sigma_max = sigma_max
+        self.sigma_min = sigma_min
+        self.inverse_timesteps = inverse_timesteps
+        self.extra_one_step = extra_one_step
+        self.reverse_sigmas = reverse_sigmas
+        self.set_timesteps(num_inference_steps)
+
+    def set_timesteps(self, num_inference_steps=100, denoising_strength=1.0, training=False):
+        sigma_start = self.sigma_min + \
+            (self.sigma_max - self.sigma_min) * denoising_strength
+        if self.extra_one_step:
+            self.sigmas = torch.linspace(
+                sigma_start, self.sigma_min, num_inference_steps + 1)[:-1]
+        else:
+            self.sigmas = torch.linspace(
+                sigma_start, self.sigma_min, num_inference_steps)
+        if self.inverse_timesteps:
+            self.sigmas = torch.flip(self.sigmas, dims=[0])
+        self.sigmas = self.shift * self.sigmas / \
+            (1 + (self.shift - 1) * self.sigmas)
+        if self.reverse_sigmas:
+            self.sigmas = 1 - self.sigmas
+        self.timesteps = self.sigmas * self.num_train_timesteps
+        if training:
+            x = self.timesteps
+            y = torch.exp(-2 * ((x - num_inference_steps / 2) /
+                          num_inference_steps) ** 2)
+            y_shifted = y - y.min()
+            bsmntw_weighing = y_shifted * \
+                (num_inference_steps / y_shifted.sum())
+            self.linear_timesteps_weights = bsmntw_weighing
+
+    def step(self, model_output, timestep, sample, to_final=False):
+        self.sigmas = self.sigmas.to(model_output.device)
+        self.timesteps = self.timesteps.to(model_output.device)
+        timestep_id = torch.argmin(
+            (self.timesteps.unsqueeze(0) - timestep.unsqueeze(1)).abs(), dim=1)
+        sigma = self.sigmas[timestep_id].reshape(-1, 1, 1, 1)
+        if to_final or (timestep_id + 1 >= len(self.timesteps)).any():
+            sigma_ = 1 if (
+                self.inverse_timesteps or self.reverse_sigmas) else 0
+        else:
+            sigma_ = self.sigmas[timestep_id + 1].reshape(-1, 1, 1, 1)
+        prev_sample = sample + model_output * (sigma_ - sigma)
+        return prev_sample
+
+    def add_noise(self, original_samples, noise, timestep):
+        """
+        Diffusion forward corruption process.
+        Input:
+            - clean_latent: the clean latent with shape [B, C, H, W]
+            - noise: the noise with shape [B, C, H, W]
+            - timestep: the timestep with shape [B]
+        Output: the corrupted latent with shape [B, C, H, W]
+        """
+        self.sigmas = self.sigmas.to(noise.device)
+        self.timesteps = self.timesteps.to(noise.device)
+        timestep_id = torch.argmin(
+            (self.timesteps.unsqueeze(0) - timestep.unsqueeze(1)).abs(), dim=1)
+        sigma = self.sigmas[timestep_id].reshape(-1, 1, 1, 1)
+        sample = (1 - sigma) * original_samples + sigma * noise
+        return sample.type_as(noise)
+
+    def training_target(self, sample, noise, timestep):
+        target = noise - sample
+        return target
+
+    def training_weight(self, timestep):
+        timestep_id = torch.argmin(
+            (self.timesteps - timestep.to(self.timesteps.device)).abs())
+        weights = self.linear_timesteps_weights[timestep_id]
+        return weights

exp_code/1_benchmark/CausVid/causvid/models/wan/generate_ode_pairs.py

@@ -0,0 +1,125 @@
+from causvid.models.wan.wan_wrapper import WanDiffusionWrapper, WanTextEncoder, WanVAEWrapper
+from causvid.models.wan.flow_match import FlowMatchScheduler
+from causvid.util import launch_distributed_job
+from causvid.data import TextDataset
+import torch.distributed as dist
+from tqdm import tqdm
+import argparse
+import torch
+import math
+import os
+
+
+def init_model(device):
+    model = WanDiffusionWrapper().to(device).to(torch.float32)
+    encoder = WanTextEncoder().to(device).to(torch.float32)
+    model.set_module_grad(
+        {
+            "model": False
+        }
+    )
+
+    scheduler = FlowMatchScheduler(
+        shift=8.0, sigma_min=0.0, extra_one_step=True)
+    scheduler.set_timesteps(num_inference_steps=50, denoising_strength=1.0)
+    scheduler.sigmas = scheduler.sigmas.to(device)
+
+    sample_neg_prompt = '色调艳丽，过曝，静态，细节模糊不清，字幕，风格，作品，画作，画面，静止，整体发灰，最差质量，低质量，JPEG压缩残留，丑陋的，残缺的，多余的手指，画得不好的手部，画得不好的脸部，畸形的，毁容的，形态畸形的肢体，手指融合，静止不动的画面，杂乱的背景，三条腿，背景人很多，倒着走'
+
+    unconditional_dict = encoder(
+        text_prompts=[sample_neg_prompt]
+    )
+
+    return model, encoder, scheduler, unconditional_dict
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--local_rank", type=int, default=-1)
+    parser.add_argument("--output_folder", type=str)
+    parser.add_argument("--caption_path", type=str)
+    parser.add_argument("--guidance_scale", type=float, default=6.0)
+
+    args = parser.parse_args()
+
+    launch_distributed_job()
+    global_rank = dist.get_rank()
+
+    device = torch.cuda.current_device()
+
+    torch.set_grad_enabled(False)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+
+    model, encoder, scheduler, unconditional_dict = init_model(device=device)
+
+    dataset = TextDataset(args.caption_path)
+
+    if global_rank == 0:
+        os.makedirs(args.output_folder, exist_ok=True)
+
+    for index in tqdm(range(int(math.ceil(len(dataset) / dist.get_world_size()))), disable=dist.get_rank() != 0):
+        prompt_index = index * dist.get_world_size() + dist.get_rank()
+        if prompt_index >= len(dataset):
+            continue
+        prompt = dataset[prompt_index]
+
+        conditional_dict = encoder(
+            text_prompts=prompt
+        )
+
+        latents = torch.randn(
+            [1, 21, 16, 60, 104], dtype=torch.float32, device=device
+        )
+
+        noisy_input = []
+
+        for progress_id, t in enumerate(tqdm(scheduler.timesteps)):
+            timestep = t * torch.ones([1, 21], device=device, dtype=torch.float32)
+
+            noisy_input.append(latents)
+
+            x0_pred_cond = model(
+                latents, conditional_dict, timestep
+            )
+
+            x0_pred_uncond = model(
+                latents, unconditional_dict, timestep
+            )
+
+            x0_pred = x0_pred_uncond + args.guidance_scale * (
+                x0_pred_cond - x0_pred_uncond
+            )
+
+            flow_pred = model._convert_x0_to_flow_pred(
+                scheduler=scheduler,
+                x0_pred=x0_pred.flatten(0, 1),
+                xt=latents.flatten(0, 1),
+                timestep=timestep.flatten(0, 1)
+            ).unflatten(0, x0_pred.shape[:2])
+
+            latents = scheduler.step(
+                flow_pred.flatten(0, 1),
+                scheduler.timesteps[progress_id] * torch.ones(
+                    [1, 21], device=device, dtype=torch.long).flatten(0, 1),
+                latents.flatten(0, 1)
+            ).unflatten(dim=0, sizes=flow_pred.shape[:2])
+
+        noisy_input.append(latents)
+
+        noisy_inputs = torch.stack(noisy_input, dim=1)
+
+        noisy_inputs = noisy_inputs[:, [0, 36, 44, -1]]
+
+        stored_data = noisy_inputs
+
+        torch.save(
+            {prompt: stored_data.cpu().detach()},
+            os.path.join(args.output_folder, f"{prompt_index:05d}.pt")
+        )
+
+    dist.barrier()
+
+
+if __name__ == "__main__":
+    main()

exp_code/1_benchmark/CausVid/causvid/models/wan/wan_base/README.md

@@ -0,0 +1,2 @@
+Code in this folder is modified from https://github.com/Wan-Video/Wan2.1
+Apache-2.0 License 

exp_code/1_benchmark/CausVid/causvid/models/wan/wan_base/__init__.py

@@ -0,0 +1,3 @@
+from . import configs, distributed, modules
+from .image2video import WanI2V
+from .text2video import WanT2V

exp_code/1_benchmark/CausVid/causvid/models/wan/wan_base/configs/__init__.py

@@ -0,0 +1,42 @@
+# Copyright 2024-2025 The Alibaba Wan Team Authors. All rights reserved.
+from .wan_t2v_14B import t2v_14B
+from .wan_t2v_1_3B import t2v_1_3B
+from .wan_i2v_14B import i2v_14B
+import copy
+import os
+
+os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+
+
+# the config of t2i_14B is the same as t2v_14B
+t2i_14B = copy.deepcopy(t2v_14B)
+t2i_14B.__name__ = 'Config: Wan T2I 14B'
+
+WAN_CONFIGS = {
+    't2v-14B': t2v_14B,
+    't2v-1.3B': t2v_1_3B,
+    'i2v-14B': i2v_14B,
+    't2i-14B': t2i_14B,
+}
+
+SIZE_CONFIGS = {
+    '720*1280': (720, 1280),
+    '1280*720': (1280, 720),
+    '480*832': (480, 832),
+    '832*480': (832, 480),
+    '1024*1024': (1024, 1024),
+}
+
+MAX_AREA_CONFIGS = {
+    '720*1280': 720 * 1280,
+    '1280*720': 1280 * 720,
+    '480*832': 480 * 832,
+    '832*480': 832 * 480,
+}
+
+SUPPORTED_SIZES = {
+    't2v-14B': ('720*1280', '1280*720', '480*832', '832*480'),
+    't2v-1.3B': ('480*832', '832*480'),
+    'i2v-14B': ('720*1280', '1280*720', '480*832', '832*480'),
+    't2i-14B': tuple(SIZE_CONFIGS.keys()),
+}