LoRA para MOSS-Image: Fizgig, AI Toolkit, KohakuMossTrainer y sd-scripts

Para tu primer LoRA de MOSS-Image, empieza con Base y congela Qwen3.5-9B. De menor a mayor trabajo de configuración, el orden es Fizgig, AI Toolkit, KohakuMossTrainer y sd-scripts. Fizgig guía mediante pantallas y ajustes predefinidos; AI Toolkit ofrece una interfaz de trabajos con campos configurables; KohakuMossTrainer genera configuraciones Python, pero requiere comandos para las cachés y el entrenamiento; sd-scripts exige gestionar dependencias, TOML y comandos directamente. El orden describe la complejidad del flujo, no una clasificación de calidad de imagen.

Las cuatro herramientas tienen ejemplos públicos de entrenamiento MOSS-Image. Exportar un archivo no garantiza buena semejanza. La evaluación debe continuar en ComfyUI con poses, fondos y prompts nuevos. Tampoco basta con que el bucle ocupe menos de 8 GB: hay que contar caché de texto y vistas previas.

Elegir por flujo y evidencia

Comprobado el 3 de noviembre de 2026. Análisis documental de código y guías oficiales, registros públicos y fichas de modelos. AirMore no entrenó estos adaptadores ni midió las GPU. Adapta rutas y parámetros piloto; validar sintaxis no demuestra calidad. IA asistió investigación, redacción y localización. La portada es una ilustración editorial.

Preparar imágenes, textos y modelos

Empieza con un conjunto piloto variado. Para identidad, combina ángulos, distancias y expresiones; para estilo, cambia los sujetos para no asociar el estilo a una sola cara. Reserva imágenes y prompts de evaluación y utiliza material autorizado.

Empareja 001.png con 001.txt en UTF-8. Describe contenido visible, composición y detalles variables; transcribe exactamente el texto de la imagen. OpenMOSS recomienda prosa detallada. Su JSON long/medium/short sirve para generar captions, no para pegarlo sin adaptar en cualquier entrenador. Este texto es ilustrativo, no un resultado entrenado:

mossbird, a small teal ceramic bird in a three-quarter view on a wooden table. Its beak points left. Soft daylight enters from the right, with a plain cream wall behind it.

El ejemplo inglés es un punto de partida común; no ordena traducir letras españolas, chinas o japonesas visibles. Revisa las alucinaciones del captioner y mantén coherente el disparador. Describir siempre los mismos rasgos, ropa y fondo puede crear asociaciones no deseadas.

Comfy-Org distribuye MOSS-Image en diffusion_models, text_encoders y vae. Los ejemplos CLI usan moss_image_base_int8_convrot.safetensors, qwen3.5_9b_int8_convrot.safetensors y VAE FLUX.2. Kohaku usa flux2-vae_small.safetensors; el ejemplo sd-scripts usa flux2-vae.safetensors. Mantén entornos Python separados de ComfyUI.

Archivos MOSS-Image de Comfy-Org

Fizgig: interfaz y comparación de épocas

Fizgig — Guía oficial

Fizgig 9.x combina una aplicación de entrenamiento con selección visual de épocas. MOSS sigue siendo experimental: entrena Base y normalmente previsualiza en SFT. Fast, Standard y Style son recetas diferentes. Comparar contra Base sin igualar ajustes puede parecer un fallo del entrenamiento.

Hay experiencias mixtas: el autor mostró mejoras con Clean-end share en sus datos, otros usuarios tuvieron resultados pobres y uno describió un ensayo satisfactorio de tres imágenes. No son un porcentaje universal de semejanza ni un mínimo de tres imágenes.

Entrenamiento publicado: u/shootthesound · r/StableDiffusion

1. Instalar y obtener modelos

Clona la revisión. Windows: install_fizgig.bat y Launch Fizgig.bat o Launch Fizgig in browser.bat. Linux: python install_fizgig.py y ./launch_fizgig.sh. Elige MOSS-Image en Training y Preferences → Download models for me. Prevé disco y preferiblemente 32 GB RAM.

git clone https://github.com/shootthesound/Fizgig.git
cd Fizgig
git checkout 11ce867242b3cba3f8d72cf4dab6810de8eee14a

2. Preparar por pestañas

Start elige carpeta, Image Prep recorta/redimensiona, Captions edita textos y Samples fija prompts. Incluye una pose o escena ausente de los datos para detectar memorización. Revisa captions automáticos.

3. Elegir preset

