top of page

Serie ComfyUI (XV) — ControlNet + LoRA en FLUX: nuevas opciones para control de forma y estilo

  • hace 6 días
  • 13 Min. de lectura

Continuamos la Serie ComfyUI, dedicada a entender y dominar la generación de imágenes con IA en local.

En artículos anteriores ya habíamos trabajado dos herramientas fundamentales por separado:


Y más recientemente vimos cómo combinarlas en SDXL para controlar al mismo tiempo la estructura y la estética de una imagen. Pero llega un momento en el que surge una pregunta natural: ¿Cómo se hace esto mismo en FLUX?


Y la respuesta no es simplemente “igual que en SDXL”, porque FLUX introduce otra forma de trabajar:

  • otra arquitectura

  • otro flujo de nodos

  • otra forma de cargar modelo, texto y muestreo

  • y también nuevas posibilidades para construir workflows más avanzados


Diagrama de flujo con imágenes de una catedral y un edificio iluminado. Texto: "Workflow ControlNet + LoRA FLUX". Logo de LozKorp.
ControlNet + LoRA en Flux

En este artículo vamos a dar ese salto. Trabajaremos con un workflow real en FLUX dev, combinando:

  • ControlNet para mantener la estructura

  • LoRA para transformar el estilo

Y lo haremos con un caso muy visual: partiremos de una imagen de una catedral gótica y la reinterpretaremos en estilo cyberpunk. Así veremos con claridad cómo FLUX permite conservar la forma de una imagen mientras empuja el resultado hacia una estética completamente distinta.


🎯 Qué vas a lograr

Al finalizar este artículo serás capaz de:

  • Entender cómo combinar ControlNet y LoRA en FLUX dentro de un mismo workflow en ComfyUI.

  • Comprender las diferencias clave respecto a SDXL:

    • nueva arquitectura

    • nuevo flujo de nodos

    • nueva forma de trabajar el muestreo

  • Construir un workflow completo basado en:

    • FLUX dev como modelo base

    • ControlNet Union Pro para control estructural

    • LoRA model-only para modificar el estilo

  • Aplicar control estructural a partir de una imagen real usando:

    • preprocesado Canny

    • y ControlNet para mantener la forma

  • Transformar completamente la estética de una imagen sin perder su estructura original.

  • Reutilizar este workflow como base para:

    • proyectos creativos

    • pipelines más complejos

    • y experimentación avanzada con FLUX

No se trata de replicar SDXL en FLUX. Se trata de entender cómo FLUX resuelve el mismo problema de forma distinta

🧩 Requisitos

Para seguir este artículo y ejecutar correctamente el workflow ControlNet + LoRA en FLUX, necesitas lo siguiente:

💻 Entorno

  • ComfyUI instalado y funcionando correctamente. Preferiblemente con GPU (recomendado para FLUX dev)

🧠 Modelo base (FLUX)

Este workflow utiliza:

💡 Nota:

  • La versión fp8 reduce el consumo de memoria y mejora la velocidad

  • A costa de una ligera pérdida de precisión (normalmente poco perceptible)

🧠 Encoders de texto (muy importante en FLUX)

En este workflow usamos:

🎨 LoRA

