#
# 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-Video

[LTX-Video](https://huggingface.co/Lightricks/LTX-Video) est un diffusion transformer conçu pour la génération rapide et en temps réel de vidéos haute résolution à partir de texte et d’images. La fonctionnalité principale de LTX-Video est le Video-VAE. Le Video-VAE présente un ratio de compression pixel vers latent plus élevé (1:192), ce qui permet un traitement plus efficace des données vidéo et une vitesse de génération accrue. Pour soutenir et prévenir la perte de détails fins lors de la génération, le décodeur du Video-VAE effectue la conversion latent vers pixel *et* la dernière étape de débruitage.

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

> [!TIP]
> Cliquez sur les modèles LTX-Video dans la barre latérale droite pour voir d'autres exemples de tâches de génération de vidéos.

L'exemple ci-dessous montre comment générer une vidéo optimisée pour la mémoire ou la vitesse d'inférence.

Reportez-vous au guide [Réduire l'utilisation de la mémoire](../../optimization/memory) pour plus de détails sur les différentes techniques d'économie de mémoire.

Le modèle LTX-Video ci-dessous nécessite environ 10 Go de VRAM.

```py
import torch
from diffusers import LTXPipeline, AutoModel
from diffusers.hooks import apply_group_offloading
from diffusers.utils import export_to_video

# fp8 layerwise weight-casting
transformer = AutoModel.from_pretrained(
    "Lightricks/LTX-Video",
    subfolder="transformer",
    dtype=torch.bfloat16
)
transformer.enable_layerwise_casting(
    storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16
)

pipeline = LTXPipeline.from_pretrained("Lightricks/LTX-Video", transformer=transformer, dtype=torch.bfloat16)

# group-offloading
onload_device = torch.device("cuda")
offload_device = torch.device("cpu")
pipeline.transformer.enable_group_offload(onload_device=onload_device, offload_device=offload_device, offload_type="leaf_level", use_stream=True)
apply_group_offloading(pipeline.text_encoder, onload_device=onload_device, offload_type="block_level", num_blocks_per_group=2)
apply_group_offloading(pipeline.vae, onload_device=onload_device, offload_type="leaf_level")

prompt = """
A woman with long brown hair and light skin smiles at another woman with long blonde hair.
The woman with brown hair wears a black jacket and has a small, barely noticeable mole on her right cheek.
The camera angle is a close-up, focused on the woman with brown hair's face. The lighting is warm and 
natural, likely from the setting sun, casting a soft glow on the scene. The scene appears to be real-life footage
"""
negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

video = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=768,
    height=512,
    num_frames=161,
    decode_timestep=0.03,
    decode_noise_scale=0.025,
    num_inference_steps=50,
).frames[0]
export_to_video(video, "output.mp4", fps=24)
```

[Compilation](../../optimization/fp16#torchcompile) est lente lors de la première exécution, mais les appels suivants au pipeline sont plus rapides. Le [cache](../../optimization/cache) peut également accélérer l'inférence en stockant et en réutilisant les sorties intermédiaires.

```py
import torch
from diffusers import LTXPipeline
from diffusers.utils import export_to_video

pipeline = LTXPipeline.from_pretrained(
    "Lightricks/LTX-Video", dtype=torch.bfloat16
)

# torch.compile
pipeline.transformer.to(memory_format=torch.channels_last)
pipeline.transformer = torch.compile(
    pipeline.transformer, mode="max-autotune", fullgraph=True
)

prompt = """
A woman with long brown hair and light skin smiles at another woman with long blonde hair.
The woman with brown hair wears a black jacket and has a small, barely noticeable mole on her right cheek.
The camera angle is a close-up, focused on the woman with brown hair's face. The lighting is warm and 
natural, likely from the setting sun, casting a soft glow on the scene. The scene appears to be real-life footage
"""
negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

video = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=768,
    height=512,
    num_frames=161,
    decode_timestep=0.03,
    decode_noise_scale=0.025,
    num_inference_steps=50,
).frames[0]
export_to_video(video, "output.mp4", fps=24)
```

## Notes

- Reportez-vous aux paramètres recommandés suivants pour la génération à partir du dépôt [LTX-Video](https://github.com/Lightricks/LTX-Video).

  - Le type de données recommandé pour le transformer, le VAE et l'encodeur de texte est `torch.bfloat16`. Le VAE et l'encodeur de texte peuvent également être en `torch.float32` ou en `torch.float16`.
  - Pour les variantes distillées par guidage de LTX-Video, définissez `guidance_scale` sur `1.0`. Le `guidance_scale` de tout autre modèle doit être défini sur une valeur plus élevée, comme `5.0`, pour une bonne qualité de génération.
  - Pour les variantes de VAE prenant en compte le pas de temps (LTX-Video 0.9.1 et versions ultérieures), définissez `decode_timestep` sur `0.05` et `image_cond_noise_scale` sur `0.025`.
  - Pour les variantes qui prennent en charge l’interpolation entre plusieurs images et vidéos de conditionnement (LTX-Video 0.9.5 et versions ultérieures), utilisez des images et des vidéos similaires pour obtenir les meilleurs résultats. Un écart par rapport aux entrées de conditionnement peut entraîner des transitions abruptes dans la vidéo générée.

- LTX-Video 0.9.7 intègre un upscaler latent spatial et un transformer de 13 milliards de paramètres. Lors de l'inférence, une vidéo basse résolution est d'abord générée rapidement, puis mise à l'échelle et affinée.

  
  Afficher un exemple de code

  ```py
  import torch
  from diffusers import LTXConditionPipeline, LTXLatentUpsamplePipeline
  from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition
  from diffusers.utils import export_to_video, load_video

  pipeline = LTXConditionPipeline.from_pretrained("Lightricks/LTX-Video-0.9.7-dev", dtype=torch.bfloat16)
  pipeline_upsample = LTXLatentUpsamplePipeline.from_pretrained("Lightricks/ltxv-spatial-upscaler-0.9.7", vae=pipeline.vae, dtype=torch.bfloat16)
  pipeline.to("cuda")  # or "mps", "xpu", "cpu"
  pipe_upsample.to("cuda")
  pipeline.vae.enable_tiling()

  def round_to_nearest_resolution_acceptable_by_vae(height, width):
      height = height - (height % pipeline.vae_temporal_compression_ratio)
      width = width - (width % pipeline.vae_temporal_compression_ratio)
      return height, width

  video = load_video(
      "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input-vid.mp4"
  )[:21]  # only use the first 21 frames as conditioning
  condition1 = LTXVideoCondition(video=video, frame_index=0)

  prompt = """
  The video depicts 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.
  """
  negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"
  expected_height, expected_width = 768, 1152
  downscale_factor = 2 / 3
  num_frames = 161

  # 1. Generate video at smaller resolution
  # Text-only conditioning is also supported without the need to pass `conditions`
  downscaled_height, downscaled_width = int(expected_height * downscale_factor), int(expected_width * downscale_factor)
  downscaled_height, downscaled_width = round_to_nearest_resolution_acceptable_by_vae(downscaled_height, downscaled_width)
  latents = pipeline(
      conditions=[condition1],
      prompt=prompt,
      negative_prompt=negative_prompt,
      width=downscaled_width,
      height=downscaled_height,
      num_frames=num_frames,
      num_inference_steps=30,
      decode_timestep=0.05,
      decode_noise_scale=0.025,
      image_cond_noise_scale=0.0,
      guidance_scale=5.0,
      guidance_rescale=0.7,
      generator=torch.Generator().manual_seed(0),
      output_type="latent",
  ).frames

  # 2. Upscale generated video using latent upsampler with fewer inference steps
  # The available latent upsampler upscales the height/width by 2x
  upscaled_height, upscaled_width = downscaled_height * 2, downscaled_width * 2
  upscaled_latents = pipe_upsample(
      latents=latents,
      output_type="latent"
  ).frames

  # 3. Denoise the upscaled video with few steps to improve texture (optional, but recommended)
  video = pipeline(
      conditions=[condition1],
      prompt=prompt,
      negative_prompt=negative_prompt,
      width=upscaled_width,
      height=upscaled_height,
      num_frames=num_frames,
      denoise_strength=0.4,  # Effectively, 4 inference steps out of 10
      num_inference_steps=10,
      latents=upscaled_latents,
      decode_timestep=0.05,
      decode_noise_scale=0.025,
      image_cond_noise_scale=0.0,
      guidance_scale=5.0,
      guidance_rescale=0.7,
      generator=torch.Generator().manual_seed(0),
      output_type="pil",
  ).frames[0]

  # 4. Downscale the video to the expected resolution
  video = [frame.resize((expected_width, expected_height)) for frame in video]

  export_to_video(video, "output.mp4", fps=24)
  ```

  

- Le modèle distillé LTX-Video 0.9.7 est distillé en termes de guidance et de timesteps pour accélérer la génération. Il est nécessaire de définir `guidance_scale` sur `1.0` et de régler `num_inference_steps` entre `4` et `10` pour une bonne qualité de génération. Vous devriez également utiliser les timesteps personnalisés suivants pour obtenir les meilleurs résultats.

  - Inférence du modèle de base pour préparer le redimensionnement : `[1000, 993, 987, 981, 975, 909, 725, 0.03]`.
  - Upscaling : `[1000, 909, 725, 421, 0]`.

  
  Afficher un exemple de code

  ```py
  import torch
  from diffusers import LTXConditionPipeline, LTXLatentUpsamplePipeline
  from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition
  from diffusers.utils import export_to_video, load_video

  pipeline = LTXConditionPipeline.from_pretrained("Lightricks/LTX-Video-0.9.7-distilled", dtype=torch.bfloat16)
  pipe_upsample = LTXLatentUpsamplePipeline.from_pretrained("Lightricks/ltxv-spatial-upscaler-0.9.7", vae=pipeline.vae, dtype=torch.bfloat16)
  pipeline.to("cuda")  # or "mps", "xpu", "cpu"
  pipe_upsample.to("cuda")
  pipeline.vae.enable_tiling()

  def round_to_nearest_resolution_acceptable_by_vae(height, width):
      height = height - (height % pipeline.vae_spatial_compression_ratio)
      width = width - (width % pipeline.vae_spatial_compression_ratio)
      return height, width

  prompt = """
  artistic anatomical 3d render, utlra quality, human half full male body with transparent 
  skin revealing structure instead of organs, muscular, intricate creative patterns, 
  monochromatic with backlighting, lightning mesh, scientific concept art, blending biology 
  with botany, surreal and ethereal quality, unreal engine 5, ray tracing, ultra realistic, 
  16K UHD, rich details. camera zooms out in a rotating fashion
  """
  negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"
  expected_height, expected_width = 768, 1152
  downscale_factor = 2 / 3
  num_frames = 161

  # 1. Generate video at smaller resolution
  downscaled_height, downscaled_width = int(expected_height * downscale_factor), int(expected_width * downscale_factor)
  downscaled_height, downscaled_width = round_to_nearest_resolution_acceptable_by_vae(downscaled_height, downscaled_width)
  latents = pipeline(
      prompt=prompt,
      negative_prompt=negative_prompt,
      width=downscaled_width,
      height=downscaled_height,
      num_frames=num_frames,
      timesteps=[1000, 993, 987, 981, 975, 909, 725, 0.03],
      decode_timestep=0.05,
      decode_noise_scale=0.025,
      image_cond_noise_scale=0.0,
      guidance_scale=1.0,
      guidance_rescale=0.7,
      generator=torch.Generator().manual_seed(0),
      output_type="latent",
  ).frames

  # 2. Upscale generated video using latent upsampler with fewer inference steps
  # The available latent upsampler upscales the height/width by 2x
  upscaled_height, upscaled_width = downscaled_height * 2, downscaled_width * 2
  upscaled_latents = pipe_upsample(
      latents=latents,
      adain_factor=1.0,
      output_type="latent"
  ).frames

  # 3. Denoise the upscaled video with few steps to improve texture (optional, but recommended)
  video = pipeline(
      prompt=prompt,
      negative_prompt=negative_prompt,
      width=upscaled_width,
      height=upscaled_height,
      num_frames=num_frames,
      denoise_strength=0.999,  # Effectively, 4 inference steps out of 5
      timesteps=[1000, 909, 725, 421, 0],
      latents=upscaled_latents,
      decode_timestep=0.05,
      decode_noise_scale=0.025,
      image_cond_noise_scale=0.0,
      guidance_scale=1.0,
      guidance_rescale=0.7,
      generator=torch.Generator().manual_seed(0),
      output_type="pil",
  ).frames[0]

  # 4. Downscale the video to the expected resolution
  video = [frame.resize((expected_width, expected_height)) for frame in video]

  export_to_video(video, "output.mp4", fps=24)
  ```

  

- Le modèle distillé LTX-Video 0.9.8 est similaire à la variante 0.9.7. Il est distillé en termes de guidance et de timestep, et un code d'inférence similaire peut être utilisé comme ci-dessus. Une amélioration de cette version est qu'elle prend en charge la génération de vidéos très longues. De plus, elle prend en charge l'utilisation du tone mapping pour améliorer la qualité de la vidéo générée à l'aide du paramètre `tone_map_compression_ratio`. La valeur par défaut de `0.6` est recommandée.

  
  Afficher un exemple de code

  ```python
  import torch
  from diffusers import LTXConditionPipeline, LTXLatentUpsamplePipeline
  from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition
  from diffusers.models.latent_upscaler import LTXLatentUpsamplerModel
  from diffusers.utils import export_to_video, load_video

  pipeline = LTXConditionPipeline.from_pretrained("Lightricks/LTX-Video-0.9.8-13B-distilled", dtype=torch.bfloat16)
  # TODO: Update the checkpoint here once updated in LTX org
  upsampler = LTXLatentUpsamplerModel.from_pretrained("a-r-r-o-w/LTX-0.9.8-Latent-Upsampler", dtype=torch.bfloat16)
  pipe_upsample = LTXLatentUpsamplePipeline(vae=pipeline.vae, latent_upsampler=upsampler).to(torch.bfloat16)
  pipeline.to("cuda")  # or "mps", "xpu", "cpu"
  pipe_upsample.to("cuda")
  pipeline.vae.enable_tiling()

  def round_to_nearest_resolution_acceptable_by_vae(height, width):
      height = height - (height % pipeline.vae_spatial_compression_ratio)
      width = width - (width % pipeline.vae_spatial_compression_ratio)
      return height, width

  prompt = """The camera pans over a snow-covered mountain range, revealing a vast expanse of snow-capped peaks and valleys.The mountains are covered in a thick layer of snow, with some areas appearing almost white while others have a slightly darker, almost grayish hue. The peaks are jagged and irregular, with some rising sharply into the sky while others are more rounded. The valleys are deep and narrow, with steep slopes that are also covered in snow. The trees in the foreground are mostly bare, with only a few leaves remaining on their branches. The sky is overcast, with thick clouds obscuring the sun. The overall impression is one of peace and tranquility, with the snow-covered mountains standing as a testament to the power and beauty of nature."""
  # prompt = """A woman walks away from a white Jeep parked on a city street at night, then ascends a staircase and knocks on a door. The woman, wearing a dark jacket and jeans, walks away from the Jeep parked on the left side of the street, her back to the camera; she walks at a steady pace, her arms swinging slightly by her sides; the street is dimly lit, with streetlights casting pools of light on the wet pavement; a man in a dark jacket and jeans walks past the Jeep in the opposite direction; the camera follows the woman from behind as she walks up a set of stairs towards a building with a green door; she reaches the top of the stairs and turns left, continuing to walk towards the building; she reaches the door and knocks on it with her right hand; the camera remains stationary, focused on the doorway; the scene is captured in real-life footage."""
  negative_prompt = "bright colors, symbols, graffiti, watermarks, worst quality, inconsistent motion, blurry, jittery, distorted"
  expected_height, expected_width = 480, 832
  downscale_factor = 2 / 3
  # num_frames = 161
  num_frames = 361

  # 1. Generate video at smaller resolution
  downscaled_height, downscaled_width = int(expected_height * downscale_factor), int(expected_width * downscale_factor)
  downscaled_height, downscaled_width = round_to_nearest_resolution_acceptable_by_vae(downscaled_height, downscaled_width)
  latents = pipeline(
      prompt=prompt,
      negative_prompt=negative_prompt,
      width=downscaled_width,
      height=downscaled_height,
      num_frames=num_frames,
      timesteps=[1000, 993, 987, 981, 975, 909, 725, 0.03],
      decode_timestep=0.05,
      decode_noise_scale=0.025,
      image_cond_noise_scale=0.0,
      guidance_scale=1.0,
      guidance_rescale=0.7,
      generator=torch.Generator().manual_seed(0),
      output_type="latent",
  ).frames

  # 2. Upscale generated video using latent upsampler with fewer inference steps
  # The available latent upsampler upscales the height/width by 2x
  upscaled_height, upscaled_width = downscaled_height * 2, downscaled_width * 2
  upscaled_latents = pipe_upsample(
      latents=latents,
      adain_factor=1.0,
      tone_map_compression_ratio=0.6,
      output_type="latent"
  ).frames

  # 3. Denoise the upscaled video with few steps to improve texture (optional, but recommended)
  video = pipeline(
      prompt=prompt,
      negative_prompt=negative_prompt,
      width=upscaled_width,
      height=upscaled_height,
      num_frames=num_frames,
      denoise_strength=0.999,  # Effectively, 4 inference steps out of 5
      timesteps=[1000, 909, 725, 421, 0],
      latents=upscaled_latents,
      decode_timestep=0.05,
      decode_noise_scale=0.025,
      image_cond_noise_scale=0.0,
      guidance_scale=1.0,
      guidance_rescale=0.7,
      generator=torch.Generator().manual_seed(0),
      output_type="pil",
  ).frames[0]

  # 4. Downscale the video to the expected resolution
  video = [frame.resize((expected_width, expected_height)) for frame in video]

  export_to_video(video, "output.mp4", fps=24)
  ```

  

- LTX-Video prend en charge les LoRA avec [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_weights).

  
  Afficher un exemple de code

  ```py
  import torch
  from diffusers import LTXConditionPipeline
  from diffusers.utils import export_to_video, load_image

  pipeline = LTXConditionPipeline.from_pretrained(
      "Lightricks/LTX-Video-0.9.5", dtype=torch.bfloat16
  )

  pipeline.load_lora_weights("Lightricks/LTX-Video-Cakeify-LoRA", adapter_name="cakeify")
  pipeline.set_adapters("cakeify")

  # use "CAKEIFY" to trigger the LoRA
  prompt = "CAKEIFY a person using a knife to cut a cake shaped like a Pikachu plushie"
  image = load_image("https://huggingface.co/Lightricks/LTX-Video-Cakeify-LoRA/resolve/main/assets/images/pikachu.png")

  video = pipeline(
      prompt=prompt,
      image=image,
      width=576,
      height=576,
      num_frames=161,
      decode_timestep=0.03,
      decode_noise_scale=0.025,
      num_inference_steps=50,
  ).frames[0]
  export_to_video(video, "output.mp4", fps=26)
  ```

  

- LTX-Video prend en charge le chargement à partir de fichiers uniques, tels que des [points de contrôle GGUF](../../quantization/gguf), via [loaders.FromOriginalModelMixin.from_single_file()](/docs/diffusers/main/fr/api/loaders/single_file#diffusers.loaders.FromOriginalModelMixin.from_single_file) ou [loaders.FromSingleFileMixin.from_single_file()](/docs/diffusers/main/fr/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file).

  
  Afficher un exemple de code

  ```py
  import torch
  from diffusers.utils import export_to_video
  from diffusers import LTXPipeline, AutoModel, GGUFQuantizationConfig

  transformer = AutoModel.from_single_file(
      "https://huggingface.co/city96/LTX-Video-gguf/blob/main/ltx-video-2b-v0.9-Q3_K_S.gguf"
      quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
      dtype=torch.bfloat16
  )
  pipeline = LTXPipeline.from_pretrained(
      "Lightricks/LTX-Video",
      transformer=transformer,
      dtype=torch.bfloat16
  )
  ```

  

## LTXI2VLongMultiPromptPipeline[[diffusers.LTXI2VLongMultiPromptPipeline]]

#### diffusers.LTXI2VLongMultiPromptPipeline[[diffusers.LTXI2VLongMultiPromptPipeline]]

```python
diffusers.LTXI2VLongMultiPromptPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTXVideo, text_encoder: T5EncoderModel, tokenizer: T5TokenizerFast, transformer: LTXVideoTransformer3DModel)
```

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

**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) ou `LTXEulerAncestralRFScheduler`) : 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 (`T5TokenizerFast`) : Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).

Pipeline multi-invocations I2V (image vers vidéo) de longue durée avec parité ComfyUI.

Fonctionnalités principales :
- Échantillonnage par fenêtre glissante temporelle uniquement (aucun fractionnement spatial H/W) ; fusion autorégressive entre les fenêtres.
- Segmentation multi-invocations par fenêtre avec des transitions fluides aux têtes de fenêtre.
- Conditionnement dur de la première image via masque par jeton pour I2V.
- Contrôle de la VRAM par fenêtrage temporel et décodage VAE par tuiles.

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

#### __appel__[[diffusers.LTXI2VLongMultiPromptPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, prompt_segments: list[dict[str, Any]] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: float = 25, guidance_scale: float = 1.0, guidance_rescale: float = 0.0, num_inference_steps: int | None = 8, sigmas: list[float, torch.Tensor] | None = None, generator: torch.Generator | list[torch.Generator] | None = None, seed: int | None = 0, cond_image: 'PIL.Image.Image' | torch.Tensor | None = None, cond_strength: float = 0.5, latents: torch.Tensor | None = None, temporal_tile_size: int = 80, temporal_overlap: int = 24, temporal_overlap_cond_strength: float = 0.5, adain_factor: float = 0.25, guidance_latents: torch.Tensor | None = None, guiding_strength: float = 1.0, negative_index_latents: torch.Tensor | None = None, negative_index_strength: float = 1.0, skip_steps_sigma_threshold: float | None = 1, decode_timestep: float | None = 0.05, decode_noise_scale: float | None = 0.025, decode_horizontal_tiles: int = 4, decode_vertical_tiles: int = 4, decode_overlap: int = 3, output_type: str | None = 'latent', return_dict: bool = True, attention_kwargs: dict[str, Any] | None = None, callback_on_step_end: Callable[[int, int], None] | None = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 128)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_i2v_long_multi_prompt.py#L935)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Prompt(s) de texte positif(s) par fenêtre. Si une seule chaîne contient « | », les parties sont séparées par des barres.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Prompt(s) négatif(s) pour supprimer le contenu indésirable.

prompt_segments (`list[dict]`, *facultatif*) : Correspondance des segments avec {"start_window", "end_window", "text"} pour remplacer les invites par fenêtre.

height (`int`, par défaut `512`) : Hauteur de l'image de sortie en pixels ; doit être divisible par 32.

width (`int`, par défaut `704`) : Largeur de l'image de sortie en pixels ; doit être divisible par 32.

num_frames (`int`, par défaut `161`) : Nombre de trames de sortie (dans l'espace des pixels décodés).

frame_rate (`float`, par défaut `25`) : images par seconde ; utilisé pour normaliser les coordonnées temporelles dans `video_coords`.

guidance_scale (`float`, par défaut `1.0`) : échelle CFG ; les valeurs > 1 activent le guidage sans classifieur.

guidance_rescale (`float`, par défaut `0.0`) : Rééchelonnement facultatif pour atténuer l'exposition excessive sous CFG (voir `rescale_noise_cfg`).

num_inference_steps (`int`, *facultatif*, valeur par défaut `8`) : Étapes de débruitage par fenêtre. Ignoré si `sigmas` est fourni.

sigmas (`list[float]` ou `torch.Tensor`, *facultatif*) : Plan de sigma explicite par fenêtre ; s'il est défini, il remplace `num_inference_steps`.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Contrôle la stochastique ; une liste est acceptée, mais seul le premier élément est utilisé (batch=1).

seed (`int`, *facultatif*, valeur par défaut `0`) : Si fourni, initialise le générateur partagé pour les latents globaux et dérive un générateur local à la fenêtre avec `seed + w_start` pour chaque fenêtre temporelle.

cond_image (`PIL.Image.Image` ou `torch.Tensor`, *facultatif*) : image de conditionnement ; fixe le cadre 0 via un masque par jeton lorsque `cond_strength > 0`.

cond_strength (`float`, par défaut `0.5`) : Force du conditionnement dur de la première image (un cond_mask plus petit ⇒ une préservation plus forte).

latents (`torch.Tensor`, *facultatif*) : Latents initiaux [B, C_lat, F_lat, H_lat, W_lat] ; si None, échantillonnés avec `randn_tensor`.

temporal_tile_size (`int`, par défaut `80`) : Taille de la fenêtre temporelle (en trames décodées) ; mise à l'échelle en interne par la compression temporelle du VAE.

temporal_overlap (`int`, par défaut `24`) : Recouvrement entre les fenêtres consécutives (en trames décodées) ; mis à l'échelle en interne par la compression.

temporal_overlap_cond_strength (`float`, par défaut `0.5`) : Intensité d'injection des latents de la fin de la fenêtre précédente au début de la nouvelle fenêtre.

adain_factor (`float`, par défaut `0.25`) : force de la normalisation AdaIN pour la cohérence inter-fenêtres (0 pour désactiver).

guidance_latents (`torch.Tensor`, *facultatif*) : Latents de référence injectés à la tête de la fenêtre ; la longueur est réduite par le chevauchement pour les fenêtres suivantes.

guiding_strength (`float`, par défaut `1.0`) : Intensité d'injection pour `guidance_latents`.

negative_index_latents (`torch.Tensor`, *facultatif*) : Un latent à image unique ajouté à la tête de la fenêtre pour la sémantique « index négatif ».

negative_index_strength (`float`, par défaut `1.0`) : Intensité d'injection pour `negative_index_latents`.

skip_steps_sigma_threshold (`float`, *facultatif*, valeur par défaut `1`) : Ignore les étapes dont le sigma dépasse ce seuil.

decode_timestep (`float`, *facultatif*, par défaut `0.05`) : Timestep au moment du décodage (si le VAE prend en charge timestep_conditioning).

decode_noise_scale (`float`, *facultatif*, valeur par défaut `0.025`) : Échelle de mélange du bruit au moment du décodage (si le VAE prend en charge timestep_conditioning).

decode_horizontal_tiles (`int`, par défaut `4`) : Nombre de tuiles horizontales lors du décodage VAE.

decode_vertical_tiles (`int`, par défaut `4`) : Nombre de tuiles verticales lors du décodage VAE.

decode_overlap (`int`, par défaut `3`) : Recouvrement (en pixels latents) entre les tuiles lors du décodage VAE.

output_type (`str`, *facultatif*, par défaut `"latent"`) : Le format de sortie de la vidéo générée. Choisissez entre "latent", "pt", "np" ou "pil". Si "latent", renvoie les latents sans décodage.

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

attention_kwargs (`dict`, *facultatif*) : Paramètres d'attention supplémentaires transmis au transformeur.

callback_on_step_end (`PipelineCallback` ou `MultiPipelineCallbacks`, *facultatif*) : Hook de rappel par étape.

callback_on_step_end_tensor_inputs (`list[str]`, par défaut `["latents"]`) : Clés de locals() à passer au callback.

max_sequence_length (`int`, par défaut `128`) : Longueur maximale du tokenizer pour l'encodage du prompt.

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

Si `return_dict` est `True`, `~pipelines.ltx.LTXPipelineOutput` est renvoyé, sinon un `tuple` est renvoyé dont le premier élément est une liste contenant les images générées. Le format de sortie dépend de `output_type` :
- "latent"/"pt" : `torch.Tensor` [B, C, F, H, W] ; "latent" est dans l'espace latent normalisé, "pt" est dans l'espace de sortie du VAE.
- "np" : `np.ndarray` post-traité.
- "pil" : `list[PIL.Image.Image]` liste d'images PIL.

Générer une séquence d’images en vidéo via des fenêtres glissantes temporelles et un planification multi-invites.

Exemples :
```py
>>> import torch
>>> from diffusers import LTXEulerAncestralRFScheduler, LTXI2VLongMultiPromptPipeline

>>> pipe = LTXI2VLongMultiPromptPipeline.from_pretrained("LTX-Video-0.9.8-13B-distilled")
>>> # For ComfyUI parity, swap in the RF scheduler (keeps the original config).
>>> pipe.scheduler = LTXEulerAncestralRFScheduler.from_config(pipe.scheduler.config)
>>> pipe = pipe.to("cuda").to(dtype=torch.bfloat16)
>>> # Example A: get decoded frames (PIL)
>>> out = pipe(
...     prompt="a chimpanzee walks | a chimpanzee eats",
...     num_frames=161,
...     height=512,
...     width=704,
...     temporal_tile_size=80,
...     temporal_overlap=24,
...     output_type="pil",
...     return_dict=True,
... )
>>> frames = out.frames[0]  # list of PIL.Image.Image
>>> # Example B: get latent video and decode later (saves VRAM during sampling)
>>> out_latent = pipe(prompt="a chimpanzee walking", output_type="latent", return_dict=True).frames
>>> frames = pipe.vae_decode_tiled(out_latent, output_type="pil")[0]
```

Formes : tailles latentes (lors de la génération automatique) :
- F_lat = (num_frames - 1) // vae_temporal_compression_ratio + 1
- H_lat = height // vae_spatial_compression_ratio
- W_lat = width // vae_spatial_compression_ratio

Remarques :
- Initialisation aléatoire : lorsque `seed` est fourni, chaque fenêtre temporelle utilise un générateur local initialisé avec `seed + w_start`, tandis que le générateur partagé est initialisé une seule fois pour les latents globaux si aucun générateur n’est transmis ; sinon, le générateur transmis est réutilisé.
- CFG : `noise_pred = uncond + w * (text - uncond)` unifié avec `guidance_rescale` facultatif.
- Mémoire : le débruitage effectue des prédictions sur l’image complète (sans tuilage spatial) ; le décodage peut être tuilé pour éviter les erreurs OOM.

#### encode_prompt[[diffusers.LTXI2VLongMultiPromptPipeline.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: torch.Tensor | None = None, negative_prompt_embeds: torch.Tensor | None = None, prompt_attention_mask: torch.Tensor | None = None, negative_prompt_attention_mask: torch.Tensor | None = None, max_sequence_length: int = 128, device: torch.device | None = None, dtype: torch.dtype | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_i2v_long_multi_prompt.py#L552)

**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.

#### prepare_latents[[diffusers.LTXI2VLongMultiPromptPipeline.prepare_latents]]

```python
prepare_latents(batch_size: int, num_channels_latents: int, height: int, width: int, num_frames: int, device: torch.device, generator: torch.Generator | None, dtype: torch.dtype = torch.float32, latents: torch.Tensor | None = None, cond_latents: torch.Tensor | None = None, cond_strength: float = 0.0, negative_index_latents: torch.Tensor | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_i2v_long_multi_prompt.py#L694)

**Retourne :**

latents, negative_index_latents, latent_num_frames, latent_height, latent_width

Préparez les latents de base et injectez éventuellement les latents de conditionnement de la première image.

#### vae_decode_tiled[[diffusers.LTXI2VLongMultiPromptPipeline.vae_decode_tiled]]

```python
vae_decode_tiled(latents: torch.Tensor, decode_timestep: float | None = None, decode_noise_scale: float | None = None, horizontal_tiles: int = 4, vertical_tiles: int = 4, overlap: int = 3, last_frame_fix: bool = True, generator: torch.Generator | None = None, output_type: str = 'pt', auto_denormalize: bool = True, compute_dtype: torch.dtype = torch.float32, enable_vae_tiling: bool = False)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_i2v_long_multi_prompt.py#L738)

**Paramètres :**

latents : [B, C_latent, F_latent, H_latent, W_latent]

decode_timestep : Étape de décodage facultative (efficace uniquement si le VAE prend en charge timestep_conditioning)

decode_noise_scale : Interpolation du bruit de décodage facultative (efficace uniquement si le VAE prend en charge timestep_conditioning)

horizontal_tiles, vertical_tiles : Nombre de tuiles horizontales/verticales (>= 1)

overlap : Recouvrement dans l'espace latent (en pixels latents, >= 0)

last_frame_fix : Indique s'il faut activer la correction « répéter le dernier image »

generator : Générateur aléatoire (utilisé pour le bruit de decode_noise_scale)

output_type : "latent" | "pt" | "np" | "pil" - "latent" : renvoie les latents inchangés (utile pour le traitement en aval) - "pt" : renvoie le tenseur dans l'espace de sortie du VAE - "np"/"pil" : sorties post-traitées via VideoProcessor.postprocess_video

auto_denormalize : Si True, applique la dénormalisation LTX aux `latents` en interne (recommandé)

compute_dtype : Précision utilisée lors de la fusion de tuiles (float32 par défaut ; réduit considérablement le flou des coutures)

enable_vae_tiling : Si True, délègue le découpage en tuiles à la méthode `tiled_decode` intégrée du VAE (définit `vae.use_tiling`).

**Retourne :** `- If output_type="latent"`

renvoie les `latents` d'entrée inchangés
- Si output_type="pt" : renvoie [B, C, F, H, W] (valeurs approximativement dans [-1, 1])
- Si output_type="np"/"pil" : renvoie les sorties post-traitées via postprocess_video

Décodage spatial par tuiles basé sur un VAE (équivalent ComfyUI) implémenté dans le style Diffusers.
- Fondu linéaire et mélange des tuiles superposées pour éviter les coutures.
- Optionnel last_frame_fix : dupliquer le dernier frame latent avant le décodage, puis supprimer time_scale_factor frames à la fin.
- Prend en charge l'injection de timestep_conditioning et decode_noise_scale.
- Par défaut, les « latents normalisés » (la sortie du débruitage) sont dénormalisés en interne (auto_denormalize=True).
- La fusion de tuiles est calculée dans compute_dtype (float32 par défaut) afin de réduire le flou et les décalages de couleur.

## LTXPipeline[[diffusers.LTXPipeline]]

#### diffusers.LTXPipeline[[diffusers.LTXPipeline]]

```python
diffusers.LTXPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTXVideo, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: LTXVideoTransformer3DModel)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx.py#L170)

**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).

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

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

#### __appel__[[diffusers.LTXPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: int = 25, num_inference_steps: int = 50, timesteps: list = None, guidance_scale: float = 3, guidance_rescale: float = 0.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, 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, output_type: str | None = '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 = ['latents'], max_sequence_length: int = 128)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx.py#L535)

**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`, par défaut `512`) : La hauteur en pixels de l'image générée. Cette valeur est définie sur 480 par défaut pour obtenir les meilleurs résultats.

width (`int`, par défaut `704`) : 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`, par défaut `161`) : Le nombre de frames vidéo à générer

frame_rate (`int`, par défaut `25`) : Fréquence d'images cible de la vidéo générée.

num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : 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.

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`, par défaut `3 `) : É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.

guidance_rescale (`float`, *facultatif*, valeur par défaut 0.0) : Facteur de rééchelonnement 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 rééchelonnement du guidage doit corriger l'exposition excessive lors de l'utilisation d'un SNR terminal nul.

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 d'images. 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.

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.

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 tensorielles 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` par défaut `128 `) : Longueur maximale de la séquence à utiliser avec le `prompt`.

**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 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 LTXPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = LTXPipeline.from_pretrained("Lightricks/LTX-Video", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> prompt = "A woman with long brown hair and light skin smiles at another woman with long blonde hair. The woman with brown hair wears a black jacket and has a small, barely noticeable mole on her right cheek. The camera angle is a close-up, focused on the woman with brown hair's face. The lighting is warm and natural, likely from the setting sun, casting a soft glow on the scene. The scene appears to be real-life footage"
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> video = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=704,
...     height=480,
...     num_frames=161,
...     num_inference_steps=50,
... ).frames[0]
>>> export_to_video(video, "output.mp4", fps=24)
```

#### encode_prompt[[diffusers.LTXPipeline.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 = 128, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx.py#L283)

**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.

## LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

#### diffusers.LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

```python
diffusers.LTXImageToVideoPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTXVideo, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: LTXVideoTransformer3DModel)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_image2video.py#L189)

**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).

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

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

#### __appel__[[diffusers.LTXImageToVideoPipeline.__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 = 704, num_frames: int = 161, frame_rate: int = 25, num_inference_steps: int = 50, timesteps: list = None, guidance_scale: float = 3, guidance_rescale: float = 0.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, 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, output_type: str | None = '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 = ['latents'], max_sequence_length: int = 128)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_image2video.py#L596)

**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`, par défaut `512`) : La hauteur en pixels de l'image générée. Cette valeur est définie sur 480 par défaut pour obtenir les meilleurs résultats.

