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

|

raw

258 kB

Được cấp phép theo Giấy phép Apache, Phiên bản 2.0 (gọi là "Giấy phép");

bạn có thể không sử dụng tệp này ngoại trừ tuân thủ theo Giấy phép.

Bạn có thể nhận được một bản sao của Giấy phép tại

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

Trừ khi được yêu cầu bởi luật pháp có hiệu lực hoặc được thỏa thuận bằng văn bản, phần mềm

được phân phối theo Giấy phép được phân phối trên cơ sở

KHÔNG CÓ BẢO HÀNH HOẶC ĐIỀU KIỆN DƯỚI BẤT KỲ HÌNH THỨC NÀO, dù được nêu rõ hay ngụ ý.

Xem Giấy phép để biết ngôn ngữ cụ thể điều chỉnh các quyền và

giới hạn theo Giấy phép. -->

LTX-2

LTX-2 là một mô hình nền tảng dựa trên DiT, được thiết kế để tạo ra video và âm thanh đồng bộ trong một mô hình duy nhất. Nó tập hợp các khối xây dựng cốt lõi của việc tạo video hiện đại, với trọng số mở và tập trung vào việc thực thi thực tế, cục bộ.

Bạn có thể tìm thấy tất cả các checkpoint gốc của LTX-Video dưới tổ chức Lightricks.

Mã nguồn gốc của LTX-2 có thể được tìm thấy tại đây.

Tạo hai giai đoạn

Các giá trị mặc định của __call__ dùng chung cho LTX2Pipeline / LTX2ImageToVideoPipeline khớp với tham chiếu LTX-2.5 (num_inference_steps=30; num_frames là tùy chọn khi có duration_head, nếu không sẽ dùng giá trị dự phòng 121). Các ví dụ bên dưới cũng sử dụng các giá trị mặc định đó cho LTX-2.0/2.3.

Quy trình được khuyến nghị để đạt chất lượng tạo ra ở mức sản xuất, quy trình này bao gồm hai giai đoạn:

Giai đoạn 1: Tạo video ở độ phân giải đích bằng cách lấy mẫu khuếch tán với hướng dẫn không phân loại (CFG). Giai đoạn này tạo ra một chuỗi video nhiễu thấp nhất quán, tuân theo điều kiện văn bản/hình ảnh.
Giai đoạn 2: Nhân đôi kích thước đầu ra của Giai đoạn 1 và tinh chỉnh chi tiết bằng một mô hình LoRA đã được chưng cất để cải thiện độ trung thực và chất lượng hình ảnh. Giai đoạn 2 có thể áp dụng CFG nhẹ hơn để bảo toàn cấu trúc từ Giai đoạn 1 trong khi tăng cường kết cấu và độ sắc nét.

Cách sử dụng mẫu của pipeline hai giai đoạn từ văn bản sang video

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

Tạo checkpoint đã chưng cất

Đường ống tạo hai giai đoạn nhanh nhất sử dụng điểm kiểm tra đã chưng cất.

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

Điều kiện tạo Pipeline

Bạn có thể sử dụng LTX2ConditionPipeline để chỉ định điều kiện hình ảnh và/hoặc video tại các chỉ số latent tùy ý. Ví dụ, chúng ta có thể chỉ định cả điều kiện khung hình đầu và khung hình cuối để thực hiện tạo video từ khung hình đầu-cuối (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",
)

Bạn có thể sử dụng cả điều kiện hình ảnh và video:

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

Vì việc điều kiện hóa được thực hiện thông qua các khung tiềm ẩn, 8 khung trong không gian dữ liệu tương ứng với khung tiềm ẩn được chỉ định cho điều kiện hình ảnh sẽ có xu hướng tĩnh.

Hướng dẫn đa phương thức

Các pipeline LTX-2.X hỗ trợ hướng dẫn đa phương thức. Nó bao gồm ba thành phần, tất cả đều sử dụng quy tắc cập nhật theo phong cách CFG:

Classifier-Free Guidance (CFG): CFG tiêu chuẩn, trong đó đầu ra bị nhiễu ("yếu hơn") được tạo ra bằng cách sử dụng prompt âm.
Spatio-Temporal Guidance (STG): STG từ bỏ việc sử dụng đầu ra bị nhiễu tạo ra từ việc bỏ qua các thao tác self-attention và thay vào đó là thay thế bằng các giá trị attention. Ý tưởng là cách này tạo ra các video sắc nét hơn và tính nhất quán không-thời gian tốt hơn.
Hướng dẫn cách ly chế độ (Modality Isolation Guidance): chuyển hướng khỏi đầu ra bị nhiễu tạo ra từ việc vô hiệu hóa chú ý chéo giữa các chế độ (cross attention) (âm thanh-sang-video và video-sang-âm thanh). Hướng dẫn này đặc thù hơn cho các mô hình LTX-2.X, với ý tưởng rằng cách này tạo ra sự nhất quán tốt hơn giữa âm thanh và video được tạo ra.

Các tham số này được điều khiển bởi các đối số guidance_scale, stg_scale và modality_scale, và có thể được thiết lập riêng biệt cho video và âm thanh. Ngoài ra, đối với STG, cần chỉ định các chỉ số khối transformer mà tại đó self-attention bị bỏ qua thông qua đối số spatio_temporal_guidance_blocks. Các pipeline LTX-2.X cũng hỗ trợ guidance rescaling để giúp giảm hiện tượng quá phơi sáng, vốn có thể là một vấn đề khi các thang độ guidance được đặt ở giá trị cao.

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

Tăng cường Prompt

