hf-doc-build/doc / diffusers /main /ja /api /pipelines /ltx2.md

|

raw

264 kB

Apache License, Version 2.0（「ライセンス」）の下でライセンスされています。

このファイルは、ライセンスに準拠した場合にのみ使用できます。

ライセンスのコピーは以下から入手できます

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

適用される法律で要求される場合、または書面による合意がある場合を除き、ソフトウェア

ライセンスに基づき配布される本ソフトウェアは、「現状のまま」

明示的または黙示的を問わず、いかなる種類の保証や条件も付随しません。

権限を管理する特定の言語については、ライセンスを参照してください。

ライセンスの下での制限。-->

LTX-2

LTX-2は、単一のモデル内で同期された動画と音声を生成するために設計されたDiTベースの基盤モデルです。最新の動画生成のコアとなる構成要素を統合しており、オープンウェイトを提供するとともに、実用的なローカル実行に焦点を当てています。

すべてのオリジナルのLTX-Videoチェックポイントは、Lightricks組織の下で確認できます。

LTX-2の元のコードベースはこちらで確認できます。

2段階の生成

共有の LTX2Pipeline / LTX2ImageToVideoPipeline の __call__ のデフォルト値は、LTX-2.5 のリファレンスと一致しています（num_inference_steps=30。duration_head が存在する場合は num_frames は省略可能で、存在しない場合は 121 にフォールバックします）。以下の例では、LTX-2.0/2.3 についてもこれらのデフォルト値を使用しています。

本番環境での高品質な生成を実現するための推奨パイプラインです。このパイプラインは2つの段階で構成されています。

ステージ1: クラスフリーガイダンス（CFG）を用いた拡散サンプリングにより、ターゲット解像度で動画を生成します。このステージでは、テキスト/画像の条件付けを尊重した、一貫性のある低ノイズの動画シーケンスが生成されます。
Stage 2: Stage 1 の出力を 2 倍にアップサンプリングし、蒸留された LoRA モデルを使用して詳細を精錬することで、忠実度と視覚的な品質を向上させます。Stage 2 では、Stage 1 の構造を維持しつつ、テクスチャとシャープネスを強化するために、より軽い CFG を適用する場合があります。

テキストから動画への変換2段階パイプラインの使用例

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

蒸留済みチェックポイントの生成

蒸留済みチェックポイントを使用して、最速の2段階生成パイプラインを実行します。

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 を使用すると、任意の潜在インデックスで画像および/または動画の条件を指定できます。例えば、最初のフレームと最後のフレームの条件を両方指定することで、first-last-frame-to-video (FLF2V) 生成を実行できます。

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

画像と動画の両方の条件を使用できます:

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のパイプラインはマルチモーダルガイダンスをサポートしています。これは3つの項で構成され、すべてCFGスタイルの更新ルールを使用します。

Classifier-Free Guidance (CFG): 標準的なCFGで、擾乱（「弱い」）出力はネガティブプロンプトを使用して生成されます。
Spatio-Temporal Guidance (STG): STGでは、self-attention 操作をショートカットして生成される擾乱された出力から離れ、代わりに attention 値を代入します。これにより、よりシャープな動画と、より良い時空間的一貫性が得られるという考えに基づいています。
Modality Isolation Guidance: クロスモーダリティ（オーディオからビデオ、およびビデオからオーディオ）のクロスアテンションを無効化して生成される、擾乱された出力からの離脱を行います。このガイダンスはLTX-2.Xモデルに特に適用されるもので、これにより生成されるオーディオとビデオの間の一貫性が向上するという考えに基づいています。

