Move dynamic-time separate-QKV checkpoints to dedicated repository

FL2VA/SHA256SUMS

@@ -1,2 +1 @@
 ad0cf8b50ba92068b5a4477527d5da73412a22db99cded35b07195504e78cf6a  minimax-h3-fl2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors
-495b9d565b17194196646ef39b0c04ac7dde4a8df695b103b3fcbe04b5da00a6  minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors

FL2VA/minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:495b9d565b17194196646ef39b0c04ac7dde4a8df695b103b3fcbe04b5da00a6
-size 22547374816

README.md

@@ -17,329 +17,151 @@ tags:
   - ref2va
 ---
 
-# MiniMax-H3 INT8 Lean ConvRot
-
-This repository contains a quality-oriented mixed-precision ComfyUI derivative
-of [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3).
-The released checkpoints cover both the **FL2VA** and **Ref2VA** diffusion
-transformers. Each is designed as a first 24 GiB GPU candidate while preserving
-more of the original model than the corresponding official pruned INT8
-checkpoint. Two layouts are provided: a stock-compatible dense time-table
-edition and a patched edition with the original FP32 time MLP and physically
-separate Q, K, and V modules.
-
-These are not official MiniMax or ComfyOrg checkpoints. The `table-*` files use
-the standard MiniMax-H3 `adaln_t_table` format and load in an unmodified
-ComfyUI. The `dynamic-*-separate-qkv-*` files require the small core patch
-included in [`patches/`](patches/).
+# MiniMax-H3 INT8 Lean ConvRot — Stock ComfyUI Edition
 