Các mô hình LTX-2.X nhạy cảm với phong cách viết prompt. Hãy tham khảo hướng dẫn viết prompt chính thức để có các khuyến nghị về cách viết một prompt tốt. Việc sử dụng tăng cường prompt, trong đó các prompt được cung cấp sẽ được tăng cường bằng text encoder của pipeline (mặc định là một mô hình Gemma 3) dựa trên một system prompt, cũng có thể cải thiện chất lượng mẫu. Thành phần pipeline tùy chọn processor cần phải có mặt để sử dụng tăng cường prompt. Bật tính năng này bằng enable_prompt_enhancement=True và một system_prompt (tùy chọn, khớp với các pipeline tham chiếu của 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 tái sử dụng các lớp LTX2Pipeline/LTX2VideoTransformer3DModel/AutoencoderKLLTX2Video/v.v. giống hệt như LTX-2.3 — không có lớp pipeline riêng biệt cho nó. Sự khác biệt mà người dùng nhìn thấy là text encoder: LTX-2.5 được ghép với checkpoint Gemma 4 (gemma4_unified) thay vì Gemma 3. Checkpoint này được tải tự động khi bạn gọi from_pretrained trên một checkpoint LTX-2.5 đã được chuyển đổi (thông qua các lớp Auto* của transformers), nên không cần thiết lập thêm gì ở thời điểm suy luận — chỉ cần trỏ from_pretrained đến một repo LTX-2.5 thay vì repo LTX-2.3.

Lightricks/LTX-2.5-Diffusers cung cấp cả hai transformer: DiT distilled trong transformer/, đây là nơi model_index.json trỏ tới, và DiT full/SFT trong transformer_full/, cần được nạp một cách tường minh (xem Full / SFT transformer). Thư mục scheduler/ của repo được cấu hình cho checkpoint distilled (use_dynamic_shifting=False, shift_terminal=None) để lịch sigma của nó được sử dụng đúng như đã cho. Mọi thứ cần cho two-stage generation cũng được cung cấp ở đó: một thư mục con latent_upsampler/ và LoRA distilled của giai đoạn 2, ltx-2.5-22b-distilled-lora-450-bf16.safetensors, ở gốc repo.

Suy luận đã chưng cất được điều khiển bởi một lịch sigma rõ ràng thay vì số bước, và chạy không có hướng dẫn (guidance_scale=1.0, do đó negative_prompt không được sử dụng). Việc truyền num_inference_steps thay vào đó sẽ cung cấp cho mô hình một lịch tuyến tính chung chung và âm thầm làm giảm chất lượng:

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

Tạo hai giai đoạn cho LTX-2.5

LTX-2.5 hỗ trợ cả hai biến thể hai giai đoạn, và DISTILLED_SIGMA_VALUES / STAGE_2_DISTILLED_SIGMA_VALUES là các lịch tham chiếu của nó:

Checkpoint đã chưng cất, cả hai giai đoạn — công thức tham chiếu cho transformer/ mặc định, và công thức được hiển thị bên dưới. Không có LoRA giai đoạn 2 nào được sử dụng, vì transformer đã được chưng cất; đây là Định dạng tạo checkpoint đã chưng cất với trọng số LTX-2.5.
Giai đoạn 1 Full/SFT + giai đoạn 2 LoRA đã chưng cất — Sinh hai giai đoạn như đã mô tả ở đầu trang này, sử dụng transformer_full/ và LoRA đi kèm. Xem bên dưới để biết những gì thay đổi.

Stage 1 chạy ở một nửa độ phân giải mục tiêu, upsampler nhân đôi độ phân giải đó, và stage 2 tinh chỉnh ở độ phân giải đầy đủ — cả video và audio, đều được reseed từ các latents của stage 1 tại noise_scale=STAGE_2_DISTILLED_SIGMA_VALUES[0]. Chiều cao và chiều rộng phải chia hết cho 64, vì stage 1 chia đôi mỗi trục và vẫn phải khớp với lưới không gian của VAE.

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

Khi độ dài được lấy từ duration head thay vì num_frames được chỉ định rõ, hãy để stage 1 quyết định và khôi phục độ dài thực tế từ các latents của nó ([B, C, F, H, W]) trước khi stage 2 chạy, thay vì dự đoán thêm một lần nữa:

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

Giai đoạn 2 với LoRA đã chưng cất

Để chạy Two-stages Generation thay vào đó — DiT full/SFT cho giai đoạn 1, LoRA distilled cho giai đoạn 2 — hãy xây dựng pipeline như trong Full / SFT transformer và tạo latents cho giai đoạn 1 bằng guidance stack đó. Hai điểm sau khác biệt so với LTX-2.0/2.3. LoRA nằm trong kho diffusers thay vì đặt cạnh các trọng số gốc, và việc lật scheduler diễn ra theo chiều ngược lại: LTX-2.5 đi kèm cấu hình scheduler distilled, do đó giai đoạn 1 là nơi bật dynamic shifting, và giai đoạn 2 tắt nó lại.

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
)

Bước upsample và lời gọi stage 2 không thay đổi so với công thức distilled ở trên: cùng sigmas=STAGE_2_DISTILLED_SIGMA_VALUES, cùng noise_scale, và guidance_scale=1.0, vì stage 2 đang chạy một mô hình distilled trong mọi trường hợp.

Giải mã tích chập và khuếch tán

LTX-2.5 cung cấp hai bộ giải mã video trên cùng một không gian ẩn, do đó các ẩn có thể hoán đổi cho nhau giữa chúng:

vae/ — VAE tích chập (AutoencoderKLLTX2Video). Đây là thành phần mà các pipeline dùng để giải mã, vì vậy mọi đoạn mã ở trên đã sử dụng nó, và đây là thành phần duy nhất trong hai thành phần hỗ trợ chia ô (pipe.vae.enable_tiling()), điều này thường giúp xử lý được độ phân giải cao.
diffusion_decoder/ — LTX2VideoDiffusionDecoderModel. Đây là một mô hình diffusion độc lập chứ không phải thành phần của pipeline, nên không được truyền dưới dạng vae: hãy chạy pipeline với output_type="latent" và truyền các latent sang LTX2VideoDiffusionDecodePipeline.

