hf-doc-build/doc / diffusers /main /es /api /pipelines /ltx_video.md

|

raw

86.8 kB

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

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

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 es lento la primera vez, pero las llamadas posteriores al pipeline son más rápidas. Caching también puede acelerar la inferencia al almacenar y reutilizar salidas intermedias.

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

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

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

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

Mostrar código de ejemplo

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, mediante loaders.FromOriginalModelMixin.from_single_file() o loaders.FromSingleFileMixin.from_single_file().

Mostrar código de ejemplo

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

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

Fuente

Parámetros:

transformer (LTXVideoTransformer3DModel) : Arquitectura de Transformer condicional para desruidar los latentes de video codificados.

scheduler (FlowMatchEulerDiscreteScheduler o LTXEulerAncestralRFScheduler) : Un programador para usar en combinación con transformer para desruidar los latentes de la imagen codificada.

vae (AutoencoderKLLTXVideo) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (T5EncoderModel) : T5, específicamente la variante google/t5-v1_1-xxl.

tokenizer (T5TokenizerFast) : Tokenizador de la clase 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]]

__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

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:

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

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

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

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

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

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

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

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

Fuente

Parámetros:

transformer (LTXVideoTransformer3DModel) : Arquitectura de Transformer condicional para desruidar los latentes de video codificados.

scheduler (FlowMatchEulerDiscreteScheduler) : Un programador para usar en combinación con transformer para desruidar los latentes de imagen codificados.

vae (AutoencoderKLLTXVideo) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (T5EncoderModel) : T5, específicamente la variante google/t5-v1_1-xxl.

tokenizer (CLIPTokenizer) : Tokenizador de la clase CLIPTokenizer.

tokenizer (T5TokenizerFast) : Segundo Tokenizer de la clase T5TokenizerFast.

Pipeline para la generación de texto a video.

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

call[[diffusers.LTXPipeline.call]]

__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

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. guidance_scale se define como w de la ecuación 2. de Imagen Paper. 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 guidance_scale se define como φ en la ecuación 16. de Common Diffusion Noise Schedules and Sample Steps are Flawed. 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 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: 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.

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:

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

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

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

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

Fuente

Parámetros:

transformer (LTXVideoTransformer3DModel) : Arquitectura de Transformer condicional para desruidar los latentes de video codificados.

scheduler (FlowMatchEulerDiscreteScheduler) : Un programador para usar en combinación con transformer para desruidar los latentes de imagen codificados.

vae (AutoencoderKLLTXVideo) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (T5EncoderModel) : T5, específicamente la variante google/t5-v1_1-xxl.

tokenizer (CLIPTokenizer) : Tokenizador de la clase CLIPTokenizer.

tokenizer (T5TokenizerFast) : Segundo Tokenizer de la clase T5TokenizerFast.

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

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

call[[diffusers.LTXImageToVideoPipeline.call]]

__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

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.