MiniMax-H3-Image-Pruned

MiniMax-H3-Image without the weights its inference never needs: 135.3 GB → 95.1 GB on disk (transformer, text encoder and VAE). The stock Diffusers and Transformers classes load it like the original, with no custom code and no trust_remote_code. Text-to-image results are bit-identical to the original on the same GPU; edit results differ by a small margin (PSNR 43.3 dB on the test edit). Every kept tensor is a byte copy of the original; nothing is quantized or retrained.

	Original	Pruned
Transformer	66.3 GB, 33.1B parameters	40.2 GB, 20.1B parameters
Text encoder (Qwen3-VL-32B)	66.7 GB, 64 decoder layers	52.5 GB, 51 decoder layers
VAE	2.3 GB	2.3 GB (unchanged)

Usage

pip install "diffusers @ git+https://github.com/huggingface/diffusers@875373ac7f5856071e345a3e394c74efccc6b9e6" \
  "transformers>=5.22" accelerate torchvision

import torch
from diffusers import ComponentsManager, ModularPipeline

manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda")  # or skip this and call pipe.to("cuda") on a GPU with 96 GB or more

pipe = ModularPipeline.from_pretrained("WaveCut/MiniMax-H3-Image-Pruned", components_manager=manager)
pipe.load_components(dtype=torch.bfloat16)

image = pipe(
    prompt="The image is a top-down photograph of ...",
    height=3552,
    width=4736,
    generator=torch.Generator().manual_seed(42),
    output="images",
)[0]

This is the code of the original card with another repository name. Editing: pass image=reference (or a list) and refer to the images as <Picture 1>, <Picture 2>, ... in the prompt. The prompting guidance of the original card applies unchanged: long, complete English descriptions; recommended sizes from 4096×4096 (1:1) to 6272×2688 (21:9).

Memory modes

enable_auto_cpu_offload moves a model off the GPU only when the next one does not fit. On a 96 GB card the pruned models fit together, so after the first image nothing moves and the run is as fast as with everything on the GPU (peak 92.7 GiB). For the lowest peak, keep one model on the GPU at a time; set the strategy after loading, because adding the components resets it to the default:

pipe.load_components(dtype=torch.bfloat16)
manager.set_offload_strategy(lambda hooks, **kwargs: hooks)  # move every other model off the GPU first

The peak is then 50-52 GiB, set by the text encoder (48.9 GiB of weights), and each image moves both models over PCIe: about 72 s at 2048×2048 instead of 5.6 s (see Profiles).

The components also load alone with the stock classes: MiniMaxH3ImageTransformer2DModel.from_pretrained(repo, subfolder="transformer") and Qwen3VLForConditionalGeneration.from_pretrained(repo, subfolder="text_encoder").

What was removed

• AdaLN projection inputs (13.0B parameters). Every block projects the timestep embedding to its modulation vectors, and the checkpoint samples on a fixed grid: six steps (one output head per step), plus t = 0.999 for the reference images of an edit. Seven timesteps need seven input columns, so adaln_proj.linear and norm_out.linear keep 8 of their 2688 input columns (time_embed_dim: 8 in the config). The new time_embedder (16 hidden units) turns each grid timestep into a one-hot code, and column k holds the original projection's output for timestep k. The stock forward pass then returns the original modulation values exactly; the GitHub repository explains the construction.
• Text encoder layers 51-63 and lm_head. The transformer is conditioned on hidden_states[50] of the Qwen3-VL text encoder, the output of decoder layer 49. Layer 50 stays because the pipeline requires more than 50 layers; with 51 layers, hidden_states[50] is still the output of layer 49. lm_head is tied to the input embedding, so loading allocates nothing for it.

Text-to-image and edit

The original model computes the modulation for a step with one timestep row in text-to-image and with two rows (step and reference) in an edit, and the matrix products round slightly differently in the two cases. The pruned checkpoint stores one value per timestep: the text-to-image value for the six steps and the edit value for the reference timestep.

• Text-to-image: bit-identical to the original.
• Edit: not bit-identical. 59,279 of the 29.1 million modulation values of the six step rows (0.20 %) differ from the original's two-row result by rounding steps. Through the 50 blocks this changes each edit step's transformer output by 2.1-2.5 % (relative L2), and the 2048×2048 test edit by PSNR 43.3 dB: mean absolute difference 0.63 of 255, 261 of 4.2 million pixels off by more than 64. In the worst region the differences follow edges; the two images look the same.

Profiles