width (`int`, par défaut `704`) : 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`, par défaut `161`) : Le nombre de frames vidéo à générer

frame_rate (`int`, par défaut `25`) : Fréquence d'images cible de la vidéo générée.

num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : 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.

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`, par défaut `3 `) : É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.

guidance_rescale (`float`, *facultatif*, valeur par défaut 0.0) : Facteur de rééchelonnement 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 rééchelonnement du guidage doit corriger l'exposition excessive lors de l'utilisation d'un SNR terminal nul.

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 d'images. 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.

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.

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 tensorielles 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` par défaut `128 `) : Longueur maximale de la séquence à utiliser avec le `prompt`.

**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 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 LTXImageToVideoPipeline
>>> from diffusers.utils import export_to_video, load_image

>>> pipe = LTXImageToVideoPipeline.from_pretrained("Lightricks/LTX-Video", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> 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. Flames engulf the structure, with smoke billowing into the air. Firefighters in protective gear rush to the scene, a fire truck labeled '38' visible behind them. The girl's neutral expression contrasts sharply with the chaos of the fire, creating a poignant and emotionally charged scene."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> video = pipe(
...     image=image,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=704,
...     height=480,
...     num_frames=161,
...     num_inference_steps=50,
... ).frames[0]
>>> export_to_video(video, "output.mp4", fps=24)
```

