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

|

raw

88.9 kB

Sous licence Apache License, Version 2.0 (la « Licence ») ;

vous ne pouvez utiliser ce fichier que conformément à la Licence.

Vous pouvez obtenir un exemplaire de la Licence à

http://www.apache.org/licenses/LICENSE-2.0

Sauf exigence légale ou accord écrit

distribué sous la Licence est distribué sur une base « EN L'ÉTAT »,

SANS AUCUNE GARANTIE NI CONDITION, explicite ou implicite.

Voir la Licence pour le langage spécifique régissant les autorisations et

limitations under the License. -->

LTX-Video

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

Vous pouvez trouver tous les points de contrôle originaux de LTX-Video sous l'organisation Lightricks.

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

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

Reportez-vous au guide Réduire l'utilisation de la mémoire pour plus de détails sur les différentes techniques d'économie de mémoire.

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

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 est lente lors de la première exécution, mais les appels suivants au pipeline sont plus rapides. Le cache peut également accélérer l'inférence en stockant et en réutilisant les sorties intermédiaires.

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

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

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

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

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

Notes

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

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

Afficher un exemple de code

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

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

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

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

prompt = """
The video depicts a winding mountain road covered in snow, with a single vehicle 
traveling along it. The road is flanked by steep, rocky cliffs and sparse vegetation. 
The landscape is characterized by rugged terrain and a river visible in the distance. 
The scene captures the solitude and beauty of a winter drive through a mountainous region.
"""
negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"
expected_height, expected_width = 768, 1152
downscale_factor = 2 / 3
num_frames = 161

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

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

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

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

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

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

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

Afficher un exemple de code

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

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

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

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

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

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

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

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

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

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

Afficher un exemple de code

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

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

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

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

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

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

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

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

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

LTX-Video prend en charge les LoRA avec load_lora_weights().

Afficher un exemple de code

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

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

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

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

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

LTX-Video prend en charge le chargement à partir de fichiers uniques, tels que des points de contrôle GGUF, via loaders.FromOriginalModelMixin.from_single_file() ou loaders.FromSingleFileMixin.from_single_file().

Afficher un exemple de code

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)

Source

Paramètres :

transformer (LTXVideoTransformer3DModel) : architecture Transformer conditionnelle pour le débruitage des latents vidéo encodés.

scheduler (FlowMatchEulerDiscreteScheduler ou LTXEulerAncestralRFScheduler) : Un planificateur à utiliser en combinaison avec transformer pour débruyer les latents d'image encodés.

vae (AutoencoderKLLTXVideo) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images à partir de représentations latentes et vers celles-ci.

text_encoder (T5EncoderModel) : T5, plus précisément la variante google/t5-v1_1-xxl.

tokenizer (T5TokenizerFast) : Tokenizer de la classe T5TokenizerFast.

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

Fonctionnalités principales :

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

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

appel[[diffusers.LTXI2VLongMultiPromptPipeline.call]]

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

Source

Paramètres :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Retourne : ~pipelines.ltx.LTXPipelineOutput ou tuple

Si return_dict est True, ~pipelines.ltx.LTXPipelineOutput est renvoyé, sinon un tuple est renvoyé dont le premier élément est une liste contenant les images générées. Le format de sortie dépend de output_type :

"latent"/"pt" : torch.Tensor [B, C, F, H, W] ; "latent" est dans l'espace latent normalisé, "pt" est dans l'espace de sortie du VAE.
"np" : np.ndarray post-traité.
"pil" : list[PIL.Image.Image] liste d'images PIL.

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

Exemples :

>>> import torch
>>> from diffusers import LTXEulerAncestralRFScheduler, LTXI2VLongMultiPromptPipeline

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

Formes : tailles latentes (lors de la génération automatique) :

F_lat = (num_frames - 1) // vae_temporal_compression_ratio + 1
H_lat = height // vae_spatial_compression_ratio
W_lat = width // vae_spatial_compression_ratio

Remarques :

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

