Entrenamiento Kohya

Entrena LoRA y DreamBooth para Stable Diffusion con Kohya en Clore.ai

Entrena LoRA, Dreambooth y ajustes finos completos para Stable Diffusion usando el entrenador de Kohya.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis pedidos

• Interfaces web: Usa la URL del puerto HTTP

• SSH: ssh -p <port> root@<proxy-address>

¿Qué es Kohya?

Kohya_ss es un conjunto de herramientas de entrenamiento para:

• LoRA - Adaptadores ligeros (los más populares)

• Dreambooth - Entrenamiento de sujeto/estilo

• Ajuste fino completo - Entrenamiento completo del modelo

• LyCORIS - Variantes avanzadas de LoRA

Requisitos

Tipo de entrenamiento	VRAM mínima	Recomendado
LoRA SD 1.5	6GB	RTX 3060
LoRA SDXL	12GB	RTX 3090
Dreambooth SD 1.5	12GB	RTX 3090
Dreambooth SDXL	24GB	RTX 4090

Despliegue rápido

Imagen de Docker:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Puertos:

22/tcp
7860/http

Comando:

apt-get update && apt-get install -y git libgl1 libglib2.0-0 && \
cd /workspace && \\
git clone https://github.com/bmaltais/kohya_ss.git && \
cd kohya_ss && \
pip install -r requirements.txt && \\
pip install xformers && \
python kohya_gui.py --listen 0.0.0.0 --server_port 7860

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis pedidos:

1. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

Uso de la interfaz web

1. Acceda en http://<proxy>:<port>

2. Seleccione el tipo de entrenamiento (LoRA, Dreambooth, etc.)

3. Configure los ajustes

4. Inicie el entrenamiento

Preparación del conjunto de datos

Estructura de carpetas

/workspace/dataset/
├── 10_mysubject/           # Repeticiones_nombre_del_concepto
│   ├── image1.png
│   ├── image1.txt          # Archivo de subtítulo
│   ├── image2.png
│   └── image2.txt
└── 10_regularization/      # Imágenes de regularización opcionales
    ├── reg1.png
    └── reg1.txt

Requisitos de las imágenes

• Resolución: 512x512 (SD 1.5) o 1024x1024 (SDXL)

• Formato: PNG o JPG

• Cantidad: 10-50 imágenes para LoRA

• Calidad: Claras, bien iluminadas, con ángulos variados

Archivos de subtítulos

Crear .txt archivo con el mismo nombre que la imagen:

myimage.txt:

una foto de la persona sks, retrato profesional, iluminación de estudio, alta calidad

Subtitulado automático

Use BLIP para subtítulos automáticos:

from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image
import os

processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base").to("cuda")

for img_file in os.listdir("./images"):
    if img_file.endswith(('.png', '.jpg')):
        image = Image.open(f"./images/{img_file}")
        inputs = processor(image, return_tensors="pt").to("cuda")
        output = model.generate(**inputs, max_new_tokens=50)
        caption = processor.decode(output[0], skip_special_tokens=True)

        txt_file = img_file.rsplit('.', 1)[0] + '.txt'
        with open(f"./images/{txt_file}", 'w') as f:
            f.write(caption)

Entrenamiento de LoRA (SD 1.5)

Configuración

En la interfaz de Kohya:

Ajuste	Valor
Modelo	runwayml/stable-diffusion-v1-5
Rango de red	32-128
Alfa de red	16-64
Tasa de aprendizaje	1e-4
Tamaño de lote	1-4
Épocas	10-20
Optimizador	AdamW8bit

Entrenamiento por línea de comandos

accelerate launch --num_cpu_threads_per_process=2 train_network.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --train_data_dir="/workspace/dataset" \
    --output_dir="/workspace/output" \
    --output_name="my_lora" \
    --resolution=512 \
    --train_batch_size=1 \
    --max_train_epochs=10 \
    --learning_rate=1e-4 \
    --network_module=networks.lora \
    --network_dim=32 \
    --network_alpha=16 \
    --mixed_precision=fp16 \
    --save_precision=fp16 \
    --optimizer_type=AdamW8bit \
    --lr_scheduler=cosine \
    --cache_latents \
    --xformers \
    --save_every_n_epochs=2

Entrenamiento de LoRA (SDXL)

accelerate launch train_network.py \
    --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
    --train_data_dir="/workspace/dataset" \
    --output_dir="/workspace/output" \
    --output_name="my_sdxl_lora" \
    --resolution=1024 \
    --train_batch_size=1 \
    --max_train_epochs=10 \
    --learning_rate=1e-4 \
    --network_module=networks.lora \
    --network_dim=32 \
    --network_alpha=16 \
    --mixed_precision=bf16 \
    --save_precision=fp16 \
    --optimizer_type=Adafactor \
    --cache_latents \
    --xformers \
    --save_every_n_epochs=2

