NitroFusion2 sur une seule carte : une image 1024px en 0,78 s, une pancarte juste en deux étapes

Crédits

• Dar-Yen Chen et Yi-Zhe Song (SketchX, CVSSP, Université du Surrey ; Turing Elite Research Labs) : NitroFusion2, l'article "NitroFusion2: Bringing Adversarial Loss to the Text Stream of Multimodal Diffusion Transformers" (arXiv 2611.05648, CC BY 4.0), les poids (Apache-2.0), la LoRA de dé-distillation (le module complémentaire de 0,38 GB), les fichiers GGUF, le code et inference.py (Apache-2.0), quatre workflows ComfyUI et la page du projet. Il s'appuie sur NitroFusion (Dar-Yen Chen, Hmrishav Bandyopadhyay, Kai Zou et Yi-Zhe Song, CVPR 2025).
• Tongyi-MAI : Z-Image-Turbo (Apache-2.0), dont le pipeline réutilise l'encodeur de texte, le tokenizer, le VAE et le scheduler.
• Les mainteneurs de diffusers : ZImagePipeline, le chargeur de LoRA Z-Image et le chargement GGUF en fichier unique dans diffusers 0.42.1.
• PedroMarinhoDev : des builds ComfyUI communautaires int8, W6A8 et W4A8 (non testés par nous).
• AI Search : là où nous l'avons repéré (2026-11-08 AI NEWS, chapitre à 03:50).
• Notre part : le backend personnalisé, le déploiement via la plateforme, les chronométrages, l'échelle de mémoire, les contrôles de qualité, l'exemple du SDK et la vidéo de démo.

Modèle et fichiers

• ChenDY/NitroFusion2 : sha 62d1a7000af9c46a0c4348d936bd7670ff33c1b9, créé le 2026-10-27, dernière modification le 2026-11-08, sans accès restreint, apache-2.0, bibliothèque diffusers, pipeline text-to-image, modèle de base Tongyi-MAI/Z-Image-Turbo. Publication indiquée sur la page : 2026-11-03.
• Transformer : ZImageTransformer2DModel de diffusers, 6 154 908 736 paramètres (la Table 1 de l'article dit 6B, comme Z-Image-Turbo). Bf16 en 3 shards : 4 986 858 288 + 4 986 868 776 + 2 336 146 728 B (12,31 GB). Fichier unique nf2-bf16.safetensors 12 309 866 400 B. nf2-BF16.gguf et nf2-F16.gguf 12 311 939 136 B chacun.
• Niveaux 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 : encodeur de texte Qwen3 en 3 shards (environ 8,05 GB), VAE 167 666 902 B, son propre transformer d'environ 24,6 GB (F32), que notre backend ne télécharge pas. Sa page revendique une latence inférieure à la seconde sur une H800 et une place sur les appareils grand public de 16 GB. L'exemple diffusers de sa page utilise num_inference_steps=9 ("This actually results in 8 DiT forwards") et guidance_scale=0.0.
• Recette des auteurs (inference.py, identique sur la branche main GitHub) : étapes 1 à 4 uniquement, décalage du scheduler {1: 3.0, 2: 6.0, 3: 8.0, 4: 9.0}, sigmas 1 - i/steps, guidage 0.0, échelles 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)}, 1024 x 1024 et 2 étapes par défaut, pipe.enable_model_cpu_offload() dans __main__.
• Méthode : Text-Stream Adversarial Distillation (des têtes de discriminateur sur les états intermédiaires des tokens de texte du MMDiT gelé) et Aspect-Cued Discrimination (le discriminateur est conditionné par des indices de typographie, d'objet, de style, d'arrière-plan, d'action et de mise en page).
• Entraînement selon l'article : 100k références synthétiques de Z-Image-Turbo à 12 étapes (EN/CN), légendes par Qwen3.5-35B-A3B, Adam lr 5e-5, batch 256, huit H100, 20 000 étapes (5 000 off-policy, 15 000 on-policy). Pas de code d'entraînement dans le dépôt.
• Limites indiquées par l'article : les scènes complexes restent difficiles, surtout en une étape ; une diversité d'échantillons plus faible (diversité OneIG sous les deux références en 1 et 2 étapes) ; un effet de bascule entre les indices ACD.

Table 1 de l'article (chiffres des auteurs, non reproduits par nous ; le texte l'appelle Table 2) :

Installation et pourquoi

