feat: GGUF + SageAttention guide — DPMSolver++ default, benchmark, README update

.gitattributes

@@ -46,3 +46,7 @@ assets/fisherman.mp4 filter=lfs diff=lfs merge=lfs -text
 assets/underwater.mp4 filter=lfs diff=lfs merge=lfs -text
 assets/vows.mp4 filter=lfs diff=lfs merge=lfs -text
 assets/woman.mp4 filter=lfs diff=lfs merge=lfs -text
+assets/sage_compare_BF16.webp filter=lfs diff=lfs merge=lfs -text
+assets/sage_compare_Q4_K_M.webp filter=lfs diff=lfs merge=lfs -text
+assets/sage_compare_Q5_K_M.webp filter=lfs diff=lfs merge=lfs -text
+assets/sage_compare_Q8_0.webp filter=lfs diff=lfs merge=lfs -text

README.md

@@ -47,8 +47,24 @@ widget:
 
 ---
 
+<!--
+  NOTE: This README is written against the CURRENT state of diffusers PR #13551
+  (pre-merge). The PR currently has issues:
+  - negative_prompt defaults to None (should be built-in)
+  - use_linear_quadratic_schedule defaults to True (should be False)
+  - DPMSolverMultistepScheduler crashes (pipeline always passes sigmas)
+  - No built-in SageAttention support (requires manual patching)
+
+  Code examples below include workarounds (explicit negative_prompt,
+  use_linear_quadratic_schedule=False, _FlowDPMSolver subclass).
+
+  TODO: Update after PR feedback is applied, and again after merge.
+  Tracking: https://github.com/MotifTechnologies/diffusers/pull/1
+-->
+
 ## 🔥 News
 