これらは guidance_scale、stg_scale、modality_scale 引数によって制御され、動画と音声でそれぞれ個別に設定できます。また、STG については、自己注意をスキップする transformer ブロックのインデックスを spatio_temporal_guidance_blocks 引数で指定する必要があります。LTX-2.X パイプラインでは、guidance スケールが高値に設定された場合に問題になりうる過剰露出を軽減するために、guidance rescaling もサポートしています。

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 モデルはプロンプトのスタイルに敏感です。良いプロンプトの書き方に関する推奨事項については、公式プロンプトガイドを参照してください。プロンプト強化を使用すると、パイプラインのテキストエンコーダー（デフォルトでは Gemma 3 モデル）がシステムプロンプトを与えられてプロンプトを強化するため、サンプルの品質を向上させることができます。プロンプト強化を使用するには、任意の processor パイプラインコンポーネントが存在する必要があります。enable_prompt_enhancement=True と system_prompt を指定して有効にします（オプトイン方式で、Lightricks のリファレンスパイプラインと一致）:

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 は、LTX-2.3 と同じ LTX2Pipeline/LTX2VideoTransformer3DModel/AutoencoderKLLTX2Video などのクラスを再利用します。専用のパイプラインクラスは存在しません。ユーザーに見える違いはテキストエンコーダーです。LTX-2.5 は、Gemma 3 の代わりに Gemma 4 (gemma4_unified) チェックポイントと組み合わされます。変換済みの LTX-2.5 チェックポイントに対して from_pretrained を呼び出すと、自動的に読み込まれます（transformers の Auto* クラスを介して）。そのため、推論時に追加のセットアップは不要です。LTX-2.3 のリポジトリではなく、LTX-2.5 のリポジトリを from_pretrained に指定するだけです。

Lightricks/LTX-2.5-Diffusers には、2 つの transformer が同梱されています。model_index.json が指しているのは transformer/ にある distilled DiT であり、もう一方の full/SFT DiT は transformer_full/ にあり、明示的にロードする必要があります（Full / SFT transformer を参照）。リポジトリの scheduler/ は distilled チェックポイント用に設定されており（use_dynamic_shifting=False、shift_terminal=None）、その sigma スケジュールがそのまま使用されるようになっています。two-stage generation に必要なものもすべて同梱されており、latent_upsampler/ サブフォルダと、リポジトリのルートにある stage 2 の distilled LoRA ltx-2.5-22b-distilled-lora-450-bf16.safetensors が含まれています。

蒸留推論はステップ数ではなく明示的なシグマスケジュールによって駆動され、ガイドなしで実行されます（guidance_scale=1.0のため、negative_promptは使用されません）。代わりにnum_inference_stepsを渡すと、モデルに汎用的な線形スケジュールが与えられ、品質が静かに低下します。

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の2段階生成

LTX-2.5 は 2 ステージのバリアントの両方をサポートしており、DISTILLED_SIGMA_VALUES / STAGE_2_DISTILLED_SIGMA_VALUES はそのリファレンススケジュールです:

蒸留済みチェックポイント（両ステージ） — デフォルトのtransformer/向けの参照レシピであり、以下に示すものです。transformerはすでに蒸留済みのため、ステージ2のLoRAは関与しません。これはLTX-2.5の重みを用いた蒸留済みチェックポイントの生成です。
Full/SFT ステージ 1 + 蒸留 LoRA ステージ 2 — このページの冒頭で説明されている2段階の生成で、transformer_full/と付属の LoRA を使用します。変更点については下記を参照してください。

Stage 1 はターゲット解像度の半分でのみ実行され、アップサンプラーによって解像度が2倍に拡大された後、Stage 2 がフル解像度で精細化を行います。これは動画および音声の両方に適用され、いずれも Stage 1 の潜在変数から noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0] を用いて再シードされます。Stage 1 が各軸を半分にしつつも VAE の空間グリッドに整列させる必要があるため、高さおよび幅は 64 で割り切れる値でなければなりません。

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

長さが明示的な num_frames ではなく duration head から得られる場合、stage 2 の実行前に、stage 1 に決定させ、その latents ([B, C, F, H, W]) から実現された長さを復元してください。2 回目に予測するのではなく、このようにします。

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

蒸留されたLoRAを用いたステージ2

代わりに2段階生成を実行する場合（ステージ1にフル/SFT DiT、ステージ2に蒸留LoRAを使用）は、フル / SFT transformerと同様にパイプラインを構築し、そのガイダンススタックでステージ1の潜在変数を生成します。その後、LTX-2.0/2.3とは2点異なります。LoRAは元の重みの隣ではなく、diffusersリポジトリ自体に格納されており、スケジューラの反転は逆方向です。LTX-2.5には蒸留スケジューラ設定が同梱されているため、ステージ1でダイナミックシフトが有効化され、ステージ2で無効化されます。

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の呼び出し自体は、上記の蒸留レシピから変更されていません。いずれの場合もステージ2では蒸留モデルが実行されるため、sigmas=STAGE_2_DISTILLED_SIGMA_VALUES、noise_scale、guidance_scale=1.0はすべて同じです。

