#
# Bajo licencia Apache License, versión 2.0 (la "Licencia");
# no puede usar este archivo excepto en cumplimiento de la Licencia.
# Puede obtener una copia de la Licencia en
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que la ley aplicable lo exija o se haya acordado por escrito, el software
# distribuido bajo la Licencia se distribuye en una base "TAL CUAL",
# SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita.
# Consulte la Licencia para el lenguaje específico que rige los permisos y
# limitaciones de la Licencia. -->

  
    
      
    
    
  

# LTX-Video

[LTX-Video](https://huggingface.co/Lightricks/LTX-Video) es un transformador de difusión diseñado para la generación rápida y en tiempo real de videos de alta resolución a partir de texto e imágenes. La característica principal de LTX-Video es el Video-VAE. El Video-VAE tiene una mayor relación de compresión de píxeles a latentes (1:192), lo que permite un procesamiento de datos de video más eficiente y una velocidad de generación más rápida. Para apoyar y evitar que se pierdan detalles finos durante la generación, el decodificador del Video-VAE realiza la conversión de latentes a píxeles *y* el último paso de desruido.

Puedes encontrar todos los checkpoints originales de LTX-Video bajo la organización [Lightricks](https://huggingface.co/Lightricks).

> [!TIP]
> Haz clic en los modelos LTX-Video en la barra lateral derecha para ver más ejemplos de otras tareas de generación de video.

El siguiente ejemplo demuestra cómo generar un video optimizado para la memoria o la velocidad de inferencia.

Consulte la guía [Reduce memory usage](../../optimization/memory) para obtener más detalles sobre las diversas técnicas de ahorro de memoria.

El modelo LTX-Video de abajo requiere ~10 GB 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) es lento la primera vez, pero las llamadas posteriores al pipeline son más rápidas. [Caching](../../optimization/cache) también puede acelerar la inferencia al almacenar y reutilizar salidas intermedias.

```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)
```

## Notas

- Consulte la siguiente configuración recomendada para la generación desde el repositorio [LTX-Video](https://github.com/Lightricks/LTX-Video).

  - El dtype recomendado para el transformer, el VAE y el codificador de texto es `torch.bfloat16`. El VAE y el codificador de texto también pueden ser `torch.float32` o `torch.float16`.
  - Para las variantes destiladas por guía de LTX-Video, establezca `guidance_scale` en `1.0`. El `guidance_scale` de cualquier otro modelo debe establecerse en un valor más alto, como `5.0`, para obtener una buena calidad de generación.
  - Para las variantes de VAE conscientes del paso de tiempo (LTX-Video 0.9.1 y superiores), establece `decode_timestep` en `0.05` y `image_cond_noise_scale` en `0.025`.
  - Para las variantes que admiten interpolación entre varias imágenes y videos de condicionamiento (LTX-Video 0.9.5 y superiores), utiliza imágenes y videos similares para obtener los mejores resultados. La divergencia respecto a las entradas de condicionamiento puede provocar transiciones bruscas en el video generado.

- LTX-Video 0.9.7 incluye un upscaler espacial de latentes y un transformer de 13B parámetros. Durante la inferencia, primero se genera rápidamente un video de baja resolución y luego se escala y refina.

  
  Mostrar código de ejemplo

  ```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)
  ```

  

- El modelo destilado LTX-Video 0.9.7 está destilado en cuanto a guía y pasos temporales para acelerar la generación. Requiere que `guidance_scale` esté establecido en `1.0` y `num_inference_steps` debe configurarse entre `4` y `10` para una buena calidad de generación. También debe utilizar los siguientes pasos temporales personalizados para obtener los mejores resultados.

  - Inferencia del modelo base para preparar el aumento de escala: `[1000, 993, 987, 981, 975, 909, 725, 0.03]`.
  - Escala: `[1000, 909, 725, 421, 0]`.

  
  Mostrar código de ejemplo

  ```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)
  ```

  

- El modelo destilado LTX-Video 0.9.8 es similar a la variante 0.9.7. Está destilado en guía y pasos de tiempo, y se puede usar código de inferencia similar al mostrado anteriormente. Una mejora de esta versión es que admite la generación de videos muy largos. Además, admite el uso de mapeo de tonos para mejorar la calidad del video generado mediante el parámetro `tone_map_compression_ratio`. Se recomienda el valor predeterminado de `0.6`.

  
  Mostrar código de ejemplo

  ```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 admite LoRAs con [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_weights).

  
  Mostrar código de ejemplo

  ```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 admite la carga desde archivos individuales, como [puntos de control GGUF](../../quantization/gguf), mediante [loaders.FromOriginalModelMixin.from_single_file()](/docs/diffusers/v0.43.0/es/api/loaders/single_file#diffusers.loaders.FromOriginalModelMixin.from_single_file) o [loaders.FromSingleFileMixin.from_single_file()](/docs/diffusers/v0.43.0/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file).

  
  Mostrar código de ejemplo

  ```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)
```

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

**Parámetros:**

transformer ([LTXVideoTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel)) : Arquitectura de Transformer condicional para desruidar los latentes de video codificados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) o `LTXEulerAncestralRFScheduler`) : Un programador para usar en combinación con `transformer` para desruidar los latentes de la imagen codificada.

vae ([AutoencoderKLLTXVideo](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_ltx_video#diffusers.AutoencoderKLLTXVideo)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).

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

Pipeline de I2V (imagen a video) de larga duración con múltiples prompts y paridad con ComfyUI.

Características principales:
- Muestreo de ventana deslizante temporal únicamente (sin partición espacial H/W); fusión autoregresiva entre ventanas.
- Segmentación multi-prompt por ventana con transiciones suaves en las cabeceras de las ventanas.
- Condicionamiento estricto del primer cuadro mediante máscara por token para I2V.
- Control de VRAM mediante ventanas temporales y decodificación VAE por mosaicos.

Referencia: https://github.com/Lightricks/LTX-Video

#### __call__[[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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : Texto de indicación (prompt) positivo por ventana. Si una sola cadena contiene '|', las partes se dividen por barras.

negative_prompt (`str` o `list[str]`, *opcional*) : Prompt(s) negativo(s) para suprimir contenido no deseado.

prompt_segments (`list[dict]`, *opcional*) : Mapeo de segmentos con {"start_window", "end_window", "text"} para sobrescribir los prompts por ventana.

height (`int`, por defecto `512`) : Altura de la imagen de salida en píxeles; debe ser divisible entre 32.

width (`int`, por defecto `704`) : Ancho de la imagen de salida en píxeles; debe ser divisible entre 32.

num_frames (`int`, por defecto `161`) : Número de fotogramas de salida (en el espacio de píxeles decodificados).

frame_rate (`float`, por defecto `25`) : Cuadros por segundo; se utiliza para normalizar las coordenadas temporales en `video_coords`.

guidance_scale (`float`, por defecto `1.0`) : escala de CFG; los valores > 1 activan la guía libre de clasificador.

guidance_rescale (`float`, por defecto `0.0`) : Reescalado opcional para mitigar la sobreexposición bajo CFG (ver `rescale_noise_cfg`).

num_inference_steps (`int`, *opcional*, valor predeterminado `8`) : Pasos de denoising por ventana. Se ignora si se proporciona `sigmas`.

sigmas (`list[float]` o `torch.Tensor`, *opcional*) : Programa de sigma explícito por ventana; si se establece, reemplaza a `num_inference_steps`.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Controla la estocasticidad; se acepta una lista, pero se utiliza el primer elemento (batch=1).

seed (`int`, *opcional*, valor predeterminado `0`) : Si se proporciona, inicializa el generador compartido para los latentes globales y deriva un generador local de ventana con `seed + w_start` por ventana temporal.

cond_image (`PIL.Image.Image` o `torch.Tensor`, *opcional*) : Imagen de condicionamiento; fija el fotograma 0 mediante una máscara por token cuando `cond_strength > 0`.

cond_strength (`float`, por defecto `0.5`) : Fuerza del condicionamiento duro del primer fotograma (un cond_mask más pequeño ⇒ mayor preservación).

latents (`torch.Tensor`, *opcional*) : Latentes iniciales [B, C_lat, F_lat, H_lat, W_lat]; si es None, se muestrean con `randn_tensor`.

temporal_tile_size (`int`, por defecto `80`) : Tamaño de la ventana temporal (en cuadros decodificados); internamente se escala por la compresión temporal del VAE.

temporal_overlap (`int`, por defecto `24`) : Solapamiento entre ventanas consecutivas (en cuadros decodificados); se escala internamente por compresión.

temporal_overlap_cond_strength (`float`, por defecto `0.5`) : Fuerza para inyectar los latentes de la cola de la ventana anterior en la cabecera de la nueva ventana.

adain_factor (`float`, por defecto `0.25`) : Fuerza de la normalización AdaIN para la consistencia entre ventanas (0 la desactiva).

guidance_latents (`torch.Tensor`, *opcional*) : Latentes de referencia inyectados en la cabecera de la ventana; la longitud se recorta según la superposición para las ventanas posteriores.

guiding_strength (`float`, por defecto `1.0`) : Intensidad de inyección para `guidance_latents`.

negative_index_latents (`torch.Tensor`, *opcional*) : Un latente de un solo cuadro añadido al inicio de la ventana para la semántica de "índice negativo".

negative_index_strength (`float`, por defecto `1.0`) : Intensidad de inyección para `negative_index_latents`.

skip_steps_sigma_threshold (`float`, *opcional*, valor predeterminado `1`) : Omite los pasos cuya sigma supera este umbral.

decode_timestep (`float`, *opcional*, valor predeterminado `0.05`) : Paso de tiempo en el momento de la decodificación (si el VAE admite timestep_conditioning).

decode_noise_scale (`float`, *opcional*, valor predeterminado `0.025`) : Escala de mezcla de ruido en el momento de la decodificación (si el VAE admite timestep_conditioning).

decode_horizontal_tiles (`int`, por defecto `4`) : Número de mosaicos horizontales durante la decodificación del VAE.

decode_vertical_tiles (`int`, por defecto `4`) : Número de mosaicos verticales durante la decodificación del VAE.

decode_overlap (`int`, por defecto `3`) : Solapamiento (en píxeles latentes) entre los mosaicos durante la decodificación del VAE.

output_type (`str`, *opcional*, por defecto `"latent"`) : El formato de salida del video generado. Elija entre "latent", "pt", "np" o "pil". Si es "latent", devuelve los latentes sin decodificar.

return_dict (`bool`, *opcional*, por defecto `True`) : Indica si se debe devolver un `~pipelines.ltx.LTXPipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Parámetros de atención adicionales que se reenvían al transformador.

callback_on_step_end (`PipelineCallback` o `MultiPipelineCallbacks`, *opcional*) : Gancho de callback por paso.

callback_on_step_end_tensor_inputs (`list[str]`, por defecto `["latents"]`) : Claves de locals() para pasar al callback.

max_sequence_length (`int`, por defecto `128`) : Longitud máxima del tokenizador para la codificación del prompt.

**Devuelve:** `~pipelines.ltx.LTXPipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `~pipelines.ltx.LTXPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con los fotogramas generados. El formato de salida depende de `output_type`:
- "latent"/"pt": `torch.Tensor` [B, C, F, H, W]; "latent" está en el espacio latente normalizado, "pt" está en el espacio de salida del VAE.
- "np": `np.ndarray` procesado.
- "pil": `list[PIL.Image.Image]` lista de imágenes PIL.

Genere una secuencia de imagen a video mediante ventanas deslizantes temporales y programación de múltiples indicaciones.

Ejemplos:
```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]
```

Formas: tamaños latentes (cuando se generan automáticamente):
- F_lat = (num_frames - 1) // vae_temporal_compression_ratio + 1
- H_lat = height // vae_spatial_compression_ratio
- W_lat = width // vae_spatial_compression_ratio

Notas:
- Seeding: cuando se proporciona `seed`, cada ventana temporal utiliza un generador local sembrado con `seed + w_start`, mientras que el generador compartido se siembra una sola vez para los latentes globales si no se pasa ningún generador; de lo contrario, se reutiliza el generador proporcionado.
- CFG: `noise_pred = uncond + w * (text - uncond)` unificado con `guidance_rescale` opcional.
- Memoria: el denoising realiza predicciones de cuadro completo (sin mosaico espacial); la decodificación puede usar mosaico para evitar 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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

device : (`torch.device`, *opcional*): dispositivo de torch

dtype : (`torch.dtype`, *opcional*): dtype de torch

Codifica el prompt en estados ocultos del codificador de texto.

#### 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)
```

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

**Devuelve:**

latents, negative_index_latents, latent_num_frames, latent_height, latent_width

Prepara los latentes base e inyecta opcionalmente los latentes de condicionamiento del primer fotograma.

#### 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)
```

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

**Parámetros:**

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

decode_timestep : Paso de decodificación opcional (solo efectivo si el VAE admite timestep_conditioning)

decode_noise_scale : Interpolación de ruido de decodificación opcional (solo es efectiva si el VAE admite timestep_conditioning)

horizontal_tiles, vertical_tiles : Número de teselas en horizontal/vertical (>= 1)

overlap : Superposición en el espacio latente (en píxeles latentes, >= 0)

last_frame_fix : Si se habilita la corrección "repetir el último fotograma"

generator : Generador aleatorio (usado para el ruido de decode_noise_scale)

output_type : "latent" | "pt" | "np" | "pil" - "latent": devuelve los latentes sin cambios (útil para el procesamiento posterior) - "pt": devuelve el tensor en el espacio de salida del VAE - "np"/"pil": salidas posprocesadas mediante VideoProcessor.postprocess_video

auto_denormalize : Si es True, aplica la desnormalización de LTX a `latents` internamente (recomendado)

compute_dtype : Precisión utilizada durante la fusión de teselas (predeterminada en float32; reduce significativamente el desenfoque en las costuras)

enable_vae_tiling : Si es True, delega el mosaico en `tiled_decode` integrado de VAE (establece `vae.use_tiling`).

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

devuelve la entrada `latents` sin cambios
- Si output_type="pt": devuelve [B, C, F, H, W] (valores aproximadamente en [-1, 1])
- Si output_type="np"/"pil": devuelve salidas posprocesadas mediante postprocess_video

Decodificación espacial por mosaicos basada en VAE (equivalencia con ComfyUI) implementada en el estilo de Diffusers.
- Desvanecer y mezclar linealmente las teselas superpuestas para evitar costuras.
- Opcional last_frame_fix: duplica el último fotograma latente antes de decodificar y luego elimina time_scale_factor fotogramas al final.
- Admite la inyección de timestep_conditioning y decode_noise_scale.
- Por defecto, los "latentes normalizados" (la salida del desruido) se desnormalizan internamente (auto_denormalize=True).
- La fusión de mosaicos se calcula en compute_dtype (float32 por defecto) para reducir el desenfoque y los cambios de color.

## LTXPipeline[[diffusers.LTXPipeline]]

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

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

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

**Parámetros:**

transformer ([LTXVideoTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel)) : Arquitectura de Transformer condicional para desruidar los latentes de video codificados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLLTXVideo](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_ltx_video#diffusers.AutoencoderKLLTXVideo)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).

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

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

Pipeline para la generación de texto a video.

Referencia: https://github.com/Lightricks/LTX-Video

#### __call__[[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[int] = 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[str] = ['latents'], max_sequence_length: int = 128)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`).

height (`int`, por defecto `512`) : La altura en píxeles de la imagen generada. Por defecto, se establece en 480 para obtener los mejores resultados.

width (`int`, por defecto `704`) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 848 para obtener los mejores resultados.

num_frames (`int`, por defecto `161`) : El número de fotogramas de vídeo a generar

frame_rate (`int`, por defecto `25`) : Tasa de fotogramas objetivo del video generado.

num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente.

guidance_scale (`float`, por defecto `3 `) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se activa estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de guía propuesto por [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` se define como `φ` en la ecuación 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para PixArt-Sigma, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

negative_prompt_attention_mask (`torch.FloatTensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos.

decode_timestep (`float`, por defecto `0.0`) : El paso de tiempo en el que se decodifica el video generado.

decode_noise_scale (`float`, por defecto `None`) : El factor de interpolación entre el ruido aleatorio y los latentes desruidados en el paso de decodificación.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Indica si se debe devolver un `~pipelines.ltx.LTXPipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int` por defecto `128 `) : Longitud máxima de la secuencia para usar con el `prompt`.

**Devuelve:** `~pipelines.ltx.LTXPipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `~pipelines.ltx.LTXPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

device : (`torch.device`, *opcional*): dispositivo de torch

dtype : (`torch.dtype`, *opcional*): dtype de torch

Codifica el prompt en estados ocultos del codificador de texto.

## LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

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

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

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

**Parámetros:**

transformer ([LTXVideoTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel)) : Arquitectura de Transformer condicional para desruidar los latentes de video codificados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLLTXVideo](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_ltx_video#diffusers.AutoencoderKLLTXVideo)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).

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

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

Pipeline para la generación de video a partir de imágenes.

Referencia: https://github.com/Lightricks/LTX-Video

#### __call__[[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[int] = 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[str] = ['latents'], max_sequence_length: int = 128)
```

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

**Parámetros:**

image (`PipelineImageInput`) : La imagen de entrada para condicionar la generación. Debe ser una imagen, una lista de imágenes o un `torch.Tensor`.

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`).