+- **[2026-04-28]** **GGUF quantized weights** now available at [Motif-Video-2B-GGUF](https://huggingface.co/Motif-Technologies/Motif-Video-2B-GGUF) — up to 2.7 GB VRAM savings with no speed penalty. **SageAttention** support for ~2× faster inference. See [GGUF + SageAttention](#-gguf--sageattention) below.
 - **[2026-04-14]** We release **Motif-Video 2B**, our 2B-parameter text-to-video and image-to-video diffusion transformer, together with the full [technical report](https://arxiv.org/abs/2604.16503).
 
 ---
@@ -127,38 +143,71 @@ For the full derivation of why Shared Cross-Attention shares K/V but not Q, and
 - CUDA-capable GPU with **30GB+ VRAM** (e.g., A100, H100) — for 24GB GPUs see [Memory-efficient Inference](#-memory-efficient-inference)
 
 ```bash
-pip install "diffusers>=0.35.2" "transformers>=5.5.4" torch accelerate ftfy einops sentencepiece regex Pillow imageio imageio-ffmpeg
+pip install "transformers>=5.5.4" torch accelerate ftfy einops sentencepiece regex Pillow imageio imageio-ffmpeg
+pip install git+https://github.com/waitingcheung/diffusers.git@feat/motif-video
 ```
 
 ### Text-to-Video (T2V)
 
 ```python
 import torch
-from diffusers import AdaptiveProjectedGuidance, DiffusionPipeline
+from diffusers import (
+    AdaptiveProjectedGuidance,
+    DPMSolverMultistepScheduler,
+    MotifVideoPipeline,
+)
 from diffusers.utils import export_to_video
 
+
+# DPMSolver++ subclass: ignores pipeline-supplied sigmas and builds its own
+# flow-matching schedule. Will be unnecessary once PR #13551 adds the
+# _is_flow_multistep branch.
+class FlowDPMSolver(DPMSolverMultistepScheduler):
+    def set_timesteps(self, num_inference_steps=None, device=None,
+                      sigmas=None, mu=None, timesteps=None):
+        if sigmas is not None and num_inference_steps is None:
+            num_inference_steps = len(sigmas)
+        super().set_timesteps(
+            num_inference_steps=num_inference_steps,
+            device=device, timesteps=timesteps,
+        )
+
+
 guider = AdaptiveProjectedGuidance(
     guidance_scale=8.0,
     adaptive_projected_guidance_rescale=12.0,
     adaptive_projected_guidance_momentum=0.1,
     use_original_formulation=True,
+    normalization_dims="spatial",
 )
 
-pipe = DiffusionPipeline.from_pretrained(
+pipe = MotifVideoPipeline.from_pretrained(
     "Motif-Technologies/Motif-Video-2B",
-    custom_pipeline="pipeline_motif_video",
-    trust_remote_code=True,
+    revision="diffusers-integration",
     torch_dtype=torch.bfloat16,
     guider=guider,
 )
+
+# DPMSolver++ for faster convergence
+pipe.scheduler = FlowDPMSolver(
+    num_train_timesteps=pipe.scheduler.config.get("num_train_timesteps", 1000),
+    algorithm_type="dpmsolver++",
+    solver_order=2,
+    prediction_type="flow_prediction",
+    use_flow_sigmas=True,
+    flow_shift=15.0,
+)
 pipe = pipe.to("cuda")
 
 output = pipe(
-    prompt="A category-five hurricane, viewed from inside the eye, reveals a circular stadium of cloud walls rising to fifty thousand feet with an eerie disk of blue sky directly overhead. Shot from a NOAA reconnaissance aircraft mounted camera, the perspective looks outward toward the eyewall — a near-vertical curtain of rotating cloud and lightning that is simultaneously terrifying and transcendent. The inner surface of the eyewall catches the setting sun, painting it in improbable shades of peach and rose. The camera slowly pans 360 degrees to complete one full revolution, capturing the entire coliseum of the storm. Below, the ocean surface is a white blur of foam and spray. The documentary-style cinematography strips away all artifice to present the storm as an entity of pure elemental power.",
+    prompt="A woman standing in a sunlit field as flower petals swirl around her in slow motion. Each petal floats gently through the golden light, casting tiny shadows. Her hair moves like water, and time seems to stand still.",
+    negative_prompt="text overlay, graphic overlay, watermark, logo, subtitles, timestamp, broadcast graphics, UI elements, random letters, frozen pose, rigid, static expression, jerky motion, mechanical motion, discontinuous motion, flat framing, depthless, dull lighting, monotone, crushed shadows, blown-out highlights, shifting background, fading background, poor continuity, identity drift, deformation, flickering, ghosting, smearing, duplication, mutated proportions, inconsistent clothing, flat colors, desaturated, tonally compressed, poor background separation, exposure shift, uneven brightness, color balance shift",
     height=736,
     width=1280,
     num_frames=121,
     num_inference_steps=50,
+    frame_rate=24,
+    use_linear_quadratic_schedule=False,
 )
 
 export_to_video(output.frames[0], "output.mp4", fps=24)
@@ -168,7 +217,11 @@ export_to_video(output.frames[0], "output.mp4", fps=24)
 
 ```python
 import torch
-from diffusers import AdaptiveProjectedGuidance, DiffusionPipeline
+from diffusers import (
+    AdaptiveProjectedGuidance,
+    DPMSolverMultistepScheduler,
+    MotifVideoPipeline,
+)
 from diffusers.utils import export_to_video, load_image
 
 guider = AdaptiveProjectedGuidance(
@@ -176,26 +229,38 @@ guider = AdaptiveProjectedGuidance(
     adaptive_projected_guidance_rescale=12.0,
     adaptive_projected_guidance_momentum=0.1,
     use_original_formulation=True,
+    normalization_dims="spatial",
 )
 
-pipe = DiffusionPipeline.from_pretrained(
+pipe = MotifVideoPipeline.from_pretrained(
     "Motif-Technologies/Motif-Video-2B",
-    custom_pipeline="pipeline_motif_video",
-    trust_remote_code=True,
+    revision="diffusers-integration",
     torch_dtype=torch.bfloat16,
     guider=guider,
 )
+
+pipe.scheduler = FlowDPMSolver(
+    num_train_timesteps=pipe.scheduler.config.get("num_train_timesteps", 1000),
+    algorithm_type="dpmsolver++",
+    solver_order=2,
+    prediction_type="flow_prediction",
+    use_flow_sigmas=True,
+    flow_shift=15.0,
+)
 pipe = pipe.to("cuda")
 
 image = load_image("https://huggingface.co/Motif-Technologies/Motif-Video-2B/resolve/main/assets/i2v_sample.jpg")
 
 output = pipe(
-    prompt="Three friends stride through a sun-bleached meadow as a warm breeze ripples the tall dry grass around their legs. The woman on the left turns her head to share a quiet laugh, the woman in the center pushes a loose curl behind her ear, and the man on the right tilts his face toward the sky. The camera drifts gently alongside them at walking pace, handheld, with soft overcast light.",
+    prompt="Three friends stride through a sun-bleached meadow as a warm breeze ripples the tall dry grass around their legs.",
+    negative_prompt="text overlay, graphic overlay, watermark, logo, subtitles, timestamp, broadcast graphics, UI elements, random letters, frozen pose, rigid, static expression, jerky motion, mechanical motion, discontinuous motion, flat framing, depthless, dull lighting, monotone, crushed shadows, blown-out highlights, shifting background, fading background, poor continuity, identity drift, deformation, flickering, ghosting, smearing, duplication, mutated proportions, inconsistent clothing, flat colors, desaturated, tonally compressed, poor background separation, exposure shift, uneven brightness, color balance shift",
     image=image,
     height=736,
     width=1280,
     num_frames=121,
     num_inference_steps=50,
+    frame_rate=24,
+    use_linear_quadratic_schedule=False,
 )
 
 export_to_video(output.frames[0], "output.mp4", fps=24)
@@ -204,28 +269,31 @@ export_to_video(output.frames[0], "output.mp4", fps=24)
 ### CLI Inference
 
 ```bash
-# Text-to-Video
+# Text-to-Video (default settings)
 python inference.py \
-  --prompt "A time-lapse of a flower blooming in a dark room, dramatic lighting" \
+  --prompt "A woman standing in a sunlit field as..." \
   --output t2v_output.mp4
 
-# Image-to-Video
+# With SageAttention (~2x faster, requires sageattention package)
 python inference.py \
-  --image assets/i2v_sample.jpg \
-  --prompt "Three friends stride through a meadow as a warm breeze ripples the tall grass" \
-  --output i2v_output.mp4
+  --prompt "Three friends stride through a sun-bleached meadow..." \
+  --use-sage-attention \
+  --output t2v_output.mp4
 ```
 
-See `inference.py` for all available options (`--help`).
+See `inference.py --help` for all available options.
 
 ### Recommended Settings
 
 | Parameter | Default | Notes |
 |---|---|---|
-| Resolution | 1280x736 | 720p, best quality |
+| Resolution | 1280×736 | 720p, best quality |
 | Frames | 121 | ~5 seconds at 24fps |
-| Guidance scale | 8.0 | |
+| Scheduler | DPMSolver++ | `solver_order=2`, `flow_shift=15.0` |
+| Guidance scale | 8.0 | With APG (`normalization_dims="spatial"`) |
 | Inference steps | 50 | |
+| Negative prompt | (built-in) | See code examples above |
+| `use_linear_quadratic_schedule` | `False` | Must be set explicitly |
 | dtype | bfloat16 | Recommended for H100/A100 |
 
 ### 🔋 Memory-efficient Inference
@@ -239,16 +307,28 @@ export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
 ```
 
 ```python
-pipe = DiffusionPipeline.from_pretrained(
+pipe = MotifVideoPipeline.from_pretrained(
     "Motif-Technologies/Motif-Video-2B",
-    custom_pipeline="pipeline_motif_video",
-    trust_remote_code=True,
+    revision="diffusers-integration",
     torch_dtype=torch.bfloat16,
     guider=guider,  # see T2V example above
 )
+pipe.scheduler = FlowDPMSolver(
+    num_train_timesteps=pipe.scheduler.config.get("num_train_timesteps", 1000),
+    algorithm_type="dpmsolver++",
+    solver_order=2,
+    prediction_type="flow_prediction",
+    use_flow_sigmas=True,
+    flow_shift=15.0,
+)
 pipe.enable_model_cpu_offload()  # replaces pipe.to("cuda")
 
-output = pipe(prompt="...", height=736, width=1280, num_frames=121, num_inference_steps=50)
+output = pipe(
+    prompt="...",
+    negative_prompt="...",
+    height=736, width=1280, num_frames=121, num_inference_steps=50,
+    frame_rate=24, use_linear_quadratic_schedule=False,
+)
 export_to_video(output.frames[0], "output.mp4", fps=24)
 ```
 
@@ -270,17 +350,29 @@ pip install torchao
 ```python
 from torchao.quantization import quantize_, Float8WeightOnlyConfig
 
-pipe = DiffusionPipeline.from_pretrained(
+pipe = MotifVideoPipeline.from_pretrained(
     "Motif-Technologies/Motif-Video-2B",
-    custom_pipeline="pipeline_motif_video",
-    trust_remote_code=True,
+    revision="diffusers-integration",
     torch_dtype=torch.bfloat16,
     guider=guider,  # see T2V example above
 )
+pipe.scheduler = FlowDPMSolver(
+    num_train_timesteps=pipe.scheduler.config.get("num_train_timesteps", 1000),
+    algorithm_type="dpmsolver++",
+    solver_order=2,
+    prediction_type="flow_prediction",
+    use_flow_sigmas=True,
+    flow_shift=15.0,
+)
 quantize_(pipe.transformer, Float8WeightOnlyConfig())
 pipe.enable_model_cpu_offload()
 
-output = pipe(prompt="...", height=736, width=1280, num_frames=121, num_inference_steps=50)
+output = pipe(
+    prompt="...",
+    negative_prompt="...",
+    height=736, width=1280, num_frames=121, num_inference_steps=50,
+    frame_rate=24, use_linear_quadratic_schedule=False,
+)
 export_to_video(output.frames[0], "output.mp4", fps=24)
 ```
 
@@ -295,6 +387,140 @@ This stores the transformer weights in FP8 (8-bit) instead of BF16 (16-bit), red
 
 Official ComfyUI custom nodes for Motif-Video 2B are currently in development. Stay tuned for updates.
 
+---
+
+### 🧊 GGUF + SageAttention
+
+GGUF quantized transformer weights are available at [Motif-Video-2B-GGUF](https://huggingface.co/Motif-Technologies/Motif-Video-2B-GGUF), reducing VRAM with minimal quality loss. Combined with [SageAttention](https://github.com/thu-ml/SageAttention) for ~2× faster attention computation.
+
+#### GGUF Inference
+
+```bash
+pip install gguf
+```
+
+```python
+import torch
+from diffusers import (
+    AdaptiveProjectedGuidance,
+    DPMSolverMultistepScheduler,
+    GGUFQuantizationConfig,
+    MotifVideoPipeline,
+    MotifVideoTransformer3DModel,
+)
+from diffusers.utils import export_to_video
+from huggingface_hub import hf_hub_download
+
+guider = AdaptiveProjectedGuidance(
+    guidance_scale=8.0,
+    adaptive_projected_guidance_rescale=12.0,
+    adaptive_projected_guidance_momentum=0.1,
+    use_original_formulation=True,
+    normalization_dims="spatial",
+)
+
+variant = "Q4_K_M"  # Options: Q4_0, Q4_1, Q4_K_M, Q5_0, Q5_1, Q5_K_M, Q6_K, Q8_0, BF16
+ckpt_path = hf_hub_download(
+    "Motif-Technologies/Motif-Video-2B-GGUF",
+    filename=f"motifv-2b-dev-{variant}.gguf",
+)
+
+transformer = MotifVideoTransformer3DModel.from_single_file(
+    ckpt_path,
+    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
+    config="Motif-Technologies/Motif-Video-2B",
+    revision="diffusers-integration",
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+)
+
+pipe = MotifVideoPipeline.from_pretrained(
+    "Motif-Technologies/Motif-Video-2B",
+    revision="diffusers-integration",
+    torch_dtype=torch.bfloat16,
+    guider=guider,
+    transformer=transformer,
+)
+
+pipe.scheduler = FlowDPMSolver(
+    num_train_timesteps=pipe.scheduler.config.get("num_train_timesteps", 1000),
+    algorithm_type="dpmsolver++",
+    solver_order=2,
+    prediction_type="flow_prediction",
+    use_flow_sigmas=True,
+    flow_shift=15.0,
+)
+pipe.enable_model_cpu_offload()
+
+output = pipe(
+    prompt="A woman standing in a sunlit field as flower petals swirl around her in slow motion. Each petal floats gently through the golden light, casting tiny shadows. Her hair moves like water, and time seems to stand still.",
+    negative_prompt="text overlay, graphic overlay, watermark, logo, subtitles, timestamp, broadcast graphics, UI elements, random letters, frozen pose, rigid, static expression, jerky motion, mechanical motion, discontinuous motion, flat framing, depthless, dull lighting, monotone, crushed shadows, blown-out highlights, shifting background, fading background, poor continuity, identity drift, deformation, flickering, ghosting, smearing, duplication, mutated proportions, inconsistent clothing, flat colors, desaturated, tonally compressed, poor background separation, exposure shift, uneven brightness, color balance shift",
+    height=736,
+    width=1280,
+    num_frames=121,
+    num_inference_steps=50,
+    frame_rate=24,
+    use_linear_quadratic_schedule=False,
+)
+export_to_video(output.frames[0], "output.mp4", fps=24)
+```
+
+#### SageAttention (Optional, ~1.6× faster)
+
+Same prompt and seed, 1280x736, 121 frames, 50 steps. Left = SDPA, Right = SageAttention.
+
+![BF16](assets/sage_compare_BF16.webp)
+![Q8_0](assets/sage_compare_Q8_0.webp)
+![Q5_K_M](assets/sage_compare_Q5_K_M.webp)
+![Q4_K_M](assets/sage_compare_Q4_K_M.webp)
+
+[SageAttention](https://github.com/thu-ml/SageAttention) accelerates attention by quantizing Q/K to INT8 and V to FP8, reducing memory bandwidth. Works with all GGUF variants.
+
+**Install** (build from source — PyPI only has 1.x, need 2.x):
+
+```bash
+# Set TORCH_CUDA_ARCH_LIST to match your GPU: "8.0" for A100, "9.0" for H100/H200
+TORCH_CUDA_ARCH_LIST="9.0" pip install git+https://github.com/thu-ml/SageAttention.git --no-build-isolation
+```
+
+**Usage with `inference.py`:**
+
+```bash
+python inference.py --use-sage-attention --prompt "..."
+```
+
+**Notes:**
+- Requires NVIDIA GPU with SM70+
+- SM90+ (H100, H200) — FP8 kernels for maximum speedup
+- SM80-SM89 (A100, RTX 3090, RTX 4090) — FP16 kernels (still faster than SDPA)
+- SM70-SM75 (V100, RTX 2080 Ti) — FP16 kernels
+- Set `TORCH_CUDA_ARCH_LIST` to match your GPU when building (e.g., `"8.6"` for RTX 3090, `"8.9"` for RTX 4090)
+- No quality degradation observed across all GGUF variants
+
+#### Benchmark
+
+Measured on NVIDIA H200, 1280x736, 121 frames, 50 steps, DPMSolver++ (order=2, flow_shift=15.0):
+
+| Variant | SDPA (s/it) | Sage (s/it) | Speedup | Peak alloc (GB) | Peak rsv (GB) | Total SDPA (s) | Total Sage (s) |
+|---------|------------|------------|---------|-----------------|----------------|----------------|----------------|
+| BF16    | 23.36      | 14.75      | 1.58x   | 14.78 / 15.12   | 24.93 / 24.90  | 1184           | 754            |
+| Q8_0    | 23.16      | 14.49      | 1.60x   | 13.10 / 13.44   | 23.14 / 23.11  | 1178           | 744            |
+| Q6_K    | 23.21      | 14.55      | 1.60x   | 12.62 / 12.95   | 22.72 / 22.69  | 1178           | 747            |
+| Q5_K_M  | 23.33      | 14.69      | 1.59x   | 12.39 / 12.72   | 22.45 / 22.42  | 1184           | 754            |
+| Q5_1    | 23.54      | 14.96      | 1.57x   | 12.47 / 12.81   | 22.66 / 22.62  | 1193           | 764            |
+| Q5_0    | 23.26      | 14.67      | 1.59x   | 12.37 / 12.71   | 22.55 / 22.52  | 1179           | 750            |
+| Q4_K_M  | 23.25      | 14.59      | 1.60x   | 12.19 / 12.53   | 22.22 / 22.18  | 1178           | 747            |
+| Q4_1    | 23.31      | 14.68      | 1.59x   | 12.26 / 12.60   | 22.26 / 22.22  | 1181           | 750            |
+| Q4_0    | 23.33      | 14.75      | 1.58x   | 12.14 / 12.47   | 22.18 / 22.14  | 1188           | 760            |
+
+Peak alloc/rsv columns show SDPA / Sage values. Sage adds ~0.3 GB alloc overhead (INT8/FP8 quantization buffers) with no change in reserved memory.
+
+**Key findings:**
+- **~1.59x faster with SageAttention** — consistent across all quantization levels
+- **VRAM unchanged** — sage overhead is negligible (~0.3 GB alloc)
+- **GGUF + Sage stacks** — Q4_K_M + Sage achieves 14.59 s/it at 12.53 GB alloc (vs BF16 SDPA: 23.36 s/it at 14.78 GB)
+
+
 ---
 
 ## 📊 Performance

_fm_solvers_unipc.py

@@ -1,759 +0,0 @@
-# Copied from https://github.com/huggingface/diffusers/blob/v0.31.0/src/diffusers/schedulers/scheduling_unipc_multistep.py
-# Convert unipc for flow matching
-# Copyright 2024-2025 The Alibaba Wan Team Authors. All rights reserved.
-
-import math
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import torch
-from diffusers.configuration_utils import ConfigMixin, register_to_config
-from diffusers.schedulers.scheduling_utils import (
-    KarrasDiffusionSchedulers,
-    SchedulerMixin,
-    SchedulerOutput,
-)
-from diffusers.utils import deprecate, is_scipy_available
-
-
-if is_scipy_available():
-    pass
-
-
-class FlowUniPCMultistepScheduler(SchedulerMixin, ConfigMixin):
-    """
-    `UniPCMultistepScheduler` is a training-free framework designed for the fast sampling of diffusion models.
-
-    This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
-    methods the library implements for all schedulers such as loading and saving.
-
-    Args:
-        num_train_timesteps (`int`, defaults to 1000):
-            The number of diffusion steps to train the model.
-        solver_order (`int`, default `2`):
-            The UniPC order which can be any positive integer. The effective order of accuracy is `solver_order + 1`
-            due to the UniC. It is recommended to use `solver_order=2` for guided sampling, and `solver_order=3` for
-            unconditional sampling.
-        prediction_type (`str`, defaults to "flow_prediction"):
-            Prediction type of the scheduler function; must be `flow_prediction` for this scheduler, which predicts
-            the flow of the diffusion process.
-        thresholding (`bool`, defaults to `False`):
-            Whether to use the "dynamic thresholding" method. This is unsuitable for latent-space diffusion models such
-            as Stable Diffusion.
-        dynamic_thresholding_ratio (`float`, defaults to 0.995):
-            The ratio for the dynamic thresholding method. Valid only when `thresholding=True`.
-        sample_max_value (`float`, defaults to 1.0):
-            The threshold value for dynamic thresholding. Valid only when `thresholding=True` and `predict_x0=True`.
-        predict_x0 (`bool`, defaults to `True`):
-            Whether to use the updating algorithm on the predicted x0.
-        solver_type (`str`, default `bh2`):
-            Solver type for UniPC. It is recommended to use `bh1` for unconditional sampling when steps < 10, and `bh2`
-            otherwise.
-        lower_order_final (`bool`, default `True`):
-            Whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. This can
-            stabilize the sampling of DPMSolver for steps < 15, especially for steps <= 10.
-        disable_corrector (`list`, default `[]`):
-            Decides which step to disable the corrector to mitigate the misalignment between `epsilon_theta(x_t, c)`
-            and `epsilon_theta(x_t^c, c)` which can influence convergence for a large guidance scale. Corrector is
-            usually disabled during the first few steps.
-        solver_p (`SchedulerMixin`, default `None`):
-            Any other scheduler that if specified, the algorithm becomes `solver_p + UniC`.
-        use_karras_sigmas (`bool`, *optional*, defaults to `False`):
-            Whether to use Karras sigmas for step sizes in the noise schedule during the sampling process. If `True`,
-            the sigmas are determined according to a sequence of noise levels {σi}.
-        use_exponential_sigmas (`bool`, *optional*, defaults to `False`):
-            Whether to use exponential sigmas for step sizes in the noise schedule during the sampling process.
-        timestep_spacing (`str`, defaults to `"linspace"`):
-            The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and
-            Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.
-        steps_offset (`int`, defaults to 0):
-            An offset added to the inference steps, as required by some model families.
-        final_sigmas_type (`str`, defaults to `"zero"`):
-            The final `sigma` value for the noise schedule during the sampling process. If `"sigma_min"`, the final
-            sigma is the same as the last sigma in the training schedule. If `zero`, the final sigma is set to 0.
-    """
-
-    _compatibles = [e.name for e in KarrasDiffusionSchedulers]
-    order = 1
-
-    @register_to_config
-    def __init__(
-        self,
-        num_train_timesteps: int = 1000,
-        solver_order: int = 2,
-        prediction_type: str = "flow_prediction",
-        shift: Optional[float] = 1.0,
-        use_dynamic_shifting=False,
-        thresholding: bool = False,
-        dynamic_thresholding_ratio: float = 0.995,
-        sample_max_value: float = 1.0,
-        predict_x0: bool = True,
-        solver_type: str = "bh2",
-        lower_order_final: bool = True,
-        disable_corrector: List[int] = [],
-        solver_p: Optional[SchedulerMixin] = None,
-        timestep_spacing: str = "linspace",
-        steps_offset: int = 0,
-        final_sigmas_type: Optional[str] = "zero",  # "zero", "sigma_min"
-    ):
-        if solver_type not in ["bh1", "bh2"]:
-            if solver_type in ["midpoint", "heun", "logrho"]:
-                self.register_to_config(solver_type="bh2")
-            else:
-                raise NotImplementedError(f"{solver_type} is not implemented for {self.__class__}")
-
-        self.predict_x0 = predict_x0
-        # setable values
-        self.num_inference_steps = None
-        alphas = np.linspace(1, 1 / num_train_timesteps, num_train_timesteps)[::-1].copy()
-        sigmas = 1.0 - alphas
-        sigmas = torch.from_numpy(sigmas).to(dtype=torch.float32)
-
-        if not use_dynamic_shifting:
-            # when use_dynamic_shifting is True, we apply the timestep shifting on the fly based on the image resolution
-            sigmas = shift * sigmas / (1 + (shift - 1) * sigmas)  # pyright: ignore
-
-        self.sigmas = sigmas
-        self.timesteps = sigmas * num_train_timesteps
-
-        self.model_outputs = [None] * solver_order
-        self.timestep_list = [None] * solver_order
-        self.lower_order_nums = 0
-        self.disable_corrector = disable_corrector
-        self.solver_p = solver_p
-        self.last_sample = None
-        self._step_index = None
-        self._begin_index = None
-
-        self.sigmas = self.sigmas.to("cpu")  # to avoid too much CPU/GPU communication
-        self.sigma_min = self.sigmas[-1].item()
-        self.sigma_max = self.sigmas[0].item()
-
-    @property
-    def step_index(self):
-        """
-        The index counter for current timestep. It will increase 1 after each scheduler step.
-        """
-        return self._step_index
-
-    @property
-    def begin_index(self):
-        """
-        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
-        """
-        return self._begin_index
-
-    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index
-    def set_begin_index(self, begin_index: int = 0):
-        """
-        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
-
-        Args:
-            begin_index (`int`):
-                The begin index for the scheduler.
-        """
-        self._begin_index = begin_index
-
-    # Modified from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler.set_timesteps
-    def set_timesteps(
-        self,
-        num_inference_steps: Union[int, None] = None,
-        device: Optional[Union[str, torch.device]] = None,
-        sigmas: Optional[List[float]] = None,
-        mu: Optional[Union[float, None]] = None,
-        shift: Optional[Union[float, None]] = None,
-    ):
-        """
-        Sets the discrete timesteps used for the diffusion chain (to be run before inference).
-        Args:
-            num_inference_steps (`int`):
-                Total number of the spacing of the time steps.
-            device (`str` or `torch.device`, *optional*):
-                The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
-        """
-
-        if self.config.use_dynamic_shifting and mu is None:
-            raise ValueError(" you have to pass a value for `mu` when `use_dynamic_shifting` is set to be `True`")
-
-        if sigmas is None:
-            sigmas = np.linspace(self.sigma_max, self.sigma_min, num_inference_steps + 1).copy()[:-1]  # pyright: ignore
-
-        if self.config.use_dynamic_shifting:
-            sigmas = self.time_shift(mu, 1.0, sigmas)  # pyright: ignore
-        else:
-            if shift is None:
-                shift = self.config.shift
-            sigmas = shift * sigmas / (1 + (shift - 1) * sigmas)  # pyright: ignore
-
-        if self.config.final_sigmas_type == "sigma_min":
-            sigma_last = self.config.sigma_min
-        elif self.config.final_sigmas_type == "zero":
-            sigma_last = 0
-        else:
-            raise ValueError(
-                f"`final_sigmas_type` must be one of 'zero', or 'sigma_min', but got {self.config.final_sigmas_type}"
-            )
-
-        timesteps = sigmas * self.config.num_train_timesteps
-        sigmas = np.concatenate([sigmas, [sigma_last]]).astype(np.float32)  # pyright: ignore
-
-        self.sigmas = torch.from_numpy(sigmas)
-        self.timesteps = torch.from_numpy(timesteps).to(device=device, dtype=torch.int64)
-
-        self.num_inference_steps = len(timesteps)
-
-        self.model_outputs = [
-            None,
-        ] * self.config.solver_order
-        self.lower_order_nums = 0
-        self.last_sample = None
-        if self.solver_p:
-            self.solver_p.set_timesteps(self.num_inference_steps, device=device)
-
-        # add an index counter for schedulers that allow duplicated timesteps
-        self._step_index = None
-        self._begin_index = None
-        self.sigmas = self.sigmas.to("cpu")  # to avoid too much CPU/GPU communication
-
-    # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler._threshold_sample
-    def _threshold_sample(self, sample: torch.Tensor) -> torch.Tensor:
-        """
-        "Dynamic thresholding: At each sampling step we set s to a certain percentile absolute pixel value in xt0 (the
-        prediction of x_0 at timestep t), and if s > 1, then we threshold xt0 to the range [-s, s] and then divide by
-        s. Dynamic thresholding pushes saturated pixels (those near -1 and 1) inwards, thereby actively preventing
-        pixels from saturation at each step. We find that dynamic thresholding results in significantly better
-        photorealism as well as better image-text alignment, especially when using very large guidance weights."
-
-        https://arxiv.org/abs/2205.11487
-        """
-        dtype = sample.dtype
-        batch_size, channels, *remaining_dims = sample.shape
-
-        if dtype not in (torch.float32, torch.float64):
-            sample = sample.float()  # upcast for quantile calculation, and clamp not implemented for cpu half
-
-        # Flatten sample for doing quantile calculation along each image
-        sample = sample.reshape(batch_size, channels * np.prod(remaining_dims))
-
-        abs_sample = sample.abs()  # "a certain percentile absolute pixel value"
-
-        s = torch.quantile(abs_sample, self.config.dynamic_thresholding_ratio, dim=1)
-        s = torch.clamp(
-            s, min=1, max=self.config.sample_max_value
-        )  # When clamped to min=1, equivalent to standard clipping to [-1, 1]
-        s = s.unsqueeze(1)  # (batch_size, 1) because clamp will broadcast along dim=0
-        sample = torch.clamp(sample, -s, s) / s  # "we threshold xt0 to the range [-s, s] and then divide by s"
-
-        sample = sample.reshape(batch_size, channels, *remaining_dims)
-        sample = sample.to(dtype)
-
-        return sample
-
-    # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler._sigma_to_t
-    def _sigma_to_t(self, sigma):
-        return sigma * self.config.num_train_timesteps
-
-    def _sigma_to_alpha_sigma_t(self, sigma):
-        return 1 - sigma, sigma
-
-    # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.set_timesteps
-    def time_shift(self, mu: float, sigma: float, t: torch.Tensor):
-        return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)
-
-    def convert_model_output(
-        self,
-        model_output: torch.Tensor,
-        *args,
-        sample: Optional[torch.Tensor] = None,
-        **kwargs,
-    ) -> torch.Tensor:
-        r"""
-        Convert the model output to the corresponding type the UniPC algorithm needs.
-
-        Args:
-            model_output (`torch.Tensor`):
-                The direct output from the learned diffusion model.
-            timestep (`int`):
-                The current discrete timestep in the diffusion chain.
-            sample (`torch.Tensor`):
-                A current instance of a sample created by the diffusion process.
-
-        Returns:
-            `torch.Tensor`:
-                The converted model output.
-        """
-        timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None)
-        if sample is None:
-            if len(args) > 1:
-                sample = args[1]
-            else:
-                raise ValueError("missing `sample` as a required keyward argument")
-        if timestep is not None:
-            deprecate(
-                "timesteps",
-                "1.0.0",
-                "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
-            )
-
-        sigma = self.sigmas[self.step_index]
-        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
-
-        if self.predict_x0:
-            if self.config.prediction_type == "flow_prediction":
-                sigma_t = self.sigmas[self.step_index]
-                x0_pred = sample - sigma_t * model_output
-            else:
-                raise ValueError(
-                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`,"
-                    " `v_prediction` or `flow_prediction` for the UniPCMultistepScheduler."
-                )
-
-            if self.config.thresholding:
-                x0_pred = self._threshold_sample(x0_pred)
-
-            return x0_pred
-        else:
-            if self.config.prediction_type == "flow_prediction":
-                sigma_t = self.sigmas[self.step_index]
-                epsilon = sample - (1 - sigma_t) * model_output
-            else:
-                raise ValueError(
-                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`,"
-                    " `v_prediction` or `flow_prediction` for the UniPCMultistepScheduler."
-                )
-
-            if self.config.thresholding:
-                sigma_t = self.sigmas[self.step_index]
-                x0_pred = sample - sigma_t * model_output
-                x0_pred = self._threshold_sample(x0_pred)
-                epsilon = model_output + x0_pred
-
-            return epsilon
-
-    def multistep_uni_p_bh_update(
-        self,
-        model_output: torch.Tensor,
-        *args,
-        sample: Optional[torch.Tensor] = None,
-        order: Optional[int] = None,
-        **kwargs,
-    ) -> torch.Tensor:
-        """
-        One step for the UniP (B(h) version). Alternatively, `self.solver_p` is used if is specified.
-
-        Args:
-            model_output (`torch.Tensor`):
-                The direct output from the learned diffusion model at the current timestep.
-            prev_timestep (`int`):
-                The previous discrete timestep in the diffusion chain.
-            sample (`torch.Tensor`):
-                A current instance of a sample created by the diffusion process.
-            order (`int`):
-                The order of UniP at this timestep (corresponds to the *p* in UniPC-p).
-
-        Returns:
-            `torch.Tensor`:
-                The sample tensor at the previous timestep.
-        """
-        prev_timestep = args[0] if len(args) > 0 else kwargs.pop("prev_timestep", None)
-        if sample is None:
-            if len(args) > 1:
-                sample = args[1]
-            else:
-                raise ValueError(" missing `sample` as a required keyward argument")
-        if order is None:
-            if len(args) > 2:
-                order = args[2]
-            else:
-                raise ValueError(" missing `order` as a required keyward argument")
-        if prev_timestep is not None:
-            deprecate(
-                "prev_timestep",
-                "1.0.0",
-                "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
-            )
-        model_output_list = self.model_outputs
-
-        s0 = self.timestep_list[-1]
-        m0 = model_output_list[-1]
-        x = sample
-
-        if self.solver_p:
-            x_t = self.solver_p.step(model_output, s0, x).prev_sample
-            return x_t
-
-        sigma_t, sigma_s0 = self.sigmas[self.step_index + 1], self.sigmas[self.step_index]  # pyright: ignore
-        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
-        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
-
-        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
-        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
-
-        h = lambda_t - lambda_s0
-        device = sample.device
-
-        rks = []
-        D1s = []
-        for i in range(1, order):
-            si = self.step_index - i  # pyright: ignore
-            mi = model_output_list[-(i + 1)]
-            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
-            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
-            rk = (lambda_si - lambda_s0) / h
-            rks.append(rk)
-            D1s.append((mi - m0) / rk)  # pyright: ignore
-
-        rks.append(1.0)
-        rks = torch.tensor(rks, device=device)
-
-        R = []
-        b = []
-
-        hh = -h if self.predict_x0 else h
-        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
-        h_phi_k = h_phi_1 / hh - 1
-
-        factorial_i = 1
-
-        if self.config.solver_type == "bh1":
-            B_h = hh
-        elif self.config.solver_type == "bh2":
-            B_h = torch.expm1(hh)
-        else:
-            raise NotImplementedError()
-
-        for i in range(1, order + 1):
-            R.append(torch.pow(rks, i - 1))
-            b.append(h_phi_k * factorial_i / B_h)
-            factorial_i *= i + 1
-            h_phi_k = h_phi_k / hh - 1 / factorial_i
-
-        R = torch.stack(R)
-        b = torch.tensor(b, device=device)
-
-        if len(D1s) > 0:
-            D1s = torch.stack(D1s, dim=1)  # (B, K)
-            # for order 2, we use a simplified version
-            if order == 2:
-                rhos_p = torch.tensor([0.5], dtype=x.dtype, device=device)
-            else:
-                rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1]).to(device).to(x.dtype)
-        else:
-            D1s = None
-
-        if self.predict_x0:
-            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
-            if D1s is not None:
-                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)  # pyright: ignore
-            else:
-                pred_res = 0
-            x_t = x_t_ - alpha_t * B_h * pred_res
-        else:
-            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
-            if D1s is not None:
-                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)  # pyright: ignore
-            else:
-                pred_res = 0
-            x_t = x_t_ - sigma_t * B_h * pred_res
-
-        x_t = x_t.to(x.dtype)
-        return x_t
-
-    def multistep_uni_c_bh_update(
-        self,
-        this_model_output: torch.Tensor,
-        *args,
-        last_sample: Optional[torch.Tensor] = None,
-        this_sample: Optional[torch.Tensor] = None,
-        order: Optional[int] = None,
-        **kwargs,
-    ) -> torch.Tensor:
-        """
-        One step for the UniC (B(h) version).
-
-        Args:
-            this_model_output (`torch.Tensor`):
-                The model outputs at `x_t`.
-            this_timestep (`int`):
-                The current timestep `t`.
-            last_sample (`torch.Tensor`):
-                The generated sample before the last predictor `x_{t-1}`.
-            this_sample (`torch.Tensor`):
-                The generated sample after the last predictor `x_{t}`.
-            order (`int`):
-                The `p` of UniC-p at this step. The effective order of accuracy should be `order + 1`.
-
-        Returns:
-            `torch.Tensor`:
-                The corrected sample tensor at the current timestep.
-        """
-        this_timestep = args[0] if len(args) > 0 else kwargs.pop("this_timestep", None)
-        if last_sample is None:
-            if len(args) > 1:
-                last_sample = args[1]
-            else:
-                raise ValueError(" missing`last_sample` as a required keyward argument")
-        if this_sample is None:
-            if len(args) > 2:
-                this_sample = args[2]
-            else:
-                raise ValueError(" missing`this_sample` as a required keyward argument")
-        if order is None:
-            if len(args) > 3:
-                order = args[3]
-            else:
-                raise ValueError(" missing`order` as a required keyward argument")
-        if this_timestep is not None:
-            deprecate(
-                "this_timestep",
-                "1.0.0",
-                "Passing `this_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
-            )
-
-        model_output_list = self.model_outputs
-
-        m0 = model_output_list[-1]
-        x = last_sample
-        x_t = this_sample
-        model_t = this_model_output
-
-        sigma_t, sigma_s0 = self.sigmas[self.step_index], self.sigmas[self.step_index - 1]  # pyright: ignore
-        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
-        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
-
-        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
-        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
-
-        h = lambda_t - lambda_s0
-        device = this_sample.device
-
-        rks = []
-        D1s = []
-        for i in range(1, order):
-            si = self.step_index - (i + 1)  # pyright: ignore
-            mi = model_output_list[-(i + 1)]
-            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
-            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
-            rk = (lambda_si - lambda_s0) / h
-            rks.append(rk)
-            D1s.append((mi - m0) / rk)  # pyright: ignore
-
-        rks.append(1.0)
-        rks = torch.tensor(rks, device=device)
-
-        R = []
-        b = []
-
-        hh = -h if self.predict_x0 else h
-        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
-        h_phi_k = h_phi_1 / hh - 1
-
-        factorial_i = 1
-
-        if self.config.solver_type == "bh1":
-            B_h = hh
-        elif self.config.solver_type == "bh2":
-            B_h = torch.expm1(hh)
-        else:
-            raise NotImplementedError()
-
-        for i in range(1, order + 1):
-            R.append(torch.pow(rks, i - 1))
-            b.append(h_phi_k * factorial_i / B_h)
-            factorial_i *= i + 1
-            h_phi_k = h_phi_k / hh - 1 / factorial_i
-
-        R = torch.stack(R)
-        b = torch.tensor(b, device=device)
-
-        if len(D1s) > 0:
-            D1s = torch.stack(D1s, dim=1)
-        else:
-            D1s = None
-
-        # for order 1, we use a simplified version
-        if order == 1:
-            rhos_c = torch.tensor([0.5], dtype=x.dtype, device=device)
-        else:
-            rhos_c = torch.linalg.solve(R, b).to(device).to(x.dtype)
-
-        if self.predict_x0:
-            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
-            if D1s is not None:
-                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
-            else:
-                corr_res = 0
-            D1_t = model_t - m0
-            x_t = x_t_ - alpha_t * B_h * (corr_res + rhos_c[-1] * D1_t)
-        else:
-            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
-            if D1s is not None:
-                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
-            else:
-                corr_res = 0
-            D1_t = model_t - m0
-            x_t = x_t_ - sigma_t * B_h * (corr_res + rhos_c[-1] * D1_t)
-        x_t = x_t.to(x.dtype)
-        return x_t
-
-    def index_for_timestep(self, timestep, schedule_timesteps=None):
-        if schedule_timesteps is None:
-            schedule_timesteps = self.timesteps
-
-        indices = (schedule_timesteps == timestep).nonzero()
-
-        # The sigma index that is taken for the **very** first `step`
-        # is always the second index (or the last index if there is only 1)
-        # This way we can ensure we don't accidentally skip a sigma in
-        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
-        pos = 1 if len(indices) > 1 else 0
-
-        return indices[pos].item()
-
-    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler._init_step_index
-    def _init_step_index(self, timestep):
-        """
-        Initialize the step_index counter for the scheduler.
-        """
-
-        if self.begin_index is None:
-            if isinstance(timestep, torch.Tensor):
-                timestep = timestep.to(self.timesteps.device)
-            self._step_index = self.index_for_timestep(timestep)
-        else:
-            self._step_index = self._begin_index
-
-    def step(
-        self,
-        model_output: torch.Tensor,
-        timestep: Union[int, torch.Tensor],
-        sample: torch.Tensor,
-        return_dict: bool = True,
-        generator=None,
-    ) -> Union[SchedulerOutput, Tuple]:
-        """
-        Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with
-        the multistep UniPC.
-
-        Args:
-            model_output (`torch.Tensor`):
-                The direct output from learned diffusion model.
-            timestep (`int`):
-                The current discrete timestep in the diffusion chain.
-            sample (`torch.Tensor`):
-                A current instance of a sample created by the diffusion process.
-            return_dict (`bool`):
-                Whether or not to return a [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`.
-
-        Returns:
-            [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`:
-                If return_dict is `True`, [`~schedulers.scheduling_utils.SchedulerOutput`] is returned, otherwise a
-                tuple is returned where the first element is the sample tensor.
-
-        """
-        if self.num_inference_steps is None:
-            raise ValueError(
-                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
-            )
-
-        if self.step_index is None:
-            self._init_step_index(timestep)
-
-        use_corrector = (
-            self.step_index > 0 and self.step_index - 1 not in self.disable_corrector and self.last_sample is not None  # pyright: ignore
-        )
-
-        model_output_convert = self.convert_model_output(model_output, sample=sample)
-        if use_corrector:
-            sample = self.multistep_uni_c_bh_update(
-                this_model_output=model_output_convert,
-                last_sample=self.last_sample,
-                this_sample=sample,
-                order=self.this_order,
-            )
-
-        for i in range(self.config.solver_order - 1):
-            self.model_outputs[i] = self.model_outputs[i + 1]
-            self.timestep_list[i] = self.timestep_list[i + 1]
-
-        self.model_outputs[-1] = model_output_convert
-        self.timestep_list[-1] = timestep  # pyright: ignore
-
-        if self.config.lower_order_final:
-            this_order = min(self.config.solver_order, len(self.timesteps) - self.step_index)  # pyright: ignore
-        else:
-            this_order = self.config.solver_order
-
-        self.this_order = min(this_order, self.lower_order_nums + 1)  # warmup for multistep
-        assert self.this_order > 0
-
-        self.last_sample = sample
-        prev_sample = self.multistep_uni_p_bh_update(
-            model_output=model_output,  # pass the original non-converted model output, in case solver-p is used
-            sample=sample,
-            order=self.this_order,
-        )
-
-        if self.lower_order_nums < self.config.solver_order:
-            self.lower_order_nums += 1
-
-        # upon completion increase step index by one
-        self._step_index += 1  # pyright: ignore
-
-        if not return_dict:
-            return (prev_sample,)
-
-        return SchedulerOutput(prev_sample=prev_sample)
-
-    def scale_model_input(self, sample: torch.Tensor, *args, **kwargs) -> torch.Tensor:
-        """
-        Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
-        current timestep.
-
-        Args:
-            sample (`torch.Tensor`):
-                The input sample.
-
-        Returns:
-            `torch.Tensor`:
-                A scaled input sample.
-        """
-        return sample
-
-    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.add_noise
-    def add_noise(
-        self,
-        original_samples: torch.Tensor,
-        noise: torch.Tensor,
-        timesteps: torch.IntTensor,
-    ) -> torch.Tensor:
-        # Make sure sigmas and timesteps have the same device and dtype as original_samples
-        sigmas = self.sigmas.to(device=original_samples.device, dtype=original_samples.dtype)
-        if original_samples.device.type == "mps" and torch.is_floating_point(timesteps):
-            # mps does not support float64
-            schedule_timesteps = self.timesteps.to(original_samples.device, dtype=torch.float32)
-            timesteps = timesteps.to(original_samples.device, dtype=torch.float32)
-        else:
-            schedule_timesteps = self.timesteps.to(original_samples.device)
-            timesteps = timesteps.to(original_samples.device)
-
-        # begin_index is None when the scheduler is used for training or pipeline does not implement set_begin_index
-        if self.begin_index is None:
-            step_indices = [self.index_for_timestep(t, schedule_timesteps) for t in timesteps]
-        elif self.step_index is not None:
-            # add_noise is called after first denoising step (for inpainting)
-            step_indices = [self.step_index] * timesteps.shape[0]
-        else:
-            # add noise is called before first denoising step to create initial latent(img2img)
-            step_indices = [self.begin_index] * timesteps.shape[0]
-
-        sigma = sigmas[step_indices].flatten()
-        while len(sigma.shape) < len(original_samples.shape):
-            sigma = sigma.unsqueeze(-1)
-
-        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
-        noisy_samples = alpha_t * original_samples + sigma_t * noise
-        return noisy_samples
-
-    def __len__(self):
-        return self.config.num_train_timesteps

inference.py

@@ -1,26 +1,43 @@
 #!/usr/bin/env python3
-"""Motif-Video 2B — Text-to-Video & Image-to-Video inference.
+"""Motif-Video 2B — Text-to-Video inference.
 
 GPU requirements: ~24GB VRAM for 720p (1280x736, 121 frames).
-Tested with: torch>=2.0, diffusers>=0.35.2, transformers>=5.0.0
+Requires: torch, diffusers (with MotifVideoPipeline), transformers>=5.5.4,
+           accelerate, ftfy, einops, sentencepiece, regex
 
-Uses Adaptive Projected Guidance (APG) by default for best quality.
+Uses Adaptive Projected Guidance (APG) and DPMSolver++ scheduler by default.
 """
 
 import argparse
 
 import torch
-from diffusers import AdaptiveProjectedGuidance, DiffusionPipeline
+from diffusers import (
+    AdaptiveProjectedGuidance,
+    DPMSolverMultistepScheduler,
+    MotifVideoPipeline,
+)
 from diffusers.utils import export_to_video
 
+_DEFAULT_NEGATIVE_PROMPT = (
+    "text overlay, graphic overlay, watermark, logo, subtitles, timestamp, "
+    "broadcast graphics, UI elements, random letters, frozen pose, rigid, "
+    "static expression, jerky motion, mechanical motion, discontinuous motion, "
+    "flat framing, depthless, dull lighting, monotone, crushed shadows, "
+    "blown-out highlights, shifting background, fading background, poor continuity, "
+    "identity drift, deformation, flickering, ghosting, smearing, duplication, "
+    "mutated proportions, inconsistent clothing, flat colors, desaturated, "
+    "tonally compressed, poor background separation, exposure shift, "
+    "uneven brightness, color balance shift"
+)
+
 
 def parse_args():
-    parser = argparse.ArgumentParser(description="Motif-Video 2B Inference (T2V / I2V)")
+    parser = argparse.ArgumentParser(description="Motif-Video 2B Inference (T2V)")
     parser.add_argument(
         "--model-path",
         type=str,
         default="Motif-Technologies/Motif-Video-2B",
-        help="HuggingFace model ID or local checkpoint path (uses trust_remote_code=True)",
+        help="HuggingFace model ID or local checkpoint path",
     )
     parser.add_argument(
         "--prompt",
@@ -28,17 +45,11 @@ def parse_args():
         default="A category-five hurricane, viewed from inside the eye, reveals a circular stadium of cloud walls rising to fifty thousand feet with an eerie disk of blue sky directly overhead. Shot from a NOAA reconnaissance aircraft mounted camera, the perspective looks outward toward the eyewall — a near-vertical curtain of rotating cloud and lightning that is simultaneously terrifying and transcendent. The inner surface of the eyewall catches the setting sun, painting it in improbable shades of peach and rose. The camera slowly pans 360 degrees to complete one full revolution, capturing the entire coliseum of the storm. Below, the ocean surface is a white blur of foam and spray. The documentary-style cinematography strips away all artifice to present the storm as an entity of pure elemental power.",
         help="Text prompt for video generation",
     )
-    parser.add_argument(
-        "--image",
-        type=str,
-        default=None,
-        help="Path to input image for I2V mode (omit for T2V)",
-    )
     parser.add_argument(
         "--negative-prompt",
         type=str,
-        default=None,
-        help="Negative prompt (default: built-in pipeline default)",
+        default=_DEFAULT_NEGATIVE_PROMPT,
+        help="Negative prompt",
     )
     parser.add_argument("--output", type=str, default="output.mp4", help="Output video file path")
     parser.add_argument("--num-frames", type=int, default=121, help="Number of frames to generate (121 = ~5s at 24fps)")
@@ -55,60 +66,140 @@ def parse_args():
         choices=["float16", "bfloat16", "float32"],
         help="Model dtype",
     )
+    parser.add_argument(
+        "--use-sage-attention",
+        action="store_true",
+        help="Enable SageAttention for ~2x faster attention (requires: pip install sageattention>=2.1.1 from GitHub source)",
+    )
     return parser.parse_args()
 
 
+def _enable_sage_attention(transformer):
+    """Patch transformer attention to use SageAttention.
+
+    Only patches _compute_attention (self-attention path). Cross-attention
+    uses _handle_cross_attention_mode which calls F.sdpa directly and is
+    unaffected by this patch.
+
+    Mask handling follows motif-models dispatch_optimized_attention pattern:
+    - mask=None: sage directly
+    - mask with uniform active length: slice active region -> sage -> pad back
+    - mask with non-uniform active length: SDPA fallback
+    """
+    from sageattention import sageattn
+    from diffusers.models.transformers.transformer_motif_video import MotifVideoAttnProcessor2_0
+
+    _orig_compute = MotifVideoAttnProcessor2_0._compute_attention
+
+    def _sage_compute(self, query, key, value, attention_mask):
+        if attention_mask is None:
+            out = sageattn(
+                query.contiguous(), key.contiguous(), value.contiguous(),
+                tensor_layout="HND", is_causal=False,
+            )
+            out = out.transpose(1, 2).flatten(2, 3).to(query.dtype)
+            return out
+
+        # Find active token count from mask (shape: [B, 1, 1, S])
+        padding_indices = attention_mask.sum(dim=-1).long().flatten()
+        common_padding_index = padding_indices[0]
+        is_uniform = (padding_indices == common_padding_index).all()
+
+        if not is_uniform:
+            return _orig_compute(self, query, key, value, attention_mask)
+
+        active_len = common_padding_index.item()
+        S = query.shape[2]
+
+        if active_len == S:
+            out = sageattn(
+                query.contiguous(), key.contiguous(), value.contiguous(),
+                tensor_layout="HND", is_causal=False,
+            )
+            out = out.transpose(1, 2).flatten(2, 3).to(query.dtype)
+            return out
+
+        # Slice to active region, run sage, pad back
+        q_a = query[:, :, :active_len, :].contiguous()
+        k_a = key[:, :, :active_len, :].contiguous()
+        v_a = value[:, :, :active_len, :].contiguous()
+
+        out_a = sageattn(q_a, k_a, v_a, tensor_layout="HND", is_causal=False)
+
+        out = query.new_zeros(query.shape)
+        out[:, :, :active_len, :] = out_a
+        out = out.transpose(1, 2).flatten(2, 3).to(query.dtype)
+        return out
+
+    MotifVideoAttnProcessor2_0._compute_attention = _sage_compute
+    transformer.to(memory_format=torch.channels_last_3d)
+    print("[SageAttention] Enabled (patched _compute_attention + channels_last_3d)")
+
+
 def main():
     args = parse_args()
 
     dtype_map = {"float16": torch.float16, "bfloat16": torch.bfloat16, "float32": torch.float32}
     torch_dtype = dtype_map[args.dtype]
 
-    mode = "I2V" if args.image else "T2V"
-    print(f"[{mode}] Loading model from: {args.model_path}")
+    print(f"[T2V] Loading model from: {args.model_path}")
 
     guider = AdaptiveProjectedGuidance(
         guidance_scale=args.guidance_scale,
         adaptive_projected_guidance_rescale=12.0,
         adaptive_projected_guidance_momentum=0.1,
-        eta=0.0,
         use_original_formulation=True,
+        normalization_dims="spatial",
     )
 
-    pipe = DiffusionPipeline.from_pretrained(
+    pipe = MotifVideoPipeline.from_pretrained(
         args.model_path,
-        custom_pipeline="pipeline_motif_video",
-        trust_remote_code=True,
         torch_dtype=torch_dtype,
         guider=guider,
     )
-    pipe = pipe.to("cuda")
 
-    generator = torch.Generator(device="cuda").manual_seed(args.seed)
+    # Replace scheduler with DPMSolver++ for faster convergence and better quality.
+    # Subclass ignores pipeline-supplied sigmas (PR branch always passes them)
+    # and uses its own flow-matching sigma schedule instead.
+    class _FlowDPMSolver(DPMSolverMultistepScheduler):
+        def set_timesteps(self, num_inference_steps=None, device=None,
+                          sigmas=None, mu=None, timesteps=None):
+            if sigmas is not None and num_inference_steps is None:
+                num_inference_steps = len(sigmas)
+            super().set_timesteps(
+                num_inference_steps=num_inference_steps,
+                device=device, timesteps=timesteps,
+            )
+
+    pipe.scheduler = _FlowDPMSolver(
+        num_train_timesteps=pipe.scheduler.config.get("num_train_timesteps", 1000),
+        algorithm_type="dpmsolver++",
+        solver_order=2,
+        prediction_type="flow_prediction",
+        use_flow_sigmas=True,
+        flow_shift=15.0,
+    )
+
+    # Offload model components to CPU between uses to reduce peak VRAM
+    pipe.enable_model_cpu_offload()
 
-    # Load image for I2V mode
-    image = None
-    if args.image:
-        from PIL import Image
+    if args.use_sage_attention:
+        _enable_sage_attention(pipe.transformer)
 
-        image = Image.open(args.image).convert("RGB")
-        print(f"[I2V] Input image: {args.image} ({image.size[0]}x{image.size[1]})")
+    generator = torch.Generator(device="cuda").manual_seed(args.seed)
 
     print(f"Generating video: {args.width}x{args.height}, {args.num_frames} frames, {args.num_inference_steps} steps")
-    pipe_kwargs = dict(
+    output = pipe(
         prompt=args.prompt,
-        image=image,
+        negative_prompt=args.negative_prompt,
         height=args.height,
         width=args.width,
         num_frames=args.num_frames,
         num_inference_steps=args.num_inference_steps,
-        generator=generator,
         frame_rate=args.fps,
+        use_linear_quadratic_schedule=False,
+        generator=generator,
     )
-    if args.negative_prompt is not None:
-        pipe_kwargs["negative_prompt"] = args.negative_prompt
-
-    output = pipe(**pipe_kwargs)
 
     video_frames = output.frames[0]
     export_to_video(video_frames, args.output, fps=args.fps)

pipeline_motif_video.py

@@ -1,1388 +0,0 @@
-# Copyright 2026 Motif Technologies, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import html
-import inspect
-from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-
-import ftfy
-import numpy as np
-import regex as re
-import torch
-from diffusers import (
-    AdaptiveProjectedGuidance,
-    AutoencoderKLWan,
-    ClassifierFreeGuidance,
-    DiffusionPipeline,
-    DPMSolverMultistepScheduler,
-    FlowMatchEulerDiscreteScheduler,
-    SkipLayerGuidance,
-    UniPCMultistepScheduler,
-)
-from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback
-from diffusers.guiders.adaptive_projected_guidance import MomentumBuffer
-from diffusers.guiders.guider_utils import GuiderOutput
-from diffusers.utils import (
-    BaseOutput,
-    is_torch_xla_available,
-    logging,
-    replace_example_docstring,
-)
-from diffusers.utils.torch_utils import randn_tensor
-from diffusers.video_processor import VideoProcessor
-from einops import rearrange
-from PIL import Image
-from torch import Tensor
-
-from transformers import (
-    BatchEncoding,
-    PreTrainedTokenizerBase,
-    SiglipImageProcessor,
-    T5Gemma2Encoder,
-)
-
-from ._fm_solvers_unipc import FlowUniPCMultistepScheduler
-
-
-if is_torch_xla_available():
-    import torch_xla.core.xla_model as xm
-
-    XLA_AVAILABLE = True
-else:
-    XLA_AVAILABLE = False
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
-    Examples:
-        ```py
-        >>> import torch
-        >>> from diffusers import MotifVideoPipeline
-        >>> from diffusers.utils import export_to_video
-
-        >>> # Load the Motif Video pipeline
-        >>> motif_video_model_id = "MotifTechnologies/Motif-Video"
-        >>> pipe = MotifVideoPipeline.from_pretrained(motif_video_model_id, torch_dtype=torch.bfloat16)
-        >>> pipe.to("cuda")
-
-        >>> prompt = "A woman with long brown hair and light skin smiles at another woman with long blonde hair. The woman with brown hair wears a black jacket and has a small, barely noticeable mole on her right cheek. The camera angle is a close-up, focused on the woman with brown hair's face. The lighting is warm and natural, likely from the setting sun, casting a soft glow on the scene. The scene appears to be real-life footage"
-        >>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"
-
-        >>> video = pipe(
-        ...     prompt=prompt,
-        ...     negative_prompt=negative_prompt,
-        ...     width=640,
-        ...     height=352,
-        ...     num_frames=65,
-        ...     num_inference_steps=50,
-        ... ).frames[0]
-        >>> export_to_video(video, "output.mp4", fps=16)
-        ```
-"""
-
-
-@dataclass
-class MotifVideoPipelineOutput(BaseOutput):
-    r"""
-    Output class for Motif Video pipelines.
-
-    Args:
-        frames (`torch.Tensor`, `np.ndarray`, or List[List[PIL.Image.Image]]):
-            List of video outputs - It can be a nested list of length `batch_size,` with each sub-list containing
-            denoised PIL image sequences of length `num_frames.` It can also be a NumPy array or Torch tensor of shape
-            `(batch_size, num_frames, channels, height, width)`.
-    """
-
-    frames: torch.Tensor
-
-
-"""Video-aware Adaptive Projected Guidance (APG).
-
-Standard APG normalizes over all spatial dimensions [C, T, H, W], which collapses
-temporal variation. This module normalizes over [C, H, W] only, preserving
-per-frame independence.
-"""
-
-
-def video_normalized_guidance(
-    pred_cond: torch.Tensor,
-    pred_uncond: torch.Tensor,
-    guidance_scale: float,
-    momentum_buffer: MomentumBuffer | None = None,
-    eta: float = 1.0,
-    norm_threshold: float = 0.0,
-    use_original_formulation: bool = False,
-) -> torch.Tensor:
-    """APG with video-aware normalization: normalize over [C, H, W], exclude T.
-
-    For 5D input [B, C, T, H, W], dim=[-1, -2, -4] normalizes per-frame (W, H, C),
-    keeping the T dimension independent. For 4D input [B, C, H, W], falls back to
-    standard [-1, -2, -3] behavior.
-    """
-    diff = pred_cond - pred_uncond
-
-    if len(diff.shape) == 5:
-        # [B, C, T, H, W] → normalize over W(-1), H(-2), C(-4), skip T(-3)
-        dim = [-1, -2, -4]
-    else:
-        # [B, C, H, W] → standard behavior
-        dim = [-i for i in range(1, len(diff.shape))]
-
-    if momentum_buffer is not None:
-        momentum_buffer.update(diff)
-        diff = momentum_buffer.running_average
-
-    if norm_threshold > 0:
-        ones = torch.ones_like(diff)
-        diff_norm = diff.norm(p=2, dim=dim, keepdim=True)
-        scale_factor = torch.minimum(ones, norm_threshold / diff_norm)
-        diff = diff * scale_factor
-
-    v0, v1 = diff.double(), pred_cond.double()
-    v1 = torch.nn.functional.normalize(v1, dim=dim)
-    v0_parallel = (v0 * v1).sum(dim=dim, keepdim=True) * v1
-    v0_orthogonal = v0 - v0_parallel
-    diff_parallel, diff_orthogonal = (
-        v0_parallel.type_as(diff),
-        v0_orthogonal.type_as(diff),
-    )
-    normalized_update = diff_orthogonal + eta * diff_parallel
-
-    pred = pred_cond if use_original_formulation else pred_uncond
-    pred = pred + guidance_scale * normalized_update
-
-    return pred
-
-
-class VideoAdaptiveProjectedGuidance(AdaptiveProjectedGuidance):
-    """APG variant that normalizes over [C, H, W] per frame, excluding the T dimension."""
-
-    def forward(self, pred_cond: torch.Tensor, pred_uncond: torch.Tensor | None = None) -> GuiderOutput:
-        pred = None
-
-        if not self._is_apg_enabled():
-            pred = pred_cond
-        else:
-            pred = video_normalized_guidance(
-                pred_cond,
-                pred_uncond,
-                self.guidance_scale,
-                self.momentum_buffer,
-                self.eta,
-                self.adaptive_projected_guidance_rescale,
-                self.use_original_formulation,
-            )
-
-        if self.guidance_rescale > 0.0:
-            from diffusers.guiders.classifier_free_guidance import rescale_noise_cfg
-
-            pred = rescale_noise_cfg(pred, pred_cond, self.guidance_rescale)
-
-        return GuiderOutput(pred=pred, pred_cond=pred_cond, pred_uncond=pred_uncond)
-
-
-# Copied from diffusers.pipelines.flux.pipeline_flux.calculate_shift
-def calculate_shift(
-    image_seq_len,
-    base_seq_len: int = 256,
-    max_seq_len: int = 4096,
-    base_shift: float = 0.5,
-    max_shift: float = 1.15,
-):
-    m = (max_shift - base_shift) / (max_seq_len - base_seq_len)
-    b = base_shift - m * base_seq_len
-    mu = image_seq_len * m + b
-    return mu
-
-
-def get_linear_quadratic_sigmas(
-    num_inference_steps: int,
-    linear_quadratic_emulating_steps: int = 250,
-) -> np.ndarray:
-    """
-    Compute a linear-quadratic sigma schedule for flow matching.
-
-    This schedule combines:
-    - First half: Linear interpolation from high noise to medium noise (slow denoising)
-    - Second half: Quadratic interpolation from medium noise to clean (faster denoising)
-
-    Convention:
-    - sigma=1.0 represents pure noise
-    - sigma=0.0 represents clean image
-    - Output sigmas are in descending order (1.0 → ~0)
-
-    Args:
-        num_inference_steps: Total number of denoising steps (must be even).
-        linear_quadratic_emulating_steps: Controls the slope of linear interpolation.
-            Higher values result in gentler slope in the first half.
-
-    Returns:
-        np.ndarray: Array of sigma values with shape (num_inference_steps,).
-            The scheduler will append a terminal 0.
-
-    Raises:
-        ValueError: If num_inference_steps is not even.
-
-    Reference:
-        Linear-quadratic timestep schedule for improved flow matching inference.
-    """
-    if num_inference_steps % 2 != 0:
-        raise ValueError(
-            f"num_inference_steps must be even for linear-quadratic schedule, but got {num_inference_steps}"
-        )
-
-    steps = num_inference_steps
-    N = linear_quadratic_emulating_steps
-    half_steps = steps // 2
-
-    # First half: linear interpolation from 1 toward 0
-    # Takes first half_steps values from linspace(1, 0, N+1)
-    linear_part = np.linspace(1.0, 0.0, N + 1)[:half_steps]
-
-    # Second half: quadratic interpolation
-    # Formula: x^2 * (half_steps/N - 1) - (half_steps/N - 1)
-    #        = (half_steps/N - 1) * (x^2 - 1)
-    # This maps x=0 to (half_steps/N - 1) * (-1) = 1 - half_steps/N
-    # and maps x=1 to 0
-    x = np.linspace(0.0, 1.0, half_steps + 1)
-    scale_factor = half_steps / N - 1  # negative value
-    quadratic_part = x**2 * scale_factor - scale_factor
-
-    # Concatenate and exclude the last 0 (scheduler appends terminal 0)
-    sigmas = np.concatenate([linear_part, quadratic_part])
-    sigmas = sigmas[:-1]  # Remove trailing 0, scheduler will append it
-
-    return sigmas.astype(np.float32)
-
-
-# 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,
-    sigmas: Optional[List[float]] = None,
-    use_linear_quadratic_schedule: bool = False,
-    linear_quadratic_emulating_steps: int = 250,
-    **kwargs,
-):
-    """
-    Retrieve timesteps from the scheduler.
-
-    Args:
-        scheduler: The noise scheduler to use.
-        num_inference_steps: Number of denoising steps.
-        device: Device to place timesteps on.
-        timesteps: Custom timestep values (mutually exclusive with sigmas).
-        sigmas: Custom sigma values (mutually exclusive with timesteps).
-        use_linear_quadratic_schedule: If True, use linear-quadratic sigma schedule.
-            This overrides the default linear schedule. Requires num_inference_steps
-            to be even.
-        linear_quadratic_emulating_steps: Controls the linear portion slope.
-            Higher values result in gentler slope in the first half. Default: 250.
-        **kwargs: Additional arguments passed to scheduler.set_timesteps().
-
-    Returns:
-        Tuple of (timesteps, num_inference_steps).
-
-    Raises:
-        ValueError: If both timesteps and sigmas are provided, or if
-            use_linear_quadratic_schedule is True but num_inference_steps is odd.
-    """
-    if timesteps is not None and sigmas is not None:
-        raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values")
-
-    # Handle linear-quadratic schedule: compute sigmas if flag is set
-    if use_linear_quadratic_schedule:
-        if sigmas is not None:
-            raise ValueError(
-                "Cannot use both `sigmas` and `use_linear_quadratic_schedule`. "
-                "The linear-quadratic schedule computes sigmas automatically."
-            )
-        if num_inference_steps is None:
-            raise ValueError("`num_inference_steps` must be provided when using `use_linear_quadratic_schedule`.")
-        sigmas = get_linear_quadratic_sigmas(
-            num_inference_steps=num_inference_steps,
-            linear_quadratic_emulating_steps=linear_quadratic_emulating_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)
-    elif sigmas is not None:
-        accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys())
-        if not accept_sigmas:
-            raise ValueError(
-                f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
-                f" sigmas schedules. Please check whether you are using the correct scheduler."
-            )
-        scheduler.set_timesteps(sigmas=sigmas, 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 basic_clean(text):
-    text = ftfy.fix_text(text)
-    text = html.unescape(html.unescape(text))
-    return text.strip()
-
-
-def whitespace_clean(text):
-    text = re.sub(r"\s+", " ", text)
-    text = text.strip()
-    return text
-
-
-def prompt_clean(text):
-    text = whitespace_clean(basic_clean(text))
-    return text
-
-
-class MotifVideoPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for text-to-video generation using MotifVideoTransformer.
-
-    Args:
-        transformer ([`MotifVideoTransformer3DModel`]):
-            Conditional Transformer architecture to denoise the encoded video latents.
-        scheduler ([`FlowMatchEulerDiscreteScheduler`]):
-            A scheduler to be used in combination with `transformer` to denoise the encoded video latents.
-        vae ([`AutoencoderKLWan`]):
-            Variational Auto-Encoder (VAE) Model to encode and decode videos to and from latent representations.
-        text_encoder ([`T5Gemma2Encoder`]):
-            Primary text encoder for encoding text prompts into embeddings.
-        tokenizer ([`PreTrainedTokenizerBase`]):
-            Tokenizer corresponding to the primary text encoder.
-        guider ([`ClassifierFreeGuidance`] or [`SkipLayerGuidance`] or [`AdaptiveProjectedGuidance`] or [`VideoAdaptiveProjectedGuidance`], *optional*):
-            The guidance method to use. If `None`, it defaults to `ClassifierFreeGuidance()`.
-    """
-
-    model_cpu_offload_seq = "text_encoder->transformer->vae"
-    _optional_components = ["feature_extractor"]
-    _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
-
-    def __init__(
-        self,
-        scheduler: Union[
-            FlowMatchEulerDiscreteScheduler,
-            DPMSolverMultistepScheduler,
-            UniPCMultistepScheduler,
-            FlowUniPCMultistepScheduler,
-        ],
-        vae: AutoencoderKLWan,
-        text_encoder: T5Gemma2Encoder,
-        tokenizer: PreTrainedTokenizerBase,
-        transformer,
-        guider: Optional[
-            Union[
-                ClassifierFreeGuidance,
-                SkipLayerGuidance,
-                AdaptiveProjectedGuidance,
-                VideoAdaptiveProjectedGuidance,
-            ]
-        ] = None,
-        feature_extractor: Optional[SiglipImageProcessor] = None,
-    ):
-        super().__init__()
-
-        self.guider = ClassifierFreeGuidance() if guider is None else guider
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            transformer=transformer,
-            scheduler=scheduler,
-            feature_extractor=feature_extractor,
-        )
-
-        self.vae_scale_factor_temporal = self.vae.config.scale_factor_temporal if getattr(self, "vae", None) else 4
-        self.vae_scale_factor_spatial = self.vae.config.scale_factor_spatial if getattr(self, "vae", None) else 8
-
-        self.transformer_spatial_patch_size = (
-            self.transformer.config.patch_size if getattr(self, "transformer", None) is not None else 2
-        )
-        self.transformer_temporal_patch_size = (
-            self.transformer.config.patch_size_t if getattr(self, "transformer") is not None else 1
-        )
-
-        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_scale_factor_spatial)
-        self.tokenizer_max_length = (
-            self.tokenizer.model_max_length if getattr(self, "tokenizer", None) is not None else 512
-        )
-
-    def _get_default_embeds(
-        self,
-        text_encoder,
-        tokenizer: PreTrainedTokenizerBase,
-        prompt: Union[str, List[str]],
-        max_sequence_length: int = 512,
-        device: Optional[torch.device] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        dtype = dtype or text_encoder.dtype
-
-        text_inputs = tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=max_sequence_length,
-            truncation=True,
-            add_special_tokens=True,
-            return_attention_mask=True,
-            return_tensors="pt",
-        )
-        text_inputs = BatchEncoding(
-            {k: v.to(device) if isinstance(v, torch.Tensor) else v for k, v in text_inputs.items()}
-        )
-
-        prompt_embeds = text_encoder(**text_inputs)[0]
-        prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
-
-        return prompt_embeds, text_inputs.attention_mask
-
-    def _average_pool(self, last_hidden_states: Tensor, attention_mask: Tensor) -> Tensor:
-        last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0)
-        denom = attention_mask.sum(dim=1, keepdim=True).clamp(min=1)  # avoid div by zero
-        return last_hidden.sum(dim=1) / denom
-
-    def _get_prompt_embeds(
-        self,
-        text_encoder: T5Gemma2Encoder,
-        tokenizer: PreTrainedTokenizerBase,
-        prompt: Union[str, List[str]] | None = None,
-        num_videos_per_prompt: int = 1,
-        max_sequence_length: int = 512,
-        device: Optional[torch.device] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        device = device or self._execution_device
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-
-        prompt_embeds_kwargs = {
-            "text_encoder": text_encoder,
-            "tokenizer": tokenizer,
-            "prompt": prompt,
-            "max_sequence_length": max_sequence_length,
-            "device": device,
-            "dtype": dtype,
-        }
-        # When enable_model_cpu_offload() is active, the accelerate forward hook is on text_encoder (parent). Moving the encoder to the execution device explicitly ensures inputs and
-        # weights are on the same device. The parent's offload hook will move text_encoder back to CPU after
-        # the next component claims the GPU.
-        if next(text_encoder.parameters()).device != torch.device(device):
-            text_encoder.to(device)
-        prompt_embeds, prompt_attention_mask = self._get_default_embeds(**prompt_embeds_kwargs)
-
-        pooled_prompt_embeds = self._average_pool(prompt_embeds, prompt_attention_mask)
-
-        return prompt_embeds, prompt_attention_mask, pooled_prompt_embeds
-
-    # Keep encode_prompt structure, uses _get_prompt_embeds internally
-    def encode_prompt(
-        self,
-        prompt: Union[str, List[str]],
-        num_videos_per_prompt: int = 1,
-        prompt_embeds: Optional[torch.Tensor] = None,
-        pooled_prompt_embeds: Optional[torch.Tensor] = None,
-        prompt_attention_mask: Optional[torch.Tensor] = None,
-        max_sequence_length: int = 512,
-        device: Optional[torch.device] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> Tuple[
-        torch.Tensor,
-        torch.Tensor,
-        torch.Tensor,
-    ]:
-        device = device or self._execution_device
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-        if prompt is not None:
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        prompt_embeds_kwargs = {
-            "device": device,
-            "dtype": dtype,
-        }
-
-        if prompt_embeds is None:
-            prompt_embeds, prompt_attention_mask, pooled_prompt_embeds = self._get_prompt_embeds(
-                text_encoder=self.text_encoder,
-                tokenizer=self.tokenizer,
-                prompt=prompt,
-                max_sequence_length=max_sequence_length,
-                **prompt_embeds_kwargs,
-            )
-
-        # Compute actual (non-padding) token count for batch=1 Flash Attention trimming in __call__
-        actual_seq_len = None
-        if batch_size == 1 and prompt_attention_mask is not None:
-            actual_seq_len = int(prompt_attention_mask.sum(dim=-1).max().item())
-
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        seq_len = prompt_embeds.shape[1]
-        prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
-        prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, seq_len, -1)
-
-        if pooled_prompt_embeds is not None:
-            pooled_prompt_embeds = pooled_prompt_embeds.repeat_interleave(num_videos_per_prompt, dim=0)
-
-        if prompt_attention_mask is not None:
-            prompt_attention_mask = prompt_attention_mask.bool()
-            prompt_attention_mask = prompt_attention_mask.view(batch_size, -1)
-            prompt_attention_mask = prompt_attention_mask.repeat_interleave(num_videos_per_prompt, dim=0)
-
-        return (
-            prompt_embeds,
-            pooled_prompt_embeds,
-            prompt_attention_mask,
-            actual_seq_len,
-        )
-
-    @property
-    def vision_encoder(self):
-        """Get the vision encoder from T5Gemma2.
-
-        T5Gemma2 has vision_tower.vision_model structure.
-        Will raise AttributeError if not available.
-        """
-        return self.text_encoder.vision_tower.vision_model
-
-    def encode_image(
-        self,
-        image: Image.Image,
-        batch_size: int = 1,
-        device: Optional[torch.device] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> torch.Tensor:
-        """Encode image to embeddings using SigLIP vision encoder."""
-        device = device or self._execution_device
-        dtype = dtype or self.transformer.dtype
-
-        image_embeds = self._get_image_embeds(
-            image_encoder=self.vision_encoder,
-            feature_extractor=self.feature_extractor,
-            image=image,
-            device=device,
-        )
-        image_embeds = image_embeds.repeat(batch_size, 1, 1)
-        return image_embeds.to(device=device, dtype=dtype)
-
-    @staticmethod
-    def _get_image_embeds(
-        image_encoder,
-        feature_extractor: SiglipImageProcessor,
-        image,
-        device: torch.device,
-    ) -> torch.Tensor:
-        """Helper to encode single image with SigLIP.
-
-        Args:
-            image_encoder: The SigLIP vision encoder model.
-            feature_extractor: SiglipImageProcessor for preprocessing.
-            image: Can be either:
-                - PIL.Image.Image: Will be preprocessed by feature_extractor
-                - torch.Tensor: Assumed to be in [0, 1] range, will be normalized and passed to encoder
-            device: Device to place tensors on.
-
-        Returns:
-            Image embeddings from the vision encoder.
-        """
-        image_encoder_dtype = next(image_encoder.parameters()).dtype
-
-        if isinstance(image, torch.Tensor):
-            image = feature_extractor.preprocess(
-                images=image.float(),
-                do_resize=True,
-                do_rescale=False,
-                do_normalize=True,
-                do_convert_rgb=True,
-                return_tensors="pt",
-            )
-        else:
-            image = feature_extractor.preprocess(
-                images=image,
-                do_resize=True,
-                do_rescale=False,
-                do_normalize=True,
-                do_convert_rgb=True,
-                return_tensors="pt",
-            )
-
-        image = image.to(device, dtype=image_encoder_dtype)
-        return image_encoder(**image).last_hidden_state
-
-    @torch.compiler.disable
-    def _prepare_first_frame_conditioning(
-        self,
-        video: torch.Tensor,
-        latents: torch.Tensor,
-        use_conditioning: bool,
-        generator: Optional[torch.Generator] = None,
-    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]:
-        """Prepare first frame conditioning tensors.
-
-        This method implements batch-level conditioning where entire
-        batches are either I2V (all samples conditioned) or T2V (no conditioning). This
-        prevents mode confusion within batches.
-
-        For I2V mode:
-        1. Extract and VAE-encode first frame from video
-        2. Create latent_condition by repeating first frame across time (frame 0 only)
-        3. Create latent_mask with 1.0 at frame 0
-        4. Get image_embeds from vision encoder
-
-        For T2V mode:
-        1. Pad with zeros for latent_condition and latent_mask
-
-        Args:
-            video: Input video tensor [batch_size, frames, channels, height, width] in [-1, 1]
-            latents: Latents [batch_size, lantent_channels, latent_num_frames, latent_height, latent_width]
-            use_conditioning: Whether to use first-frame conditioning (True for I2V, False for T2V)
-            generator: Optional random number generator for reproducibility
-
-        Returns:
-            Tuple of (latent_condition, latent_mask, image_embeds).
-            - latent_condition: [B, C, F, H, W] conditioning signal (zeros for T2V)
-            - latent_mask: [B, 1, F, H, W] binary mask (zeros for T2V)
-            - image_embeds: [B, N, D] image embeddings from vision encoder or None for T2V
-        """
-        batch_size, lantent_channels, latent_num_frames, latent_height, latent_width = latents.shape
-        device = latents.device
-        dtype = latents.dtype
-
-        # Determine if we should use conditioning
-        use_conditioning = use_conditioning and (latent_num_frames > 1)
-
-        # Initialize conditioning tensors
-        latent_condition = torch.zeros(
-            batch_size,
-            lantent_channels,
-            latent_num_frames,
-            latent_height,
-            latent_width,
-            device=device,
-            dtype=dtype,
-        )
-        latent_mask = torch.zeros(
-            batch_size,
-            1,
-            latent_num_frames,
-            latent_height,
-            latent_width,
-            device=device,
-            dtype=dtype,
-        )
-        image_embeds = None
-
-        if use_conditioning:
-            with torch.no_grad():
-                # Encode first frame for latent_condition
-                first_frame_latents = self.vae.encode(
-                    rearrange(video[:, 0:1], "b f c h w -> b c f h w")
-                ).latent_dist.sample(generator=generator)
-            first_frame_latents = self._normalize_latents(
-                latents=first_frame_latents,
-                latents_mean=self.vae.config.latents_mean,
-                latents_std=self.vae.config.latents_std,
-            )
-
-            # Create latent_condition by repeating first frame across time
-            latent_condition = first_frame_latents.repeat(1, 1, latent_num_frames, 1, 1)
-            latent_condition[:, :, 1:, :, :] = 0
-
-            # latent_mask: 1.0 at frame 0, 0.0 elsewhere
-            latent_mask[:, :, 0] = 1.0
-
-            # image_embeds from vision encoder
-            first_frame_vision = video[:, 0]  # [B, C, H, W]
-            first_frame_vision = ((first_frame_vision + 1) / 2).clamp(0, 1)
-
-            with torch.no_grad():
-                image_embeds = self._get_image_embeds(
-                    image_encoder=self.vision_encoder,
-                    feature_extractor=self.feature_extractor,
-                    image=first_frame_vision,
-                    device=device,
-                )
-
-        return latent_condition, latent_mask, image_embeds
-
-    def check_inputs(
-        self,
-        prompt,
-        negative_prompt,
-        height,
-        width,
-        batch_size,
-        callback_on_step_end_tensor_inputs=None,
-        prompt_embeds=None,
-        negative_prompt_embeds=None,
-        prompt_attention_mask=None,
-        negative_prompt_attention_mask=None,
-    ):
-        # Resolution must be divisible by VAE scale factor * transformer patch size
-        # (e.g. 8 * 2 = 16 for default config) to avoid latent/patch dimension mismatch.
-        spatial_divisor = self.vae_scale_factor_spatial * self.transformer_spatial_patch_size
-        if height % spatial_divisor != 0 or width % spatial_divisor != 0:
-            raise ValueError(
-                f"`height` and `width` have to be divisible by {spatial_divisor} "
-                f"(vae_scale={self.vae_scale_factor_spatial} * patch_size={self.transformer_spatial_patch_size}) "
-                f"but are {height} and {width}."
-            )
-
-        if callback_on_step_end_tensor_inputs is not None and not all(
-            k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
-        ):
-            raise ValueError(
-                f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
-            )
-
-        if prompt is not None and prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
-                " only forward one of the two."
-            )
-        elif prompt is None and prompt_embeds is None:
-            raise ValueError(
-                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
-            )
-        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        # Validate negative_prompt: must be None, str, or list with matching batch_size
-        if negative_prompt is not None:
-            if not isinstance(negative_prompt, (str, list)):
-                raise ValueError(f"`negative_prompt` has to be of type `str` or `list` but is {type(negative_prompt)}")
-            if isinstance(negative_prompt, list) and len(negative_prompt) != batch_size:
-                raise ValueError(
-                    f"`negative_prompt` list length ({len(negative_prompt)}) must match batch_size ({batch_size})."
-                )
-
-        if prompt_embeds is not None and prompt_attention_mask is None:
-            raise ValueError("Must provide `prompt_attention_mask` when specifying `prompt_embeds`.")
-
-        if negative_prompt_embeds is not None and negative_prompt_attention_mask is None:
-            raise ValueError("Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.")
-
-        if prompt_embeds is not None and negative_prompt_embeds is not None:
-            if prompt_embeds.shape != negative_prompt_embeds.shape:
-                raise ValueError(
-                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
-                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
-                    f" {negative_prompt_embeds.shape}."
-                )
-            if prompt_attention_mask.shape != negative_prompt_attention_mask.shape:
-                raise ValueError(
-                    "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when passed directly, but"
-                    f" got: `prompt_attention_mask` {prompt_attention_mask.shape} != `negative_prompt_attention_mask`"
-                    f" {negative_prompt_attention_mask.shape}."
-                )
-
-    def _prepare_negative_prompt(
-        self,
-        negative_prompt: Optional[Union[str, List[str]]],
-        batch_size: int,
-    ) -> List[str]:
-        """
-        Prepare negative_prompt to match batch_size.
-
-        Args:
-            negative_prompt: None, a single string, or a list of strings matching batch_size.
-            batch_size: The number of prompts in the batch.
-
-        Returns:
-            A list of negative prompts with length equal to batch_size.
-        """
-        if negative_prompt is None:
-            return [""] * batch_size
-        if isinstance(negative_prompt, str):
-            return [negative_prompt] * batch_size
-        return negative_prompt
-
-    @staticmethod
-    def _pack_latents(latents: torch.Tensor, patch_size: int = 1, patch_size_t: int = 1) -> torch.Tensor:
-        batch_size, num_channels, num_frames, height, width = latents.shape
-        post_patch_num_frames = num_frames // patch_size_t
-        post_patch_height = height // patch_size
-        post_patch_width = width // patch_size
-        latents = latents.reshape(
-            batch_size,
-            -1,
-            post_patch_num_frames,
-            patch_size_t,
-            post_patch_height,
-            patch_size,
-            post_patch_width,
-            patch_size,
-        )
-        latents = latents.permute(0, 2, 4, 6, 1, 3, 5, 7).flatten(4, 7).flatten(1, 3)
-        return latents
-
-    @staticmethod
-    def _unpack_latents(
-        latents: torch.Tensor,
-        num_frames: int,
-        height: int,
-        width: int,
-        patch_size: int = 1,
-        patch_size_t: int = 1,
-    ) -> torch.Tensor:
-        batch_size = latents.size(0)
-        latents = latents.reshape(
-            batch_size,
-            num_frames,
-            height,
-            width,
-            -1,
-            patch_size_t,
-            patch_size,
-            patch_size,
-        )
-        latents = latents.permute(0, 4, 1, 5, 2, 6, 3, 7).flatten(6, 7).flatten(4, 5).flatten(2, 3)
-        return latents
-
-    @staticmethod
-    def _normalize_latents(
-        latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor
-    ) -> torch.Tensor:
-        # Normalize latents across the channel dimension [B, C, F, H, W]
-        latents_mean = torch.tensor(latents_mean).view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents_std = torch.tensor(latents_std).view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents = (latents - latents_mean) / latents_std
-        return latents
-
-    @staticmethod
-    def _denormalize_latents(
-        latents: torch.Tensor, latents_mean: torch.Tensor, latents_std: torch.Tensor
-    ) -> torch.Tensor:
-        # Denormalize latents across the channel dimension [B, C, F, H, W]
-        latents_mean = torch.tensor(latents_mean).view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents_std = torch.tensor(latents_std).view(1, -1, 1, 1, 1).to(latents.device, latents.dtype)
-        latents = latents * latents_std + latents_mean
-        return latents
-
-    def prepare_latents(
-        self,
-        batch_size: int = 1,
-        num_channels_latents: int = 16,
-        height: int = 352,
-        width: int = 640,
-        num_frames: int = 65,
-        dtype: Optional[torch.dtype] = None,
-        device: Optional[torch.device] = None,
-        generator: Optional[torch.Generator] = None,
-        latents: Optional[torch.Tensor] = None,
-    ) -> torch.Tensor:
-        if latents is not None:
-            return latents.to(device=device, dtype=dtype)
-
-        shape = (
-            batch_size,
-            num_channels_latents,
-            (num_frames - 1) // self.vae_scale_factor_temporal + 1,
-            height // self.vae_scale_factor_spatial,
-            width // self.vae_scale_factor_spatial,
-        )
-
-        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."
-            )
-
-        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        return latents
-
-    @property
-    def num_timesteps(self):
-        return self._num_timesteps
-
-    @property
-    def current_timestep(self):
-        return self._current_timestep
-
-    @property
-    def attention_kwargs(self):
-        return self._attention_kwargs
-
-    @property
-    def interrupt(self):
-        return self._interrupt
-
-    @torch.no_grad()
-    @replace_example_docstring(EXAMPLE_DOC_STRING)
-    def __call__(
-        self,
-        prompt: Union[str, List[str]] | None = None,
-        image=None,
-        negative_prompt: Optional[
-            Union[str, List[str]]
-        ] = "text overlay, graphic overlay, watermark, logo, subtitles, timestamp, broadcast graphics, UI elements, random letters, frozen pose, rigid, static expression, jerky motion, mechanical motion, discontinuous motion, flat framing, depthless, dull lighting, monotone, crushed shadows, blown-out highlights, shifting background, fading background, poor continuity, identity drift, deformation, flickering, ghosting, smearing, duplication, mutated proportions, inconsistent clothing, flat colors, desaturated, tonally compressed, poor background separation, exposure shift, uneven brightness, color balance shift",
-        height: int = 736,
-        width: int = 1280,
-        num_frames: int = 121,
-        frame_rate: int = 24,
-        num_inference_steps: int = 50,
-        timesteps: List[int] | None = None,
-        use_linear_quadratic_schedule: bool = False,
-        linear_quadratic_emulating_steps: int = 250,
-        num_videos_per_prompt: Optional[int] = 1,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        latents: Optional[torch.Tensor] = None,
-        prompt_embeds: Optional[torch.Tensor] = None,
-        pooled_prompt_embeds: Optional[torch.Tensor] = None,
-        prompt_attention_mask: Optional[torch.Tensor] = None,
-        negative_prompt_embeds: Optional[torch.Tensor] = None,
-        negative_pooled_prompt_embeds: Optional[torch.Tensor] = None,
-        negative_prompt_attention_mask: Optional[torch.Tensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        attention_kwargs: Optional[Dict[str, Any]] = None,
-        callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
-        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
-        max_sequence_length: int = 512,
-        use_attention_mask: bool = True,
-        vae_batch_size: int | None = None,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`.
-                instead.
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. If not defined, one has to pass
-                `negative_prompt_embeds` instead. Ignored when not using guidance.
-            height (`int`, defaults to `352`):
-                The height in pixels of the generated image.
-            width (`int`, defaults to `640`):
-                The width in pixels of the generated image.
-            num_frames (`int`, defaults to `65`):
-                The number of video frames to generate
-            frame_rate (`int`, defaults to `25`):
-                Frame rate for the output video.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality video at the
-                expense of slower inference.
-            timesteps (`List[int]`, *optional*):
-                Custom timesteps to use for the denoising process.
-            use_linear_quadratic_schedule (`bool`, defaults to `True`):
-                Whether to use a linear-quadratic sigma schedule instead of the default linear schedule.
-                This schedule combines linear interpolation in the first half (slow denoising at high noise)
-                with quadratic interpolation in the second half (faster denoising toward clean image).
-                Requires `num_inference_steps` to be even.
-            linear_quadratic_emulating_steps (`int`, defaults to `250`):
-                Controls the slope of linear interpolation in the first half of the linear-quadratic schedule.
-                Higher values result in a gentler slope. Only used when `use_linear_quadratic_schedule=True`.
-            num_videos_per_prompt (`int`, *optional*, defaults to 1):
-                The number of videos to generate per prompt.
-            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
-                PyTorch Generator object(s) for deterministic generation.
-            latents (`torch.Tensor`, *optional*):
-                Pre-generated noisy latents.
-            prompt_embeds (`torch.Tensor`, *optional*):
-                Pre-generated text embeddings.
-            pooled_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting.
-                If not provided, pooled text embeddings will be generated from `prompt` input argument.
-            prompt_attention_mask (`torch.Tensor`, *optional*):
-                Pre-generated attention mask for text embeddings.
-            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative text embeddings.
-            negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
-                weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt`
-                input argument.
-            negative_prompt_attention_mask (`torch.FloatTensor`, *optional*):
-                Pre-generated attention mask for negative text embeddings.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format ("pil" or "np").
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether to return a `MotifVideoPipelineOutput`.
-            attention_kwargs (`dict`, *optional*):
-                Arguments passed to the attention processor.
-            callback_on_step_end (`Callable`, *optional*):
-                Callback function called at the end of each step.
-            callback_on_step_end_tensor_inputs (`List`, *optional*):
-                Tensors to include in the callback.
-            max_sequence_length (`int` defaults to `512`):
-                Maximum sequence length for the tokenizer.
-
-        Examples:
-
-        Returns:
-            [`~pipelines.motif_video.MotifVideoPipelineOutput`] or `tuple`:
-                If `return_dict` is `True`, returns [`~pipelines.motif_video.MotifVideoPipelineOutput`],
-                otherwise returns a tuple where the first element is a list of generated video frames.
-        """
-
-        if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)):
-            callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs
-
-        # 1. Define call parameters (batch_size needed for check_inputs)
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        # 2. Check inputs. Raise error if not correct
-        self.check_inputs(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            batch_size=batch_size,
-            callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-        )
-
-        self._attention_kwargs = attention_kwargs
-        self._interrupt = False
-        self._current_timestep = None
-
-        # Auto-upgrade AdaptiveProjectedGuidance to VideoAdaptiveProjectedGuidance
-        # for video generation. Video-aware APG normalizes per-frame [C,H,W] instead
-        # of collapsing the temporal axis, preserving motion quality.
-        if type(self.guider) is AdaptiveProjectedGuidance:
-            self.guider = VideoAdaptiveProjectedGuidance(
-                guidance_scale=self.guider.guidance_scale,
-                adaptive_projected_guidance_rescale=self.guider.adaptive_projected_guidance_rescale,
-                adaptive_projected_guidance_momentum=self.guider.adaptive_projected_guidance_momentum,
-                eta=self.guider.eta,
-                use_original_formulation=self.guider.use_original_formulation,
-            )
-
-        device = self._execution_device
-
-        # 3. Prepare text embeddings
-        prompt_embeds, pooled_prompt_embeds, prompt_attention_mask, pos_actual_len = self.encode_prompt(
-            prompt=prompt,
-            num_videos_per_prompt=num_videos_per_prompt,
-            prompt_embeds=prompt_embeds,
-            pooled_prompt_embeds=pooled_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            max_sequence_length=max_sequence_length,
-            device=device,
-        )
-
-        if not self.guider._enabled and pos_actual_len is not None:
-            prompt_embeds = prompt_embeds[:, :pos_actual_len, :]
-            prompt_attention_mask = None
-
-        if self.guider._enabled:
-            negative_prompt = self._prepare_negative_prompt(negative_prompt, batch_size)
-            (
-                negative_prompt_embeds,
-                negative_pooled_prompt_embeds,
-                negative_prompt_attention_mask,
-                neg_actual_len,
-            ) = self.encode_prompt(
-                prompt=negative_prompt,
-                num_videos_per_prompt=num_videos_per_prompt,
-                prompt_embeds=negative_prompt_embeds,
-                pooled_prompt_embeds=negative_pooled_prompt_embeds,
-                prompt_attention_mask=negative_prompt_attention_mask,
-                max_sequence_length=max_sequence_length,
-                device=device,
-            )
-
-            # Trim each to its own actual length — guider runs pos/neg in separate loop iterations,
-            # so different seq lengths are fine. No padding embeddings attend without mask.
-            if pos_actual_len is not None and neg_actual_len is not None:
-                prompt_embeds = prompt_embeds[:, :pos_actual_len, :]
-                negative_prompt_embeds = negative_prompt_embeds[:, :neg_actual_len, :]
-                prompt_attention_mask = None
-                negative_prompt_attention_mask = None
-
-        num_channels_latents = self.vae.config.z_dim
-        latents = self.prepare_latents(
-            batch_size * num_videos_per_prompt,
-            num_channels_latents,
-            height,
-            width,
-            num_frames,
-            self.transformer.dtype,
-            device,
-            generator,
-            latents,
-        )
-
-        # 4.5 Preprocess image for I2V conditioning
-        if image is not None:
-            from PIL import Image as PILImage
-
-            if isinstance(image, PILImage.Image):
-                image = image.convert("RGB").resize((width, height), PILImage.LANCZOS)
-                image = torch.from_numpy(np.array(image)).permute(2, 0, 1).float() / 255.0
-                image = image * 2.0 - 1.0  # [0,1] -> [-1,1]
-                image = image.unsqueeze(0)  # [1, C, H, W]
-            # Handle [C, H, W] -> [1, C, H, W]
-            if image.dim() == 3:
-                image = image.unsqueeze(0)
-            # [B, C, H, W] -> [B, 1, C, H, W] for video format
-            if image.dim() == 4:
-                image = image.unsqueeze(1)
-            image = image.to(device=device, dtype=self.vae.dtype)
-
-        # 5. Prepare timesteps (including mu calculation)
-
-        # Recalculate latent dims based on VAE for mu calculation
-        latent_height = height // self.vae_scale_factor_spatial
-        latent_width = width // self.vae_scale_factor_spatial
-        latent_num_frames = (num_frames - 1) // self.vae_scale_factor_temporal + 1
-
-        # Calculate sequence length based on *packed* dimensions if transformer uses packing
-        # Packed dims: H/patch, W/patch, F/patch_t
-        packed_latent_height = latent_height // self.transformer_spatial_patch_size
-        packed_latent_width = latent_width // self.transformer_spatial_patch_size
-        packed_latent_num_frames = latent_num_frames // self.transformer_temporal_patch_size
-        video_sequence_length = packed_latent_num_frames * packed_latent_height * packed_latent_width
-
-        # Compute sigmas: use linear-quadratic schedule if enabled, otherwise default linear
-        _is_flow_multistep = isinstance(
-            self.scheduler,
-            (
-                DPMSolverMultistepScheduler,
-                UniPCMultistepScheduler,
-                FlowUniPCMultistepScheduler,
-            ),
-        )
-
-        # Compute mu once, shared by both branches (required by FlowUniPCMultistepScheduler)
-        mu = calculate_shift(
-            video_sequence_length,
-            self.scheduler.config.get("base_image_seq_len", 256),
-            self.scheduler.config.get("max_image_seq_len", 4096),
-            self.scheduler.config.get("base_shift", 0.5),
-            self.scheduler.config.get("max_shift", 1.15),
-        )
-
-        if _is_flow_multistep:
-            # DPMSolver/UniPC manage their own sigma schedule via use_flow_sigmas + flow_shift.
-            # Pass mu for dynamic shifting support (required by FlowUniPCMultistepScheduler).
-            timesteps, num_inference_steps = retrieve_timesteps(
-                self.scheduler,
-                num_inference_steps,
-                device,
-                timesteps,
-                mu=mu,
-            )
-        else:
-            if use_linear_quadratic_schedule:
-                # Linear-quadratic schedule computes sigmas internally in retrieve_timesteps
-                sigmas = None
-            else:
-                sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps)
-
-            timesteps, num_inference_steps = retrieve_timesteps(
-                self.scheduler,
-                num_inference_steps,
-                device,
-                timesteps,
-                sigmas=sigmas,
-                use_linear_quadratic_schedule=use_linear_quadratic_schedule,
-                linear_quadratic_emulating_steps=linear_quadratic_emulating_steps,
-                mu=mu,
-            )
-
-        # Get conditioning tensors
-        latent_condition, latent_mask, image_embeds = self._prepare_first_frame_conditioning(
-            image,
-            latents,
-            use_conditioning=image is not None,
-            generator=generator,
-        )
-
-        num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0)
-        self._num_timesteps = len(timesteps)
-
-        # 6. Denoising loop
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                if self.interrupt:
-                    continue
-
-                self._current_timestep = t
-
-                # Concatenate current latents with conditioning for this timestep
-                # [latents | latent_condition | latent_mask]
-                hidden_states = torch.cat([latents, latent_condition, latent_mask], dim=1)
-
-                # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
-                timestep = t.expand(latents.shape[0])
-
-                # Step 1: Collect model inputs needed for the guidance method
-                # conditional inputs should always be first element in the tuple
-                guider_inputs = {
-                    "encoder_hidden_states": (prompt_embeds, negative_prompt_embeds),
-                }
-                if use_attention_mask and prompt_attention_mask is not None:
-                    guider_inputs["encoder_attention_mask"] = (
-                        prompt_attention_mask,
-                        negative_prompt_attention_mask,
-                    )
-                if self.transformer.config.pooled_projection_dim is not None:
-                    guider_inputs["pooled_projections"] = (
-                        pooled_prompt_embeds,
-                        negative_pooled_prompt_embeds,
-                    )
-                if image_embeds is not None:
-                    guider_inputs["image_embeds"] = (image_embeds, image_embeds)
-
-                # Step 2: Update guider's internal state for this denoising step
-                self.guider.set_state(step=i, num_inference_steps=num_inference_steps, timestep=t)
-                # Sigma injection for guiders that support sigma-based gating
-                # (Kynkäänniemi 2024). Must precede `prepare_inputs` because
-                # `num_conditions` → `_is_cfg_enabled()` reads `_current_sigma`.
-                # Duck-typed so diffusers-native guiders are unaffected; guard
-                # on scheduler too since some schedulers don't expose `sigmas`.
-                if hasattr(self.guider, "_current_sigma") and hasattr(self.scheduler, "sigmas"):
-                    self.guider._current_sigma = float(self.scheduler.sigmas[i])
-
-                # Step 3: Prepare batched model inputs based on the guidance method
-                # The guider splits model inputs into separate batches for conditional/unconditional predictions.
-                # For CFG with guider_inputs = {"encoder_hidden_states": (prompt_embeds, negative_prompt_embeds)}:
-                # you will get a guider_state with two batches:
-                #   guider_state = [
-                #       {"encoder_hidden_states": prompt_embeds, "__guidance_identifier__": "pred_cond"},      # conditional batch
-                #       {"encoder_hidden_states": negative_prompt_embeds, "__guidance_identifier__": "pred_uncond"},  # unconditional batch
-                #   ]
-                # Other guidance methods may return 1 batch (no guidance) or 3+ batches (e.g., PAG, APG).
-                guider_state = self.guider.prepare_inputs(guider_inputs)
-
-                # Step 4: Run the denoiser for each batch
-                # Each batch in guider_state represents a different conditioning (conditional, unconditional, etc.).
-                # We run the model once per batch and store the noise prediction in guider_state_batch.noise_pred.
-                for guider_state_batch in guider_state:
-                    self.guider.prepare_models(self.transformer)
-
-                    # Extract conditioning kwargs for this batch (e.g., encoder_hidden_states)
-                    cond_kwargs = {
-                        input_name: getattr(guider_state_batch, input_name) for input_name in guider_inputs.keys()
-                    }
-
-                    tread_disabled = getattr(self.guider, "_current_tread_disabled", False)
-
-                    # Override TREAD selection ratio per batch if the guider provides one
-                    selection_ratio = getattr(self.guider, "_current_selection_ratio", None)
-                    tread_mixin = getattr(self.transformer, "_inference_tread_mixin", None)
-                    if (
-                        selection_ratio is not None
-                        and tread_mixin is not None
-                        and tread_mixin._tread_route is not None
-                    ):
-                        tread_mixin._tread_route["sel"] = selection_ratio
-
-                    # e.g. "pred_cond"/"pred_uncond"
-                    context_name = getattr(guider_state_batch, self.guider._identifier_key)
-                    with self.transformer.cache_context(context_name):
-                        # Run denoiser and store noise prediction in this batch
-
-                        noise_pred = self.transformer(
-                            hidden_states=hidden_states,
-                            timestep=timestep,
-                            attention_kwargs=self.attention_kwargs,
-                            return_dict=False,
-                            tread_disabled=tread_disabled,
-                            **cond_kwargs,
-                        )[0].clone()
-
-                        guider_state_batch.noise_pred = noise_pred
-                    # Cleanup model (e.g., remove hooks)
-                    self.guider.cleanup_models(self.transformer)
-
-                # Step 5: Combine predictions using the guidance method
-                # The guider takes all noise predictions from guider_state and combines them according to the guidance algorithm.
-                # Continuing the CFG example, the guider receives:
-                #   guider_state = [
-                #       {"encoder_hidden_states": prompt_embeds, "noise_pred": noise_pred_cond, "__guidance_identifier__": "pred_cond"},      # batch 0
-                #       {"encoder_hidden_states": negative_prompt_embeds, "noise_pred": noise_pred_uncond, "__guidance_identifier__": "pred_uncond"},  # batch 1
-                #   ]
-                # And extracts predictions using the __guidance_identifier__:
-                #   pred_cond = guider_state[0]["noise_pred"]      # extracts noise_pred_cond
-                #   pred_uncond = guider_state[1]["noise_pred"]    # extracts noise_pred_uncond
-                # Then applies CFG formula:
-                #   noise_pred = pred_uncond + guidance_scale * (pred_cond - pred_uncond)
-                # Returns GuiderOutput(pred=noise_pred, pred_cond=pred_cond, pred_uncond=pred_uncond)
-                noise_pred = self.guider(guider_state)[0]
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
-
-                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)
-                    # Handle negative embeds if needed by callback
-                    if "negative_prompt_embeds" in callback_outputs:
-                        negative_prompt_embeds = callback_outputs.pop("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 XLA_AVAILABLE:
-                    xm.mark_step()
-
-        self._current_timestep = None
-
-        if output_type == "latent":
-            video = latents
-        else:
-            latents = latents.to(self.vae.dtype)
-            latents = self._denormalize_latents(latents, self.vae.config.latents_mean, self.vae.config.latents_std)
-            if vae_batch_size is not None and latents.shape[0] > vae_batch_size:
-                video_chunks = []
-                for i in range(0, latents.shape[0], vae_batch_size):
-                    chunk = latents[i : i + vae_batch_size]
-                    video_chunks.append(self.vae.decode(chunk, return_dict=False)[0])
-                video = torch.cat(video_chunks, dim=0)
-                del video_chunks
-            else:
-                video = self.vae.decode(latents, return_dict=False)[0]
-            video = self.video_processor.postprocess_video(video, output_type=output_type)
-
-        # Offload all models
-        self.maybe_free_model_hooks()
-
-        if not return_dict:
-            return (video,)
-
-        # Return updated output type
-        return MotifVideoPipelineOutput(frames=video)