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

|

raw

113 kB

Лицензия Apache License, Version 2.0 («Лицензия»);

вы можете использовать этот файл только в соответствии с Лицензией.

Вы можете получить копию Лицензии по адресу

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

Если это не требуется применимым законодательством или не оговорено письменно, программное

распространяется по Лицензии на условиях «КАК ЕСТЬ»,

БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ ИЛИ УСЛОВИЙ, прямо указанных или подразумеваемых.

См. Лицензию для получения конкретных условий, регулирующих разрешения и

ограничениями Лицензии. -->

LTX-Video

LTX-Video — это диффузионный трансформер, предназначенный для быстрого и генерации в реальном времени видео высокого разрешения по тексту и изображениям. Ключевой особенностью LTX-Video является Video-VAE. Video-VAE обеспечивает более высокий коэффициент сжатия пикселей в латентное пространство (1:192), что позволяет более эффективно обрабатывать видеоданные и ускоряет генерацию. Чтобы поддержать и предотвратить потерю мелких деталей при генерации, декодер Video-VAE выполняет преобразование из латентного пространства в пиксели и последний шаг денойзинга.

Все исходные контрольные точки LTX-Video можно найти в организации Lightricks.

Нажмите на модели LTX-Video в правой боковой панели, чтобы увидеть больше примеров других задач генерации видео.

Пример ниже демонстрирует, как сгенерировать видео, оптимизированное по памяти или скорости инференса.

См. руководство Сокращение использования памяти для получения подробной информации о различных техниках экономии памяти.

Модель LTX-Video, описанная ниже, требует ~10 ГБ видеопамяти.

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)

Компиляция выполняется медленно при первом запуске, но последующие вызовы конвейера становятся быстрее. Кэширование также может ускорить инференс за счёт хранения и повторного использования промежуточных результатов.

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)

Примечания

См. следующие рекомендуемые настройки для генерации из репозитория LTX-Video.
- Рекомендуемый dtype для трансформера, VAE и текстового энкодера — torch.bfloat16. VAE и текстовый энкодер также могут использовать torch.float32 или torch.float16.
- Для вариантов LTX-Video с дистилляцией по руководству установите guidance_scale в 1.0. Для любой другой модели значение guidance_scale должно быть выше, например 5.0, чтобы обеспечить хорошее качество генерации.
- Для вариантов VAE с учётом временного шага (LTX-Video 0.9.1 и выше) установите decode_timestep в 0.05, а image_cond_noise_scale — в 0.025.
- Для вариантов, поддерживающих интерполяцию между несколькими изображениями и видео для условного управления (LTX-Video 0.9.5 и выше), используйте похожие изображения и видео для достижения наилучших результатов. Отклонение от входных данных для условного управления может привести к резким переходам в сгенерированном видео.

LTX-Video 0.9.7 включает пространственный латентный апскейлер и трансформер с 13 млрд параметров. Во время инференса сначала быстро генерируется видео низкого разрешения, после чего оно масштабируется и уточняется.

Показать пример кода

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)

Дистиллированная модель LTX-Video 0.9.7 прошла дистилляцию по guidance и timestep для ускорения генерации. Для неё необходимо установить guidance_scale в значение 1.0, а num_inference_steps — в диапазон от 4 до 10 для обеспечения высокого качества генерации. Также для достижения наилучших результатов следует использовать следующие пользовательские timestep.

Вывод базовой модели для подготовки к увеличению разрешения: [1000, 993, 987, 981, 975, 909, 725, 0.03].
Увеличение: [1000, 909, 725, 421, 0].

Показать пример кода

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)

Дистиллированная модель LTX-Video 0.9.8 похожа на вариант 0.9.7. Она дистиллирована по guidance и timestep, и для её вывода можно использовать аналогичный код, как описано выше. Улучшение этой версии заключается в поддержке генерации очень длинных видео. Кроме того, она поддерживает использование tone mapping для повышения качества генерируемого видео с помощью параметра tone_map_compression_ratio. Рекомендуется значение по умолчанию 0.6.