畳み込みおよび拡散デコーディング

LTX-2.5は、同じ潜在空間上で動作する2つのビデオデコーダーを備えており、そのため潜在変数はこれら間で相互に交換可能です。

vae/ — 畳み込み VAE（AutoencoderKLLTX2Video）。パイプラインがデコードに使用するコンポーネントであり、上記のスニペットはすべてこれを使用しています。また、2 つのうちタイル化（pipe.vae.enable_tiling()）に対応しているのはこれだけで、通常、これにより高解像度の出力が可能になります。
diffusion_decoder/ — LTX2VideoDiffusionDecoderModel。これはパイプラインのコンポーネントではなく、それ自体が拡散モデルであるため、vae として渡すことはありません。output_type="latent" を指定してパイプラインを実行し、得られた潜在変数を LTX2VideoDiffusionDecodePipeline に渡してください。

エンコーディングは常にvae/を経由するため、画像および動画の条件付けは選択によって影響を受けません。

拡散デコーダでデコードを行うと、2つの点が変わります。output_type="latent"を指定するとボーコーダもスキップされるため、音声は潜在変数として返され、手動で処理を完了させる必要があります。また、NATTENプロセッサは動画解像度では実質的に必須です。

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

これを2段階生成と組み合わせるには、stage 2に対してoutput_type="latent"を指定し、その結果をデコードします。

decoder.enable_tiling() は、pipe.vae.enable_tiling() が畳み込み VAE に対して行うのと同様に、高解像度のデコードをメモリ内に保持するための機能です。デコードにおけるメモリ消費の主要部分である最後のアップサンプリング段階と拡散段階は、オーバーラップするタイルで実行され、その後それらがブレンドされて再結合されるため、ピークメモリは動画サイズではなくタイルサイズによって上限が設定されます。タイルリングは、潜在変数が 1 つのタイルを超えた場合にのみ有効になり、タイルサイズとオーバーラップサイズは tile_sample_min_* / tile_sample_stride_* 引数（デフォルト値は参照実装と一致）で調整できます。拡散段階では各タイルが個別にデノイズされるため、タイルリングによるデコードでは、タイルリングなしの結果と完全に一致する出力は得られません。

単一カードでは、デコードの前にパイプラインを退避させることも有効です（pipe.scheduler とボコーダーの output_sampling_rate を取得した後、pipe.to("cpu") と torch.cuda.empty_cache() を呼び出します）。これは、デコーダーが独自の空き領域を必要とするためです。アテンションのバックエンド、タイルリングの詳細、およびデコーダーのその他の動作については、LTX2VideoDiffusionDecoderModel を参照してください。

フル / SFT transformer

transformer_full/ は model_index.json によって参照されていないため、明示的に読み込む必要があります。また、異なるスケジューラと実用的なガイダンススタックも必要です。同梱されている scheduler/ は蒸留済みチェックポイント用に設定されており、ガイダンスのデフォルト値は LTX-2.0 世代の汎用値です。これでは LTX-2.5 の SFT 実行時にエラーは発生しませんが、ガイダンスが不足していることが視覚的に明らかになります。Multimodal Guidance の推奨事項は、ブロック 28 における STG を含め、そのまま適用できます。

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= を渡してください：

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 を用いた image-to-video にも同様のことが当てはまります。pipe.prompt_enhancer/pipe.processor を同様に設定し、enable_prompt_enhancement=True を渡します（LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT を使用し、参照画像とテキストプロンプトの両方に条件付けを行います）。オーバーライドしない限り、system_prompt= は不要です。

LTX-2.5の自動再生時間

LTX-2.5のチェックポイントには、transformerが条件付けられるのと同じテキストコネクタの出力から、記述されたショットの長さを予測する小さなduration_headが同梱されています。読み込まれたパイプラインにこれが含まれている場合、**num_framesはデフォルトで自動予測されます**。省略すると、モデルが長さを決定します。

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

長さを自分で設定するには、num_frames を明示的に渡します。整数は常に head より優先されます:

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

LTX-2.0 または LTX-2.3 のチェックポイントから読み込まれた Pipelines には duration head が存在せず、従来のデフォルトである 121 フレームが維持されるため、これらに対しては変更点はありません。