Việc mã hóa luôn đi qua vae/, do đó điều kiện hóa hình ảnh và video không bị ảnh hưởng bởi lựa chọn này.

Hai điều thay đổi khi bạn giải mã bằng diffusion decoder. output_type="latent" cũng bỏ qua vocoder, vì vậy âm thanh được trả về dưới dạng latents và phải được hoàn thiện thủ công, và bộ xử lý NATTEN thực sự là bắt buộc ở độ phân giải video:

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

Để kết hợp điều này với sinh hai giai đoạn, hãy yêu cầu giai đoạn 2 trả về output_type="latent" và giải mã kết quả đó.

decoder.enable_tiling() là cách giữ cho quá trình giải mã độ phân giải cao nằm trong bộ nhớ, tương tự như cách pipe.vae.enable_tiling() thực hiện cho VAE tích chập. Phần chiếm dụng bộ nhớ chủ yếu của quá trình giải mã — giai đoạn lấy mẫu lên cuối cùng và giai đoạn khuếch tán — sau đó sẽ chạy trên các ô chồng lấn được trộn lại với nhau, do đó bộ nhớ đỉnh được giới hạn bởi kích thước ô thay vì kích thước video. Tiling chỉ kích hoạt khi latent vượt quá một ô, và kích thước ô cùng phần chồng lấn có thể được tinh chỉnh thông qua các đối số tile_sample_min_* / tile_sample_stride_* (giá trị mặc định khớp với bản triển khai tham chiếu). Vì giai đoạn khuếch tán khử nhiễu từng ô riêng biệt, một bản giải mã dạng ô sẽ không tái tạo chính xác kết quả của bản giải mã không chia ô.

Trên một card duy nhất, cũng đáng để di chuyển pipeline sang một bên trước khi giải mã (pipe.to("cpu") và torch.cuda.empty_cache(), sau khi đã lưu lại pipe.scheduler và output_sampling_rate của vocoder), vì bộ giải mã cần không gian riêng. Xem LTX2VideoDiffusionDecoderModel để biết về các backend attention, chi tiết tiling và các hành vi khác của bộ giải mã.

Transformer Full / SFT

transformer_full/ không được tham chiếu bởi model_index.json, do đó cần nạp nó một cách tường minh. Nó cũng cần một scheduler khác và một bộ guidance thực sự: scheduler/ đi kèm được cấu hình cho checkpoint distilled, và các giá trị mặc định của guidance là các giá trị chung chung từ thời LTX-2.0, khiến một lần chạy SFT của LTX-2.5 bị thiếu guidance rõ rệt mà không gây ra bất kỳ cảnh báo nào. Các khuyến nghị về Multimodal Guidance áp dụng nguyên vẹn ở đây, bao gồm cả STG trên block 28:

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

Bỏ sigmas ở đây — DiT đầy đủ lấy lịch trình từ scheduler.

Tăng cường Prompt cho LTX-2.5

Việc sử dụng prompt enhancement được khuyến nghị mạnh mẽ cho LTX-2.5; hãy truyền enable_prompt_enhancement=True để bật tính năng này (giống như các pipeline tham chiếu của Lightricks). Khác với LTX-2.0/2.3, nơi cùng một checkpoint text encoder đóng vai trò kép là enhancer (xem Prompt Enhancement ở trên), text encoder được fine-tune của LTX-2.5 không được huấn luyện cho enhancement. Thay vào đó, enhancement sử dụng một checkpoint google/gemma-4-E2B-it riêng biệt, có sẵn. Nạp nó vào các thành phần tùy chọn prompt_enhancer/processor của pipeline, sau đó bật enhancement — pipeline mặc định sử dụng LTX2_5_T2V_DEFAULT_SYSTEM_PROMPT và công thức Gemma 4 (do_sample=False, no_repeat_ngram_size=5, max_new_tokens=600). Truyền một system_prompt= rõ ràng để ghi đè:

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

