Entrenamiento de Textual Inversion 2025: Embeddings vs LoRA

La Textual Inversion (TI) enseña nuevos conceptos a Stable Diffusion aprendiendo únicamente los embeddings de tokens dentro de un codificador de texto congelado. A diferencia del LoRA o el ajuste completo, la TI nunca toca los pesos del modelo: simplemente añade una nueva "palabra" al tokenizador y optimiza su representación vectorial. El resultado es un archivo diminuto .safetensors (normalmente de 10–50 KB) que se copia en la carpeta embeddings y se invoca en los prompts por su nombre de archivo.

Cómo difiere el entrenamiento LoRA de la TI — los dos métodos se complementan para distintos casos de uso.

TL;DR

• Usa embeddings para: sujetos, estilos u objetos únicos donde importa más el tamaño del archivo y la portabilidad entre modelos
• Usa LoRAs para: personajes complejos, composiciones multicombo o cuando necesitas mayor fidelidad
• Entrena sobre modelos base SD 1.5 o SDXL originales — los embeddings entrenados en ajustes rara vez transfieren bien
• Kohya_ss soporta TI solo para SD 1.x/2.x y SDXL — no existe soporte de TI para FLUX ni SD3

Cuándo un Embedding Supera a un LoRA

Escenario | Por qué gana la TI | Source ----------|-------------------|-------- Portabilidad entre modelos | Una TI entrenada en un modelo base original funciona en la mayoría de los ajustes | A1111 wiki VRAM limitada | Solo se actualizan los embeddings de tokens; la U-Net y la VAE permanecen congeladas | Kohya_ss docs Iteración rápida | 1.000–2.000 pasos típicos para la TI | Kohya_ss docs Transferencia de estilo | --use_style_template aísla la estética sin sesgo de sujeto | Kohya_ss docs

Los embeddings destacan cuando necesitas un token de concepto portable que funcione entre modelos derivados de la misma base. Los LoRAs siguen ganando para escenas multisujeto y control preciso de poses.

Cómo Funciona la Textual Inversion

La TI añade un token de marcador de posición especial al tokenizador (ej. <mychar>), expande la matriz de embeddings en una fila y luego congela todo el modelo — U-Net, VAE y codificador de texto — mientras optimiza únicamente esa fila nueva. Durante el entrenamiento, cada imagen se empareja con una plantilla de prompt que contiene el marcador. El gradiente fluye a través del codificador de texto congelado hacia el nuevo vector de embedding, empujándolo hasta que el modelo reconstruye las imágenes de entrenamiento cuando se invoca en el prompt.

El mecanismo es específico del modelo por diseño. La dimensión del embedding, el vocabulario del tokenizador y la arquitectura del codificador de texto son fijos por familia de modelos. SD 1.5 usa un codificador CLIP-L de 768 dimensiones; SDXL usa codificadores duales CLIP-L/CLIP-G; FLUX y SD3 usan arquitecturas transformer completamente distintas. Por eso un embedding TI entrenado en SD 1.5 no puede cargarse en SDXL o FLUX — el espacio de IDs de token y las dimensiones del embedding no coinciden.

Entrenamiento en Kohya_ss (SD 1.5 / SDXL)

Requisitos previos

• Repositorio Kohya_ss sd-scripts clonado y entorno configurado
• Dataset preparado (15–25 imágenes cuadradas a 512×512 para SD 1.5, 1024×1024 para SDXL)
• Checkpoint del modelo base original (no un ajuste)

Parámetros principales

