How to Train a Wan 2.2 LoRA With musubi-tuner (High and Low Noise, 16 GB and 24 GB)

Training your own Wan 2.2 LoRA lets you teach the video model a character, an art style, a product or a type of motion, then use it in ComfyUI like any other LoRA.

The most popular free tool for this is musubi-tuner by kohya-ss, the same developer behind Kohya’s sd-scripts. It supports Wan 2.2’s 14B text-to-video and image-to-video models, including its unusual two-model (high noise and low noise) design.

This step-by-step guide shows how to train a Wan 2.2 LoRA locally with musubi-tuner in November 2026: hardware you need, exact model files and folders, installing musubi-tuner on Windows or Linux, preparing an image or video dataset, the dataset TOML, caching, the full training command for high and low noise, settings for 16 GB and 24 GB GPUs, using the LoRA in ComfyUI, and fixes for common errors.

How Wan 2.2 LoRA Training Works

Wan 2.2’s 14B models are split into two diffusion models (DiTs):

Model	Handles	What a LoRA on it changes most
High noise	The early, very noisy steps	Overall layout, composition and motion
Low noise	The later, cleaner steps	Fine detail, faces, textures and style

During generation the sampler switches from the high-noise model to the low-noise model at a set point (the “timestep boundary”). musubi-tuner lets you train a LoRA for one model at a time, or for both together. Its docs give these recommended timestep ranges when training one model:

Model	Min timestep	Max timestep
I2V low noise	0	900
I2V high noise	900	1000
T2V low noise	0	875
T2V high noise	875	1000

The default boundary when training both together is 0.9 for I2V and 0.875 for T2V, matching the tables above.

What You Need (Hardware and Files)

• NVIDIA GPU: 24 GB VRAM is the comfortable target. musubi-tuner says it can train with 720×1280 images on 24 GB using fp8. 16 GB works with block swapping and smaller resolutions, but slower.
• System RAM: 64 GB recommended. If you train both DiTs at once with --offload_inactive_dit on Windows, the docs say about 96 GB or more is needed.
• Disk: 100 GB+ free for the fp16 models, caches and outputs.
• Software: Python 3.10 or newer (tested with 3.10 and 3.12), Git, and a recent NVIDIA driver.
• Dataset: 15-50 good images or short clips of your subject or style, with captions.

If you trained image LoRAs before, our Kohya_ss LoRA training guide covers the general ideas (repeats, epochs, learning rate) that apply here too.

Step 1: Install musubi-tuner

1. Open a terminal in the folder where you keep AI tools and clone the repo:

   git clone https://github.com/kohya-ss/musubi-tuner
   cd musubi-tuner

2. Create and activate a virtual environment:

   # Windows
   python -m venv venv
   venv\Scripts\activate
   
   # Linux / macOS
   python3 -m venv venv
   source venv/bin/activate

3. Install PyTorch 2.6 or newer that matches your CUDA. The README’s example uses CUDA 12.4:

   pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124

   RTX 50-series cards need a newer CUDA build (12.8 or later), so pick the matching index URL from pytorch.org.

4. Install musubi-tuner and the optional extras:

   pip install -e .
   pip install ascii-magic matplotlib tensorboard prompt-toolkit

5. Configure Accelerate:

   accelerate config

   Answer: This machine, No distributed training, CPU only NO, torch dynamo NO, DeepSpeed NO, GPU ids all, mixed precision bf16.

Optional: SageAttention speeds up inference only, not training. Our SageAttention on Windows guide covers installing it.

Step 2: Download the Model Files

File	What it is	Where to get it
wan2.2_t2v_high_noise_14B_fp16.safetensors + wan2.2_t2v_low_noise_14B_fp16.safetensors (T2V) or wan2.2_i2v_high_noise_14B_fp16.safetensors + wan2.2_i2v_low_noise_14B_fp16.safetensors (I2V)	The two Wan 2.2 DiTs	Comfy-Org/Wan_2.2_ComfyUI_Repackaged on Hugging Face, folder split_files/diffusion_models
Wan2.1_VAE.pth or wan_2.1_vae.safetensors	VAE (14B models use the Wan 2.1 VAE)	Wan-AI/Wan2.1-I2V-14B-720P, or Comfy-Org Wan 2.1 repackaged split_files/vae
models_t5_umt5-xxl-enc-bf16.pth	T5 text encoder for training	Wan-AI/Wan2.1-I2V-14B-720P