Điều tương tự cũng áp dụng cho image-to-video với LTX2ImageToVideoPipeline: đặt pipe.prompt_enhancer/pipe.processor theo cách tương tự và truyền enable_prompt_enhancement=True (sử dụng LTX2_5_I2V_DEFAULT_SYSTEM_PROMPT, điều kiện hóa dựa trên cả hình ảnh tham chiếu và text prompt) — một lần nữa, không cần system_prompt= trừ khi bạn muốn ghi đè lên nó.

Thời lượng tự động cho LTX-2.5

Các checkpoint của LTX-2.5 đi kèm một duration_head nhỏ, dự đoán độ dài của cảnh được mô tả, từ cùng đầu ra text-connector mà transformer được điều kiện hóa. Khi pipeline được nạp có thành phần này, num_frames sẽ được tự động dự đoán theo mặc định — hãy bỏ qua tham số này và để mô hình tự chọn độ dài:

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

Để tự đặt độ dài, hãy truyền num_frames một cách tường minh. Một số nguyên luôn được ưu tiên hơn phần đầu:

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

Pipelines được nạp từ checkpoint LTX-2.0 hoặc LTX-2.3 không có duration head và giữ nguyên mặc định trước đó là 121 khung hình, do đó điều này không thay đổi gì đối với chúng.

Truyền min_seconds / max_seconds để ràng buộc dự đoán. Dự đoán thô sẽ bị kẹp vào khoảng đó, sau đó được chuyển đổi thành khung hình:

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

Số khung hình dự đoán được làm tròn theo lưới thời gian nhân quả của VAE (8k + 1), do đó thời lượng thực tế bị lượng tử hóa — khoảng 0,33 giây mỗi bước ở 24 fps — và thay đổi theo frame_rate, vì đầu ra dự đoán số giây thay vì số khung hình. min_seconds phải nhỏ hơn nghiêm ngặt so với max_seconds. Các giới hạn này bị bỏ qua khi num_frames được đặt rõ ràng.

Các giới hạn hẹp hơn một bước lưới có thể không thể thỏa mãn chính xác: ở 24 fps, [1.0s, 1.02s] được chuyển đổi thành [24, 24] khung hình, và 24 không phải là 8k + 1. Điểm lưới gần nhất sẽ được sử dụng và một cảnh báo được ghi lại, do đó độ dài trả về có thể nằm ngay ngoài các giới hạn chặt chẽ như vậy.

Để kiểm tra một dự đoán mà không tạo video, hãy gọi trực tiếp phần đầu (head). Mọi thứ cần thiết đều là công khai:

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

Việc chuyển đổi checkpoint 2.5 sẽ tự động lấy phần head với --full_pipeline, hoặc riêng lẻ với --duration_head. Các checkpoint trước 2.5 không có trọng số như vậy, và quá trình chuyển đổi sẽ bỏ qua thành phần này thay vì báo lỗi.

Tốc độ chuyển động cho LTX-2.5

LTX-2 đặt mỗi token video trên một trục thời gian tính bằng giây, mặc định được suy ra từ frame_rate, tức là tốc độ phát. motion_speed (mặc định là 1.0) tách biệt hai yếu tố này: trục thời gian được điều kiện hóa bởi frame_rate / motion_speed, trong khi độ dài âm thanh, duration head và video được trả về vẫn tuân theo frame_rate. Với frame_rate=24.0 và motion_speed=0.2, mô hình được thông báo rằng hành động được ghi lại ở 120 fps và kết quả được phát ở 24 fps, tạo ra hiệu ứng chậm 5 lần.

