Un lienzo crema muestra un grafo de nodos: cuatro rectángulos coloreados (prompt de texto, encoder, sampler, save) conectados por cables rojos, con puntos chicos que marcan entradas y salidas. Un único cuadrado ámbar renderizado a la derecha representa la imagen final. Puntos de puntuación Bauhaus y un triángulo de apoyo.
[ IA y Automatización ]7 min de lectura

Generar arte: el caos y la belleza de ComfyUI

Fase 4 · Agentes autónomos y UX

Un entorno de programación visual por nodos para generación de imágenes, el patch de driver de GPU que costó un fin de semana, y por qué exponer el grafo es una virtud, no un defecto.

ComfyUIStable Diffusion XLPyTorchDocker

La generación de texto es abstracta. Escribís, el modelo responde, la respuesta son palabras. La generación de imágenes es terca, porque se puede discutir si la imagen es la que querías. La discusión no es subjetiva; es arquitectónica. Un prompt más un modelo más algunas configuraciones producen una imagen, y la imagen casi es la que querías pero no del todo, y la parte que querés cambiar está trabada detrás de una interfaz de un clic que no te va a contar por qué tomó esa decisión.

ComfyUI es la respuesta a esa frustración. Saca todo el pipeline de generación de imágenes de la caja de un solo clic y lo deja sobre un lienzo, como un grafo de nodos que podés ver, editar y reconectar. La primera vez que lo abrís, el grafo parece el cableado de un avión. Una semana después, parece la descripción honesta de lo que las otras herramientas te estaban escondiendo.

La analogía

Un sintetizador moderno tiene un panel frontal con perillas grandes y amistosas. Girás “filter cutoff” y el sonido se pone más brillante. Esa perilla funciona porque debajo hay un circuito analógico específico, un filtro controlado por voltaje, que toma el voltaje de control de la perilla y dobla el sonido en consecuencia. La perilla es una simplificación de una ruta de señal parcheable.

Un sintetizador modular expone la ruta de señal. Osciladores, envelopes, filtros, mixers son módulos separados, cada uno con sockets físicos de entrada y salida. Corrés cables de patch entre ellos. Si querés que el envelope module el filter cutoff, corrés un cable de “envelope out” a “filter CV in”. Nada está escondido. Cada perilla del sinte más simple era este cable, dibujado corto y soldado cerrado.

ComfyUI es el sintetizador modular para la generación de imágenes. El prompt de texto es un módulo. El sampler latente es otro. El decoder VAE que convierte latents en píxeles es un tercero. Las conexiones las corrés vos, y a cambio entendés lo que la herramienta realmente está haciendo.

La tecnología traducida

Un pipeline de generación de imágenes con Stable Diffusion tiene, como mínimo, estas etapas:

  1. Text encoder. Convierte tu prompt en un vector embedding.
  2. Sampler latente. Corre el loop de difusión inversa en espacio “latente” comprimido, guiado por el embedding. Produce un tensor chico que codifica el contenido de la imagen.
  3. Decoder VAE (variational autoencoder). Descomprime el tensor latente en datos de imagen en espacio de píxel.
  4. Save / display. Escribe el PNG a disco y lo muestra en el UI.

Cada producto comercial de arte con IA corre este pipeline detrás de un botón. ComfyUI lo muestra como cuatro nodos conectados. Ahora podés insertar cosas entre los nodos: un segundo encoder para combinar dos prompts con pesos, un ControlNet para condicionar el sampler a una imagen de pose, un upscaler tileado entre VAE y save para partir un render 4K en tiles manejables. Cada uno de esos es un nodo nuevo, conectado con un solo arrastre.

Las ventajas prácticas, cuando la curva de aprendizaje se aplana:

  • Reproducibilidad. Un workflow se guarda como JSON. Soltás el JSON en el ComfyUI de otra persona y obtiene el mismo pipeline exacto, hasta la semilla y la configuración del sampler.
  • Ramificación. Renderizá tres variaciones del mismo latente, una por configuración de sampler, en una sola corrida.
  • Debuggabilidad. Cuando una salida está mal, podés inspeccionar los latentes intermedios y ver dónde el pipeline dobló.

El costo es que la primera hora desorienta. Todo tutorial arranca igual: “conectá el checkpoint loader al KSampler, rutéa el prompt positivo y el prompt negativo, enganchá una fuente de imagen latente, después VAE-decode”. Después de hacerlo dos veces, dejás de leer tutoriales.

La acción

Correr ComfyUI en un contenedor con acceso a GPU

