Connect with us
Cómo configurar ComfyUI con Hermes Agent: guía completa y detallada Cómo configurar ComfyUI con Hermes Agent: guía completa y detallada

Audio

Cómo configurar ComfyUI con Hermes Agent: guía completa y detallada

Published

3 meses ago

on

Aprende a instalar, configurar y ejecutar ComfyUI con Hermes Agent en local o en la nube, con ejemplos detallados para generación de imágenes, audio y video. Incluye optimización de recursos (RAM + VRAM), trabajo en lotes, parámetros avanzados y solución de problemas comunes en Windows, macOS y Linux.

Introducción: ¿por qué ComfyUI y Hermes Agent?

ComfyUI se ha convertido en una de las herramientas más potentes para trabajar con modelos de difusión estable, gracias a su enfoque basado en nodos, que permite crear flujos de trabajo personalizados y complejos. A diferencia de otras interfaces como Automatic1111 o Stable Diffusion WebUI, ComfyUI ofrece:

  • flexibilidad total: puedes conectar nodos de manera ilimitada para crear procesos únicos.
  • eficiencia: optimizado para usar menos recursos y generar resultados más rápidos.
  • escalabilidad: ideal para trabajar en lotes o integrar con otros sistemas mediante APIs.
  • comunidad activa: constante desarrollo de nuevos nodos y modelos.

La integración con Hermes Agent lleva esto un paso más allá, permitiendo:

  • Automatizar workflows complejos mediante scripts.
  • Ejecutar generaciones en segundo plano o en servidores remotos.
  • Integrar ComfyUI con otras herramientas de IA o pipelines de datos.

Esta guía está diseñada para llevarte desde la instalación básica hasta el dominio avanzado de ComfyUI, incluyendo:

  • Preparación del entorno en Windows, macOS y Linux.
  • Configuración de hardware y optimización de recursos (RAM + VRAM).
  • Generación de imágenes, audio y video con ejemplos prácticos.
  • Trabajo en lotes y gestión de colas.
  • Solución de problemas comunes.

Requisitos previos: preparación del entorno

Antes de instalar ComfyUI, es fundamental preparar tu sistema correctamente. Esta sección te guía paso a paso para cada sistema operativo.

Requisitos generales

  • Hardware mínimo recomendado:
    • GPU: NVIDIA con 6 GB VRAM (para SD1.5) o 8 GB VRAM (para SDXL/Flux).
    • RAM: 16 GB (mínimo para trabajo básico), 32 GB o más (recomendado para lotes o modelos grandes).
    • Almacenamiento: 50 GB libres (para modelos, nodos y dependencias).
    • Sistema operativo: Windows 10/11, macOS (Apple Silicon o Intel), o Linux (Ubuntu 20.04+ recomendado).
  • Software requerido:

Preparación en Windows

Windows requiere atención especial debido a las diferencias en las rutas de archivos y la gestión de entornos. Sigue estos pasos para preparar tu sistema:

1. Instalación de Python

  1. Descarga la última versión de Python desde python.org. Asegúrate de seleccionar la versión para Windows.
  2. Durante la instalación:
    • Marca la casilla “Add Python to PATH” (esto es crítico para ejecutar comandos desde cualquier directorio).
    • Selecciona “Install for all users” si tienes permisos de administrador.
    • Elige la opción “Customize installation” y asegúrate de que pip esté seleccionado.
  3. Verifica la instalación abriendo PowerShell o CMD y ejecutando: 
    python --version

    Deberías ver algo como Python 3.10.11 o Python 3.11.5.

  4. Si el comando no funciona, reinicia tu computadora y prueba nuevamente.

2. Instalación de Git (opcional, pero recomendado)

Git es necesario si planeas instalar ComfyUI manualmente o contribuir al proyecto.

  1. Descarga Git desde git-scm.com.
  2. Durante la instalación, acepta las opciones predeterminadas.
  3. Verifica la instalación con: 
    git --version

3. Configuración del entorno para ComfyUI

ComfyUI requiere que los comandos se ejecuten desde su directorio de instalación. Aquí te explicamos cómo hacerlo correctamente:

  1. Crea una carpeta para ComfyUI, por ejemplo: 
    mkdir C:\ComfyUI
  2. Navega a esta carpeta: 
    cd C:\ComfyUI
  3. Todos los comandos relacionados con ComfyUI (como python scripts\hardware_check.py) deben ejecutarse desde aquí.

4. Solución de problemas comunes en Windows

  • Error: “python is not recognized”:
    • Causa: Python no está en el PATH.
    • Solución:
      1. Abre el Panel de Control > Sistema > Configuración avanzada del sistema > Variables de entorno.
      2. En Variables del sistema, busca Path y haz clic en Editar.
      3. Añade la ruta donde está instalado Python (ej: C:\Users\TuUsuario\AppData\Local\Programs\Python\Python310\ y C:\Users\TuUsuario\AppData\Local\Programs\Python\Python310\Scripts\).
      4. Guarda los cambios y reinicia la terminal.
  • Error: “No such file or directory”:
    • Causa: No estás en el directorio correcto o la ruta del script es incorrecta.
    • Solución:
      1. Verifica que estás en el directorio de ComfyUI (cd C:\ComfyUI).
      2. Usa la ruta relativa correcta. En Windows, las barras son invertidas: scripts\hardware_check.py.
      3. Si el archivo no existe, asegúrate de haber descargado ComfyUI correctamente.

Preparación en macOS

macOS, especialmente con chips Apple Silicon (M1/M2), requiere pasos específicos para garantizar la compatibilidad.

1. Instalación de Python

  1. Abre Terminal.
  2. Verifica si Python 3 ya está instalado: 
    python3 --version

    Si no lo está, instálalo con Homebrew: 

    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    brew install python
  3. Verifica la instalación: 
    python3 --version

2. Instalación de Git

Git suele estar preinstalado en macOS. Verifica con: 

git --version

Si no está instalado, instálalo con Homebrew: 

brew install git

3. Configuración del entorno para ComfyUI

  1. Crea una carpeta para ComfyUI: 
    mkdir ~/ComfyUI
  2. Navega a esta carpeta: 
    cd ~/ComfyUI
  3. Todos los comandos de ComfyUI deben ejecutarse desde aquí.

4. Solución de problemas comunes en macOS

  • Error: “command not found: python3”:
    • Causa: Python 3 no está instalado o no está en el PATH.
    • Solución:
      1. Instala Python 3 con Homebrew como se indicó anteriormente.
      2. Verifica que el PATH esté configurado correctamente. Homebrew suele manejar esto automáticamente.
  • Error: “No module named ‘torch’”:
    • Causa: PyTorch no está instalado o no es compatible con tu hardware.
    • Solución:
      1. Instala PyTorch para macOS con Apple Silicon: 
        pip3 install torch torchvision torchaudio
      2. Si usas un Mac con Intel, usa: 
        pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cpu

Preparación en Linux

Linux (especialmente Ubuntu) es el entorno más compatible con ComfyUI, pero requiere conocimientos básicos de terminal.

1. Instalación de Python y dependencias

  1. Abre una terminal.
  2. Actualiza el sistema: 
    sudo apt update && sudo apt upgrade -y
  3. Instala Python 3 y pip: 
    sudo apt install -y python3 python3-pip python3-venv
  4. Verifica la instalación: 
    python3 --version

2. Instalación de Git

sudo apt install -y git

3. Instalación de controladores de GPU (NVIDIA)

Si tienes una GPU NVIDIA, instala los controladores y CUDA:

  1. Verifica tu modelo de GPU: 
    lspci | grep -i nvidia
  2. Instala los controladores recomendados para tu GPU. Para Ubuntu: 
    sudo ubuntu-drivers autoinstall
  3. Instala CUDA Toolkit (versión 12.1 recomendada para ComfyUI): 
    sudo apt install -y nvidia-cuda-toolkit

    o sigue las instrucciones oficiales de NVIDIA: descargar CUDA.

  4. Verifica la instalación: 
    nvidia-smi

    Deberías ver información sobre tu GPU y los controladores.

4. Configuración del entorno para ComfyUI

  1. Crea una carpeta para ComfyUI: 
    mkdir ~/ComfyUI
  2. Navega a esta carpeta: 
    cd ~/ComfyUI
  3. Todos los comandos de ComfyUI deben ejecutarse desde aquí.

5. Solución de problemas comunes en Linux

  • Error: “python3: command not found”:
    • Causa: Python 3 no está instalado.
    • Solución: 
      sudo apt install -y python3
  • Error: “No CUDA-capable device is detected”:
    • Causa: Los controladores de NVIDIA o CUDA no están instalados correctamente.
    • Solución:
      1. Verifica que los controladores estén instalados: 
        nvidia-smi
      2. Instala CUDA Toolkit como se indicó anteriormente.
      3. Reinicia el sistema.

¿Local o Comfy Cloud? Cómo decidir la mejor opción

La elección entre instalación local y Comfy Cloud depende de tus recursos, objetivos y nivel de experiencia. Aquí te detallamos todo lo que necesitas saber para tomar la mejor decisión.

Comparación detallada: Local vs. Comfy Cloud

Instalación local:

Advertisement
  • Ventajas:
    • Control total: puedes personalizar cada aspecto de la instalación y los workflows.
    • Sin limitaciones de uso: no dependes de cuotas o suscripciones (excepto por el hardware).
    • Privacidad: todos los datos y generaciones quedan en tu máquina.
    • Rendimiento: si tienes una GPU potente, la generación será más rápida que en la nube.
    • Acceso a todos los modelos: puedes descargar e instalar cualquier modelo compatible.
  • Desventajas:
    • Requisitos de hardware: necesitas una GPU con suficiente VRAM y RAM para modelos avanzados.
    • Configuración compleja: requiere conocimientos técnicos para instalar y mantener el entorno.
    • Espacio en disco: los modelos y dependencias pueden ocupar decenas de GB.
  • Recomendado para:
    • Usuarios con GPU NVIDIA/AMD con 8 GB VRAM o más.
    • Desarrolladores o usuarios avanzados que necesitan personalización.
    • Proyectos que requieren privacidad o control total.

Comfy Cloud:

  • Ventajas:
    • Sin requisitos de hardware: funciona en cualquier dispositivo con conexión a internet.
    • Fácil de usar: no requiere instalación ni configuración.
    • Acceso a GPUs potentes: puedes usar GPUs de alta gama (hasta 24 GB VRAM) sin invertir en hardware.
    • Mantenimiento cero: no necesitas actualizar modelos o dependencias.
  • Desventajas:
    • Limitaciones en el plan gratuito: no permite ejecución de workflows vía API.
    • Coste: los planes pagados pueden ser caros para uso intensivo.
    • Latencia: la generación puede ser más lenta debido a la conexión a internet.
    • Privacidad: tus datos y generaciones están en servidores externos.
  • Recomendado para:
    • Usuarios sin GPU o con hardware limitado.
    • Principiantes que quieren probar ComfyUI sin complicaciones.
    • Proyectos puntuales o experimentación.

Cómo verificar tu hardware para instalación local

Antes de decidirte por la instalación local, es crucial verificar si tu hardware cumple con los requisitos mínimos. El script hardware_check.py de ComfyUI te ayuda a hacerlo.

