MiniMax-H3-SVDQuant-int4-pdd8

MiniMax-H3 SVDQuant INT4 + PDD 8-Step (Baked, Curve AdaLN)

A merged checkpoint for MiniMax-H3 (33B single-stream audio-video DiT, FL2VA) combining SVDQuant 4-bit quantization (rank 128, INT4) with the official PDD 8-step distillation (alibaba-pai/MiniMax-H3-Acc-LoRAs).

• The trunk LoRA (rank 64) is baked into the SVDQuant low-rank branches (global rank 128→320), so it adds zero runtime overhead; the PDD head bank switches the distilled output heads per sigma, enabling 8-step sampling.
• The AdaLN modulation tables use the curve parameterization (same as the Comfy-Org pruned release: one shared adaln_t_table + per-block [96768, 8] projections) instead of the raw bf16 tables. This alone removes ~24GB from the checkpoint.

Result: 14GB checkpoint — 30% smaller than the official int8 (20GB), and it is the only 24GB configuration that keeps the whole DiT resident on the GPU.

Benchmarks (RTX 4090 24GB, ComfyUI 0.34, sage, 1344×768 × 141 frames ≈ 145k packed tokens, seed 12345)

Measured end-to-end (cold: model load + text encode + 8/20 steps + VAE decode + save; "warm" = models already resident, same measurement otherwise). Sampling alone (8 steps) is ~115 s of the 189 s:

4.4× faster than this model's own naive first run, 3.2× faster than the official int8 Turbo stack, 3.0× faster than the official PDD stack — at identical step count (8) and the same seed.

Why: on a 24GB card the official 21GB int8 checkpoint can never fully reside next to the ~145k-token activation working set (three tuned-budget attempts OOMed), so every step pays PCIe streaming. At 14GB this checkpoint fits entirely with ~6GB of activation headroom once the KJNodes low-VRAM patches are applied — zero streaming. The int4 GEMM itself was never the bottleneck.

Same token count at the community's reference load (1056×608 × 243 frames): 201 s with this model (vs 400 s for the best tuned int8+Turbo configuration we could get OOM-free).

Timing note: our benchmarks used a remote text-encoder service (TE ~3 s). With a local qwen3vl-32B nvfp4 TE on a 24GB card, add roughly +130 s on the first run (weight load + dequant encode; measured 8.6 s + 122 s on a 4090D) and ~10-40 s when the TE has to swap back in for a new prompt; repeated runs with the same prompt skip TE entirely via conditioning cache. All compared stacks share the same TE cost, so the speed ratios are unaffected.

The 24GB recipe (what the fast row uses)

1. KJNodes experimental MiniMax patches: MiniMaxH3MemoryEfficientSageAttentionPatch → MiniMaxLowVRAMAttention (head_chunks 4) → MiniMaxChunkFeedForward (chunks 2). These cut the activation peak without changing the math.
2. ModelMemoryUsageFactorOverride (KJNodes, memory category) set to 0.06, so ComfyUI's activation estimate stops pushing the DiT into offload. 0.06 was measured on ComfyUI 0.34; if your build estimates differently, tune by the load_models_gpu log line: raise the factor if you OOM, lower it until the DiT reports fully resident.

Upstream KJNodes calls quantized modules directly with 2D packed tensors, which the nunchaku SVDQuant layers reject. Use our drop-in build instead (same nodes, SVDQuant-compatible):

• comfyui_kj_minimax_patches.py → drop into ComfyUI/custom_nodes/ (standalone, no other deps). If you also have full KJNodes installed, its upstream MiniMax nodes conflict by name — remove KJNodes' minimax nodes or keep only this file (upstream's versions crash on SVDQuant modules; see file header).
• minimax_h3_int4_pdd8_workflow_24gb_api.json — the full 24GB workflow (this recipe wired up); minimax_h3_int4_pdd8_workflow_api.json remains the plain baseline.

If your GPU has ≥32GB (5090, RTX PRO), the plain workflow already fits; the recipe only buys you headroom.

Sample

Same prompt/seed as the benchmark: "A golden retriever runs across a sunlit beach, splashing through the shallow waves." — 1344×768 × 141 frames @ 24fps, with audio:

<video src="https://huggingface.co/1ronman1993/MiniMax-H3-SVDQuant-int4-pdd8/resolve/main/samples/dog_beach_int4_pdd8_kj.mp4" controls muted></video>

Quality vs the same-pipeline int8+PDD baseline: LPIPS ≈ 0.37 (fp4 sibling measurement; this int4 build tracks it within run-to-run drift). Patch-neutrality of the 24GB recipe vs the unpatched run on the same weights: LPIPS 0.34–0.41, SSIM 0.70–0.80, audio waveform correlation 0.94 — same scene, fine detail shifted by the head-grouped sage quantization.

Which GPUs this is for

Turing / Ampere / Ada (sm_75 – sm_89): RTX 3090, 4090, 4070 Ti SUPER, A100, L40, …

Blackwell GPUs (RTX 50 series, sm_120) dropped INT4 tensor cores — nunchaku has no INT4 GEMM kernel there and will refuse to load this file (Please use "fp4" quantization for Blackwell GPUs). On Blackwell, use the fp4 sibling instead: 1ronman1993/MiniMax-H3-SVDQuant-fp4-pdd8.

Files

• svdq-int4_r128-minimax-h3-curveadaln-pdd8.safetensors — main model → ComfyUI/models/diffusion_models/
• minimax_h3_fl2va_pdd_acc_8step_comfyui.safetensors — PDD head bank → ComfyUI/models/pdd_acc/ (ComfyUI conversion of the alibaba-pai release; the PDD node switches distilled output heads per sigma)
• comfyui-nunchaku-minimax-h3.tar.gz — the ComfyUI-nunchaku plugin build with MiniMax-H3 support (NunchakuMinimaxH3DiTLoader); unpack into ComfyUI/custom_nodes/ComfyUI-nunchaku/
• comfyui_kj_minimax_patches.py — SVDQuant-compatible KJNodes MiniMax patch nodes (see recipe above)
• minimax_h3_int4_pdd8_workflow_api.json — ComfyUI API-format workflow (plain)
• minimax_h3_int4_pdd8_workflow_24gb_api.json — ComfyUI API-format workflow (24GB-optimized)

Requirements

• ComfyUI ≥ 0.33 (post MiniMax-H3 carried-audio rework)

• The bundled ComfyUI-nunchaku plugin (see above). It additionally requires the nunchaku Python package with MiniMax-H3 support — this is not in upstream yet, so build it from the fork (needs a CUDA toolkit with nvcc; ~10 min build):

  git clone https://github.com/cage1993/nunchaku.git -b feat/minimax-h3
  cd nunchaku && git submodule update --init --recursive
  NUNCHAKU_INSTALL_MODE=FAST pip install -e . --no-build-isolation
  

  Plugin python deps (pip install -r requirements.txt in the plugin folder) are only needed for the plugin's other model families; for MiniMax-H3 alone, diffusers, transformers, safetensors and accelerate suffice.

• ComfyUI-MiniMax-H3-PDD-Acc (provides MiniMaxH3PDDAccApply / MiniMaxH3SigmaShift)

• sageattention (the 24GB recipe uses it through the patch nodes)

• Remaining components from Comfy-Org/MiniMax-H3:

  • text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors → ComfyUI/models/text_encoders/
  • vae/minimax_h3_video_vae_fp16.safetensors and vae/minimax_h3_audio_vae_fp32.safetensors → ComfyUI/models/vae/

Sampling recipe (must follow exactly)

• Sampler euler + sigmas from the MiniMaxH3PDDAccApply node output (8 steps), CFG = 1.0
• MiniMaxH3SigmaShift: shift_video = 12, shift_audio = 3
• MiniMaxH3PDDAccApply: lora_strength = 0 (trunk LoRA already baked into this checkpoint), head_strength = 1.0, nfe = 8
• Do NOT stack block-caching nodes (TeaCache / EasyCache / …) or other distillation LoRAs

License

• Derived weights of MiniMax-H3 — subject to the original model's license
• PDD Acc LoRA: alibaba-pai, Apache-2.0
• comfyui_kj_minimax_patches.py vendors nodes from kijai/ComfyUI-KJNodes, Apache-2.0