La instalación es directa; la configuración que la hace “de producción” es la parte que vale documentar. ComfyUI es una app de Python. Corre bien nativa sobre el nodo IA. Igual la corro en un contenedor Docker, por el mismo motivo por el que todo lo demás del lab está contenerizado: rollback limpio, sin dependencias filtradas al host.

# docker-compose.yml para ComfyUI sobre el nodo IA (host bare-metal).
services:
  comfyui:
    image: ghcr.io/ai-dock/comfyui:latest-cuda
    container_name: comfyui
    restart: unless-stopped
    runtime: nvidia   # Pasá la GPU al contenedor.
    environment:
      NVIDIA_VISIBLE_DEVICES: all
      NVIDIA_DRIVER_CAPABILITIES: compute,utility

      # Usá el pool ZFS para los checkpoints de modelos: son archivos grandes.
      CF_TUNNEL_TOKEN: ""
      WEB_PASSWORD: "${WEB_PASSWORD}"

    volumes:
      # Los modelos persisten en el pool ZFS y sobreviven al rebuild del contenedor.
      - /tank/comfyui/models:/opt/ComfyUI/models
      - /tank/comfyui/output:/opt/ComfyUI/output
      - /tank/comfyui/user:/opt/ComfyUI/user

    ports:
      - "198.51.100.20:8188:8188"

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Levantalo, abrí el UI web en http://198.51.100.20:8188, tirá un checkpoint base de Stable Diffusion XL y renderizá la primera imagen. El checkpoint pesa ~6 GB; la primera descarga tarda un minuto en gigabit, después todo queda local.

Lo que se rompió

El fin de semana que instalé ComfyUI, el build más nuevo de PyTorch estaba una versión adelante del runtime CUDA que había fijado en la entrada 14. ComfyUI arrancó, cargó el modelo, y en el primer paso de inferencia crasheó con:

RuntimeError: CUDA error: no kernel image is available for execution on the device.

El error se lee como falla de hardware; no lo es. Significa que los kernels compilados de PyTorch estaban construidos para una capacidad de cómputo CUDA (sm_89 para placas Ada Lovelace) que mi runtime CUDA instalado no incluía. La solución era o bajar PyTorch a la versión que matcheara mi runtime CUDA, o subir el runtime CUDA a la de PyTorch. Elegí subir, porque el runtime CUDA más nuevo era compatible hacia atrás con la instalación de Ollama de la entrada 14:

# Desinstalá el runtime CUDA viejo.
sudo apt remove nvidia-cuda-toolkit

# Instalá la versión que matchea PyTorch actual (12.1 en ese momento).
# Desde el repositorio apt de NVIDIA: mirá sus docs para el keyring vigente.
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update
sudo apt install cuda-toolkit-12-1

# Reconstruí el contenedor para que PyTorch tome el runtime nuevo.
docker compose down
docker compose up -d --build

Después del upgrade del runtime, el render se completó en siete segundos. Escribí un post-it sobre el monitor: fijá juntas las versiones de PyTorch y CUDA; tratalas como una sola dependencia. Un mes después el post-it se pagó solo cuando un apt upgrade ingenuo habría empujado el runtime y roto ComfyUI de nuevo.

Un bug más chico y menos glamoroso: la segunda corrida del contenedor no podía escribir archivos de salida. Adentro del contenedor, ComfyUI corre como UID 1000; en el pool ZFS, el directorio /tank/comfyui/output era de root. El contenedor podía leer los checkpoints de modelos (accesibles a todo el mundo) pero no escribir salidas. Un chown -R 1000:1000 /tank/comfyui/{output,user} en el host, y las imágenes empezaron a aterrizar en el directorio de salida. La solución es aburrida; olvidarla cuesta veinte minutos.

Por qué exponer el grafo es el punto

Los productos comerciales de generación de imágenes esconden el pipeline porque la simplicidad vende. El pipeline existe igual; vos no lo tocás. Para trabajo profesional o creativo, el intercambio está mal. Un diseñador que quiere una variación de luz específica no puede pedirle a un producto de un clic que cambie la escala CFG de la primera mitad de los pasos de difusión dejando la segunda mitad quieta; ComfyUI te deja cablear eso en tres minutos agregando un nodo KSamplerAdvanced con un rango de pasos.

El grafo no es un impuesto. Es la interfaz que la herramienta debió tener desde el principio. Una vez que aceptás eso, ComfyUI deja de parecer cableado de avión y empieza a parecer el esquema de algo que por fin podés moldear.

Footnotes

  1. ComfyUI tiene licencia GPL; inicio en github.com/comfyanonymous/ComfyUI. El paper de investigación de Stable Diffusion es Rombach et al. (2022), “High-Resolution Image Synthesis with Latent Diffusion Models”, arxiv.org/abs/2112.10752. ↩

Tabla de Contenidos