Pasos para ejecutar el verificador de hardware

En Windows:
  1. Abre PowerShell o CMD.
  2. Navega al directorio de ComfyUI (ej: C:\ComfyUI): 
    cd C:\ComfyUI
  3. Ejecuta el script: 
    python scripts\hardware_check.py

    Nota: Usa barra invertida (\) en Windows.

En macOS:
  1. Abre Terminal.
  2. Navega al directorio de ComfyUI (ej: ~/ComfyUI): 
    cd ~/ComfyUI
  3. Ejecuta el script: 
    python3 scripts/hardware_check.py
En Linux:
  1. Abre una terminal.
  2. Navega al directorio de ComfyUI (ej: ~/ComfyUI): 
    cd ~/ComfyUI
  3. Ejecuta el script: 
    python3 scripts/hardware_check.py

Interpretación de los resultados

El script devolverá uno de los siguientes veredictos:

  • ok:
    • Significado: tu hardware cumple con los requisitos para ejecutar modelos avanzados como SDXL o Flux.
    • Requisitos típicos:
      • GPU NVIDIA con 8 GB VRAM o más.
      • Apple Silicon M1/M2 con 32 GB de RAM unificada.
    • Recomendación: proceder con instalación local.
  • marginal:
    • Significado: tu hardware puede ejecutar SD1.5 sin problemas, pero modelos como SDXL o Flux pueden ser lentos o requerir ajustes.
    • Requisitos típicos:
      • GPU NVIDIA con 6 GB VRAM.
      • Apple Silicon M1 con 16 GB de RAM unificada.
    • Recomendación:
      • Usa SD1.5 o modelos ligeros.
      • Reduce la resolución o el número de pasos en modelos grandes.
      • Combina RAM y VRAM para mejorar el rendimiento.
  • cloud:
    • Significado: tu hardware no cumple con los requisitos mínimos para ejecutar ComfyUI localmente.
    • Requisitos típicos:
      • Sin GPU.
      • GPU con menos de 6 GB VRAM.
      • Apple Silicon con menos de 16 GB de RAM unificada.
      • Mac con chip Intel.
    • Recomendación: usar Comfy Cloud o actualizar tu hardware.

Si el veredicto es cloud pero aún quieres intentar la instalación local, el script mostrará advertencias sobre posibles errores de memoria (Out of Memory). En estos casos, puedes:

  • Forzar la instalación local con comfy --skip-prompt install --cpu (pero la generación será muy lenta).
  • Optimizar el uso de RAM y VRAM como se explica en la sección de optimización de recursos.

Optimización de recursos: cómo combinar RAM y VRAM

ComfyUI puede configurarse para usar tanto la VRAM de tu GPU como la RAM de tu sistema, lo que es especialmente útil cuando trabajas con modelos grandes o en lotes. Esta sección te explica cómo hacerlo y qué configuraciones son óptimas para diferentes escenarios.

¿Por qué combinar RAM y VRAM?

La VRAM (memoria de la GPU) es mucho más rápida que la RAM (memoria del sistema), pero es limitada. Cuando la VRAM se agota, ComfyUI puede usar la RAM como respaldo, aunque esto puede ralentizar el proceso. Sin embargo, en muchos casos, es preferible a no poder ejecutar el modelo en absoluto.

Casos de uso donde esto es útil:

  • Ejecutar modelos grandes (como SDXL o Flux) en GPUs con VRAM limitada (ej: 6 GB).
  • Trabajar con lotes de imágenes o videos.
  • Evitar errores de Out of Memory (OOM) al generar imágenes en alta resolución.
  • Experimentar con modelos que requieren más memoria de la disponible en tu GPU.

Cómo configurar el uso de RAM y VRAM

La configuración se realiza editando el archivo config.json en el directorio de ComfyUI. Si este archivo no existe, puedes crearlo.

Pasos para editar config.json

En Windows:
  1. Abre el Bloc de notas o cualquier editor de texto (recomendado: Notepad++ o VS Code).
  2. Navega al directorio de ComfyUI y abre el archivo config.json. Si no existe, créalo.
  3. Añade o modifica las siguientes líneas: 
    {
  "use_cpu": false,
  "use_ram": true,
  "ram_size": 32,
  "vram_size": 8
}
  4. Guarda el archivo.
  5. Reinicia el servidor de ComfyUI para que los cambios surtan efecto.
En macOS/Linux:
  1. Abre una terminal.
  2. Navega al directorio de ComfyUI: 
    cd ~/ComfyUI
  3. Edita el archivo config.json con un editor como nano o vim: 
    nano config.json
  4. Añade o modifica las siguientes líneas: 
    {
  "use_cpu": false,
  "use_ram": true,
  "ram_size": 32,
  "vram_size": 8
}
  5. Guarda el archivo (Ctrl+O en nano, luego Ctrl+X para salir).
  6. Reinicia el servidor de ComfyUI.

Explicación de los parámetros

  • use_cpu:
    • Descripción: si se establece en true, ComfyUI usará la CPU para generaciones (no recomendado, muy lento).
    • Valor recomendado: false.
  • use_ram:
    • Descripción: activa el uso de RAM como respaldo cuando la VRAM se agota.
    • Valor recomendado: true si tienes suficiente RAM.
  • ram_size:
    • Descripción: cantidad de RAM en GB que ComfyUI puede usar.
    • Valor recomendado:
      • 16-32 GB: para modelos como SDXL.
      • 8-16 GB: para SD1.5 o modelos ligeros.
  • vram_size:
    • Descripción: cantidad de VRAM en GB que ComfyUI puede usar.
    • Valor recomendado:
      • 6-8 GB: para SD1.5.
      • 8-12 GB: para SDXL o Flux.

Configuraciones recomendadas según tu hardware

Escenario 1: GPU con 6 GB VRAM + 16 GB RAM

Configuración: 

{
  "use_cpu": false,
  "use_ram": true,
  "ram_size": 8,
  "vram_size": 6
}

Casos de uso:

  • Generación de imágenes con SD1.5 en resoluciones de hasta 768×768.
  • Trabajo con lotes pequeños (4-8 imágenes a la vez).

Limitaciones:

  • SDXL o Flux pueden ser lentos o fallar.
  • Resoluciones mayores a 1024×1024 pueden causar errores de memoria.

Escenario 2: GPU con 8 GB VRAM + 32 GB RAM

Configuración: 

{
  "use_cpu": false,
  "use_ram": true,
  "ram_size": 16,
  "vram_size": 8
}

Casos de uso:

  • Generación de imágenes con SDXL en resoluciones de hasta 1024×1024.
  • Trabajo con lotes de 8-16 imágenes a la vez.
  • Generación de videos cortos (hasta 5 segundos).

Limitaciones:

  • Flux o modelos muy grandes pueden requerir ajustes adicionales.
  • Generación de audio puede ser lenta.

Escenario 3: GPU con 12 GB VRAM + 64 GB RAM

Configuración: 

{
  "use_cpu": false,
  "use_ram": true,
  "ram_size": 32,
  "vram_size": 12
}

Casos de uso:

Advertisement
  • Generación de imágenes con SDXL o Flux en resoluciones de hasta 1536×1536.
  • Trabajo con lotes grandes (32+ imágenes a la vez).
  • Generación de videos de hasta 10 segundos con buena calidad.
  • Generación de audio con modelos avanzados.

Limitaciones:

  • Poco o nada, este hardware es ideal para la mayoría de tareas en ComfyUI.

Escenario 4: Sin GPU (solo CPU) + 32 GB RAM

Configuración: 

{
  "use_cpu": true,
  "use_ram": true,
  "ram_size": 24,
  "vram_size": 0
}

Casos de uso:

  • Generación de imágenes muy pequeñas (256×256) con SD1.5.
  • Pruebas básicas o aprendizaje.

Limitaciones:

  • La generación será extremadamente lenta (puede tardar minutos por imagen).
  • No es recomendable para uso serio.

Consejos para optimizar el uso de memoria

  • Reduce la resolución:
    • Si estás cerca del límite de memoria, reduce la resolución de la imagen (ej: de 1024×1024 a 768×768).
    • Usa el parámetro --resolution en tus workflows.
  • Disminuye el número de pasos:
    • Para SD1.5, 20-30 pasos suelen ser suficientes.
    • Para SDXL, 30-40 pasos son un buen equilibrio entre calidad y rendimiento.
  • Usa modelos más ligeros:
    • SD1.5 requiere menos VRAM que SDXL o Flux.
    • Prueba con versiones “pruned” (podadas) de los modelos, que ocupan menos memoria.
  • Limita el tamaño de los lotes:
    • Si trabajas en lotes, reduce el número de imágenes generadas en paralelo (--parallel).
    • Ejemplo: --parallel 2 en lugar de --parallel 4.
  • Cierra otras aplicaciones:
    • Cierra programas que consuman RAM o VRAM (ej: navegadores, juegos, software de edición).
  • Usa el modo –lowvram:
    • Algunos modelos permiten un modo de bajo consumo de VRAM. Consulta la documentación del modelo.

Rutas de instalación: elige la que mejor se adapte a ti

A continuación, te detallamos las 5 rutas de instalación disponibles, con instrucciones específicas para cada sistema operativo.

Ruta A: Comfy Cloud (sin instalación local)

Perfecta para usuarios sin GPU o que buscan una solución lista para usar. Comfy Cloud ofrece un entorno preconfigurado con acceso a GPUs potentes en la nube.

Ventajas y desventajas

Ventajas:

  • No requiere hardware potente.
  • Acceso a GPUs de alta gama (hasta 24 GB VRAM).
  • Sin configuración local.
  • Mantenimiento cero.

Desventajas:

  • El plan gratuito tiene limitaciones (no permite ejecución de workflows vía API).
  • Los planes pagados pueden ser caros para uso intensivo.
  • Latencia de red puede afectar la velocidad.

Pasos para configurar Comfy Cloud

  1. Regístrate en Comfy Cloud.
  2. Inicia sesión en platform.comfy.org.
  3. Genera una API key:
    1. Ve a la sección API Keys en tu perfil.
    2. Haz clic en Create New Key.
    3. Copia la clave generada (tendrá un formato como comfyui-xxxxxxxxxxxx).
  4. Configura la variable de entorno con tu API key:
    • En Windows (PowerShell): 
      $env:COMFY_CLOUD_API_KEY="comfyui-xxxxxxxxxxxx"

      Nota: Esta variable solo durará mientras la sesión de PowerShell esté abierta. Para hacerla permanente, usa: 

      [System.Environment]::SetEnvironmentVariable("COMFY_CLOUD_API_KEY", "comfyui-xxxxxxxxxxxx", "User")
    • En macOS/Linux (Terminal): 
      export COMFY_CLOUD_API_KEY="comfyui-xxxxxxxxxxxx"

      Nota: Para hacerla permanente, añade esta línea a tu archivo ~/.bashrc o ~/.zshrc: 

      echo 'export COMFY_CLOUD_API_KEY="comfyui-xxxxxxxxxxxx"' >> ~/.bashrc

      Luego ejecuta: 

      source ~/.bashrc
  5. Ejecuta workflows usando el parámetro --host: 
    comfy --host https://cloud.comfy.org prompt --workflow workflow.json