#### encode_prompt[[diffusers.LTXImageToVideoPipeline.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 = 128, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_image2video.py#L306)

**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.

## LTXConditionPipeline[[diffusers.LTXConditionPipeline]]

#### diffusers.LTXConditionPipeline[[diffusers.LTXConditionPipeline]]

```python
diffusers.LTXConditionPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTXVideo, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: LTXVideoTransformer3DModel)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_condition.py#L252)

**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).

Pipeline pour la génération de vidéo à partir de texte/image/vidéo.

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

#### __appel__[[diffusers.LTXConditionPipeline.__call__]]

```python
__call__(conditions: diffusers.pipelines.ltx.pipeline_ltx_condition.LTXVideoCondition | list[diffusers.pipelines.ltx.pipeline_ltx_condition.LTXVideoCondition] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]]] = None, video: list = None, frame_index: int | list[int] = 0, strength: float | list[float] = 1.0, denoise_strength: float = 1.0, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: int = 25, num_inference_steps: int = 50, timesteps: list = None, guidance_scale: float = 3, guidance_rescale: float = 0.0, image_cond_noise_scale: float = 0.15, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, 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, output_type: str | None = '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 = ['latents'], max_sequence_length: int = 256)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_condition.py#L848)

**Paramètres :**

conditions (`list[LTXVideoCondition], *optional*`) : The list of frame-conditioning items for the video generation.If not provided, conditions will be created using `image`, `video`, `frame_index` and `strength`.