Fast: rank 16, LR 1e-4, 70 épocas, 0,25 MP. Standard: rank 32, LR 1e-4, 70 épocas, 1 MP. Style: rank 16, LR 5e-5, 50 épocas, 1 MP. No significa necesitar todas las épocas. Slider y ajuste completo no son LoRA convencional.

4. Registrar planificación y preview

Conserva inicialmente el preset actual de Clean-end share. Los posts antiguos pasaron por 60 y 30; hoy la guía usa Slide. No mezcles versiones. Desactiva Turbo mientras estableces la referencia visual.

5. Entrenar, comparar y exportar

Start Training inicia el trabajo. En Runs & outputs o LoRA Royale compara épocas con semillas/prompts fijos. La salida se configura en Training; por defecto output_loras. Valida el .safetensors elegido en ComfyUI. ArcFace/DINOv2 ayudan a seleccionar, sin ser porcentajes calibrados de identidad.

AI Toolkit: trabajos y YAML

AI Toolkit — Guía oficial

AI Toolkit admite Base y SFT como arquitecturas distintas, con UI y configuraciones. Para LoRA convencional de texto a imagen elige moss_image:base y OpenMOSS-Team/MOSS-Image-Base. Las variantes de edición son otra tarea. Mantén train_text_encoder: false.

かみもと publicó una ejecución Windows 11/RTX 4070 12 GB, RAM 48 GB, 30 imágenes anime, buckets 1024 y 2.000 pasos: rank/alpha 16/16, LR 1e-4, AdamW8bit, ConvRot8 en ambos componentes, descarga del transformer 50% y encoder 100%, cachés y sin previews. Su entrenamiento de fotos reales usó A100; ese tiempo no pertenece a la 4070.

Entrenamiento publicado: かみもと · u/FitEgg603

1. Abrir la interfaz

Clona el proyecto y ejecuta run_windows.bat o run_linux.sh. El Manager integrado sigue siendo experimental y prepara el entorno para localhost:8675; también admite la CLI mostrada. El lanzador puede actualizar el código: registra la revisión final y exporta la configuración.

git clone https://github.com/ostris/ai-toolkit.git
cd ai-toolkit

python3 -m manager install
python3 -m manager doctor
python3 -m manager launch

2. Crear datos y trabajo

Selecciona la carpeta con captions, un nombre nuevo y MOSS-Image Base. Verifica moss_image:base. Empieza con LoRA normal, rank/alpha 16/16, convrot8 en modelo/encoder, cálculo bf16 y encoder congelado.

3. Aplicar la receta de memoria

Lote 1, acumulación 1, buckets 1024, LR 1e-4, AdamW8bit, checkpointing y cachés de texto/latentes. Descarga encoder 1.0 y transformer 0.5. Desactiva previews al principio. Es un punto de partida publicado, no garantía universal de 12 GB.

4. Guardar y ejecutar YAML

Guarda el ejemplo completo como config/moss_subject.yaml y sustituye la carpeta. Revisa retención de checkpoints. Primero crea una copia con otro nombre y steps: 1; después ejecuta la configuración principal en el entorno correcto. También puedes completar esos campos en la UI y exportar su YAML.

job: extension
config:
  name: moss_subject
  process:
    - type: diffusion_trainer
      training_folder: output
      device: cuda
      trigger_word: mossbird
      network:
        type: lora
        linear: 16
        linear_alpha: 16
      save:
        dtype: bf16
        save_every: 250
        max_step_saves_to_keep: 8
        save_format: diffusers
        push_to_hub: false
      datasets:
        - folder_path: /absolute/path/to/moss-data
          caption_ext: txt
          resolution: [1024]
          cache_latents_to_disk: true
          num_repeats: 1
      train:
        batch_size: 1
        steps: 2000
        gradient_accumulation: 1
        train_unet: true
        train_text_encoder: false
        gradient_checkpointing: true
        noise_scheduler: flowmatch
        optimizer: adamw8bit
        lr: 0.0001
        timestep_type: shift
        dtype: bf16
        cache_text_embeddings: true
        disable_sampling: true
      model:
        name_or_path: OpenMOSS-Team/MOSS-Image-Base
        arch: moss_image:base
        quantize: true
        qtype: convrot8
        quantize_te: true
        qtype_te: convrot8
        low_vram: true
        layer_offloading: true
        layer_offloading_text_encoder_percent: 1.0
        layer_offloading_transformer_percent: 0.5
      sample:
        sampler: flowmatch
        sample_every: 250
        width: 1024
        height: 1024
        samples:
          - prompt: mossbird, a teal ceramic bird on a windowsill
        seed: 42
        guidance_scale: 3
        sample_steps: 30

