# Stable Diffusion WebUI

La interfaz web más popular para Stable Diffusion en GPUs de CLORE.AI.

{% 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 %}

## Requisitos del servidor

| Parámetro        | Mínimo        | Recomendado |
| ---------------- | ------------- | ----------- |
| RAM              | 16GB          | 32GB+       |
| VRAM             | 8GB           | 12GB+       |
| Red              | 500Mbps       | 1Gbps+      |
| Tiempo de inicio | 10-20 minutos | -           |

{% hint style="warning" %}
**Tiempo de inicio:** El primer lanzamiento instala dependencias de Python y descarga el modelo base (10-20 minutos según la velocidad de la red). HTTP 502 durante este tiempo es normal.
{% endhint %}

## ¿Por qué SD WebUI?

* **Con muchas funciones** - txt2img, img2img, inpainting, outpainting
* **Extensiones** - Enorme ecosistema de complementos
* **Fácil de usar** - Interfaz web intuitiva
* **Bien documentado** - Gran soporte comunitario

> 📚 Véase también: [Cómo ejecutar Stable Diffusion en una GPU en la nube](https://blog.clore.ai/how-to-run-stable-diffusion-cloud-gpu/)

## Despliegue rápido en CLORE.AI

**Imagen Docker:**

```
universonic/stable-diffusion-webui:latest
```

**Puertos:**

```
22/tcp
8080/http
```

**Comando:**

```bash
./webui.sh --listen --xformers
```

### Verificar que funciona

Después del despliegue, encuentre su `http_pub` URL en **Mis pedidos**:

```bash
# Compruebe si la interfaz es accesible (puede tardar 10-20 min en la primera ejecución)
curl https://your-http-pub.clorecloud.net/
```

{% hint style="info" %}
Si obtiene HTTP 502 durante más de 20 minutos, verifique:

1. El servidor tiene 16GB+ de RAM
2. El servidor tiene 8GB+ de VRAM
3. La velocidad de la red es adecuada para descargar dependencias
   {% endhint %}

## Acceder a su servicio

Cuando se despliega en CLORE.AI, acceda a SD WebUI a través de la `http_pub` URL:

* **Interfaz web:** `https://your-http-pub.clorecloud.net/`
* **API (si está habilitada):** `https://your-http-pub.clorecloud.net/sdapi/v1/`

{% hint style="info" %}
Todo `localhost:7860` los ejemplos siguientes funcionan cuando está conectado por SSH. Para acceso externo, reemplácelo por su `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## Instalación

### Usando Docker (Recomendado)

```bash
docker run -d --gpus all \
    -p 8080:8080 \
    -v sd-webui-data:/app/stable-diffusion-webui \
    universonic/stable-diffusion-webui:latest
```

### Instalación manual

```bash
# Instalar dependencias
sudo apt install python3.10 python3.10-venv git wget

# Clonar repositorio
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui

# Ejecutar (instala todo automáticamente)
./webui.sh --listen --xformers
```

## Estructura de directorios

```
stable-diffusion-webui/
├── models/
│   ├── Stable-diffusion/   # Modelos principales (.safetensors)
│   ├── Lora/               # Modelos LoRA
│   ├── VAE/                # Modelos VAE
│   ├── ControlNet/         # Modelos ControlNet
│   └── ESRGAN/             # Upscalers
├── embeddings/             # Inversiones textuales
├── extensions/             # Extensiones instaladas
├── outputs/                # Imágenes generadas
└── scripts/                # Scripts personalizados
```

## Descargar modelos

### Puntos de control

```bash
cd models/Stable-diffusion

# SD 1.5
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# SDXL
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

# Realistic Vision (Fotorrealista)
wget "https://civitai.com/api/download/models/245598" -O realisticVision_v60B1.safetensors

# DreamShaper (Artístico)
wget "https://civitai.com/api/download/models/351306" -O dreamshaper_8.safetensors
```

### VAE (Mejores colores)

```bash
cd models/VAE

# SD 1.5 VAE
wget https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.safetensors

# SDXL VAE
wget https://huggingface.co/stabilityai/sdxl-vae/resolve/main/sdxl_vae.safetensors
```

## Uso básico

### txt2img (Texto a imagen)

1. Seleccionar modelo del menú desplegable
2. Introducir prompt positivo: lo que quieres
3. Introducir prompt negativo: lo que quieres evitar
4. Establecer dimensiones (512x512 para SD1.5, 1024x1024 para SDXL)
5. Hacer clic en Generar

### img2img (Imagen a imagen)

1. Ir a la pestaña img2img
2. Subir imagen de origen
3. Introducir prompt describiendo los cambios deseados
4. Ajustar **Fuerza de desruido** (0.3-0.8)
5. Generar

### Inpainting

1. Ir a img2img → Inpaint
2. Subir imagen
3. Dibujar máscara sobre el área a cambiar
4. Introducir prompt para el área enmascarada
5. Generar

## Ajustes esenciales

### Ajustes de generación

| Configuración | SD 1.5          | SDXL            |
| ------------- | --------------- | --------------- |
| Ancho         | 512             | 1024            |
| Alto          | 512             | 1024            |
| Pasos         | 20-30           | 20-40           |
| Escala CFG    | 7               | 5-7             |
| Sampler       | DPM++ 2M Karras | DPM++ 2M Karras |

### Argumentos de línea de comandos

```bash
./webui.sh \
    --listen \              # Permitir acceso externo
    --port 7860 \           # Número de puerto
    --xformers \            # Optimización de memoria
    --enable-insecure-extension-access \  # Permitir extensiones
    --api \                 # Habilitar API
    --no-half-vae           # Arreglar imágenes negras
```

### Para baja VRAM

```bash
./webui.sh \
    --listen \
    --medvram \           # 6-8GB VRAM
    # o
    --lowvram \           # 4GB VRAM
    --xformers
```

## Extensiones populares

### Imprescindibles

| Extensión                 | Propósito                            |
| ------------------------- | ------------------------------------ |
| ControlNet                | Generación guiada                    |
| ADetailer                 | Corrección automática de caras/manos |
| Ultimate SD Upscale       | Mejor escalado                       |
| sd-webui-segment-anything | Segmentación                         |
| Regional Prompter         | Prompts multirregión                 |

### Instalar extensiones

1. Ir a **Extensiones** pestaña
2. Hacer clic **Disponible**
3. Hacer clic **Cargar desde**
4. Buscar e instalar
5. Aplicar y reiniciar la interfaz

O manualmente:

```bash
cd extensions
git clone https://github.com/Mikubill/sd-webui-controlnet.git
```

## ControlNet

### Instalación

```bash
# Instalar extensión
cd extensions
git clone https://github.com/Mikubill/sd-webui-controlnet.git

# Descargar modelos
cd ../models/ControlNet
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11f1p_sd15_depth.pth
```

### Uso

1. Expandir sección ControlNet
2. Subir imagen de control
3. Seleccionar preprocesador (Canny, OpenPose, etc.)
4. Seleccionar modelo que coincida con el preprocesador
5. Generar

## Uso de la API

Habilitar con `--api` flag, luego:

```python
import requests
import base64

# Para acceso externo, use su URL http_pub:
API_URL = "https://your-http-pub.clorecloud.net"
# O vía SSH: API_URL = "http://localhost:7860"

def txt2img(prompt, negative="", steps=20, width=512, height=512):
    response = requests.post(
        f"{API_URL}/sdapi/v1/txt2img",
        json={
            "prompt": prompt,
            "negative_prompt": negative,
            "steps": steps,
            "width": width,
            "height": height,
        }
    )
    return base64.b64decode(response.json()["images"][0])

# Generar y guardar
image_data = txt2img("A beautiful sunset over mountains")
with open("output.png", "wb") as f:
    f.write(image_data)
```

### API img2img

```python
import base64

def img2img(prompt, image_path, denoising=0.5):
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    response = requests.post(
        f"{API_URL}/sdapi/v1/img2img",
        json={
            "prompt": prompt,
            "init_images": [image_b64],
            "denoising_strength": denoising,
            "steps": 30,
        }
    )
    return base64.b64decode(response.json()["images"][0])
```

## Redacción de prompts

### Estructura básica

```
[sujeto], [estilo], [detalles], [iluminación], [etiquetas de calidad]
```

### Ejemplos de prompts

```
# Retrato
retrato de una joven, fotografía profesional,
iluminación suave, poca profundidad de campo, 8k uhd,
altamente detallado, fotorrealista

# Paisaje
majestuoso paisaje montañoso al atardecer, nubes dramáticas,
iluminación de hora dorada, estilo National Geographic,
fondo de pantalla 8k, altamente detallado

# Anime
1chica, cabello plateado, ojos azules, uniforme escolar,
cerezos en flor, primavera, obra maestra, mejor calidad
```

### Prompts negativos

```
# General
baja resolución, mala anatomía, manos malas, texto, error,
dedos faltantes, recortado, peor calidad, baja calidad,
artefactos jpeg, firma, marca de agua, borroso

# Para fotorrealista
caricatura, anime, ilustración, pintura, dibujo,
render 3D, cgi
```

## Consejos de rendimiento

1. **Habilitar xFormers** - Aumento significativo de velocidad
2. **Usar VAE** - Mejores colores
3. **Tamaño de lote 1** - Para VRAM limitada
4. **Hires Fix** - Generar pequeño, luego escalar
5. **ADetailer** - Corrección automática de caras

## Requisitos de GPU

| Modelo         | VRAM mínima | VRAM recomendada | RAM mín |
| -------------- | ----------- | ---------------- | ------- |
| SD 1.5         | 4GB         | 8GB              | 16GB    |
| SD 2.1         | 6GB         | 8GB              | 16GB    |
| SDXL           | 8GB         | 12GB             | 16GB    |
| Con ControlNet | +2GB        | +4GB             | 16GB    |

## Perfiles de GPU

### RTX 3060 12GB (Económica)

```bash
# Comando de lanzamiento
./webui.sh --medvram --xformers

# settings.json recomendados:
# - SD 1.5: 512x512, lote 4, 20-30 pasos
# - SDXL: 768x768, lote 1, 20 pasos
# - Habilitar VAE tiling en Configuración
# - Usar ADetailer para caras
```

**Mejores modelos:** SD 1.5, DreamShaper, RealisticVision

### RTX 3090 24GB (Óptima)

```bash
# Comando de lanzamiento
./webui.sh --xformers

# Configuración recomendada:
# - SD 1.5: 512x512, lote 8, 30 pasos
# - SDXL: 1024x1024, lote 2, 30 pasos
# - ControlNet + SD 1.5 funciona muy bien
# - Hires fix a 2x funciona
```

**Mejores modelos:** SDXL, Juggernaut, RealVisXL

### RTX 4090 24GB (Rendimiento)

```bash
# Comando de lanzamiento
./webui.sh --xformers --opt-sdp-attention

# Configuración recomendada:
# - SD 1.5: 512x512, lote 16, 30 pasos
# - SDXL: 1024x1024, lote 4, 40 pasos
# - Varias ControlNets simultáneamente
# - Hires fix a 4x
```

**Mejores modelos:** SDXL, Pony Diffusion, Cualquier modelo de alta resolución

### A100 40GB/80GB (Producción)

```bash
# Comando de lanzamiento
./webui.sh --opt-sdp-attention --no-half-vae

# Configuración recomendada:
# - SDXL: 1024x1024, lote 8+, 50 pasos
# - Varias ControlNet + IP-Adapter
# - Hires fix a 4096x4096
# - AnimateDiff para vídeo
```

**Ideal para:** Generación por lotes, flujos de trabajo complejos, vídeo

## Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

| GPU      | VRAM | Precio/día | Velocidad SD1.5 | Velocidad SDXL |
| -------- | ---- | ---------- | --------------- | -------------- |
| RTX 3060 | 12GB | $0.15–0.30 | \~4 seg         | \~12 seg       |
| RTX 3090 | 24GB | $0.30–1.00 | \~2 seg         | \~6 seg        |
| RTX 4090 | 24GB | $0.50–2.00 | \~1 seg         | \~3 seg        |
| A100     | 40GB | $1.50–3.00 | \~0.5 seg       | \~2 seg        |

*Precios en USD/día. Las tarifas varían según el proveedor — consulte* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

## Solución de problemas

### HTTP 502 durante mucho tiempo

1. **Comprobar RAM:** El servidor debe tener 16GB+ de RAM
2. **Comprobar VRAM:** Debe tener 8GB+ para SDXL
3. **Instalando dependencias:** La primera ejecución tarda 10-20 min
4. **Red lenta:** El ancho de banda bajo provoca un inicio más largo

### Imágenes negras

```bash
# Añadir a los argumentos de lanzamiento
--no-half-vae
```

### Falta de memoria

```bash
# Usar optimización
--medvram
--xformers
```

### Extensiones que no cargan

```bash
--enable-insecure-extension-access
```

### Generación lenta

1. Habilitar xFormers
2. Reducir tamaño de imagen
3. Reducir pasos (20 suele ser suficiente)

## Siguientes pasos

* [ComfyUI](https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/comfyui) - Flujos de trabajo más avanzados
* [FLUX.1](https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/flux) - Último modelo
* [ControlNet](https://docs.clore.ai/guides/guides_v2-es/procesamiento-de-imagenes/controlnet-advanced) - Generación guiada
* [Entrenamiento LoRA](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/kohya-training) - Modelos personalizados