height (`int`, por defecto `512`) : La altura en píxeles de la imagen generada. Por defecto, se establece en 480 para obtener los mejores resultados.

width (`int`, por defecto `704`) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 848 para obtener los mejores resultados.

num_frames (`int`, por defecto `161`) : El número de fotogramas de vídeo a generar

frame_rate (`int`, por defecto `25`) : Tasa de fotogramas objetivo del video generado.

num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente.

guidance_scale (`float`, por defecto `3 `) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se activa estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de guía propuesto por [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` se define como `φ` en la ecuación 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para PixArt-Sigma, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

negative_prompt_attention_mask (`torch.FloatTensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos.

decode_timestep (`float`, por defecto `0.0`) : El paso de tiempo en el que se decodifica el video generado.

decode_noise_scale (`float`, por defecto `None`) : El factor de interpolación entre el ruido aleatorio y los latentes desruidados en el paso de decodificación.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Indica si se debe devolver un `~pipelines.ltx.LTXPipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int` por defecto `128 `) : Longitud máxima de la secuencia para usar con el `prompt`.

**Devuelve:** `~pipelines.ltx.LTXPipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `~pipelines.ltx.LTXPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

device : (`torch.device`, *opcional*): dispositivo de torch

dtype : (`torch.dtype`, *opcional*): dtype de torch