Показать пример кода

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 поддерживает LoRA с помощью load_lora_weights().

Показать пример кода

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 supports loading from single files, such as GGUF checkpoints, with loaders.FromOriginalModelMixin.from_single_file() or loaders.FromSingleFileMixin.from_single_file().

Показать пример кода

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)

Источник

Параметры:

transformer (LTXVideoTransformer3DModel) : Условная архитектура Transformer для удаления шума из закодированных латентных представлений видео.

scheduler (FlowMatchEulerDiscreteScheduler или LTXEulerAncestralRFScheduler) : планировщик, используемый в связке с transformer для удаления шума из закодированных латентов изображения.

vae (AutoencoderKLLTXVideo) : Модель вариационного автоэнкодера (VAE) для кодирования изображений в латентные представления и декодирования из них.

text_encoder (T5EncoderModel) : T5, а именно вариант google/t5-v1_1-xxl.

tokenizer (T5TokenizerFast) : Токенизатор класса T5TokenizerFast.

Пайплайн I2V (изображение в видео) с длительным временем генерации и несколькими промптами, обеспечивающий совместимость с ComfyUI.

Ключевые возможности:

Только временная выборка со скользящим окном (без пространственного разбиения по H/W); авторегрессионное слияние между окнами.
Сегментация по нескольким промптам на каждое окно с плавными переходами в начале окон.
Жёсткое условие по первому кадру через маску для каждого токена для I2V.
Управление VRAM с помощью временного оконного метода и тайловой декодировки VAE.

Справочник: 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)

Источник

Параметры:

prompt (str или list[str], необязательный) : Положительные текстовые промпты для каждого окна. Если одна строка содержит '|', части разделяются по вертикальным чертам.

negative_prompt (str или list[str], необязательный) : Отрицательный промпт(ы) для подавления нежелательного контента.

prompt_segments (list[dict], необязательный) : Соответствие сегментов в формате {"start_window", "end_window", "text"} для переопределения промптов для каждого окна.

height (int, по умолчанию 512) : Высота выходного изображения в пикселях; должна делиться на 32.

width (int, по умолчанию 704) : Ширина выходного изображения в пикселях; должна делиться на 32.

num_frames (int, по умолчанию 161) : Количество выходных кадров (в пространстве декодированных пикселей).

frame_rate (float, по умолчанию 25) : Количество кадров в секунду; используется для нормализации временных координат в video_coords.

guidance_scale (float, по умолчанию 1.0) : масштаб CFG; значения > 1 включают classifier-free guidance.

guidance_rescale (float, по умолчанию 0.0) : Необязательное масштабирование для смягчения переэкспозиции при CFG (см. rescale_noise_cfg).

num_inference_steps (int, optional, по умолчанию 8) : Количество шагов денойзинга на окно. Игнорируется, если задан sigmas.

sigmas (list[float] или torch.Tensor, необязательный) : Явный график сигмы для каждого окна; если задан, переопределяет num_inference_steps.

generator (torch.Generator или list[torch.Generator], необязательный) : Управляет стохастичностью; принимается список, но используется только первый элемент (batch=1).

seed (int, optional, по умолчанию 0) : Если указано, задаёт seed для общего генератора глобальных латентов и выводит локальный для окна генератор с seed + w_start для каждого временного окна.

cond_image (PIL.Image.Image или torch.Tensor, необязательный) : Изображение для условия; фиксирует кадр 0 с помощью маски по токенам, если cond_strength > 0.

cond_strength (float, по умолчанию 0.5) : Сила жёсткого условия для первого кадра (меньшее значение cond_mask ⇒ более сильное сохранение).

latents (torch.Tensor, необязательный) : Начальные латенты [B, C_lat, F_lat, H_lat, W_lat]; если None, генерируются с помощью randn_tensor.

temporal_tile_size (int, по умолчанию 80) : Размер временного окна (в декодированных кадрах); внутренне масштабируется временным сжатием VAE.

