ComfyUI para principiantes: instálalo y construye un flujo de texto a imagen nodo por nodo

Instala ComfyUI portable en Windows, descarga un checkpoint de Stable Diffusion 1.5 y construye el grafo básico de texto a imagen desde un lienzo vacío: Empty Latent Image, Load Checkpoint, prompts, KSampler, VAE Decode y Save Image, con lo que hace cada ajuste.

Anton Tenitsky13 de octubre de 20267 min de lecturaVersión en vídeo más abajo

Esta guía se tradujo del inglés con IA y puede contener errores. Leer el original.

Dos teteras de porcelana blanca sobre un fondo blanco liso, generadas con Stable Diffusion 1.5 en ComfyUI

ComfyUI es una interfaz basada en nodos para ejecutar modelos de imágenes de IA. Es muy avanzada y, en algunos aspectos, más capaz que las herramientas web de pago: no siempre da mejor calidad, pero funciona en local, es gratuita y puedes hacer que haga cosas muy concretas que ninguna herramienta web te permitirá. Este es el primer paso: instalarla y construir desde cero el grafo básico de texto a imagen, para entender qué hace cada nodo. Las primeras generaciones son teteras.

En resumen

  • Instala: descarga la versión portable desde la página de GitHub de ComfyUI, descomprime y ejecuta run_nvidia_gpu.bat.
  • Modelo: Stable Diffusion 1.5 (v1-5-pruned-emaonly.safetensors) en ComfyUI/models/checkpoints.
  • El grafo: Empty Latent Image → Load Checkpoint → dos prompts CLIP Text Encode → KSampler → VAE Decode → Save Image.
  • Valores por defecto que funcionan: 20 steps, CFG 8, sampler dpm_2, scheduler karras para imágenes fotorrealistas.

Instala ComfyUI

Python

Instalé Python 3.11.5 desde python.org, una versión compatible con ComfyUI. Las versiones de Python recién salidas pueden causar problemas de compatibilidad, o puede que no; es difícil saberlo con seguridad. Descarga el instalador de Windows y sigue los pasos básicos. (La versión portable de ComfyUI de abajo también trae su propio Python integrado.)

ComfyUI portable

La página de GitHub de ComfyUI tiene los archivos, la documentación y una útil lista de atajos de teclado, que merece la pena consultar de vez en cuando y memorizar.

  1. En Windows, usa la versión portable: el enlace de descarga directa te da un zip. (La instalación para otros sistemas está más abajo en esa página.)
  2. Descomprímelo, abre la carpeta y haz doble clic en run_nvidia_gpu.bat. Si no tienes una GPU utilizable, usa en su lugar la versión de CPU.
  3. El primer arranque descarga los módulos que necesita ComfyUI; dale de 5 a 10 minutos. Después se abre en tu navegador.
La carpeta de ComfyUI portable en el Explorador de Windows, con carpetas como custom_nodes, models, input y output
La carpeta de ComfyUI: los modelos van en models, tus renders acaban en output.

Si no se abre con un flujo ya cargado, ve a Workflow → Browse Templates y elige Image Generation, la plantilla más básica. Haz clic en Queue y te avisará de que todavía no hay ningún modelo.

Descarga un modelo

Stable Diffusion 1.5

Consigue Stable Diffusion 1.5 de Hugging Face: abre Files and versions y descarga v1-5-pruned-emaonly.safetensors. Ponlo en ComfyUI/models/checkpoints.

Prefiere .safetensors a .ckpt. Un archivo .ckpt es un pickle de Python, que puede contener código que se ejecuta al cargarlo; safetensors es un formato que solo contiene los números del modelo. Eso importa sobre todo cuando descargas modelos de sitios de la comunidad.

Por qué 1.5 y no un modelo más nuevo

Hay mucha confusión entre los principiantes: Stable Diffusion 3.5, 2.1, SDXL, Flux, 1.5. Empieza con 1.5:

  • Está muy probado. La fuerza de ComfyUI es que puedes arrastrar el flujo de otra persona y funciona, y muchos custom nodes, plugins y flujos necesitan un modelo 1.5 (o SDXL), y con menos frecuencia 3.5 o Flux.
  • Es rápido. Mientras aprendes, quieres muchas iteraciones, y la calidad importa menos en esta fase.