image (`PipelineImageInput` ou `list[PipelineImageInput]`, *facultatif*) : L’image ou les images à utiliser pour conditionner la génération de la vidéo. Si non fourni, il faut passer `video` ou `conditions`.

video (`list[PipelineImageInput]`, *facultatif*) : La vidéo à utiliser pour conditionner la génération de la vidéo. Si elle n'est pas fournie, il est nécessaire de passer `image` ou `conditions`.

frame_index (`int` ou `list[int]`, *facultatif*) : L’indice ou les indices de la ou des images à partir desquels l’image ou la vidéo conditionnera la génération de la vidéo. Si non fourni, il est nécessaire de passer `conditions`.

strength (`float` ou `list[float]`, *facultatif*) : La force ou les forces de l'effet de conditionnement. Si non fourni, il est nécessaire de passer `conditions`.

denoise_strength (`float`, par défaut `1.0`) : L'intensité du bruit ajouté aux latents pour l'édition. Une intensité plus élevée ajoute davantage de bruit aux latents, ce qui entraîne plus de différences entre la vidéo d'origine et la vidéo générée. Cela est utile pour l'édition vidéo-à-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 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`, par défaut `512`) : La hauteur en pixels de l'image générée. Cette valeur est définie sur 480 par défaut pour obtenir les meilleurs résultats.

width (`int`, par défaut `704`) : 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`, par défaut `161`) : Le nombre de frames vidéo à générer

