Wan 2.2 High Noise vs Low Noise LoRA Workflow

A common piece of community advice claims Wan 2.2 requires two independent pipelines — one for the high-noise expert and one for the low-noise expert — each with its own ModelSamplingSD3 and KSampler. The official ComfyUI workflow chains the two experts sequentially through a single latent flow.

TL;DR

• Sequential, not parallel. The high-noise KSampler feeds its partially denoised latent directly into the low-noise KSampler — one shared latent flow, not two independent pipelines.
• Use LoraLoaderModelOnly. It applies LoRA only to the diffusion model, leaving the shared T5 text encoder untouched. The standard LoraLoader modifies both the diffusion model and the CLIP/T5 encoder.
• Two ModelSamplingSD3 nodes required. Each expert is a separate model object loaded by its own UNETLoader; both need independent shift=8.0 patches.

Why Wan 2.2 Uses Two Expert Models

Wan 2.2's 14B variant uses a Mixture-of-Experts architecture separating denoising across two specialized models ^[1]. The high-noise expert handles early-stage denoising (timesteps ~875–1000) for layout, composition, and motion. The low-noise expert handles late-stage denoising (timesteps ~0–875) for texture, facial detail, and color fidelity ^[1]. Both experts contain ~14B parameters each (27B total), but only 14B are active per step as the model switches experts based on SNR ^[1].

The SNR threshold determines the transition point ^[1]. The official ComfyUI workflow implements this via two KSamplerAdvanced nodes in sequence: the first runs steps 0–10, its output latent becomes input for the second running steps 10–20 ^[3]. The low-noise stage requires the partially denoised latent from the high-noise stage.

For more on diffusion scheduling, see Wan 2.1 training fundamentals.

The Critical Correction: Sequential, Not Parallel

Several community sources describe Wan 2.2 as requiring "two parallel pipelines" — one high-noise chain and one low-noise chain, each with its own ModelSamplingSD3 and KSampler ^[4]. The official ComfyUI 14B T2V workflow JSON reveals a sequential structure: two UNETLoader nodes (one per expert), each with its own ModelSamplingSD3, then two KSamplerAdvanced nodes in series. The high-noise sampler (steps 0–10) outputs a LATENT that links directly to the low-noise sampler (steps 10–20) as input ^[3]. There is a single shared latent flow.

Running the low-noise expert from pure noise produces incoherent output because it expects a partially structured latent. Running only the high-noise expert stops at step 10, leaving visible noise ^[5]. Both stages are necessary and must be chained in order.

The complete pipeline for a Wan 2.2 14B workflow with LoRAs looks like this:

1. UNETLoader (high noise) → loads wan2.2_t2v_high_noise_14B_fp8_scaled.safetensors
2. LoraLoaderModelOnly → chain as many LoRA nodes as needed, each taking the previous MODEL output
3. ModelSamplingSD3 → patches the high-noise model with shift=8.0 ^[8]
4. KSamplerAdvanced (high noise) → start_step=0, end_step=10, return_with_leftover_noise=enable
5. KSamplerAdvanced (low noise) → start_step=10, end_step=20, return_with_leftover_noise=disable (receives latent from step 4)
6. UNETLoader (low noise) → loads wan2.2_t2v_low_noise_14B_fp8_scaled.safetensors
7. LoraLoaderModelOnly → same LoRA chain applied to low-noise base
8. ModelSamplingSD3 → patches the low-noise model with shift=8.0 ^[8]

For ComfyUI node fundamentals, see ComfyUI pipelines basics.

Both ModelSamplingSD3 nodes use shift=8.0 in the official workflow ^[3]. Do not merge the two ModelSamplingSD3 nodes into one — they operate on separate model objects loaded by separate UNETLoader nodes.

Why LoraLoaderModelOnly, Not LoraLoader

Wan 2.2 uses a single T5 text encoder (umt5_xxl) shared across both experts, and standard LoRA training targets only the diffusion transformer ^[6]. The standard LoraLoader node returns both a modified model and a modified CLIP — its source calls comfy.sd.load_lora_for_models(model, clip, lora, strength_model, strength_clip) and returns (model_lora, clip_lora) ^[7]. Because Wan 2.2 LoRAs contain no CLIP weights, applying them to the shared encoder is unnecessary and can change encoder behavior.