encode_prompt[[diffusers.LTXI2VLongMultiPromptPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: torch.Tensor | None = None, negative_prompt_embeds: torch.Tensor | None = None, prompt_attention_mask: torch.Tensor | None = None, negative_prompt_attention_mask: torch.Tensor | None = None, max_sequence_length: int = 128, device: torch.device | None = None, dtype: torch.dtype | None = None)

Source

Paramètres :

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

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

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

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

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

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

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

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

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

prepare_latents[[diffusers.LTXI2VLongMultiPromptPipeline.prepare_latents]]

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

Source

Retourne :

latents, negative_index_latents, latent_num_frames, latent_height, latent_width

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

vae_decode_tiled[[diffusers.LTXI2VLongMultiPromptPipeline.vae_decode_tiled]]

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

Source

Paramètres :

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

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

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

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

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

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

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

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

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

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

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

Retourne : - If output_type="latent"

renvoie les latents d'entrée inchangés

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

Décodage spatial par tuiles basé sur un VAE (équivalent ComfyUI) implémenté dans le style Diffusers.

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

LTXPipeline[[diffusers.LTXPipeline]]

diffusers.LTXPipeline[[diffusers.LTXPipeline]]

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

Source

Paramètres :

transformer (LTXVideoTransformer3DModel) : architecture Transformer conditionnelle pour le débruitage des latents vidéo encodés.

scheduler (FlowMatchEulerDiscreteScheduler) : un planificateur à utiliser en combinaison avec transformer pour débruyer les latents d'image encodés.

vae (AutoencoderKLLTXVideo) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images à partir de représentations latentes et vers celles-ci.

text_encoder (T5EncoderModel) : T5, plus précisément la variante google/t5-v1_1-xxl.

tokenizer (CLIPTokenizer) : Tokenizer de la classe CLIPTokenizer.

tokenizer (T5TokenizerFast) : Second Tokenizer de la classe T5TokenizerFast.

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

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

appel[[diffusers.LTXPipeline.call]]

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

Source

Paramètres :

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

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

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

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

num_frames (int, par défaut 161) : Le nombre de frames vidéo à générer

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

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

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

guidance_scale (float, par défaut 3 ) : Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance. guidance_scale est défini comme w de l'équation 2. de Imagen Paper. L'échelle de guidage est activée en définissant guidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au prompt texte, généralement au détriment de la qualité de l'image.

guidance_rescale (float, facultatif, valeur par défaut 0.0) : Facteur de rééchelonnement du guidage proposé par Common Diffusion Noise Schedules and Sample Steps are Flawed guidance_scale est défini comme φ dans l'équation 16. de Common Diffusion Noise Schedules and Sample Steps are Flawed. Le facteur de rééchelonnement du guidage doit corriger l'exposition excessive lors de l'utilisation d'un SNR terminal nul.

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

generator (torch.Generator ou list[torch.Generator], facultatif) : Un ou une liste de générateurs torch pour rendre la génération déterministe.

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

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

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

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

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

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

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

output_type (str, facultatif, par défaut "pil") : Le format de sortie de l'image générée. Choisissez entre PIL : PIL.Image.Image ou np.array.

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

attention_kwargs (dict, facultatif) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessor tel que défini sous self.processor dans diffusers.models.attention_processor.

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

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

max_sequence_length (int par défaut 128 ) : Longueur maximale de la séquence à utiliser avec le prompt.

Retourne : ~pipelines.ltx.LTXPipelineOutput ou tuple

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

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

Exemples :

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

Source

Paramètres :

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

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

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

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

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

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

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

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

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

LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

diffusers.LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

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

Source

Paramètres :

transformer (LTXVideoTransformer3DModel) : architecture Transformer conditionnelle pour le débruitage des latents vidéo encodés.

scheduler (FlowMatchEulerDiscreteScheduler) : un planificateur à utiliser en combinaison avec transformer pour débruyer les latents d'image encodés.

vae (AutoencoderKLLTXVideo) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images à partir de représentations latentes et vers celles-ci.

text_encoder (T5EncoderModel) : T5, plus précisément la variante google/t5-v1_1-xxl.

tokenizer (CLIPTokenizer) : Tokenizer de la classe CLIPTokenizer.

tokenizer (T5TokenizerFast) : Second Tokenizer de la classe T5TokenizerFast.

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

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

appel[[diffusers.LTXImageToVideoPipeline.call]]

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

Source

Paramètres :

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