Update pipeline.py

pipeline.py

@@ -14,21 +14,18 @@
 
 import inspect
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union, Tuple
 
 import numpy as np
 import torch
-import torch.nn.functional as F
-from PIL import Image
 from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer, CLIPVisionModelWithProjection
 
+# Updated to use absolute paths
 from diffusers.image_processor import PipelineImageInput, VaeImageProcessor
 from diffusers.loaders import IPAdapterMixin, LoraLoaderMixin, TextualInversionLoaderMixin
-from diffusers.models import AutoencoderKL, ControlNetModel, UNet2DConditionModel, UNetMotionModel
+from diffusers.models import AutoencoderKL, ImageProjection, UNet2DConditionModel, UNetMotionModel, ControlNetModel
 from diffusers.models.lora import adjust_lora_scale_text_encoder
 from diffusers.models.unet_motion_model import MotionAdapter
-from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel
-from diffusers.pipelines.pipeline_utils import DiffusionPipeline
 from diffusers.schedulers import (
     DDIMScheduler,
     DPMSolverMultistepScheduler,
@@ -37,9 +34,27 @@ from diffusers.schedulers import (
     LMSDiscreteScheduler,
     PNDMScheduler,
 )
-from diffusers.utils import USE_PEFT_BACKEND, BaseOutput, deprecate, logging, scale_lora_layers, unscale_lora_layers
+from diffusers.utils import (
+    USE_PEFT_BACKEND,
+    BaseOutput,
+    logging,
+    scale_lora_layers,
+    unscale_lora_layers,
+)
 from diffusers.utils.torch_utils import is_compiled_module, randn_tensor
 
+# Added imports based on the working paths
+from diffusers.models import ControlNetModel
+from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline
+from diffusers.utils import deprecate
+
+import torchvision
+import PIL
+import PIL.Image
+import math
+import time
+
 
 logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
 
@@ -47,49 +62,72 @@ EXAMPLE_DOC_STRING = """
     Examples:
         ```py
         >>> import torch
-        >>> from diffusers import AutoencoderKL, ControlNetModel, MotionAdapter
-        >>> from diffusers.pipelines import DiffusionPipeline
-        >>> from diffusers.schedulers import DPMSolverMultistepScheduler
-        >>> from PIL import Image
-
-        >>> motion_id = "guoyww/animatediff-motion-adapter-v1-5-2"
-        >>> adapter = MotionAdapter.from_pretrained(motion_id)
-        >>> controlnet = ControlNetModel.from_pretrained("lllyasviel/control_v11p_sd15_openpose", torch_dtype=torch.float16)
-        >>> vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", torch_dtype=torch.float16)
-
-        >>> model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
-        >>> pipe = DiffusionPipeline.from_pretrained(
-        ...     model_id,
-        ...     motion_adapter=adapter,
-        ...     controlnet=controlnet,
-        ...     vae=vae,
-        ...     custom_pipeline="pipeline_animatediff_controlnet",
-        ... ).to(device="cuda", dtype=torch.float16)
-        >>> pipe.scheduler = DPMSolverMultistepScheduler.from_pretrained(
-        ...     model_id, subfolder="scheduler", clip_sample=False, timestep_spacing="linspace", steps_offset=1
-        ... )
-        >>> pipe.enable_vae_slicing()
-
-        >>> conditioning_frames = []
-        >>> for i in range(1, 16 + 1):
-        ...     conditioning_frames.append(Image.open(f"frame_{i}.png"))
-
-        >>> prompt = "astronaut in space, dancing"
-        >>> negative_prompt = "bad quality, worst quality, jpeg artifacts, ugly"
-        >>> result = pipe(
-        ...     prompt=prompt,
-        ...     negative_prompt=negative_prompt,
-        ...     width=512,
-        ...     height=768,
-        ...     conditioning_frames=conditioning_frames,
-        ...     num_inference_steps=12,
-        ... ).frames[0]
-
+        >>> from diffusers import MotionAdapter, AnimateDiffPipeline, DDIMScheduler
         >>> from diffusers.utils import export_to_gif
-        >>> export_to_gif(result.frames[0], "result.gif")
+        >>> adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")
+        >>> pipe = AnimateDiffPipeline.from_pretrained("frankjoshua/toonyou_beta6", motion_adapter=adapter)
+        >>> pipe.scheduler = DDIMScheduler(beta_schedule="linear", steps_offset=1, clip_sample=False)
+        >>> output = pipe(prompt="A corgi walking in the park")
+        >>> frames = output.frames[0]
+        >>> export_to_gif(frames, "animation.gif")
         ```
 """
+# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.retrieve_latents
+def retrieve_latents(
+    encoder_output: torch.Tensor, generator: Optional[torch.Generator] = None, sample_mode: str = "sample"
+):
+    if hasattr(encoder_output, "latent_dist") and sample_mode == "sample":
+        return encoder_output.latent_dist.sample(generator)
+    elif hasattr(encoder_output, "latent_dist") and sample_mode == "argmax":
+        return encoder_output.latent_dist.mode()
+    elif hasattr(encoder_output, "latents"):
+        return encoder_output.latents
+    else:
+        raise AttributeError("Could not access latents of provided encoder_output")
+
+# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps
+def retrieve_timesteps(
+    scheduler,
+    num_inference_steps: Optional[int] = None,
+    device: Optional[Union[str, torch.device]] = None,
+    timesteps: Optional[List[int]] = None,
+    **kwargs,
+):
+    """
+    Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles
+    custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`.
 
+    Args:
+        scheduler (`SchedulerMixin`):
+            The scheduler to get timesteps from.
+        num_inference_steps (`int`):
+            The number of diffusion steps used when generating samples with a pre-trained model. If used,
+            `timesteps` must be `None`.
+        device (`str` or `torch.device`, *optional*):
+            The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
+        timesteps (`List[int]`, *optional*):
+                Custom timesteps used to support arbitrary spacing between timesteps. If `None`, then the default
+                timestep spacing strategy of the scheduler is used. If `timesteps` is passed, `num_inference_steps`
+                must be `None`.
+
+    Returns:
+        `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the
+        second element is the number of inference steps.
+    """
+    if timesteps is not None:
+        accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys())
+        # if not accepts_timesteps:
+        #     raise ValueError(
+        #         f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
+        #         f" timestep schedules. Please check whether you are using the correct scheduler."
+        #     )
+        scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs)
+        timesteps = scheduler.timesteps
+        num_inference_steps = len(timesteps)
+    else:
+        scheduler.set_timesteps(num_inference_steps, device=device, **kwargs)
+        timesteps = scheduler.timesteps
+    return timesteps, num_inference_steps
 
 def tensor2vid(video: torch.Tensor, processor, output_type="np"):
     # Based on:
@@ -107,23 +145,20 @@ def tensor2vid(video: torch.Tensor, processor, output_type="np"):
 
 
 @dataclass
-class AnimateDiffControlNetPipelineOutput(BaseOutput):
+class AnimateDiffPipelineOutput(BaseOutput):
     frames: Union[torch.Tensor, np.ndarray]
 
 
-class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMixin, IPAdapterMixin, LoraLoaderMixin):
+class AnimateDiffPipeline(DiffusionPipeline, TextualInversionLoaderMixin, IPAdapterMixin, LoraLoaderMixin):
     r"""
     Pipeline for text-to-video generation.
-
     This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
     implemented for all pipelines (downloading, saving, running on a particular device, etc.).
-
     The pipeline also inherits the following loading methods:
         - [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings
         - [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights
         - [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights
         - [`~loaders.IPAdapterMixin.load_ip_adapter`] for loading IP Adapters
-
     Args:
         vae ([`AutoencoderKL`]):
             Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
@@ -140,9 +175,8 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
             [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
     """
 
