Image Generation

A few dozen images, under 15,000 steps: T8's MiniMax H3 Image training guide is really about pairing your images correctly

November 23, 20260 views阅读中文原文
A few dozen images, under 15,000 steps: T8's MiniMax H3 Image training guide is really about pairing your images correctly

The short version

This is a training tutorial that T8 (T8star-Aix on Bilibili) published on the morning of November 22 — not a model launch, and not another unpacking of new weights. It picks up where his previous video left off (the single-head node plus a detail-correction LoRA) and fills in the step most people get stuck on: how do you actually train your own MiniMax H3 Image LoRA?

Three takeaways from the video:

  • It converges fast. The author used only "a few dozen images," and a text-to-image LoRA was usable somewhere between a few thousand and roughly fifteen thousand steps. His three runs stopped at 18,500, 10,500 and 15,000 steps; the 15,000-step one held up better on side profiles and small angles.
  • Stop watching the loss curve. Convergence is quick enough that the curve stops telling you anything. He is explicit that what matters is "how it actually looks when you run it" — if it looks close enough, stop.
  • For editing, the pairing direction matters more than the hyperparameters. When training on paired images, the target must be the finished result, and the control image must be the original. Get that backwards and the run is wasted.

What the seven-minute video actually shows

The video runs 7:17 and follows a clean line:

  1. It recaps the previous day's release: a full BF16 backbone, a single-head multi-step node, and a 172 MB MLP100 correction LoRA meant to restore material detail at long step counts.
  2. It introduces the new piece: the trainer has been uploaded, people in the comments and group chats are already running it, and the common reaction is "this is the easiest model I've ever trained."
  3. It then demonstrates two kinds of training live: text-to-image LoRA and image editing on paired images.
  4. It closes with comparisons: close-up similarity, side angles, and the edited results.

The author does not hide the weak spot: on face consistency, H3 Image is weaker than Qwen-Image 2.1. His explanation is straightforward — H3 Image has far more parameters, more detail and a better grasp of concepts, so once consistency is patched up, its range of uses widens considerably. Training a LoRA is that patch.

How to use the trainer: three settings to get right before you start

The video uses an existing trainer UI (he says it is uploaded, but does not say the repository name out loud). Three places are easy to get wrong:

Common pitfalls

  • Pick the right base model. Two entries in the list have very similar names; choose the original H3 Image one. Choosing the wrong entry makes every parameter below it meaningless.
  • Leave memory-saving options off if you have headroom. Only enable the low-VRAM option and layer offloading when VRAM or system RAM is short. Leaving them on when you have room just makes the run slower for nothing.
  • Scale rank with your dataset. For higher-resolution data you can push rank to 32 or 64. For a personal set of a few dozen images, the default is enough.

Two smaller habits: set several save points in the output directory, or earlier checkpoints get overwritten; and set the step count higher than you need, because you can stop at any time — if you do not need the extra steps, just interrupt.

Paired-image training: don't flip the direction

This is the most useful part of the video, and it is what decides whether the run works.

Text-to-image is simple: one image, a trigger word, and some keywords. No control image needed.

Image editing is different — you feed paired images, meaning "before" and "after":

  • Target = the final result image, the one you want the model to learn to output.
  • Control image = the original, the input before editing.
  • For paired or multi-image training you must upload the control image; skipping it throws an error.

He also mentions turning off a particular default toggle for paired training (in his words, the option that handles things by first frame or first image). It does not change the concept, but it is worth checking against the UI when you actually sit down to do it.

As for what you can teach: his framing is that "the model already has these concepts, and training reinforces them." So he demonstrates object removal — clutter in the original, clean in the result. You are not teaching the model what removal is; you are aligning an existing ability to your own material. The same applies to three-view sheets and turning a subject while keeping identity.

There is also a combination trick: when rotating a direction, stacking the earlier text-to-image LoRA raises similarity. The two work together — one handles concept and detail, the other handles direction and identity.

How to use the trained model

