InvokeAI

Ejecuta InvokeAI, la caja de herramientas profesional de Stable Diffusion con lienzo basado en nodos en las GPU de Clore.ai

InvokeAI es un conjunto de herramientas de nivel profesional para Stable Diffusion que cuenta con un avanzado editor tipo lienzo basado en nodos, soporte completo para SDXL/SD1.5/SD2.x, ControlNet, IP-Adapter, gestión de LoRA y una interfaz web pulida. Está diseñado para artistas y profesionales creativos que necesitan control preciso sobre su flujo de trabajo de generación de imágenes. Las GPU de alto VRAM de CLORE.AI permiten ejecutar SDXL a resolución completa con múltiples ControlNets simultáneamente.

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	12 GB	32 GB+
VRAM	6 GB	12 GB+
Disco	40 GB	200 GB+
GPU	NVIDIA GTX 1060 6GB+	RTX 3090, RTX 4090, A100

Para SDXL (1024×1024) sin compromisos, se recomienda 12 GB de VRAM. Para SD1.5 (512×512 o 768×768), 6 GB de VRAM son suficientes. Más VRAM = mayor resolución, generación más rápida y más ControlNets simultáneamente.

Despliegue rápido en CLORE.AI

Imagen Docker: ghcr.io/invoke-ai/invokeai:latest

Puertos: 22/tcp, 9090/http

Variables de entorno:

Variable	Ejemplo	Descripción
INVOKEAI_ROOT	/invokeai	Directorio raíz para modelos y salidas

Configuración paso a paso

1. Alquila un servidor GPU en CLORE.AI

Visita CLORE.AI Marketplace y busca:

• Trabajo creativo económico: RTX 3080/3090 (10–24 GB VRAM)

• SDXL profesional: RTX 4090 (24 GB VRAM)

• Calidad máxima: A100 80GB — ejecuta múltiples modelos simultáneamente

2. Conéctate por SSH a tu servidor

ssh -p <PORT> root@<SERVER_IP>

3. Crea la estructura de directorios de InvokeAI

mkdir -p /root/invokeai

4. Descarga la imagen Docker de InvokeAI

docker pull ghcr.io/invoke-ai/invokeai:latest

5. Lanza InvokeAI

Lanzamiento básico:

docker run -d \
  --name invokeai \
  --gpus all \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -e INVOKEAI_ROOT=/invokeai \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090

Con root personalizado y recursos aumentados:

docker run -d \
  --name invokeai \
  --gpus all \
  --shm-size 8g \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -v /root/models:/root/models \
  -e INVOKEAI_ROOT=/invokeai \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090

Con GPU específica (servidor multi-GPU):

docker run -d \
  --name invokeai \
  --gpus '"device=0"' \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -e INVOKEAI_ROOT=/invokeai \
  -e CUDA_VISIBLE_DEVICES=0 \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090

6. Espera a la inicialización

docker logs -f invokeai

Busca: Uvicorn ejecutándose en http://0.0.0.0:9090

7. Acceso vía proxy HTTP de CLORE.AI

Abre tu panel de CLORE.AI y encuentra el http_pub URL para el puerto 9090:

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

Esto abre la interfaz web completa de InvokeAI en tu navegador.

8. Descarga tu primer modelo

En la UI de InvokeAI:

1. Haz clic Administrador de modelos (icono de cubo en la barra lateral izquierda)

2. Haz clic Agregar modelo → HuggingFace

3. Introduce el ID del modelo (p. ej., stabilityai/stable-diffusion-xl-base-1.0)

4. Haz clic Agregar modelo

O descarga directamente desde CivitAI:

1. Ve a Administrador de modelos → Agregar modelo → URL

2. Pega la URL de descarga de CivitAI

3. Establece el tipo de modelo (Checkpoint, LoRA, etc.)

---

Ejemplos de uso

Ejemplo 1: Generación básica de imagen vía UI web