Ruta B: ComfyUI Desktop (Windows/macOS)

Instalador de un clic para usuarios no técnicos (versión Beta). Ideal para quienes buscan una solución sencilla y rápida.

Requisitos

  • Windows 10/11 (64-bit) con GPU NVIDIA.
  • macOS 11+ (Big Sur) o superior con Apple Silicon (M1/M2).
  • Al menos 10 GB de espacio en disco.

Pasos para Windows

  1. Descarga el instalador desde ComfyUI Desktop para Windows.
  2. Ejecuta el instalador y sigue las instrucciones.
  3. Una vez instalado, abre ComfyUI Desktop desde el menú Inicio.
  4. El instalador configurará automáticamente el entorno, incluyendo Python y las dependencias necesarias.

Pasos para macOS

  1. Descarga el instalador desde ComfyUI para macOS.
  2. Abre el archivo descargado (será un .dmg).
  3. Arrastra ComfyUI a la carpeta de Aplicaciones.
  4. Abre ComfyUI desde la carpeta de Aplicaciones.

Nota: Linux no es compatible con ComfyUI Desktop. Si usas Linux, ve a la Ruta D o E.

Ruta C: ComfyUI Portable (solo Windows)

Para usuarios que prefieren portabilidad y no quieren instalar el software de forma permanente. Esta opción es ideal para probar ComfyUI sin afectar tu sistema.

Advertisement

Requisitos

  • Windows 10/11 (64-bit).
  • GPU NVIDIA con controladores actualizados.
  • Al menos 20 GB de espacio en disco.

Pasos para instalar ComfyUI Portable

  1. Descarga el archivo ZIP desde GitHub releases. Busca el archivo ComfyUI_windows_portable.zip.
  2. Extrae el archivo ZIP en una carpeta de tu elección (ej: C:\ComfyUI_Portable).
  3. Navega a la carpeta extraída: 
    cd C:\ComfyUI_Portable
  4. Ejecuta el script correspondiente a tu hardware:
    • Para GPUs NVIDIA: 
      run_nvidia_gpu.bat
    • Para GPUs AMD o CPU: 
      run_cpu.bat
  5. La primera vez que lo ejecutes, ComfyUI descargará las dependencias necesarias. Esto puede tardar varios minutos.
  6. Una vez completado, se abrirá una ventana del navegador con la interfaz de ComfyUI.

Actualizar ComfyUI Portable

  1. Navega a la carpeta de ComfyUI Portable: 
    cd C:\ComfyUI_Portable
  2. Ejecuta el script de actualización: 
    update\update_comfyui_stable.bat

Ventajas y desventajas

Ventajas:

  • No requiere instalación permanente.
  • Fácil de mover o eliminar.
  • Ideal para probar ComfyUI.

Desventajas:

  • No está optimizado para uso avanzado.
  • Las actualizaciones pueden ser más lentas.

Ruta D: comfy-cli (recomendado para agentes y usuarios avanzados)

La opción más flexible y recomendada para integración con Hermes Agent. Permite un control total sobre la instalación y configuración, y es compatible con todos los sistemas operativos.

Ventajas

  • Instalación y gestión simplificadas mediante línea de comandos.
  • Compatibilidad con todos los sistemas operativos.
  • Ideal para automatización y integración con otros sistemas.
  • Soporte para múltiples instancias de ComfyUI.

Pasos para instalar comfy-cli

En Windows:
  1. Abre PowerShell como administrador.
  2. Instala pipx (recomendado para gestionar herramientas de Python): 
    python -m pip install --user pipx
    python -m pipx ensurepath

    Nota: Si recibes un error de permisos, ejecuta PowerShell como administrador.

  3. Instala comfy-cli: 
    pipx install comfy-cli

    Si pipx no funciona, usa pip directamente: 

    pip install --user comfy-cli
  4. Verifica la instalación: 
    comfy --version
  5. Desactiva las analíticas no interactivas: 
    comfy --skip-prompt tracking disable
  6. Instala ComfyUI según tu hardware:
    • Para NVIDIA (CUDA): 
      comfy --skip-prompt install --nvidia
    • Para AMD (ROCm, solo Linux): 
      comfy --skip-prompt install --amd
    • Para Apple Silicon (MPS): 
      comfy --skip-prompt install --m-series
    • Para CPU (lento, no recomendado): 
      comfy --skip-prompt install --cpu
    • Para NVIDIA con resolución rápida de dependencias (usando uv): 
      comfy --skip-prompt install --nvidia --fast-deps
  7. Inicia el servidor de ComfyUI:
    • En segundo plano (puerto 8188): 
      comfy launch --background
    • En un puerto personalizado (ej: 8190) accesible en la red local: 
      comfy launch -- --listen 0.0.0.0 --port 8190
  8. Verifica que el servidor esté funcionando: 
    curl -s http://127.0.0.1:8188/system_stats

    Deberías ver un JSON con información del sistema.

En macOS:
  1. Abre Terminal.
  2. Instala pipx (recomendado): 
    brew install pipx
    pipx ensurepath
  3. Instala comfy-cli: 
    pipx install comfy-cli

    Si prefieres usar pip: 

    pip install --user comfy-cli
  4. Verifica la instalación: 
    comfy --version
  5. Desactiva las analíticas: 
    comfy --skip-prompt tracking disable
  6. Instala ComfyUI:
    • Para Apple Silicon (M1/M2): 
      comfy --skip-prompt install --m-series
    • Para CPU: 
      comfy --skip-prompt install --cpu
  7. Inicia el servidor: 
    comfy launch --background
En Linux:
  1. Abre una terminal.
  2. Instala pipx: 
    sudo apt install -y pipx
    pipx ensurepath
  3. Instala comfy-cli: 
    pipx install comfy-cli

    o 

    pip install --user comfy-cli
  4. Verifica la instalación: 
    comfy --version
  5. Desactiva las analíticas: 
    comfy --skip-prompt tracking disable
  6. Instala ComfyUI:
    • Para NVIDIA (CUDA): 
      comfy --skip-prompt install --nvidia
    • Para AMD (ROCm): 
      comfy --skip-prompt install --amd
    • Para CPU: 
      comfy --skip-prompt install --cpu
  7. Inicia el servidor: 
    comfy launch --background

Ruta E: instalación manual (avanzado)

Para usuarios con hardware especializado (Ascend NPU, Cambricon MLU, Intel Arc) o que necesitan un control absoluto sobre el entorno. Esta ruta es la más flexible pero también la más compleja.

Requisitos

  • Conocimientos básicos de línea de comandos.
  • Git instalado.
  • Python 3.10 o superior.
  • Controladores de GPU actualizados (si aplica).

Pasos para instalación manual

En Windows:
  1. Abre PowerShell o CMD.
  2. Clona el repositorio de ComfyUI: 
    git clone https://github.com/comfyanonymous/ComfyUI.git
  3. Navega al directorio de ComfyUI: 
    cd ComfyUI
  4. Crea un entorno virtual: 
    python -m venv venv
  5. Activa el entorno virtual: 
    .\venv\Scripts\activate
  6. Instala PyTorch según tu hardware:
    • Para NVIDIA (CUDA 12.1): 
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130
    • Para CPU: 
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
  7. Instala las dependencias de ComfyUI: 
    pip install -r requirements.txt
  8. Inicia ComfyUI: 
    python main.py
En macOS:
  1. Abre Terminal.
  2. Instala dependencias del sistema (si usas Homebrew): 
    brew install git python
  3. Clona el repositorio: 
    git clone https://github.com/comfyanonymous/ComfyUI.git
  4. Navega al directorio: 
    cd ComfyUI
  5. Crea un entorno virtual: 
    python3 -m venv venv
  6. Activa el entorno: 
    source venv/bin/activate
  7. Instala PyTorch para Apple Silicon: 
    pip install torch torchvision torchaudio
  8. Instala las dependencias: 
    pip install -r requirements.txt
  9. Inicia ComfyUI: 
    python main.py
En Linux:
  1. Abre una terminal.
  2. Instala dependencias del sistema (Ubuntu/Debian): 
    sudo apt update && sudo apt install -y git python3 python3-venv python3-pip
  3. Clona el repositorio: 
    git clone https://github.com/comfyanonymous/ComfyUI.git
  4. Navega al directorio: 
    cd ComfyUI
  5. Crea un entorno virtual: 
    python3 -m venv venv
  6. Activa el entorno: 
    source venv/bin/activate
  7. Instala PyTorch según tu GPU:
    • Para NVIDIA (CUDA 12.1): 
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130
    • Para AMD (ROCm): 
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.6
    • Para CPU: 
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
  8. Instala las dependencias: 
    pip install -r requirements.txt
  9. Inicia ComfyUI: 
    python main.py

Post-instalación: descarga de modelos y nodos personalizados

Una vez instalado ComfyUI, el siguiente paso es descargar los modelos y nodos que necesitarás para empezar a generar contenido. Esta sección te guía a través del proceso, con ejemplos detallados y comandos específicos para cada sistema operativo.

Descarga de modelos base

Los modelos son archivos que contienen los pesos de las redes neuronales y determinan el estilo y la calidad de las generaciones. ComfyUI soporta una amplia variedad de modelos, desde versiones ligeras como SD1.5 hasta modelos avanzados como SDXL o Flux.

Modelos recomendados para empezar

Aquí tienes una lista de modelos populares, sus características y casos de uso:

1. Stable Diffusion 1.5 (SD1.5)
  • Tamaño: ~2-4 GB.
  • Requisitos mínimos:
    • GPU: 4 GB VRAM.
    • RAM: 8 GB.
  • Casos de uso:
    • Ideal para principiantes.
    • Generación rápida de imágenes.
    • Pruebas y experimentación.
  • Versiones populares:
    • v1-5-pruned-emaonly.safetensors: versión podada (más ligera).
    • v1-5-full-emaonly.safetensors: versión completa (mejor calidad).
  • Comando de descarga: 
    comfy model download --url "https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors" --relative-path models/checkpoints
2. Stable Diffusion XL (SDXL)
  • Tamaño: ~6-7 GB.
  • Requisitos mínimos:
    • GPU: 8 GB VRAM (recomendado 12 GB para mejor rendimiento).
    • RAM: 16 GB.
  • Casos de uso:
    • Generación de imágenes de alta calidad.
    • Proyectos profesionales.
    • Estilos artísticos complejos.
  • Versiones populares:
    • sd_xl_base_1.0.safetensors: modelo base.
    • sd_xl_refiner_1.0.safetensors: refiner para mejorar detalles.
  • Comando de descarga: 
    comfy model download --url "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors" --relative-path models/checkpoints
3. Flux (Dev y Schnel)
  • Tamaño: ~12-14 GB.
  • Requisitos mínimos:
    • GPU: 12 GB VRAM (recomendado).
    • RAM: 32 GB.
  • Casos de uso:
    • Generación de imágenes con estilo artístico avanzado.
    • Proyectos que requieren alta calidad y detalle.
  • Versiones populares:
    • flux1-dev-fp8.safetensors: versión para desarrollo.
    • flux1-schnel-fp8.safetensors: versión rápida.
  • Comando de descarga (Flux Dev): 
    comfy model download --url "https://huggingface.co/Comfy-Org/flux1-dev/resolve/main/flux1-dev-fp8.safetensors" --relative-path models/checkpoints
