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

  
    
      
    
    
  

# LTX-Video

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

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

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

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

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

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

```py
import torch
from diffusers import LTXPipeline, AutoModel
from diffusers.hooks import apply_group_offloading
from diffusers.utils import export_to_video

# fp8 layerwise weight-casting
transformer = AutoModel.from_pretrained(
    "Lightricks/LTX-Video",
    subfolder="transformer",
    dtype=torch.bfloat16
)
transformer.enable_layerwise_casting(
    storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16
)

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

# group-offloading
onload_device = torch.device("cuda")
offload_device = torch.device("cpu")
pipeline.transformer.enable_group_offload(onload_device=onload_device, offload_device=offload_device, offload_type="leaf_level", use_stream=True)
apply_group_offloading(pipeline.text_encoder, onload_device=onload_device, offload_type="block_level", num_blocks_per_group=2)
apply_group_offloading(pipeline.vae, onload_device=onload_device, offload_type="leaf_level")

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

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

[Компиляция](../../optimization/fp16#torchcompile) выполняется медленно при первом запуске, но последующие вызовы конвейера становятся быстрее. [Кэширование](../../optimization/cache) также может ускорить инференс за счёт хранения и повторного использования промежуточных результатов.

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

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

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

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

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

## Примечания

- См. следующие рекомендуемые настройки для генерации из репозитория [LTX-Video](https://github.com/Lightricks/LTX-Video).

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

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

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

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

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

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

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

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

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

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

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

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

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

  

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

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

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

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

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

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

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

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

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

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

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

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

  

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

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

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

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

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

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

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

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

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

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

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

  

- LTX-Video поддерживает LoRA с помощью [load_lora_weights()](/docs/diffusers/v0.43.0/ru/api/loaders/lora#diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_weights).

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

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

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

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

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

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

  

- LTX-Video supports loading from single files, such as [GGUF checkpoints](../../quantization/gguf), with [loaders.FromOriginalModelMixin.from_single_file()](/docs/diffusers/v0.43.0/ru/api/loaders/single_file#diffusers.loaders.FromOriginalModelMixin.from_single_file) or [loaders.FromSingleFileMixin.from_single_file()](/docs/diffusers/v0.43.0/ru/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file).

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

  ```py
  import torch
  from diffusers.utils import export_to_video
  from diffusers import LTXPipeline, AutoModel, GGUFQuantizationConfig

  transformer = AutoModel.from_single_file(
      "https://huggingface.co/city96/LTX-Video-gguf/blob/main/ltx-video-2b-v0.9-Q3_K_S.gguf"
      quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
      dtype=torch.bfloat16
  )
  pipeline = LTXPipeline.from_pretrained(
      "Lightricks/LTX-Video",
      transformer=transformer,
      dtype=torch.bfloat16
  )
  ```

  

## LTXI2VLongMultiPromptPipeline[[diffusers.LTXI2VLongMultiPromptPipeline]]

#### diffusers.LTXI2VLongMultiPromptPipeline[[diffusers.LTXI2VLongMultiPromptPipeline]]

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

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

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

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) или `LTXEulerAncestralRFScheduler`) : планировщик, используемый в связке с `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 (`T5TokenizerFast`) : Токенизатор класса [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).

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

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

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

#### __call__[[diffusers.LTXI2VLongMultiPromptPipeline.__call__]]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Если `return_dict` равно `True`, возвращается `~pipelines.ltx.LTXPipelineOutput`, иначе возвращается `tuple`, где первый элемент — это список с сгенерированными кадрами. Формат вывода зависит от `output_type`:
- "latent"/"pt": `torch.Tensor` [B, C, F, H, W]; "latent" — в нормализованном латентном пространстве, "pt" — в пространстве вывода VAE.
- "np": `np.ndarray` после обработки.
- "pil": `list[PIL.Image.Image]` список изображений PIL.

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

