Training a LoRA normally costs hours. Z-Image's Image-to-LoRA path claims to produce a reusable LoRA in the low tens of seconds, and this episode tests the updated Z-Image version of that path: 6 images in, a style LoRA out, then a text-to-image run, then the same LoRA inside a depth-ControlNet graph with high/low-noise splitting and tiled upscaling. The author reports the style is recognisably reproduced, while admitting that content from the training set leaks into the output.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (3 files); anything the video reports about results is attributed to the author.

When this is useful

  • You want a style LoRA from a handful of reference images and cannot wait hours for a training run.
  • You need the LoRA to be reusable: download it once, then drop it into other ComfyUI graphs.
  • You want style transfer under control by combining the i2L LoRA with a depth ControlNet pass.

What changed in this version

Three graphs, one training node

The episode ships three workflows: training + test, training + ControlNet test, and training + ControlNet test + tiled upscale.

All three share the same primitive: a single RunningHub i2L node that takes a batch of images, trains, and hands back a LoRA file. On the online platform the LoRA is downloadable from the task list; running locally it is written to disk.

The previous version of this trick was built on Qwen-Image; the Z-Image version landed on 30 January. The graph is built on the Z-Image Base family, not Turbo.

Why Base and not Turbo

The author states plainly that this technique does not work with the Turbo model and only works with Base. That is why the ControlNet graph takes Base in the high-noise half and Base again in the low-noise half instead of handing over to Turbo.

CLIP is wired to the positive conditioning only. The author is explicit that the negative branch must not be fed from the CLIP loader; the official negative prompt is supplied in the graph instead.

High/low noise split, then tiled upscale

The point of splitting is not to switch models mid-run: it is to let the ControlNet act only in the high-noise phase, then let the low-noise phase finish the image, before a tiled upscale pass.

The author reports 50 steps in total, split 25 high-noise / 25 low-noise, and describes the upscale stage as almost fully automatic.

The ControlNet itself is depth-based: load an image, run it through a preprocessor to get the control image, and scale by pixels rather than by a fixed side length.

What the tests actually show

A pure text-to-image run driven by a 6-image training set keeps the style, but reference elements from the training set still show up. The author calls separating style from content "very difficult" and does not claim it is solved.

When the training set contains many faces, generated characters are affected; removing the faces from the training set lowers that influence noticeably.

The official guidance is 1-6 training images; the author uses 6, calling that "sufficient".

How to run it

  1. Open the training + test graph on RunningHub (or install the open-source node locally, which the author says runs fully offline).
  2. Load 6 training images; the official range is 1-6 and the author treats 6 as sufficient.
  3. Run the i2L node. On the platform, download the LoRA from the task list; locally it is saved to disk.
  4. Switch to the text-to-image graph, insert the LoRA, and keep the CLIP feed on the positive side only with the official negative prompt.
  5. For the ControlNet variant: load a control image, run the preprocessor, set the pixel-based size, and let the graph split 50 steps into 25 high-noise and 25 low-noise.
  6. Finish with the tiled upscale graph; the author describes that stage as almost automatic.

Parameter basis

Z Image i2L (Image to LoRA)快速lora训练+测试 - 23 nodes

Item Value (from JSON)
UNET loader z_image_bf16.safetensors / default
CLIP loader qwen_3_4b.safetensors / lumina2
VAE ae.safetensors
KSampler steps 50 · cfg 4 · res_multistep · simple · denoise 1
Latent size 1024x1536 · batch 1
LoRA (empty slot - the i2L node writes the trained LoRA here at run time) @ 1.1 / clip 1

Z Image i2L (Image to LoRA)快速lora训练+联合CN测试+放大 - 62 nodes

Item Value (from JSON)
UNET loader z_image_bf16.safetensors / default
CLIP loader qwen_3_4b.safetensors / lumina2
VAE ae.safetensors
BasicScheduler steps 10 · scheduler simple · denoise 1
KSampler steps 20 · cfg 3 · euler · simple · denoise 0.25
Latent size 512x472 · batch 1
LoRA Z-Image-Fun-Lora-Distill-4-Steps-2602-ComfyUI.safetensors @ 1; (empty slot - the i2L node writes the trained LoRA here at run time) @ 1.1 / clip 1

Z Image i2L (Image to LoRA)快速lora训练+联合CN测试 - 43 nodes

Item Value (from JSON)
UNET loader z_image_bf16.safetensors / default
CLIP loader qwen_3_4b.safetensors / lumina2
VAE ae.safetensors
BasicScheduler steps 10 · scheduler simple · denoise 1
Latent size 512x472 · batch 1
LoRA Z-Image-Fun-Lora-Distill-4-Steps-2602-ComfyUI.safetensors @ 1; (empty slot - the i2L node writes the trained LoRA here at run time) @ 1.1 / clip 1

The 50-step setting, the 25/25 split and the CFG 4 / sigma shift 8 recommendation are stated in the video; the sampler wiring above is read from the JSON. In the ControlNet graph the KSampler shows 20 steps at cfg 3 with denoise 0.25, i.e. it is a partial-denoise refinement pass after the custom-sampler split.

Honest limits

  • Styles, not identities. The author positions i2L for style reference; content elements from the training set leak into results and that is not fixed.
  • Base only. The technique is stated not to work with Turbo, which rules out the fastest Z-Image route.
  • Face-heavy training sets bias the output. Fewer faces in the set, less leakage.
  • The "tens of seconds" figure is the author's report from the video, not an independent benchmark.

Episode resources