-    model_cpu_offload_seq = "text_encoder->unet->vae"
-    _optional_components = ["feature_extractor", "image_encoder"]
-    _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
+    model_cpu_offload_seq = "text_encoder->image_encoder->unet->vae"
+    _optional_components = ["feature_extractor", "image_encoder","controlnet"]
 
     def __init__(
         self,
@@ -151,7 +185,6 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
         tokenizer: CLIPTokenizer,
         unet: UNet2DConditionModel,
         motion_adapter: MotionAdapter,
-        controlnet: Union[ControlNetModel, MultiControlNetModel],
         scheduler: Union[
             DDIMScheduler,
             PNDMScheduler,
@@ -160,12 +193,23 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
             EulerAncestralDiscreteScheduler,
             DPMSolverMultistepScheduler,
         ],
+        controlnet: Optional[Union[ControlNetModel, MultiControlNetModel]]=None,
         feature_extractor: Optional[CLIPImageProcessor] = None,
         image_encoder: Optional[CLIPVisionModelWithProjection] = None,
     ):
         super().__init__()
         unet = UNetMotionModel.from_unet2d(unet, motion_adapter)
-
+        if hasattr(self.pipe, "controlnet"):print("has controlnet")
+        if controlnet is None:
+            if hasattr(self, "controlnet"):delattr(self, "controlnet")
+            
+        # print all the attributes
+        print("Attributes:")
+        for attr in dir(self):
+            print(attr)
+        
+        print("contorlnet still exists:", hasattr(self, "controlnet"))
+        
         self.register_modules(
             vae=vae,
             text_encoder=text_encoder,
@@ -183,6 +227,9 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
             vae_scale_factor=self.vae_scale_factor, do_convert_rgb=True, do_normalize=False
         )
 
+    def load_motion_adapter(self,motion_adapter):
+        self.register_modules(motion_adapter=motion_adapter)
+    
     # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.encode_prompt with num_images_per_prompt -> num_videos_per_prompt
     def encode_prompt(
         self,
@@ -198,7 +245,6 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
     ):
         r"""
         Encodes the prompt into text encoder hidden states.
-
         Args:
             prompt (`str` or `List[str]`, *optional*):
                 prompt to be encoded
@@ -366,18 +412,29 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
         return prompt_embeds, negative_prompt_embeds
 
     # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.encode_image
-    def encode_image(self, image, device, num_images_per_prompt):
+    def encode_image(self, image, device, num_images_per_prompt, output_hidden_states=None):
         dtype = next(self.image_encoder.parameters()).dtype
 
         if not isinstance(image, torch.Tensor):
             image = self.feature_extractor(image, return_tensors="pt").pixel_values
 
         image = image.to(device=device, dtype=dtype)
-        image_embeds = self.image_encoder(image).image_embeds
-        image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0)
+        if output_hidden_states:
+            image_enc_hidden_states = self.image_encoder(image, output_hidden_states=True).hidden_states[-2]
+            image_enc_hidden_states = image_enc_hidden_states.repeat_interleave(num_images_per_prompt, dim=0)
+            uncond_image_enc_hidden_states = self.image_encoder(
+                torch.zeros_like(image), output_hidden_states=True
+            ).hidden_states[-2]
+            uncond_image_enc_hidden_states = uncond_image_enc_hidden_states.repeat_interleave(
+                num_images_per_prompt, dim=0
+            )
+            return image_enc_hidden_states, uncond_image_enc_hidden_states
+        else:
+            image_embeds = self.image_encoder(image).image_embeds
+            image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0)
+            uncond_image_embeds = torch.zeros_like(image_embeds)
 
-        uncond_image_embeds = torch.zeros_like(image_embeds)
-        return image_embeds, uncond_image_embeds
+            return image_embeds, uncond_image_embeds
 
     # Copied from diffusers.pipelines.text_to_video_synthesis/pipeline_text_to_video_synth.TextToVideoSDPipeline.decode_latents
     def decode_latents(self, latents):
@@ -439,12 +496,9 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
     # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_freeu
     def enable_freeu(self, s1: float, s2: float, b1: float, b2: float):
         r"""Enables the FreeU mechanism as in https://arxiv.org/abs/2309.11497.
-
         The suffixes after the scaling factors represent the stages where they are being applied.
-
         Please refer to the [official repository](https://github.com/ChenyangSi/FreeU) for combinations of the values
         that are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.
-
         Args:
             s1 (`float`):
                 Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
@@ -493,10 +547,6 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
         prompt_embeds=None,
         negative_prompt_embeds=None,
         callback_on_step_end_tensor_inputs=None,
-        image=None,
-        controlnet_conditioning_scale=1.0,
-        control_guidance_start=0.0,
-        control_guidance_end=1.0,
     ):
         if height % 8 != 0 or width % 8 != 0:
             raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
@@ -539,147 +589,323 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
                     f" {negative_prompt_embeds.shape}."
                 )
 
-        # `prompt` needs more sophisticated handling when there are multiple
-        # conditionings.
-        if isinstance(self.controlnet, MultiControlNetModel):
-            if isinstance(prompt, list):
-                logger.warning(
-                    f"You have {len(self.controlnet.nets)} ControlNets and you have passed {len(prompt)}"
-                    " prompts. The conditionings will be fixed across the prompts."
-                )
-
-        # Check `image`
-        is_compiled = hasattr(F, "scaled_dot_product_attention") and isinstance(
-            self.controlnet, torch._dynamo.eval_frame.OptimizedModule
+    # Copied from diffusers.pipelines.text_to_video_synthesis.pipeline_text_to_video_synth.TextToVideoSDPipeline.prepare_latents
+    def prepare_latents(self, batch_size, num_channels_latents, num_frames, height, width, dtype, device, generator, latents=None):
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_frames,
+            height // self.vae_scale_factor,
+            width // self.vae_scale_factor,
         )
-        if (
-            isinstance(self.controlnet, ControlNetModel)
-            or is_compiled
-            and isinstance(self.controlnet._orig_mod, ControlNetModel)
-        ):
-            if isinstance(image, list):
-                for image_ in image:
-                    self.check_image(image_, prompt, prompt_embeds)
-            else:
-                self.check_image(image, prompt, prompt_embeds)
-        elif (
-            isinstance(self.controlnet, MultiControlNetModel)
-            or is_compiled
-            and isinstance(self.controlnet._orig_mod, MultiControlNetModel)
-        ):
-            if not isinstance(image, list):
-                raise TypeError("For multiple controlnets: `image` must be type `list`")
-
-            # When `image` is a nested list:
-            # (e.g. [[canny_image_1, pose_image_1], [canny_image_2, pose_image_2]])
-            elif any(isinstance(i, list) for i in image):
-                raise ValueError("A single batch of multiple conditionings are supported at the moment.")
-            elif len(image) != len(self.controlnet.nets):
-                raise ValueError(
-                    f"For multiple controlnets: `image` must have the same length as the number of controlnets, but got {len(image)} images and {len(self.controlnet.nets)} ControlNets."
-                )
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
 
-            for control_ in image:
-                for image_ in control_:
-                    self.check_image(image_, prompt, prompt_embeds)
+        if latents is None:
+            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
         else:
-            assert False
+            latents = latents.to(device)
 
-        # Check `controlnet_conditioning_scale`
-        if (
-            isinstance(self.controlnet, ControlNetModel)
-            or is_compiled
-            and isinstance(self.controlnet._orig_mod, ControlNetModel)
-        ):
-            if not isinstance(controlnet_conditioning_scale, float):
-                raise TypeError("For single controlnet: `controlnet_conditioning_scale` must be type `float`.")
-        elif (
-            isinstance(self.controlnet, MultiControlNetModel)
-            or is_compiled
-            and isinstance(self.controlnet._orig_mod, MultiControlNetModel)
-        ):
-            if isinstance(controlnet_conditioning_scale, list):
-                if any(isinstance(i, list) for i in controlnet_conditioning_scale):
-                    raise ValueError("A single batch of multiple conditionings are supported at the moment.")
-            elif isinstance(controlnet_conditioning_scale, list) and len(controlnet_conditioning_scale) != len(
-                self.controlnet.nets
-            ):
-                raise ValueError(
-                    "For multiple controlnets: When `controlnet_conditioning_scale` is specified as `list`, it must have"
-                    " the same length as the number of controlnets"
-                )
+        # scale the initial noise by the standard deviation required by the scheduler
+        latents = latents * self.scheduler.init_noise_sigma
+        return latents
+    
+    def prepare_latents_same_start(self, batch_size, num_channels_latents, num_frames, height, width, dtype, device, generator, latents=None, context_size=16, overlap=4, strength=0.5):
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_frames,
+            height // self.vae_scale_factor,
+            width // self.vae_scale_factor,
+        )
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        if latents is None:
+            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
         else:
-            assert False
+            latents = latents.to(device)
+            
+        # make every (context_size-overlap) frames have the same noise
+        loop_size = context_size - overlap
+        loop_count = num_frames // loop_size
+        for i in range(loop_count):
+            # repeat the first frames noise for i*loop_size frame
+            # lerp the first frames noise
+            latents[:, :, i*loop_size:(i*loop_size)+overlap, :, :] = torch.lerp(latents[:, :, i*loop_size:(i*loop_size)+overlap, :, :], latents[:, :, 0:overlap, :, :], strength)
+            
+        # scale the initial noise by the standard deviation required by the scheduler
+        latents = latents * self.scheduler.init_noise_sigma
+        return latents
+
+    def prepare_latents_consistent(self, batch_size, num_channels_latents, num_frames, height, width, dtype, device, generator, latents=None,smooth_weight=0.5,smooth_steps=3):
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_frames,
+            height // self.vae_scale_factor,
+            width // self.vae_scale_factor,
+        )
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        if latents is None:
+            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
 
-        if not isinstance(control_guidance_start, (tuple, list)):
-            control_guidance_start = [control_guidance_start]
+            # blend each frame with the surrounding N frames making sure to wrap around at the end
+            for i in range(num_frames):
+                blended_latent = torch.zeros_like(latents[:, :, i])
+                for s in range(-smooth_steps, smooth_steps + 1):
+                    if s == 0:
+                        continue
+                    frame_index = (i + s) % num_frames
+                    weight = (smooth_steps - abs(s)) / smooth_steps
+                    blended_latent += latents[:, :, frame_index] * weight
+                latents[:, :, i] = blended_latent / (2 * smooth_steps)
+                
+            latents = torch.lerp(randn_tensor(shape, generator=generator, device=device, dtype=dtype),latents, smooth_weight)
+        else:
+            latents = latents.to(device)
 
-        if not isinstance(control_guidance_end, (tuple, list)):
-            control_guidance_end = [control_guidance_end]
+        # scale the initial noise by the standard deviation required by the scheduler
+        latents = latents * self.scheduler.init_noise_sigma
+        return latents
 
-        if len(control_guidance_start) != len(control_guidance_end):
+    def prepare_motion_latents(self, batch_size, num_channels_latents, num_frames, height, width, dtype, device, generator, 
+                        latents=None, x_velocity=0, y_velocity=0, scale_velocity=0):
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_frames,
+            height // self.vae_scale_factor,
+            width // self.vae_scale_factor,
+        )
+        if isinstance(generator, list) and len(generator) != batch_size:
             raise ValueError(
-                f"`control_guidance_start` has {len(control_guidance_start)} elements, but `control_guidance_end` has {len(control_guidance_end)} elements. Make sure to provide the same number of elements to each list."
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
             )
 
-        if isinstance(self.controlnet, MultiControlNetModel):
-            if len(control_guidance_start) != len(self.controlnet.nets):
-                raise ValueError(
-                    f"`control_guidance_start`: {control_guidance_start} has {len(control_guidance_start)} elements but there are {len(self.controlnet.nets)} controlnets available. Make sure to provide {len(self.controlnet.nets)}."
-                )
+        if latents is None:
+            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+        else:
+            latents = latents.to(device)
 