Примеры:
```py
>>> import torch
>>> from diffusers import LTXEulerAncestralRFScheduler, LTXI2VLongMultiPromptPipeline

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

Формы: размеры латентов (при автоматической генерации):
- F_lat = (num_frames - 1) // vae_temporal_compression_ratio + 1
- H_lat = height // vae_spatial_compression_ratio
- W_lat = width // vae_spatial_compression_ratio

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

#### encode_prompt[[diffusers.LTXI2VLongMultiPromptPipeline.encode_prompt]]

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

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

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

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

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

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

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

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

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

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

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

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

#### prepare_latents[[diffusers.LTXI2VLongMultiPromptPipeline.prepare_latents]]

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

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

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

latents, negative_index_latents, latent_num_frames, latent_height, latent_width

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

#### vae_decode_tiled[[diffusers.LTXI2VLongMultiPromptPipeline.vae_decode_tiled]]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## LTXPipeline[[diffusers.LTXPipeline]]

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

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

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

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

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

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

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

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

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: int = 25, num_inference_steps: int = 50, timesteps: list[int] = None, guidance_scale: float = 3, guidance_rescale: float = 0.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 128)
```

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

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

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

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

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

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

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

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

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

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

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

guidance_rescale (`float`, *optional*, defaults to 0.0) : Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are Flawed](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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> pipe = LTXPipeline.from_pretrained("Lightricks/LTX-Video", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

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

>>> video = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=704,
...     height=480,
...     num_frames=161,
...     num_inference_steps=50,
... ).frames[0]
>>> export_to_video(video, "output.mp4", fps=24)
```

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

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

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

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

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

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

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

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

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

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

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

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

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

## LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

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

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

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

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

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

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

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

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

```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: int = 25, num_inference_steps: int = 50, timesteps: list[int] = None, guidance_scale: float = 3, guidance_rescale: float = 0.0, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 128)
```

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

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

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

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

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

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

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

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

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

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

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

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

guidance_rescale (`float`, *optional*, defaults to 0.0) : Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are Flawed](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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примеры:
```py
>>> import torch
>>> from diffusers import LTXImageToVideoPipeline
>>> from diffusers.utils import export_to_video, load_image

>>> pipe = LTXImageToVideoPipeline.from_pretrained("Lightricks/LTX-Video", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> image = load_image(
...     "https://huggingface.co/datasets/a-r-r-o-w/tiny-meme-dataset-captioned/resolve/main/images/8.png"
... )
>>> prompt = "A young girl stands calmly in the foreground, looking directly at the camera, as a house fire rages in the background. Flames engulf the structure, with smoke billowing into the air. Firefighters in protective gear rush to the scene, a fire truck labeled '38' visible behind them. The girl's neutral expression contrasts sharply with the chaos of the fire, creating a poignant and emotionally charged scene."
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> video = pipe(
...     image=image,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=704,
...     height=480,
...     num_frames=161,
...     num_inference_steps=50,
... ).frames[0]
>>> export_to_video(video, "output.mp4", fps=24)
```

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

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

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

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

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

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

## LTXConditionPipeline[[diffusers.LTXConditionPipeline]]

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

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

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

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

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

Пайплайн для генерации видео из текста/изображения/видео.

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

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

```python
__call__(conditions: diffusers.pipelines.ltx.pipeline_ltx_condition.LTXVideoCondition | list[diffusers.pipelines.ltx.pipeline_ltx_condition.LTXVideoCondition] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]]] = None, video: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] = None, frame_index: int | list[int] = 0, strength: float | list[float] = 1.0, denoise_strength: float = 1.0, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: int = 25, num_inference_steps: int = 50, timesteps: list[int] = None, guidance_scale: float = 3, guidance_rescale: float = 0.0, image_cond_noise_scale: float = 0.15, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 256)
```

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

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

conditions (`list[LTXVideoCondition], *optional*`) : Список элементов для условного формирования кадров при генерации видео. Если не указан, условия будут созданы с использованием `image`, `video`, `frame_index` и `strength`.

image (`PipelineImageInput` или `list[PipelineImageInput]`, *необязательный*) : Изображение или изображения для условного формирования генерации видео. Если не указано, необходимо передать `video` или `conditions`.

video (`list[PipelineImageInput]`, *необязательный*) : Видео, на основе которого будет выполняться генерация видео. Если не указано, необходимо передать `image` или `conditions`.

frame_index (`int` или `list[int]`, *необязательный*) : Индекс кадра или индексы кадров, на которых изображение или видео будут условно влиять на генерацию видео. Если не указано, необходимо передать `conditions`.

strength (`float` или `list[float]`, *необязательный*) : Сила или набор сил эффекта обусловливания. Если не указано, необходимо передать `conditions`.

denoise_strength (`float`, по умолчанию `1.0`) : Сила шума, добавляемого к латентам для редактирования. Чем выше сила, тем больше шума добавляется к латентам, что приводит к более значительным различиям между исходным и сгенерированным видео. Это полезно для редактирования видео в видео.

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

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

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

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

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

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

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

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

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

guidance_rescale (`float`, *optional*, defaults to 0.0) : Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are Flawed](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.

image_cond_noise_scale (`float`, по умолчанию `0.15`) : Масштаб шума, добавляемого к латентам условного изображения.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примеры:
```py
>>> import torch
>>> from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXConditionPipeline, LTXVideoCondition
>>> from diffusers.utils import export_to_video, load_video, load_image

