# SD WebUI Forge

SD WebUI Forge es un fork optimizado del clásico Stable Diffusion WebUI de AUTOMATIC1111, desarrollado por el equipo lllyasviel. Ofrece una gestión de VRAM significativamente mejor (permitiendo SDXL en GPUs de 4 GB), soporte nativo para modelos FLUX, velocidades de generación más rápidas y compatibilidad total hacia atrás con todas las extensiones y modelos de A1111. El mercado flexible de GPU de CLORE.AI te permite elegir la GPU perfecta para Forge — desde tarjetas económicas hasta A100 de primera línea.

{% 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       | 8 GB                 | 16 GB+             |
| VRAM      | 4 GB                 | 12 GB+             |
| Disco     | 30 GB                | 200 GB+            |
| GPU       | NVIDIA GTX 1650 4GB+ | RTX 3090, RTX 4090 |

{% hint style="info" %}
La ventaja clave de Forge es su optimizador de VRAM: puede ejecutar SDXL con tan solo 4 GB de VRAM (con velocidad más lenta). Para modelos FLUX, 12 GB de VRAM es el mínimo práctico, y 24 GB para calidad y velocidad completas.
{% endhint %}

## Despliegue rápido en CLORE.AI

**Imagen Docker:** `nykk3/stable-diffusion-webui-forge:latest`

**Puertos:** `22/tcp`, `7860/http`

**Variables de entorno:**

| Variable           | Ejemplo                | Descripción                      |
| ------------------ | ---------------------- | -------------------------------- |
| `CLI_ARGS`         | `--xformers --medvram` | Argumentos CLI adicionales       |
| `COMMANDLINE_ARGS` | `--api --listen`       | Variable alternativa de args CLI |

## Configuración paso a paso

### 1. Alquila un servidor GPU en CLORE.AI

Dirígete a [CLORE.AI Marketplace](https://clore.ai/marketplace):

* **SD1.5 económico**: GTX 1660/2060 (6 GB) — suficiente para 512/768px
* **Compatible con SDXL**: RTX 3080/3090 (10–24 GB)
* **Compatible con FLUX**: RTX 4090/A6000 (24+ GB)
* **Calidad máxima**: A100 80GB para generación por lotes

### 2. Conéctate por SSH a tu servidor

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Crear directorios de almacenamiento

```bash
mkdir -p /root/sd-forge/{models,outputs,extensions,configs}
mkdir -p /root/sd-forge/models/{Stable-diffusion,VAE,Lora,ControlNet,embeddings,ESRGAN}
```

### 4. Descargar y ejecutar SD WebUI Forge

**Lanzamiento estándar:**

```bash
docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -v /root/sd-forge/extensions:/app/stable-diffusion-webui/extensions \
  nykk3/stable-diffusion-webui-forge:latest
```

**Con API habilitada y flags de rendimiento adicionales:**

```bash
docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -v /root/sd-forge/extensions:/app/stable-diffusion-webui/extensions \
  -e CLI_ARGS="--api --xformers --enable-insecure-extension-access" \
  nykk3/stable-diffusion-webui-forge:latest
```

**Modo baja VRAM (GPUs de 4-6 GB):**

```bash
docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -e CLI_ARGS="--api --medvram-sdxl --opt-sdp-attention" \
  nykk3/stable-diffusion-webui-forge:latest
```

**Rendimiento máximo (24+ GB VRAM):**

```bash
docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -e CLI_ARGS="--api --xformers --no-half-vae" \
  nykk3/stable-diffusion-webui-forge:latest
```

### 5. Monitorizar el arranque

```bash
docker logs -f sd-forge
```

Busca:

```
Se está ejecutando en la URL local:  http://0.0.0.0:7860
```

El inicio normalmente tarda 2–5 minutos en la primera ejecución.

### 6. Acceder a la interfaz web

Su URL http\_pub de CLORE.AI para el puerto 7860:

```
https://<order-id>-7860.clore.ai/
```

### 7. Añadir modelos

**Método 1: Descargar vía CivitAI en la UI web**

* Ve a **Extensions → Installed → Models** (algunas versiones)
* O usa el descargador por URL en Settings

**Método 2: Descargar directamente en el servidor**

```bash
# Descargar modelo base SDXL
cd /root/sd-forge/models/Stable-diffusion
wget -O "sd_xl_base_1.0.safetensors" \
  "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors"

# Descargar FLUX.1-schnell (modelo FLUX rápido)
wget -O "flux1-schnell.safetensors" \
  "https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors"
```

**Método 3: HuggingFace CLI**

```bash
docker exec -it sd-forge bash -c "
pip install huggingface_hub
huggingface-cli download stabilityai/stable-diffusion-xl-base-1.0 \
  sd_xl_base_1.0.safetensors \
  --local-dir /app/stable-diffusion-webui/models/Stable-diffusion/
"
```

***

## Ejemplos de uso

### Ejemplo 1: Texto a imagen vía Web UI

1. Abre la UI de Forge en tu URL de CLORE.AI
2. Selecciona tu modelo desde el **Checkpoint** desplegable
3. Introduce el prompt: `"retrato cinematográfico de un guerrero, hora dorada, fotografía 8k"`
4. Establece prompt negativo: `"borroso, baja resolución, marca de agua, feo"`
5. Establece ancho/alto: `1024x1024` para SDXL, `512x768` para SD1.5
6. Ajusta pasos: 20–30, CFG: 7
7. Haz clic **Generar**

### Ejemplo 2: Generación con FLUX

Los modelos FLUX funcionan de forma diferente — sin prompt negativo, calidad superior:

1. Selecciona el checkpoint FLUX (flux1-dev.safetensors)
2. Bajo **Forge**, selecciona el **Unet** y **VAE** si son archivos separados
3. Introduce el prompt (no hace falta prompt negativo):

   ```
   Un paisaje impresionante al atardecer, montañas reflejadas en un lago prístino,
   fotorrealista, ultra detallado, fotografía profesional
   ```
4. Pasos: 20, CFG: 1.0 (FLUX usa CFG más bajo)
5. Sampler: `Euler` o `DPM++ 2M`

### Ejemplo 3: Generación guiada por ControlNet

1. Instala la extensión ControlNet (si no viene preinstalada):
   * Ve a **Extensions → Available → Load from**
   * Busca "ControlNet" e instala
2. Descarga modelos de ControlNet a `/root/sd-forge/models/ControlNet/`
3. En txt2img, expande **ControlNet** sección
4. Sube imagen de referencia (pose, profundidad, borde canny)
5. Selecciona el preprocesador y el modelo que coincida con tu tipo de referencia
6. Genera — la salida sigue la estructura de la referencia

### Ejemplo 4: Uso de la API

Con `--api` flag, Forge expone una API REST:

```python
import requests
import base64
import io
from PIL import Image

BASE_URL = "http://localhost:7860"  # o la URL http_pub de CLORE.AI

# Texto a imagen
payload = {
    "prompt": "un sereno jardín japonés con cerezos en flor, estilo acuarela",
    "negative_prompt": "feo, borroso, baja calidad",
    "steps": 25,
    "cfg_scale": 7,
    "width": 1024,
    "height": 1024,
    "sampler_name": "DPM++ 2M",
    "batch_size": 1,
}

response = requests.post(f"{BASE_URL}/sdapi/v1/txt2img", json=payload)
result = response.json()

# Guardar la imagen
for i, img_b64 in enumerate(result["images"]):
    img_data = base64.b64decode(img_b64)
    img = Image.open(io.BytesIO(img_data))
    img.save(f"output_{i}.png")
    print(f"Saved output_{i}.png")
```

### Ejemplo 5: Script de generación por lotes

```python
import requests
import base64
import io
from PIL import Image
import os

BASE_URL = "http://localhost:7860"

prompts = [
    ("ciudad cyberpunk de noche, luces de neón, lluvia", "cyberpunk"),
    ("bosque antiguo, niebla mística, arte fantástico", "fantasy"),
    ("diseño de logo minimalista, formas geométricas, fondo blanco", "logo"),
    ("retrato de un marinero anciano, rostro curtido, pintura al óleo", "portrait"),
]

os.makedirs("batch_output", exist_ok=True)

for prompt_text, filename in prompts:
    print(f"Generating: {filename}...")
    response = requests.post(
        f"{BASE_URL}/sdapi/v1/txt2img",
        json={
            "prompt": prompt_text,
            "negative_prompt": "baja calidad, borroso, marca de agua",
            "steps": 25,
            "cfg_scale": 7,
            "width": 1024,
            "height": 1024,
        },
    )
    
    if response.status_code == 200:
        img_b64 = response.json()["images"][0]
        img = Image.open(io.BytesIO(base64.b64decode(img_b64)))
        img.save(f"batch_output/{filename}.png")
        print(f"  Saved batch_output/{filename}.png")
    else:
        print(f"  Error: {response.status_code}")
```

***

## Configuración

### Argumentos CLI clave

| Argumento                            | Descripción                                                |
| ------------------------------------ | ---------------------------------------------------------- |
| `--api`                              | Habilitar API REST                                         |
| `--listen`                           | Escuchar en todas las interfaces (requerido para CLORE.AI) |
| `--port 7860`                        | Cambiar puerto                                             |
| `--xformers`                         | Habilitar atención xFormers (más rápido, menos VRAM)       |
| `--medvram`                          | Modo VRAM medio (SD1.5 en 6GB)                             |
| `--medvram-sdxl`                     | VRAM media para SDXL (SDXL en 8GB)                         |
| `--lowvram`                          | Modo baja VRAM (muy lento, cualquier GPU)                  |
| `--no-half`                          | Usar float32 (más VRAM, más estable)                       |
| `--no-half-vae`                      | Mantener VAE en float32 (evita imágenes negras)            |
| `--opt-sdp-attention`                | Atención de producto punto escalada de PyTorch             |
| `--enable-insecure-extension-access` | Permitir instalación de extensiones                        |
| `--skip-version-check`               | Omitir comprobaciones de versión de Python/torch           |

### Ajustes específicos de Forge

Forge añade un **Forge** panel en la UI con:

* **Forge Unet**: Seleccionar backend de optimización (por defecto, bnb, etc.)
* **Compilación de Diffusers Torch**: Habilitar para 20-30% de generación más rápida (la primera ejecución compila)
* **Pesos en GPU**: Cuánto mantener en GPU frente a CPU

***

## Consejos de rendimiento

### 1. Usa xFormers para 20-30% menos VRAM

```bash
--xformers
```

Mejora automáticamente el rendimiento en la mayoría de GPUs.

### 2. Optimizador de VRAM de Forge

Forge gestiona la VRAM automáticamente mejor que A1111. Simplemente usa el `--medvram-sdxl` flag para SDXL en GPUs de 8-12 GB y deja que lo gestione todo.

### 3. Habilitar compilación Torch (Ampere+)

En la pestaña Forge en la UI, habilita **Compilación de Diffusers Torch**. La primera generación tarda 2-3 minutos en compilar, pero las siguientes son 20-30% más rápidas.

### 4. Combinaciones óptimas de pasos/sampler

| Objetivo  | Sampler            | Pasos | CFG |
| --------- | ------------------ | ----- | --- |
| Velocidad | `DPM++ SDE Karras` | 15-20 | 7   |
| Calidad   | `DPM++ 2M Karras`  | 25-35 | 7   |
| Artístico | `Euler a`          | 20-30 | 5-7 |
| FLUX      | `Euler`            | 20    | 1   |

### 5. Usar Tile VAE para resoluciones 2K+

Para resolución ultra alta (2048×2048+), habilita **VAE en mosaicos** en la pestaña SD para prevenir errores OOM del VAE.

### 6. Lotes localmente con la API

En lugar de generar de uno en uno en la UI, usa la API con `batch_size` para mayor rendimiento:

```python
payload = {
    "prompt": "...",
    "batch_size": 4,  # Generar 4 imágenes a la vez
    "n_iter": 2,      # Ejecutar 2 iteraciones = 8 imágenes en total
}
```

***

## Solución de problemas

### Problema: Imágenes negras o verdes

Problema de precisión del VAE. Añade el flag:

```bash
--no-half-vae
```

O usa el `sdxl-vae-fp16-fix.safetensors` VAE.

### Problema: "CUDA out of memory"

Prueba en este orden:

1. `--medvram-sdxl` (para SDXL)
2. `--medvram` (para SD1.5)
3. Reducir resolución de la imagen
4. `--lowvram` (último recurso, muy lento)

### Problema: Extensiones que no cargan

```bash
# Permitir acceso a extensiones
-e CLI_ARGS="--enable-insecure-extension-access"
```

Luego instala desde la pestaña Extensions en la UI.

### Problema: El arranque tarda demasiado

Normal en la primera ejecución — se calculan PyTorch y los hashes de los modelos. Los inicios posteriores son más rápidos.

```bash
docker logs -f sd-forge  # Ver progreso
```

### Problema: No se puede acceder a la UI desde el navegador

Asegúrate de que el proceso Forge se enlaza a `0.0.0.0`:

* Añade `--listen` a CLI\_ARGS
* Verifica que el puerto 7860 esté en la lista de puertos de tu orden de CLORE.AI

### Problema: Modelo no aparece en el desplegable

Después de colocar `.safetensors` archivos en la carpeta correcta, haz clic **🔄 Actualizar** junto al desplegable Checkpoint.

***

## Enlaces

* [GitHub (Forge)](https://github.com/lllyasviel/stable-diffusion-webui-forge)
* [GitHub (base A1111)](https://github.com/AUTOMATIC1111/stable-diffusion-webui)
* [Docker Hub (nykk3)](https://hub.docker.com/r/nykk3/stable-diffusion-webui-forge)
* [CivitAI (Modelos)](https://civitai.com)
* [Modelos FLUX](https://huggingface.co/black-forest-labs)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)

***

## Recomendaciones de GPU en Clore.ai

| Caso de uso        | GPU recomendada | Coste estimado en Clore.ai |
| ------------------ | --------------- | -------------------------- |
| Desarrollo/Pruebas | RTX 3090 (24GB) | \~$0.12/gpu/hr             |
| Producción         | RTX 4090 (24GB) | \~$0.70/gpu/hr             |
| Gran escala        | A100 80GB       | \~$1.20/gpu/hr             |

> 💡 Todos los ejemplos en esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.


---

# 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/sd-webui-forge.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.