-        for start, end in zip(control_guidance_start, control_guidance_end):
-            if start >= end:
-                raise ValueError(
-                    f"control guidance start: {start} cannot be larger or equal to control guidance end: {end}."
+        # scale the initial noise by the standard deviation required by the scheduler
+        latents = latents * self.scheduler.init_noise_sigma
+        
+        for frame in range(num_frames):
+            x_offset = int(frame * x_velocity)  # Convert to int
+            y_offset = int(frame * y_velocity)  # Convert to int
+            scale_factor = 1 + frame * scale_velocity
+
+            # Apply offsets
+            latents[:, :, frame] = torch.roll(latents[:, :, frame], shifts=(x_offset,), dims=3)  # x direction
+            latents[:, :, frame] = torch.roll(latents[:, :, frame], shifts=(y_offset,), dims=2)  # y direction
+
+            # Apply scaling - This is a simple approach and might not be ideal for all applications
+            if scale_factor != 1:
+                scaled_size = (
+                    int(latents.shape[3] * scale_factor),
+                    int(latents.shape[4] * scale_factor)
                 )
-            if start < 0.0:
-                raise ValueError(f"control guidance start: {start} can't be smaller than 0.")
-            if end > 1.0:
-                raise ValueError(f"control guidance end: {end} can't be larger than 1.0.")
-
-    # Copied from diffusers.pipelines.controlnet.pipeline_controlnet.StableDiffusionControlNetPipeline.check_image
-    def check_image(self, image, prompt, prompt_embeds):
-        image_is_pil = isinstance(image, Image.Image)
-        image_is_tensor = isinstance(image, torch.Tensor)
-        image_is_np = isinstance(image, np.ndarray)
-        image_is_pil_list = isinstance(image, list) and isinstance(image[0], Image.Image)
-        image_is_tensor_list = isinstance(image, list) and isinstance(image[0], torch.Tensor)
-        image_is_np_list = isinstance(image, list) and isinstance(image[0], np.ndarray)
-
-        if (
-            not image_is_pil
-            and not image_is_tensor
-            and not image_is_np
-            and not image_is_pil_list
-            and not image_is_tensor_list
-            and not image_is_np_list
-        ):
-            raise TypeError(
-                f"image must be passed and be one of PIL image, numpy array, torch tensor, list of PIL images, list of numpy arrays or list of torch tensors, but is {type(image)}"
+                latents[:, :, frame] = torch.nn.functional.interpolate(
+                    latents[:, :, frame].unsqueeze(0), size=scaled_size, mode='bilinear', align_corners=False
+                ).squeeze(0)
+
+        return latents
+
+    def generate_correlated_noise(self, latents, init_noise_correlation):
+        cloned_latents = latents.clone()
+        p = init_noise_correlation
+        flattened_latents = torch.flatten(cloned_latents)
+        noise = torch.randn_like(flattened_latents)
+        correlated_noise = flattened_latents * p + math.sqrt(1 - p**2) * noise
+
+        return correlated_noise.reshape(cloned_latents.shape)
+
+    def generate_correlated_latents(self, latents, init_noise_correlation):
+        cloned_latents = latents.clone()
+        for i in range(1, cloned_latents.shape[2]):
+            p = init_noise_correlation
+            flattened_latents = torch.flatten(cloned_latents[:, :, i])
+            prev_flattened_latents = torch.flatten(cloned_latents[:, :, i - 1])
+            correlated_latents = (prev_flattened_latents * p/math.sqrt((1+p**2))+flattened_latents * math.sqrt(1/(1 + p**2)))
+            cloned_latents[:, :, i] = correlated_latents.reshape(cloned_latents[:, :, i].shape)
+
+        return cloned_latents
+
+    def generate_correlated_latents_legacy(self, latents, init_noise_correlation):
+        cloned_latents = latents.clone()
+        for i in range(1, cloned_latents.shape[2]):
+            p = init_noise_correlation
+            flattened_latents = torch.flatten(cloned_latents[:, :, i])
+            prev_flattened_latents = torch.flatten(cloned_latents[:, :, i - 1])
+            correlated_latents = (
+                prev_flattened_latents * p
+                + 
+                flattened_latents * math.sqrt(1 - p**2)
+            )
+            cloned_latents[:, :, i] = correlated_latents.reshape(
+                cloned_latents[:, :, i].shape
             )
 
-        if image_is_pil:
-            image_batch_size = 1
-        else:
-            image_batch_size = len(image)
+        return cloned_latents
+
+    def generate_mixed_noise(self, noise, init_noise_correlation):
+        shared_noise = torch.randn_like(noise[0, :, 0])
+        for b in range(noise.shape[0]):
+            for f in range(noise.shape[2]):
+                p = init_noise_correlation
+                flattened_latents = torch.flatten(noise[b, :, f])
+                shared_latents = torch.flatten(shared_noise)
+                correlated_latents = (
+                    shared_latents * math.sqrt(p**2/(1+p**2)) + 
+                    flattened_latents * math.sqrt(1/(1+p**2))
+                )
+                noise[b, :, f] = correlated_latents.reshape(noise[b, :, f].shape)
 
-        if prompt is not None and isinstance(prompt, str):
-            prompt_batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            prompt_batch_size = len(prompt)
-        elif prompt_embeds is not None:
-            prompt_batch_size = prompt_embeds.shape[0]
+        return noise
+
+    def prepare_correlated_latents(
+        self,
+        init_image,
+        init_image_strength,
+        init_noise_correlation,
+        batch_size,
+        num_channels_latents,
+        video_length,
+        height,
+        width,
+        dtype,
+        device,
+        generator,
+        latents=None,
+    ):
+        shape = (
+            batch_size,
+            num_channels_latents,
+            video_length,
+            height // self.vae_scale_factor,
+            width // self.vae_scale_factor,
+        )
+
+        if init_image is not None:
+            start_image = ((torchvision.transforms.functional.pil_to_tensor(init_image))/ 255 )[:3, :, :].to("cuda").to(dtype).unsqueeze(0)
+            start_image = (
+                self.vae.encode(start_image.mul(2).sub(1))
+                .latent_dist.sample()
+                .view(1, 4, height // 8, width // 8)
+                * 0.18215
+            )
+            init_latents = start_image.unsqueeze(2).repeat(1, 1, video_length, 1, 1)
+        else:
+            init_latents = None
 
-        if image_batch_size != 1 and image_batch_size != prompt_batch_size:
+        if isinstance(generator, list) and len(generator) != batch_size:
             raise ValueError(
-                f"If image batch size is not 1, image batch size must be same as prompt batch size. image batch size: {image_batch_size}, prompt batch size: {prompt_batch_size}"
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
             )
+        if latents is None:
+            rand_device = "cpu" if device.type == "mps" else device
+            if isinstance(generator, list):
+                shape = shape
+                # shape = (1,) + shape[1:]
+                # ignore init latents for batch model
+                latents = [torch.randn(shape, generator=generator[i], device=rand_device, dtype=dtype)for i in range(batch_size)]
+                latents = torch.cat(latents, dim=0).to(device)
+            else:
+                if init_latents is not None:
+                    offset = int(
+                        init_image_strength * (len(self.scheduler.timesteps) - 1)
+                    )
+                    noise = torch.randn_like(init_latents)
+                    noise = self.generate_correlated_latents(noise, init_noise_correlation)
+
+                    # Eric - some black magic here
+                    # We should be only adding the noise at timestep[offset], but I noticed that
+                    # we get more motion and cooler motion if we add the noise at timestep[offset - 1]
+                    # or offset - 2. However, this breaks the fewer timesteps there are, so let's interpolate
+                    timesteps = self.scheduler.timesteps
+                    average_timestep = None
+                    if offset == 0:
+                        average_timestep = timesteps[0]
+                    elif offset == 1:
+                        average_timestep = (
+                            timesteps[offset - 1] * (1 - init_image_strength)
+                            + timesteps[offset] * init_image_strength
+                        )
+                    else:
+                        average_timestep = timesteps[offset - 1]
+
+                    latents = self.scheduler.add_noise(
+                        init_latents, noise, average_timestep.long()
+                    )
+
+                    latents = self.scheduler.add_noise(
+                        latents, torch.randn_like(init_latents), timesteps[-2]
+                    )
+                else:
+                    latents = torch.randn(
+                        shape, generator=generator, device=rand_device, dtype=dtype
+                    ).to(device)
+                    latents = self.generate_correlated_latents(
+                        latents, init_noise_correlation
+                    )
+        else:
+            if latents.shape != shape:
+                raise ValueError(
+                    f"Unexpected latents shape, got {latents.shape}, expected {shape}"
+                )
+            latents = latents.to(device)
 
-    # Copied from diffusers.pipelines.text_to_video_synthesis.pipeline_text_to_video_synth.TextToVideoSDPipeline.prepare_latents
-    def prepare_latents(
-        self, batch_size, num_channels_latents, num_frames, height, width, dtype, device, generator, latents=None
+        # scale the initial noise by the standard deviation required by the scheduler
+        if init_latents is None:
+            latents = latents * self.scheduler.init_noise_sigma
+        # elif self.unet.trained_initial_frames and init_latents is not None:
+        #     # we only want to use this as the first frame
+        #     init_latents[:, :, 1:] = torch.zeros_like(init_latents[:, :, 1:])
+            
+        latents = latents.to(device)
+        return latents, init_latents        
+        
+    def prepare_video_latents(
+        self,
+        video,
+        height,
+        width,
+        num_channels_latents,
+        batch_size,
+        timestep,
+        dtype,
+        device,
+        generator,
+        latents=None,
     ):
+        # video must be a list of list of images
+        # the outer list denotes having multiple videos as input, whereas inner list means the frames of the video
+        # as a list of images
+        if not isinstance(video[0], list):
+            video = [video]
+        if latents is None:
+            video = torch.cat(
+                [self.image_processor.preprocess(vid, height=height, width=width).unsqueeze(0) for vid in video], dim=0
+            )
+            video = video.to(device=device, dtype=dtype)
+            num_frames = video.shape[1]
+        else:
+            num_frames = latents.shape[2]
+
         shape = (
             batch_size,
             num_channels_latents,
@@ -687,6 +913,7 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
             height // self.vae_scale_factor,
             width // self.vae_scale_factor,
         )
+
         if isinstance(generator, list) and len(generator) != batch_size:
             raise ValueError(
                 f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
@@ -694,16 +921,63 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
             )
 
         if latents is None:
-            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        else:
-            latents = latents.to(device)
+            # make sure the VAE is in float32 mode, as it overflows in float16
+            if self.vae.config.force_upcast:
+                video = video.float()
+                self.vae.to(dtype=torch.float32)
+
+            if isinstance(generator, list):
+                if len(generator) != batch_size:
+                    raise ValueError(
+                        f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                        f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+                    )
+
+                init_latents = [
+                    retrieve_latents(self.vae.encode(video[i]), generator=generator[i]).unsqueeze(0)
+                    for i in range(batch_size)
+                ]
+            else:
+                init_latents = [
+                    retrieve_latents(self.vae.encode(vid), generator=generator).unsqueeze(0) for vid in video
+                ]
 
-        # scale the initial noise by the standard deviation required by the scheduler
-        latents = latents * self.scheduler.init_noise_sigma
-        return latents
+            init_latents = torch.cat(init_latents, dim=0)
+
+            # restore vae to original dtype
+            if self.vae.config.force_upcast:
+                self.vae.to(dtype)
+
+            init_latents = init_latents.to(dtype)
+            init_latents = self.vae.config.scaling_factor * init_latents
 
+            if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
+                # expand init_latents for batch_size
+                error_message = (
+                    f"You have passed {batch_size} text prompts (`prompt`), but only {init_latents.shape[0]} initial"
+                    " images (`image`). Please make sure to update your script to pass as many initial images as text prompts"
+                )
+                raise ValueError(error_message)
+            elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
+                raise ValueError(
+                    f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
+                )
+            else:
+                init_latents = torch.cat([init_latents], dim=0)
+
+            noise = randn_tensor(init_latents.shape, generator=generator, device=device, dtype=dtype)
+            latents = self.scheduler.add_noise(init_latents, noise, timestep).permute(0, 2, 1, 3, 4)
+        else:
+            if shape != latents.shape:
+                # [B, C, F, H, W]
+                raise ValueError(f"`latents` expected to have {shape=}, but found {latents.shape=}")
+            latents = latents.to(device, dtype=dtype)
+
+        return latents 
+        
+        
     # Copied from diffusers.pipelines.controlnet.pipeline_controlnet.StableDiffusionControlNetPipeline.prepare_image
-    def prepare_image(
+    def prepare_control_frames(
         self,
         image,
         width,
@@ -716,51 +990,32 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
         guess_mode=False,
     ):
         image = self.control_image_processor.preprocess(image, height=height, width=width).to(dtype=torch.float32)
-        image_batch_size = image.shape[0]
+        # image_batch_size = image.shape[0]
+        image_batch_size = len(image)
 
-        if image_batch_size == 1:
-            repeat_by = batch_size
-        else:
-            # image batch size is the same as prompt batch size
-            repeat_by = num_images_per_prompt
+        # if image_batch_size == 1:
+        #     repeat_by = batch_size
+        # else:
+        #     # image batch size is the same as prompt batch size
+        #     repeat_by = num_images_per_prompt
 
-        image = image.repeat_interleave(repeat_by, dim=0)
+        # image = image.repeat_interleave(repeat_by, dim=0)
 
         image = image.to(device=device, dtype=dtype)
 
-        if do_classifier_free_guidance and not guess_mode:
-            image = torch.cat([image] * 2)
+        # if do_classifier_free_guidance and not guess_mode:
+        #     image = torch.cat([image] * 2)
 
         return image
-
-    @property
-    def guidance_scale(self):
-        return self._guidance_scale
-
-    @property
-    def clip_skip(self):
-        return self._clip_skip
-
-    # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-    # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-    # corresponds to doing no classifier free guidance.
-    @property
-    def do_classifier_free_guidance(self):
-        return self._guidance_scale > 1
-
-    @property
-    def cross_attention_kwargs(self):
-        return self._cross_attention_kwargs
-
-    @property
-    def num_timesteps(self):
-        return self._num_timesteps
-
+        
     @torch.no_grad()
     def __call__(
         self,
         prompt: Union[str, List[str]] = None,
         num_frames: Optional[int] = 16,
+        context_size=16,
+        overlap=2,
+        step=1,
         height: Optional[int] = None,
         width: Optional[int] = None,
         num_inference_steps: int = 50,
@@ -773,22 +1028,31 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
         prompt_embeds: Optional[torch.FloatTensor] = None,
         negative_prompt_embeds: Optional[torch.FloatTensor] = None,
         ip_adapter_image: Optional[PipelineImageInput] = None,
-        conditioning_frames: Optional[List[PipelineImageInput]] = None,
         output_type: Optional[str] = "pil",
+        output_path: Optional[str] = None,
         return_dict: bool = True,
+        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
+        callback_steps: Optional[int] = 1,
         cross_attention_kwargs: Optional[Dict[str, Any]] = None,
+        clip_skip: Optional[int] = None,
+        x_velocity: Optional[float] = 0,
+        y_velocity: Optional[float] = 0,
+        scale_velocity: Optional[float] = 0,
+        init_image: Optional[PipelineImageInput] = None,
+        init_image_strength: Optional[float] = 1.0,
+        init_noise_correlation: Optional[float] = 0.0,
+        latent_mode: Optional[str] = "normal",
+        smooth_weight: Optional[float] = 0.5,
+        smooth_steps: Optional[int] = 3,
+        initial_context_scale: Optional[float] = 1.0,
+        conditioning_frames: Optional[List[PipelineImageInput]] = None,
         controlnet_conditioning_scale: Union[float, List[float]] = 1.0,
-        guess_mode: bool = False,
         control_guidance_start: Union[float, List[float]] = 0.0,
         control_guidance_end: Union[float, List[float]] = 1.0,
-        clip_skip: Optional[int] = None,
-        callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
-        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
-        **kwargs,
+        guess_mode: bool = False,
     ):
         r"""
         The call function to the pipeline for generation.
-
         Args:
             prompt (`str` or `List[str]`, *optional*):
                 The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`.
@@ -825,83 +1089,49 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
             negative_prompt_embeds (`torch.FloatTensor`, *optional*):
                 Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
                 not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
-            ip_adapter_image (`PipelineImageInput`, *optional*):
-                Optional image input to work with IP Adapters.
-            conditioning_frames (`List[PipelineImageInput]`, *optional*):
-                The ControlNet input condition to provide guidance to the `unet` for generation. If multiple ControlNets
-                are specified, images must be passed as a list such that each element of the list can be correctly
-                batched for input to a single ControlNet.
+            ip_adapter_image: (`PipelineImageInput`, *optional*): Optional image input to work with IP Adapters.
             output_type (`str`, *optional*, defaults to `"pil"`):
                 The output format of the generated video. Choose between `torch.FloatTensor`, `PIL.Image` or
                 `np.array`.
             return_dict (`bool`, *optional*, defaults to `True`):
                 Whether or not to return a [`~pipelines.text_to_video_synthesis.TextToVideoSDPipelineOutput`] instead
                 of a plain tuple.
+            callback (`Callable`, *optional*):
+                A function that calls every `callback_steps` steps during inference. The function is called with the
+                following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
+            callback_steps (`int`, *optional*, defaults to 1):
+                The frequency at which the `callback` function is called. If not specified, the callback is called at
+                every step.
             cross_attention_kwargs (`dict`, *optional*):
                 A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in
                 [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
-            controlnet_conditioning_scale (`float` or `List[float]`, *optional*, defaults to 1.0):
-                The outputs of the ControlNet are multiplied by `controlnet_conditioning_scale` before they are added
-                to the residual in the original `unet`. If multiple ControlNets are specified in `init`, you can set
-                the corresponding scale as a list.
-            guess_mode (`bool`, *optional*, defaults to `False`):
-                The ControlNet encoder tries to recognize the content of the input image even if you remove all
-                prompts. A `guidance_scale` value between 3.0 and 5.0 is recommended.
-            control_guidance_start (`float` or `List[float]`, *optional*, defaults to 0.0):
-                The percentage of total steps at which the ControlNet starts applying.
-            control_guidance_end (`float` or `List[float]`, *optional*, defaults to 1.0):
-                The percentage of total steps at which the ControlNet stops applying.
             clip_skip (`int`, *optional*):
                 Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
                 the output of the pre-final layer will be used for computing the prompt embeddings.
-            allback_on_step_end (`Callable`, *optional*):
-                A function that calls at the end of each denoising steps during the inference. The function is called
-                with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int,
-                callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by
-                `callback_on_step_end_tensor_inputs`.
-            callback_on_step_end_tensor_inputs (`List`, *optional*):
-                The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list
-                will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the
-                `._callback_tensor_inputs` attribute of your pipeine class.
-
         Examples:
-
         Returns:
             [`~pipelines.text_to_video_synthesis.TextToVideoSDPipelineOutput`] or `tuple`:
                 If `return_dict` is `True`, [`~pipelines.text_to_video_synthesis.TextToVideoSDPipelineOutput`] is
                 returned, otherwise a `tuple` is returned where the first element is a list with the generated frames.
         """
-
-        callback = kwargs.pop("callback", None)
-        callback_steps = kwargs.pop("callback_steps", None)
-
-        if callback is not None:
-            deprecate(
-                "callback",
-                "1.0.0",
-                "Passing `callback` as an input argument to `__call__` is deprecated, consider using `callback_on_step_end`",
-            )
-        if callback_steps is not None:
-            deprecate(
-                "callback_steps",
-                "1.0.0",
-                "Passing `callback_steps` as an input argument to `__call__` is deprecated, consider using `callback_on_step_end`",
-            )
-
-        controlnet = self.controlnet._orig_mod if is_compiled_module(self.controlnet) else self.controlnet
-
-        # align format for control guidance
-        if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):
-            control_guidance_start = len(control_guidance_end) * [control_guidance_start]
-        elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):
-            control_guidance_end = len(control_guidance_start) * [control_guidance_end]
-        elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):
-            mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1
-            control_guidance_start, control_guidance_end = (
-                mult * [control_guidance_start],
-                mult * [control_guidance_end],
-            )
-
+        
+        if self.controlnet != None:
+            controlnet = self.controlnet._orig_mod if is_compiled_module(self.controlnet) else self.controlnet
+
+            # align format for control guidance
+            control_end = control_guidance_end
+            if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):
+                control_guidance_start = len(control_guidance_end) * [control_guidance_start]
+            elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):
+                control_guidance_end = len(control_guidance_start) * [control_guidance_end]
+            elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):
+                mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1
+                control_guidance_start, control_guidance_end = (
+                    mult * [control_guidance_start],
+                    mult * [control_guidance_end],
+                )
+            
+            
         # 0. Default height and width to unet
         height = height or self.unet.config.sample_size * self.vae_scale_factor
         width = width or self.unet.config.sample_size * self.vae_scale_factor