Parámetro | Valor recomendado | Notas ----------|-------------------|------- --pretrained_model_name_or_path | ruta a v1-5-pruned-emaonly.safetensors o base SDXL | Debe ser un modelo base original --token_string | cadena única como mychar123 | No debe existir en el tokenizador --init_word | palabra de concepto como woman o cat | Se permiten múltiples palabras (ej. anime girl) --num_vectors_per_token | 1 (por defecto) o 4–5 para sujetos complejos | Más vectores = más tokens de prompt consumidos --learning_rate | 1e-6 (docs de Kohya) o 2e-6 (por defecto del código) o 0.005 (paper) | Ver nota sobre la tasa de aprendizaje --lr_scheduler | constant | --optimizer_type | AdamW8bit (preferido) o AdamW | AdamW8bit + bf16 puede dar error en Linux --mixed_precision | bf16 (RTX 30/40) o fp16 | --max_train_steps | 1000–2000 | Guardar checkpoints cada 200 pasos --cache_latents | habilitado | Reduce significativamente la VRAM --use_object_template | habilitado (para sujetos) | Ignora los archivos de caption --use_style_template | habilitado (para estilos) | Ignora los archivos de caption

Discrepancia en la tasa de aprendizaje

Tres valores circulan en la comunidad: Los tres valores provienen del paper original de Gal et al. 2022, de la documentación de Kohya_ss y de guías comunitarias como la de Malcolm Rey:

• 0.005 — usado en el paper original de Gal et al. 2022 con Adam original en fp32, 3–5 imágenes
• 1e-6 — recomendación de la documentación de Kohya_ss para AdamW8bit, fp16/bf16, datasets más grandes
• 2e-6 — valor por defecto del código Kohya_ss (--learning_rate por defecto en library/args.py)

Todos producen embeddings funcionales. El valor 0.005 reproduce el setup del paper; 1e-6/2e-6 consideran el optimizador, la precisión y los tamaños de dataset típicos de Kohya_ss. Comienza en 1e-6, aumenta solo si la convergencia se estanca.

Comando de ejemplo (SD 1.5)

accelerate launch --num_cpu_threads_per_process 2 train_textual_inversion.py \
  --pretrained_model_name_or_path="models/Stable-diffusion/v1-5-pruned-emaonly.safetensors" \
  --train_data_dir="data/mychar" \
  --output_dir="output/mychar" \
  --output_name="mychar-ti" \
  --save_model_as=safetensors \
  --token_string="mychar123" \
  --init_word="woman" \
  --num_vectors_per_token=5 \
  --learning_rate=1e-6 \
  --lr_scheduler="constant" \
  --optimizer_type="AdamW8bit" \
  --mixed_precision="bf16" \
  --cache_latents \
  --use_object_template \
  --vae="models/VAE/vae-ft-mse-840000-ema-pruned.safetensors" \
  --max_train_steps=1000 \
  --save_every_n_steps=200

Para SDXL, usa sdxl_train_textual_inversion.py con --resolution=1024,1024 y el checkpoint base SDXL. Para SDXL, usa sdxl_train_textual_inversion.py con --resolution=1024,1024 y el checkpoint base SDXL. El tutorial de Desi_Cafe en Civitai recorre el flujo completo paso a paso para SD 1.5.

Tutorial paso a paso de Textual Inversion — si prefieres seguir un ejemplo con capturas en vez de leer la referencia.

Tutorial paso a paso de entrenamiento LoRA — si decides que LoRA encaja mejor con tu caso de uso.

Entrenamiento en A1111 WebUI

1. Abre la pestaña Textual Inversion
2. Crear embedding: asígnale nombre, define el texto de inicialización (ej. woman), elige vectores por token (1–16)
3. Preprocesar: apunta a las imágenes fuente, activa "Crear copias volteadas" para aumento de datos
4. Entrenar: selecciona el embedding, define la tasa de aprendizaje (por defecto 0.005), pasos máximos (1.000–5.000), directorio de logs
5. Plantilla: usa subject.txt para objetos/personas, style.txt para estéticas
6. Iniciar entrenamiento — monitorea la pérdida y las imágenes de vista previa

A1111 soporta programación de la tasa de aprendizaje mediante sintaxis de prompt: 0.005:100, 1e-3:1000, 1e-5 reduce la LR en los pasos especificados.

Usando el Embedding Entrenado

1. Copia el archivo .safetensors a stable-diffusion-webui/embeddings/
2. No hace falta reiniciar — el embedding se carga inmediatamente
3. En los prompts, usa el nombre de archivo (sin extensión) como token: photo of mychar-ti
4. Pondera como cualquier token: (mychar-ti:1.2) aumenta la influencia

