MiniMax H3 Pruned Turbo LoRA (4-Step)
for FL2VA model
Special thanks to larryvrh for the original MiniMax H3 Turbo LoRA:
https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora
This adapted release is based on the original acceleration checkpoint:
or
https://github.com/xiaolibai-sys/ComfyUI-MiniMaxH3
first
Announcement
After several days of experimentation, I have identified a serious issue: certain DiT blocks (from the 20th to the 40th) in Minimax H3 are extremely sensitive to input perturbations—even when the AdaLN modulation error is as small as 1e-5 to 1e-4. After propagating through 50 layers, this can result in a 10% difference in the hidden L2 norm (compared to the BF16 model + LoRA). Therefore, this is not a good approach, and I have decided to abandon it. Perhaps a better alternative is to follow Larryvrh's method of precomputing t_embedding and computing online. In other words, the offline approximated AdaLN_t_table with low-rank structure cannot adequately represent the rich dynamics of LoRA—it is lossy. However, for users with extremely limited VRAM, this remains the only way to bake weights offline into the model (at least for now). I will provide a simple baking script at https://github.com/xiaolibai-sys/MiniMax-H3-Lora-Bake, where you can bake the converted LoRA weights to reduce runtime LoRA memory usage. Finally, thank you all for your support.
What This Is
This is a complete pruned MiniMax H3 LoRA for 4-step video and audio generation. The original Turbo LoRA targets the full 2688-dimensional AdaLN branch. Pruned models instead use an 8-dimensional adaln_t_table plus per-block projections, so the original AdaLN matrices cannot be applied directly.
This adapted LoRA bakes the AdaLN adaptation into the pruned model format. It contains the backbone LoRA weights, adaln_t_table, per-block AdaLN projection weights and biases, and final layer AdaLN weights and biases. No h3_silu_temb_grid file is required at runtime.
Available Versions
There are two versions of the adapted LoRA.
The first version uses ALS optimization. The shared table and every per-block projection are jointly refined over several iterations. This version gives the best accuracy for a single complete LoRA. Measured against the exact BF16 full model plus LoRA modulation, block max relative error is around 1.5e-5 and final layer relative error is around 4.5e-5.
The second version uses a fixed shared table. The table is initialized from builtin:fl2va or builtin:ref2va and is not updated. Only projection and bias are optimized. Block max relative error is around 8.8e-5 and final layer relative error is around 1.27e-4.
The ALS version is recommended when you only need one adapter and want the closest possible approximation. The fixed-table version is recommended when multiple LoRA adapters must be combined. Because all fixed-table outputs share the same T, projections can be combined linearly:
P_combined = P_base + sum(strength_j (P_j - P_base))
b_combined = b_base + sum(strength_j (b_j - b_base))
T_combined = T_common
Both versions are complete pruned LoRAs and can be placed directly into ComfyUI/models/loras.
How to Use
Place the LoRA into:
ComfyUI/models/loras
Then load it with the official LoraLoader, LoraLoaderModelOnly, or the MiniMax H3 LoRA Loader node from ComfyUI-MiniMaxH3.
Support for the complete pruned LoRA format in ComfyUI is proposed here(DOWNLOAD IT FIRST):
https://github.com/Comfy-Org/ComfyUI/pull/15353
Support is also included in ComfyUI-MiniMaxH3 version 1.2.0 and newer(with audio shift fixed):
https://github.com/xiaolibai-sys/ComfyUI-MiniMaxH3
The table builder repository is available here:
https://github.com/xiaolibai-sys/MiniMax-H3-Pruned-Lora-Adapter
Credits
Original acceleration LoRA by larryvrh.
Official ComfyUI integration PR:
https://github.com/Comfy-Org/ComfyUI/pull/15353
ComfyUI node package:
Description
FAQ
Comments (19)
what does this have to do with lightx2v at all?
do these work on the refrence model by chance?
Same doubt for me also
Supported with Ref2VA Model ?
Worked perfectly for me, though I did bump it up to 8 steps instead of 4. For those not sure how to use it, just put it in a Lora Loader with a strength of 1 and plug your minimax model (e.g. - minimax_h3_ref2va_pruned_int8_convrot.safetensors) into the Lora Loader, and then the Lora Loader into both the Basic Guider and the Basic Scheduler. Then adjust the steps in the Basic Scheduler to 8. Done.
so have u tested with Ref2VA Model ?
From my first comment: "minimax_h3_ref2va_pruned_int8_convrot.safetensors". That's the model I'm using.
Update: No_Cantaloupe_735599 provided a link to a higher quality lora that's half the size of this one: https://civitai.red/models/2837571/minimax-h3-turbo-loras?modelVersionId=3202732
The explanation is too difficult to understand when looking at the post written by xiaolibai-sys. I found this a bit confusing, so I tried to sort it out in my own words:
The original is larryvrh's MiniMax-H3-Turbo-Lora.
However, there is a problem using it with pruned models. So xiaolibai-sys fixed this issue, making the Turbo LoRA usable on pruned models as well — and that's what's uploaded here.
The title mentions LightX2V, but this wasn't actually made by the LightX2V team. It seems the name was just added to help people understand what kind of thing this is. Strictly speaking, it isn't LightX2V. I think that only added to the confusion for people. In my opinion, the name Turbo Lora alone would have been sufficient.
-----------------------------------------
I just finished testing and am adding a comment.
To use xiaolibai-sys's LoRA, you have to install a dedicated custom node pack and use a dedicated node; however, I found that it doesn't yield better results and is slow.
If I have to endure various inconveniences and take additional actions without any benefit in return, what is the reason to bother using this? I don't know.
I tested combining Larryvrh's LoRA with a pruned model, and there were no issues. It is true that there were problems initially, but they have now been resolved. To quote Larryvrh's GitHub Commit e7ad532:
"Pruned/curve base support: run-time adaln injection, one LoRA covers all bases (v1.1.0)"
I apologize to xiaolibai-sys for saying this, but... you can just use Larryvrh's Turbo LoRA. It is faster and of better quality.
so i have a question. can anyone bake this lora into the base model and then make a int8 convrot version? if that's even possible.
i'm saying this because i'm very vram limited, and adding a lora, any lora, adds a lot to the inference time. so much that i almost have no speed gain
Yes, it is possible, and I made a small tool for exactly this use case:
https://github.com/xiaolibai-sys/MiniMax-H3-Lora-Bake
It takes a complete pruned LoRA and the pruned int8 convrot base model, dequantizes the ComfyUI weights to FP32, folds the LoRA into the weights, then requantizes back using the same ComfyUI int8 convrot layout (weight, weight_scale, and comfy_quant metadata). The output is a fixed base model, so there is no per-step LoRA compute and no LoRA file to load during inference. This should be run from your ComfyUI environment, and comfy-kitchen must be installed before running the bake script.
@xiaolibai_2019260 thank you! i installed everything and i'm testing your script right now
https://imgur.com/cKxv7g7
it's stuck at that stage though,
baked blocks.48 (41.4s, 882 keys staged)
baked blocks.49 (42.1s, 900 keys staged)
baked token_refiner.blocks.0
baked token_refiner.blocks.1
and my disk usage is at 100%
Edit: nevermid, it's done.
@ZelashZelash Glad it worked out! Hope the baked model gives you the VRAM headroom and speed you were looking for.
I used the original turbo lora just fine with the pruned model, only difference is that it threw a harmless key error which you can ignore.
Could you explain how this is different from larryvrh's for us who don't understand all the technical stuff?
How is this different from Larryvrh’s?
Here’s the simplest way to think about it.
Imagine the full MiniMax H3 model is a big kitchen with every tool available. The pruned model is a smaller kitchen that saves memory but is missing some tools. The original Turbo LoRA is a recipe written for the big kitchen.
Larryvrh’s node is like a portable helper that stands beside the small kitchen and improvises the missing tools every time you cook. It can make the recipe work on the pruned model, but you need that special helper installed, and you need to use their custom node every time.
Our tool is different: it translates the recipe once into a version that only uses tools the small kitchen already has. The output is a self-contained pruned LoRA file. You don’t need the helper to improvise during cooking anymore. You just load the translated file.
So both can achieve a similar result, but they work in different ways:
Larryvrh’s approach: original recipe + special helper running in the background
Our approach: translated recipe, ready to load as a complete pruned LoRA file
Practical differences:
Larryvrh’s needs its custom node and bundled grid to make the original LoRA work on pruned models.
Our converted LoRA is designed to be loaded through our node, and also through standard ComfyUI loading once the official PR is merged, without that runtime helper.
Our converted LoRA also supports combining multiple LoRAs on a shared base, which makes community LoRAs easier to stack and publish.
If someone says they used the original Turbo LoRA on pruned and only saw one “harmless key warning,” that probably means they were using Larryvrh’s node, which handles the missing part automatically. In a standard loader, that warning actually means an important part of the LoRA is being skipped, so it is not harmless.
Which one should you use?
If you already use Larryvrh’s node and it works well, you don’t need to switch. If you want a self-contained LoRA file, easier distribution, standard loading compatibility, and the ability to combine multiple LoRAs, our converted version is the better fit.
@xiaolibai_2019260 Ah ok, I think I get it. So this can be used without the custom lora loader. What about the custom sampler? I guess I don't need to use that either?
Less motion with this lora. Compared with others turbo lora like Turbo lora by tsolful.
You're right. Better quality and half the size. Thanks for sharing the link.