frame_rate (`int`, par défaut `25`) : Fréquence d'images cible de la vidéo générée.

num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : 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.

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`, par défaut `3 `) : É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.

guidance_rescale (`float`, *facultatif*, valeur par défaut 0.0) : Facteur de rééchelonnement 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 rééchelonnement du guidage doit corriger l'exposition excessive lors de l'utilisation d'un SNR terminal nul.

image_cond_noise_scale (`float`, par défaut `0.15`) : Échelle du bruit ajouté aux latents de l'image de conditionnement.

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 d'images. 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.

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.

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 tensorielles 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` par défaut `128 `) : Longueur maximale de la séquence à utiliser avec le `prompt`.

**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 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.pipelines.ltx.pipeline_ltx_condition import LTXConditionPipeline, LTXVideoCondition
>>> from diffusers.utils import export_to_video, load_video, load_image

>>> pipe = LTXConditionPipeline.from_pretrained("Lightricks/LTX-Video-0.9.5", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> # Load input image and video
>>> video = load_video(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input-vid.mp4"
... )
>>> image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input.jpg"
... )

>>> # Create conditioning objects
>>> condition1 = LTXVideoCondition(
...     image=image,
...     frame_index=0,
... )
>>> condition2 = LTXVideoCondition(
...     video=video,
...     frame_index=80,
... )

