scripts/prepare_ltx.py

"""Prepare the complete LTX-2.5 pipeline from pinned, licensed public weights.

Run on the model-download worker. The pinned upstream converter strictly checks
every component; no parameters are randomly initialized or omitted.
"""

import argparse
import gc
import functools
import hashlib
import importlib.util
import json
from pathlib import Path
import shutil
import subprocess
import sys
import urllib.request


REVISION = "93deb76408feee57d04b3cfeed3ded56a7a068ee"
CONVERTER = "efe46a5b177af67c64b3666da8ddddac7ee12163"
FILES = {
    "diffusion_models/ltx-2.5-22b-distilled-transformer-bf16.safetensors": "31eb3cad89b9e54e99dd3baf286f70825ac4f6c660a70d9184d895be76d7bff4",
    "text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors": "ef7243612fdae7a75cb4d5cee9433e81380675fb6c213bd98ae74a9cd16561d1",
    "vae/ltx-2.5-audio-vae-bf16.safetensors": "c52733d37f6a7fb7949c3dc0fb468c6cb2169e4d836983a73babb9f0d54837a5",
    "vae/ltx-2.5-video-vae-bf16.safetensors": "847e14ca7f3355debca0cea4eaa24ac0fbcdf0061da054ac89ca638a869ddba3",
    "vae/ltx-2.5-video-vae-conv-bf16.safetensors": "685b06ee3d9b2039647698fc4ea33175112462fc374e2777312c907897dfce8d",
}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--source", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    args = parser.parse_args()
    args.source.mkdir(parents=True, exist_ok=True)
    args.output.mkdir(parents=True, exist_ok=True)
    vendor = args.source / "converter"
    package = vendor / "package"
    if not (package / "diffusers/__init__.py").exists():
        subprocess.run([sys.executable, "-m", "pip", "install", "--no-deps", "--target", str(package),
                        f"https://github.com/huggingface/diffusers/archive/{CONVERTER}.zip"], check=True)
    sys.path.insert(0, str(package))
    script = vendor / "convert_ltx2_to_diffusers.py"
    if not script.exists():
        urllib.request.urlretrieve(f"https://raw.githubusercontent.com/huggingface/diffusers/{CONVERTER}/scripts/convert_ltx2_to_diffusers.py", script)
    spec = importlib.util.spec_from_file_location("ltx_converter", script)
    converter = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(converter)

    import torch
    from accelerate import init_empty_weights
    from huggingface_hub import hf_hub_download
    from safetensors import safe_open
    from safetensors.torch import load_file
    from transformers import AutoConfig, AutoModelForImageTextToText, AutoTokenizer
    from diffusers import FlowMatchEulerDiscreteScheduler

    # The source checkpoint also stores the optional keyframe-stream tag.
    # Keep it verbatim. Plain video decoding never reads this parameter.
    decoder_init = converter.LTX2VideoDiffusionDecoderModel.__init__

    @functools.wraps(decoder_init)
    def init_with_keyframe_tag(self, *a, **kw):
        decoder_init(self, *a, **kw)
        self.decoder.register_parameter("type_emb", torch.nn.Parameter(torch.empty(128)))

    converter.LTX2VideoDiffusionDecoderModel.__init__ = init_with_keyframe_tag

    for name, digest in FILES.items():
        conv = "-conv-" in name
        path = Path(hf_hub_download("comfyicu/LTX-2.5" if conv else "pinecoresystems/LTX-2.5-serving", name,
                    revision="1026e00f808dbd9601911479b22d65b760737dc8" if conv else REVISION,
                    local_dir=args.source, token=False))
        with path.open("rb") as stream:
            actual = hashlib.file_digest(stream, "sha256").hexdigest()
        if actual != digest:
            raise ValueError(f"Checkpoint hash mismatch: {name}")
        print("VERIFIED", name, flush=True)
    for name in ("LICENSE.md", "NOTICE"):
        path = hf_hub_download("pinecoresystems/LTX-2.5-serving", name, revision=REVISION,
                               local_dir=args.source, token=False)
        shutil.copyfile(path, args.output / name)

    components = {}

    def save(name, model):
        model.save_pretrained(args.output / name, safe_serialization=True, max_shard_size="2GB")
        components[name] = ["transformers" if name == "text_encoder" else "diffusers", type(model).__name__]
        print("SAVED", name, flush=True)

    text_path = args.source / "text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors"
    with safe_open(text_path, framework="pt") as source:
        config = AutoConfig.for_model(**json.loads(source.metadata()["gemma_config"]))
        tokenizer = args.output / "tokenizer"
        tokenizer.mkdir(exist_ok=True)
        for key in source.keys():
            if key == "tokenizer_json" or key.startswith("hf_asset__"):
                name = "tokenizer.json" if key == "tokenizer_json" else key.removeprefix("hf_asset__")
                (tokenizer / name).write_bytes(source.get_tensor(key).numpy().tobytes())
        text_weights, projections = {}, {}
        for key in source.keys():
            if key.startswith("text_embedding_projection."):
                projections[key] = source.get_tensor(key)
            elif key.startswith("model."):
                text_weights["model.language_model." + key.removeprefix("model.")] = source.get_tensor(key)
            elif key.startswith("vision_model."):
                text_weights["model.embed_vision." + key.removeprefix("vision_model.")] = source.get_tensor(key)
            elif key.startswith("multi_modal_projector."):
                text_weights["model.embed_vision.multimodal_embedder." + key.removeprefix("multi_modal_projector.")] = source.get_tensor(key)
            elif key.startswith("audio_projector."):
                text_weights["model.embed_audio." + key.removeprefix("audio_projector.")] = source.get_tensor(key)
        text_weights["lm_head.weight"] = text_weights["model.language_model.embed_tokens.weight"]
        with init_empty_weights():
            text_encoder = AutoModelForImageTextToText.from_config(config)
        text_encoder.load_state_dict(text_weights, strict=True, assign=True)
        text_encoder.tie_weights()
        save("text_encoder", text_encoder)
        del text_encoder, text_weights
        AutoTokenizer.from_pretrained(tokenizer, local_files_only=True)
        components["tokenizer"] = ["transformers", "AutoTokenizer"]
        gc.collect()

    state = {key.removeprefix("model.diffusion_model."): value for key, value in
             load_file(args.source / "diffusion_models/ltx-2.5-22b-distilled-transformer-bf16.safetensors").items()}
    state.update(projections)
    save("transformer", converter.convert_ltx2_transformer(state, "2.5"))
    save("connectors", converter.convert_ltx2_connectors(state, "2.5", config.text_config))
    del state, projections
    gc.collect()
    save("vae", converter.convert_ltx2_video_vae(
        load_file(args.source / "vae/ltx-2.5-video-vae-conv-bf16.safetensors"), "2.5", False))
    gc.collect()
    save("diffusion_decoder", converter.convert_ltx2_diffusion_video_vae(
        load_file(args.source / "vae/ltx-2.5-video-vae-bf16.safetensors"), "2.5"))
    gc.collect()
    audio = load_file(args.source / "vae/ltx-2.5-audio-vae-bf16.safetensors")
    save("audio_vae", converter.convert_ltx2_audio_vae(
        {k.removeprefix("audio_vae."): v for k, v in audio.items() if k.startswith("audio_vae.")}, "2.5"))
    save("vocoder", converter.convert_ltx2_vocoder(
        {k.removeprefix("vocoder."): v for k, v in audio.items() if k.startswith("vocoder.")}, "2.5"))
    scheduler = FlowMatchEulerDiscreteScheduler(use_dynamic_shifting=False, base_shift=0.95,
        max_shift=2.05, base_image_seq_len=1024, max_image_seq_len=4096, shift_terminal=None)
    scheduler.save_pretrained(args.output / "scheduler")
    components["scheduler"] = ["diffusers", type(scheduler).__name__]
    (args.output / "model_index.json").write_text(json.dumps({"_class_name": "LTX2Pipeline",
        "_diffusers_version": "0.41.0.dev0", **components}, indent=2) + "\n")
    (args.output / "conversion.json").write_text(json.dumps(dict(
        original_model="Lightricks/LTX-2.5", original_revision="49b093a39c19169a8a81721dcc541e07e945232f",
        public_distribution="pinecoresystems/LTX-2.5-serving", revision=REVISION,
        conv_vae_distribution="comfyicu/LTX-2.5", conv_vae_revision="1026e00f808dbd9601911479b22d65b760737dc8",
        converter_revision=CONVERTER, source_sha256=FILES,
        validation="Every component loaded with strict=True; all source file SHA256 values verified.",
        text_encoder_adapter="Lossless parameter-name mapping, including vision/audio embeddings and tied LM head."), indent=2) + "\n")


if __name__ == "__main__":
    main()