min_seconds / max_seconds を渡すことで、予測値を制約できます。生の予測値は指定された範囲にクランプされた後、フレーム数に変換されます。

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）にスナップされるため、実際の再生時間は量子化されます（24 fps の場合、1 ステップあたり約 0.33 秒）。また、ヘッドがフレーム数ではなく秒数を予測するため、frame_rate によって変化します。min_seconds は max_seconds より厳密に小さい必要があります。num_frames が明示的に設定されている場合、これらの境界値は無視されます。

1グリッドステップより狭い範囲は、厳密には満たせない場合があります。24 fps の場合、[1.0s, 1.02s] は [24, 24] フレームに変換されますが、24 は 8k + 1 ではありません。この場合、最も近いグリッドポイントが使用され、警告がログに記録されるため、返される長さが、そのような厳密な範囲のすぐ外側になる可能性があります。

予測を検査して動画を生成せずに確認するには、ヘッドを直接呼び出します。必要なものはすべて公開されています:

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のチェックポイントを変換する場合、--full_pipelineを指定するとヘッドが自動的に選択されます。または、--duration_headを単独で指定することもできます。2.5以前のチェックポイントにはそのような重みが存在しないため、変換時にエラーになるのではなく、該当コンポーネントがスキップされます。

LTX-2.5のモーション速度

LTX-2 は、すべての動画トークンを秒単位の時間軸上に配置します。この時間軸はデフォルトでは再生レートである frame_rate から導出されます。motion_speed（デフォルト 1.0）によってこれらを分離します。時間軸は frame_rate / motion_speed に条件付けられますが、音声の長さ、duration head、および返される動画は引き続き frame_rate に従います。frame_rate=24.0 かつ motion_speed=0.2 の場合、モデルにはアクションが 120 fps で撮影されたと伝えられ、結果は 24 fps で再生されるため、5 倍のスローモーションになります。

ベースモデルは 24/25/30/60 fps 程度で学習されているため、1.0 から大きく離れた速度は、それら用に学習されたアダプター（例: Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control、ゲート付き: まず Hub でライセンスに同意してください）を使用する場合にのみ意味を持ちます。motion_speed を指定しないと、その LoRA は通常の LoRA として読み込まれ、モーション制御の恩恵は得られません。モデルカードでは、LoRA 強度 1.0 で、速度 1.0、0.5、0.2、0.1、0.05、0.025 の使用が推奨されています。プロンプトから速度を示す言葉（「slow motion」「high fps」など）を除外し、motion_speed 単独で効果が駆動されるため、速度を問わず同じキャプションを再利用してください。

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フレーム（24 fpsで約5秒）であり、変化するのは動きのペースだけです。2段階生成では、両方の段階に同じmotion_speedを渡します。第2段階では動画が再デノイズされるため、リアルタイム軸で実行するとスローモーションが取り消されてしまいます。reference driverは、両パスが共有するステージオブジェクトをラップすることで、同じことを実現しています。

motion_speed は LTX-2 / LTX-2.5 のモジュラーブロックの入力としても使用され、モジュラーパイプラインへの渡し方も同様です。

LTX-2.5 モジュラー

LTX-2.5 はモジュラーパイプラインとしても利用できます。デフォルトのブロックセットは拡散デコーダーを使用し、num_frames が省略されている場合は動画の長さを予測します。guider と audio_guider コンポーネントを通じて、動画と音声に対してそれぞれ個別にガイダンスを適用します。利用可能なガイダンスパラメータについては LTX2Guidance を参照してください。デフォルトでは、モジュラーパイプラインは google/gemma-4-E2B-it リポジトリからプロンプトエンハンサーとプロセッサーをダウンロードします。以下は T2V のモジュラー例です:

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ワークフローが使用されます:

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、LTX25AutoBlocks）で、サポートされているワークフローを確認できます。

LTX-2.5 向けの Diffusion Fidelity Rendering (DFR)

