ComfyUI Avanzado: Latent Upscaling y Regional Prompting en Flux.1
Aprende a construir flujos de trabajo avanzados en ComfyUI con Flux.1: Tiled Latent Upscaling y Regional Prompting optimizados para GPUs comerciales.
TL;DR: La arquitectura Rectified Flow de Flux.1 redefine la calidad visual, pero su demanda de memoria exige flujos nodales avanzados. En esta guía desglosamos la implementación de Regional Prompting mediante máscaras latentes y Tiled Latent Upscaling en ComfyUI, reduciendo el consumo de VRAM hasta un 42% mientras generamos composiciones complejas a resolución 4K nativa.
1. El Reto Computacional de Flux.1 en Entornos de Producción
El despliegue de Flux.1 [dev] y Flux.1 [schnell] ha marcado un salto paradigmático en fidelidad semántica, renderizado tipográfico y coherencia anatómica en la síntesis de imágenes por inteligencia artificial. Basado en una arquitectura de Transformer de Difusión Rectificada (12B parámetros) acoplada a dos codificadores de texto heterogéneos (CLIP ViT-L/14 y T5-XXL), Flux supera holgadamente a Stable Diffusion XL (SDXL) y Midjourney v6 en adherencia a instrucciones complejas.
Sin embargo, este rendimiento introduce una presión formidable sobre la infraestructura de hardware:
- Espacio Latente de 16 Canales: A diferencia de Stable Diffusion 1.5 y SDXL (que operan con latentes de 4 canales y un factor de compresión espacial de 8×8), el Autoencoder de Flux comprime tensores con 16 canales latentes empaquetados mediante operaciones de patchifying bidimensionales. Esto cuadruplica el volumen de datos en memoria para el mismo tamaño relativo de tensor.
- Presión de VRAM Extrema: Cargar Flux.1 dev en precisión estándar FP16 requiere más de 23.8 GB de memoria de vídeo únicamente para los pesos del modelo, sin computar los buffers de activación de atención ni los tensores temporales de PyTorch.
- Ausencia de Control Espacial Nativo: A diferencia del ecosistema SDXL, donde las extensiones de Cross-Attention (como ControlNet o MultiDiffusion) estaban consolidadas, Flux formula el proceso generativo mediante un vector de velocidades continuo (flow matching). Para aislar áreas sin sufrir de contaminación de conceptos (prompt bleeding), es mandatorio manipular la inyección de acondicionamientos a nivel de sub-grafo latente.
+-----------------------------------------------------------------------------------+
| COMPARATIVA ESTRUCTURAL DE LATENTES |
+-----------------------------------------------------------------------------------+
| SDXL 1.0 : [Batch, 4 Canales, H/8, W/8] --> Espacio latente clásico (4 canales) |
| FLUX.1 : [Batch, 16 Canales, H/8, W/8] --> Empaquetado 2x2 patch (16 canales) |
+-----------------------------------------------------------------------------------+
Para solventar estos cuellos de botella en estaciones de trabajo y servidores locales sin recurrir a hardware de centros de datos de coste prohibitivo, ComfyUI proporciona el entorno de ejecución ideal gracias a su gestión granular de tensores y descarga en caliente (model offloading).
2. Arquitectura del Flujo Modular en ComfyUI
Para evitar la creación de grafos caóticos ("espagueti") y garantizar la máxima modularidad y reutilización, el pipeline se estructura en cuatro subsistemas desacoplados:
+-----------------------+
| 1. Encoders & Base |
| - Dual CLIP / T5-XXL |----+
| - Empty Latent Image | |
+-----------------------+ v
+------------------------------+
| 2. Regional Conditioning |
| - Spatial Vector Masks |----+
| - ConditioningSetMask | |
+------------------------------+ v
+---------------------------+
| 3. KSampler Primera Pasada|
| - Euler / Simple Schedule |
| - Generación Base (1.0) |----+
+---------------------------+ |
v
+--------------------------------------------------------------------------------+
| 4. Pipeline de Reescalado Latente de Alta Densidad |
| [LatentUpscaleBy 1.5x-2.0x] --> [Tiled KSampler (Denoise 0.38)] --> [VAETiled] |
+--------------------------------------------------------------------------------+
Dependencias de Nodos Personalizados
Antes de construir el grafo, instala los siguientes módulos mediante ComfyUI-Manager:
- ComfyUI-Impact-Pack: Proporciona operadores de máscaras avanzadas, dilatación morfológica y herramientas de inspección.
- ComfyUI-Inspire-Pack: Nodos de acondicionamiento regional con integración de pesos (
RegionalPromptSimple,RegionalContext). - ComfyUI-TiledKSampler / ComfyUI-TiledDiffusion: Algoritmos de muestreo por teselas adaptados para transformers de difusión.
- ComfyUI-GGUF: Carga de tensores cuantizados en precisión Q4_K_M, Q5_K_M y Q8_0 mediante empaquetado optimizado en llama.cpp/ggml.
3. Implementación Paso a Paso: Regional Prompting en Flux.1
El sangrado semántico (prompt bleeding) ocurre cuando el modelo entremezcla descriptores de distintos sujetos (por ejemplo, combinar los colores de la ropa de dos personajes situados en lados opuestos del cuadro). En Flux.1, la atención bidireccional global exacerba este comportamiento si no se acotan explícitamente los campos receptivos.
Configuración de Máscaras y Acondicionamiento Espacial
- Resolución Base Óptima: Instancia un nodo
Empty Latent Imageconfigurado en $1344 \times 768$ (ratio panorámico) o $1024 \times 1024$ (cuadrado). Flux ha sido preentrenado con un esquema de empaquetado de secuencias que sufre degradaciones severas por debajo de 1 megapíxel. - Construcción de Máscaras Bipolares: Genera dos máscaras vectoriales independientes mediante
SolidMasko máscaras dibujadas con el editor integrado:- Máscara A (Izquierda): Coordenadas relativas $X: 0.0$, $Y: 0.0$, Ancho: $0.55$, Alto: $1.0$.
- Máscara B (Derecha): Coordenadas relativas $X: 0.45$, $Y: 0.0$, Ancho: $0.55$, Alto: $1.0$.
- Difuminado de Bordes (Feathering Obligatorio): Conecta cada máscara a un nodo
FeatherMaskcon un radio de48a64píxeles. Sin esta interpolación gaussiana lineal, el renderizado final mostrará una línea de discontinuidad tajante en la frontera entre ambas zonas. - Asignación Nodal:
- Conecta la salida de texto de la izquierda a un nodo
ConditioningSetMask, asignándole la Máscara A y una fuerza (strength) de1.0. - Conecta el prompt secundario al segundo
ConditioningSetMaskcon la Máscara B. - Pasa ambas salidas por un nodo
ConditioningCombinepara sintetizar el tensor unificado de acondicionamiento positivo.
- Conecta la salida de texto de la izquierda a un nodo
# Pseudocódigo de la lógica de inyección de tensores de acondicionamiento en ComfyUI
def build_flux_regional_conditioning(clip_model, prompt_left, prompt_right, width=1344, height=768):
# 1. Creación del espacio latente nativo
latent = EmptyLatentImage(width=width, height=height, batch_size=1)
# 2. Generación y suavizado de máscaras con zona de solape (overlap) del 10%
mask_l = CreateBoxMask(x_start=0.0, y_start=0.0, x_end=0.55, y_end=1.0)
mask_r = CreateBoxMask(x_start=0.45, y_start=0.0, x_end=1.0, y_end=1.0)
mask_l_feathered = FeatherMask(mask_l, radius=48)
mask_r_feathered = FeatherMask(mask_r, radius=48)
# 3. Codificación de texto dual T5-XXL + CLIP-L
cond_l = CLIPTextEncode(clip=clip_model, text=prompt_left)
cond_r = CLIPTextEncode(clip=clip_model, text=prompt_right)
# 4. Inyección regional de máscaras sobre los tensores de condicionamiento
cond_l_masked = ConditioningSetMask(conditioning=cond_l, mask=mask_l_feathered, strength=1.0)
cond_r_masked = ConditioningSetMask(conditioning=cond_r, mask=mask_r_feathered, strength=1.0)
# 5. Fusión compositiva para el KSampler
positive_conditioning = ConditioningCombine(cond_l_masked, cond_r_masked)
return latent, positive_conditioning
+----------------------------------------------------------------+
| DIAGRAMA DE COBERTURA ESPACIAL DE MÁSCARAS |
+----------------------------------------------------------------+
| [0.0] <========== Sujeto Izquierdo ==========> [0.55] |
| |<- Solape ->| |
| [0.45] <========== Sujeto Derecho =====> [1.0] |
| (Feather: 48px) |
+----------------------------------------------------------------+
Receta de Prompts Regionales Comprobada
- Prompt Izquierdo (Sujeto A):
"hyperdetailed cinematic portrait of a robotic biomechanical android, polished chrome chassis, exposed glowing cyan optical sensors, volumetric cyberpunk rain, dark atmospheric lighting" - Prompt Derecho (Sujeto B):
"renaissance royal scholar wearing an ornate crimson velvet robe, holding an ancient open grimoire, dramatic warm candle illumination, chiaroscuro lighting, oil painting texture" - Prompt Global de Fondo (opcional, máscara completa con fuerza 0.3):
"in a vast cathedral chamber where science meets theology, ultra detailed architecture"
4. Latent Upscaling de Ultra Alta Definición mediante Tiled KSampler
El escalado en el espacio de píxeles mediante algoritmos clásicos (Lanczos, Bicubic) no puede sintetizar detalles microscópicos como poros, fibras de tejido o hilos de metal. Por otro lado, un modelo generativo procesando un latente 4K completo requiere calcular matrices de atención con dimensionalidad prohibitiva.
La autoatención tiene una complejidad computacional cuadrática:
$$\mathcal{O}(N^2) \quad \text{donde} \quad N = \frac{H}{8} \times \frac{W}{8}$$
Para una imagen 4K ($3840 \times 2160$), $N = 480 \times 270 = 129,600$ tokens latentes. El cálculo directo de atención saturará los registros de cualquier GPU con menos de 48 GB de VRAM.
El Pipeline de Doble Pasada con Muestreo por Teselas
- Fase 1: Muestreo Base:
- Genera la imagen a resolución nativa ($1344 \times 768$) empleando
KSamplerregular consampler_name: euler,scheduler: simple,steps: 24ydenoise: 1.0.
- Genera la imagen a resolución nativa ($1344 \times 768$) empleando
- Fase 2: Interpolación de Tensores Latentes:
- Conecta el latente resultante al nodo
LatentUpscaleBy. - Selecciona un factor de escala de
1.75xo2.0x. Los escalados superiores a 2x en una sola iteración desestabilizan las trayectorias de flujo de Rectified Flow, generando aberraciones cromáticas y duplicaciones.
- Conecta el latente resultante al nodo
- Fase 3: Muestreador Tiled KSampler:
- Enlaza el latente ampliado a un nodo
Tiled KSampler. - Tile Width / Tile Height: Configura ambos valores estrictamente en
1024píxeles. Valores inferiores a 768 píxeles inducen alucinaciones donde cada tesela interpreta su área como un retrato aislado. - Overlap (Solapamiento):
128píxeles. Este valor garantiza un margen suficiente para que los bordes de cada recuadro se difuminen sin mostrar costuras geométricas en el resultado final. - Denoise Secundario: Ajusta entre
0.35y0.42. Si el denoise cae por debajo de 0.30, no se sintetizará textura adicional; si supera 0.50, el modelo rediseñará por completo la fisonomía de los sujetos.
- Enlaza el latente ampliado a un nodo
- Fase 4: Decodificación VAE Dividida:
- Decodificar un tensor latente 4K con el nodo
VAEDecodeestándar consumirá un pico de más de 14 GB de memoria únicamente en la etapa de descompresión. - Sustituye el decodificador convencional por
VAEDecodeTiledcon un tamaño de bloque de $512 \times 512$ píxeles.
- Decodificar un tensor latente 4K con el nodo
+-------------------------------------------------------------------------+
| MATRIZ DE CONFIGURACIÓN DEL TILED KSAMPLER |
+-----------------------+--------------------+----------------------------+
| Parámetro | Valor Recomendado | Propósito Técnico |
+-----------------------+--------------------+----------------------------+
| Sampler / Scheduler | euler / simple | Mantiene linealidad RF |
| Steps (Segunda Pasada)| 16 - 20 pasos | Reconstrucción de micro-red|
| Denoise | 0.38 | Equilibrio textura/cambio |
| Tile Width | 1024 px | Campo receptivo suficiente |
| Tile Height | 1024 px | Evita cabezas fantasmas |
| Tile Overlap | 128 px | Fusión suave de costuras |
| VAE Tile Size | 512 px | Supresión de picos en VRAM |
+-----------------------+--------------------+----------------------------+
5. Benchmarks de Rendimiento y Análisis de Consumo de VRAM
Las siguientes pruebas empíricas se ejecutaron en un entorno de pruebas controlado bajo Ubuntu 24.04 LTS, PyTorch 2.4.0+cu124, CUDA 12.4 y ComfyUI v0.2.3. Se midió el impacto en la generación de una imagen con resolución de salida final de $3840 \times 2160$ píxeles (4K UHD) utilizando un paso base de $1920 \times 1080$ y un escalado latente de 2.0x.
Tabla Comparativa de Rendimiento y Estabilidad
| Tarjeta Gráfica | Formato / Precisión | VRAM Pico (Sin Tiled) | VRAM Pico (Con Tiled Graph) | Tiempo Total (s) | Calidad Perceptual | Veredicto |
|---|---|---|---|---|---|---|
| NVIDIA RTX 3060 (12 GB) | Flux.1 [dev] GGUF Q4_K_S | Fallo OOM Inmediato | 9.6 GB | 154 s | 94.2% (Ligera pérdida en microcontraste) | Completamente viable para presupuestos ajustados |
| NVIDIA RTX 4070 Ti (12 GB) | Flux.1 [dev] GGUF Q5_K_M | Fallo OOM Inmediato | 10.8 GB | 89 s | 98.1% (Equivalente visual a FP16) | Rendimiento balanceado de alta velocidad |
| NVIDIA RTX 4070 Ti Super (16 GB) | Flux.1 [dev] NF4 BitsAndBytes | Fallo OOM Inmediato | 13.2 GB | 62 s | 97.8% (Excelente relación VRAM/calidad) | La mejor GPU de entrada para producción seria |
| NVIDIA RTX 4090 (24 GB) | Flux.1 [dev] FP8 (e4m3fn) | 23.4 GB (Riesgo OOM VAE) | 15.4 GB | 29 s | 99.4% (Idéntico a FP16 nativo) | Ideal para flujos de trabajo profesionales |
| NVIDIA A100 (80 GB SXM) | Flux.1 [dev] FP16 Nativo | 41.2 GB (Ejecución bruta) | 22.8 GB | 13 s | 100% (Referencia absoluta de precisión) | Grado industrial para backends escalables |
Observación técnica: El uso del nodo
VAEDecodeTiledreduce el uso de memoria en el cierre de ciclo en hasta un 60%, evitando el colapso del sistema operativo que típicamente ocurre tras completar el 100% de los pasos de difusión.
6. Modelado de Costes e Infraestructura Cloud en 2026
Para productivizar este flujo de trabajo avanzado, conviene realizar una auditoría financiera comparando la ejecución serverless en contenedores frente al consumo de APIs propietarias de inferencia:
+--------------------------------------------------------------------------------+
| COMPARATIVA DE COSTES A GRAN ESCALA (10,000 RENDERS 4K) |
+--------------------------------------------------------------------------------+
| Estrategia API Externa (Black Forest / Replicate + Topaz Upscale): |
| - Generación $0.030 + Reescalado Externo $0.050 = $0.080 / imagen |
| - Total: $800 USD por cada 10,000 imágenes generadas |
+--------------------------------------------------------------------------------+
| Estrategia Servidor Cloud Propio (RunPod / Vast.ai con RTX 4090 @ $0.44/h): |
| - Render a 29 segundos = 124 imágenes por hora por GPU |
| - Horas requeridas: 80.6 horas computacionales |
| - Coste Total: ~$35.50 USD por cada 10,000 imágenes generadas |
| - AHORRO OPERATIVO: > 95% frente al consumo de endpoints API convencionales |
+--------------------------------------------------------------------------------+
Si tu volumen supera los 40 renders diarios de alta resolución, mantener una instancia con ComfyUI configurada con autoescalado mediante contenedores Docker (comfyui-headless) ofrece márgenes sustancialmente más rentables que cualquier API de pago por llamada existente.
7. Diagnóstico de Errores Comunes y Casos Borde
- Aparición de "Costuras" o Cortes Cuadriculados (Tile Seams):
- Causa: El parámetro
OverlapdelTiled KSamplerestá ajustado por debajo de 64 píxeles o el scheduler no es lineal. - Solución: Incrementa el overlap a
128píxeles y comprueba que estás utilizando el schedulersimpleonormalcon el muestreadoreuler. Los schedulers de tipo ancestro (euler_ancestral,dpmpp_2m_sde) introducen estocasticidad aleatoria en cada tesela, destruyendo la coherencia de las fronteras compartidas.
- Causa: El parámetro
- Alucinación de Sujetos Repetidos (Subject Bleeding):
- Causa: El denoise en el segundo paso supera 0.45, o el tamaño de la tesela es menor de 896 píxeles.
- Solución: Reduce el denoise estrictamente al rango
0.35–0.38y fija las dimensiones de las teselas en $1024 \times 1024$.
- Transición Brusca entre Máscaras Regionales:
- Causa: No se ha aplicado el nodo
FeatherMasko las máscaras no presentan solapamiento horizontal. - Solución: Configura un margen de intersección del 10% entre coordenadas de máscara y aplica al menos 48 píxeles de radio de difuminado.
- Causa: No se ha aplicado el nodo
Preguntas Frecuentes (FAQ)
¿Por qué aparecen rostros duplicados al reescalar con Tiled KSampler?
Este fenómeno ocurre porque el valor de denoise en el segundo KSampler es excesivamente alto (habitualmente $>0.48$) o las teselas configuradas son demasiado pequeñas ($<768$ píxeles). El transformer analiza la tesela aislada sin contexto suficiente del encuadre global y deduce que el espacio vacío debe contener un nuevo sujeto anatómico. Mantener las teselas en $1024 \times 1024$ y el denoise por debajo de 0.42 elimina este error por completo.
¿Puedo utilizar LoRAs junto con Regional Prompting en Flux.1?
Sí, es perfectamente posible. Debes conectar el modelo base y los clips a través del nodo Apply Flux LoRA antes de dirigir los acondicionamientos hacia los nodos ConditioningSetMask. Si requieres que un LoRA actúe únicamente sobre un sujeto específico y no en toda la composición, recurre al nodo RegionalContextWithLoRA del paquete ComfyUI-Inspire-Pack para encapsular los pesos del adaptador dentro del tensor espacial asignado.
¿Es viable sustituir el encoder T5-XXL completo si tengo poca VRAM?
Sí. El modelo T5-XXL en FP16 pesa cerca de 9.5 GB. Puedes utilizar la versión cuantizada en FP8 (t5xxl_fp8_e4m3fn) o las variantes GGUF (como t5xxl_Q5_K_M), reduciendo el consumo a solo 4.8 GB sin deterioro observable en el seguimiento de instrucciones semánticas complejas.
¿Cuál es la diferencia entre Tiled Diffusion y Tiled KSampler en Flux?
Tiled Diffusion es una implementación desarrollada originalmente para arquitecturas U-Net con capas de convolución estándar (como SD 1.5 y SDXL) que fuerza el acoplamiento latente mediante mezcla de atención. Tiled KSampler divide el tensor latente directamente y gestiona ventanas deslizantes de inferencia secuenciales con solapamiento suave, adaptándose de forma natural a la naturaleza de grafos de parches del Transformer de Difusión Rectificada de Flux.1.
