LC Krea2 Semantic Vector Tuner

Merging is the popular way to change a model, and it's also the blunt one: you need a second checkpoint that already has the quality you want, then you average the two and hope the good parts don't cancel. LC Krea2 Semantic Vector Tuner is the other approach. One model goes in, the same model comes out, and specific regions of its weights have been scaled up or down - amplification instead of interpolation.

If you've ever wanted "more of what this model already does, but only in the late blocks," this is the node rather than a merge.

How it works

The mechanism is ported from the Arthemy SDXL Suite's model tuner, and it's a neat trick: for each weight tensor, it first bakes any patches already applied (via comfy.lora.calculate_weight), multiplies the baked tensor by your target multiplier, and then adds the difference back as a patch through ModelPatcher.add_patches. So nothing is overwritten destructively - it's a delta patch on top of the live model, which is also why it composes with LoRAs. Put it after your LoRA loaders and the LoRA's contribution gets baked into the scaled result rather than scaled separately.

Because it's a patch and not baked weights, the tuned model exists only for the session. Write it out with LC Checkpoint Save when you've found something you like.

The inputs

There are a lot of sliders, but they fall into three groups and only one group is fiddly.

model - one checkpoint. No second model, that's the whole point.

mode is the setting people skip and shouldn't. Soft Value (the default) runs your slider through a response curve before applying it: below 1.0 it eases down gently, and above it everything compresses hard, so a slider set to 2.0 lands at roughly 1.13x rather than doubling the weights. Real Value applies the number literally. Use Soft to explore - you can slide to 2.0 and still get an image instead of noise. Switch to Real only when you know exactly what you're doing and want that literal multiplier.

The 28 blocks are covered by three zone sliders - low_blocks (blocks 0–8), mid_blocks (9–17), high_blocks (18–27). If three zones aren't fine enough, blocks_override takes a comma list of exactly 28 multipliers, one per block, and overrides the zones. It does not affect the named regions; those always come from their own sliders.

The 10 named regions - first, tmlp, txtmlp, tproj, txtfusion_layer0, txtfusion_layer1, txtfusion_projector, txtfusion_refiner0, txtfusion_refiner1, last - each get a slider from 0.0 to 2.0, defaulting to 1.0 (no change). These are Krea 2's architecturally distinct parts: the input/embedding weights, the timestep and text MLPs, the projection layers, and the five text/image fusion pieces. base_scale is the fallback multiplier for any weight that isn't one of the 28 blocks or those 10 regions - leave it at 1.0 unless you're doing something deliberate.

The node's honest caveat, straight from its source: the named-region descriptions "go by what the prefix names imply, not verified internals." The prefixes are real and come from core's ModelMergeKrea2; the semantics of turning txtfusion_projector up 20% are not documented anywhere by anyone. You are experimenting.

The second output is the useful one

model goes into a KSampler or a save node. info is a STRING one-liner - Krea2 Tuned | mode=... | base=... | low=... mid=... high=... | patches=N - and it's your diagnostic. Because the node computes strength = target - 1 and skips any tensor whose strength is exactly zero, a completely untouched node reports patches=0 and is a no-op that costs you nothing. If you queue a run and info says zero patches, you know your sliders aren't doing anything - usually because you left mode on Real Value with everything at 1.0, or because you've only changed a region you thought you'd changed. Wire it to a Show Text node while you tune; drop it once you're done.

Why only three zones, not SDXL-style sub-groups

The Arthemy tuner it's ported from labels SDXL's UNet with named sub-groups, because SDXL's UNet genuinely specialises by depth. Krea 2's 28 blocks are architecturally uniform, with no verified evidence they specialise the same way, so this node doesn't invent fine-grained labels for them. Three zones plus a manual override, that's it. Worth knowing before you go hunting for the "faces" slider. There isn't one.

Install

ComfyUI Manager: search ComfyUI LC Modelbuilder Nodes. Manual:

cd ComfyUI/custom_nodes
git clone https://github.com/lonecatone23/ComfyUI_LC_ModelBuilder_nodes

Restart. No requirements.txt here and nothing to pip install - this node uses comfy.lora and core's patching, nothing external. (requirements.txt being missing is expected across this pack; the only real dependency is in LC Face Variety Scorer, installed by install.py.) If the LC nodes don't appear at all, check that __init__.py sits directly inside the pack folder rather than one level deeper.

What to expect, and the trap

The effects are subtle, and that's the feature. A 10% boost to one region is not a style change; it's a nudge. If you want a visible transformation, merge models. If you want to tune out a weakness in a model you otherwise like, this is the tool.

The extreme ends are hostile. At 0.0 you're zeroing a region's weights - on first or tproj that will likely produce garbage, not a stylised image. Soft Value protects you on the high side (2.0 → ~1.13x); it doesn't protect you at zero. Move in 0.05 steps on the named regions and generate between changes.

It's a one-time cost at queue time. The node clones the model and walks the whole state_dict, holding a float32 copy of each tensor as it goes: a RAM spike and a noticeable pause when you queue on a 12B checkpoint. Not per-step overhead - the pause is at build, not sampling.

Pair it with the scorer. This is the pack's other half working as designed: run a batch through LC Face Variety Scorer, get a score and a grid of faces, nudge a region, run the batch again. It's slow, but it's the difference between tuning a model and fiddling with sliders until you feel something.