Add files using upload-large-folder tool

exp_code/1_benchmark/DiffSynth-Studio/diffsynth.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: diffsynth
+Version: 1.1.7
+Summary: Enjoy the magic of Diffusion models!
+Author: Artiprocher
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+License-File: LICENSE

exp_code/1_benchmark/DiffSynth-Studio/diffsynth.egg-info/SOURCES.txt

@@ -0,0 +1,243 @@
+LICENSE
+README.md
+setup.py
+diffsynth/__init__.py
+diffsynth.egg-info/PKG-INFO
+diffsynth.egg-info/SOURCES.txt
+diffsynth.egg-info/dependency_links.txt
+diffsynth.egg-info/requires.txt
+diffsynth.egg-info/top_level.txt
+diffsynth/configs/__init__.py
+diffsynth/configs/model_config.py
+diffsynth/controlnets/__init__.py
+diffsynth/controlnets/controlnet_unit.py
+diffsynth/controlnets/processors.py
+diffsynth/data/__init__.py
+diffsynth/data/simple_text_image.py
+diffsynth/data/video.py
+diffsynth/distributed/__init__.py
+diffsynth/distributed/xdit_context_parallel.py
+diffsynth/extensions/__init__.py
+diffsynth/extensions/ESRGAN/__init__.py
+diffsynth/extensions/FastBlend/__init__.py
+diffsynth/extensions/FastBlend/api.py
+diffsynth/extensions/FastBlend/cupy_kernels.py
+diffsynth/extensions/FastBlend/data.py
+diffsynth/extensions/FastBlend/patch_match.py
+diffsynth/extensions/FastBlend/runners/__init__.py
+diffsynth/extensions/FastBlend/runners/accurate.py
+diffsynth/extensions/FastBlend/runners/balanced.py
+diffsynth/extensions/FastBlend/runners/fast.py
+diffsynth/extensions/FastBlend/runners/interpolation.py
+diffsynth/extensions/ImageQualityMetric/__init__.py
+diffsynth/extensions/ImageQualityMetric/aesthetic.py
+diffsynth/extensions/ImageQualityMetric/clip.py
+diffsynth/extensions/ImageQualityMetric/config.py
+diffsynth/extensions/ImageQualityMetric/hps.py
+diffsynth/extensions/ImageQualityMetric/imagereward.py
+diffsynth/extensions/ImageQualityMetric/mps.py
+diffsynth/extensions/ImageQualityMetric/pickscore.py
+diffsynth/extensions/ImageQualityMetric/BLIP/__init__.py
+diffsynth/extensions/ImageQualityMetric/BLIP/blip.py
+diffsynth/extensions/ImageQualityMetric/BLIP/blip_pretrain.py
+diffsynth/extensions/ImageQualityMetric/BLIP/med.py
+diffsynth/extensions/ImageQualityMetric/BLIP/vit.py
+diffsynth/extensions/ImageQualityMetric/open_clip/__init__.py
+diffsynth/extensions/ImageQualityMetric/open_clip/coca_model.py
+diffsynth/extensions/ImageQualityMetric/open_clip/constants.py
+diffsynth/extensions/ImageQualityMetric/open_clip/factory.py
+diffsynth/extensions/ImageQualityMetric/open_clip/generation_utils.py
+diffsynth/extensions/ImageQualityMetric/open_clip/hf_configs.py
+diffsynth/extensions/ImageQualityMetric/open_clip/hf_model.py
+diffsynth/extensions/ImageQualityMetric/open_clip/loss.py
+diffsynth/extensions/ImageQualityMetric/open_clip/model.py
+diffsynth/extensions/ImageQualityMetric/open_clip/modified_resnet.py
+diffsynth/extensions/ImageQualityMetric/open_clip/openai.py
+diffsynth/extensions/ImageQualityMetric/open_clip/pretrained.py
+diffsynth/extensions/ImageQualityMetric/open_clip/push_to_hf_hub.py
+diffsynth/extensions/ImageQualityMetric/open_clip/timm_model.py
+diffsynth/extensions/ImageQualityMetric/open_clip/tokenizer.py
+diffsynth/extensions/ImageQualityMetric/open_clip/transform.py
+diffsynth/extensions/ImageQualityMetric/open_clip/transformer.py
+diffsynth/extensions/ImageQualityMetric/open_clip/utils.py
+diffsynth/extensions/ImageQualityMetric/open_clip/version.py
+diffsynth/extensions/ImageQualityMetric/trainer/__init__.py
+diffsynth/extensions/ImageQualityMetric/trainer/models/__init__.py
+diffsynth/extensions/ImageQualityMetric/trainer/models/base_model.py
+diffsynth/extensions/ImageQualityMetric/trainer/models/clip_model.py
+diffsynth/extensions/ImageQualityMetric/trainer/models/cross_modeling.py
+diffsynth/extensions/RIFE/__init__.py
+diffsynth/lora/__init__.py
+diffsynth/lora/flux_lora.py
+diffsynth/models/__init__.py
+diffsynth/models/attention.py
+diffsynth/models/cog_dit.py
+diffsynth/models/cog_vae.py
+diffsynth/models/downloader.py
+diffsynth/models/flux_controlnet.py
+diffsynth/models/flux_dit.py
+diffsynth/models/flux_infiniteyou.py
+diffsynth/models/flux_ipadapter.py
+diffsynth/models/flux_lora_encoder.py
+diffsynth/models/flux_text_encoder.py
+diffsynth/models/flux_vae.py
+diffsynth/models/flux_value_control.py
+diffsynth/models/hunyuan_dit.py
+diffsynth/models/hunyuan_dit_text_encoder.py
+diffsynth/models/hunyuan_video_dit.py
+diffsynth/models/hunyuan_video_text_encoder.py
+diffsynth/models/hunyuan_video_vae_decoder.py
+diffsynth/models/hunyuan_video_vae_encoder.py
+diffsynth/models/kolors_text_encoder.py
+diffsynth/models/lora.py
+diffsynth/models/model_manager.py
+diffsynth/models/nexus_gen.py
+diffsynth/models/nexus_gen_ar_model.py
+diffsynth/models/nexus_gen_projector.py
+diffsynth/models/omnigen.py
+diffsynth/models/qwen_image_controlnet.py
+diffsynth/models/qwen_image_dit.py
+diffsynth/models/qwen_image_text_encoder.py
+diffsynth/models/qwen_image_vae.py
+diffsynth/models/qwenvl.py
+diffsynth/models/sd3_dit.py
+diffsynth/models/sd3_text_encoder.py
+diffsynth/models/sd3_vae_decoder.py
+diffsynth/models/sd3_vae_encoder.py
+diffsynth/models/sd_controlnet.py
+diffsynth/models/sd_ipadapter.py
+diffsynth/models/sd_motion.py
+diffsynth/models/sd_text_encoder.py
+diffsynth/models/sd_unet.py
+diffsynth/models/sd_vae_decoder.py
+diffsynth/models/sd_vae_encoder.py
+diffsynth/models/sdxl_controlnet.py
+diffsynth/models/sdxl_ipadapter.py
+diffsynth/models/sdxl_motion.py
+diffsynth/models/sdxl_text_encoder.py
+diffsynth/models/sdxl_unet.py
+diffsynth/models/sdxl_vae_decoder.py
+diffsynth/models/sdxl_vae_encoder.py
+diffsynth/models/step1x_connector.py
+diffsynth/models/stepvideo_dit.py
+diffsynth/models/stepvideo_text_encoder.py
+diffsynth/models/stepvideo_vae.py
+diffsynth/models/svd_image_encoder.py
+diffsynth/models/svd_unet.py
+diffsynth/models/svd_vae_decoder.py
+diffsynth/models/svd_vae_encoder.py
+diffsynth/models/tiler.py
+diffsynth/models/utils.py
+diffsynth/models/wan_video_camera_controller.py
+diffsynth/models/wan_video_dit.py
+diffsynth/models/wan_video_dit_s2v.py
+diffsynth/models/wan_video_image_encoder.py
+diffsynth/models/wan_video_motion_controller.py
+diffsynth/models/wan_video_text_encoder.py
+diffsynth/models/wan_video_vace.py
+diffsynth/models/wan_video_vae.py
+diffsynth/models/wav2vec.py
+diffsynth/pipelines/__init__.py
+diffsynth/pipelines/base.py
+diffsynth/pipelines/cog_video.py
+diffsynth/pipelines/dancer.py
+diffsynth/pipelines/flux_image.py
+diffsynth/pipelines/flux_image_new.py
+diffsynth/pipelines/hunyuan_image.py
+diffsynth/pipelines/hunyuan_video.py
+diffsynth/pipelines/omnigen_image.py
+diffsynth/pipelines/pipeline_runner.py
+diffsynth/pipelines/qwen_image.py
+diffsynth/pipelines/sd3_image.py
+diffsynth/pipelines/sd_image.py
+diffsynth/pipelines/sd_video.py
+diffsynth/pipelines/sdxl_image.py
+diffsynth/pipelines/sdxl_video.py
+diffsynth/pipelines/step_video.py
+diffsynth/pipelines/svd_video.py
+diffsynth/pipelines/wan_video.py
+diffsynth/pipelines/wan_video_new.py
+diffsynth/processors/FastBlend.py
+diffsynth/processors/PILEditor.py
+diffsynth/processors/RIFE.py
+diffsynth/processors/__init__.py
+diffsynth/processors/base.py
+diffsynth/processors/sequencial_processor.py
+diffsynth/prompters/__init__.py
+diffsynth/prompters/base_prompter.py
+diffsynth/prompters/cog_prompter.py
+diffsynth/prompters/flux_prompter.py
+diffsynth/prompters/hunyuan_dit_prompter.py
+diffsynth/prompters/hunyuan_video_prompter.py
+diffsynth/prompters/kolors_prompter.py
+diffsynth/prompters/omnigen_prompter.py
+diffsynth/prompters/omost.py
+diffsynth/prompters/prompt_refiners.py
+diffsynth/prompters/sd3_prompter.py
+diffsynth/prompters/sd_prompter.py
+diffsynth/prompters/sdxl_prompter.py
+diffsynth/prompters/stepvideo_prompter.py
+diffsynth/prompters/wan_prompter.py
+diffsynth/schedulers/__init__.py
+diffsynth/schedulers/continuous_ode.py
+diffsynth/schedulers/ddim.py
+diffsynth/schedulers/flow_match.py
+diffsynth/tokenizer_configs/__init__.py
+diffsynth/tokenizer_configs/cog/tokenizer/added_tokens.json
+diffsynth/tokenizer_configs/cog/tokenizer/special_tokens_map.json
+diffsynth/tokenizer_configs/cog/tokenizer/spiece.model
+diffsynth/tokenizer_configs/cog/tokenizer/tokenizer_config.json
+diffsynth/tokenizer_configs/flux/tokenizer_1/merges.txt
+diffsynth/tokenizer_configs/flux/tokenizer_1/special_tokens_map.json
+diffsynth/tokenizer_configs/flux/tokenizer_1/tokenizer_config.json
+diffsynth/tokenizer_configs/flux/tokenizer_1/vocab.json
+diffsynth/tokenizer_configs/flux/tokenizer_2/special_tokens_map.json
+diffsynth/tokenizer_configs/flux/tokenizer_2/spiece.model
+diffsynth/tokenizer_configs/flux/tokenizer_2/tokenizer.json
+diffsynth/tokenizer_configs/flux/tokenizer_2/tokenizer_config.json
+diffsynth/tokenizer_configs/hunyuan_dit/tokenizer/special_tokens_map.json
+diffsynth/tokenizer_configs/hunyuan_dit/tokenizer/tokenizer_config.json
+diffsynth/tokenizer_configs/hunyuan_dit/tokenizer/vocab.txt
+diffsynth/tokenizer_configs/hunyuan_dit/tokenizer/vocab_org.txt
+diffsynth/tokenizer_configs/hunyuan_dit/tokenizer_t5/config.json
+diffsynth/tokenizer_configs/hunyuan_dit/tokenizer_t5/special_tokens_map.json
+diffsynth/tokenizer_configs/hunyuan_dit/tokenizer_t5/spiece.model
+diffsynth/tokenizer_configs/hunyuan_dit/tokenizer_t5/tokenizer_config.json
+diffsynth/tokenizer_configs/hunyuan_video/tokenizer_1/merges.txt
+diffsynth/tokenizer_configs/hunyuan_video/tokenizer_1/special_tokens_map.json
+diffsynth/tokenizer_configs/hunyuan_video/tokenizer_1/tokenizer_config.json
+diffsynth/tokenizer_configs/hunyuan_video/tokenizer_1/vocab.json
+diffsynth/tokenizer_configs/hunyuan_video/tokenizer_2/preprocessor_config.json
+diffsynth/tokenizer_configs/hunyuan_video/tokenizer_2/special_tokens_map.json
+diffsynth/tokenizer_configs/hunyuan_video/tokenizer_2/tokenizer.json
+diffsynth/tokenizer_configs/hunyuan_video/tokenizer_2/tokenizer_config.json
+diffsynth/tokenizer_configs/kolors/tokenizer/tokenizer.model
+diffsynth/tokenizer_configs/kolors/tokenizer/tokenizer_config.json
+diffsynth/tokenizer_configs/kolors/tokenizer/vocab.txt
+diffsynth/tokenizer_configs/stable_diffusion/tokenizer/merges.txt
+diffsynth/tokenizer_configs/stable_diffusion/tokenizer/special_tokens_map.json
+diffsynth/tokenizer_configs/stable_diffusion/tokenizer/tokenizer_config.json
+diffsynth/tokenizer_configs/stable_diffusion/tokenizer/vocab.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_1/merges.txt
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_1/special_tokens_map.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_1/tokenizer_config.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_1/vocab.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_2/merges.txt
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_2/special_tokens_map.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_2/tokenizer_config.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_2/vocab.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_3/special_tokens_map.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_3/spiece.model
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_3/tokenizer.json
+diffsynth/tokenizer_configs/stable_diffusion_3/tokenizer_3/tokenizer_config.json
+diffsynth/tokenizer_configs/stable_diffusion_xl/tokenizer_2/merges.txt
+diffsynth/tokenizer_configs/stable_diffusion_xl/tokenizer_2/special_tokens_map.json
+diffsynth/tokenizer_configs/stable_diffusion_xl/tokenizer_2/tokenizer_config.json
+diffsynth/tokenizer_configs/stable_diffusion_xl/tokenizer_2/vocab.json
+diffsynth/trainers/__init__.py
+diffsynth/trainers/text_to_image.py
+diffsynth/trainers/utils.py
+diffsynth/utils/__init__.py
+diffsynth/vram_management/__init__.py
+diffsynth/vram_management/gradient_checkpointing.py
+diffsynth/vram_management/layers.py