• GPU : une RTX 4090 sur InferenceKey Cloud. La carte a indiqué NVIDIA GeForce RTX 4090, 49140 MiB (la variante 48 GB), donc le workload principal a tourné avec NF2_VRAM_LIMIT_GIB=23.4 pour tenir lieu de carte de 24 GB. Aucune carte standard de 24 GB n'a été utilisée. Le pipeline bf16 a besoin d'environ 22 GiB résidents, d'où un budget de 24 GB comme référence. Ensuite une vraie RTX 2000 Ada 16 GB (16 380 MiB, 70 W) pour le contrôle sur petite carte.
• Backend : un nouveau backend Python personnalisé, NitroFusion2Backend 0.1.0 (paquet de 5 600 B), sur ZImagePipeline de diffusers 0.42.1, avec le transformer NitroFusion2 et la LoRA comme adaptateur dedistill. Versions épinglées : torch 2.14.1, transformers 5.21.0, accelerate 1.15.0, peft 0.21.2, gguf 0.19.0. Pourquoi un backend personnalisé : aucun backend intégré ne sert le pipeline Z-Image. Pourquoi diffusers : c'est le chemin des auteurs eux-mêmes, et la 0.42.1 a le pipeline, le chargeur de LoRA et le GGUF en fichier unique pour ce transformer.
• Modes mémoire (NF2_MEMORY_MODE) : gpu (tout résident), model (enable_model_cpu_offload, le défaut du script des auteurs), sequential. Le défaut auto choisit gpu seulement avec au moins 23 GiB libres, sinon model. Sur une carte de 16 GB, réglez explicitement NF2_TRANSFORMER=nf2-Q4_K_M.gguf et NF2_MEMORY_MODE=gpu, sinon auto se rabat sur l'offload et vous perdez le chemin à 4 s.
• Stack : un manager InferenceKey local, nats-proxy et un worker compilés depuis main 97aec23e. La production n'a jamais été touchée.
• Champs de la requête (style images OpenAI) : prompt (obligatoire), size ("1024x1024", côtés de 256 à 2048, multiples de 16), seed, steps ou num_inference_steps (1 à 4, 2 par défaut), dedistill (true par défaut), output_format (png, jpeg, webp). Le guidage vaut toujours 0. La réponse ajoute seconds, encode_seconds, vae_seconds, vram_peak_gib et memory_mode. Endpoint : POST /endpoint/<project>/nitrofusion2/v1/images/generations.

Pas à pas avec l'exemple du SDK

L'exemple correspond au commit 1ca451bd sur 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