4. Modelos LoRA y Embeddings

Además de los modelos base, puedes descargar LoRAs (adaptadores de bajo rango) y Embeddings para personalizar tus generaciones.

  • LoRA:
    • Tamaño: ~10-200 MB.
    • Casos de uso:
      • Añadir estilos específicos (ej: “anime”, “fotorealista”).
      • Personalizar personajes o objetos.
    • Ejemplo de descarga: 
      comfy model download --url "https://huggingface.co/sayakpaul/sd-model-finetuned-lora-t4/resolve/main/pytorch_lora_weights.safetensors" --relative-path models/loras
  • Embeddings:
    • Tamaño: ~1-10 MB.
    • Casos de uso:
      • Mejorar la coherencia de conceptos (ej: “manos”, “ojos”).
      • Añadir estilos o texturas específicas.
    • Ejemplo de descarga: 
      comfy model download --url "https://huggingface.co/embeddings/negative_hand/resolve/main/negative_hand.pt" --relative-path models/embeddings

Dónde se guardan los modelos

Por defecto, los modelos descargados con comfy model download se guardan en las siguientes carpetas dentro del directorio de ComfyUI:

  • models/checkpoints: modelos base (SD1.5, SDXL, Flux).
  • models/loras: adaptadores LoRA.
  • models/embeddings: embeddings.
  • models/vae: modelos VAE (para decodificación de imágenes).
  • models/controlnet: modelos ControlNet.

Cómo cambiar la ubicación de los modelos:

  1. Edita el archivo config.json en el directorio de ComfyUI.
  2. Añade o modifica las rutas según tus preferencias: 
    {
  "checkpoint_dir": "C:/MisModelos/checkpoints",
  "lora_dir": "C:/MisModelos/loras",
  "embedding_dir": "C:/MisModelos/embeddings"
}
  3. Reinicia el servidor de ComfyUI para que los cambios surtan efecto.

Cómo ejecutar los comandos de descarga

Los comandos de descarga de modelos deben ejecutarse desde el directorio de instalación de ComfyUI. Asegúrate de estar en el directorio correcto antes de ejecutarlos.

En Windows:
  1. Abre PowerShell o CMD.
  2. Navega al directorio de ComfyUI: 
    cd C:\ComfyUI
  3. Ejecuta el comando de descarga. Por ejemplo, para SDXL: 
    comfy model download --url "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors" --relative-path models/checkpoints
En macOS/Linux:
  1. Abre una terminal.
  2. Navega al directorio de ComfyUI: 
    cd ~/ComfyUI
  3. Ejecuta el comando de descarga: 
    comfy model download --url "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors" --relative-path models/checkpoints

Instalación de nodos personalizados

Los nodos personalizados amplían las capacidades de ComfyUI, permitiéndote añadir funcionalidades como generación de video, control de calidad, herramientas de preprocesamiento, y más. Esta sección te muestra cómo instalar y gestionar nodos, con ejemplos de los más útiles.

Nodos esenciales para empezar

Aquí tienes una lista de nodos populares, sus funciones y comandos de instalación:

1. comfyui-impact-pack
  • Descripción: paquete de utilidades esenciales que incluye nodos para ajustes de color, máscaras, efectos especiales y herramientas de posprocesamiento.
  • Casos de uso:
    • Ajustar colores y contrastes.
    • Aplicar efectos como desenfoque o nitidez.
    • Trabajar con máscaras y selecciones.
  • Comando de instalación: 
    comfy node install comfyui-impact-pack
2. comfyui-animatediff-evolved
  • Descripción: permite generar videos a partir de imágenes usando técnicas de animación basadas en AnimateDiff.
  • Casos de uso:
    • Crear videos a partir de una secuencia de imágenes.
    • Añadir movimiento a imágenes estáticas.
    • Generar animaciones con estilos artísticos.
  • Requisitos:
    • Modelo AnimateDiff descargado (ej: mm_sd_v15_v2.ckpt).
  • Comando de instalación: 
    comfy node install comfyui-animatediff-evolved
  • Comando para descargar el modelo AnimateDiff: 
    comfy model download --url "https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt" --relative-path models/animatediff
3. comfyui-controlnet-aux
  • Descripción: preprocesadores para ControlNet, útiles para guiar la generación de imágenes con poses, bordes o estructuras específicas.
  • Casos de uso:
    • Generar imágenes con poses específicas (ej: usando una imagen de referencia).
    • Controlar la composición de la imagen (ej: líneas de contorno).
    • Aplicar estilos basados en imágenes de referencia.
  • Comando de instalación: 
    comfy node install comfyui-controlnet-aux
4. comfyui-essentials
  • Descripción: herramientas comunes como nodos de texto, imágenes, utilidades de carga y guardado, y más.
  • Casos de uso:
    • Cargar y guardar imágenes.
    • Añadir texto a imágenes.
    • Realizar operaciones básicas de manipulación de imágenes.
  • Comando de instalación: 
    comfy node install comfyui-essentials
5. comfyui-audio
  • Descripción: nodos para generación y procesamiento de audio usando modelos como AudioLDM.
  • Casos de uso:
    • Generar sonidos ambientales.
    • Crear efectos de audio.
    • Convertir texto a audio.
  • Requisitos:
    • Modelo AudioLDM descargado.
  • Comando de instalación: 
    comfy node install comfyui-audio
  • Comando para descargar AudioLDM: 
    comfy model download --url "https://huggingface.co/cvssp/audioldm/resolve/main/audioldm-s-full-v2.ckpt" --relative-path models/audio
6. comfyui-manager
  • Descripción: gestor de nodos y modelos para ComfyUI, con interfaz gráfica.
  • Casos de uso:
    • Instalar, actualizar y eliminar nodos desde la interfaz de ComfyUI.
    • Gestionar modelos y dependencias.
  • Comando de instalación: 
    comfy node install comfyui-manager

Cómo ejecutar los comandos de instalación de nodos

Los comandos de instalación de nodos deben ejecutarse desde el directorio de instalación de ComfyUI. Asegúrate de estar en el directorio correcto antes de ejecutarlos.

En Windows:
  1. Abre PowerShell o CMD.
  2. Navega al directorio de ComfyUI: 
    cd C:\ComfyUI
  3. Instala un nodo, por ejemplo: 
    comfy node install comfyui-impact-pack
En macOS/Linux:
  1. Abre una terminal.
  2. Navega al directorio de ComfyUI: 
    cd ~/ComfyUI
  3. Instala un nodo: 
    comfy node install comfyui-impact-pack

Actualizar y gestionar nodos

Mantener tus nodos actualizados es importante para garantizar la compatibilidad y el acceso a las últimas funcionalidades.

Actualizar todos los nodos

Para actualizar todos los nodos instalados, ejecuta: 

comfy node update all
Actualizar un nodo específico

Para actualizar un nodo en particular:

Advertisement
comfy node update comfyui-impact-pack
Listar nodos instalados

Para ver una lista de todos los nodos instalados: 

comfy node list
Desinstalar un nodo

Para eliminar un nodo que ya no necesitas: 

comfy node uninstall comfyui-impact-pack
Instalar dependencias de un workflow

Si tienes un workflow en formato JSON y quieres instalar todas sus dependencias automáticamente: 

comfy node install-deps --workflow=workflows/mi_workflow.json

Parámetros de calidad: cómo optimizar tus generaciones

La calidad de las imágenes, videos o audio generados con ComfyUI depende en gran medida de los parámetros que configures. Esta sección te explica en detalle los parámetros más importantes, cómo afectan el resultado y qué valores son óptimos para diferentes casos de uso.

Parámetros para generación de imágenes

Parámetros básicos

1. Prompt (indicación)
  • Descripción: texto que describe lo que quieres generar. Es el parámetro más importante, ya que guía al modelo hacia el resultado deseado.
  • Consejos para un buen prompt:
    • Sé específico: en lugar de "un paisaje", usa "un paisaje montañoso al atardecer con un lago, estilo fotorrealista, colores cálidos, alta resolución".
    • Usa términos descriptivos: incluye detalles sobre el estilo, la composición, los colores y la iluminación.
    • Ordena por importancia: coloca los conceptos más importantes al principio del prompt.
    • Usa pesos: para dar más importancia a ciertos términos, usa (término:1.2) para aumentar su peso o (término:0.8) para disminuirlo.
  • Ejemplos:
    • Mal: "una persona".
    • Mejor: "una mujer joven con cabello largo y oscuro, sonriendo, estilo fotorrealista, iluminación suave".
    • Avanzado: "(una mujer joven:1.3) con (cabello largo y oscuro:1.2), sonriendo, estilo fotorrealista, iluminación suave desde la izquierda, fondo desenfocado, alta resolución, 8k".
2. Negative Prompt (indicación negativa)
  • Descripción: texto que describe lo que NO quieres en la imagen. Ayuda a evitar resultados no deseados.
  • Consejos:
    • Incluye términos que describan defectos comunes (ej: "borroso", "pixelado", "baja calidad").
    • Evita características no deseadas (ej: "manos deformadas", "dedos extra").
    • Usa términos genéricos para evitar estilos no deseados (ej: "anime" si quieres fotorrealismo).
  • Ejemplos:
    • Básico: "borroso, pixelado, baja calidad".
    • Avanzado: "borroso, pixelado, baja calidad, deformado, texto, manos mal dibujadas, dedos extra, ojos asimétricos, iluminación pobre".
3. Steps (pasos)
  • Descripción: número de iteraciones que el modelo realizará para generar la imagen. Más pasos generalmente significan mayor calidad, pero también más tiempo de generación.
  • Valores recomendados:
    • SD1.5:
      • 20-30 pasos: buena calidad para la mayoría de casos.
      • 40-50 pasos: alta calidad, ideal para imágenes detalladas.
    • SDXL:
      • 30-40 pasos: equilibrio entre calidad y velocidad.
      • 50-60 pasos: máxima calidad para proyectos profesionales.
    • Flux:
      • 40-60 pasos: recomendado para este modelo.
  • Impacto en el rendimiento:
    • Cada paso adicional aumenta el tiempo de generación en un ~5-10%.
    • Más de 60 pasos rara vez mejora significativamente la calidad.
4. CFG Scale (escala de guía)
  • Descripción: qué tan estrictamente el modelo sigue el prompt. Valores altos significan mayor adherencia al prompt, pero menos creatividad.
  • Valores recomendados:
    • 7-10: equilibrio entre creatividad y adherencia al prompt.
    • 12-15: adherencia estricta al prompt (ideal para proyectos específicos).
    • 5-7: mayor creatividad (el modelo puede desviarse más del prompt).
  • Ejemplos:
    • CFG 7: el modelo interpretará el prompt de manera más libre.
    • CFG 12: el modelo seguirá el prompt de manera más estricta.
5. Seed (semilla)
  • Descripción: número que determina la aleatoriedad de la generación. El mismo seed + prompt = misma imagen.
  • Valores:
    • -1: semilla aleatoria (cada generación será única).
    • Cualquier número positivo (ej: 123456789): semilla fija (para reproducir resultados).
  • Casos de uso:
    • Seed aleatorio: para generar variaciones únicas.
    • Seed fijo: para reproducir una imagen que te gustó.