temporal_overlap (int, по умолчанию 24) : Пересечение между последовательными окнами (в декодированных кадрах); масштабируется внутренне с учётом сжатия.

temporal_overlap_cond_strength (float, по умолчанию 0.5) : Сила, с которой латенты хвоста предыдущего окна вставляются в начало нового окна.

adain_factor (float, по умолчанию 0.25) : сила нормализации AdaIN для согласованности между окнами (0 отключает).

guidance_latents (torch.Tensor, необязательный) : Ссылочные латенты, внедряемые в начало окна; длина обрезается по перекрытию для последующих окон.

guiding_strength (float, по умолчанию 1.0) : Сила инъекции для guidance_latents.

negative_index_latents (torch.Tensor, необязательный) : Однокадровый латентный вектор, добавляемый в начало окна для семантики «отрицательного индекса».

negative_index_strength (float, по умолчанию 1.0) : Сила инъекции для negative_index_latents.

skip_steps_sigma_threshold (float, необязательный, по умолчанию 1) : Пропускать шаги, сигма которых превышает этот порог.

decode_timestep (float, необязательный, по умолчанию 0.05) : Шаг времени на этапе декодирования (если VAE поддерживает timestep_conditioning).

decode_noise_scale (float, необязательный, по умолчанию 0.025) : Масштаб смешивания шума на этапе декодирования (если VAE поддерживает timestep_conditioning).

decode_horizontal_tiles (int, по умолчанию 4) : Количество горизонтальных тайлов при декодировании VAE.

decode_vertical_tiles (int, по умолчанию 4) : Количество вертикальных тайлов при декодировании VAE.

decode_overlap (int, по умолчанию 3) : Перекрывание (в латентных пикселях) между тайлами при декодировании VAE.

output_type (str, необязательный, по умолчанию "latent") : Формат вывода сгенерированного видео. Выберите один из вариантов: "latent", "pt", "np" или "pil". Если выбрано "latent", возвращаются латенты без декодирования.

return_dict (bool, необязательный, по умолчанию True) : Возвращать ли ~pipelines.ltx.LTXPipelineOutput вместо обычного кортежа.

attention_kwargs (dict, необязательный) : Дополнительные параметры внимания, передаваемые в трансформер.

callback_on_step_end (PipelineCallback или MultiPipelineCallbacks, необязательный) : Хук обратного вызова для каждого шага.

callback_on_step_end_tensor_inputs (list[str], по умолчанию ["latents"]) : Ключи из locals(), которые передаются в callback.

max_sequence_length (int, по умолчанию 128) : Максимальная длина токенизатора для кодирования промпта.

Возвращает: ~pipelines.ltx.LTXPipelineOutput или tuple

Если return_dict равно True, возвращается ~pipelines.ltx.LTXPipelineOutput, иначе возвращается tuple, где первый элемент — это список с сгенерированными кадрами. Формат вывода зависит от output_type:

"latent"/"pt": torch.Tensor [B, C, F, H, W]; "latent" — в нормализованном латентном пространстве, "pt" — в пространстве вывода VAE.
"np": np.ndarray после обработки.
"pil": list[PIL.Image.Image] список изображений PIL.

Сгенерируйте последовательность изображений в видео с использованием временных скользящих окон и многопромптного планирования.

Примеры:

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

Формы: размеры латентов (при автоматической генерации):

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

Примечания:

Инициализация: если seed задан, каждое временное окно использует локальный генератор, инициализированный значением seed + w_start, тогда как общий генератор инициализируется один раз для глобальных латентов, если генератор не передан; в противном случае переданный генератор переиспользуется.
CFG: единая noise_pred = uncond + w * (text - uncond) с необязательным guidance_rescale.
Память: процесс денойзинга выполняет предсказания для полного кадра (без пространственного тайлинга); декодирование можно выполнять с тайлингом, чтобы избежать 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)

Источник

Параметры:

prompt (str или list[str], необязательный) : промпт для кодирования