Important rules from the musubi-tuner docs:

• Use fp16 (or bf16) DiTs. fp8_scaled models, like the ones many ComfyUI workflows use, are not supported for training.
• Do not use wan2.2_vae.safetensors. That VAE is for the 5B model and is not compatible with 14B.
• No CLIP model is needed for Wan 2.2.

Already use Wan 2.2 in ComfyUI? You may have the VAE in ComfyUI/models/vae/. You can point musubi-tuner at it directly. See our Wan 2.2 ComfyUI guide for the inference side.

Step 3: Prepare Your Dataset

Images or videos?

• Images: best for characters, faces, objects and art styles. Faster to train and cache.
• Short videos: needed if you want to teach a specific motion or camera move.
• You can mix both by adding two datasets in the TOML.

Folder layout

dataset/
  images/
    img001.png
    img001.txt
    img002.png
    img002.txt
  videos/
    clip001.mp4
    clip001.txt
  cache_images/
  cache_videos/

Each image or clip needs a caption file with the same name and a .txt extension.

Caption tips

• Describe the scene in plain sentences, like a prompt you would type later.
• Use a unique trigger word for your subject, for example “zqx woman in a red jacket walking along a beach at sunset”.
• Describe what changes between images (pose, background, lighting) so the LoRA learns the subject, not the background.
• Only use images you have the rights to. Do not train on real people without their consent.

Video clip tips

• Keep clips short: 2-5 seconds of the motion you care about.
• Wan works at 16 fps. If your clips are 30 fps, set source_fps = 30.0 so frames are skipped to match.
• Frame counts must follow N×4+1 (1, 5, 9 … 25, 45, 81). Other values are rounded down.

Step 4: Write the Dataset TOML

Save this as dataset.toml and edit the paths:

[general]
resolution = [960, 544]
caption_extension = ".txt"
batch_size = 1
enable_bucket = true
bucket_no_upscale = false

[[datasets]]
image_directory = "C:/train/dataset/images"
cache_directory = "C:/train/dataset/cache_images"
num_repeats = 1

[[datasets]]
video_directory = "C:/train/dataset/videos"
cache_directory = "C:/train/dataset/cache_videos"
target_frames = [1, 25, 45]
frame_extraction = "head"
source_fps = 30.0

• resolution is width, height. Start at 960×544 or lower on 16 GB.
• num_repeats repeats a dataset, useful to balance a small image set against videos.
• target_frames and frame_extraction = "head" take the first 1, 25 and 45 frames of each clip.
• Always give each dataset its own cache_directory.
• Remove the video block if you are training on images only.

Step 5: Cache Latents and Text Encoder Outputs

1. Cache latents (encodes your images and clips with the VAE):

   python src/musubi_tuner/wan_cache_latents.py --dataset_config dataset.toml --vae path/to/wan_2.1_vae.safetensors

   For an I2V LoRA, add --i2v. Low on VRAM? Add --vae_cache_cpu.

2. Cache text encoder outputs (encodes your captions with T5):

   python src/musubi_tuner/wan_cache_text_encoder_outputs.py --dataset_config dataset.toml --t5 path/to/models_t5_umt5-xxl-enc-bf16.pth --batch_size 16

   Under about 16 GB VRAM, add --fp8_t5 and lower --batch_size.

3. Check that the cache folders now contain files. Re-run these steps whenever you change images, captions or resolution.

Step 6: Train the LoRA (High and Low Noise)

Option A: Train one model at a time (recommended)

This is gentler on RAM and lets you check each half. Here is a T2V low-noise run (enter as one line, or use ^ on Windows / \ on Linux for line breaks):

