> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/kohya-training.md).

# 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.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
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:**

```bash
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:

```python
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

```bash
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)

```bash
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

```bash
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

```bash
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

```bash
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

```python
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)

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

### Inversión textual

```bash
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

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

### Convertir formatos

```python

# 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*](https://clore.ai/marketplace) *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:

```bash
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)

```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

```bash
# 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

```toml
# 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

```python
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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/entrenamiento/kohya-training.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.