NitroFusion2 en una sola tarjeta: una imagen de 1024 px en 0,78 s y un cartel correcto en dos pasos

Créditos

• Dar-Yen Chen y Yi-Zhe Song (SketchX, CVSSP, Universidad de Surrey; Turing Elite Research Labs): NitroFusion2, el artículo "NitroFusion2: Bringing Adversarial Loss to the Text Stream of Multimodal Diffusion Transformers" (arXiv 2611.05648, CC BY 4.0), los pesos (Apache-2.0), la LoRA de des-destilación (el complemento de 0,38 GB), los ficheros GGUF, el código y inference.py (Apache-2.0), cuatro workflows de ComfyUI y la página del proyecto. Se apoya en NitroFusion (Dar-Yen Chen, Hmrishav Bandyopadhyay, Kai Zou y Yi-Zhe Song, CVPR 2025).
• Tongyi-MAI: Z-Image-Turbo (Apache-2.0), cuyo codificador de texto, tokenizador, VAE y scheduler reutiliza el pipeline.
• Los mantenedores de diffusers: ZImagePipeline, el cargador de LoRA de Z-Image y la carga de GGUF en un solo fichero en diffusers 0.42.1.
• PedroMarinhoDev: versiones de la comunidad para ComfyUI en int8, W6A8 y W4A8 (no las hemos probado).
• AI Search: donde lo vimos (2026-11-08 AI NEWS, capítulo en el 03:50).
• Nuestra parte: el backend personalizado, el despliegue a través de la plataforma, los tiempos, la escalera de memoria, las comprobaciones de calidad, el ejemplo del SDK y el vídeo de la demo.

Modelo y ficheros

• ChenDY/NitroFusion2: sha 62d1a7000af9c46a0c4348d936bd7670ff33c1b9, creado el 2026-10-27, modificado por última vez el 2026-11-08, sin restricción de acceso, apache-2.0, librería diffusers, pipeline text-to-image, modelo base Tongyi-MAI/Z-Image-Turbo. Publicación según la ficha: 2026-11-03.
• Transformer: ZImageTransformer2DModel de diffusers, 6.154.908.736 parámetros (la tabla 1 del artículo dice 6B, igual que Z-Image-Turbo). Bf16 en 3 fragmentos: 4.986.858.288 + 4.986.868.776 + 2.336.146.728 B (12,31 GB). Fichero único nf2-bf16.safetensors de 12.309.866.400 B. nf2-BF16.gguf y nf2-F16.gguf de 12.311.939.136 B cada uno.
• Niveles GGUF (GB): Q2_K_4XS 2,04, Q2_K_3XS 2,30, Q2_K_2XS 2,70, Q2_K_XS 3,00, Q2_K_S 3,30, Q2_K_M 3,60, Q2_K_L 4,01, Q3_K_S 4,36, Q3_K_M 4,56, Q3_K_L 4,60, Q4_0 4,59, Q4_K_S 4,79, Q4_1 4,85, Q4_K_M 5,07, Q5_0 5,26, Q5_K_S 5,29, Q5_1 5,53, Q5_K_M 5,58, Q6_K 6,10, Q8_0 7,22.
• nf2-dedistill-lora.safetensors: 381.553.336 B.
• Z-Image-Turbo sha f332072a: codificador de texto Qwen3 en 3 fragmentos (unos 8,05 GB), VAE de 167.666.902 B, y su propio transformer de unos 24,6 GB (F32), que nuestro backend no descarga. Su ficha promete una latencia por debajo del segundo en una H800 y que entra en dispositivos de consumo de 16 GB. El ejemplo de diffusers de su ficha usa num_inference_steps=9 ("This actually results in 8 DiT forwards") y guidance_scale=0.0.
• Receta de los autores (inference.py, idéntico en main de GitHub): solo de 1 a 4 pasos, shift del scheduler {1: 3.0, 2: 6.0, 3: 8.0, 4: 9.0}, sigmas 1 - i/steps, guía 0.0, escalas de LoRA {1: (0.0,), 2: (0.5, 0.0), 3: (0.5, 0.6, 0.0), 4: (0.5, 0.6, 0.7, 0.0)}, por defecto 1024 x 1024 y 2 pasos, pipe.enable_model_cpu_offload() en __main__.
• Método: Text-Stream Adversarial Distillation (cabezas discriminadoras sobre los estados intermedios de los tokens de texto del MMDiT congelado) y Aspect-Cued Discrimination (el discriminador se condiciona con pistas de tipografía, objeto, estilo, fondo, acción y composición).
• Entrenamiento según el artículo: 100k referencias sintéticas de Z-Image-Turbo con 12 pasos (EN/CN), descripciones de Qwen3.5-35B-A3B, Adam lr 5e-5, batch 256, ocho H100, 20.000 pasos (5.000 off-policy, 15.000 on-policy). No hay código de entrenamiento en el repo.
• Limitaciones según el artículo: las escenas complejas siguen costando, sobre todo con un paso; menos diversidad entre muestras (la diversidad de OneIG queda por debajo de las dos referencias con 1 y 2 pasos); un efecto balancín entre las pistas de ACD.

