# 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](/guides/guides_v2-es/generacion-de-imagenes/comfyui.md) - Flujos de trabajo más avanzados
* [FLUX.1](/guides/guides_v2-es/generacion-de-imagenes/flux.md) - Último modelo
* [ControlNet](/guides/guides_v2-es/procesamiento-de-imagenes/controlnet-advanced.md) - Generación guiada
* [Entrenamiento LoRA](/guides/guides_v2-es/entrenamiento/kohya-training.md) - Modelos personalizados


---

# 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/generacion-de-imagenes/stable-diffusion-webui.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.