Parámetros avanzados

1. Sampler (muestreador)
  • Descripción: algoritmo usado para generar la imagen. Cada sampler tiene sus propias características en términos de velocidad, calidad y estilo.
  • Samplers populares:
    Sampler Velocidad Calidad Estilo Recomendado para
    Euler a Rápido Buena Versátil Uso general
    DPM++ 2M Karras Medio Alta Detallado SDXL, imágenes detalladas
    UniPC Medio Alta Equilibrado Uso general, buen equilibrio
    DDIM Rápido Media Consistente Generación rápida
    DPM++ SDE Karras Lento Muy alta Artístico Imágenes artísticas, alta calidad
  • Recomendaciones:
    • Para SD1.5: Euler a o UniPC.
    • Para SDXL: DPM++ 2M Karras o DPM++ SDE Karras.
    • Para Flux: DPM++ 2M Karras.
2. Resolución (ancho x alto)
  • Descripción: tamaño de la imagen generada en píxeles.
  • Valores recomendados:
    Modelo Resolución mínima Resolución recomendada Resolución máxima
    SD1.5 512×512 768×768 1024×1024 (con 8 GB VRAM)
    SDXL 1024×1024 1024×1024 1536×1536 (con 12 GB VRAM)
    Flux 1024×1024 1024×1024 2048×2048 (con 16 GB VRAM)
  • Consejos:
    • Si tu GPU tiene VRAM limitada, usa resoluciones más bajas.
    • Para imágenes en formato apaisado (ej: 16:9), usa resoluciones como 1152×768 o 1536×1024.
    • Puedes usar el parámetro --resolution en tus workflows.
3. Denoise (desruido)
  • Descripción: en img2img o inpainting, qué tan fuerte es la modificación aplicada a la imagen original. Valores altos significan más cambios.
  • Valores recomendados:
    • 0.3-0.5: cambios sutiles (ideal para retoques).
    • 0.6-0.8: cambios moderados.
    • 0.9-1.0: cambios significativos (la imagen resultante será muy diferente a la original).
  • Ejemplo de uso:
    • Si quieres mejorar una foto sin cambiarla demasiado: denoise: 0.4.
    • Si quieres transformar una imagen (ej: de día a noche): denoise: 0.8.

Ejemplos detallados de generación de imágenes

En esta sección, te proporcionamos ejemplos prácticos y detallados para generar imágenes con diferentes estilos, resoluciones y parámetros. Cada ejemplo incluye el prompt, los parámetros y el comando para ejecutarlo.

Ejemplo 1: Retrato fotorrealista

Objetivo: generar un retrato de alta calidad con estilo fotorrealista.

Advertisement

Workflow (JSON): 

{
  "prompt": "(una mujer joven:1.3) con (cabello largo y castaño:1.2), sonriendo, ojos azules, estilo fotorrealista, iluminación suave desde la izquierda, fondo desenfocado, alta resolución, 8k, detalles en la piel y el cabello",
  "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, manos mal dibujadas, dedos extra, ojos asimétricos, iluminación pobre, sombras duras",
  "steps": 40,
  "CFG_scale": 10,
  "seed": 123456789,
  "sampler": "DPM++ 2M Karras",
  "resolution": "1024x1024",
  "model": "SDXL"
}

Comando para ejecutar en Windows:

  1. Abre PowerShell o CMD.
  2. Navega al directorio de ComfyUI: 
    cd C:\ComfyUI
  3. Ejecuta el comando: 
    python scripts\run_workflow.py ^
  --workflow workflows\retrato_fotorrealista.json ^
  --args "{'prompt': '(una mujer joven:1.3) con (cabello largo y castaño:1.2), sonriendo, ojos azules, estilo fotorrealista, iluminación suave desde la izquierda, fondo desenfocado, alta resolución, 8k, detalles en la piel y el cabello', 'negative_prompt': 'borroso, pixelado, baja calidad, deformado, texto, manos mal dibujadas, dedos extra, ojos asimétricos, iluminación pobre, sombras duras', 'steps': 40, 'CFG_scale': 10, 'seed': 123456789, 'sampler': 'DPM++ 2M Karras', 'resolution': '1024x1024'}" ^
  --output-dir .\outputs\retratos

    Nota: En Windows, usa ^ para continuar el comando en una nueva línea.

Comando para ejecutar en macOS/Linux:

  1. Abre una terminal.
  2. Navega al directorio de ComfyUI: 
    cd ~/ComfyUI
  3. Ejecuta el comando: 
    python3 scripts/run_workflow.py \
  --workflow workflows/retrato_fotorrealista.json \
  --args '{
    "prompt": "(una mujer joven:1.3) con (cabello largo y castaño:1.2), sonriendo, ojos azules, estilo fotorrealista, iluminación suave desde la izquierda, fondo desenfocado, alta resolución, 8k, detalles en la piel y el cabello",
    "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, manos mal dibujadas, dedos extra, ojos asimétricos, iluminación pobre, sombras duras",
    "steps": 40,
    "CFG_scale": 10,
    "seed": 123456789,
    "sampler": "DPM++ 2M Karras",
    "resolution": "1024x1024"
  }' \
  --output-dir ./outputs/retratos

Dónde se guarda el resultado: en la carpeta outputs/retratos dentro del directorio de ComfyUI.

Notas y consejos:

  • Modelo: SDXL es ideal para retratos debido a su capacidad para capturar detalles finos.
  • Sampler: DPM++ 2M Karras es uno de los mejores para SDXL en términos de calidad.
  • Steps: 40 pasos son suficientes para obtener buena calidad sin exceso de tiempo.
  • CFG Scale: 10 es un buen equilibrio entre adherencia al prompt y creatividad.
  • Prompt: Se usan pesos (:1.3) para dar más importancia a ciertos términos (ej: “mujer joven” y “cabello castaño”).

Ejemplo 2: Paisaje fantástico en alta resolución

Objetivo: crear un paisaje de fantasía con elementos mágicos y alta calidad.

Workflow (JSON): 

{
  "prompt": "paisaje de fantasía épica, montañas flotantes con cascadas, castillo en el cielo, dragones volando, nubes algodonosas, estilo arte conceptual, colores vibrantes y saturados, iluminación dramática, alta resolución, 8k, detalles en las texturas",
  "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, elementos modernos, estilo realista, colores apagados",
  "steps": 50,
  "CFG_scale": 12,
  "seed": -1,
  "sampler": "DPM++ SDE Karras",
  "resolution": "1536x1024",
  "model": "SDXL"
}

Comando para ejecutar en Windows:

Advertisement
python scripts\run_workflow.py ^
  --workflow workflows\paisaje_fantastico.json ^
  --args "{'prompt': 'paisaje de fantasía épica, montañas flotantes con cascadas, castillo en el cielo, dragones volando, nubes algodonosas, estilo arte conceptual, colores vibrantes y saturados, iluminación dramática, alta resolución, 8k, detalles en las texturas', 'negative_prompt': 'borroso, pixelado, baja calidad, deformado, texto, elementos modernos, estilo realista, colores apagados', 'steps': 50, 'CFG_scale': 12, 'seed': -1, 'sampler': 'DPM++ SDE Karras', 'resolution': '1536x1024'}" ^
  --output-dir .\outputs\paisajes

Comando para ejecutar en macOS/Linux: 

python3 scripts/run_workflow.py \
  --workflow workflows/paisaje_fantastico.json \
  --args '{
    "prompt": "paisaje de fantasía épica, montañas flotantes con cascadas, castillo en el cielo, dragones volando, nubes algodonosas, estilo arte conceptual, colores vibrantes y saturados, iluminación dramática, alta resolución, 8k, detalles en las texturas",
    "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, elementos modernos, estilo realista, colores apagados",
    "steps": 50,
    "CFG_scale": 12,
    "seed": -1,
    "sampler": "DPM++ SDE Karras",
    "resolution": "1536x1024"
  }' \
  --output-dir ./outputs/paisajes

Dónde se guarda el resultado: en la carpeta outputs/paisajes.

Notas y consejos:

  • Resolución: 1536×1024 es ideal para paisajes panorámicos (relación 3:2).
  • Steps: 50 pasos para asegurar detalles en elementos complejos como dragones o castillos.
  • CFG Scale: 12 para adherencia estricta al prompt (importante para paisajes detallados).
  • Sampler: DPM++ SDE Karras es excelente para imágenes artísticas y detalladas.
  • Seed: -1 para generar una imagen única cada vez.

Ejemplo 3: Concepto de producto futurista

Objetivo: diseñar un dispositivo tecnológico con estilo cyberpunk.

Workflow (JSON): 

{
  "prompt": "dispositivo futurista, diseño elegante y aerodinámico, pantalla holográfica flotante, materiales metálicos y vidrio, estilo cyberpunk, iluminación azul y morada, detalles en los bordes, alta resolución, 8k, render 3D",
  "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, diseño antiguo, colores apagados, iluminación pobre",
  "steps": 30,
  "CFG_scale": 8,
  "seed": 987654321,
  "sampler": "Euler a",
  "resolution": "1024x1024",
  "model": "SD1.5"
}

Comando para ejecutar en Windows:

Advertisement
python scripts\run_workflow.py ^
  --workflow workflows\concepto_producto.json ^
  --args "{'prompt': 'dispositivo futurista, diseño elegante y aerodinámico, pantalla holográfica flotante, materiales metálicos y vidrio, estilo cyberpunk, iluminación azul y morada, detalles en los bordes, alta resolución, 8k, render 3D', 'negative_prompt': 'borroso, pixelado, baja calidad, deformado, texto, diseño antiguo, colores apagados, iluminación pobre', 'steps': 30, 'CFG_scale': 8, 'seed': 987654321, 'sampler': 'Euler a', 'resolution': '1024x1024'}" ^
  --output-dir .\outputs\conceptos

Comando para ejecutar en macOS/Linux: 

python3 scripts/run_workflow.py \
  --workflow workflows/concepto_producto.json \
  --args '{
    "prompt": "dispositivo futurista, diseño elegante y aerodinámico, pantalla holográfica flotante, materiales metálicos y vidrio, estilo cyberpunk, iluminación azul y morada, detalles en los bordes, alta resolución, 8k, render 3D",
    "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, diseño antiguo, colores apagados, iluminación pobre",
    "steps": 30,
    "CFG_scale": 8,
    "seed": 987654321,
    "sampler": "Euler a",
    "resolution": "1024x1024"
  }' \
  --output-dir ./outputs/conceptos

Dónde se guarda el resultado: en la carpeta outputs/conceptos.

Notas y consejos:

  • Modelo: SD1.5 es suficiente para conceptos de productos, ya que no requiere tanta VRAM como SDXL.
  • Steps: 30 pasos son suficientes para diseños no demasiado complejos.
  • CFG Scale: 8 para un equilibrio entre creatividad y adherencia al prompt.
  • Sampler: Euler a es rápido y versátil para este tipo de generaciones.

Generación de video con ComfyUI