LTX2DFRPipeline は、リアルタイム性（ウォールクロック時間）を犠牲にして詳細の忠実度を高めます。各 __call__ は height × width での 1回のデノイズパス であり、動画と、それらのスロットからシードされた追加の単一ピクセルフレームの キーフレームスロット を生成するか、これらのスロットからシードされた提供された潜在変数（latents）を再デノイズします。呼び出し側は、他の LTX 2段階パイプラインと同様にステージを組み合わせます。すなわち、このパイプライン、LTX2LatentUpsamplePipeline、再びこのパイプライン、そして各時間ラウンドごとに LTX2DFRTemporalRefinePipeline を実行します。

スロットは1ピクセルフレームを取得するために1フレーム分の潜在トークンを消費するため、その位置での実効的な時間方向の圧縮が緩和されます。これにより、周囲の映像は補間されたフレームではなく、真に新しいフレームを条件として生成されます。スロットの位置は、VAEの時間方向の境界（24ピクセルフレームまたは32ピクセルフレームのうち、リクエストへのパディングが少ない方）に整列されたセグメントグリッドから決定されます。キャンバスは内部でセグメントの整数倍にパディングされ、output_type="latent" はそのパディング済みグリッドを返すため、パディング上のスロットが破棄されることはありません。VAEデコードの前に trim_canvas でトリミングしてください。

この処理には、use_keyframes_abs_pos_embedding を設定した config を持つ transformer が必要です。この設定により、単一ピクセルフレームの latents に学習済み embedding が付与されます。LTX-2.5 のチェックポイントにはこれが同梱されていますが、それより古いバージョンでは、解釈できないトークンにトークン予算を消費するのを避けるため、パイプラインは例外を送出します。

追加トークンの予算について: 各スロットが1フレーム分の潜在フレームを追加するため、ステージ2は同等の2段階蒸留パスよりも長いシーケンスを実行します — 1024x1536 / 121フレームでは+31% (24576 -> 32256トークン、24フレームのセグメントグリッド上で5スロット)。ピーク活性化メモリはこれに比例して増加するため、通常の蒸留レシピでギリギリ収まる解像度でも、DFR下ではenable_sequential_cpu_offload、vae.enable_tiling()、またはより小さいキャンバスが必要になる場合があります。

Composition は keyframes および keyframe_positions に対して return_dict=True を使用します(return_dict=False の場合は、同じ4つのフィールドがタプルとして返されます)。

以下の完全なレシピが、スタートに最適なものです: 1088×1920 の画像から動画への変換、1 回の x2 時間方向リファイン、およびステージ 2 での x2 空間方向ディテール化 IC-LoRA。

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 は最終出力ではなく、このパスのものです。ステージ 1 は 1080p キャンバスの半分（544×960）で実行され、ステージ 2 は 1088×1920 で実行されます。それぞれは VAE の空間圧縮比（LTX-2.5 では単一パスの場合 32、ステージ 1 が 1080p の半分である場合 64）で割り切れる必要があります。そのため、1080p は 1920×1088、4K は 3840×2176 となっています。各パスは固定の蒸留スケジュール（sigmas）を実行するため、num_inference_steps は存在しません。また、蒸留スケジュールはガイダンスなしで学習されているため、negative_prompt や guidance_scale も存在しません。同梱されているオーディオはステージ 1 のものです。後続のパスでもオーディオストリームは実行されますが、これはビデオブランチがクロスモーダルアテンションを使用できるようにするためであり、波形自体はステージ 1 以降は精錬されません。

空間ディテール処理。 2x 空間ディテール処理 IC-LoRA を、ステージ 1 の後に名前付きアダプターとして読み込み、ステージ 2 のみで有効にします（set_adapters(["detailing"], adapter_weights=[0.5])）。これにより、ステージ 2 はステージ 1 の半解像度潜在変数を reference_latents として参照します。ステージ 1 と時間軸ラウンドでは、アダプターを無効にします。ステージ 1 より前に LoRA を読み込んだ場合、transformer.disable_adapters() で無効化できますが、set_adapters では再有効化されません。ステージ 2 の前に transformer.enable_adapters() を呼び出すか、レシピに従ってステージ 1 の後に重みをロードしてください。reference_downscale_factor（デフォルトは 2）は、参照トークンの空間座標をターゲットの座標系にスケーリングします。