LoraLoaderModelOnly applies the patch only to the MODEL — its source passes None for clip and 0 for strength_clip ^[7]. It returns a single MODEL output that feeds the next node in the chain, and the node description notes that "multiple LoRA nodes can be linked together" ^[7].

The strength_model parameter controls how strongly the LoRA weights modify the model.

Training parameters

The musubi-tuner Wan 2.2 workflow uses --network_dim 16 --network_alpha 16 with --learning_rate 3e-4 and a polynomial LR scheduler (power=8) ^[6]. All hyperparameters — optimizer (adamw, weight_decay=0.1), mixed precision (fp16), gradient checkpointing, and --fp8_base — are shared across both expert training runs ^[6].

Required Models and File Names

The official ComfyUI resources list these files for the 14B variants ^[2][3]:

Place all diffusion models in ComfyUI/models/diffusion_models/, the VAE in ComfyUI/models/vae/, and the text encoder in ComfyUI/models/text_encoders/ ^[2].

The 5B model variant (wan2.2_ti2v_5B_fp16.safetensors) uses a different VAE (wan2.2_vae.safetensors) and a single model file — no high/low noise split ^[2]. The workflow described here applies only to the 14B models.

Common Errors and Fixes

Training LoRAs for Both Experts

Training must be done separately for each expert. The musubi-tuner training commands differ only in the --dit model file path and the --min_timestep / --max_timestep values ^[6]. High-noise training uses --min_timestep 875 --max_timestep 1000; low-noise training uses --min_timestep 0 --max_timestep 875 ^[6]. All other hyperparameters — learning rate (3e-4), network dimension (16), network alpha (16), optimizer (adamw with weight_decay=0.1), LR scheduler (polynomial, power=8), and mixed precision (fp16) — are identical ^[6]. At inference, both trained LoRAs must be loaded: one on the high-noise expert chain, one on the low-noise expert chain.

If this is your first LoRA, start with training a LoRA from scratch and come back for the two-expert specifics.

FAQ

Why does Wan 2.2 have two model files for 14B? Wan 2.2 uses a Mixture-of-Experts architecture where two separate 14B models handle different phases of denoising. The high-noise expert manages early-stage structure and motion; the low-noise expert handles late-stage detail refinement. ^[1]

How do I connect high-noise and low-noise models in ComfyUI? The high-noise KSamplerAdvanced output feeds its LATENT directly into the low-noise KSamplerAdvanced input. Do not create two independent pipelines that each generate from noise. ^[3]

Do I need two separate KSamplers for Wan 2.2? Yes, connected in sequence. The high-noise KSamplerAdvanced processes steps 0–10 and passes its output to the low-noise KSamplerAdvanced, which processes steps 10–20. ^[3]

What is the timestep boundary between high-noise and low-noise experts? The boundary depends on the SNR of the current denoising step, defined by the SNR minimum threshold. The official workflow handles this via KSamplerAdvanced step ranges, not manual model switching. ^[1]

Why use LoraLoaderModelOnly instead of LoraLoader for Wan 2.2? LoraLoaderModelOnly applies LoRA weights only to the diffusion model, leaving the shared text encoder untouched. LoraLoader modifies both the diffusion model and the CLIP/T5 encoder, which is unintended for Wan 2.2 LoRAs trained only against the DiT. ^[7]

What shift value should I use in ModelSamplingSD3 for Wan 2.2? The official 14B T2V workflow uses a shift value of 8.0 in both ModelSamplingSD3 nodes. The parameter accepts values between 0.0 and 100.0. ^[8]

Do I train one LoRA or two LoRAs for Wan 2.2 14B? You train two separate LoRAs, one on the high-noise base model and one on the low-noise base model, using the same dataset and identical hyperparameters. At inference, both LoRAs are loaded, one on each expert chain. ^[6]

Sources