ComfyUI permite generar videos a partir de imágenes usando nodos como comfyui-animatediff-evolved. Esta sección te guía a través del proceso, desde la instalación de los nodos necesarios hasta la generación de un video completo.

Requisitos previos para generación de video

  • Nodo comfyui-animatediff-evolved instalado.
  • Modelo AnimateDiff descargado (ej: mm_sd_v15_v2.ckpt).
  • Modelo base (SD1.5 o SDXL) para generar los fotogramas.
  • Herramienta para combinar fotogramas en video (ej: FFmpeg).

Instalación de dependencias para video

1. Instalar el nodo AnimateDiff

Ejecuta el siguiente comando desde el directorio de ComfyUI: 

comfy node install comfyui-animatediff-evolved

2. Descargar el modelo AnimateDiff

Descarga el modelo mm_sd_v15_v2.ckpt: 

comfy model download --url "https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt" --relative-path models/animatediff

3. Instalar FFmpeg (para combinar fotogramas en video)

FFmpeg es una herramienta de línea de comandos para procesar video. Es necesaria para combinar los fotogramas generados en un video.

Advertisement
En Windows:
  1. Descarga FFmpeg desde ffmpeg.org.
  2. Extrae el archivo ZIP y añade la carpeta bin al PATH de tu sistema.
  3. Verifica la instalación abriendo CMD y ejecutando: 
    ffmpeg -version
En macOS:

Instala FFmpeg con Homebrew: 

brew install ffmpeg
En Linux:

Instala FFmpeg con apt: 

sudo apt install -y ffmpeg

Parámetros clave para generación de video

La generación de video en ComfyUI implica crear una secuencia de imágenes (fotogramas) y luego combinarlas en un video. Estos son los parámetros más importantes:

1. frame_count (número de fotogramas)

  • Descripción: número de imágenes que compondrán el video.
  • Valores recomendados:
    • 16-24 fotogramas: para videos cortos (1-2 segundos a 12 FPS).
    • 36-48 fotogramas: para videos de 3-4 segundos a 12 FPS.
    • 60+ fotogramas: para videos más largos (5+ segundos).
  • Impacto en el rendimiento:
    • Más fotogramas = más tiempo de generación y más uso de memoria.
    • Cada fotograma se genera como una imagen individual, por lo que el proceso puede ser lento.

2. fps (fotogramas por segundo)

  • Descripción: número de fotogramas que se mostrarán por segundo en el video final.
  • Valores recomendados:
    • 12 FPS: suficiente para la mayoría de casos (equilibrio entre fluidez y tamaño de archivo).
    • 24 FPS: para videos más fluidos (requiere más fotogramas y recursos).
    • 30 FPS: para alta calidad (requiere hardware potente).

3. motion_scale (escala de movimiento)

  • Descripción: qué tan pronunciado es el movimiento entre fotogramas.
  • Valores recomendados:
    • 1.0-1.5: movimiento sutil (ideal para paisajes o escenas estáticas con pequeños cambios).
    • 2.0-3.0: movimiento moderado (para escenas con acción).
    • 4.0+: movimiento drástico (puede generar resultados poco naturales).

4. context_length (longitud del contexto)

  • Descripción: número de fotogramas que el modelo considera para el movimiento. Valores más altos generan movimientos más suaves pero requieren más memoria.
  • Valores recomendados:
    • 16: para videos cortos.
    • 32: para videos más largos con movimientos suaves.

Ejemplo detallado: generación de un video de un atardecer

Objetivo: crear un video de 4 segundos de un atardecer en la playa con olas y nubes en movimiento.

Workflow (JSON): 

{
  "prompt": "atardecer en la playa, olas suaves rompiendo en la orilla, nubes en movimiento, cielo anaranjado y rosado, reflejos en el agua, estilo realista, colores cálidos, alta resolución, 8k",
  "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, elementos modernos, estilo anime",
  "steps": 30,
  "CFG_scale": 10,
  "seed": -1,
  "sampler": "DPM++ 2M Karras",
  "resolution": "1024x576",
  "frame_count": 48,
  "fps": 12,
  "motion_scale": 2.0,
  "context_length": 16,
  "model": "SDXL",
  "animatediff_model": "mm_sd_v15_v2.ckpt"
}

Comando para ejecutar en Windows:

  1. Abre PowerShell o CMD.
  2. Navega al directorio de ComfyUI: 
    cd C:\ComfyUI
  3. Ejecuta el comando: 
    python scripts\run_workflow.py ^
  --workflow workflows\atardecer_video.json ^
  --args "{'prompt': 'atardecer en la playa, olas suaves rompiendo en la orilla, nubes en movimiento, cielo anaranjado y rosado, reflejos en el agua, estilo realista, colores cálidos, alta resolución, 8k', 'negative_prompt': 'borroso, pixelado, baja calidad, deformado, texto, elementos modernos, estilo anime', 'steps': 30, 'CFG_scale': 10, 'seed': -1, 'sampler': 'DPM++ 2M Karras', 'resolution': '1024x576', 'frame_count': 48, 'fps': 12, 'motion_scale': 2.0, 'context_length': 16}" ^
  --output-dir .\outputs\videos\atardecer

Comando para ejecutar en macOS/Linux:

  1. Abre una terminal.
  2. Navega al directorio de ComfyUI: 
    cd ~/ComfyUI
  3. Ejecuta el comando: 
    python3 scripts/run_workflow.py \
  --workflow workflows/atardecer_video.json \
  --args '{
    "prompt": "atardecer en la playa, olas suaves rompiendo en la orilla, nubes en movimiento, cielo anaranjado y rosado, reflejos en el agua, estilo realista, colores cálidos, alta resolución, 8k",
    "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, elementos modernos, estilo anime",
    "steps": 30,
    "CFG_scale": 10,
    "seed": -1,
    "sampler": "DPM++ 2M Karras",
    "resolution": "1024x576",
    "frame_count": 48,
    "fps": 12,
    "motion_scale": 2.0,
    "context_length": 16
  }' \
  --output-dir ./outputs/videos/atardecer

Dónde se guardan los fotogramas: en la carpeta outputs/videos/atardecer, con nombres como frame_0001.png, frame_0002.png, etc.

Cómo combinar los fotogramas en un video:

Advertisement

Una vez generados los fotogramas, usa FFmpeg para crearlos en un video:

En Windows:

ffmpeg -framerate 12 -i .\outputs\videos\atardecer\frame_%04d.png -c:v libx264 -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" .\outputs\videos\atardecer.mp4

En macOS/Linux:

ffmpeg -framerate 12 -i ./outputs/videos/atardecer/frame_%04d.png -c:v libx264 -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" ./outputs/videos/atardecer.mp4

Explicación del comando FFmpeg:

  • -framerate 12: establece 12 FPS (debe coincidir con el fps del workflow).
  • -i frame_%04d.png: indica que los fotogramas tienen nombres como frame_0001.png, frame_0002.png, etc.
  • -c:v libx264: usa el códec de video H.264.
  • -pix_fmt yuv420p: formato de píxeles compatible con la mayoría de reproductores.
  • -vf "scale=...": ajusta las dimensiones para que sean pares (requerido por algunos códecs).
  • atardecer.mp4: nombre del archivo de salida.

Notas y consejos:

  • Resolución: 1024×576 mantiene una relación de aspecto panorámica (16:9), ideal para videos.
  • frame_count: 48 fotogramas a 12 FPS = 4 segundos de video.
  • motion_scale: 2.0 genera un movimiento notable pero natural en las olas y nubes.
  • context_length: 16 ayuda a mantener la coherencia entre fotogramas.
  • Modelo: SDXL es ideal para paisajes detallados.
  • Sampler: DPM++ 2M Karras ofrece buena calidad para SDXL.

Ejemplo detallado: generación de un video de una ciudad futurista

Objetivo: crear un video de 5 segundos de una ciudad futurista con luces neón y movimiento de vehículos.

Workflow (JSON): 

{
  "prompt": "ciudad futurista de noche, rascacielos con luces neón azules y rosadas, calles iluminadas, vehículos voladores, estilo cyberpunk, atmósfera oscura con reflejos de luz, alta resolución, 8k",
  "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, estilo realista, colores apagados",
  "steps": 40,
  "CFG_scale": 12,
  "seed": 1122334455,
  "sampler": "DPM++ SDE Karras",
  "resolution": "1152x768",
  "frame_count": 60,
  "fps": 12,
  "motion_scale": 3.0,
  "context_length": 32,
  "model": "SDXL",
  "animatediff_model": "mm_sd_v15_v2.ckpt"
}

Comando para ejecutar en Windows: 

python scripts\run_workflow.py ^
  --workflow workflows\ciudad_futurista_video.json ^
  --args "{'prompt': 'ciudad futurista de noche, rascacielos con luces neón azules y rosadas, calles iluminadas, vehículos voladores, estilo cyberpunk, atmósfera oscura con reflejos de luz, alta resolución, 8k', 'negative_prompt': 'borroso, pixelado, baja calidad, deformado, texto, estilo realista, colores apagados', 'steps': 40, 'CFG_scale': 12, 'seed': 1122334455, 'sampler': 'DPM++ SDE Karras', 'resolution': '1152x768', 'frame_count': 60, 'fps': 12, 'motion_scale': 3.0, 'context_length': 32}" ^
  --output-dir .\outputs\videos\ciudad_futurista

Comando para combinar los fotogramas en video (Windows):

Advertisement
ffmpeg -framerate 12 -i .\outputs\videos\ciudad_futurista\frame_%04d.png -c:v libx264 -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" .\outputs\videos\ciudad_futurista.mp4

Notas y consejos:

  • Resolución: 1152×768 (relación 16:9) es ideal para videos panorámicos.
  • frame_count: 60 fotogramas a 12 FPS = 5 segundos de video.
  • motion_scale: 3.0 para un movimiento más pronunciado en luces y vehículos.
  • context_length: 32 para mayor coherencia en escenas complejas.
  • Steps: 40 para asegurar detalles en una escena tan detallada.

Generación de audio con ComfyUI

Aunque ComfyUI está principalmente enfocado en imágenes y video, es posible generar audio usando nodos especializados como comfyui-audio. Esta sección te guía a través del proceso, desde la instalación de los nodos necesarios hasta la generación de audio de alta calidad.

Requisitos previos para generación de audio

  • Nodo comfyui-audio instalado.
  • Modelo de audio como AudioLDM descargado.
  • Suficiente RAM (la generación de audio puede consumir varios GB de RAM).

Instalación de dependencias para audio

1. Instalar el nodo de audio

Ejecuta el siguiente comando desde el directorio de ComfyUI: 

comfy node install comfyui-audio

2. Descargar el modelo AudioLDM

Descarga el modelo audioldm-s-full-v2.ckpt: 

comfy model download --url "https://huggingface.co/cvssp/audioldm/resolve/main/audioldm-s-full-v2.ckpt" --relative-path models/audio

Parámetros clave para generación de audio