時間方向の精錬。 LTX2DFRTemporalRefinePipeline は 1 ラウンドで、時間方向にアップサンプリングし、キーフレームの継ぎ目でタイル分割し、LTXEulerAncestralRFScheduler（eta=0.5）で祖先デノイズを実行し、後続タイルのリードインを破棄して結合し、キャリーキーフレームのバッグをマージします。このスケジューラは自分で構築してください。他のスケジューラではラウンドが拒否されます。決定論的なステップは最後まで実行され、より柔らかいキャンバスを返すだけになるためです。ラウンドごとにパイプラインを 1 回呼び出し、round_index を渡して 2 倍 / 4 倍のループを回します。ラウンドの終了後、keyframe_positions は元の num_frames から再導出できなくなるため、そのまま引き継ぐ必要があります。各タイルには、凍結されたステージ 1 のオーディオのうち、そのタイル自身の再生ウィンドウをカバーするスライスが渡されます。source_seconds は ステージ 1 の長さであり、ラウンド間で固定されるため、後続のラウンドではデフォルト値を受け取るのではなく、明示的に渡す必要があります。

とは無関係に、再生が30を超える場合、のfpsは常に60です。RoPEの時間はpixel_frame / fpsであるため、120 fpsの時間基準では、学習時の分布と比較して各トークンの時間的スパンが半分になり、48 fpsでは引き伸ばされます。両者は60であると偽り、デコードされたフレームを再生レートで扱います。

第3の空間ステージ。これらを組み合わせます。第4のパイプラインはありません。動画のみを空間的にアップサンプリングし、RGBでキャリーキーフレームを再構築します（decode → Lanczos ×2 → encode、rebuild_epilogue_keyframes()経由。エピローグキーフレームを潜在空間でアップサンプリングしないこと）。その後、以下を実行します：

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

2つの軸は異なる方法で継ぎ目処理されています。空間的な境界のどちらの側にも既知の答えが存在しないため、これらの重複部分は台形重みでブレンドされます。時間方向のタイルは、最終的なリファインラウンドのキーフレームの継ぎ目で切り分けられます。

拡散デコーダーによるデコーディング。 最大のディテール忠実度を確保するには、output_type="latent" のまま、（すでに正規化解除済みで、場合によっては trim_canvas が適用済みの）潜変数を LTX2VideoDiffusionDecodePipeline に渡します。

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

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)

Apache License, Version 2.0（「ライセンス」）の下でライセンスされています。

このファイルは、ライセンスに準拠した場合にのみ使用できます。

ライセンスのコピーは以下から入手できます

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

適用される法律で要求される場合、または書面による合意がある場合を除き、ソフトウェア

ライセンスに基づき配布される本ソフトウェアは、「現状のまま」

明示的または黙示的を問わず、いかなる種類の保証や条件も付随しません。

権限を管理する特定の言語については、ライセンスを参照してください。

ライセンスの下での制限。-->

LTX-2

2段階の生成

蒸留済みチェックポイントの生成

条件付きパイプライン生成

マルチモーダルガイダンス

プロンプトの強化

LTX-2.5

LTX-2.5の2段階生成

蒸留されたLoRAを用いたステージ2

畳み込みおよび拡散デコーディング

フル / SFT transformer

LTX-2.5 用のプロンプト強化

LTX-2.5の自動再生時間

LTX-2.5のモーション速度

LTX-2.5 モジュラー

LTX-2.5 向けの Diffusion Fidelity Rendering (DFR)

LTX2Pipeline[[diffusers.LTX2Pipeline]]

diffusers.LTX2Pipeline[[diffusers.LTX2Pipeline]]

call[[diffusers.LTX2Pipeline.call]]

encode_prompt[[diffusers.LTX2Pipeline.encode_prompt]]

enhance_prompt[[diffusers.LTX2Pipeline.enhance_prompt]]

LTX2ImageToVideoPipeline[[diffusers.LTX2ImageToVideoPipeline]]

diffusers.LTX2ImageToVideoPipeline[[diffusers.LTX2ImageToVideoPipeline]]

call[[diffusers.LTX2ImageToVideoPipeline.call]]

encode_prompt[[diffusers.LTX2ImageToVideoPipeline.encode_prompt]]

enhance_prompt[[diffusers.LTX2ImageToVideoPipeline.enhance_prompt]]

LTX2ConditionPipeline[[diffusers.LTX2ConditionPipeline]]

diffusers.LTX2ConditionPipeline[[diffusers.LTX2ConditionPipeline]]