1. Abre InvokeAI en tu URL http_pub de CLORE.AI

2. Haz clic Texto a imagen en el selector de flujo de trabajo

3. Introduce un prompt: "un majestuoso dragón posado en una montaña de cristal, arte digital, 4k"

4. Establece prompt negativo: "borroso, baja calidad, marca de agua"

5. Establece la resolución a 1024x1024 (SDXL) o 512x512 (SD1.5)

6. Haz clic Invocar

Ejemplo 2: Usando el lienzo basado en nodos

El editor de flujos de trabajo es la característica distintiva de InvokeAI:

1. Haz clic Flujos de trabajo en la navegación superior

2. Haz clic Nuevo flujo de trabajo

3. Agregar nodos: Texto → Imagen, conectar a Guardar imagen

4. Agrega un ControlNet nodo para generación guiada:

   • Clic derecho → Agregar nodo → ControlNet

   • Conecta tu imagen de referencia

   • Selecciona procesador: Canny, Profundidad, Pose, etc.

5. Haz clic Invocar para ejecutar la canalización completa

Ejemplo 3: Uso de LoRA

1. Descarga una LoRA desde CivitAI (vía Administrador de modelos → importación por URL)

2. En el panel de generación, busca LoRA sección

3. Haz clic + y selecciona tu LoRA

4. Establece el peso (0.5–1.0 típico)

5. Añade la palabra de activación al prompt (listada en la página del modelo en CivitAI)

Prompt de ejemplo con activador LoRA:

retrato de una mujer, <lora:detail-tweaker:0.8>, hiperrealista, iluminación de estudio

Ejemplo 4: Usando IP-Adapter para transferencia de estilo

1. Activa IP-Adapter en el panel de generación

2. Sube una imagen de estilo de referencia

3. Establece el peso (0.5 = influencia sutil, 1.0 = influencia fuerte)

4. Genera con cualquier prompt — la salida coincidirá con el estilo de referencia

Ejemplo 5: Uso de la API (sin interfaz)

InvokeAI expone una API REST para uso programático:

import requests
import time
import base64

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

# Lista modelos disponibles
models = requests.get(f"{BASE_URL}/api/v1/models").json()
print("Modelos disponibles:", [m["name"] for m in models.get("items", [])])

# Encolar una generación
payload = {
    "batch": {
        "graph": {
            "nodes": {
                "text_encoder": {
                    "type": "compel",
                    "id": "text_encoder",
                    "prompt": "una ciudad futurista al atardecer, fotorrealista",
                },
                "noise": {
                    "type": "noise",
                    "id": "noise",
                    "width": 1024,
                    "height": 1024,
                    "seed": 42,
                },
                "denoise_latents": {
                    "type": "denoise_latents",
                    "id": "denoise_latents",
                    "steps": 30,
                    "cfg_scale": 7.5,
                    "scheduler": "dpmpp_2m",
                },
                "l2i": {
                    "type": "l2i",
                    "id": "l2i",
                },
            },
            "edges": [],
        }
    }
}

# Más simple: usa la API de cola
response = requests.post(f"{BASE_URL}/api/v1/queue/default/enqueue_batch", json=payload)
print(response.status_code)

---

Configuración

Archivo de configuración invokeai.yaml

Ubicado en /root/invokeai/invokeai.yaml:

InvokeAI:
  Servidor web:
    host: 0.0.0.0
    port: 9090
    allow_origins: []
    
  Características:
    esrgan: true          # escalado ESRGAN
    internet_available: true
    
  Memoria/Rendimiento:
    ram: 12.0             # RAM máxima para la caché de modelos (GB)
    vram: 0.25            # Fracción de VRAM para la caché de modelos
    lazy_offload: true    # Descargar modelos a CPU cuando no estén en uso
    
  Rutas:
    models_path: /invokeai/models
    db_path: /invokeai/databases/invokeai.db
    outdir: /invokeai/outputs