Mô hình cơ sở được huấn luyện ở khoảng 24/25/30/60 fps, do đó các tốc độ khác xa 1.0 chỉ có ý nghĩa khi dùng kèm một adapter được huấn luyện riêng cho chúng, chẳng hạn Lightricks/LTX-2.5-22b-LoRA-Slow-Motion-Control (có kiểm soát truy cập: hãy chấp nhận giấy phép của nó trên Hub trước). Nếu không có motion_speed, LoRA đó sẽ được nạp như một LoRA thông thường và không cung cấp bất kỳ khả năng kiểm soát chuyển động nào. Thẻ mô hình đề xuất các tốc độ 1.0, 0.5, 0.2, 0.1, 0.05 và 0.025, với cường độ LoRA là 1.0. Hãy bỏ các từ chỉ tốc độ ("slow motion", "high fps") ra khỏi prompt và tái sử dụng cùng một caption cho các tốc độ khác nhau, vì chỉ motion_speed mới quyết định hiệu ứng.

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

Cả hai đoạn clip đều dài 121 khung hình (khoảng 5 giây ở 24 fps) và chỉ tốc độ của chuyển động thay đổi. Trong sinh hai giai đoạn, hãy truyền cùng một motion_speed cho cả hai giai đoạn. Giai đoạn 2 khử nhiễu lại video, và nó sẽ hủy bỏ hiệu ứng chậm nếu chạy trên trục thời gian thực. Trình điều khiển tham chiếu thực hiện điều tương tự bằng cách bọc đối tượng giai đoạn mà cả hai lần chạy đều dùng chung.

motion_speed cũng là một đầu vào của các khối module LTX-2 / LTX-2.5, và nó được truyền vào pipeline module theo cách tương tự.

LTX-2.5 Modular

LTX-2.5 cũng có sẵn dưới dạng pipeline modular. Blockset mặc định sử dụng diffusion decoder và dự đoán thời lượng video khi num_frames bị bỏ qua. Nó áp dụng guidance riêng biệt cho video và audio thông qua các thành phần guider và audio_guider. Xem LTX2Guidance để biết các tham số guidance khả dụng. Mặc định, pipeline modular sẽ tải prompt enhancer và processor từ repo google/gemma-4-E2B-it. Dưới đây là một ví dụ modular 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",
)

Pipeline dạng module sẽ tự động chuyển đổi quy trình làm việc dựa trên các đầu vào được cung cấp. Ví dụ, nếu image được cung cấp, quy trình làm việc I2V sẽ được sử dụng:

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

Bạn có thể xem các workflow được hỗ trợ trong tài liệu của mỗi blockset (ví dụ: LTX2AutoBlocks, LTX25AutoBlocks).

Diffusion Fidelity Rendering (DFR) cho LTX-2.5

LTX2DFRPipeline đánh đổi thời gian thực thi để đổi lấy độ chi tiết. Mỗi lần gọi __call__ là một lượt khử nhiễu ở kích thước height × width: nó tạo ra video cùng các khung khóa dạng khung đơn pixel bổ sung, hoặc khử nhiễu lại các latent được cung cấp, có nguồn gốc từ các khung khóa đó. Người gọi sẽ kết hợp các giai đoạn theo cách tương tự như các pipeline hai giai đoạn khác của LTX — pipeline này, LTX2LatentUpsamplePipeline, lại pipeline này, sau đó là LTX2DFRTemporalRefinePipeline cho mỗi vòng lặp theo thời gian.

Một slot tốn một khung latent đầy đủ các token để mua một khung pixel, điều này làm nới lỏng mức nén thời gian hiệu dụng tại vị trí đó — do đó, video xung quanh được điều kiện hóa dựa trên các khung thực sự mới thay vì các khung nội suy. Các vị trí slot đến từ một lưới phân đoạn được căn chỉnh với biên thời gian của VAE (24 hoặc 32 khung pixel, tùy cái nào đệm ít hơn cho yêu cầu). Bức tranh được đệm đến một số nguyên các phân đoạn bên trong; output_type="latent" trả về lưới đã đệm đó để một slot trên phần đệm không bị loại bỏ. Cắt bằng trim_canvas trước khi giải mã VAE.

