Entrenamiento Kohya

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

Entrena LoRA, Dreambooth y afinaciones completas para Stable Diffusion usando el entrenador de Kohya.

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

Alquilar en CLORE.AI

Visita CLORE.AI Marketplace
Filtrar por tipo de GPU, VRAM y precio
Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)
Configura tu pedido:
- Selecciona imagen Docker
- Establece puertos (TCP para SSH, HTTP para interfaces web)
- Agrega variables de entorno si es necesario
- Introduce el comando de inicio
Selecciona pago: CLORE, BTC, o USDT/USDC
Crea el pedido y espera el 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
Afinación completa - 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 Docker:

pytorch/pytorch:2.5.1-cuda12.4-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:

Ir a Mis Pedidos página
Haz clic en tu pedido
Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Usando la interfaz web

Acceder en http://<proxy>:<port>
Seleccionar tipo de entrenamiento (LoRA, Dreambooth, etc.)
Configurar ajustes
Iniciar entrenamiento

Preparación del conjunto de datos

Estructura de carpetas

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

Requisitos de imagen

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:

miimagen.txt:

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

Auto-subtitulado

Usar 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 LoRA (SD 1.5)

Configuración

En la UI de Kohya:

Ajuste

Valor

Modelo

runwayml/stable-diffusion-v1-5

Rango de la red

32-128

Alpha de la 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 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="a photo of sks person" \
    --class_prompt="a photo of person" \
    --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="painting in the style of 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 la red

64-128

32-64

Alpha de la red

32-64

16-32

Tasa de aprendizaje

1e-4

5e-5

1e-4

Épocas

15-25

10-15

Evitando sobreajuste

Usar imágenes de regularización
Reducir la tasa de aprendizaje
Menos épocas
Aumentar el alpha de la red

Evitando subajuste

Más imágenes de entrenamiento
Tasa de aprendizaje más alta
Más épocas
Reducir el alpha de la red

Monitoreo del entrenamiento

TensorBoard

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

Métricas clave

pérdida - Debe disminuir y luego estabilizarse
lr - Programación de la tasa de aprendizaje
época - Progreso del entrenamiento

Probar tu LoRA

Con Automatic1111

Copiar LoRA a:

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

Usar en el prompt:

<lora:my_lora:0.8> a photo of sks person

Con ComfyUI

Cargar el nodo LoRA y conectar 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("a photo of sks person, professional portrait").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="style" \
    --placeholder_token="<my-style>" \
    --initializer_token="art" \
    --resolution=512 \
    --train_batch_size=1 \
    --max_train_steps=3000 \
    --learning_rate=5e-4

Guardado y exportación

Descargar 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 fecha 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 CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)
Paga con CLORE tokens
Compara precios entre diferentes proveedores

Entrenamiento LoRA para FLUX

Entrena adaptadores LoRA para FLUX.1-dev y FLUX.1-schnell — la última generación de modelos difusivos tipo transformer 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)

40GB+

A100 40GB

Nota: FLUX usa la arquitectura DiT (Diffusion Transformer): la dinámica de entrenamiento difiere significativamente de SD 1.5 / SDXL.

Instalación para FLUX

Instalar PyTorch con soporte CUDA 12.4:

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

Configuración LoRA para 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: usar 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 para FLUX — LR 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 menor funciona bien (16-64)
network_alpha = 16         # Establecer 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 para 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 vs 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 REQUERIDO

Módulo de red

networks.lora

networks.lora_flux

Dimensión de la red

32–128

8–64 (más pequeño)

Optimizador

AdamW8bit

Adafactor

VRAM mínima

12GB

16–24GB

Arquitectura

U-Net

DiT (Transformer)

Guía de tasa de aprendizaje para FLUX

# Conservador (más seguro, menor riesgo 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. Comienza en 1e-4 y reduce a 5e-5 si ves problemas de calidad. Para SDXL, 1e-3 es común — evita esto 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")

# Cargar tu LoRA entrenada
pipe.load_lora_weights("/workspace/output/my_flux_lora.safetensors")