-## Included files
-
-| Path | Purpose |
-|---|---|
-| [`FL2VA/minimax-h3-fl2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors`](FL2VA/minimax-h3-fl2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors) | Stock-compatible FL2VA diffusion transformer, 20.940 GiB |
-| [`Ref2VA/minimax-h3-ref2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors`](Ref2VA/minimax-h3-ref2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors) | Stock-compatible Ref2VA diffusion transformer, 20.940 GiB |
-| [`FL2VA/minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors`](FL2VA/minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors) | Patched FL2VA: original FP32 time MLP and separate Q/K/V, 20.999 GiB |
-| [`Ref2VA/minimax-h3-ref2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors`](Ref2VA/minimax-h3-ref2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors) | Patched Ref2VA: original FP32 time MLP and separate Q/K/V, 20.999 GiB |
-| [`vae/minimax_h3_video_vae_fp16.safetensors`](vae/minimax_h3_video_vae_fp16.safetensors) | Stock ComfyUI MiniMax-H3 visual VAE, FP16, 4.850 GiB |
-| [`vae/minimax_h3_audio_vae_fp32.safetensors`](vae/minimax_h3_audio_vae_fp32.safetensors) | Stock ComfyUI MiniMax-H3 stereo audio VAE, FP32, 0.564 GiB |
-| [`patches/comfyui-minimax-h3-dynamic-time-separate-qkv.patch`](patches/comfyui-minimax-h3-dynamic-time-separate-qkv.patch) | Required ComfyUI core patch for the two dynamic/separate files |
-| [`reports/layer_policy.json`](reports/layer_policy.json) / [`layer_policy_ref2va.json`](reports/layer_policy_ref2va.json) | Exact per-layer precision policies |
-| [`reports/validation.json`](reports/validation.json) / [`validation_ref2va.json`](reports/validation_ref2va.json) | Structural, numerical, and CPU-load results |
-| [`reports/validation_dynamic_separate_fl2va.json`](reports/validation_dynamic_separate_fl2va.json) / [`validation_dynamic_separate_ref2va.json`](reports/validation_dynamic_separate_ref2va.json) | Bitwise split and dynamic-time validation for the patched files |
-| [`reports/loadtest_dynamic_separate_fl2va.json`](reports/loadtest_dynamic_separate_fl2va.json) / [`loadtest_dynamic_separate_ref2va.json`](reports/loadtest_dynamic_separate_ref2va.json) | Full patched-Comfy CPU loader results |
-| [`reports/mm_quant_profile_fl2va.json`](reports/mm_quant_profile_fl2va.json) | Row-sampled reconstruction profile for all 200 main matrices |
-| [`reports/mm_quant_profile_ref2va.json`](reports/mm_quant_profile_ref2va.json) | Matching Ref2VA reconstruction profile |
-
-This repository intentionally does **not** include the MiniMax-H3 text encoder.
-It is being prepared as a separate repository. ComfyUI does not require the
-Diffusers scheduler, tokenizer, processor, or remote-code Python bundles as
-separate downloads: a standard workflow needs one selected diffusion model,
-the two included VAEs, and a compatible MiniMax-H3 text encoder.
-
-## Shared quantization policy
-
-The original FL2VA and Ref2VA Diffusers shards each contain 50 transformer
-blocks with separate Q, K, and V tensors. Both release layouts use the same
-quality21 precision policy:
-
-- swaps the two `fc1` halves from `[value, gate]` to `[gate, value]`;
-- stores 170 selected main attention/MLP matrices as INT8 ConvRot with group
-  size 256 and per-row FP32 scales;
-- keeps 30 high-error main matrices as exact BF16 copies;
-- keeps the two-block token refiner, norms, Q/K norms, and condition projection
-  at their source precision;
-- keeps patch projections and video/audio output heads in source FP32;
-- replaces only the redundant input width of the 51 large AdaLN projections,
-  while keeping every block and final AdaLN projection separate in FP32.
-
-The stock-compatible files additionally pack attention rows as global
-`cat(Q,K,V)` and evaluate the original FP32 time embedder offline into a dense
-FP32 table with 4,097 rows and 16 coordinates. Each stock-compatible checkpoint
-contains 872 tensor entries: 170 INT8 weights, 170 quantization configuration
-blobs, 250 BF16 entries, and 282 FP32 entries.
-
-## Patched dynamic-time, separate-QKV edition
-
-The two `dynamic-k16-separate-qkv` files retain the original four FP32 time-MLP
-tensors:
+This repository contains stock-compatible, quality-oriented mixed-precision
+INT8 ConvRot conversions of
+[`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3), plus the
+standard MiniMax-H3 visual and audio VAEs. FL2VA and Ref2VA are separate because
+their diffusion-transformer weights are task-specific.
 
-```text
-256 -> 5,376 -> 2,688
-full_t = SiLU(original_time_embedder(t))
-coords = (full_t - mean) @ basis[2,688 x 16]
-AdaLN_i(t) = separate_linear_i(coords)
-```
+These are community derivatives, not official MiniMax or ComfyOrg checkpoints.
+The diffusion checkpoints use the standard MiniMax-H3 `adaln_t_table` layout
+and load in unmodified ComfyUI. No core patch or custom node is required.
 
-The 16-dimensional dynamic basis compresses only the shared input subspace of
-the 51 very wide AdaLN projections. It does not replace the time MLP with an
-interpolation table, and it does not merge the 51 per-block/final AdaLN layers.
+The experimental edition with the original FP32 time MLP and physically
+separate Q/K/V projections has moved to
+[`DmitryDB/MiniMax-H3-INT8-Lean-ConvRot-Dynamic-Time-Separate-QKV`](https://huggingface.co/DmitryDB/MiniMax-H3-INT8-Lean-ConvRot-Dynamic-Time-Separate-QKV).
+It requires a ComfyUI core patch and is intentionally kept separate to avoid
+confusion.
 
-Q, K, and V are also separate modules all the way through loading and forward:
-
-- 50 main blocks contain independent INT8 ConvRot `q_proj`, `k_proj`, and
-  `v_proj` weights, scales, and descriptors;
-- both token-refiner blocks contain independent BF16 Q, K, and V projections;
-- the checkpoint contains no `qkv_proj` key;
-- the patch performs three projection calls rather than concatenating the
-  tensors at load time.
-
-This changes storage structure, not the quantization values. All 156 resulting
-Q/K/V projection tensors are bit-identical to the corresponding contiguous
-thirds of the validated fused release. Per-row scales were already independent,
-so splitting QKV alone is not claimed as a quality improvement. It may be
-slower than fused QKV because the current ConvRot path can rotate the same input
-three times and launches three projections. GPU speed and peak VRAM have not
-yet been measured.
-
-Each patched checkpoint contains 1,181 tensor entries and 270 INT8 ConvRot
-modules. The total quantized QKV payload is unchanged; the approximately
-0.059 GiB size increase comes primarily from restoring the original FP32 time
-MLP.
+## Included files
 
-## Precision policy
+| Path | Purpose |
+|---|---|
+| `FL2VA/minimax-h3-fl2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors` | Stock-compatible FL2VA diffusion transformer, 20.940 GiB |
+| `Ref2VA/minimax-h3-ref2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors` | Stock-compatible Ref2VA diffusion transformer, 20.940 GiB |
+| `vae/minimax_h3_video_vae_fp16.safetensors` | Stock ComfyUI MiniMax-H3 visual VAE, FP16, 4.850 GiB |
+| `vae/minimax_h3_audio_vae_fp32.safetensors` | Stock ComfyUI MiniMax-H3 stereo audio VAE, FP32, 0.564 GiB |
+| `reports/validation.json` / `validation_ref2va.json` | Structural, table-error, and clean-Comfy CPU-load validation |
+| `reports/layer_policy.json` / `layer_policy_ref2va.json` | Exact BF16/INT8 layer policy |
+| `reports/mm_quant_profile_fl2va.json` / `mm_quant_profile_ref2va.json` | Row-sampled reconstruction profiles |
+
+The MiniMax-H3 Qwen3-VL text encoder is not included in this repository. A
+standard workflow needs one selected diffusion checkpoint, both VAEs, and a
+compatible MiniMax-H3 text encoder installed separately.
+
+## Quantization policy
+
+The original FL2VA and Ref2VA transformers each contain 50 main transformer
+blocks. Each block has four attention projections and two MLP matrices, for 300
+main matrices. The quality21 policy keeps the high-risk matrices in their
+source precision and compresses the rest:
+
+- 170 main matrices use INT8 ConvRot with Hadamard group size 256;
+- 30 high-risk main matrices remain BF16;
+- token-refiner attention/MLP weights remain BF16;
+- normalization tensors remain BF16;
+- patch projections and video/audio output heads retain source FP32;
+- 51 AdaLN projections are represented through separate FP32 rank-16 table
+  projections.
+
+Q, K, and V originate as separate Diffusers tensors. For stock ComfyUI they are
+packed as global `cat(Q,K,V)` into `qkv_proj`, which is the layout expected by
+the unmodified runtime.
+
+The BF16 islands were selected by deterministic row-sampled reconstruction
+analysis rather than by a blanket first/last-block rule. FL2VA and Ref2VA were
+profiled independently and selected the same 30 matrices.
+
+## Time conditioning
+
+The raw model uses a wide FP32 time MLP followed by 51 large AdaLN projections.
+The release samples the original FP32 time path on 4,097 points, derives a
+shared 16-dimensional basis, and stores one independent FP32 projection for
+every transformer block plus the final layer.
+
+The saved `adaln_t_table` has shape `[4097, 16]`. ComfyUI linearly interpolates
+the 16 coordinates and applies the per-layer projection. On 19 validation
+timesteps, relative AdaLN output error against the raw HF dynamic path was:
+
+- FL2VA: about `3.04e-7` to `3.82e-7`;
+- Ref2VA: about `3.42e-7` to `4.46e-7`.
+
+This is substantially more accurate than using a direct wide cached table at
+the same grid density while remaining compatible with stock ComfyUI.
 
-Every DiT block has four main matrices: QKV, attention output, MLP `fc1`, and
-MLP `fc2`, for 200 matrices total per checkpoint. The `quality21` profile stores
-170 in INT8 and 30 in BF16.
+## Comparison with official ComfyOrg files
 
-The BF16 island is:
+| Checkpoint | Size | Main matrices | Time/AdaLN representation |
+|---|---:|---:|---|
+| Official full INT8 ConvRot | 27.557 GiB | 300 INT8 | Wide FP32 AdaLN table |
+| Official pruned INT8 ConvRot | 19.530 GiB | 200 INT8 | Wide FP32 AdaLN table |
+| This stock quality21 edition | 20.940 GiB | 170 INT8 + 30 BF16 | FP32 `[4097,16]` table + 51 projections |
 
-- attention output projections in blocks 0–15, 17, 19, 20, 27, 38, 43–47,
-  and 49 (27 matrices);
-- MLP `fc2` in blocks 39, 45, and 49 (3 matrices).
+Each file is about 1.410 GiB larger than its official pruned INT8 counterpart.
+The additional space is intentionally spent on the rank-16 time representation
+and BF16 islands. The sampled weight-reconstruction proxy improved from about
+`0.9345%` mean relative error for official-style absmax INT8 to about `0.7639%`
+for this mixed profile. This is a proxy, not an end-to-end perceptual result.
 
-These were selected from deterministic reconstruction audits using 64 output
-rows and every input column of each matrix. Ref2VA independently selected the
-same 30-layer set as FL2VA, with a per-layer error correlation of `0.999676`.
-Attention output projections were the most error-prone family and are
-considerably cheaper to retain in BF16 than QKV or `fc1`. The exact
-machine-readable lists are in [`reports/layer_policy.json`](reports/layer_policy.json)
-and [`reports/layer_policy_ref2va.json`](reports/layer_policy_ref2va.json).
+## Installation
 
-## Stock-compatible time conditioning
+Place one or both diffusion checkpoints in:
 
-The time embedder maps the current diffusion timestep/noise level to a
-2,688-dimensional signal. Every transformer block turns this signal into its
-own AdaLN shifts, scales, and gates, telling the network which denoising stage
-is being evaluated.
+```text
+ComfyUI/models/diffusion_models/
+```
 
-At inference this frozen mapping traces a smooth one-dimensional curve because
-its input is a single scalar timestep. This release evaluates the original FP32
-time MLP offline, projects the curve onto a shared 16-dimensional basis, and
-stores those coordinates at 4,097 evenly spaced points:
+Place both VAE files in:
 
 ```text
-u(t) = SiLU(original_time_embedder(t))
-table[j] = project(u(j / 4096))
-AdaLN_i(t) = linear_i(interpolate(table, t))
+ComfyUI/models/vae/
 ```
 
-Each of the 50 block AdaLN projections and the final AdaLN projection remains a
-different FP32 linear layer. Only their shared input curve is compressed.
+Install a compatible MiniMax-H3 Qwen3-VL text encoder separately, then use the
+matching stock MiniMax-H3 FL2VA or Ref2VA workflow.
 
-On 19 validation timesteps, the relative AdaLN output error against the raw HF
-weights was `3.04e-7` to `3.82e-7` for FL2VA and `3.42e-7` to `4.46e-7` for
-Ref2VA across blocks 0, 24, 49, and the final layer. For context, the official
-pruned rank-8 FP16 tables measured about `0.016%–0.021%` on the same
-projections. This comparison covers only the time/AdaLN path, not end-to-end
-generation quality.
+## Validation performed
 
-## Comparison with official ComfyOrg files
+- safetensors structure, shapes, and dtypes;
+- 170/170 INT8 ConvRot blobs with group size 256;
+- all 30 BF16 main matrices present according to the published policy;
+- non-quantized source tensors compared against the raw MiniMax-H3 shards;
+- FP32 rank-16 time tables and 51 projections checked numerically;
+- full CPU load through clean, unmodified ComfyUI commit `14b05228` as
+  `ModelPatcher -> MiniMaxH3Model`, table mode enabled and no dynamic time MLP;
+- both VAE files fully loaded through the same clean ComfyUI;
+- VAE checksums match the standard ComfyOrg repackaged files.
 
-| Checkpoint | Size | Main matrices | Time/AdaLN representation |
-|---|---:|---:|---|
-| Official regular INT8 ConvRot | about 31.70 GiB | 200 INT8 | full AdaLN weights |
-| Official pruned INT8 ConvRot | 19.530 GiB | 200 INT8 | FP16 rank-8 table |
-| Each stock `table-k16 quality21` release | 20.940 GiB | 170 INT8 + 30 BF16 | FP32 rank-16 table, 4,097 rows |
-| Each patched `dynamic-k16 separate-QKV quality21` release | 20.999 GiB | Same 170 semantic main matrices; 270 physical INT8 modules | Original FP32 time MLP + FP32 dynamic rank-16 basis |
-
-Each stock file is about 1.410 GiB (7.22%) larger than its official pruned INT8
-counterpart. The patched edition adds about 0.059 GiB over the stock quality21
-file by restoring the original FP32 time MLP. The remaining added space is
-intentionally spent on a higher-precision time representation and a BF16 island
-for the most sensitive main matrices.
-
-The full 200-matrix sampled reconstruction proxies produced:
-
-| Variant | Official-style absmax INT8 | This profile |
-|---|---:|---:|
-| FL2VA | 0.9345% | 0.7639% |
-| Ref2VA | 0.9345% | 0.7639% |
-
-For these profiles, selected BF16 matrices count as zero storage reconstruction
-error. On the remaining 170 INT8 matrices, searched scales reduced the mean
-proxy from about 0.9109% to 0.8987%. The approximately 18.25% overall reduction
-is a sampled weight reconstruction result, **not** a perceptual or generation
-benchmark.
-
-## ComfyUI installation
-
-1. Use a current ComfyUI checkout with MiniMax-H3 and native INT8 ConvRot
-   support. The stock table files were CPU-load-tested on a clean, unmodified
-   ComfyUI commit `14b05228cef127ce529bc0c08660770d4af3e9a8`.
-2. If using a `dynamic-k16-separate-qkv` file, apply the included patch from the
-   root of that ComfyUI checkout. This is not required for the `table-k16` files:
-
-   ```powershell
-   git apply --check C:\path\to\comfyui-minimax-h3-dynamic-time-separate-qkv.patch
-   git apply C:\path\to\comfyui-minimax-h3-dynamic-time-separate-qkv.patch
-   ```
-
-   The patch was verified with `git apply --check` against commit `14b05228`.
-   It updates MiniMax-H3 model detection/runtime and makes partial-offload
-   bookkeeping tolerate packed INT8 layers without a regular `.weight` field.
-3. Place the FL2VA and/or Ref2VA safetensors file in
-   `ComfyUI/models/diffusion_models/`. FL2VA is for text/image first-last-frame
-   workflows; Ref2VA is for reference image/video/audio workflows.
-4. Place both files from `vae/` in `ComfyUI/models/vae/`.
-5. Load one diffusion checkpoint and both VAEs with the standard loaders in the
-   matching MiniMax-H3 FL2VA or Ref2VA workflow. Supply a compatible text
-   encoder separately.
+SHA-256:
 
 ```text
-ComfyUI/models/
-|-- diffusion_models/
-|   `-- <one FL2VA or Ref2VA table/dynamic-separate checkpoint>
-|-- vae/
-|   |-- minimax_h3_video_vae_fp16.safetensors
-|   `-- minimax_h3_audio_vae_fp32.safetensors
-`-- text_encoders/
-    `-- <MiniMax-H3 text encoder from its separate repository>
+ad0cf8b50ba92068b5a4477527d5da73412a22db99cded35b07195504e78cf6a  FL2VA/minimax-h3-fl2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors
+f4b2a8b4a53446f5d696a39deb693b09ac7ce37013793a8b19340644e38b154f  Ref2VA/minimax-h3-ref2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors
+7c1f131492e7eddacaac9069a61b81bdd39de5cc96561e677c5eab1cdce5e522  vae/minimax_h3_video_vae_fp16.safetensors
+8e505d95dd1561d47abd43d4238fd40d9bb1ae9e147ed0a4cba778d76ae4db48  vae/minimax_h3_audio_vae_fp32.safetensors
 ```
 
-No custom node is required. Only the two explicitly named dynamic/separate
-checkpoints require the included core patch.
-
-## Validation status
-
-Completed:
-
-- safetensors structure, shapes, dtypes, and all 170 ConvRot descriptors;
-- SHA-256: FL2VA
-  `ad0cf8b50ba92068b5a4477527d5da73412a22db99cded35b07195504e78cf6a`;
-  Ref2VA
-  `f4b2a8b4a53446f5d696a39deb693b09ac7ce37013793a8b19340644e38b154f`;
-- BF16 main island: 30/30 matrices bitwise equal to raw HF;
-- FL2VA: 871/871 tensors outside the time representation preserved bit-for-bit
-  during the final stock-table conversion;
-- Ref2VA: 258/258 direct source-copy tensors (4,146,503,680 bytes) bitwise equal
-  to raw HF;
-- FP32 table interpolation checked at every one of the 4,096 interval
-  midpoints; FL2VA grid rows reproduced exactly, and the independent Ref2VA
-  FP64-SVD rebuild differed by at most `4.55e-13`;
-- full CPU load through a clean, unmodified ComfyUI as
-  `ModelPatcher -> MiniMaxH3Model`, table mode `(4097, 16)`, for both diffusion
-  checkpoints;
-- patched editions: 1,181 keys, 270 INT8 ConvRot descriptors at group size 256,
-  zero fused-QKV keys, and all 156 Q/K/V projection tensors bitwise equal to
-  the corresponding thirds of the stock quality21 checkpoints;
-- patched editions: all 719 common non-QKV tensors bitwise equal to their stock
-  quality21 counterparts and all four FP32 time-MLP tensors bitwise equal to
-  the selected raw HF variant;
-- patched FL2VA dynamic coordinates reproduce the released 4,097-row table
-  bit-for-bit; the independently reconstructed Ref2VA dynamic path differs by
-  `2.89e-7` relative (`1.31e-6` maximum absolute coordinate error);
-- patched AdaLN output relative errors on 19 timesteps are `2.85e-7` to
-  `3.32e-7` for FL2VA and `2.96e-7` to `3.31e-7` for Ref2VA across blocks
-  0, 24, 49, and the final layer;
-- both patched files fully load on CPU through the patched ComfyUI as
-  `MiniMaxH3Model`, with dynamic basis enabled, table mode disabled, and
-  independent Q/K/V modules in both the main stack and token refiner;
-- patched SHA-256: FL2VA
-  `495b9d565b17194196646ef39b0c04ac7dde4a8df695b103b3fcbe04b5da00a6`;
-  Ref2VA
-  `82d16de12bee9d006c83c80b8843f2bb7e05cd25320724113ca7d128c6be6a04`;
-- both companion VAE files fully loaded on CPU through the same clean ComfyUI:
-  `MiniMaxH3VideoVAE` in FP16 with native internal tiling, and
-  `MiniMaxH3AudioVAE` in FP32 with 32 kHz stereo output;
-- companion VAE SHA-256 checksums match the official Comfy-Org repackaged files:
-  `7c1f131492e7eddacaac9069a61b81bdd39de5cc96561e677c5eab1cdce5e522`
-  (video) and
-  `8e505d95dd1561d47abd43d4238fd40d9bb1ae9e147ed0a4cba778d76ae4db48`
-  (audio).
-
-Not completed at release time:
-
-- CUDA/GPU loading of these exact checkpoints;
-- peak VRAM measurement for a target resolution and frame count;
-- end-to-end FL2VA or Ref2VA generation;
-- same-seed visual/audio A/B against BF16 and official pruned variants.
-
-Therefore, 20.940 GiB (stock table) or 20.999 GiB (patched dynamic/separate) 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.
-
-## Conversion provenance
-
-The converter reads the original top-level `transformer/` or `transformer_ref/`
-Diffusers shards from MiniMaxAI directly; it does not create a 61+ GiB merged
-BF16 intermediate. The nested task-specific transformer folders were not used
-because their already-packed QKV is head-major. The stock-compatible edition
-uses global `cat(Q,K,V)` packing expected by unmodified ComfyUI; the patched
-edition retains the top-level source's separate Q, K, and V ordering.
-
-The official FL2VA and Ref2VA pruned files,
-[`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)
-and
-[`minimax_h3_ref2va_pruned_int8_convrot.safetensors`](https://huggingface.co/Comfy-Org/MiniMax-H3/blob/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors),
-were used only as layout references and as the sources of the corresponding
-FP32 `rope.inv_freq` tensors absent from the raw Diffusers state dicts.
-
-The two files under `vae/` are unmodified, bit-identical copies of the standard
-[`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3/tree/main/vae)
-repackages. The original remote-code VAE bundles are more complicated: the
-visual VAE constructs a causal 3D-CNN encoder and 36-layer ViT decoder from
-Python and configuration files, while the audio VAE constructs a DAC-lineage
-encoder and BigVGAN decoder. ComfyUI implements both architectures natively.
-The single-file visual repack casts all 560 source weight tensors from FP32 to
-FP16 and embeds the latent statistics; the audio repack preserves 743 tensors,
-folds 172 weight-normalized pairs into ordinary FP32 weights, and embeds its
-latent statistics. No remote Python code or external VAE config is required.
-
-## Limitations and intended use
-
-This release is intended for research and local ComfyUI inference. It is a
-new, structurally validated operating point, not a completed quality benchmark.
-Both variants were profiled separately. Their independently selected
-quality21 BF16 islands are identical, but this does not establish perceptual
-quality without end-to-end A/B generation. The separate-QKV runtime also trades
-the fused projection for three independent ConvRot calls, so it should be
-treated as an experimental quality/architecture variant until GPU speed and
-VRAM are measured.
+## Validation not yet completed
+
+- GPU loading and peak-VRAM measurement;
+- fixed-seed end-to-end FL2VA/Ref2VA generation;
+- video and audio A/B quality comparison against BF16 and official INT8.
+
+The 20.940 GiB file size is a disk-weight target, not a guarantee that every
+24 GiB workflow will fit. Runtime memory also depends on activation size,
+resolution, frame count, attention implementation, and offload settings.
 
 ## License
 
-This derivative is distributed under the
-[MiniMax H3 Community License Agreement](LICENSE). The license limits use and
-distribution to its defined Applicable Territory, excludes the European Union,
-United Kingdom, Republic of Korea, and United States, and includes additional
-use and redistribution conditions. Read the full license and [`NOTICE`](NOTICE)
-before downloading, using, or redistributing these files.
+MiniMax H3 is distributed under the MiniMax H3 Community License Agreement.
+Read `LICENSE` before using or redistributing these derivatives. The
+modification summary is provided in `NOTICE`.
 
 ## Links
 
-- [Original MiniMax-H3 repository](https://huggingface.co/MiniMaxAI/MiniMax-H3)
+- [Original MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3)
+- [Experimental dynamic-time / separate-QKV edition](https://huggingface.co/DmitryDB/MiniMax-H3-INT8-Lean-ConvRot-Dynamic-Time-Separate-QKV)
 - [Official ComfyOrg MiniMax-H3 files](https://huggingface.co/Comfy-Org/MiniMax-H3)
-- [ComfyUI](https://github.com/Comfy-Org/ComfyUI)
+- [ComfyUI](https://github.com/comfyanonymous/ComfyUI)

Ref2VA/SHA256SUMS

@@ -1,2 +1 @@
 f4b2a8b4a53446f5d696a39deb693b09ac7ce37013793a8b19340644e38b154f  minimax-h3-ref2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors
-82d16de12bee9d006c83c80b8843f2bb7e05cd25320724113ca7d128c6be6a04  minimax-h3-ref2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors

Ref2VA/minimax-h3-ref2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:82d16de12bee9d006c83c80b8843f2bb7e05cd25320724113ca7d128c6be6a04
-size 22547376168

patches/comfyui-minimax-h3-dynamic-time-separate-qkv.patch

@@ -1,220 +0,0 @@
-diff --git a/comfy/ldm/minimax/model.py b/comfy/ldm/minimax/model.py
---- a/comfy/ldm/minimax/model.py
-+++ b/comfy/ldm/minimax/model.py
-@@ -143,19 +143,29 @@ def rope_rotation_table(angles, dtype):
- 
- 
- class Attention(nn.Module):
--    def __init__(self, hidden, heads, head_dim, eps, dtype=None, device=None, operations=None):
-+    def __init__(self, hidden, heads, head_dim, eps, separate_qkv=False,
-+                 dtype=None, device=None, operations=None):
-         super().__init__()
-         self.heads = heads
-         self.head_dim = head_dim
-+        self.separate_qkv = separate_qkv
-         inner = heads * head_dim
--        self.qkv_proj = operations.Linear(hidden, inner * 3, bias=False, dtype=dtype, device=device)
-+        if separate_qkv:
-+            self.q_proj = operations.Linear(hidden, inner, bias=False, dtype=dtype, device=device)
-+            self.k_proj = operations.Linear(hidden, inner, bias=False, dtype=dtype, device=device)
-+            self.v_proj = operations.Linear(hidden, inner, bias=False, dtype=dtype, device=device)
-+        else:
-+            self.qkv_proj = operations.Linear(hidden, inner * 3, bias=False, dtype=dtype, device=device)
-         self.q_norm = operations.RMSNorm(head_dim, eps=eps, dtype=dtype, device=device)
-         self.k_norm = operations.RMSNorm(head_dim, eps=eps, dtype=dtype, device=device)
-         self.out_proj = operations.Linear(inner, hidden, bias=False, dtype=dtype, device=device)
- 
-     def forward(self, x, rope_freqs=None, transformer_options={}):
-         s = x.shape[0]
--        q, k, v = self.qkv_proj(x).split(self.heads * self.head_dim, dim=-1)
-+        if self.separate_qkv:
-+            q, k, v = self.q_proj(x), self.k_proj(x), self.v_proj(x)
-+        else:
-+            q, k, v = self.qkv_proj(x).split(self.heads * self.head_dim, dim=-1)
-         v = v.view(s, self.heads, self.head_dim)
-         if rope_freqs is not None:
-             # fused per-head RMSNorm + partial split-half rope, in place on the qkv buffer
-@@ -224,11 +234,13 @@ def _mod_gate(x, gate, other, segments):
- 
- 
- class RefinerBlock(nn.Module):
--    def __init__(self, hidden, heads, head_dim, ffn, eps, qk_eps, dtype=None, device=None, operations=None):
-+    def __init__(self, hidden, heads, head_dim, ffn, eps, qk_eps, separate_qkv=False,
-+                 dtype=None, device=None, operations=None):
-         super().__init__()
-         self.norm1 = operations.RMSNorm(hidden, eps=eps, dtype=dtype, device=device)
-         self.norm2 = operations.RMSNorm(hidden, eps=eps, dtype=dtype, device=device)
--        self.attn = Attention(hidden, heads, head_dim, qk_eps, dtype=dtype, device=device, operations=operations)
-+        self.attn = Attention(hidden, heads, head_dim, qk_eps, separate_qkv=separate_qkv,
-+                              dtype=dtype, device=device, operations=operations)
-         self.mlp = MLP(hidden, ffn, dtype=dtype, device=device, operations=operations)
- 
-     def forward(self, x, transformer_options={}):
-@@ -239,10 +251,11 @@ class RefinerBlock(nn.Module):
- 
- class TokenRefiner(nn.Module):
-     def __init__(self, num_layers, hidden, heads, head_dim, ffn, eps, qk_eps, final_eps,
--                 dtype=None, device=None, operations=None):
-+                 separate_qkv=False, dtype=None, device=None, operations=None):
-         super().__init__()
-         self.blocks = nn.ModuleList([
--            RefinerBlock(hidden, heads, head_dim, ffn, eps, qk_eps, dtype=dtype, device=device, operations=operations)
-+            RefinerBlock(hidden, heads, head_dim, ffn, eps, qk_eps, separate_qkv=separate_qkv,
-+                         dtype=dtype, device=device, operations=operations)
-             for _ in range(num_layers)])
-         self.final_norm = operations.RMSNorm(hidden, eps=final_eps, dtype=dtype, device=device)
- 
-@@ -254,11 +267,13 @@ class TokenRefiner(nn.Module):
- 
- class DiTBlock(nn.Module):
-     def __init__(self, hidden, heads, head_dim, ffn, t_dim, eps, qk_eps,
--                 apply_silu=True, adaln_dtype=None, dtype=None, device=None, operations=None):
-+                 apply_silu=True, adaln_dtype=None, separate_qkv=False,
-+                 dtype=None, device=None, operations=None):
-         super().__init__()
-         self.norm1 = operations.RMSNorm(hidden, eps=eps, dtype=dtype, device=device)
-         self.norm2 = operations.RMSNorm(hidden, eps=eps, dtype=dtype, device=device)
--        self.attn = Attention(hidden, heads, head_dim, qk_eps, dtype=dtype, device=device, operations=operations)
-+        self.attn = Attention(hidden, heads, head_dim, qk_eps, separate_qkv=separate_qkv,
-+                              dtype=dtype, device=device, operations=operations)
-         self.mlp = MLP(hidden, ffn, dtype=dtype, device=device, operations=operations)
-         self.adaln_proj = AdalnProj(t_dim, hidden, 6, 3, apply_silu=apply_silu,
-                                     dtype=adaln_dtype if adaln_dtype is not None else dtype,
-@@ -416,7 +431,7 @@ class MiniMaxH3Model(nn.Module):
-                  timestep_input_dim=256, time_embed_hidden_size=5376, time_embed_dim=2688,
-                  rope_inv_freq_len=16, norm_eps=1e-5, qk_norm_eps=1e-5, final_norm_eps=1e-5,
-                  sigma_shift_video=12.0, sigma_shift_audio=3.0,
--                 adaln_curve_grid=None,
-+                 adaln_curve_grid=None, adaln_curve_basis_dim=None, separate_qkv=False,
-                  image_model=None, dtype=None, device=None, operations=None, **kwargs):
-         super().__init__()
-         self.dtype = dtype
-@@ -426,30 +441,43 @@ class MiniMaxH3Model(nn.Module):
-         self.audio_latents_dim = audio_latents_dim
-         self.sigma_shift_video = sigma_shift_video
-         self.sigma_shift_audio = sigma_shift_audio
--        self.use_adaln_curves = adaln_curve_grid is not None
--        # curve-form checkpoints replace the time embedder and full-width adaln weights with a small shared basis of the time-embedding curve
-+        self.separate_qkv = separate_qkv
-+        if adaln_curve_grid is not None and adaln_curve_basis_dim is not None:
-+            raise ValueError("adaln table and dynamic basis modes are mutually exclusive")
-+        self.use_adaln_table = adaln_curve_grid is not None
-+        self.use_adaln_basis = adaln_curve_basis_dim is not None
-+        self.use_adaln_curves = self.use_adaln_table or self.use_adaln_basis
-+        # Curve checkpoints replace full-width adaLN weights with projections
-+        # over a small shared basis.  Table mode also replaces the time MLP;
-+        # dynamic-basis mode retains it and projects its exact fp32 output.
-         curve = {"apply_silu": not self.use_adaln_curves,
-                  "adaln_dtype": torch.float32 if self.use_adaln_curves else dtype}
-+        adaln_dim = adaln_curve_basis_dim if self.use_adaln_basis else time_embed_dim
-         video_patch_dim = latents_dim * self.patch_size[0] * self.patch_size[1] * self.patch_size[2]
- 
-         self.video_patch_proj = operations.Linear(video_patch_dim, hidden_size, bias=True, dtype=torch.float32, device=device)
-         self.audio_patch_proj = operations.Linear(audio_latents_dim, hidden_size, bias=True, dtype=torch.float32, device=device)
-         self.condition_proj = operations.Linear(text_dim, hidden_size, bias=True, dtype=dtype, device=device)
--        if self.use_adaln_curves:
-+        if self.use_adaln_table:
-             self.register_buffer("adaln_t_table", torch.empty(adaln_curve_grid, time_embed_dim, dtype=torch.float32))
-         else:
-             self.time_embedder = TimeEmbedder(timestep_input_dim, time_embed_hidden_size, time_embed_dim,
-                                               dtype=torch.float32, device=device, operations=operations)
-+            if self.use_adaln_basis:
-+                self.register_buffer("adaln_curve_basis", torch.empty(time_embed_dim, adaln_curve_basis_dim, dtype=torch.float32))
-+                self.register_buffer("adaln_curve_mean", torch.empty(time_embed_dim, dtype=torch.float32))
-         self.rope = nn.Module()
-         self.rope.register_buffer("inv_freq", torch.empty(rope_inv_freq_len, dtype=torch.float32))
-         self.token_refiner = TokenRefiner(token_refiner_num_layers, hidden_size, num_attention_heads,
-                                           attention_head_dim, ffn_hidden_size, norm_eps, qk_norm_eps,
--                                          final_norm_eps, dtype=dtype, device=device, operations=operations)
-+                                          final_norm_eps, separate_qkv=separate_qkv,
-+                                          dtype=dtype, device=device, operations=operations)
-         self.blocks = nn.ModuleList([
-             DiTBlock(hidden_size, num_attention_heads, attention_head_dim, ffn_hidden_size,
--                     time_embed_dim, norm_eps, qk_norm_eps, **curve, dtype=dtype, device=device, operations=operations)
-+                     adaln_dim, norm_eps, qk_norm_eps, separate_qkv=separate_qkv,
-+                     **curve, dtype=dtype, device=device, operations=operations)
-             for _ in range(num_layers)])
--        self.final_layer = FinalLayer(hidden_size, time_embed_dim, video_patch_dim, audio_latents_dim,
-+        self.final_layer = FinalLayer(hidden_size, adaln_dim, video_patch_dim, audio_latents_dim,
-                                       final_norm_eps, **curve, dtype=dtype, device=device, operations=operations)
- 
-     def preprocess_text_embeds(self, text_states):
-@@ -599,12 +627,19 @@ class MiniMaxH3Model(nn.Module):
-                 aoff += n
- 
-         t_vals = torch.tensor(unique_t, dtype=torch.float32, device=device)
--        if self.use_adaln_curves:
-+        if self.use_adaln_table:
-             # adaln projections consume interpolated coordinates of the time-embedding curve
-             table = comfy.model_management.cast_to(self.adaln_t_table, device=device)
-             pos = t_vals.clamp(0.0, 1.0) * (table.shape[0] - 1)     # t in [0,1] -> fractional grid index, out-of-range t clamps to the curve ends
-             i0 = pos.floor().long().clamp(max=table.shape[0] - 2)   # lower grid row, max-clamp keeps t=1.0 on the last interval instead of reading past the table
-             t_emb = torch.lerp(table[i0], table[i0 + 1], (pos - i0).unsqueeze(1))  # blend the two rows by the fractional part
-+        elif self.use_adaln_basis:
-+            # Preserve the original fp32 time MLP and remove only the redundant
-+            # directions that its smooth one-dimensional output curve never uses.
-+            full_t_emb = nn.functional.silu(self.time_embedder(t_vals))
-+            basis = comfy.model_management.cast_to(self.adaln_curve_basis, device=device)
-+            mean = comfy.model_management.cast_to(self.adaln_curve_mean, device=device)
-+            t_emb = (full_t_emb - mean) @ basis
-         else:
-             t_emb = self.time_embedder(t_vals).to(dtype)
- 
-diff --git a/comfy/model_detection.py b/comfy/model_detection.py
---- a/comfy/model_detection.py
-+++ b/comfy/model_detection.py
-@@ -368,11 +368,23 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
-         dit_config["latents_dim"] = state_dict['{}final_layer.video_out.weight'.format(key_prefix)].shape[0] // 4  # patch 1x2x2
-         dit_config["audio_latents_dim"] = state_dict['{}final_layer.audio_out.weight'.format(key_prefix)].shape[0]
-         dit_config["attention_head_dim"] = state_dict['{}blocks.0.attn.q_norm.weight'.format(key_prefix)].shape[0]
--        qkv = state_dict['{}blocks.0.attn.qkv_proj.weight'.format(key_prefix)]
--        dit_config["num_attention_heads"] = qkv.shape[0] // (3 * dit_config["attention_head_dim"])
-+        qkv_key = '{}blocks.0.attn.qkv_proj.weight'.format(key_prefix)
-+        separate_keys = tuple('{}blocks.0.attn.{}_proj.weight'.format(key_prefix, name) for name in ('q', 'k', 'v'))
-+        if qkv_key in state_dict_keys:
-+            qkv = state_dict[qkv_key]
-+            dit_config["num_attention_heads"] = qkv.shape[0] // (3 * dit_config["attention_head_dim"])
-+        elif all(k in state_dict_keys for k in separate_keys):
-+            q, k, v = (state_dict[name] for name in separate_keys)
-+            if q.shape != k.shape or q.shape != v.shape:
-+                raise ValueError("MiniMax H3 separate Q/K/V projection shapes do not match")
-+            dit_config["num_attention_heads"] = q.shape[0] // dit_config["attention_head_dim"]
-+            dit_config["separate_qkv"] = True
-+        else:
-+            raise ValueError("MiniMax H3 checkpoint has neither fused nor separate Q/K/V projections")
-         dit_config["ffn_hidden_size"] = state_dict['{}blocks.0.mlp.fc1.weight'.format(key_prefix)].shape[0] // 2
-         dit_config["text_dim"] = state_dict['{}condition_proj.weight'.format(key_prefix)].shape[1]
-         table_key = '{}adaln_t_table'.format(key_prefix)
-+        basis_key = '{}adaln_curve_basis'.format(key_prefix)
-         if table_key in state_dict_keys:
-             # adaln shipped over a precomputed curve basis: the adaln linears span a small shared basis of the time-embedding curve (no time embedder)
-             table = state_dict[table_key].shape  # [grid, k]
-@@ -383,6 +395,11 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
-             dit_config["timestep_input_dim"] = te.shape[1]
-             dit_config["time_embed_hidden_size"] = te.shape[0]
-             dit_config["time_embed_dim"] = state_dict['{}time_embedder.proj_out.weight'.format(key_prefix)].shape[0]
-+            if basis_key in state_dict_keys:
-+                basis = state_dict[basis_key].shape  # [full time dim, compact adaLN dim]
-+                if basis[0] != dit_config["time_embed_dim"]:
-+                    raise ValueError("MiniMax H3 adaLN basis input does not match time embedder output")
-+                dit_config["adaln_curve_basis_dim"] = basis[1]
-         dit_config["rope_inv_freq_len"] = state_dict['{}rope.inv_freq'.format(key_prefix)].shape[0]
-         if metadata is not None and "config" in metadata:
-             dit_config.update(json.loads(metadata["config"]).get("transformer", {}))
-diff --git a/comfy/model_patcher.py b/comfy/model_patcher.py
---- a/comfy/model_patcher.py
-+++ b/comfy/model_patcher.py
-@@ -231,8 +231,11 @@ def get_key_weight(model, key):
-         except AttributeError:
-             pass
- 
--        weight = getattr(op, op_keys[1])
--        if convert_func is not None:
-+        # Quantized comfy_kitchen layers (int8/fp4) may not expose a regular
-+        # .weight attribute.  Returning None lets the existing caller skip
-+        # those packed weights during partial-offload bookkeeping.
-+        weight = getattr(op, op_keys[1], None)
-+        if weight is not None and convert_func is not None:
-             weight = comfy.utils.get_attr(model, key)
- 
-     return weight, set_func, convert_func

reports/loadtest_dynamic_separate_fl2va.json

@@ -1,31 +0,0 @@
-{
-  "checkpoint": "F:\\AI\\ComfyUI_windows_portable\\ComfyUI\\models\\diffusion_models\\minimax-h3\\minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors",
-  "bytes": 22547374816,
-  "load_device": "cpu",
-  "elapsed_seconds": 8.17470669746399,
-  "checks": {
-    "model_class": "MiniMaxH3Model",
-    "separate_qkv": true,
-    "dynamic_basis": true,
-    "table_mode": false,
-    "basis_shape": [
-      2688,
-      16
-    ],
-    "has_main_q_proj": true,
-    "has_main_k_proj": true,
-    "has_main_v_proj": true,
-    "has_main_qkv_proj": false,
-    "has_refiner_q_proj": true,
-    "has_refiner_qkv_proj": false,
-    "time_proj_in_shape": [
-      5376,
-      256
-    ],
-    "time_proj_out_shape": [
-      2688,
-      5376
-    ]
-  },
-  "status": "pass"
-}

reports/loadtest_dynamic_separate_ref2va.json

@@ -1,31 +0,0 @@
-{
-  "checkpoint": "F:\\AI\\ComfyUI_windows_portable\\ComfyUI\\models\\diffusion_models\\minimax-h3\\minimax-h3-ref2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors",
-  "bytes": 22547376168,
-  "load_device": "cpu",
-  "elapsed_seconds": 8.223532438278198,
-  "checks": {
-    "model_class": "MiniMaxH3Model",
-    "separate_qkv": true,
-    "dynamic_basis": true,
-    "table_mode": false,
-    "basis_shape": [
-      2688,
-      16
-    ],
-    "has_main_q_proj": true,
-    "has_main_k_proj": true,
-    "has_main_v_proj": true,
-    "has_main_qkv_proj": false,
-    "has_refiner_q_proj": true,
-    "has_refiner_qkv_proj": false,
-    "time_proj_in_shape": [
-      5376,
-      256
-    ],
-    "time_proj_out_shape": [
-      2688,
-      5376
-    ]
-  },
-  "status": "pass"
-}

reports/validation_dynamic_separate_fl2va.json

@@ -1,32 +0,0 @@
-{
-  "variant": "fl2va",
-  "checkpoint": "F:\\AI\\ComfyUI_windows_portable\\ComfyUI\\models\\diffusion_models\\minimax-h3\\minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors",
-  "table_source": "F:\\AI\\ComfyUI_windows_portable\\ComfyUI\\models\\diffusion_models\\minimax-h3\\minimax-h3-fl2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors",
-  "bytes": 22547374816,
-  "gib": 20.99887916445732,
-  "keys": 1181,
-  "quantized_linears": 270,
-  "quant_groups": {
-    "256": 270
-  },
-  "fused_qkv_keys": 0,
-  "separate_qkv_projection_weights": 156,
-  "qkv_split_tensors_bitwise": 156,
-  "common_tensors_bitwise": 719,
-  "bf16_main": 30,
-  "time_embedder_bitwise_raw_hf": true,
-  "basis_shape": [
-    2688,
-    16
-  ],
-  "basis_orthogonality_max_abs": 5.364418029785156e-07,
-  "dynamic_vs_released_table_relative": 0.0,
-  "dynamic_vs_released_table_max_abs": 0.0,
-  "adaln_curve_samples": 19,
-  "adaln_relative_errors": {
-    "block_0": 3.2893751722440356e-07,
-    "block_24": 3.324676356442069e-07,
-    "block_49": 3.217328412574716e-07,
-    "final": 2.851764975275728e-07
-  }
-}

reports/validation_dynamic_separate_ref2va.json

@@ -1,32 +0,0 @@
-{
-  "variant": "ref2va",
-  "checkpoint": "F:\\AI\\ComfyUI_windows_portable\\ComfyUI\\models\\diffusion_models\\minimax-h3\\minimax-h3-ref2va-int8-lean-convrot-dynamic-k16-separate-qkv-quality21.safetensors",
-  "table_source": "F:\\AI\\ComfyUI_windows_portable\\ComfyUI\\models\\diffusion_models\\minimax-h3\\minimax-h3-ref2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors",
-  "bytes": 22547376168,
-  "gib": 20.998880423605442,
-  "keys": 1181,
-  "quantized_linears": 270,
-  "quant_groups": {
-    "256": 270
-  },
-  "fused_qkv_keys": 0,
-  "separate_qkv_projection_weights": 156,
-  "qkv_split_tensors_bitwise": 156,
-  "common_tensors_bitwise": 719,
-  "bf16_main": 30,
-  "time_embedder_bitwise_raw_hf": true,
-  "basis_shape": [
-    2688,
-    16
-  ],
-  "basis_orthogonality_max_abs": 2.384185791015625e-07,
-  "dynamic_vs_released_table_relative": 2.8884949188068276e-07,
-  "dynamic_vs_released_table_max_abs": 1.30385160446167e-06,
-  "adaln_curve_samples": 19,
-  "adaln_relative_errors": {
-    "block_0": 3.29813104826826e-07,
-    "block_24": 3.3073698091357073e-07,
-    "block_49": 3.2451748666062485e-07,
-    "final": 2.9567746651082416e-07
-  }
-}