NVIDIA Automodel : le couteau suisse pour dompter l’IA générative d’images et vidéos

QU’EST-CE QUE NVIDIA NEMO AUTOMODEL ?

Imaginez un atelier de bricolage pour l’intelligence artificielle, où vous pouvez prendre n’importe quel modèle d’IA générative, l’adapter à vos besoins, et le faire tourner sur des centaines de GPU sans rien casser. C’est exactement ce que propose NVIDIA NeMo Automodel, une bibliothèque open source intégrée à PyTorch et conçue pour entraîner des modèles de diffusion (diffusion models) à grande échelle. Ces modèles, comme FLUX.1-dev pour le texte vers image ou Wan 2.1 pour le texte vers vidéo, sont parmi les plus populaires depuis deux ans. Mais les entraîner ou les personnaliser demande des Outils puissants, capables de gérer des calculs complexes sans exploser la mémoire.

NeMo Automodel répond à ce défi avec des fonctionnalités clés : sharding mémoire-efficace (répartir les calculs sur plusieurs GPU), caching des latents (stocker des données intermédiaires pour accélérer l’entraînement), bucketing multi-résolution (gérer des images de tailles différentes), et une configuration qui passe facilement d’un seul GPU à des centaines. En résumé, c’est l’outil idéal pour ceux qui veulent entraîner des modèles d’IA sans devenir des experts en calcul distribué.

LES MODÈLES D’IA SUPPORTÉS : FLUX, WAN 2.1, HUANYUANVIDEO…

NeMo Automodel ne fonctionne pas qu’avec un seul modèle. Il est conçu pour s’adapter à une longue liste de modèles d’IA générative disponibles sur la Hugging Face Hub, la plateforme où les chercheurs partagent leurs créations. Voici les principaux modèles supportés par les recettes prêtes à l’emploi intégrées à NeMo Automodel :

Chacun de ces modèles a sa spécialité : certains excellent pour transformer du texte en images ultra-réalistes, d’autres pour générer des vidéos à partir de descriptions. Grâce à NeMo Automodel, vous pouvez les personnaliser sans avoir à réécrire tout le code de zéro. Il suffit d’utiliser les fichiers de configuration (.yaml) fournis et de lancer l’entraînement avec vos propres données.

CE QUE CETTE COLLABORATION CHANGE VRAIMENT

La collaboration entre NVIDIA et Hugging Face n’est pas qu’une simple intégration technique. Elle apporte des avantages concrets pour les utilisateurs de la bibliothèque Diffusers, qui est devenue la référence pour travailler avec les modèles de diffusion. Voici ce que cette alliance change :

Concrètement, si vous avez déjà un modèle hébergé sur Hugging Face, vous pouvez l’entraîner avec NeMo Automodel sans perdre de temps à convertir les fichiers. Une fois l’entraînement terminé, votre modèle personnalisé peut être réutilisé directement dans Diffusers ou partagé sur le Hub. Plus besoin de jongler entre différents formats ou de réécrire des scripts d’entraînement pour chaque nouveau modèle.

LE FINE-TUNING EN 4 ÉTAPES SIMPLES

Pour montrer comment ça marche, prenons un exemple concret : fine-tuner le modèle FLUX.1-dev sur un jeu de données de 78 cartes de tarot. Voici les étapes à suivre, détaillées et reproductibles.

1. PRÉ-ENCODER LE JEU DE DONNÉES

L’entraînement d’un modèle de diffusion ne se fait pas directement sur les images brutes. D’abord, il faut encoder ces images pour obtenir leurs latents (des versions compressées et simplifiées des images) et leurs embeddings textuels (les représentations numériques des descriptions associées). Cette étape est cruciale car elle accélère énormément l’entraînement : au lieu de traiter les images à chaque itération, le modèle travaille avec des données déjà prêtes.

Pour notre exemple avec les cartes de tarot, nous utilisons un jeu de données public disponible sur Hugging Face : multimodalart/1920-raider-waite-tarot-public-domain. Ce jeu contient 78 images accompagnées de légendes. Voici la commande à exécuter pour pré-encoder ces données :

uv run --locked --no-default-groups \
  --extra diffusion \
  --extra diffusion-media \
