#
# Sous licence Apache License, Version 2.0 (la « Licence ») ;
# vous ne pouvez utiliser ce fichier que conformément à la Licence.
# Vous pouvez obtenir un exemplaire de la Licence à
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Sauf exigence légale ou accord écrit
# distribué sous la Licence est distribué sur une base « EN L'ÉTAT »,
# SANS AUCUNE GARANTIE NI CONDITION, explicite ou implicite.
# Voir la Licence pour le langage spécifique régissant les autorisations et
# limitations under the License. -->

# LTX-2

  

[LTX-2](https://hf.co/papers/2601.03233) est un modèle de fondation basé sur DiT, conçu pour générer de la vidéo et de l’audio synchronisés au sein d’un seul modèle. Il réunit les briques fondamentales de la génération vidéo moderne, avec des poids ouverts et une orientation vers une exécution locale et pratique.

Vous pouvez trouver tous les points de contrôle originaux de LTX-Video sous l'organisation [Lightricks](https://huggingface.co/Lightricks).

Le code source original de LTX-2 peut être trouvé [ici](https://github.com/Lightricks/LTX-2).

## Génération en deux étapes

Les valeurs par défaut du `__call__` partagé de `LTX2Pipeline` / `LTX2ImageToVideoPipeline` correspondent à la référence LTX-2.5 (`num_inference_steps=30` ; `num_frames` est facultatif lorsqu'un `duration_head` est présent, sinon il retombe sur `121`). Les exemples ci-dessous utilisent ces valeurs par défaut pour LTX-2.0/2.3 également.

Pipeline recommandé pour obtenir une génération de qualité production, ce pipeline est composé de deux étapes :

- Étape 1 : générer une vidéo à la résolution cible en utilisant l'échantillonnage par diffusion avec un guidage sans classifieur (CFG). Cette étape produit une séquence vidéo cohérente à faible bruit qui respecte le conditionnement texte/image.
- Étape 2 : Augmenter la résolution de la sortie de l'étape 1 par un facteur de 2 et affiner les détails à l'aide d'un modèle LoRA distillé pour améliorer la fidélité et la qualité visuelle. L'étape 2 peut appliquer un CFG plus léger pour préserver la structure de l'étape 1 tout en améliorant la texture et la netteté.

Exemple d'utilisation du pipeline de génération de vidéo à partir de texte en deux étapes

```py
import torch
from diffusers import FlowMatchEulerDiscreteScheduler
from diffusers.pipelines.ltx2 import LTX2Pipeline, LTX2LatentUpsamplePipeline
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.utils import STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video

device = "cuda:0"
width = 768
height = 512

pipe = LTX2Pipeline.from_pretrained(
    "Lightricks/LTX-2", dtype=torch.bfloat16
)
pipe.enable_sequential_cpu_offload(device=device)

prompt = "A beautiful sunset over the ocean"
negative_prompt = "shaky, glitchy, low quality, worst quality, deformed, distorted, disfigured, motion smear, motion artifacts, fused fingers, bad anatomy, weird hand, ugly, transition, static."

# Stage 1 default (non-distilled) inference
frame_rate = 24.0
video_latent, audio_latent = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=30,
    sigmas=None,
    guidance_scale=3.0,
    output_type="latent",
    return_dict=False,
)

latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    "Lightricks/LTX-2",
    subfolder="latent_upsampler",
    dtype=torch.bfloat16,
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
upsample_pipe.enable_model_cpu_offload(device=device)
upscaled_video_latent = upsample_pipe(
    latents=video_latent,
    output_type="latent",
    return_dict=False,
)[0]

# Load Stage 2 distilled LoRA
pipe.load_lora_weights(
    "Lightricks/LTX-2", adapter_name="stage_2_distilled", weight_name="ltx-2-19b-distilled-lora-384.safetensors"
)
pipe.set_adapters("stage_2_distilled", 1.0)
# VAE tiling is usually necessary to avoid OOM error when VAE decoding
pipe.vae.enable_tiling()
# Change scheduler to use Stage 2 distilled sigmas as is
new_scheduler = FlowMatchEulerDiscreteScheduler.from_config(
    pipe.scheduler.config, use_dynamic_shifting=False, shift_terminal=None
)
pipe.scheduler = new_scheduler
# Stage 2 inference with distilled LoRA and sigmas
video, audio = pipe(
    latents=upscaled_video_latent,
    audio_latents=audio_latent,
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=3,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0], # renoise with first sigma value https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/ti2vid_two_stages.py#L218
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_lora_distilled_sample.mp4",
)
```

## Génération de points de contrôle distillés
Pipeline de génération en deux étapes le plus rapide, utilisant un point de contrôle distillé.

```py
import torch
from diffusers.pipelines.ltx2 import LTX2Pipeline, LTX2LatentUpsamplePipeline
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "rootonchair/LTX-2-19b-distilled"

pipe = LTX2Pipeline.from_pretrained(
    model_path, dtype=torch.bfloat16
)
pipe.enable_sequential_cpu_offload(device=device)

prompt = "A beautiful sunset over the ocean"
negative_prompt = "shaky, glitchy, low quality, worst quality, deformed, distorted, disfigured, motion smear, motion artifacts, fused fingers, bad anatomy, weird hand, ugly, transition, static."

frame_rate = 24.0
video_latent, audio_latent = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=8,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    generator=generator,
    output_type="latent",
    return_dict=False,
)

latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    model_path,
    subfolder="latent_upsampler",
    dtype=torch.bfloat16,
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
upsample_pipe.enable_model_cpu_offload(device=device)
upscaled_video_latent = upsample_pipe(
    latents=video_latent,
    output_type="latent",
    return_dict=False,
)[0]

video, audio = pipe(
    latents=upscaled_video_latent,
    audio_latents=audio_latent,
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=3,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0], # renoise with first sigma value https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/distilled.py#L178
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    generator=generator,
    guidance_scale=1.0,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_distilled_sample.mp4",
)
```

## Génération du pipeline de condition

Vous pouvez utiliser `LTX2ConditionPipeline` pour spécifier des conditions d’image et/ou de vidéo à des indices latents arbitraires. Par exemple, nous pouvons spécifier à la fois une condition de première image et une condition de dernière image pour effectuer une génération first-last-frame-to-video (FLF2V) :

```py
import torch
from diffusers import LTX2ConditionPipeline, LTX2LatentUpsamplePipeline
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video
from diffusers.utils import load_image

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "rootonchair/LTX-2-19b-distilled"

pipe = LTX2ConditionPipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

prompt = (
    "CG animation style, a small blue bird takes off from the ground, flapping its wings. The bird's feathers are "
    "delicate, with a unique pattern on its chest. The background shows a blue sky with white clouds under bright "
    "sunshine. The camera follows the bird upward, capturing its flight and the vastness of the sky from a close-up, "
    "low-angle perspective."
)

first_image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_first_frame.png",
)
last_image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_last_frame.png",
)
first_cond = LTX2VideoCondition(frames=first_image, index=0, strength=1.0)
last_cond = LTX2VideoCondition(frames=last_image, index=-1, strength=1.0)
conditions = [first_cond, last_cond]

frame_rate = 24.0
video_latent, audio_latent = pipe(
    conditions=conditions,
    prompt=prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=8,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    generator=generator,
    output_type="latent",
    return_dict=False,
)

latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    model_path,
    subfolder="latent_upsampler",
    dtype=torch.bfloat16,
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
upsample_pipe.enable_model_cpu_offload(device=device)
upscaled_video_latent = upsample_pipe(
    latents=video_latent,
    output_type="latent",
    return_dict=False,
)[0]

video, audio = pipe(
    latents=upscaled_video_latent,
    audio_latents=audio_latent,
    prompt=prompt,
    width=width * 2,
    height=height * 2,
    num_inference_steps=3,
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    generator=generator,
    guidance_scale=1.0,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_distilled_flf2v.mp4",
)
```

Vous pouvez utiliser à la fois des conditions d'image et de vidéo :

```py
import torch
from diffusers import LTX2ConditionPipeline
from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT
from diffusers.utils import load_image, load_video

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "rootonchair/LTX-2-19b-distilled"

pipe = LTX2ConditionPipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

prompt = (
    "The video depicts a long, straight highway stretching into the distance, flanked by metal guardrails. The road is "
    "divided into multiple lanes, with a few vehicles visible in the far distance. The surrounding landscape features "
    "dry, grassy fields on one side and rolling hills on the other. The sky is mostly clear with a few scattered "
    "clouds, suggesting a bright, sunny day. And then the camera switch to a winding mountain road covered in snow, "
    "with a single vehicle traveling along it. The road is flanked by steep, rocky cliffs and sparse vegetation. The "
    "landscape is characterized by rugged terrain and a river visible in the distance. The scene captures the "
    "solitude and beauty of a winter drive through a mountainous region."
)

cond_video = load_video(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input-vid.mp4"
)
cond_image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input.jpg"
)
video_cond = LTX2VideoCondition(frames=cond_video, index=0, strength=1.0)
image_cond = LTX2VideoCondition(frames=cond_image, index=8, strength=1.0)
conditions = [video_cond, image_cond]

frame_rate = 24.0
video, audio = pipe(
    conditions=conditions,
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=30,
    guidance_scale=3.0,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_cond_video.mp4",
)
```

Comme le conditionnement est effectué via des images latentes, les 8 images de l'espace des données correspondant à l'image latente spécifiée pour une condition d'image tendront à être statiques.

## Guidage multimodal

Les pipelines LTX-2.X prennent en charge le guidage multimodal. Il est composé de trois termes, tous utilisant une règle de mise à jour de type CFG :

1. Guidage sans classifieur (CFG) : [CFG](https://huggingface.co/papers/2207.12598) standard où la sortie perturbée (« plus faible ») est générée à l'aide du prompt négatif.
2. Guidance spatio-temporelle (STG) : [STG](https://huggingface.co/papers/2411.18664) s'écarte d'une sortie perturbée créée en court-circuitant les opérations d'auto-attention et substitue à la place les valeurs d'attention. L'idée est que cela crée des vidéos plus nettes et une meilleure cohérence spatio-temporelle.
3. Guidance d'isolation de la modalité : s'écarte d'une sortie perturbée créée en désactivant l'attention croisée inter-modalités (audio-vers-vidéo et vidéo-vers-audio). Cette guidance est plus spécifique aux modèles [LTX-2.X](https://huggingface.co/papers/2601.03233), avec l'idée qu'elle produit une meilleure cohérence entre l'audio et la vidéo générés.

Ces paramètres sont contrôlés par les arguments `guidance_scale`, `stg_scale` et `modality_scale` et peuvent être définis séparément pour la vidéo et l’audio. De plus, pour STG, il est nécessaire de spécifier les indices des blocs du transformer où l’auto-attention est ignorée via l’argument `spatio_temporal_guidance_blocks`. Les pipelines LTX-2.X prennent également en charge le [guidance rescaling](https://huggingface.co/papers/2305.08891) pour aider à réduire l’exposition excessive, un problème qui peut survenir lorsque les échelles de guidance sont fixées à des valeurs élevées.

```py
import torch
from diffusers import LTX2ImageToVideoPipeline
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT
from diffusers.utils import load_image

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "diffusers/LTX-2.3-Diffusers"

pipe = LTX2ImageToVideoPipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

prompt = (
    "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in "
    "gentle low-gravity motion. Fine lunar dust lifts and drifts outward with each movement, floating in slow arcs "
    "before settling back onto the ground. The astronaut pushes free in a deliberate, weightless motion, small "
    "fragments of the egg tumbling and spinning through the air. In the background, the deep darkness of space subtly "
    "shifts as stars glide with the camera's movement, emphasizing vast depth and scale. The camera performs a "
    "smooth, cinematic slow push-in, with natural parallax between the foreground dust, the astronaut, and the "
    "distant starfield. Ultra-realistic detail, physically accurate low-gravity motion, cinematic lighting, and a "
    "breath-taking, movie-like shot."
)

image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg",
)

video, audio = pipe(
    image=image,
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=30,
    guidance_scale=3.0,  # Recommended LTX-2.3 guidance parameters
    stg_scale=1.0,  # Note that 0.0 (not 1.0) means that STG is disabled (all other guidance is disabled at 1.0)
    modality_scale=3.0,
    guidance_rescale=0.7,
    audio_guidance_scale=7.0,  # Note that a higher CFG guidance scale is recommended for audio
    audio_stg_scale=1.0,
    audio_modality_scale=3.0,
    audio_guidance_rescale=0.7,
    spatio_temporal_guidance_blocks=[28],
    use_cross_timestep=True,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_3_i2v_stage_1.mp4",
)
```

## Amélioration du prompt

Les modèles LTX-2.X sont sensibles au style de formulation des prompts. Consultez le [guide officiel de formulation des prompts](https://ltx.io/model/model-blog/prompting-guide-for-ltx-2) pour des recommandations sur la rédaction d’un bon prompt. L’utilisation de l’amélioration de prompt, où les prompts fournis sont enrichis à l’aide de l’encodeur de texte du pipeline (par défaut un modèle [Gemma 3](https://huggingface.co/google/gemma-3-12b-it-qat-q4_0-unquantized)) à partir d’un prompt système, peut également améliorer la qualité des échantillons. Le composant de pipeline optionnel `processor` doit être présent pour utiliser l’amélioration de prompt. Activez-le avec `enable_prompt_enhancement=True` et un `system_prompt` (opt-in, conforme aux pipelines de référence Lightricks) :

```py
import torch
from transformers import Gemma3Processor
from diffusers import LTX2Pipeline
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT, T2V_DEFAULT_SYSTEM_PROMPT

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "diffusers/LTX-2.3-Diffusers"

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_model_cpu_offload(device=device)
pipe.vae.enable_tiling()
if getattr(pipe, "processor", None) is None:
    processor = Gemma3Processor.from_pretrained("google/gemma-3-12b-it-qat-q4_0-unquantized")
    pipe.processor = processor

prompt = (
    "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in "
    "gentle low-gravity motion. Fine lunar dust lifts and drifts outward with each movement, floating in slow arcs "
    "before settling back onto the ground. The astronaut pushes free in a deliberate, weightless motion, small "
    "fragments of the egg tumbling and spinning through the air. In the background, the deep darkness of space subtly "
    "shifts as stars glide with the camera's movement, emphasizing vast depth and scale. The camera performs a "
    "smooth, cinematic slow push-in, with natural parallax between the foreground dust, the astronaut, and the "
    "distant starfield. Ultra-realistic detail, physically accurate low-gravity motion, cinematic lighting, and a "
    "breath-taking, movie-like shot."
)

video, audio = pipe(
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=30,
    guidance_scale=3.0,
    stg_scale=1.0,
    modality_scale=3.0,
    guidance_rescale=0.7,
    audio_guidance_scale=7.0,
    audio_stg_scale=1.0,
    audio_modality_scale=3.0,
    audio_guidance_rescale=0.7,
    spatio_temporal_guidance_blocks=[28],
    use_cross_timestep=True,
    enable_prompt_enhancement=True,
    system_prompt=T2V_DEFAULT_SYSTEM_PROMPT,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_3_t2v_stage_1.mp4",
)
```

## LTX-2.5

LTX-2.5 réutilise les mêmes classes `LTX2Pipeline`/`LTX2VideoTransformer3DModel`/`AutoencoderKLLTX2Video`/etc. que LTX-2.3 — il n'existe pas de classe de pipeline distincte pour ce modèle. La différence visible pour l'utilisateur réside dans l'encodeur de texte : LTX-2.5 est associé à un point de contrôle Gemma 4 (`gemma4_unified`) au lieu de Gemma 3. Ce dernier est chargé automatiquement lors de l'appel de `from_pretrained` sur un point de contrôle LTX-2.5 converti (via les classes `Auto*` de `transformers`), de sorte qu'aucune configuration supplémentaire n'est nécessaire au moment de l'inférence — il suffit de diriger `from_pretrained` vers un dépôt LTX-2.5 plutôt qu'un dépôt LTX-2.3.

[`Lightricks/LTX-2.5-Diffusers`](https://huggingface.co/Lightricks/LTX-2.5-Diffusers) fournit les deux transformers : le DiT **distillé** dans `transformer/`, auquel `model_index.json` pointe, et le DiT complet/SFT dans `transformer_full/`, qui doit être chargé explicitement (voir [Transformer complet / SFT](#full--sft-transformer)). Le `scheduler/` du dépôt est configuré pour le checkpoint distillé (`use_dynamic_shifting=False`, `shift_terminal=None`) afin que son calendrier de sigmas soit utilisé tel quel. Tout ce dont [la génération en deux étapes](#two-stage-generation-for-ltx-25) a besoin y est également fourni : un sous-dossier `latent_upsampler/` et le LoRA distillé de l'étape 2, `ltx-2.5-22b-distilled-lora-450-bf16.safetensors`, à la racine du dépôt.

L’inférence distillée est pilotée par un calendrier sigma explicite plutôt que par un nombre d’étapes, et s’exécute sans guidage (`guidance_scale=1.0`, donc `negative_prompt` n’est pas utilisé). Transmettre `num_inference_steps` à la place fournirait au modèle un calendrier linéaire générique et entraînerait une perte de qualité silencieuse :

```py
import torch
from diffusers import LTX2Pipeline
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "Lightricks/LTX-2.5-Diffusers"

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

prompt = "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."

video, audio = pipe(
    prompt=prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_t2v.mp4",
)
```

### Génération en deux étapes pour LTX-2.5

LTX-2.5 prend en charge les deux variantes à deux étapes, et `DISTILLED_SIGMA_VALUES` / `STAGE_2_DISTILLED_SIGMA_VALUES` sont ses plans de référence :

- **Point de contrôle distillé, les deux étapes** — la recette de référence pour le `transformer/` par défaut, et celle présentée ci-dessous. Aucun LoRA d'étape 2 n'est impliqué, car le transformer est déjà distillé ; il s'agit de la [Génération du point de contrôle distillé](#distilled-checkpoint-generation) avec les poids LTX-2.5.
- **Étape 1 Full/SFT + étape 2 LoRA distillé** — [Génération en deux étapes](#two-stages-generation) comme décrit en haut de cette page, en utilisant `transformer_full/` et le LoRA fourni. Voir [ci-dessous](#stage-2-with-the-distilled-lora) pour les modifications.

L'étape 1 s'exécute à la moitié de la résolution cible, l'upsampler la double, et l'étape 2 affine à la résolution complète — vidéo *et* audio, toutes deux réinitialisées à partir des latents de l'étape 1 avec `noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0]`. La hauteur et la largeur doivent être divisibles par 64, car l'étape 1 divise chaque axe par deux et doit toujours correspondre à la grille spatiale du VAE.

```py
import torch
from diffusers.pipelines.ltx2 import LTX2Pipeline, LTX2LatentUpsamplePipeline
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video

device = "cuda"  # or "mps", "xpu", "cpu"
width = 1536
height = 1024
num_frames = 121
frame_rate = 24.0
model_path = "Lightricks/LTX-2.5-Diffusers"

# One generator for the whole call, threaded through both stages, so stage 2 continues the noise
# stream instead of repeating stage 1's draw.
generator = torch.Generator(device).manual_seed(42)

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)

prompt = "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."

# Stage 1: half resolution, 8 distilled sigmas
video_latent, audio_latent = pipe(
    prompt=prompt,
    width=width // 2,
    height=height // 2,
    num_frames=num_frames,
    frame_rate=frame_rate,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    generator=generator,
    output_type="latent",
    return_dict=False,
)

latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    model_path,
    subfolder="latent_upsampler",
    dtype=torch.bfloat16,
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
upsample_pipe.enable_model_cpu_offload(device=device)
# `latents_normalized=False`: `output_type="latent"` already applied the latent statistics, and the
# upsampler is trained on denormalized latents. Stage 2 renormalizes them in `prepare_latents`.
upscaled_video_latent = upsample_pipe(
    latents=video_latent,
    latents_normalized=False,
    output_type="latent",
    return_dict=False,
)[0]

# Stage 2: full resolution, 3 sigmas, reseeded from stage 1. Pass `num_frames` explicitly here --
# omitting it would run the duration head a second time instead of using the stage 1 length.
pipe.vae.enable_tiling()
video, audio = pipe(
    prompt=prompt,
    latents=upscaled_video_latent,
    audio_latents=audio_latent,
    width=width,
    height=height,
    num_frames=num_frames,
    frame_rate=frame_rate,
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],  # renoise with the stage 2 entry sigma
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_t2v_two_stages.mp4",
)
```

Lorsque la longueur provient de la [tête de durée](#automatic-duration-for-ltx-25) plutôt que d’un `num_frames` explicite, laissez l’étape 1 décider et récupérer la longueur réalisée à partir de ses latents (`[B, C, F, H, W]`) avant l’exécution de l’étape 2, au lieu de prédire une seconde fois :

```py
num_frames = (video_latent.shape[2] - 1) * pipe.vae_temporal_compression_ratio + 1
```

#### Étape 2 avec le LoRA distillé

Pour exécuter la [génération en deux étapes](#two-stages-generation) à la place — DiT complet/SFT pour l’étape 1, LoRA distillé pour l’étape 2 —, construisez le pipeline comme indiqué dans [transformer complet / SFT](#full--sft-transformer) et générez les latents de l’étape 1 avec cette pile de guidage. Deux éléments diffèrent alors de LTX-2.0/2.3. Le LoRA se trouve dans le dépôt diffusers lui-même plutôt qu’à côté des poids d’origine, et l’inversion du planificateur se fait dans l’autre sens : LTX-2.5 fournit la configuration du planificateur *distillé*, de sorte que c’est l’étape 1 qui a activé le décalage dynamique, et l’étape 2 qui le désactive à nouveau.

```py
pipe.load_lora_weights(
    "Lightricks/LTX-2.5-Diffusers",
    adapter_name="stage_2_distilled",
    weight_name="ltx-2.5-22b-distilled-lora-450-bf16.safetensors",
)
pipe.set_adapters("stage_2_distilled", 1.0)
pipe.vae.enable_tiling()

pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(
    pipe.scheduler.config, use_dynamic_shifting=False, shift_terminal=None
)
```

L'étape de suréchantillonnage et l'appel de l'étape 2 sont inchangés par rapport à la recette distillée ci-dessus : mêmes `sigmas=STAGE_2_DISTILLED_SIGMA_VALUES`, même `noise_scale` et `guidance_scale=1.0`, car l'étape 2 exécute de toute façon un modèle distillé.

### Décodage convolutif et par diffusion

LTX-2.5 fournit deux décodeurs vidéo sur le même espace latent, de sorte que les latents sont interchangeables entre eux :

- `vae/` — le VAE convolutif ([AutoencoderKLLTX2Video](/docs/diffusers/main/fr/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video)). C’est lui que les pipelines utilisent pour le décodage, donc tous les extraits ci-dessus l’emploient déjà, et c’est le seul des deux à prendre en charge le tuilage (`pipe.vae.enable_tiling()`), ce qui permet généralement de faire tenir une haute résolution.
- `diffusion_decoder/` — [LTX2VideoDiffusionDecoderModel](/docs/diffusers/main/fr/api/models/ltx2_diffusion_decoder#diffusers.LTX2VideoDiffusionDecoderModel). Il s’agit d’un modèle de diffusion à part entière et non d’un composant de pipeline, il n’est donc pas transmis en tant que `vae` : exécutez le pipeline avec `output_type="latent"` et transmettez les latents à [LTX2VideoDiffusionDecodePipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2VideoDiffusionDecodePipeline).

L'encodage passe toujours par `vae/`, de sorte que le conditionnement par image et par vidéo n'est pas affecté par le choix effectué.

Deux éléments changent lors du décodage avec le décodeur de diffusion. `output_type="latent"` passe également par le vocoder, de sorte que l’audio est renvoyé sous forme de latents et doit être finalisé manuellement, et le processeur NATTEN est en pratique obligatoire aux résolutions vidéo :

```py
import torch
from diffusers import LTX2Pipeline, LTX2VideoDiffusionDecodePipeline, LTX2VideoDiffusionDecoderModel
from diffusers.models.autoencoders.ltx2_diffusion_decoder import LTX2VideoVaeNeighborhoodNattenProcessor
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video

device = "cuda"  # or "mps", "xpu", "cpu"
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(42)
model_path = "Lightricks/LTX-2.5-Diffusers"

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_model_cpu_offload(device=device)

prompt = "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."

latents, audio_latents = pipe(
    prompt=prompt,
    width=960,
    height=544,
    num_frames=121,
    frame_rate=frame_rate,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    generator=generator,
    output_type="latent",
    return_dict=False,
)

# `output_type="latent"` skips the vocoder, so finish the audio by hand. These latents are already
# denormalized, which is what `audio_vae.decode` expects.
mel = pipe.audio_vae.decode(audio_latents.to(pipe.audio_vae.dtype), return_dict=False)[0]
audio = pipe.vocoder(mel)

decoder = LTX2VideoDiffusionDecoderModel.from_pretrained(
    model_path, subfolder="diffusion_decoder", dtype=torch.bfloat16
).to(device)
# The decoder runs on the `flex` backend by default, and uncompiled `flex_attention` materializes the
# full score matrix -- tens of GB at video resolutions. NATTEN's kernels are what the original
# implementation uses; they are fetched from the Hub by `kernels` (`pip install kernels`), not from a
# local NATTEN build. Switching the attention *backend* instead raises: only `flex` takes the BlockMask.
decoder.set_attn_processor(LTX2VideoVaeNeighborhoodNattenProcessor())
# Decode in overlapping tiles so peak memory scales with the tile size rather than the video size.
decoder.enable_tiling()

decode_pipe = LTX2VideoDiffusionDecodePipeline(diffusion_decoder=decoder, scheduler=pipe.scheduler)

# `denormalize=False`: `output_type="latent"` already applied the latent statistics, so applying them
# again would rescale every channel by its std a second time. The decoder draws the noise it denoises,
# so pass a generator to make decoding reproducible.
video = decode_pipe(
    latents, generator=generator, output_type="np", denormalize=False, return_dict=False
)[0]

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_t2v_diffusion_decode.mp4",
)
```

Pour combiner cela avec la [génération en deux étapes](#two-stage-generation-for-ltx-25), demandez à *l'étape 2* de produire `output_type="latent"` et décodez ce résultat.

`decoder.enable_tiling()` est ce qui permet de maintenir un décodage haute résolution en mémoire, de la même manière que `pipe.vae.enable_tiling()` le fait pour le VAE convolutif. La partie du décodage qui domine la consommation mémoire — l’étape finale de suréchantillonnage et l’étape de diffusion — s’exécute alors sur des tuiles superposées qui sont ensuite fusionnées, de sorte que la mémoire de pointe est limitée par la taille de la tuile plutôt que par la taille de la vidéo. Le découpage en tuiles n’entre en jeu que lorsque le latent dépasse une tuile, et les tailles de tuile et de chevauchement peuvent être ajustées via les arguments `tile_sample_min_*` / `tile_sample_stride_*` (les valeurs par défaut correspondent à l’implémentation de référence). Étant donné que l’étape de diffusion débruite chaque tuile séparément, un décodage en tuiles ne reproduit pas exactement le résultat non découpé.

Sur une carte unique, il est également judicieux de déplacer le pipeline hors de la mémoire GPU avant le décodage (`pipe.to("cpu")` et `torch.cuda.empty_cache()`, après avoir capturé `pipe.scheduler` et le `output_sampling_rate` du vocodeur), car le décodeur a besoin de sa propre marge de manœuvre. Consultez [LTX2VideoDiffusionDecoderModel](/docs/diffusers/main/fr/api/models/ltx2_diffusion_decoder#diffusers.LTX2VideoDiffusionDecoderModel) pour les backends d'attention, les détails du tuilage et le reste du comportement du décodeur.

### Transformeur complet / SFT

`transformer_full/` n’est pas référencé par `model_index.json`, il faut donc le charger explicitement. Il nécessite également un scheduler différent et une pile de guidance réelle : le `scheduler/` fourni est configuré pour le checkpoint distillé, et les valeurs par défaut de guidance sont des génériques de l’ère LTX-2.0 qui laissent un run SFT LTX-2.5 visiblement sous-guidé sans déclencher d’alerte. Les recommandations de [Multimodal Guidance](#multimodal-guidance) s’appliquent ici sans modification, y compris le STG sur le bloc `28` :

```py
import torch
from diffusers import FlowMatchEulerDiscreteScheduler, LTX2Pipeline, LTX2VideoTransformer3DModel
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT

device = "cuda"  # or "mps", "xpu", "cpu"
model_path = "Lightricks/LTX-2.5-Diffusers"

# Passing `transformer=` keeps `from_pretrained` from fetching the distilled folder as well.
transformer = LTX2VideoTransformer3DModel.from_pretrained(
    model_path, subfolder="transformer_full", dtype=torch.bfloat16
)
pipe = LTX2Pipeline.from_pretrained(model_path, transformer=transformer, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

# Re-enable dynamic shifting and the terminal shift, which the distilled configuration turns off.
pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(
    pipe.scheduler.config, use_dynamic_shifting=True, shift_terminal=0.1
)

video, audio = pipe(
    prompt="A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees.",
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=768,
    height=512,
    num_frames=121,
    frame_rate=24.0,
    num_inference_steps=30,
    guidance_scale=3.0,
    stg_scale=1.0,
    modality_scale=3.0,
    guidance_rescale=0.7,
    audio_guidance_scale=7.0,
    audio_stg_scale=1.0,
    audio_modality_scale=3.0,
    audio_guidance_rescale=0.7,
    spatio_temporal_guidance_blocks=[28],
    use_cross_timestep=True,
    generator=torch.Generator(device).manual_seed(42),
    output_type="np",
    return_dict=False,
)
```

Déposez `sigmas` ici — le DiT complet récupère son calendrier depuis le scheduler.

### Amélioration des prompts pour LTX-2.5

**L'utilisation de l'amélioration du prompt est fortement recommandée pour LTX-2.5 ; passez `enable_prompt_enhancement=True` pour l'activer** (comme dans les pipelines de référence Lightricks). Contrairement à LTX-2.0/2.3, où le même point de contrôle de l'encodeur de texte sert également d'améliorateur (voir [Amélioration du prompt](#prompt-enhancement) ci-dessus), l'encodeur de texte affiné de LTX-2.5 n'a pas été entraîné pour l'amélioration. À la place, l'amélioration utilise un point de contrôle distinct, prêt à l'emploi, `google/gemma-4-E2B-it`. Chargez-le dans les composants optionnels `prompt_enhancer`/`processor` du pipeline, puis activez l'amélioration — le pipeline utilise par défaut `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` et la recette Gemma 4 (`do_sample=False`, `no_repeat_ngram_size=5`, `max_new_tokens=600`). Passez un `system_prompt=` explicite pour le remplacer :

```py
import torch
from transformers import AutoModelForImageTextToText, AutoProcessor
from diffusers import LTX2Pipeline
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "Lightricks/LTX-2.5-Diffusers"
enhancer_model_id = "google/gemma-4-E2B-it"

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_model_cpu_offload(device=device)
pipe.vae.enable_tiling()
if getattr(pipe, "prompt_enhancer", None) is None:
    pipe.prompt_enhancer = AutoModelForImageTextToText.from_pretrained(enhancer_model_id)
    pipe.processor = AutoProcessor.from_pretrained(enhancer_model_id)

prompt = "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."

video, audio = pipe(
    prompt=prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    enable_prompt_enhancement=True,
    # No `system_prompt=` needed -- defaults to `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` when `prompt_enhancer` is set.
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_t2v_enhanced.mp4",
)
```

Il en va de même pour la génération vidéo à partir d’image avec `LTX2ImageToVideoPipeline` : configurez `pipe.prompt_enhancer`/`pipe.processor` de la même manière et passez `enable_prompt_enhancement=True` (en utilisant `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT`, avec un conditionnement à la fois sur l’image de référence et sur le prompt texte) — encore une fois, aucun `system_prompt=` n’est nécessaire, sauf si vous souhaitez le remplacer.

### Durée automatique pour LTX-2.5

Les points de contrôle LTX-2.5 incluent un petit `duration_head` qui prédit la durée de la séquence décrite, à partir de la même sortie de connecteur de texte sur laquelle le transformateur est conditionné. Lorsque le pipeline chargé en possède un, **`num_frames` est prédit automatiquement par défaut** — omettez-le et le modèle choisira la durée :

```py
video, audio = pipe(prompt=prompt, output_type="np", return_dict=False)
```

Pour définir la longueur vous-même, passez explicitement `num_frames`. Un entier l’emporte toujours sur la tête :

```py
video, audio = pipe(prompt=prompt, num_frames=121, output_type="np", return_dict=False)
```

Les pipelines chargés à partir de points de contrôle LTX-2.0 ou LTX-2.3 ne disposent pas de tête de durée et conservent la valeur par défaut précédente de 121 images, ce qui ne change donc rien pour eux.

Passez `min_seconds` / `max_seconds` pour contraindre la prédiction. La prédiction brute est bornée dans l'intervalle, puis convertie en images :

```py
video, audio = pipe(
    prompt=prompt,
    min_seconds=2.0,
    max_seconds=10.0,
    frame_rate=frame_rate,
    output_type="np",
    return_dict=False,
)
```

Les nombres de frames prédits sont arrondis à la grille temporelle causale du VAE (`8k + 1`), si bien que la durée réalisée est quantifiée — environ 0,33 s par pas à 24 fps — et elle varie avec `frame_rate`, car la tête prédit des secondes plutôt que des frames. `min_seconds` doit être strictement inférieur à `max_seconds`. Ces bornes sont ignorées lorsque `num_frames` est défini explicitement.

Des bornes plus étroites qu'une étape de grille peuvent ne pas être satisfaites exactement : à 24 fps, `[1.0s, 1.02s]` se convertit en `[24, 24]` images, et 24 n'est pas de la forme `8k + 1`. Le point de grille le plus proche est utilisé et un avertissement est consigné, de sorte que la longueur renvoyée peut se situer juste en dehors de bornes aussi strictes.

Pour inspecter une prédiction sans générer de vidéo, appelez directement la tête. Tout ce dont elle a besoin est public :

```py
prompt_embeds, prompt_attention_mask, _, _ = pipe.encode_prompt(prompt, do_classifier_free_guidance=False)
video_tokens, audio_tokens, _ = pipe.connectors(prompt_embeds, prompt_attention_mask)

num_frames = pipe.duration_head.predict_num_frames(
    video_tokens,
    audio_tokens,
    frame_rate=24.0,
    temporal_compression_ratio=pipe.vae_temporal_compression_ratio,
)
seconds = pipe.duration_head(video_tokens, audio_tokens).item()  # raw, before clamping
print(f"predicted {seconds:.2f}s -> {num_frames} frames")
```

La conversion d’un point de contrôle 2.5 récupère automatiquement la tête avec `--full_pipeline`, ou de manière isolée avec `--duration_head`. Les points de contrôle antérieurs à la version 2.5 ne contiennent pas de tels poids, et la conversion ignore ce composant au lieu d’échouer.

### Vitesse de mouvement pour LTX-2.5

LTX-2 place chaque jeton vidéo sur un axe temporel en secondes, dérivé par défaut de `frame_rate`, le taux de lecture. `motion_speed` (valeur par défaut `1.0`) sépare les deux : l’axe temporel est conditionné par `frame_rate / motion_speed`, tandis que la durée de l’audio, la [duration head](#automatic-duration-for-ltx-25) et la vidéo renvoyée suivent toujours `frame_rate`. Avec `frame_rate=24.0` et `motion_speed=0.2`, le modèle est informé que l’action a été capturée à 120 images par seconde et que le résultat est lu à 24 images par seconde, ce qui produit un ralenti de 5x.

Le modèle de base est entraîné aux alentours de 24/25/30/60 fps, de sorte que des vitesses très éloignées de `1.0` n’ont de sens qu’avec un adaptateur entraîné à cet effet, tel que [`Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control`](https://huggingface.co/Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control) (accès restreint : acceptez d’abord sa licence sur le Hub). Sans `motion_speed`, ce LoRA se charge comme un LoRA standard et ne fournit aucun contrôle du mouvement. La fiche modèle suggère des vitesses de `1.0`, `0.5`, `0.2`, `0.1`, `0.05` et `0.025`, avec une intensité LoRA de `1.0`. Omettez les termes de vitesse (« slow motion », « high fps ») du prompt et réutilisez la même légende pour toutes les vitesses, car `motion_speed` à lui seul pilote l’effet.

```py
import torch
from diffusers import LTX2ImageToVideoPipeline
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video, load_image

device = "cuda"  # or "mps", "xpu", "cpu"
width = 1920  # the LoRA's recommended resolution; the effect is much weaker at 768x512
height = 1088
frame_rate = 24.0  # playback rate, always 24 for this LoRA
model_path = "Lightricks/LTX-2.5-Diffusers"

pipe = LTX2ImageToVideoPipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.load_lora_weights(
    "Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control",
    weight_name="ltx-2.5-22b-lora-slow-motion-control-1.0.safetensors",
    adapter_name="slow_motion",
)
pipe.set_adapters("slow_motion", 1.0)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
)
# No speed wording: the same caption is reused at every speed.
prompt = (
    "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking apart and lunar dust "
    "lifting into the air, while the camera pushes in."
)

for motion_speed in (1.0, 0.2):
    video, audio = pipe(
        image=image,
        prompt=prompt,
        width=width,
        height=height,
        num_frames=121,
        frame_rate=frame_rate,
        motion_speed=motion_speed,  # 1.0 = real time, 0.2 = 5x slow motion
        sigmas=DISTILLED_SIGMA_VALUES,
        guidance_scale=1.0,
        audio_guidance_scale=1.0,
        generator=torch.Generator(device).manual_seed(42),
        output_type="np",
        return_dict=False,
    )

    encode_video(
        video[0],
        fps=frame_rate,  # the file plays at the playback rate, not frame_rate / motion_speed
        audio=audio[0].float().cpu(),
        audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
        output_path=f"ltx2_5_i2v_motion_speed_{motion_speed}.mp4",
    )
```

Les deux extraits durent 121 images (environ 5 secondes à 24 images par seconde) et seul le rythme du mouvement change. Dans la [génération en deux étapes](#two-stage-generation-for-ltx-25), passez la même valeur de `motion_speed` aux **deux** étapes. L'étape 2 ré-applique le débruitage à la vidéo et annulerait le ralenti si elle s'exécutait sur l'axe du temps réel. Le [pilote de référence](https://huggingface.co/Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control/blob/main/distilled_speed_demo.py) fait de même en encapsulant l'objet d'étape partagé par les deux passages.

`motion_speed` est également une entrée des blocs modulaires LTX-2 / LTX-2.5, et elle est transmise au pipeline modulaire de la même manière.

### LTX-2.5 Modulaire

LTX-2.5 est également disponible sous forme de pipeline modulaire. Le jeu de blocs par défaut utilise le décodeur de diffusion et prédit la durée de la vidéo lorsque `num_frames` est omis. Il applique le guidage séparément à la vidéo et à l’audio via les composants `guider` et `audio_guider`. Consultez [LTX2Guidance](/docs/diffusers/main/fr/api/modular_diffusers/guiders#diffusers.LTX2Guidance) pour les paramètres de guidage disponibles. Par défaut, le pipeline modulaire télécharge l’améliorateur et le processeur de prompt depuis le dépôt [google/gemma-4-E2B-it](https://huggingface.co/google/gemma-4-E2B-it). Voici un exemple modulaire T2V :

```py
import torch
from diffusers import ModularPipeline, ComponentsManager
from diffusers.models.autoencoders.ltx2_diffusion_decoder import LTX2VideoVaeNeighborhoodNattenProcessor
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT
from diffusers.utils import encode_video

device = "cuda"  # or "mps", "xpu", "cpu"
frame_rate = 24.0
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)

model_path = "Lightricks/LTX-2.5-Diffusers"

cm = ComponentsManager()
pipe = ModularPipeline.from_pretrained(model_path, components_manager=cm)
pipe.load_components(dtype=torch.bfloat16)
# Set memory_reserve_margin higher to more aggressively offload component models
cm.enable_auto_cpu_offload(device=device, memory_reserve_margin="20GB")
# The NATTEN processor works if `kernels` is available (`pip install kernels`)
# Otherwise omit the below line to use the Flex Attention processor
pipe.diffusion_decoder.set_attn_processor(LTX2VideoVaeNeighborhoodNattenProcessor())
pipe.diffusion_decoder.enable_tiling()

prompt = (
    "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."
)

output_state = pipe(
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=768,
    height=512,
    num_frames=None,  # Set to an int (e.g. 121) to specify a fixed video length
    frame_rate=frame_rate,
    num_inference_steps=30,
    use_cross_timestep=True,
    enable_prompt_enhancement=True,
    generator=generator,
    output_type="np",
)
video = output_state.get("videos")
audio = output_state.get("audio")

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_modular_t2v.mp4",
)
```

Le pipeline modulaire basculera automatiquement les flux de travail en fonction des entrées fournies. Par exemple, si `image` est fourni, un flux de travail I2V sera utilisé :

```py
import torch
from diffusers import ModularPipeline, ComponentsManager
from diffusers.models.autoencoders.ltx2_diffusion_decoder import LTX2VideoVaeNeighborhoodNattenProcessor
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT
from diffusers.utils import encode_video, load_image

device = "cuda"  # or "mps", "xpu", "cpu"
frame_rate = 24.0
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)

model_path = "Lightricks/LTX-2.5-Diffusers"

cm = ComponentsManager()
pipe = ModularPipeline.from_pretrained(model_path, components_manager=cm)
pipe.load_components(dtype=torch.bfloat16)
cm.enable_auto_cpu_offload(device=device, memory_reserve_margin="20GB")
pipe.diffusion_decoder.set_attn_processor(LTX2VideoVaeNeighborhoodNattenProcessor())
pipe.diffusion_decoder.enable_tiling()

prompt = (
    "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in "
    "gentle low-gravity motion."
)
image_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
image = load_image(image_path)

output_state = pipe(
    image=image,
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=768,
    height=512,
    num_frames=None,  # Set to an int (e.g. 121) to specify a fixed video length
    frame_rate=frame_rate,
    num_inference_steps=30,
    use_cross_timestep=True,
    enable_prompt_enhancement=True,
    generator=generator,
    output_type="np",
)
video = output_state.get("videos")
audio = output_state.get("audio")

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_modular_i2v.mp4",
)
```

Vous pouvez consulter les workflows pris en charge dans la documentation de chaque blockset (par exemple [LTX2AutoBlocks](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2AutoBlocks), [LTX25AutoBlocks](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX25AutoBlocks)).

### Rendu de fidélité par diffusion (DFR) pour LTX-2.5

`LTX2DFRPipeline` échange le temps réel contre la fidélité des détails. Chaque `__call__` est **un passage de débruitage** à `height` × `width` : il génère une vidéo ainsi que des **slots de keyframes** supplémentaires de type image à un seul pixel, ou il débruite à nouveau des latents fournis, initialisés à partir de ces slots. Les appelants composent les étapes de la même manière que pour les autres pipelines LTX à deux étapes — ce pipeline, [LTX2LatentUpsamplePipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2LatentUpsamplePipeline), ce pipeline à nouveau, puis [LTX2DFRTemporalRefinePipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRTemporalRefinePipeline) pour chaque passe temporelle.

Un slot coûte un cadre latent complet de jetons pour acheter un cadre pixel, ce qui relâche la compression temporelle effective à cette position — la vidéo environnante est donc conditionnée sur des cadres réellement nouveaux plutôt que sur des cadres interpolés. Les positions des slots proviennent d'une grille de segments alignée sur la frontière temporelle du VAE (24 ou 32 cadres pixel, selon celle qui minimise le bourrage de la requête). La toile est bourrée à un nombre entier de segments en interne ; `output_type="latent"` renvoie cette grille bourrée afin qu'un slot situé sur le bourrage ne soit pas supprimé. Effectuez un rognage avec `trim_canvas` avant le décodage VAE.

Cela nécessite un transformer dont la configuration définit `use_keyframes_abs_pos_embedding`, ce qui marque les latents de trames monoxel avec un embedding appris. Les points de contrôle LTX-2.5 l’incluent ; le pipeline lève une erreur pour toute version antérieure plutôt que de gaspiller le budget de jetons sur des jetons qu’il ne peut pas interpréter.

Budget pour les jetons supplémentaires : chaque slot ajoute l’équivalent d’une frame latente, de sorte que l’étape 2 exécute une séquence plus longue que le passage distillé à deux étapes équivalent — +31 % à 1024x1536 / 121 frames (24576 -> 32256 tokens, 5 slots sur une grille de segments de 24 frames). La mémoire d’activation au pic évolue en conséquence, si bien qu’une résolution qui correspond juste à la recette distillée standard peut nécessiter `enable_sequential_cpu_offload`, `vae.enable_tiling()`, ou un canevas plus petit sous DFR.

La composition utilise `return_dict=True` pour `keyframes` et `keyframe_positions` (`return_dict=False` renvoie les mêmes quatre champs sous forme de tuple).

La recette complète ci-dessous est celle à privilégier pour démarrer : image-vers-vidéo 1088×1920, un tour de raffinement temporel x2, et le IC-LoRA de détail spatial x2 en étape 2.

```py
import torch
from diffusers import (
    LTX2DFRPipeline,
    LTX2DFRTemporalRefinePipeline,
    LTX2LatentUpsamplePipeline,
    LTXEulerAncestralRFScheduler,
)
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.utils import trim_canvas
from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
from diffusers.pipelines.ltx2.utils import STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video, load_image

pipe = LTX2DFRPipeline.from_pretrained("Lightricks/LTX-2.5-Diffusers", torch_dtype=torch.bfloat16)
latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    "Lightricks/LTX-2.5-Diffusers", subfolder="latent_upsampler", torch_dtype=torch.bfloat16
)
# The x2 temporal upsampler is not in the published `model_index.json` — convert it with
# `--temporal_latent_upsampler`.
temporal_latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    "path/to/converted/temporal_latent_upsampler", torch_dtype=torch.bfloat16
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
temporal_pipe = LTX2DFRTemporalRefinePipeline(
    scheduler=LTXEulerAncestralRFScheduler(eta=0.5),
    vae=pipe.vae,
    audio_vae=pipe.audio_vae,
    text_encoder=pipe.text_encoder,
    tokenizer=pipe.tokenizer,
    connectors=pipe.connectors,
    transformer=pipe.transformer,
    vocoder=pipe.vocoder,
    temporal_latent_upsampler=temporal_latent_upsampler,
)

# All three pipelines share the same components, so place them together. Do not call
# `enable_model_cpu_offload()` on one of them: its hooks would own modules the other two also call,
# and `temporal_latent_upsampler` — held only by `temporal_pipe` — would never reach the device.
pipe.to("cuda")
upsample_pipe.to("cuda")
temporal_pipe.to("cuda")

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png")
prompt = "A tabby cat stretching in a sunlit window, dust motes drifting in the light"
conditions = [LTX2VideoCondition(frames=image, index=0, strength=1.0)]
height, width = 1088, 1920
frame_rate = 24.0
generator = torch.Generator(device="cuda").manual_seed(0)

num_frames = 121
out = pipe(
    prompt=prompt,
    conditions=conditions,
    height=height // 2,
    width=width // 2,
    num_frames=num_frames,
    frame_rate=frame_rate,
    generator=generator,
    output_type="latent",
)
up_video = upsample_pipe(latents=out.frames, output_type="latent", return_dict=False)[0]
up_keyframes = upsample_pipe(latents=out.keyframes, output_type="latent", return_dict=False)[0]

# Load after stage 1 so the adapter is never disabled. `set_adapters` does not re-enable a
# transformer that already had `disable_adapters()` called on it.
pipe.load_lora_weights("Lightricks/LTX-2.5-22b-IC-LoRA-Pixel-Spatial-Upscaler", adapter_name="detailing")
pipe.set_adapters(["detailing"], adapter_weights=[0.5])
out2 = pipe(
    prompt=prompt,
    conditions=conditions,
    latents=up_video,
    audio_latents=out.audio,
    keyframes_latents=up_keyframes,
    keyframe_positions=out.keyframe_positions,
    reference_latents=out.frames,
    height=height,
    width=width,
    num_frames=num_frames,
    frame_rate=frame_rate,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    generator=generator,
    output_type="latent",
)
pipe.transformer.disable_adapters()

# `num_frames` here is the *padded* canvas the latents actually cover, which `resolve_canvas` may have
# grown past the 121 that were asked for. `condition_num_frames` stays the original request so a
# negative `condition.index` does not wrap onto the pad.
ratio = pipe.vae.temporal_compression_ratio
canvas_frames = (out2.frames.shape[2] - 1) * ratio + 1
out3 = temporal_pipe(
    latents=out2.frames,
    keyframes_latents=out2.keyframes,
    keyframe_positions=out2.keyframe_positions,
    audio_latents=out.audio,
    prompt=prompt,
    conditions=conditions,
    height=height,
    width=width,
    num_frames=canvas_frames,
    frame_rate=frame_rate,
    source_seconds=canvas_frames / frame_rate,
    condition_num_frames=num_frames,
    generator=generator,
    output_type="latent",
)

# Keep the padded canvas until decode so a slot on the pad is not dropped. `trim_canvas` counts *pixel*
# frames, and the round mapped `N -> 2 (N - 1) + 1`.
playback_fps = frame_rate * 2
requested_frames = (num_frames - 1) * 2 + 1
video_latents = trim_canvas(out3.frames, requested_frames, ratio)
timestep = None
if pipe.vae.config.timestep_conditioning:
    timestep = torch.zeros(video_latents.shape[0], device=video_latents.device, dtype=pipe.vae.dtype)
video = pipe.vae.decode(video_latents.to(pipe.vae.dtype), timestep, return_dict=False)[0]
video = pipe.video_processor.postprocess_video(video, output_type="np")

# Audio is stage 1's. Cut it to the video's duration so a muxed container does not outlast the picture.
audio = pipe.vocoder(pipe.audio_vae.decode(out.audio.to(pipe.audio_vae.dtype), return_dict=False)[0])
audio_samples = round(requested_frames / playback_fps * pipe.vocoder.config.output_sampling_rate)
audio = audio[..., : min(audio.shape[-1], audio_samples)]

encode_video(
    video[0],
    fps=playback_fps,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_dfr.mp4",
)
```

`height` et `width` correspondent à **ce passage**, et non à la sortie finale. L’étape 1 s’exécute à la moitié du canevas 1080p (544×960) ; l’étape 2 à 1088×1920. Chacune doit être divisible par le ratio de compression spatiale du VAE (32 sur LTX-2.5 pour un passage unique ; 64 lorsque l’étape 1 est la moitié du 1080p). C’est pourquoi le 1080p est **1920×1088** et le 4K est **3840×2176**. Chaque passage exécute un calendrier distillé fixe (`sigmas`), il n’y a donc pas de `num_inference_steps` ; les calendriers distillés sont entraînés sans guidage, il n’y a donc pas non plus de `negative_prompt` ou de `guidance_scale`. L’audio fourni est celui de l’étape 1 — les passages ultérieurs exécutent toujours un flux audio afin que la branche vidéo dispose d’une attention intermodale ; la forme d’onde elle-même n’est pas affinée après l’étape 1.

**Détail spatial.** Chargez l'IC-LoRA de détail spatial 2x sous un adaptateur nommé **après l'étape 1** et activez-le uniquement pour l'étape 2 (`set_adapters(["detailing"], adapter_weights=[0.5])`). L'étape 2 porte alors son attention sur le latent de demi-résolution de l'étape 1 en tant que `reference_latents`. L'étape 1 et les passes temporelles s'exécutent avec l'adaptateur désactivé. Si vous chargez le LoRA avant l'étape 1, `transformer.disable_adapters()` le désactive, et `set_adapters` ne le **réactive** pas — appelez `transformer.enable_adapters()` avant l'étape 2, ou chargez les poids après l'étape 1 comme dans la recette. `reference_downscale_factor` (valeur par défaut `2`) met à l'échelle les coordonnées spatiales des jetons de référence dans l'espace de coordonnées de la cible.

**Raffinement temporel.** [LTX2DFRTemporalRefinePipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRTemporalRefinePipeline) correspond à un seul passage : suréchantillonnage temporel, tuilage aux coutures des images clés, débruitage ancestral avec `LTXEulerAncestralRFScheduler` (`eta=0.5`), assemblage par suppression de l’entrée de la tuile suivante, et fusion du sac d’images clés portées. Construisez ce planificateur vous-même — le passage est refusé avec tout autre planificateur, car une étape déterministe s’exécuterait jusqu’au bout et ne renverrait qu’une toile plus douce. Appelez le pipeline une fois par passage ; bouclez pour 2x / 4x en transmettant `round_index`. Après un passage, `keyframe_positions` ne peut plus être redéduit du `num_frames` d’origine et doit être transmis tel quel. Chaque tuile reçoit la portion de l’audio figé de l’étape 1 couvrant sa propre fenêtre de lecture. `source_seconds` est la durée de l’*étape 1* et reste fixe d’un passage à l’autre, les passages suivants doivent donc le transmettre explicitement plutôt que de prendre la valeur par défaut.

Le fps de conditionnement est de 60 dès que la lecture dépasse 30, indépendamment du multiplexage : le temps de RoPE est `pixel_frame / fps`, donc une base temporelle de 120 fps réduirait de moitié l'étendue temporelle de chaque jeton par rapport à la distribution d'entraînement, tandis que 48 fps l'étirerait. Les deux mentent en affirmant être à 60 et traitent les images décodées au taux de lecture.

**Une troisième étape spatiale.** Composez-la ; il n'existe pas de quatrième pipeline. Effectuez un suréchantillonnage spatial de la **vidéo uniquement**, reconstruisez les images clés de transport en RGB (`decode` → Lanczos ×2 → `encode` via [rebuild_epilogue_keyframes()](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipeline.rebuild_epilogue_keyframes) ; ne faites jamais de suréchantillonnage latent des images clés de l'épilogue), puis :

```py
from diffusers.pipelines.ltx2.dfr_layout import epilogue_tiles, pixel_to_latent_index

# One more doubling on top of the recipe above, so every stage below the output halves again:
# `epilogue_height` must be divisible by 128 (`4 * 32`), which is why 4K is 3840x2176.
epilogue_height, epilogue_width = height * 2, width * 2
refined_frames = (out3.frames.shape[2] - 1) * ratio + 1

up_video = upsample_pipe(latents=out3.frames, output_type="latent", return_dict=False)[0]
epilogue_keyframes = pipe.rebuild_epilogue_keyframes(
    out3.keyframes,
    decode_timestep=0.0,
    decode_noise_scale=0.0,
    seed=0,
    device=up_video.device,
    dtype=torch.float32,
)

# Temporal cuts land on the seams the *last* round stitched on -- the positions handed into it, doubled --
# not on every carry keyframe, since the slots that round invented sit mid-window.
tiles = epilogue_tiles(
    latent_shape=(
        (refined_frames - 1) // ratio + 1,
        epilogue_height // pipe.vae.spatial_compression_ratio,
        epilogue_width // pipe.vae.spatial_compression_ratio,
    ),
    frame_tiles=2,  # 2 ** number of temporal rounds
    frame_seams=[pixel_to_latent_index(2 * p, ratio) for p in out2.keyframe_positions],
)

pipe.transformer.enable_adapters()  # the epilogue is a detailing pass too
out4 = pipe(
    prompt=prompt,
    conditions=conditions,
    latents=up_video,
    audio_latents=out.audio,
    generate_slots=False,
    guidance_keyframe_latents=epilogue_keyframes,
    guidance_keyframe_positions=out3.keyframe_positions,
    reference_latents=out3.frames,
    height=epilogue_height,
    width=epilogue_width,
    num_frames=refined_frames,
    frame_rate=playback_fps,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    freeze_audio=True,
    video_tiles=tiles,
    generator=generator,
    output_type="latent",
)
pipe.transformer.disable_adapters()
```

Les deux axes sont assemblés différemment. Aucun des deux côtés d'une frontière spatiale ne détient une réponse connue, de sorte que ces chevauchements sont fusionnés avec des poids trapézoïdaux. Les tuiles temporelles sont découpées sur les coutures des images clés de la dernière passe de raffinement.

**Décodage avec le décodeur de diffusion.** Pour une fidélité maximale des détails, restez sur `output_type="latent"` et transmettez les latents (déjà dénormalisés, éventuellement `trim_canvas`'d) à [LTX2VideoDiffusionDecodePipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2VideoDiffusionDecodePipeline).

```py
from diffusers import LTX2VideoDiffusionDecodePipeline
from diffusers.models.autoencoders.ltx2_diffusion_decoder import LTX2VideoDiffusionDecoderModel

decoder = LTX2VideoDiffusionDecoderModel.from_pretrained(
    "Lightricks/LTX-2.5-Diffusers", subfolder="diffusion_decoder", dtype=torch.bfloat16
)
decode_pipe = LTX2VideoDiffusionDecodePipeline(
    diffusion_decoder=decoder, scheduler=pipe.scheduler, vae=pipe.vae
)
decode_pipe.enable_model_cpu_offload()
# `denormalize=False`: the `output_type="latent"` path already applied the latent statistics.
video = decode_pipe(latents=out3.frames, denormalize=False, output_type="np", return_dict=False)[0]
```

## LTX2Pipeline[[diffusers.LTX2Pipeline]]

#### diffusers.LTX2Pipeline[[diffusers.LTX2Pipeline]]

```python
diffusers.LTX2Pipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, processor: transformers.processing_utils.ProcessorMixin | None = None, prompt_enhancer: transformers.models.gemma4.modeling_gemma4.Gemma4ForConditionalGeneration | None = None, duration_head: diffusers.pipelines.ltx2.duration_head.LTX2DurationHead | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2.py#L209)

**Paramètres :**

transformer ([LTXVideoTransformer3DModel](/docs/diffusers/main/fr/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel)) : architecture Transformer conditionnelle pour le débruitage des latents vidéo encodés.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.

vae ([AutoencoderKLLTXVideo](/docs/diffusers/main/fr/api/models/autoencoderkl_ltx_video#diffusers.AutoencoderKLLTXVideo)) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images à partir de représentations latentes et vers celles-ci.

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).

tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).

tokenizer (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).

connectors (`LTX2TextConnectors`) : Pile de connecteurs de texte utilisée pour adapter les états cachés de l'encodeur de texte aux branches vidéo et audio.

Pipeline pour la génération de vidéos à partir de texte.

Référence : https://github.com/Lightricks/LTX-Video

#### __appel__[[diffusers.LTX2Pipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int | None = None, min_seconds: float = 1.0, max_seconds: float = 20.0, frame_rate: float = 24.0, motion_speed: float = 1.0, num_inference_steps: int = 30, sigmas: list[float] | None = None, timesteps: list[int] = None, guidance_scale: float = 3.0, stg_scale: float = 1.0, modality_scale: float = 3.0, guidance_rescale: float = 0.7, audio_guidance_scale: float | None = 7.0, audio_stg_scale: float | None = 1.0, audio_modality_scale: float | None = 3.0, audio_guidance_rescale: float | None = 0.7, spatio_temporal_guidance_blocks: list[int] | None = [28], noise_scale: float = 0.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, use_cross_timestep: bool = True, system_prompt: str | None = None, enable_prompt_enhancement: bool = False, prompt_max_new_tokens: int | None = None, prompt_enhancement_kwargs: dict[str, typing.Any] | None = None, prompt_enhancement_seed: int = 10, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 1024)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2.py#L929)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer `prompt_embeds` à la place.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (`guidance_scale < 1`).

height (`int`, *facultatif*, valeur par défaut `512`) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 480 par défaut pour obtenir les meilleurs résultats.

width (`int`, *facultatif*, par défaut `768`) : La largeur en pixels de l'image générée. Cette valeur est définie sur 848 par défaut pour obtenir les meilleurs résultats.

num_frames (`int`, *facultatif*) : Le nombre de frames vidéo à générer. Si non fourni, la valeur par défaut est une durée prédite automatiquement lorsque ce pipeline possède un composant `duration_head` (checkpoints LTX-2.5 et ultérieurs), et `121` sinon. Passez un entier pour définir explicitement la longueur. Les nombres prédits automatiquement sont alignés sur la grille temporelle causale du VAE, de sorte que la durée réalisée est quantifiée (environ 0,33 s à 24 fps).

min_seconds (`float`, *facultatif*, valeur par défaut `1.0`) : Limite inférieure de la durée auto-prédite lorsque `num_frames` est omis et qu'une `duration_head` est présente. Ignoré lorsque `num_frames` est défini explicitement.

max_seconds (`float`, *facultatif*, valeur par défaut `20.0`) : Limite supérieure de la durée prédite automatiquement lorsque `num_frames` est omis et qu'une `duration_head` est présente. Ignoré lorsque `num_frames` est défini explicitement. Doit être strictement supérieur à `min_seconds`.

frame_rate (`float`, *facultatif*, par défaut `24.0`) : Le nombre d'images par seconde (FPS) de la vidéo générée.

motion_speed (`float`, *facultatif*, par défaut `1.0`) : Vitesse du mouvement par rapport au temps réel. Les embeddings positionnels sont conditionnés par `frame_rate / motion_speed`, donc les valeurs inférieures à 1 ralentissent le mouvement, par exemple `0.2` pour le ralenti 5x du LoRA Slow-Motion-Control. `frame_rate` reste le taux de lecture : la durée audio et le nombre de frames prédit en dépendent.

num_inference_steps (`int`, *facultatif*, valeur par défaut 30) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

sigmas (`List[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'il n'est pas défini, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.

timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `timesteps` dans leur méthode `set_timesteps`. S'il n'est pas défini, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé. Doit être dans l'ordre décroissant.

guidance_scale (`float`, *facultatif*, valeur par défaut `4.0`) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image. Utilisé pour la modalité vidéo (une valeur distincte `audio_guidance_scale` existe pour la modalité audio).

stg_scale (`float`, *facultatif*, valeur par défaut `0.0`) : Échelle de guidage vidéo pour le Spatio-Temporal Guidance (STG), proposée dans [Spatiotemporal Skip Guidance for Enhanced Video Diffusion Sampling](https://arxiv.org/abs/2411.18664). Le STG utilise une estimation de type CFG où l’on déplace l’échantillon loin d’un échantillon faible issu d’une version perturbée du modèle de débruitage. L’activation du STG entraîne un passage avant supplémentaire du modèle de débruitage ; la valeur par défaut de `0.0` signifie que le STG est désactivé.

modality_scale (`float`, *facultatif*, valeur par défaut `1.0`) : Échelle de guidage vidéo pour l'isolation de la modalité dans le guidage LTX-2.X, où l'on déplace l'échantillon loin d'un échantillon plus faible généré par le modèle de débruitage avec l'attention croisée inter-modalités (audio-vers-vidéo et vidéo-vers-audio) désactivée, en utilisant une estimation de type CFG. L'activation du guidage de modalité entraînera un passage avant supplémentaire du modèle de débruitage ; la valeur par défaut de `1.0` signifie que le guidage de modalité est désactivé.

guidance_rescale (`float`, *facultatif*, valeur par défaut 0.0) : Facteur de rescaling du guidage proposé par [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` est défini comme `φ` dans l'équation 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Le facteur de rescaling du guidage doit corriger l'exposition excessive lors de l'utilisation d'un SNR terminal nul. Utilisé pour la modalité vidéo.

audio_guidance_scale (`float`, *facultatif* par défaut `None`) : Échelle de guidage audio pour CFG par rapport au prompt négatif. La règle de mise à jour CFG est la même pour la vidéo et l’audio, mais ils peuvent utiliser des valeurs différentes pour l’échelle de guidage. Les auteurs de LTX-2.X suggèrent que `audio_guidance_scale` doit être plus élevé par rapport à `guidance_scale` vidéo (par exemple, pour LTX-2.3, ils suggèrent 3.0 pour la vidéo et 7.0 pour l’audio). Si `None`, la valeur par défaut est la valeur vidéo `guidance_scale`.

audio_stg_scale (`float`, *facultatif*, valeur par défaut `None`) : Échelle de guidage audio pour STG. Comme pour CFG, la règle de mise à jour STG est par ailleurs identique pour la vidéo et l’audio. Pour LTX-2.3, une valeur de 1.0 est suggérée pour la vidéo et l’audio. Si `None`, la valeur par défaut est la valeur vidéo `stg_scale`.

audio_modality_scale (`float`, *facultatif*, valeur par défaut `None`) : Échelle de guidage audio pour l'isolation de la modalité dans le guidage de LTX-2.X. Comme pour le CFG, la règle de guidage de la modalité est par ailleurs identique pour la vidéo et l'audio. Pour LTX-2.3, une valeur de 3.0 est suggérée pour la vidéo et l'audio. Si `None`, la valeur par défaut est la valeur vidéo `modality_scale`.

audio_guidance_rescale (`float`, *facultatif*, valeur par défaut `None`) : Un facteur de rescaling du guidage distinct pour la modalité audio. Si `None`, la valeur par défaut est la valeur vidéo `guidance_rescale`.

spatio_temporal_guidance_blocks (`list[int]`, *facultatif*, valeur par défaut `None`) : Les indices de blocs de transformeur, indexés à partir de zéro, auxquels appliquer le STG. Doit être fourni si le STG est utilisé (`stg_scale` ou `audio_stg_scale` est supérieur à `0`). Une valeur de `[29]` est recommandée pour LTX-2.0 et `[28]` est recommandée pour LTX-2.3.

noise_scale (`float`, *facultatif*, valeur par défaut `0.0`) : Le facteur d'interpolation entre le bruit aléatoire et les latents débruités à chaque pas de temps. Applique du bruit aux `latents` et aux `audio_latents` avant de poursuivre le débruitage.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre de vidéos à générer par invite.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération de vidéos. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.

audio_latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération audio. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pré-généré pour les embeddings de texte.

negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Pour PixArt-Sigma, ce prompt négatif doit être "". S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

negative_prompt_attention_mask (`torch.FloatTensor`, *facultatif*) : Masque d'attention pré-généré pour les embeddings de texte négatif.

decode_timestep (`float`, par défaut `0.0`) : Le pas de temps auquel la vidéo générée est décodée.

decode_noise_scale (`float`, par défaut `None`) : Le facteur d'interpolation entre le bruit aléatoire et les latents débruités à l'étape de décodage.

use_cross_timestep (`bool` *facultatif*, par défaut `True`) : Indique s'il faut utiliser la sigma de la modalité croisée (l'audio est la modalité croisée de la vidéo, et vice versa) lors du calcul des paramètres de modulation de l'attention croisée. `True` correspond au comportement de LTX-2.3/2.5 ; `False` correspond au comportement hérité de LTX-2.0.

system_prompt (`str`, *facultatif*, valeur par défaut `None`) : Invite système facultative à utiliser pour l'amélioration de l'invite. L'invite système sera utilisée par l'améliorateur d'invite (un modèle de génération conditionnelle Gemma -- le composant `prompt_enhancer` dédié s'il est configuré, sinon le `text_encoder` principal) pour générer une invite améliorée à partir de l'`prompt` d'origine afin de conditionner la génération. Si aucune n'est fournie et qu'un `prompt_enhancer` dédié est configuré (LTX-2.5), la valeur par défaut est `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` (depuis `diffusers.pipelines.ltx2.utils`) -- voir `enable_prompt_enhancement`.

enable_prompt_enhancement (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut exécuter l'amélioration du prompt. Option, conformément aux pipelines de référence Lightricks. Si `True` et que `system_prompt` est omis, LTX-2.5 utilise `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` si un `prompt_enhancer` dédié est configuré ; LTX-2.0/2.3 nécessitent un `system_prompt` explicite.

prompt_max_new_tokens (`int`, *facultatif*, valeur par défaut `None`) : Le nombre maximal de nouveaux jetons à générer lors de l'amélioration du prompt. Si non fourni, utilise 600 pour un `prompt_enhancer` Gemma 4 dédié (LTX-2.5) ou 512 pour le repli sur le `text_encoder` Gemma 3 (LTX-2.0/2.3).

prompt_enhancement_kwargs (`dict[str, Any]`, *facultatif*, valeur par défaut `None`) : Arguments nommés pour l'appel `.generate` de l'améliorateur de prompt. S'ils ne sont pas fournis, ils correspondent toujours au modèle qui effectue l'amélioration : `do_sample=False, no_repeat_ngram_size=5` (glouton) lors de l'utilisation d'un `prompt_enhancer` dédié (LTX-2.5), ou `do_sample=True, temperature=0.7` pour le repli sur le `text_encoder` (LTX-2.0/2.3). Voir https://huggingface.co/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate pour plus de détails.

prompt_enhancement_seed (`int`, *facultatif*, valeur par défaut `10`) : Graine aléatoire pour toute opération aléatoire lors de l'amélioration du prompt.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.ltx.LTX2PipelineOutput` plutôt qu'un simple tuple.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`List`, *facultatif*, par défaut `["latents"]`) : La liste des entrées de tenseurs pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.

max_sequence_length (`int`, *facultatif*, valeur par défaut `1024`) : Longueur de séquence maximale à utiliser avec le `prompt`.

**Retourne :** `~pipelines.ltx.LTX2PipelineOutput` ou `tuple`

Si `return_dict` est `True`, `~pipelines.ltx.LTX2PipelineOutput` est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant les images générées.

Fonction appelée lors de l'appel du pipeline pour la génération.

Exemples :
```py
>>> import torch
>>> from diffusers import LTX2Pipeline
>>> from diffusers.utils import encode_video

>>> pipe = LTX2Pipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> 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"

>>> frame_rate = 24.0
>>> video, audio = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=121,
...     frame_rate=frame_rate,
...     num_inference_steps=30,
...     guidance_scale=3.0,
...     output_type="np",
...     return_dict=False,
... )

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,  # should be 24000
...     output_path="video.mp4",
... )
```

#### encode_prompt[[diffusers.LTX2Pipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, scale_factor: int = 8, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2.py#L367)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser le guidage sans classifieur ou non.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

device : (`torch.device`, *facultatif*) : appareil torch

dtype : (`torch.dtype`, *facultatif*) : torch dtype

Encode le prompt dans les états cachés de l'encodeur de texte.

#### enhance_prompt[[diffusers.LTX2Pipeline.enhance_prompt]]

```python
enhance_prompt(prompt: str, system_prompt: str, max_new_tokens: int | None = None, seed: int = 10, generator: typing.Optional[torch.Generator] = None, generation_kwargs: dict[str, typing.Any] | None = None, device: typing.Union[str, torch.device, NoneType] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2.py#L574)

Enhances the supplied `prompt` by generating a new prompt using the prompt enhancer (a Gemma conditional-generation model) from it and a system prompt. When `image` is supplied, the enhancer is also conditioned on that reference frame (I2V / keyframe-style enhancement). Uses the dedicated `prompt_enhancer` component if one is configured (e.g. LTX-2.5, whose text encoder isn't trained for enhancement), otherwise falls back to the main `text_encoder` (LTX-2.0/2.3, which double as their own enhancer).

Les modèles de messages, les mots-clés de décodage, le nettoyage des réponses et la préparation du côté long des images correspondent à `ltx-core` / `ltx-pipelines` (`enhance_t2v` / `enhance_i2v` / `generate_enhanced_prompt`).

## LTX2ImageToVideoPipeline[[diffusers.LTX2ImageToVideoPipeline]]

#### diffusers.LTX2ImageToVideoPipeline[[diffusers.LTX2ImageToVideoPipeline]]

```python
diffusers.LTX2ImageToVideoPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, processor: transformers.processing_utils.ProcessorMixin | None = None, prompt_enhancer: transformers.models.gemma4.modeling_gemma4.Gemma4ForConditionalGeneration | None = None, duration_head: diffusers.pipelines.ltx2.duration_head.LTX2DurationHead | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_image2video.py#L229)

Pipeline pour la génération de vidéos à partir d'images.

Référence : https://github.com/Lightricks/LTX-Video

TODO

#### __appel__[[diffusers.LTX2ImageToVideoPipeline.__call__]]

```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int | None = None, min_seconds: float = 1.0, max_seconds: float = 20.0, frame_rate: float = 24.0, motion_speed: float = 1.0, num_inference_steps: int = 30, sigmas: list[float] | None = None, timesteps: list[int] | None = None, guidance_scale: float = 3.0, stg_scale: float = 1.0, modality_scale: float = 3.0, guidance_rescale: float = 0.7, audio_guidance_scale: float | None = 7.0, audio_stg_scale: float | None = 1.0, audio_modality_scale: float | None = 3.0, audio_guidance_rescale: float | None = 0.7, spatio_temporal_guidance_blocks: list[int] | None = [28], noise_scale: float = 0.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, use_cross_timestep: bool = True, system_prompt: str | None = None, enable_prompt_enhancement: bool = False, prompt_max_new_tokens: int | None = None, prompt_enhancement_kwargs: dict[str, typing.Any] | None = None, prompt_enhancement_seed: int = 10, image_crf: int | None = None, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 1024)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_image2video.py#L983)

**Paramètres :**

image (`PipelineImageInput`) : L'image d'entrée sur laquelle conditionner la génération. Doit être une image, une liste d'images ou un `torch.Tensor`.

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer `prompt_embeds` à la place.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (`guidance_scale < 1`).

height (`int`, *facultatif*, valeur par défaut `512`) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 480 par défaut pour obtenir les meilleurs résultats.

width (`int`, *facultatif*, par défaut `768`) : La largeur en pixels de l'image générée. Cette valeur est définie sur 848 par défaut pour obtenir les meilleurs résultats.

num_frames (`int`, *facultatif*) : Le nombre de frames vidéo à générer. Si non fourni, la valeur par défaut est une durée prédite automatiquement lorsque ce pipeline possède un composant `duration_head` (checkpoints LTX-2.5 et ultérieurs), et `121` sinon. Passez un entier pour définir explicitement la longueur. Les nombres prédits automatiquement sont alignés sur la grille temporelle causale du VAE, de sorte que la durée réalisée est quantifiée (environ 0,33 s à 24 fps).

min_seconds (`float`, *facultatif*, valeur par défaut `1.0`) : Limite inférieure de la durée auto-prédite lorsque `num_frames` est omis et qu'une `duration_head` est présente. Ignoré lorsque `num_frames` est défini explicitement.

max_seconds (`float`, *facultatif*, valeur par défaut `20.0`) : Limite supérieure de la durée prédite automatiquement lorsque `num_frames` est omis et qu'une `duration_head` est présente. Ignoré lorsque `num_frames` est défini explicitement. Doit être strictement supérieur à `min_seconds`.

frame_rate (`float`, *facultatif*, par défaut `24.0`) : Le nombre d'images par seconde (FPS) de la vidéo générée.

motion_speed (`float`, *facultatif*, par défaut `1.0`) : Vitesse du mouvement par rapport au temps réel. Les embeddings positionnels sont conditionnés par `frame_rate / motion_speed`, donc les valeurs inférieures à 1 ralentissent le mouvement, par exemple `0.2` pour le ralenti 5x du LoRA Slow-Motion-Control. `frame_rate` reste le taux de lecture : la durée audio et le nombre de frames prédit en dépendent.

num_inference_steps (`int`, *facultatif*, valeur par défaut 30) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

sigmas (`List[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'il n'est pas défini, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.

timesteps (`List[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `timesteps` dans leur méthode `set_timesteps`. S'il n'est pas défini, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé. Doit être dans l'ordre décroissant.

guidance_scale (`float`, *facultatif*, valeur par défaut `4.0`) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image. Utilisé pour la modalité vidéo (une valeur distincte `audio_guidance_scale` existe pour la modalité audio).

stg_scale (`float`, *facultatif*, valeur par défaut `0.0`) : Échelle de guidage vidéo pour le Spatio-Temporal Guidance (STG), proposée dans [Spatiotemporal Skip Guidance for Enhanced Video Diffusion Sampling](https://arxiv.org/abs/2411.18664). Le STG utilise une estimation de type CFG où l’on déplace l’échantillon loin d’un échantillon faible issu d’une version perturbée du modèle de débruitage. L’activation du STG entraîne un passage avant supplémentaire du modèle de débruitage ; la valeur par défaut de `0.0` signifie que le STG est désactivé.

modality_scale (`float`, *facultatif*, valeur par défaut `1.0`) : Échelle de guidage vidéo pour l'isolation de la modalité dans le guidage LTX-2.X, où l'on déplace l'échantillon loin d'un échantillon plus faible généré par le modèle de débruitage avec l'attention croisée inter-modalités (audio-vers-vidéo et vidéo-vers-audio) désactivée, en utilisant une estimation de type CFG. L'activation du guidage de modalité entraînera un passage avant supplémentaire du modèle de débruitage ; la valeur par défaut de `1.0` signifie que le guidage de modalité est désactivé.

guidance_rescale (`float`, *facultatif*, valeur par défaut 0.0) : Facteur de rescaling du guidage proposé par [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` est défini comme `φ` dans l'équation 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Le facteur de rescaling du guidage doit corriger l'exposition excessive lors de l'utilisation d'un SNR terminal nul. Utilisé pour la modalité vidéo.

audio_guidance_scale (`float`, *facultatif* par défaut `None`) : Échelle de guidage audio pour CFG par rapport au prompt négatif. La règle de mise à jour CFG est la même pour la vidéo et l’audio, mais ils peuvent utiliser des valeurs différentes pour l’échelle de guidage. Les auteurs de LTX-2.X suggèrent que `audio_guidance_scale` doit être plus élevé par rapport à `guidance_scale` vidéo (par exemple, pour LTX-2.3, ils suggèrent 3.0 pour la vidéo et 7.0 pour l’audio). Si `None`, la valeur par défaut est la valeur vidéo `guidance_scale`.

audio_stg_scale (`float`, *facultatif*, valeur par défaut `None`) : Échelle de guidage audio pour STG. Comme pour CFG, la règle de mise à jour STG est par ailleurs identique pour la vidéo et l’audio. Pour LTX-2.3, une valeur de 1.0 est suggérée pour la vidéo et l’audio. Si `None`, la valeur par défaut est la valeur vidéo `stg_scale`.

audio_modality_scale (`float`, *facultatif*, valeur par défaut `None`) : Échelle de guidage audio pour l'isolation de la modalité dans le guidage de LTX-2.X. Comme pour le CFG, la règle de guidage de la modalité est par ailleurs identique pour la vidéo et l'audio. Pour LTX-2.3, une valeur de 3.0 est suggérée pour la vidéo et l'audio. Si `None`, la valeur par défaut est la valeur vidéo `modality_scale`.

audio_guidance_rescale (`float`, *facultatif*, valeur par défaut `None`) : Un facteur de rescaling du guidage distinct pour la modalité audio. Si `None`, la valeur par défaut est la valeur vidéo `guidance_rescale`.

spatio_temporal_guidance_blocks (`list[int]`, *facultatif*, valeur par défaut `None`) : Les indices de blocs de transformeur, indexés à partir de zéro, auxquels appliquer le STG. Doit être fourni si le STG est utilisé (`stg_scale` ou `audio_stg_scale` est supérieur à `0`). Une valeur de `[29]` est recommandée pour LTX-2.0 et `[28]` est recommandée pour LTX-2.3.

noise_scale (`float`, *facultatif*, valeur par défaut `0.0`) : Le facteur d'interpolation entre le bruit aléatoire et les latents débruités à chaque pas de temps. Applique du bruit aux `latents` et aux `audio_latents` avant de poursuivre le débruitage.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre de vidéos à générer par invite.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération de vidéos. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.

audio_latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération audio. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pré-généré pour les embeddings de texte.

negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Pour PixArt-Sigma, ce prompt négatif doit être "". S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

negative_prompt_attention_mask (`torch.FloatTensor`, *facultatif*) : Masque d'attention pré-généré pour les embeddings de texte négatif.

decode_timestep (`float`, par défaut `0.0`) : Le pas de temps auquel la vidéo générée est décodée.

decode_noise_scale (`float`, par défaut `None`) : Le facteur d'interpolation entre le bruit aléatoire et les latents débruités à l'étape de décodage.

use_cross_timestep (`bool` *facultatif*, par défaut `True`) : Indique s'il faut utiliser la sigma de la modalité croisée (l'audio est la modalité croisée de la vidéo, et vice versa) lors du calcul des paramètres de modulation de l'attention croisée. `True` correspond au comportement de LTX-2.3/2.5 ; `False` correspond au comportement hérité de LTX-2.0.

system_prompt (`str`, *facultatif*, valeur par défaut `None`) : Invite système facultative à utiliser pour l'amélioration de l'invite. L'invite système sera utilisée par l'améliorateur d'invite (un modèle de génération conditionnelle Gemma -- le composant `prompt_enhancer` dédié s'il est configuré, sinon le `text_encoder` principal) pour générer une invite améliorée à partir de l'`prompt` d'origine et de la première `image` afin de conditionner la génération. Si elle n'est pas fournie et qu'un `prompt_enhancer` dédié est configuré (LTX-2.5), la valeur par défaut est `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT` (depuis `diffusers.pipelines.ltx2.utils`) -- voir `enable_prompt_enhancement`.

enable_prompt_enhancement (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut exécuter l'amélioration du prompt. Option, conformément aux pipelines de référence Lightricks. Si `True` et que `system_prompt` est omis, LTX-2.5 utilise `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT` si un `prompt_enhancer` dédié est configuré ; LTX-2.0/2.3 nécessitent un `system_prompt` explicite.

prompt_max_new_tokens (`int`, *facultatif*, valeur par défaut `None`) : Le nombre maximal de nouveaux jetons à générer lors de l'amélioration du prompt. Si non fourni, utilise 600 pour un `prompt_enhancer` Gemma 4 dédié (LTX-2.5) ou 512 pour le repli sur le `text_encoder` Gemma 3 (LTX-2.0/2.3).

prompt_enhancement_kwargs (`dict[str, Any]`, *facultatif*, valeur par défaut `None`) : Arguments nommés pour l'appel `.generate` de l'améliorateur de prompt. S'ils ne sont pas fournis, ils correspondent toujours au modèle qui effectue l'amélioration : `do_sample=False, no_repeat_ngram_size=3` (glouton) lors de l'utilisation d'un `prompt_enhancer` dédié (LTX-2.5), ou `do_sample=True, temperature=0.7` pour le repli sur le `text_encoder` (LTX-2.0/2.3). Voir https://huggingface.co/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate pour plus de détails.

prompt_enhancement_seed (`int`, *facultatif*, valeur par défaut `10`) : Graine aléatoire pour toute opération aléatoire lors de l'amélioration du prompt.

image_crf (`int`, *facultatif*, valeur par défaut `None`) : CRF H.264 utilisé pour recompresser l'`image` de conditionnement avant l'encodage VAE, afin de correspondre à la compression utilisée lors de l'entraînement du modèle. `None` signifie « utiliser la valeur par défaut du modèle » (33 jusqu'à LTX-2.3, 18 pour LTX-2.5). Passez `0` pour ignorer la recompression. Nécessite un `PIL.Image.Image` lorsque la recompression est exécutée.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.ltx.LTX2PipelineOutput` plutôt qu'un simple tuple.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`List`, *facultatif*) : La liste des entrées de tenseurs pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.

max_sequence_length (`int`, *facultatif*, valeur par défaut `1024`) : Longueur de séquence maximale à utiliser avec le `prompt`.

**Retourne :** `~pipelines.ltx.LTX2PipelineOutput` ou `tuple`

Si `return_dict` est `True`, `~pipelines.ltx.LTX2PipelineOutput` est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant les images générées.

Fonction appelée lors de l'appel du pipeline pour la génération.

Exemples :
```py
>>> import torch
>>> from diffusers import LTX2ImageToVideoPipeline
>>> from diffusers.utils import encode_video
>>> from diffusers.utils import load_image

>>> pipe = LTX2ImageToVideoPipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> image = load_image(
...     "https://huggingface.co/datasets/a-r-r-o-w/tiny-meme-dataset-captioned/resolve/main/images/8.png"
... )
>>> prompt = "A young girl stands calmly in the foreground, looking directly at the camera, as a house fire rages in the background."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> frame_rate = 24.0
>>> video, audio = pipe(
...     image=image,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=121,
...     frame_rate=frame_rate,
...     num_inference_steps=30,
...     guidance_scale=3.0,
...     output_type="np",
...     return_dict=False,
... )

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,  # should be 24000
...     output_path="video.mp4",
... )
```

#### encode_prompt[[diffusers.LTX2ImageToVideoPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, scale_factor: int = 8, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_image2video.py#L372)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser le guidage sans classifieur ou non.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

device : (`torch.device`, *facultatif*) : appareil torch

dtype : (`torch.dtype`, *facultatif*) : torch dtype

Encode le prompt dans les états cachés de l'encodeur de texte.

#### enhance_prompt[[diffusers.LTX2ImageToVideoPipeline.enhance_prompt]]

```python
enhance_prompt(prompt: str, system_prompt: str, max_new_tokens: int | None = None, seed: int = 10, generator: typing.Optional[torch.Generator] = None, generation_kwargs: dict[str, typing.Any] | None = None, device: typing.Union[str, torch.device, NoneType] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_image2video.py#L580)

Enhances the supplied `prompt` by generating a new prompt using the prompt enhancer (a Gemma conditional-generation model) from it and a system prompt. When `image` is supplied, the enhancer is also conditioned on that reference frame (I2V / keyframe-style enhancement). Uses the dedicated `prompt_enhancer` component if one is configured (e.g. LTX-2.5, whose text encoder isn't trained for enhancement), otherwise falls back to the main `text_encoder` (LTX-2.0/2.3, which double as their own enhancer).

Les modèles de messages, les mots-clés de décodage, le nettoyage des réponses et la préparation du côté long des images correspondent à `ltx-core` / `ltx-pipelines` (`enhance_t2v` / `enhance_i2v` / `generate_enhanced_prompt`).

## LTX2ConditionPipeline[[diffusers.LTX2ConditionPipeline]]

#### diffusers.LTX2ConditionPipeline[[diffusers.LTX2ConditionPipeline]]

```python
diffusers.LTX2ConditionPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, audio_scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | None = None, processor: transformers.processing_utils.ProcessorMixin | None = None, prompt_enhancer: transformers.models.gemma4.modeling_gemma4.Gemma4ForConditionalGeneration | None = None, duration_head: diffusers.pipelines.ltx2.duration_head.LTX2DurationHead | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L266)

Pipeline de génération de vidéo permettant d'insérer des conditions d'image à des emplacements arbitraires de la vidéo.

Référence : https://github.com/Lightricks/LTX-Video

TODO

#### __appel__[[diffusers.LTX2ConditionPipeline.__call__]]

```python
__call__(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int | None = None, min_seconds: float = 1.0, max_seconds: float = 20.0, frame_rate: float = 24.0, motion_speed: float = 1.0, num_inference_steps: int = 30, sigmas: list[float] | None = None, timesteps: list[float] | None = None, guidance_scale: float = 3.0, stg_scale: float = 1.0, modality_scale: float = 3.0, guidance_rescale: float = 0.7, audio_guidance_scale: float | None = 7.0, audio_stg_scale: float | None = 1.0, audio_modality_scale: float | None = 3.0, audio_guidance_rescale: float | None = 0.7, spatio_temporal_guidance_blocks: list[int] | None = [28], noise_scale: float | None = None, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, use_cross_timestep: bool = True, system_prompt: str | None = None, enable_prompt_enhancement: bool = False, prompt_max_new_tokens: int | None = None, prompt_enhancement_kwargs: dict[str, typing.Any] | None = None, prompt_enhancement_seed: int = 10, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 1024)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L1348)

**Paramètres :**

conditions (`List[LTXVideoCondition], *optional*`) : La liste des éléments de conditionnement par image pour la génération de la vidéo.

prompt (`str` ou `List[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer `prompt_embeds` à la place.

negative_prompt (`str` ou `List[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n'est pas utilisé (`guidance_scale < 1`).

height (`int`, *facultatif*, valeur par défaut `512`) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 480 par défaut pour obtenir les meilleurs résultats.

width (`int`, *facultatif*, par défaut `768`) : La largeur en pixels de l'image générée. Cette valeur est définie sur 848 par défaut pour obtenir les meilleurs résultats.

num_frames (`int`, *facultatif*) : Le nombre de frames vidéo à générer. Si non fourni, la valeur par défaut est une durée prédite automatiquement lorsque ce pipeline possède un composant `duration_head` (checkpoints LTX-2.5 et ultérieurs), et `121` sinon. Passez un entier pour définir explicitement la longueur. Les nombres prédits automatiquement sont alignés sur la grille temporelle causale du VAE, de sorte que la durée réalisée est quantifiée (environ 0,33 s à 24 fps).

min_seconds (`float`, *facultatif*, valeur par défaut `1.0`) : Limite inférieure de la durée auto-prédite lorsque `num_frames` est omis et qu'une `duration_head` est présente. Ignoré lorsque `num_frames` est défini explicitement.

max_seconds (`float`, *facultatif*, valeur par défaut `20.0`) : Limite supérieure de la durée prédite automatiquement lorsque `num_frames` est omis et qu'une `duration_head` est présente. Ignoré lorsque `num_frames` est défini explicitement. Doit être strictement supérieur à `min_seconds`.

frame_rate (`float`, *facultatif*, par défaut `24.0`) : Le nombre d'images par seconde (FPS) de la vidéo générée.

motion_speed (`float`, *facultatif*, par défaut `1.0`) : Vitesse du mouvement par rapport au temps réel. Les embeddings positionnels sont conditionnés par `frame_rate / motion_speed`, donc les valeurs inférieures à 1 ralentissent le mouvement, par exemple `0.2` pour le ralenti 5x du LoRA Slow-Motion-Control. `frame_rate` reste le taux de lecture : la durée audio et le nombre de frames prédit en dépendent.

num_inference_steps (`int`, *facultatif*, valeur par défaut 30) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

sigmas (`List[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'il n'est pas défini, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.

timesteps (`List[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `timesteps` dans leur méthode `set_timesteps`. S'il n'est pas défini, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé. Doit être dans l'ordre décroissant.

guidance_scale (`float`, *facultatif*, valeur par défaut `4.0`) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image. Utilisé pour la modalité vidéo (une valeur distincte `audio_guidance_scale` existe pour la modalité audio).

stg_scale (`float`, *facultatif*, valeur par défaut `0.0`) : Échelle de guidage vidéo pour le Spatio-Temporal Guidance (STG), proposée dans [Spatiotemporal Skip Guidance for Enhanced Video Diffusion Sampling](https://arxiv.org/abs/2411.18664). Le STG utilise une estimation de type CFG où l’on déplace l’échantillon loin d’un échantillon faible issu d’une version perturbée du modèle de débruitage. L’activation du STG entraîne un passage avant supplémentaire du modèle de débruitage ; la valeur par défaut de `0.0` signifie que le STG est désactivé.

modality_scale (`float`, *facultatif*, valeur par défaut `1.0`) : Échelle de guidage vidéo pour l'isolation de la modalité dans le guidage LTX-2.X, où l'on déplace l'échantillon loin d'un échantillon plus faible généré par le modèle de débruitage avec l'attention croisée inter-modalités (audio-vers-vidéo et vidéo-vers-audio) désactivée, en utilisant une estimation de type CFG. L'activation du guidage de modalité entraînera un passage avant supplémentaire du modèle de débruitage ; la valeur par défaut de `1.0` signifie que le guidage de modalité est désactivé.

guidance_rescale (`float`, *facultatif*, valeur par défaut 0.0) : Facteur de rescaling du guidage proposé par [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` est défini comme `φ` dans l'équation 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Le facteur de rescaling du guidage doit corriger l'exposition excessive lors de l'utilisation d'un SNR terminal nul. Utilisé pour la modalité vidéo.

audio_guidance_scale (`float`, *facultatif* par défaut `None`) : Échelle de guidage audio pour CFG par rapport au prompt négatif. La règle de mise à jour CFG est la même pour la vidéo et l’audio, mais ils peuvent utiliser des valeurs différentes pour l’échelle de guidage. Les auteurs de LTX-2.X suggèrent que `audio_guidance_scale` doit être plus élevé par rapport à `guidance_scale` vidéo (par exemple, pour LTX-2.3, ils suggèrent 3.0 pour la vidéo et 7.0 pour l’audio). Si `None`, la valeur par défaut est la valeur vidéo `guidance_scale`.

audio_stg_scale (`float`, *facultatif*, valeur par défaut `None`) : Échelle de guidage audio pour STG. Comme pour CFG, la règle de mise à jour STG est par ailleurs identique pour la vidéo et l’audio. Pour LTX-2.3, une valeur de 1.0 est suggérée pour la vidéo et l’audio. Si `None`, la valeur par défaut est la valeur vidéo `stg_scale`.

audio_modality_scale (`float`, *facultatif*, valeur par défaut `None`) : Échelle de guidage audio pour l'isolation de la modalité dans le guidage de LTX-2.X. Comme pour le CFG, la règle de guidage de la modalité est par ailleurs identique pour la vidéo et l'audio. Pour LTX-2.3, une valeur de 3.0 est suggérée pour la vidéo et l'audio. Si `None`, la valeur par défaut est la valeur vidéo `modality_scale`.

audio_guidance_rescale (`float`, *facultatif*, valeur par défaut `None`) : Un facteur de rescaling du guidage distinct pour la modalité audio. Si `None`, la valeur par défaut est la valeur vidéo `guidance_rescale`.

spatio_temporal_guidance_blocks (`list[int]`, *facultatif*, valeur par défaut `None`) : Les indices de blocs de transformeur, indexés à partir de zéro, auxquels appliquer le STG. Doit être fourni si le STG est utilisé (`stg_scale` ou `audio_stg_scale` est supérieur à `0`). Une valeur de `[29]` est recommandée pour LTX-2.0 et `[28]` est recommandée pour LTX-2.3.

noise_scale (`float`, *facultatif*, par défaut `None`) : Le facteur d'interpolation entre le bruit aléatoire et les latents débruités à chaque pas de temps. Applique du bruit aux `latents` et aux `audio_latents` avant de poursuivre le débruitage. S'il n'est pas défini, il sera déduit de l'ordonnancement des sigmas.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre de vidéos à générer par invite.

generator (`torch.Generator` ou `List[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération de vidéos. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.

audio_latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération audio. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pré-généré pour les embeddings de texte.

negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Pour PixArt-Sigma, ce prompt négatif doit être "". S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

negative_prompt_attention_mask (`torch.FloatTensor`, *facultatif*) : Masque d'attention pré-généré pour les embeddings de texte négatif.

decode_timestep (`float`, par défaut `0.0`) : Le pas de temps auquel la vidéo générée est décodée.

decode_noise_scale (`float`, par défaut `None`) : Le facteur d'interpolation entre le bruit aléatoire et les latents débruités à l'étape de décodage.

use_cross_timestep (`bool` *facultatif*, par défaut `True`) : Indique s'il faut utiliser la sigma de la modalité croisée (l'audio est la modalité croisée de la vidéo, et vice versa) lors du calcul des paramètres de modulation de l'attention croisée. `True` correspond au comportement de LTX-2.3/2.5 ; `False` correspond au comportement hérité de LTX-2.0.

system_prompt (`str`, *facultatif*, valeur par défaut `None`) : Invite système facultative à utiliser pour l'amélioration de l'invite. L'invite système sera utilisée par l'améliorateur d'invite (un modèle de génération conditionnelle Gemma -- le composant `prompt_enhancer` dédié s'il est configuré, sinon le `text_encoder` principal) pour générer une invite améliorée à partir de l'`prompt` d'origine (et d'une image de conditionnement si disponible) afin de conditionner la génération. Si non fournie et qu'un `prompt_enhancer` dédié est configuré (LTX-2.5), la valeur par défaut est `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT` si une image de conditionnement est disponible, sinon `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` -- voir `enable_prompt_enhancement`.

enable_prompt_enhancement (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut exécuter l'amélioration du prompt. Option, conformément aux pipelines de référence Lightricks. Si `True` et que `system_prompt` est omis, LTX-2.5 choisit `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT` / `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` en fonction de la disponibilité d'une image de conditionnement.

prompt_max_new_tokens (`int`, *facultatif*, valeur par défaut `None`) : Le nombre maximal de nouveaux jetons à générer lors de l'amélioration du prompt. Si non fourni, utilise 600 pour un `prompt_enhancer` Gemma 4 dédié (LTX-2.5) ou 512 pour le repli sur le `text_encoder` Gemma 3 (LTX-2.0/2.3).

prompt_enhancement_kwargs (`dict[str, Any]`, *facultatif*, valeur par défaut `None`) : Arguments nommés pour l'appel `.generate` de l'améliorateur de prompt. S'ils ne sont pas fournis, ils correspondent toujours au modèle qui effectue l'amélioration : `do_sample=False, no_repeat_ngram_size=5` (glouton) lors de l'utilisation d'un `prompt_enhancer` dédié (LTX-2.5), ou `do_sample=True, temperature=0.7` pour le repli sur le `text_encoder` (LTX-2.0/2.3). Voir https://huggingface.co/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate pour plus de détails.

prompt_enhancement_seed (`int`, *facultatif*, valeur par défaut `10`) : Graine aléatoire pour toute opération aléatoire lors de l'amélioration du prompt.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.ltx.LTX2PipelineOutput` plutôt qu'un simple tuple.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`List`, *facultatif*) : La liste des entrées de tenseurs pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.

max_sequence_length (`int`, *facultatif*, valeur par défaut `1024`) : Longueur de séquence maximale à utiliser avec le `prompt`.

**Retourne :** `~pipelines.ltx.LTX2PipelineOutput` ou `tuple`

Si `return_dict` est `True`, `~pipelines.ltx.LTX2PipelineOutput` est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant les images générées.

Fonction appelée lors de l'appel du pipeline pour la génération.

Exemples :
```py
>>> import torch
>>> from diffusers import LTX2ConditionPipeline
>>> from diffusers.utils import encode_video
>>> from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
>>> from diffusers.utils import load_image

>>> pipe = LTX2ConditionPipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> first_image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_first_frame.png"
... )
>>> last_image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_last_frame.png"
... )
>>> first_cond = LTX2VideoCondition(frames=first_image, index=0, strength=1.0)
>>> last_cond = LTX2VideoCondition(frames=last_image, index=-1, strength=1.0)
>>> conditions = [first_cond, last_cond]
>>> prompt = "CG animation style, a small blue bird takes off from the ground, flapping its wings."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted, static"

>>> frame_rate = 24.0
>>> video = pipe(
...     conditions=conditions,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=121,
...     frame_rate=frame_rate,
...     num_inference_steps=30,
...     guidance_scale=3.0,
...     output_type="np",
...     return_dict=False,
... )
>>> video = (video * 255).round().astype("uint8")
>>> video = torch.from_numpy(video)

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,  # should be 24000
...     output_path="video.mp4",
... )
```

#### apply_first_frame_conditioning[[diffusers.LTX2ConditionPipeline.apply_first_frame_conditioning]]

```python
apply_first_frame_conditioning(latents: Tensor, conditioning_mask: Tensor, condition_latents: list[torch.Tensor], condition_strengths: list[float], condition_indices: list[int], latent_height: int, latent_width: int)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L964)

**Paramètres :**

latents (`torch.Tensor`) : Latents initiaux empilés (patchifiés) de forme [batch_size, patch_seq_len, hidden_dim].

conditioning_mask (`torch.Tensor`) : masque de conditionnement initial, empaqueté (patchifié), de forme [batch_size, patch_seq_len, 1], avec des valeurs dans [0, 1], où 0 signifie que la sortie du modèle de débruitage sera entièrement utilisée et 1 signifie que la condition sera entièrement utilisée.

**Retourne :** `Tuple[torch.Tensor, torch.Tensor, torch.Tensor]`

Retourne un 3-tuple de tenseurs où :
1. Les latents vidéo empilés avec les conditions de la première image appliquées.
2. Le masque de conditionnement compact avec les intensités de la première image appliquées.
3. Les latents de conditionnement propres aux positions de la première image (zéros ailleurs).

Appliquez le conditionnement visuel de la première image en écrasant les jetons aux positions de la première image.

Seules les conditions pour lesquelles `latent_idx == 0` sont appliquées ici (correspondant à `VideoConditionByLatentIndex` dans l’implémentation de référence). Les conditions aux indices latents non nuls sont ajoutées en tant que jetons de keyframe distincts via `prepare_keyframe_extras` (correspondant à `VideoConditionByKeyframeIndex`) et sont ignorées ici.

#### encode_prompt[[diffusers.LTX2ConditionPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, scale_factor: int = 8, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L419)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser le guidage sans classifieur ou non.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

device : (`torch.device`, *facultatif*) : appareil torch

dtype : (`torch.dtype`, *facultatif*) : torch dtype

Encode le prompt dans les états cachés de l'encodeur de texte.

#### enhance_prompt[[diffusers.LTX2ConditionPipeline.enhance_prompt]]

```python
enhance_prompt(prompt: str, system_prompt: str, max_new_tokens: int | None = None, seed: int = 10, generator: typing.Optional[torch.Generator] = None, generation_kwargs: dict[str, typing.Any] | None = None, device: typing.Union[str, torch.device, NoneType] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L627)

Enhances the supplied `prompt` by generating a new prompt using the prompt enhancer (a Gemma conditional-generation model) from it and a system prompt. When `image` is supplied, the enhancer is also conditioned on that reference frame (I2V / keyframe-style enhancement). Uses the dedicated `prompt_enhancer` component if one is configured (e.g. LTX-2.5, whose text encoder isn't trained for enhancement), otherwise falls back to the main `text_encoder` (LTX-2.0/2.3, which double as their own enhancer).

Les modèles de messages, les mots-clés de décodage, le nettoyage des réponses et la préparation du côté long des images correspondent à `ltx-core` / `ltx-pipelines` (`enhance_t2v` / `enhance_i2v` / `generate_enhanced_prompt`).

#### prepare_latents[[diffusers.LTX2ConditionPipeline.prepare_latents]]

```python
prepare_latents(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, batch_size: int = 1, num_channels_latents: int = 128, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, noise_scale: float = 1.0, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L1071)

Préparez les latents vidéo bruités en appliquant les conditions de cadre.

Les conditions de la première image (`latent_idx == 0`) sont appliquées en écrasant les jetons aux positions de la première image (sémantique de `VideoConditionByLatentIndex`). Les conditions non liées à la première image (`latent_idx > 0`) sont concaténées à la séquence latente principale avec un `conditioning_mask = strength` par jeton (sémantique de `VideoConditionByKeyframeIndex`) — la formule de pas de temps existante de la boucle de débruitage `t * (1 - conditioning_mask)` et le mélange post-traitement `denoised * (1 - conditioning_mask) + clean * conditioning_mask` les pilotent ensuite au fil des étapes.

Retourne un 4-uplet :
- `latents` : latents bruités empilés (jetons de base + jetons de keyframe concaténés sur la dimension de la séquence).
- `conditioning_mask` : masque de conditionnement compact avec des valeurs dans `[0, 1]` — `1` aux positions de la première image, `strength` aux positions des images clés, `0` ailleurs.
- `clean_latents` : valeurs de conditionnement propres aux positions conditionnées (zéros ailleurs) ; même forme que `latents`.
- `keyframe_coords` : coordonnées positionnelles `[B, 3, num_keyframe_patches, 2]` à ajouter à `video_coords`, ou `None` s'il n'y a pas de conditions autres que la première image.

#### preprocess_conditions[[diffusers.LTX2ConditionPipeline.preprocess_conditions]]

```python
preprocess_conditions(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, device: typing.Optional[torch.device] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L846)

**Paramètres :**

conditions (`LTX2VideoCondition` ou `List[LTX2VideoCondition]`, *facultatif*, valeur par défaut `None`) : Une liste d'instances de conditions image/vidéo.

height (`int`, *facultatif*, valeur par défaut `512`) : La hauteur souhaitée en pixels.

width (`int`, *facultatif*, par défaut `768`) : La largeur souhaitée en pixels.

num_frames (`int`, *facultatif*, valeur par défaut `121`) : Le nombre de frames souhaité dans la vidéo générée.

device (`torch.device`, *facultatif*, par défaut `None`) : L'appareil sur lequel placer les tenseurs d'images/vidéos prétraitées.

**Retourne :** `Tuple[List[torch.Tensor], List[float], List[int], List[int]]`

Retourne un 4-uplet de listes de longueur `len(conditions)` comme suit :
1. La première liste est une liste de tenseurs vidéo prétraités de forme [batch_size=1, num_channels, num_frames, height, width].
2. La deuxième liste est une liste de forces de conditionnement.
3. La troisième liste est une liste d'indices de l'espace latent pour chaque condition.
4. La quatrième liste est une liste de nombres de trames (rognées) dans l'espace des pixels par condition. Elle est nécessaire pour la sémantique des coordonnées des images clés (les images clés d'une seule trame de pixel ont une étendue temporelle bornée).

Prétraite les images/vidéos de condition en tenseurs torch.

#### trim_conditioning_sequence[[diffusers.LTX2ConditionPipeline.trim_conditioning_sequence]]

```python
trim_conditioning_sequence(start_frame: int, sequence_num_frames: int, target_num_frames: int)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L829)

**Paramètres :**

start_frame (int) : Le numéro de la cible de la première image de la séquence.

sequence_num_frames (int) : Le nombre de frames dans la séquence.

target_num_frames (int) : Le nombre de frames cible dans la vidéo générée.

**Retourne :** `int`

longueur de séquence mise à jour

Réduire une séquence de conditionnement au nombre de frames autorisé.

## LTX2DFRPipeline[[diffusers.LTX2DFRPipeline]]

#### diffusers.LTX2DFRPipeline[[diffusers.LTX2DFRPipeline]]

```python
diffusers.LTX2DFRPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, processor: transformers.processing_utils.ProcessorMixin | None = None, prompt_enhancer: transformers.models.gemma4.modeling_gemma4.Gemma4ForConditionalGeneration | None = None, duration_head: diffusers.pipelines.ltx2.duration_head.LTX2DurationHead | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L122)

**Paramètres :**

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents vidéo encodés.

vae ([AutoencoderKLLTX2Video](/docs/diffusers/main/fr/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video)) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos à partir de représentations latentes et inversement.

audio_vae ([AutoencoderKLLTX2Audio](/docs/diffusers/main/fr/api/models/autoencoderkl_audio_ltx_2#diffusers.AutoencoderKLLTX2Audio)) : VAE audio pour encoder et décoder des spectrogrammes audio.

text_encoder (`Gemma3ForConditionalGeneration` ou `Gemma4UnifiedForConditionalGeneration`) : modèle d'encodeur de texte.

tokenizer (`GemmaTokenizer` ou `GemmaTokenizerFast`) : Tokenizer pour l'encodeur de texte.

connectors (`LTX2TextConnectors`) : Pile de connecteurs de texte utilisée pour adapter les états cachés de l'encodeur de texte aux branches vidéo et audio.

transformer ([LTX2VideoTransformer3DModel](/docs/diffusers/main/fr/api/models/ltx2_video_transformer3d#diffusers.LTX2VideoTransformer3DModel)) : architecture Transformer conditionnelle pour le débruitage des latents vidéo encodés.

vocoder (`LTX2Vocoder` ou `LTX2VocoderWithBWE`) : Vocodeur pour convertir les spectrogrammes de mel en formes d'onde audio.

processor (`ProcessorMixin`, *facultatif*) : Processeur utilisé pour le chat templating et l'amélioration des prompts.

prompt_enhancer (`Gemma4ForConditionalGeneration`, *facultatif*) : Modèle dédié à l'amélioration des prompts (LTX-2.5).

duration_head (`LTX2DurationHead`, *facultatif*) : Prédit `num_frames` à partir des embeddings du prompt lorsque `num_frames` n'est pas fourni.

Pipeline pour un passage de débruitage Diffusion Fidelity Rendering (DFR) avec LTX-2.5.

Un passage génère une vidéo *et* des emplacements de keyframes supplémentaires à un seul pixel, ou redébruite des latents fournis initialisés à partir de ces emplacements. Les appelants composent les étapes : ce pipeline à la moitié de la résolution, [LTX2LatentUpsamplePipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2LatentUpsamplePipeline) spatialement, ce pipeline à nouveau à la résolution complète avec les emplacements suréchantillonnés et une référence IC-LoRA, puis [LTX2DFRTemporalRefinePipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRTemporalRefinePipeline) pour chaque tour de raffinement temporel. Consultez la documentation LTX-2 pour la recette 1080p.

Les positions des slots proviennent d'une grille de segments alignée sur la frontière temporelle du VAE (`resolve_canvas`). La grille est rembourrée pour atteindre un nombre entier de segments ; `output_type="latent"` renvoie cette grille rembourrée afin qu'aucun slot situé sur le rembourrage ne soit supprimé. Utilisez `trim_canvas` avant le décodage VAE.

Nécessite un transformer dont la configuration définit `use_keyframes_abs_pos_embedding` (LTX-2.5 et versions ultérieures) lorsque `generate_slots=True`.

Référence : https://github.com/Lightricks/LTX-2

#### __appel__[[diffusers.LTX2DFRPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 704, width: int = 1216, num_frames: int | None = None, frame_rate: float = 24.0, min_seconds: float = 1.0, max_seconds: float = 20.0, latents: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, keyframes_latents: typing.Optional[torch.Tensor] = None, keyframe_positions: list[int] | None = None, reference_latents: typing.Optional[torch.Tensor] = None, reference_downscale_factor: int = 2, guidance_keyframe_latents: typing.Optional[torch.Tensor] = None, guidance_keyframe_positions: list[int] | None = None, guidance_keyframe_strength: float = 1.0, generate_slots: bool = True, sigmas: list[float] = [1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875], noise_scale: float | None = None, freeze_audio: bool = False, video_tiles: list[diffusers.pipelines.ltx2.dfr_layout.LTX2DFREpilogueTile] | None = None, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, use_cross_timestep: bool = True, system_prompt: str | None = None, enable_prompt_enhancement: bool = False, prompt_max_new_tokens: int | None = None, prompt_enhancement_kwargs: dict[str, typing.Any] | None = None, prompt_enhancement_seed: int = 10, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 1024)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L1522)

**Paramètres :**

prompt (`str` ou `List[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération de la vidéo. S'il n'est pas défini, il faut passer `prompt_embeds`.

conditions (`LTX2VideoCondition` ou `List[LTX2VideoCondition]`, *facultatif*) : Conditions d'image ou de vidéo au niveau des images. `index` est un index *latent* sur `num_frames` de ce passage.

height (`int`, *facultatif*, valeur par défaut `704`) : La hauteur en pixels de **cette passe**, et non celle de la sortie finale composée.

width (`int`, *facultatif*, valeur par défaut `1216`) : La largeur en pixels de ce passage.

num_frames (`int`, *facultatif*) : Nombre de trames de pixels de ce passage, avant le bourrage interne du canevas. S'il n'est pas fourni, la durée est prédite à partir du prompt par le `duration_head`. Doit satisfaire à `(num_frames - 1) % 8 == 0`.

frame_rate (`float`, *facultatif*, valeur par défaut `24.0`) : FPS de lecture de ce passage. Le temps RoPE est arrondi à 60 lorsque cette valeur est supérieure à 30.

min_seconds (`float`, *facultatif*, valeur par défaut `1.0`) : Limite inférieure de la durée auto-prédite lorsque `num_frames` est omis.

max_seconds (`float`, *facultatif*, valeur par défaut `20.0`) : Limite supérieure de la durée auto-prédite lorsque `num_frames` est omis.

latents (`torch.Tensor`, *facultatif*) : Latents vidéo bruts `(batch_size, channels, frames, height, width)` à redébruitiser (étape 2 / épilogue).

audio_latents (`torch.Tensor`, *facultatif*) : Latents audio bruts non décompressés de forme `(batch_size, channels, length, mel_bins)`. L'étape 2 exécute toujours un passage audio conjoint ; la forme d'onde livrée d'une recette composée est celle de l'étape 1, que l'appelant conserve.

keyframes_latents (`torch.Tensor`, *facultatif*) : valeurs initiales brutes des slots de forme `(batch_size, channels, num_slots, height, width)`, utilisées lorsque `generate_slots=True`.

keyframe_positions (`list[int]`, *facultatif*) : Indices des trames de pixels des créneaux générés. Par défaut, `resolve_canvas(num_frames)`.

reference_latents (`torch.Tensor`, *facultatif*) : Vidéo de référence brute IC-LoRA (généralement les images de l'étape 1).

reference_downscale_factor (`int`, *facultatif*, valeur par défaut `2`) : Ratio entre ce passage et la résolution de référence, utilisé pour mettre à l'échelle les coordonnées des jetons de référence.

guidance_keyframe_latents (`torch.Tensor`, *facultatif*) : Clés d'ancrage brutes épinglées `(batch_size, channels, K, height, width)` — le chemin épilogue. Pas des emplacements générés.

guidance_keyframe_positions (`list[int]`, *facultatif*) : Indices des trames de pixels pour `guidance_keyframe_latents`.

guidance_keyframe_strength (`float`, *facultatif*, par défaut `1.0`) : Intensité du conditionnement pour les images clés de guidage épinglées.

generate_slots (`bool`, *facultatif*, par défaut `True`) : Ajoute les jetons de slot-image-clé générés. L'épilogue définit cette valeur sur `False` et fixe `guidance_keyframe_latents` à la place.

sigmas (`list[float]`, *facultatif*) : Plan de bruit pour ce passage, sans le terminal `0.0`.

noise_scale (`float`, *facultatif*) : Niveau de bruit auquel commencent les jetons non conditionnés. Par défaut, `sigmas[0]`.

freeze_audio (`bool`, *facultatif*, valeur par défaut `False`) : Conserver l'audio à sigma 0 (épilogue / lorsqu'il suit une forme d'onde de l'étape 1 figée).

video_tiles (`list[LTX2DFREpilogueTile]`, *facultatif*) : Tiling de l'épilogue issu de `epilogue_tiles()`, permettant ainsi de faire avancer un seul canevas même si la résolution est trop grande pour un seul passage avant : chaque étape exécute le transformer une fois par tuile et fusionne les prédictions. Résolu en un plan de jetons par rapport aux coordonnées RoPE propres à ce passage, ce qui explique pourquoi la disposition est transmise plutôt que le plan — les coordonnées n'existent qu'une fois [prepare_latents()](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipeline.prepare_latents) exécuté.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre de vidéos à générer par invite.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Générateur(s) aléatoire(s) pour la reproductibilité.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées.

prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pré-généré pour les embeddings de texte.

decode_timestep (`float`, par défaut `0.0`) : Le pas de temps auquel la vidéo générée est décodée.

decode_noise_scale (`float`, par défaut `None`) : Échelle du bruit lors du décodage.

use_cross_timestep (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser la sigma inter-modalité pour la modulation de l'attention croisée. `True` pour LTX-2.3+.

system_prompt (`str`, *facultatif*) : Invite système facultative pour l'amélioration de l'invite. Voir `enable_prompt_enhancement`.

enable_prompt_enhancement (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut exécuter l'amélioration du prompt.

prompt_max_new_tokens (`int`, *facultatif*) : Le nombre maximal de nouveaux jetons à générer lors de l'amélioration du prompt.

prompt_enhancement_kwargs (`dict[str, Any]`, *facultatif*) : Arguments par mot-clé pour l'appel `.generate` de l'améliorateur de prompt.

prompt_enhancement_seed (`int`, *facultatif*, valeur par défaut `10`) : Graine aléatoire pour toute opération aléatoire lors de l'amélioration du prompt.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Format de sortie. Choisissez `"pil"`, `"np"`, `"pt"` ou `"latent"`. La sortie latente est le canevas non rogné.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [LTX2DFRPipelineOutput](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) ou un simple tuple `(frames, audio, keyframes, keyframe_positions)`.

attention_kwargs (`dict`, *facultatif*) : Arguments supplémentaires transmis au processeur d'attention.

callback_on_step_end (`Callable`, *facultatif*) : Une fonction appelée à la fin de chaque étape de débruitage.

callback_on_step_end_tensor_inputs (`List`, *facultatif*, par défaut `["latents"]`) : entrées Tensor pour la fonction de rappel.

max_sequence_length (`int`, *facultatif*, valeur par défaut `1024`) : Longueur maximale de la séquence pour le prompt texte.

**Retourne :** [LTX2DFRPipelineOutput](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) ou `tuple`

Si `return_dict` est `True`, [LTX2DFRPipelineOutput](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) est retourné, sinon un `tuple` de `(video, audio, keyframes, keyframe_positions)` est retourné.

Fonction appelée lors de l'appel du pipeline pour la génération.

Un passage de débruitage à `height` × `width`. Composez les étapes dans l'appelant : ce pipeline à la moitié de la résolution, un échantillonnage spatial ascendant, ce pipeline à nouveau avec `latents` / `keyframes_latents` / `reference_latents`, puis [LTX2DFRTemporalRefinePipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRTemporalRefinePipeline) pour chaque passe temporelle.

Exemples :
```py
>>> import torch
>>> from diffusers import LTX2DFRPipeline
>>> from diffusers.utils import encode_video

>>> pipe = LTX2DFRPipeline.from_pretrained("Lightricks/LTX-2.5-Diffusers", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> frame_rate = 24.0
>>> video, audio, _, _ = pipe(
...     prompt="A tabby cat stretching in a sunlit window, dust motes drifting in the light",
...     height=704,
...     width=1216,
...     num_frames=121,
...     frame_rate=frame_rate,
...     output_type="np",
...     return_dict=False,
... )

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
...     output_path="dfr_output.mp4",
... )
```

#### denoise[[diffusers.LTX2DFRPipeline.denoise]]

```python
denoise(latents: Tensor, conditioning_mask: Tensor, clean_latents: Tensor, video_coords: Tensor, keyframes_mask: Tensor, prompt_embeds: Tensor, audio_prompt_embeds: Tensor, prompt_attention_mask: Tensor, sigmas: list[float], frame_rate: float, audio_latents: Tensor, freeze_audio: bool = False, video_tile_plan: list | None = None, generator: typing.Optional[torch.Generator] = None, use_cross_timestep: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, progress_bar = None, step_offset: int = 0, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L1225)

**Paramètres :**

sigmas (`list[float]`) : Plan de bruit pour ce passage, sans le terminal `0.0`.

freeze_audio (`bool`, *facultatif*, valeur par défaut `False`) : Conserve `audio_latents` propre (pas de temps/sigma 0, aucune étape Euler audio) tout en exécutant l'attention croisée audio-verso-vidéo. Ignoré lorsque `audio_latents` est `None`.

video_tile_plan (`list`, *facultatif*) : Plan de jetons par tuile issu de `video_tile_plan`[`~diffusers.pipelines.ltx2.dfr_layout.video_tile_plan`]. S'il est fourni, chaque étape exécute le transformer une fois par tuile et fusionne les prédictions, de sorte que l'échantillonneur parcourt toujours un seul canevas complet et que les tuiles concordent sur leurs chevauchements à chaque étape.

generator (`torch.Generator`, *facultatif*) : Transmis à `LTXEulerAncestralRFScheduler.step()`. Les tuiles temporelles passent une graine par tuile afin que les tirages ancestraux ne partagent pas un flux et ne consomment pas l'état que le bruitage initial de la tuile suivante lit. L'Euler distillé ne le lit pas.

step_offset (`int`) : Index de la première étape de ce passage dans l'ensemble du plan de la pipeline, utilisé pour `callback_on_step_end` et la barre de progression partagée.

Effectuer un passage de débruitage DFR sur `sigmas` et retourner `(latents, audio_latents)`, tous deux encore empilés.

L’horaire distillé est utilisé sans guidage sans classifieur, ce qui correspond à un seul appel au transformeur par étape. Chaque passe exécute les deux flux, car la branche vidéo a besoin de l’attention intermodale, même lorsque l’audio qu’elle produit est jeté. `freeze_audio=True` maintient le flux audio à sigma 0 (aucune étape d’Euler) afin que la vidéo puisse toujours effectuer une attention croisée avec celui-ci — les tuiles de raffinement temporel et l’épilogue utilisent ce mécanisme pour suivre la parole de l’étape 1 sans que chaque tuile ne redébruite une réalisation audio différente.

Après le mélange de conditionnement x0, la vitesse est `(latents - denoised) / sigma`, de sorte qu'une étape RF `x0 = x - σ v` récupère le `denoised` mélangé. Les étapes 1 / 2 / l'épilogue conservent [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) et appliquent cette étape d'Euler telle quelle. Le raffinement temporel remplace par `LTXEulerAncestralRFScheduler` (`eta=0.5`) ; cette étape rebruit chaque jeton, il faut donc réappliquer le mélange de conditionnement par la suite, sinon les ancrages de couture de force 0,95 s'érodent.

#### encode_conditions[[diffusers.LTX2DFRPipeline.encode_conditions]]

```python
encode_conditions(conditions: list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None, height: int, width: int, num_frames: int, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, generator: typing.Optional[torch.Generator] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L1189)

Prétraitez et encodez les conditions de trame avec le VAE, positionnées par trame de pixels.

Retourne `(pixel_frame_index, latent, strength, num_pixel_frames)` pour chaque condition, prêt pour `condition_latents` de [prepare_latents()](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipeline.prepare_latents). L’encodage est maintenu séparé du placement, car les tours de raffinement temporel échelonnent la position d’une condition par `2 ** round` et la réinitialisent par tuile, et ne doivent pas réencoder la même image fixe une fois par tuile pour ce faire.

L'index retourné est sur la grille de pixels propre à `num_frames` ; le transfert sur un canevas affiné est à la charge de l'appelant.

#### encode_prompt[[diffusers.LTX2DFRPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L529)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre de vidéos à générer par invite.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pré-généré pour `prompt_embeds`.

device : (`torch.device`, *facultatif*) : appareil torch

dtype : (`torch.dtype`, *facultatif*) : torch dtype

Encode le prompt dans les états cachés de l'encodeur de texte.

DFR exécute le calendrier sigma distillé, qui est entraîné pour être utilisé sans guidage sans classifieur, il n'y a donc pas de branche négative ici.

#### enhance_prompt[[diffusers.LTX2DFRPipeline.enhance_prompt]]

```python
enhance_prompt(prompt: str, system_prompt: str, max_new_tokens: int | None = None, seed: int = 10, generator: typing.Optional[torch.Generator] = None, generation_kwargs: dict[str, typing.Any] | None = None, device: typing.Union[str, torch.device, NoneType] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L389)

Enhances the supplied `prompt` by generating a new prompt using the prompt enhancer (a Gemma conditional-generation model) from it and a system prompt. When `image` is supplied, the enhancer is also conditioned on that reference frame (I2V / keyframe-style enhancement). Uses the dedicated `prompt_enhancer` component if one is configured (e.g. LTX-2.5, whose text encoder isn't trained for enhancement), otherwise falls back to the main `text_encoder` (LTX-2.0/2.3, which double as their own enhancer).

Les modèles de messages, les mots-clés de décodage, le nettoyage des réponses et la préparation du côté long des images correspondent à `ltx-core` / `ltx-pipelines` (`enhance_t2v` / `enhance_i2v` / `generate_enhanced_prompt`).

#### prepare_latents[[diffusers.LTX2DFRPipeline.prepare_latents]]

```python
prepare_latents(conditions: list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, condition_latents: list[tuple[int, torch.Tensor, float, int]] | None = None, keyframe_latents: list[tuple[int, torch.Tensor, float]] | None = None, slot_frame_indices: list[int] | None = None, slot_initial_latents: typing.Optional[torch.Tensor] = None, reference_latents: typing.Optional[torch.Tensor] = None, reference_downscale_factor: int = 1, batch_size: int = 1, num_channels_latents: int = 128, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, noise_scale: float = 1.0, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None, latents_normalized: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L886)

**Paramètres :**

conditions (`list[LTX2VideoCondition]`, *facultatif*) : Conditions d'image / vidéo au niveau des images, positionnées par index latent.

condition_latents (`list[tuple[int, torch.Tensor, float, int]]`, *facultatif*) : Représentation déjà encodée de `conditions`, sous la forme `(pixel_frame_index, latent, strength, num_pixel_frames)`. L'index est en pixels plutôt qu'en latents, car une passe de raffinement temporel multiplie la position d'une condition par `2 ** round` et le résultat ne tombe généralement pas sur une frontière latente — seul un jeton de planche-clé ajouté peut s'y situer, et il est placé par pixel. `pixel_frame_index == 0` signifie toujours « remplacer la première image ».

keyframe_latents (`list[tuple[int, torch.Tensor, float]]`, *facultatif*) : guidage de keyframes déjà encodé sous forme de `(pixel_frame_index, latent, strength)`, où `latent` a la forme `(batch_size, num_channels_latents, 1, latent_height, latent_width)`. Utilisé par les tours de raffinement temporel pour ancrer les keyframes de couture transmises depuis le tour précédent.

slot_frame_indices (`list[int]`, *facultatif*) : Positions des images clés générées.

slot_initial_latents (`torch.Tensor`, *facultatif*) : `(batch_size, num_channels_latents, len(slot_frame_indices), latent_height, latent_width)` contenu écrit dans les jetons de slot avant le bruitage.

reference_latents (`torch.Tensor`, *facultatif*) : `(batch_size, num_channels_latents, F, H, W)` Latent de référence IC-LoRA.

reference_downscale_factor (`int`, par défaut `1`) : Ratio entre la résolution cible et la résolution de référence.

latents (`torch.Tensor`, *facultatif*) : `(batch_size, num_channels_latents, F, H, W)` contenu initial pour les jetons de base. Les latents du pipeline public sont bruts (non normalisés) ; passez `latents_normalized=False` à cette frontière. Les boucles de tuiles qui sont déjà dans l’espace normalisé par le VAE conservent la valeur par défaut.

latents_normalized (`bool`, par défaut `True`) : Indique si `latents`, `slot_initial_latents`, `reference_latents` et `keyframe_latents` sont déjà normalisés par le VAE. Les boucles internes de tuiles passent `True` ; chaque `__call__` de pipeline passe `False`.

noise_scale (`float`, par défaut `1.0`) : Niveau de bruit auquel les jetons non conditionnés sont initialisés, c'est-à-dire la première sigma du calendrier.

**Retourne :** `tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, slice | None]`

`(latents, conditioning_mask, clean_latents, video_coords, keyframes_mask, slot_token_slice)`. `slot_token_slice` indexe les jetons de créneaux de keyframes générés dans la séquence compactée, ou `None` si aucun créneau n’a été demandé.

Préparez les latents vidéo bruités et empilés pour un passage de débruitage DFR.

La séquence compacte est disposée comme suit : `[base | keyframes | slots | reference]` :

- Les jetons de base couvrent la grille latente cible, initialisée à partir de `latents` lorsqu’ils sont fournis.
- Les conditions de trame avec `index == 0` définissent la cible propre aux positions de la première trame ; celles avec `index > 0` et chaque entrée de `keyframe_latents` sont ajoutées en tant que jetons de trame clé supplémentaires avec un masque de conditionnement par jeton égal à leur intensité.
- `slot_frame_indices` ajoute, pour chaque position, un lot de jetons de keyframe *générés* correspondant à une frame latente, avec un masque de conditionnement `0` (entièrement débruité) et une portée temporelle RoPE d’exactement une frame pixel. Ce sont les emplacements de keyframe qui confèrent à DFR ses frames supplémentaires ; `slot_initial_latents` initialise leur contenu.
- `reference_latents` ajoute le latent de résolution moitié de l’étape 1 comme référence IC-LoRA entièrement propre, avec des coordonnées spatiales mises à l’échelle par `reference_downscale_factor` afin qu’il corresponde à l’espace de coordonnées cible.

Les jetons de conditionnement ajoutés portent leur contenu dans `clean_latents` et un zéro de remplacement dans `latents`, tandis que les emplacements de images clés portent leur graine dans `latents` et des zéros dans `clean_latents` -- les `latents` retournés sont le mélange bruité des deux (voir l'étape de bruitage à la fin de cette méthode).

#### preprocess_conditions[[diffusers.LTX2DFRPipeline.preprocess_conditions]]

```python
preprocess_conditions(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, device: typing.Optional[torch.device] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L707)

**Paramètres :**

conditions (`LTX2VideoCondition` ou `List[LTX2VideoCondition]`, *facultatif*, valeur par défaut `None`) : Une liste d'instances de conditions image/vidéo.

height (`int`, *facultatif*, valeur par défaut `512`) : La hauteur souhaitée en pixels.

width (`int`, *facultatif*, par défaut `768`) : La largeur souhaitée en pixels.

num_frames (`int`, *facultatif*, valeur par défaut `121`) : Le nombre de frames souhaité dans la vidéo générée.

device (`torch.device`, *facultatif*, par défaut `None`) : L'appareil sur lequel placer les tenseurs d'images/vidéos prétraitées.

**Retourne :** `Tuple[List[torch.Tensor], List[float], List[int], List[int]]`

Retourne un 4-uplet de listes de longueur `len(conditions)` comme suit :
1. La première liste est une liste de tenseurs vidéo prétraités de forme [batch_size=1, num_channels, num_frames, height, width].
2. La deuxième liste est une liste de forces de conditionnement.
3. La troisième liste est une liste d'indices de l'espace latent pour chaque condition.
4. La quatrième liste est une liste de nombres de trames (rognées) dans l'espace des pixels par condition. Elle est nécessaire pour la sémantique des coordonnées des images clés (les images clés d'une seule trame de pixel ont une étendue temporelle bornée).

Prétraite les images/vidéos de condition en tenseurs torch.

#### rebuild_epilogue_keyframes[[diffusers.LTX2DFRPipeline.rebuild_epilogue_keyframes]]

```python
rebuild_epilogue_keyframes(keyframe_latents: Tensor, decode_timestep: float, decode_noise_scale: float, seed: int, device: device, dtype: dtype)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L1454)

**Paramètres :**

keyframe_latents (`torch.Tensor`) : Clés brutes `(batch_size, C, K, H, W)`, telles que renvoyées par un passage précédent.

seed (`int`) : Graine de base ; le plan `i` est décodé sous `seed + 4000 + i`, de sorte que les pixels d'un plan ne dépendent pas du nombre de plans décodés avant lui.

**Retourne :** `torch.Tensor`

Latents bruts `(batch_size, C, K, 2H, 2W)`, prêts à être renvoyés directement en tant que `guidance_keyframe_latents`.

Re-encodez les images clés de transport à deux fois leur résolution via le RGB.

Il s’agit d’images déjà stabilisées par les cycles de raffinement, de sorte que l’épilogue les *reçoit* plutôt qu’il ne les génère. Le décodage en pixels, l’agrandissement x2 avec Lanczos puis le réencodage préservent l’image tout en la positionnant sur la grille de sortie, ce qui permet à l’épilogue de la verrouiller parfaitement propre.

Chaque plan est décodé comme un clip d'une seule image. Le VAE est causal, donc un décodage empilé permettrait aux plans voisins de se mélanger entre eux -- ce sont des images fixes indépendantes, et non une séquence.

#### trim_conditioning_sequence[[diffusers.LTX2DFRPipeline.trim_conditioning_sequence]]

```python
trim_conditioning_sequence(start_frame: int, sequence_num_frames: int, target_num_frames: int)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L689)

**Paramètres :**

start_frame (int) : Le numéro de la cible de la première image de la séquence.

sequence_num_frames (int) : Le nombre de frames dans la séquence.

target_num_frames (int) : Le nombre de frames cible dans la vidéo générée.

**Retourne :** `int`

longueur de séquence mise à jour

Réduire une séquence de conditionnement au nombre de frames autorisé.

## LTX2DFRTemporalRefinePipeline[[diffusers.LTX2DFRTemporalRefinePipeline]]

#### diffusers.LTX2DFRTemporalRefinePipeline[[diffusers.LTX2DFRTemporalRefinePipeline]]

```python
diffusers.LTX2DFRTemporalRefinePipeline(scheduler: LTXEulerAncestralRFScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, temporal_latent_upsampler: LTX2LatentUpsamplerModel)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L151)

**Paramètres :**

scheduler (`LTXEulerAncestralRFScheduler`) : planificateur Euler ancestral dans la paramétrisation rectified-flow. À construire avec `eta=0.5` pour correspondre à la recette temporelle DFR.

vae ([AutoencoderKLLTX2Video](/docs/diffusers/main/fr/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video)) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos à partir de représentations latentes et inversement.

audio_vae ([AutoencoderKLLTX2Audio](/docs/diffusers/main/fr/api/models/autoencoderkl_audio_ltx_2#diffusers.AutoencoderKLLTX2Audio)) : VAE audio pour encoder et décoder des spectrogrammes audio.

text_encoder (`Gemma3ForConditionalGeneration` ou `Gemma4UnifiedForConditionalGeneration`) : modèle d'encodeur de texte.

tokenizer (`GemmaTokenizer` ou `GemmaTokenizerFast`) : Tokenizer pour l'encodeur de texte.

connectors (`LTX2TextConnectors`) : Pile de connecteurs de texte utilisée pour adapter les états cachés de l'encodeur de texte aux branches vidéo et audio.

transformer ([LTX2VideoTransformer3DModel](/docs/diffusers/main/fr/api/models/ltx2_video_transformer3d#diffusers.LTX2VideoTransformer3DModel)) : architecture Transformer conditionnelle pour le débruitage des latents vidéo encodés.

vocoder (`LTX2Vocoder` ou `LTX2VocoderWithBWE`) : Vocodeur pour convertir les spectrogrammes de mel en formes d'onde audio.

temporal_latent_upsampler (`LTX2LatentUpsamplerModel`) : Upsampler latent temporel x2 appliqué au début du tour.

Une passe de raffinement temporel DFR : interpoler la toile x2 dans le temps, tuiler sur les coutures des images clés, débruitage ancestral de chaque tuile, assemblage en supprimant l’intro de la tuile suivante, et fusion du sac d’images clés portées.

Le planificateur est `LTXEulerAncestralRFScheduler` (`eta=0.5` par défaut). Les étapes 1 / 2 / l'épilogue spatial restent sur [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) via [LTX2DFRPipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipeline). Appelez ce pipeline une fois par tour ; l'appelant boucle pour 2x / 4x.

Les `latents` / `keyframes_latents` / `audio_latents` entrants sont bruts (non normalisés), conformément à [LTX2Pipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2Pipeline). `keyframe_positions` doit correspondre aux positions renvoyées par le passage précédent — elles ne peuvent pas être re-déduites du `num_frames` d'origine après l'exécution d'un passage.

#### __appel__[[diffusers.LTX2DFRTemporalRefinePipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, latents: Tensor = None, keyframes_latents: Tensor = None, keyframe_positions: list[int] = None, audio_latents: Tensor = None, conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 704, width: int = 1216, num_frames: int = 121, frame_rate: float = 24.0, source_seconds: float | None = None, condition_num_frames: int | None = None, round_index: int = 1, sigmas: list[float] = [0.975, 0.909375, 0.725, 0.421875], noise_scale: float | None = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, use_cross_timestep: bool = True, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 1024)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L1349)

**Paramètres :**

prompt (`str` ou `List[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération de la vidéo. S'il n'est pas défini, il faut passer `prompt_embeds`.

latents (`torch.Tensor`) : Latents vidéo bruts de la toile **input**, `(batch_size, channels, frames, height, width)`.

keyframes_latents (`torch.Tensor`) : Images clés brutes `(batch_size, channels, K, height, width)` de la passe précédente.

keyframe_positions (`list[int]`) : Indices des trames de pixels de `keyframes_latents` sur le canevas **d'entrée**.

audio_latents (`torch.Tensor`) : Audio de l'étape 1 figé, dépaqueté et dénormalisé. Chaque tuile reçoit la tranche couvrant sa fenêtre de lecture ; l'audio renvoyé est cette forme d'onde, et non une dénormalisation par tuile.

conditions (`LTX2VideoCondition` ou `List[LTX2VideoCondition]`, *facultatif*) : Conditions au niveau des images indexées sur `condition_num_frames` (la demande d'origine). À chaque itération, la position en pixels d'une condition est multipliée par `2 ** round_index`.

height (`int`, *facultatif*, valeur par défaut `704`) : Hauteur en pixels de ce passage (identique à celle de la vidéo d'entrée).

width (`int`, *facultatif*, valeur par défaut `1216`) : Largeur en pixels de ce passage.

num_frames (`int`, *facultatif*, valeur par défaut `121`) : Nombre de trames de pixels de la **toile d'entrée** (non rognée).

frame_rate (`float`, *facultatif*, valeur par défaut `24.0`) : FPS de lecture de l'**entrée**. Le round le double.

source_seconds (`float`, *facultatif*) : Durée de l'audio de l'étape 1 figée. La valeur par défaut est `num_frames / frame_rate`, ce qui est correct pour le premier tour ; les tours suivants doivent transmettre la durée originale de l'étape 1 afin que les tuiles ne dérivent pas.

condition_num_frames (`int`, *facultatif*) : Nombre de frames `num_frames` d'origine utilisé pour encoder les `conditions`. Par défaut, `num_frames`. Après un padding ou un tour précédent, passez la requête d'origine afin que `index=-1` ne se replie pas sur la fin du contenu padding.

round_index (`int`, *facultatif*, valeur par défaut `1`) : numéro de tour basé sur 1. Les tuiles de bruit ancestral sont initialisées avec `seed + 1000 * round_index + tile`, et les conditions sont mises à l'échelle par `2 ** round_index`.

sigmas (`list[float]`, *facultatif*) : Plan de distillation pour les tuiles de ce tour, sans le `0.0` terminal.

noise_scale (`float`, *facultatif*) : Niveau de bruit auquel commencent les jetons non conditionnés. Par défaut, `sigmas[0]`.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Générateur(s) aléatoire(s) pour la reproductibilité. Les tirages ancestraux utilisent une graine distincte par tuile, dérivée de la `initial_seed()` de ce générateur.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées.

prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pré-généré pour les embeddings de texte.

decode_timestep (`float`, par défaut `0.0`) : Le pas de temps auquel la vidéo générée est décodée.

decode_noise_scale (`float`, par défaut `None`) : Échelle du bruit lors du décodage.

use_cross_timestep (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser la sigma inter-modalité pour la modulation de l'attention croisée. `True` pour LTX-2.3+.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Format de sortie. Choisissez `"pil"`, `"np"`, `"pt"` ou `"latent"`. La sortie latente est le canevas non rogné.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [LTX2DFRPipelineOutput](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) ou un simple tuple `(frames, audio, keyframes, keyframe_positions)`.

attention_kwargs (`dict`, *facultatif*) : Arguments supplémentaires transmis au processeur d'attention.

callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage, sur chaque tuile.

callback_on_step_end_tensor_inputs (`List`, *facultatif*, par défaut `["latents"]`) : entrées Tensor pour la fonction de rappel.

max_sequence_length (`int`, *facultatif*, valeur par défaut `1024`) : Longueur maximale de la séquence pour le prompt texte.

**Retourne :** [LTX2DFRPipelineOutput](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) ou `tuple`

Si `return_dict` est `True`, [LTX2DFRPipelineOutput](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) est retourné, sinon un `tuple` de `(video, audio, keyframes, keyframe_positions)` est retourné.

Exécuter une passe de raffinement temporel.

Exemples :
```py
>>> import torch
>>> from diffusers import LTX2DFRPipeline, LTX2DFRTemporalRefinePipeline, LTXEulerAncestralRFScheduler
>>> from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel

>>> pipe = LTX2DFRPipeline.from_pretrained("Lightricks/LTX-2.5-Diffusers", torch_dtype=torch.bfloat16)
>>> temporal_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
...     "path/to/converted/temporal_latent_upsampler", torch_dtype=torch.bfloat16
... )
>>> temporal_pipe = LTX2DFRTemporalRefinePipeline(
...     scheduler=LTXEulerAncestralRFScheduler(eta=0.5),
...     vae=pipe.vae,
...     audio_vae=pipe.audio_vae,
...     text_encoder=pipe.text_encoder,
...     tokenizer=pipe.tokenizer,
...     connectors=pipe.connectors,
...     transformer=pipe.transformer,
...     vocoder=pipe.vocoder,
...     temporal_latent_upsampler=temporal_upsampler,
... )
>>> # `out` is a prior DFR pass at the same spatial size, `return_dict=True`.
>>> out = temporal_pipe(
...     latents=out.frames,
...     keyframes_latents=out.keyframes,
...     keyframe_positions=out.keyframe_positions,
...     audio_latents=out.audio,
...     prompt="A tabby cat stretching in a sunlit window",
...     height=1088,
...     width=1920,
...     num_frames=121,
...     output_type="latent",
... )
```

#### denoise[[diffusers.LTX2DFRTemporalRefinePipeline.denoise]]

```python
denoise(latents: Tensor, conditioning_mask: Tensor, clean_latents: Tensor, video_coords: Tensor, keyframes_mask: Tensor, prompt_embeds: Tensor, audio_prompt_embeds: Tensor, prompt_attention_mask: Tensor, sigmas: list[float], frame_rate: float, audio_latents: Tensor, freeze_audio: bool = False, video_tile_plan: list | None = None, generator: typing.Optional[torch.Generator] = None, use_cross_timestep: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, progress_bar = None, step_offset: int = 0, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L1138)

**Paramètres :**

sigmas (`list[float]`) : Plan de bruit pour ce passage, sans le terminal `0.0`.

freeze_audio (`bool`, *facultatif*, valeur par défaut `False`) : Conserve `audio_latents` propre (pas de temps/sigma 0, aucune étape Euler audio) tout en exécutant l'attention croisée audio-verso-vidéo. Ignoré lorsque `audio_latents` est `None`.

video_tile_plan (`list`, *facultatif*) : Plan de jetons par tuile issu de `video_tile_plan`[`~diffusers.pipelines.ltx2.dfr_layout.video_tile_plan`]. S'il est fourni, chaque étape exécute le transformer une fois par tuile et fusionne les prédictions, de sorte que l'échantillonneur parcourt toujours un seul canevas complet et que les tuiles concordent sur leurs chevauchements à chaque étape.

generator (`torch.Generator`, *facultatif*) : Transmis à `LTXEulerAncestralRFScheduler.step()`. Les tuiles temporelles passent une graine par tuile afin que les tirages ancestraux ne partagent pas un flux et ne consomment pas l'état que le bruitage initial de la tuile suivante lit. L'Euler distillé ne le lit pas.

step_offset (`int`) : Index de la première étape de ce passage dans l'ensemble du plan de la pipeline, utilisé pour `callback_on_step_end` et la barre de progression partagée.

Effectuer un passage de débruitage DFR sur `sigmas` et retourner `(latents, audio_latents)`, tous deux encore empilés.

L’horaire distillé est utilisé sans guidage sans classifieur, ce qui correspond à un seul appel au transformeur par étape. Chaque passe exécute les deux flux, car la branche vidéo a besoin de l’attention intermodale, même lorsque l’audio qu’elle produit est jeté. `freeze_audio=True` maintient le flux audio à sigma 0 (aucune étape d’Euler) afin que la vidéo puisse toujours effectuer une attention croisée avec celui-ci — les tuiles de raffinement temporel et l’épilogue utilisent ce mécanisme pour suivre la parole de l’étape 1 sans que chaque tuile ne redébruite une réalisation audio différente.

Après le mélange de conditionnement x0, la vitesse est `(latents - denoised) / sigma`, de sorte qu'une étape RF `x0 = x - σ v` récupère le `denoised` mélangé. Les étapes 1 / 2 / l'épilogue conservent [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) et appliquent cette étape d'Euler telle quelle. Le raffinement temporel remplace par `LTXEulerAncestralRFScheduler` (`eta=0.5`) ; cette étape rebruit chaque jeton, il faut donc réappliquer le mélange de conditionnement par la suite, sinon les ancrages de couture de force 0,95 s'érodent.

#### encode_conditions[[diffusers.LTX2DFRTemporalRefinePipeline.encode_conditions]]

```python
encode_conditions(conditions: list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None, height: int, width: int, num_frames: int, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, generator: typing.Optional[torch.Generator] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L1101)

Prétraitez et encodez les conditions de trame avec le VAE, positionnées par trame de pixels.

Retourne `(pixel_frame_index, latent, strength, num_pixel_frames)` pour chaque condition, prêt pour `condition_latents` de [prepare_latents()](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2DFRPipeline.prepare_latents). L’encodage est maintenu séparé du placement, car les tours de raffinement temporel échelonnent la position d’une condition par `2 ** round` et la réinitialisent par tuile, et ne doivent pas réencoder la même image fixe une fois par tuile pour ce faire.

L'index retourné est sur la grille de pixels propre à `num_frames` ; le transfert sur un canevas affiné est à la charge de l'appelant.

#### encode_prompt[[diffusers.LTX2DFRTemporalRefinePipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L470)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre de vidéos à générer par invite.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pré-généré pour `prompt_embeds`.

device : (`torch.device`, *facultatif*) : appareil torch

dtype : (`torch.dtype`, *facultatif*) : torch dtype

Encode le prompt dans les états cachés de l'encodeur de texte.

DFR exécute le calendrier sigma distillé, qui est entraîné pour être utilisé sans guidage sans classifieur, il n'y a donc pas de branche négative ici.

#### prepare_latents[[diffusers.LTX2DFRTemporalRefinePipeline.prepare_latents]]

```python
prepare_latents(conditions: list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, condition_latents: list[tuple[int, torch.Tensor, float, int]] | None = None, keyframe_latents: list[tuple[int, torch.Tensor, float]] | None = None, slot_frame_indices: list[int] | None = None, slot_initial_latents: typing.Optional[torch.Tensor] = None, reference_latents: typing.Optional[torch.Tensor] = None, reference_downscale_factor: int = 1, batch_size: int = 1, num_channels_latents: int = 128, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, noise_scale: float = 1.0, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None, latents_normalized: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L828)

**Paramètres :**

conditions (`list[LTX2VideoCondition]`, *facultatif*) : Conditions d'image / vidéo au niveau des images, positionnées par index latent.

condition_latents (`list[tuple[int, torch.Tensor, float, int]]`, *facultatif*) : Représentation déjà encodée de `conditions`, sous la forme `(pixel_frame_index, latent, strength, num_pixel_frames)`. L'index est en pixels plutôt qu'en latents, car une passe de raffinement temporel multiplie la position d'une condition par `2 ** round` et le résultat ne tombe généralement pas sur une frontière latente — seul un jeton de planche-clé ajouté peut s'y situer, et il est placé par pixel. `pixel_frame_index == 0` signifie toujours « remplacer la première image ».

keyframe_latents (`list[tuple[int, torch.Tensor, float]]`, *facultatif*) : guidage de keyframes déjà encodé sous forme de `(pixel_frame_index, latent, strength)`, où `latent` a la forme `(batch_size, num_channels_latents, 1, latent_height, latent_width)`. Utilisé par les tours de raffinement temporel pour ancrer les keyframes de couture transmises depuis le tour précédent.

slot_frame_indices (`list[int]`, *facultatif*) : Positions des images clés générées.

slot_initial_latents (`torch.Tensor`, *facultatif*) : `(batch_size, num_channels_latents, len(slot_frame_indices), latent_height, latent_width)` contenu écrit dans les jetons de slot avant le bruitage.

reference_latents (`torch.Tensor`, *facultatif*) : `(batch_size, num_channels_latents, F, H, W)` Latent de référence IC-LoRA.

reference_downscale_factor (`int`, par défaut `1`) : Ratio entre la résolution cible et la résolution de référence.

latents (`torch.Tensor`, *facultatif*) : `(batch_size, num_channels_latents, F, H, W)` contenu initial pour les jetons de base. Les latents du pipeline public sont bruts (non normalisés) ; passez `latents_normalized=False` à cette frontière. Les boucles de tuiles qui sont déjà dans l’espace normalisé par le VAE conservent la valeur par défaut.

latents_normalized (`bool`, par défaut `True`) : Indique si `latents`, `slot_initial_latents`, `reference_latents` et `keyframe_latents` sont déjà normalisés par le VAE. Les boucles internes de tuiles passent `True` ; chaque `__call__` de pipeline passe `False`.

noise_scale (`float`, par défaut `1.0`) : Niveau de bruit auquel les jetons non conditionnés sont initialisés, c'est-à-dire la première sigma du calendrier.

**Retourne :** `tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, slice | None]`

`(latents, conditioning_mask, clean_latents, video_coords, keyframes_mask, slot_token_slice)`. `slot_token_slice` indexe les jetons de créneaux de keyframes générés dans la séquence compactée, ou `None` si aucun créneau n’a été demandé.

Préparez les latents vidéo bruités et empilés pour un passage de débruitage DFR.

La séquence compacte est disposée comme suit : `[base | keyframes | slots | reference]` :

- Les jetons de base couvrent la grille latente cible, initialisée à partir de `latents` lorsqu’ils sont fournis.
- Les conditions de trame avec `index == 0` définissent la cible propre aux positions de la première trame ; celles avec `index > 0` et chaque entrée de `keyframe_latents` sont ajoutées en tant que jetons de trame clé supplémentaires avec un masque de conditionnement par jeton égal à leur intensité.
- `slot_frame_indices` ajoute, pour chaque position, un lot de jetons de keyframe *générés* correspondant à une frame latente, avec un masque de conditionnement `0` (entièrement débruité) et une portée temporelle RoPE d’exactement une frame pixel. Ce sont les emplacements de keyframe qui confèrent à DFR ses frames supplémentaires ; `slot_initial_latents` initialise leur contenu.
- `reference_latents` ajoute le latent de résolution moitié de l’étape 1 comme référence IC-LoRA entièrement propre, avec des coordonnées spatiales mises à l’échelle par `reference_downscale_factor` afin qu’il corresponde à l’espace de coordonnées cible.

Les jetons de conditionnement ajoutés portent leur contenu dans `clean_latents` et un zéro de remplacement dans `latents`, tandis que les emplacements de images clés portent leur graine dans `latents` et des zéros dans `clean_latents` -- les `latents` retournés sont le mélange bruité des deux (voir l'étape de bruitage à la fin de cette méthode).

#### preprocess_conditions[[diffusers.LTX2DFRTemporalRefinePipeline.preprocess_conditions]]

```python
preprocess_conditions(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, device: typing.Optional[torch.device] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L648)

**Paramètres :**

conditions (`LTX2VideoCondition` ou `List[LTX2VideoCondition]`, *facultatif*, valeur par défaut `None`) : Une liste d'instances de conditions image/vidéo.

height (`int`, *facultatif*, valeur par défaut `512`) : La hauteur souhaitée en pixels.

width (`int`, *facultatif*, par défaut `768`) : La largeur souhaitée en pixels.

num_frames (`int`, *facultatif*, valeur par défaut `121`) : Le nombre de frames souhaité dans la vidéo générée.

device (`torch.device`, *facultatif*, par défaut `None`) : L'appareil sur lequel placer les tenseurs d'images/vidéos prétraitées.

**Retourne :** `Tuple[List[torch.Tensor], List[float], List[int], List[int]]`

Retourne un 4-uplet de listes de longueur `len(conditions)` comme suit :
1. La première liste est une liste de tenseurs vidéo prétraités de forme [batch_size=1, num_channels, num_frames, height, width].
2. La deuxième liste est une liste de forces de conditionnement.
3. La troisième liste est une liste d'indices de l'espace latent pour chaque condition.
4. La quatrième liste est une liste de nombres de trames (rognées) dans l'espace des pixels par condition. Elle est nécessaire pour la sémantique des coordonnées des images clés (les images clés d'une seule trame de pixel ont une étendue temporelle bornée).

Prétraite les images/vidéos de condition en tenseurs torch.

#### trim_conditioning_sequence[[diffusers.LTX2DFRTemporalRefinePipeline.trim_conditioning_sequence]]

```python
trim_conditioning_sequence(start_frame: int, sequence_num_frames: int, target_num_frames: int)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L630)

**Paramètres :**

start_frame (int) : Le numéro de la cible de la première image de la séquence.

sequence_num_frames (int) : Le nombre de frames dans la séquence.

target_num_frames (int) : Le nombre de frames cible dans la vidéo générée.

**Retourne :** `int`

longueur de séquence mise à jour

Réduire une séquence de conditionnement au nombre de frames autorisé.

#### upsample_latents[[diffusers.LTX2DFRTemporalRefinePipeline.upsample_latents]]

```python
upsample_latents(latents: Tensor, upsampler: LTX2LatentUpsamplerModel)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L1090)

Exécutez `upsampler` sur les latents normalisés, en effectuant un aller-retour dans l'espace latent brut du VAE, comme il l'attend.

## LTX2DFRPipelineOutput[[diffusers.LTX2DFRPipelineOutput]]

#### diffusers.LTX2DFRPipelineOutput[[diffusers.LTX2DFRPipelineOutput]]

```python
diffusers.LTX2DFRPipelineOutput(frames: Tensor, audio: Tensor, keyframes: typing.Optional[torch.Tensor] = None, keyframe_positions: list[int] | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_output.py#L27)

**Paramètres :**

frames (`torch.Tensor`, `np.ndarray` ou list[list[PIL.Image.Image]]) : Vidéo débruitée. La sortie latente est le canevas non rogné, de forme `(batch_size, num_channels, latent_frames, latent_height, latent_width)`.

audio (`torch.Tensor`, `np.ndarray`) : Latents audio ou forme d'onde associés.

keyframes (`torch.Tensor`, *facultatif*) : Latents de keyframes générés ou transmis, de forme `(batch_size, num_channels, num_keyframes, latent_height, latent_width)`. `None` lorsque `output_type != "latent"`, ou lorsque le passage n’a pas produit de slots (par exemple, un épilogue tuilé).

keyframe_positions (`list[int]`, *facultatif*) : Index de la trame pixel de chaque image clé sur la toile de ce passage ; `None` chaque fois que `keyframes` est `None`. Après un cycle temporel, ceux-ci ne peuvent plus être dérivés du `num_frames` d'origine et doivent être transmis à l'étape suivante.

Classe de sortie pour les pipelines DFR.

## LTX2LatentUpsamplePipeline[[diffusers.LTX2LatentUpsamplePipeline]]

#### diffusers.LTX2LatentUpsamplePipeline[[diffusers.LTX2LatentUpsamplePipeline]]

```python
diffusers.LTX2LatentUpsamplePipeline(vae: AutoencoderKLLTX2Video, latent_upsampler: LTX2LatentUpsamplerModel)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_latent_upsample.py#L104)

#### __appel__[[diffusers.LTX2LatentUpsamplePipeline.__call__]]

```python
__call__(video: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, spatial_patch_size: int = 1, temporal_patch_size: int = 1, latents: typing.Optional[torch.Tensor] = None, latents_normalized: bool = False, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, adain_factor: float = 0.0, tone_map_compression_ratio: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str | None = 'pil', return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_latent_upsample.py#L264)

**Paramètres :**

video (`list[PipelineImageInput]`, *facultatif*) : La vidéo à suréchantillonner (par exemple, la sortie de la première étape de LTX 2.0). Si elle n'est pas fournie, `latents` doit être fourni.

height (`int`, *facultatif*, valeur par défaut `512`) : La hauteur en pixels de la vidéo d'entrée (et non de la vidéo générée, qui aura une résolution plus élevée).

width (`int`, *facultatif*, valeur par défaut `768`) : La largeur en pixels de la vidéo d'entrée (et non de la vidéo générée, qui aura une résolution plus élevée).

num_frames (`int`, *facultatif*, par défaut `121`) : Le nombre de frames dans la vidéo d'entrée.

spatial_patch_size (`int`, *facultatif*, valeur par défaut `1`) : La taille spatiale des patches des latents vidéo. Utilisé lorsque `latents` est fourni si le dépaquetage est nécessaire.

temporal_patch_size (`int`, *facultatif*, valeur par défaut `1`) : La taille des patches temporels des latents vidéo. Utilisé lorsque `latents` est fourni si le dépaquetage est nécessaire.

latents (`torch.Tensor`, *facultatif*) : Latents vidéo pré-générés. Peut être fourni à la place de l'argument `video`. Peut être soit une séquence de patches de forme `(batch_size, seq_len, hidden_dim)`, soit un latent vidéo de forme `(batch_size, latent_channels, latent_frames, latent_height, latent_width)`.

latents_normalized (`bool`, *optional*, defaults to `False`) : If `latents` are supplied, whether the `latents` are normalized using the VAE latent mean and std. If `True`, the `latents` will be denormalized before being supplied to the latent upsampler.

decode_timestep (`float`, par défaut `0.0`) : Le pas de temps auquel la vidéo générée est décodée.

decode_noise_scale (`float`, par défaut `None`) : Le facteur d'interpolation entre le bruit aléatoire et les latents débruités à l'étape de décodage.

adain_factor (`float`, *facultatif*, valeur par défaut `0.0`) : Facteur de mélange Adaptive Instance Normalization (AdaIN) entre les latents suréchantillonnés et les latents d'origine. Doit être compris dans [-10.0, 10.0] ; fournir 0.0 (la valeur par défaut) signifie qu'AdaIN n'est pas effectué.

tone_map_compression_ratio (`float`, *facultatif*, par défaut `0.0`) : La force de compression pour le tone mapping, qui réduit la plage dynamique des valeurs latentes. Cela est utile pour régulariser les latentes à forte variance ou pour conditionner les sorties lors de la génération. Doit être compris dans [0, 1], où 0.0 (la valeur par défaut) signifie que le tone mapping n'est pas appliqué et 1.0 correspond à l'effet de compression complet.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.ltx.LTXPipelineOutput` plutôt qu'un simple tuple.

**Retourne :** `~pipelines.ltx.LTXPipelineOutput` ou `tuple`

Si `return_dict` est `True`, `~pipelines.ltx.LTXPipelineOutput` est retourné, sinon un `tuple` est retourné dont le premier élément est la vidéo upsampled.

Fonction appelée lors de l'appel du pipeline pour la génération.

Exemples :
```py
>>> import torch
>>> from diffusers import LTX2ImageToVideoPipeline, LTX2LatentUpsamplePipeline
>>> from diffusers.utils import encode_video
>>> from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
>>> from diffusers.utils import load_image

>>> pipe = LTX2ImageToVideoPipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> image = load_image(
...     "https://huggingface.co/datasets/a-r-r-o-w/tiny-meme-dataset-captioned/resolve/main/images/8.png"
... )
>>> prompt = "A young girl stands calmly in the foreground, looking directly at the camera, as a house fire rages in the background."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> frame_rate = 24.0
>>> video, audio = pipe(
...     image=image,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=121,
...     frame_rate=frame_rate,
...     num_inference_steps=40,
...     guidance_scale=4.0,
...     output_type="pil",
...     return_dict=False,
... )

>>> latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
...     "Lightricks/LTX-2", subfolder="latent_upsampler", torch_dtype=torch.bfloat16
... )
>>> upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
>>> upsample_pipe.vae.enable_tiling()
>>> upsample_pipe.to(device="cuda", dtype=torch.bfloat16)

>>> video = upsample_pipe(
...     video=video,
...     width=768,
...     height=512,
...     output_type="np",
...     return_dict=False,
... )[0]

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,  # should be 24000
...     output_path="video.mp4",
... )
```

#### adain_filter_latent[[diffusers.LTX2LatentUpsamplePipeline.adain_filter_latent]]

```python
adain_filter_latent(latents: Tensor, reference_latents: Tensor, factor: float = 1.0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_latent_upsample.py#L168)

**Paramètres :**

latents (`torch.Tensor`) : Latents d'entrée à normaliser

reference_latents (`torch.Tensor`) : Les latents de référence fournissant les statistiques de style.

factor (`float`) : Facteur de mélange entre le latent original et le latent transformé. Plage : -10.0 à 10.0, Par défaut : 1.0

**Retourne :** `torch.Tensor`

Le tenseur latent transformé

Applique la normalisation d'instance adaptative (AdaIN) à un tenseur latent en se basant sur les statistiques d'un tenseur latent de référence.

#### tone_map_latents[[diffusers.LTX2LatentUpsamplePipeline.tone_map_latents]]

```python
tone_map_latents(latents: Tensor, compression: float)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_latent_upsample.py#L196)

**Paramètres :**

latents : torch.Tensor Tenseur latent d'entrée avec une forme arbitraire. Il est attendu qu'il soit approximativement dans l'intervalle [-1, 1] ou [0, 1].

compression : float Intensité de la compression dans l'intervalle [0, 1]. - 0.0 : aucun mappage de ton (transformation identité) - 1.0 : effet de compression maximal

**Retourne :**

torch.Tensor Le tenseur latent avec mapping de tonalité, de la même forme que l'entrée.

Applique une fonction de mappage de tonalité non linéaire aux valeurs latentes afin de réduire leur plage dynamique de manière perceptuellement lisse, en utilisant une compression basée sur une sigmoïde.

Cela est utile pour régulariser les latents à forte variance ou pour conditionner les sorties lors de la génération, en particulier lors du contrôle du comportement dynamique avec un facteur de `compression`.

## LTX2VideoDiffusionDecodePipeline[[diffusers.LTX2VideoDiffusionDecodePipeline]]

#### diffusers.LTX2VideoDiffusionDecodePipeline[[diffusers.LTX2VideoDiffusionDecodePipeline]]

```python
diffusers.LTX2VideoDiffusionDecodePipeline(diffusion_decoder: LTX2VideoDiffusionDecoderModel, scheduler, vae: AutoencoderKLLTX2Video = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_diffusion_decode.py#L27)

**Paramètres :**

diffusion_decoder ([LTX2VideoDiffusionDecoderModel](/docs/diffusers/main/fr/api/models/ltx2_diffusion_decoder#diffusers.LTX2VideoDiffusionDecoderModel)) : Le décodeur vidéo par diffusion.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Planificateur pilotant les étapes de débruitage du décodeur.

vae ([AutoencoderKLLTX2Video](/docs/diffusers/main/fr/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video), *facultatif*) : Consulté uniquement pour les statistiques latentes utilisées pour la dénormalisation. S’il est omis, le pipeline utilise les valeurs par défaut de LTX-2, de sorte qu’un flux de travail de décodage uniquement n’a pas à charger un second autoencodeur.

Décoder les latents vidéo LTX-2 avec le décodeur de diffusion introduit dans LTX-2.5.

Contrairement à un décodeur convolutif, celui-ci est lui-même un petit modèle de diffusion : il débruite les pixels en fonction d’un volume de contexte construit à partir des latents, il a donc besoin d’un planificateur et d’un générateur. Associez-le à n’importe quel pipeline LTX-2 exécuté avec `output_type="latent"` en passant `denormalize=False`, car cette voie a déjà appliqué les statistiques des latents.

#### __appel__[[diffusers.LTX2VideoDiffusionDecodePipeline.__call__]]

```python
__call__(latents: Tensor, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str = 'pil', return_dict: bool = True, denormalize: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_ltx2_diffusion_decode.py#L79)

**Paramètres :**

latents (`torch.Tensor`) : Latents de forme `(B, C, F, H, W)`. Notez qu'une exécution du pipeline LTX-2 avec `output_type="latent"` renvoie des latents *déjà* dénormalisés ; passez donc `denormalize=False` pour ceux-ci.

generator (`torch.Generator`, *facultatif*) : Le décodeur échantillonne le bruit qu'il débruite, il est donc recommandé de passer un générateur pour rendre le décodage reproductible.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de la vidéo décodée. Choisissez entre `"pil"`, `"np"`, `"pt"` et `"latent"`.

return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `LTX2VideoDecodeOutput` plutôt qu'un simple tuple.

denormalize (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut appliquer les statistiques latentes avant le décodage. Définissez sur `False` si les latentes sont déjà dénormalisées.

**Retourne :** `LTX2VideoDecodeOutput` ou `tuple`

## LTX2DurationHead[[diffusers.pipelines.ltx2.LTX2DurationHead]]

#### diffusers.pipelines.ltx2.LTX2DurationHead[[diffusers.pipelines.ltx2.LTX2DurationHead]]

```python
diffusers.pipelines.ltx2.LTX2DurationHead(video_cross_attention_dim: int = 4096, audio_cross_attention_dim: int = 2048, pooler_hidden_dim: int = 256, num_queries: int = 1, num_pooler_heads: int = 4, mlp_hidden_dim: int = 256)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/duration_head.py#L81)

**Paramètres :**

video_cross_attention_dim (`int`, par défaut `4096`) : Largeur de la sortie du connecteur vidéo.

audio_cross_attention_dim (`int`, par défaut `2048`) : Largeur de la sortie du connecteur audio.

pooler_hidden_dim (`int`, par défaut `256`) : Dimension cachée partagée dans laquelle les deux modalités sont projetées.

num_queries (`int`, par défaut `1`) : Nombre de requêtes de pooling apprenables.

num_pooler_heads (`int`, par défaut `4`) : Têtes d'attention utilisées par le pooler.

mlp_hidden_dim (`int`, par défaut `256`) : Largeur cachée du MLP de sortie. Préfixé par un suffixe `_dim` pour éviter toute collision avec le sous-module `mlp_hidden`, que `ConfigMixin.__getattr__` masquerait autrement avec cette valeur de configuration.

Prédit la durée naturelle de la prise suggérée par une légende, à partir des sorties du connecteur texte de LTX-2.

La tête est agnostique par rapport à la modalité : passez la sortie du connecteur vidéo, celle du connecteur audio, ou les deux. Les projections d'entrée spécifiques à chaque modalité projettent chaque flux dans une dimension de pooler partagée, les embeddings de modalité apprenables étiquettent les flux afin que le pooler puisse les distinguer, et un petit MLP transforme le vectoriel poolé en durée logarithmique. La cible de régression est entraînée en secondes logarithmiques, de sorte que `forward` exponentie et que les appelants reçoivent toujours des secondes.

Disponible à partir des points de contrôle LTX-2.5.

#### forward[[diffusers.pipelines.ltx2.LTX2DurationHead.forward]]

```python
forward(video_tokens: typing.Optional[torch.Tensor] = None, audio_tokens: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/duration_head.py#L134)

**Paramètres :**

video_tokens (`torch.Tensor` de forme `(batch_size, seq_len, video_cross_attention_dim)`, *facultatif*) : Sortie du connecteur vidéo.

audio_tokens (`torch.Tensor` de forme `(batch_size, seq_len, audio_cross_attention_dim)`, *facultatif*) : Sortie du connecteur audio.

**Retourne :** `torch.Tensor` de forme `(batch_size,)`

la durée prédite en secondes.

#### predict_num_frames[[diffusers.pipelines.ltx2.LTX2DurationHead.predict_num_frames]]

```python
predict_num_frames(video_tokens: typing.Optional[torch.Tensor] = None, audio_tokens: typing.Optional[torch.Tensor] = None, frame_rate: float, temporal_compression_ratio: int, min_seconds: float = 1.0, max_seconds: float = 20.0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/duration_head.py#L172)

**Paramètres :**

video_tokens (`torch.Tensor`, *facultatif*) : Sortie du connecteur vidéo pour un prompt unique.

audio_tokens (`torch.Tensor`, *facultatif*) : sortie du connecteur audio pour un seul prompt.

frame_rate (`float`) : Nombre d'images par seconde utilisé pour convertir la durée prédite en nombre d'images.

temporal_compression_ratio (`int`) : Le ratio de compression temporelle du VAE, qui définit la grille de frames.

min_seconds (`float`, par défaut `1.0`) : Limite inférieure de la prédiction.

max_seconds (`float`, par défaut `20.0`) : Limite supérieure de la prédiction.

**Retourne :** `int`

un nombre de images aligné sur la grille temporelle du VAE.

Prédit un nombre d'images à partir des jetons de connecteur, borné à `[min_seconds, max_seconds]` et aligné sur la grille temporelle causale du VAE (`k * temporal_compression_ratio + 1`).

Le clamp est appliqué avant le snapping : un nombre de frames clamped n’est pas nécessairement aligné sur la grille, donc effectuer le snapping en premier donnerait un résultat différent. Comme le snapping arrondit par défaut, il peut aboutir en dessous du minimum ; dans ce cas, le résultat est arrondi par excès au point de grille suivant, afin que le nombre de frames reste dans les limites.

Des bornes étroites peuvent aboutir à une fenêtre de trame ne contenant aucun point de grille -- à 24 fps, `[1.0s, 1.02s]` est arrondi à `[24, 24]`, et 24 n'est pas de la forme `8k + 1`. Le point de grille le plus proche est alors utilisé et un avertissement est consigné, car dépasser la limite de moins d'un pas de grille est préférable à refuser la génération. Le nombre retourné est donc toujours aligné sur la grille, mais peut se situer juste en dehors des bornes demandées dans ce cas.

## LTX2PipelineOutput[[diffusers.pipelines.ltx2.LTX2PipelineOutput]]

#### diffusers.pipelines.ltx2.LTX2PipelineOutput[[diffusers.pipelines.ltx2.LTX2PipelineOutput]]

```python
diffusers.pipelines.ltx2.LTX2PipelineOutput(frames: Tensor, audio: Tensor)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx2/pipeline_output.py#L9)

**Paramètres :**

frames (`torch.Tensor`, `np.ndarray` ou list[list[PIL.Image.Image]]) : Liste de sorties vidéo - Il peut s'agir d'une liste imbriquée de longueur `batch_size,` où chaque sous-liste contient des séquences d'images PIL débruitées de longueur `num_frames.` Il peut également s'agir d'un tableau NumPy ou d'un tenseur Torch de forme `(batch_size, num_frames, channels, height, width)`.

audio (`torch.Tensor`, `np.ndarray`) : TODO

Classe de sortie pour les pipelines LTX.

## LTX2ModularPipeline[[diffusers.LTX2ModularPipeline]]

#### diffusers.LTX2ModularPipeline[[diffusers.LTX2ModularPipeline]]

```python
diffusers.LTX2ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/ltx2/modular_pipeline.py#L26)

Un ModularPipeline pour LTX-2 (génération conjointe de vidéo et d'audio).

## LTX2AutoBlocks[[diffusers.LTX2AutoBlocks]]

#### diffusers.LTX2AutoBlocks[[diffusers.LTX2AutoBlocks]]

```python
diffusers.LTX2AutoBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/ltx2/modular_blocks_ltx2.py#L1761)

Auto blocks pour LTX-2 prenant en charge la génération texte-vers-vidéo, image-vers-vidéo, condition-vers-vidéo et in-context (IC-LoRA) (vidéo + audio conjointes).

Workflows pris en charge :
- `text2video` : nécessite `prompt`
- `image2video` : nécessite `image`, `prompt`
- `condition` : nécessite `conditions`, `prompt`
- `in_context` : nécessite `reference_conditions`, `num_frames`, `prompt`

Composants : prompt_enhancer (`PreTrainedModel`) processor (`ProcessorMixin`) text_encoder (`PreTrainedModel`) tokenizer (`PreTrainedTokenizerBase`) connectors (`LTX2TextConnectors`) duration_head (`LTX2DurationHead`) vae (`AutoencoderKLLTX2Video`) video_processor (`VideoProcessor`) transformer (`LTX2VideoTransformer3DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) audio_vae (`AutoencoderKLLTX2Audio`) guider (`LTX2Guidance`) audio_guider (`LTX2Guidance`) vocoder (`LTX2Vocoder`)

Entrées : prompt (`str`, *facultatif*) : Le prompt ou les prompts pour guider la génération d'image. conditions (`list`, *facultatif*) : `LTX2VideoCondition` (ou une liste de ceux-ci) plaçant des conditions d'image/vidéo aux indices de trames latentes de la vidéo générée. enable_prompt_enhancement (`bool`, *facultatif*, défaut à False) : Indique s'il faut exécuter l'améliorateur de prompt. Optionnel, conformément aux pipelines de référence Lightricks. system_prompt (`str`, *facultatif*) : Prompt système pour l'amélioration. Défaut à `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT` si une trame de condition `PIL.Image.Image` est disponible, sinon `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT`. prompt_max_new_tokens (`int`, *facultatif*) : Nombre maximal de nouveaux jetons à générer lors de l'amélioration du prompt. Défaut à 600, le budget de l'améliorateur Gemma-4 de LTX-2.5. prompt_enhancement_kwargs (`dict`, *facultatif*) : Arguments par mot-clé pour l'appel `.generate` de l'améliorateur. Défaut au décodage glouton. prompt_enhancement_seed (`int`, *facultatif*, défaut à 10) : Graine aléatoire pour l'amélioration du prompt (inerte sous le décodage glouton de LTX-2.5). generator (`Generator`, *facultatif*) : Générateur Torch pour une génération déterministe. image (`Image | list`, *facultatif*) : Image(s) de référence pour le débruitage. Peut être une image unique ou une liste d'images. negative_prompt (`str`, *facultatif*) : Le prompt ou les prompts qui ne doivent pas guider la génération d'image. max_sequence_length (`int`, *facultatif*, défaut à 1024) : Longueur de séquence maximale pour l'encodage du prompt. min_seconds (`float`, *facultatif*, défaut à 1.0) : Limite inférieure de la durée prédite automatiquement. max_seconds (`float`, *facultatif*, défaut à 20.0) : Limite supérieure de la durée prédite automatiquement. Doit être strictement supérieure à `min_seconds`. frame_rate (`float`, *facultatif*, défaut à 24.0) : Nombre de trames par seconde de la vidéo générée. height (`int`, *facultatif*, défaut à 512) : La hauteur en pixels de l'image générée. width (`int`, *facultatif*, défaut à 704) : La largeur en pixels de l'image générée. image_crf (`int`, *facultatif*) : CRF H.264 utilisé pour recompresser l'`image` de conditionnement avant l'encodage VAE, correspondant à la compression contre laquelle le modèle a été entraîné. `None` (défaut) est résolu à partir de la génération de l'encodeur de texte (33 jusqu'à LTX-2.3, 18 pour LTX-2.5). Passez `0` pour ignorer la recompression. Nécessite un `PIL.Image.Image` lorsque la recompression est exécutée. num_frames (`int`, *facultatif*) : Le nombre de trames dans la vidéo générée. Omettez pour prédire automatiquement via le `duration_head` (voir `LTX2AutoDurationStep`). reference_conditions (`list`, *facultatif*) : `LTX2ReferenceCondition` (ou une liste de ceux-ci) dont les vidéos sont encodées en jetons latents supplémentaires auxquels l'adaptateur IC-LoRA prête attention. reference_downscale_factor (`int`, *facultatif*, défaut à 1) : Ratio entre les résolutions cible et de référence ; 2 signifie que la référence est prétraitée à la moitié de la résolution cible. Les coordonnées spatiales sont mises à l'échelle par ce facteur afin que les jetons de référence se situent dans l'espace de coordonnées cible. Doit correspondre au facteur avec lequel l'IC-LoRA a été entraîné. conditioning_attention_strength (`float`, *facultatif*, défaut à 1.0) : Scalaire dans [0, 1] contrôlant la force avec laquelle les jetons bruités et les jetons de référence se prêtent attention mutuellement. 1.0 (défaut) laisse l'attention non masquée. conditioning_attention_mask (`Tensor`, *facultatif*) : Masque facultatif dans l'espace pixel de forme (1, 1, F, H, W) avec des valeurs dans [0, 1] donnant une force d'attention spatialement variable. Sous-échantillonné à la grille latente de référence et multiplié par `conditioning_attention_strength`. motion_speed (`float`, *facultatif*, défaut à 1.0) : Vitesse du mouvement par rapport au temps réel. Les plongements positionnels sont conditionnés sur `frame_rate / motion_speed`, de sorte que les valeurs inférieures à 1 ralentissent le mouvement, par exemple `0.2` pour le ralenti 5x du LoRA Slow-Motion-Control. `frame_rate` reste le taux de lecture. num_videos_per_prompt (`int`, *facultatif*, défaut à 1) : Le nombre d'images à générer par prompt. condition_latents (`list`, *facultatif*) : Latents VAE normalisés par condition de forme [1, C, F, H, W]. condition_strengths (`list`, *facultatif*) : Forces de conditionnement par condition. condition_indices (`list`, *facultatif*) : Indice de trame latente par condition auquel la condition est appliquée. condition_pixel_frames (`list`, *facultatif*) : Nombre de trames pixel rognées par condition, utilisé pour limiter les coordonnées des trames clés uniques. reference_latents (`Tensor`, *facultatif*) : Jetons de référence empilés de forme [1, total_reference_tokens, C], ou `None` si aucune condition de référence n'a été fournie (`LTX2AutoReferenceEncoderStep` est ignoré). reference_coords (`Tensor`, *facultatif*) : Coordonnées RoPE pour les jetons de référence. reference_token_counts (`list`, *facultatif*) : Nombre de jetons par référence, dans l'ordre de `reference_conditions`. latents (`Tensor`) : Latents bruités pré-générés pour la génération d'image. noise_scale (`float`, *facultatif*) : Niveau de bruit initial pour les jetons non conditionnés. `None` (défaut) est résolu à `sigmas[0]` si des `sigmas` personnalisés sont fournis, sinon 1.0. sigmas (`list`, *facultatif*) : Sigmas personnalisés pour le processus de débruitage. reference_cross_mask (`Tensor`, *facultatif*) : Forces d'attention bruité<->référence par jeton de référence de forme [1, num_ref_tokens]. num_inference_steps (`int`) : Le nombre d'étapes de débruitage. timesteps (`Tensor`) : Pas de temps pour le processus de débruitage. audio_latents (`Tensor`) : Latents audio pré-encodés facultatifs ; un bruit aléatoire est utilisé s'ils ne sont pas fournis. **denoiser_input_fields (`None`, *facultatif*) : Entrées conditionnelles du modèle pour le débruiteur : par exemple prompt_embeds, negative_prompt_embeds, etc. use_cross_timestep (`bool`, *facultatif*, défaut à True) : Indique s'il faut conditionner le transformeur sur un pas de temps croisé distinct par jeton (LTX-2.3+). attention_kwargs (`dict`, *facultatif*) : Kwargs supplémentaires pour les processeurs d'attention. image_latents (`Tensor`, *facultatif*) : Latents d'image de référence encodés par VAE utilisés pour le conditionnement image-vers-vidéo. output_type (`str`, *facultatif*, défaut à pil) : Format de sortie : 'pil', 'np', 'pt'. decode_timestep (`None`, *facultatif*, défaut à 0.0) : Le pas de temps auquel le VAE décode les latents finaux. decode_noise_scale (`None`, *facultatif*) : Facteur d'interpolation du bruit appliqué aux latents au pas de temps de décodage.

Sorties : vidéos (`list`) : Les vidéos générées. audio (`Tensor`) : La forme d'onde audio générée.

## LTX25ModularPipeline[[diffusers.LTX25ModularPipeline]]

#### diffusers.LTX25ModularPipeline[[diffusers.LTX25ModularPipeline]]

```python
diffusers.LTX25ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/ltx2/modular_pipeline.py#L125)

Un ModularPipeline pour LTX-2.5 (génération conjointe de vidéo et d'audio).

Identique à [LTX2ModularPipeline](/docs/diffusers/main/fr/api/pipelines/ltx2#diffusers.LTX2ModularPipeline), à l’exception de ses blocs par défaut qui décodent avec le décodeur vidéo de diffusion, le défaut natif à partir de LTX-2.5. Un point de contrôle est routé ici via `modular_model_index.json`.

## LTX25AutoBlocks[[diffusers.LTX25AutoBlocks]]

#### diffusers.LTX25AutoBlocks[[diffusers.LTX25AutoBlocks]]

```python
diffusers.LTX25AutoBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/ltx2/modular_blocks_ltx25.py#L215)

Auto blocks pour LTX-2.5 prenant en charge la génération texte-vers-vidéo, image-vers-vidéo, condition-vers-vidéo et in-context (IC-LoRA) (vidéo + audio conjointes). Identique à `LTX2AutoBlocks` à l'exception du décodeur vidéo qui est `LTX2DiffusionVaeDecoderStep`, car le décodeur de diffusion est le défaut natif à partir de LTX-2.5. Pour décoder avec le VAE convolutif à la place, remplacez le bloc de décodage : `blocks.sub_blocks["decode"] = LTX2AutoDecoderStep()`.

Workflows pris en charge :
- `text2video` : nécessite `prompt`
- `image2video` : nécessite `image`, `prompt`
- `condition` : nécessite `conditions`, `prompt`
- `in_context` : nécessite `reference_conditions`, `num_frames`, `prompt`

Composants : prompt_enhancer (`PreTrainedModel`) processor (`ProcessorMixin`) text_encoder (`PreTrainedModel`) tokenizer (`PreTrainedTokenizerBase`) connectors (`LTX2TextConnectors`) duration_head (`LTX2DurationHead`) vae (`AutoencoderKLLTX2Video`) video_processor (`VideoProcessor`) transformer (`LTX2VideoTransformer3DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) audio_vae (`AutoencoderKLLTX2Audio`) guider (`LTX2Guidance`) audio_guider (`LTX2Guidance`) diffusion_decoder (`LTX2VideoDiffusionDecoderModel`) vocoder (`LTX2Vocoder`)

Entrées : prompt (`str`, *facultatif*) : Le prompt ou les prompts pour guider la génération d'image. conditions (`list`, *facultatif*) : `LTX2VideoCondition` (ou une liste de ceux-ci) plaçant des conditions d'image/vidéo aux indices de trames latentes de la vidéo générée. enable_prompt_enhancement (`bool`, *facultatif*, défaut à False) : Indique s'il faut exécuter l'améliorateur de prompt. Optionnel, conformément aux pipelines de référence Lightricks. system_prompt (`str`, *facultatif*) : Prompt système pour l'amélioration. Défaut à `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT` si une trame de condition `PIL.Image.Image` est disponible, sinon `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT`. prompt_max_new_tokens (`int`, *facultatif*) : Nombre maximal de nouveaux jetons à générer lors de l'amélioration du prompt. Défaut à 600, le budget de l'améliorateur Gemma-4 de LTX-2.5. prompt_enhancement_kwargs (`dict`, *facultatif*) : Arguments par mot-clé pour l'appel `.generate` de l'améliorateur. Défaut au décodage glouton. prompt_enhancement_seed (`int`, *facultatif*, défaut à 10) : Graine aléatoire pour l'amélioration du prompt (inerte sous le décodage glouton de LTX-2.5). generator (`Generator`, *facultatif*) : Générateur Torch pour une génération déterministe. image (`Image | list`, *facultatif*) : Image(s) de référence pour le débruitage. Peut être une image unique ou une liste d'images. negative_prompt (`str`, *facultatif*) : Le prompt ou les prompts qui ne doivent pas guider la génération d'image. max_sequence_length (`int`, *facultatif*, défaut à 1024) : Longueur de séquence maximale pour l'encodage du prompt. min_seconds (`float`, *facultatif*, défaut à 1.0) : Limite inférieure de la durée prédite automatiquement. max_seconds (`float`, *facultatif*, défaut à 20.0) : Limite supérieure de la durée prédite automatiquement. Doit être strictement supérieure à `min_seconds`. frame_rate (`float`, *facultatif*, défaut à 24.0) : Nombre de trames par seconde de la vidéo générée. height (`int`, *facultatif*, défaut à 512) : La hauteur en pixels de l'image générée. width (`int`, *facultatif*, défaut à 704) : La largeur en pixels de l'image générée. image_crf (`int`, *facultatif*) : CRF H.264 utilisé pour recompresser l'`image` de conditionnement avant l'encodage VAE, correspondant à la compression contre laquelle le modèle a été entraîné. `None` (défaut) est résolu à partir de la génération de l'encodeur de texte (33 jusqu'à LTX-2.3, 18 pour LTX-2.5). Passez `0` pour ignorer la recompression. Nécessite un `PIL.Image.Image` lorsque la recompression est exécutée. num_frames (`int`, *facultatif*) : Le nombre de trames dans la vidéo générée. Omettez pour prédire automatiquement via le `duration_head` (voir `LTX2AutoDurationStep`). reference_conditions (`list`, *facultatif*) : `LTX2ReferenceCondition` (ou une liste de ceux-ci) dont les vidéos sont encodées en jetons latents supplémentaires auxquels l'adaptateur IC-LoRA prête attention. reference_downscale_factor (`int`, *facultatif*, défaut à 1) : Ratio entre les résolutions cible et de référence ; 2 signifie que la référence est prétraitée à la moitié de la résolution cible. Les coordonnées spatiales sont mises à l'échelle par ce facteur afin que les jetons de référence se situent dans l'espace de coordonnées cible. Doit correspondre au facteur avec lequel l'IC-LoRA a été entraîné. conditioning_attention_strength (`float`, *facultatif*, défaut à 1.0) : Scalaire dans [0, 1] contrôlant la force avec laquelle les jetons bruités et les jetons de référence se prêtent attention mutuellement. 1.0 (défaut) laisse l'attention non masquée. conditioning_attention_mask (`Tensor`, *facultatif*) : Masque facultatif dans l'espace pixel de forme (1, 1, F, H, W) avec des valeurs dans [0, 1] donnant une force d'attention spatialement variable. Sous-échantillonné à la grille latente de référence et multiplié par `conditioning_attention_strength`. motion_speed (`float`, *facultatif*, défaut à 1.0) : Vitesse du mouvement par rapport au temps réel. Les plongements positionnels sont conditionnés sur `frame_rate / motion_speed`, donc les valeurs inférieures à 1 ralentissent le mouvement, par exemple `0.2` pour le ralenti 5x du LoRA Slow-Motion-Control. `frame_rate` reste le taux de lecture. num_videos_per_prompt (`int`, *facultatif*, défaut à 1) : Le nombre d'images à générer par prompt. condition_latents (`list`, *facultatif*) : Latents VAE normalisés par condition de forme [1, C, F, H, W]. condition_strengths (`list`, *facultatif*) : Forces de conditionnement par condition. condition_indices (`list`, *facultatif*) : Indice de trame latente par condition auquel la condition est appliquée. condition_pixel_frames (`list`, *facultatif*) : Nombre de trames pixel rognées par condition, utilisé pour limiter les coordonnées des trames clés uniques. reference_latents (`Tensor`, *facultatif*) : Jetons de référence empilés de forme [1, total_reference_tokens, C], ou `None` si aucune condition de référence n'a été fournie (`LTX2AutoReferenceEncoderStep` est ignoré). reference_coords (`Tensor`, *facultatif*) : Coordonnées RoPE pour les jetons de référence. reference_token_counts (`list`, *facultatif*) : Nombre de jetons par référence, dans l'ordre de `reference_conditions`. latents (`Tensor`) : Latents bruités pré-générés pour la génération d'image. noise_scale (`float`, *facultatif*) : Niveau de bruit initial pour les jetons non conditionnés. `None` (défaut) est résolu à `sigmas[0]` si des `sigmas` personnalisés sont fournis, sinon 1.0. sigmas (`list`, *facultatif*) : Sigmas personnalisés pour le processus de débruitage. reference_cross_mask (`Tensor`, *facultatif*) : Forces d'attention bruité<->référence par jeton de référence de forme [1, num_ref_tokens]. num_inference_steps (`int`) : Le nombre d'étapes de débruitage. timesteps (`Tensor`) : Pas de temps pour le processus de débruitage. audio_latents (`Tensor`) : Latents audio pré-encodés facultatifs ; un bruit aléatoire est utilisé s'ils ne sont pas fournis. **denoiser_input_fields (`None`, *facultatif*) : Entrées conditionnelles du modèle pour le débruiteur : par exemple prompt_embeds, negative_prompt_embeds, etc. use_cross_timestep (`bool`, *facultatif*, défaut à True) : Indique s'il faut conditionner le transformeur sur un pas de temps croisé séparé par jeton (LTX-2.3+). attention_kwargs (`dict`, *facultatif*) : Kwargs supplémentaires pour les processeurs d'attention. image_latents (`Tensor`, *facultatif*) : Latents d'image de référence encodés par VAE utilisés pour le conditionnement image-vers-vidéo. output_type (`str`, *facultatif*, défaut à pil) : Format de sortie : 'pil', 'np', 'pt'.

Sorties : vidéos (`list`) : Les vidéos générées. audio (`Tensor`) : La forme d'onde audio générée.