accelerate launch --num_cpu_threads_per_process 1 --mixed_precision bf16 src/musubi_tuner/wan_train_network.py \
  --task t2v-A14B \
  --dit path/to/wan2.2_t2v_low_noise_14B_fp16.safetensors \
  --dataset_config dataset.toml --sdpa --mixed_precision bf16 --fp8_base \
  --min_timestep 0 --max_timestep 875 --preserve_distribution_shape \
  --optimizer_type adamw8bit --learning_rate 2e-4 --gradient_checkpointing \
  --max_data_loader_n_workers 2 --persistent_data_loader_workers \
  --network_module networks.lora_wan --network_dim 32 \
  --timestep_sampling shift --discrete_flow_shift 3.0 \
  --max_train_epochs 16 --save_every_n_epochs 1 --seed 42 \
  --output_dir output --output_name mylora_low

For the high-noise LoRA, swap --dit to the high-noise file, set --min_timestep 875 --max_timestep 1000, and change --output_name to mylora_high. For I2V, use --task i2v-A14B, the I2V files and the 900 boundary instead of 875.

Option B: Train both models in one run

  --task t2v-A14B \
  --dit path/to/wan2.2_t2v_low_noise_14B_fp16.safetensors \
  --dit_high_noise path/to/wan2.2_t2v_high_noise_14B_fp16.safetensors \
  --timestep_boundary 0.875 \
  --offload_inactive_dit

Keep the rest of the command the same, minus the min/max timestep flags. --offload_inactive_dit moves the idle model to system RAM. It only works without --blocks_to_swap, and on Windows needs about 96 GB RAM. With less RAM, use --blocks_to_swap instead.

What the key settings mean

Flag	What it does	Starting value
--network_module networks.lora_wan	Required for Wan LoRAs	Always set
--network_dim	LoRA rank (size and capacity)	16-32 for characters, 32-64 for styles
--learning_rate	How fast it learns	2e-4 (docs example); lower to 1e-4 if it overfits
--fp8_base	Runs the base model in fp8 to save VRAM	On for 16-24 GB
--discrete_flow_shift	Noise schedule shift	3.0 in the docs example; official inference uses 12.0 (T2V) and 5.0 (I2V) for reference
--max_train_epochs / --save_every_n_epochs	Training length and checkpoints	16 / 1, then test several checkpoints
--force_v2_1_time_embedding	Smaller time embedding to save VRAM	Try it if you are short on memory

musubi-tuner notes that the right timestep_sampling and discrete_flow_shift values need experimentation, and many options are not fully verified. Treat these as starting points.

Optional: sample videos during training

--vae path/to/wan_2.1_vae.safetensors --t5 path/to/models_t5_umt5-xxl-enc-bf16.pth \
--sample_prompts prompts.txt --sample_every_n_epochs 1 --sample_at_first

Put one prompt per line in prompts.txt. Samples slow training but show you when the LoRA starts working or overfitting.

Settings for 16 GB, 24 GB and 32 GB GPUs

GPU	Suggested setup
16 GB (RTX 4060 Ti 16 GB, 5060 Ti, 5070 Ti, 5080)	One model at a time, --fp8_base, --gradient_checkpointing, --blocks_to_swap (start around 20 and raise if you hit OOM), resolution 640×368 to 832×480, images or very short clips, --fp8_t5 when caching
24 GB (RTX 3090, 4090)	--fp8_base, 960×544 or 720p images, short clips, fewer or no swapped blocks
32 GB+ (RTX 5090, workstation cards)	720p images and longer clips; with 96 GB+ RAM, try training both models together

Running out of memory? See our CUDA out of memory fix guide, and lower resolution or frame count before anything else.

Step 7: Use Your LoRA in ComfyUI

