Remove conversion tools from model repository

NOTICE

@@ -6,5 +6,5 @@ The FL2VA safetensors checkpoint in this repository is a modified derivative of
 MiniMax H3. It was converted from the original Diffusers tensor layout to the
 ComfyUI layout, selectively quantized to INT8 ConvRot, and compressed with a
 dynamic rank-16 representation of the AdaLN time-conditioning curve. The
-included ComfyUI patch and conversion/validation scripts are also modified or
-new files provided for this derivative release.
+included ComfyUI patch is also a modified file provided for this derivative
+release.

README.md

@@ -36,7 +36,6 @@ small ComfyUI core patch included in [`comfy_patch/`](comfy_patch/).
 | [`reports/layer_policy.json`](reports/layer_policy.json) | Exact per-layer precision policy |
 | [`reports/validation.json`](reports/validation.json) | Structural, numerical, and CPU-load results |
 | [`reports/mm_quant_profile_fl2va.json`](reports/mm_quant_profile_fl2va.json) | Row-sampled reconstruction profile for all 200 main matrices |
-| [`tools/`](tools/) | Audited converter, profiler, and validator sources |
 
 This repository intentionally does **not** include the MiniMax-H3 text encoder,
 tokenizer, or video/audio VAEs. The text encoder is being prepared as a separate
@@ -168,15 +167,14 @@ Therefore, 20.999 GiB is the on-disk tensor payload, not a promise that every
 workflow will remain under 24 GiB. Activations, runtime buffers, resolution,
 frame count, batch size, and offloading policy determine peak VRAM.
 
-## Reproduction
+## Conversion provenance
 
 The converter reads the original top-level `transformer/` Diffusers shards from
 MiniMaxAI directly; it does not create a 61+ GiB merged BF16 intermediate. The
 nested task-specific transformer folder was not used because its already-packed
 QKV is head-major, while current ComfyUI expects global `cat(Q,K,V)` packing.
 
