Serie ComfyUI (II) — Workflow simple usando FLUX

josejotxe
15 nov
9 Min. de lectura

Empezamos la segunda entrega de la Serie ComfyUI, dedicada a la creación de imágenes con IA en local. En esta ocasión vamos a construir, ejecutar y entender un workflow básico usando modelos FLUX, una nueva generación de modelos de difusión que destaca por su velocidad y calidad incluso con hardware modesto.

🎯 Qué vas a lograr

Crear un workflow simple para generar imágenes con modelos FLUX.
Entender qué hace cada nodo del flujo y cómo se conectan.
Ajustar parámetros clave (prompts, sampler, resolución, pasos, CFG).
Generar y guardar tu primera imagen usando un modelo FLUX en ComfyUI.

🧩 Requisitos

ComfyUI instalado y funcionando (preferiblemente con GPU).
Modelo FLUX, CLIP y VAE compatibles. (todos son descargables gratuitamente de hugginface y/o de civit.ai
- En este ejemplo hemos usado:
  - flux1-schnell-fp8.safetensors
  - t5xxl_fp8_e4m3fn.safetensors
  - clip_l.safetensors
  - ae.sft

💡 ¿Qué es un modelo FLUX?

Los modelos FLUX son una familia reciente de modelos de difusión optimizados para un rendimiento más rápido y eficiente que los SDXL o SD1.5 tradicionales.

FLUX.1 Schnell → versión ligera y muy rápida, ideal para pruebas y workflows simples.
FLUX.1 Dev → más precisa, algo más pesada, pensada para trabajos de detalle fino.
FLUX.1 Pro → pensada para entornos profesionales y outputs de mayor resolución.

Estos modelos pueden encontrarse en plataformas como HuggingFace o CivitAI, donde los usuarios comparten versiones, estilos y ejemplos.

🗂️ Crear o cargar el workflow en ComfyUI

Tienes dos maneras de trabajar con este flujo:

🅰️ Opción A — Cargar el workflow ya creado

Descarga el archivo JSON adjunto:📁 WF_Flux_Simple_DifussionModels.json

Abre ComfyUI.
En el menú superior, selecciona:Workflow → Load
Elige el archivo descargado.Verás aparecer en el lienzo todos los nodos conectados y configurados. Puedes hacer zoom y arrastrar con el ratón para explorarlos.

Cargar un workflow desde un archivo JSON

Esta opción es la más rápida si quieres probar directamente la generación con modelos FLUX.

🅱️ Opción B — Crear el workflow desde cero

Si prefieres aprender cómo se construye paso a paso, puedes partir de un flujo vacío y añadir los nodos uno a uno siguiendo las indicaciones de la siguiente sección:👉 “Entendiendo el workflow nodo a nodo”

Ahí explicamos en detalle qué hace cada bloque, cómo se conecta y qué parámetros conviene modificar en cada uno.

🧱 Entendiendo el workflow nodo a nodo

A continuación, explicamos los bloques principales del flujo y cómo trabajan entre sí.Cada nodo cumple una función dentro del proceso de generación, desde la carga del modelo hasta el guardado de la imagen final.

1️⃣ LoadDifussionModel

Qué hace: carga el modelo FLUX principal, encargado del proceso de difusión. Este modelo es el núcleo que transforma ruido en imagen, siguiendo las condiciones que dictan los prompts y el sampler.
Qué tocar: selecciona tu modelo FLUX. Puedes usar cualquiera de la familia (schnell, dev, pro). El formato recomendado es .safetensors, que evita riesgos de seguridad. También puedes cambiar el tipo de precisión (FP8, FP16…) según tu GPU.
- unet_name
  - Este es el archivo del modelo UNet que se va a cargar.
  - El nombre flux1-schnell-fp8.safetensors indica:
    - Flux1 → Es un modelo de la familia FLUX, optimizado para velocidad y calidad.
    - Schnell → versión ligera y rápida de flux optimizada para rendimiento.
    - fp8 → Significa que los pesos del modelo están cuantizados en float 8 bits, lo que reduce el tamaño del modelo y mejora la velocidad (a costa de una ligera pérdida de precisión).
    - .safetensors → Formato seguro y eficiente para almacenar tensores (más rápido y seguro que .ckpt).
    - Este modelo ocupa unos 17Gb y se puede descargar por ejemplo a través de este enlace
      - https://huggingface.co/Comfy-Org/flux1-schnell/tree/main
    - Una vez descargado habrá que copiarlo en la ruta de Pinokio de los checkpoints
      - C:\pinokio\api\comfy.git\app\models\checkpoints
- weight_dtype
  - Es el tipo de dato (precisión) en que se cargarán los pesos del modelo.
  - Al haber escogido un modelo fp8 tendrá que ser compatible con este
  - Escogemos "fp8_e4m3fn"
Conexiones del nodo: su salida MODEL se conecta a dos nodos:
- BasicScheduler (para definir los pasos de muestreo).
- BasicGuider (que combina el modelo con el prompt para guiar la difusión).

Nota: Cuantización

La cuantización FP8 (float 8 bits) es una técnica para reducir el tamaño y acelerar los cálculos de los modelos de IA.

En lugar de usar los valores normales en 16 o 32 bits (FP16 o FP32), el modelo guarda los pesos con solo 8 bits por número, usando menos memoria y procesando más rápido.

🔹 Ventajas:

Ocupa menos espacio (más ligero).
Se ejecuta más rápido, ideal para GPUs modernas.

🔹 Desventajas:

Pierde algo de precisión (ligera caída de calidad en algunos casos).

En resumen: FP8 = el modelo va más rápido y pesa menos, sacrificando un poco de exactitud.

2️⃣ DualCLIPLoader

Qué hace: carga los modelos de lenguaje CLIP, que interpretan los prompts. En este caso, se utilizan dos (t5xxl_fp8_e4m3fn.safetensors y clip_l.safetensors), que convierten el texto en una representación comprensible por el modelo FLUX. Convierten las frases escritas en el prompt en vectores numéricos.
Qué tocar: solo asegúrate de tener ambos archivos CLIP en la carpeta correspondiente (C:\pinokio\api\comfy.git\app\models\clip). Puedes probar otros CLIP si deseas estilos de interpretación distintos.
Conexiones del nodo: su salida CLIP se conecta al nodo CLIPTextEncode, que usará este modelo para procesar el prompt de texto.

3️⃣ CLIPTextEncode

Qué hace: convierte tu prompt positivo (lo que quieres ver) en un conjunto de vectores numéricos. Estos vectores guían al modelo FLUX en la generación de la imagen.
Qué tocar: escribe tu prompt en el cuadro de texto. En nuestro ejemplo este es el prompt que hemos escrito:

Una figura espectral domina la escena, envuelta en una luz azul helada. Es un hechicero con ropas harapienta emergiendo en la niebla.
Bajo sus harapos brilla una armadura antigua. En su pecho resplandece un amuleto azul que irradia energía. Creaneo semi oculto y ojos que arden con fuego.
En una mano sostiene una espada brillante con las letras LK grabadas en la hoja, y energía mágica fluye a su alrededor.
El fondo es una montaña helada con viento y luz azulada, que hace destacar su presencia fantasmal y poderosa.

Conexiones del nodo: recibe como entrada el CLIP desde DualCLIPLoader. Su salida CONDITIONING se conecta al BasicGuider, que combina esta información con el modelo para guiar la difusión.

4️⃣ BasicScheduler

Qué hace: controla el número de pasos de muestreo y el tipo de escalado del ruido. En otras palabras, determina cómo evoluciona el ruido hacia la imagen final.
Qué tocar:
- shceduler: (en este caso hemos escogido "normal")
  - Define el tipo de curva o método que se usa para calcular la reducción del ruido.
  - Cada tipo tiene su propia forma de distribuir los pasos y puede afectar el estilo, contraste o suavidad de la imagen.
- steps:
  - Indica cuántos pasos de difusión se harán (por ejemplo, 20, 30, 50...).
  - Más pasos = más detalle, pero tarda más.
- denoise
  - Controla cuánta fuerza de denoising se aplica (valor entre 0 y 1).
    - 1 → Genera desde ruido total (imagen nueva).
    - 0.5 → Aplica cambios suaves (útil para re-generar sin perder la forma original).
Conexiones del nodo: recibe el modelo (MODEL) desde el LoadDiffussionModel y entrega el resultado (SIGMAS) al nodo SplitSigmas.

NOTA: tipos de scheduler

Tipo	Características principales
normal	Balanceado, el más estándar. Buena calidad y estabilidad.
karras	Distribuye los pasos de forma no lineal, mejora detalles finos. Ideal para imágenes complejas.
exponential	Hace reducciones rápidas al principio y lentas al final. A veces produce estilos más suaves.
simple	Curva básica, útil para pruebas rápidas.
ddim_uniform	Variante de DDIM (deterministic diffusion). Más rápido, con menos pasos.
beta / linear_quadratic	Cambian la progresión del ruido de forma matemática; pueden alterar el estilo.
kl_optimal	Optimiza la distribución del ruido para lograr imágenes limpias con menos pasos.

5️⃣ SplitSigmas

Qué hace: divide las “sigmas” (niveles de ruido) en dos tramos: altos y bajos. Esto permite al sampler aplicar distintas estrategias de denoise según la fase del proceso.
Qué tocar: normalmente nada. Solo si estás experimentando con controladores avanzados podrías ajustar el punto de corte de sigmas.
- step
  - Indica en qué punto se dividirá esa lista.
    - Por ejemplo, si el step es 0, la división ocurre al inicio (todo se considera bajo ruido).
    - Si lo aumentas, separa los primeros valores (ruido alto) del resto (ruido bajo).
  - Esto permite aislar fases del proceso, como:
    - aplicar un denoising diferente al principio y al final,
    - usar distintos samplers o pesos según la etapa de generación.
Conexiones del nodo: recibe SIGMAS del BasicScheduler. Su salida low_sigmas va al SamplerCustomAdvanced, mientras que high_sigmas puede quedar sin uso en este flujo simple.
- high_sigmas → Los valores de ruido correspondientes a las etapas iniciales del proceso (más ruido).
- low_sigmas → Los valores de las etapas finales (menos ruido, más detalle).

6️⃣ KSamplerSelect

Qué hace: permite seleccionar el sampler que usará el modelo durante el proceso de denoising.
- El sampler (muestreador) controla cómo el modelo aplica los pasos de denoising (reducción del ruido) para convertir el ruido inicial en una imagen coherente. En otras palabras: Mientras el scheduler define el “ritmo” de limpieza del ruido,el sampler define el método matemático con el que esa limpieza se realiza.
- Cada sampler usa una fórmula distinta para calcular la siguiente imagen intermedia a partir de la anterior.
Qué tocar: selecciona un sampler en el menú desplegable. Los más comunes son:
- Euler → rápido y estable (usado aquí).
- DPM++ 2M → más suave, con mayor detalle.
- UniPC → más control, aunque más lento.
Conexiones del nodo: no tiene entradas. Su salida SAMPLER se conecta directamente al SamplerCustomAdvanced.

7️⃣ RandomNoise

Qué hace: genera el ruido inicial con el que el modelo empezará a trabajar. Cada ejecución crea un patrón aleatorio distinto (a menos que se fije la semilla).
Qué tocar: puedes fijar la seed (semilla) si quieres resultados reproducibles. Si la dejas en “randomize”, cada ejecución generará una imagen distinta.
Conexiones del nodo: no recibe entradas. Su salida NOISE se conecta al SamplerCustomAdvanced.

8️⃣ EmptyLatentImage

Qué hace: crea un lienzo latente vacío con la resolución deseada. Este “espacio latente” es donde el modelo aplicará el proceso de difusión.
Qué tocar: define el tamaño (ancho y alto) y el número de imágenes por lote (batch_size).
- Por ejemplo: 896×1152 y 1 imagen por ejecución.
Conexiones del nodo: no tiene entradas. Su salida LATENT se conecta al SamplerCustomAdvanced.

9️⃣ BasicGuider

Qué hace: combina el modelo (MODEL) y el prompt codificado (CONDITIONING) para guiar la generación. Ess el nodo que “traduce” tus instrucciones textuales en dirección visual.
Qué tocar: normalmente nada. Puedes experimentar conectando aquí diferentes condicionantes si usas múltiples prompts o controladores.
Conexiones del nodo: recibe el MODEL desde LoadDifussionModel y el CONDITIONING desde CLIPTextEncode. Su salida GUIDER va al SamplerCustomAdvanced.

🔟 SamplerCustomAdvanced

Qué hace: es el corazón del workflow. Combina todos los elementos (modelo, ruido, guías, sampler, sigmas y latente) y ejecuta el proceso de difusión para generar la imagen final en el espacio latente.
Qué tocar: aquí puedes ajustar los parámetros de pasos, CFG o samplers si tu versión del nodo lo permite. En este flujo se usa la configuración estándar del modelo FLUX.
Conexiones del nodo:
- Recibe cinco entradas:
  - NOISE de RandomNoise
  - GUIDER de BasicGuider
  - SAMPLER de KSamplerSelect
  - SIGMAS de SplitSigmas
  - LATENT de EmptyLatentImage
- Su salida LATENT se conecta al VAEDecode.

11️⃣ Load VAE + VAEDecode

Qué hace: el nodo "Load VAE" carga el modelo VAE (ae.sft) y el nodo "VAE Decode" transforma el espacio latente en una imagen RGB visible. Este paso convierte los valores matemáticos en píxeles reales.
Qué tocar: verifica que el VAE seleccionado sea compatible con el modelo FLUX usado. En la mayoría de los casos, el que se incluye en el pack oficial funciona correctamente.
Conexiones del nodo:
- VAELoader no tiene entradas; su salida VAE se conecta al VAEDecode.
- VAEDecode recibe además el LATENT final desde SamplerCustomAdvanced y genera una salida IMAGE.

12️⃣ SaveImage + PreviewImage

Qué hace: los nodos finales del flujo permiten guardar la imagen generada y visualizarla directamente en ComfyUI.
Qué tocar:
- en SaveImage, puedes cambiar la carpeta de salida (por defecto, output/flux/ComfyUI).
- PreviewImage no requiere ajustes: muestra el resultado en el lienzo.
Conexiones del nodo: ambos reciben la salida IMAGE del VAEDecode. SaveImage guarda el archivo y PreviewImage lo muestra en pantalla.

▶️ Ejecutar y generar tu imagen

Verifica que todos los modelos están bien cargados.
Ajusta tu prompt (en inglés da mejores resultados).
Cambia resolución, sampler o pasos si lo deseas.
Pulsa Run.
Visualiza el resultado con PreviewImage o abre la carpeta de salida.

💡 Consejo:Si obtienes un resultado interesante, fija la seed y modifica un solo parámetro cada vez para explorar variaciones.

🌐 Recursos útiles

🌍 Hugging Face: uno de los mayores repositorios de IA del mundo, donde encontrarás miles de modelos —incluidos los compatibles con Stable Diffusion y ComfyUI— listos para descargar y usar.
🎨CivitAI: plataforma comunitaria donde los usuarios comparten modelos, estilos, LoRAs y nodos específicos para ComfyUI, clasificados por categoría, versión y nivel de complejidad.
🧠 En Lozkorp:
- Descubre el artículo previo donde introdujimos ComfyUI dentro del ciclo “Generación de imágenes con IA en local (IV)”:🔗 Generación de imágenes con IA en local (IV) — ComfyUI
- Artículo previo de esta serie donde se muestra un workflow simple para la generación de imágenes con comfyUI usando modelos SDXL: 🔗 ComfyUI (I): Tu primer workflow con SDXL — guía paso a paso
- Archivo JSON de este ejemplo "WF_Flux_Simple_DifussionModels.json"

🗺️ Conclusión

Con este segundo artículo ya sabes cómo crear un flujo completo en ComfyUI usando modelos FLUX, desde la carga de nodos hasta la generación final de imágenes. Los modelos FLUX ofrecen una alternativa moderna, ligera y rápida a SDXL, ideal para experimentar y crear imágenes sorprendentes incluso en equipos modestos.