The second half is two comparison sets. He gives no numeric table; everything is visual judgment, so here it is as stated:

  • Slow route: the previous day's "detail-enhanced original model" at many steps. A 10,000-step LoRA looks decent here, but some angles still don't match well.
  • Fast route: six steps plus the QKV correction — a combination he says scored better than some other models in an earlier test. Add the trained LoRA and you can lower CFG a little.
  • His own verdict: you still have to actually run it, not just read the curve. The same LoRA gives different answers under different samplers and angles.
  • Editing route: after the edit, stacking the matching LoRA pushes consistency higher again. His tone is noticeably firmer here — at that point he considers it competitive with Qwen-Image 2.1, and H3 Image natively outputs 4K, which he calls very important.

One update at the end: the online workflow from the previous video failed to configure on RunningHub yesterday and is fixed and live today. It accepts all kinds of LoRAs — the node outputs a single head, but LoRAs still work, and he says it felt good in his own runs. For anyone who does not want to fight with 66 GB of weights locally, that is the path to try first.

Official specs and the license you need to read

To give "can I even train this" a reference point, here are the hard numbers from the official model card:

  • The DiT has 33.1B parameters, 50 layers, hidden size 5376, 56 attention heads, FFN size 14336, and 3D multimodal RoPE.
  • Weights are BF16; the embedding, timestep and output layers are FP32.
  • The released checkpoint is distilled to 6 sampling steps with no classifier-free guidance — which is exactly why every community "multi-step" effort needs an extra node and a correction LoRA.
  • Output is about 16 megapixels: 4096×4096 at 1:1, up to 6272×2688 at the widest, with no external upscaler.
  • Text-to-image and instruction-based editing live in one checkpoint, with up to 16 reference images.
  • The text encoder is not in the image repository; it is pulled separately from MiniMax-H3 and is about 66.7 GB.

The license is the part people skip. MiniMax-H3-Image ships under a community license whose "Applicable Territory" excludes the European Union, the United Kingdom, the Republic of Korea and the United States. Anyone in those regions needs separate written authorization. Open weights do not mean free commercial use, and they do not mean globally available. If you plan to sell something, check where you are first.

Who this is not a good fit for

  • People who want a one-click finished LoRA. This is still a workflow where you build the dataset and judge the output yourself; the author repeats that the call is visual, with no automatic scoring.
  • Machines short on VRAM or RAM. Training is heavier than inference. The inference setup in the video is 16 GB of VRAM plus 128 GB of RAM for a 66 GB backbone; training is tighter still.
  • People who need precise local edits. The failure cases in his earlier experimental LoRA include drift in local edits and a missing umbrella handle. Training improves consistency; it does not turn editing into pixel-level control.
  • People who care about face consistency and won't train. By the author's own account, the base model is behind Qwen-Image 2.1 there, and that gap stays until you train.

Cost and time

  • Training itself: a few dozen images, a few thousand to roughly fifteen thousand steps. He calls it "very fast," and finished models land in the output directory under the trigger-word folder.
  • The real hardware cost is model size: a 66.29 GB full backbone (the community ComfyUI conversion), a 27.14 GB INT8 text encoder, and a 1.17 GB VAE. Running fully local means budgeting disk and RAM first.
  • To skip that: use the online workflow he fixed today.

Next steps

  1. Train a text-to-image LoRA on 20–40 images in one style, set the step count around 12,000, check it by eye halfway through, and stop if it isn't working.
  2. Then prepare 15–30 image pairs (original → result), put the result in the target slot and the original in the control slot, and train one narrow concept such as removal or background swap.
  3. Fix the prompt and seed, then compare three setups — six steps with QKV, six steps with your LoRA, and many steps with the detail LoRA — and keep only the one that looks most stable.
  4. Before any commercial use, confirm which territory you are in.

Sources

This article is based on a full transcript of the Bilibili video titled "MiniMax H3 Image training tutorial — high-detail suite model nodes, much better ID consistency, every weak spot covered, extremely low training difficulty" (BV1Auy5zzE3w, published November 22, 2026). Official specifications and license terms come from the MiniMax-H3-Image model card and LICENSE on Hugging Face. The state of the trainer ecosystem is corroborated by several third-party H3 Image LoRA training projects on GitHub. The author did not name the trainer repository in the video, so this article does not attribute it to a specific repository.

Sources

Comments

0 published
Log inorsign up to leave a comment.

Loading comments...