Configuración recomendada por GPU

RTX 3090 / 4090 (24 GB VRAM):

Memoria/Rendimiento:
  ram: 24.0
  vram: 0.5   # Mantener 50% para el modelo activo
  lazy_offload: false  # No descargar — suficiente VRAM

RTX 3080 (10 GB VRAM):

Memoria/Rendimiento:
  ram: 16.0
  vram: 0.25
  lazy_offload: true

GPUs más pequeñas (6-8 GB VRAM):

Memoria/Rendimiento:
  ram: 8.0
  vram: 0.1
  lazy_offload: true

---

Consejos de rendimiento

1. Usa SDXL-Turbo o SDXL-Lightning para generación rápida

En lugar de SDXL base (25–50 pasos), usa:

• SDXL-Turbo: 1–4 pasos, generación en tiempo real

• SDXL-Lightning: 4–8 pasos, calidad casi SDXL

Descargar vía Administrador de modelos → HuggingFace:

• stabilityai/sdxl-turbo

• ByteDance/SDXL-Lightning

2. Elige el programador correcto

Scheduler	Calidad	Velocidad	Mejor para
euler_a	Bueno	Rápido	Uso general
dpmpp_2m	Excelente	Rápido	Fotorrealista
dpmpp_2m_sde	Excelente	Medio	Alto detalle
ddim	Bueno	Rápido	Retoque/Inpainting
lms	Bueno	Rápido	Estilos artísticos

3. Habilita la optimización de memoria xFormers

InvokeAI la habilita automáticamente cuando está disponible. Verifica en los logs:

xFormers está disponible

4. Usa caché de modelos

Mantén tus modelos más usados en la caché. En invokeai.yaml:

ram: 32.0  # Más grande = más modelos en caché

5. Usa tiled para altas resoluciones

Para imágenes más grandes de lo que permite tu VRAM (p. ej., 2048×2048 en GPU de 12 GB):

• Usa VAE en mosaicos en el editor de flujos de trabajo

• O genera a 1024×1024 y luego amplía con ESRGAN

---

Solución de problemas

Problema: "CUDA out of memory"

RuntimeError: CUDA out of memory

Soluciones:

1. Reducir resolución (1024→768 o 512)

2. Reducir tamaño de lote a 1

3. Habilitar lazy offloading en invokeai.yaml

4. Usar un modelo más pequeño (SD1.5 en lugar de SDXL)

Problema: UI web no accesible

# Comprueba si el contenedor está en ejecución
docker ps | grep invokeai

# Comprueba los logs por errores
docker logs invokeai 2>&1 | tail -50

# Verifica el mapeo de puertos
docker port invokeai

Asegúrate de que el puerto 9090 esté listado en la configuración de puertos de tu orden en CLORE.AI.

Problema: la descarga del modelo falla dentro del contenedor

# Descargar manualmente vía exec
docker exec -it invokeai bash
cd /invokeai/models/main
wget "https://civitai.com/api/download/models/XXX" -O mymodel.safetensors

Problema: Generación lenta (< 1 it/s)

• Comprueba la utilización de la GPU: docker exec -it invokeai nvidia-smi

• Asegúrate de que xFormers esté habilitado en los logs

• Prueba euler_a scheduler (el más rápido)

Problema: Imágenes negras/rotas

Normalmente es un problema del VAE. Prueba:

1. Administrador de modelos → Editar modelo → Cambiar VAE a sdxl-vae-fp16-fix

2. O añade --fp32-vae flag

Problema: El contenedor no arranca

docker logs invokeai
# Común: el puerto 9090 ya está en uso
# Solución:
docker stop $(docker ps -q --filter "publish=9090")
docker start invokeai

---

Enlaces

• GitHub

• Documentación

• Docker Hub / GHCR

• CivitAI (Modelos)

• CLORE.AI Marketplace

---

Recomendaciones de GPU de 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.