@@ -910,24 +1140,9 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
 
         # 1. Check inputs. Raise error if not correct
         self.check_inputs(
-            prompt=prompt,
-            height=height,
-            width=width,
-            callback_steps=callback_steps,
-            negative_prompt=negative_prompt,
-            callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            image=conditioning_frames,
-            controlnet_conditioning_scale=controlnet_conditioning_scale,
-            control_guidance_start=control_guidance_start,
-            control_guidance_end=control_guidance_end,
+            prompt, height, width, callback_steps, negative_prompt, prompt_embeds, negative_prompt_embeds
         )
 
-        self._guidance_scale = guidance_scale
-        self._clip_skip = clip_skip
-        self._cross_attention_kwargs = cross_attention_kwargs
-
         # 2. Define call parameters
         if prompt is not None and isinstance(prompt, str):
             batch_size = 1
@@ -937,16 +1152,23 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
             batch_size = prompt_embeds.shape[0]
 
         device = self._execution_device
-
-        if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float):
-            controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets)
-
-        global_pool_conditions = (
-            controlnet.config.global_pool_conditions
-            if isinstance(controlnet, ControlNetModel)
-            else controlnet.nets[0].config.global_pool_conditions
-        )
-        guess_mode = guess_mode or global_pool_conditions
+        
+        if self.controlnet != None:
+            if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float):
+                controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets)
+
+            global_pool_conditions = (
+                controlnet.config.global_pool_conditions
+                if isinstance(controlnet, ControlNetModel)
+                else controlnet.nets[0].config.global_pool_conditions
+            )
+            guess_mode = guess_mode or global_pool_conditions
+            
+            
+        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
+        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
+        # corresponds to doing no classifier free guidance.
+        do_classifier_free_guidance = guidance_scale > 1.0
 
         # 3. Encode input prompt
         text_encoder_lora_scale = (
@@ -956,180 +1178,382 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
             prompt,
             device,
             num_videos_per_prompt,
-            self.do_classifier_free_guidance,
+            do_classifier_free_guidance,
             negative_prompt,
             prompt_embeds=prompt_embeds,
             negative_prompt_embeds=negative_prompt_embeds,
             lora_scale=text_encoder_lora_scale,
-            clip_skip=self.clip_skip,
+            clip_skip=clip_skip,
         )
         # For classifier free guidance, we need to do two forward passes.
         # Here we concatenate the unconditional and text embeddings into a single batch
         # to avoid doing two forward passes