>>> 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."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> # Generate video
>>> generator = torch.Generator("cuda").manual_seed(0)
>>> # Text-only conditioning is also supported without the need to pass `conditions`
>>> video = pipe(
...     conditions=[condition1, condition2],
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=161,
...     num_inference_steps=40,
...     generator=generator,
... ).frames[0]

>>> export_to_video(video, "output.mp4", fps=24)
```

#### add_noise_to_image_conditioning_latents[[diffusers.LTXConditionPipeline.add_noise_to_image_conditioning_latents]]

```python
add_noise_to_image_conditioning_latents(t: float, init_latents: Tensor, latents: Tensor, noise_scale: float, conditioning_mask: Tensor, generator, eps = 1e-06)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_condition.py#L646)

Ajoutez un bruit dépendant du pas de temps aux latents de conditionnement dur. Cela aide à assurer la continuité du mouvement, en particulier lorsque la condition est une seule image.

#### encode_prompt[[diffusers.LTXConditionPipeline.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 = 256, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_condition.py#L369)

**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.

#### trim_conditioning_sequence[[diffusers.LTXConditionPipeline.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/ltx/pipeline_ltx_condition.py#L629)

**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é.

## LTXLatentUpsamplePipeline[[diffusers.LTXLatentUpsamplePipeline]]