1. Copy mylora_high.safetensors and mylora_low.safetensors from output/ to ComfyUI/models/loras/.
2. Open your Wan 2.2 workflow. It has two model loaders, one for high noise and one for low noise.
3. Add a LoraLoaderModelOnly node after each model loader: the high-noise LoRA on the high-noise model and the low-noise LoRA on the low-noise model.
4. Start with strength 1.0, then try 0.7-1.2.
5. Put your trigger word in the prompt and generate.
6. If you only trained the low-noise LoRA, load it on the low-noise branch only. It will still change detail and style.

musubi-tuner says its Wan LoRAs appear to be compatible with ComfyUI, though it may depend on the nodes used. More on loaders in our how to use LoRA in ComfyUI guide.

Tips for Better Results

• Quality beats quantity. 20 sharp, varied images beat 200 blurry ones.
• Test several epochs. Save every epoch and compare. Later is not always better.
• Watch for overfitting: if every output copies a training image’s background or pose, use an earlier checkpoint or lower the learning rate.
• Character LoRAs: the low-noise LoRA does most of the work on faces and detail. Many people train it first and add the high-noise LoRA later if motion or layout needs help.
• Motion LoRAs: use video clips and give the high-noise model enough training, since it shapes movement.
• Keep captions consistent in style, and always include your trigger word.
• Monitor with TensorBoard: add --logging_dir logs and run tensorboard --logdir logs.

Troubleshooting

Problem	Cause	Fix
CUDA out of memory	Resolution, frames or model too big for VRAM	Lower resolution/frames, add --blocks_to_swap, use --fp8_base, train one model at a time
Error loading DiT weights	Using an fp8_scaled model	Download the fp16 DiTs
Shape mismatch on VAE	Using wan2.2_vae (5B VAE)	Use Wan2.1_VAE.pth or wan_2.1_vae.safetensors
System freezes or RAM full on Windows	--offload_inactive_dit uses shared VRAM	Use --blocks_to_swap instead, or train models separately
Hangs while caching HEVC videos	Old av package bug	Re-run pip install -e . to update av, or convert clips to H.264
“No module named musubi_tuner”	venv not active or not installed	Activate venv, run pip install -e . in the repo folder
Frame count changed	Not an N×4+1 value	Use 1, 5, 9 … 45, 81 in target_frames
LoRA has no effect in ComfyUI	Loaded on the wrong model or trigger word missing	High LoRA on high model, low on low; include trigger word; raise strength
Outputs look burned or copy training images	Overfitting	Use an earlier epoch, lower learning rate or rank, add variety to the dataset

My Take

For a first Wan 2.2 LoRA, train a low-noise image LoRA of a simple character or style at 960×544 with the docs’ example settings, save every epoch, and test in ComfyUI. Once that works, add a high-noise LoRA or video clips for motion.

On a 16 GB card it is slow but doable; on 24 GB it is genuinely practical.

musubi-tuner moves fast, so pull the latest version before each project and read its Wan docs for new flags.

FAQ

Can I train a Wan 2.2 LoRA on 16 GB VRAM?

Yes, with --fp8_base, --blocks_to_swap, gradient checkpointing, lower resolution and one model at a time. It is slower than on 24 GB.

Do I need to train both high-noise and low-noise LoRAs?

Not always. A low-noise LoRA alone often handles characters and style. Train the high-noise LoRA for motion or composition.

Can I train the Wan 2.2 5B model with musubi-tuner?

musubi-tuner’s Wan 2.2 support is for the 14B models only (t2v-A14B and i2v-A14B).

Can I use fp8_scaled Wan models for training?

No. Use fp16 or bf16 DiTs. fp8_scaled models are not supported, even with --fp8_scaled.

How many images do I need?

Around 15-50 good, varied images is a common starting point for a character or style.

Do Wan 2.1 LoRAs work on Wan 2.2?

Some partially work on the low-noise model, but results vary. Training directly on Wan 2.2 gives the best results.

Is musubi-tuner free?

Yes, it is open source on GitHub.

Sources

• kohya-ss/musubi-tuner README (install, requirements)
• musubi-tuner docs: Wan 2.1/2.2 training
• musubi-tuner docs: Dataset config
• ComfyUI docs: Wan 2.2 (model file names and folders)