# DreamBooth

Entrenar Stable Diffusion para generar imágenes de sujetos específicos.

{% 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 DreamBooth?

DreamBooth afina SD con tus imágenes:

* Entrenar con 5-20 imágenes
* Generar nuevas imágenes de tu sujeto
* Cualquier estilo o contexto
* Funciona con SD 1.5 y SDXL

## Requisitos

| Modelo        | VRAM | Tiempo de Entrenamiento |
| ------------- | ---- | ----------------------- |
| SD 1.5        | 12GB | 15-30 min               |
| SDXL          | 24GB | 30-60 min               |
| SD 1.5 + LoRA | 8GB  | 10-20 min               |

## Despliegue rápido

**Imagen Docker:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
pip install diffusers transformers accelerate bitsandbytes && \
pip install xformers peft && \
python dreambooth_train.py
```

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

## Instalación

```bash
pip install diffusers transformers accelerate
pip install bitsandbytes xformers peft
```

## Preparar Datos de Entrenamiento

1. Recopila 5-20 imágenes de tu sujeto
2. Recortar a la cara/sujeto
3. Redimensionar a 512x512 (o 1024x1024 para SDXL)
4. Eliminar fondos si es necesario

```python
from PIL import Image
import os

def prepare_images(input_dir, output_dir, size=512):
    os.makedirs(output_dir, exist_ok=True)

    for filename in os.listdir(input_dir):
        if filename.endswith(('.jpg', '.png', '.jpeg')):
            img = Image.open(os.path.join(input_dir, filename))
            img = img.convert('RGB')

            # Recorte centrado a cuadrado
            min_dim = min(img.size)
            left = (img.width - min_dim) // 2
            top = (img.height - min_dim) // 2
            img = img.crop((left, top, left + min_dim, top + min_dim))

            # Redimensionar
            img = img.resize((size, size), Image.LANCZOS)
            img.save(os.path.join(output_dir, filename))

prepare_images("./raw_photos", "./training_data")
```

## DreamBooth con LoRA (Recomendado)

Entrenamiento eficiente en memoria:

```python
from diffusers import StableDiffusionPipeline, DDPMScheduler
from diffusers.loaders import LoraLoaderMixin
import torch

# Script de entrenamiento
from accelerate import Accelerator
from diffusers import AutoencoderKL, UNet2DConditionModel
from transformers import CLIPTextModel, CLIPTokenizer
from peft import LoraConfig, get_peft_model

# Cargar modelos
model_id = "runwayml/stable-diffusion-v1-5"
tokenizer = CLIPTokenizer.from_pretrained(model_id, subfolder="tokenizer")
text_encoder = CLIPTextModel.from_pretrained(model_id, subfolder="text_encoder")
vae = AutoencoderKL.from_pretrained(model_id, subfolder="vae")
unet = UNet2DConditionModel.from_pretrained(model_id, subfolder="unet")

# Añadir LoRA al UNet
lora_config = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=["to_q", "to_k", "to_v", "to_out.0"],
    lora_dropout=0.1,
)

unet = get_peft_model(unet, lora_config)
```

## Usando el Script de Entrenamiento de diffusers

```bash

# Clonar los scripts de entrenamiento
git clone https://github.com/huggingface/diffusers
cd diffusers/examples/dreambooth

# Instalar dependencias
pip install -r requirements.txt

# Entrenar con LoRA
accelerate launch train_dreambooth_lora.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --instance_data_dir="./training_data" \
    --instance_prompt="a photo of sks person" \
    --output_dir="./dreambooth_model" \
    --resolution=512 \
    --train_batch_size=1 \
    --gradient_accumulation_steps=1 \
    --learning_rate=1e-4 \
    --lr_scheduler="constant" \
    --lr_warmup_steps=0 \
    --max_train_steps=500 \
    --seed=42