negative_prompt (str или list[str], необязательный) : Промпт или промпты, которые не должны направлять генерацию изображения. Если не задан, необходимо передать negative_prompt_embeds. Игнорируется, если не используется направляющее влияние (то есть игнорируется, если guidance_scale меньше 1).

do_classifier_free_guidance (bool, необязательный, по умолчанию True) : Использовать ли classifier free guidance.

num_videos_per_prompt (int, optional, по умолчанию 1) : Количество видео, которые должны быть сгенерированы для каждого промпта. Устройство torch, на котором должны размещаться результирующие эмбеддинги

prompt_embeds (torch.Tensor, необязательный) : Предварительно сгенерированные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, например для взвешивания промпта. Если не предоставлены, текстовые эмбеддинги будут сгенерированы из входного аргумента prompt.

negative_prompt_embeds (torch.Tensor, необязательный) : Предварительно сгенерированные отрицательные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, например для взвешивания промпта. Если не предоставлены, negative_prompt_embeds будут сгенерированы из входного аргумента negative_prompt.

device : (torch.device, необязательный): устройство torch

dtype : (torch.dtype, необязательный): torch dtype

Кодирует промпт в скрытые состояния текстового энкодера.

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)

Источник

Возвращает:

latents, negative_index_latents, latent_num_frames, latent_height, latent_width

Подготовьте базовые латенты и при необходимости вставьте латенты для условного кодирования первого кадра.

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)

Источник

Параметры:

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

decode_timestep : необязательный шаг декодирования (действует только если VAE поддерживает timestep_conditioning)

decode_noise_scale : Интерполяция шума декодирования (действует только если VAE поддерживает timestep_conditioning)

horizontal_tiles, vertical_tiles : Количество тайлов по горизонтали/вертикали (>= 1)

overlap : Пересечение в латентном пространстве (в латентных пикселях, >= 0)

last_frame_fix : Включить ли исправление «повтор последнего кадра»

generator : Генератор случайных чисел (используется для шума decode_noise_scale)

output_type : "latent" | "pt" | "np" | "pil" - "latent": возвращает латенты без изменений (полезно для последующей обработки) - "pt": возвращает тензор в пространстве вывода VAE - "np"/"pil": результаты после обработки через VideoProcessor.postprocess_video

auto_denormalize : Если True, применяет денормализацию LTX к latents внутри (рекомендуется)

compute_dtype : Точность, используемая при слиянии тайлов (по умолчанию float32; значительно снижает размытие швов)

enable_vae_tiling : Если True, делегирует тайлинг встроенному tiled_decode VAE (устанавливает vae.use_tiling).

Возвращает: - If output_type="latent"

возвращает входные latents без изменений

Если output_type="pt": возвращает [B, C, F, H, W] (значения примерно в диапазоне [-1, 1])
Если output_type="np"/"pil": возвращает постобработанные результаты через postprocess_video

Пространственное тайловое декодирование на основе VAE (эквивалент ComfyUI), реализованное в стиле Diffusers.

Линейно смягчайте и смешивайте перекрывающиеся плитки, чтобы избежать швов.
Необязательный last_frame_fix: дублировать последний латентный кадр перед декодированием, затем удалить time_scale_factor кадров в конце.
Поддерживает внедрение timestep_conditioning и decode_noise_scale.
По умолчанию «нормализованные латенты» (результат денуазинга) денормализуются внутри (auto_denormalize=True).
Слияние тайлов вычисляется в compute_dtype (по умолчанию float32) для уменьшения размытия и сдвигов цвета.

LTXPipeline[[diffusers.LTXPipeline]]

diffusers.LTXPipeline[[diffusers.LTXPipeline]]

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

Источник

Параметры:

transformer (LTXVideoTransformer3DModel) : Условная архитектура Transformer для удаления шума из закодированных латентных представлений видео.

scheduler (FlowMatchEulerDiscreteScheduler) : планировщик, используемый в связке с transformer для удаления шума из закодированных латентов изображения.

vae (AutoencoderKLLTXVideo) : Модель вариационного автоэнкодера (VAE) для кодирования изображений в латентные представления и декодирования из них.