Tabla 1 del artículo (cifras de los autores, no reproducidas por nosotros; el texto la llama tabla 2):

Montaje y por qué

• GPU: una RTX 4090 en InferenceKey Cloud. La tarjeta se identificó como NVIDIA GeForce RTX 4090, 49140 MiB (la variante de 48 GB), así que el workload principal se ejecutó con NF2_VRAM_LIMIT_GIB=23.4 para hacer de tarjeta de 24 GB. No se usó ninguna tarjeta estándar de 24 GB. El pipeline bf16 necesita unos 22 GiB residentes, y por eso la referencia es un presupuesto de 24 GB. Después, una RTX 2000 Ada de 16 GB real (16.380 MiB, 70 W) para la comprobación con tarjeta pequeña.
• Backend: un backend de Python personalizado nuevo, NitroFusion2Backend 0.1.0 (paquete de 5.600 B), sobre ZImagePipeline de diffusers 0.42.1, con el transformer de NitroFusion2 y la LoRA como adaptador dedistill. Versiones fijadas: torch 2.14.1, transformers 5.21.0, accelerate 1.15.0, peft 0.21.2, gguf 0.19.0. Por qué personalizado: ningún backend integrado sirve el pipeline de Z-Image. Por qué diffusers: es el camino de los propios autores, y la 0.42.1 tiene el pipeline, el cargador de LoRA y el GGUF en un solo fichero para este transformer.
• Modos de memoria (NF2_MEMORY_MODE): gpu (todo residente), model (enable_model_cpu_offload, el valor por defecto del script de los autores), sequential. El valor por defecto auto elige gpu solo con al menos 23 GiB libres; si no, model. En una tarjeta de 16 GB, pon NF2_TRANSFORMER=nf2-Q4_K_M.gguf y NF2_MEMORY_MODE=gpu de forma explícita, o auto vuelve al offload y pierdes el camino de 4 s.
• Stack: un manager local de InferenceKey, nats-proxy y worker compilados desde main 97aec23e. Producción sin tocar.
• Campos de la petición (al estilo de imágenes de OpenAI): prompt (obligatorio), size ("1024x1024", lados de 256 a 2048, múltiplos de 16), seed, steps o num_inference_steps (de 1 a 4, por defecto 2), dedistill (por defecto true), output_format (png, jpeg, webp). La guía siempre es 0. La respuesta añade seconds, encode_seconds, vae_seconds, vram_peak_gib y memory_mode. Endpoint: POST /endpoint/<project>/nitrofusion2/v1/images/generations.

Paso a paso con el ejemplo del SDK