>>> pipe = LTXConditionPipeline.from_pretrained("Lightricks/LTX-Video-0.9.5", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> # Load input image and video
>>> video = load_video(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input-vid.mp4"
... )
>>> image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input.jpg"
... )

>>> # Create conditioning objects
>>> condition1 = LTXVideoCondition(
...     image=image,
...     frame_index=0,
... )
>>> condition2 = LTXVideoCondition(
...     video=video,
...     frame_index=80,
... )

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

>>> # Generate video
>>> generator = torch.Generator("cuda").manual_seed(0)
>>> # Text-only conditioning is also supported without the need to pass `conditions`
>>> video = pipe(
...     conditions=[condition1, condition2],
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=768,
...     height=512,
...     num_frames=161,
...     num_inference_steps=40,
...     generator=generator,
... ).frames[0]

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

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

```python
add_noise_to_image_conditioning_latents(t: float, init_latents: Tensor, latents: Tensor, noise_scale: float, conditioning_mask: Tensor, generator, eps = 1e-06)
```

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

Добавьте шум, зависящий от временного шага, в латенты жёсткого обусловливания. Это способствует непрерывности движения, особенно при обусловливании по одному кадру.

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

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

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

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

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

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

#### trim_conditioning_sequence[[diffusers.LTXConditionPipeline.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/ltx/pipeline_ltx_condition.py#L629)

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

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

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

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

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

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

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

## LTXLatentUpsamplePipeline[[diffusers.LTXLatentUpsamplePipeline]]

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

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

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

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

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

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

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

video (`list[PipelineImageInput]`, *optional*) : Входные кадры видео для апсемплинга. Взаимоисключается с `latents`.

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

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

latents (`torch.Tensor`, *необязательный*) : Предварительно закодированные латенты видео для апсемплинга. Взаимоисключается с `video`.

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

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

adain_factor (`float`, по умолчанию `0.0`) : Сила применения статистического согласования AdaIN к апсемплированным латентам.

tone_map_compression_ratio (`float`, по умолчанию `0.0`) : Коэффициент сжатия, используемый для тонмаппинга апсемплированных латентов. Должен находиться в диапазоне [0, 1].

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

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

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

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

`~pipelines.ltx.LTXPipelineOutput`, если `return_dict` равно True, иначе `tuple`. При возврате кортежа первым элементом является видео с увеличенным разрешением (или латенты, если `output_type="latent"`).

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

#### adain_filter_latent[[diffusers.LTXLatentUpsamplePipeline.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/ltx/pipeline_ltx_latent_upsample.py#L94)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## LTXPipelineOutput[[diffusers.pipelines.ltx.pipeline_output.LTXPipelineOutput]]

#### diffusers.pipelines.ltx.pipeline_output.LTXPipelineOutput[[diffusers.pipelines.ltx.pipeline_output.LTXPipelineOutput]]

```python
diffusers.pipelines.ltx.pipeline_output.LTXPipelineOutput(frames: Tensor)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ltx/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)`.

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