Codifica el prompt en estados ocultos del codificador de texto.

## LTXConditionPipeline[[diffusers.LTXConditionPipeline]]

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

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

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

**Parámetros:**

transformer ([LTXVideoTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel)) : Arquitectura de Transformer condicional para desruidar los latentes de video codificados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLLTXVideo](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_ltx_video#diffusers.AutoencoderKLLTXVideo)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).

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

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

Pipeline para la generación de video a partir de texto, imagen o video.

Referencia: https://github.com/Lightricks/LTX-Video

#### __call__[[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[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] = 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[int] = 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[str] = ['latents'], max_sequence_length: int = 256)
```

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

**Parámetros:**

conditions (`list[LTXVideoCondition], *optional*`) : La lista de elementos de condicionamiento por fotogramas para la generación de video. Si no se proporciona, las condiciones se crearán utilizando `image`, `video`, `frame_index` y `strength`.

image (`PipelineImageInput` o `list[PipelineImageInput]`, *opcional*) : La imagen o las imágenes para condicionar la generación del video. Si no se proporciona, se debe pasar `video` o `conditions`.

video (`list[PipelineImageInput]`, *opcional*) : El video para condicionar la generación del video. Si no se proporciona, es necesario pasar `image` o `conditions`.

frame_index (`int` o `list[int]`, *opcional*) : El índice de fotograma o los índices de fotograma en los que la imagen o el video afectarán condicionalmente la generación del video. Si no se proporciona, se debe pasar `conditions`.

strength (`float` o `list[float]`, *opcional*) : La fuerza o fuerzas del efecto de condicionamiento. Si no se proporciona, es necesario pasar `conditions`.

denoise_strength (`float`, por defecto `1.0`) : La intensidad del ruido añadido a los latentes para la edición. Una intensidad mayor implica más ruido en los latentes, lo que genera más diferencias entre el video original y el video generado. Esto es útil para la edición de video a video.

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`).

