Upload 4 files

modular_model_index.json

@@ -52,7 +52,7 @@
         null,
         null
       ],
-      "pretrained_model_name_or_path": "OzzyGT/MiniMax_H3_sdnq_dynamic_8bit",
+      "pretrained_model_name_or_path": "OzzyGT/MiniMax_H3_sdnq_8bit_pruned",
       "subfolder": "vae",
       "variant": null,
       "revision": null

vae/config.json

@@ -0,0 +1,100 @@
+{
+  "_class_name": "MiniMaxH3Fp16DecoderVae",
+  "_diffusers_version": "0.36.0.dev0",
+  "in_channels": 3,
+  "out_channels": 3,
+  "latent_channels": 24,
+  "block_out_channels": [
+    128,
+    256,
+    256,
+    512,
+    512,
+    1024
+  ],
+  "layers_per_block": 2,
+  "spatial_downsample_factors": [
+    2,
+    2,
+    2,
+    2,
+    1,
+    1
+  ],
+  "temporal_downsample_factors": [
+    1,
+    2,
+    2,
+    1,
+    1,
+    1
+  ],
+  "norm_num_groups": 32,
+  "norm_eps": 1e-06,
+  "spatial_padding_mode": "reflect",
+  "decoder_num_layers": 36,
+  "decoder_num_attention_heads": 32,
+  "decoder_attention_head_dim": 64,
+  "decoder_num_register_tokens": 4,
+  "decoder_ffn_mult": 4,
+  "decoder_rope_theta": 100.0,
+  "decoder_rope_dim_ratio": 0.75,
+  "decoder_norm_eps": 1e-05,
+  "clip_length": 17,
+  "token_drop": 3,
+  "latents_mean": [
+    0.858090341091156,
+    -0.9606591463088989,
+    1.0661640167236328,
+    -0.5090325474739075,
+    -0.2727581858634949,
+    -1.3675414323806763,
+    -0.2553254961967468,
+    -0.26907554268836975,
+    -0.5376840829849243,
+    -0.0464097298681736,
+    0.6657370328903198,
+    0.19690127670764923,
+    -0.5460608005523682,
+    -0.4035342037677765,
+    -0.23683024942874908,
+    0.25928452610969543,
+    -0.30133944749832153,
+    0.211341992020607,
+    -1.1206848621368408,
+    0.3581933379173279,
+    -0.04225143790245056,
+    0.2604829967021942,
+    0.22864092886447906,
+    0.7056031823158264
+  ],
+  "latents_std": [
+    1.2223774194717407,
+    1.2767263650894165,
+    1.6831774711608887,
+    1.7549455165863037,
+    1.5636216402053833,
+    2.194143533706665,
+    0.9653137922286987,
+    1.0569885969161987,
+    0.841948926448822,
+    0.7729952931404114,
+    1.8955937623977661,
+    0.946841835975647,
+    0.7996809482574463,
+    0.44988900423049927,
+    0.7197399735450745,
+    0.6936293244361877,
+    2.961095094680786,
+    2.7694199085235596,
+    3.0496184825897217,
+    2.1088054180145264,
+    3.276226282119751,
+    3.1627357006073,
+    2.2816812992095947,
+    2.6127843856811523
+  ],
+  "auto_map": {
+    "AutoModel": "modeling_minimax_h3_vae_fp16.MiniMaxH3Fp16DecoderVae"
+  }
+}

vae/diffusion_pytorch_model.safetensors

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

vae/modeling_minimax_h3_vae_fp16.py

@@ -0,0 +1,47 @@
+"""MiniMax-H3 video VAE that holds the float16 decoder this checkpoint was saved with.
+
+`AutoencoderKLMiniMaxH3` pins every top-level module to float32 through `_keep_in_fp32_modules`,
+so a pipeline-level `dtype=` cannot reach the weights. That is deliberate upstream: the decode
+block runs `vae.decode` inside `torch.autocast(torch.float16)`, and the pin stops a pipeline
+running in bfloat16 from downcasting the decoder to a format with fewer mantissa bits than the
+recipe is built on.
+
+The cost is that a checkpoint already storing a float16 decoder gets upcast on load: 5.19 GiB of
+weights become 9.70 GiB, and the autocast then builds a float16 copy of all of them on every pass,
+so decode peaks at 14.90 GiB instead of 6.65 GiB.
+
+This class carries the checkpoint's own layout instead of the caller's dtype: the decoder ends up
+float16 with its per-block `scale1` / `scale2` modulation tensors in float32 -- exactly the 511/72
+split stored in the file -- whatever `dtype` the pipeline passes, including bfloat16.
+
+It keeps the upstream pin rather than narrowing it, and casts down afterwards, because the route
+matters. Narrowing the pin lets a `dtype=torch.bfloat16` load land the decoder in bfloat16 first,
+and casting that to float16 is a lossy round trip: bfloat16 keeps 8 mantissa bits against
+float16's 10, which measured 1.4e-2 of drift against 2.8e-3 for the real thing. Loading pinned to
+float32 is a lossless widening of the stored float16, so the cast back recovers the original bits.
+"""
+
+import torch
+
+from diffusers.models.autoencoders.autoencoder_kl_minimax_h3 import AutoencoderKLMiniMaxH3
+
+
+FP32_DECODER_SUFFIXES = ("scale1", "scale2")
+
+
+class MiniMaxH3Fp16DecoderVae(AutoencoderKLMiniMaxH3):
+    # Left exactly as upstream: every module widens to float32 at load, losslessly.
+    _keep_in_fp32_modules = ["encoder", "decoder", "quant_conv", "post_quant_conv"]
+
+    def apply_checkpoint_dtypes(self):
+        """Put the decoder back to the float16/float32 split the checkpoint stores."""
+        for name, parameter in self.decoder.named_parameters():
+            target = torch.float32 if name.endswith(FP32_DECODER_SUFFIXES) else torch.float16
+            if parameter.dtype != target and parameter.dtype.is_floating_point:
+                parameter.data = parameter.data.to(target)
+        return self
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        model = super().from_pretrained(*args, **kwargs)
+        return model.apply_checkpoint_dtypes()