python run.py config/moss_subject.yaml

5. Comparar checkpoints

El ejemplo guarda cada 250 actualizaciones y retiene ocho. Revisa la carpeta del trabajo. Otro informe LoKr usó factor distinto, 6.600 pasos y guidance adicional; su “90% de semejanza” es estimación visual, no un resultado objetivo transferible a LoRA normal.

KohakuMossTrainer: configurar, entrenar y exportar

KohakuMossTrainer — Guía oficial

KohakuMossTrainer es un framework independiente, no un nodo de ComfyUI. Combina perfiles de GPU, fuentes de datos y algoritmos LyCORIS en configuraciones Python verificadas. OpenMOSS lo incluye entre sus proyectos relacionados; admite Base/SFT y exportación con claves ComfyUI. LoRA, LoKr y ajuste completo son modos diferentes.

yoru publicó un ensayo de estilo de 13 imágenes y 50 pasos, con registros y exportaciones ComfyUI/LyCORIS. Necesitó mucha fuerza para notar el efecto: demuestra entrenamiento y exportación, no que 50 pasos completen un estilo. Su GUI privada no está disponible para descargar.

Entrenamiento publicado: yoru

1. Instalar por separado

Clona la revisión comprobada. Windows necesita las herramientas C++ indicadas; el instalador detecta GPU/controlador. Ejecuta el comando Windows mostrado o bash scripts/install/install.sh en Linux. Activa .venv\Scripts\activate.bat desde cmd, o source .venv/bin/activate en Linux; no necesitas cambiar la política global de scripts.

git clone https://github.com/KohakuBlueleaf/KohakuMossTrainer.git
cd KohakuMossTrainer
git checkout b06ac60e54321955c24e818add5d32b2fad23ed6

Windows

powershell -ExecutionPolicy Bypass -File scripts\install\install.ps1

Linux

bash scripts/install/install.sh

2. Revisar y descargar

Ejecuta kohakumoss-doctor y resuelve los componentes ausentes. La descarga de una línea conserva las carpetas; también puedes reutilizar modelos ComfyUI compatibles. Cuenta espacio para pesos y cachés, además del adaptador.

hf download Comfy-Org/MOSS-Image diffusion_models/moss_image_base_int8_convrot.safetensors text_encoders/qwen3.5_9b_int8_convrot.safetensors vae/flux2-vae_small.safetensors --local-dir ComfyUI/models

3. Crear el plan

Sustituye la ruta absoluta. –source folder_nl selecciona imágenes con captions naturales. Inspecciona el plan antes de crear cachés de texto y latentes. Ejecuta desde la raíz del repositorio con el entorno activo.

kohakumoss-doctor
kohakumoss-config new train --weights ComfyUI/models --data /absolute/path/to/moss-data --source folder_nl --name moss_subject
kogine run scripts/data/inspect_data.py --config configs/user/moss_subject_data.py
kogine run scripts/data/cache_text.py --config configs/user/moss_subject_data.py
kogine run scripts/data/cache_latents.py --config configs/user/moss_subject_data.py

4. Definir un piloto

Conserva las capas use_config generadas y modifica los valores indicados en configs/user/moss_subject.py. No son óptimos universales. Revisa muestras y tokens por lote: una actualización empaquetada no equivale necesariamente a una imagen. Reduce el área antes de cachear si captions largos superan el presupuesto.

STEPS = 1200
DIM = 16
ALPHA = 16.0
LR = 0.0001
SAVE_EVERY = 200
SAMPLE_EVERY = 0

5. Probar antes de entrenar

La prueba de 100 pasos usa otro nombre. Comprueba valores no finitos y exportación real; no mide semejanza. Después inicia el trabajo previsto. El primer ajuste de kernels puede tardar. RESUME=latest recupera estado; INIT_FROM parte de pesos con optimizador y planificación nuevos.

kogine run scripts/train/moss.py --config configs/user/moss_subject.py --set RUN_NAME=moss_smoke --set STEPS=100 --set SAMPLE_EVERY=0

kogine run scripts/train/moss.py --config configs/user/moss_subject.py

6. Elegir la exportación