Guía de embeddings negativos y ponderación de tokens — combina tu embedding entrenado con una ponderación adecuada para mejores resultados.

Errores comunes y soluciones

Síntoma | Causa | Solución --------|-------|--------- Loss: nan | Tasa de aprendizaje demasiado alta | Reducir a 1e-6 o menos; usar scheduler constante Token string already exists in tokenizer | El marcador colisiona con el vocabulario | Añadir números/caracteres especiales: mychar123, <mychar> CUDA setup error con AdamW8bit + bf16 | Incompatibilidad con la plataforma Linux | Cambiar a AdamW + bf16 o AdamW8bit + fp16 El embedding funciona solo en el modelo de entrenamiento | La TI es específica del modelo por diseño | Entrenar en un modelo base original para mejor portabilidad Sin mejora después de 500+ pasos | El token falta en los captions/plantillas | Asegurar que --use_object_template está habilitado o que el token aparece en los captions Artefactos de sobreentrenamiento a partir de 1.300 pasos | Demasiados pasos para el tamaño del dataset | Detener en 800–1.000 pasos; usar un checkpoint anterior

FAQ

¿Cuándo debería usar un embedding en lugar de un LoRA?

Usa embeddings cuando importa el tamaño del archivo (compartir, móvil), necesitas portabilidad entre modelos o estás entrenando un sujeto/estilo único con VRAM limitada. Los LoRAs manejan mejor las escenas multicombo y mayor fidelidad.

¿Qué tasa de aprendizaje es mejor para textual inversion?

Comienza en 1e-6 con Kohya_ss (AdamW8bit, fp16/bf16). Usa 0.005 solo si reproduces el setup del paper original (Adam original, fp32, 3–5 imágenes). Ambos convergen; 1e-6 es más seguro para datasets más grandes.

¿Puedo usar embeddings entre diferentes modelos de Stable Diffusion?

Solo dentro de la misma familia de arquitectura. Un embedding SD 1.5 funciona en la mayoría de los ajustes SD 1.5 pero no en SDXL, SD3 ni FLUX. Cada familia de modelos necesita su propio entrenamiento TI.

¿Cuántas imágenes de entrenamiento necesito para textual inversion?

El paper original mostró que 3–5 imágenes son suficientes. La práctica comunitaria usa 15–25 para mayor robustez. Más imágenes requieren proporcionalmente más pasos.

¿Funciona textual inversion con SDXL o FLUX?

SDXL: sí, mediante sdxl_train_textual_inversion.py. FLUX y SD3: no — sus arquitecturas transformer carecen de implementaciones de TI en Kohya_ss o diffusers. SDXL: sí, mediante sdxl_train_textual_inversion.py. FLUX y SD3: no — sus arquitecturas transformer carecen de implementaciones de TI en Kohya_ss ni en la librería diffusers de HuggingFace.

¿Por qué mi embedding no funciona en otros modelos?

La TI se vincula al tokenizador y codificador de texto de un modelo específico. Los ajustes que modifican el codificador de texto (ej. CLIP skip, modelos fusionados) rompen la compatibilidad. Entrena en el modelo base original para máxima portabilidad.

¿Qué hace --num_vectors_per_token?

Cada vector consume un token del límite de 77 tokens del prompt. El valor por defecto es 1. Los valores 4–5 capturan sujetos complejos mejor pero reducen el espacio del prompt. El paper encontró que un único vector suele ser suficiente.

Resumen de soporte por modelo

Familia de modelo | Soporte TI | Script ------------------|------------|------- SD 1.x / 2.x | Sí | train_textual_inversion.py SDXL | Sí | sdxl_train_textual_inversion.py SD 3 / 3.5 | No | Solo LoRA FLUX.1 | No | Solo LoRA HunyuanImage | No | Solo LoRA Anima | No | Solo LoRA

Para SD3, FLUX y arquitecturas más recientes, LoRA sigue siendo la única opción de personalización en Kohya_ss.