SD WebUI Forge

Despliega Stable Diffusion WebUI Forge con gestión de VRAM optimizada y soporte FLUX en las GPU de Clore.ai

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.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

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

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.

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:

• 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

ssh -p <PORT> root@<SERVER_IP>

3. Crear directorios de almacenamiento

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:

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:

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):

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):

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

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

# 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

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:

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

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

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

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:

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

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

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)

• GitHub (base A1111)

• Docker Hub (nykk3)

• CivitAI (Modelos)

• Modelos FLUX

• 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 servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.