-See [`tools/README.md`](tools/README.md) for exact dry-run, CPU-build, and
-validation commands. The official
+The official
 [`minimax_h3_fl2va_pruned_int8_convrot.safetensors`](https://huggingface.co/Comfy-Org/MiniMax-H3/blob/main/diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors)
 was used only as a layout reference and as the source of the FP32
 `rope.inv_freq` tensor absent from the raw Diffusers state dict.

requirements.txt

@@ -1,3 +0,0 @@
-torch
-safetensors
-comfy-kitchen

tools/README.md

@@ -1,49 +0,0 @@
-# Reproduction tools
-
-These are the exact converter, profiler, and validator used for this release,
-with local paths replaced by CLI arguments. They are research utilities, not a
-general MiniMax-H3 conversion library.
-
-Requirements:
-
-- Python 3.10+
-- PyTorch
-- `safetensors`
-- `comfy-kitchen` from a current ComfyUI environment
-
-The converter reads the original top-level Diffusers shards directly; it does
-not need a merged BF16 file. Use `MiniMaxAI/MiniMax-H3`'s `transformer/` folder,
-not the nested task folder whose already-packed QKV uses a different row order.
-It also uses the official pruned ComfyOrg file as a structural reference and to
-copy `rope.inv_freq`, which is absent from the raw Diffusers state dict.
-
-Dry run:
-
-```bash
-python tools/mm_quantize_lean.py fl2va \
-  --src /path/to/MiniMax-H3/transformer \
-  --reference /path/to/minimax_h3_fl2va_pruned_int8_convrot.safetensors \
-  --dst /path/to/output.safetensors \
-  --profile quality21 --time-mode dynamic --rank 16 --device cpu --dry-run
-```
-
-Build on CPU:
-
-```bash
-python tools/mm_quantize_lean.py fl2va \
-  --src /path/to/MiniMax-H3/transformer \
-  --reference /path/to/minimax_h3_fl2va_pruned_int8_convrot.safetensors \
-  --dst /path/to/output.safetensors \
-  --profile quality21 --time-mode dynamic --rank 16 --device cpu --overwrite
-```
-
-Validate:
-
-```bash
-python tools/mm_validate_dynamic_built.py fl2va /path/to/output.safetensors \
-  --src /path/to/MiniMax-H3/transformer --profile quality21
-```
-
-The public scripts preserve the exact mapping and quantization behavior used by
-the release. Some diagnostic messages remain in Russian because these files are
-the audited build sources rather than a rewritten approximation.

tools/convert_int8_convrot.py

@@ -1,556 +0,0 @@
-# -*- coding: utf-8 -*-
-r"""Конвертер моделей ComfyUI в INT8 ConvRot.
-
-Берёт safetensors (bf16/fp16/fp32) и квантует линейные слои в int8 с поворотом
-Адамара, как это делают официальные сборки Comfy-Org (int8_tensorwise + convrot).
-
-Не трогает: нормализации, эмбеддеры, bias, 1D-тензоры и матрицы, у которых
-входная размерность не кратна размеру группы — они остаются в исходной точности.
-
-Запуск:
-  python_embeded\python.exe -s tools\convert_int8_convrot.py <вход.safetensors> <выход.safetensors>
-     [--groupsize 256] [--device cuda:0] [--dry-run]
-"""
-import argparse
-import json
-import os
-import re
-import sys
-import time
-
-import torch
-from safetensors import safe_open
-from safetensors.torch import save_file
-
-
-class HFShardReader:
-    """Читает HF-репозиторий (папку с шардами) так же, как safe_open один файл.
-
-    Нужно, чтобы квантовать прямо из оригинала, не складывая на диск
-    промежуточный файл на десятки гигабайт. Значения при этом те же самые:
-    склейка ничего не меняла, но лишняя запись и чтение никому не нужны.
-
-    Имена приводятся к раскладке ComfyUI теми же правилами, что в
-    merge_hf_to_comfy.py, визуальная часть остаётся на месте.
-    """
-
-    RENAME = [
-        ("model.language_model.", "model."),
-        ("language_model.model.", "model."),
-        ("language_model.", ""),
-        ("vision_tower.", ""),
-    ]
-
-    def __init__(self, path: str):
-        import glob
-        self._files = {}
-        self._map = {}
-        shards = sorted(glob.glob(os.path.join(path, "*.safetensors")))
-        if not shards:
-            raise SystemExit(f"в папке нет файлов safetensors: {path}")
-        for shard in shards:
-            f = safe_open(shard, framework="pt")
-            self._files[shard] = f
-            for k in f.keys():
-                self._map[self._rename(k)] = (shard, k)
-        print(f"  прочитано шардов: {len(shards)}, тензоров: {len(self._map)}")
-
-    @classmethod
-    def _rename(cls, key: str) -> str:
-        for old, new in cls.RENAME:
-            if key.startswith(old):
-                rest = key[len(old):]
-                return rest if rest.startswith("model.") or not new else new + rest
-        return key
-
-    def keys(self):
-        return list(self._map)
-
-    def get_tensor(self, key: str):
-        shard, orig = self._map[key]
-        return self._files[shard].get_tensor(orig)
-
-    def metadata(self):
-        return {"format": "pt"}
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc):
-        self._files.clear()
-
-sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "ComfyUI"))
-
-# Слои, которые официальные сборки Comfy-Org оставляют в исходной точности:
-# нормализации, эмбеддеры, входной/выходной слой. Их квантование заметно бьёт по качеству.
-SKIP_TOKENS = (
-    # диффузионные трансформеры
-    # "_emb." с точкой, а не "_emb": иначе под запрет попадают модули вида
-    # video_embeddings_connector - а это обычные блоки внимания и полносвязные
-    # слои на 4 ГБ, которые квантовать можно и нужно
-    "norm", "embedder", "pad_token", "emb.", "_emb.",
-    "final_layer", "x_embedder", "proj_out", "time_in", "vector_in",
-    # Слои модуляции: выдают масштаб и сдвиг для каждого блока, поэтому ошибка
-    # в них умножается на всю сеть. Мы их не квантуем НИКОГДА - это наше решение
-    # по замеру, а не подражание чужим сборкам.
-    #
-    # Единодушия у авторов тут нет, пересчитано по файлам на диске 31.07.2026:
-    #   LTX 2.3      0 из 24  квантовано
-    #   Anima        0 из 170
-    #   Z-Image     32 из 33  <- квантует, вопреки прежней записи в этом коде
-    # Поэтому по Z-Image и Ideogram сверка audit_reference_int8.py всегда будет
-    # показывать ~84 %, и это ОСОЗНАННОЕ расхождение, а не промах правила.
-    "adaln", "modulation",
-    # входные проекции (diffusers-нейминг): в эталонных сборках Comfy-Org,
-    # obsxrver и supermind они всегда остаются в исходной точности - проверено
-    # по файлам LTX 2.3, Z-Image, Krea 2 и Qwen-Image
-    "img_in", "txt_in", "patch_embed", "context_embedder",
-    # языковые модели (текст-энкодеры)
-    "lm_head", "embed_tokens", "token_embd", "shared.", "wte", "wpe",
-    # части полных чекпоинтов, которые квантовать нельзя: VAE свёрточный и к
-    # int8 чувствителен, текстовая проекция маленькая и стоит на входе, а
-    # per_channel_statistics - это вообще не веса, а нормировочные константы
-    "vae.", "text_embedding_projection", "per_channel_statistics", "vocoder.",
-)
-
-# Коэффициенты подрезания выбросов при подборе масштаба.
-# У диффузионных моделей оптимум почти всегда в 0.95-1.00 (медиана 0.982), поэтому
-# основная часть сетки плотная: шаг 0.001 в диапазоне 1.000-0.940. Но у текст-энкодеров
-# хвосты тяжелее: у qwen2.5-VL 3.2% строк упирались в край 0.940, то есть их оптимум
-# лежал ещё ниже и просто не находился. Поэтому дальше идёт разреженный хвост до 0.80 -
-# он почти не стоит времени, зато снимает обрезание перебора. См. tools/check_range.py.
-def build_ratios(lo: float = 0.80) -> tuple:
-    """Сетка от 1.0 вниз до lo: плотно у единицы, дальше всё разреженнее."""
-    out = [round(1.0 - i * 0.001, 4) for i in range(61)]       # 1.000 .. 0.940
-    out += [round(0.938 - i * 0.002, 4) for i in range(20)]    # 0.938 .. 0.900
-    out += [round(0.895 - i * 0.005, 4) for i in range(20)]    # 0.895 .. 0.800
-    return tuple(r for r in out if r >= lo - 1e-9)
-
-
-SEARCH_RATIOS = build_ratios()
-
-
-# Поворот Адамара строится удвоением матрицы 4x4, поэтому размер группы обязан
-# быть степенью четвёрки (см. _build_hadamard: "Regular Hadamard size must be a
-# power of 4"). Отсюда и лесенка: 256 -> 64 -> 16.
-GROUPSIZE_LADDER = (256, 64, 16)
-
-_DIGITS = re.compile(r"\d+")
-# Порог повторяемости. Два - это ещё не стопка: linear_fc1/linear_fc2 одного
-# модуля дают ровно два совпадения по шаблону.
-REPEAT_MIN = 3
-
-
-def block_patterns(layer: str) -> tuple[str, ...]:
-    """Варианты имени, где обезличена ровно одна числовая позиция.
-
-    Одновременная замена всех цифр смешивала независимые роли. Например,
-    ``blocks.0.mlp.fc1`` и ``blocks.1.mlp.fc2`` превращались в один шаблон.
-    Из-за этого два блока token_refiner с fc1/fc2 давали ложную стопку из
-    четырёх слоёв и проходили порог повторяемости 3.
-    """
-    return tuple(layer[:m.start()] + "#" + layer[m.end():] for m in _DIGITS.finditer(layer))
-
-
-def repeated_layers(layer_names, repeat_min: int = REPEAT_MIN) -> set:
-    """Слои, которые входят в повторяющуюся стопку блоков.
-
-    Зачем это вместо списка подстрок. Эталонные сборки квантуют тело сети и
-    оставляют в исходной точности края: входные проекции, выходные головы,
-    таблицы вложений, мост зрение->язык. Объединяет их не название, а то, что
-    они существуют в единственном экземпляре, тогда как тело - это одна и та же
-    ноd, повторённая по числу блоков. Номер блока в имени и есть тот признак,
-    который отличает тело от края, и он не зависит от того, как автор модели
-    назвал свои модули.
-
-    Проверено сверкой с эталонами (tools/audit_reference_int8.py): по этому
-    признаку сами собой отсеиваются lm_head, embed_tokens, patchify_proj,
-    visual.merger, visual.pos_embed, adaln_single.emb.* - всё то, что раньше
-    приходилось перечислять руками.
-    """
-    counts: dict[str, int] = {}
-    for name in layer_names:
-        for pattern in set(block_patterns(name)):
-            counts[pattern] = counts.get(pattern, 0) + 1
-    return {
-        name for name in layer_names
-        if any(counts[pattern] >= repeat_min for pattern in block_patterns(name))
-    }
-
-
-def pick_groupsize(out_f: int, in_f: int, groupsize) -> int | None:
-    """Какую группу взять этому слою. Число - взять его же или отказать.
-
-    "auto" спускается по лесенке до первой группы, на которую делится входная
-    размерность. Это нужно зрительным башням: у Qwen3-VL ширина 1152 и 4304, ни
-    одна из них не кратна 256, поэтому при фиксированной группе всё зрение
-    оставалось в bf16. Эталонные сборки supermind делают ровно так же - проверено
-    по comfy_quant в qwen3vl_8b_int8_convrot: 256 у языковой части, 64 у
-    visual.attn, 16 у visual.mlp.linear_fc2.
-    """
-    if groupsize != "auto":
-        g = int(groupsize)
-        return g if in_f % g == 0 and min(out_f, in_f) >= g else None
-    # Мелкая группа - способ достать слой с неудобной шириной, а не разрешение
-    # квантовать что угодно узкое. Порог по узкой стороне остаётся базовым (256),
-    # иначе в отбор лезут краевые слои: gate_logits (32 x 4096) и входные
-    # проекции с пикселей patchify_proj (4096 x 128). Эталонные сборки LTX их не
-    # берут - сверено поимённо в tools/audit_reference_int8.py.
-    if min(out_f, in_f) < GROUPSIZE_LADDER[0]:
-        return None
-    for g in GROUPSIZE_LADDER:
-        if in_f % g == 0:
-            return g
-    return None
-
-
-def should_quantize(name: str, t: torch.Tensor, groupsize,
-                    skip_tokens=None, repeated=None) -> tuple[bool, str, int]:
-    if not name.endswith(".weight"):
-        return False, "не weight", 0
-    if t.ndim != 2:
-        return False, f"ndim={t.ndim}", 0
-    if repeated is not None and name[: -len(".weight")] not in repeated:
-        return False, "одиночный слой (не повторяется по блокам)", 0
-    low = name.lower()
-    for tok in (SKIP_TOKENS if skip_tokens is None else skip_tokens):
-        if tok in low:
-            return False, f"имя содержит '{tok}'", 0
-    out_f, in_f = t.shape
-    g = pick_groupsize(out_f, in_f, groupsize)
-    if g is None:
-        if in_f % (int(groupsize) if groupsize != "auto" else GROUPSIZE_LADDER[-1]):
-            return False, f"in_features {in_f} не кратно {groupsize}", 0
-        return False, f"слишком маленький слой {tuple(t.shape)}", 0
-    return True, "", g
-
-
-def _cost(residual: torch.Tensor, objective: str, step: torch.Tensor,
-          chan_w: torch.Tensor | None = None) -> torch.Tensor:
-    """Во что нам обходится остаток. Сетка значений всегда равномерная - ядро
-    разжимает строго как q*scale, кодбука в формате нет. Свободен только критерий,
-    по которому выбирается точка подрезания, и от него зависит, насколько сильно
-    мы готовы жертвовать выбросами ради основной массы весов.
-
-      mse   - квадрат: выбросы дороги, подрезаем осторожно
-      l1    - модуль: выбросы дешевле, подрезаем смелее
-      huber - квадрат вблизи нуля, модуль дальше: компромисс
-    """
-    # Взвешивание по каналам (AWQ-стиль): ошибка в канале, по которому приходят
-    # большие активации, стоит дороже. chan_w - средний квадрат входа по каналам,
-    # снятый capture_activations.py уже в повёрнутом пространстве. Это в точности
-    # диагональ гессиана слоя, то есть переход от "ошибки весов" к "ошибке выхода".
-    if objective == "mse":
-        sq = residual ** 2
-        if chan_w is not None:
-            sq = sq * chan_w
-        return sq.sum(dim=1, keepdim=True)
-    if objective == "l1":
-        a = residual.abs()
-        if chan_w is not None:
-            a = a * chan_w
-        return a.sum(dim=1, keepdim=True)
-    if objective == "huber":
-        d = step                      # порог - один шаг кванта
-        a = residual.abs()
-        quad = torch.minimum(a, d)
-        h = 0.5 * quad ** 2 + d * (a - quad)
-        if chan_w is not None:
-            h = h * chan_w
-        return h.sum(dim=1, keepdim=True)
-    raise SystemExit(f"неизвестный критерий {objective}")
-
-
-def quantize_search(w: torch.Tensor, groupsize: int, ratios,
-                    objective: str = "mse",
-                    qmin: int = -127,
-                    sign_aware: bool = False,
-                    ls_refit: bool = False,
-                    chan_w: torch.Tensor | None = None,
-                    clip_margin: float = 0.0) -> tuple[torch.Tensor, torch.Tensor]:
-    """INT8 ConvRot с подбором масштаба по минимуму ошибки (вместо простого absmax).
-
-    Официальные сборки берут scale = absmax/127. Небольшое подрезание выбросов
-    почти всегда уменьшает суммарную ошибку: редкие большие веса округляются
-    чуть грубее, зато основная масса значений ложится на сетку точнее.
-    """
-    from comfy_kitchen.backends.eager.quantization import _build_hadamard, _rotate_weight
-
-    h = _build_hadamard(groupsize, device=w.device, dtype=w.dtype)
-    w_rot = _rotate_weight(w, h, groupsize)
-
-    absmax = w_rot.abs().amax(dim=1, keepdim=True).clamp(min=1e-12)
-    best_scale = absmax / 127.0
-    best_err = torch.full_like(absmax, float("inf"))
-
-    if sign_aware:
-        # Единственный честный способ дотянуться до -128: разрешать его только
-        # тем строкам, у которых отрицательный хвост и так длиннее положительного.
-        # Тогда несимметричная сетка не создаёт перекос, а повторяет уже имеющийся.
-        neg_heavy = w_rot.amin(dim=1, keepdim=True).abs() > w_rot.amax(dim=1, keepdim=True)
-        lo = torch.where(neg_heavy, -128.0, -127.0).to(w_rot.dtype)
-    else:
-        lo = torch.full_like(absmax, float(qmin))
-    hi = torch.full_like(absmax, 127.0)
-
-    # qmin=-127 (симметрично) по умолчанию. Значение -128 формально доступно и
-    # уменьшает ошибку весов, но вносит односторонний сдвиг: сетка перестаёт быть
-    # симметричной, у ошибки появляется ненулевое среднее, и на генерации это
-    # выходит дороже выигрыша. Проверено на стенде - см. bench_quant.py.
-    for r in ratios:
-        scale = absmax * r / 127.0
-        q = torch.minimum(torch.maximum(torch.round(w_rot / scale), lo), hi)
-        err = _cost(q * scale - w_rot, objective, scale, chan_w)
-        better = err < best_err
-        best_err = torch.where(better, err, best_err)
-        best_scale = torch.where(better, scale, best_scale)
-
-    if clip_margin > 0.0:
-        # Порог на подрезание. Эталонные сборки оставляют без подрезания заметно
-        # больше строк, чем даёт чистый минимум MSE (у qwen3-4b 9.4% против наших
-        # 2-3%), и на выходе энкодера это оказывается лучше. Похоже, у выбросов
-        # есть функциональная роль, которую квадрат ошибки не видит. Поэтому режем
-        # только там, где выигрыш действительно заметный.
-        s0 = absmax / 127.0
-        q0 = torch.minimum(torch.maximum(torch.round(w_rot / s0), lo), hi)
-        e0 = _cost(q0 * s0 - w_rot, objective, s0, chan_w)
-        keep = best_err >= e0 * (1.0 - clip_margin)
-        best_scale = torch.where(keep, s0, best_scale)
-        del q0
-
-    q = torch.minimum(torch.maximum(torch.round(w_rot / best_scale), lo), hi)
-
-    if ls_refit:
-        # При фиксированных целых q оптимальный по МНК масштаб - это (q·w)/(q·q),
-        # а не absmax/127. Пересчёт убирает систематический сдвиг реконструкции,
-        # который и появляется, когда сетка перестаёт быть симметричной.
-        num = (q * w_rot).sum(dim=1, keepdim=True)
-        den = (q * q).sum(dim=1, keepdim=True).clamp(min=1.0)
-        best_scale = torch.where(num > 0, num / den, best_scale)
-
-    return q.to(torch.int8), best_scale.to(torch.float32)
-
-
-def quantize_int4(w: torch.Tensor, groupsize: int):
-    """Тот же поворот Адамара, но 4 бита вместо 8.
-
-    Ядро читает такой слой по маркеру format=convrot_w4a4 и жёстко ожидает
-    quant_group_size=64 (см. comfy/ops.py, ветка convrot_w4a4), поэтому размер
-    группы квантования не настраиваем.
-    """
-    from comfy_kitchen.tensor.convrot_w4a4 import TensorCoreConvRotW4A4Layout
-    qdata, params = TensorCoreConvRotW4A4Layout.quantize(
-        w, convrot_groupsize=groupsize, quant_group_size=64, linear_dtype="int4")
-    return qdata, params.scale
-
-
-def int4_error(w: torch.Tensor, groupsize: int) -> float:
-    """Во сколько раз 4 бита дороже 8 на этом слое. Нужно, чтобы выбрать,
-    какие слои не жалко ужать сильнее."""
-    from comfy_kitchen.tensor.convrot_w4a4 import TensorCoreConvRotW4A4Layout
-    q8, s8 = quantize_search(w, groupsize, SEARCH_RATIOS)
-    from comfy_kitchen.tensor.int8 import TensorWiseINT8Layout
-    p8 = TensorWiseINT8Layout.Params(scale=s8, orig_dtype=torch.float32,
-                                     orig_shape=tuple(q8.shape), is_weight=True,
-                                     convrot=True, convrot_groupsize=groupsize)
-    e8 = (TensorWiseINT8Layout.dequantize(q8.to(w.device), p8) - w).norm().item()
-
-    q4, params4 = TensorCoreConvRotW4A4Layout.quantize(
-        w, convrot_groupsize=groupsize, quant_group_size=64, linear_dtype="int4")
-    e4 = (TensorCoreConvRotW4A4Layout.dequantize(q4, params4).float() - w).norm().item()
-    return e4 / max(e8, 1e-12)
-
-
-def load_calib(path: str, alpha: float, device: str):
-    """Статистика активаций из capture_activations.py -> веса каналов."""
-    if not path:
-        return None
-    blob = torch.load(path, map_location="cpu")
-    stats = blob["stats"]
-    out = {}
-    for name, v in stats.items():
-        w = v.to(device=device, dtype=torch.float32).clamp(min=1e-12)
-        w = w / w.mean()                       # нормируем, чтобы масштаб ошибки не поехал
-        out[name] = w.pow(alpha).reshape(1, -1)
-    print(f"калибровка: {path}\n  слоёв {len(out)}, промптов {blob.get('prompts')}, "
-          f"шагов {blob.get('steps')}, показатель {alpha}")
-    return out
-
-
-def calib_for(calib, tensor_name: str):
-    """Ключи калибровки - пути модулей, ключи файла - они же плюс '.weight'."""
-    if not calib:
-        return None
-    layer = tensor_name[: -len(".weight")]
-    if layer in calib:
-        return calib[layer]
-    for prefix in ("model.diffusion_model.", "diffusion_model.", "model."):
-        if layer.startswith(prefix) and layer[len(prefix):] in calib:
-            return calib[layer[len(prefix):]]
-    return None
-
-
-def convert(src: str, dst: str, groupsize: int, device: str, dry_run: bool,
-            search: bool = False, objective: str = "mse", qmin: int = -127,
-            sign_aware: bool = False, ls_refit: bool = False,
-            calib_path: str = "", calib_alpha: float = 1.0,
-            search_min: float = 0.80, clip_margin: float = 0.0,
-            quant_adaln: bool = False, skip_connectors: bool = False,
-            select: str = "names", drop_prefixes: tuple = (),
-            passthrough_dtype: str = "") -> None:
-    t0 = time.time()
-    ratios = build_ratios(search_min)
-    skip = SKIP_TOKENS
-    if skip_connectors:
-        # Вернуть старое поведение: не трогать *_embeddings_connector. Это 96 слоёв
-        # обычного внимания и полносвязных на 4 ГБ, которые эталонные сборки
-        # пропускают. Нужно, чтобы отделить вклад коннекторов от вклада подрезания.
-        skip = tuple(t for t in skip if t != "_emb.") + ("_emb",)
-        print("режим: коннекторы НЕ квантуются (как в эталонных сборках)")
-    if quant_adaln:
-        # AdaLN задаёт масштаб и сдвиг каждому блоку, поэтому его везде защищают.
-        # Но это восьмибитный шаг, а не четырёхбитный - проверяем замером, а не верой.
-        skip = tuple(t for t in SKIP_TOKENS if t not in ("adaln", "modulation"))
-        print("режим: AdaLN тоже квантуется")
-    if groupsize == "auto":
-        print(f"режим: группа подбирается послойно по лесенке {GROUPSIZE_LADDER}")
-    out: dict[str, torch.Tensor] = {}
-    quantized = skipped = 0
-    skip_reasons: dict[str, int] = {}
-    gs_used: dict[int, int] = {}
-    calib = load_calib(calib_path, calib_alpha, device)
-    calib_hits = 0
-
-    # папка = HF-репозиторий, читаем шарды напрямую; файл = как раньше
-    opener = HFShardReader(src) if os.path.isdir(src) else safe_open(src, framework="pt")
-    with opener as f:
-        keys = list(f.keys())
-        # ComfyUI читает конфигурацию модели из метаданных файла (model_detection.py:
-        # dit_config.update(json.loads(metadata["config"])...). Без них он строит
-        # ��одель по умолчанию, и чекпоинт не грузится: "size mismatch for
-        # scale_shift_table: [9, 4096] vs [6, 4096]". Переносим как есть.
-        meta = f.metadata()
-        print(f"вход: {src}\n  тензоров: {len(keys)}"
-              f"{', метаданных: ' + str(len(meta)) if meta else ', метаданных нет'}")
-
-        repeated = None
-        if select in ("structure", "both"):
-            names = [k[: -len(".weight")] for k in keys if k.endswith(".weight")]
-            repeated = repeated_layers(names)
-            print(f"  повторяющихся по блокам слоёв: {len(repeated)} из {len(names)}")
-        if select == "structure":
-            skip = ()  # имена больше не участвуют, отбор чисто структурный
-
-        for i, k in enumerate(keys, 1):
-            if drop_prefixes and k.startswith(drop_prefixes):
-                skip_reasons["выброшен(--drop)"] = skip_reasons.get("выброшен(--drop)", 0) + 1
-                continue
-            t = f.get_tensor(k)
-            ok, why, gs = should_quantize(k, t, groupsize, skip, repeated)
-            if not ok:
-                skipped += 1
-                skip_reasons[why.split()[0]] = skip_reasons.get(why.split()[0], 0) + 1
-                if passthrough_dtype == "bf16" and t.dtype == torch.float32:
-                    t = t.to(torch.bfloat16)
-                out[k] = t
-                continue
-            gs_used[gs] = gs_used.get(gs, 0) + 1
-
-            if dry_run:
-                quantized += 1
-                continue
-
-            # поворот и подбор масштаба считаем в float32: в bf16 сама ротация
-            # вносит заметную ошибку (проверено на эталонных сборках)
-            w = t.to(device=device, dtype=torch.float32)
-            # оба режима идут через один и тот же код: absmax - это просто подбор
-            # по единственному коэффициенту 1.0
-            cw = calib_for(calib, k)
-            calib_hits += cw is not None
-            qdata, scale = quantize_search(
-                w, gs, ratios if search else (1.0,), objective, qmin,
-                sign_aware, ls_refit, cw, clip_margin)
-            layer = k[: -len(".weight")]
-            out[k] = qdata.cpu()
-            out[f"{layer}.weight_scale"] = scale.cpu()
-            conf = {"format": "int8_tensorwise", "convrot": True, "convrot_groupsize": gs}
-            out[f"{layer}.comfy_quant"] = torch.tensor(
-                list(json.dumps(conf).encode("utf-8")), dtype=torch.uint8)
-            quantized += 1
-            del w, qdata, scale
-
-            if i % 50 == 0 or i == len(keys):
-                done = quantized + skipped
-                print(f"  [{done}/{len(keys)}] квантовано {quantized}, пропущено {skipped}",
-                      flush=True)
-
-    print(f"\nитог: квантовано {quantized}, оставлено {skipped}")
-    print("  причины пропуска:", skip_reasons)
-    print("  размеры групп:", dict(sorted(gs_used.items(), reverse=True)))
-    if calib:
-        print(f"  калибровка нашлась для {calib_hits} из {quantized} слоёв")
-        if calib_hits < quantized:
-            print("  ВНИМАНИЕ: часть слоёв квантована без калибровки - проверь имена")
-    if dry_run:
-        print("(dry-run: файл не записан)")
-        return
-
-    os.makedirs(os.path.dirname(os.path.abspath(dst)), exist_ok=True)
-    save_file(out, dst, metadata=meta if meta else None)
-    src_gb = os.path.getsize(src) / 1e9
-    dst_gb = os.path.getsize(dst) / 1e9
-    print(f"\nзаписано: {dst}\n  {src_gb:.2f} GB -> {dst_gb:.2f} GB  за {time.time()-t0:.0f} c")
-
-
-if __name__ == "__main__":
-    ap = argparse.ArgumentParser()
-    ap.add_argument("src")
-    ap.add_argument("dst")
-    ap.add_argument("--groupsize", default=256,
-                    type=lambda v: v if v == "auto" else int(v),
-                    help="число или auto — тогда группа подбирается послойно "
-                         f"по лесенке {GROUPSIZE_LADDER}, как в эталонных сборках")
-    ap.add_argument("--device", default="cuda:0")
-    ap.add_argument("--dry-run", action="store_true")
-    ap.add_argument("--no-search-scale", action="store_true",
-                    help="взять простой absmax вместо подбора масштаба (быстрее, но хуже эталона)")
-    ap.add_argument("--objective", default="mse", choices=("mse", "l1", "huber"),
-                    help="критерий выбора точки подрезания выбросов")
-    ap.add_argument("--asymmetric", action="store_true",
-                    help="р��зрешить -128 всем строкам (ошибка весов меньше, на генерации хуже)")
-    ap.add_argument("--sign-aware", action="store_true",
-                    help="разрешать -128 только строкам с длинным отрицательным хвостом")
-    ap.add_argument("--ls-refit", action="store_true",
-                    help="пересчитать масштаб по МНК после выбора целых значений")
-    ap.add_argument("--calib", default="",
-                    help="файл статистики активаций от capture_activations.py")
-    ap.add_argument("--calib-alpha", type=float, default=1.0,
-                    help="показатель степени для веса канала: 1.0 - диагональ гессиана, "
-                         "0.5 - мягче, 0.0 - как без калибровки")
-    ap.add_argument("--search-min", type=float, default=0.80,
-                    help="нижняя граница перебора коэффициентов подрезания")
-    ap.add_argument("--skip-connectors", action="store_true",
-                    help="не квантовать *_embeddings_connector, как в эталонных сборках")
-    ap.add_argument("--quant-adaln", action="store_true",
-                    help="квантовать и слои модуляции AdaLN (ещё ~0.34 ГБ экономии)")
-    ap.add_argument("--clip-margin", type=float, default=0.0,
-                    help="подрезать строку, только если ошибка падает больше чем на эту долю "
-                         "(0.03 = на 3%%); иначе оставить absmax")
-    ap.add_argument("--select", default="names", choices=("names", "structure", "both"),
-                    help="как отбирать слои: names — по списку подстрок (как раньше); "
-                         "structure — по повторяемости в стопке блоков, без имён; "
-                         "both — оба условия сразу")
-    ap.add_argument("--drop-prefixes", default="",
-                    help="префиксы через запятую: такие тензоры НЕ переносить в выход "
-                         "вовсе (для LTX: vae.,audio_vae.,vocoder.,text_embedding_projection. "
-                         "— компоненты лежат отдельными файлами, дубли не нужны)")
-    ap.add_argument("--passthrough-dtype", default="", choices=("", "bf16"),
-                    help="во что кастовать НЕквантуемые тензоры (для fp32-исходников "
-                         "вроде HiDream-O1: без этого эмбеддинги уедут в выход в fp32)")
-    a = ap.parse_args()
-    convert(a.src, a.dst, a.groupsize, a.device, a.dry_run,
-            not a.no_search_scale, a.objective, -128 if a.asymmetric else -127,
-            a.sign_aware, a.ls_refit, a.calib, a.calib_alpha, a.search_min,
-            a.clip_margin, a.quant_adaln, a.skip_connectors, a.select,
-            tuple(p for p in a.drop_prefixes.split(",") if p),
-            a.passthrough_dtype)