Measured on one RTX PRO 6000 Blackwell Server Edition (96 GB, 600 W power limit), bfloat16, one image after a warm-up image. Time includes prompt encoding, six steps and VAE decoding.

Run	2048×2048	Edit, 2048×2048	4736×3552	GPU memory peak, 4736×3552
Original, model offload (code of the original card)	97.6 s	101.6 s	120.8 s	68.2 GiB
Pruned, one model on the GPU at a time	72.2 s	76.0 s	92.8 s	50.4 GiB (edit: 51.7 GiB)
Pruned, all on the GPU (pipe.to("cuda"))	5.6 s	9.3 s	26.7 s	92.7 GiB

The original does not fit a 96 GB card (124 GiB of transformer and text encoder), so the offload manager moves the transformer and the text encoder for every image. With one model on the GPU at a time the pruned checkpoint does the same, with 30 % less data to move. With everything on the GPU nothing moves; the stock auto offload (the code above) measured the same on this card, 5.6 s / 9.4 s / 26.4 s with a 92.7 GiB peak. The sampling steps themselves cost the same in all rows. GPUs with 80 GB or with 141 GB or more were not measured.

All rows ran on the same machine. With every model on the GPU (auto offload on this card included), the edit took 14-22 s instead of 9.3 s in three of five runs: the text encoder's pass over the reference image took 5-9 s instead of under 1 s. The cause is not identified; the table shows the fast runs. With one model on the GPU at a time the images are bit-identical to the all-on-GPU ones.

Verification

scripts/verify.py in the GitHub repository ran the official Modular Diffusers pipeline and this checkpoint, both with the stock classes, on the same prompts and seeds: two text-to-image prompts and one edit at 2048×2048, and one text-to-image prompt at 4736×3552.

• Text-to-image images: bit-identical in every run (0 differing pixels), with model offload and with everything on the GPU.
• Text conditioning (hidden_states[50], 36 to 1757 tokens, the edit included): bit-identical.
• Transformer: the 18 recorded calls of the original pipeline, replayed through the pruned transformer. The 12 text-to-image calls give bit-identical outputs; the 6 edit calls differ by 2.1-2.5 % (relative L2).
• Edit image: PSNR 43.3 dB against the original, mean absolute difference 0.63 of 255.
• Build checks: every grid timestep gives an exact one-hot code with float32, TF32 and bfloat16 matmuls; every stored column times 32 reproduces the original projection output.
• The published repository, loaded from the Hub into an empty cache with only Diffusers and Transformers installed (the code above), reproduced the text-to-image test image bit for bit and the edit with the same PSNR 43.3 dB.

Software: torch 2.11.0+cu128, diffusers at 875373ac, transformers 5.22.2, NVIDIA driver 615.71.09; source checkpoint MiniMaxAI/MiniMax-H3-Image@492fd8c4.

Limits

• Only the release's sampling grid. A timestep off the grid gives no valid code, and the stock transformer does not check for it: the result is wrong without an error. The original has one output head per step of this grid and cannot change it either.
• The stored values were computed on an RTX PRO 6000 Blackwell. On another GPU type the original model can round its own AdaLN outputs differently by single bfloat16 steps, while this checkpoint keeps the values of the build GPU, so the two can differ there by about as much as the original differs between two GPU types (not measured). minimax-h3-image-prune --skip text_encoder copies from the GitHub repository rebuilds the transformer on your GPU.
• SGLang and ComfyUI were not tested with this checkpoint.

Files

Path	Content
transformer/	Transformer with 8-column AdaLN projections and the one-hot time_embedder; build_report.json
text_encoder/	Qwen3-VL conditioner, decoder layers 0-50, with its tokenizer files
vae/, tokenizer/, processor/, scheduler/	Original files
modular_model_index.json	Modular Diffusers index, original component classes
LICENSE, NOTICE	MiniMax-H3-Image Community License and the required notice
assets/	Card images

License

MiniMax-H3-Image is licensed under the MiniMax-H3-Image Community License Agreement, Copyright © 2026 MiniMax. All Rights Reserved. This is a modified version by WaveCut; the modified files carry a notice of the change (_notice in configs, notice in safetensors metadata). The license applies to this repository unchanged: use, reproduction and distribution are licensed only within the Applicable Territory, which excludes the European Union, the United Kingdom, the Republic of Korea and the United States of America, and they are subject to the Acceptable Use Policy (Exhibit A). A Hosted Service, or annual revenue above 1 million USD, needs MiniMax's prior written authorization. See LICENSE.