Busca runs/moss/moss_subject/export/ y las exportaciones de checkpoints. Usa -comfy.safetensors en ComfyUI; un archivo LyCORIS o un transformer fusionado no es lo mismo. Guarda config.json, registros y revisión del modelo.

sd-scripts: control mediante TOML

sd-scripts — Guía oficial

sd-scripts incluye moss_image_train_network.py y una guía bilingüe. La revisión comprobada incorpora v0.12.3, con truncated_logit_normal y mejoras INT8/compile. No significa que cualquier GUI kohya_ss antigua tenga esos controles.

エマノン documentó estilo con 500 imágenes generadas y también accesorios indeseados al restringir FFN. La ficha descargable FFF_MOSS-Alba-style identifica sd-scripts, Base, encoder congelado y dim 16/alpha 1. Son flujos reales, no prueba de una selección de capas universalmente mejor.

Entrenamiento publicado: エマノン · FFF_MOSS-Alba-style

1. Preparar Python y PyTorch

Clona la revisión y crea venv. Actívalo con venv\Scripts\activate.bat en cmd o source venv/bin/activate en Linux. Instala primero PyTorch CUDA apropiado: el ejemplo torch 2.6/CUDA 12.4 del README no es para RTX 50. Instala requisitos, comprueba CUDA y configura Accelerate para una GPU local y bf16.

git clone https://github.com/kohya-ss/sd-scripts.git
cd sd-scripts
git checkout cb70b96858477e716a2096292ab8aab433277f38
python -m venv venv

python -m pip install --upgrade -r requirements.txt
python -c "import torch; print(torch.__version__, torch.cuda.is_available())"
accelerate config

2. Crear dataset.toml

Sustituye image_dir por ruta absoluta, también C:/… en Windows. Se usan lote 1, 1024, captions sin barajar y repetición 1; dimensiones de bucket múltiplos de 16. No añadas transformaciones aleatorias incompatibles con cachés.

[general]
caption_extension = ".txt"
shuffle_caption = false
enable_multiline_caption = true

[[datasets]]
resolution = 1024
batch_size = 1
enable_bucket = true
bucket_reso_steps = 64

  [[datasets.subsets]]
  image_dir = "/absolute/path/to/moss-data"
  num_repeats = 1

3. Crear train_moss.toml

Selecciona los dos archivos ConvRot INT8 prequantizados y el VAE FLUX.2. Se detectan automáticamente, sin flags de cuantización extra. Entrena solo DiT. Rank 16/alpha 1 mantiene la escala del ejemplo oficial: pasar alpha a 16 cambia el experimento.

pretrained_model_name_or_path = "/absolute/path/to/moss_image_base_int8_convrot.safetensors"
text_encoder = "/absolute/path/to/qwen3.5_9b_int8_convrot.safetensors"
vae = "/absolute/path/to/flux2-vae.safetensors"
dataset_config = "dataset.toml"
output_dir = "/absolute/path/to/moss-output"
output_name = "moss_subject"
save_model_as = "safetensors"
save_precision = "bf16"
network_module = "networks.lora_generic"
network_dim = 16
network_alpha = 1
network_train_unet_only = true
learning_rate = 0.0001
optimizer_type = "AdamW"
lr_scheduler = "constant"
timestep_sampling = "truncated_logit_normal"
logit_mean = -1.09
logit_std = 0.95
discrete_flow_shift = 1.0
max_train_epochs = 10
save_every_n_epochs = 1
gradient_accumulation_steps = 1
mixed_precision = "bf16"
gradient_checkpointing = true
cache_latents = true
cache_latents_to_disk = true
cache_text_encoder_outputs = true
cache_text_encoder_outputs_to_disk = true
blocks_to_swap = 20
max_data_loader_n_workers = 2
persistent_data_loader_workers = true
seed = 42

4. Ejecutar y revisar

Lanza el comando Accelerate de una línea. Con 30 imágenes, repetición/lote/acumulación 1 y una GPU, diez épocas son unas 300 actualizaciones: es piloto, no garantía de acabado. Cachés y checkpoints ocupan ubicaciones diferentes.

accelerate launch --num_cpu_threads_per_process 1 moss_image_train_network.py --config_file train_moss.toml

5. Ajustar memoria por separado

El ejemplo intercambia 20 bloques; 36 reduce VRAM con coste de transferencia. H2D-only requiere checkpointing. No combines block swap con unsloth/CPU offload checkpointing. Esta ruta no admite FP8 base ni encoder W4A8 GPTQ. Pocos workers persistentes ayudan en Windows.

