Add files using upload-large-folder tool

FL2VA/SHA256SUMS

@@ -1 +1,2 @@
 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

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

README.md

@@ -24,10 +24,14 @@ 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.
+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. They use the standard
-MiniMax-H3 `adaln_t_table` format and load in an unmodified ComfyUI.
+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/).
 
 ## Included files
 
@@ -35,10 +39,15 @@ MiniMax-H3 `adaln_t_table` format and load in an unmodified ComfyUI.
 |---|---|
 | [`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 |
 
@@ -48,14 +57,12 @@ 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.
 
-## What was changed
+## Shared quantization policy
 
 The original FL2VA and Ref2VA Diffusers shards each contain 50 transformer
-blocks with separate Q, K, and V tensors. The converter streams the selected
-variant directly and performs the layout changes required by current ComfyUI
-MiniMax-H3 support:
+blocks with separate Q, K, and V tensors. Both release layouts use the same
+quality21 precision policy:
 
-- packs attention rows as global `cat(Q, K, V)`;
 - 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;
@@ -63,14 +70,52 @@ MiniMax-H3 support:
 - 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;
-- evaluates the original FP32 time embedder offline and stores its smooth
-  one-dimensional output curve as a dense FP32 table with 4,097 rows and 16
-  coordinates;
 - replaces only the redundant input width of the 51 large AdaLN projections,
   while keeping every block and final AdaLN projection separate in FP32.
 
-Each checkpoint contains 872 tensor entries: 170 INT8 weights, 170
-quantization configuration blobs, 250 BF16 entries, and 282 FP32 entries.
+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:
+
+```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)
+```
+
+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.
+
+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.
 
 ## Precision policy
 
@@ -92,7 +137,7 @@ 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).
 
-## Time conditioning and the AdaLN table
+## Stock-compatible time conditioning
 
 The time embedder maps the current diffusion timestep/noise level to a
 2,688-dimensional signal. Every transformer block turns this signal into its
@@ -126,12 +171,14 @@ generation quality.
 |---|---:|---:|---|
 | 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 `quality21` release | 20.940 GiB | 170 INT8 + 30 BF16 | FP32 rank-16 table, 4,097 rows |
+| 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 file is about 1.410 GiB (7.22%) larger than its official pruned INT8
-counterpart. The added space is intentionally spent on a much denser,
-higher-precision time curve and a BF16 island for the most sensitive main
-matrices.
+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:
 
@@ -149,21 +196,31 @@ benchmark.
 ## ComfyUI installation
 
 1. Use a current ComfyUI checkout with MiniMax-H3 and native INT8 ConvRot
-   support. This release was CPU-load-tested on a clean, unmodified ComfyUI
-   commit `14b05228cef127ce529bc0c08660770d4af3e9a8`.
-2. Place the FL2VA and/or Ref2VA safetensors file in
+   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.
-3. Place both files from `vae/` in `ComfyUI/models/vae/`.
-4. Load one diffusion checkpoint and both VAEs with the standard loaders in the
+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.
 
 ```text
 ComfyUI/models/
 |-- diffusion_models/
-|   |-- minimax-h3-fl2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors
-|   `-- minimax-h3-ref2va-int8-lean-convrot-table-k16-g4097-quality21.safetensors
+|   `-- <one FL2VA or Ref2VA table/dynamic-separate checkpoint>
 |-- vae/
 |   |-- minimax_h3_video_vae_fp16.safetensors
 |   `-- minimax_h3_audio_vae_fp32.safetensors
@@ -171,7 +228,8 @@ ComfyUI/models/
     `-- <MiniMax-H3 text encoder from its separate repository>
 ```
 
-No custom node or core patch is required for either checkpoint.
+No custom node is required. Only the two explicitly named dynamic/separate
+checkpoints require the included core patch.
 
 ## Validation status
 
@@ -193,6 +251,25 @@ Completed:
 - 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;
@@ -209,17 +286,19 @@ Not completed at release time:
 - end-to-end FL2VA or Ref2VA generation;
 - same-seed visual/audio A/B against BF16 and official pruned variants.
 
-Therefore, 20.940 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.
+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, while current ComfyUI expects
-global `cat(Q,K,V)` packing.
+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)
@@ -245,7 +324,10 @@ 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.
+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.
 
 ## License
 

Ref2VA/SHA256SUMS

@@ -1 +1,2 @@
 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

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

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

@@ -0,0 +1,220 @@
+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

@@ -0,0 +1,31 @@
+{
+  "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

@@ -0,0 +1,31 @@
+{
+  "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

@@ -0,0 +1,32 @@
+{
+  "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

@@ -0,0 +1,32 @@
+{
+  "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
+  }
+}