text_encoder (T5EncoderModel) : T5, а именно вариант google/t5-v1_1-xxl.

tokenizer (CLIPTokenizer) : Токенизатор класса CLIPTokenizer.

tokenizer (T5TokenizerFast) : Второй токенизатор класса T5TokenizerFast.

Пайплайн для генерации видео по тексту.

Справочник: 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)

Источник

Параметры:

prompt (str или list[str], необязательный) : Промпт или промпты для управления генерацией изображения. Если не задан, необходимо передать prompt_embeds вместо него.

negative_prompt (str или list[str], необязательный) : Промпт или промпты, которые не должны направлять генерацию изображения. Если не задан, необходимо передать negative_prompt_embeds. Игнорируется, если не используется направляющее влияние (guidance_scale < 1).

height (int, по умолчанию 512) : Высота генерируемого изображения в пикселях. По умолчанию установлено значение 480 для достижения наилучших результатов.

width (int, по умолчанию 704) : Ширина генерируемого изображения в пикселях. По умолчанию установлено значение 848 для достижения наилучших результатов.

num_frames (int, по умолчанию 161) : количество кадров видео для генерации

frame_rate (int, по умолчанию 25) : Целевая частота кадров для генерируемого видео.

num_inference_steps (int, optional, по умолчанию 50) : Количество шагов денойзинга. Как правило, большее число шагов денойзинга приводит к изображению более высокого качества, но за счёт более медленного вывода.

timesteps (list[int], optional) : Пользовательские шаги для процесса денойзинга с планировщиками, поддерживающими аргумент timesteps в их методе set_timesteps. Если не определено, будет использоваться поведение по умолчанию при передаче num_inference_steps. Должны быть в порядке убывания.

guidance_scale (float, по умолчанию 3 ) : масштаб руководства, определённый в Classifier-Free Diffusion Guidance. guidance_scale соответствует w из уравнения 2 в Imagen Paper. Масштаб руководства активируется при установке guidance_scale > 1. Более высокое значение масштаба руководства способствует генерации изображений, тесно связанных с текстовым prompt, обычно за счёт снижения качества изображения.

guidance_rescale (float, optional, defaults to 0.0) : Guidance rescale factor proposed by Common Diffusion Noise Schedules and Sample Steps are Flawed guidance_scale is defined as φ in equation 16. of Common Diffusion Noise Schedules and Sample Steps are Flawed. Guidance rescale factor should fix overexposure when using zero terminal SNR.

num_videos_per_prompt (int, необязательный, по умолчанию 1) : Количество видео, генерируемых на один промпт.

generator (torch.Generator или list[torch.Generator], необязательный) : Один или список генераторов torch для обеспечения детерминированности генерации.

latents (torch.Tensor, необязательный) : Предварительно сгенерированные зашумленные латенты, выбранные из гауссова распределения, которые используются в качестве входных данных для генерации изображений. Можно использовать, чтобы скорректировать одну и ту же генерацию с разными промптами. Если не предоставлены, тензор латентов будет сгенерирован путём выборки с использованием переданного случайного generator.

prompt_embeds (torch.Tensor, необязательный) : Предварительно сгенерированные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, например для взвешивания промпта. Если не предоставлены, текстовые эмбеддинги будут сгенерированы из входного аргумента prompt.

prompt_attention_mask (torch.Tensor, необязательный) : Предварительно сгенерированная маска внимания для текстовых эмбеддингов.

negative_prompt_embeds (torch.FloatTensor, необязательный) : Предварительно сгенерированные отрицательные текстовые эмбеддинги. Для PixArt-Sigma этот отрицательный промпт должен быть "". Если не указан, negative_prompt_embeds будет сгенерирован из аргумента negative_prompt.

negative_prompt_attention_mask (torch.FloatTensor, необязательный) : Предварительно сгенерированная маска внимания для отрицательных текстовых эмбеддингов.