height (`int`, por defecto `512`) : La altura en píxeles de la imagen generada. Por defecto, se establece en 480 para obtener los mejores resultados.

width (`int`, por defecto `704`) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 848 para obtener los mejores resultados.

num_frames (`int`, por defecto `161`) : El número de fotogramas de vídeo a generar

frame_rate (`int`, por defecto `25`) : Tasa de fotogramas objetivo del video generado.

num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente.

guidance_scale (`float`, por defecto `3 `) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se activa estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de guía propuesto por [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` se define como `φ` en la ecuación 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero.

image_cond_noise_scale (`float`, por defecto `0.15`) : Escala del ruido añadido a los latentes de la imagen de condicionamiento.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para PixArt-Sigma, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

negative_prompt_attention_mask (`torch.FloatTensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos.

decode_timestep (`float`, por defecto `0.0`) : El paso de tiempo en el que se decodifica el video generado.

decode_noise_scale (`float`, por defecto `None`) : El factor de interpolación entre el ruido aleatorio y los latentes desruidados en el paso de decodificación.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Indica si se debe devolver un `~pipelines.ltx.LTXPipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int` por defecto `128 `) : Longitud máxima de la secuencia para usar con el `prompt`.

**Devuelve:** `~pipelines.ltx.LTXPipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `~pipelines.ltx.LTXPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```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)
```

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

