#
# Лицензия Apache License, Version 2.0 («Лицензия»);
# вы можете использовать этот файл только в соответствии с Лицензией.
# Вы можете получить копию Лицензии по адресу
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Если это не требуется применимым законодательством или не оговорено письменно, программное
# распространяется по Лицензии на условиях «КАК ЕСТЬ»,
# БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ ИЛИ УСЛОВИЙ, прямо указанных или подразумеваемых.
# См. Лицензию для получения конкретных условий, регулирующих разрешения и
# ограничениями Лицензии. -->

# LTX-2

  

[LTX-2](https://hf.co/papers/2601.03233) — это базовая модель на основе DiT, предназначенная для генерации синхронизированного видео и аудио в рамках одной модели. Она объединяет ключевые компоненты современных систем генерации видео, предоставляя открытые веса и акцентируя внимание на практическом локальном выполнении.

Все исходные контрольные точки LTX-Video можно найти в организации [Lightricks](https://huggingface.co/Lightricks).

Исходный код LTX-2 можно найти [здесь](https://github.com/Lightricks/LTX-2).

## Генерация в два этапа

Значения по умолчанию для общего `LTX2Pipeline` / `LTX2ImageToVideoPipeline` `__call__` соответствуют эталонным для LTX-2.5 (`num_inference_steps=30`; `num_frames` является необязательным, если присутствует `duration_head`, в противном случае используется значение по умолчанию `121`). В примерах ниже эти значения по умолчанию также используются для LTX-2.0/2.3.

Рекомендуемый конвейер для достижения производственного качества генерации; он состоит из двух этапов:

- Этап 1: сгенерировать видео в целевом разрешении с помощью диффузионного сэмплирования с использованием classifier-free guidance (CFG). На этом этапе формируется последовательность кадров с низким уровнем шума, согласованная с текстовым/изображением-условием.
- Этап 2: Увеличение разрешения вывода этапа 1 в 2 раза и уточнение деталей с использованием дистиллированной модели LoRA для повышения точности и визуального качества. На этапе 2 может применяться более слабый CFG, чтобы сохранить структуру, полученную на этапе 1, одновременно улучшая текстуру и резкость.

Пример использования двухэтапного конвейера text-to-video

```py
import torch
from diffusers import FlowMatchEulerDiscreteScheduler
from diffusers.pipelines.ltx2 import LTX2Pipeline, LTX2LatentUpsamplePipeline
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.utils import STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video

device = "cuda:0"
width = 768
height = 512

pipe = LTX2Pipeline.from_pretrained(
    "Lightricks/LTX-2", dtype=torch.bfloat16
)
pipe.enable_sequential_cpu_offload(device=device)

prompt = "A beautiful sunset over the ocean"
negative_prompt = "shaky, glitchy, low quality, worst quality, deformed, distorted, disfigured, motion smear, motion artifacts, fused fingers, bad anatomy, weird hand, ugly, transition, static."

# Stage 1 default (non-distilled) inference
frame_rate = 24.0
video_latent, audio_latent = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=30,
    sigmas=None,
    guidance_scale=3.0,
    output_type="latent",
    return_dict=False,
)

latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    "Lightricks/LTX-2",
    subfolder="latent_upsampler",
    dtype=torch.bfloat16,
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
upsample_pipe.enable_model_cpu_offload(device=device)
upscaled_video_latent = upsample_pipe(
    latents=video_latent,
    output_type="latent",
    return_dict=False,
)[0]

# Load Stage 2 distilled LoRA
pipe.load_lora_weights(
    "Lightricks/LTX-2", adapter_name="stage_2_distilled", weight_name="ltx-2-19b-distilled-lora-384.safetensors"
)
pipe.set_adapters("stage_2_distilled", 1.0)
# VAE tiling is usually necessary to avoid OOM error when VAE decoding
pipe.vae.enable_tiling()
# Change scheduler to use Stage 2 distilled sigmas as is
new_scheduler = FlowMatchEulerDiscreteScheduler.from_config(
    pipe.scheduler.config, use_dynamic_shifting=False, shift_terminal=None
)
pipe.scheduler = new_scheduler
# Stage 2 inference with distilled LoRA and sigmas
video, audio = pipe(
    latents=upscaled_video_latent,
    audio_latents=audio_latent,
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=3,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0], # renoise with first sigma value https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/ti2vid_two_stages.py#L218
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_lora_distilled_sample.mp4",
)
```

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

```py
import torch
from diffusers.pipelines.ltx2 import LTX2Pipeline, LTX2LatentUpsamplePipeline
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "rootonchair/LTX-2-19b-distilled"

pipe = LTX2Pipeline.from_pretrained(
    model_path, dtype=torch.bfloat16
)
pipe.enable_sequential_cpu_offload(device=device)

prompt = "A beautiful sunset over the ocean"
negative_prompt = "shaky, glitchy, low quality, worst quality, deformed, distorted, disfigured, motion smear, motion artifacts, fused fingers, bad anatomy, weird hand, ugly, transition, static."

frame_rate = 24.0
video_latent, audio_latent = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=8,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    generator=generator,
    output_type="latent",
    return_dict=False,
)

latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    model_path,
    subfolder="latent_upsampler",
    dtype=torch.bfloat16,
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
upsample_pipe.enable_model_cpu_offload(device=device)
upscaled_video_latent = upsample_pipe(
    latents=video_latent,
    output_type="latent",
    return_dict=False,
)[0]

video, audio = pipe(
    latents=upscaled_video_latent,
    audio_latents=audio_latent,
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=3,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0], # renoise with first sigma value https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/distilled.py#L178
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    generator=generator,
    guidance_scale=1.0,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_distilled_sample.mp4",
)
```

## Условная генерация конвейера

С помощью `LTX2ConditionPipeline` можно задать условия по изображению и/или видео для произвольных латентных индексов. Например, можно указать условия для первого и последнего кадров, чтобы выполнить генерацию видео по первым и последним кадрам (FLF2V):

```py
import torch
from diffusers import LTX2ConditionPipeline, LTX2LatentUpsamplePipeline
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video
from diffusers.utils import load_image

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "rootonchair/LTX-2-19b-distilled"

pipe = LTX2ConditionPipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

prompt = (
    "CG animation style, a small blue bird takes off from the ground, flapping its wings. The bird's feathers are "
    "delicate, with a unique pattern on its chest. The background shows a blue sky with white clouds under bright "
    "sunshine. The camera follows the bird upward, capturing its flight and the vastness of the sky from a close-up, "
    "low-angle perspective."
)

first_image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_first_frame.png",
)
last_image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_last_frame.png",
)
first_cond = LTX2VideoCondition(frames=first_image, index=0, strength=1.0)
last_cond = LTX2VideoCondition(frames=last_image, index=-1, strength=1.0)
conditions = [first_cond, last_cond]

frame_rate = 24.0
video_latent, audio_latent = pipe(
    conditions=conditions,
    prompt=prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=8,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    generator=generator,
    output_type="latent",
    return_dict=False,
)

latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    model_path,
    subfolder="latent_upsampler",
    dtype=torch.bfloat16,
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
upsample_pipe.enable_model_cpu_offload(device=device)
upscaled_video_latent = upsample_pipe(
    latents=video_latent,
    output_type="latent",
    return_dict=False,
)[0]

video, audio = pipe(
    latents=upscaled_video_latent,
    audio_latents=audio_latent,
    prompt=prompt,
    width=width * 2,
    height=height * 2,
    num_inference_steps=3,
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    generator=generator,
    guidance_scale=1.0,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_distilled_flf2v.mp4",
)
```

Вы можете использовать как условия на основе изображений, так и на основе видео:

```py
import torch
from diffusers import LTX2ConditionPipeline
from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT
from diffusers.utils import load_image, load_video

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "rootonchair/LTX-2-19b-distilled"

pipe = LTX2ConditionPipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

prompt = (
    "The video depicts a long, straight highway stretching into the distance, flanked by metal guardrails. The road is "
    "divided into multiple lanes, with a few vehicles visible in the far distance. The surrounding landscape features "
    "dry, grassy fields on one side and rolling hills on the other. The sky is mostly clear with a few scattered "
    "clouds, suggesting a bright, sunny day. And then the camera switch to a winding mountain road covered in snow, "
    "with a single vehicle traveling along it. The road is flanked by steep, rocky cliffs and sparse vegetation. The "
    "landscape is characterized by rugged terrain and a river visible in the distance. The scene captures the "
    "solitude and beauty of a winter drive through a mountainous region."
)

cond_video = load_video(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input-vid.mp4"
)
cond_image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input.jpg"
)
video_cond = LTX2VideoCondition(frames=cond_video, index=0, strength=1.0)
image_cond = LTX2VideoCondition(frames=cond_image, index=8, strength=1.0)
conditions = [video_cond, image_cond]

frame_rate = 24.0
video, audio = pipe(
    conditions=conditions,
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=30,
    guidance_scale=3.0,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_cond_video.mp4",
)
```

Поскольку обусловливание выполняется через латентные кадры, 8 кадров в пространстве данных, соответствующих указанному латентному кадру для условия изображения, будут иметь тенденцию к статичности.

## Мультимодальное управление

Пайплайны LTX-2.X поддерживают мультимодальное управление. Оно состоит из трёх слагаемых, каждое из которых использует правило обновления в стиле CFG:

1. Classifier-Free Guidance (CFG): стандартный [CFG](https://huggingface.co/papers/2207.12598), где возмущённый («более слабый») вывод генерируется с использованием негативного промпта.
2. Пространственно-временное управление (STG): [STG](https://huggingface.co/papers/2411.18664) отходит от использования возмущённого вывода, полученного путём сокращения операций само-внимания, и вместо этого подставляет значения внимания. Идея состоит в том, что это приводит к более чётким видео и лучшей пространственно-временной согласованности.
3. Руководство по изоляции модальности: отходит от возмущённого вывода, создаваемого путём отключения кросс-внимания между модальностями (аудио-в-видео и видео-в-аудио). Это руководство более специфично для моделей [LTX-2.X](https://huggingface.co/papers/2601.03233), с идеей о том, что это обеспечивает лучшую согласованность между сгенерированным аудио и видео.

Эти параметры управляются аргументами `guidance_scale`, `stg_scale` и `modality_scale` и могут быть заданы отдельно для видео и аудио. Кроме того, для STG необходимо указать индексы блоков трансформера, в которых пропускается само-внимание, с помощью аргумента `spatio_temporal_guidance_blocks`. Пайплайны LTX-2.X также поддерживают [масштабирование гайданса](https://huggingface.co/papers/2305.08891), что помогает снизить переэкспозицию, которая может возникать при высоких значениях масштабов гайданса.

```py
import torch
from diffusers import LTX2ImageToVideoPipeline
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT
from diffusers.utils import load_image

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "diffusers/LTX-2.3-Diffusers"

pipe = LTX2ImageToVideoPipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

prompt = (
    "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in "
    "gentle low-gravity motion. Fine lunar dust lifts and drifts outward with each movement, floating in slow arcs "
    "before settling back onto the ground. The astronaut pushes free in a deliberate, weightless motion, small "
    "fragments of the egg tumbling and spinning through the air. In the background, the deep darkness of space subtly "
    "shifts as stars glide with the camera's movement, emphasizing vast depth and scale. The camera performs a "
    "smooth, cinematic slow push-in, with natural parallax between the foreground dust, the astronaut, and the "
    "distant starfield. Ultra-realistic detail, physically accurate low-gravity motion, cinematic lighting, and a "
    "breath-taking, movie-like shot."
)

image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg",
)

video, audio = pipe(
    image=image,
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=30,
    guidance_scale=3.0,  # Recommended LTX-2.3 guidance parameters
    stg_scale=1.0,  # Note that 0.0 (not 1.0) means that STG is disabled (all other guidance is disabled at 1.0)
    modality_scale=3.0,
    guidance_rescale=0.7,
    audio_guidance_scale=7.0,  # Note that a higher CFG guidance scale is recommended for audio
    audio_stg_scale=1.0,
    audio_modality_scale=3.0,
    audio_guidance_rescale=0.7,
    spatio_temporal_guidance_blocks=[28],
    use_cross_timestep=True,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_3_i2v_stage_1.mp4",
)
```

## Улучшение промпта

Модели LTX-2.X чувствительны к стилю промптов. См. [официальное руководство по промптам](https://ltx.io/model/model-blog/prompting-guide-for-ltx-2) с рекомендациями по написанию качественных промптов. Использование улучшения промптов, при котором предоставленные промпты улучшаются с помощью текстового энкодера пайплайна (по умолчанию модель [Gemma 3](https://huggingface.co/google/gemma-3-12b-it-qat-q4_0-unquantized)) на основе системного промпта, также может повысить качество сгенерированных образцов. Для использования улучшения промптов обязателен опциональный компонент пайплайна `processor`. Включите его с помощью `enable_prompt_enhancement=True` и `system_prompt` (по желанию, в соответствии с эталонными пайплайнами Lightricks):

```py
import torch
from transformers import Gemma3Processor
from diffusers import LTX2Pipeline
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT, T2V_DEFAULT_SYSTEM_PROMPT

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "diffusers/LTX-2.3-Diffusers"

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_model_cpu_offload(device=device)
pipe.vae.enable_tiling()
if getattr(pipe, "processor", None) is None:
    processor = Gemma3Processor.from_pretrained("google/gemma-3-12b-it-qat-q4_0-unquantized")
    pipe.processor = processor

prompt = (
    "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in "
    "gentle low-gravity motion. Fine lunar dust lifts and drifts outward with each movement, floating in slow arcs "
    "before settling back onto the ground. The astronaut pushes free in a deliberate, weightless motion, small "
    "fragments of the egg tumbling and spinning through the air. In the background, the deep darkness of space subtly "
    "shifts as stars glide with the camera's movement, emphasizing vast depth and scale. The camera performs a "
    "smooth, cinematic slow push-in, with natural parallax between the foreground dust, the astronaut, and the "
    "distant starfield. Ultra-realistic detail, physically accurate low-gravity motion, cinematic lighting, and a "
    "breath-taking, movie-like shot."
)

video, audio = pipe(
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    num_inference_steps=30,
    guidance_scale=3.0,
    stg_scale=1.0,
    modality_scale=3.0,
    guidance_rescale=0.7,
    audio_guidance_scale=7.0,
    audio_stg_scale=1.0,
    audio_modality_scale=3.0,
    audio_guidance_rescale=0.7,
    spatio_temporal_guidance_blocks=[28],
    use_cross_timestep=True,
    enable_prompt_enhancement=True,
    system_prompt=T2V_DEFAULT_SYSTEM_PROMPT,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_3_t2v_stage_1.mp4",
)
```

## LTX-2.5

LTX-2.5 использует те же классы `LTX2Pipeline`/`LTX2VideoTransformer3DModel`/`AutoencoderKLLTX2Video`/и т. д., что и LTX-2.3 — отдельного класса пайплайна для него нет. Разница, видимая пользователем, заключается в текстовом энкодере: LTX-2.5 работает с чекпоинтом Gemma 4 (`gemma4_unified`), а не Gemma 3. Он загружается автоматически при вызове `from_pretrained` для сконвертированного чекпоинта LTX-2.5 (через классы `Auto*` из `transformers`), поэтому дополнительная настройка на этапе инференса не требуется — достаточно указать в `from_pretrained` репозиторий LTX-2.5 вместо LTX-2.3.

[`Lightricks/LTX-2.5-Diffusers`](https://huggingface.co/Lightricks/LTX-2.5-Diffusers) содержит оба трансформера: **дистиллированный** DiT в `transformer/`, на который указывает `model_index.json`, и полный/SFT DiT в `transformer_full/`, который необходимо загружать явно (см. [Полный / SFT трансформер](#full--sft-transformer)). Папка `scheduler/` в репозитории настроена для дистиллированной контрольной точки (`use_dynamic_shifting=False`, `shift_terminal=None`), чтобы её сигма-расписание использовалось в точности в том виде, в котором задано. Всё, что требуется для [двухстадийной генерации](#two-stage-generation-for-ltx-25), также поставляется там: подпапка `latent_upsampler/` и дистиллированный LoRA для второй стадии, `ltx-2.5-22b-distilled-lora-450-bf16.safetensors`, в корне репозитория.

Дистиллированный вывод управляется явным расписанием сигмы, а не количеством шагов, и выполняется без направляющего сигнала (`guidance_scale=1.0`, поэтому `negative_prompt` не используется). Передача `num_inference_steps` вместо этого даст модели общее линейное расписание и незаметно снизит качество:

```py
import torch
from diffusers import LTX2Pipeline
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "Lightricks/LTX-2.5-Diffusers"

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

prompt = "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."

video, audio = pipe(
    prompt=prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_t2v.mp4",
)
```

### Двухэтапная генерация для LTX-2.5

LTX-2.5 поддерживает оба двухстадийных варианта, а `DISTILLED_SIGMA_VALUES` / `STAGE_2_DISTILLED_SIGMA_VALUES` являются его эталонными расписаниями:

- **Дистиллированная контрольная точка, оба этапа** — эталонный рецепт для стандартного `transformer/`, показанный ниже. LoRA второго этапа не используется, поскольку трансформер уже дистиллирован; это [Генерация дистиллированной контрольной точки](#distilled-checkpoint-generation) с весами LTX-2.5.
- **Полный SFT, этап 1 + дистиллированный LoRA, этап 2** — [Двухэтапная генерация](#two-stages-generation), описанная в начале этой страницы, с использованием `transformer_full/` и поставляемого LoRA. Подробности о изменениях — [ниже](#stage-2-with-the-distilled-lora).

Этап 1 выполняется в половинном от целевого разрешении, апсемплер удваивает его, а этап 2 уточняет изображение в полном разрешении — видео *и* аудио, оба с новым посевом из латентов этапа 1 при `noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0]`. Высота и ширина должны делиться на 64, поскольку этап 1 уменьшает каждую ось вдвое и всё равно должен попасть на пространственную сетку VAE.

```py
import torch
from diffusers.pipelines.ltx2 import LTX2Pipeline, LTX2LatentUpsamplePipeline
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES, STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video

device = "cuda"  # or "mps", "xpu", "cpu"
width = 1536
height = 1024
num_frames = 121
frame_rate = 24.0
model_path = "Lightricks/LTX-2.5-Diffusers"

# One generator for the whole call, threaded through both stages, so stage 2 continues the noise
# stream instead of repeating stage 1's draw.
generator = torch.Generator(device).manual_seed(42)

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)

prompt = "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."

# Stage 1: half resolution, 8 distilled sigmas
video_latent, audio_latent = pipe(
    prompt=prompt,
    width=width // 2,
    height=height // 2,
    num_frames=num_frames,
    frame_rate=frame_rate,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    generator=generator,
    output_type="latent",
    return_dict=False,
)

latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    model_path,
    subfolder="latent_upsampler",
    dtype=torch.bfloat16,
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
upsample_pipe.enable_model_cpu_offload(device=device)
# `latents_normalized=False`: `output_type="latent"` already applied the latent statistics, and the
# upsampler is trained on denormalized latents. Stage 2 renormalizes them in `prepare_latents`.
upscaled_video_latent = upsample_pipe(
    latents=video_latent,
    latents_normalized=False,
    output_type="latent",
    return_dict=False,
)[0]

# Stage 2: full resolution, 3 sigmas, reseeded from stage 1. Pass `num_frames` explicitly here --
# omitting it would run the duration head a second time instead of using the stage 1 length.
pipe.vae.enable_tiling()
video, audio = pipe(
    prompt=prompt,
    latents=upscaled_video_latent,
    audio_latents=audio_latent,
    width=width,
    height=height,
    num_frames=num_frames,
    frame_rate=frame_rate,
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],  # renoise with the stage 2 entry sigma
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_t2v_two_stages.mp4",
)
```

Если длина определяется [duration head](#automatic-duration-for-ltx-25), а не явным параметром `num_frames`, пусть этап 1 принимает решение и восстанавливает фактическую длину из своих латентов (`[B, C, F, H, W]`) до запуска этапа 2, вместо того чтобы предсказывать её повторно:

```py
num_frames = (video_latent.shape[2] - 1) * pipe.vae_temporal_compression_ratio + 1
```

#### Этап 2 с дистиллированным LoRA

Чтобы вместо этого запустить [Two-stages Generation](#two-stages-generation) — полный/SFT DiT для первого этапа, дистиллированный LoRA для второго — соберите пайплайн так, как описано в разделе [Full / SFT transformer](#full--sft-transformer), и сгенерируйте латенты первого этапа с использованием этого стека guidance. Затем два момента отличаются от LTX-2.0/2.3. LoRA находится в самом репозитории diffusers, а не рядом с исходными весами, а переключение планировщика происходит в обратную сторону: в LTX-2.5 поставляется конфигурация планировщика *distilled*, поэтому именно на первом этапе включается динамический сдвиг, а на втором он снова отключается.

```py
pipe.load_lora_weights(
    "Lightricks/LTX-2.5-Diffusers",
    adapter_name="stage_2_distilled",
    weight_name="ltx-2.5-22b-distilled-lora-450-bf16.safetensors",
)
pipe.set_adapters("stage_2_distilled", 1.0)
pipe.vae.enable_tiling()

pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(
    pipe.scheduler.config, use_dynamic_shifting=False, shift_terminal=None
)
```

Шаг апсемплинга и вызов этапа 2 остаются без изменений по сравнению с приведённым выше дистиллированным рецептом: те же `sigmas=STAGE_2_DISTILLED_SIGMA_VALUES`, тот же `noise_scale` и `guidance_scale=1.0`, поскольку на этапе 2 в любом случае выполняется дистиллированная модель.

### Свёрточное и диффузионное декодирование

LTX-2.5 включает в себя два видеодекодера, работающих в одном и том же латентном пространстве, поэтому латенты взаимозаменяемы между ними:

- `vae/` — свёрточный VAE ([AutoencoderKLLTX2Video](/docs/diffusers/v0.43.0/ru/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video)). Именно с его помощью пайплайны выполняют декодирование, поэтому все приведённые выше фрагменты кода уже используют его. Это единственный из двух, который поддерживает тайлинг (`pipe.vae.enable_tiling()`), что обычно позволяет уместить изображение высокого разрешения в память.
- `diffusion_decoder/` — [LTX2VideoDiffusionDecoderModel](/docs/diffusers/v0.43.0/ru/api/models/ltx2_diffusion_decoder#diffusers.LTX2VideoDiffusionDecoderModel). Это самостоятельная диффузионная модель, а не компонент пайплайна, поэтому она не передаётся как `vae`: запустите пайплайн с `output_type="latent"` и передайте латенты в [LTX2VideoDiffusionDecodePipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2VideoDiffusionDecodePipeline).

Кодирование всегда выполняется через `vae/`, поэтому выбор не влияет на условное кодирование изображений и видео.

При декодировании с помощью диффузионного декодера меняется две вещи. `output_type="latent"` также пропускает вокодер, поэтому аудио возвращается в виде латентов и требует ручной доработки, а процессор NATTEN фактически обязателен при видео-разрешениях:

```py
import torch
from diffusers import LTX2Pipeline, LTX2VideoDiffusionDecodePipeline, LTX2VideoDiffusionDecoderModel
from diffusers.models.autoencoders.ltx2_diffusion_decoder import LTX2VideoVaeNeighborhoodNattenProcessor
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video

device = "cuda"  # or "mps", "xpu", "cpu"
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(42)
model_path = "Lightricks/LTX-2.5-Diffusers"

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_model_cpu_offload(device=device)

prompt = "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."

latents, audio_latents = pipe(
    prompt=prompt,
    width=960,
    height=544,
    num_frames=121,
    frame_rate=frame_rate,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    generator=generator,
    output_type="latent",
    return_dict=False,
)

# `output_type="latent"` skips the vocoder, so finish the audio by hand. These latents are already
# denormalized, which is what `audio_vae.decode` expects.
mel = pipe.audio_vae.decode(audio_latents.to(pipe.audio_vae.dtype), return_dict=False)[0]
audio = pipe.vocoder(mel)

decoder = LTX2VideoDiffusionDecoderModel.from_pretrained(
    model_path, subfolder="diffusion_decoder", dtype=torch.bfloat16
).to(device)
# The decoder runs on the `flex` backend by default, and uncompiled `flex_attention` materializes the
# full score matrix -- tens of GB at video resolutions. NATTEN's kernels are what the original
# implementation uses; they are fetched from the Hub by `kernels` (`pip install kernels`), not from a
# local NATTEN build. Switching the attention *backend* instead raises: only `flex` takes the BlockMask.
decoder.set_attn_processor(LTX2VideoVaeNeighborhoodNattenProcessor())
# Decode in overlapping tiles so peak memory scales with the tile size rather than the video size.
decoder.enable_tiling()

decode_pipe = LTX2VideoDiffusionDecodePipeline(diffusion_decoder=decoder, scheduler=pipe.scheduler)

# `denormalize=False`: `output_type="latent"` already applied the latent statistics, so applying them
# again would rescale every channel by its std a second time. The decoder draws the noise it denoises,
# so pass a generator to make decoding reproducible.
video = decode_pipe(
    latents, generator=generator, output_type="np", denormalize=False, return_dict=False
)[0]

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_t2v_diffusion_decode.mp4",
)
```

Чтобы объединить это с [двухэтапной генерацией](#two-stage-generation-for-ltx-25), запросите у *второго этапа* `output_type="latent"` и декодируйте результат.

`decoder.enable_tiling()` позволяет удерживать декодирование высокого разрешения в памяти, аналогично тому, как `pipe.vae.enable_tiling()` делает это для свёрточного VAE. Памятёмкая часть декодирования — последний этап апсемплинга и этап диффузии — выполняется на перекрывающихся тайлах, которые затем смешиваются обратно, поэтому пиковое потребление памяти ограничивается размером тайла, а не размером видео. Тайлинг включается только тогда, когда латентное представление превышает один тайл, а размеры тайла и перекрытия можно настроить через аргументы `tile_sample_min_*` / `tile_sample_stride_*` (значения по умолчанию совпадают с эталонной реализацией). Поскольку на этапе диффузии шум удаляется для каждого тайла отдельно, результат декодирования с тайлингом не совпадает точно с результатом без тайлинга.

На одной карте также стоит освободить память перед декодированием (`pipe.to("cpu")` и `torch.cuda.empty_cache()`, после сохранения `pipe.scheduler` и `output_sampling_rate` вокодера), так как декодеру требуется собственное свободное пространство. Подробности об attention-бэкендах, тайлинге и остальном поведении декодера см. в [LTX2VideoDiffusionDecoderModel](/docs/diffusers/v0.43.0/ru/api/models/ltx2_diffusion_decoder#diffusers.LTX2VideoDiffusionDecoderModel).

### Полный / SFT-трансформер

`transformer_full/` не указан в `model_index.json`, поэтому его нужно загружать явно. Кроме того, для него требуется другой планировщик и полноценный механизм guidance: поставляемый `scheduler/` настроен для дистиллированной контрольной точки, а значения по умолчанию для guidance — это общие настройки эпохи LTX-2.0, из-за которых прогон SFT для LTX-2.5 явно недоконтролируется, при этом никаких ошибок не возникает. Рекомендации из раздела [Multimodal Guidance](#multimodal-guidance) применимы здесь без изменений, включая STG на блоке `28`:

```py
import torch
from diffusers import FlowMatchEulerDiscreteScheduler, LTX2Pipeline, LTX2VideoTransformer3DModel
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT

device = "cuda"  # or "mps", "xpu", "cpu"
model_path = "Lightricks/LTX-2.5-Diffusers"

# Passing `transformer=` keeps `from_pretrained` from fetching the distilled folder as well.
transformer = LTX2VideoTransformer3DModel.from_pretrained(
    model_path, subfolder="transformer_full", dtype=torch.bfloat16
)
pipe = LTX2Pipeline.from_pretrained(model_path, transformer=transformer, dtype=torch.bfloat16)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

# Re-enable dynamic shifting and the terminal shift, which the distilled configuration turns off.
pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(
    pipe.scheduler.config, use_dynamic_shifting=True, shift_terminal=0.1
)

video, audio = pipe(
    prompt="A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees.",
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=768,
    height=512,
    num_frames=121,
    frame_rate=24.0,
    num_inference_steps=30,
    guidance_scale=3.0,
    stg_scale=1.0,
    modality_scale=3.0,
    guidance_rescale=0.7,
    audio_guidance_scale=7.0,
    audio_stg_scale=1.0,
    audio_modality_scale=3.0,
    audio_guidance_rescale=0.7,
    spatio_temporal_guidance_blocks=[28],
    use_cross_timestep=True,
    generator=torch.Generator(device).manual_seed(42),
    output_type="np",
    return_dict=False,
)
```

Перетащите `sigmas` сюда — полный DiT получает расписание из планировщика.

### Улучшение промптов для LTX-2.5

**Использование улучшения промптов настоятельно рекомендуется для LTX-2.5; передайте `enable_prompt_enhancement=True`, чтобы включить эту функцию** (аналогично эталонным пайплайнам Lightricks). В отличие от LTX-2.0/2.3, где один и тот же чекпоинт текстового энкодера выполняет роль улучшателя (см. [Улучшение промптов](#prompt-enhancement) выше), дообученный текстовый энкодер LTX-2.5 не обучался для улучшения. Вместо этого для улучшения используется отдельный готовый чекпоинт `google/gemma-4-E2B-it`. Загрузите его в необязательные компоненты пайплайна `prompt_enhancer`/`processor`, а затем включите улучшение — по умолчанию пайплайн использует `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` и рецепт Gemma 4 (`do_sample=False`, `no_repeat_ngram_size=5`, `max_new_tokens=600`). Передайте явное значение `system_prompt=`, чтобы переопределить:

```py
import torch
from transformers import AutoModelForImageTextToText, AutoProcessor
from diffusers import LTX2Pipeline
from diffusers.utils import encode_video
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES

device = "cuda"  # or "mps", "xpu", "cpu"
width = 768
height = 512
random_seed = 42
frame_rate = 24.0
generator = torch.Generator(device).manual_seed(random_seed)
model_path = "Lightricks/LTX-2.5-Diffusers"
enhancer_model_id = "google/gemma-4-E2B-it"

pipe = LTX2Pipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.enable_model_cpu_offload(device=device)
pipe.vae.enable_tiling()
if getattr(pipe, "prompt_enhancer", None) is None:
    pipe.prompt_enhancer = AutoModelForImageTextToText.from_pretrained(enhancer_model_id)
    pipe.processor = AutoProcessor.from_pretrained(enhancer_model_id)

prompt = "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."

video, audio = pipe(
    prompt=prompt,
    width=width,
    height=height,
    num_frames=121,
    frame_rate=frame_rate,
    sigmas=DISTILLED_SIGMA_VALUES,
    guidance_scale=1.0,
    audio_guidance_scale=1.0,
    enable_prompt_enhancement=True,
    # No `system_prompt=` needed -- defaults to `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` when `prompt_enhancer` is set.
    generator=generator,
    output_type="np",
    return_dict=False,
)

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_t2v_enhanced.mp4",
)
```

То же самое относится к генерации видео по изображению с помощью `LTX2ImageToVideoPipeline`: установите `pipe.prompt_enhancer`/`pipe.processor` аналогичным образом и передайте `enable_prompt_enhancement=True` (используя `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT`, с условием на исходное изображение и текстовый промпт) — снова, `system_prompt=` не требуется, если вы не хотите переопределить его.

### Автоматическая длительность для LTX-2.5

Чекпоинты LTX-2.5 поставляются с небольшим `duration_head`, который предсказывает длительность описанного кадра на основе того же вывода текстового коннектора, на который опирается трансформер. Если загруженный пайплайн содержит этот модуль, **`num_frames` по умолчанию предсказывается автоматически** — просто опустите этот параметр, и модель сама выберет длину:

```py
video, audio = pipe(prompt=prompt, output_type="np", return_dict=False)
```

Чтобы задать длину самостоятельно, явно передайте `num_frames`. Целое число всегда имеет приоритет над заголовком:

```py
video, audio = pipe(prompt=prompt, num_frames=121, output_type="np", return_dict=False)
```

Пайплайны, загруженные из чекпоинтов LTX-2.0 или LTX-2.3, не имеют duration head и сохраняют предыдущее значение по умолчанию в 121 кадр, поэтому для них это ничего не меняет.

Передайте `min_seconds` / `max_seconds`, чтобы ограничить предсказание. Сырое предсказание ограничивается указанным диапазоном, а затем преобразуется в кадры:

```py
video, audio = pipe(
    prompt=prompt,
    min_seconds=2.0,
    max_seconds=10.0,
    frame_rate=frame_rate,
    output_type="np",
    return_dict=False,
)
```

Предсказанное количество кадров округляется до каузальной временной сетки VAE (`8k + 1`), поэтому фактическая длительность квантуется — примерно 0,33 с на шаг при 24 кадрах/с — и смещается в зависимости от `frame_rate`, поскольку head предсказывает секунды, а не кадры. `min_seconds` должно быть строго меньше `max_seconds`. Эти границы игнорируются, если `num_frames` задано явно.

Границы, уже одного шага сетки, могут не удовлетворяться точно: при 24 кадрах в секунду `[1.0s, 1.02s]` преобразуется в `[24, 24]` кадров, а 24 не является `8k + 1`. Используется ближайшая точка сетки, и в журнал выводится предупреждение, поэтому возвращаемая длина может оказаться чуть за пределами таких строгих границ.

Чтобы проверить предсказание без генерации видео, вызовите head напрямую. Всё, что ему нужно, является публичным:

```py
prompt_embeds, prompt_attention_mask, _, _ = pipe.encode_prompt(prompt, do_classifier_free_guidance=False)
video_tokens, audio_tokens, _ = pipe.connectors(prompt_embeds, prompt_attention_mask)

num_frames = pipe.duration_head.predict_num_frames(
    video_tokens,
    audio_tokens,
    frame_rate=24.0,
    temporal_compression_ratio=pipe.vae_temporal_compression_ratio,
)
seconds = pipe.duration_head(video_tokens, audio_tokens).item()  # raw, before clamping
print(f"predicted {seconds:.2f}s -> {num_frames} frames")
```

Конвертация контрольной точки версии 2.5 автоматически подхватывает head с помощью `--full_pipeline` или отдельно с помощью `--duration_head`. В контрольных точках, созданных до версии 2.5, таких весов нет, поэтому при конвертации этот компонент просто пропускается, а не вызывает ошибку.

### Скорость движения для LTX-2.5

LTX-2 размещает каждый видеотокен на временной оси в секундах, которая по умолчанию выводится из `frame_rate` — скорости воспроизведения. Параметр `motion_speed` (по умолчанию `1.0`) разделяет эти величины: временная ось обусловлена значением `frame_rate / motion_speed`, тогда как длина аудио, [duration head](#automatic-duration-for-ltx-25) и возвращаемое видео по-прежнему следуют `frame_rate`. При `frame_rate=24.0` и `motion_speed=0.2` модели сообщается, что действие было записано со скоростью 120 кадров/с, а результат воспроизводится со скоростью 24 кадра/с, что даёт замедление в 5 раз.

Базовая модель обучена на скоростях около 24/25/30/60 fps, поэтому значения, сильно отличающиеся от `1.0`, имеют смысл только в сочетании с адаптером, обученным для них, например [`Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control`](https://huggingface.co/Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control) (с ограниченным доступом: сначала примите её лицензию на Hub). Без `motion_speed` этот LoRA загружается как обычный LoRA и не обеспечивает никакого управления движением. В карточке модели рекомендуются скорости `1.0`, `0.5`, `0.2`, `0.1`, `0.05` и `0.025` при силе LoRA `1.0`. Не включайте в промпт слова, описывающие скорость («slow motion», «high fps»), и используйте один и тот же описательный текст для всех скоростей, поскольку именно `motion_speed` определяет эффект.

```py
import torch
from diffusers import LTX2ImageToVideoPipeline
from diffusers.pipelines.ltx2.utils import DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video, load_image

device = "cuda"  # or "mps", "xpu", "cpu"
width = 1920  # the LoRA's recommended resolution; the effect is much weaker at 768x512
height = 1088
frame_rate = 24.0  # playback rate, always 24 for this LoRA
model_path = "Lightricks/LTX-2.5-Diffusers"

pipe = LTX2ImageToVideoPipeline.from_pretrained(model_path, dtype=torch.bfloat16)
pipe.load_lora_weights(
    "Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control",
    weight_name="ltx-2.5-22b-lora-slow-motion-control-1.0.safetensors",
    adapter_name="slow_motion",
)
pipe.set_adapters("slow_motion", 1.0)
pipe.enable_sequential_cpu_offload(device=device)
pipe.vae.enable_tiling()

image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
)
# No speed wording: the same caption is reused at every speed.
prompt = (
    "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking apart and lunar dust "
    "lifting into the air, while the camera pushes in."
)

for motion_speed in (1.0, 0.2):
    video, audio = pipe(
        image=image,
        prompt=prompt,
        width=width,
        height=height,
        num_frames=121,
        frame_rate=frame_rate,
        motion_speed=motion_speed,  # 1.0 = real time, 0.2 = 5x slow motion
        sigmas=DISTILLED_SIGMA_VALUES,
        guidance_scale=1.0,
        audio_guidance_scale=1.0,
        generator=torch.Generator(device).manual_seed(42),
        output_type="np",
        return_dict=False,
    )

    encode_video(
        video[0],
        fps=frame_rate,  # the file plays at the playback rate, not frame_rate / motion_speed
        audio=audio[0].float().cpu(),
        audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
        output_path=f"ltx2_5_i2v_motion_speed_{motion_speed}.mp4",
    )
```

Оба клипа длятся 121 кадр (около 5 секунд при 24 кадрах в секунду), при этом меняется только темп движения. При [двухэтапной генерации](#two-stage-generation-for-ltx-25) передавайте одно и то же значение `motion_speed` на **оба** этапа. Этап 2 повторно выполняет удаление шума из видео, и если бы он работал в реальном времени, это отменило бы замедленное воспроизведение. [Справочный драйвер](https://huggingface.co/Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control/blob/main/distilled_speed_demo.py) делает то же самое, оборачивая объект этапа, которым пользуются оба прохода.

`motion_speed` также является входным параметром модульных блоков LTX-2 / LTX-2.5 и передаётся в модульный пайплайн аналогичным образом.

### LTX-2.5 Модульный

LTX-2.5 также доступен в виде модульного конвейера. Набор блоков по умолчанию использует диффузионный декодер и предсказывает длительность видео, если `num_frames` не указан. Он применяет гайданс отдельно к видео и аудио через компоненты `guider` и `audio_guider`. См. [LTX2Guidance](/docs/diffusers/v0.43.0/ru/api/modular_diffusers/guiders#diffusers.LTX2Guidance) для списка доступных параметров гайданса. По умолчанию модульный конвейер скачивает промпт-усилитель и процессор из репозитория [google/gemma-4-E2B-it](https://huggingface.co/google/gemma-4-E2B-it). Ниже приведен пример модульного T2V:

```py
import torch
from diffusers import ModularPipeline, ComponentsManager
from diffusers.models.autoencoders.ltx2_diffusion_decoder import LTX2VideoVaeNeighborhoodNattenProcessor
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT
from diffusers.utils import encode_video

device = "cuda"  # or "mps", "xpu", "cpu"
frame_rate = 24.0
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)

model_path = "Lightricks/LTX-2.5-Diffusers"

cm = ComponentsManager()
pipe = ModularPipeline.from_pretrained(model_path, components_manager=cm)
pipe.load_components(dtype=torch.bfloat16)
# Set memory_reserve_margin higher to more aggressively offload component models
cm.enable_auto_cpu_offload(device=device, memory_reserve_margin="20GB")
# The NATTEN processor works if `kernels` is available (`pip install kernels`)
# Otherwise omit the below line to use the Flex Attention processor
pipe.diffusion_decoder.set_attn_processor(LTX2VideoVaeNeighborhoodNattenProcessor())
pipe.diffusion_decoder.enable_tiling()

prompt = (
    "A cinematic shot of a red fox walking through a snowy forest at dawn, golden light filtering through pine trees."
)

output_state = pipe(
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=768,
    height=512,
    num_frames=None,  # Set to an int (e.g. 121) to specify a fixed video length
    frame_rate=frame_rate,
    num_inference_steps=30,
    use_cross_timestep=True,
    enable_prompt_enhancement=True,
    generator=generator,
    output_type="np",
)
video = output_state.get("videos")
audio = output_state.get("audio")

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_modular_t2v.mp4",
)
```

Модульный конвейер будет автоматически переключать рабочие процессы в зависимости от переданных входных данных. Например, если передан `image`, будет использован рабочий процесс I2V:

```py
import torch
from diffusers import ModularPipeline, ComponentsManager
from diffusers.models.autoencoders.ltx2_diffusion_decoder import LTX2VideoVaeNeighborhoodNattenProcessor
from diffusers.pipelines.ltx2.utils import DEFAULT_NEGATIVE_PROMPT
from diffusers.utils import encode_video, load_image

device = "cuda"  # or "mps", "xpu", "cpu"
frame_rate = 24.0
random_seed = 42
generator = torch.Generator(device).manual_seed(random_seed)

model_path = "Lightricks/LTX-2.5-Diffusers"

cm = ComponentsManager()
pipe = ModularPipeline.from_pretrained(model_path, components_manager=cm)
pipe.load_components(dtype=torch.bfloat16)
cm.enable_auto_cpu_offload(device=device, memory_reserve_margin="20GB")
pipe.diffusion_decoder.set_attn_processor(LTX2VideoVaeNeighborhoodNattenProcessor())
pipe.diffusion_decoder.enable_tiling()

prompt = (
    "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in "
    "gentle low-gravity motion."
)
image_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
image = load_image(image_path)

output_state = pipe(
    image=image,
    prompt=prompt,
    negative_prompt=DEFAULT_NEGATIVE_PROMPT,
    width=768,
    height=512,
    num_frames=None,  # Set to an int (e.g. 121) to specify a fixed video length
    frame_rate=frame_rate,
    num_inference_steps=30,
    use_cross_timestep=True,
    enable_prompt_enhancement=True,
    generator=generator,
    output_type="np",
)
video = output_state.get("videos")
audio = output_state.get("audio")

encode_video(
    video[0],
    fps=frame_rate,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_modular_i2v.mp4",
)
```

Поддерживаемые рабочие процессы можно найти в документации для каждого набора блоков (например, [LTX2AutoBlocks](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2AutoBlocks), [LTX25AutoBlocks](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX25AutoBlocks)).

### Diffusion Fidelity Rendering (DFR) для LTX-2.5

`LTX2DFRPipeline` жертвует временем выполнения ради детализации. Каждый вызов `__call__` — это **один проход денойзинга** с разрешением `height` × `width`: он генерирует видео и дополнительные **слоты для ключевых кадров** размером в один пиксель, либо повторно денойзит переданные латенты, инициализированные из этих слотов. Вызывающий код комбинирует этапы так же, как в других двухэтапных пайплайнах LTX: этот пайплайн, затем [LTX2LatentUpsamplePipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2LatentUpsamplePipeline), снова этот пайплайн, а для каждого временного раунда — [LTX2DFRTemporalRefinePipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRTemporalRefinePipeline).

Слот обходится в полный латентный кадр токенов ради одного пиксельного кадра, что ослабляет эффективное временное сжатие в этой позиции — поэтому окружающее видео обуславливается действительно новыми кадрами, а не интерполированными. Позиции слотов определяются по сегментной сетке, выровненной по временной границе VAE (24 или 32 пиксельных кадра, в зависимости от того, какой вариант требует меньше дополнения). Холст внутренним образом дополняется до целого числа сегментов; `output_type="latent"` возвращает эту дополненную сетку, чтобы слот на дополнении не был отброшен. Обрежьте с помощью `trim_canvas` перед декодированием VAE.

Для этого требуется трансформер, в конфигурации которого задан параметр `use_keyframes_abs_pos_embedding`, отмечающий латенты одиночных пиксельных кадров с помощью обучаемого эмбеддинга. Чекпоинты LTX-2.5 поставляются с этим параметром; пайплайн вызывает исключение для более старых версий, чтобы не тратить бюджет токенов на токены, которые он не может интерпретировать.

Бюджет на дополнительные токены: каждый слот добавляет объём, соответствующий одному латентному кадру, поэтому второй этап обрабатывает более длинную последовательность, чем эквивалентный двухэтапный дистиллированный проход — на 31% больше при разрешении 1024x1536 и 121 кадре (24576 -> 32256 токенов, 5 слотов на сетке сегментов из 24 кадров). Пиковая память активаций масштабируется пропорционально этому, поэтому разрешение, которое едва помещается в рамках обычного дистиллированного рецепта, может потребовать `enable_sequential_cpu_offload`, `vae.enable_tiling()` или уменьшения холста при использовании DFR.

Composition использует `return_dict=True` для `keyframes` и `keyframe_positions` (`return_dict=False` возвращает те же четыре поля в виде кортежа).

Полный рецепт, приведённый ниже, — это тот, с которого стоит начинать: преобразование изображения в видео с разрешением 1088×1920, один раунд временного уточнения x2 и пространственный детализирующий IC-LoRA x2 на этапе 2.

```py
import torch
from diffusers import (
    LTX2DFRPipeline,
    LTX2DFRTemporalRefinePipeline,
    LTX2LatentUpsamplePipeline,
    LTXEulerAncestralRFScheduler,
)
from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
from diffusers.pipelines.ltx2.utils import trim_canvas
from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
from diffusers.pipelines.ltx2.utils import STAGE_2_DISTILLED_SIGMA_VALUES
from diffusers.utils import encode_video, load_image

pipe = LTX2DFRPipeline.from_pretrained("Lightricks/LTX-2.5-Diffusers", torch_dtype=torch.bfloat16)
latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    "Lightricks/LTX-2.5-Diffusers", subfolder="latent_upsampler", torch_dtype=torch.bfloat16
)
# The x2 temporal upsampler is not in the published `model_index.json` — convert it with
# `--temporal_latent_upsampler`.
temporal_latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
    "path/to/converted/temporal_latent_upsampler", torch_dtype=torch.bfloat16
)
upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
temporal_pipe = LTX2DFRTemporalRefinePipeline(
    scheduler=LTXEulerAncestralRFScheduler(eta=0.5),
    vae=pipe.vae,
    audio_vae=pipe.audio_vae,
    text_encoder=pipe.text_encoder,
    tokenizer=pipe.tokenizer,
    connectors=pipe.connectors,
    transformer=pipe.transformer,
    vocoder=pipe.vocoder,
    temporal_latent_upsampler=temporal_latent_upsampler,
)

# All three pipelines share the same components, so place them together. Do not call
# `enable_model_cpu_offload()` on one of them: its hooks would own modules the other two also call,
# and `temporal_latent_upsampler` — held only by `temporal_pipe` — would never reach the device.
pipe.to("cuda")
upsample_pipe.to("cuda")
temporal_pipe.to("cuda")

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png")
prompt = "A tabby cat stretching in a sunlit window, dust motes drifting in the light"
conditions = [LTX2VideoCondition(frames=image, index=0, strength=1.0)]
height, width = 1088, 1920
frame_rate = 24.0
generator = torch.Generator(device="cuda").manual_seed(0)

num_frames = 121
out = pipe(
    prompt=prompt,
    conditions=conditions,
    height=height // 2,
    width=width // 2,
    num_frames=num_frames,
    frame_rate=frame_rate,
    generator=generator,
    output_type="latent",
)
up_video = upsample_pipe(latents=out.frames, output_type="latent", return_dict=False)[0]
up_keyframes = upsample_pipe(latents=out.keyframes, output_type="latent", return_dict=False)[0]

# Load after stage 1 so the adapter is never disabled. `set_adapters` does not re-enable a
# transformer that already had `disable_adapters()` called on it.
pipe.load_lora_weights("Lightricks/LTX-2.5-22b-IC-LoRA-Pixel-Spatial-Upscaler", adapter_name="detailing")
pipe.set_adapters(["detailing"], adapter_weights=[0.5])
out2 = pipe(
    prompt=prompt,
    conditions=conditions,
    latents=up_video,
    audio_latents=out.audio,
    keyframes_latents=up_keyframes,
    keyframe_positions=out.keyframe_positions,
    reference_latents=out.frames,
    height=height,
    width=width,
    num_frames=num_frames,
    frame_rate=frame_rate,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    generator=generator,
    output_type="latent",
)
pipe.transformer.disable_adapters()

# `num_frames` here is the *padded* canvas the latents actually cover, which `resolve_canvas` may have
# grown past the 121 that were asked for. `condition_num_frames` stays the original request so a
# negative `condition.index` does not wrap onto the pad.
ratio = pipe.vae.temporal_compression_ratio
canvas_frames = (out2.frames.shape[2] - 1) * ratio + 1
out3 = temporal_pipe(
    latents=out2.frames,
    keyframes_latents=out2.keyframes,
    keyframe_positions=out2.keyframe_positions,
    audio_latents=out.audio,
    prompt=prompt,
    conditions=conditions,
    height=height,
    width=width,
    num_frames=canvas_frames,
    frame_rate=frame_rate,
    source_seconds=canvas_frames / frame_rate,
    condition_num_frames=num_frames,
    generator=generator,
    output_type="latent",
)

# Keep the padded canvas until decode so a slot on the pad is not dropped. `trim_canvas` counts *pixel*
# frames, and the round mapped `N -> 2 (N - 1) + 1`.
playback_fps = frame_rate * 2
requested_frames = (num_frames - 1) * 2 + 1
video_latents = trim_canvas(out3.frames, requested_frames, ratio)
timestep = None
if pipe.vae.config.timestep_conditioning:
    timestep = torch.zeros(video_latents.shape[0], device=video_latents.device, dtype=pipe.vae.dtype)
video = pipe.vae.decode(video_latents.to(pipe.vae.dtype), timestep, return_dict=False)[0]
video = pipe.video_processor.postprocess_video(video, output_type="np")

# Audio is stage 1's. Cut it to the video's duration so a muxed container does not outlast the picture.
audio = pipe.vocoder(pipe.audio_vae.decode(out.audio.to(pipe.audio_vae.dtype), return_dict=False)[0])
audio_samples = round(requested_frames / playback_fps * pipe.vocoder.config.output_sampling_rate)
audio = audio[..., : min(audio.shape[-1], audio_samples)]

encode_video(
    video[0],
    fps=playback_fps,
    audio=audio[0].float().cpu(),
    audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
    output_path="ltx2_5_dfr.mp4",
)
```

`height` и `width` соответствуют **данному проходу**, а не итоговому выводу. Первый этап выполняется на холсте с разрешением, вдвое меньшим, чем 1080p (544×960); второй этап — на 1088×1920. Каждое значение должно делиться на коэффициент пространственного сжатия VAE (32 для LTX-2.5 при одном проходе; 64, если первый этап составляет половину от 1080p). Именно поэтому разрешение 1080p равно **1920×1088**, а 4K — **3840×2176**. Каждый проход использует фиксированный дистиллированный график (`sigmas`), поэтому параметра `num_inference_steps` нет; дистиллированные графики обучаются без гайданса, поэтому отсутствуют также `negative_prompt` и `guidance_scale`. Встроенный звук соответствует первому этапу — последующие проходы всё равно запускают аудиопоток, чтобы ветвь видео имела кросс-модальное внимание; сама форма волны после первого этапа не уточняется.

**Пространственная детализация.** Загрузите IC-LoRA для 2x пространственной детализации как именованный адаптер **после этапа 1** и активируйте его только для этапа 2 (`set_adapters(["detailing"], adapter_weights=[0.5])`). На этапе 2 модель обращается к латентному представлению с половинным разрешением этапа 1 как к `reference_latents`. Этап 1 и временные раунды выполняются с выключенным адаптером. Если вы загрузите LoRA до этапа 1, `transformer.disable_adapters()` отключит его, а `set_adapters` **не** включит его обратно — вызовите `transformer.enable_adapters()` перед этапом 2 или загрузите веса после этапа 1, как в рецепте. `reference_downscale_factor` (по умолчанию `2`) масштабирует пространственные координаты токенов-ссылок в пространство координат целевого изображения.

**Повременное уточнение.** [LTX2DFRTemporalRefinePipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRTemporalRefinePipeline) представляет собой один раунд: временное увеличение разрешения, разбиение на тайлы по швам ключевых кадров, предковое шумоподавление с помощью `LTXEulerAncestralRFScheduler` (`eta=0.5`), склейка путём отбрасывания начального участка последующего тайла и объединение набора переносимых ключевых кадров. Этот планировщик необходимо создать самостоятельно — раунд будет отклонён при использовании любого другого, поскольку детерминированный шаг дойдёт до конца и вернёт лишь более мягкий холст. Вызывайте пайплайн один раз на раунд; для 2x / 4x используйте цикл, передавая `round_index`. После раунда `keyframe_positions` невозможно повторно вывести из исходного `num_frames`, поэтому их необходимо передавать явно. Каждый тайл получает срез замороженного аудио первого этапа, покрывающий собственное окно воспроизведения. `source_seconds` — это длительность *первого этапа*, она остаётся неизменной между раундами, поэтому в последующих раундах её нужно передавать явно, а не полагаться на значение по умолчанию.

Условие fps равно 60 всегда, когда воспроизведение выше 30, независимо от мультиплексирования: время RoPE вычисляется как `pixel_frame / fps`, поэтому временная база 120 fps вдвое сократит временной диапазон каждого токена по сравнению с обученным распределением, а 48 fps — растянет. Оба лгут, что они 60, и обрабатывают декодированные кадры на скорости воспроизведения.

**Третий пространственный этап.** Соберите его; четвёртого пайплайна нет. Пространственно увеличьте **только видео**, пересоздайте ключевые кадры carry в RGB (`decode` → Lanczos ×2 → `encode` через [rebuild_epilogue_keyframes()](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipeline.rebuild_epilogue_keyframes); никогда не увеличивайте ключевые кадры epilogue в латентном пространстве), затем:

```py
from diffusers.pipelines.ltx2.dfr_layout import epilogue_tiles, pixel_to_latent_index

# One more doubling on top of the recipe above, so every stage below the output halves again:
# `epilogue_height` must be divisible by 128 (`4 * 32`), which is why 4K is 3840x2176.
epilogue_height, epilogue_width = height * 2, width * 2
refined_frames = (out3.frames.shape[2] - 1) * ratio + 1

up_video = upsample_pipe(latents=out3.frames, output_type="latent", return_dict=False)[0]
epilogue_keyframes = pipe.rebuild_epilogue_keyframes(
    out3.keyframes,
    decode_timestep=0.0,
    decode_noise_scale=0.0,
    seed=0,
    device=up_video.device,
    dtype=torch.float32,
)

# Temporal cuts land on the seams the *last* round stitched on -- the positions handed into it, doubled --
# not on every carry keyframe, since the slots that round invented sit mid-window.
tiles = epilogue_tiles(
    latent_shape=(
        (refined_frames - 1) // ratio + 1,
        epilogue_height // pipe.vae.spatial_compression_ratio,
        epilogue_width // pipe.vae.spatial_compression_ratio,
    ),
    frame_tiles=2,  # 2 ** number of temporal rounds
    frame_seams=[pixel_to_latent_index(2 * p, ratio) for p in out2.keyframe_positions],
)

pipe.transformer.enable_adapters()  # the epilogue is a detailing pass too
out4 = pipe(
    prompt=prompt,
    conditions=conditions,
    latents=up_video,
    audio_latents=out.audio,
    generate_slots=False,
    guidance_keyframe_latents=epilogue_keyframes,
    guidance_keyframe_positions=out3.keyframe_positions,
    reference_latents=out3.frames,
    height=epilogue_height,
    width=epilogue_width,
    num_frames=refined_frames,
    frame_rate=playback_fps,
    noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0],
    sigmas=STAGE_2_DISTILLED_SIGMA_VALUES,
    freeze_audio=True,
    video_tiles=tiles,
    generator=generator,
    output_type="latent",
)
pipe.transformer.disable_adapters()
```

Две оси сшиваются по-разному. Ни одна из сторон пространственной границы не содержит известного ответа, поэтому эти перекрытия смешиваются с трапециевидными весами. Временные тайлы разрезаются по швам ключевых кадров последнего раунда уточнения.

**Декодирование с помощью диффузионного декодера.** Для максимальной детализации оставайтесь на `output_type="latent"` и передавайте (уже денормализованные, возможно, обрезанные с помощью `trim_canvas`) латенты в [LTX2VideoDiffusionDecodePipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2VideoDiffusionDecodePipeline).

```py
from diffusers import LTX2VideoDiffusionDecodePipeline
from diffusers.models.autoencoders.ltx2_diffusion_decoder import LTX2VideoDiffusionDecoderModel

decoder = LTX2VideoDiffusionDecoderModel.from_pretrained(
    "Lightricks/LTX-2.5-Diffusers", subfolder="diffusion_decoder", dtype=torch.bfloat16
)
decode_pipe = LTX2VideoDiffusionDecodePipeline(
    diffusion_decoder=decoder, scheduler=pipe.scheduler, vae=pipe.vae
)
decode_pipe.enable_model_cpu_offload()
# `denormalize=False`: the `output_type="latent"` path already applied the latent statistics.
video = decode_pipe(latents=out3.frames, denormalize=False, output_type="np", return_dict=False)[0]
```

## LTX2Pipeline[[diffusers.LTX2Pipeline]]

#### diffusers.LTX2Pipeline[[diffusers.LTX2Pipeline]]

```python
diffusers.LTX2Pipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, processor: transformers.processing_utils.ProcessorMixin | None = None, prompt_enhancer: transformers.models.gemma4.modeling_gemma4.Gemma4ForConditionalGeneration | None = None, duration_head: diffusers.pipelines.ltx2.duration_head.LTX2DurationHead | None = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2.py#L209)

**Параметры:**

transformer ([LTXVideoTransformer3DModel](/docs/diffusers/v0.43.0/ru/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel)) : Условная архитектура Transformer для удаления шума из закодированных латентных представлений видео.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/ru/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : планировщик, используемый в связке с `transformer` для удаления шума из закодированных латентов изображения.

vae ([AutoencoderKLLTXVideo](/docs/diffusers/v0.43.0/ru/api/models/autoencoderkl_ltx_video#diffusers.AutoencoderKLLTXVideo)) : Модель вариационного автоэнкодера (VAE) для кодирования изображений в латентные представления и декодирования из них.

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), а именно вариант [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).

tokenizer (`CLIPTokenizer`) : Токенизатор класса [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).

tokenizer (`T5TokenizerFast`) : Второй токенизатор класса [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).

connectors (`LTX2TextConnectors`) : Стек текстовых коннекторов, используемый для адаптации скрытых состояний текстового энкодера для видео- и аудиоветвей.

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

Справочник: https://github.com/Lightricks/LTX-Video

#### __call__[[diffusers.LTX2Pipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int | None = None, min_seconds: float = 1.0, max_seconds: float = 20.0, frame_rate: float = 24.0, motion_speed: float = 1.0, num_inference_steps: int = 30, sigmas: list[float] | None = None, timesteps: list[int] = None, guidance_scale: float = 3.0, stg_scale: float = 1.0, modality_scale: float = 3.0, guidance_rescale: float = 0.7, audio_guidance_scale: float | None = 7.0, audio_stg_scale: float | None = 1.0, audio_modality_scale: float | None = 3.0, audio_guidance_rescale: float | None = 0.7, spatio_temporal_guidance_blocks: list[int] | None = [28], noise_scale: float = 0.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_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, use_cross_timestep: bool = True, system_prompt: str | None = None, enable_prompt_enhancement: bool = False, prompt_max_new_tokens: int | None = None, prompt_enhancement_kwargs: dict[str, typing.Any] | None = None, prompt_enhancement_seed: int = 10, output_type: str = '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 = 1024)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2.py#L929)

**Параметры:**

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

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

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

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

num_frames (`int`, *optional*) : Количество кадров видео для генерации. Если значение не указано, по умолчанию используется автоматически предсказанная длительность, если у этого пайплайна есть компонент `duration_head` (чекпоинты LTX-2.5 и новее), иначе — `121`. Передайте целое число, чтобы явно задать длину. Автоматически предсказанное количество кадров округляется до каузальной временной сетки VAE, поэтому фактическая длительность квантуется (примерно 0,33 с при 24 кадрах в секунду).

min_seconds (`float`, *optional*, по умолчанию `1.0`) : Нижняя граница для автоматически предсказанной длительности, если `num_frames` не указан и присутствует `duration_head`. Игнорируется, если `num_frames` задан явно.

max_seconds (`float`, *optional*, по умолчанию `20.0`) : Верхняя граница для автоматически предсказанной длительности, если `num_frames` не указан и присутствует `duration_head`. Игнорируется, если `num_frames` задан явно. Должно быть строго больше `min_seconds`.

frame_rate (`float`, *необязательный*, по умолчанию `24.0`) : Количество кадров в секунду (FPS) в сгенерированном видео.

motion_speed (`float`, *optional*, по умолчанию `1.0`) : Скорость движения относительно реального времени. Позиционные эмбеддинги зависят от `frame_rate / motion_speed`, поэтому значения меньше 1 замедляют движение, например, `0.2` для 5-кратного замедления в Slow-Motion-Control LoRA. `frame_rate` остается скоростью воспроизведения: длительность аудио и предсказанное количество кадров определяются именно им.

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

sigmas (`List[float]`, *необязательный*) : Пользовательские сигмы для процесса денуазинга в планировщиках, поддерживающих аргумент `sigmas` в методе `set_timesteps`. Если не задано, будет использоваться поведение по умолчанию при передаче `num_inference_steps`.

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

guidance_scale (`float`, *необязательный*, по умолчанию `4.0`) : Масштаб руководства, определённый в [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` определяется как `w` из уравнения 2 в [Imagen Paper](https://huggingface.co/papers/2205.11487). Масштаб руководства активируется при установке `guidance_scale > 1`. Более высокий масштаб руководства способствует генерации изображений, тесно связанных с текстовым `prompt`, обычно за счёт снижения качества изображения. Используется для модальности видео (для модальности аудио существует отдельное значение `audio_guidance_scale`).

stg_scale (`float`, *optional*, по умолчанию `0.0`) : Масштаб руководства для видео в методе Spatio-Temporal Guidance (STG), предложенном в статье [Spatiotemporal Skip Guidance for Enhanced Video Diffusion Sampling](https://arxiv.org/abs/2411.18664). STG использует оценку, аналогичную CFG, при которой образец смещается от слабого образца, полученного из возмущенной версии модели денойзинга. Включение STG приводит к дополнительному прямому проходу модели денойзинга; значение по умолчанию `0.0` означает, что STG отключен.

modality_scale (`float`, *optional*, по умолчанию `1.0`) : Масштаб руководства для видео в LTX-2.X для изоляции модальности, при котором образец смещается от более слабого образца, сгенерированного моделью денуизинга с отключенным кросс-вниманием между модальностями (аудио-в-видео и видео-в-аудио), с использованием оценки, аналогичной CFG. Включение руководства по модальности приводит к дополнительному прямому проходу модели денуизинга; значение по умолчанию `1.0` означает, что руководство по модальности отключено.

guidance_rescale (`float`, *optional*, defaults to 0.0) : Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` is defined as `φ` in equation 16. of [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Guidance rescale factor should fix overexposure when using zero terminal SNR. Used for the video modality.

audio_guidance_scale (`float`, *optional* по умолчанию `None`) : Масштаб аудио-гидирования для CFG относительно негативного промпта. Правило обновления CFG одинаково для видео и аудио, но для масштаба гидирования могут использоваться разные значения. Авторы LTX-2.X рекомендуют, чтобы `audio_guidance_scale` был выше относительно видео `guidance_scale` (например, для LTX-2.3 они рекомендуют 3.0 для видео и 7.0 для аудио). Если `None`, по умолчанию используется значение видео `guidance_scale`.

audio_stg_scale (`float`, *optional*, по умолчанию `None`) : Масштаб аудио-гидирования для STG. Как и в случае с CFG, правило обновления STG в остальном одинаково для видео и аудио. Для LTX-2.3 рекомендуется значение 1.0 как для видео, так и для аудио. Если `None`, по умолчанию используется значение для видео `stg_scale`.

audio_modality_scale (`float`, *optional*, по умолчанию `None`) : Масштаб аудио-гидинга для изоляции модальности в LTX-2.X. Как и в случае с CFG, правило гидинга модальности в остальном одинаково для видео и аудио. Для LTX-2.3 рекомендуется значение 3.0 как для видео, так и для аудио. Если `None`, по умолчанию используется значение для видео `modality_scale`.

audio_guidance_rescale (`float`, *необязательный*, по умолчанию `None`) : Отдельный коэффициент rescale для модальности аудио. Если `None`, по умолчанию используется значение видео `guidance_rescale`.

spatio_temporal_guidance_blocks (`list[int]`, *необязательный*, по умолчанию `None`) : Индексы блоков трансформера (начиная с нуля), на которых следует применять STG. Обязательный параметр при использовании STG (если `stg_scale` или `audio_stg_scale` больше `0`). Для LTX-2.0 рекомендуется значение `[29]`, а для LTX-2.3 — `[28]`.

noise_scale (`float`, *необязательный*, по умолчанию `0.0`) : Коэффициент интерполяции между случайным шумом и денойзанными латентами на каждом шаге. Применяет шум к `latents` и `audio_latents` перед продолжением денойзинга.

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

generator (`torch.Generator` или `list[torch.Generator]`, *необязательный*) : Один или список [генераторов torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) для обеспечения детерминированности генерации.

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

audio_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`) : Коэффициент интерполяции между случайным шумом и денойзанными латентами на шаге декодирования.

use_cross_timestep (`bool` *optional*, по умолчанию `True`) : Использовать ли сигму кросс-модальности (аудио является кросс-модальностью для видео и наоборот) при вычислении параметров модуляции кросс-внимания. `True` — поведение LTX-2.3/2.5; `False` — устаревшее поведение LTX-2.0.

system_prompt (`str`, *необязательный*, по умолчанию `None`) : Необязательная системная подсказка для улучшения промпта. Системная подсказка будет использоваться улучшителем промпта (модель условной генерации Gemma — выделенный компонент `prompt_enhancer`, если он настроен, в противном случае основной `text_encoder`) для генерации улучшенного промпта из исходного `prompt` для управления генерацией. Если не указано, а выделенный `prompt_enhancer` настроен (LTX-2.5), по умолчанию используется `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` (из `diffusers.pipelines.ltx2.utils`) — см. `enable_prompt_enhancement`.

enable_prompt_enhancement (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли выполнять улучшение промпта. Функция включается явно, в соответствии с эталонными конвейерами Lightricks. Если `True` и `system_prompt` не указан, LTX-2.5 использует `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT`, если настроен специальный `prompt_enhancer`; для LTX-2.0/2.3 требуется явное указание `system_prompt`.

prompt_max_new_tokens (`int`, *необязательный*, по умолчанию `None`) : Максимальное количество новых токенов для генерации при улучшении промпта. Если значение не указано, используется 600 для выделенного Gemma 4 `prompt_enhancer` (LTX-2.5) или 512 для резервного Gemma 3 `text_encoder` (LTX-2.0/2.3).

prompt_enhancement_kwargs (`dict[str, Any]`, *необязательный*, по умолчанию `None`) : Именованные аргументы для вызова `.generate` усилителя промпта. Если не указаны, всегда соответствуют модели, выполняющей усиление: `do_sample=False, no_repeat_ngram_size=5` (жадный поиск) при использовании выделенного `prompt_enhancer` (LTX-2.5) или `do_sample=True, temperature=0.7` для резервного `text_encoder` (LTX-2.0/2.3). Дополнительные сведения см. в https://huggingface.co/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate.

prompt_enhancement_seed (`int`, *необязательный*, по умолчанию `10`) : Случайное зерно для любых операций с использованием случайности при улучшении промпта.

output_type (`str`, *необязательный*, по умолчанию `"pil"`) : Формат вывода для генерируемого изображения. Выберите между [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` или `np.array`.

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

attention_kwargs (`dict`, *необязательный*) : Словарь kwargs, который при указании передается в `AttentionProcessor`, определенный в `self.processor` в [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

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`, *необязательный*, по умолчанию `["latents"]`) : Список тензорных входных данных для функции `callback_on_step_end`. Тензоры, указанные в списке, будут переданы в качестве аргумента `callback_kwargs`. Вы сможете включать только переменные, перечисленные в атрибуте `._callback_tensor_inputs` вашего класса конвейера.

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

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

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

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

Примеры:
```py
>>> import torch
>>> from diffusers import LTX2Pipeline
>>> from diffusers.utils import encode_video

>>> pipe = LTX2Pipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

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

>>> frame_rate = 24.0
>>> video, audio = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=121,
...     frame_rate=frame_rate,
...     num_inference_steps=30,
...     guidance_scale=3.0,
...     output_type="np",
...     return_dict=False,
... )

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,  # should be 24000
...     output_path="video.mp4",
... )
```

#### encode_prompt[[diffusers.LTX2Pipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, scale_factor: int = 8, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2.py#L367)

**Параметры:**

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

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

#### enhance_prompt[[diffusers.LTX2Pipeline.enhance_prompt]]

```python
enhance_prompt(prompt: str, system_prompt: str, max_new_tokens: int | None = None, seed: int = 10, generator: typing.Optional[torch.Generator] = None, generation_kwargs: dict[str, typing.Any] | None = None, device: typing.Union[str, torch.device, NoneType] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2.py#L574)

Улучшает переданный `prompt`, генерируя новый промпт с помощью модуля улучшения промптов (модель условной генерации Gemma) на основе исходного промпта и системного промпта. Если передан `image`, модуль улучшения также использует этот кадр в качестве опорного (улучшение в стиле I2V / ключевых кадров). Использует выделенный компонент `prompt_enhancer`, если он настроен (например, LTX-2.5, текстовый энкодер которого не обучен для улучшения), в противном случае использует основной `text_encoder` (LTX-2.0/2.3, который выполняет роль собственного модуля улучшения).

Шаблоны сообщений, аргументы декодирования, очистка ответа и подготовка длинной стороны изображения соответствуют `ltx-core` / `ltx-pipelines` (`enhance_t2v` / `enhance_i2v` / `generate_enhanced_prompt`).

## LTX2ImageToVideoPipeline[[diffusers.LTX2ImageToVideoPipeline]]

#### diffusers.LTX2ImageToVideoPipeline[[diffusers.LTX2ImageToVideoPipeline]]

```python
diffusers.LTX2ImageToVideoPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, processor: transformers.processing_utils.ProcessorMixin | None = None, prompt_enhancer: transformers.models.gemma4.modeling_gemma4.Gemma4ForConditionalGeneration | None = None, duration_head: diffusers.pipelines.ltx2.duration_head.LTX2DurationHead | None = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_image2video.py#L229)

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

Справочник: https://github.com/Lightricks/LTX-Video

TODO

#### __call__[[diffusers.LTX2ImageToVideoPipeline.__call__]]

```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int | None = None, min_seconds: float = 1.0, max_seconds: float = 20.0, frame_rate: float = 24.0, motion_speed: float = 1.0, num_inference_steps: int = 30, sigmas: list[float] | None = None, timesteps: list[int] | None = None, guidance_scale: float = 3.0, stg_scale: float = 1.0, modality_scale: float = 3.0, guidance_rescale: float = 0.7, audio_guidance_scale: float | None = 7.0, audio_stg_scale: float | None = 1.0, audio_modality_scale: float | None = 3.0, audio_guidance_rescale: float | None = 0.7, spatio_temporal_guidance_blocks: list[int] | None = [28], noise_scale: float = 0.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_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, use_cross_timestep: bool = True, system_prompt: str | None = None, enable_prompt_enhancement: bool = False, prompt_max_new_tokens: int | None = None, prompt_enhancement_kwargs: dict[str, typing.Any] | None = None, prompt_enhancement_seed: int = 10, image_crf: int | None = None, output_type: str = '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 = 1024)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_image2video.py#L983)

**Параметры:**

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

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

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

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

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

num_frames (`int`, *optional*) : Количество кадров видео для генерации. Если значение не указано, по умолчанию используется автоматически предсказанная длительность, если у этого пайплайна есть компонент `duration_head` (чекпоинты LTX-2.5 и новее), иначе — `121`. Передайте целое число, чтобы явно задать длину. Автоматически предсказанное количество кадров округляется до каузальной временной сетки VAE, поэтому фактическая длительность квантуется (примерно 0,33 с при 24 кадрах в секунду).

min_seconds (`float`, *optional*, по умолчанию `1.0`) : Нижняя граница для автоматически предсказанной длительности, если `num_frames` не указан и присутствует `duration_head`. Игнорируется, если `num_frames` задан явно.

max_seconds (`float`, *optional*, по умолчанию `20.0`) : Верхняя граница для автоматически предсказанной длительности, если `num_frames` не указан и присутствует `duration_head`. Игнорируется, если `num_frames` задан явно. Должно быть строго больше `min_seconds`.

frame_rate (`float`, *необязательный*, по умолчанию `24.0`) : Количество кадров в секунду (FPS) в сгенерированном видео.

motion_speed (`float`, *optional*, по умолчанию `1.0`) : Скорость движения относительно реального времени. Позиционные эмбеддинги зависят от `frame_rate / motion_speed`, поэтому значения меньше 1 замедляют движение, например, `0.2` для 5-кратного замедления в Slow-Motion-Control LoRA. `frame_rate` остается скоростью воспроизведения: длительность аудио и предсказанное количество кадров определяются именно им.

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

sigmas (`List[float]`, *необязательный*) : Пользовательские сигмы для процесса денуазинга в планировщиках, поддерживающих аргумент `sigmas` в методе `set_timesteps`. Если не задано, будет использоваться поведение по умолчанию при передаче `num_inference_steps`.

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

guidance_scale (`float`, *необязательный*, по умолчанию `4.0`) : Масштаб руководства, определённый в [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` определяется как `w` из уравнения 2 в [Imagen Paper](https://huggingface.co/papers/2205.11487). Масштаб руководства активируется при установке `guidance_scale > 1`. Более высокий масштаб руководства способствует генерации изображений, тесно связанных с текстовым `prompt`, обычно за счёт снижения качества изображения. Используется для модальности видео (для модальности аудио существует отдельное значение `audio_guidance_scale`).

stg_scale (`float`, *optional*, по умолчанию `0.0`) : Масштаб руководства для видео в методе Spatio-Temporal Guidance (STG), предложенном в статье [Spatiotemporal Skip Guidance for Enhanced Video Diffusion Sampling](https://arxiv.org/abs/2411.18664). STG использует оценку, аналогичную CFG, при которой образец смещается от слабого образца, полученного из возмущенной версии модели денойзинга. Включение STG приводит к дополнительному прямому проходу модели денойзинга; значение по умолчанию `0.0` означает, что STG отключен.

modality_scale (`float`, *optional*, по умолчанию `1.0`) : Масштаб руководства для видео в LTX-2.X для изоляции модальности, при котором образец смещается от более слабого образца, сгенерированного моделью денуизинга с отключенным кросс-вниманием между модальностями (аудио-в-видео и видео-в-аудио), с использованием оценки, аналогичной CFG. Включение руководства по модальности приводит к дополнительному прямому проходу модели денуизинга; значение по умолчанию `1.0` означает, что руководство по модальности отключено.

guidance_rescale (`float`, *optional*, defaults to 0.0) : Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` is defined as `φ` in equation 16. of [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Guidance rescale factor should fix overexposure when using zero terminal SNR. Used for the video modality.

audio_guidance_scale (`float`, *optional* по умолчанию `None`) : Масштаб аудио-гидирования для CFG относительно негативного промпта. Правило обновления CFG одинаково для видео и аудио, но для масштаба гидирования могут использоваться разные значения. Авторы LTX-2.X рекомендуют, чтобы `audio_guidance_scale` был выше относительно видео `guidance_scale` (например, для LTX-2.3 они рекомендуют 3.0 для видео и 7.0 для аудио). Если `None`, по умолчанию используется значение видео `guidance_scale`.

audio_stg_scale (`float`, *optional*, по умолчанию `None`) : Масштаб аудио-гидирования для STG. Как и в случае с CFG, правило обновления STG в остальном одинаково для видео и аудио. Для LTX-2.3 рекомендуется значение 1.0 как для видео, так и для аудио. Если `None`, по умолчанию используется значение для видео `stg_scale`.

audio_modality_scale (`float`, *optional*, по умолчанию `None`) : Масштаб аудио-гидинга для изоляции модальности в LTX-2.X. Как и в случае с CFG, правило гидинга модальности в остальном одинаково для видео и аудио. Для LTX-2.3 рекомендуется значение 3.0 как для видео, так и для аудио. Если `None`, по умолчанию используется значение для видео `modality_scale`.

audio_guidance_rescale (`float`, *необязательный*, по умолчанию `None`) : Отдельный коэффициент rescale для модальности аудио. Если `None`, по умолчанию используется значение видео `guidance_rescale`.

spatio_temporal_guidance_blocks (`list[int]`, *необязательный*, по умолчанию `None`) : Индексы блоков трансформера (начиная с нуля), на которых следует применять STG. Обязательный параметр при использовании STG (если `stg_scale` или `audio_stg_scale` больше `0`). Для LTX-2.0 рекомендуется значение `[29]`, а для LTX-2.3 — `[28]`.

noise_scale (`float`, *необязательный*, по умолчанию `0.0`) : Коэффициент интерполяции между случайным шумом и денойзанными латентами на каждом шаге. Применяет шум к `latents` и `audio_latents` перед продолжением денойзинга.

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

generator (`torch.Generator` или `list[torch.Generator]`, *необязательный*) : Один или список [генераторов torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) для обеспечения детерминированности генерации.

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

audio_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`) : Коэффициент интерполяции между случайным шумом и денойзанными латентами на шаге декодирования.

use_cross_timestep (`bool` *optional*, по умолчанию `True`) : Использовать ли сигму кросс-модальности (аудио является кросс-модальностью для видео и наоборот) при вычислении параметров модуляции кросс-внимания. `True` — поведение LTX-2.3/2.5; `False` — устаревшее поведение LTX-2.0.

system_prompt (`str`, *необязательный*, по умолчанию `None`) : Необязательная системная подсказка для улучшения промпта. Системная подсказка будет использоваться улучшителем промпта (модель условной генерации Gemma — выделенный компонент `prompt_enhancer`, если он настроен, в противном случае основной `text_encoder`) для генерации улучшенного промпта на основе исходного `prompt` и первого `image` для условия генерации. Если значение не указано, а выделенный `prompt_enhancer` настроен (LTX-2.5), по умолчанию используется `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT` (из `diffusers.pipelines.ltx2.utils`) — см. `enable_prompt_enhancement`.

enable_prompt_enhancement (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли выполнять улучшение промпта. Функция включается явно, в соответствии с эталонными конвейерами Lightricks. Если `True` и `system_prompt` не указан, LTX-2.5 использует `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT`, если настроен специальный `prompt_enhancer`; для LTX-2.0/2.3 требуется явное указание `system_prompt`.

prompt_max_new_tokens (`int`, *необязательный*, по умолчанию `None`) : Максимальное количество новых токенов для генерации при улучшении промпта. Если значение не указано, используется 600 для выделенного Gemma 4 `prompt_enhancer` (LTX-2.5) или 512 для резервного Gemma 3 `text_encoder` (LTX-2.0/2.3).

prompt_enhancement_kwargs (`dict[str, Any]`, *необязательный*, по умолчанию `None`) : Именованные аргументы для вызова `.generate` усилителя промпта. Если не указаны, всегда соответствуют модели, выполняющей усиление: `do_sample=False, no_repeat_ngram_size=3` (жадный поиск) при использовании выделенного `prompt_enhancer` (LTX-2.5) или `do_sample=True, temperature=0.7` для резервного `text_encoder` (LTX-2.0/2.3). Подробнее см. https://huggingface.co/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate

prompt_enhancement_seed (`int`, *необязательный*, по умолчанию `10`) : Случайное зерно для любых операций с использованием случайности при улучшении промпта.

image_crf (`int`, *необязательный*, по умолчанию `None`) : CRF H.264, используемый для перекодирования исходного `image` перед кодированием VAE, в соответствии со сжатием, на котором обучалась модель. `None` означает «использовать значение по умолчанию модели» (33 для LTX-2.3, 18 для LTX-2.5). Передайте `0`, чтобы пропустить перекодирование. Для выполнения перекодирования требуется `PIL.Image.Image`.

output_type (`str`, *необязательный*, по умолчанию `"pil"`) : Формат вывода для генерируемого изображения. Выберите между [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` или `np.array`.

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

attention_kwargs (`dict`, *необязательный*) : Словарь kwargs, который при указании передается в `AttentionProcessor`, определенный в `self.processor` в [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

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`, *необязательный*) : Список тензорных входных данных для функции `callback_on_step_end`. Тензоры, указанные в списке, будут переданы в качестве аргумента `callback_kwargs`. Вы сможете включать только переменные, перечисленные в атрибуте `._callback_tensor_inputs` вашего класса конвейера.

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

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

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

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

Примеры:
```py
>>> import torch
>>> from diffusers import LTX2ImageToVideoPipeline
>>> from diffusers.utils import encode_video
>>> from diffusers.utils import load_image

>>> pipe = LTX2ImageToVideoPipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> image = load_image(
...     "https://huggingface.co/datasets/a-r-r-o-w/tiny-meme-dataset-captioned/resolve/main/images/8.png"
... )
>>> prompt = "A young girl stands calmly in the foreground, looking directly at the camera, as a house fire rages in the background."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> frame_rate = 24.0
>>> video, audio = pipe(
...     image=image,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=121,
...     frame_rate=frame_rate,
...     num_inference_steps=30,
...     guidance_scale=3.0,
...     output_type="np",
...     return_dict=False,
... )

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,  # should be 24000
...     output_path="video.mp4",
... )
```

#### encode_prompt[[diffusers.LTX2ImageToVideoPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, scale_factor: int = 8, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_image2video.py#L372)

**Параметры:**

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

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

#### enhance_prompt[[diffusers.LTX2ImageToVideoPipeline.enhance_prompt]]

```python
enhance_prompt(prompt: str, system_prompt: str, max_new_tokens: int | None = None, seed: int = 10, generator: typing.Optional[torch.Generator] = None, generation_kwargs: dict[str, typing.Any] | None = None, device: typing.Union[str, torch.device, NoneType] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_image2video.py#L580)

Улучшает переданный `prompt`, генерируя новый промпт с помощью модуля улучшения промптов (модель условной генерации Gemma) на основе исходного промпта и системного промпта. Если передан `image`, модуль улучшения также использует этот кадр в качестве опорного (улучшение в стиле I2V / ключевых кадров). Использует выделенный компонент `prompt_enhancer`, если он настроен (например, LTX-2.5, текстовый энкодер которого не обучен для улучшения), в противном случае использует основной `text_encoder` (LTX-2.0/2.3, который выполняет роль собственного модуля улучшения).

Шаблоны сообщений, аргументы декодирования, очистка ответа и подготовка длинной стороны изображения соответствуют `ltx-core` / `ltx-pipelines` (`enhance_t2v` / `enhance_i2v` / `generate_enhanced_prompt`).

## LTX2ConditionPipeline[[diffusers.LTX2ConditionPipeline]]

#### diffusers.LTX2ConditionPipeline[[diffusers.LTX2ConditionPipeline]]

```python
diffusers.LTX2ConditionPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, audio_scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | None = None, processor: transformers.processing_utils.ProcessorMixin | None = None, prompt_enhancer: transformers.models.gemma4.modeling_gemma4.Gemma4ForConditionalGeneration | None = None, duration_head: diffusers.pipelines.ltx2.duration_head.LTX2DurationHead | None = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L266)

Pipeline для генерации видео, позволяющий вставлять условия на основе изображений в произвольные части видео.

Справочник: https://github.com/Lightricks/LTX-Video

TODO

#### __call__[[diffusers.LTX2ConditionPipeline.__call__]]

```python
__call__(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int | None = None, min_seconds: float = 1.0, max_seconds: float = 20.0, frame_rate: float = 24.0, motion_speed: float = 1.0, num_inference_steps: int = 30, sigmas: list[float] | None = None, timesteps: list[float] | None = None, guidance_scale: float = 3.0, stg_scale: float = 1.0, modality_scale: float = 3.0, guidance_rescale: float = 0.7, audio_guidance_scale: float | None = 7.0, audio_stg_scale: float | None = 1.0, audio_modality_scale: float | None = 3.0, audio_guidance_rescale: float | None = 0.7, spatio_temporal_guidance_blocks: list[int] | None = [28], noise_scale: float | None = None, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_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, use_cross_timestep: bool = True, system_prompt: str | None = None, enable_prompt_enhancement: bool = False, prompt_max_new_tokens: int | None = None, prompt_enhancement_kwargs: dict[str, typing.Any] | None = None, prompt_enhancement_seed: int = 10, output_type: str = '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 = 1024)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L1348)

**Параметры:**

conditions (`List[LTXVideoCondition], *optional*`) : Список элементов для условного формирования кадров при генерации видео.

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

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

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

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

num_frames (`int`, *optional*) : Количество кадров видео для генерации. Если значение не указано, по умолчанию используется автоматически предсказанная длительность, если у этого пайплайна есть компонент `duration_head` (чекпоинты LTX-2.5 и новее), иначе — `121`. Передайте целое число, чтобы явно задать длину. Автоматически предсказанное количество кадров округляется до каузальной временной сетки VAE, поэтому фактическая длительность квантуется (примерно 0,33 с при 24 кадрах в секунду).

min_seconds (`float`, *optional*, по умолчанию `1.0`) : Нижняя граница для автоматически предсказанной длительности, если `num_frames` не указан и присутствует `duration_head`. Игнорируется, если `num_frames` задан явно.

max_seconds (`float`, *optional*, по умолчанию `20.0`) : Верхняя граница для автоматически предсказанной длительности, если `num_frames` не указан и присутствует `duration_head`. Игнорируется, если `num_frames` задан явно. Должно быть строго больше `min_seconds`.

frame_rate (`float`, *необязательный*, по умолчанию `24.0`) : Количество кадров в секунду (FPS) в сгенерированном видео.

motion_speed (`float`, *optional*, по умолчанию `1.0`) : Скорость движения относительно реального времени. Позиционные эмбеддинги зависят от `frame_rate / motion_speed`, поэтому значения меньше 1 замедляют движение, например, `0.2` для 5-кратного замедления в Slow-Motion-Control LoRA. `frame_rate` остается скоростью воспроизведения: длительность аудио и предсказанное количество кадров определяются именно им.

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

sigmas (`List[float]`, *необязательный*) : Пользовательские сигмы для процесса денуазинга в планировщиках, поддерживающих аргумент `sigmas` в методе `set_timesteps`. Если не задано, будет использоваться поведение по умолчанию при передаче `num_inference_steps`.

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

guidance_scale (`float`, *необязательный*, по умолчанию `4.0`) : Масштаб руководства, определённый в [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` определяется как `w` из уравнения 2 в [Imagen Paper](https://huggingface.co/papers/2205.11487). Масштаб руководства активируется при установке `guidance_scale > 1`. Более высокий масштаб руководства способствует генерации изображений, тесно связанных с текстовым `prompt`, обычно за счёт снижения качества изображения. Используется для модальности видео (для модальности аудио существует отдельное значение `audio_guidance_scale`).

stg_scale (`float`, *optional*, по умолчанию `0.0`) : Масштаб руководства для видео в методе Spatio-Temporal Guidance (STG), предложенном в статье [Spatiotemporal Skip Guidance for Enhanced Video Diffusion Sampling](https://arxiv.org/abs/2411.18664). STG использует оценку, аналогичную CFG, при которой образец смещается от слабого образца, полученного из возмущенной версии модели денойзинга. Включение STG приводит к дополнительному прямому проходу модели денойзинга; значение по умолчанию `0.0` означает, что STG отключен.

modality_scale (`float`, *optional*, по умолчанию `1.0`) : Масштаб руководства для видео в LTX-2.X для изоляции модальности, при котором образец смещается от более слабого образца, сгенерированного моделью денуизинга с отключенным кросс-вниманием между модальностями (аудио-в-видео и видео-в-аудио), с использованием оценки, аналогичной CFG. Включение руководства по модальности приводит к дополнительному прямому проходу модели денуизинга; значение по умолчанию `1.0` означает, что руководство по модальности отключено.

guidance_rescale (`float`, *optional*, defaults to 0.0) : Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` is defined as `φ` in equation 16. of [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Guidance rescale factor should fix overexposure when using zero terminal SNR. Used for the video modality.

audio_guidance_scale (`float`, *optional* по умолчанию `None`) : Масштаб аудио-гидирования для CFG относительно негативного промпта. Правило обновления CFG одинаково для видео и аудио, но для масштаба гидирования могут использоваться разные значения. Авторы LTX-2.X рекомендуют, чтобы `audio_guidance_scale` был выше относительно видео `guidance_scale` (например, для LTX-2.3 они рекомендуют 3.0 для видео и 7.0 для аудио). Если `None`, по умолчанию используется значение видео `guidance_scale`.

audio_stg_scale (`float`, *optional*, по умолчанию `None`) : Масштаб аудио-гидирования для STG. Как и в случае с CFG, правило обновления STG в остальном одинаково для видео и аудио. Для LTX-2.3 рекомендуется значение 1.0 как для видео, так и для аудио. Если `None`, по умолчанию используется значение для видео `stg_scale`.

audio_modality_scale (`float`, *optional*, по умолчанию `None`) : Масштаб аудио-гидинга для изоляции модальности в LTX-2.X. Как и в случае с CFG, правило гидинга модальности в остальном одинаково для видео и аудио. Для LTX-2.3 рекомендуется значение 3.0 как для видео, так и для аудио. Если `None`, по умолчанию используется значение для видео `modality_scale`.

audio_guidance_rescale (`float`, *необязательный*, по умолчанию `None`) : Отдельный коэффициент rescale для модальности аудио. Если `None`, по умолчанию используется значение видео `guidance_rescale`.

spatio_temporal_guidance_blocks (`list[int]`, *необязательный*, по умолчанию `None`) : Индексы блоков трансформера (начиная с нуля), на которых следует применять STG. Обязательный параметр при использовании STG (если `stg_scale` или `audio_stg_scale` больше `0`). Для LTX-2.0 рекомендуется значение `[29]`, а для LTX-2.3 — `[28]`.

noise_scale (`float`, *необязательный*, по умолчанию `None`) : Коэффициент интерполяции между случайным шумом и денойзанными латентами на каждом шаге. Применяет шум к `latents` и `audio_latents` перед продолжением денойзинга. Если не задан, вычисляется из расписания сигм.

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

generator (`torch.Generator` или `List[torch.Generator]`, *необязательный*) : Один или список [генераторов torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) для обеспечения детерминированности генерации.

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

audio_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`) : Коэффициент интерполяции между случайным шумом и денойзанными латентами на шаге декодирования.

use_cross_timestep (`bool` *optional*, по умолчанию `True`) : Использовать ли сигму кросс-модальности (аудио является кросс-модальностью для видео и наоборот) при вычислении параметров модуляции кросс-внимания. `True` — поведение LTX-2.3/2.5; `False` — устаревшее поведение LTX-2.0.

system_prompt (`str`, *необязательный*, по умолчанию `None`) : Необязательная системная подсказка для улучшения промпта. Системная подсказка используется улучшителем промпта (модель условной генерации Gemma — выделенный компонент `prompt_enhancer`, если он настроен, в противном случае основной `text_encoder`) для генерации улучшенного промпта на основе исходного `prompt` (и условного изображения, если оно доступно) для управления генерацией. Если значение не указано, а выделенный `prompt_enhancer` настроен (LTX-2.5), по умолчанию используется `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT`, если доступно условное изображение, в противном случае `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` — см. `enable_prompt_enhancement`.

enable_prompt_enhancement (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли выполнять улучшение промпта. Функция включается явно, в соответствии с эталонными конвейерами Lightricks. Если `True` и `system_prompt` не указан, LTX-2.5 выбирает `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT` / `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT` в зависимости от наличия изображения для условного формирования.

prompt_max_new_tokens (`int`, *необязательный*, по умолчанию `None`) : Максимальное количество новых токенов для генерации при улучшении промпта. Если значение не указано, используется 600 для выделенного Gemma 4 `prompt_enhancer` (LTX-2.5) или 512 для резервного Gemma 3 `text_encoder` (LTX-2.0/2.3).

prompt_enhancement_kwargs (`dict[str, Any]`, *необязательный*, по умолчанию `None`) : Именованные аргументы для вызова `.generate` усилителя промпта. Если не указаны, всегда соответствуют модели, выполняющей усиление: `do_sample=False, no_repeat_ngram_size=5` (жадный поиск) при использовании выделенного `prompt_enhancer` (LTX-2.5) или `do_sample=True, temperature=0.7` для резервного `text_encoder` (LTX-2.0/2.3). Дополнительные сведения см. в https://huggingface.co/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate.

prompt_enhancement_seed (`int`, *необязательный*, по умолчанию `10`) : Случайное зерно для любых операций с использованием случайности при улучшении промпта.

output_type (`str`, *необязательный*, по умолчанию `"pil"`) : Формат вывода для генерируемого изображения. Выберите между [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` или `np.array`.

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

attention_kwargs (`dict`, *необязательный*) : Словарь kwargs, который при указании передается в `AttentionProcessor`, определенный в `self.processor` в [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

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`, *необязательный*) : Список тензорных входных данных для функции `callback_on_step_end`. Тензоры, указанные в списке, будут переданы в качестве аргумента `callback_kwargs`. Вы сможете включать только переменные, перечисленные в атрибуте `._callback_tensor_inputs` вашего класса конвейера.

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

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

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

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

Примеры:
```py
>>> import torch
>>> from diffusers import LTX2ConditionPipeline
>>> from diffusers.utils import encode_video
>>> from diffusers.pipelines.ltx2.pipeline_ltx2_condition import LTX2VideoCondition
>>> from diffusers.utils import load_image

>>> pipe = LTX2ConditionPipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> first_image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_first_frame.png"
... )
>>> last_image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_last_frame.png"
... )
>>> first_cond = LTX2VideoCondition(frames=first_image, index=0, strength=1.0)
>>> last_cond = LTX2VideoCondition(frames=last_image, index=-1, strength=1.0)
>>> conditions = [first_cond, last_cond]
>>> prompt = "CG animation style, a small blue bird takes off from the ground, flapping its wings."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted, static"

>>> frame_rate = 24.0
>>> video = pipe(
...     conditions=conditions,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=121,
...     frame_rate=frame_rate,
...     num_inference_steps=30,
...     guidance_scale=3.0,
...     output_type="np",
...     return_dict=False,
... )
>>> video = (video * 255).round().astype("uint8")
>>> video = torch.from_numpy(video)

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,  # should be 24000
...     output_path="video.mp4",
... )
```

#### apply_first_frame_conditioning[[diffusers.LTX2ConditionPipeline.apply_first_frame_conditioning]]

```python
apply_first_frame_conditioning(latents: Tensor, conditioning_mask: Tensor, condition_latents: list[torch.Tensor], condition_strengths: list[float], condition_indices: list[int], latent_height: int, latent_width: int)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L964)

**Параметры:**

latents (`torch.Tensor`) : Начальные упакованные (патчифицированные) латенты формы [batch_size, patch_seq_len, hidden_dim].

conditioning_mask (`torch.Tensor`) : Начальная упакованная (патчифицированная) маска условий формы [batch_size, patch_seq_len, 1] со значениями в диапазоне [0, 1], где 0 означает, что выход модели денуазинга будет использован полностью, а 1 — что условие будет использовано полностью.

**Возвращает:** `Tuple[torch.Tensor, torch.Tensor, torch.Tensor]`

Возвращает кортеж из трёх тензоров, где:
1. Сжатые латенты видео с применёнными условиями для первого кадра.
2. Маска упакованных условий с применёнными значениями силы для первого кадра.
3. Чистые условные латенты в позициях первого кадра (в остальных местах — нули).

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

Здесь применяются только условия с `latent_idx == 0` (в соответствии с `VideoConditionByLatentIndex` в эталонной реализации). Условия с ненулевыми индексами латентов добавляются как отдельные токены ключевых кадров через `prepare_keyframe_extras` (в соответствии с `VideoConditionByKeyframeIndex`) и пропускаются здесь.

#### encode_prompt[[diffusers.LTX2ConditionPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, scale_factor: int = 8, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L419)

**Параметры:**

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

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

#### enhance_prompt[[diffusers.LTX2ConditionPipeline.enhance_prompt]]

```python
enhance_prompt(prompt: str, system_prompt: str, max_new_tokens: int | None = None, seed: int = 10, generator: typing.Optional[torch.Generator] = None, generation_kwargs: dict[str, typing.Any] | None = None, device: typing.Union[str, torch.device, NoneType] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L627)

Улучшает переданный `prompt`, генерируя новый промпт с помощью модуля улучшения промптов (модель условной генерации Gemma) на основе исходного промпта и системного промпта. Если передан `image`, модуль улучшения также использует этот кадр в качестве опорного (улучшение в стиле I2V / ключевых кадров). Использует выделенный компонент `prompt_enhancer`, если он настроен (например, LTX-2.5, текстовый энкодер которого не обучен для улучшения), в противном случае использует основной `text_encoder` (LTX-2.0/2.3, который выполняет роль собственного модуля улучшения).

Шаблоны сообщений, аргументы декодирования, очистка ответа и подготовка длинной стороны изображения соответствуют `ltx-core` / `ltx-pipelines` (`enhance_t2v` / `enhance_i2v` / `generate_enhanced_prompt`).

#### prepare_latents[[diffusers.LTX2ConditionPipeline.prepare_latents]]

```python
prepare_latents(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, batch_size: int = 1, num_channels_latents: int = 128, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, noise_scale: float = 1.0, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L1071)

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

Условия первого кадра (`latent_idx == 0`) применяются путём перезаписи токенов в позициях первого кадра (семантика `VideoConditionByLatentIndex`). Условия, не относящиеся к первому кадру (`latent_idx > 0`), конкатенируются с основной латентной последовательностью с использованием поэлементного `conditioning_mask = strength` (семантика `VideoConditionByKeyframeIndex`) — далее их по шагам управляют существующая формула временного шага в цикле денойзинга `t * (1 - conditioning_mask)` и постобработка смешивания `denoised * (1 - conditioning_mask) + clean * conditioning_mask`.

Возвращает 4-кортеж:
- `latents`: упакованные зашумлённые латенты (базовые токены + любые токены ключевых кадров, объединённые по размерности последовательности).
- `conditioning_mask`: упакованная маска условий со значениями в диапазоне `[0, 1]` — `1` в позициях первого кадра, `strength` в позициях ключевых кадров, `0` в остальных.
- `clean_latents`: значения чистого условия в позициях с условием (ноль в остальных местах); та же форма, что и у `latents`.
- `keyframe_coords`: `[B, 3, num_keyframe_patches, 2]` координаты позиций, которые добавляются к `video_coords`, или `None`, если нет условий, отличных от первого кадра.

#### preprocess_conditions[[diffusers.LTX2ConditionPipeline.preprocess_conditions]]

```python
preprocess_conditions(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, device: typing.Optional[torch.device] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L846)

**Параметры:**

conditions (`LTX2VideoCondition` или `List[LTX2VideoCondition]`, *optional*, по умолчанию `None`) : Список экземпляров условий изображения/видео.

height (`int`, *необязательный*, по умолчанию `512`) : Требуемая высота в пикселях.

width (`int`, *необязательный*, по умолчанию `768`) : Требуемая ширина в пикселях.

num_frames (`int`, *необязательный*, по умолчанию `121`) : Требуемое количество кадров в генерируемом видео.

device (`torch.device`, *необязательный*, по умолчанию `None`) : Устройство, на котором размещаются тензоры предобработанных изображений/видео.

**Возвращает:** `Tuple[List[torch.Tensor], List[float], List[int], List[int]]`

Возвращает 4-кортеж списков длины `len(conditions)` в следующем виде:
1. Первый список — это список предобработанных тензоров видео с формой [batch_size=1, num_channels, num_frames, height, width].
2. Второй список — это список сил обусловливания.
3. Третий список — это список индексов пространства латентов для каждого условия.
4. Четвёртый список — это список (обрезанных) количеств кадров в пиксельном пространстве для каждого условия. Это необходимо для семантики координат ключевых кадров (ключевые кадры с одним пиксельным кадром имеют ограниченное временное расширение).

Предварительно обрабатывает изображения/видео условий в тензоры torch.

#### trim_conditioning_sequence[[diffusers.LTX2ConditionPipeline.trim_conditioning_sequence]]

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py#L829)

**Параметры:**

start_frame (int) : Номер целевого кадра первого кадра в последовательности.

sequence_num_frames (int) : Количество кадров в последовательности.

target_num_frames (int) : Целевое количество кадров в сгенерированном видео.

**Возвращает:** `int`

обновленная длина последовательности

Обрежьте последовательность условий до допустимого количества кадров.

## LTX2DFRPipeline[[diffusers.LTX2DFRPipeline]]

#### diffusers.LTX2DFRPipeline[[diffusers.LTX2DFRPipeline]]

```python
diffusers.LTX2DFRPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, processor: transformers.processing_utils.ProcessorMixin | None = None, prompt_enhancer: transformers.models.gemma4.modeling_gemma4.Gemma4ForConditionalGeneration | None = None, duration_head: diffusers.pipelines.ltx2.duration_head.LTX2DurationHead | None = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L122)

**Параметры:**

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/ru/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : планировщик, используемый в связке с `transformer` для удаления шума из закодированных латентных представлений видео.

vae ([AutoencoderKLLTX2Video](/docs/diffusers/v0.43.0/ru/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video)) : Модель вариационного автоэнкодера (VAE) для кодирования и декодирования видео в латентные представления и обратно.

audio_vae ([AutoencoderKLLTX2Audio](/docs/diffusers/v0.43.0/ru/api/models/autoencoderkl_audio_ltx_2#diffusers.AutoencoderKLLTX2Audio)) : аудио-VAE для кодирования и декодирования аудиоспектрограмм.

text_encoder (`Gemma3ForConditionalGeneration` или `Gemma4UnifiedForConditionalGeneration`) : модель текстового кодировщика.

tokenizer (`GemmaTokenizer` или `GemmaTokenizerFast`) : Токенизатор для текстового энкодера.

connectors (`LTX2TextConnectors`) : Стек текстовых коннекторов, используемый для адаптации скрытых состояний текстового энкодера для видео- и аудиоветвей.

transformer ([LTX2VideoTransformer3DModel](/docs/diffusers/v0.43.0/ru/api/models/ltx2_video_transformer3d#diffusers.LTX2VideoTransformer3DModel)) : Условная архитектура Transformer для удаления шума из закодированных латентных представлений видео.

vocoder (`LTX2Vocoder` или `LTX2VocoderWithBWE`) : Vocoder для преобразования мел-спектрограмм в аудиосигналы.

processor (`ProcessorMixin`, *необязательный*) : Процессор, используемый для улучшения промптов и шаблонов чата.

prompt_enhancer (`Gemma4ForConditionalGeneration`, *необязательный*) : Специализированная модель для улучшения промптов (LTX-2.5).

duration_head (`LTX2DurationHead`, *необязательный*) : Предсказывает `num_frames` из эмбеддингов промпта, если `num_frames` не передан.

Пайплайн для одного прохода шумоподавления Diffusion Fidelity Rendering (DFR) с LTX-2.5.

Один проход генерирует видео *и* дополнительные слоты для ключевых кадров с одним пикселем, либо повторно выполняет денойзинг переданных латентов, инициализированных из этих слотов. Вызывающая сторона комбинирует этапы: данный пайплайн с половинным разрешением, [LTX2LatentUpsamplePipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2LatentUpsamplePipeline) для пространственного апскейлинга, затем снова данный пайплайн с полным разрешением, используя апскейленные слоты и эталон IC-LoRA, после чего [LTX2DFRTemporalRefinePipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRTemporalRefinePipeline) для каждого раунда временной детализации. См. документацию LTX-2 для рецепта 1080p.

Позиции слотов определяются сегментной сеткой, выровненной по временной границе VAE (`resolve_canvas`). Сетка дополняется до целого числа сегментов; `output_type="latent"` возвращает эту дополненную сетку, чтобы слоты на области дополнения не терялись. Перед декодированием VAE обрежьте сетку с помощью `trim_canvas`.

Требуется трансформер, в конфигурации которого задан `use_keyframes_abs_pos_embedding` (LTX-2.5 и новее), при `generate_slots=True`.

Справочник: https://github.com/Lightricks/LTX-2

#### __call__[[diffusers.LTX2DFRPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 704, width: int = 1216, num_frames: int | None = None, frame_rate: float = 24.0, min_seconds: float = 1.0, max_seconds: float = 20.0, latents: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, keyframes_latents: typing.Optional[torch.Tensor] = None, keyframe_positions: list[int] | None = None, reference_latents: typing.Optional[torch.Tensor] = None, reference_downscale_factor: int = 2, guidance_keyframe_latents: typing.Optional[torch.Tensor] = None, guidance_keyframe_positions: list[int] | None = None, guidance_keyframe_strength: float = 1.0, generate_slots: bool = True, sigmas: list[float] = [1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875], noise_scale: float | None = None, freeze_audio: bool = False, video_tiles: list[diffusers.pipelines.ltx2.dfr_layout.LTX2DFREpilogueTile] | None = None, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, use_cross_timestep: bool = True, system_prompt: str | None = None, enable_prompt_enhancement: bool = False, prompt_max_new_tokens: int | None = None, prompt_enhancement_kwargs: dict[str, typing.Any] | None = None, prompt_enhancement_seed: int = 10, output_type: str = '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 = 1024)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L1522)

**Параметры:**

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

conditions (`LTX2VideoCondition` или `List[LTX2VideoCondition]`, *optional*) : Условия для изображений или видео на уровне кадров. `index` — это *латентный* индекс для `num_frames` данного прохода.

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

width (`int`, *необязательный*, по умолчанию `1216`) : Ширина этого прохода в пикселях.

num_frames (`int`, *optional*) : Количество кадров пикселей для этого прохода, до внутренней отступной области холста. Если не указано, длительность предсказывается из запроса с помощью `duration_head`. Должно удовлетворять условию `(num_frames - 1) % 8 == 0`.

frame_rate (`float`, *необязательный*, по умолчанию `24.0`) : Частота кадров (fps) воспроизведения для этого прохода. Время RoPE округляется до 60, если это значение превышает 30.

min_seconds (`float`, *optional*, по умолчанию `1.0`) : Нижняя граница для автоматически предсказанной длительности, если `num_frames` не указан.

max_seconds (`float`, *optional*, по умолчанию `20.0`) : Верхняя граница для автоматически предсказанной длительности, если `num_frames` не указано.

latents (`torch.Tensor`, *необязательный*) : Исходные латенты видео `(batch_size, channels, frames, height, width)` для повторного удаления шума (этап 2 / эпилог).

audio_latents (`torch.Tensor`, *необязательный*) : Сырые распакованные аудио-латенты `(batch_size, channels, length, mel_bins)`. На этапе 2 по-прежнему выполняется общий аудио-проход; передаваемая волновая форма составленного рецепта соответствует этапу 1, и вызывающая сторона сохраняет её.

keyframes_latents (`torch.Tensor`, *необязательный*) : Исходные значения слотов `(batch_size, channels, num_slots, height, width)`, используются при `generate_slots=True`.

keyframe_positions (`list[int]`, *необязательный*) : Индексы пиксельных кадров сгенерированных слотов. По умолчанию `resolve_canvas(num_frames)`.

reference_latents (`torch.Tensor`, *необязательный*) : Исходное видео-ссылка IC-LoRA (как правило, кадры из этапа 1).

reference_downscale_factor (`int`, *optional*, по умолчанию `2`) : Соотношение между этим проходом и эталонным разрешением, используется для масштабирования координат эталонных токенов.

guidance_keyframe_latents (`torch.Tensor`, *необязательный*) : Сырые закреплённые ключевые кадры направляющих `(batch_size, channels, K, height, width)` — путь эпилога. Не сгенерированные слоты.

guidance_keyframe_positions (`list[int]`, *необязательный*) : Индексы пиксельных кадров для `guidance_keyframe_latents`.

guidance_keyframe_strength (`float`, *необязательный*, по умолчанию `1.0`) : Сила обусловливания для закреплённых ключевых кадров направляющей.

generate_slots (`bool`, *необязательный*, по умолчанию `True`) : Добавляет токены сгенерированных ключевых кадров. Эпилог устанавливает это значение в `False` и вместо этого фиксирует `guidance_keyframe_latents`.

sigmas (`list[float]`, *необязательный*) : Шкала шума для этого прохода, без конечного значения `0.0`.

noise_scale (`float`, *optional*) : Уровень шума, с которого начинаются токены без условий. По умолчанию `sigmas[0]`.

freeze_audio (`bool`, *необязательный*, по умолчанию `False`) : Удерживать аудио на сигме 0 (эпилог / при следовании за замороженной волновой формой первого этапа).

video_tiles (`list[LTX2DFREpilogueTile]`, *optional*) : Эпилог-тайлинг из `epilogue_tiles()`, благодаря чему разрешение, слишком большое для одного прохода, всё равно может обрабатываться по одному холсту: на каждом шаге трансформатор запускается один раз на тайл, а предсказания смешиваются. Разрешается в план токенов относительно собственных координат RoPE данного прохода, поэтому передаётся именно раскладка, а не план — координаты существуют только после выполнения [prepare_latents()](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipeline.prepare_latents).

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

generator (`torch.Generator` или `list[torch.Generator]`, *необязательно*) : Генератор(ы) случайных чисел для воспроизводимости.

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

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

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

decode_noise_scale (`float`, по умолчанию `None`) : Масштаб шума при декодировании.

use_cross_timestep (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли кросс-модальное сигма для модуляции кросс-внимания. `True` для LTX-2.3+.

system_prompt (`str`, *необязательный*) : Необязательная системная подсказка для улучшения промпта. См. `enable_prompt_enhancement`.

enable_prompt_enhancement (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли выполнять улучшение промпта.

prompt_max_new_tokens (`int`, *необязательный*) : Максимальное количество новых токенов для генерации при выполнении улучшения промпта.

prompt_enhancement_kwargs (`dict[str, Any]`, *необязательный*) : Аргументы с ключами для вызова `.generate` усилителя промпта.

prompt_enhancement_seed (`int`, *необязательный*, по умолчанию `10`) : Случайное зерно для любых операций с использованием случайности при улучшении промпта.

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

return_dict (`bool`, *необязательный*, по умолчанию `True`) : Определяет, возвращать ли [LTX2DFRPipelineOutput](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) или обычный кортеж `(frames, audio, keyframes, keyframe_positions)`.

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

callback_on_step_end (`Callable`, *необязательный*) : функция, вызываемая в конце каждого шага денойзинга.

callback_on_step_end_tensor_inputs (`List`, *необязательный*, по умолчанию `["latents"]`) : тензорные входные данные для функции обратного вызова.

max_sequence_length (`int`, *необязательный*, по умолчанию `1024`) : Максимальная длина последовательности для текстового промпта.

**Возвращает:** [LTX2DFRPipelineOutput](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) или `tuple`

Если `return_dict` равно `True`, возвращается [LTX2DFRPipelineOutput](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput), иначе возвращается `tuple` вида `(video, audio, keyframes, keyframe_positions)`.

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

Один проход шумоподавления при размере `height` × `width`. Собирайте этапы в вызывающем коде: этот пайплайн в половинном разрешении, пространственное увеличение, снова этот пайплайн с `latents` / `keyframes_latents` / `reference_latents`, затем [LTX2DFRTemporalRefinePipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRTemporalRefinePipeline) для каждого временного раунда.

Примеры:
```py
>>> import torch
>>> from diffusers import LTX2DFRPipeline
>>> from diffusers.utils import encode_video

>>> pipe = LTX2DFRPipeline.from_pretrained("Lightricks/LTX-2.5-Diffusers", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> frame_rate = 24.0
>>> video, audio, _, _ = pipe(
...     prompt="A tabby cat stretching in a sunlit window, dust motes drifting in the light",
...     height=704,
...     width=1216,
...     num_frames=121,
...     frame_rate=frame_rate,
...     output_type="np",
...     return_dict=False,
... )

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,
...     output_path="dfr_output.mp4",
... )
```

#### denoise[[diffusers.LTX2DFRPipeline.denoise]]

```python
denoise(latents: Tensor, conditioning_mask: Tensor, clean_latents: Tensor, video_coords: Tensor, keyframes_mask: Tensor, prompt_embeds: Tensor, audio_prompt_embeds: Tensor, prompt_attention_mask: Tensor, sigmas: list[float], frame_rate: float, audio_latents: Tensor, freeze_audio: bool = False, video_tile_plan: list | None = None, generator: typing.Optional[torch.Generator] = None, use_cross_timestep: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, progress_bar = None, step_offset: int = 0, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] | None = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L1225)

**Параметры:**

sigmas (`list[float]`) : Расписание шума для этого прохода, без конечного значения `0.0`.

freeze_audio (`bool`, *необязательный*, по умолчанию `False`) : Держать `audio_latents` чистыми (timestep/sigma 0, без шага Euler для аудио), при этом продолжая выполнять cross-attention от аудио к видео. Игнорируется, если `audio_latents` равно `None`.

video_tile_plan (`list`, *optional*) : План токенов для каждой плитки из `video_tile_plan`[`~diffusers.pipelines.ltx2.dfr_layout.video_tile_plan`]. Если указан, на каждом шаге трансформатор выполняется один раз для каждой плитки, а предсказания смешиваются, поэтому сэмплер по-прежнему делает шаг по одному полному холсту, и плитки согласуются в зонах перекрытия на каждом шаге.

generator (`torch.Generator`, *optional*) : Передаётся в `LTXEulerAncestralRFScheduler.step()`. Временные тайлы передают сид для каждого тайла, чтобы выборки предков не использовали общий поток и не затрагивали состояние, которое читает начальное шумовое воздействие следующего тайла. Дистиллированный Эйлер не читает этот параметр.

step_offset (`int`) : Индекс первого шага данного прохода в общем расписании конвейера, используется для `callback_on_step_end` и общей строки прогресса.

Выполните один проход шумоподавления DFR по `sigmas` и верните `(latents, audio_latents)`, оба по-прежнему упакованные.

Дистиллированный расписание используется без classifier-free guidance, поэтому на каждом шаге выполняется один вызов трансформера. Каждый проход запускает оба потока, поскольку видеоветви требуется кросс-модальное внимание даже там, где создаваемый ею звук отбрасывается. `freeze_audio=True` удерживает аудиопоток на сигме 0 (без шага Эйлера), чтобы видео всё ещё могло обращаться к нему через кросс-внимание — временные refine-плитки и эпилог используют это, чтобы следовать речи первого этапа, не перепрогоняя денойзинг для каждой плитки с новым реализацией звука.

После смешивания условия x0 скорость равна `(latents - denoised) / sigma`, поэтому шаг RF `x0 = x - σ v` восстанавливает смешанный `denoised`. Этапы 1 / 2 / эпилог используют [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/ru/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) и выполняют этот шаг Эйлера без изменений. Temporal refine подменяет его на `LTXEulerAncestralRFScheduler` (`eta=0.5`); этот шаг добавляет шум каждому токену, поэтому смешивание условия применяется повторно, иначе якоря шва со strength 0.95 деградируют.

#### encode_conditions[[diffusers.LTX2DFRPipeline.encode_conditions]]

```python
encode_conditions(conditions: list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None, height: int, width: int, num_frames: int, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, generator: typing.Optional[torch.Generator] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L1189)

Предобработка и кодирование условий кадров с помощью VAE, позиционированных по пиксельным кадрам.

Возвращает `(pixel_frame_index, latent, strength, num_pixel_frames)` для каждого условия, готовое для `condition_latents` в [prepare_latents()](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipeline.prepare_latents). Кодирование отделено от размещения, поскольку раунды временного уточнения масштабируют позицию условия на `2 ** round` и пересчитывают её для каждой плитки, и при этом не следует повторно кодировать один и тот же статичный кадр для каждой плитки.

Возвращаемый индекс относится к собственной пиксельной сетке `num_frames`; перенос его на уточненный холст — задача вызывающего кода.

#### encode_prompt[[diffusers.LTX2DFRPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L529)

**Параметры:**

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

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

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

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

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

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

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

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

#### enhance_prompt[[diffusers.LTX2DFRPipeline.enhance_prompt]]

```python
enhance_prompt(prompt: str, system_prompt: str, max_new_tokens: int | None = None, seed: int = 10, generator: typing.Optional[torch.Generator] = None, generation_kwargs: dict[str, typing.Any] | None = None, device: typing.Union[str, torch.device, NoneType] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L389)

Улучшает переданный `prompt`, генерируя новый промпт с помощью модуля улучшения промптов (модель условной генерации Gemma) на основе исходного промпта и системного промпта. Если передан `image`, модуль улучшения также использует этот кадр в качестве опорного (улучшение в стиле I2V / ключевых кадров). Использует выделенный компонент `prompt_enhancer`, если он настроен (например, LTX-2.5, текстовый энкодер которого не обучен для улучшения), в противном случае использует основной `text_encoder` (LTX-2.0/2.3, который выполняет роль собственного модуля улучшения).

Шаблоны сообщений, аргументы декодирования, очистка ответа и подготовка длинной стороны изображения соответствуют `ltx-core` / `ltx-pipelines` (`enhance_t2v` / `enhance_i2v` / `generate_enhanced_prompt`).

#### prepare_latents[[diffusers.LTX2DFRPipeline.prepare_latents]]

```python
prepare_latents(conditions: list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, condition_latents: list[tuple[int, torch.Tensor, float, int]] | None = None, keyframe_latents: list[tuple[int, torch.Tensor, float]] | None = None, slot_frame_indices: list[int] | None = None, slot_initial_latents: typing.Optional[torch.Tensor] = None, reference_latents: typing.Optional[torch.Tensor] = None, reference_downscale_factor: int = 1, batch_size: int = 1, num_channels_latents: int = 128, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, noise_scale: float = 1.0, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None, latents_normalized: bool = True)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L886)

**Параметры:**

conditions (`list[LTX2VideoCondition]`, *необязательный*) : Изображения/видео-условия на уровне кадров, позиционируемые по индексу латента.

condition_latents (`list[tuple[int, torch.Tensor, float, int]]`, *необязательный*) : Уже закодированная замена для `conditions` в виде `(pixel_frame_index, latent, strength, num_pixel_frames)`. Используется индекс пикселя, а не латента, потому что раунд временного уточнения масштабирует позицию условия на `2 ** round`, и результат, как правило, не попадает на границу латента — только добавленный токен ключевого кадра может находиться там, и он размещается по пикселю. `pixel_frame_index == 0` по-прежнему означает «заменить первый кадр».

keyframe_latents (`list[tuple[int, torch.Tensor, float]]`, *необязательный*) : Уже закодированное руководство по ключевым кадрам в виде `(pixel_frame_index, latent, strength)`, где `latent` имеет форму `(batch_size, num_channels_latents, 1, latent_height, latent_width)`. Используется временными раундами уточнения для фиксации ключевых кадров шва, переданных из предыдущего раунда.

slot_frame_indices (`list[int]`, *необязательный*) : Позиции пиксельных кадров для сгенерированных ключевых кадров.

slot_initial_latents (`torch.Tensor`, *необязательный*) : `(batch_size, num_channels_latents, len(slot_frame_indices), latent_height, latent_width)` содержимое, записанное в слот-токены до добавления шума.

reference_latents (`torch.Tensor`, *необязательный*) : `(batch_size, num_channels_latents, F, H, W)` Ссылочный латентный вектор IC-LoRA.

reference_downscale_factor (`int`, по умолчанию `1`) : Соотношение между целевым и эталонным разрешением.

latents (`torch.Tensor`, *необязательный*) : `(batch_size, num_channels_latents, F, H, W)` начальное содержимое для базовых токенов. Публичные латенты пайплайна являются сырыми (денормализованными); на этой границе передавайте `latents_normalized=False`. Циклы по тайлам, которые уже находятся в пространстве нормализации VAE, оставляют значение по умолчанию.

latents_normalized (`bool`, по умолчанию `True`) : Указывает, являются ли `latents`, `slot_initial_latents`, `reference_latents` и `keyframe_latents` уже нормализованными VAE. Внутренние циклы по тайлам передают `True`; каждый вызов `__call__` пайплайна передаёт `False`.

noise_scale (`float`, по умолчанию `1.0`) : Уровень шума, с которым инициализируются токены без условий, то есть первое сигма расписания.

**Возвращает:** `tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, slice | None]`

`(latents, conditioning_mask, clean_latents, video_coords, keyframes_mask, slot_token_slice)`. `slot_token_slice` индексирует токены слотов сгенерированных ключевых кадров в упакованной последовательности, либо `None`, если слоты не запрашивались.

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

Упакованная последовательность размещается в формате `[base | keyframes | slots | reference]`:

- Базовые токены покрывают целевую латентную сетку, инициализируясь из `latents`, если они предоставлены.
- Условия кадров с `index == 0` задают чистую цель на позициях первого кадра; те, у которых `index > 0`, и все элементы `keyframe_latents` добавляются как дополнительные токены ключевых кадров с маской условного сигнала для каждого токена, равной их силе.
- `slot_frame_indices` добавляет по одному набору токенов ключевых кадров, *сгенерированных* для одного латентного кадра, на каждую позицию, с маской условного контекста `0` (полностью денойзится) и временным диапазоном RoPE, равным ровно одному пиксельному кадру. Это слоты ключевых кадров, которые обеспечивают DFR дополнительные кадры; `slot_initial_latents` задаёт их начальное содержимое.
- `reference_latents` добавляет латентное представление полурезолюции первого этапа в качестве полностью чистого эталона IC-LoRA, при этом пространственные координаты масштабируются коэффициентом `reference_downscale_factor`, чтобы соответствовать целевому пространству координат.

Токены добавляемого условия несут своё содержимое в `clean_latents` и нулевой плейсхолдер в `latents`, тогда как слоты ключевых кадров несут своё зерно в `latents` и нули в `clean_latents` -- возвращаемые `latents` представляют собой зашумлённую смесь обоих (см. шаг добавления шума в конце этого метода).

#### preprocess_conditions[[diffusers.LTX2DFRPipeline.preprocess_conditions]]

```python
preprocess_conditions(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, device: typing.Optional[torch.device] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L707)

**Параметры:**

conditions (`LTX2VideoCondition` или `List[LTX2VideoCondition]`, *optional*, по умолчанию `None`) : Список экземпляров условий изображения/видео.

height (`int`, *необязательный*, по умолчанию `512`) : Требуемая высота в пикселях.

width (`int`, *необязательный*, по умолчанию `768`) : Требуемая ширина в пикселях.

num_frames (`int`, *необязательный*, по умолчанию `121`) : Требуемое количество кадров в генерируемом видео.

device (`torch.device`, *необязательный*, по умолчанию `None`) : Устройство, на котором размещаются тензоры предобработанных изображений/видео.

**Возвращает:** `Tuple[List[torch.Tensor], List[float], List[int], List[int]]`

Возвращает 4-кортеж списков длины `len(conditions)` в следующем виде:
1. Первый список — это список предобработанных тензоров видео с формой [batch_size=1, num_channels, num_frames, height, width].
2. Второй список — это список сил обусловливания.
3. Третий список — это список индексов пространства латентов для каждого условия.
4. Четвёртый список — это список (обрезанных) количеств кадров в пиксельном пространстве для каждого условия. Это необходимо для семантики координат ключевых кадров (ключевые кадры с одним пиксельным кадром имеют ограниченное временное расширение).

Предварительно обрабатывает изображения/видео условий в тензоры torch.

#### rebuild_epilogue_keyframes[[diffusers.LTX2DFRPipeline.rebuild_epilogue_keyframes]]

```python
rebuild_epilogue_keyframes(keyframe_latents: Tensor, decode_timestep: float, decode_noise_scale: float, seed: int, device: device, dtype: dtype)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L1454)

**Параметры:**

keyframe_latents (`torch.Tensor`) : Сырые `(batch_size, C, K, H, W)` ключевые кадры, как их вернул предыдущий проход.

seed (`int`) : Базовый seed; плоскость `i` декодируется под `seed + 4000 + i`, поэтому пиксели плоскости не зависят от того, сколько плоскостей было декодировано до неё.

**Возвращает:** `torch.Tensor`

Сырые латенты `(batch_size, C, K, 2H, 2W)`, готовые к передаче обратно в качестве `guidance_keyframe_latents`.

Перекодировать ключевые кадры с переносом с удвоенным разрешением через RGB.

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

Каждая плоскость декодируется как отдельный однокадровый клип. VAE является каузальным, поэтому при стековом декодировании соседние плоскости «проникали» бы друг в друга — это независимые статичные кадры, а не последовательность.

#### trim_conditioning_sequence[[diffusers.LTX2DFRPipeline.trim_conditioning_sequence]]

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr.py#L689)

**Параметры:**

start_frame (int) : Номер целевого кадра первого кадра в последовательности.

sequence_num_frames (int) : Количество кадров в последовательности.

target_num_frames (int) : Целевое количество кадров в сгенерированном видео.

**Возвращает:** `int`

обновленная длина последовательности

Обрежьте последовательность условий до допустимого количества кадров.

## LTX2DFRTemporalRefinePipeline[[diffusers.LTX2DFRTemporalRefinePipeline]]

#### diffusers.LTX2DFRTemporalRefinePipeline[[diffusers.LTX2DFRTemporalRefinePipeline]]

```python
diffusers.LTX2DFRTemporalRefinePipeline(scheduler: LTXEulerAncestralRFScheduler, vae: AutoencoderKLLTX2Video, audio_vae: AutoencoderKLLTX2Audio, text_encoder: transformers.models.gemma3.modeling_gemma3.Gemma3ForConditionalGeneration | transformers.models.gemma4_unified.modeling_gemma4_unified.Gemma4UnifiedForConditionalGeneration, tokenizer: GemmaTokenizer, connectors: LTX2TextConnectors, transformer: LTX2VideoTransformer3DModel, vocoder: diffusers.pipelines.ltx2.vocoder.LTX2Vocoder | diffusers.pipelines.ltx2.vocoder.LTX2VocoderWithBWE, temporal_latent_upsampler: LTX2LatentUpsamplerModel)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L151)

**Параметры:**

scheduler (`LTXEulerAncestralRFScheduler`) : планировщик Ancestral Euler в параметризации rectified-flow. Создайте с `eta=0.5`, чтобы соответствовать временному рецепту DFR.

vae ([AutoencoderKLLTX2Video](/docs/diffusers/v0.43.0/ru/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video)) : Модель вариационного автоэнкодера (VAE) для кодирования и декодирования видео в латентные представления и обратно.

audio_vae ([AutoencoderKLLTX2Audio](/docs/diffusers/v0.43.0/ru/api/models/autoencoderkl_audio_ltx_2#diffusers.AutoencoderKLLTX2Audio)) : аудио-VAE для кодирования и декодирования аудиоспектрограмм.

text_encoder (`Gemma3ForConditionalGeneration` или `Gemma4UnifiedForConditionalGeneration`) : модель текстового кодировщика.

tokenizer (`GemmaTokenizer` или `GemmaTokenizerFast`) : Токенизатор для текстового энкодера.

connectors (`LTX2TextConnectors`) : Стек текстовых коннекторов, используемый для адаптации скрытых состояний текстового энкодера для видео- и аудиоветвей.

transformer ([LTX2VideoTransformer3DModel](/docs/diffusers/v0.43.0/ru/api/models/ltx2_video_transformer3d#diffusers.LTX2VideoTransformer3DModel)) : Условная архитектура Transformer для удаления шума из закодированных латентных представлений видео.

vocoder (`LTX2Vocoder` или `LTX2VocoderWithBWE`) : Vocoder для преобразования мел-спектрограмм в аудиосигналы.

temporal_latent_upsampler (`LTX2LatentUpsamplerModel`) : временной латентный апсемплер x2, применяемый в начале раунда.

Один раунд уточнения временного DFR: интерполяция холста x2 во времени, тайлинг на швах ключевых кадров, денойзинг каждого тайла с использованием предкового шума, склейка путём отбрасывания вступительной части более позднего тайла и объединение пакета ключевых кадров переноса.

Планировщик — `LTXEulerAncestralRFScheduler` (по умолчанию `eta=0.5`). Этапы 1 / 2 / пространственный эпилог остаются на [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/ru/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) через [LTX2DFRPipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipeline). Вызывайте этот пайплайн один раз за раунд; вызывающая сторона выполняет цикл для 2x / 4x.

Входящие `latents` / `keyframes_latents` / `audio_latents` являются сырыми (ненормализованными), что соответствует [LTX2Pipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2Pipeline). `keyframe_positions` должны быть позициями, возвращёнными на предыдущем проходе — их невозможно повторно вывести из исходного `num_frames` после выполнения раунда.

#### __call__[[diffusers.LTX2DFRTemporalRefinePipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, latents: Tensor = None, keyframes_latents: Tensor = None, keyframe_positions: list[int] = None, audio_latents: Tensor = None, conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 704, width: int = 1216, num_frames: int = 121, frame_rate: float = 24.0, source_seconds: float | None = None, condition_num_frames: int | None = None, round_index: int = 1, sigmas: list[float] = [0.975, 0.909375, 0.725, 0.421875], noise_scale: float | None = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, use_cross_timestep: bool = True, output_type: str = '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 = 1024)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L1349)

**Параметры:**

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

latents (`torch.Tensor`) : Сырые видео-латенты холста **input**, `(batch_size, channels, frames, height, width)`.

keyframes_latents (`torch.Tensor`) : Сырые ключевые кадры `(batch_size, channels, K, height, width)` из предыдущего прохода.

keyframe_positions (`list[int]`) : Индексы пиксельных кадров `keyframes_latents` на **входном** холсте.

audio_latents (`torch.Tensor`) : Замороженный аудио-поток первой стадии, распакованный и денормализованный. Каждой плитке передается срез, покрывающий ее окно воспроизведения; возвращаемый аудио-поток представляет собой эту форму волны, а не повторную денормализацию для каждой плитки.

conditions (`LTX2VideoCondition` или `List[LTX2VideoCondition]`, *optional*) : Условия на уровне кадров, индексируемые по `condition_num_frames` (исходный запрос). На каждом раунде пиксельная позиция условия масштабируется на `2 ** round_index`.

height (`int`, *необязательный*, по умолчанию `704`) : Высота в пикселях для этого прохода (такая же, как у входящего видео).

width (`int`, *необязательный*, по умолчанию `1216`) : Ширина в пикселях для этого прохода.

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

frame_rate (`float`, *необязательный*, по умолчанию `24.0`) : Частота кадров (fps) **входного** видео. Округление удваивает её.

source_seconds (`float`, *optional*) : Длительность замороженного аудио первого этапа. По умолчанию равно `num_frames / frame_rate`, что верно для первого раунда; в последующих раундах необходимо передавать исходную длительность первого этапа, чтобы плитки не смещались.

condition_num_frames (`int`, *optional*) : исходное значение `num_frames`, использованное для кодирования `conditions`. По умолчанию равно `num_frames`. После дополнения нулями или предыдущего раунда передавайте исходный запрос, чтобы `index=-1` не указывал на хвост дополненных данных.

round_index (`int`, *optional*, по умолчанию `1`) : номер раунда, начиная с 1. Плитки формируют исходный шум как `seed + 1000 * round_index + tile`, а условия масштабируются множителем `2 ** round_index`.

sigmas (`list[float]`, *необязательный*) : Упрощённое расписание для тайлов текущего раунда, без конечного `0.0`.

noise_scale (`float`, *optional*) : Уровень шума, с которого начинаются токены без условий. По умолчанию `sigmas[0]`.

generator (`torch.Generator` или `list[torch.Generator]`, *необязательный*) : Генератор(ы) случайных чисел для воспроизводимости. Выборки предков используют отдельный посев для каждой плитки, производный от `initial_seed()` этого генератора.

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

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

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

decode_noise_scale (`float`, по умолчанию `None`) : Масштаб шума при декодировании.

use_cross_timestep (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли кросс-модальное сигма для модуляции кросс-внимания. `True` для LTX-2.3+.

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

return_dict (`bool`, *необязательный*, по умолчанию `True`) : Определяет, возвращать ли [LTX2DFRPipelineOutput](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) или обычный кортеж `(frames, audio, keyframes, keyframe_positions)`.

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

callback_on_step_end (`Callable`, *необязательный*) : функция, вызываемая в конце каждого шага денойзинга для каждой плитки.

callback_on_step_end_tensor_inputs (`List`, *необязательный*, по умолчанию `["latents"]`) : тензорные входные данные для функции обратного вызова.

max_sequence_length (`int`, *необязательный*, по умолчанию `1024`) : Максимальная длина последовательности для текстового промпта.

**Возвращает:** [LTX2DFRPipelineOutput](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput) или `tuple`

Если `return_dict` равно `True`, возвращается [LTX2DFRPipelineOutput](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipelineOutput), иначе возвращается `tuple` вида `(video, audio, keyframes, keyframe_positions)`.

Выполнить один раунд временной детализации.

Примеры:
```py
>>> import torch
>>> from diffusers import LTX2DFRPipeline, LTX2DFRTemporalRefinePipeline, LTXEulerAncestralRFScheduler
>>> from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel

>>> pipe = LTX2DFRPipeline.from_pretrained("Lightricks/LTX-2.5-Diffusers", torch_dtype=torch.bfloat16)
>>> temporal_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
...     "path/to/converted/temporal_latent_upsampler", torch_dtype=torch.bfloat16
... )
>>> temporal_pipe = LTX2DFRTemporalRefinePipeline(
...     scheduler=LTXEulerAncestralRFScheduler(eta=0.5),
...     vae=pipe.vae,
...     audio_vae=pipe.audio_vae,
...     text_encoder=pipe.text_encoder,
...     tokenizer=pipe.tokenizer,
...     connectors=pipe.connectors,
...     transformer=pipe.transformer,
...     vocoder=pipe.vocoder,
...     temporal_latent_upsampler=temporal_upsampler,
... )
>>> # `out` is a prior DFR pass at the same spatial size, `return_dict=True`.
>>> out = temporal_pipe(
...     latents=out.frames,
...     keyframes_latents=out.keyframes,
...     keyframe_positions=out.keyframe_positions,
...     audio_latents=out.audio,
...     prompt="A tabby cat stretching in a sunlit window",
...     height=1088,
...     width=1920,
...     num_frames=121,
...     output_type="latent",
... )
```

#### denoise[[diffusers.LTX2DFRTemporalRefinePipeline.denoise]]

```python
denoise(latents: Tensor, conditioning_mask: Tensor, clean_latents: Tensor, video_coords: Tensor, keyframes_mask: Tensor, prompt_embeds: Tensor, audio_prompt_embeds: Tensor, prompt_attention_mask: Tensor, sigmas: list[float], frame_rate: float, audio_latents: Tensor, freeze_audio: bool = False, video_tile_plan: list | None = None, generator: typing.Optional[torch.Generator] = None, use_cross_timestep: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, progress_bar = None, step_offset: int = 0, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] | None = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L1138)

**Параметры:**

sigmas (`list[float]`) : Расписание шума для этого прохода, без конечного значения `0.0`.

freeze_audio (`bool`, *необязательный*, по умолчанию `False`) : Держать `audio_latents` чистыми (timestep/sigma 0, без шага Euler для аудио), при этом продолжая выполнять cross-attention от аудио к видео. Игнорируется, если `audio_latents` равно `None`.

video_tile_plan (`list`, *optional*) : План токенов для каждой плитки из `video_tile_plan`[`~diffusers.pipelines.ltx2.dfr_layout.video_tile_plan`]. Если указан, на каждом шаге трансформатор выполняется один раз для каждой плитки, а предсказания смешиваются, поэтому сэмплер по-прежнему делает шаг по одному полному холсту, и плитки согласуются в зонах перекрытия на каждом шаге.

generator (`torch.Generator`, *optional*) : Передаётся в `LTXEulerAncestralRFScheduler.step()`. Временные тайлы передают сид для каждого тайла, чтобы выборки предков не использовали общий поток и не затрагивали состояние, которое читает начальное шумовое воздействие следующего тайла. Дистиллированный Эйлер не читает этот параметр.

step_offset (`int`) : Индекс первого шага данного прохода в общем расписании конвейера, используется для `callback_on_step_end` и общей строки прогресса.

Выполните один проход шумоподавления DFR по `sigmas` и верните `(latents, audio_latents)`, оба по-прежнему упакованные.

Дистиллированный расписание используется без classifier-free guidance, поэтому на каждом шаге выполняется один вызов трансформера. Каждый проход запускает оба потока, поскольку видеоветви требуется кросс-модальное внимание даже там, где создаваемый ею звук отбрасывается. `freeze_audio=True` удерживает аудиопоток на сигме 0 (без шага Эйлера), чтобы видео всё ещё могло обращаться к нему через кросс-внимание — временные refine-плитки и эпилог используют это, чтобы следовать речи первого этапа, не перепрогоняя денойзинг для каждой плитки с новым реализацией звука.

После смешивания условия x0 скорость равна `(latents - denoised) / sigma`, поэтому шаг RF `x0 = x - σ v` восстанавливает смешанный `denoised`. Этапы 1 / 2 / эпилог используют [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/ru/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) и выполняют этот шаг Эйлера без изменений. Temporal refine подменяет его на `LTXEulerAncestralRFScheduler` (`eta=0.5`); этот шаг добавляет шум каждому токену, поэтому смешивание условия применяется повторно, иначе якоря шва со strength 0.95 деградируют.

#### encode_conditions[[diffusers.LTX2DFRTemporalRefinePipeline.encode_conditions]]

```python
encode_conditions(conditions: list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None, height: int, width: int, num_frames: int, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, generator: typing.Optional[torch.Generator] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L1101)

Предобработка и кодирование условий кадров с помощью VAE, позиционированных по пиксельным кадрам.

Возвращает `(pixel_frame_index, latent, strength, num_pixel_frames)` для каждого условия, готовое для `condition_latents` в [prepare_latents()](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2DFRPipeline.prepare_latents). Кодирование отделено от размещения, поскольку раунды временного уточнения масштабируют позицию условия на `2 ** round` и пересчитывают её для каждой плитки, и при этом не следует повторно кодировать один и тот же статичный кадр для каждой плитки.

Возвращаемый индекс относится к собственной пиксельной сетке `num_frames`; перенос его на уточненный холст — задача вызывающего кода.

#### encode_prompt[[diffusers.LTX2DFRTemporalRefinePipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L470)

**Параметры:**

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

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

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

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

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

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

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

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

#### prepare_latents[[diffusers.LTX2DFRTemporalRefinePipeline.prepare_latents]]

```python
prepare_latents(conditions: list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, condition_latents: list[tuple[int, torch.Tensor, float, int]] | None = None, keyframe_latents: list[tuple[int, torch.Tensor, float]] | None = None, slot_frame_indices: list[int] | None = None, slot_initial_latents: typing.Optional[torch.Tensor] = None, reference_latents: typing.Optional[torch.Tensor] = None, reference_downscale_factor: int = 1, batch_size: int = 1, num_channels_latents: int = 128, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, noise_scale: float = 1.0, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None, latents_normalized: bool = True)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L828)

**Параметры:**

conditions (`list[LTX2VideoCondition]`, *необязательный*) : Изображения/видео-условия на уровне кадров, позиционируемые по индексу латента.

condition_latents (`list[tuple[int, torch.Tensor, float, int]]`, *необязательный*) : Уже закодированная замена для `conditions` в виде `(pixel_frame_index, latent, strength, num_pixel_frames)`. Используется индекс пикселя, а не латента, потому что раунд временного уточнения масштабирует позицию условия на `2 ** round`, и результат, как правило, не попадает на границу латента — только добавленный токен ключевого кадра может находиться там, и он размещается по пикселю. `pixel_frame_index == 0` по-прежнему означает «заменить первый кадр».

keyframe_latents (`list[tuple[int, torch.Tensor, float]]`, *необязательный*) : Уже закодированное руководство по ключевым кадрам в виде `(pixel_frame_index, latent, strength)`, где `latent` имеет форму `(batch_size, num_channels_latents, 1, latent_height, latent_width)`. Используется временными раундами уточнения для фиксации ключевых кадров шва, переданных из предыдущего раунда.

slot_frame_indices (`list[int]`, *необязательный*) : Позиции пиксельных кадров для сгенерированных ключевых кадров.

slot_initial_latents (`torch.Tensor`, *необязательный*) : `(batch_size, num_channels_latents, len(slot_frame_indices), latent_height, latent_width)` содержимое, записанное в слот-токены до добавления шума.

reference_latents (`torch.Tensor`, *необязательный*) : `(batch_size, num_channels_latents, F, H, W)` Ссылочный латентный вектор IC-LoRA.

reference_downscale_factor (`int`, по умолчанию `1`) : Соотношение между целевым и эталонным разрешением.

latents (`torch.Tensor`, *необязательный*) : `(batch_size, num_channels_latents, F, H, W)` начальное содержимое для базовых токенов. Публичные латенты пайплайна являются сырыми (денормализованными); на этой границе передавайте `latents_normalized=False`. Циклы по тайлам, которые уже находятся в пространстве нормализации VAE, оставляют значение по умолчанию.

latents_normalized (`bool`, по умолчанию `True`) : Указывает, являются ли `latents`, `slot_initial_latents`, `reference_latents` и `keyframe_latents` уже нормализованными VAE. Внутренние циклы по тайлам передают `True`; каждый вызов `__call__` пайплайна передаёт `False`.

noise_scale (`float`, по умолчанию `1.0`) : Уровень шума, с которым инициализируются токены без условий, то есть первое сигма расписания.

**Возвращает:** `tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, slice | None]`

`(latents, conditioning_mask, clean_latents, video_coords, keyframes_mask, slot_token_slice)`. `slot_token_slice` индексирует токены слотов сгенерированных ключевых кадров в упакованной последовательности, либо `None`, если слоты не запрашивались.

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

Упакованная последовательность размещается в формате `[base | keyframes | slots | reference]`:

- Базовые токены покрывают целевую латентную сетку, инициализируясь из `latents`, если они предоставлены.
- Условия кадров с `index == 0` задают чистую цель на позициях первого кадра; те, у которых `index > 0`, и все элементы `keyframe_latents` добавляются как дополнительные токены ключевых кадров с маской условного сигнала для каждого токена, равной их силе.
- `slot_frame_indices` добавляет по одному набору токенов ключевых кадров, *сгенерированных* для одного латентного кадра, на каждую позицию, с маской условного контекста `0` (полностью денойзится) и временным диапазоном RoPE, равным ровно одному пиксельному кадру. Это слоты ключевых кадров, которые обеспечивают DFR дополнительные кадры; `slot_initial_latents` задаёт их начальное содержимое.
- `reference_latents` добавляет латентное представление полурезолюции первого этапа в качестве полностью чистого эталона IC-LoRA, при этом пространственные координаты масштабируются коэффициентом `reference_downscale_factor`, чтобы соответствовать целевому пространству координат.

Токены добавляемого условия несут своё содержимое в `clean_latents` и нулевой плейсхолдер в `latents`, тогда как слоты ключевых кадров несут своё зерно в `latents` и нули в `clean_latents` -- возвращаемые `latents` представляют собой зашумлённую смесь обоих (см. шаг добавления шума в конце этого метода).

#### preprocess_conditions[[diffusers.LTX2DFRTemporalRefinePipeline.preprocess_conditions]]

```python
preprocess_conditions(conditions: diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition | list[diffusers.pipelines.ltx2.pipeline_ltx2_condition.LTX2VideoCondition] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, device: typing.Optional[torch.device] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L648)

**Параметры:**

conditions (`LTX2VideoCondition` или `List[LTX2VideoCondition]`, *optional*, по умолчанию `None`) : Список экземпляров условий изображения/видео.

height (`int`, *необязательный*, по умолчанию `512`) : Требуемая высота в пикселях.

width (`int`, *необязательный*, по умолчанию `768`) : Требуемая ширина в пикселях.

num_frames (`int`, *необязательный*, по умолчанию `121`) : Требуемое количество кадров в генерируемом видео.

device (`torch.device`, *необязательный*, по умолчанию `None`) : Устройство, на котором размещаются тензоры предобработанных изображений/видео.

**Возвращает:** `Tuple[List[torch.Tensor], List[float], List[int], List[int]]`

Возвращает 4-кортеж списков длины `len(conditions)` в следующем виде:
1. Первый список — это список предобработанных тензоров видео с формой [batch_size=1, num_channels, num_frames, height, width].
2. Второй список — это список сил обусловливания.
3. Третий список — это список индексов пространства латентов для каждого условия.
4. Четвёртый список — это список (обрезанных) количеств кадров в пиксельном пространстве для каждого условия. Это необходимо для семантики координат ключевых кадров (ключевые кадры с одним пиксельным кадром имеют ограниченное временное расширение).

Предварительно обрабатывает изображения/видео условий в тензоры torch.

#### trim_conditioning_sequence[[diffusers.LTX2DFRTemporalRefinePipeline.trim_conditioning_sequence]]

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L630)

**Параметры:**

start_frame (int) : Номер целевого кадра первого кадра в последовательности.

sequence_num_frames (int) : Количество кадров в последовательности.

target_num_frames (int) : Целевое количество кадров в сгенерированном видео.

**Возвращает:** `int`

обновленная длина последовательности

Обрежьте последовательность условий до допустимого количества кадров.

#### upsample_latents[[diffusers.LTX2DFRTemporalRefinePipeline.upsample_latents]]

```python
upsample_latents(latents: Tensor, upsampler: LTX2LatentUpsamplerModel)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_dfr_temporal_refine.py#L1090)

Запустите `upsampler` на нормализованных латентах, выполнив обратное преобразование в исходное латентное пространство VAE, как того требует модель.

## LTX2DFRPipelineOutput[[diffusers.LTX2DFRPipelineOutput]]

#### diffusers.LTX2DFRPipelineOutput[[diffusers.LTX2DFRPipelineOutput]]

```python
diffusers.LTX2DFRPipelineOutput(frames: Tensor, audio: Tensor, keyframes: typing.Optional[torch.Tensor] = None, keyframe_positions: list[int] | None = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_output.py#L27)

**Параметры:**

frames (`torch.Tensor`, `np.ndarray` или list[list[PIL.Image.Image]]) : Денойзрованное видео. Латентный вывод — это необрезанный холст, форма `(batch_size, num_channels, latent_frames, latent_height, latent_width)`.

audio (`torch.Tensor`, `np.ndarray`) : Сопроводительные аудио-латенты или волновая форма.

keyframes (`torch.Tensor`, *необязательный*) : Сгенерированные или переданные латенты ключевых кадров формы `(batch_size, num_channels, num_keyframes, latent_height, latent_width)`. `None`, если `output_type != "latent"`, или если проход не создал слоты (например, в случае тайловой эпилога).

keyframe_positions (`list[int]`, *optional*) : Индекс пиксельного кадра каждого ключевого кадра на холсте данного прохода; `None`, если `keyframes` равно `None`. После временного раунда их невозможно повторно вывести из исходного `num_frames`, и их необходимо передать на следующий этап.

Класс вывода для конвейеров DFR.

## LTX2LatentUpsamplePipeline[[diffusers.LTX2LatentUpsamplePipeline]]

#### diffusers.LTX2LatentUpsamplePipeline[[diffusers.LTX2LatentUpsamplePipeline]]

```python
diffusers.LTX2LatentUpsamplePipeline(vae: AutoencoderKLLTX2Video, latent_upsampler: LTX2LatentUpsamplerModel)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_latent_upsample.py#L104)

#### __call__[[diffusers.LTX2LatentUpsamplePipeline.__call__]]

```python
__call__(video: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, spatial_patch_size: int = 1, temporal_patch_size: int = 1, latents: typing.Optional[torch.Tensor] = None, latents_normalized: bool = False, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, adain_factor: float = 0.0, tone_map_compression_ratio: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str | None = 'pil', return_dict: bool = True)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_latent_upsample.py#L264)

**Параметры:**

video (`list[PipelineImageInput]`, *необязательный*) : Видео, подлежащее апскейлингу (например, вывод первого этапа LTX 2.0). Если не указано, следует передать `latents`.

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

width (`int`, *optional*, по умолчанию `768`) : Ширина входного видео в пикселях (не сгенерированного видео, которое будет иметь более высокое разрешение).

num_frames (`int`, *необязательный*, по умолчанию `121`) : Количество кадров во входном видео.

spatial_patch_size (`int`, *optional*, по умолчанию `1`) : Пространственный размер патча для латентов видео. Используется, если `latents` передан и требуется распаковка.

temporal_patch_size (`int`, *optional*, по умолчанию `1`) : Размер временного патча для латентов видео. Используется, если `latents` передан и требуется распаковка.

latents (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные латенты видео. Этот параметр можно передать вместо аргумента `video`. Может представлять собой последовательность патчей формы `(batch_size, seq_len, hidden_dim)` или латентное представление видео формы `(batch_size, latent_channels, latent_frames, latent_height, latent_width)`.

latents_normalized (`bool`, *необязательный*, по умолчанию `False`) : Если переданы `latents`, указывает, нормализуются ли `latents` с помощью среднего значения и стандартного отклонения латентного пространства VAE. Если `True`, `latents` будут денормализованы перед передачей в латентный апсемплер.

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

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

adain_factor (`float`, *optional*, по умолчанию `0.0`) : Коэффициент смешивания Adaptive Instance Normalization (AdaIN) между увеличенными и исходными латентами. Должен находиться в диапазоне [-10.0, 10.0]; значение 0.0 (по умолчанию) означает, что AdaIN не выполняется.

tone_map_compression_ratio (`float`, *optional*, по умолчанию `0.0`) : Сила сжатия для tone mapping, которая уменьшает динамический диапазон значений латентов. Это полезно для регуляризации латентов с высокой дисперсией или для управления выходными данными во время генерации. Значение должно находиться в диапазоне [0, 1], где 0.0 (значение по умолчанию) означает, что tone mapping не применяется, а 1.0 соответствует полному эффекту сжатия.

generator (`torch.Generator` или `list[torch.Generator]`, *необязательный*) : Один или список [генераторов torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) для обеспечения детерминированности генерации.

output_type (`str`, *необязательный*, по умолчанию `"pil"`) : Формат вывода для генерируемого изображения. Выберите между [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` или `np.array`.

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

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

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

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

Примеры:
```py
>>> import torch
>>> from diffusers import LTX2ImageToVideoPipeline, LTX2LatentUpsamplePipeline
>>> from diffusers.utils import encode_video
>>> from diffusers.models.latent_upscaler import LTX2LatentUpsamplerModel
>>> from diffusers.utils import load_image

>>> pipe = LTX2ImageToVideoPipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()

>>> image = load_image(
...     "https://huggingface.co/datasets/a-r-r-o-w/tiny-meme-dataset-captioned/resolve/main/images/8.png"
... )
>>> prompt = "A young girl stands calmly in the foreground, looking directly at the camera, as a house fire rages in the background."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> frame_rate = 24.0
>>> video, audio = pipe(
...     image=image,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=121,
...     frame_rate=frame_rate,
...     num_inference_steps=40,
...     guidance_scale=4.0,
...     output_type="pil",
...     return_dict=False,
... )

>>> latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
...     "Lightricks/LTX-2", subfolder="latent_upsampler", torch_dtype=torch.bfloat16
... )
>>> upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
>>> upsample_pipe.vae.enable_tiling()
>>> upsample_pipe.to(device="cuda", dtype=torch.bfloat16)

>>> video = upsample_pipe(
...     video=video,
...     width=768,
...     height=512,
...     output_type="np",
...     return_dict=False,
... )[0]

>>> encode_video(
...     video[0],
...     fps=frame_rate,
...     audio=audio[0].float().cpu(),
...     audio_sample_rate=pipe.vocoder.config.output_sampling_rate,  # should be 24000
...     output_path="video.mp4",
... )
```

#### adain_filter_latent[[diffusers.LTX2LatentUpsamplePipeline.adain_filter_latent]]

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_latent_upsample.py#L168)

**Параметры:**

latents (`torch.Tensor`) : Входные латенты для нормализации

reference_latents (`torch.Tensor`) : Ссылочные латенты, задающие стилистические статистики.

factor (`float`) : Коэффициент смешения между исходным и преобразованным латентным представлением. Диапазон: от -10.0 до 10.0, значение по умолчанию: 1.0

**Возвращает:** `torch.Tensor`

Трансформированный латентный тензор

Применяет адаптивную нормализацию экземпляров (AdaIN) к тензору латентных переменных на основе статистики из опорного тензора латентных переменных.

#### tone_map_latents[[diffusers.LTX2LatentUpsamplePipeline.tone_map_latents]]

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_latent_upsample.py#L196)

**Параметры:**

latents : torch.Tensor Входной латентный тензор произвольной формы. Ожидается, что его значения будут примерно в диапазоне [-1, 1] или [0, 1].

compression : float Сила сжатия в диапазоне [0, 1]. - 0.0: Без тонмаппинга (тождественное преобразование) - 1.0: Полное сжатие

**Возвращает:**

torch.Tensor Латентный тензор с тоном, сопоставленный с входным, той же формы.

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

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

## LTX2VideoDiffusionDecodePipeline[[diffusers.LTX2VideoDiffusionDecodePipeline]]

#### diffusers.LTX2VideoDiffusionDecodePipeline[[diffusers.LTX2VideoDiffusionDecodePipeline]]

```python
diffusers.LTX2VideoDiffusionDecodePipeline(diffusion_decoder: LTX2VideoDiffusionDecoderModel, scheduler, vae: AutoencoderKLLTX2Video = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_diffusion_decode.py#L27)

**Параметры:**

diffusion_decoder ([LTX2VideoDiffusionDecoderModel](/docs/diffusers/v0.43.0/ru/api/models/ltx2_diffusion_decoder#diffusers.LTX2VideoDiffusionDecoderModel)) : диффузионный декодер видео.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/ru/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : планировщик, управляющий шагами денойзинга декодера.

vae ([AutoencoderKLLTX2Video](/docs/diffusers/v0.43.0/ru/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video), *optional*) : Используется только для получения латентных статистик, применяемых при денормализации. Если параметр не указан, конвейер переключается на значения по умолчанию для LTX-2, поэтому в сценарии, где выполняется только декодирование, не требуется загружать второй автоэнкодер.

Декодирование латентов видео LTX-2 с помощью диффузионного декодера, представленного в LTX-2.5.

В отличие от свёрточного декодера, этот сам является небольшой диффузионной моделью: он снимает шум с пикселей, используя в качестве условия контекстный объём, построенный из латентов, поэтому ему необходимы планировщик и генератор. Используйте его в паре с любым пайплайном LTX-2, запущенным с `output_type="latent"`, передавая `denormalize=False`, так как на этом пути статистика латентов уже была применена.

#### __call__[[diffusers.LTX2VideoDiffusionDecodePipeline.__call__]]

```python
__call__(latents: Tensor, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str = 'pil', return_dict: bool = True, denormalize: bool = True)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_ltx2_diffusion_decode.py#L79)

**Параметры:**

latents (`torch.Tensor`) : Латенты формы `(B, C, F, H, W)`. Обратите внимание, что запуск конвейера LTX-2 с параметром `output_type="latent"` возвращает латенты, которые *уже* денормализованы, поэтому для них передавайте `denormalize=False`.

generator (`torch.Generator`, *необязательный*) : Декодер генерирует шум, который затем очищает, поэтому передайте генератор, чтобы сделать декодирование воспроизводимым.

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

return_dict (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли возвращать `LTX2VideoDecodeOutput` вместо обычного кортежа.

denormalize (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли применять статистику латентов перед декодированием. Установите `False`, если латенты уже денормализованы.

**Возвращает:** `LTX2VideoDecodeOutput` или `tuple`

## LTX2DurationHead[[diffusers.pipelines.ltx2.LTX2DurationHead]]

#### diffusers.pipelines.ltx2.LTX2DurationHead[[diffusers.pipelines.ltx2.LTX2DurationHead]]

```python
diffusers.pipelines.ltx2.LTX2DurationHead(video_cross_attention_dim: int = 4096, audio_cross_attention_dim: int = 2048, pooler_hidden_dim: int = 256, num_queries: int = 1, num_pooler_heads: int = 4, mlp_hidden_dim: int = 256)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/duration_head.py#L81)

**Параметры:**

video_cross_attention_dim (`int`, по умолчанию `4096`) : Ширина выходного слоя видеоконнектора.

audio_cross_attention_dim (`int`, по умолчанию `2048`) : Ширина выхода аудио-коннектора.

pooler_hidden_dim (`int`, по умолчанию `256`) : Общая скрытая размерность, в которую проецируются оба модальности.

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

num_pooler_heads (`int`, по умолчанию `4`) : Количество attention-голов, используемых пуллером.

mlp_hidden_dim (`int`, по умолчанию `256`) : Скрытая ширина выходного MLP. Имя содержит суффикс `_dim`, чтобы избежать конфликта с подмодулем `mlp_hidden`, который в противном случае был бы затенён этим значением конфигурации через `ConfigMixin.__getattr__`.

Предсказывает естественную длительность кадра, подразумеваемую подписью, на основе выходов текстового коннектора LTX-2.

Голова не зависит от модальности: передайте выход коннектора видео, аудио или оба. Специфичные для модальности проекции ввода отображают каждый поток в общее пространство пулера, обучаемые эмбеддинги модальности помечают потоки, чтобы пулер мог их различать, а небольшой MLP преобразует пулированный вектор в лог-длительность. Целевая величина регрессии обучается в лог-секундах, поэтому `forward` возводит в степень, и вызывающая сторона всегда получает секунды.

Доступно начиная с контрольных точек LTX-2.5.

#### forward[[diffusers.pipelines.ltx2.LTX2DurationHead.forward]]

```python
forward(video_tokens: typing.Optional[torch.Tensor] = None, audio_tokens: typing.Optional[torch.Tensor] = None)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/duration_head.py#L134)

**Параметры:**

video_tokens (`torch.Tensor` формы `(batch_size, seq_len, video_cross_attention_dim)`, *необязательный*) : Выход видеоконнектора.

audio_tokens (`torch.Tensor` формы `(batch_size, seq_len, audio_cross_attention_dim)`, *необязательный*) : Вывод аудио-коннектора.

**Возвращает:** `torch.Tensor` формы `(batch_size,)`

предсказанная длительность в секундах.

#### predict_num_frames[[diffusers.pipelines.ltx2.LTX2DurationHead.predict_num_frames]]

```python
predict_num_frames(video_tokens: typing.Optional[torch.Tensor] = None, audio_tokens: typing.Optional[torch.Tensor] = None, frame_rate: float, temporal_compression_ratio: int, min_seconds: float = 1.0, max_seconds: float = 20.0)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/duration_head.py#L172)

**Параметры:**

video_tokens (`torch.Tensor`, *необязательный*) : Выход видеоконнектора для одного промпта.

audio_tokens (`torch.Tensor`, *необязательный*) : Вывод аудиоконнектора для одного запроса.

frame_rate (`float`) : Количество кадров в секунду, используемое для преобразования прогнозируемой длительности в число кадров.

temporal_compression_ratio (`int`) : временное сжатие VAE, определяющее сетку кадров.

min_seconds (`float`, по умолчанию `1.0`) : Нижняя граница для предсказания.

max_seconds (`float`, по умолчанию `20.0`) : Верхняя граница предсказания.

**Возвращает:** `int`

количество кадров, соответствующее временной сетке VAE.

Предсказывает количество кадров по токенам коннектора, ограничивает значение диапазоном `[min_seconds, max_seconds]` и выравнивает по каузальной временной сетке VAE (`k * temporal_compression_ratio + 1`).

Ограничение (clamp) применяется до привязки: количество кадров после ограничения не обязательно совпадает с сеткой, поэтому предварительная привязка дала бы иной результат. Поскольку привязка округляет вниз, результат может оказаться ниже минимального значения; в этом случае значение округляется вверх до следующей точки сетки, чтобы количество кадров оставалось в пределах допустимых границ.

Узкие границы могут привести к окну кадров, не содержащему ни одной точки сетки: при 24 кадрах в секунде `[1.0s, 1.02s]` округляется до `[24, 24]`, а 24 не является `8k + 1`. В этом случае используется ближайшая точка сетки и записывается предупреждение, поскольку превышение менее чем на один шаг сетки предпочтительнее отказа от генерации. Следовательно, возвращаемое количество всегда соответствует сетке, но в данной ситуации может оказаться чуть за пределами запрошенных границ.

## LTX2PipelineOutput[[diffusers.pipelines.ltx2.LTX2PipelineOutput]]

#### diffusers.pipelines.ltx2.LTX2PipelineOutput[[diffusers.pipelines.ltx2.LTX2PipelineOutput]]

```python
diffusers.pipelines.ltx2.LTX2PipelineOutput(frames: Tensor, audio: Tensor)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx2/pipeline_output.py#L9)

**Параметры:**

frames (`torch.Tensor`, `np.ndarray` или list[list[PIL.Image.Image]]) : Список видеовыходов — может представлять собой вложенный список длины `batch_size,` где каждый подсписок содержит последовательности денойзированных изображений PIL длины `num_frames.` Также может быть массивом NumPy или тензором Torch формы `(batch_size, num_frames, channels, height, width)`.

audio (`torch.Tensor`, `np.ndarray`) : TODO

Класс вывода для конвейеров LTX.

## LTX2ModularPipeline[[diffusers.LTX2ModularPipeline]]

#### diffusers.LTX2ModularPipeline[[diffusers.LTX2ModularPipeline]]

```python
diffusers.LTX2ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/ltx2/modular_pipeline.py#L26)

Модульный ModularPipeline для LTX-2 (совместная генерация видео и аудио).

## LTX2AutoBlocks[[diffusers.LTX2AutoBlocks]]

#### diffusers.LTX2AutoBlocks[[diffusers.LTX2AutoBlocks]]

```python
diffusers.LTX2AutoBlocks()
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/ltx2/modular_blocks_ltx2.py#L1761)

Auto-блоки для LTX-2, поддерживающие генерацию видео из текста, из изображения, из условия и в контексте (IC-LoRA) (совместное видео + аудио).

Поддерживаемые рабочие процессы:
- `text2video`: требуется `prompt`
- `image2video`: требуется `image`, `prompt`
- `condition`: требует `conditions`, `prompt`
- `in_context`: требует `reference_conditions`, `num_frames`, `prompt`

Компоненты: prompt_enhancer (`PreTrainedModel`) processor (`ProcessorMixin`) text_encoder (`PreTrainedModel`) tokenizer (`PreTrainedTokenizerBase`) connectors (`LTX2TextConnectors`) duration_head (`LTX2DurationHead`) vae (`AutoencoderKLLTX2Video`) video_processor (`VideoProcessor`) transformer (`LTX2VideoTransformer3DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) audio_vae (`AutoencoderKLLTX2Audio`) guider (`LTX2Guidance`) audio_guider (`LTX2Guidance`) vocoder (`LTX2Vocoder`)

Входные данные: prompt (`str`, *необязательный*): Промпт или промпты для управления генерацией изображения. conditions (`list`, *необязательный*): `LTX2VideoCondition` (или список таких объектов), задающий условия изображения/видео для латентных кадров сгенерированного видео. enable_prompt_enhancement (`bool`, *необязательный*, по умолчанию False): Нужно ли запускать улучшитель промпта. Опционально, в соответствии с эталонными конвейерами Lightricks. system_prompt (`str`, *необязательный*): Системный промпт для улучшения. По умолчанию `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT`, если доступно условие кадра `PIL.Image.Image`, иначе `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT`. prompt_max_new_tokens (`int`, *необязательный*): Максимальное количество новых токенов для генерации при улучшении промпта. По умолчанию 600, бюджет улучшителя LTX-2.5 Gemma-4. prompt_enhancement_kwargs (`dict`, *необязательный*): Именованные аргументы для вызова `.generate` улучшителя. По умолчанию жадное декодирование. prompt_enhancement_seed (`int`, *необязательный*, по умолчанию 10): Случайный сид для улучшения промпта (не действует при жадном декодировании LTX-2.5). generator (`Generator`, *необязательный*): Генератор Torch для детерминированной генерации. image (`Image | list`, *необязательный*): Изображение-ссылка или список изображений для денойзинга. Может быть одним изображением или списком изображений. negative_prompt (`str`, *необязательный*): Промпт или промпты, которые не должны направлять генерацию изображения. max_sequence_length (`int`, *необязательный*, по умолчанию 1024): Максимальная длина последовательности для кодирования промпта. min_seconds (`float`, *необязательный*, по умолчанию 1.0): Нижняя граница для автоматически предсказанной длительности. max_seconds (`float`, *необязательный*, по умолчанию 20.0): Верхняя граница для автоматически предсказанной длительности. Должно быть строго больше `min_seconds`. frame_rate (`float`, *необязательный*, по умолчанию 24.0): Количество кадров в секунду сгенерированного видео. height (`int`, *необязательный*, по умолчанию 512): Высота сгенерированного изображения в пикселях. width (`int`, *необязательный*, по умолчанию 704): Ширина сгенерированного изображения в пикселях. image_crf (`int`, *необязательный*): H.264 CRF, используемый для перекодирования условия `image` перед кодированием VAE, в соответствии со сжатием, на котором обучалась модель. `None` (по умолчанию) определяется из генерации текстового кодировщика (33 для LTX-2.3, 18 для LTX-2.5). Передайте `0`, чтобы пропустить перекодирование. Требует `PIL.Image.Image`, если выполняется перекодирование. num_frames (`int`, *необязательный*): Количество кадров в сгенерированном видео. Пропустите, чтобы автоматически предсказать через `duration_head` (см. `LTX2AutoDurationStep`). reference_conditions (`list`, *необязательный*): `LTX2ReferenceCondition` (или список таких объектов), видео которых кодируются в дополнительные латентные токены, на которые обращает внимание адаптер IC-LoRA. reference_downscale_factor (`int`, *необязательный*, по умолчанию 1): Соотношение между целевым и эталонным разрешениями; 2 означает, что эталон обрабатывается с разрешением в половину целевого. Пространственные координаты масштабируются этим коэффициентом, чтобы токены эталона попадали в целевое координатное пространство. Должно соответствовать коэффициенту, с которым обучался IC-LoRA. conditioning_attention_strength (`float`, *необязательный*, по умолчанию 1.0): Скаляр в [0, 1], управляющий силой, с которой шумовые токены и токены эталона обращают внимание друг на друга. 1.0 (по умолчанию) оставляет внимание без маски. conditioning_attention_mask (`Tensor`, *необязательный*): Необязательная маска в пиксельном пространстве формы (1, 1, F, H, W) со значениями в [0, 1], задающая пространственно изменяющуюся силу внимания. Уменьшается до латентной сетки эталона и умножается на `conditioning_attention_strength`. motion_speed (`float`, *необязательный*, по умолчанию 1.0): Скорость движения относительно реального времени. Позиционные эмбеддинги обусловлены `frame_rate / motion_speed`, поэтому значения меньше 1 замедляют движение, например `0.2` для 5-кратного замедления LoRA Slow-Motion-Control. `frame_rate` остается скоростью воспроизведения. num_videos_per_prompt (`int`, *необязательный*, по умолчанию 1): Количество изображений для генерации на один промпт. condition_latents (`list`, *необязательный*): Нормализованные латенты VAE для каждого условия формы [1, C, F, H, W]. condition_strengths (`list`, *необязательный*): Силы обусловливания для каждого условия. condition_indices (`list`, *необязательный*): Индекс латентного кадра для каждого условия, на котором применяется условие. condition_pixel_frames (`list`, *необязательный*): Количество обрезанных пиксельных кадров для каждого условия, используемое для ограничения координат одиночных ключевых кадров. reference_latents (`Tensor`, *необязательный*): Упакованные токены эталона формы [1, total_reference_tokens, C] или `None`, если условия эталона не были предоставлены (`LTX2AutoReferenceEncoderStep` пропускается). reference_coords (`Tensor`, *необязательный*): Координаты RoPE для токенов эталона. reference_token_counts (`list`, *необязательный*): Количество токенов для каждого эталона, в порядке `reference_conditions`. latents (`Tensor`): Предварительно сгенерированные шумовые латенты для генерации изображения. noise_scale (`float`, *необязательный*): Начальный уровень шума для необусловленных токенов. `None` (по умолчанию) разрешается в `sigmas[0]`, если предоставлены пользовательские `sigmas`, иначе 1.0. sigmas (`list`, *необязательный*): Пользовательские сигмы для процесса денойзинга. reference_cross_mask (`Tensor`, *необязательный*): Силы внимания шумовые<->эталон для каждого токена эталона формы [1, num_ref_tokens]. num_inference_steps (`int`): Количество шагов денойзинга. timesteps (`Tensor`): Шаги времени для процесса денойзинга. audio_latents (`Tensor`): Необязательные предварительно закодированные латенты аудио; если не предоставлены, используется случайный шум. **denoiser_input_fields (`None`, *необязательный*): условные входные данные модели для денойзера: например, prompt_embeds, negative_prompt_embeds и т.д. use_cross_timestep (`bool`, *необязательный*, по умолчанию True): Нужно ли обусловливать трансформер отдельным кросс-шагом времени для каждого токена (LTX-2.3+). attention_kwargs (`dict`, *необязательный*): Дополнительные именованные аргументы для процессоров внимания. image_latents (`Tensor`, *необязательный*): Латенты изображения-ссылки, закодированные VAE, используемые для обусловливания image-to-video. output_type (`str`, *необязательный*, по умолчанию pil): Формат вывода: 'pil', 'np', 'pt'. decode_timestep (`None`, *необязательный*, по умолчанию 0.0): Шаг времени, на котором VAE декодирует финальные латенты. decode_noise_scale (`None`, *необязательный*): Коэффициент интерполяции шума, применяемый к латентам на шаге декодирования.

Выводы: videos (`list`): сгенерированные видео. audio (`Tensor`): сгенерированная звуковая волна.

## LTX25ModularPipeline[[diffusers.LTX25ModularPipeline]]

#### diffusers.LTX25ModularPipeline[[diffusers.LTX25ModularPipeline]]

```python
diffusers.LTX25ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/ltx2/modular_pipeline.py#L125)

Модульный ModularPipeline для LTX-2.5 (совместная генерация видео и аудио).

Идентичен [LTX2ModularPipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/ltx2#diffusers.LTX2ModularPipeline), за исключением того, что его блоки по умолчанию декодируют с помощью диффузионного видео-декодера, который является нативным значением по умолчанию начиная с LTX-2.5. Чекпоинт направляется сюда через `modular_model_index.json`.

## LTX25AutoBlocks[[diffusers.LTX25AutoBlocks]]

#### diffusers.LTX25AutoBlocks[[diffusers.LTX25AutoBlocks]]

```python
diffusers.LTX25AutoBlocks()
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/ltx2/modular_blocks_ltx25.py#L215)

Auto-блоки для LTX-2.5, поддерживающие генерацию видео из текста, из изображения, из условия и в контексте (IC-LoRA) (совместное видео + аудио). Идентичны `LTX2AutoBlocks`, за исключением того, что видео-декодер — это `LTX2DiffusionVaeDecoderStep`, поскольку диффузионный декодер является нативным значением по умолчанию начиная с LTX-2.5. Чтобы декодировать с помощью свёрточного VAE, замените блок декодирования: `blocks.sub_blocks["decode"] = LTX2AutoDecoderStep()`.

Поддерживаемые рабочие процессы:
- `text2video`: требуется `prompt`
- `image2video`: требуется `image`, `prompt`
- `condition`: требует `conditions`, `prompt`
- `in_context`: требует `reference_conditions`, `num_frames`, `prompt`

Компоненты: prompt_enhancer (`PreTrainedModel`) processor (`ProcessorMixin`) text_encoder (`PreTrainedModel`) tokenizer (`PreTrainedTokenizerBase`) connectors (`LTX2TextConnectors`) duration_head (`LTX2DurationHead`) vae (`AutoencoderKLLTX2Video`) video_processor (`VideoProcessor`) transformer (`LTX2VideoTransformer3DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) audio_vae (`AutoencoderKLLTX2Audio`) guider (`LTX2Guidance`) audio_guider (`LTX2Guidance`) diffusion_decoder (`LTX2VideoDiffusionDecoderModel`) vocoder (`LTX2Vocoder`)

Входные данные: prompt (`str`, *необязательный*): Промпт или промпты для управления генерацией изображения. conditions (`list`, *необязательный*): `LTX2VideoCondition` (или список таких объектов), задающий условия изображения/видео для латентных кадров сгенерированного видео. enable_prompt_enhancement (`bool`, *необязательный*, по умолчанию False): Нужно ли запускать улучшитель промпта. Включается явно, в соответствии с эталонными пайплайнами Lightricks. system_prompt (`str`, *необязательный*): Системный промпт для улучшения. По умолчанию используется `LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT`, если доступно условие кадра `PIL.Image.Image`, иначе `LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT`. prompt_max_new_tokens (`int`, *необязательный*): Максимальное количество новых токенов для генерации при улучшении промпта. По умолчанию 600, бюджет улучшителя LTX-2.5 Gemma-4. prompt_enhancement_kwargs (`dict`, *необязательный*): Именованные аргументы для вызова `.generate` улучшителя. По умолчанию используется жадное декодирование. prompt_enhancement_seed (`int`, *необязательный*, по умолчанию 10): Случайный сид для улучшения промпта (не влияет при жадном декодировании LTX-2.5). generator (`Generator`, *необязательный*): Генератор Torch для детерминированной генерации. image (`Image | list`, *необязательный*): Изображение-ссылка или список изображений для денойзинга. Может быть одним изображением или списком изображений. negative_prompt (`str`, *необязательный*): Промпт или промпты, которые не должны направлять генерацию изображения. max_sequence_length (`int`, *необязательный*, по умолчанию 1024): Максимальная длина последовательности для кодирования промпта. min_seconds (`float`, *необязательный*, по умолчанию 1.0): Нижняя граница для автоматически предсказанной длительности. max_seconds (`float`, *необязательный*, по умолчанию 20.0): Верхняя граница для автоматически предсказанной длительности. Должно быть строго больше `min_seconds`. frame_rate (`float`, *необязательный*, по умолчанию 24.0): Количество кадров в секунду сгенерированного видео. height (`int`, *необязательный*, по умолчанию 512): Высота сгенерированного изображения в пикселях. width (`int`, *необязательный*, по умолчанию 704): Ширина сгенерированного изображения в пикселях. image_crf (`int`, *необязательный*): CRF H.264, используемый для перекодирования изображения-условия `image` перед кодированием VAE, чтобы соответствовать сжатию, на котором обучалась модель. `None` (по умолчанию) определяется из генерации текстового кодировщика (33 для LTX-2.3, 18 для LTX-2.5). Передайте `0`, чтобы пропустить перекодирование. Требует `PIL.Image.Image`, если выполняется перекодирование. num_frames (`int`, *необязательный*): Количество кадров в сгенерированном видео. Если не указано, длительность предсказывается автоматически через `duration_head` (см. `LTX2AutoDurationStep`). reference_conditions (`list`, *необязательный*): `LTX2ReferenceCondition` (или список таких объектов), видео которых кодируются в дополнительные латентные токены, на которые обращает внимание адаптер IC-LoRA. reference_downscale_factor (`int`, *необязательный*, по умолчанию 1): Соотношение между целевым и эталонным разрешением; 2 означает, что эталонное изображение предобрабатывается с половинным целевым разрешением. Пространственные координаты масштабируются этим коэффициентом, чтобы токены эталона попадали в целевое координатное пространство. Должно соответствовать коэффициенту, с которым обучался IC-LoRA. conditioning_attention_strength (`float`, *необязательный*, по умолчанию 1.0): Скаляр в диапазоне [0, 1], управляющий силой взаимного внимания шумовых и эталонных токенов. 1.0 (по умолчанию) оставляет внимание без маски. conditioning_attention_mask (`Tensor`, *необязательный*): Необязательная маска в пиксельном пространстве формы (1, 1, F, H, W) со значениями в [0, 1], задающая пространственно изменяющуюся силу внимания. Уменьшается до латентной сетки эталона и умножается на `conditioning_attention_strength`. motion_speed (`float`, *необязательный*, по умолчанию 1.0): Скорость движения относительно реального времени. Позиционные эмбеддинги обусловлены `frame_rate / motion_speed`, поэтому значения меньше 1 замедляют движение, например `0.2` для 5-кратного замедления LoRA Slow-Motion-Control. `frame_rate` остается частотой воспроизведения. num_videos_per_prompt (`int`, *необязательный*, по умолчанию 1): Количество изображений для генерации на один промпт. condition_latents (`list`, *необязательный*): Нормализованные латенты VAE для каждого условия формы [1, C, F, H, W]. condition_strengths (`list`, *необязательный*): Силы обусловливания для каждого условия. condition_indices (`list`, *необязательный*): Индекс латентного кадра для каждого условия, на котором применяется условие. condition_pixel_frames (`list`, *необязательный*): Количество обрезанных пиксельных кадров для каждого условия, используемое для ограничения координат одиночных ключевых кадров. reference_latents (`Tensor`, *необязательный*): Упакованные эталонные токены формы [1, total_reference_tokens, C] или `None`, если эталонные условия не были предоставлены (`LTX2AutoReferenceEncoderStep` пропускается). reference_coords (`Tensor`, *необязательный*): Координаты RoPE для эталонных токенов. reference_token_counts (`list`, *необязательный*): Количество токенов для каждого эталона, в порядке `reference_conditions`. latents (`Tensor`): Предсгенерированные шумовые латенты для генерации изображения. noise_scale (`float`, *необязательный*): Начальный уровень шума для необусловленных токенов. `None` (по умолчанию) разрешается в `sigmas[0]`, если предоставлены пользовательские `sigmas`, иначе 1.0. sigmas (`list`, *необязательный*): Пользовательские сигмы для процесса денойзинга. reference_cross_mask (`Tensor`, *необязательный*): Силы внимания шумовые<->эталонные для каждого эталонного токена формы [1, num_ref_tokens]. num_inference_steps (`int`): Количество шагов денойзинга. timesteps (`Tensor`): Шаги времени для процесса денойзинга. audio_latents (`Tensor`): Необязательные предкодированные аудио-латенты; если не предоставлены, используется случайный шум. **denoiser_input_fields (`None`, *необязательный*): Условные входные данные модели для денойзера: например, prompt_embeds, negative_prompt_embeds и т.д. use_cross_timestep (`bool`, *необязательный*, по умолчанию True): Нужно ли обусловливать трансформер отдельным кросс-шагом времени для каждого токена (LTX-2.3+). attention_kwargs (`dict`, *необязательный*): Дополнительные именованные аргументы для процессоров внимания. image_latents (`Tensor`, *необязательный*): Латенты изображения-ссылки, закодированные VAE, используемые для обусловливания image-to-video. output_type (`str`, *необязательный*, по умолчанию pil): Формат вывода: 'pil', 'np', 'pt'.

Выводы: videos (`list`): сгенерированные видео. audio (`Tensor`): сгенерированная звуковая волна.