tools/mm_profile_main_quant.py

@@ -1,143 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Profile sampled INT8 convrot reconstruction error for all MiniMax-H3 DiT weights.
-
-The profiler keeps every input column (so Hadamard rotation is exact) but samples
-output rows deterministically.  It is intended for choosing a small BF16 island;
-the final converter still quantizes every retained INT8 tensor in full.
-"""
-import argparse
-import json
-import os
-import sys
-import time
-
-import torch
-
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-ROOT = os.environ.get("MINIMAX_H3_ROOT", os.getcwd())
-TOOLS = SCRIPT_DIR
-sys.path.insert(0, TOOLS)
-
-from convert_int8_convrot import build_ratios, quantize_search  # noqa: E402
-from mm_quantize_lean import ShardReader  # noqa: E402
-from comfy_kitchen.backends.eager.quantization import _build_hadamard, _rotate_weight  # noqa: E402
-
-sys.stdout.reconfigure(encoding="utf-8")
-torch.set_grad_enabled(False)
-
-
-SHAPES = {
-    "attn.qkv_proj": (21504, 5376),
-    "attn.out_proj": (5376, 7168),
-    "mlp.fc1": (28672, 5376),
-    "mlp.fc2": (5376, 14336),
-}
-
-
-def source_weight(reader, block, kind):
-    prefix = f"transformer_blocks.{block}"
-    if kind == "attn.qkv_proj":
-        return torch.cat([reader.get_tensor(f"{prefix}.attn.to_{part}.weight") for part in "qkv"], dim=0)
-    if kind == "attn.out_proj":
-        return reader.get_tensor(f"{prefix}.attn.to_out.0.weight")
-    if kind == "mlp.fc1":
-        weight = reader.get_tensor(f"{prefix}.ff.net.0.proj.weight")
-        half = weight.shape[0] // 2
-        return torch.cat((weight[half:], weight[:half]), dim=0)
-    if kind == "mlp.fc2":
-        return reader.get_tensor(f"{prefix}.ff.net.2.weight")
-    raise ValueError(kind)
-
-
-def sampled_rows(weight, count):
-    if weight.shape[0] <= count:
-        return weight
-    index = torch.linspace(0, weight.shape[0] - 1, count, dtype=torch.float64).round().long()
-    return weight.index_select(0, index)
-
-
-def profile(weight, groupsize, rows, ratios, device, clip_margin):
-    sample = sampled_rows(weight, rows).to(device=device, dtype=torch.float32)
-    hadamard = _build_hadamard(groupsize, device=sample.device, dtype=sample.dtype)
-    rotated = _rotate_weight(sample, hadamard, groupsize)
-    absmax = rotated.abs().amax(dim=1, keepdim=True).clamp(min=1e-12)
-    scale0 = absmax / 127.0
-    q0 = torch.round(rotated / scale0).clamp(-127, 127)
-    err0 = ((q0 * scale0 - rotated).norm() / rotated.norm()).item()
-    q, scale = quantize_search(sample, groupsize, ratios, clip_margin=clip_margin)
-    err = ((q.float() * scale - rotated).norm() / rotated.norm()).item()
-    clipped = (scale < scale0 * 0.9999).float().mean().item()
-    del sample, hadamard, rotated, absmax, scale0, q0, q, scale
-    return err0, err, clipped
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("variant", choices=("fl2va", "ref2va"))
-    ap.add_argument("--src", default="", help="raw diffusers transformer directory")
-    ap.add_argument("--device", default="cuda:1")
-    ap.add_argument("--rows", type=int, default=192)
-    ap.add_argument("--blocks", type=int, default=50,
-                    help="число первых блоков; только для короткой проверки профайлера")
-    ap.add_argument("--groupsize", type=int, choices=(16, 64, 256), default=256)
-    ap.add_argument("--search-min", type=float, default=0.80)
-    ap.add_argument("--clip-margin", type=float, default=0.05)
-    ap.add_argument("--out", default="")
-    args = ap.parse_args()
-
-    source = args.src or os.path.join(ROOT, "HF",
-                                     "transformer" if args.variant == "fl2va" else "transformer_ref")
-    out = args.out or os.path.join(ROOT, "comfy_headless", f"mm_quant_profile_{args.variant}.json")
-    ratios = build_ratios(args.search_min)
-    results = []
-    started = time.time()
-    print(f"source={source}\ndevice={args.device} rows={args.rows} g={args.groupsize}\nout={out}", flush=True)
-
-    with ShardReader(source) as reader:
-        for block in range(args.blocks):
-            block_started = time.time()
-            for kind, shape in SHAPES.items():
-                weight = source_weight(reader, block, kind)
-                if tuple(weight.shape) != shape:
-                    raise RuntimeError(f"blocks.{block}.{kind}: {tuple(weight.shape)} != {shape}")
-                err0, err, clipped = profile(weight, args.groupsize, args.rows, ratios,
-                                             args.device, args.clip_margin)
-                count = weight.numel()
-                out_features = weight.shape[0]
-                int8_bytes = count + out_features * 4 + len(json.dumps({
-                    "format": "int8_tensorwise", "convrot": True,
-                    "convrot_groupsize": args.groupsize}).encode("utf-8"))
-                bf16_delta = count * 2 - int8_bytes
-                results.append({
-                    "layer": f"blocks.{block}.{kind}",
-                    "block": block,
-                    "kind": kind,
-                    "shape": list(weight.shape),
-                    "sample_rows": min(args.rows, weight.shape[0]),
-                    "absmax_error": err0,
-                    "searched_error": err,
-                    "improvement": err0 - err,
-                    "clipped_row_fraction": clipped,
-                    "bf16_delta_bytes": bf16_delta,
-                })
-                del weight
-            print(f"block {block:02d}/49: {time.time() - block_started:.1f}s, total {time.time() - started:.0f}s",
-                  flush=True)
-
-    payload = {
-        "variant": args.variant,
-        "source": source,
-        "groupsize": args.groupsize,
-        "rows": args.rows,
-        "search_min": args.search_min,
-        "clip_margin": args.clip_margin,
-        "elapsed_seconds": time.time() - started,
-        "layers": results,
-    }
-    with open(out, "w", encoding="utf-8") as stream:
-        json.dump(payload, stream, ensure_ascii=False, indent=2)
-    print(f"готово: {out}; слоёв={len(results)}, {time.time() - started:.0f}s", flush=True)
-
-
-if __name__ == "__main__":
-    main()

tools/mm_quantize_lean.py

@@ -1,562 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Build MiniMax-H3 INT8 lean-convrot + high-precision adaLN curve.
-
-The input is the original diffusers transformer/transformer_ref directory.
-Q/K/V packing and fc1 ordering are converted while streaming, so the script
-does not need a 61.7 GiB merged BF16 file or a 20-44 GiB tensor dictionary in
-RAM.
-"""
-import argparse
-import json
-import math
-import os
-import re
-import struct
-import sys
-import time
-
-import torch
-import torch.nn.functional as F
-from safetensors import safe_open
-
-
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-ROOT = os.environ.get("MINIMAX_H3_ROOT", os.getcwd())
-HF = os.path.join(ROOT, "HF")
-COMFYORG = os.path.join(ROOT, "comfyorg")
-TOOLS = SCRIPT_DIR
-MODELS = os.path.join(ROOT, "output")
-
-sys.path.insert(0, TOOLS)
-from convert_int8_convrot import build_ratios, quantize_search  # noqa: E402
-
-sys.stdout.reconfigure(encoding="utf-8")
-torch.set_grad_enabled(False)
-
-
-DTYPE_BYTES = {"F64": 8, "F32": 4, "F16": 2, "BF16": 2, "I64": 8,
-               "I32": 4, "I16": 2, "I8": 1, "U8": 1, "BOOL": 1}
-TORCH_TO_ST = {torch.float64: "F64", torch.float32: "F32", torch.float16: "F16",
-               torch.bfloat16: "BF16", torch.int64: "I64", torch.int32: "I32",
-               torch.int16: "I16", torch.int8: "I8", torch.uint8: "U8",
-               torch.bool: "BOOL"}
-def quant_blob(groupsize):
-    return json.dumps({"format": "int8_tensorwise", "convrot": True,
-                       "convrot_groupsize": groupsize}).encode("utf-8")
-
-
-def block_layers(blocks, suffix):
-    return tuple(f"blocks.{block}.{suffix}" for block in blocks)
-
-
-# Deterministic 64-row/full-column FL2VA audit.  Attention output projections
-# are both the most error-prone family and the cheapest useful BF16 upgrade.
-OUT_PROJ_ERR_GE_105 = (2, 1, 0, 3, 5, 7, 15, 38, 49, 6, 9, 45, 4, 19)
-OUT_PROJ_ERR_GE_100 = OUT_PROJ_ERR_GE_105 + (14, 43, 8, 17, 10, 11, 47, 27, 44, 12, 13, 46, 20)
-TOP_FC2 = (49, 45, 39, 29, 44)
-
-QUALITY_PROFILES = {
-    "compact": (),
-    # ~20.39 GiB with dynamic rank16.
-    "quality20": block_layers(OUT_PROJ_ERR_GE_105, "attn.out_proj")
-                 + block_layers(TOP_FC2[:1], "mlp.fc2"),
-    # ~21.00 GiB: recommended first 24 GiB load/generation candidate.
-    "quality21": block_layers(OUT_PROJ_ERR_GE_100, "attn.out_proj")
-                 + block_layers(TOP_FC2[:3], "mlp.fc2"),
-    # ~21.97 GiB: only after quality21 demonstrates enough activation headroom.
-    "quality22": block_layers(range(50), "attn.out_proj")
-                 + block_layers(TOP_FC2, "mlp.fc2"),
-}
-def tensor_bytes(dtype, shape):
-    total = DTYPE_BYTES[dtype]
-    for dim in shape:
-        total *= dim
-    return total
-
-
-class ShardReader:
-    def __init__(self, path):
-        self.path = os.path.abspath(path)
-        indexes = [name for name in os.listdir(self.path) if name.endswith(".safetensors.index.json")]
-        if len(indexes) != 1:
-            raise SystemExit(f"ожидался один *.safetensors.index.json в {self.path}, найдено {len(indexes)}")
-        index = json.load(open(os.path.join(self.path, indexes[0]), encoding="utf-8"))
-        self.weight_map = index["weight_map"]
-        self._files = {}
-        for name in sorted(set(self.weight_map.values())):
-            full = os.path.join(self.path, name)
-            if not os.path.isfile(full):
-                raise SystemExit(f"нет шарда из index: {full}")
-            self._files[name] = safe_open(full, framework="pt")
-
-    def keys(self):
-        return list(self.weight_map)
-
-    def get_slice(self, key):
-        return self._files[self.weight_map[key]].get_slice(key)
-
-    def get_tensor(self, key):
-        return self._files[self.weight_map[key]].get_tensor(key)
-
-    def close(self):
-        self._files.clear()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc, traceback):
-        self.close()
-
-
-def validate_source(reader):
-    keys = set(reader.keys())
-    if len(keys) != 638:
-        raise SystemExit(f"неожиданное число исходных тензоров: {len(keys)}, ожидалось 638")
-    shapes = {
-        "transformer_blocks.0.attn.to_q.weight": [7168, 5376],
-        "transformer_blocks.0.attn.to_k.weight": [7168, 5376],
-        "transformer_blocks.0.attn.to_v.weight": [7168, 5376],
-        "transformer_blocks.0.attn.to_out.0.weight": [5376, 7168],
-        "transformer_blocks.0.ff.net.0.proj.weight": [28672, 5376],
-        "transformer_blocks.0.ff.net.2.weight": [5376, 14336],
-        "transformer_blocks.0.adaln_proj.linear.weight": [96768, 2688],
-        "norm_out.linear.weight": [10752, 2688],
-        "time_embedder.linear_1.weight": [5376, 256],
-        "time_embedder.linear_2.weight": [2688, 5376],
-    }
-    for key, expected_shape in shapes.items():
-        if key not in keys:
-            raise SystemExit(f"в источнике нет {key}")
-        actual = reader.get_slice(key).get_shape()
-        if actual != expected_shape:
-            raise SystemExit(f"форма {key}: {actual}, ожидалось {expected_shape}")
-    print("источник diffusers: 638 тензоров, 50 DiT-блоков, формы верны")
-
-
-def task(kind, entries, source=None, prefix=None, **extra):
-    out = {"kind": kind, "entries": entries, "source": source, "prefix": prefix}
-    out.update(extra)
-    return out
-
-
-def build_tasks(reader, rank, grid, time_mode="dynamic", bf16_layers=(), groupsize=256):
-    tasks = []
-    used = set()
-    quant_count = curve_count = 0
-    bf16_layers = set(bf16_layers)
-    seen_main_layers = set()
-
-    def add_copy(out_key, src_key, kind="copy"):
-        sl = reader.get_slice(src_key)
-        tasks.append(task(kind, [(out_key, sl.get_dtype(), sl.get_shape())], source=src_key))
-        used.add(src_key)
-
-    def add_qkv(out_key, src_prefix, quantized, groupsize=256):
-        sources = tuple(src_prefix + f".attn.to_{name}.weight" for name in ("q", "k", "v"))
-        shape = reader.get_slice(sources[0]).get_shape()
-        out_shape = [shape[0] * 3, shape[1]]
-        if quantized:
-            layer = out_key[:-len(".weight")]
-            blob = quant_blob(groupsize)
-            entries = [(out_key, "I8", out_shape),
-                       (layer + ".weight_scale", "F32", [out_shape[0], 1]),
-                       (layer + ".comfy_quant", "U8", [len(blob)])]
-            tasks.append(task("quant_qkv", entries, source=sources, groupsize=groupsize, blob=blob))
-        else:
-            tasks.append(task("copy_qkv", [(out_key, reader.get_slice(sources[0]).get_dtype(), out_shape)], source=sources))
-        used.update(sources)
-
-    def add_quant(out_key, src_key, kind="quant", groupsize=256):
-        nonlocal quant_count
-        shape = reader.get_slice(src_key).get_shape()
-        layer = out_key[:-len(".weight")]
-        blob = quant_blob(groupsize)
-        entries = [(out_key, "I8", shape),
-                   (layer + ".weight_scale", "F32", [shape[0], 1]),
-                   (layer + ".comfy_quant", "U8", [len(blob)])]
-        tasks.append(task(kind, entries, source=src_key, groupsize=groupsize, blob=blob))
-        used.add(src_key)
-        quant_count += 1
-
-    def add_main_qkv(out_key, src_prefix):
-        nonlocal quant_count
-        layer = out_key[:-len(".weight")]
-        seen_main_layers.add(layer)
-        quantized = layer not in bf16_layers
-        add_qkv(out_key, src_prefix, quantized=quantized, groupsize=groupsize)
-        if quantized:
-            quant_count += 1
-
-    def add_main(out_key, src_key, quant_kind="quant", copy_kind="copy"):
-        layer = out_key[:-len(".weight")]
-        seen_main_layers.add(layer)
-        if layer in bf16_layers:
-            add_copy(out_key, src_key, kind=copy_kind)
-        else:
-            add_quant(out_key, src_key, kind=quant_kind, groupsize=groupsize)
-
-    def add_curve(out_prefix, src_prefix):
-        nonlocal curve_count
-        weight_key, bias_key = src_prefix + ".weight", src_prefix + ".bias"
-        out_features = reader.get_slice(weight_key).get_shape()[0]
-        tasks.append(task("curve", [(out_prefix + ".weight", "F32", [out_features, rank]),
-                                     (out_prefix + ".bias", "F32", [out_features])],
-                          source=src_prefix, prefix=out_prefix))
-        used.update((weight_key, bias_key))
-        curve_count += 1
-
-    for block in range(50):
-        src = f"transformer_blocks.{block}"
-        out = f"blocks.{block}"
-        add_main_qkv(out + ".attn.qkv_proj.weight", src)
-        add_main(out + ".attn.out_proj.weight", src + ".attn.to_out.0.weight")
-        add_copy(out + ".attn.q_norm.weight", src + ".attn.norm_q.weight")
-        add_copy(out + ".attn.k_norm.weight", src + ".attn.norm_k.weight")
-        add_main(out + ".mlp.fc1.weight", src + ".ff.net.0.proj.weight",
-                 quant_kind="quant_fc1", copy_kind="copy_fc1")
-        add_main(out + ".mlp.fc2.weight", src + ".ff.net.2.weight")
-        add_copy(out + ".norm1.weight", src + ".norm1.weight")
-        add_copy(out + ".norm2.weight", src + ".norm2.weight")
-        add_curve(out + ".adaln_proj.linear", src + ".adaln_proj.linear")
-
-    for block in range(2):
-        src = f"token_refiner.refiner_blocks.{block}"
-        out = f"token_refiner.blocks.{block}"
-        add_qkv(out + ".attn.qkv_proj.weight", src, quantized=False)
-        add_copy(out + ".attn.out_proj.weight", src + ".attn.to_out.0.weight")
-        add_copy(out + ".attn.q_norm.weight", src + ".attn.norm_q.weight")
-        add_copy(out + ".attn.k_norm.weight", src + ".attn.norm_k.weight")
-        add_copy(out + ".mlp.fc1.weight", src + ".ff.net.0.proj.weight", kind="copy_fc1")
-        add_copy(out + ".mlp.fc2.weight", src + ".ff.net.2.weight")
-        add_copy(out + ".norm1.weight", src + ".norm1.weight")
-        add_copy(out + ".norm2.weight", src + ".norm2.weight")
-
-    add_copy("token_refiner.final_norm.weight", "token_refiner.final_norm.weight")
-    for out_key, src_key in (
-        ("condition_proj.weight", "context_embedder.weight"),
-        ("condition_proj.bias", "context_embedder.bias"),
-        ("video_patch_proj.weight", "proj_in.weight"),
-        ("video_patch_proj.bias", "proj_in.bias"),
-        ("audio_patch_proj.weight", "audio_proj_in.weight"),
-        ("audio_patch_proj.bias", "audio_proj_in.bias"),
-        ("final_layer.video_out.weight", "proj_out.weight"),
-        ("final_layer.video_out.bias", "proj_out.bias"),
-        ("final_layer.audio_out.weight", "audio_proj_out.weight"),
-        ("final_layer.audio_out.bias", "audio_proj_out.bias"),
-        ("final_layer.norm.weight", "norm_out.norm.weight"),
-    ):
-        add_copy(out_key, src_key)
-    add_curve("final_layer.adaln_proj.linear", "norm_out.linear")
-
-    time_pairs = (
-        ("time_embedder.proj_in.weight", "time_embedder.linear_1.weight"),
-        ("time_embedder.proj_in.bias", "time_embedder.linear_1.bias"),
-        ("time_embedder.proj_out.weight", "time_embedder.linear_2.weight"),
-        ("time_embedder.proj_out.bias", "time_embedder.linear_2.bias"),
-    )
-    if time_mode == "dynamic":
-        for out_key, src_key in time_pairs:
-            add_copy(out_key, src_key)
-        tasks.append(task("basis", [("adaln_curve_basis", "F32", [2688, rank]),
-                                    ("adaln_curve_mean", "F32", [2688])]))
-    elif time_mode == "table":
-        used.update(src for _, src in time_pairs)
-        tasks.append(task("table", [("adaln_t_table", "F32", [grid, rank])]))
-    else:
-        raise ValueError(time_mode)
-    missing, extra = set(reader.keys()) - used, used - set(reader.keys())
-    if missing or extra:
-        raise SystemExit(f"маппинг diffusers неполон: не использовано {len(missing)}, неизвестных {len(extra)}; {sorted(missing)[:3]}")
-    tasks.append(task("rope", [("rope.inv_freq", "F32", [16])]))
-    unknown_bf16 = bf16_layers - seen_main_layers
-    if unknown_bf16:
-        raise SystemExit(f"неизвестные BF16-слои: {sorted(unknown_bf16)}")
-    expected_quant = 200 - len(bf16_layers)
-    if quant_count != expected_quant or curve_count != 51:
-        raise SystemExit(f"план неполон: INT8={quant_count}/{expected_quant}, adaLN={curve_count}/51")
-    entries = [entry for item in tasks for entry in item["entries"]]
-    expected_entries = (937 if time_mode == "dynamic" else 932) - 2 * len(bf16_layers)
-    if len(entries) != expected_entries or len({entry[0] for entry in entries}) != len(entries):
-        raise SystemExit(f"неверный выходной keyset: {len(entries)} вместо {expected_entries}")
-    return tasks
-
-
-def inspect_reference(tasks, path, time_mode="dynamic", bf16_layers=()):
-    planned = {key: (dtype, shape) for item in tasks for key, dtype, shape in item["entries"]}
-    bf16_layers = set(bf16_layers)
-    with safe_open(path, framework="pt") as ref:
-        ref_keys = set(ref.keys())
-        expected_missing = set()
-        for layer in bf16_layers:
-            expected_missing.update((layer + ".weight_scale", layer + ".comfy_quant"))
-        expected_extra = set()
-        if time_mode == "dynamic":
-            expected_missing.add("adaln_t_table")
-            expected_extra.update({"adaln_curve_basis", "adaln_curve_mean",
-                                   "time_embedder.proj_in.weight", "time_embedder.proj_in.bias",
-                                   "time_embedder.proj_out.weight", "time_embedder.proj_out.bias"})
-        actual_missing = ref_keys - set(planned)
-        actual_extra = set(planned) - ref_keys
-        if actual_missing != expected_missing or actual_extra != expected_extra:
-            raise SystemExit("keyset расходится с ожидаемым расширением pruned-формата: "
-                             f"missing={sorted(actual_missing ^ expected_missing)[:5]} "
-                             f"extra={sorted(actual_extra ^ expected_extra)[:5]}")
-        mismatches = []
-        for key, (dtype, shape) in planned.items():
-            if key not in ref_keys or "adaln_proj.linear" in key or key == "adaln_t_table":
-                continue
-            sl = ref.get_slice(key)
-            layer = key[:-len(".weight")] if key.endswith(".weight") else ""
-            dtype_mismatch = sl.get_dtype() != dtype and layer not in bf16_layers
-            if dtype_mismatch or sl.get_shape() != shape:
-                mismatches.append((key, dtype, shape, sl.get_dtype(), sl.get_shape()))
-        if mismatches:
-            raise SystemExit(f"формат расходится с pruned-эталоном вне curve-части: {mismatches[:3]}")
-    print(f"эталон comfyorg-pruned: общие формы совпадают; dynamic={time_mode == 'dynamic'}, "
-          f"BF16 main={len(bf16_layers)}")
-
-
-def make_curve(reader, rank, grid, device):
-    w1 = reader.get_tensor("time_embedder.linear_1.weight").to(device=device, dtype=torch.float32)
-    b1 = reader.get_tensor("time_embedder.linear_1.bias").to(device=device, dtype=torch.float32)
-    w2 = reader.get_tensor("time_embedder.linear_2.weight").to(device=device, dtype=torch.float32)
-    b2 = reader.get_tensor("time_embedder.linear_2.bias").to(device=device, dtype=torch.float32)
-    half = 128
-    freqs = torch.exp(-math.log(10000.0) * torch.arange(half, dtype=torch.float32, device=device) / half)
-
-    def evaluate(t):
-        args = t[:, None] * freqs[None]
-        emb = torch.cat((torch.cos(args), torch.sin(args)), dim=1)
-        return F.silu(F.linear(F.silu(F.linear(emb, w1, b1)), w2, b2))
-
-    # 2049 points are sufficient to determine the shared subspace.  The output
-    # table may be denser: Comfy derives the grid length from table.shape[0].
-    fit_t = torch.linspace(0.0, 1.0, 2049, dtype=torch.float32, device=device)
-    curve = evaluate(fit_t)
-    # Evaluate the real runtime formula in F32, then solve the tiny singular
-    # directions in F64 on CPU.  F32 SVD bottoms out at ~1.09e-6 relative error
-    # for rank 16; the F64 solve followed by F32 storage reaches ~2.72e-7.
-    curve_cpu = curve.cpu()
-    curve64 = curve_cpu.double()
-    mean64 = curve64.mean(0)
-    centered64 = curve64 - mean64
-    _, singular, vh = torch.linalg.svd(centered64, full_matrices=False)
-    basis64 = vh[:rank].T.contiguous()
-    basis = basis64.to(device=device, dtype=torch.float32)
-    mean = mean64.to(device=device, dtype=torch.float32)
-    table_t = torch.linspace(0.0, 1.0, grid, dtype=torch.float32, device=device)
-    table_curve = evaluate(table_t)
-    table = ((table_curve.cpu().double() - mean64) @ basis64).to(torch.float32)
-    energy = (singular[:rank].square().sum() / singular.square().sum()).item()
-    reconstruction = table @ basis.cpu().T + mean.cpu()
-    grid_error = ((reconstruction - table_curve.cpu()).norm() / table_curve.cpu().norm()).item()
-    # Real runtime values usually lie between table rows.  Midpoints provide a
-    # sensitive deterministic check of the linear interpolation error.
-    mid_t = (torch.arange(grid - 1, dtype=torch.float32, device=device) + 0.5) / (grid - 1)
-    mid_curve = evaluate(mid_t).cpu()
-    mid_coords = (table[:-1] + table[1:]) * 0.5
-    mid_reconstruction = mid_coords @ basis.cpu().T + mean.cpu()
-    midpoint_error = ((mid_reconstruction - mid_curve).norm() / mid_curve.norm()).item()
-    midpoint_max = ((mid_reconstruction - mid_curve).norm(dim=1) /
-                    mid_curve.norm(dim=1).clamp(min=1e-12)).max().item()
-    projection = torch.cat((basis, mean[:, None]), dim=1)
-    del w1, b1, w2, b2, curve, curve_cpu, curve64, centered64, vh, basis64
-    del table_curve, reconstruction, mid_curve, mid_reconstruction, mid_coords
-    print(f"adaLN curve: rank={rank}, grid={grid}, энергия={energy:.10f}, "
-          f"grid err={grid_error:.8%}, midpoint err={midpoint_error:.8%}, "
-          f"max={midpoint_max:.8%}")
-    return projection, table
-
-
-def make_header(tasks):
-    header = {}
-    offset = 0
-    for item in tasks:
-        for key, dtype, shape in item["entries"]:
-            size = tensor_bytes(dtype, shape)
-            header[key] = {"dtype": dtype, "shape": shape, "data_offsets": [offset, offset + size]}
-            offset += size
-    raw = json.dumps(header, separators=(",", ":")).encode("utf-8")
-    raw += b" " * ((-len(raw)) % 8)
-    return raw, offset
-
-
-def raw_bytes(tensor):
-    tensor = tensor.detach().to(device="cpu").contiguous()
-    if tensor.dtype not in TORCH_TO_ST:
-        raise TypeError(f"неподдерживаемый dtype {tensor.dtype}")
-    return tensor.view(torch.uint8).numpy().tobytes()
-
-
-def write_tensor(stream, tensor, expected):
-    key, dtype, shape = expected
-    actual_dtype = TORCH_TO_ST.get(tensor.dtype)
-    if actual_dtype != dtype or list(tensor.shape) != shape:
-        raise RuntimeError(f"{key}: получили {actual_dtype} {list(tensor.shape)}, ожидалось {dtype} {shape}")
-    blob = raw_bytes(tensor)
-    expected_bytes = tensor_bytes(dtype, shape)
-    if len(blob) != expected_bytes:
-        raise RuntimeError(f"{key}: байт {len(blob)}, ожидалось {expected_bytes}")
-    stream.write(blob)
-
-
-def build(reader, tasks, reference, dst, rank, grid, device, search_min, clip_margin, overwrite):
-    partial = dst + ".partial"
-    if (os.path.exists(dst) or os.path.exists(partial)) and not overwrite:
-        raise SystemExit(f"выход или partial уже существует; используйте --overwrite: {dst}")
-    os.makedirs(os.path.dirname(os.path.abspath(dst)), exist_ok=True)
-    header, data_size = make_header(tasks)
-    projection, table = make_curve(reader, rank, grid, device)
-    ratios = build_ratios(search_min)
-    t0 = time.time()
-    quant_done = curve_done = 0
-    expected_quant = sum(item["kind"] in ("quant", "quant_fc1", "quant_qkv") for item in tasks)
-
-    def report_block(key):
-        match = re.fullmatch(r"blocks\.(\d+)\.mlp\.fc2\.weight", key)
-        if match:
-            print(f"  DiT block {int(match.group(1)):02d}/49: INT8 {quant_done}/{expected_quant}, "
-                  f"{time.time() - t0:.0f} c", flush=True)
-
-    with safe_open(reference, framework="pt") as ref, open(partial, "wb") as stream:
-        stream.write(struct.pack("<Q", len(header)))
-        stream.write(header)
-        for item in tasks:
-            if item["kind"] == "copy":
-                tensor = reader.get_tensor(item["source"])
-                write_tensor(stream, tensor, item["entries"][0])
-                del tensor
-                report_block(item["entries"][0][0])
-            elif item["kind"] in ("copy_qkv", "quant_qkv"):
-                weight = torch.cat([reader.get_tensor(key) for key in item["source"]], dim=0)
-                if item["kind"] == "copy_qkv":
-                    write_tensor(stream, weight, item["entries"][0])
-                    del weight
-                    continue
-                weight = weight.to(device=device, dtype=torch.float32)
-                qdata, scale = quantize_search(weight, item["groupsize"], ratios, clip_margin=clip_margin)
-                write_tensor(stream, qdata.cpu(), item["entries"][0])
-                write_tensor(stream, scale.cpu(), item["entries"][1])
-                blob = torch.tensor(list(item["blob"]), dtype=torch.uint8)
-                write_tensor(stream, blob, item["entries"][2])
-                quant_done += 1
-                del weight, qdata, scale, blob
-            elif item["kind"] in ("copy_fc1", "quant_fc1"):
-                weight = reader.get_tensor(item["source"])
-                half = weight.shape[0] // 2
-                weight = torch.cat((weight[half:], weight[:half]), dim=0)
-                if item["kind"] == "copy_fc1":
-                    write_tensor(stream, weight, item["entries"][0])
-                    del weight
-                    continue
-                weight = weight.to(device=device, dtype=torch.float32)
-                qdata, scale = quantize_search(weight, item["groupsize"], ratios, clip_margin=clip_margin)
-                write_tensor(stream, qdata.cpu(), item["entries"][0])
-                write_tensor(stream, scale.cpu(), item["entries"][1])
-                blob = torch.tensor(list(item["blob"]), dtype=torch.uint8)
-                write_tensor(stream, blob, item["entries"][2])
-                quant_done += 1
-                del weight, qdata, scale, blob
-            elif item["kind"] == "quant":
-                weight = reader.get_tensor(item["source"]).to(device=device, dtype=torch.float32)
-                qdata, scale = quantize_search(weight, item["groupsize"], ratios, clip_margin=clip_margin)
-                write_tensor(stream, qdata.cpu(), item["entries"][0])
-                write_tensor(stream, scale.cpu(), item["entries"][1])
-                blob = torch.tensor(list(item["blob"]), dtype=torch.uint8)
-                write_tensor(stream, blob, item["entries"][2])
-                quant_done += 1
-                del weight, qdata, scale, blob
-                report_block(item["entries"][0][0])
-            elif item["kind"] == "curve":
-                source = item["source"]
-                weight = reader.get_tensor(source + ".weight").to(device=device, dtype=torch.float32)
-                bias = reader.get_tensor(source + ".bias").to(device=device, dtype=torch.float32)
-                packed = weight @ projection
-                curve_weight = packed[:, :rank]
-                curve_bias = bias + packed[:, rank]
-                write_tensor(stream, curve_weight.cpu(), item["entries"][0])
-                write_tensor(stream, curve_bias.cpu(), item["entries"][1])
-                curve_done += 1
-                del weight, bias, packed, curve_weight, curve_bias
-            elif item["kind"] == "table":
-                write_tensor(stream, table.cpu(), item["entries"][0])
-            elif item["kind"] == "basis":
-                write_tensor(stream, projection[:, :rank].cpu(), item["entries"][0])
-                write_tensor(stream, projection[:, rank].cpu(), item["entries"][1])
-            elif item["kind"] == "rope":
-                write_tensor(stream, ref.get_tensor("rope.inv_freq"), item["entries"][0])
-            else:
-                raise RuntimeError(item["kind"])
-    expected_size = 8 + len(header) + data_size
-    actual_size = os.path.getsize(partial)
-    if actual_size != expected_size:
-        raise RuntimeError(f"partial имеет {actual_size} байт, ожидалось {expected_size}")
-    with safe_open(partial, framework="pt") as result:
-        expected_keys = sum(len(item["entries"]) for item in tasks)
-        if len(result.keys()) != expected_keys:
-            raise RuntimeError(f"safetensors открылся, но ключей {len(result.keys())}, ожидалось {expected_keys}")
-    os.replace(partial, dst)
-    print(f"готово: {dst}\n  {actual_size / 2**30:.3f} GiB, INT8={quant_done}, curve={curve_done}, {time.time() - t0:.0f} c")
-
-
-def defaults(variant, rank, grid, time_mode, profile):
-    source = os.path.join(HF, "transformer" if variant == "fl2va" else "transformer_ref")
-    reference = os.path.join(COMFYORG, f"minimax-h3-{variant}-pruned-int8-convrot-comfyorg.safetensors")
-    curve_tag = f"table-k{rank}-g{grid}" if time_mode == "table" else f"dynamic-k{rank}"
-    dst = os.path.join(MODELS, f"minimax-h3-{variant}-int8-lean-convrot-{curve_tag}-{profile}.safetensors")
-    return source, reference, dst
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("variant", choices=("fl2va", "ref2va"))
-    ap.add_argument("--rank", type=int, default=16, choices=(8, 16, 32, 64))
-    ap.add_argument("--time-mode", choices=("dynamic", "table"), default="dynamic",
-                    help="dynamic сохраняет исходный F32 time_embedder; table совместим с pruned")
-    ap.add_argument("--grid", type=int, default=4097,
-                    help="число строк table или плотность численной проверки dynamic basis")
-    ap.add_argument("--profile", choices=tuple(QUALITY_PROFILES), default="quality21")
-    ap.add_argument("--bf16-layer", action="append", default=[],
-                    help="дополнительный base-name основного слоя, например blocks.48.mlp.fc2")
-    ap.add_argument("--groupsize", type=int, choices=(16, 64, 256), default=256)
-    ap.add_argument("--src", default="")
-    ap.add_argument("--reference", default="")
-    ap.add_argument("--dst", default="")
-    ap.add_argument("--device", default="cuda:0")
-    ap.add_argument("--search-min", type=float, default=0.80)
-    ap.add_argument("--clip-margin", type=float, default=0.05)
-    ap.add_argument("--dry-run", action="store_true")
-    ap.add_argument("--overwrite", action="store_true")
-    args = ap.parse_args()
-    if args.grid < 2:
-        ap.error("--grid должен быть не меньше 2")
-
-    bf16_layers = set(QUALITY_PROFILES[args.profile]) | set(args.bf16_layer)
-    source, reference, dst = defaults(args.variant, args.rank, args.grid, args.time_mode, args.profile)
-    source = args.src or source
-    reference = args.reference or reference
-    dst = args.dst or dst
-    print(f"variant={args.variant} rank={args.rank} time={args.time_mode} profile={args.profile}\n"
-          f"BF16 main={sorted(bf16_layers)}\nsrc={source}\nreference={reference}\ndst={dst}")
-    reader = ShardReader(source)
-    try:
-        validate_source(reader)
-        tasks = build_tasks(reader, args.rank, args.grid, args.time_mode, bf16_layers, args.groupsize)
-        inspect_reference(tasks, reference, args.time_mode, bf16_layers)
-        _, data_size = make_header(tasks)
-        entries = sum(len(item["entries"]) for item in tasks)
-        quant_count = sum(item["kind"] in ("quant", "quant_fc1", "quant_qkv") for item in tasks)
-        print(f"план: {entries} тензоров, {quant_count} INT8 g{args.groupsize}, "
-              f"BF16 main={len(bf16_layers)}, 51 adaLN curve F32 k={args.rank} time={args.time_mode}; "
-              f"данные {data_size / 2**30:.3f} GiB")
-        if args.dry_run:
-            print("dry-run: веса не читались целиком, GPU не использовалась, файл не создан")
-            return
-        build(reader, tasks, reference, dst, args.rank, args.grid, args.device, args.search_min,
-              args.clip_margin, args.overwrite)
-    finally:
-        reader.close()
-
-
-if __name__ == "__main__":
-    main()

