# Entrenamiento Kohya

Entrena LoRA, Dreambooth y afinaciones completas 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 [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio de puja)
4. 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
5. Selecciona pago: **CLORE**, **BTC**, o **USDT/USDC**
6. 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:**

```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. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. 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

1. Acceder en `http://<proxy>:<port>`
2. Seleccionar tipo de entrenamiento (LoRA, Dreambooth, etc.)
3. Configurar ajustes
4. 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:

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

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

```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="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  | 32     |
| Alpha de la red     | 32-64             | 16-32  | 16     |
| Tasa de aprendizaje | 1e-4              | 5e-5   | 1e-4   |
| Épocas              | 15-25             | 10-15  | 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

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

```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("a photo of sks person, professional portrait").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="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

```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 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*](https://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:

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

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

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

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

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


---

# Agent Instructions: 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:

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

The question should be specific, self-contained, and written in natural language.
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.