1. Prompt de audio

  • Descripción: texto que describe el audio que quieres generar. A diferencia de los prompts para imágenes, los prompts de audio deben enfocarse en sonidos, ambientes y texturas sonoras.
  • Consejos:
    • Sé específico con el tipo de sonido (ej: "sonido de lluvia" en lugar de "sonido natural").
    • Incluye detalles sobre el ambiente (ej: "bosque con pájaros").
    • Usa términos descriptivos para el estilo (ej: "relajante", "dramático", "futurista").
  • Ejemplos:
    • Ambiente natural: "sonido de un bosque, pájaros cantando, viento suave entre los árboles, río fluyendo a lo lejos, ambiente tranquilo y relajante".
    • Ciudad futurista: "ciudad futurista de noche, sonidos de vehículos voladores, luces neón, música electrónica de fondo, ambiente cyberpunk".
    • Efectos de sonido: "explosión lejana, eco en una cueva, sonidos de rocas cayendo, ambiente oscuro y misterioso".

2. Duration (duración)

  • Descripción: duración del audio en segundos.
  • Valores recomendados:
    • 5-10 segundos: para pruebas rápidas o sonidos cortos.
    • 20-30 segundos: para generaciones más largas y complejas.
    • 60+ segundos: para proyectos avanzados (requiere más RAM y tiempo).

3. sample_rate (tasa de muestreo)

  • Descripción: calidad del audio en Hz (hercios).
  • Valores recomendados:
    • 16000 Hz: calidad baja (suficiente para pruebas o voz).
    • 44100 Hz: calidad CD (recomendado para la mayoría de casos).
    • 48000 Hz: calidad alta (para proyectos profesionales).

4. negative_prompt (indicación negativa para audio)

  • Descripción: términos que describen lo que NO quieres en el audio.
  • Ejemplos:
    • Básico: "ruido, distorsión, voces humanas".
    • Avanzado: "ruido de fondo, distorsión, voces, música no deseada, sonidos electrónicos".

Ejemplo detallado: generación de un sonido ambiental de bosque

Objetivo: crear un audio de 20 segundos con sonidos de un bosque tranquilo.

Workflow (JSON): 

{
  "prompt": "sonido de un bosque denso, pájaros cantando en diferentes tonos, viento suave moviendo las hojas, río fluyendo a lo lejos, insectos chirriando, ambiente tranquilo y relajante, alta calidad",
  "negative_prompt": "ruido, distorsión, voces humanas, música, sonidos artificiales, tráfico",
  "duration": 20,
  "sample_rate": 44100,
  "model": "audioldm-s-full-v2.ckpt"
}

Comando para ejecutar en Windows:

  1. Abre PowerShell o CMD.
  2. Navega al directorio de ComfyUI: 
    cd C:\ComfyUI
  3. Ejecuta el comando: 
    python scripts\run_workflow.py ^
  --workflow workflows\bosque_audio.json ^
  --args "{'prompt': 'sonido de un bosque denso, pájaros cantando en diferentes tonos, viento suave moviendo las hojas, río fluyendo a lo lejos, insectos chirriando, ambiente tranquilo y relajante, alta calidad', 'negative_prompt': 'ruido, distorsión, voces humanas, música, sonidos artificiales, tráfico', 'duration': 20, 'sample_rate': 44100}" ^
  --output-dir .\outputs\audios

Comando para ejecutar en macOS/Linux:

  1. Abre una terminal.
  2. Navega al directorio de ComfyUI: 
    cd ~/ComfyUI
  3. Ejecuta el comando: 
    python3 scripts/run_workflow.py \
  --workflow workflows/bosque_audio.json \
  --args '{
    "prompt": "sonido de un bosque denso, pájaros cantando en diferentes tonos, viento suave moviendo las hojas, río fluyendo a lo lejos, insectos chirriando, ambiente tranquilo y relajante, alta calidad",
    "negative_prompt": "ruido, distorsión, voces humanas, música, sonidos artificiales, tráfico",
    "duration": 20,
    "sample_rate": 44100
  }' \
  --output-dir ./outputs/audios

Dónde se guarda el resultado: en la carpeta outputs/audios como un archivo WAV (ej: output.wav).

Notas y consejos:

Advertisement
  • sample_rate: 44100 Hz es la calidad estándar para audio (calidad CD).
  • duration: 20 segundos es suficiente para capturar una variedad de sonidos ambientales.
  • negative_prompt: ayuda a evitar ruidos no deseados como voces o música.
  • Modelo: AudioLDM es uno de los modelos más avanzados para generación de audio con IA.

Ejemplo detallado: generación de efectos de sonido futuristas

Objetivo: crear un audio de 15 segundos con sonidos de una nave espacial.

Workflow (JSON): 

{
  "prompt": "sonidos de una nave espacial, motores humeantes, alertas electrónicas, pitidos de control, ambiente futurista, sonidos metálicos, alta calidad, estilo ciencia ficción",
  "negative_prompt": "ruido, distorsión, voces, música, sonidos naturales, tráfico",
  "duration": 15,
  "sample_rate": 48000,
  "model": "audioldm-s-full-v2.ckpt"
}

Comando para ejecutar en Windows: 

python scripts\run_workflow.py ^
  --workflow workflows\nave_espacial_audio.json ^
  --args "{'prompt': 'sonidos de una nave espacial, motores humeantes, alertas electrónicas, pitidos de control, ambiente futurista, sonidos metálicos, alta calidad, estilo ciencia ficción', 'negative_prompt': 'ruido, distorsión, voces, música, sonidos naturales, tráfico', 'duration': 15, 'sample_rate': 48000}" ^
  --output-dir .\outputs\audios

Notas y consejos:

  • sample_rate: 48000 Hz para mayor calidad en efectos de sonido.
  • Prompt: términos como "motores humeantes" y "alertas electrónicas" ayudan a guiar al modelo hacia sonidos específicos.
  • Uso: este tipo de audio es ideal para proyectos de video, juegos o experiencias inmersivas.

Trabajo en lotes: cómo generar múltiples imágenes a la vez

El trabajo en lotes te permite generar múltiples imágenes con un solo comando, lo que es ideal para:

  • Crear variaciones de un mismo prompt.
  • Generar datasets para entrenamiento de modelos.
  • Ahorrar tiempo en proyectos grandes.

Parámetros clave para trabajo en lotes

1. count (cantidad)

  • Descripción: número de imágenes a generar.
  • Valores recomendados:
    • 8-16: para pruebas o variaciones rápidas.
    • 32-64: para datasets pequeños o proyectos medianos.
    • 100+: para datasets grandes (requiere hardware potente).

2. parallel (paralelo)

  • Descripción: número de imágenes a generar simultáneamente.
  • Valores recomendados:
    • 1: para GPUs con menos de 8 GB VRAM.
    • 2-4: para GPUs con 8-12 GB VRAM.
    • 4-8: para GPUs con 16+ GB VRAM.
  • Impacto en el rendimiento:
    • Más procesos en paralelo = más rápido, pero también más uso de VRAM y RAM.
    • Si excedes la VRAM disponible, el sistema puede ralentizarse o fallar.

3. randomize_seed (aleatorizar semilla)

  • Descripción: si se activa, cada imagen tendrá una semilla aleatoria.
  • Valor recomendado: true para obtener variaciones únicas.

Ejemplo detallado: generación de 32 variaciones de un retrato

Objetivo: generar 32 imágenes diferentes de un retrato con estilo fotorrealista.

Comando para ejecutar en Windows:

  1. Abre PowerShell o CMD.
  2. Navega al directorio de ComfyUI: 
    cd C:\ComfyUI
  3. Ejecuta el comando: 
    python scripts\run_batch.py ^
  --workflow workflows\retrato_lote.json ^
  --args "{'prompt': '(una mujer joven:1.3) con (cabello largo:1.2), sonriendo, estilo fotorrealista, iluminación suave, alta resolución', 'negative_prompt': 'borroso, pixelado, baja calidad, deformado, texto, manos mal dibujadas', 'steps': 30, 'CFG_scale': 10, 'sampler': 'DPM++ 2M Karras', 'resolution': '1024x1024'}" ^
  --count 32 --randomize-seed --parallel 4 ^
  --output-dir .\outputs\retratos_lote

Comando para ejecutar en macOS/Linux:

  1. Abre una terminal.
  2. Navega al directorio de ComfyUI: 
    cd ~/ComfyUI
  3. Ejecuta el comando: 
    python3 scripts/run_batch.py \
  --workflow workflows/retrato_lote.json \
  --args '{
    "prompt": "(una mujer joven:1.3) con (cabello largo:1.2), sonriendo, estilo fotorrealista, iluminación suave, alta resolución",
    "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, manos mal dibujadas",
    "steps": 30,
    "CFG_scale": 10,
    "sampler": "DPM++ 2M Karras",
    "resolution": "1024x1024"
  }' \
  --count 32 --randomize-seed --parallel 4 \
  --output-dir ./outputs/retratos_lote

Dónde se guardan los resultados: en la carpeta outputs/retratos_lote, con nombres como image_0001.png, image_0002.png, etc.

Notas y consejos:

Advertisement
  • parallel 4: genera 4 imágenes a la vez (ideal para GPUs con 12 GB VRAM o más).
  • randomize_seed: asegura que cada imagen sea única.
  • count 32: genera 32 imágenes en total.
  • Resolución: 1024×1024 es ideal para retratos detallados.

Ejemplo detallado: generación de un dataset para entrenamiento

Objetivo: generar 100 imágenes de diferentes estilos arquitectónicos para un dataset de entrenamiento.

Comando para ejecutar en Windows: 

python scripts\run_batch.py ^
  --workflow workflows\arquitectura_dataset.json ^
  --args "{'prompt': 'edificio moderno, diseño futurista, (vidrio y acero:1.2), estilo minimalista, iluminación natural, alta resolución, 8k', 'negative_prompt': 'borroso, pixelado, baja calidad, deformado, texto, estilo antiguo, colores apagados', 'steps': 40, 'CFG_scale': 12, 'sampler': 'UniPC', 'resolution': '1024x1024'}" ^
  --count 100 --randomize-seed --parallel 2 ^
  --output-dir .\outputs\dataset_arquitectura

Comando para ejecutar en macOS/Linux: 

python3 scripts/run_batch.py \
  --workflow workflows/arquitectura_dataset.json \
  --args '{
    "prompt": "edificio moderno, diseño futurista, (vidrio y acero:1.2), estilo minimalista, iluminación natural, alta resolución, 8k",
    "negative_prompt": "borroso, pixelado, baja calidad, deformado, texto, estilo antiguo, colores apagados",
    "steps": 40,
    "CFG_scale": 12,
    "sampler": "UniPC",
    "resolution": "1024x1024"
  }' \
  --count 100 --randomize-seed --parallel 2 \
  --output-dir ./outputs/dataset_arquitectura

Dónde se guardan los resultados: en la carpeta outputs/dataset_arquitectura.

Notas y consejos:

  • parallel 2: limita el número de procesos simultáneos para evitar sobrecargar la GPU.
  • count 100: genera 100 imágenes para el dataset.
  • CFG Scale 12: asegura adherencia estricta al prompt para mantener consistencia en el dataset.
  • Steps 40: garantiza alta calidad en todas las imágenes.

¿Cómo verificar que todo funciona correctamente?

Ejecutar el verificador de salud

El script health_check.py verifica que tu instalación de ComfyUI esté funcionando correctamente. Este script comprueba:

  • Si comfy-cli está en el PATH.
  • Si el servidor de ComfyUI es accesible.
  • Si hay al menos un modelo checkpoint instalado.
  • Si el sistema pasa una prueba de humo (generación de una imagen de prueba).