exp_code/1_benchmark/DiffSynth-Studio/diffsynth.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

exp_code/1_benchmark/DiffSynth-Studio/diffsynth.egg-info/requires.txt

@@ -0,0 +1,16 @@
+torch>=2.0.0
+torchvision
+cupy-cuda12x
+transformers
+controlnet-aux==0.0.7
+imageio
+imageio[ffmpeg]
+safetensors
+einops
+sentencepiece
+protobuf
+modelscope
+ftfy
+pynvml
+pandas
+accelerate

exp_code/1_benchmark/DiffSynth-Studio/diffsynth.egg-info/top_level.txt

@@ -0,0 +1 @@
+diffsynth

exp_code/1_benchmark/DiffSynth-Studio/diffsynth/pipelines/__init__.py

@@ -0,0 +1,15 @@
+from .sd_image import SDImagePipeline
+from .sd_video import SDVideoPipeline
+from .sdxl_image import SDXLImagePipeline
+from .sdxl_video import SDXLVideoPipeline
+from .sd3_image import SD3ImagePipeline
+from .hunyuan_image import HunyuanDiTImagePipeline
+from .svd_video import SVDVideoPipeline
+from .flux_image import FluxImagePipeline
+from .cog_video import CogVideoPipeline
+from .omnigen_image import OmnigenImagePipeline
+from .pipeline_runner import SDVideoPipelineRunner
+from .hunyuan_video import HunyuanVideoPipeline
+from .step_video import StepVideoPipeline
+from .wan_video import WanVideoPipeline
+KolorsImagePipeline = SDXLImagePipeline

