SD WebUI Forge

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

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

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

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 principal ventaja de Forge es su optimizador de VRAM: puede ejecutar SDXL con tan solo 4 GB de VRAM (a menor velocidad). Para los modelos FLUX, 12 GB de VRAM es el mínimo práctico, y 24 GB ofrecen calidad y velocidad completas.

Despliegue rápido en CLORE.AI

Imagen de 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 de entorno alternativa para args CLI

Configuración paso a paso

1. Alquila un servidor GPU en CLORE.AI

Ve a Marketplace de CLORE.AI:

• SD1.5 económico: GTX 1660/2060 (6 GB) — suficiente para 512/768 px

• Compatible con SDXL: RTX 3080/3090 (10–24 GB)

• Compatible con FLUX: RTX 4090/A6000 (24+ GB)

• Máxima calidad: A100 de 80 GB 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

Inicio 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 la API habilitada y banderas extra de rendimiento:

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

Máximo rendimiento (24+ GB de 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. Supervisar el inicio

docker logs -f sd-forge

Busca:

Running on local URL:  http://0.0.0.0:7860

El inicio suele tardar entre 2 y 5 minutos la primera vez.

6. Acceder a la interfaz web

Tu URL http_pub de CLORE.AI para el puerto 7860:

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

7. Añadir modelos

Método 1: descargar mediante CivitAI en la interfaz web

• Ve a Extensiones → Instaladas → Modelos (algunas versiones)

• O usa el descargador por URL en Configuración

Método 2: descargar directamente en el servidor

# Descargar el 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: CLI de HuggingFace

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 mediante la interfaz web

1. Abre la interfaz de Forge en tu URL de CLORE.AI

2. Selecciona tu modelo en el Punto de control desplegable

3. Introduce el prompt: "retrato cinematográfico de un guerrero, hora dorada, fotografía 8k"

4. Establece el prompt negativo: "borroso, baja resolución, marca de agua, feo"

5. Ajusta ancho/alto: 1024x1024 para SDXL, 512x768 para SD1.5

6. Ajusta pasos: 20–30, CFG: 7

7. Haz clic en Generar

Ejemplo 2: Generación FLUX

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

1. Selecciona el punto de control FLUX (flux1-dev.safetensors)

2. En Forge, selecciona el adecuado Unet y VAE si son archivos separados

3. Introduce el prompt (no se necesita prompt negativo):

   Un paisaje impresionante al atardecer, montañas reflejadas en un lago prístino,
   fotorealista, ultra detallado, fotografía profesional

4. Pasos: 20, CFG: 1.0 (FLUX usa un CFG más bajo)

5. Muestreador: Euler o DPM++ 2M

Ejemplo 3: Generación guiada por ControlNet

1. Instala la extensión ControlNet (si no está preinstalada):

   • Ve a Extensiones → Disponibles → Cargar desde

   • Busca "ControlNet" e instálalo

2. Descarga los modelos ControlNet en /root/sd-forge/models/ControlNet/

3. En txt2img, despliega ControlNet la sección

4. Sube la imagen de referencia (pose, profundidad, bordes Canny)

5. Selecciona el preprocesador y el modelo que coincidan con tu tipo de referencia

6. Genera — la salida sigue la estructura de referencia

Ejemplo 4: Uso de la API

Con --api bandera, Forge expone una API REST:

import requests
import base64
import io
from PIL import Image

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

# Texto a imagen
payload = {
    "prompt": "un sereno jardín japonés con flores de cerezo, 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()

# Guarda 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 ciberpunk de noche, luces de neón, lluvia", "ciberpunk"),
    ("bosque antiguo, niebla mística, arte de fantasía", "fantasía"),
    ("diseño minimalista de logotipo, formas geométricas, fondo blanco", "logo"),
    ("retrato de un viejo marinero, rostro curtido, pintura al óleo", "retrato"),
]

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 clave de CLI

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

Configuraciones específicas de Forge

Forge añade un Forge panel en la interfaz con:

• Unet de Forge: Selecciona el backend de optimización (predeterminado, bnb, etc.)

• Compilación de Torch de Diffusers: Actívala para una generación un 20-30% más rápida (la primera ejecución compila)

• Pesos de GPU: Cuánto mantener en la GPU frente a la CPU

---

Consejos de rendimiento

1. Usa xFormers para un 20-30% menos de VRAM

--xformers

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

2. Optimizador de VRAM de Forge

Forge gestiona automáticamente la VRAM mejor que A1111. Solo usa la --medvram-sdxl bandera para SDXL en GPUs de 8-12 GB y deja que se encargue del resto.

3. Habilita la compilación de Torch (Ampere+)

En la pestaña Forge de la interfaz, activa Compilación de Torch de Diffusers. 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/muestreador

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. Usa Tile VAE para resoluciones de 2K+

Para resoluciones ultraaltas (2048×2048+), activa VAE en mosaico en la pestaña SD para evitar errores de VAE OOM.

6. Procesa por lotes localmente con la API

En lugar de generar uno a la vez en la interfaz, usa la API con batch_size para un mayor rendimiento:

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

---

Solución de problemas

Problema: imágenes negras o verdes

Problema de precisión de VAE. Añade la bandera:

--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. Reduce la resolución de la imagen

4. --lowvram (último recurso, muy lento)

Problema: las extensiones no cargan

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

Después instálalo desde la pestaña Extensiones de la interfaz.

Problema: el arranque tarda demasiado

Es normal en la primera ejecución — se calculan PyTorch y los hashes del modelo. Los inicios posteriores son más rápidos.

docker logs -f sd-forge  # Ver el progreso

Problema: no puedes acceder a la interfaz desde el navegador

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

• Añade --listen a CLI_ARGS

• Verifica que el puerto 7860 esté en la lista de puertos de tu pedido de CLORE.AI

Problema: el modelo no aparece en el desplegable

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

---

Enlaces

• GitHub (Forge)

• GitHub (base A1111)

• Docker Hub (nykk3)

• CivitAI (Modelos)

• Modelos FLUX

• Marketplace de CLORE.AI

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Producción	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Gran escala	A100 80GB	bare metal

💡 Todos los ejemplos de esta guía pueden desplegarse en Clore.ai servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.