python -m tools.diffusion.preprocessing_multiprocess image \
  --dataset_name multimodalart/1920-raider-waite-tarot-public-domain \
  --datasetmediacolumn image \
  --datasetcaptioncolumn caption \
  --dataset_streaming \
  --max_images 78 \
  --outputdir /cache/fluxtarot \
  --processor flux \
  --model_name black-forest-labs/FLUX.1-dev \
  --max_pixels 245760

Cette commande va :

• Télécharger les images et leurs légendes depuis Hugging Face.
• Encoder les images en latents avec le modèle FLUX.1-dev.
• Stocker le tout dans un dossier organisé comme suit :

/cache/flux_tarot/
├── 384x640/
│   ├── .pt
│   └── .
├── metadatashard0000.json
├── metadata.json
└── hfdataset/
    └── images/

Les fichiers .pt contiennent les latents des images, tandis que les fichiers metadata.json stockent les informations sur chaque image (taille, légende, etc.).

2. LANCER L’ENTRAÎNEMENT AVEC UN FICHIER DE CONFIGURATION EXISTANT

NeMo Automodel utilise des fichiers de configuration au format YAML pour définir les paramètres d’entraînement. Pour FLUX.1-dev, le fichier fluxt2iflow.yaml est déjà prêt à l’emploi. Il contient toutes les options nécessaires : choix du modèle, type de fine-tuning (complet ou LoRA), taille de lot, et bien plus.

Pour lancer l’entraînement, il suffit d’exécuter cette commande en surchargeant les paramètres spécifiques à notre jeu de données :

uv run --locked --no-default-groups --extra diffusion \
  torchrun --nproc-per-node=8 \
  examples/diffusion/finetune/finetune.py \
  -c examples/diffusion/finetune/fluxt2iflow.yaml \
  --model.transformerenginefp8 false \
  --data.dataloader.cachedir /cache/fluxtarot \
  --data.dataloader.base_resolution '[384,640]' \
  --lrscheduler.lrdecay_style constant \
  --lrscheduler.lrwarmup_steps 20 \
  --stepscheduler.maxsteps 200 \
  --stepscheduler.ckptevery_steps 50 \
  --checkpoint.checkpointdir /tmp/fluxtarot/checkpoints/full \
  --checkpoint.save_consolidated true \
  --seed 2026

Voici ce que font les principaux paramètres :

• --nproc-per-node=8 : utilise 8 GPU pour l’entraînement.
• --data.dataloader.cache_dir : pointe vers le dossier où sont stockés les latents pré-encodés.
• --stepscheduler.maxsteps 200 : limite l’entraînement à 200 étapes.
• --seed 2026 : fixe une graine pour la reproductibilité.

À la fin de l’entraînement, des points de contrôle (checkpoints) sont sauvegardés à chaque étape : 50, 100, 150 et 200. Le dernier point de contrôle est nommé epoch66step_199, même si l’entraînement a duré 200 étapes.

3. GÉNÉRER DES IMAGES AVEC LE MODÈLE PERSONNALISÉ

Une fois l’entraînement terminé, il est temps de tester le modèle personnalisé. Pour cela, on utilise un autre fichier de configuration, generate_flux.yaml, qui définit comment générer des images à partir de prompts textuels. Voici la commande pour générer une image avec le modèle fine-tuné :

uv run --locked --no-default-groups --extra diffusion \
python examples/diffusion/generate/generate.py \
  -c examples/diffusion/generate/configs/generate_flux.yaml \
  --model.checkpoint /tmp/fluxtarot/checkpoints/full/epoch66step199 \
  --inference.height 640 \
  --inference.width 384 \
  --inference.prompts '["a trtcrd of an astronaut tending a rose garden on Mars, \"the gardener\""']' \
  --output.outputdir /tmp/fluxtarot/generations/full/step_200 \
  --seed 2026

Le paramètre trtcrd est un token déclencheur qui permet d’activer le style appris pendant le fine-tuning (ici, le style des cartes de tarot). Sans ce token, le modèle génère une image normale, sans le style personnalisé.

Pour comparer, on peut générer une image sans le token déclencheur :

