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:

  1. 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.
  2. 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.
  3. 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

  1. Resolución Base Óptima: Instancia un nodo Empty Latent Image configurado 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.
  2. Construcción de Máscaras Bipolares: Genera dos máscaras vectoriales independientes mediante SolidMask o 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$.
  3. Difuminado de Bordes (Feathering Obligatorio): Conecta cada máscara a un nodo FeatherMask con un radio de 48 a 64 píxeles. Sin esta interpolación gaussiana lineal, el renderizado final mostrará una línea de discontinuidad tajante en la frontera entre ambas zonas.
  4. 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) de 1.0.
    • Conecta el prompt secundario al segundo ConditioningSetMask con la Máscara B.
    • Pasa ambas salidas por un nodo ConditioningCombine para sintetizar el tensor unificado de acondicionamiento positivo.
# 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

  1. Fase 1: Muestreo Base:
    • Genera la imagen a resolución nativa ($1344 \times 768$) empleando KSampler regular con sampler_name: euler, scheduler: simple, steps: 24 y denoise: 1.0.
  2. Fase 2: Interpolación de Tensores Latentes:
    • Conecta el latente resultante al nodo LatentUpscaleBy.
    • Selecciona un factor de escala de 1.75x o 2.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.
  3. Fase 3: Muestreador Tiled KSampler:
    • Enlaza el latente ampliado a un nodo Tiled KSampler.
    • Tile Width / Tile Height: Configura ambos valores estrictamente en 1024 píxeles. Valores inferiores a 768 píxeles inducen alucinaciones donde cada tesela interpreta su área como un retrato aislado.
    • Overlap (Solapamiento): 128 pí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.35 y 0.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.
  4. Fase 4: Decodificación VAE Dividida:
    • Decodificar un tensor latente 4K con el nodo VAEDecode estándar consumirá un pico de más de 14 GB de memoria únicamente en la etapa de descompresión.
    • Sustituye el decodificador convencional por VAEDecodeTiled con un tamaño de bloque de $512 \times 512$ píxeles.
+-------------------------------------------------------------------------+
|               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 VAEDecodeTiled reduce 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

  1. Aparición de "Costuras" o Cortes Cuadriculados (Tile Seams):
    • Causa: El parámetro Overlap del Tiled KSampler está ajustado por debajo de 64 píxeles o el scheduler no es lineal.
    • Solución: Incrementa el overlap a 128 píxeles y comprueba que estás utilizando el scheduler simple o normal con el muestreador euler. Los schedulers de tipo ancestro (euler_ancestral, dpmpp_2m_sde) introducen estocasticidad aleatoria en cada tesela, destruyendo la coherencia de las fronteras compartidas.
  2. 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.38 y fija las dimensiones de las teselas en $1024 \times 1024$.
  3. Transición Brusca entre Máscaras Regionales:
    • Causa: No se ha aplicado el nodo FeatherMask o 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.

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.

Leave a Reply

Your email address will not be published. Required fields are marked *