Điều này yêu cầu một transformer có config đặt use_keyframes_abs_pos_embedding, đánh dấu các latent của khung hình đơn pixel bằng một embedding đã học. Các checkpoint của LTX-2.5 được cung cấp kèm theo; pipeline sẽ gây lỗi với bất kỳ phiên bản cũ hơn thay vì tiêu tốn ngân sách token cho các token mà nó không thể diễn giải.

Dự trù ngân sách cho các token bổ sung: mỗi slot thêm một lượng tương đương một khung hình latent, do đó giai đoạn 2 chạy một chuỗi dài hơn so với lượt chạy hai giai đoạn đã chưng cất tương đương — tăng 31% ở độ phân giải 1024x1536 / 121 khung hình (24576 -> 32256 token, 5 slot trên lưới phân đoạn 24 khung hình). Bộ nhớ kích hoạt đỉnh tăng theo tỷ lệ đó, nên một độ phân giải vừa vặn với công thức chưng cất thông thường có thể cần enable_sequential_cpu_offload, vae.enable_tiling(), hoặc một khung hình nhỏ hơn dưới DFR.

Composition sử dụng return_dict=True cho keyframes và keyframe_positions (return_dict=False trả về bốn trường tương tự dưới dạng tuple).

Công thức đầy đủ bên dưới là công thức đáng để bắt đầu: tạo video từ ảnh kích thước 1088×1920, một vòng tinh chỉnh thời gian x2, và IC-LoRA chi tiết hóa không gian x2 ở giai đoạn 2.

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 và width là đường đi này, không phải đầu ra cuối cùng. Giai đoạn 1 chạy ở một nửa canvas 1080p (544×960); giai đoạn 2 ở 1088×1920. Mỗi đường đi phải chia hết cho tỷ lệ nén không gian của VAE (32 trên LTX-2.5 cho một đường đi đơn; 64 khi giai đoạn 1 là một nửa của 1080p). Đây là lý do 1080p là 1920×1088 và 4K là 3840×2176. Mỗi đường đi chạy một lịch trình chưng cất cố định (sigmas), vì vậy không có num_inference_steps; các lịch trình chưng cất được huấn luyện mà không có hướng dẫn, vì vậy cũng không có negative_prompt hay guidance_scale. Âm thanh được cung cấp là của giai đoạn 1 — các đường đi sau vẫn chạy một luồng âm thanh để nhánh video có chú ý liên phương thức; chính dạng sóng không được tinh chỉnh sau giai đoạn 1.

Chi tiết hóa không gian. Nạp IC-LoRA chi tiết hóa không gian 2x dưới một adapter có tên sau giai đoạn 1 và kích hoạt nó chỉ cho giai đoạn 2 (set_adapters(["detailing"], adapter_weights=[0.5])). Giai đoạn 2 sau đó sẽ chú ý đến latent bán độ phân giải của giai đoạn 1 như reference_latents. Giai đoạn 1 và các vòng thời gian chạy với adapter tắt. Nếu bạn nạp LoRA trước giai đoạn 1, transformer.disable_adapters() sẽ tắt nó, và set_adapters sẽ không bật lại — hãy gọi transformer.enable_adapters() trước giai đoạn 2, hoặc nạp trọng số sau giai đoạn 1 như trong công thức. reference_downscale_factor (mặc định 2) sẽ thu nhỏ tọa độ không gian của các token tham chiếu vào không gian tọa độ của mục tiêu.