exp_code/1_benchmark/DiffSynth-Studio/diffsynth/pipelines/base.py

@@ -0,0 +1,127 @@
+import torch
+import numpy as np
+from PIL import Image
+from torchvision.transforms import GaussianBlur
+
+
+
+class BasePipeline(torch.nn.Module):
+
+    def __init__(self, device="cuda", torch_dtype=torch.float16, height_division_factor=64, width_division_factor=64):
+        super().__init__()
+        self.device = device
+        self.torch_dtype = torch_dtype
+        self.height_division_factor = height_division_factor
+        self.width_division_factor = width_division_factor
+        self.cpu_offload = False
+        self.model_names = []
+
+
+    def check_resize_height_width(self, height, width):
+        if height % self.height_division_factor != 0:
+            height = (height + self.height_division_factor - 1) // self.height_division_factor * self.height_division_factor
+            print(f"The height cannot be evenly divided by {self.height_division_factor}. We round it up to {height}.")
+        if width % self.width_division_factor != 0:
+            width = (width + self.width_division_factor - 1) // self.width_division_factor * self.width_division_factor
+            print(f"The width cannot be evenly divided by {self.width_division_factor}. We round it up to {width}.")
+        return height, width
+
+
+    def preprocess_image(self, image):
+        image = torch.Tensor(np.array(image, dtype=np.float32) * (2 / 255) - 1).permute(2, 0, 1).unsqueeze(0)
+        return image
+    
+
+    def preprocess_images(self, images):
+        return [self.preprocess_image(image) for image in images]
+    
+
+    def vae_output_to_image(self, vae_output):
+        image = vae_output[0].cpu().float().permute(1, 2, 0).numpy()
+        image = Image.fromarray(((image / 2 + 0.5).clip(0, 1) * 255).astype("uint8"))
+        return image
+    
+
+    def vae_output_to_video(self, vae_output):
+        video = vae_output.cpu().permute(1, 2, 0).numpy()
+        video = [Image.fromarray(((image / 2 + 0.5).clip(0, 1) * 255).astype("uint8")) for image in video]
+        return video
+
+    
+    def merge_latents(self, value, latents, masks, scales, blur_kernel_size=33, blur_sigma=10.0):
+        if len(latents) > 0:
+            blur = GaussianBlur(kernel_size=blur_kernel_size, sigma=blur_sigma)
+            height, width = value.shape[-2:]
+            weight = torch.ones_like(value)
+            for latent, mask, scale in zip(latents, masks, scales):
+                mask = self.preprocess_image(mask.resize((width, height))).mean(dim=1, keepdim=True) > 0
+                mask = mask.repeat(1, latent.shape[1], 1, 1).to(dtype=latent.dtype, device=latent.device)
+                mask = blur(mask)
+                value += latent * mask * scale
+                weight += mask * scale
+            value /= weight
+        return value
+
+
+    def control_noise_via_local_prompts(self, prompt_emb_global, prompt_emb_locals, masks, mask_scales, inference_callback, special_kwargs=None, special_local_kwargs_list=None):
+        if special_kwargs is None:
+            noise_pred_global = inference_callback(prompt_emb_global)
+        else:
+            noise_pred_global = inference_callback(prompt_emb_global, special_kwargs)
+        if special_local_kwargs_list is None:
+            noise_pred_locals = [inference_callback(prompt_emb_local) for prompt_emb_local in prompt_emb_locals]
+        else:
+            noise_pred_locals = [inference_callback(prompt_emb_local, special_kwargs) for prompt_emb_local, special_kwargs in zip(prompt_emb_locals, special_local_kwargs_list)]
+        noise_pred = self.merge_latents(noise_pred_global, noise_pred_locals, masks, mask_scales)
+        return noise_pred
+    
+
+    def extend_prompt(self, prompt, local_prompts, masks, mask_scales):
+        local_prompts = local_prompts or []
+        masks = masks or []
+        mask_scales = mask_scales or []
+        extended_prompt_dict = self.prompter.extend_prompt(prompt)
+        prompt = extended_prompt_dict.get("prompt", prompt)
+        local_prompts += extended_prompt_dict.get("prompts", [])
+        masks += extended_prompt_dict.get("masks", [])
+        mask_scales += [100.0] * len(extended_prompt_dict.get("masks", []))
+        return prompt, local_prompts, masks, mask_scales
+    
+    
+    def enable_cpu_offload(self):
+        self.cpu_offload = True
+
+
+    def load_models_to_device(self, loadmodel_names=[]):
+        # only load models to device if cpu_offload is enabled
+        if not self.cpu_offload:
+            return
+        # offload the unneeded models to cpu
+        for model_name in self.model_names:
+            if model_name not in loadmodel_names:
+                model = getattr(self, model_name)
+                if model is not None:
+                    if hasattr(model, "vram_management_enabled") and model.vram_management_enabled:
+                        for module in model.modules():
+                            if hasattr(module, "offload"):
+                                module.offload()
+                    else:
+                        model.cpu()
+        # load the needed models to device
+        for model_name in loadmodel_names:
+            model = getattr(self, model_name)
+            if model is not None:
+                if hasattr(model, "vram_management_enabled") and model.vram_management_enabled:
+                    for module in model.modules():
+                        if hasattr(module, "onload"):
+                            module.onload()
+                else:
+                    model.to(self.device)
+        # fresh the cuda cache
+        torch.cuda.empty_cache()
+
+    
+    def generate_noise(self, shape, seed=None, device="cpu", dtype=torch.float16):
+        generator = None if seed is None else torch.Generator(device).manual_seed(seed)
+        noise = torch.randn(shape, generator=generator, device=device, dtype=dtype)
+        return noise