Entrenamiento Dreambooth

Entrenamiento de sujeto

accelerate launch train_dreambooth.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --instance_data_dir="/workspace/dataset/instance" \
    --class_data_dir="/workspace/dataset/class" \
    --output_dir="/workspace/output" \
    --instance_prompt="una foto de la persona sks" \
    --class_prompt="una foto de una persona" \
    --with_prior_preservation \
    --prior_loss_weight=1.0 \
    --num_class_images=200 \
    --resolution=512 \
    --train_batch_size=1 \
    --learning_rate=2e-6 \
    --max_train_steps=1000 \
    --mixed_precision=fp16 \
    --gradient_checkpointing

Entrenamiento de estilo

accelerate launch train_dreambooth.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --instance_data_dir="/workspace/dataset/style" \
    --output_dir="/workspace/output" \
    --instance_prompt="pintura al estilo de xyz" \
    --resolution=512 \
    --train_batch_size=1 \
    --learning_rate=5e-6 \
    --max_train_steps=2000 \
    --mixed_precision=fp16

Consejos de entrenamiento

Ajustes óptimos

Parámetro	Persona/Personaje	Estilo	Objeto
Rango de red	64-128	32-64	32
Alfa de red	32-64	16-32	16
Tasa de aprendizaje	1e-4	5e-5	1e-4
Épocas	15-25	10-15	10-15

Evitar el sobreajuste

• Use imágenes de regularización

• Tasa de aprendizaje más baja

• Menos épocas

• Aumentar el alfa de red

Evitar el infraajuste

• Más imágenes de entrenamiento

• Tasa de aprendizaje más alta

• Más épocas

• Alfa de red más bajo

Monitoreo del entrenamiento

TensorBoard

tensorboard --logdir /workspace/output/logs --port 6006 --bind_all

Métricas clave

• pérdida - Debería disminuir y luego estabilizarse

• lr - Programación de la tasa de aprendizaje

• época - Progreso del entrenamiento

Probando tu LoRA

Con Automatic1111

Copiar LoRA a:

stable-diffusion-webui/models/Lora/my_lora.safetensors

Usar en el prompt:

<lora:my_lora:0.8> una foto de la persona sks

Con ComfyUI

Cargue el nodo LoRA y conéctelo al modelo.

Con Diffusers

from diffusers import StableDiffusionPipeline
import torch

pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_lora_weights("/workspace/output/my_lora.safetensors")

image = pipe("una foto de la persona sks, retrato profesional").images[0]

Entrenamiento avanzado

LyCORIS (LoHa, LoKR)

accelerate launch train_network.py \
    --network_module=lycoris.kohya \
    --network_args "algo=loha" "conv_dim=4" "conv_alpha=2" \
    ...

Inversión textual

accelerate launch train_textual_inversion.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --train_data_dir="/workspace/dataset" \
    --learnable_property="estilo" \
    --placeholder_token="<my-style>" \
    --initializer_token="art" \
    --resolution=512 \
    --train_batch_size=1 \
    --max_train_steps=3000 \
    --learning_rate=5e-4

Guardar y exportar

Descargar el modelo entrenado

scp -P <port> root@<proxy>:/workspace/output/my_lora.safetensors ./

Convertir formatos

# SafeTensors a PyTorch
from safetensors.torch import load_file, save_file
import torch

state_dict = load_file("model.safetensors")
torch.save(state_dict, "model.pt")

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Los precios varían según el proveedor y la demanda. Consulta Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Entrenamiento LoRA de FLUX

Entrena adaptadores LoRA para FLUX.1-dev y FLUX.1-schnell: la última generación de modelos de transformadores de difusión con calidad superior.

Requisitos de VRAM

Modelo	VRAM mínima	GPU recomendada
FLUX.1-schnell	16GB	RTX 4080 / 3090
FLUX.1-dev	24GB	RTX 4090
FLUX.1-dev (bf16)	40 GB+	A100 40GB

Nota: FLUX usa la arquitectura DiT (Transformador de difusión) — la dinámica de entrenamiento difiere significativamente de SD 1.5 / SDXL.

Instalación para FLUX

Instale PyTorch con soporte para CUDA 12.8:

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install xformers --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt
pip install accelerate sentencepiece protobuf

Configuración LoRA de FLUX (flux_lora.toml)

[general]
shuffle_caption = false
caption_extension = ".txt"
keep_tokens = 1

[datasets]
[[datasets.subsets]]
image_dir = "/workspace/dataset/train"
caption_extension = ".txt"
num_repeats = 5
resolution = [512, 512]

[training]
pretrained_model_name_or_path = "black-forest-labs/FLUX.1-dev"
output_dir = "/workspace/output"
output_name = "my_flux_lora"

# Específico de FLUX: use bf16 (NO fp16 — FLUX requiere bf16)
mixed_precision = "bf16"
save_precision = "bf16"
full_bf16 = true