```

## Parámetros de Entrenamiento

| Parámetro          | Recomendado               | Efecto                                        |
| ------------------ | ------------------------- | --------------------------------------------- |
| learning\_rate     | 1e-4 a 5e-6               | Más alto = más rápido, más bajo = más estable |
| max\_train\_steps  | 400-1000                  | Más = mejor ajuste                            |
| train\_batch\_size | 1-2                       | Más alto necesita más VRAM                    |
| resolution         | 512 (SD1.5) / 1024 (SDXL) | Tamaño de Entrenamiento                       |

## Prompt de Instancia

Elige un identificador único:

```bash

# Buenos prompts
"a photo of sks person"      # sks = token único
"a photo of xyz dog"
"a photo of abc car"

# El token (sks, xyz, abc) debería ser raro
```

## Con preservación de clase

Prevenir sobreajuste:

```bash
accelerate launch train_dreambooth_lora.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --instance_data_dir="./my_dog_photos" \
    --instance_prompt="a photo of sks dog" \
    --class_data_dir="./regular_dog_photos" \
    --class_prompt="a photo of dog" \
    --with_prior_preservation \
    --prior_loss_weight=1.0 \
    --num_class_images=200 \
    --output_dir="./dreambooth_dog" \
    --max_train_steps=800
```

## DreamBooth SDXL

```bash
accelerate launch train_dreambooth_lora_sdxl.py \
    --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
    --instance_data_dir="./training_data" \
    --instance_prompt="a photo of sks person" \
    --output_dir="./dreambooth_sdxl" \
    --resolution=1024 \
    --train_batch_size=1 \
    --gradient_accumulation_steps=4 \
    --learning_rate=1e-4 \
    --max_train_steps=500 \
    --mixed_precision="fp16"
```

## Usando el Modelo Entrenado

### Cargar LoRA

```python
from diffusers import StableDiffusionPipeline
import torch

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

# Cargar tu LoRA entrenada
pipe.load_lora_weights("./dreambooth_model")

# Generar
image = pipe(
    "a photo of sks person as an astronaut on mars",
    num_inference_steps=30,
    guidance_scale=7.5
).images[0]

image.save("astronaut.png")
```

### Afinado Completo

```python
pipe = StableDiffusionPipeline.from_pretrained(
    "./dreambooth_model",
    torch_dtype=torch.float16
).to("cuda")

image = pipe("a photo of sks person in a suit").images[0]
```

## Interfaz Gradio

```python
import gradio as gr
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("./dreambooth_model")

def generate(prompt, negative_prompt, steps, guidance, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    ).images[0]

    return image

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label="Prompt (usa 'sks' para tu sujeto)"),
        gr.Textbox(label="Prompt Negativo", value="borroso, feo"),
        gr.Slider(20, 50, value=30, step=1, label="Steps"),
        gr.Slider(5, 15, value=7.5, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Semilla")
    ],
    outputs=gr.Image(label="Imagen generada"),
    title="Generador de Retratos DreamBooth"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Consejos de entrenamiento

### Para Personas

* Usar ángulos variados (frontal, lateral, 3/4)
* Diferentes condiciones de iluminación
* Varias expresiones
* Fotos claras y de alta resolución

### Para Objetos

* Múltiples ángulos
* Diferentes fondos
* Iluminación consistente
* Sin oclusión

### Para Estilos

* 10-20 imágenes de ejemplo
* Estilo artístico consistente
* Varios sujetos en ese estilo

## Solución de problemas

### Sobreajuste

* Reducir max\_train\_steps
* Bajar learning\_rate
* Usar preservación de prior
* Más imágenes de entrenamiento

### Subajuste

* Aumentar max\_train\_steps
* Aprendizaje más alto (learning\_rate)
* Más imágenes de entrenamiento
* Comprobar la calidad de las imágenes

### Estilo no aprendido

* Aumentar el rango de LoRA (r=16 o 32)
* Entrenar más tiempo
* Usar más ejemplos

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

## Próximos pasos

* [Entrenamiento Kohya](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/kohya-training) - Entrenamiento avanzado
* Stable Diffusion WebUI - Usar modelos
* [Afinado LoRA](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/kohya-training) - Entrenamiento LLM