image = pipe(
    prompt="a photo of sks person, professional portrait, studio lighting",
    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 OOM

Reducir el tamaño de lote a 1
Habilitar gradient checkpointing
Usar optimizador de 8bit
Reducir la resolución

Resultados deficientes

Más/mejores imágenes de entrenamiento
Ajustar la tasa de aprendizaje
Comprobar que los subtítulos coincidan con las imágenes
Probar diferente rango de red

Bloqueos durante el entrenamiento

Comprobar la versión de CUDA
Actualizar xformers
Reducir el tamaño del lote
Comprobar espacio en disco

Problemas específicos de FLUX

"bf16 no soportado" — Usar GPUs serie A (Ampere+) o RTX 30/40
OOM en FLUX.1-dev — Cambiar a FLUX.1-schnell (necesita 16GB) o habilitar cache_text_encoder_outputs
Resultados borrosos — Aumentar network_dim a 32–64, reducir la tasa de aprendizaje a 5e-5
Pérdida NaN — Desactivar full_bf16, comprobar tu conjunto de datos por imágenes corruptas

AnteriorDreamBooth SiguienteAjustar LLM

Última actualización hace 1 día

¿Te fue útil?

hashtagAlquilar en CLORE.AI

hashtagAccede a tu servidor

hashtag¿Qué es Kohya?

hashtagRequisitos

hashtagDespliegue rápido

hashtagAccediendo a tu servicio

hashtagUsando la interfaz web

hashtagPreparación del conjunto de datos

hashtagEstructura de carpetas

hashtagRequisitos de imagen

hashtagArchivos de subtítulos

hashtagAuto-subtitulado

hashtagEntrenamiento LoRA (SD 1.5)

hashtagConfiguración

hashtagEntrenamiento por línea de comandos

hashtagEntrenamiento LoRA (SDXL)

hashtagEntrenamiento Dreambooth

hashtagEntrenamiento de sujeto

hashtagEntrenamiento de estilo

hashtagConsejos de entrenamiento

hashtagAjustes óptimos

hashtagEvitando sobreajuste

hashtagEvitando subajuste

hashtagMonitoreo del entrenamiento

hashtagTensorBoard

hashtagMétricas clave

hashtagProbar tu LoRA

hashtagCon Automatic1111

hashtagCon ComfyUI

hashtagCon Diffusers

hashtagEntrenamiento avanzado

hashtagLyCORIS (LoHa, LoKR)

hashtagInversión textual

hashtagGuardado y exportación

hashtagDescargar modelo entrenado

hashtagConvertir formatos

hashtagEstimación de costos

hashtagEntrenamiento LoRA para FLUX

hashtagRequisitos de VRAM

hashtagInstalación para FLUX

hashtagConfiguración LoRA para FLUX (flux_lora.toml)

hashtagComando de entrenamiento LoRA para FLUX

hashtagFLUX vs SDXL: Diferencias clave

hashtagGuía de tasa de aprendizaje para FLUX

hashtagProbando LoRA de FLUX

hashtagSolución de problemas

hashtagError OOM

hashtagResultados deficientes

hashtagBloqueos durante el entrenamiento

hashtagProblemas específicos de FLUX

Alquilar en CLORE.AI

Accede a tu servidor

¿Qué es Kohya?

Requisitos

Despliegue rápido

Accediendo a tu servicio

Usando la interfaz web

Preparación del conjunto de datos

Estructura de carpetas

Requisitos de imagen

Archivos de subtítulos

Auto-subtitulado

Entrenamiento LoRA (SD 1.5)

Configuración

Entrenamiento por línea de comandos

Entrenamiento LoRA (SDXL)

Entrenamiento Dreambooth

Entrenamiento de sujeto

Entrenamiento de estilo

Consejos de entrenamiento

Ajustes óptimos

Evitando sobreajuste

Evitando subajuste

Monitoreo del entrenamiento

TensorBoard

Métricas clave

Probar tu LoRA

Con Automatic1111

Con ComfyUI

Con Diffusers

Entrenamiento avanzado

LyCORIS (LoHa, LoKR)

Inversión textual

Guardado y exportación

Descargar modelo entrenado

Convertir formatos

Estimación de costos

Entrenamiento LoRA para FLUX

Requisitos de VRAM

Instalación para FLUX

Configuración LoRA para FLUX (flux_lora.toml)

Comando de entrenamiento LoRA para FLUX

FLUX vs SDXL: Diferencias clave

Guía de tasa de aprendizaje para FLUX

Probando LoRA de FLUX

Solución de problemas

Error OOM

Resultados deficientes

Bloqueos durante el entrenamiento

Problemas específicos de FLUX