Tinh chỉnh theo thời gian. LTX2DFRTemporalRefinePipeline là một vòng: lấy mẫu lên theo thời gian, chia tile tại các điểm nối keyframe, khử nhiễu tổ tiên bằng LTXEulerAncestralRFScheduler (eta=0.5), ghép lại bằng cách bỏ phần lead-in của tile sau, và hợp nhất túi keyframe mang theo. Hãy tự xây dựng scheduler đó — vòng sẽ bị từ chối nếu dùng bất kỳ thứ gì khác, vì một bước xác định sẽ chạy đến hoàn tất và chỉ trả về một canvas mềm hơn. Gọi pipeline một lần mỗi vòng; lặp cho 2x / 4x, truyền round_index. Sau một vòng, keyframe_positions không thể suy ra lại từ num_frames ban đầu và phải được truyền qua. Mỗi tile được giao phần slice của audio giai đoạn 1 đã đóng băng, bao phủ cửa sổ phát của chính nó. source_seconds là thời lượng giai đoạn 1 và giữ nguyên qua các vòng, nên các vòng sau phải truyền nó một cách tường minh thay vì dùng giá trị mặc định.

Tốc độ khung hình (fps) điều kiện luôn là 60 bất cứ khi nào tốc độ phát vượt quá 30, độc lập với quá trình ghép kênh (muxing): thời gian RoPE là pixel_frame / fps, do đó cơ sở thời gian 120 fps sẽ làm giảm một nửa khoảng thời gian của mỗi token so với phân phối đã huấn luyện, còn 48 fps sẽ làm giãn nó. Cả hai đều khai báo là 60 và xử lý các khung hình đã giải mã theo tốc độ phát.

Giai đoạn không gian thứ ba. Kết hợp nó; không có pipeline thứ tư. Upsample không gian chỉ video, xây dựng lại các keyframe carry trong RGB (decode → Lanczos ×2 → encode thông qua rebuild_epilogue_keyframes(); không bao giờ latent-upsample các keyframe epilogue), sau đó:

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

Hai trục được nối liền theo các cách khác nhau. Không có phía nào của một biên không gian chứa một câu trả lời đã biết, do đó các phần chồng lấn đó được trộn lẫn với trọng số hình thang. Các ô thời gian được cắt tại các đường nối khung hình chính của vòng tinh chỉnh cuối cùng.

Giải mã bằng bộ giải mã khuếch tán. Để đạt độ trung thực chi tiết tối đa, hãy giữ output_type="latent" và truyền các latent (đã được chuẩn hóa ngược, có thể đã được trim_canvas) cho 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)

Được cấp phép theo Giấy phép Apache, Phiên bản 2.0 (gọi là "Giấy phép");

bạn có thể không sử dụng tệp này ngoại trừ tuân thủ theo Giấy phép.

Bạn có thể nhận được một bản sao của Giấy phép tại

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

Trừ khi được yêu cầu bởi luật pháp có hiệu lực hoặc được thỏa thuận bằng văn bản, phần mềm

được phân phối theo Giấy phép được phân phối trên cơ sở

KHÔNG CÓ BẢO HÀNH HOẶC ĐIỀU KIỆN DƯỚI BẤT KỲ HÌNH THỨC NÀO, dù được nêu rõ hay ngụ ý.

Xem Giấy phép để biết ngôn ngữ cụ thể điều chỉnh các quyền và

giới hạn theo Giấy phép. -->

LTX-2

Tạo hai giai đoạn

Tạo checkpoint đã chưng cất

Điều kiện tạo Pipeline

Hướng dẫn đa phương thức

Tăng cường Prompt

LTX-2.5

Tạo hai giai đoạn cho LTX-2.5

Giai đoạn 2 với LoRA đã chưng cất

Giải mã tích chập và khuếch tán

Transformer Full / SFT

Tăng cường Prompt cho LTX-2.5

Thời lượng tự động cho LTX-2.5

Tốc độ chuyển động cho LTX-2.5

LTX-2.5 Modular

Diffusion Fidelity Rendering (DFR) cho LTX-2.5

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