Derrière chaque image produite par un générateur comme Stable Diffusion, Midjourney ou DALL-E, il y a un processus que peu d’utilisateurs comprennent vraiment. Le logiciel ne « dessine » pas. Il part d’un bloc de bruit aléatoire et retire progressivement ce bruit, étape par étape, jusqu’à faire apparaître une image cohérente. Ce mécanisme s’appelle la diffusion, et il repose sur une architecture dont chaque composant joue un rôle distinct. Dans les équipes techniques, la question « comment ça marche en dessous » revient de plus en plus souvent quand il s’agit de choisir un modèle, de configurer un pipeline de rendu ou de comprendre pourquoi une génération échoue.
Le principe fondamental : ajouter du bruit puis apprendre à l’enlever
Un modèle de diffusion fonctionne en deux temps. La première phase, appelée diffusion directe, consiste à prendre une image réelle et à lui ajouter du bruit gaussien progressivement, en plusieurs centaines d’étapes, jusqu’à ce que l’image originale soit totalement noyée dans le bruit. À la fin de ce processus, il ne reste qu’un tableau de valeurs aléatoires, sans aucune structure visuelle reconnaissable. La deuxième phase est l’inverse : le modèle apprend à débruiter. À chaque étape, il prédit quel bruit a été ajouté, puis le soustrait. Répétée sur des dizaines d’itérations successives, cette opération reconstruit progressivement une image structurée à partir du chaos. Le concept a été formalisé dans un article fondateur de 2020 sur les Denoising Diffusion Probabilistic Models (DDPM), qui a posé les bases théoriques de toute la génération visuelle actuelle. Ce qui rend ces modèles redoutablement efficaces, c’est que le réseau de neurones n’a pas besoin d’apprendre à « dessiner » une image entière. Il a seulement besoin d’apprendre à estimer le bruit présent dans un signal partiellement dégradé. C’est une tâche plus simple, plus stable numériquement et qui se prête bien à l’entraînement sur des jeux massifs de données visuelles. Par comparaison, les GAN (Generative Adversarial Networks) qui dominaient la génération d’images avant 2020 souffraient d’une instabilité chronique à l’entraînement et d’un phénomène de « mode collapse » où le modèle se bloquait sur un nombre limité de résultats. La diffusion a résolu ces deux problèmes en adoptant un processus de génération progressif plutôt qu’une production en une seule passe.
Pourquoi tout se passe dans l’espace latent
Appliquer la diffusion directement sur une image en haute résolution serait extrêmement coûteux en calcul. Une image de 512×512 pixels en RGB contient environ 786 000 valeurs. Travailler sur ces données brutes à chaque étape de débruitage demanderait une puissance GPU considérable, et le temps de génération serait prohibitif. C’est le problème que résout l’architecture de diffusion latente, publiée fin 2021 par l’équipe CompVis sur arXiv et devenue la base de toutes les versions de Stable Diffusion, de la v1.1 jusqu’à SDXL.
Avant de lancer la diffusion, un autoencodeur variationnel (VAE) compresse l’image depuis l’espace pixel vers un espace latent beaucoup plus compact. Cette compression conserve les informations sémantiques essentielles, les formes, les structures, les couleurs dominantes, tout en éliminant la redondance pixel par pixel. Le résultat est un tableau de valeurs environ 48 fois plus petit que l’image originale. Toute la diffusion et le débruitage se font dans cet espace compressé. Le modèle n’a jamais besoin de manipuler l’image en pleine résolution pendant la génération. Ce n’est qu’à la toute fin que le décodeur VAE reconvertit le résultat latent en image visible.
Cette astuce a changé la donne. Un rendu qui aurait pris plusieurs minutes en espace pixel peut se faire en quelques dizaines de secondes dans l’espace latent. Sans cette compression préalable, aucun de ces modèles ne pourrait tourner sur du matériel grand public. Les ingénieurs qui déploient ces systèmes en production le savent bien : la qualité du VAE influence directement la netteté du résultat final, et un VAE mal calibré se repère immédiatement à des artefacts flous ou des textures qui « bavent » sur les contours.
Les trois composants qui travaillent ensemble
Un pipeline de diffusion latente repose sur trois modules principaux qui fonctionnent de concert. Le premier est le U-Net, le réseau de neurones qui effectue le débruitage. Son architecture en forme de U lui permet de traiter l’image à plusieurs échelles simultanément : les couches descendantes capturent le contexte global, les couches ascendantes reconstruisent les détails fins. À chaque étape du processus, le U-Net prédit le vecteur de bruit présent dans la représentation latente. Ce vecteur est ensuite soustrait, et le résultat sert d’entrée pour l’étape suivante. Le nombre d’itérations dépend du scheduler choisi, généralement entre 20 et 50 étapes pour un compromis acceptable entre qualité et vitesse.
Le deuxième composant est l’encodeur de texte CLIP. Quand un utilisateur tape un prompt, ce texte est découpé en tokens puis converti en un vecteur d’embedding par le modèle CLIP. Ce vecteur conditionne le U-Net via un mécanisme de cross-attention : à chaque étape de débruitage, le réseau consulte l’embedding textuel pour orienter la reconstruction dans la direction décrite par le prompt. C’est ce mécanisme qui fait la différence entre une image aléatoire et une image qui correspond à ce que l’utilisateur a demandé. Le troisième est le VAE déjà mentionné, qui fait le pont entre l’espace latent et l’espace pixel. Son encodeur compresse, son décodeur décompresse. La chaîne complète est donc : prompt → CLIP → U-Net × N étapes → VAE décodeur → image finale.
LoRA : adapter le modèle sans le réentraîner
Les modèles de diffusion de base sont entraînés sur des jeux massifs de plusieurs milliards d’images. Mais dans la pratique, les utilisateurs ont besoin de résultats spécialisés : un style visuel particulier, un type de posture, une esthétique cinématique, une cohérence de personnage entre plusieurs rendus. Réentraîner le modèle entier pour chaque cas d’usage serait impraticable, tant en temps qu’en coût GPU. C’est le problème que résout LoRA (Low-Rank Adaptation), une technique publiée par Hu et al. en 2022 et devenue incontournable dans l’écosystème de la diffusion.
Le principe est d’injecter de petites matrices de faible rang dans les couches d’attention du U-Net, sans modifier les poids originaux du modèle. Ces matrices sont légères, quelques mégaoctets contre plusieurs gigaoctets pour le modèle complet, et peuvent être entraînées sur un jeu ciblé en quelques heures sur un seul GPU. Le résultat est un fichier complémentaire qui oriente le comportement du modèle dans une direction précise sans altérer ses capacités générales. En pratique, un développeur peut empiler plusieurs LoRA sur un même modèle de base pour combiner différents effets : un LoRA pour le style, un autre pour la posture, un troisième pour la lumière. L’ordre d’application et le poids attribué à chaque LoRA influencent le rendu final, ce qui donne aux intégrateurs un contrôle fin sur le résultat sans jamais toucher au modèle source. La communauté open source autour de Stable Diffusion a produit des milliers de LoRA spécialisés, disponibles en téléchargement et utilisables avec n’importe quel modèle compatible. Des services comme bodyswap.ai exploitent cette architecture pour configurer des rendus spécialisés par catégorie, en combinant plusieurs LoRA sur un modèle de base commun. C’est cette couche de personnalisation qui permet d’obtenir des résultats cohérents et spécifiques sans dépendre d’un modèle unique monolithique. Pour les équipes techniques, c’est aussi un levier d’optimisation : au lieu de maintenir plusieurs modèles lourds en mémoire, un seul modèle de base suffit, complété par des LoRA qui se chargent et se déchargent à la volée selon le rendu demandé.
De l’image fixe à la séquence animée
L’extension de la diffusion latente à la vidéo suit une logique similaire, mais avec une complexité supplémentaire : la dimension temporelle. Au lieu de travailler sur un tableau latent en 2D (hauteur × largeur), le modèle travaille sur un volume 3D qui inclut le temps (hauteur × largeur × nombre de frames). Le VAE est adapté en version 3D pour compresser et décompresser des séquences entières plutôt que des images isolées. Cette extension n’est pas triviale : le volume de calcul augmente proportionnellement au nombre de frames, et la mémoire VRAM nécessaire croît rapidement. C’est une des raisons pour lesquelles les séquences générées par IA dépassent rarement les 5 à 20 secondes en production courante. Au-delà, la mémoire requise explose et le temps de rendu devient difficilement compatible avec un usage interactif. Les modèles qui génèrent des séquences plus longues utilisent généralement un découpage par segments, avec des mécanismes de chevauchement pour maintenir la continuité entre les morceaux.
Le U-Net est également modifié. Après chaque bloc spatial classique, des couches de convolution temporelle et d’attention temporelle sont insérées pour capturer les relations entre les frames successives. Un bras qui se lève dans une frame continue à se lever dans la suivante, au lieu de sauter d’une position à une autre. La qualité de cette cohérence temporelle dépend directement du nombre de couches temporelles et de la taille du contexte que le modèle peut traiter simultanément. Un modèle avec un contexte court produira des mouvements saccadés, tandis qu’un contexte plus long permet des transitions fluides, au prix d’une consommation mémoire nettement plus élevée. Pour le cas spécifique de la conversion image-vers-vidéo, l’image source est d’abord encodée en vecteur latent par un Vision Transformer, puis ce vecteur conditionne le modèle pour que la séquence générée reste fidèle au contenu visuel de départ.
Les architectures les plus récentes remplacent progressivement le U-Net par des Diffusion Transformers (DiT), qui gèrent mieux les longues séquences et offrent une meilleure scalabilité. Mais le principe fondamental reste le même depuis 2021 : compresser, bruiter, débruiter, conditionner, décompresser. Ce qui change, c’est la taille des modèles, la qualité des VAE, la sophistication des schedulers et la finesse des LoRA appliqués. Pour un développeur ou un intégrateur, maîtriser cette chaîne technique est devenu aussi essentiel que comprendre une architecture REST ou un pipeline CI/CD.