tools/mm_validate_dynamic_built.py

@@ -1,137 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Validate a built MiniMax-H3 dynamic-basis checkpoint against raw HF weights."""
-import argparse
-import json
-import math
-import os
-import sys
-
-import torch
-import torch.nn.functional as F
-from safetensors import safe_open
-
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-ROOT = os.environ.get("MINIMAX_H3_ROOT", os.getcwd())
-sys.path.insert(0, SCRIPT_DIR)
-from mm_quantize_lean import QUALITY_PROFILES, ShardReader  # noqa: E402
-
-sys.stdout.reconfigure(encoding="utf-8")
-torch.set_grad_enabled(False)
-
-
-def rel(actual, expected):
-    return ((actual - expected).norm() / expected.norm().clamp(min=1e-12)).item()
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("variant", choices=("fl2va", "ref2va"))
-    ap.add_argument("checkpoint")
-    ap.add_argument("--src", default="", help="raw diffusers transformer directory")
-    ap.add_argument("--profile", choices=tuple(QUALITY_PROFILES), default="quality21")
-    ap.add_argument("--samples", type=int, default=9)
-    args = ap.parse_args()
-
-    source = args.src or os.path.join(ROOT, "HF",
-                                     "transformer" if args.variant == "fl2va" else "transformer_ref")
-    expected_bf16 = set(QUALITY_PROFILES[args.profile])
-    results = {}
-
-    with ShardReader(source) as raw, safe_open(args.checkpoint, framework="pt") as built:
-        keys = set(built.keys())
-        quant = [key for key in keys if key.endswith(".comfy_quant")]
-        groups = {}
-        for key in quant:
-            config = json.loads(bytes(built.get_tensor(key).numpy()).decode())
-            groups[config["convrot_groupsize"]] = groups.get(config["convrot_groupsize"], 0) + 1
-
-        actual_bf16 = set()
-        for block in range(50):
-            for suffix in ("attn.qkv_proj", "attn.out_proj", "mlp.fc1", "mlp.fc2"):
-                base = f"blocks.{block}.{suffix}"
-                if built.get_slice(base + ".weight").get_dtype() == "BF16":
-                    actual_bf16.add(base)
-        if actual_bf16 != expected_bf16:
-            raise RuntimeError(f"BF16 profile mismatch: -{sorted(expected_bf16 - actual_bf16)} "
-                               f"+{sorted(actual_bf16 - expected_bf16)}")
-
-        time_pairs = (
-            ("time_embedder.linear_1.weight", "time_embedder.proj_in.weight"),
-            ("time_embedder.linear_1.bias", "time_embedder.proj_in.bias"),
-            ("time_embedder.linear_2.weight", "time_embedder.proj_out.weight"),
-            ("time_embedder.linear_2.bias", "time_embedder.proj_out.bias"),
-        )
-        time_bitwise = all(torch.equal(raw.get_tensor(src), built.get_tensor(dst))
-                           for src, dst in time_pairs)
-        if not time_bitwise:
-            raise RuntimeError("time_embedder differs from raw HF")
-
-        # All quality21 BF16 islands are out_proj or fc2 and should be exact copies.
-        bf16_bad = []
-        for base in sorted(actual_bf16):
-            parts = base.split(".")
-            block = int(parts[1])
-            suffix = ".".join(parts[2:])
-            if suffix == "attn.out_proj":
-                src = f"transformer_blocks.{block}.attn.to_out.0.weight"
-            elif suffix == "mlp.fc2":
-                src = f"transformer_blocks.{block}.ff.net.2.weight"
-            else:
-                raise RuntimeError(f"validator needs mapping for {base}")
-            if not torch.equal(raw.get_tensor(src), built.get_tensor(base + ".weight")):
-                bf16_bad.append(base)
-        if bf16_bad:
-            raise RuntimeError(f"BF16 tensors differ: {bf16_bad}")
-
-        w1 = built.get_tensor("time_embedder.proj_in.weight").float()
-        b1 = built.get_tensor("time_embedder.proj_in.bias").float()
-        w2 = built.get_tensor("time_embedder.proj_out.weight").float()
-        b2 = built.get_tensor("time_embedder.proj_out.bias").float()
-        basis = built.get_tensor("adaln_curve_basis").float()
-        mean = built.get_tensor("adaln_curve_mean").float()
-        orth_error = (basis.T @ basis - torch.eye(basis.shape[1])).abs().max().item()
-
-        t = torch.linspace(0.0, 1.0, args.samples, dtype=torch.float32)
-        half = 128
-        freqs = torch.exp(-math.log(10000.0) * torch.arange(half, dtype=torch.float32) / half)
-        phase = t[:, None] * freqs[None]
-        sinusoid = torch.cat((torch.cos(phase), torch.sin(phase)), dim=1)
-        u = F.silu(F.linear(F.silu(F.linear(sinusoid, w1, b1)), w2, b2))
-        coords = (u - mean) @ basis
-
-        curve_errors = {}
-        for block in (0, 24, 49):
-            src = f"transformer_blocks.{block}.adaln_proj.linear"
-            dst = f"blocks.{block}.adaln_proj.linear"
-            exact = F.linear(u, raw.get_tensor(src + ".weight").float(),
-                             raw.get_tensor(src + ".bias").float())
-            approx = F.linear(coords, built.get_tensor(dst + ".weight").float(),
-                              built.get_tensor(dst + ".bias").float())
-            curve_errors[f"block_{block}"] = rel(approx, exact)
-            del exact, approx
-        exact = F.linear(u, raw.get_tensor("norm_out.linear.weight").float(),
-                         raw.get_tensor("norm_out.linear.bias").float())
-        approx = F.linear(coords, built.get_tensor("final_layer.adaln_proj.linear.weight").float(),
-                          built.get_tensor("final_layer.adaln_proj.linear.bias").float())
-        curve_errors["final"] = rel(approx, exact)
-
-        results = {
-            "checkpoint": args.checkpoint,
-            "bytes": os.path.getsize(args.checkpoint),
-            "keys": len(keys),
-            "quant": len(quant),
-            "quant_groups": groups,
-            "bf16_main": len(actual_bf16),
-            "time_embedder_bitwise": time_bitwise,
-            "bf16_main_bitwise": len(actual_bf16) - len(bf16_bad),
-            "basis_shape": list(basis.shape),
-            "basis_orthogonality_max_abs": orth_error,
-            "curve_samples": args.samples,
-            "adaln_relative_errors": curve_errors,
-        }
-
-    print(json.dumps(results, ensure_ascii=False, indent=2))
-
-
-if __name__ == "__main__":
-    main()