call[[diffusers.LTX2ConditionPipeline.call]]

apply_first_frame_conditioning[[diffusers.LTX2ConditionPipeline.apply_first_frame_conditioning]]

encode_prompt[[diffusers.LTX2ConditionPipeline.encode_prompt]]

enhance_prompt[[diffusers.LTX2ConditionPipeline.enhance_prompt]]

prepare_latents[[diffusers.LTX2ConditionPipeline.prepare_latents]]

preprocess_conditions[[diffusers.LTX2ConditionPipeline.preprocess_conditions]]

trim_conditioning_sequence[[diffusers.LTX2ConditionPipeline.trim_conditioning_sequence]]

LTX2DFRPipeline[[diffusers.LTX2DFRPipeline]]

diffusers.LTX2DFRPipeline[[diffusers.LTX2DFRPipeline]]

call[[diffusers.LTX2DFRPipeline.call]]

denoise[[diffusers.LTX2DFRPipeline.denoise]]

encode_conditions[[diffusers.LTX2DFRPipeline.encode_conditions]]

encode_prompt[[diffusers.LTX2DFRPipeline.encode_prompt]]

enhance_prompt[[diffusers.LTX2DFRPipeline.enhance_prompt]]

prepare_latents[[diffusers.LTX2DFRPipeline.prepare_latents]]

preprocess_conditions[[diffusers.LTX2DFRPipeline.preprocess_conditions]]

rebuild_epilogue_keyframes[[diffusers.LTX2DFRPipeline.rebuild_epilogue_keyframes]]

trim_conditioning_sequence[[diffusers.LTX2DFRPipeline.trim_conditioning_sequence]]

LTX2DFRTemporalRefinePipeline[[diffusers.LTX2DFRTemporalRefinePipeline]]

diffusers.LTX2DFRTemporalRefinePipeline[[diffusers.LTX2DFRTemporalRefinePipeline]]

call[[diffusers.LTX2DFRTemporalRefinePipeline.call]]

denoise[[diffusers.LTX2DFRTemporalRefinePipeline.denoise]]

encode_conditions[[diffusers.LTX2DFRTemporalRefinePipeline.encode_conditions]]

encode_prompt[[diffusers.LTX2DFRTemporalRefinePipeline.encode_prompt]]

prepare_latents[[diffusers.LTX2DFRTemporalRefinePipeline.prepare_latents]]

preprocess_conditions[[diffusers.LTX2DFRTemporalRefinePipeline.preprocess_conditions]]

trim_conditioning_sequence[[diffusers.LTX2DFRTemporalRefinePipeline.trim_conditioning_sequence]]

upsample_latents[[diffusers.LTX2DFRTemporalRefinePipeline.upsample_latents]]

LTX2DFRPipelineOutput[[diffusers.LTX2DFRPipelineOutput]]

diffusers.LTX2DFRPipelineOutput[[diffusers.LTX2DFRPipelineOutput]]

LTX2LatentUpsamplePipeline[[diffusers.LTX2LatentUpsamplePipeline]]

diffusers.LTX2LatentUpsamplePipeline[[diffusers.LTX2LatentUpsamplePipeline]]

call[[diffusers.LTX2LatentUpsamplePipeline.call]]

adain_filter_latent[[diffusers.LTX2LatentUpsamplePipeline.adain_filter_latent]]

tone_map_latents[[diffusers.LTX2LatentUpsamplePipeline.tone_map_latents]]

LTX2VideoDiffusionDecodePipeline[[diffusers.LTX2VideoDiffusionDecodePipeline]]

diffusers.LTX2VideoDiffusionDecodePipeline[[diffusers.LTX2VideoDiffusionDecodePipeline]]

call[[diffusers.LTX2VideoDiffusionDecodePipeline.call]]

LTX2DurationHead[[diffusers.pipelines.ltx2.LTX2DurationHead]]

diffusers.pipelines.ltx2.LTX2DurationHead[[diffusers.pipelines.ltx2.LTX2DurationHead]]

forward[[diffusers.pipelines.ltx2.LTX2DurationHead.forward]]

predict_num_frames[[diffusers.pipelines.ltx2.LTX2DurationHead.predict_num_frames]]

LTX2PipelineOutput[[diffusers.pipelines.ltx2.LTX2PipelineOutput]]