En Windows:

  1. Abre PowerShell o CMD.
  2. Navega al directorio de ComfyUI: 
    cd C:\ComfyUI
  3. Ejecuta el script: 
    python scripts\health_check.py

En macOS/Linux:

  1. Abre una terminal.
  2. Navega al directorio de ComfyUI: 
    cd ~/ComfyUI
  3. Ejecuta el script: 
    python3 scripts/health_check.py

Verificar dependencias de un workflow

El script check_deps.py verifica que un workflow específico tenga todas sus dependencias instaladas (modelos, nodos, etc.).

Comando:

python3 scripts/check_deps.py workflows/mi_workflow.json

Salida esperada:

Advertisement
{
  "is_ready": true,
  "missing_models": [],
  "missing_nodes": []
}

Si is_ready es false, el script listará los modelos o nodos faltantes.

Gestión de cola y recursos del sistema

Cuando trabajas con múltiples workflows o lotes grandes, es importante gestionar la cola de trabajo y los recursos del sistema para evitar cuellos de botella o errores de memoria.

Ver cola de trabajo

Para ver los workflows en cola y su estado: 

curl -s http://127.0.0.1:8188/queue | python3 -m json.tool

Salida esperada: un JSON con información sobre los workflows en cola, incluyendo su estado (pending, running, etc.).

Cancelar trabajos pendientes

Para limpiar la cola de trabajos pendientes:

Advertisement
curl -X POST http://127.0.0.1:8188/queue -d '{"clear": true}'

Interrumpir trabajo en ejecución

Para detener un workflow que se está ejecutando: 

curl -X POST http://127.0.0.1:8188/interrupt

Liberar memoria de GPU

Si necesitas liberar recursos después de un trabajo intensivo: 

curl -X POST http://127.0.0.1:8188/free \
  -H "Content-Type: application/json" \
  -d '{"unload_models": true, "free_memory": true}'

Este comando descarga los modelos de la VRAM y libera memoria, lo que es útil si planeas ejecutar otros workflows con diferentes requisitos.

Tips y errores comunes que debes evitar

Errores comunes y cómo solucionarlos

1. “No such file or directory” al ejecutar un script

Causa: No estás en el directorio correcto o la ruta del script es incorrecta.

Solución:

Advertisement
  1. Navega al directorio de ComfyUI antes de ejecutar el script.
  2. Verifica que el archivo existe en la carpeta scripts.
  3. Usa la ruta relativa correcta:
    • En Windows: scripts\hardware_check.py.
    • En macOS/Linux: scripts/hardware_check.py.

2. “python: command not found”

Causa: Python no está instalado o no está en el PATH.

Solución:

  1. Instala Python desde python.org.
  2. Durante la instalación, marca la opción “Add Python to PATH”.
  3. Reinicia la terminal y verifica con python --version (Windows) o python3 --version (macOS/Linux).

3. “No module named ‘torch’”

Causa: PyTorch no está instalado o no es compatible con tu hardware.

Solución:

  1. Instala PyTorch según tu hardware:
    • NVIDIA (CUDA): 
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130
    • AMD (ROCm): 
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.6
    • Apple Silicon (M1/M2): 
      pip install torch torchvision torchaudio
    • CPU: 
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
  2. Verifica la instalación con: 
    python -c "import torch; print(torch.__version__)"

4. “Out of Memory” (OOM)

Causa: No tienes suficiente VRAM o RAM para ejecutar el workflow.

Soluciones:

  1. Reduce la resolución de la imagen (ej: de 1024×1024 a 768×768).
  2. Disminuye el número de pasos (steps).
  3. Usa un modelo más ligero (ej: SD1.5 en lugar de SDXL).
  4. Reduce el tamaño del lote (--parallel).
  5. Combina RAM y VRAM editando config.json.
  6. Cierra otras aplicaciones que consuman memoria.

5. “class_type not found”

Causa: Falta un nodo personalizado requerido por el workflow.

Solución:

  1. Identifica el nodo faltante en el mensaje de error.
  2. Instálalo con: 
    comfy node install <nombre-del-nodo>
  3. Reinicia el servidor de ComfyUI.

6. El nivel gratuito de Comfy Cloud no permite ejecutar workflows

Causa: El nivel gratuito de Comfy Cloud tiene limitaciones.

Solución:

Advertisement
  1. Actualiza a un plan pagado en Comfy Cloud.
  2. O usa la instalación local si tienes el hardware adecuado.

Lista de verificación final: ¿estás listo para empezar?

Antes de considerar la instalación completa, verifica que:

  1. Has preparado el entorno correctamente (Python, Git, controladores de GPU).
  2. El veredicto del chequeo de hardware es ok o marginal, o has elegido Comfy Cloud.
  3. comfy --version funciona correctamente.
  4. curl http://127.0.0.1:8188/system_stats devuelve un JSON válido.
  5. Tienes al menos un modelo checkpoint instalado.
  6. El JSON de tu workflow está en formato API.
  7. check_deps.py reporta is_ready: true.
  8. Una prueba de ejecución se completa y los outputs aparecen en el directorio especificado.
  9. Has configurado correctamente el uso de RAM y VRAM si es necesario.

Preguntas frecuentes sobre ComfyUI y Hermes Agent

¿Puedo usar ComfyUI sin GPU?

Sí, pero con limitaciones:

  • Con CPU: Puedes ejecutar ComfyUI en modo CPU, pero la generación será extremadamente lenta (puede tardar minutos por imagen).
  • Con Comfy Cloud: La opción recomendada si no tienes GPU. Ofrece acceso a GPUs potentes en la nube.

¿Cuál es la diferencia entre SD1.5, SDXL y Flux?

Modelo Tamaño VRAM mínima Calidad Estilo Recomendado para
SD1.5 ~2-4 GB 4 GB Buena Versátil Principiantes, pruebas rápidas
SDXL ~6-7 GB 8 GB Alta Fotorrealista/artístico Proyectos profesionales, alta calidad
Flux ~12-14 GB 12 GB Muy alta Artístico avanzado Proyectos de alta gama, estilo único

¿Cómo solucionar el error “class_type not found”?

Este error ocurre cuando falta un nodo personalizado en tu instalación. Para solucionarlo:

  1. Identifica el nodo faltante en el mensaje de error (ej: comfyui-impact-pack).
  2. Instálalo con: 
    comfy node install <nombre-del-nodo>
  3. Reinicia el servidor de ComfyUI.

¿Puedo generar videos con ComfyUI?

Sí, usando nodos como comfyui-animatediff-evolved y modelos de animación como AnimateDiff. El proceso implica:

  1. Generar una secuencia de imágenes (fotogramas).
  2. Combinar los fotogramas en un video usando FFmpeg.

Consulta la sección de generación de video para más detalles.

¿Cómo optimizar el uso de memoria?

Puedes optimizar el uso de memoria de las siguientes maneras:

  1. Edita el archivo config.json para combinar RAM y VRAM.
  2. Reduce la resolución de las imágenes.
  3. Disminuye el número de pasos (steps).
  4. Usa modelos más ligeros (ej: SD1.5 en lugar de SDXL).
  5. Limita el tamaño de los lotes (--parallel).

¿Dónde se guardan los archivos generados?

Por defecto, los archivos generados se guardan en:

  • outputs/: imágenes generadas.
  • outputs/videos/: fotogramas para videos.
  • outputs/audios/: archivos de audio.

Puedes cambiar estas ubicaciones:

  1. Editando el archivo config.json.
  2. Especificando un directorio personalizado con --output-dir al ejecutar un workflow.

Glosario de términos

  • checkpoint: archivo que contiene los pesos de un modelo de inteligencia artificial (ej: sd_xl_base_1.0.safetensors).
  • workflow: secuencia de nodos en ComfyUI que define un proceso de generación. Se guarda como un archivo JSON.
  • VRAM: memoria dedicada de la GPU. Crítica para ejecutar modelos de IA.
  • RAM: memoria del sistema. Puede usarse como respaldo cuando la VRAM se agota.
  • prompt: texto que describe lo que quieres generar. Cuanto más detallado, mejor.
  • negative prompt: texto que describe lo que NO quieres en la generación.
  • steps: número de iteraciones para generar la imagen. Más pasos = mayor calidad, pero también más tiempo.
  • CFG scale: qué tan estrictamente el modelo sigue el prompt. Valores altos = más adherencia, menos creatividad.
  • seed: número que determina la aleatoriedad de la generación. El mismo seed + prompt = misma imagen.
  • sampler: algoritmo usado para generar la imagen. Cada uno tiene sus propias características.
  • resolución: tamaño de la imagen en píxeles (ej: 1024×1024).
  • denoise: en img2img, qué tan fuerte es la modificación aplicada a la imagen original.
  • frame_count: número de fotogramas en un video.
  • fps: fotogramas por segundo en un video.
  • motion_scale: qué tan pronunciado es el movimiento entre fotogramas en un video.
  • context_length: número de fotogramas que el modelo considera para el movimiento.
  • LoRA: adaptador de bajo rango que permite personalizar modelos sin reentrenarlos completamente.
  • embedding: archivo que contiene representaciones vectoriales de conceptos (ej: estilos, texturas).
  • PATH: variable de entorno que indica al sistema operativo dónde buscar ejecutables como Python.

Post Views: 677
Related Topics:
Continue Reading
Advertisement

Audio

Oats: la herramienta de IA open source para notas de reuniones locales y privadas

Published

2 días ago

on

15 septiembre, 2026

By

Oats: la herramienta de IA open source para notas de reuniones locales y privadas

Oats graba tus reuniones directamente en tu Mac o Windows, genera resúmenes y listas de tareas sin usar bots ni nubes externas. Es open-source, gratuita y se integra con Obsidian. Descubre cómo funciona y por qué es una alternativa revolucionaria a herramientas como Otter.ai.

(más…)

Post Views: 372
Continue Reading

Android

Podcast ONE: 11 de septiembre de 2026

Published

6 días ago

on

11 septiembre, 2026

By

Podcast ONE: 11 de septiembre de 2026

Podcast ONE: 11 de septiembre de 2026

(más…)

Podcast: Play in new window | Download

Post Views: 520
Continue Reading

Apple

Apple Surprise and Shine 2026: todos los lanzamientos, precios y análisis de actualización

Published

1 semana ago

on

9 septiembre, 2026

By

Apple Surprise and Shine 2026: todos los lanzamientos, precios y análisis de actualización

El 9 de septiembre de 2026, Apple presentó en su evento Surprise and Shine sus productos más esperados del año: el iPhone 18 Pro, iPhone 18 Pro Max, el primer iPhone plegable Duo, los AirPods 5, el Apple Watch Series 12 y el Apple Watch Ultra 4. Aquí te ofrecemos un resumen validado con imágenes oficiales de Apple, precios, especificaciones técnicas, y un análisis crítico para decidir si vale la pena actualizar.

(más…)

Post Views: 774
Continue Reading

Lo más reciente

Lo más popular

Subscribete a nuestro Podcast

Apple PodcastsAndroidby EmailRSS

Trending