VRAM y RAM durante todo el proceso

No son un ranking: cambian experimentos y métricas. Deben caber calentamiento, caché, entrenamiento y preview. Tamaño de archivo no es VRAM residente. En Kohaku el presupuesto incluye imagen y texto; captions muy largos pueden reducir tokens de imagen conservados en perfiles pequeños.

Código gratuito no significa GPU alquilada, almacenamiento o captioning API gratuitos. Si necesitas privacidad, conserva los datos localmente; nube y servicios de captions implican otras transferencias.

Cargar y evaluar en ComfyUI

1. Actualiza ComfyUI y abre su flujo MOSS-Image nativo. Genera primero sin el adaptador nuevo con modelo, Qwen3.5-9B y VAE FLUX.2 correctos. Así separas fallos de carga de resultados de entrenamiento.
2. Copia el .safetensors de formato ComfyUI a ComfyUI/models/loras y actualiza la lista. Para LoRA solo DiT con base bf16, inserta LoraLoaderModelOnly en la ruta MODEL del cargador de difusión hacia el sampler; no cambies la rama de texto.
3. Para SFT INT8, Fizgig recomienda LoraLoaderBypassModelOnly, que aplica el adaptador junto a los pesos cuantizados. Es experimental y su nombre incluye “for debugging”. Si falta, revisa actualización/registro; fusionar pesos cuantizados no es la misma operación.
4. Mantén semilla, prompt, tamaño, base, VAE, encoder y sampler iguales. Prueba fuerza 0, 0,5 y 1,0, varios checkpoints y prompts reservados. Son puntos de evaluación, no óptimos garantizados. Escribir <lora:…> en un prompt no sustituye el nodo.
5. Para igualar Fizgig: SFT, res_multistep/simple, 30 pasos, CFG 4, shift 5 y SkipLayerGuidanceDiTSimple capa 22, inicio 0/fin 0,5. Base tiene otro punto oficial: Euler, al menos 50 pasos, CFG 3 y shift 5. No cambies de receta silenciosamente al comparar épocas.
6. Desactiva adaptadores de aceleración/destilación para la primera comparación. Después prueba por separado el compatible con Base o SFT. LoRA de identidad y DMD de velocidad tienen funciones y planificaciones diferentes.

mossbird, a teal ceramic bird on a rainy windowsill, side view, soft watercolor illustration

Corregir errores antes de aumentar pasos

OOM antes del primer paso

Identifica si ocurre al cachear texto/latentes, calentar kernels, entrenar o previsualizar. Reducir resolución no siempre resuelve la carga del encoder. Desactiva previews o ajusta presupuesto y descarga compatibles; no mezcles flags de otros entrenadores.

Claves no cargadas o sin efecto

Comprueba arquitectura, formato y ComfyUI reciente. Estado de recuperación, LyCORIS, -comfy y modelo fusionado son archivos distintos. Revisa fuerza y conexiones antes de reentrenar.

Se parece en el entrenador pero no en ComfyUI

Iguala Base/SFT, cuantización, VAE, SLG, CFG, planificación y adaptadores exclusivos del preview. La pérdida no detecta esta discrepancia. Evalúa poses nuevas, no solo retratos conocidos.

La pérdida fluctúa o más pasos empeoran

La difusión muestrea niveles de ruido distintos; no necesita una curva suave. Guarda checkpoints y juzga identidad/estilo, obediencia al prompt y memorización. Cambia un grupo de parámetros cada vez; más texto, rango o pasos no son soluciones automáticas.

Qué herramienta elegir primero

Elige Fizgig para empezar con pantallas, ajustes predefinidos y comparación visual de épocas. AI Toolkit encaja con trabajos UI/YAML reutilizables; KohakuMossTrainer, con configuraciones y cachés específicas de MOSS; sd-scripts, con control directo por CLI/TOML. Tu experiencia previa puede cambiar cuál resulta más sencillo. Haz una prueba corta y evalúa el adaptador exportado antes de dedicar miles de actualizaciones.

KohakuMoss License 1.0 exige “Kohaku” en nombres de software/productos/servicios derivados y exime modelos, adaptadores e imágenes entrenados. AI Toolkit usa MIT; Fizgig Apache-2.0; sd-scripts principalmente Apache-2.0 con componentes bajo otros términos. Derechos de modelos y datos son independientes; no es una autorización comercial general.

Análisis del modelo MOSS-Image · Guía general de entrenamiento LoRA