train_batch_size = 1
max_train_epochs = 20
gradient_checkpointing = true
gradient_accumulation_steps = 4

# Parámetros LoRA de FLUX — ¡tasa de aprendizaje más baja que SDXL!
learning_rate = 1e-4
lr_scheduler = "cosine_with_restarts"
lr_warmup_steps = 100

# Configuración de la red
network_module = "networks.lora_flux"
network_dim = 16           # FLUX: una dimensión más pequeña funciona bien (16-64)
network_alpha = 16         # Establézcalo igual a network_dim

# Opciones específicas de FLUX
t5xxl_max_token_length = 512
apply_t5_attn_mask = true

# Optimizador — Adafactor funciona bien para FLUX
optimizer_type = "adafactor"
optimizer_args = ["scale_parameter=False", "relative_step=False", "warmup_init=False"]

# Ahorro de memoria
cache_latents = true
cache_latents_to_disk = true
cache_text_encoder_outputs = true
cache_text_encoder_outputs_to_disk = true

# Muestreo durante el entrenamiento (vista previa opcional)
sample_every_n_epochs = 5
sample_prompts = "/workspace/sample_prompts.txt"

Comando de entrenamiento LoRA de FLUX

# GPU única
accelerate launch train_network.py \
    --config_file flux_lora.toml \
    --network_module networks.lora_flux \
    --network_dim 16 \
    --network_alpha 16 \
    --mixed_precision bf16 \
    --full_bf16

# Con parámetros explícitos (sin toml)
accelerate launch train_network.py \
    --pretrained_model_name_or_path "black-forest-labs/FLUX.1-dev" \
    --train_data_dir "/workspace/dataset" \
    --output_dir "/workspace/output" \
    --output_name "my_flux_lora" \
    --network_module networks.lora_flux \
    --network_dim 16 \
    --network_alpha 16 \
    --learning_rate 1e-4 \
    --max_train_epochs 20 \
    --train_batch_size 1 \
    --gradient_accumulation_steps 4 \
    --mixed_precision bf16 \
    --full_bf16 \
    --optimizer_type adafactor \
    --cache_latents \
    --cache_text_encoder_outputs \
    --t5xxl_max_token_length 512 \
    --apply_t5_attn_mask \
    --save_every_n_epochs 5

FLUX frente a SDXL: diferencias clave

Parámetro	SDXL	FLUX.1
Tasa de aprendizaje	1e-3 a 1e-4	1e-4 a 5e-5
Precisión	fp16 o bf16	bf16 OBLIGATORIO
Módulo de red	networks.lora	networks.lora_flux
Dimensión de red	32–128	8–64 (más pequeño)
Optimizador	AdamW8bit	Adafactor
VRAM mínima	12GB	16–24 GB
Arquitectura	U-Net	DiT (Transformer)

Guía de tasa de aprendizaje para FLUX

# Conservador (más seguro, menos probabilidad de sobreajuste)
learning_rate = 5e-5

# Estándar (buen punto de partida)
learning_rate = 1e-4

# Agresivo (más expresivo, riesgo de artefactos)
learning_rate = 2e-4

Consejo: FLUX es más sensible a la tasa de aprendizaje que SDXL. Empiece en 1e-4 y reduzca a 5e-5 si observa problemas de calidad. Para SDXL, 1e-3 es común — evítelo para FLUX.

Probando LoRA de FLUX

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16,
).to("cuda")

# Cargue su LoRA entrenado
pipe.load_lora_weights("/workspace/output/my_flux_lora.safetensors")

image = pipe(
    prompt="una foto de la persona sks, retrato profesional, iluminación de estudio",
    num_inference_steps=28,
    guidance_scale=3.5,
    width=1024,
    height=1024,
).images[0]

image.save("flux_lora_test.png")

---

Solución de problemas

Error de OOM

• Reduce el tamaño de lote a 1

• Activa el checkpointing de gradiente

• Usa un optimizador 8bit

• Menor resolución

Resultados deficientes

• Más/mejores imágenes de entrenamiento

• Ajuste la tasa de aprendizaje

• Verifique que los subtítulos coincidan con las imágenes

• Pruebe un rango de red diferente

El entrenamiento se bloquea

• Verifique la versión de CUDA

• Actualice xformers

• Reducir el tamaño del lote

• Comprueba el espacio en disco

Problemas específicos de FLUX

• "bf16 no es compatible" — Usa GPUs de las series A (Ampere+) o RTX 30/40

• OOM en FLUX.1-dev — Cambia a FLUX.1-schnell (necesita 16 GB) o habilita cache_text_encoder_outputs

• Resultados borrosos — Aumenta network_dim a 32–64, baja la tasa de aprendizaje a 5e-5

• Pérdida NaN — Desactiva full_bf16, comprueba si tu conjunto de datos tiene imágenes corruptas