Añada ruido dependiente del paso de tiempo a los latentes de condicionamiento duro. Esto ayuda con la continuidad del movimiento, especialmente cuando se condiciona en un solo fotograma.

#### 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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

device : (`torch.device`, *opcional*): dispositivo de torch

dtype : (`torch.dtype`, *opcional*): dtype de torch

Codifica el prompt en estados ocultos del codificador de texto.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx/pipeline_ltx_condition.py#L629)

**Parámetros:**

start_frame (int) : El número de cuadro objetivo del primer cuadro de la secuencia.

sequence_num_frames (int) : El número de fotogramas en la secuencia.

target_num_frames (int) : El número objetivo de fotogramas en el video generado.

**Devuelve:** `int`

longitud de secuencia actualizada

Recorta una secuencia de condicionamiento al número de fotogramas permitido.

## LTXLatentUpsamplePipeline[[diffusers.LTXLatentUpsamplePipeline]]

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

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

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

#### __call__[[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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx/pipeline_ltx_latent_upsample.py#L188)

**Parámetros:**

video (`list[PipelineImageInput]`, *opcional*) : Los fotogramas de video de entrada para aumentar la resolución. Mutuamente excluyente con `latents`.

height (`int`, por defecto `512`) : La altura en píxeles de la salida ampliada.