En este artículo utilizamos: cyberflies_lora_flux_f16.safetensors (https://civitai.com/models/579328/cyberflies-lora-fluxxl)

🧠 ControlNet

Usamos: FLUX.1-dev-ControlNet-Union-Pro.safetensors (https://huggingface.co/Shakker-Labs/FLUX.1-dev-ControlNet-Union-Pro/tree/main)

🧠 VAE


🗂️ Crear o cargar el workflow en ComfyUI

Tienes dos maneras de trabajar con este flujo:

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

1️⃣ Descarga el archivo JSON adjunto:📁  wf_ComfyUI_FLUX_DEV_ControlNet_LoRA_Simple.json


2️⃣ Abre ComfyUI.

3️⃣ En el menú superior selecciona:Workflow → Load

4️⃣ Carga el archivo JSON. Verás en el lienzo todos los nodos conectados y listos para funcionar.


Interfaz de software con menú resaltado. Botones "Workflow" y "Open" en rosa. Flecha apunta a diagrama colorido en fondo gris.
Cargar workflow en ComfyUI

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

Si prefieres entenderlo pieza a pieza, puedes recrearlo manualmente. En la siguiente sección explicamos qué hace cada bloque del flujo.


Interfaz de software con menú desplegable resaltado. Botón "New" y flecha magenta apuntan a área de trabajo en blanco. Textos: "Workflow", "Edit".
Empezar con Workflow en blanco

🧠 Qué cambia realmente al usar FLUX

Hasta ahora, en la serie, hemos trabajado principalmente con Stable Diffusion (SDXL), y eso implica una forma bastante concreta de construir workflows: un checkpoint central, prompts codificados con CLIP, ControlNet aplicado sobre la difusión y un bloque principal de generación (KSampler).


FLUX rompe ese esquema. FLUX no es simplemente “otro checkpoint”. Es una arquitectura distinta

Y eso cambia cómo se construye el workflow.


🧩 Diferencia 1 — Modelo + encoders separados

En SDXL:

  • el modelo incluye todo lo necesario

En FLUX:

  • el modelo se divide en varias piezas:

    • modelo de difusión (UNET)

    • encoder T5

    • encoder CLIP

👉 Por eso aparece el nodo:

  • DualCLIPLoader (T5 + CLIP)


🧠 Diferencia 2 — T5 cambia cómo funcionan los prompts

En SDXL:

  • CLIP interpreta prompts de forma más “etiquetada”

En FLUX:

  • T5 interpreta lenguaje más natural. Esto da mejor coherencia, mejor comprensión semántica y menos necesidad de “trucos”


⚙️ Diferencia 3 — El flujo de generación

En SDXL tienes:

  • un nodo central: KSampler

En FLUX el flujo se divide en:

  • BasicScheduler → define el proceso

  • BasicGuider → aplica el conditioning

  • SamplerCustomAdvanced → ejecuta la generación

👉 Esto da más control, pero también cambia cómo piensas el workflow.


🎛️ Diferencia 4 — LoRA model-only

En SDXL:

  • LoRA modifica modelo y CLIP

En FLUX:

  • usamos LoraLoaderModelOnly. El LoRA afecta solo al modelo. Esto hace que el estilo sea más controlado y menos invasivo en el texto


🧠 Diferencia 5 — ControlNet en FLUX

En SDXL:

  • ControlNet está muy estandarizado

En FLUX:

  • está evolucionando

  • hay múltiples enfoques y aparecen modelos como Union Pro

👉 Esto abre más posibilidades… pero también requiere entender mejor lo que estás haciendo.


⚖️ Resumen rápido

Aspecto

SDXL

FLUX

Arquitectura

integrada

modular

Prompt

CLIP

T5 + CLIP

Generación

KSampler

Scheduler + Guider + Sampler

LoRA

modelo + CLIP

modelo only

ControlNet

estándar

flexible / en evolución

No estás cambiando de modelo. Estás cambiando de forma de trabajar

Esto significa que no puedes copiar workflows de SDXL, tienes que entender cada bloque y construir de forma más consciente. Pero a cambio tienes más control, más flexibilidad y más capacidad de escalar workflows


⚙️ El workflow: estructura general

La lógica del workflow es la siguiente:

Imagen → Canny → ControlNetApply  Prompt → ControlNetApply → Guider  Modelo FLUX → LoRA → Scheduler / Guider  Latente + Noise → Sampler → Imagen final

El flujo completo se compone de los siguientes elementos:

Nº

Bloque

Función

1️⃣

LoadImage

Carga la imagen base

2️⃣

Canny

Extrae la estructura

3️⃣

ControlNetLoader

Carga el modelo de control

4️⃣

ControlNetApplyAdvanced

Aplica el control estructural

5️⃣

DualCLIPLoader

Carga T5 + CLIP

6️⃣

CLIPTextEncode (+)

Prompt positivo

7️⃣

CLIPTextEncode (–)

Prompt negativo

8️⃣

UNETLoader

Carga FLUX dev

9️⃣

LoraLoaderModelOnly

Aplica el estilo

🔟

BasicScheduler

Define el proceso de difusión

1️⃣1️⃣

BasicGuider

Combina modelo y prompt

1️⃣2️⃣

RandomNoise

Genera el ruido inicial

1️⃣3️⃣

EmptyLatentImage

Define la resolución

1️⃣4️⃣

SamplerCustomAdvanced

Genera la imagen

1️⃣5️⃣

VAEDecode

Convierte a imagen

1️⃣6️⃣

SaveImage / Preview

Visualiza y guarda

🔗 Cómo fluye la información

En este workflow hay tres flujos principales que se combinan:

🧠 1. Flujo de estructura (ControlNet)

Imagen → Canny → ControlNet

👉 Define: la forma, la composición y la la geometría


🎨 2. Flujo de estilo (LoRA)

Modelo FLUX → LoRA

👉 Define: estética, iluminación y lenguaje visual


📝 3. Flujo de intención (Prompt)

Prompt → ControlNet → Guider

👉 Define: qué quieres generar y cómo interpretar la escena


🧱 Entendiendo el workflow paso a paso

1️⃣ LoadImage (imagen base)

Qué hace: carga la imagen de entrada que se utilizará como referencia estructural. En este caso nuestra imagen se llama Catedral_Leon.png 

Qué tocar:

  • La imagen de entrada. Cuanto más clara sea la estructura, mejor funcionará el control.

Salida:

  • IMAGE → Canny


Interfaz de usuario mostrando proceso de edición de imagen. Vista de catedral en imagen con bordes resaltados. Texto visible: "Catedral_Leon.png".
Load Image & Canny & Load ControlNet Model

2️⃣ Canny (preprocesado)

Qué hace: convierte la imagen en un mapa de bordes que servirá como guía para ControlNet.

Qué tocar:

  • low: 0.1

  • high: 0.3

👉 Ajuste típico:

  • valores bajos → más detalle

  • valores altos → menos ruido

Salida:

  • IMAGE → ControlNetApplyAdvanced

  • IMAGE → Preview (visualización)


3️⃣ ControlNetLoader

Qué hace: carga el modelo de ControlNet. Debe ser compatible con FLUX dev.

Qué tocar:

  • Seleccionar el modelo ControlNet

  • En este workflow:

Salida:

  • CONTROL_NET → ControlNetApplyAdvanced


4️⃣ DualCLIPLoader (T5 + CLIP)

Qué hace: carga los encoders de texto utilizados por FLUX. 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 descargados y colocados en la carpeta correspondiente (C:\pinokio\api\comfy.git\app\models\clip). Puedes probar otros CLIP si deseas estilos de interpretación distintos.

Salida:

  • CLIP → CLIPTextEncode (+ / –)


Diagrama de flujo de un proceso de codificación con nodos llamados CLIP, que incluyen instrucciones de texto, ControlNet y carga de VAE.
DualCLIPLoader & CLIP Text Encoder (positive & negative) & Load VAE and Apply ControlNet

5️⃣ CLIPTextEncode (prompt positivo)

Qué hace: convierte el prompt positivo en instrucciones para el modelo.

👉 Ejemplo usado:

cyberpunk gothic cathedral at night, neon lights illuminating gothic structures, rain, wet surfaces, reflections, fog, dramatic cinematic lighting, futuristic reinterpretation, ultra detailed, moody atmosphere, cyberflies

Qué tocar:

  • El contenido del prompt. Debe reforzar tanto el el estilo (LoRA) como la intención visual

  • Revisa la documentación del LoRA que uses ya que podría haber "palagras trigger" que tengas que añadir en el prompt para "activar" el uso del LoRA.

Salida:

  • CONDITIONING → ControlNetApplyAdvanced


6️⃣ CLIPTextEncode (prompt negativo)

Qué hace: indica qué debe evitar el modelo. En este workflow está vacío.

Qué tocar:

  • Añadir términos si aparecen errores,

Ejemplo:

  • photorealistic, blurry, low quality, artifacts

Salida:

  • CONDITIONING → ControlNetApplyAdvanced


7️⃣ ControlNetApplyAdvanced

Qué hace: aplica el control estructural combinando: prompt, Imagen (Canny), modelo ControlNet y el VAE

Qué tocar:

  • strength: 0.75

  • start: 0

  • end: 0.8

👉 Interpretación:

  • fuerza alta → más fidelidad estructural

  • rango limitado → deja libertad al final

Salida:

  • CONDITIONING (positive) → BasicGuider


8️⃣ UNETLoader (modelo FLUX)

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.

Salida:

  • MODEL → LoRALoaderModelOnly


Diagrama de flujo con bloques morados y grises conectados por líneas. Texto visible: "Load Diffusion Model", "LoraLoaderModelOnly", "BasicScheduler".
Load Difussion Model & LoraLoaderModelOnly

9️⃣ LoraLoaderModelOnly (estilo)

Qué hace: aplica el LoRA directamente sobre el modelo.

Qué tocar:

  • LoRA: seleccionamos un LoRA que tiene que ser compatible con FLUX

  • strength_model (fuerza): 0.8. Más alto → estilo más fuerte

Salida:

  • MODEL → Scheduler y Guider


🔟 BasicScheduler

Qué hace: define el proceso de difusión. 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 fina

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).

Salida:

  • SIGMAS → Sampler


Diagrama de flujo de procesos con bloques conectados que incluyen "BasicScheduler", "RandomNoise" y "Save Image". Fondo gris, borde colorido.
Nodos alrededor de SamplerCustomAdvanced

1️⃣1️⃣ BasicGuider

Qué hace: combina el modelo (MODEL) y el prompt codificado (CONDITIONING del ControlNet) para guiar la generación. Es 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.

Salida:

  • GUIDER → Sampler


1️⃣2️⃣ 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.

Salida:

  • SAMPLER → Sampler


1️⃣3️⃣ 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.

Salida:

  • NOISE → Sampler


1️⃣4️⃣ 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 en nuestro caso: 768 ×1152 y 1 imagen por ejecución.

  • Para seleccionar las dimensiones deberías tener en cuenta las dimensiones de la imagen de entrada.

Salida:

  • LATENT → Sampler


1️⃣5️⃣ 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:

  • normalmente nada (control indirecto desde otros nodos)

Salida:

  • LATENT → VAEDecode


1️⃣6️⃣ VAELoader + 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.

Salida:

  • IMAGE → Preview / Save


1️⃣7️⃣ PreviewImage / SaveImage

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.

Salida:

  • imagen final


🎛️ Ajustes clave: cómo controlar el resultado

Una vez que el workflow funciona, el resultado final depende del equilibrio entre tres elementos:

  • ControlNet → forma

  • LoRA → estilo

  • Prompt → intención

En FLUX, este equilibrio es especialmente importante, porque el modelo responde de forma más “inteligente” y menos mecánica que en SDXL.


⚙️ 1. ControlNet — control de la estructura

Es el parámetro que determina cuánto se respeta la imagen original.

  • strength alto → mantiene la forma

  • end < 1 → deja libertad al final

👉 Esto permite:

  • conservar la estructura

  • pero aplicar estilo

🎨 2. LoRA — control del estilo

Define cómo se ve la imagen.

  • más alto → estilo dominante

  • más bajo → resultado más neutro

📝 3. Prompt — dirección del resultado

El prompt define cómo se interpreta la escena.


🧪 Casos típicos y cómo corregirlos

Cuando combinas ControlNet + LoRA en FLUX, los problemas suelen venir de un mal equilibrio entre estructura, estilo e intención. Aquí tienes una guía rápida para identificar y corregir los casos más habituales.

Caso

Qué ocurre

Causa probable

Solución

🔴 Imagen rígida, poco natural

La estructura domina completamente

ControlNet demasiado fuerte

Bajar strength (0.75 → 0.6) o reducir end (0.8 → 0.6)

🔴 El estilo apenas se nota

Imagen demasiado neutra

ControlNet alto o LoRA bajo

Bajar ControlNet o subir ligeramente el LoRA

🔴 Imagen deformada

Pérdida de estructura original

LoRA demasiado fuerte

Bajar peso del LoRA (0.8 → 0.6)

🔴 Resultado caótico

Falta de coherencia visual

Prompt poco claro o conflictivo

Simplificar y reforzar el prompt

🔴 Exceso de líneas o ruido

Demasiado detalle estructural

Canny demasiado sensible

Subir low/high o usar imagen más limpia

🔴 Resultado impredecible

Cambios difíciles de entender

Se modifican muchas variables a la vez

Aplicar regla: una variable por iteración

🔴 La imagen “no parece FLUX”

Resultado plano o sin carácter

Prompt pobre o LoRA mal integrado

Añadir contexto y reforzar estilo en el prompt

Si algo no funciona:1️⃣ Revisa ControlNet2️⃣ Revisa LoRA3️⃣ Revisa el prompt4️⃣ Ajusta una sola variable

👉 Y vuelve a probar


🔁 Qué puedes probar a continuación

Una vez que entiendes cómo combinar ControlNet + LoRA en FLUX, el siguiente paso es experimentar de forma controlada.

Aquí tienes varias pruebas que te ayudarán a dominar realmente este tipo de workflows.

Prueba

Qué hacer

Qué vas a observar

🧪 Cambiar la imagen de entrada

Probar con distintas imágenes: arquitectura, retratos, objetos

Cómo FLUX adapta la estructura manteniendo coherencia

🎨 Cambiar el LoRA

Mantener la misma imagen y probar distintos estilos

Cómo cambia la estética sin perder la composición

⚖️ Ajustar ControlNet

Probar valores: 0.6 / 0.75 / 0.9

Diferencias entre fidelidad estructural y libertad creativa

🎛️ Cambiar la resolución

Modificar EmptyLatentImage (ej. 768×1152 vs 1152×768)

Impacto en composición y proporciones

🧪 Modificar el prompt

Simplificar, añadir contexto o cambiar intención

Cómo FLUX interpreta lenguaje natural

🔄 Cambiar el modelo base

Probar distintas versiones de FLUX

Diferencias en comportamiento y calidad

No intentes hacer todo a la vez. El objetivo no es probar más cosas, es entender mejor lo que haces


Catedral gótica en León al día y de noche, construcción con letrero León. Mujer con bikini azul y fusil en playa soleada. Mujer en traje negro con arma de noche.
Ejemplos de uso de este workflow

🗺️ Conclusión

En este artículo has dado un paso importante dentro de la serie: pasar de trabajar en SDXL a entender cómo construir workflows en FLUX, yeso no es solo un cambio de modelo. Es un cambio de enfoque.


El workflow de este artículo es deliberadamente simple. Porque el valor real no está en el JSON, sino en cómo equilibras:

  • la estructura (ControlNet)

  • el estilo (LoRA)

  • la intención (prompt)


A partir de ahora puedes:

  • trasladar workflows de SDXL a FLUX con criterio

  • construir flujos más flexibles y modulares

  • mantener estructura mientras transformas estilo

  • entender qué hace cada bloque del sistema

  • diseñar resultados en lugar de generarlos al azar


Este artículo abre la puerta a workflows más avanzados.

A partir de aquí puedes explorar:

  • uso de múltiples ControlNet

  • combinación de varios LoRA

  • ajuste fino del proceso de difusión

  • workflows más complejos y automatizados

Generar imágenes con IA no es cuestión de suerte, es cuestión de control

Si quieres seguir aprendiendo a dominar la IA en local y construir workflows realmente útiles:


🌐 Recursos útiles


Comentarios

© 2025 by Lozkorp                                                         

bottom of page