-        if self.do_classifier_free_guidance:
+        if do_classifier_free_guidance:
             prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
 
         if ip_adapter_image is not None:
-            image_embeds, negative_image_embeds = self.encode_image(ip_adapter_image, device, num_videos_per_prompt)
-            if self.do_classifier_free_guidance:
+            output_hidden_state = False if isinstance(self.unet.encoder_hid_proj, ImageProjection) else True
+            image_embeds, negative_image_embeds = self.encode_image(
+                ip_adapter_image, device, num_videos_per_prompt, output_hidden_state
+            )
+            if do_classifier_free_guidance:
                 image_embeds = torch.cat([negative_image_embeds, image_embeds])
 
-        if isinstance(controlnet, ControlNetModel):
-            conditioning_frames = self.prepare_image(
-                image=conditioning_frames,
-                width=width,
-                height=height,
-                batch_size=batch_size * num_videos_per_prompt * num_frames,
-                num_images_per_prompt=num_videos_per_prompt,
-                device=device,
-                dtype=controlnet.dtype,
-                do_classifier_free_guidance=self.do_classifier_free_guidance,
-                guess_mode=guess_mode,
-            )
-        elif isinstance(controlnet, MultiControlNetModel):
-            cond_prepared_frames = []
-            for frame_ in conditioning_frames:
-                prepared_frame = self.prepare_image(
-                    image=frame_,
+        if self.controlnet != None:
+            if isinstance(controlnet, ControlNetModel):
+                # conditioning_frames = self.prepare_image(
+                #     image=conditioning_frames,
+                #     width=width,
+                #     height=height,
+                #     batch_size=batch_size * num_videos_per_prompt * num_frames,
+                #     num_images_per_prompt=num_videos_per_prompt,
+                #     device=device,
+                #     dtype=controlnet.dtype,
+                #     do_classifier_free_guidance=self.do_classifier_free_guidance,
+                #     guess_mode=guess_mode,
+                # )
+                conditioning_frames = self.prepare_control_frames(
+                    image=conditioning_frames,
                     width=width,
                     height=height,
                     batch_size=batch_size * num_videos_per_prompt * num_frames,
                     num_images_per_prompt=num_videos_per_prompt,
                     device=device,
                     dtype=controlnet.dtype,
-                    do_classifier_free_guidance=self.do_classifier_free_guidance,
+                    do_classifier_free_guidance=do_classifier_free_guidance,
                     guess_mode=guess_mode,
                 )
-
-                cond_prepared_frames.append(prepared_frame)
-
-            conditioning_frames = cond_prepared_frames
-        else:
-            assert False
+                                    
+            elif isinstance(controlnet, MultiControlNetModel):
+                cond_prepared_frames = []
+                for frame_ in conditioning_frames:
+                    # prepared_frame = self.prepare_image(
+                    #     image=frame_,
+                    #     width=width,
+                    #     height=height,
+                    #     batch_size=batch_size * num_videos_per_prompt * num_frames,
+                    #     num_images_per_prompt=num_videos_per_prompt,
+                    #     device=device,
+                    #     dtype=controlnet.dtype,
+                    #     do_classifier_free_guidance=self.do_classifier_free_guidance,
+                    #     guess_mode=guess_mode,
+                    # )
+        
+                    prepared_frame = self.prepare_control_frames(
+                        image=frame_,
+                        width=width,
+                        height=height,
+                        batch_size=batch_size * num_videos_per_prompt * num_frames,
+                        num_images_per_prompt=num_videos_per_prompt,
+                        device=device,
+                        dtype=controlnet.dtype,
+                        do_classifier_free_guidance=do_classifier_free_guidance,
+                        guess_mode=guess_mode,
+                    )
+                    
+                    cond_prepared_frames.append(prepared_frame)
+
+                conditioning_frames = cond_prepared_frames
+            else:
+                assert False
 
         # 4. Prepare timesteps
         self.scheduler.set_timesteps(num_inference_steps, device=device)
         timesteps = self.scheduler.timesteps
-        self._num_timesteps = len(timesteps)
+        
 
+        # round num frames to the nearest multiple of context size - overlap
+        num_frames = (num_frames // (context_size - overlap)) * (context_size - overlap)
+        
         # 5. Prepare latent variables
         num_channels_latents = self.unet.config.in_channels
-        latents = self.prepare_latents(
-            batch_size * num_videos_per_prompt,
-            num_channels_latents,
-            num_frames,
-            height,
-            width,
-            prompt_embeds.dtype,
-            device,
-            generator,
-            latents,
-        )
+        if(latent_mode == "normal"):
+            latents = self.prepare_latents(
+                batch_size * num_videos_per_prompt,
+                num_channels_latents,
+                num_frames,
+                height,
+                width,
+                prompt_embeds.dtype,
+                device,
+                generator,
+                latents,
+            )
+        if(latent_mode == "same_start"):
+            latents = self.prepare_latents_same_start(
+                batch_size * num_videos_per_prompt,
+                num_channels_latents,
+                num_frames,
+                height,
+                width,
+                prompt_embeds.dtype,
+                device,
+                generator,
+                latents,
+                context_size=context_size,
+                overlap=overlap,
+                strength=init_image_strength,
+            )
+        elif(latent_mode == "motion"):
+            latents = self.prepare_motion_latents(
+                batch_size * num_videos_per_prompt,
+                num_channels_latents,
+                num_frames,
+                height,
+                width,
+                prompt_embeds.dtype,
+                device,
+                generator,
+                latents,
+                x_velocity=x_velocity,
+                y_velocity=y_velocity,
+                scale_velocity=scale_velocity,
+            )
+        elif(latent_mode == "correlated"):        
+            latents, init_latents = self.prepare_correlated_latents(
+                init_image,
+                init_image_strength,
+                init_noise_correlation,
+                batch_size,
+                num_channels_latents,
+                num_frames,
+                height,
+                width,
+                prompt_embeds.dtype,
+                device,
+                generator,
+            )
+        elif(latent_mode == "consistent"):
+            latents = self.prepare_latents_consistent(
+                batch_size * num_videos_per_prompt,
+                num_channels_latents,
+                num_frames,
+                height,
+                width,
+                prompt_embeds.dtype,
+                device,
+                generator,
+                latents,
+                smooth_weight,
+                smooth_steps,
+            )
+        elif(latent_mode == "video"):
+            # 4. Prepare timesteps
+            # timesteps, num_inference_steps = retrieve_timesteps(self.scheduler, num_inference_steps, device, timesteps)
+            # timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, init_image_strength, device)
+            latent_timestep = timesteps[:1].repeat(batch_size * num_videos_per_prompt)
+            self._num_timesteps = len(timesteps)
+            num_channels_latents = self.unet.config.in_channels
+            latents = self.prepare_video_latents(
+                video=init_image,
+                height=height,
+                width=width,
+                num_channels_latents=num_channels_latents,
+                batch_size=batch_size * num_videos_per_prompt,
+                timestep=latent_timestep,
+                dtype=prompt_embeds.dtype,
+                device=device,
+                generator=generator,
+                latents=latents,
+            )
+
 
         # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
         extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
-        # 7. Add image embeds for IP-Adapter
+        
+        # 7 Add image embeds for IP-Adapter
         added_cond_kwargs = {"image_embeds": image_embeds} if ip_adapter_image is not None else None
-
+        
         # 7.1 Create tensor stating which controlnets to keep
-        controlnet_keep = []
-        for i in range(len(timesteps)):
-            keeps = [
-                1.0 - float(i / len(timesteps) < s or (i + 1) / len(timesteps) > e)
-                for s, e in zip(control_guidance_start, control_guidance_end)
-            ]
-            controlnet_keep.append(keeps[0] if isinstance(controlnet, ControlNetModel) else keeps)
-
-        print("############ START ANIMATEDIFF CONTZROLNET PIPELINE #############")
+        if self.controlnet != None:
+            controlnet_keep = []
+            for i in range(len(timesteps)):
+                keeps = [
+                    1.0 - float(i / len(timesteps) < s or (i + 1) / len(timesteps) > e)
+                    for s, e in zip(control_guidance_start, control_guidance_end)
+                ]
+                controlnet_keep.append(keeps[0] if isinstance(controlnet, ControlNetModel) else keeps)
+
+        # divide the initial latents into context groups
+        
+        def context_scheduler(context_size, overlap, offset, total_frames, total_timesteps):
+            # Calculate the number of context groups based on frame count and context size
+            number_of_context_groups = (total_frames // (context_size - overlap))
+            # Initialize a list to store context indexes for all timesteps
+            all_context_indexes = []
+            # Iterate over each timestep
+            for timestep in range(total_timesteps):
+                # Initialize a list to store groups of context indexes for this timestep
+                timestep_context_groups = []
+                # Iterate over each context group
+                for group_index in range(number_of_context_groups):
+                    # Initialize a list to store context indexes for this group
+                    context_group_indexes = []
+                    # Iterate over each index in the context group
+                    local_context_size = context_size
+                    if timestep <= 1:
+                        local_context_size = int(context_size * initial_context_scale)
+                    for index in range(local_context_size):
+                        # if its the first timestep, spread the indexes out evenly over the full frame range, offset by the group index
+                        frame_index = (group_index * (local_context_size - overlap)) + (offset * timestep) + index
+                        # If frame index exceeds total frames, wrap around
+                        if frame_index >= total_frames:
+                            frame_index %= total_frames
+                        # Add the frame index to the group's list
+                        context_group_indexes.append(frame_index)
+                    # Add the group's indexes to the timestep's list
+                    timestep_context_groups.append(context_group_indexes)
+                # Add the timestep's context groups to the overall list
+                all_context_indexes.append(timestep_context_groups)
+            return all_context_indexes
+                
+        context_indexes = context_scheduler(context_size, overlap, step, num_frames, len(timesteps))
+        
         # Denoising loop
         num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
+        with self.progress_bar(total=len(timesteps)) as progress_bar:
             for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = torch.cat([latents] * 2) if self.do_classifier_free_guidance else latents
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
-                if guess_mode and self.do_classifier_free_guidance:
-                    # Infer ControlNet only for the conditional batch.
-                    control_model_input = latents
-                    control_model_input = self.scheduler.scale_model_input(control_model_input, t)
-                    controlnet_prompt_embeds = prompt_embeds.chunk(2)[1]
-                else:
-                    control_model_input = latent_model_input
-                    controlnet_prompt_embeds = prompt_embeds
-                controlnet_prompt_embeds = controlnet_prompt_embeds.repeat_interleave(num_frames, dim=0)
-
-                if isinstance(controlnet_keep[i], list):
-                    cond_scale = [c * s for c, s in zip(controlnet_conditioning_scale, controlnet_keep[i])]
-                else:
-                    controlnet_cond_scale = controlnet_conditioning_scale
-                    if isinstance(controlnet_cond_scale, list):
-                        controlnet_cond_scale = controlnet_cond_scale[0]
-                    cond_scale = controlnet_cond_scale * controlnet_keep[i]
-
-                print("-----------------------")
-                print("control_model_input.shape", control_model_input.shape)
+                noise_pred_uncond_sum = torch.zeros_like(latents).to(device).to(dtype=torch.float16)
+                noise_pred_text_sum = torch.zeros_like(latents).to(device).to(dtype=torch.float16)
+                latent_counter = torch.zeros(num_frames).to(device).to(dtype=torch.float16)
+        
+                # foreach context group seperately denoise the current timestep
+                for context_group in range(len(context_indexes[i])):
+                    # calculate to current indexes, considering overlapa
+                    current_context_indexes = context_indexes[i][context_group]
+
+                    # select the relevent context from the latents
+                    current_context_latents = latents[:, :, current_context_indexes, :, :]
+                    
+                    # expand the latents if we are doing classifier free guidance
+                    latent_model_input = torch.cat([current_context_latents] * 2) if do_classifier_free_guidance else current_context_latents
+                    latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
+
+                    if self.controlnet != None and i < int(control_end*num_inference_steps):
+                        
+                        torch.cuda.synchronize()  # Synchronize GPU
+                        control_start = time.time()
+                
+                        current_context_conditioning_frames = conditioning_frames[current_context_indexes, :, :, :] 
+                        current_context_conditioning_frames = torch.cat([current_context_conditioning_frames] * 2) if do_classifier_free_guidance else current_context_conditioning_frames
+
+                    
+                        if guess_mode and self.do_classifier_free_guidance:
+                            # Infer ControlNet only for the conditional batch.
+                            control_model_input = latents
+                            control_model_input = self.scheduler.scale_model_input(control_model_input, t)
+                            controlnet_prompt_embeds = prompt_embeds.chunk(2)[1]
+                        else:
+                            control_model_input = latent_model_input
+                            controlnet_prompt_embeds = prompt_embeds
+                        controlnet_prompt_embeds = controlnet_prompt_embeds.repeat_interleave(len(current_context_indexes), dim=0)
+
+                        if isinstance(controlnet_keep[i], list):
+                            cond_scale = [c * s for c, s in zip(controlnet_conditioning_scale, controlnet_keep[i])]
+                        else:
+                            controlnet_cond_scale = controlnet_conditioning_scale
+                            if isinstance(controlnet_cond_scale, list):
+                                controlnet_cond_scale = controlnet_cond_scale[0]
+                            cond_scale = controlnet_cond_scale * controlnet_keep[i]
+                            
+                                           
+                        control_model_input = torch.transpose(control_model_input, 1, 2)
+                        control_model_input = control_model_input.reshape(
+                            (-1, control_model_input.shape[2], control_model_input.shape[3], control_model_input.shape[4])
+                        )
+
+    
+                        down_block_res_samples, mid_block_res_sample = self.controlnet(
+                            control_model_input,
+                            t,
+                            encoder_hidden_states=controlnet_prompt_embeds,
+                            controlnet_cond=current_context_conditioning_frames,
+                            conditioning_scale=cond_scale,
+                            guess_mode=guess_mode,
+                            return_dict=False,
+                        )
+                        
+                        unet_start = time.time()
+                        # predict the noise residual with the added controlnet residuals
+                        noise_pred = self.unet(
+                            latent_model_input,
+                            t,
+                            encoder_hidden_states=prompt_embeds,
+                            cross_attention_kwargs=cross_attention_kwargs,
+                            added_cond_kwargs=added_cond_kwargs,
+                            down_block_additional_residuals=down_block_res_samples,
+                            mid_block_additional_residual=mid_block_res_sample,
+                        ).sample
+                    
+                    else:
+                        # predict the noise residual without contorlnet
+                        torch.cuda.synchronize()
+                        unet_start = time.time()
+                        noise_pred = self.unet(
+                            latent_model_input,
+                            t,
+                            encoder_hidden_states=prompt_embeds,
+                            cross_attention_kwargs=cross_attention_kwargs,
+                            added_cond_kwargs=added_cond_kwargs,
+                        ).sample
+
+                    if do_classifier_free_guidance:
+                        # Start timing for overall guidance process
+                        torch.cuda.synchronize()  # Synchronize GPU before starting timing
+                        start_guidance_time = time.time()
+
+                        # Timing for chunk operation
+                        torch.cuda.synchronize()  # Synchronize GPU before chunking
+                        time_chunk_start = time.time()
+
+                        noise_pred_uncond, noise_pred_text = torch.chunk(noise_pred, 2, dim=0)
+
+                        # Timing for batch addition and latent counter increment
+                        torch.cuda.synchronize()  # Synchronize GPU before batch addition
+                        time_batch_addition_start = time.time()
+                        
+                        # Perform batch addition
+                        noise_pred_uncond_sum[..., current_context_indexes, :, :] += noise_pred_uncond
+                        noise_pred_text_sum[..., current_context_indexes, :, :] += noise_pred_text
+                        latent_counter[current_context_indexes] += 1
+
+                    # set the step index to the current batch
+                    self.scheduler._step_index = i
                 
-                control_model_input = torch.transpose(control_model_input, 1, 2)
-                control_model_input = control_model_input.reshape(
-                    (-1, control_model_input.shape[2], control_model_input.shape[3], control_model_input.shape[4])
-                )
-                print("prompt_embeds.shape", prompt_embeds.shape)
-                print("control_model_input.shape", control_model_input.shape)
-                print("controlnet_prompt_embeds.shape", controlnet_prompt_embeds.shape)
-                print("conditioning_frames.shape", conditioning_frames.shape)
-                print("cond_scale", cond_scale)
-                print("guess_mode", guess_mode)
-  
-                down_block_res_samples, mid_block_res_sample = self.controlnet(
-                    control_model_input,
-                    t,
-                    encoder_hidden_states=controlnet_prompt_embeds,
-                    controlnet_cond=conditioning_frames,
-                    conditioning_scale=cond_scale,
-                    guess_mode=guess_mode,
-                    return_dict=False,
-                )
-
-                # predict the noise residual
-                noise_pred = self.unet(
-                    latent_model_input,
-                    t,
-                    encoder_hidden_states=prompt_embeds,
-                    cross_attention_kwargs=self.cross_attention_kwargs,
-                    added_cond_kwargs=added_cond_kwargs,
-                    down_block_additional_residuals=down_block_res_samples,
-                    mid_block_additional_residual=mid_block_res_sample,
-                ).sample
-
                 # perform guidance
-                if self.do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+                if do_classifier_free_guidance:
+                    latent_counter = latent_counter.reshape(1, 1, num_frames, 1, 1)
+                    noise_pred_uncond = noise_pred_uncond_sum / latent_counter
+                    noise_pred_text = noise_pred_text_sum / latent_counter
+                    
                     noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
+                
                 # compute the previous noisy sample x_t -> x_t-1
                 latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
-                if callback_on_step_end is not None:
-                    callback_kwargs = {}
-                    for k in callback_on_step_end_tensor_inputs:
-                        callback_kwargs[k] = locals()[k]
-                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
-
-                    latents = callback_outputs.pop("latents", latents)
-                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
-                    negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
-
+                
                 # call the callback, if provided
                 if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
                     progress_bar.update()
                     if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
+                        callback(i, t, None)
+        
         if output_type == "latent":
-            return AnimateDiffControlNetPipelineOutput(frames=latents)
-
+            return AnimateDiffPipelineOutput(frames=latents)
+
+        # save frames
+        if output_path is not None:
+            output_batch_size = 2 # prevents out of memory errors with large videos
+            num_digits = output_path.count('#')  # count the number of '#' characters
+            frame_format = output_path.replace('#' * num_digits, '{:0' + str(num_digits) + 'd}')
+            for batch in range((num_frames + output_batch_size - 1) // output_batch_size):
+                start_id = batch * output_batch_size
+                end_id = min((batch + 1) * output_batch_size, num_frames)
+                video_tensor = self.decode_latents(latents[:, :, start_id:end_id, :, :])
+                video = tensor2vid(video_tensor, self.image_processor, output_type=output_type)
+                for f_id, frame in enumerate(video[0]):
+                    frame.save(frame_format.format(start_id + f_id))
+            return output_path
+            
         # Post-processing
         video_tensor = self.decode_latents(latents)
 
@@ -1144,4 +1568,4 @@ class AnimateDiffControlNetPipeline(DiffusionPipeline, TextualInversionLoaderMix
         if not return_dict:
             return (video,)
 
-        return AnimateDiffControlNetPipelineOutput(frames=video)
+        return AnimateDiffPipelineOutput(frames=video)