exp_code/1_benchmark/DiffSynth-Studio/diffsynth/pipelines/cog_video.py

@@ -0,0 +1,135 @@
+from ..models import ModelManager, FluxTextEncoder2, CogDiT, CogVAEEncoder, CogVAEDecoder
+from ..prompters import CogPrompter
+from ..schedulers import EnhancedDDIMScheduler
+from .base import BasePipeline
+import torch
+from tqdm import tqdm
+from PIL import Image
+import numpy as np
+from einops import rearrange
+
+
+
+class CogVideoPipeline(BasePipeline):
+
+    def __init__(self, device="cuda", torch_dtype=torch.float16):
+        super().__init__(device=device, torch_dtype=torch_dtype, height_division_factor=16, width_division_factor=16)
+        self.scheduler = EnhancedDDIMScheduler(rescale_zero_terminal_snr=True, prediction_type="v_prediction")
+        self.prompter = CogPrompter()
+        # models
+        self.text_encoder: FluxTextEncoder2 = None
+        self.dit: CogDiT = None
+        self.vae_encoder: CogVAEEncoder = None
+        self.vae_decoder: CogVAEDecoder = None
+    
+
+    def fetch_models(self, model_manager: ModelManager, prompt_refiner_classes=[]):
+        self.text_encoder = model_manager.fetch_model("flux_text_encoder_2")
+        self.dit = model_manager.fetch_model("cog_dit")
+        self.vae_encoder = model_manager.fetch_model("cog_vae_encoder")
+        self.vae_decoder = model_manager.fetch_model("cog_vae_decoder")
+        self.prompter.fetch_models(self.text_encoder)
+        self.prompter.load_prompt_refiners(model_manager, prompt_refiner_classes)
+
+
+    @staticmethod
+    def from_model_manager(model_manager: ModelManager, prompt_refiner_classes=[]):
+        pipe = CogVideoPipeline(
+            device=model_manager.device,
+            torch_dtype=model_manager.torch_dtype
+        )
+        pipe.fetch_models(model_manager, prompt_refiner_classes)
+        return pipe
+    
+
+    def tensor2video(self, frames):
+        frames = rearrange(frames, "C T H W -> T H W C")
+        frames = ((frames.float() + 1) * 127.5).clip(0, 255).cpu().numpy().astype(np.uint8)
+        frames = [Image.fromarray(frame) for frame in frames]
+        return frames
+    
+
+    def encode_prompt(self, prompt, positive=True):
+        prompt_emb = self.prompter.encode_prompt(prompt, device=self.device, positive=positive)
+        return {"prompt_emb": prompt_emb}
+    
+
+    def prepare_extra_input(self, latents):
+        return {"image_rotary_emb": self.dit.prepare_rotary_positional_embeddings(latents.shape[3], latents.shape[4], latents.shape[2], device=self.device)}
+
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        prompt,
+        negative_prompt="",
+        input_video=None,
+        cfg_scale=7.0,
+        denoising_strength=1.0,
+        num_frames=49,
+        height=480,
+        width=720,
+        num_inference_steps=20,
+        tiled=False,
+        tile_size=(60, 90),
+        tile_stride=(30, 45),
+        seed=None,
+        progress_bar_cmd=tqdm,
+        progress_bar_st=None,
+    ):
+        height, width = self.check_resize_height_width(height, width)
+        
+        # Tiler parameters
+        tiler_kwargs = {"tiled": tiled, "tile_size": tile_size, "tile_stride": tile_stride}
+
+        # Prepare scheduler
+        self.scheduler.set_timesteps(num_inference_steps, denoising_strength=denoising_strength)
+
+        # Prepare latent tensors
+        noise = self.generate_noise((1, 16, num_frames // 4 + 1, height//8, width//8), seed=seed, device="cpu", dtype=self.torch_dtype)
+        
+        if denoising_strength == 1.0:
+            latents = noise.clone()
+        else:
+            input_video = self.preprocess_images(input_video)
+            input_video = torch.stack(input_video, dim=2)
+            latents = self.vae_encoder.encode_video(input_video, **tiler_kwargs, progress_bar=progress_bar_cmd).to(dtype=self.torch_dtype)
+            latents = self.scheduler.add_noise(latents, noise, self.scheduler.timesteps[0])
+        if not tiled: latents = latents.to(self.device)
+
+        # Encode prompt
+        prompt_emb_posi = self.encode_prompt(prompt, positive=True)
+        if cfg_scale != 1.0:
+            prompt_emb_nega = self.encode_prompt(negative_prompt, positive=False)
+
+        # Extra input
+        extra_input = self.prepare_extra_input(latents)
+
+        # Denoise
+        for progress_id, timestep in enumerate(progress_bar_cmd(self.scheduler.timesteps)):
+            timestep = timestep.unsqueeze(0).to(self.device)
+
+            # Classifier-free guidance
+            noise_pred_posi = self.dit(
+                latents, timestep=timestep, **prompt_emb_posi, **tiler_kwargs, **extra_input
+            )
+            if cfg_scale != 1.0:
+                noise_pred_nega = self.dit(
+                    latents, timestep=timestep, **prompt_emb_nega, **tiler_kwargs, **extra_input
+                )
+                noise_pred = noise_pred_nega + cfg_scale * (noise_pred_posi - noise_pred_nega)
+            else:
+                noise_pred = noise_pred_posi
+
+            # DDIM
+            latents = self.scheduler.step(noise_pred, self.scheduler.timesteps[progress_id], latents)
+            
+            # Update progress bar
+            if progress_bar_st is not None:
+                progress_bar_st.progress(progress_id / len(self.scheduler.timesteps))
+
+        # Decode image
+        video = self.vae_decoder.decode_video(latents.to("cpu"), **tiler_kwargs, progress_bar=progress_bar_cmd)
+        video = self.tensor2video(video[0])
+
+        return video