SD 1.5 es un modelo base. La gente lo afina con conjuntos de datos adicionales, y esos modelos dan resultados mucho mejores. A veces juego con el normal, pero lo más habitual es que use un modelo afinado como epiCPhotoGasm.

Modelos afinados en Civitai

Civitai tiene un enorme número de modelos afinados para SD 1.5, SDXL, Flux y más. Busca un estilo (anime, estilizado, un pintor clásico como Rembrandt, lo que sea) y comprueba el modelo base que figura en cada página. Para un buen fotorrealismo elegí epiCPhotoGasm, un modelo SD 1.5. Va en la misma carpeta checkpoints.

La página del modelo epiCPhotoGasm en Civitai con retratos de muestra y un botón de descarga
epiCPhotoGasm en Civitai: un modelo SD 1.5 afinado para el fotorrealismo.

De vuelta en ComfyUI, Edit → Refresh Node Definitions encuentra los archivos nuevos. Para cambios mayores a veces hace falta reiniciar ComfyUI por completo.

Tu primera imagen

Elige un modelo en Load Checkpoint y haz clic en Queue. Mantén abierta la ventana de comandos: muestra los errores y cuánto tarda cada imagen.

La plantilla de generación de imágenes por defecto de ComfyUI con Load Checkpoint, dos prompts, KSampler, VAE Decode, Save Image y Empty Latent Image, y la lista de checkpoints abierta
La plantilla por defecto, con los dos checkpoints descargados en la lista.

La interfaz en sí es sencilla: guardar y exportar, deshacer y rehacer, ayuda y documentación, una biblioteca de nodos para buscar nodos, una biblioteca de modelos y tus archivos de flujo. Haz clic de nuevo en un icono de la barra lateral para ocultar su panel.

Construye tú mismo el grafo

Empieza desde una página en blanco: Workflow → New. Haz doble clic en el lienzo vacío para buscar un nodo por su nombre.

1. Empty Latent Image: el lienzo

Añade Empty Latent Image. Fija la resolución y el tamaño del lote, el número de imágenes por ejecución (el recuento de lotes junto al botón Queue hace algo parecido).

Es un lienzo en blanco en el espacio latente: una representación codificada y ruidosa en la que trabaja el modelo, almacenada como un tensor (una matriz multidimensional de números). No soy matemático; la idea útil es que manipulas ese latente dándole información: un prompt de texto, otra imagen, una guía de estilo o ruido.

2. Load Checkpoint: el modelo

Añade Load Checkpoint («checkpoint» significa modelo) y elige SD 1.5. Tiene tres salidas:

  • MODEL le dice a ComfyUI qué modelo se usa a lo largo del proceso.
  • CLIP gestiona las entradas que orientan la imagen, como tu prompt de texto.
  • VAE, un autocodificador variacional, codifica una imagen en el espacio latente y la decodifica de vuelta. Muchos checkpoints incluyen uno; también puedes cargar un VAE distinto para obtener otro aspecto.
Un nodo Load Checkpoint con las salidas MODEL, CLIP y VAE y v1-5-pruned-emaonly seleccionado
Load Checkpoint: un modelo, tres salidas.

3. Dos prompts

Arrastra desde la salida CLIP y suelta; ComfyUI ofrece los nodos compatibles. Elige CLIP Text Encode (Prompt). Cópialo (Ctrl+C, Ctrl+V) y conecta también la copia. Normalmente trabajas con dos prompts: uno positivo para lo que quieres y otro negativo para lo que no. Haz doble clic en el título de un nodo para renombrarlo.

4. KSampler: donde todo se junta

Arrastra desde MODEL y elige KSampler, el nodo que resuelve la imagen. Conecta el prompt positivo, el prompt negativo y el latente vacío. Sus ajustes:

  • Seed con control_after_generate: fixed repite la misma imagen, increment cuenta 1, 2, 3 para que puedas seguir los cambios, randomize hace que cada ejecución sea nueva.
  • Steps: más steps, mayor calidad, renders más largos. Dos steps se ven feos; 80 se ven más finos pero tardan mucho más. Algunos modelos funcionan mejor con un número concreto, así que lee su documentación.
  • CFG (classifier-free guidance): los valores más bajos dan más libertad al modelo. Con 1–2 obtienes ruido o una imagen en blanco; con 12, 15 o 20 se adhiere al prompt con mucha más fuerza y puede producir fallos. 8 es el estándar y un buen valor por defecto; experimenta entre 4 y 10, más o menos.
  • Sampler: el algoritmo que crea la imagen. Algunos sirven para resultados estilizados, otros para fotorrealismo; algunos son más rápidos. Yo usé dpm_2 para imágenes fotorrealistas.
  • Scheduler: el patrón de ruido que se añade durante el muestreo. karras va bien con imágenes realistas.
  • Denoise: cuánto se aleja el resultado del latente de entrada. Con un latente vacío no tiene efecto aquí; importa en la imagen a imagen.