uv run --locked --no-default-groups --extra diffusion \
python examples/diffusion/generate/generate.py \
  -c examples/diffusion/generate/configs/generate_flux.yaml \
  --model.checkpoint /tmp/fluxtarot/checkpoints/full/epoch66step199 \
  --inference.height 640 \
  --inference.width 384 \
  --inference.prompts '["an astronaut tending a rose garden on Mars, \"the gardener\""']' \
  --output.outputdir /tmp/fluxtarot/generations/control \
  --seed 2026

4. RÉSULTATS : UN STYLE DE TAROT BIEN APPRIS

Après 200 étapes d’entraînement, les images générées avec le token trtcrd affichent clairement le style des cartes de tarot : une palette de couleurs vintage (crème, rouge, noir), des contours d’encre épais, des aplats de couleurs, des tons de papier vieilli, et une composition allégorique. Sans le token, l’image reste photographique, ce qui prouve que le style personnalisé est bien associé au token et non au modèle de base.

PERFORMANCES : DES CHIFFRES QUI PARLENT

Pour mesurer l’efficacité de NeMo Automodel, des tests ont été réalisés sur une machine équipée de 8 GPU NVIDIA H100 80GB. Les résultats montrent des performances impressionnantes, avec des temps d’entraînement et des débits d’images par seconde qui varient selon le type de fine-tuning.

Avec un fine-tuning complet (Full FSDP2) sur FLUX.1-dev, l’entraînement atteint 35,51 images/seconde avec une taille de lot globale (GBS) de 32 et une taille de lot locale (LBS) de 4. Le temps par étape est de 0,902 seconde, et chaque GPU alloue jusqu’à 63,88 GiB de mémoire. Avec LoRA (r64 DDP), le débit monte à 53,73 images/seconde pour une GBS de 48 et une LBS de 6, avec un temps par étape de 0,894 seconde et une mémoire allouée de 67,43 GiB.

Pour Qwen-Image, un autre modèle de diffusion, les résultats sont similaires : 41,21 images/seconde en fine-tuning complet et 46,63 images/seconde avec LoRA.

Les tests sur la génération de vidéos montrent que NeMo Automodel permet de traiter chaque clip vidéo de 49 images en un temps raisonnable, même si les chiffres exacts ne sont pas précisés dans la source.

D’AUTRES EXEMPLES DE FINE-TUNING : GHIBLI, WAN 2.1…

NeMo Automodel ne se limite pas à FLUX.1-dev et aux cartes de tarot. D’autres exemples de fine-tuning sont disponibles pour montrer sa polyvalence. Par exemple, fine-tuner le modèle Wan 2.1 sur un jeu de données de vidéos Ghibli a permis d’adapter le style de sortie du modèle. Les résultats montrent une différence notable dans l’apparence des fleurs générées par rapport au modèle de base.

Un autre exemple utilise LoRA sur Wan 2.1 pour appliquer un style Ghibli aux vidéos. L’effet est particulièrement visible sur les yeux des personnages, qui prennent un aspect caractéristique des dessins animés du studio Ghibli.

ESSAYEZ DÈS AUJOURD’HUI

Si vous voulez tester NeMo Automodel par vous-même, tout est prêt : des guides détaillés, des exemples de code, et une documentation complète sont disponibles. Vous pouvez commencer par installer NeMo Automodel via Docker ou pip, puis suivre les tutoriels pas à pas. La collaboration entre NVIDIA et Hugging Face a rendu le fine-tuning accessible à tous, même sans expertise en calcul distribué.

CE QUI VIENT ENSUITE : DES API PYTHON POUR UNE UTILISATION ENCORE PLUS SIMPLE

Les fichiers de configuration YAML sont parfaits pour des équipes qui veulent des configurations reproductibles et faciles à partager. Mais pour beaucoup d’utilisateurs, une interface en Python serait encore plus pratique, surtout pour intégrer le fine-tuning dans des notebooks ou des workflows existants.

NVIDIA et Hugging Face prévoient de lancer une API Python typée pour NeMo Automodel. Cette API permettra de composer les recettes de fine-tuning directement en Python, en utilisant les mêmes modèles, données, optimiseurs et paramètres de parallélisme que les fichiers YAML. L’objectif est de rendre le fine-tuning encore plus accessible, en offrant une interface intuitive pour ceux qui préfèrent coder en Python plutôt que de manipuler des fichiers de configuration.