Sans INFERENCEKEY_TENANT_ID et INFERENCEKEY_USER_TOKEN, publish.py se contente de construire dist/*.tar.gz, affiche "upload the package from Dashboard -> Custom backends instead" et sort avec le code 0. Dans ce cas, envoyez le fichier depuis Dashboard -> Custom backends avant de lancer main.py, sinon ensure() n'a aucun backend à déployer.

Pour une carte de 16 GB, ajoutez à .env avant main.py :

NF2_TRANSFORMER=nf2-Q4_K_M.gguf
NF2_MEMORY_MODE=gpu

main.py appelle ensure() pour un workload fixe sur IK_WORKER_ID avec ready_timeout_secs: 2400, request_timeout_secs: 600 et l'environnement NF2_*, attend avec wait_until_ready(2400), puis fait trois appels en 1024 x 1024 avec la seed 42 : la pancarte en 1 étape, le menu en 1 étape et le menu en 2 étapes. Il supprime le workload à la sortie, sauf avec IK_KEEP_ALIVE=1. Disque : environ 21 GB de poids (26 GB avec le fichier Q4_K_M en plus) plus un venv de 5,5 GB.

Une seule requête :

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}'

Mesures complètes

Délai jusqu'à prêt :

• RTX 4090 : "ready after 67 s" côté SDK. Venv 28 s (CPython 3.12.3), puis download 33.8s, load 4.4s, transformer bf16, memory mode gpu (budget 23.4 GiB), weights in VRAM 19.5 GiB. Cache HF d'environ 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.

Par requête, 1024 x 1024, seed 42, une à la fois. Temps GPU mesuré dans le backend avec cuda.synchronize, aller-retour depuis le client HTTP jusqu'au manager local.

Dérivé de ces chiffres, requêtes uniques, sans batching : environ 1,2 à 1,3 image par seconde de temps GPU en 1 étape (0,67 à 0,69 en aller-retour) et environ 0,75 en 2 étapes (0,50 à 0,51 en aller-retour). Le testeur d'images du tableau de bord a affiché "ok · 1098 ms" pour l'affiche en 1 étape.

Échelle de VRAM. Les échelons émulés ont tourné dans un processus séparé sur la 4090 de 48 GB avec torch.cuda.set_per_process_memory_fraction, à côté du workload en service, donc leurs temps peuvent inclure un peu de contention. Chaque échelon a fait tourner la pancarte et le menu en 1 et 2 étapes, deux fois, seed 42.

Non essayé : un encodeur de texte quantifié ou sur CPU pour 8 GB ; des résolutions autres que 1024 ; les builds ComfyUI communautaires int8, W6A8 et W4A8 ; des tailles de batch au-dessus de 1 et la concurrence ; de vraies cartes de 12 GB et des cartes standard de 24 GB (aucune carte de 10 à 12 GB n'était disponible) ; les niveaux GGUF Q2, Q3, Q5 et Q6 ; Q8_0 avec offload ou sur une carte de 24 GB ; Z-Image-Turbo à 8 étapes.

Notes de qualité (une seed par cas, pas un benchmark)

Prompts : la pancarte du chat et le portrait des auteurs, plus quatre des nôtres (un menu de café sur ardoise, une affiche du tram de Lisbonne, une partition sur un piano, une paire de mains).

• Pancarte (prompt des auteurs "a cat holding a sign that says hello world") : 4090 en 1 étape "HELLO WORd" (L manquant, d minuscule, H baveux), en 2 étapes "Hello World". Les échelons Q4 sur la 4090 ont donné le même texte que le bf16. RTX 2000 Ada Q4 : 1 étape "HELLO WORLD", 2 étapes juste.
• Menu ("FLAT WHITE 3.20 / CROISSANT 2.80 / SOURDOUGH 4.50") : "SOURDOAGH" en 1, 2 et 4 étapes et en 2 sans LoRA sur la 4090. RTX 2000 Ada en 1 étape : "CROSSANT" et un "0" parasite sous 4.50 ; en 2 étapes "SOURDOAGH".
• Affiche : "LISBOA" et "Tram 28 - every 12 minutes" justes en 1 et 2 étapes et sur la carte de 16 GB.
• Piano : titre "Nocturne No. 2 in E-flat" illisible en 1 étape, encore imparfait en 2. Mains plausibles.
• Portrait (prompt des auteurs) : propre en 1 et 2 étapes.

Vidéo de démo

Une présentation commentée de 3 minutes : ce qu'est NitroFusion2 (avec la page du projet des auteurs, leurs figures et leur Table 1, crédités), le panneau qui génère en 1 et 2 étapes, et l'échelle de mémoire.

Problèmes restants

1. La 4090 était une variante de 48 GB. Le résultat à 24 GB est une limite (NF2_VRAM_LIMIT_GIB=23.4), pas une carte standard de 24 GB. Statut : signalé, non retesté sur une carte de 24 GB.
2. Les valeurs par défaut du testeur d'images (20 étapes, guidage 4,5) renvoient 400 NitroFusion2 is distilled for 1 to 4 steps. Statut : documenté dans le README, valeurs par défaut de la plateforme inchangées.
3. Q8_0 ne tient pas dans 16 GB avec l'encodeur de texte bf16 résident. Statut : utiliser Q4_K_M.
4. 8 GB échoue : OOM avec l'offload du modèle, KeyError: None avec l'offload séquentiel et un transformer GGUF. Statut : ouvert, non essayé avec un encodeur de texte plus petit.
5. Erreurs de texte en une étape, et une faute ("SOURDOAGH") à tous les nombres d'étapes. Statut : comportement du modèle, conforme au retard sur le rendu du texte que reconnaît l'article.
6. Mineur : notre premier SQL d'amorçage pour le tenant de test local a touché le tenant par défaut amorcé ; corrigé avant le redémarrage du manager, sans effet sur le test. Un RuntimeWarning sans conséquence à propos de inferencekey.backend.serve dans sys.modules apparaît dans le stderr du backend.

Sources

• Page du modèle : https://huggingface.co/ChenDY/NitroFusion2
• Code et inference.py : https://github.com/ChenDarYen/NitroFusion2
• Article : https://arxiv.org/abs/2611.05648
• Page du projet : https://chendaryen.github.io/NitroFusion2.github.io/
• Modèle de base : https://huggingface.co/Tongyi-MAI/Z-Image-Turbo
• Là où nous l'avons repéré : https://www.youtube.com/watch?v=9RIK3A24ZxA (AI Search, 2026-11-08, à 03:50)
• Exemple du SDK : https://github.com/inferencekey/inferencekey-sdk/tree/main/examples/nitrofusion2-text2image-custom-backend-private-nvidia