Un primer plano del nodo KSampler con seed, control_after_generate, steps, cfg, sampler, scheduler y denoise
Los ajustes del KSampler, antes de cambiar a dpm_2 y karras.

5. VAE Decode y Save Image

VAE Decode convierte el latente (la matriz de números) en una imagen real. Conecta la salida del KSampler y el VAE del checkpoint. Después añade Save Image. Los resultados se guardan en ComfyUI/output.

Escribe «teapot» en el prompt positivo y ejecuta. ComfyUI resalta en verde el nodo que se está ejecutando en ese momento.

El KSampler con dpm_2 y karras alimentando VAE Decode y Save Image, que muestra una tetera blanca
El grafo terminado y una primera tetera.

Mejorar el resultado

La primera tetera no era muy bonita. Lo que ayudó:

  • Una mejor redacción: «white background, isolated, centered».
  • Un prompt negativo: a veces hacía imágenes de anime o estilizadas, así que puse esas palabras en el prompt negativo.
  • Un modelo mejor: pasar de SD 1.5 normal a epiCPhotoGasm.

Después subí la resolución a 1024 × 1024. Cuatro veces los píxeles tardaron unas cuatro veces más: de 5 a 23 segundos. A ese tamaño seguía haciendo varias teteras, así que añadí «single teapot» al prompt. Decir «white background» también hacía que la tetera tendiera a ser blanca; puedes pedir una tetera negra sobre un fondo blanco si quieres una. Todavía falla de vez en cuando. Puse en cola cuatro y me fui a hacer té.

El nodo Save Image mostrando una taza y dos teteras sobre un fondo blanco, con el tooltip Batch Count junto al botón Queue
A 1024 × 1024 le gustaba añadir teteras de más, así que el prompt recibió «single teapot».

Esta es una configuración muy básica que apenas roza la superficie. Gana experiencia cambiando prompts y valores y viendo qué cambia; así se desarrolla el instinto para el software. Siguiente: instala el ComfyUI Manager y prueba la imagen a imagen.

Ejecutarlo sin una GPU potente

SD 1.5 funciona en tarjetas modestas. Para modelos más pesados como SDXL y Flux, o para lotes largos, ahora alquilo GPU; mira mi introducción a RunPod.

Ver la versión en vídeo (19:22)

Todo lo anterior también está en el vídeo, si prefieres seguirlo en pantalla. El vídeo está en inglés.

Preguntas frecuentes

¿Con qué modelo de Stable Diffusion debe empezar un principiante en ComfyUI?

Con Stable Diffusion 1.5. Es rápido, y muchos flujos compartidos, custom nodes y plugins están hechos para él (o para SDXL). Para obtener mejores imágenes, usa un SD 1.5 afinado de Civitai, como epiCPhotoGasm.

¿Dónde pongo los archivos de modelo en ComfyUI?

Los checkpoints van en ComfyUI/models/checkpoints. Luego usa Edit → Refresh Node Definitions (o reinicia ComfyUI) para que aparezcan en la lista de Load Checkpoint.

¿Qué CFG y cuántos steps debo usar?

CFG 8 es un buen valor por defecto; vale la pena experimentar entre 4 y 10. Los valores muy bajos dan ruido y los muy altos siguen el prompt con demasiada fuerza y producen fallos. Más steps significan mayor calidad pero renders más largos; alrededor de 20 es un inicio normal.

¿Por qué el denoise no hace nada en mi flujo de texto a imagen?

El denoise controla cuánto se aleja el resultado del latente de entrada. Con un latente vacío no hay nada de lo que alejarse, así que no tiene efecto. Importa en la imagen a imagen.

Anton Tenitsky es artista 3D con más de 15 años en gráficos por ordenador, que ha trabajado con Nickelodeon, Gameloft, Marvel Rivals y muchos otros clientes. Más sobre mí

Guías relacionadas