width (`int`, por defecto `704`) : El ancho en píxeles de la salida ampliada.

latents (`torch.Tensor`, *opcional*) : Latentes de video precodificados para aumentar la resolución. Mutuamente excluyente con `video`.

decode_timestep (`float` o `list[float]`, por defecto `0.0`) : El paso de tiempo en el que se decodifican los latentes ampliados.

decode_noise_scale (`float` o `list[float]`, *opcional*) : Factor de interpolación entre el ruido aleatorio y los latentes desruidos en el paso de decodificación.

adain_factor (`float`, por defecto `0.0`) : Intensidad del ajuste estadístico de AdaIN aplicado a los latentes interpolados.

tone_map_compression_ratio (`float`, por defecto `0.0`) : Relación de compresión utilizada para el mapeo de tonos de los latentes interpolados. Debe estar en el rango [0, 1].

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida del video generado. Elija entre `PIL.Image`, `np.array` o `latent`.

return_dict (`bool`, *opcional*, por defecto `True`) : Indica si se debe devolver un `~pipelines.ltx.LTXPipelineOutput` en lugar de una tupla simple.

**Devuelve:** `~pipelines.ltx.LTXPipelineOutput` o `tuple`

`~pipelines.ltx.LTXPipelineOutput` si `return_dict` es True, de lo contrario una `tuple`. Al devolver una tupla, el primer elemento es el video ampliado (o los latentes si `output_type="latent"`).

