Add pinned public inference entry and installation guide

README.md

@@ -11,68 +11,107 @@ tags:
 
 # DiffusionART HunyuanVideo 7:2:1 — selected step 30
 
-This private release contains **one full HunyuanVideo transformer**, not a LoRA
-adapter or a complete video pipeline. It is the author-selected model-only
-checkpoint from W&B run [`tk1w4go1`](https://wandb.ai/vanzl3386-chinese-university-of-hong-kong-shenzhen/flow-grpo-algo/runs/tk1w4go1),
-at optimizer step 30 / rollout 15. The planned 100-update run later stopped at
-step 40; this package makes no claim that 100 updates completed.
+This private release is a **full HunyuanVideo transformer**, not a complete
+pipeline or LoRA adapter. It is the selected optimizer-step-30 checkpoint from
+[run `tk1w4go1`](https://wandb.ai/vanzl3386-chinese-university-of-hong-kong-shenzhen/flow-grpo-algo/runs/tk1w4go1).
+The original HunyuanVideo-13B transformer was trained with temporal alignment,
+video quality, and motion quality rewards weighted 0.7 / 0.2 / 0.1, plus a
+frozen pretrained-velocity MSE regularizer with beta 0.1. The transformer is
+stored as F32 safetensors shards. The public base model supplies the VAE, text
+encoders, tokenizers, and scheduler. `release.json` records the source and shard
+hashes; this inference update does not alter those files.
 
-The original HunyuanVideo-13B transformer was trained with masked scalar
-DiffusionART feedback from fixed-normalized temporal alignment, video quality,
-and motion quality rewards at weights **0.7 / 0.2 / 0.1**, plus a frozen
-pretrained-velocity MSE regularizer with beta **0.1**. This is a full F32
-transformer export. Tensor names, shapes, dtypes, and values were preserved
-when the original safetensors file was split into shards smaller than 5 GB.
-The package includes no optimizer state, RNG state, VAE, text encoders, or
-tokenizers.
+## Requirements
 
-## Base and native loading
+- Access to this private Hugging Face repository through `HF_TOKEN` or an
+  interactive Hugging Face login. The commands keep the login and model cache
+  in the chosen work directory. Do not put a token in a script or shell history.
+- Linux x86-64, Python **3.12**, a CUDA 12.1 compatible NVIDIA driver and CUDA
+  toolkit (`nvcc`) for building the pinned `flash-attn` version, plus `curl`,
+  `tar`, and `sha256sum`.
+- One H800 with **at least 100 GiB available GPU memory** for the verified
+  default path. Independent inference used one 140 GiB H800 and peaked at
+  92.39 GiB allocated. Allow at least **100 GiB writable disk space** for the
+  private transformer, pinned public base assets, and installation caches.
+  `--cpu-offload` is available for constrained GPUs but was not part of the
+  independent acceptance run.
 
-Use the separate public base pipeline assets from
-[`hunyuanvideo-community/HunyuanVideo`](https://huggingface.co/hunyuanvideo-community/HunyuanVideo)
-at revision `e8c2aaa66fe3742a32c11a6766aecbf07c56e773`. The training and
-evaluation runtime used the native `hunyuan_hf` loader in
-[`XueZeyue/DanceGRPO`](https://github.com/XueZeyue/DanceGRPO) at revision
-`15cc71d53cc2e6e18a68ee607d5fb6ba9a99e344`. Its transformer loading
-call takes the downloaded `transformer/` directory as the checkpoint and the
-public base snapshot as the model root:
+## Install and generate one MP4
 
-```python
-import torch
-from fastvideo.utils.load import load_transformer
-from huggingface_hub import snapshot_download
+The commands use only this release and the fixed **public**
+[`XueZeyue/DanceGRPO`](https://github.com/XueZeyue/DanceGRPO/tree/15cc71d53cc2e6e18a68ee607d5fb6ba9a99e344)
+runtime. No private training repository, saved prompt embeddings, notebook, or
+MPI launcher is needed. Choose a work directory with the required free space.
 
-release = snapshot_download("vanzl/DiffusionART-HunyuanVideo-7-2-1")
-base = snapshot_download(
-    "hunyuanvideo-community/HunyuanVideo",
-    revision="e8c2aaa66fe3742a32c11a6766aecbf07c56e773",
-)
-transformer = load_transformer(
-    "hunyuan_hf", f"{release}/transformer", base, torch.float32
+```bash
+export RUN_DIR="${RUN_DIR:-$PWD/diffusionart-t2v-demo}"
+export HF_HOME="$RUN_DIR/cache/hf"
+export HF_HUB_CACHE="$HF_HOME/hub"
+export PIP_CACHE_DIR="$RUN_DIR/pip-cache"
+export TMPDIR="$RUN_DIR/tmp"
+export XDG_CACHE_HOME="$RUN_DIR/xdg-cache"
+mkdir -p "$RUN_DIR" "$HF_HOME" "$HF_HUB_CACHE" "$PIP_CACHE_DIR" "$TMPDIR" "$XDG_CACHE_HOME"
+cd "$RUN_DIR"
+python3.12 -m venv bootstrap
+bootstrap/bin/python -m pip install 'huggingface-hub==0.26.1'
+if [ -z "${HF_TOKEN:-}" ] && [ ! -f "$HF_HOME/token" ]; then
+  bootstrap/bin/huggingface-cli login
+fi
+
+# If MODEL_REVISION is already set to a known 40-character commit SHA, keep it.
+# Otherwise resolve main exactly once, then pin every download to that SHA.
+if [ -z "${MODEL_REVISION:-}" ]; then
+  MODEL_REVISION="$(bootstrap/bin/python -c 'from huggingface_hub import HfApi; print(HfApi().model_info("vanzl/DiffusionART-HunyuanVideo-7-2-1", token=True).sha)')"
+fi
+export MODEL_REVISION
+printf 'Pinned model revision: %s\n' "$MODEL_REVISION"
+
+bootstrap/bin/python - <<'PY'
+import os
+from huggingface_hub import snapshot_download
+snapshot_download(
+    repo_id="vanzl/DiffusionART-HunyuanVideo-7-2-1",
+    revision=os.environ["MODEL_REVISION"],
+    token=True,
+    allow_patterns=["README.md", "infer.py", "install.sh", "requirements-inference.txt"],
+    local_dir="release",
 )
+PY
+
+bash release/install.sh "$RUN_DIR/venv" "$RUN_DIR/DanceGRPO-public"
+"$RUN_DIR/venv/bin/python" release/infer.py \
+  --revision "$MODEL_REVISION" \
+  --prompt 'A white horse gallops through shallow water along a sunlit beach.' \
+  --seed 42 \
+  --output "$RUN_DIR/horse_seed42.mp4" \
+  --cache-dir "$RUN_DIR/cache"
 ```
 
-This shows the native loader interface and does not constitute an independently
-tested inference example. Compatibility with a standard Diffusers pipeline has
-not been validated for this release. The original `config.json` was preserved
-byte for byte, including its source `_name_or_path` metadata; loading should
-use the supplied checkpoint directory and public base snapshot as above.
+`install.sh` installs PyTorch **2.5.0+cu121**, torchvision **0.20.0+cu121**,
+the versions in `requirements-inference.txt`, `flash-attn==2.7.0.post2`,
+`liger-kernel==0.4.1`, and the public DanceGRPO commit
+`15cc71d53cc2e6e18a68ee607d5fb6ba9a99e344`. It verifies the public
+source archive SHA256 before installation. `infer.py` downloads this model at
+`--revision` and the base model at fixed revision
+`e8c2aaa66fe3742a32c11a6766aecbf07c56e773` into `--cache-dir`.
+Pass a different `--prompt`, `--seed`, or `--output` to make another video.
+`infer.py` refuses to overwrite an existing MP4 and validates the generated
+file by decoding every frame.
 
-The fixed evaluation protocol used 53 frames at 640×640 and 8 FPS, 30 sampling
-steps, shift 7, eta 0, no classic CFG, and embedded guidance tensor 6018. The
-step 30 eval had 150 scored samples; its validation100 raw VQ/MQ/TA means were
-6.51484375 / 2.6786230605840684 / 1.6762551510334014. These are recorded
-evaluation results, not an independent GPU inference check of this upload.
+The verified protocol is **640×640, 53 frames, 8 FPS, 30 sampling steps,
+FlowMatchEulerDiscreteScheduler shift 7, eta 0, and no classic CFG**. The
+public pipeline takes `guidance_scale=6.018` as the user-facing value and
+multiplies it by 1000 internally, yielding embedded guidance **6018**. Do not
+pass 6018 as `guidance_scale`. The loader keeps the transformer in F32, runs
+with BF16 autocast, loads both tokenizers from the pinned public base model,
+and enables VAE tiling. The script prints the MP4 SHA256, decoded frame count,
+resolution, FPS, and pixel statistics after a successful run.
 
-## Provenance and terms
+## Terms and provenance
 
-See `release.json` for the exact run, runtime/contract revisions, source and
-shard hashes, and validation status. Tencent's original HunyuanVideo weights
-and derivatives are subject to the **Tencent Hunyuan Community License
-Agreement**. The official upstream [`LICENSE.txt`](LICENSE.txt) and
-[`Notice`](Notice) are included unchanged from
-[`tencent/HunyuanVideo`](https://huggingface.co/tencent/HunyuanVideo)
-revision `6204ad6aea1a77ff5aba337c88278bb9500eb37`. Review those terms,
-including their territory and use restrictions, before distributing or using
-the model. The community Diffusers conversion did not provide a separate
-license file at the pinned base revision.
+The package has no optimizer, RNG state, or training code. Tencent's original
+HunyuanVideo weights and derivatives are subject to the **Tencent Hunyuan
+Community License Agreement**. Read the included [LICENSE.txt](LICENSE.txt)
+and [Notice](Notice) before use. The model card and inference helpers do not
+change their terms. The original run was planned for 100 updates but stopped
+at step 40; this release selects step 30 and does not claim 100 updates.

infer.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""Generate one video with the pinned public HunyuanVideo inference pipeline."""
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+import time
+from pathlib import Path
+
+
+MODEL_ID = "vanzl/DiffusionART-HunyuanVideo-7-2-1"
+BASE_ID = "hunyuanvideo-community/HunyuanVideo"
+BASE_REVISION = "e8c2aaa66fe3742a32c11a6766aecbf07c56e773"
+FRAMES = 53
+WIDTH = HEIGHT = 640
+FPS = 8
+STEPS = 30
+SHIFT = 7.0
+GUIDANCE_SCALE = 6.018  # The public pipeline multiplies this by 1000.
+
+
+def arguments():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--prompt", required=True, help="Text prompt for one video")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output", required=True, type=Path, help="Output MP4 path")
+    parser.add_argument("--cache-dir", required=True, type=Path,
+                        help="Writable directory for both pinned Hugging Face snapshots and runtime caches")
+    parser.add_argument("--revision", required=True,
+                        help="Exact 40-character commit SHA of the private model release")
+    parser.add_argument("--cpu-offload", action="store_true",
+                        help="Move inactive modules to CPU; the default H800 acceptance did not need this")
+    args = parser.parse_args()
+    if not args.prompt.strip():
+        parser.error("--prompt must contain text")
+    if not re.fullmatch(r"[0-9a-f]{40}", args.revision):
+        parser.error("--revision must be a fixed 40-character lowercase commit SHA")
+    if args.output.suffix.lower() != ".mp4":
+        parser.error("--output must end in .mp4")
+    if args.output.exists():
+        parser.error(f"output already exists: {args.output}")
+    return args
+
+
+def configure_caches(root: Path):
+    root.mkdir(parents=True, exist_ok=True)
+    hf_home = root / "hf"
+    hub = hf_home / "hub"
+    for directory in (hf_home, hub, root / "xdg", root / "tmp", root / "triton"):
+        directory.mkdir(parents=True, exist_ok=True)
+    os.environ.update({
+        "HF_HOME": str(hf_home),
+        "HF_HUB_CACHE": str(hub),
+        "HUGGINGFACE_HUB_CACHE": str(hub),
+        "HF_ASSETS_CACHE": str(hf_home / "assets"),
+        "XDG_CACHE_HOME": str(root / "xdg"),
+        "TMPDIR": str(root / "tmp"),
+        "TRITON_CACHE_DIR": str(root / "triton"),
+        "TOKENIZERS_PARALLELISM": "false",
+        "HF_HUB_DISABLE_TELEMETRY": "1",
+        "PYTHONNOUSERSITE": "1",
+    })
+    return hub
+
+
+def sha256(path: Path):
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for block in iter(lambda: source.read(16 * 1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def validate_video(path: Path):
+    import av
+    import numpy as np
+
+    frame_count = 0
+    pixel_sum = 0.0
+    squared_sum = 0.0
+    pixel_min = 255
+    pixel_max = 0
+    with av.open(str(path)) as container:
+        streams = [stream for stream in container.streams if stream.type == "video"]
+        if len(streams) != 1:
+            raise RuntimeError(f"expected one video stream, got {len(streams)}")
+        stream = streams[0]
+        width, height = stream.width, stream.height
+        fps = float(stream.average_rate)
+        for frame in container.decode(stream):
+            pixels = frame.to_ndarray(format="rgb24")
+            if pixels.shape != (HEIGHT, WIDTH, 3):
+                raise RuntimeError(f"unexpected frame shape: {pixels.shape}")
+            values = pixels.astype(np.float64)
+            pixel_sum += float(values.sum())
+            squared_sum += float(np.square(values).sum())
+            pixel_min = min(pixel_min, int(pixels.min()))
+            pixel_max = max(pixel_max, int(pixels.max()))
+            frame_count += 1
+    if (frame_count, width, height) != (FRAMES, WIDTH, HEIGHT):
+        raise RuntimeError(f"unexpected video geometry: {(frame_count, width, height)}")
+    if abs(fps - FPS) > 0.01:
+        raise RuntimeError(f"unexpected FPS: {fps}")
+    count = frame_count * width * height * 3
+    mean = pixel_sum / count
+    std = max(0.0, squared_sum / count - mean * mean) ** 0.5
+    if pixel_max <= pixel_min or pixel_max == 0 or std <= 1.0:
+        raise RuntimeError(f"blank or nearly constant video: range={pixel_min}:{pixel_max}, std={std}")
+    return {"decoded_frames": frame_count, "width": width, "height": height,
+            "fps": fps, "pixel_min": pixel_min, "pixel_max": pixel_max,
+            "pixel_mean": mean, "pixel_std": std}
+
+
+def main():
+    args = arguments()
+    cache_root = args.cache_dir.expanduser().resolve()
+    hub_cache = configure_caches(cache_root)
+    output = args.output.expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+
+    # Import after setting cache variables, so neither library selects a home cache.
+    import torch
+    from diffusers import FlowMatchEulerDiscreteScheduler
+    from diffusers.utils import export_to_video
+    from fastvideo.models.hunyuan_hf.pipeline_hunyuan import HunyuanVideoPipeline
+    from fastvideo.utils.load import load_transformer
+    from huggingface_hub import snapshot_download
+
+    if not torch.cuda.is_available():
+        raise RuntimeError("A CUDA GPU is required")
+    if torch.version.cuda != "12.1":
+        raise RuntimeError(f"expected the verified PyTorch CUDA 12.1 build, got {torch.version.cuda}")
+    model = Path(snapshot_download(MODEL_ID, revision=args.revision,
+                                   cache_dir=str(hub_cache), token=True))
+    base = Path(snapshot_download(BASE_ID, revision=BASE_REVISION,
+                                  cache_dir=str(hub_cache)))
+    if model.name != args.revision or base.name != BASE_REVISION:
+        raise RuntimeError("Hugging Face snapshot revision differs from the requested commit")
+
+    started = time.perf_counter()
+    transformer = load_transformer("hunyuan_hf", str(model / "transformer"),
+                                   str(base), torch.float32)
+    if transformer.dtype != torch.float32:
+        raise RuntimeError(f"unexpected transformer dtype: {transformer.dtype}")
+    # The public base snapshot supplies both text tokenizers and encoders. This
+    # preserves the pipeline's default prompt template and avoids saved embeds.
+    pipe = HunyuanVideoPipeline.from_pretrained(
+        str(base), transformer=transformer, torch_dtype=torch.bfloat16)
+    if not isinstance(pipe.scheduler, FlowMatchEulerDiscreteScheduler):
+        raise RuntimeError(f"unexpected scheduler: {type(pipe.scheduler).__name__}")
+    if abs(float(pipe.scheduler.config.shift) - SHIFT) > 1e-6:
+        raise RuntimeError(f"unexpected scheduler shift: {pipe.scheduler.config.shift}")
+    pipe.enable_vae_tiling()
+    if args.cpu_offload:
+        pipe.enable_model_cpu_offload()
+    else:
+        pipe.to("cuda:0")
+    load_seconds = time.perf_counter() - started
+
+    generator = torch.Generator(device="cpu").manual_seed(args.seed)
+    torch.cuda.reset_peak_memory_stats(0)
+    started = time.perf_counter()
+    with torch.inference_mode(), torch.autocast("cuda", dtype=torch.bfloat16):
+        frames = pipe(prompt=[args.prompt], height=HEIGHT, width=WIDTH,
+                      num_frames=FRAMES, num_inference_steps=STEPS,
+                      guidance_scale=GUIDANCE_SCALE, generator=generator).frames[0]
+    inference_seconds = time.perf_counter() - started
+    peak_bytes = torch.cuda.max_memory_allocated(0)
+
+    partial = output.with_name(f"{output.stem}.partial.{os.getpid()}.mp4")
+    try:
+        export_to_video(frames, str(partial), fps=FPS)
+        del frames
+        decoded = validate_video(partial)
+        partial.replace(output)
+    finally:
+        if partial.exists():
+            partial.unlink()
+    result = {"output": str(output), "sha256": sha256(output),
+              "model_revision": args.revision, "base_revision": BASE_REVISION,
+              "prompt": args.prompt, "seed": args.seed,
+              "sampling": {"frames": FRAMES, "width": WIDTH, "height": HEIGHT,
+                           "fps": FPS, "steps": STEPS, "shift": SHIFT, "eta": 0,
+                           "classic_cfg": False, "guidance_scale": GUIDANCE_SCALE,
+                           "embedded_guidance": 6018},
+              "load_seconds": round(load_seconds, 2),
+              "inference_seconds": round(inference_seconds, 2),
+              "peak_cuda_allocated_bytes": peak_bytes, "decoded": decoded}
+    print(json.dumps(result, ensure_ascii=False, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as error:
+        print(f"inference failed: {error}", file=sys.stderr, flush=True)
+        raise

install.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -ne 2 ]]; then
+  echo "usage: bash install.sh ABSOLUTE_VENV_DIR ABSOLUTE_PUBLIC_RUNTIME_DIR" >&2
+  exit 2
+fi
+VENV_DIR="$1"
+PUBLIC_DIR="$2"
+[[ "$VENV_DIR" = /* && "$PUBLIC_DIR" = /* ]] || {
+  echo "Both paths must be absolute." >&2
+  exit 2
+}
+[[ ! -e "$VENV_DIR" && ! -e "$PUBLIC_DIR" ]] || {
+  echo "Use fresh venv and public-runtime directories." >&2
+  exit 2
+}
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+PUBLIC_COMMIT=15cc71d53cc2e6e18a68ee607d5fb6ba9a99e344
+PUBLIC_ARCHIVE_SHA256=65e1e74b26989af16ba2232486d461d500249f69ebaa164eb210b69ed17cb1f6
+WORK_DIR="$(dirname -- "$VENV_DIR")"
+export PYTHONNOUSERSITE=1
+unset PYTHONPATH
+export PIP_CONFIG_FILE=/dev/null
+export PIP_EXTRA_INDEX_URL=
+export PIP_DISABLE_PIP_VERSION_CHECK=1
+export PIP_CACHE_DIR="${PIP_CACHE_DIR:-$WORK_DIR/pip-cache}"
+export TMPDIR="${TMPDIR:-$WORK_DIR/tmp}"
+export XDG_CACHE_HOME="${XDG_CACHE_HOME:-$WORK_DIR/xdg-cache}"
+export MAX_JOBS="${MAX_JOBS:-4}"
+mkdir -p "$PIP_CACHE_DIR" "$TMPDIR" "$XDG_CACHE_HOME" "$(dirname -- "$PUBLIC_DIR")"
+
+echo "STAGE create isolated Python 3.12 environment"
+python3.12 -m venv "$VENV_DIR"
+PYTHON="$VENV_DIR/bin/python"
+
+echo "STAGE install PyTorch 2.5.0 CUDA 12.1"
+timeout 1800s "$PYTHON" -m pip install --timeout 60 --retries 3 \
+  --index-url https://download.pytorch.org/whl/cu121 \
+  --extra-index-url https://pypi.org/simple \
+  'torch==2.5.0+cu121' 'torchvision==0.20.0+cu121'
+
+echo "STAGE install pinned inference dependencies"
+timeout 1800s "$PYTHON" -m pip install --timeout 60 --retries 3 \
+  --index-url https://pypi.org/simple \
+  -r "$SCRIPT_DIR/requirements-inference.txt"
+
+echo "STAGE fetch fixed public DanceGRPO source"
+ARCHIVE="$WORK_DIR/DanceGRPO-$PUBLIC_COMMIT.tar.gz"
+timeout 600s curl --fail --location --retry 3 --retry-delay 2 \
+  "https://github.com/XueZeyue/DanceGRPO/archive/$PUBLIC_COMMIT.tar.gz" \
+  --output "$ARCHIVE"
+printf '%s  %s\n' "$PUBLIC_ARCHIVE_SHA256" "$ARCHIVE" | sha256sum --check --status
+mkdir "$PUBLIC_DIR"
+tar --extract --gzip --file "$ARCHIVE" --directory "$PUBLIC_DIR" --strip-components=1 \
+  --no-same-owner --no-same-permissions
+test -f "$PUBLIC_DIR/fastvideo/models/hunyuan_hf/pipeline_hunyuan.py"
+timeout 600s "$PYTHON" -m pip install --timeout 60 --retries 3 \
+  --index-url https://pypi.org/simple --no-deps --editable "$PUBLIC_DIR"
+
+echo "STAGE build fixed flash-attn and install required public loader import"
+timeout 3600s "$PYTHON" -m pip install --timeout 60 --retries 3 \
+  --index-url https://pypi.org/simple --no-build-isolation 'flash-attn==2.7.0.post2'
+timeout 600s "$PYTHON" -m pip install --timeout 60 --retries 3 \
+  --index-url https://pypi.org/simple --no-deps 'liger-kernel==0.4.1'
+
+echo "STAGE verify inference imports and installed versions"
+"$PYTHON" - <<'PY'
+import av, diffusers, fastvideo, huggingface_hub, torch, transformers
+from fastvideo.models.hunyuan_hf.pipeline_hunyuan import HunyuanVideoPipeline
+from fastvideo.utils.load import load_transformer
+assert torch.__version__ == '2.5.0+cu121', torch.__version__
+assert torch.version.cuda == '12.1', torch.version.cuda
+assert diffusers.__version__ == '0.32.0', diffusers.__version__
+assert transformers.__version__ == '4.46.1', transformers.__version__
+print('verified:', torch.__version__, diffusers.__version__, transformers.__version__,
+      av.__version__, huggingface_hub.__version__, flush=True)
+PY
+echo "INSTALL COMPLETE: $VENV_DIR"

requirements-inference.txt

@@ -0,0 +1,42 @@
+# Versions used by the independent public-pipeline inference acceptance.
+# PyTorch, the fixed public runtime, flash-attn, and liger-kernel are installed
+# in that order by install.sh because flash-attn builds against PyTorch.
+accelerate==1.0.1
+av==13.1.0
+certifi==2026.7.22
+charset-normalizer==3.5.2
+diffusers==0.32.0
+einops==0.8.0
+filelock==4.0.12
+fsspec==2026.9.0
+hf_transfer==0.1.9
+huggingface-hub==0.26.1
+idna==3.20
+imageio==2.36.0
+imageio-ffmpeg==0.5.1
+importlib_metadata==9.0.1
+Jinja2==3.1.6
+MarkupSafe==3.0.4
+mpmath==1.3.0
+networkx==3.7
+ninja==1.11.1.1
+numpy==1.26.3
+packaging==26.3
+peft==0.13.2
+pillow==10.2.0
+protobuf==5.28.3
+psutil==7.2.2
+PyYAML==6.0.3
+regex==2026.9.29
+requests==2.34.2
+safetensors==0.8.0
+sentencepiece==0.2.0
+setuptools==84.0.0
+sympy==1.13.1
+tokenizers==0.20.3
+typing_extensions==4.16.0
+tqdm==4.70.1
+transformers==4.46.1
+urllib3==2.8.0
+wheel==0.44.0
+zipp==4.1.1