← ImageLoRA · All LoRA guides
MOSS Image LoRA training with kohya sd-scripts: setup guide
Setting up kohya sd-scripts to train a MOSS Image LoRA: support status, the settings known to work, and links to the docs. Status in kohya sd-scripts: supported (v0.12.3, Oct 26; LoRA incl. ConvRot INT8 with --compile, H2D-only block swap, truncated_logit_normal timesteps).
About kohya sd-scripts
The long-standing kohya training scripts (also used by the kohya_ss GUI); strongest for SD1.5/SDXL-era models. Sources: github.com/kohya-ss/sd-scripts
VRAM
kohya sd-scripts guide (1024px, batch 1, LoRA dim 16, AdamW, gradient checkpointing, text encoder outputs cached): ~13 GB training with bf16 DiT, ~9 GB with ConvRot INT8 DiT + text encoder, ~5-7 GB adding block swap (needs ~15 GB system RAM). v0.12.2's H2D-only block swap on an RTX 3090 (bf16, 1024px, batch 1, --blocks_to_swap 36): ~7 GB at 9.4 s/step vs 11.7 s/step with classic block swap. Caching text encoder outputs needs ~8.3 GB even in INT8, so 8 GB GPUs are not supported yet. Training the text encoder LoRA too: ~17 GB INT8, ~32 GB bf16. SimpleTuner ships 24, 32, 48, 80 and 144 GB recipes at 512px. ai-toolkit: ~15 GB at batch 2, 1024px, AdamW. kohya sd-scripts v0.12.3: --compile with --convrot_int8 runs at 3.35-3.47 s/it vs 3.95 s/it bf16 (1024px, RTX PRO 6000 at 250 W) with the INT8 VRAM savings. ai-toolkit Base config: ~10.5 GB at ~1.8 s/it on an RTX 5090
Settings that work for MOSS Image (any trainer)
- Learns fast
- Tokenizer loading bug fixed same day (Oct 16) in ai-toolkit; update before training
- SFT variant: stripe artifacts, no fix yet
- sd-scripts: fp8_base is not supported for MOSS Image; use --convrot_int8 (and --convrot_int8_text_encoder) instead
- sd-scripts: --timestep_sampling sigma --weighting_scheme logit_normal --logit_mean -1.09 --logit_std 0.95 --discrete_flow_shift 1.0 approximates pre-training; simpler alternative: --timestep_sampling shift --discrete_flow_shift 3.0. Since v0.12.3, --timestep_sampling truncated_logit_normal --logit_mean -1.09 --logit_std 0.95 --discrete_flow_shift 1.0 reproduces MOSS Image's pre-training schedule exactly and is what the MOSS docs recommend (extra args --timestep_cutoff, default 0.95, and --timestep_uniform_ratio, default 0.01)
- sd-scripts example: LR 1e-4 constant at network_alpha 1 (lower LR if you raise alpha)
- SimpleTuner recipes: rank-32 LoRA, LR 1e-4, REPA, 4,000 steps, 512px-area training; validate at 50 steps, CFG 3, 1024px
- Edit/reference LoRAs: SimpleTuner model_flavour sft-edit or base-edit with matching target and reference folders; ai-toolkit also trains Base and SFT as edit models
- Base LoRA with ai-toolkit defaults (adamw8bit, shift timesteps, rank 32) gives a good style by ~1,500 steps; Base-trained LoRAs also work on SFT
- Try a higher LoRA rank than usual for plain LoRA (smaller hidden size than Krea 2); for likeness, LoKr rank 4 works well (see the recipe above)
- Full fine-tunes on small datasets collapse after a few epochs; use LoRA unless you have a very large dataset
- ComfyUI "lora key not loaded": ai-toolkit now saves unfused q/k/v LoRA keys (Oct 17); use the Comfy-Org MOSS files to fix it
- ai-toolkit low_vram + cache_text_embeddings could OOM at startup because the text encoder stayed on the GPU; fixed in ai-toolkit on Oct 17, so update first
- Inference: an SFT LoRA at ~0.6 strength with the Base model at 30 steps, CFG 3 works well; 8-step DMD LoRAs exist for SFT and Base but can weaken LoRA effect
- Base DMD2 speed LoRA is final (update 3000, Oct 20): stock Euler, 4-8 steps, CFG 1
- Testing your LoRA's likeness: skip Kromoss and turbo/DMD speed LoRAs, use 50 steps, CFG 2 and LoRA strength ~1.5, and generate at 1.5 MP or more (2-3 MP is best)
- OpenMOSS user guide: keep the text encoder frozen when training on MOSS Image Base
- OpenMOSS user guide, captioning: an LLM prompt that returns JSON with long, medium and short captions; recommended captioners are Gemma 4, Qwen 3.5 27B or Qwen 3.5 35B-A3B with thinking mode on
- OpenMOSS user guide, Base inference: 50+ steps, CFG 3 (3-6 for short prompts), shift 5, Euler sampler
- Using the whole JSON caption output as the caption works well; ai-toolkit accepts .json caption files
- Standard LoRA recipe that trains well on Base: LoRA on attention + MLP, rank 32, alpha 32, AdamW LR 1e-4 (betas 0.9/0.95, weight decay 0.01), grad clip 1.0, cosine schedule with 100 warmup steps and min multiplier 0.1, bf16, text encoder and VAE frozen, ~1 MP (1024²) with aspect ratio kept, no min-SNR
- Low-VRAM ai-toolkit LoKr on Base: rank 4 LoKr, 8-bit quantization, low VRAM on, text encoder fully offloaded, transformer 50% offloaded
- A Krea 2 config pasted straight into MOSS Image gives poor results; start from MOSS-specific settings
- sd-scripts v0.12.2: cache several caption variants per image (for example the long, medium and short captions) and pick one at random each step; before, only the first was kept
- sd-scripts v0.12.2 H2D-only block swap: add --block_swap_h2d_only to --blocks_to_swap (needs --gradient_checkpointing; optional --block_swap_ring_size, default 2, and --use_pinned_memory_for_block_swap). MOSS Image LoRA on an RTX 3090 at 1024px, batch 1, 36 blocks swapped: 9.4 s/step instead of 11.7 (~20% faster) at ~7 GB VRAM. LoRA only, not full fine-tuning
- sd-scripts v0.12.3: per-subset timestep offsets now work with logit_normal sampling (positive = more noise)
- sd-scripts v0.12.3: --compile now works with --convrot_int8. 1024px, batch 1, grad accumulation 4 on an RTX PRO 6000 at 250 W: 5.02 s/it INT8 without compile, 3.47 s/it with compile, 3.35 s/it with the faster INT8 backward, vs 3.95 s/it bf16, keeping the INT8 VRAM savings. Extra INT8 GEMM autotune configs roughly double kernel throughput on the RTX 3090 (~4% on Blackwell forward). Also fixes compile graph breaks on Python below 3.12. Not in a release yet
- sd-scripts: if you train the text encoder LoRA, don't cache text encoder outputs; older LoRA command examples in the docs did both (fixed in v0.12.2)
- Kromoss: Apache 2.0 full fine-tune of Base that fixes Base's blurriness; drop-in for SFT files and workflows (50 steps, CFG 3), with an 8-step turbo LoRA (8 steps, CFG 1, euler/simple) and, since Oct 20, an 8-steps DMD2 LoRA (8 steps, 4 also works, CFG 1, strength 1). Still being updated (update 11000 on Oct 20). v1.0 is also on Civitai (same file as on Hugging Face). Kromoss DMD LoRA v1 that works: strength 0.4, CFG 3, 32 steps
- Kromoss int8 ConvRot single file (~5.4 GB) runs in ComfyUI on smaller GPUs; its convert_to_comfy.py turns your own MOSS Image diffusers fine-tune into a ComfyUI single file
- ai-toolkit "no module named fla" (flash-linear-attention) in Docker: fixed Oct 19, so pull the latest version and update dependencies; prompt encoding at batch size above 1 also got faster the same day
- ComfyUI v0.42.1 fixes crashes in the MOSS Image template workflow; ComfyUI master adds MOSS RoPE scaling (ScaleRope node) for higher resolutions and a MOSS color/depth control node
- RoPE scaling for high-res MOSS works best at partial strength; an experimental hi-res reference LoRA using depth/color maps reaches ~8K without duplicated subjects
- If SFT feels stiff: extract SFT as a LoRA and apply it to Base at ~0.5 strength
- SimpleTuner: LoKr training with torch.compile needs LyCORIS 4.1.3, which SimpleTuner requires since Oct 20
- Character LoRAs reach near-photoreal likeness around 3,000 steps; smaller datasets ~2,000, very large datasets ~5,000
- Train character LoRAs on Base for good results
- Ostris-style edit training gives slightly better results but is about 3x slower to train and to run
- Multi-character LoRAs blend faces in close-ups with several characters
- ai-toolkit auto-caption downloads a 30+ GB captioner that runs out of memory on a 12 GB GPU; caption your dataset separately on small cards
- DiffSynth-Studio trains MOSS Image Base and SFT since Oct 20 and publishes an 8-step SFT TurboLoRA (DiffSynth-Studio/MOSS-Image-SFT-TurboLoRA) and a 3.5-bit EntroPack quant that runs in about 4 GB (DiffSynth-Studio/MOSS-Image-EntroPack)
- Likeness on Base in ai-toolkit: LoKr rank 4, sigmoid timesteps, high-noise bias. Most runs are done by 3,000 steps on 40-100 image datasets, and they come out better without differential guidance. EMA 0.99 at 3,000 steps on 30 images also works
- Character LoRA with progressive resolution in ai-toolkit: 768px for the first ~60% of steps, then 1024px, ~5,000 steps total, LR 5e-4 with automagic3 and min_lr at half the LR, sigmoid timesteps, 100-200 dataset images for strong likeness
- automagic3 drops the learning rate fast on MOSS Image (it hits the floor around step 600). Set min_lr to 2e-5-3e-5 and weight_decay to 1e-5, or use ai-toolkit's automagic4 (Automagic V4, experimental, Oct 23): its LR controller settles at a fixed point (step_target, default 0.1), so the LR doesn't drift to the floor
- Don't exclude block 22 when training for likeness
- Style LoRAs learn fast: the style shows by step 300-900
- Base renders weak faces and bodies for small, distant people in wide shots. It works best when the subject fills the frame, so plan your dataset and test prompts that way
- ComfyUI master (Oct 22, PR #17296) loads MOSS Image edit LoRAs: feed the reference images through the stock ReferenceLatent node and set reference_latents_method to match how the LoRA was trained: index_timestep_zero (default, ai-toolkit edit training with kv_cache), index_timestep_zero_joint (ai-toolkit with kv_cache: false), index_timestep_zero_frame0 (chinoll/Moss-Image-Edit) or index (references at the image's timestep). The experimental Text Encode MOSS-Image Edit node also passes references to the vision tower as in ai-toolkit training. References are cached once per run (826 to 457 ms/step at 1024px with a 1 MP reference) and work alongside the color/depth control node
- Moss-Image-Edit (chinoll): an instruction-edit LoRA for MOSS Image Base or SFT (colors, outfits, lighting, seasons, style), up to 4 reference images, with single- and multi-reference ComfyUI workflows
- ComfyUI-Moss-Image-Edit-Native runs chinoll's Moss-Image-Edit and akhaliq's MOSS-Image-Edit-HQ (armV3, weights/armV3/armV3.safetensors) on ComfyUI's native MOSS-Image (v0.42+). Use the converted chinoll file from PedroMarinhoDev/Moss-Image-Edit-ComfyUI. Defaults from 300+ test edits: LoRA strength 1.0 (lower redraws the scene instead of editing), CFG 5 for chinoll and 3 for HQ, skip layer guidance on layer 22, 30 steps euler/simple, empty negative, references and output in the same ~1 MP bucket, and SFT rather than Base (both LoRAs were trained on SFT). chinoll keeps faces closest; HQ is best at text but overpaints fine structures
- ComfyUI master (Oct 25, PR #17338) lowers peak MOSS memory a bit
- ai-toolkit MOSS Image Base config: ~10.5 GB VRAM at ~1.8 s/it on an RTX 5090
- Likeness comes out best with 100-200 dataset images
- MOSS is very dataset-sensitive: settings that work on one dataset often don't carry over to another, so test on yours
- Plain natural-language captions work for MOSS Image
- ComfyUI master (Oct 23, PR #17320): Text Encode MOSS-Image Edit has image_strength (0 ignores references, 1 unchanged, above 1 emphasizes them). Each reference adds ~150 vision tokens, which used to outweigh the prompt; lower it if the prompt gets ignored
- ai-toolkit (Oct 23, commit 7861f92): MOSS VAE decode is no longer forced to no_grad; update if you train through the VAE decode
- MOSS-Image-Alpha-LoRA (paralaif, proof of concept): text-to-image with a real alpha channel for MOSS SFT. End the prompt with ', isolated on a transparent background' and decode with the RGBA VAE from trmz/flux2-klein-alpha. Trained on 39 images in ~40 minutes on a 16 GB GPU
- Kaloscope style adapters (heathcliff01): separate style conditioning by artist name, weighted blends or a reference image for MOSS Image Base and Krea 2 Raw/Turbo; needs its own ComfyUI nodes
- In the ComfyUI MOSS Image template, raise CFG from 2.5 to 3-4 before judging a LoRA; at 2.5 a good LoRA can look broken
- Pose and action LoRAs: the high LR that suits character LoRAs makes them rigid and copies the dataset people; use a lower LR, or train one LoRA per pose
- Large datasets need only about 1 epoch: ~950 images at gradient accumulation 4 (~250 steps) trains well, and 2 epochs overtrains
- RTX 5090 at 512+768 buckets: batch 4 fits and trains better than batch 6, which hits the VRAM limit; with the transformer in nvfp4, a batch-4 run uses about 18 GB
- If automagic drives the LR too low, start from a higher LR or switch to Prodigy
- Validation images are expensive with the text encoder fully offloaded: 20 of them slow a run from 5 s/it to 30 s/it, so keep validation prompts few
- MOSS-Image-heal (KBlueLeaf): full finetune of OpenMOSS-Team/MOSS-Image-Base with a healed residual stream (largest stream value 3,083 vs base 58,411; stream RMS 7.5x lower; every weight within 64x its tensor RMS vs 349 base outliers). Probe metrics: flow loss 0.4289 vs 0.4280, velocity cosine 0.9983. Transformer only; text encoder, tokenizer, VAE and scheduler from official Base. Apache-2.0. ComfyUI: moss_image_heal_bf16/fp16/int8_convrot.safetensors
- KohakuMossTrainer trains MOSS-Image Base/SFT adapters with every LyCORIS algorithm plus full finetune, on Windows and Linux, from 6 GB cards to multi-GPU; a style LoRA at rank 8 on an RTX 4090 with aggressive offload uses about 12-13 GB at ~0.85 images/s (v0.1.0, Oct 18)
General tips
- Gated Hugging Face models: click 'Agree and access' on each model page, or you'll get 403 errors
- Steps scale with dataset size (steps = epochs x images at batch 1)
- A safe start: LoKr with auto rank (~64), batch/grad accumulation 4
- Leave out of your captions whatever you want burned into the LoRA; caption what should stay changeable
- ai-toolkit dataset folder weights let you train the same images with long, medium and short captions in separate folders
- ai-toolkit supports validation loss, which shows when a run stops improving
- In ai-toolkit, Cache text embeddings works for basically every model and frees the text encoder from VRAM and RAM
- Prefer int8 convrot over qfloat8 quantization in ai-toolkit: better quality at the same memory
- Gradient accumulation and batch size don't scale the learning rate in ai-toolkit; a bigger batch needs about 1.5-2.5x the steps
Compare with other trainers
Where to rent a 16 GB+ GPU
Cheapest 16 GB+ cards (2026-10-20 08:06 UTC) from RunPod and Vast.ai. Prices move constantly; see the live price table.
| GPU | VRAM | RunPod community $/hr | Vast.ai cheapest $/hr |
|---|
| Tesla V100 | 16 GB | $0.19 | $0.08 |
| RTX 3090 | 24 GB | $0.22 | $0.12 |
| RTX 5060 Ti | 16 GB | — | $0.14 |
| Tesla V100S | 32 GB | — | $0.14 |
| RTX A5000 | 24 GB | $0.16 | — |
| RTX A4000 | 16 GB | $0.17 | — |
Sources
FAQ
Does kohya sd-scripts support MOSS Image?
Yes: supported (v0.12.3, Oct 26; LoRA incl. ConvRot INT8 with --compile, H2D-only block swap, truncated_logit_normal timesteps) (see sources below).
How much VRAM do I need for a MOSS Image LoRA?
kohya sd-scripts guide (1024px, batch 1, LoRA dim 16, AdamW, gradient checkpointing, text encoder outputs cached): ~13 GB training with bf16 DiT, ~9 GB with ConvRot INT8 DiT + text encoder, ~5-7 GB adding block swap (needs ~15 GB system RAM). v0.12.2's H2D-only block swap on an RTX 3090 (bf16, 1024px, batch 1, --blocks_to_swap 36): ~7 GB at 9.4 s/step vs 11.7 s/step with classic block swap. Caching text encoder outputs needs ~8.3 GB even in INT8, so 8 GB GPUs are not supported yet. Training the text encoder LoRA too: ~17 GB INT8, ~32 GB bf16. SimpleTuner ships 24, 32, 48, 80 and 144 GB recipes at 512px. ai-toolkit: ~15 GB at batch 2, 1024px, AdamW. kohya sd-scripts v0.12.3: --compile with --convrot_int8 runs at 3.35-3.47 s/it vs 3.95 s/it bf16 (1024px, RTX PRO 6000 at 250 W) with the INT8 VRAM savings. ai-toolkit Base config: ~10.5 GB at ~1.8 s/it on an RTX 5090
Weekly newsletter: new models, trainer releases, cheapest GPUs.
Subscribe
Data updated 2026-10-20. Disclosure: RunPod and Vast.ai links are referral links; ImageLoRA may earn a commission at no cost to you. unknown = no data yet. · Raw data (JSON) · llms.txt