decode_timestep (float, по умолчанию 0.0) : Шаг времени, на котором декодируется сгенерированное видео.

decode_noise_scale (float, по умолчанию None) : Коэффициент интерполяции между случайным шумом и денойзанными латентами на шаге декодирования.

output_type (str, необязательный, по умолчанию "pil") : Формат вывода для генерируемого изображения. Выберите между PIL: PIL.Image.Image или np.array.

return_dict (bool, необязательный, по умолчанию True) : Возвращать ли ~pipelines.ltx.LTXPipelineOutput вместо обычного кортежа.

attention_kwargs (dict, необязательный) : Словарь kwargs, который при указании передается в AttentionProcessor, определенный в self.processor в diffusers.models.attention_processor.

callback_on_step_end (Callable, необязательный) : функция, вызываемая в конце каждого шага денойзинга во время инференса. Функция вызывается со следующими аргументами: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs будет содержать список всех тензоров, как указано в callback_on_step_end_tensor_inputs.

callback_on_step_end_tensor_inputs (list, optional) : Список тензорных входных данных для функции callback_on_step_end. Тензоры, указанные в списке, будут переданы в качестве аргумента callback_kwargs. Вы сможете включать только переменные, перечисленные в атрибуте ._callback_tensor_inputs вашего класса pipeline.

max_sequence_length (int по умолчанию 128 ) : Максимальная длина последовательности, используемая с prompt.

Возвращает: ~pipelines.ltx.LTXPipelineOutput или tuple

Если return_dict равно True, возвращается ~pipelines.ltx.LTXPipelineOutput, иначе возвращается tuple, где первый элемент — это список с сгенерированными изображениями.

Функция, вызываемая при обращении к конвейеру для генерации.

Примеры:

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

Источник

Параметры:

prompt (str или list[str], необязательный) : промпт для кодирования

negative_prompt (str или list[str], необязательный) : Промпт или промпты, которые не должны направлять генерацию изображения. Если не задан, необходимо передать negative_prompt_embeds. Игнорируется, если не используется направляющее влияние (то есть игнорируется, если guidance_scale меньше 1).

do_classifier_free_guidance (bool, необязательный, по умолчанию True) : Использовать ли classifier free guidance.

num_videos_per_prompt (int, optional, по умолчанию 1) : Количество видео, которые должны быть сгенерированы для каждого промпта. Устройство torch, на котором должны размещаться результирующие эмбеддинги

prompt_embeds (torch.Tensor, необязательный) : Предварительно сгенерированные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, например для взвешивания промпта. Если не предоставлены, текстовые эмбеддинги будут сгенерированы из входного аргумента prompt.

negative_prompt_embeds (torch.Tensor, необязательный) : Предварительно сгенерированные отрицательные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, например для взвешивания промпта. Если не предоставлены, negative_prompt_embeds будут сгенерированы из входного аргумента negative_prompt.

device : (torch.device, необязательный): устройство torch

dtype : (torch.dtype, необязательный): torch dtype

Кодирует промпт в скрытые состояния текстового энкодера.

LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

diffusers.LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

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

Источник

Параметры:

transformer (LTXVideoTransformer3DModel) : Условная архитектура Transformer для удаления шума из закодированных латентных представлений видео.

scheduler (FlowMatchEulerDiscreteScheduler) : планировщик, используемый в связке с transformer для удаления шума из закодированных латентов изображения.

vae (AutoencoderKLLTXVideo) : Модель вариационного автоэнкодера (VAE) для кодирования изображений в латентные представления и декодирования из них.

text_encoder (T5EncoderModel) : T5, а именно вариант google/t5-v1_1-xxl.

tokenizer (CLIPTokenizer) : Токенизатор класса CLIPTokenizer.

tokenizer (T5TokenizerFast) : Второй токенизатор класса T5TokenizerFast.

Пайплайн для генерации видео по изображению.

Справочник: 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)

Источник

Параметры:

image (PipelineImageInput) : Входное изображение для обусловливания генерации. Должно быть изображением, списком изображений или torch.Tensor.