Función invocada al llamar a la pipeline para el aumento de resolución de latentes.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx/pipeline_ltx_latent_upsample.py#L94)

**Parámetros:**

latents (`torch.Tensor`) : Latentes de entrada para normalizar

reference_latents (`torch.Tensor`) : Los latentes de referencia que proporcionan las estadísticas de estilo.

factor (`float`) : Factor de mezcla entre el latente original y el transformado. Rango: -10.0 a 10.0, Valor predeterminado: 1.0

**Devuelve:** `torch.Tensor`

El tensor latente transformado

Aplica la Normalización Adaptativa de Instancia (AdaIN) a un tensor latente en función de las estadísticas de un tensor latente de referencia.

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

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

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

**Parámetros:**

latents : torch.Tensor Tensor latente de entrada con forma arbitraria. Se espera que esté aproximadamente en el rango [-1, 1] o [0, 1].

compression : float Intensidad de la compresión en el rango [0, 1]. - 0.0: Sin mapeo de tonos (transformación identidad) - 1.0: Efecto de compresión completo

**Devuelve:**

torch.Tensor El tensor latente con mapeo de tonos de la misma forma que la entrada.

Aplica una función de mapeo de tono no lineal a los valores latentes para reducir su rango dinámico de manera perceptualmente suave mediante una compresión basada en sigmoide.

Esto es útil para regularizar latentes de alta varianza o para condicionar las salidas durante la generación, especialmente al controlar el comportamiento dinámico con un factor 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx/pipeline_output.py#L9)

**Parámetros:**

frames (`torch.Tensor`, `np.ndarray` o list[list[PIL.Image.Image]]) : lista de salidas de video - Puede ser una lista anidada de longitud `batch_size,` donde cada sublista contiene secuencias de imágenes PIL desruidas de longitud `num_frames.` También puede ser un array de NumPy o un tensor de Torch de forma `(batch_size, num_frames, channels, height, width)`.

Clase de salida para las tuberías de LTX.