#### diffusers.LTXLatentUpsamplePipeline[[diffusers.LTXLatentUpsamplePipeline]]

```python
diffusers.LTXLatentUpsamplePipeline(vae: AutoencoderKLLTXVideo, latent_upsampler: LTXLatentUpsamplerModel)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/pipeline_ltx_latent_upsample.py#L44)

#### __appel__[[diffusers.LTXLatentUpsamplePipeline.__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 = 704, latents: typing.Optional[torch.Tensor] = None, 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/ltx/pipeline_ltx_latent_upsample.py#L188)

**Paramètres :**

video (`list[PipelineImageInput]`, *facultatif*) : Les images d'entrée de la vidéo à suréchantillonner. Mutuellement exclusif avec `latents`.

height (`int`, par défaut `512`) : La hauteur en pixels de la sortie redimensionnée.

width (`int`, par défaut `704`) : La largeur en pixels de la sortie après suréchantillonnage.

latents (`torch.Tensor`, *facultatif*) : Latents vidéo pré-encodés à suréchantillonner. Mutuellement exclusif avec `video`.

decode_timestep (`float` ou `list[float]`, par défaut `0.0`) : Le pas de temps auquel les latents suréchantillonnés sont décodés.

decode_noise_scale (`float` ou `list[float]`, *facultatif*) : Facteur d'interpolation entre le bruit aléatoire et les latents débruités à l'étape de décodage.

adain_factor (`float`, par défaut `0.0`) : Intensité de l'adaptation statistique AdaIN appliquée aux latents après suréchantillonnage.

tone_map_compression_ratio (`float`, par défaut `0.0`) : Ratio de compression utilisé pour le tone mapping des latents suréchantillonnés. Doit être compris dans l'intervalle [0, 1].

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un [`torch.Generator`](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 la vidéo générée. Choisissez entre `PIL.Image`, `np.array` ou `latent`.

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`

`~pipelines.ltx.LTXPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est la vidéo upsampled (ou les latents si `output_type="latent"`).

Fonction appelée lors de l'appel du pipeline pour le suréchantillonnage latent.

#### adain_filter_latent[[diffusers.LTXLatentUpsamplePipeline.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/ltx/pipeline_ltx_latent_upsample.py#L94)

**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.LTXLatentUpsamplePipeline.tone_map_latents]]

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

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

**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`.

## LTXPipelineOutput[[diffusers.pipelines.ltx.pipeline_output.LTXPipelineOutput]]

#### diffusers.pipelines.ltx.pipeline_output.LTXPipelineOutput[[diffusers.pipelines.ltx.pipeline_output.LTXPipelineOutput]]

```python
diffusers.pipelines.ltx.pipeline_output.LTXPipelineOutput(frames: Tensor)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ltx/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)`.

Classe de sortie pour les pipelines LTX.