MSR reference-to-video demo on LTX-2.5

.gitattributes

@@ -33,3 +33,12 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+examples/cyberpunk_1.jpg filter=lfs diff=lfs merge=lfs -text
+examples/cyberpunk_2.jpg filter=lfs diff=lfs merge=lfs -text
+examples/cyberpunk_3.jpg filter=lfs diff=lfs merge=lfs -text
+examples/forest_1.jpg filter=lfs diff=lfs merge=lfs -text
+examples/forest_2.jpg filter=lfs diff=lfs merge=lfs -text
+examples/forest_3.jpg filter=lfs diff=lfs merge=lfs -text
+examples/hallway_1.jpg filter=lfs diff=lfs merge=lfs -text
+examples/hallway_2.jpg filter=lfs diff=lfs merge=lfs -text
+examples/hallway_3.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,92 @@
----
-title: Ltx25 Multi Subject Reference
-emoji: 🐠
-colorFrom: green
-colorTo: purple
-sdk: gradio
-sdk_version: 6.26.0
-python_version: '3.12'
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: LTX-2.5 Multiple Subject Reference
+emoji: 🎭
+colorFrom: indigo
+colorTo: red
+sdk: gradio
+sdk_version: 6.26.0
+app_file: app.py
+python_version: "3.12"
+pinned: false
+short_description: Multi-subject reference images to video with LTX-2.5
+startup_duration_timeout: 1h
+models:
+  - LiconStudio/LTX-2.5-Multiple-Subject-Reference
+  - Lightricks/LTX-2.5-Diffusers
+tags:
+  - ltx-2.5
+  - ic-lora
+  - multi-subject
+  - reference-to-video
+  - image-to-video
+---
+
+# 🎭 LTX-2.5 · Licon MSR V1
+
+Up to **four subject stills plus one scene still**, named in the prompt (`Image 1:`,
+`Image 2:`, `Image 3: Scene, …`), become a video with native audio that keeps every subject's
+identity, clothing and the scene's look.
+
+[`LiconStudio/LTX-2.5-Multiple-Subject-Reference`](https://huggingface.co/LiconStudio/LTX-2.5-Multiple-Subject-Reference)
+(rank 128, apache-2.0) on [`Lightricks/LTX-2.5`](https://huggingface.co/Lightricks/LTX-2.5)
+(22B, distilled), run through upstream `diffusers`.
+
+## How it works
+
+Each reference still is repeated to 33 frames, VAE-encoded, given a **learned slot embedding**
+and placed at a **negative temporal position** — slot *i* of *N* sits at pixel-frame
+`-(N - i)`, i.e. just before frame 0. The video tokens then retrieve subject identity through
+the transformer's own self-attention. Reference tokens ride along at `conditioning_mask = 1`
+(fully clean) and are cropped off before decoding.
+
+| | |
+|---|---|
+| **Base** | [`Lightricks/LTX-2.5-Diffusers`](https://huggingface.co/Lightricks/LTX-2.5-Diffusers) — distilled 22B DiT + Gemma-4 text encoder + video/audio VAEs. `transformer_full/`, `prompt_enhancer/`, `diffusion_decoder/` and `temporal_latent_upsampler/` are excluded from the snapshot |
+| **Adapter** | `LTX-2.5-Licon-MSR-V1.safetensors`, strength 1.0. The file holds ComfyUI-style LoRA keys (only conversion: `diffusion_model.` → `transformer.`) *and* the non-LoRA `reference_slot_embedding` MLP, which is applied by hand |
+| **Code** | `diffusers` main @ `d57cecde` — `LTX2InContextPipeline`, subclassed in `msr.py` |
+| **Hardware** | ZeroGPU `xlarge` (96 GB). The 22B DiT plus the Gemma-4 encoder packs to ~71 GB, over the 48 GB slice |
+| **Output** | 1280×704 @ 24 fps by default (1664×960 available), with LTX-2.5's native audio |
+
+## Faithfulness to the reference implementation
+
+The author's reference is a ComfyUI graph:
+[`ComfyUI-LTX2.5-MSR`](https://github.com/liconstudio/ComfyUI-LTX2.5-MSR) plus
+`LTX2.5-MSR-sample-workflow.json`. Every node is reproduced:
+
+| ComfyUI node | Here |
+|---|---|
+| `ComfyUILTX25MSRICLoRALoader` | `split_slot_state` + `load_lora_weights`. The loader's metadata guards (`reference_token_order=prepend`, `reference_slot_time_offsets=pic1_based_negative_time`, `reference_downscale_factor=1`) hold for this checkpoint |
+| `_resize_reference` | `msr.msr_resize` — 1:1 port. Subject slots letterbox onto a **white** canvas unless the source already covers the target in the same aspect family (`landscape` ≥ 1.25, `portrait` ≤ 0.8, else `square`), in which case centre-crop-resize; the background slot always centre-crop-resizes. Bilinear, no antialias, matching `comfy.utils.common_upscale` |
+| `_slot_embedding` | `msr.slot_embedding` — `slot_id/16` → `[scaled, sin(scaled·f), cos(scaled·f)]` → SiLU MLP → 128-dim code, added broadcast over the channel axis of the *normalized* reference latent. ComfyUI's LTX2 VAE normalizes inside `encode` (`per_channel_statistics.normalize`), which is exactly diffusers' `_normalize_latents`, so the two spaces agree |
+| `LTXVAddGuide.append_keyframe(frame_idx=-(N-i))` | `coords[:, 0] += frame_offset / frame_rate` after `prepare_video_coords`. ComfyUI adds the offset in pixel-frames *before* the model's `× 1/frame_rate`; `prepare_video_coords` applies the same causal shift + `clamp(min=0)` and has already divided, so the two are algebraically identical |
+| guide `strength=1.0`, no pixel mask | ComfyUI's `_build_guide_self_attention_mask` returns `None` in that case, and diffusers builds no mask when `conditioning_attention_strength == 1.0` — the stacks agree |
+| `LTXVCropGuides` | `output_type="latent"` already returns only the base tokens |
+| `PromptRelayEncode` (one local segment) | A single prompt textbox. With one segment the relay's token mask covers everything, so it reduces to encoding `global + local` concatenated — which is what the UI's prompt box is |
+| two `ManualSigmas` + two `LTXVBaseSampler` | 8 distilled sigmas at half resolution → ×2 latent upsample → 3 sigmas at full resolution, one `torch.Generator` threaded through both stages, MSR guide re-attached in stage 2 as in the graph |
+| `CFGGuider` cfg=1 / `LTXVDualCFGGuider [1,1]` | every guidance knob explicitly zeroed (`guidance_scale=1.0`, `stg_scale=0.0`, `modality_scale=1.0`, `guidance_rescale=0.0`). The merged pipeline's defaults are SFT values and each adds a blended extra transformer pass that badly degrades distilled output |
+| `LTXVAudioVAEDecode` | audio is decoded and muxed into the mp4 |
+
+## Deviations
+
+* **Resolution.** The workflow renders 1664×960 × 361 frames (15 s). The default here is
+  1280×704 × 97 frames (4 s) so a run fits comfortably in a visitor's ZeroGPU quota; both the
+  workflow geometry and 8 s are selectable under **Advanced**.
+* **Tiled VAE decode.** The final decode is tiled (untiled it wants >100 GB). Reference
+  encoding is *not* tiled, matching the node's `use_tiled_encode=False`, with a tiled fallback
+  only if it would OOM.
+* `use_keyframes_abs_pos_embedding` is `True` in the transformer config, and ComfyUI applies
+  that marker to first-frame tokens. `LTX2InContextPipeline` never passes
+  `video_keyframes_mask`, so it is skipped — but the parameter is zero-initialised in the base
+  checkpoint and the LoRA does not train it, so the difference is exactly zero.
+
+## Examples
+
+The three examples are the author's own validation references and prompts, taken verbatim from
+[`validition_V1/`](https://huggingface.co/LiconStudio/LTX-2.5-Multiple-Subject-Reference/tree/main/validition_V1)
+in the model repo (`03`, `06`, `07` — the three shown on the model card), downscaled to 1280 px
+and re-encoded as JPEG. The model repo is apache-2.0.
+
+## Licenses
+
+Adapter: apache-2.0. Base model: the
+[LTX-2 Community License](https://huggingface.co/Lightricks/LTX-2.5).

app.py

@@ -0,0 +1,522 @@
+"""LTX-2.5 · Licon MSR V1 — multi-subject reference-to-video on ZeroGPU.
+
+Up to five reference stills (four subject slots + one scene slot) plus a prompt that names
+them ("Image 1: …", "Image 2: …") produce a video with native audio, keeping each subject's
+identity, clothing and the scene's look.
+
+The author's reference implementation is a ComfyUI graph
+(https://github.com/liconstudio/ComfyUI-LTX2.5-MSR + `LTX2.5-MSR-sample-workflow.json`);
+`msr.py` is a 1:1 port of the custom node's encoder onto `LTX2InContextPipeline`.
+"""
+
+import os
+
+os.environ.setdefault("PYTORCH_ALLOC_CONF", "backend:cudaMallocAsync")
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "backend:cudaMallocAsync")
+
+import spaces  # noqa: E402  — must precede torch / any CUDA-touching import
+
+import random  # noqa: E402
+import tempfile  # noqa: E402
+import time  # noqa: E402
+
+import gradio as gr  # noqa: E402
+import numpy as np  # noqa: E402
+import PIL.Image  # noqa: E402
+import torch  # noqa: E402
+from huggingface_hub import hf_hub_download, snapshot_download  # noqa: E402
+from safetensors.torch import load_file  # noqa: E402
+
+from diffusers import LTX2LatentUpsamplePipeline  # noqa: E402
+from diffusers.pipelines.ltx2.latent_upsampler import LTX2LatentUpsamplerModel  # noqa: E402
+from diffusers.pipelines.ltx2.utils import (  # noqa: E402
+    DISTILLED_SIGMA_VALUES,
+    STAGE_2_DISTILLED_SIGMA_VALUES,
+)
+from diffusers.utils import encode_video  # noqa: E402
+
+from msr import LTX25MSRPipeline, build_references, split_slot_state  # noqa: E402
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+BASE_ID = "Lightricks/LTX-2.5-Diffusers"
+LORA_ID = "LiconStudio/LTX-2.5-Multiple-Subject-Reference"
+LORA_FILE = "LTX-2.5-Licon-MSR-V1.safetensors"
+
+FRAME_RATE = 24.0
+MAX_SEED = 2**31 - 1
+MAX_TEXT_TOKENS = 1024
+
+# The workflow's two ManualSigmas nodes, which are exactly diffusers' distilled schedules.
+STAGE_1_SIGMAS = DISTILLED_SIGMA_VALUES
+STAGE_2_SIGMAS = STAGE_2_DISTILLED_SIGMA_VALUES
+
+# Stage 1 runs at half of each of these, then a x2 latent upsample feeds stage 2.
+RESOLUTIONS = {
+    "1280 × 704 · 16:9": (1280, 704),
+    "1664 × 960 · 16:9 (workflow, slower)": (1664, 960),
+    "704 × 1280 · 9:16 portrait": (704, 1280),
+    "960 × 960 · 1:1": (960, 960),
+}
+DEFAULT_RESOLUTION = "1280 × 704 · 16:9"
+DEFAULT_SECONDS = 4.0
+DEFAULT_REFERENCE_FRAMES = 33  # the workflow's `reference_frames`
+
+print("[msr] downloading LTX-2.5 (diffusers)...", flush=True)
+# `from_pretrained` derives allow-patterns from every model-like file in the repo, so it would
+# pull both DiTs and both shardings of the distilled one (~114 GB). Snapshot explicitly instead;
+# prompt_enhancer / diffusion_decoder / temporal_latent_upsampler are not components of the
+# in-context pipeline and are pure download + VRAM waste here.
+MODEL_DIR = snapshot_download(
+    BASE_ID,
+    ignore_patterns=[
+        "transformer_full/*",
+        "transformer/*-of-00008*",
+        "prompt_enhancer/*",
+        "diffusion_decoder/*",
+        "temporal_latent_upsampler/*",
+    ],
+    token=HF_TOKEN,
+    max_workers=8,
+)
+LORA_PATH = hf_hub_download(LORA_ID, LORA_FILE, token=HF_TOKEN)
+
+print("[msr] building pipeline...", flush=True)
+pipe = LTX25MSRPipeline.from_pretrained(
+    MODEL_DIR, prompt_enhancer=None, processor=None, dtype=torch.bfloat16
+)
+latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained(
+    MODEL_DIR, subfolder="latent_upsampler", dtype=torch.bfloat16
+)
+
+# The checkpoint carries two different things under one `diffusion_model.` prefix: rank-128 LoRA
+# tensors (diffusers module paths, so a prefix swap is the whole conversion) and the learned
+# `reference_slot_embedding` MLP, which is not a LoRA and is applied by hand in `msr.py`.
+_raw = load_file(LORA_PATH)
+_slot_state, _lora_raw = split_slot_state(_raw)
+_lora_sd = {k.replace("diffusion_model.", "transformer.", 1): v for k, v in _lora_raw.items()}
+del _raw, _lora_raw
+pipe.load_lora_weights(_lora_sd, adapter_name="msr")
+pipe.set_adapters(["msr"], [1.0])
+del _lora_sd
+pipe.msr_slot_state = _slot_state
+print(
+    f"[msr] LoRA applied (strength 1.0); slot-embedding keys: {sorted(_slot_state)}",
+    flush=True,
+)
+
+# ZeroGPU: module scope + eager .to("cuda"). The backend packs the weights to disk at startup
+# and streams them into VRAM on the first @spaces.GPU entry.
+pipe.to("cuda")
+latent_upsampler.to("cuda")
+pipe.vae.enable_tiling()  # stage-2 decode alone would want >100 GB untiled
+
+upsample_pipe = LTX2LatentUpsamplePipeline(vae=pipe.vae, latent_upsampler=latent_upsampler)
+AUDIO_SR = pipe.vocoder.config.output_sampling_rate
+print("[msr] ready", flush=True)
+
+
+# ------------------------------------------------------------------------------------------
+# helpers
+# ------------------------------------------------------------------------------------------
+def _plan(resolution: str, seconds: float, reference_frames: int, num_refs: int):
+    """Resolve UI values into geometry plus a stage-2 token count (the cost driver)."""
+    width, height = RESOLUTIONS.get(resolution, RESOLUTIONS[DEFAULT_RESOLUTION])
+    num_frames = max(25, int(round(float(seconds) * FRAME_RATE)) // 8 * 8 + 1)
+    ref_keep = max(1, ((int(reference_frames) - 1) // 8) * 8 + 1)
+    latent_frames = (num_frames - 1) // 8 + 1
+    ref_latent_frames = (ref_keep - 1) // 8 + 1
+    tokens = (latent_frames + num_refs * ref_latent_frames) * (height // 32) * (width // 32)
+    return width, height, num_frames, ref_keep, tokens
+
+
+def _count_refs(*images) -> int:
+    return max(1, sum(1 for image in images if image is not None))
+
+
+def gpu_duration(
+    prompt=None,
+    subject_1=None,
+    subject_2=None,
+    scene_image=None,
+    subject_3=None,
+    subject_4=None,
+    resolution=DEFAULT_RESOLUTION,
+    seconds=DEFAULT_SECONDS,
+    reference_frames=DEFAULT_REFERENCE_FRAMES,
+    *_args,
+    **_kwargs,
+):
+    """Scale the ZeroGPU reservation with the stage-2 sequence length.
+
+    Sized from the measured 1280x704 / 97-frame / 3-reference run and extrapolated with an
+    n^1.4 attention term. Kept as tight as the measurement allows: `duration` is charged
+    against every visitor's daily quota.
+    """
+    num_refs = _count_refs(subject_1, subject_2, subject_3, subject_4, scene_image)
+    *_geom, tokens = _plan(resolution, seconds, reference_frames, num_refs)
+    return int(min(400, 60 + 130 * (tokens / 24640.0) ** 1.4))
+
+
+def _write_video(frames, path: str, audio=None) -> None:
+    frames = np.asarray(frames)
+    if frames.dtype == np.uint8:
+        frames = frames.astype(np.float32) / 255.0
+    kwargs = {}
+    if audio is not None:
+        kwargs = dict(audio=audio, audio_sample_rate=AUDIO_SR)
+    encode_video(frames, fps=FRAME_RATE, output_path=path, **kwargs)
+
+
+def _as_pil(image):
+    if image is None:
+        return None
+    if isinstance(image, PIL.Image.Image):
+        return image.convert("RGB")
+    if isinstance(image, np.ndarray):
+        return PIL.Image.fromarray(image.astype(np.uint8)).convert("RGB")
+    return PIL.Image.open(image).convert("RGB")
+
+
+# ------------------------------------------------------------------------------------------
+# generation
+# ------------------------------------------------------------------------------------------
+@spaces.GPU(duration=gpu_duration, size="xlarge")
+def generate(
+    prompt: str,
+    subject_1,
+    subject_2,
+    scene_image,
+    subject_3=None,
+    subject_4=None,
+    resolution: str = DEFAULT_RESOLUTION,
+    seconds: float = DEFAULT_SECONDS,
+    reference_frames: int = DEFAULT_REFERENCE_FRAMES,
+    seed: int = 42,
+    randomize_seed: bool = True,
+):
+    """Generate a video with audio whose subjects and scene come from the reference stills.
+
+    Args:
+        prompt: describe each reference on its own line ("Image 1: …", "Image 2: …",
+            "Image 3: Scene, …"), then the shot itself — action, camera moves, dialogue.
+        subject_1: reference still for subject slot 1. Required.
+        subject_2: reference still for subject slot 2, or empty.
+        scene_image: reference still for the scene / background slot, or empty. Unlike the
+            subject slots it is centre-cropped rather than letterboxed.
+        subject_3: reference still for subject slot 3, or empty.
+        subject_4: reference still for subject slot 4, or empty.
+        resolution: final output resolution; stage 1 samples at half of it.
+        seconds: video length in seconds at 24 fps.
+        reference_frames: how many frames each still is repeated to before VAE encoding
+            (the ComfyUI node's `reference_frames`; 33 is the workflow value).
+        seed: RNG seed.
+        randomize_seed: pick a fresh random seed instead of using `seed`.
+
+    Returns:
+        The mp4 path and a one-line run summary.
+    """
+    started = time.perf_counter()
+
+    if not (prompt or "").strip():
+        raise gr.Error("A prompt is required.")
+    if subject_1 is None:
+        raise gr.Error("At least one reference image is required (Subject 1).")
+
+    # The node collects pic1..pic4 then background, skipping empties, so the scene slot always
+    # takes the last slot id and each slot lands at pixel-frame -(num_slots - index).
+    subjects = [_as_pil(x) for x in (subject_1, subject_2, subject_3, subject_4)]
+    subjects = [x for x in subjects if x is not None]
+    scene = _as_pil(scene_image)
+    images = subjects + ([scene] if scene is not None else [])
+    flags = [False] * len(subjects) + ([True] if scene is not None else [])
+    references = build_references(images, flags)
+
+    width, height, num_frames, ref_keep, tokens = _plan(
+        resolution, seconds, reference_frames, len(references)
+    )
+    pipe.msr_reference_frames = ref_keep
+
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    generator = torch.Generator("cuda").manual_seed(int(seed))
+
+    # One Gemma pass, reused by both stages (the 12B encoder is far too expensive to run twice).
+    prompt_embeds, prompt_mask, _, _ = pipe.encode_prompt(
+        prompt=[prompt],
+        negative_prompt=None,
+        do_classifier_free_guidance=False,
+        num_videos_per_prompt=1,
+        max_sequence_length=MAX_TEXT_TOKENS,
+        device=pipe._execution_device,
+    )
+
+    shared = dict(
+        prompt=None,
+        prompt_embeds=prompt_embeds,
+        prompt_attention_mask=prompt_mask,
+        negative_prompt=None,
+        frame_rate=FRAME_RATE,
+        # Distilled checkpoint (SimpleDenoiser): every guidance knob is off, matching the
+        # workflow's cfg=1 CFGGuider / DualCFGGuider [1, 1]. The merged pipeline's defaults are
+        # SFT values and each one adds a blended extra transformer pass that wrecks the output.
+        guidance_scale=1.0,
+        audio_guidance_scale=1.0,
+        stg_scale=0.0,
+        audio_stg_scale=0.0,
+        modality_scale=1.0,
+        audio_modality_scale=1.0,
+        guidance_rescale=0.0,
+        audio_guidance_rescale=0.0,
+        spatio_temporal_guidance_blocks=None,
+        reference_downscale_factor=1,
+        conditioning_attention_strength=1.0,
+        generator=generator,
+        return_dict=False,
+    )
+
+    print(
+        f"[gen] {len(references)} slot(s) · {width}x{height} · {num_frames}f · "
+        f"ref {ref_keep}f · ~{tokens} stage-2 tokens · seed {seed}",
+        flush=True,
+    )
+
+    # ---- stage 1: half resolution, 8 distilled sigmas, MSR reference tokens attached ----
+    stage_1 = time.perf_counter()
+    s1_latents, s1_audio = pipe(
+        reference_conditions=references,
+        height=height // 2,
+        width=width // 2,
+        num_frames=num_frames,
+        sigmas=STAGE_1_SIGMAS,
+        output_type="latent",
+        **shared,
+    )
+    print(f"[gen] stage 1 in {time.perf_counter() - stage_1:.1f}s", flush=True)
+
+    # ---- x2 spatial latent upsample. `output_type="latent"` has already cropped the
+    #      reference tokens off, which is what the graph's LTXVCropGuides does. ----
+    stage_up = time.perf_counter()
+    up_latents = upsample_pipe(latents=s1_latents, output_type="latent", return_dict=False)[0]
+    print(f"[gen] upsample in {time.perf_counter() - stage_up:.1f}s", flush=True)
+
+    # ---- stage 2: full resolution, 3 sigmas. The workflow re-attaches the MSR guide here,
+    #      so the reference tokens are encoded again at the larger size. ----
+    stage_2 = time.perf_counter()
+    video, audio = pipe(
+        reference_conditions=references,
+        height=height,
+        width=width,
+        num_frames=num_frames,
+        sigmas=STAGE_2_SIGMAS,
+        latents=up_latents,
+        audio_latents=s1_audio,
+        noise_scale=STAGE_2_SIGMAS[0],
+        output_type="np",
+        **shared,
+    )
+    print(f"[gen] stage 2 in {time.perf_counter() - stage_2:.1f}s", flush=True)
+
+    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as handle:
+        out_path = handle.name
+    _write_video(video[0], out_path, audio=audio[0].float().cpu() if audio is not None else None)
+
+    elapsed = time.perf_counter() - started
+    print(f"[gen] done in {elapsed:.1f}s", flush=True)
+    return out_path, (
+        f"{len(references)} reference slot(s) · {width}×{height} · "
+        f"{num_frames} frames ({num_frames / FRAME_RATE:.1f}s) · seed {seed} · {elapsed:.0f}s"
+    )
+
+
+# ------------------------------------------------------------------------------------------
+# examples (the author's own validation set, apache-2.0, from the model repo)
+# ------------------------------------------------------------------------------------------
+EXAMPLES = [
+    [
+        "Image 1: Beast-girl, fluffy orange cat ears and a long tail, big amber eyes, fluffy "
+        "orange short hair, cream-white puffy dress with a bow, bare legs and small boots, "
+        "Pixar-style 3D cartoon rendering, photorealistic render quality.\n"
+        "Image 2: Elf girl, long pointed ears, silver-white long hair, big emerald eyes, "
+        "leaf-green robe with a vine belt, barefoot, Pixar-style 3D cartoon rendering, "
+        "photorealistic render quality.\n"
+        "Image 3: Scene, enchanted forest clearing, foreground glowing mushrooms and "
+        "wildflowers, midground the two figures, background ancient trees with light shafts "
+        "through the leaves, warm dappled golden light, fireflies drifting, Pixar-style 3D "
+        "cartoon rendering, photorealistic render quality.\n\n"
+        "A clearing in an enchanted forest, warm dappled golden light falling through the "
+        "ancient canopy, fireflies drifting in the light shafts, glowing mushrooms and "
+        "wildflowers dotting the foreground. Figure 1 is the beast-girl, Figure 2 is the elf "
+        "girl. The two stand in the clearing, Pixar-style 3D cartoon rendering. The shot "
+        "starts on a medium two-shot, slow dolly push-in about 40%. Figure 1 curiously leans "
+        "in toward Figure 2, looking at her pointed ears, and asks: \"How are your ears so "
+        "pointy?\" Figure 2 smiles and answers: \"These are elf ears.\" Figure 1 reaches up to "
+        "touch her own fluffy orange cat ears and says happily: \"Then mine are fluffy!\" No "
+        "cut throughout, with birdsong and wind rustling through leaves underneath, their hair "
+        "and hems swaying lightly in the breeze, the beast-girl's tail flicking.",
+        "examples/forest_1.jpg",
+        "examples/forest_2.jpg",
+        "examples/forest_3.jpg",
+    ],
+    [
+        "Image 1: Man, black buzz cut with shaved lines on both sides, hard jawline, black "
+        "techwear parka with reflective strips, dark grey cargo pants, black tactical boots, "
+        "photorealistic natural texture.\n"
+        "Image 2: Woman, neck-length silver-grey gradient bob, cold-blue contact lenses and "
+        "ear-clip cuffs, translucent PVC long coat over a liquid-silver bodysuit, black "
+        "wide-leg pants, silver platform boots, photorealistic natural texture.\n"
+        "Image 3: Scene, late-night cyberpunk club booth, foreground bottles and neon, "
+        "midground leather booth, background dancefloor strobe light, cyan-blue key light, "
+        "magenta fill light, low-hanging smoke, low-frequency beat, photorealistic natural "
+        "texture.\n\n"
+        "Inside a late-night cyberpunk club booth, cyan-blue key light pressed low, magenta "
+        "fill light tracing the leather booth's silhouette, the dancefloor strobe flashing in "
+        "the distance, smoke hanging low, a low-frequency beat running continuously. Image 1 "
+        "in the black techwear parka sits in the booth, a bottle beside him, head down and "
+        "spaced out. Image 2 in the translucent PVC long coat walks to Image 1's side and sits "
+        "down, naturally leaning on his shoulder, her silver-grey bob brushing against his "
+        "parka. Image 1 turns his head to look at her, she lifts her eyes back to him, the two "
+        "holding still for one second. The shot starts on a side medium of Image 1, slow dolly "
+        "push-in about 40% as Image 2 approaches, then a small slow orbit around the two. "
+        "Photorealistic natural texture.",
+        "examples/cyberpunk_1.jpg",
+        "examples/cyberpunk_2.jpg",
+        "examples/cyberpunk_3.jpg",
+    ],
+    [
+        "Image 1: East Asian, 30 years old, man, very short buzz cut, thick dark straight "
+        "eyebrows, hard jawline, sharp gaze, black high-collar technical windbreaker with "
+        "silver-grey reflective strips and zippered pockets across the chest and upper arms.\n"
+        "Image 2: East Asian, 20 years old, woman, neck-length wavy bob with wispy bangs, "
+        "bright red satin headband, pearl stud earrings.\n"
+        "Image 3: Scene, late-night apartment entryway narrow hallway, foreground a black "
+        "metal coat rack and black curved-handle umbrellas leaning against the wall, midground "
+        "the two facing off, background a half-open white door leading into a brighter room, "
+        "light-grey walls and matte grey square-tile floor, cool-white overhead light with "
+        "cold-blue light seeping through the door, sharp high contrast, oppressive standoff "
+        "mood, photorealistic natural texture.\n\n"
+        "Late-night apartment entryway narrow hallway, cool-white overhead light, a half-open "
+        "white door leading into a brighter room, cold-blue light seeping through the door, "
+        "sharp high contrast no bloom; camera axis slightly diagonal, fixed from the door "
+        "toward the interior. Figure 1 stands upper-right near the door facing lower-left, "
+        "Figure 2 stands lower-left in midground facing upper-right, one step apart. Figure "
+        "1's shoulders are tense, half-turned toward the door; Figure 2 blocks the hallway "
+        "with reddened eyes under her red headband. Diagonal composition, locked camera, slow "
+        "push-in about 25%, Figure 2's lashes trembling, Figure 1's jaw muscles tightening, "
+        "the two's gazes locked, the overhead light humming low, the brighter room beyond in "
+        "silence. Photorealistic natural texture.",
+        "examples/hallway_1.jpg",
+        "examples/hallway_2.jpg",
+        "examples/hallway_3.jpg",
+    ],
+]
+
+
+CSS = """
+.main.fillable { max-width: 1280px !important; }
+.dark .gradio-container { color: var(--body-text-color); }
+"""
+
+with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title="LTX-2.5 Multi-Subject Reference") as demo:
+    gr.Markdown(
+        "# 🎭 LTX-2.5 · Multiple Subject Reference\n"
+        "Give up to **four subject stills plus one scene still**, name them in the prompt "
+        "(`Image 1:`, `Image 2:`, `Image 3: Scene, …`), and get a video with native audio that "
+        "keeps every subject's identity, clothing and the scene's look.\n\n"
+        "[`LiconStudio/LTX-2.5-Multiple-Subject-Reference`](https://huggingface.co/LiconStudio/LTX-2.5-Multiple-Subject-Reference)"
+        " on [`Lightricks/LTX-2.5`](https://huggingface.co/Lightricks/LTX-2.5) (22B, distilled)."
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            prompt = gr.Textbox(
+                label="Prompt",
+                lines=10,
+                max_lines=22,
+                placeholder=(
+                    "Image 1: <who / what slot 1 is — build, hair, clothes>\n"
+                    "Image 2: <who / what slot 2 is>\n"
+                    "Image 3: Scene, <where it happens, lighting, mood>\n\n"
+                    "<the shot itself: what they do, camera moves, dialogue, sound>"
+                ),
+            )
+            with gr.Row():
+                subject_1 = gr.Image(label="Subject 1", type="pil", height=190)
+                subject_2 = gr.Image(label="Subject 2 (optional)", type="pil", height=190)
+                scene_image = gr.Image(label="Scene (optional)", type="pil", height=190)
+
+            with gr.Accordion("More subject slots", open=False):
+                with gr.Row():
+                    subject_3 = gr.Image(label="Subject 3 (optional)", type="pil", height=190)
+                    subject_4 = gr.Image(label="Subject 4 (optional)", type="pil", height=190)
+
+            with gr.Accordion("Advanced", open=False):
+                resolution = gr.Dropdown(
+                    list(RESOLUTIONS),
+                    value=DEFAULT_RESOLUTION,
+                    label="Resolution",
+                    info="Stage 1 samples at half of this, then a ×2 latent upsample.",
+                )
+                seconds = gr.Slider(
+                    1.0, 8.0, value=DEFAULT_SECONDS, step=0.5, label="Length (seconds @ 24 fps)"
+                )
+                reference_frames = gr.Slider(
+                    9,
+                    33,
+                    value=DEFAULT_REFERENCE_FRAMES,
+                    step=8,
+                    label="Reference frames per slot",
+                    info="How many frames each still is repeated to before VAE encoding. "
+                    "33 is the author's workflow value; lower is faster and weaker.",
+                )
+                with gr.Row():
+                    seed = gr.Slider(0, MAX_SEED, value=42, step=1, label="Seed")
+                    randomize_seed = gr.Checkbox(value=True, label="Randomize seed")
+
+            run_button = gr.Button("Generate", variant="primary")
+
+        with gr.Column(scale=1):
+            video_out = gr.Video(label="Result", autoplay=True, height=430)
+            info_out = gr.Textbox(label="Run", lines=2, interactive=False)
+
+    inputs = [
+        prompt,
+        subject_1,
+        subject_2,
+        scene_image,
+        subject_3,
+        subject_4,
+        resolution,
+        seconds,
+        reference_frames,
+        seed,
+        randomize_seed,
+    ]
+    outputs = [video_out, info_out]
+
+    run_button.click(fn=generate, inputs=inputs, outputs=outputs)
+
+    gr.Examples(
+        examples=EXAMPLES,
+        inputs=[prompt, subject_1, subject_2, scene_image],
+        outputs=outputs,
+        fn=generate,
+        cache_examples=True,
+        cache_mode="lazy",
+        label="The author's own validation references and prompts",
+    )
+
+    gr.Markdown(
+        "### Prompting\n"
+        "* Describe **every** reference on its own line, in slot order, using the same labels "
+        "(`Image 1`, `Image 2`, …). The scene still is always the last slot.\n"
+        "* Then state who does what, where they stand relative to each other, camera moves and "
+        "any dialogue — LTX-2.5 generates the audio too.\n"
+        "* Subject stills are letterboxed onto white; the scene still is centre-cropped. "
+        "Character-sheet style references (front / three-quarter / back on a plain background) "
+        "work best — that is what the LoRA was validated on.\n\n"
+        "Reference images and prompts are the author's own validation set from the model repo "
+        "(apache-2.0)."
+    )
+
+demo.queue().launch(mcp_server=True, show_error=True)

msr.py

@@ -0,0 +1,333 @@
+"""LTX-2.5 Multiple-Subject-Reference (MSR) — a diffusers port of the author's ComfyUI nodes.
+
+Reference implementation: https://github.com/liconstudio/ComfyUI-LTX2.5-MSR (`nodes.py`).
+Everything the custom node does that plain IC-LoRA conditioning does *not* lives here:
+
+1. `msr_resize` — the node's own reference-image fitting rule. Subject slots are letterboxed
+   onto a **white** canvas unless the source already covers the target in the same aspect
+   family (then it is centre-crop-resized); the background slot is always centre-crop-resized.
+2. `slot_embedding` — the LoRA's learned Fourier-MLP slot code, added broadcast over the
+   channel axis of the *normalized* reference latent. This is what tells the transformer
+   "these tokens are subject #2".
+3. Negative temporal offsets — reference tokens are placed *before* frame 0 on the RoPE time
+   axis at `-(num_slots - slot_index)` pixel-frames, i.e. each slot gets its own one-frame
+   slice of negative time. ComfyUI does `pixel_coords[:, 0] += frame_idx` before the model
+   divides the temporal axis by `frame_rate`; diffusers' `prepare_video_coords` already
+   divides, so the equivalent here is `+= frame_offset / frame_rate` afterwards.
+
+Everything else the node relies on is already what `LTX2InContextPipeline` does: reference
+tokens are appended at the END of the packed sequence with `conditioning_mask = strength`,
+and `output_type="latent"` crops them back off (ComfyUI's `LTXVCropGuides`). With
+`strength=1.0` and no pixel mask, ComfyUI's `_build_guide_self_attention_mask` returns
+`None` and diffusers builds no mask either — the two stacks agree.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+import PIL.Image
+import torch
+import torch.nn.functional as F
+
+from diffusers.pipelines.ltx2.pipeline_ltx2_ic_lora import (
+    LTX2InContextPipeline,
+    LTX2ReferenceCondition,
+    retrieve_latents,
+)
+
+SLOT_PREFIXES = ("diffusion_model.reference_slot_embedding.", "reference_slot_embedding.")
+
+# The node hard-requires these two metadata values; anything else means a different token
+# layout than the one implemented below.
+EXPECTED_METADATA = {
+    "reference_token_order": "prepend",
+    "reference_slot_time_offsets": "pic1_based_negative_time",
+}
+
+
+# ------------------------------------------------------------------------------------------
+# LoRA state-dict splitting
+# ------------------------------------------------------------------------------------------
+def split_slot_state(state_dict: dict) -> tuple[dict, dict]:
+    """Separate the `reference_slot_embedding.*` weights (not a LoRA) from the LoRA tensors."""
+    slot: dict[str, torch.Tensor] = {}
+    rest: dict[str, torch.Tensor] = {}
+    for key, value in state_dict.items():
+        for prefix in SLOT_PREFIXES:
+            if key.startswith(prefix):
+                slot[key[len(prefix) :]] = value
+                break
+        else:
+            rest[key] = value
+    return slot, rest
+
+
+def slot_embedding(
+    slot_id: int, state: dict, device: torch.device, dtype: torch.dtype
+) -> torch.Tensor:
+    """1:1 port of `ComfyUI-LTX2.5-MSR/nodes.py::_slot_embedding`.
+
+    `slot_id / 16` is expanded into `[scaled, sin(scaled * f), cos(scaled * f)]` and pushed
+    through the LoRA's 2-layer SiLU MLP, giving a 128-dim per-slot code.
+    """
+    frequencies = state["frequencies"].to(device=device, dtype=torch.float32)
+    slot_value = torch.tensor(float(slot_id), device=device, dtype=torch.float32)
+    scaled = slot_value / 16.0
+    phases = scaled * frequencies
+    features = torch.cat((scaled.reshape(1), torch.sin(phases), torch.cos(phases)))
+    hidden = F.silu(
+        F.linear(
+            features,
+            state["net.0.weight"].to(device=device, dtype=torch.float32),
+            state["net.0.bias"].to(device=device, dtype=torch.float32),
+        )
+    )
+    embedding = F.linear(
+        hidden,
+        state["net.2.weight"].to(device=device, dtype=torch.float32),
+        state["net.2.bias"].to(device=device, dtype=torch.float32),
+    )
+    return embedding.to(dtype=dtype)
+
+
+# ------------------------------------------------------------------------------------------
+# reference-image fitting (ComfyUI `comfy.utils.common_upscale` semantics)
+# ------------------------------------------------------------------------------------------
+def _bilinear(x: torch.Tensor, height: int, width: int) -> torch.Tensor:
+    # ComfyUI uses plain `F.interpolate(..., mode="bilinear")` — no antialias, align_corners=False.
+    return F.interpolate(x, size=(height, width), mode="bilinear")
+
+
+def _center_crop_resize(x: torch.Tensor, target_width: int, target_height: int) -> torch.Tensor:
+    """`common_upscale(..., crop="center")`: crop to the target aspect, then bilinear resize."""
+    old_height, old_width = x.shape[-2:]
+    old_aspect = old_width / old_height
+    new_aspect = target_width / target_height
+    x_off = y_off = 0
+    if old_aspect > new_aspect:
+        x_off = round((old_width - old_width * (new_aspect / old_aspect)) / 2)
+    elif old_aspect < new_aspect:
+        y_off = round((old_height - old_height * (old_aspect / new_aspect)) / 2)
+    cropped = x.narrow(-2, y_off, old_height - y_off * 2).narrow(-1, x_off, old_width - x_off * 2)
+    return _bilinear(cropped, target_height, target_width)
+
+
+def _aspect_family(width: int, height: int) -> str:
+    ratio = width / height
+    if ratio >= 1.25:
+        return "landscape"
+    if ratio <= 0.8:
+        return "portrait"
+    return "square"
+
+
+def msr_resize(
+    x: torch.Tensor, target_width: int, target_height: int, is_background: bool
+) -> torch.Tensor:
+    """1:1 port of `nodes.py::_resize_reference`. `x` is `[F, C, H, W]`, float in `[0, 1]`."""
+    if is_background:
+        return _center_crop_resize(x, target_width, target_height)
+
+    source_height, source_width = x.shape[-2:]
+    if source_width == target_width and source_height == target_height:
+        return x
+
+    same_family = _aspect_family(source_width, source_height) == _aspect_family(
+        target_width, target_height
+    )
+    source_is_smaller = source_width <= target_width and source_height <= target_height
+    if same_family and not source_is_smaller:
+        return _center_crop_resize(x, target_width, target_height)
+
+    # Letterbox onto a white canvas, preserving the source aspect ratio.
+    scale = min(target_width / source_width, target_height / source_height)
+    resized_width = max(1, min(target_width, round(source_width * scale)))
+    resized_height = max(1, min(target_height, round(source_height * scale)))
+    resized = _bilinear(x, resized_height, resized_width)
+    canvas = torch.ones(
+        (x.shape[0], x.shape[1], target_height, target_width), dtype=x.dtype, device=x.device
+    )
+    left = (target_width - resized_width) // 2
+    top = (target_height - resized_height) // 2
+    canvas[:, :, top : top + resized_height, left : left + resized_width] = resized
+    return canvas
+
+
+def to_frames_tensor(image) -> torch.Tensor:
+    """Any PIL / ndarray / tensor still -> `[1, 3, H, W]` float32 in `[0, 1]`."""
+    if isinstance(image, PIL.Image.Image):
+        array = np.asarray(image.convert("RGB"), dtype=np.float32) / 255.0
+        tensor = torch.from_numpy(array).permute(2, 0, 1)
+    elif isinstance(image, np.ndarray):
+        array = image.astype(np.float32)
+        if array.max() > 1.5:
+            array = array / 255.0
+        tensor = torch.from_numpy(array[..., :3]).permute(2, 0, 1)
+    elif isinstance(image, torch.Tensor):
+        tensor = image.float()
+        if tensor.ndim == 4:
+            tensor = tensor[0]
+        if tensor.shape[0] not in (1, 3):  # HWC
+            tensor = tensor.permute(2, 0, 1)
+        tensor = tensor[:3]
+    else:
+        raise TypeError(f"Unsupported reference image type: {type(image)}")
+    return tensor.unsqueeze(0)
+
+
+# ------------------------------------------------------------------------------------------
+# pipeline
+# ------------------------------------------------------------------------------------------
+@dataclass
+class MSRReference(LTX2ReferenceCondition):
+    """An MSR reference slot. `frames` holds a single still image (any PIL/np/tensor)."""
+
+    slot_id: int = 1
+    frame_offset: int = 0
+    is_background: bool = False
+
+
+class LTX25MSRPipeline(LTX2InContextPipeline):
+    """`LTX2InContextPipeline` with the MSR reference encoder swapped in.
+
+    `_encode_reference_conditions` is the single override point: `prepare_latents` and
+    `__call__` already append the returned tokens/coords in the layout the LoRA expects.
+    """
+
+    msr_slot_state: dict | None = None
+    msr_reference_frames: int = 33
+    # The workflow runs the guide node with `use_tiled_encode=False`, so reference stills are
+    # encoded whole. Falls back to tiled encoding if that ever runs out of memory.
+    msr_tiled_encode: bool = False
+
+    def _encode_reference_pixels(self, pixels, generator):
+        previous = getattr(self.vae, "use_tiling", False)
+        self.vae.use_tiling = bool(self.msr_tiled_encode)
+        try:
+            return retrieve_latents(
+                self.vae.encode(pixels), generator=generator, sample_mode="argmax"
+            )
+        except torch.cuda.OutOfMemoryError:
+            torch.cuda.empty_cache()
+            self.vae.use_tiling = True
+            return retrieve_latents(
+                self.vae.encode(pixels), generator=generator, sample_mode="argmax"
+            )
+        finally:
+            self.vae.use_tiling = previous
+
+    def _encode_reference_conditions(
+        self,
+        reference_conditions,
+        height: int,
+        width: int,
+        num_frames: int,
+        reference_downscale_factor: int = 1,
+        frame_rate: float = 24.0,
+        conditioning_attention_strength: float = 1.0,
+        conditioning_attention_mask=None,
+        dtype=None,
+        device=None,
+        generator=None,
+    ):
+        ref_height = height // reference_downscale_factor
+        ref_width = width // reference_downscale_factor
+        mask_needed = conditioning_attention_strength < 1.0 or conditioning_attention_mask is not None
+
+        temporal_ratio = self.vae_temporal_compression_ratio
+        n_frames = int(self.msr_reference_frames)
+        # `nodes.py::_encode_reference`: trim to a VAE-legal frame count.
+        keep = ((n_frames - 1) // temporal_ratio) * temporal_ratio + 1
+
+        all_latents, all_coords, all_cross, token_counts = [], [], [], []
+
+        for ref in reference_conditions:
+            still = to_frames_tensor(ref.frames)  # [1, 3, H, W] in [0, 1]
+            is_background = bool(getattr(ref, "is_background", False))
+            fitted = msr_resize(still, ref_width, ref_height, is_background)
+
+            # A still repeated to `keep` frames. Resizing once and repeating is identical to
+            # (and far cheaper than) the node's `image.repeat(reference_frames, ...)` first.
+            pixels = fitted.repeat(keep, 1, 1, 1)  # [keep, 3, h, w]
+            pixels = pixels.permute(1, 0, 2, 3).unsqueeze(0)  # [1, 3, keep, h, w]
+            # ComfyUI's VAE wrapper applies `image * 2 - 1` before `encode`.
+            pixels = (pixels * 2.0 - 1.0).to(device=device, dtype=self.vae.dtype)
+
+            latent = self._encode_reference_pixels(pixels, generator)
+            # ComfyUI's LTX2 VAE normalizes inside `encode` (`per_channel_statistics.normalize`),
+            # so the slot embedding must be added in this normalized space.
+            latent = self._normalize_latents(
+                latent, self.vae.latents_mean, self.vae.latents_std
+            ).to(device=device, dtype=dtype)
+
+            if self.msr_slot_state:
+                embedding = slot_embedding(
+                    int(getattr(ref, "slot_id", 1)), self.msr_slot_state, latent.device, latent.dtype
+                )
+                latent = latent + embedding.view(1, -1, 1, 1, 1)
+
+            _, _, latent_frames, latent_height, latent_width = latent.shape
+            packed = self._pack_latents(
+                latent, self.transformer_spatial_patch_size, self.transformer_temporal_patch_size
+            )
+
+            coords = self.transformer.rope.prepare_video_coords(
+                batch_size=1,
+                num_frames=latent_frames,
+                height=latent_height,
+                width=latent_width,
+                device=device,
+                fps=frame_rate,
+            )
+            if reference_downscale_factor != 1:
+                coords[:, 1, :, :] = coords[:, 1, :, :] * reference_downscale_factor
+                coords[:, 2, :, :] = coords[:, 2, :, :] * reference_downscale_factor
+            # The MSR slot offset. ComfyUI adds it in pixel-frames before the model's `/ fps`;
+            # `prepare_video_coords` has already divided, hence `/ frame_rate` here.
+            offset = float(getattr(ref, "frame_offset", 0)) / float(frame_rate)
+            if offset:
+                coords[:, 0, :, :] = coords[:, 0, :, :] + offset
+
+            num_tokens = packed.shape[1]
+            all_latents.append(packed)
+            all_coords.append(coords)
+            token_counts.append(num_tokens)
+
+            if mask_needed:
+                if conditioning_attention_mask is not None:
+                    cross = self._downsample_mask_to_latent(
+                        mask=conditioning_attention_mask,
+                        latent_num_frames=latent_frames,
+                        latent_height=latent_height,
+                        latent_width=latent_width,
+                    ).to(device=device, dtype=torch.float32)
+                else:
+                    cross = torch.ones((1, num_tokens), device=device, dtype=torch.float32)
+                all_cross.append(cross * conditioning_attention_strength)
+
+        reference_latents = torch.cat(all_latents, dim=1)
+        reference_coords = torch.cat(all_coords, dim=2)
+        reference_cross_mask = torch.cat(all_cross, dim=1) if mask_needed else None
+        return reference_latents, reference_coords, reference_cross_mask, token_counts
+
+
+def build_references(images: list, backgrounds: list[bool]) -> list[MSRReference]:
+    """Assign slot ids and negative time offsets exactly as `nodes.py` does.
+
+    The node collects `pic1..pic4` then `background`, skipping empties, so the background —
+    when present — always takes the last slot. Slot `i` (0-based) is placed at pixel-frame
+    `-(num_slots - i)`, i.e. the slots occupy `[-N, -1]` in order.
+    """
+    num_slots = len(images)
+    return [
+        MSRReference(
+            frames=image,
+            strength=1.0,
+            slot_id=index + 1,
+            frame_offset=-(num_slots - index),
+            is_background=is_background,
+        )
+        for index, (image, is_background) in enumerate(zip(images, backgrounds))
+    ]

requirements.txt

@@ -0,0 +1,31 @@
+# LTX-2.5 and `LTX2InContextPipeline` (the in-context reference conditioning this Space is
+# built on) are not in a PyPI diffusers release yet. Pinned to a known-good main commit.
+diffusers @ git+https://github.com/huggingface/diffusers@d57cecde92a6d396845ab35425aa27469dff8173
+
+# gradio and spaces are deliberately absent: the platform preinstalls and pins them.
+#
+# huggingface_hub IS pinned, which is the exception rather than an oversight: diffusers main
+# imports `get_cached_repo_tree` from it and the base image ships an older hub without it.
+huggingface_hub>=1.23.0,<2.0
+gradio_client
+
+# 5.12.1 breaks at import against current `kernels`; 5.14.1 declares kernels>=0.15.2,<0.16 and
+# imports cleanly. The Gemma4* classes LTX-2.5 needs live here.
+transformers==5.14.1
+kernels
+
+accelerate
+peft
+safetensors
+sentencepiece
+protobuf
+av
+imageio
+imageio-ffmpeg
+Pillow
+numpy
+scipy
+
+# Not preinstalled on the ZeroGPU image; torch itself is left unpinned so the runtime's build wins.
+torchvision
+torchaudio