El ejemplo es el commit 1ca451bd de main de inferencekey-sdk: backend.py, publish.py, main.py, requirements.txt, README.md, .env.example.

cp .env.example .env    # INFERENCEKEY_SDK_TOKEN, INFERENCEKEY_API_KEY,
                        # INFERENCEKEY_PROJECT, IK_WORKER_ID (read by main.py)
# publish.py does not read .env: export these two in the shell
export INFERENCEKEY_TENANT_ID=<tenant-id>
export INFERENCEKEY_USER_TOKEN=<dashboard-session-token>
python publish.py       # packages backend.py into dist/ and uploads it to your tenant
IK_KEEP_ALIVE=1 python main.py

Sin INFERENCEKEY_TENANT_ID e INFERENCEKEY_USER_TOKEN, publish.py solo genera dist/*.tar.gz, imprime "upload the package from Dashboard -> Custom backends instead" y sale con 0. En ese caso, sube el fichero desde Dashboard -> Custom backends antes de ejecutar main.py, o ensure() no tendrá ningún backend que desplegar.

Para una tarjeta de 16 GB, añade a .env antes de main.py:

NF2_TRANSFORMER=nf2-Q4_K_M.gguf
NF2_MEMORY_MODE=gpu

main.py llama a ensure() para un workload fijo en IK_WORKER_ID con ready_timeout_secs: 2400, request_timeout_secs: 600 y el entorno NF2_*, espera con wait_until_ready(2400) y después hace tres llamadas a 1024 x 1024 con la semilla 42: el cartel con 1 paso, el menú con 1 paso y el menú con 2 pasos. Borra el workload al salir salvo con IK_KEEP_ALIVE=1. Disco: unos 21 GB de pesos (26 GB si además está el fichero Q4_K_M) más un venv de 5,5 GB.

Una petición suelta:

curl -s https://<api-host>/endpoint/<project>/nitrofusion2/v1/images/generations \
  -H "Authorization: Bearer $INFERENCEKEY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a cat holding a sign that says hello world",
       "size": "1024x1024", "steps": 2, "seed": 42}'

Mediciones completas

Tiempo hasta listo:

• RTX 4090: "ready after 67 s" según el SDK. Venv 28 s (CPython 3.12.3), después download 33.8s, load 4.4s, transformer bf16, memory mode gpu (budget 23.4 GiB), weights in VRAM 19.5 GiB. Caché de HF de unos 20 GB.
• RTX 2000 Ada: "ready after 76 s". download 28.4s, load 23.0s, transformer nf2-Q4_K_M.gguf, memory mode gpu (budget 15.5 GiB), weights in VRAM 12.7 GiB.

Por petición, 1024 x 1024, semilla 42, una cada vez. Tiempo de GPU medido en el backend con cuda.synchronize, ida y vuelta desde el cliente HTTP hasta el manager local.

Derivado de lo anterior, peticiones sueltas, sin batching: de 1,2 a 1,3 imágenes por segundo de tiempo de GPU con 1 paso (de 0,67 a 0,69 por ida y vuelta) y unas 0,75 con 2 pasos (de 0,50 a 0,51 por ida y vuelta). El probador de imágenes del panel mostró "ok · 1098 ms" para el póster de 1 paso.

Escalera de VRAM. Los escalones emulados se ejecutaron en un proceso aparte en la 4090 de 48 GB con torch.cuda.set_per_process_memory_fraction, junto al workload en marcha, así que sus tiempos pueden incluir algo de contención. Cada escalón ejecutó el cartel y el menú con 1 y 2 pasos, dos veces, semilla 42.

Sin probar: un codificador de texto cuantizado o en CPU para 8 GB; resoluciones distintas de 1024; las versiones de la comunidad para ComfyUI en int8, W6A8 y W4A8; batches de más de 1 y concurrencia; tarjetas reales de 12 GB y tarjetas estándar de 24 GB (no había ninguna tarjeta de 10 a 12 GB disponible); los niveles GGUF Q2, Q3, Q5 y Q6; Q8_0 con offload o en una tarjeta de 24 GB; Z-Image-Turbo con 8 pasos.

Notas de calidad (una semilla por caso, no es un benchmark)

Prompts: el cartel del gato y el retrato de los autores, más cuatro nuestros (un menú de cafetería en pizarra, un póster del tranvía de Lisboa, una partitura sobre un piano y un par de manos).

• Cartel (prompt de los autores "a cat holding a sign that says hello world"): en la 4090, 1 paso "HELLO WORd" (falta la L, d minúscula, H borrosa), 2 pasos "Hello World". Los escalones Q4 en la 4090 dieron el mismo texto que bf16. RTX 2000 Ada con Q4: 1 paso "HELLO WORLD", 2 pasos bien.
• Menú ("FLAT WHITE 3.20 / CROISSANT 2.80 / SOURDOUGH 4.50"): "SOURDOAGH" con 1, 2 y 4 pasos y con 2 sin LoRA en la 4090. RTX 2000 Ada con 1 paso: "CROSSANT" y un "0" suelto debajo de 4.50; con 2 pasos, "SOURDOAGH".
• Póster: "LISBOA" y "Tram 28 - every 12 minutes" bien con 1 y 2 pasos y en la tarjeta de 16 GB.
• Piano: el título "Nocturne No. 2 in E-flat" ilegible con 1 paso, aún imperfecto con 2. Manos creíbles.
• Retrato (prompt de los autores): limpio con 1 y 2 pasos.

Vídeo de la demo

Un recorrido narrado de 3 minutos: qué es NitroFusion2 (con la página del proyecto, las figuras y la tabla 1 de los autores, con su crédito), el panel generando con 1 y 2 pasos, y la escalera de memoria.

Problemas pendientes

1. La 4090 era una variante de 48 GB. El resultado de 24 GB es un límite (NF2_VRAM_LIMIT_GIB=23.4), no una tarjeta estándar de 24 GB. Estado: indicado, sin repetir en una tarjeta de 24 GB.
2. Valores por defecto del probador de imágenes (20 pasos, guía 4,5): devuelven un 400 NitroFusion2 is distilled for 1 to 4 steps. Estado: documentado en el README, valores por defecto de la plataforma sin cambiar.
3. Q8_0 no entra en 16 GB con el codificador de texto bf16 residente. Estado: usar Q4_K_M.
4. 8 GB falla: OOM con offload del modelo, KeyError: None con offload secuencial y un transformer GGUF. Estado: abierto, sin probar con un codificador de texto más pequeño.
5. Errores de texto con un paso, y una errata ("SOURDOAGH") con todos los números de pasos. Estado: comportamiento del modelo, coincide con la carencia en el renderizado de texto que reconoce el artículo.
6. Menor: nuestro primer SQL de siembra para el tenant de prueba local afectó por error al tenant por defecto sembrado; se corrigió antes de reiniciar el manager, sin efecto en la prueba. En el stderr del backend aparece un RuntimeWarning inofensivo sobre inferencekey.backend.serve en sys.modules.

Fuentes

• Ficha del modelo: https://huggingface.co/ChenDY/NitroFusion2
• Código e inference.py: https://github.com/ChenDarYen/NitroFusion2
• Artículo: https://arxiv.org/abs/2611.05648
• Página del proyecto: https://chendaryen.github.io/NitroFusion2.github.io/
• Modelo base: https://huggingface.co/Tongyi-MAI/Z-Image-Turbo
• Dónde lo vimos: https://www.youtube.com/watch?v=9RIK3A24ZxA (AI Search, 2026-11-08, en el 03:50)
• Ejemplo del SDK: https://github.com/inferencekey/inferencekey-sdk/tree/main/examples/nitrofusion2-text2image-custom-backend-private-nvidia