6  ⚔️ Modèles Génératifs Antagonistes et Diffusion (GAN)

// ==========================================
// _ojs_bridge.qmd — OJS Global Namespace Bridge
//
// Include ONCE at the top of each chapter index.qmd:
//   {{< include ../../assets/_ojs_bridge.qmd >}}
//
// window.aptitek is set by an async `<script type="module">` in the page
// header (_quarto.yml include-in-header). That import may resolve AFTER
// OJS starts executing, causing `aptitek` to be undefined.
//
// Fix: return a Promise from this cell. OJS suspends all downstream cells
// until the promise resolves — the built-in, idiomatic solution for async
// dependencies in Observable JS.
//
// ✅ Zero-maintenance: adding a new export to index.js barrel is
//    instantly available — no edits to this file ever needed.
// ✅ Race-condition-safe: downstream cells never see undefined.
// ✅ Anti-double-definition: only ONE OJS name (`aptitek`) is defined.
// ==========================================
aptitek = {
  if (window.aptitek) return window.aptitek;
  return new Promise(resolve => {
    const check = () =>
      window.aptitek
        ? resolve(window.aptitek)
        : requestAnimationFrame(check);
    check();
  });
}

6.1 Modéliser la Distribution

Un classifieur apprend à reconnaître. Un modèle génératif apprend à inventer des exemples crédibles — comme un peintre qui a vu assez de tableaux pour en créer un nouveau dans le même style.

L’idée centrale est simple : au lieu de seulement dire “ceci est un chat”, le modèle apprend ce qui rend une image de chat plausible, puis fabrique une nouvelle image qui respecte ces régularités.

🔍 Détails techniques

Le passage de l’apprentissage discriminatif à l’apprentissage génératif représente un saut conceptuel majeur. Là où un classificateur apprend la frontière de décision p(y|\mathbf{x}) — une partition de l’espace — un modèle génératif ambitionne de modéliser la distribution sous-jacente p_0(\mathbf{x}) qui a généré les données. Capturer cette distribution, c’est capturer l’essence structurelle du réel : non pas distinguer les données, mais les comprendre suffisamment pour les reconstruire (Wikipedia contributors 2026a; Weng 2025).

6.1.1 Deux Philosophies

Face à des données compliquées, deux stratégies existent : essayer de calculer leur “recette exacte”, ou apprendre à produire des exemples qui y ressemblent. Pour les images, la deuxième stratégie est souvent la plus réaliste.

🔍 Détails techniques

Face au problème d’estimer p_0, deux approches philosophiquement distinctes émergent.

L’approche explicite tente d’estimer directement la densité p_0(\mathbf{x}) via des estimateurs paramétriques (mélanges gaussiens) ou non-paramétriques (estimation par noyaux — KDE). La KDE souffre de la malédiction de la dimensionnalité : pour des données de haute dimension (d \gg 10), le nombre d’échantillons nécessaires croît exponentiellement avec d, rendant toute estimation directe impossible sur des images ou du texte.

L’approche implicite contourne ce problème en n’estimant pas p_0 directement. Elle apprend soit une transformation qui mappe une distribution simple (bruit gaussien) vers p_0, soit la fonction de score \nabla_\mathbf{x} \log p_0(\mathbf{x}) qui permet un échantillonnage efficace via des dynamiques de Langevin. Cette transition vers l’implicite a trouvé sa première réalisation transformatrice dans les Réseaux Antagonistes Génératifs (Goodfellow et al. 2014b).

6.1.2 Du VAE au GAN

Les VAE compressent puis reconstruisent. Les GANs retirent la partie “compression” : ils partent d’un bruit aléatoire et apprennent directement à le transformer en image réaliste.

🔍 Détails techniques

Les autoencodeurs variationnels (chapitre précédent) introduisent un encodeur explicite qui contraint la structure de l’espace latent. Les GANs abandonnent l’encodeur : la génération pure devient l’objectif. Un bruit simple \mathbf{z} \sim \mathcal{N}(\mathbf{0}, \mathbf{I}) est transformé en une donnée réaliste \hat{\mathbf{x}} = G(\mathbf{z}) par le générateur, sans jamais passer par un encodeur. Cette approche, plus audacieuse, est aussi plus instable — et c’est l’instabilité contrôlée qui constitue le cœur du paradigme GAN.

🎨 L’Intuition du Peintre et du Critique

L’apprentissage génératif via un GAN s’apparente à un jeu entre un peintre apprenti (le générateur) et un critique d’art expert (le discriminateur). Le peintre tente de produire des faux tableaux assez convaincants pour tromper le critique. Le critique, de son côté, s’entraîne à distinguer les originaux des contrefaçons. En améliorant mutuellement leur expertise, les deux convergent vers un équilibre où les faux sont indiscernables des originaux. La “qualité artistique” n’est jamais définie explicitement : elle émerge de la compétition (PatSnap Eureka 2025).

6.1.3 Mesures de Divergence

Le générateur cherche à réduire l’écart entre ses faux exemples et les vrais. Plus cet écart est mal mesuré, plus l’entraînement devient instable — comme un peintre qui recevrait une critique confuse.

🔍 Détails mathématiques

Le cœur théorique des GANs repose sur la minimisation d’une divergence entre distributions. Le générateur G cherche à rendre p_G(\mathbf{x}) — la distribution des données générées — indiscernable de p_0(\mathbf{x}) — la distribution réelle. Formellement, l’objectif est :

G^* = \arg\min_G \, D(p_0 \| p_G)

Le choix de la divergence D a des conséquences profondes sur la stabilité de l’entraînement, comme nous le verrons. Le GAN original utilise la divergence de Jensen-Shannon, les WGAN utilisent la distance de Wasserstein (Arjovsky and Bottou 2017).

6.2 Le Duel Algorithmique des GANs

Deux réseaux s’affrontent en boucle : le générateur fabrique des faux, le discriminateur tente de les détecter. À force de se mesurer l’un à l’autre, les deux s’améliorent jusqu’à ce que les faux soient indiscernables des vrais.

Un GAN fonctionne donc comme un atelier de contrefaçon supervisé par un expert : le faussaire apprend uniquement grâce aux retours du critique.

🔍 Cadre théorique

Introduits par Goodfellow et al. en 2014, les Réseaux Antagonistes Génératifs reformulent la génération comme un problème de théorie des jeux à somme nulle (Goodfellow et al. 2014a). Deux réseaux sont entraînés simultanément dans une compétition asymétrique dont l’issue idéale est un Équilibre de Nash.

6.2.1 Les Deux Acteurs

Le Générateur G_\theta — Le Faussaire :

Le générateur est l’apprenti faussaire : il reçoit du bruit au hasard et essaie d’en faire une image assez crédible pour tromper l’expert.

🔍 Détails techniques

G_\theta : \mathbf{z} \mapsto \hat{\mathbf{x}} est une fonction paramétrique qui transforme un vecteur de bruit \mathbf{z} \sim p_z(\mathbf{z}) (typiquement gaussien) en une donnée synthétique \hat{\mathbf{x}}. Son seul objectif : produire des données \hat{\mathbf{x}} \sim p_G qui ressemblent à p_0 au point de tromper le discriminateur. Le générateur n’observe jamais les données réelles directement — il ne reçoit que le signal de retour du discriminateur.

Le Discriminateur D_\phi — L’Expert :

Le discriminateur est le critique d’art : il regarde une image et répond “vrai” ou “faux”. Sa critique sert ensuite de leçon au générateur.

🔍 Détails techniques

D_\phi : \mathbf{x} \mapsto [0, 1] est un classificateur binaire qui estime la probabilité qu’une donnée soit réelle. Son rôle est double : distinguer les réelles des fausses, et simultanément servir d’estimateur de la divergence entre p_0 et p_G.

6.2.2 L’Objectif Minimax

Le générateur veut minimiser la probabilité que ses faux soient détectés ; le discriminateur veut la maximiser. Le jeu converge quand aucun des deux ne peut plus s’améliorer — l’Équilibre de Nash.

On peut lire ce duel comme une partie de cache-cache : l’un apprend à mieux se cacher, l’autre à mieux repérer. L’objectif n’est pas qu’un joueur gagne pour toujours, mais que les deux arrivent à un niveau où les faux sont aussi convaincants que les vrais.

🔢 Formule minimax et équilibre théorique

L’entraînement conjoint est décrit par le jeu à deux joueurs (Goodfellow et al. 2014a; Moghaddam et al. 2023) :

\min_G \max_D \; V(G, D) = \mathbb{E}_{\mathbf{x} \sim p_0}\!\left[\log D(\mathbf{x})\right] + \mathbb{E}_{\mathbf{z} \sim p_z}\!\left[\log(1 - D(G(\mathbf{z})))\right] (voir le Glossaire)

• \min_G \max_D : jeu minimax où le discriminateur D cherche à maximiser le critère V tandis que le générateur G cherche à le minimiser.
• \mathbb{E}_{\mathbf{x} \sim p_0} : espérance mathématique calculée sur les données réelles échantillonnées selon la distribution de données p_0.
• \mathbb{E}_{\mathbf{z} \sim p_z} : espérance calculée sur les vecteurs de bruit latent \mathbf{z} échantillonnés selon l’a priori gaussien p_z.
• D(\mathbf{x}) : prédiction du discriminateur pour une vraie donnée \mathbf{x}.
• G(\mathbf{z}) : donnée synthétique générée à partir du bruit \mathbf{z}.

À l’optimum global, si G est assez expressif, le discriminateur optimal satisfait D^*(\mathbf{x}) = \frac{p_0(\mathbf{x})}{p_0(\mathbf{x}) + p_G(\mathbf{x})}. En substituant D^* dans V, la valeur du jeu devient la divergence de Jensen-Shannon :

V(G, D^*) = -\log 4 + 2 \cdot D_{\text{JS}}(p_0 \| p_G) (voir le Glossaire)

• D^* : le discriminateur théorique optimal à chaque étape de l’entraînement.
• D_{\text{JS}}(p_0 \| p_G) : divergence de Jensen-Shannon (symétrique et toujours positive) comparant la distribution réelle p_0 à la distribution générée p_G.

L’Équilibre de Nash est atteint quand p_G = p_0, auquel cas D^*(\mathbf{x}) = \frac{1}{2} partout et V = -\log 4.

⚔️ Duel GAN

viewof gan_epoch = Inputs.range([0, 100], {
  label: "Époques d'entraînement",
  value: 0, step: 1
})

import { createGanDuel } from "../../assets/js/simulations/gan.js"
createGanDuel(gan_epoch)

6.2.3 Les Pathologies de l’Entraînement

L’équilibre du jeu GAN est très difficile à atteindre en pratique : soit le discriminateur devient trop fort et coupe tout signal au générateur, soit le générateur trouve un raccourci et ne produit que quelques sorties « sûres ».

Dans la métaphore du peintre, deux pannes reviennent souvent : le critique devient si sévère que l’apprenti ne sait plus quoi corriger, ou l’apprenti répète toujours le même tableau qui passe à peu près.

🔍 Détails des instabilités

En pratique, cet équilibre théorique est difficile à atteindre en raison de deux instabilités structurelles (Brownlee 2019; Google for Developers, n.d.) :

Vanishing Gradients :

Quand le discriminateur est trop performant, D(\hat{\mathbf{x}}) \approx 0 pour toutes les données générées. Le gradient \nabla_\theta \log(1 - D(G(\mathbf{z}))) s’annule, et le générateur ne reçoit plus de signal utile pour s’améliorer. En pratique, on utilise l’objectif alternatif \max_G \mathbb{E}[\log D(G(\mathbf{z}))] (non-saturating loss) pour pallier ce problème (Jackson, n.d.).

Mode Collapse :

Le générateur converge vers un ensemble limité de sorties “sûres” qui trompent le discriminateur, ignorant la diversité de p_0. Au lieu d’apprendre toute la distribution, il “mémorise” quelques modes. Le discriminateur, confronté à ces faux répétitifs, converge vers une contre-stratégie locale, et le jeu oscille plutôt que de converger globalement (PatSnap Eureka 2025).

Pathologie	Symptôme	Cause
Vanishing gradients	Gradient nul pour G	Discriminateur trop fort
Mode collapse	Faible diversité des sorties	Générateur en boucle locale
Oscillation	Poids qui ne convergent pas	Dynamique de Nash non-convexe
Explosion du discriminateur	D(\hat{\mathbf{x}}) \to 0 brutalement	Désynchronisation des vitesses d’entraînement

6.2.4 L’Équilibre de Nash en Pratique

En théorie, le duel a un point d’équilibre. En pratique, avec de grands réseaux de neurones, le terrain est cabossé : les deux joueurs peuvent tourner en rond, se dépasser, ou apprendre à des vitesses trop différentes.

🔍 Pourquoi la convergence est fragile

La convergence vers l’Équilibre de Nash dans un espace de paramètres non-convexe est problématique. Les dynamiques de gradient standard (descente de gradient alternée) ne garantissent pas la convergence dans un jeu à somme nulle non-convexe. L’entraînement des GANs requiert un équilibre délicat entre les vitesses d’apprentissage, le nombre de mises à jour relatives du discriminateur et du générateur, et des techniques de régularisation spécifiques (Moghaddam et al. 2023).

6.3 Architectures Avancées et Stabilisation des GANs

Les GANs de base sont puissants mais nerveux. Les architectures avancées ajoutent des rails : certaines aident le modèle à mieux comprendre les images, d’autres donnent plus de contrôle, et d’autres rendent le duel plus stable.

🔍 Vue technique

L’évolution des GANs est une histoire de stabilisation progressive : chaque architecture répond à une pathologie spécifique identifiée dans les GANs naïfs. Trois axes de progression dominent : les biais structurels (convolutions), le contrôle de la synthèse (style/conditioning), et la régularisation théorique (distance de Wasserstein).

📉 Stabilité GAN

import { GAN_ARCH_OPTIONS } from "../../assets/js/simulations/learning-curves.js"
viewof gan_arch = Inputs.select(GAN_ARCH_OPTIONS, { value: "GAN vanilla", label: "Architecture" })

import { updateGANArchViz } from "../../assets/js/simulations/learning-curves.js"

_ganArch = {
  updateGANArchViz(document.getElementById("gan-arch-chart-container"), gan_arch);
}

6.3.1 DCGAN et Convolutions

Un DCGAN donne au GAN les bons outils pour les images : au lieu de regarder les pixels comme une longue liste, il regarde des petits voisinages, comme un œil qui repère d’abord des contours et des textures.

🔍 Détails techniques

Le DCGAN (Deep Convolutional GAN, Radford et al. 2015) est la première architecture systématiquement stable (Radford, Metz, and Chintala 2015). Son apport fondamental : remplacer les couches entièrement connectées par des convolutions dans le générateur et le discriminateur. Ce choix force les deux réseaux à exploiter les corrélations spatiales locales plutôt que de traiter chaque pixel indépendamment.

Le générateur DCGAN utilise des convolutions transposées (transposed convolutions) pour upsampler progressivement du bruit \mathbf{z} vers l’image finale. Le discriminateur utilise des convolutions avec stride pour downsampler. Des Batch Normalization stabilisent les activations à chaque couche. Les fonctions d’activation ReLU (générateur) et Leaky ReLU (discriminateur) complètent le design.

Cette inductive bias spatiale réduit drastiquement les oscillations et le mode collapse pour la génération d’images, établissant les convolutions comme composante standard des GANs visuels.

6.3.2 StyleGAN et Style

StyleGAN sépare ce qui change la structure générale d’une image de ce qui change son apparence fine. C’est comme régler séparément la pose d’un portrait, l’éclairage, la texture de peau et la couleur des cheveux.

🔍 Détails techniques

StyleGAN (Karras et al. 2018, 2019) représente un saut qualitatif majeur en réarchitecturant fondamentalement le générateur pour découpler style et contenu (Chen, Zhang, and Zhang 2026) :

• Mapping Network : Un MLP de 8 couches transforme le vecteur de bruit \mathbf{z} en un vecteur de style intermédiaire \mathbf{w} \in \mathcal{W}. Cet espace \mathcal{W} est plus linéaire et disentangled que \mathcal{Z}.
• AdaIN (Adaptive Instance Normalization) : À chaque couche du générateur, le style \mathbf{w} est injecté via des paramètres d’échelle et de décalage qui modulent les cartes de caractéristiques : \text{AdaIN}(\mathbf{x}_i, \mathbf{w}) = \mathbf{y}_{s,i} \frac{\mathbf{x}_i - \mu(\mathbf{x}_i)}{\sigma(\mathbf{x}_i)} + \mathbf{y}_{b,i}.
• Progressive Growing : L’entraînement commence sur de petites résolutions (4×4) et augmente progressivement jusqu’à 1024×1024, permettant au réseau d’abord d’apprendre la structure globale, puis les détails.

Cette architecture permet un contrôle sémantique granulaire : les couches basses du générateur contrôlent la structure haute fréquence (poses, formes) tandis que les couches hautes contrôlent les textures fines (couleur, éclairage).

6.3.3 cGAN Conditionnel

Un cGAN ajoute une consigne au faussaire : “génère un chat”, “transforme cette esquisse”, ou “augmente la résolution”. Le critique vérifie alors deux choses : l’image est-elle réaliste, et respecte-t-elle la consigne ?

🔍 Détails techniques

Les GANs Conditionnels (conditional GANs) ajoutent une information de condition \mathbf{c} (classe, texte, image) à la fois au générateur et au discriminateur (“Generative Adversarial Networks | CAIS++,” n.d.) :

G(\mathbf{z}, \mathbf{c}) \to \hat{\mathbf{x}}, \qquad D(\mathbf{x}, \mathbf{c}) \to [0,1]

Le discriminateur ne juge plus seulement si \mathbf{x} est réaliste, mais si (\mathbf{x}, \mathbf{c}) est une paire cohérente. Les cGANs permettent la génération contrôlée : image-to-image (pix2pix), texte-to-image (première génération), ou super-résolution conditionnée sur une image basse résolution.

6.3.4 WGAN et Distance de Wasserstein

Le WGAN change la manière de mesurer l’écart entre les vrais exemples et les faux. Au lieu d’un verdict brutal, il donne une distance plus progressive, comme mesurer combien de travail il faudrait pour transformer un tas de sable en un autre tas.

🔢 Distance de Wasserstein et WGAN-GP

La critique théorique la plus fondamentale des GANs originaux identifie la divergence de Jensen-Shannon comme source d’instabilité (Arjovsky and Bottou 2017). Quand p_0 et p_G ont des supports disjoints (fréquent en haute dimension), la divergence JS est constante (\log 2) partout sauf sur leur intersection — le gradient est donc nul, même si les distributions sont très éloignées.

Le WGAN substitue la Distance de Wasserstein (ou Earth Mover’s Distance) comme objectif (Wikipedia contributors 2026b) :

W(p_0, p_G) = \sup_{\|f\|_L \leq 1} \mathbb{E}_{\mathbf{x} \sim p_0}[f(\mathbf{x})] - \mathbb{E}_{\hat{\mathbf{x}} \sim p_G}[f(\hat{\mathbf{x}})]

Contrairement à la divergence JS, W est continue et différentiable même quand les supports sont disjoints, fournissant un gradient informatif au générateur dans tous les cas. Le discriminateur (rebaptisé “critique” car non borné à [0,1]) apprend à maximiser la différence d’espérance entre réelles et fausses, sous la contrainte de Lipschitz \|f\|_L \leq 1.

WGAN-GP (Gulrajani et al. 2017) impose cette contrainte via une pénalité de gradient plutôt que par clipping des poids (Gulrajani et al. 2017) :

\mathcal{L}_{\text{GP}} = \lambda \, \mathbb{E}_{\hat{\mathbf{x}} \sim p_{\hat{\mathbf{x}}}}\!\left[\left(\|\nabla_{\hat{\mathbf{x}}} D(\hat{\mathbf{x}})\|_2 - 1\right)^2\right]

où \hat{\mathbf{x}} est tiré uniformément sur les segments reliant des points réels et générés.

6.3.5 Normalisation Spectrale

La normalisation spectrale limite la violence des réactions du discriminateur. C’est comme régler le volume maximal du critique pour qu’il donne encore un signal utile au générateur.

🔍 Détails techniques

La Normalisation Spectrale (Miyato et al. 2018) offre une alternative élégante à la pénalité de gradient (Davies Meyer 2026; Cosgrove 2018). Elle contrôle la constante de Lipschitz du discriminateur en normalisant chaque couche de poids \mathbf{W} par sa valeur singulière maximale \sigma_{\max}(\mathbf{W}) :

\hat{\mathbf{W}} = \frac{\mathbf{W}}{\sigma_{\max}(\mathbf{W})}

\sigma_{\max} est estimée efficacement par l’algorithme de power iteration, qui converge en quelques itérations. Cette normalisation garantit que chaque couche est 1-Lipschitz, rendant l’ensemble du réseau K-Lipschitz (pour un K contrôlable). La normalisation spectrale s’applique aussi facilement au discriminateur qu’au générateur, et est devenue un standard de stabilisation (“[PDF] Spectral Normalization for Generative Adversarial Networks - Semantic Scholar,” n.d.).

6.4 Génération par Diffusion Inverse

Un DDPM apprend à créer en faisant l’inverse d’une destruction contrôlée : on apprend d’abord comment une image devient du bruit, puis le modèle apprend à retirer ce bruit étape par étape.

C’est une autre façon de générer : au lieu d’un duel entre faussaire et critique, on entraîne un spécialiste du “nettoyage” qui sait transformer un nuage de bruit en image cohérente.

🔍 Détails techniques

Les Denoising Diffusion Probabilistic Models (DDPM) représentent un changement de paradigme par rapport aux GANs. Inspirés par la physique statistique, ils déplacent la charge générative de la compétition adversariale vers la reconstruction thermodynamique : apprendre à inverser un processus de dégradation progressive (Ho, Jain, and Abbeel 2020; Weng 2021).

🌡️ Diffusion DDPM

viewof ddpm_t = Inputs.range([0, 100], { value: 0, step: 1, label: "Pas t" })

ᾱ_t

—

Signal restant

import { updateDiffusionViz } from "../../assets/js/simulations/diffusion.js"

_ddpmViz = {
  updateDiffusionViz(
    document.getElementById("ddpm-chart-container"),
    document.getElementById("ddpm-alpha-display"),
    { t: ddpm_t, T: 100 }
  );
}

6.4.1 Destruction Contrôlée

Le processus forward salit progressivement une image avec du bruit. Au début, on reconnaît encore l’image ; à la fin, il ne reste qu’un brouillard aléatoire.

🔢 Formules du bruit progressif

Le processus forward (ou de diffusion) dégrade itérativement une donnée \mathbf{x}_0 \sim p_0 en ajoutant du bruit gaussien à chaque pas de temps t \in \{1, \ldots, T\} (Singh and Bongratz 2024; “Denoising Diffusion Probabilistic Models in Six Simple Steps - arXiv” 2024). Ce processus est markovien et défini par :

q(\mathbf{x}_t | \mathbf{x}_{t-1}) = \mathcal{N}(\mathbf{x}_t; \sqrt{1 - \beta_t} \, \mathbf{x}_{t-1}, \beta_t \mathbf{I}) (voir le Glossaire)

• q(\mathbf{x}_t | \mathbf{x}_{t-1}) : la probabilité conditionnelle de transition d’état au pas t.
• \beta_t (bêta) : coefficient de bruit au pas t (déterminant la quantité de bruit injectée).
• \mathbf{I} : la matrice identité (bruit isotrope, identique et indépendant sur chaque dimension).

où \{\beta_t\}_{t=1}^T est un calendrier de bruit (noise schedule) croissant. En définissant \alpha_t = 1 - \beta_t et \bar\alpha_t = \prod_{s=1}^t \alpha_s, on obtient la forme fermée permettant d’échantillonner \mathbf{x}_t directement depuis \mathbf{x}_0 sans simuler toutes les étapes intermédiaires (voir le Glossaire) :

q(\mathbf{x}_t | \mathbf{x}_0) = \mathcal{N}(\mathbf{x}_t; \sqrt{\bar\alpha_t} \, \mathbf{x}_0, (1 - \bar\alpha_t) \mathbf{I})

• \alpha_t (alpha) : coefficient de conservation du signal original au pas t.
• \bar\alpha_t : le produit cumulatif (via l’opérateur de produit successif \prod) des coefficients de conservation du pas 1 au pas t.

Pour T suffisamment grand (typiquement T = 1000) et \bar\alpha_T \approx 0, \mathbf{x}_T \approx \mathcal{N}(\mathbf{0}, \mathbf{I}) — la donnée est devenue du bruit pur.

🌡️ Diffusion de l’Encre

Imaginez une goutte d’encre dans un verre d’eau. Le processus forward est la diffusion naturelle : l’encre se disperse progressivement jusqu’à ce que la solution soit uniformément colorée (état de haute entropie = bruit pur). Le processus reverse est la diffusion inverse : apprendre à reconcentrer l’encre en une goutte cohérente à partir du chaos. La physique interdit ce retour spontané (deuxième loi de la thermodynamique), mais un modèle entraîné peut l’apprendre statistiquement, à condition de connaître le “gradient de densité” — la fonction de score.

6.4.2 Reconstruction Apprise

Le processus reverse est le geste inverse : partir du brouillard et retirer un petit morceau de bruit à chaque étape, comme si l’on essayait de reformer la goutte d’encre dispersée.

🔢 Formules de reconstruction

Le processus reverse apprend à remonter de \mathbf{x}_T vers \mathbf{x}_0, étape par étape. La distribution inverse est approximée par un réseau de neurones p_\theta (Ho, Jain, and Abbeel 2020; Raha, n.d.) :

p_\theta(\mathbf{x}_{t-1} | \mathbf{x}_t) = \mathcal{N}(\mathbf{x}_{t-1}; \boldsymbol{\mu}_\theta(\mathbf{x}_t, t), \boldsymbol{\Sigma}_\theta(\mathbf{x}_t, t)) (voir le Glossaire)

• p_\theta(\mathbf{x}_{t-1} | \mathbf{x}_t) : distribution inverse apprise paramétrée par les poids \theta du réseau.
• \boldsymbol{\mu}_\theta(\mathbf{x}_t, t), \boldsymbol{\Sigma}_\theta(\mathbf{x}_t, t) : moyenne et covariance de l’état précédent estimées par le réseau de neurones.

Ho et al. (2020) montrent qu’il est optimal de paramétrer \boldsymbol{\mu}_\theta non pas directement, mais via une prédiction du bruit \boldsymbol{\epsilon}_\theta(\mathbf{x}_t, t) (voir le Glossaire) :

\boldsymbol{\mu}_\theta(\mathbf{x}_t, t) = \frac{1}{\sqrt{\alpha_t}} \left(\mathbf{x}_t - \frac{\beta_t}{\sqrt{1 - \bar\alpha_t}} \boldsymbol{\epsilon}_\theta(\mathbf{x}_t, t)\right)

• \boldsymbol{\epsilon}_\theta(\mathbf{x}_t, t) : le bruit d’écart gaussien estimé par le réseau (U-Net) à partir de la version bruitée \mathbf{x}_t et de l’indice temporel t.

6.4.3 L’Objectif Simplifié

À l’entraînement, on donne au modèle une image bruitée et on lui demande : “quel bruit a été ajouté ?” S’il sait prédire ce bruit, il sait aussi l’enlever.

🔢 Perte de débruitage

L’objectif d’entraînement ELBO se simplifie remarquablement en une perte de débruitage (Ho, Jain, and Abbeel 2020; “DIFFUSION MODELS,” n.d.) :

\mathcal{L}_{\text{simple}} = \mathbb{E}_{t, \mathbf{x}_0, \boldsymbol{\epsilon}}\!\left[\|\boldsymbol{\epsilon} - \boldsymbol{\epsilon}_\theta(\sqrt{\bar\alpha_t}\,\mathbf{x}_0 + \sqrt{1-\bar\alpha_t}\,\boldsymbol{\epsilon}, \, t)\|^2\right] (voir le Glossaire)

• \mathbb{E}_{t, \mathbf{x}_0, \boldsymbol{\epsilon}} : espérance mathématique calculée sur le pas t (tiré uniformément), l’échantillon initial \mathbf{x}_0, et le bruit gaussien standard \boldsymbol{\epsilon} \sim \mathcal{N}(\mathbf{0}, \mathbf{I}).
• \|\cdot\|^2 : la norme Euclidienne au carré, pénalisant l’erreur de prédiction de bruit élément par élément.

Le modèle apprend simplement à prédire le bruit ajouté à partir de l’image bruitée et du pas de temps t. Cette reformulation est à la fois simple à implémenter et efficace à optimiser.

6.4.4 L’Architecture U-Net

Le U-Net regarde l’image à plusieurs tailles à la fois : les grandes formes d’un côté, les petits détails de l’autre. C’est utile pour enlever du bruit sans perdre la structure globale.

🔍 Détails techniques

Le réseau \boldsymbol{\epsilon}_\theta est typiquement un U-Net — une architecture encodeur-décodeur avec connexions de saut (skip connections) permettant de combiner les représentations à différentes échelles (Milvus, n.d.a). Le partage de poids entre les couches du U-Net à différentes résolutions spatiales est une forme de Sparse Weight-Sharing : le même filtre appris s’applique à différentes échelles, exploitant la structure multi-échelle inhérente aux images naturelles.

6.4.5 DDIM Déterministe

Le DDPM classique est lent parce qu’il enlève le bruit en beaucoup de petites étapes. DDIM garde le même modèle, mais prend des raccourcis plus directs pour générer plus vite.

🔢 Formule DDIM

Un défaut majeur des DDPM est la lenteur de la génération : T = 1000 passes du réseau pour générer une image. Le DDIM (Denoising Diffusion Implicit Models) reformule le processus inverse comme un ODE déterministe plutôt qu’une SDE stochastique, permettant de réduire le nombre de pas à 50–100 sans perte significative de qualité (Milvus, n.d.b; Tarricone 2026) :

\mathbf{x}_{t-1} = \sqrt{\bar\alpha_{t-1}} \underbrace{\frac{\mathbf{x}_t - \sqrt{1-\bar\alpha_t}\,\boldsymbol{\epsilon}_\theta(\mathbf{x}_t, t)}{\sqrt{\bar\alpha_t}}}_{\text{prédiction de }\mathbf{x}_0} + \sqrt{1-\bar\alpha_{t-1}} \, \boldsymbol{\epsilon}_\theta(\mathbf{x}_t, t) (voir le Glossaire)

• \bar\alpha_{t-1} : le coefficient cumulatif de conservation du signal à l’étape temporelle précédente t-1.

Le DDIM utilise le même modèle entraîné que le DDPM mais change uniquement le schéma de sampling, offrant un compromis vitesse/qualité contrôlable.

6.5 Pourquoi la Diffusion Domine

Les modèles de diffusion marchent bien parce qu’ils exploitent une propriété simple des images : un pixel dépend surtout de ses voisins. Ils n’essaient donc pas d’apprendre tout l’univers d’un coup, mais une multitude de relations locales.

🔍 Résultat théorique

La supériorité empirique des modèles de diffusion sur les GANs pour la génération d’images haute qualité a longtemps manqué de fondements théoriques rigoureux. Les travaux de Kwon, Kim et Ohn (2026) fournissent la première preuve d’optimalité minimax pour les modèles de diffusion sur des classes de densités réalistes (Kwon, Kim, and Ohn 2026).

6.5.1 Densités Factorisables et Structure de Graphe

Une image n’est pas une liste de pixels indépendants. Les pixels voisins forment des petits groupes cohérents : un bord, une texture, une ombre. La diffusion tire parti de cette structure locale.

🔢 Formulation par graphe

La clé du résultat de Kwon et al. est l’hypothèse de factorisabilité : la densité cible p_0 est supposée factorisable selon la structure d’un graphe de Markov. Formellement, si les variables (\mathbf{x}_1, \ldots, \mathbf{x}_n) sont organisées en un graphe \mathcal{G}, la densité se factorise en produit de facteurs locaux dépendant uniquement des nœuds voisins dans \mathcal{G} :

p_0(\mathbf{x}) \propto \prod_{C \in \mathcal{C}(\mathcal{G})} \phi_C(\mathbf{x}_C)

où \mathcal{C}(\mathcal{G}) est l’ensemble des cliques maximales. Pour des images naturelles, cette hypothèse est bien vérifiée : les pixels voisins sont fortement corrélés, tandis que les pixels distants sont quasi-indépendants conditionnellement aux pixels intermédiaires. La dimension effective d du problème est alors gouvernée par la taille des cliques maximales, non par la dimension ambiante D (nombre de pixels) (Kwon, Kim, and Ohn 2026).

6.5.2 Dimensionnalité et Diffusion

Le problème des images, c’est leur taille : une image contient énormément de pixels. Si on veut apprendre toutes les combinaisons possibles directement, le nombre d’exemples nécessaires explose. La diffusion réduit ce problème en apprenant surtout des relations locales.

🔢 Taux de convergence

Pour les estimateurs classiques (KDE, mélanges paramétriques), le taux de convergence optimal pour estimer p_0 \in \mathcal{H}^\beta (espace de Sobolev de régularité \beta) est (Kwon, Kim, and Ohn 2026) :

\text{Rate}_{\text{classique}} = O\!\left(n^{-\frac{\beta}{2\beta + D}}\right)

où n est le nombre d’échantillons et D est la dimension ambiante. Pour des images haute résolution (D \gg 100), ce taux est catastrophiquement lent — la malédiction de la dimensionnalité est totale.

Pour les modèles de diffusion avec architecture Sparse Weight-Sharing (U-Net, CNN), Kwon et al. démontrent un taux adapté à la dimension effective d des cliques (Kwon, Kim, and Ohn 2026) :

\text{Rate}_{\text{diffusion}} = O\!\left(n^{-\frac{\beta}{2\beta + d}}\right)

Ce résultat est remarquable : les modèles de diffusion s’affranchissent de la malédiction de la dimensionnalité en s’adaptant automatiquement à la structure de dépendance locale des données.

6.5.3 Le Rôle du Sparse Weight-Sharing

Le partage de poids est une astuce très concrète : le même détecteur de motif peut servir à plusieurs endroits de l’image. Un filtre qui repère un bord en haut à gauche peut aussi repérer un bord en bas à droite.

🔍 Lecture théorique

Le lien entre l’architecture et la théorie est direct : le partage de poids épars (Sparse Weight-Sharing) des convolutions et U-Nets agit comme un régulateur de l’entropie métrique du modèle (Kwon, Kim, and Ohn 2026). En limitant la complexité effective du modèle via le partage de paramètres, ces architectures respectent une contrainte implicite sur le nombre de “degrés de liberté fonctionnels”, permettant d’atteindre le taux minimax optimal.

En d’autres termes, l’U-Net n’est pas seulement un choix architectural pratique — c’est un choix théoriquement fondé qui garantit l’optimalité statistique de l’estimateur de score.

6.5.4 Comparaison Pratique

En pratique, les GANs génèrent vite mais peuvent manquer de diversité. La diffusion est plus lente, mais couvre mieux les variations des données et s’entraîne plus calmement.

Critère	GANs	DDPM/Diffusion
Couverture de p_0	Partielle (mode collapse)	Totale (couverture garantie)
Stabilité d’entraînement	Fragile (équilibre Nash)	Robuste (objectif convexe par étape)
Vitesse de génération	Rapide (1 passe)	Lente (T passes, améliorable via DDIM)
Qualité haute résolution	Excellente (StyleGAN)	SOTA actuel
Fondement théorique	Partiel	Optimalité minimax prouvée (Kwon, Kim, and Ohn 2026)
Contrôle de la génération	Via conditioning	Via guidance (classifier, CFG)

6.5.5 La Guidance sans Classificateur (CFG)

La CFG est une manière de pousser le modèle à mieux suivre une consigne. Elle augmente le poids de la direction “ceci ressemble à la demande”, un peu comme demander au peintre : “plus chat, moins paysage”.

🔢 Formule de guidance

Un apport majeur pour la génération conditionnelle par diffusion est le Classifier-Free Guidance (Ho et Salimans 2022). Plutôt qu’un classificateur externe, le modèle apprend simultanément la prédiction conditionnelle \boldsymbol{\epsilon}_\theta(\mathbf{x}_t, \mathbf{c}) et inconditionnelle \boldsymbol{\epsilon}_\theta(\mathbf{x}_t, \emptyset). La guidance est alors appliquée comme une extrapolation directionnelle :

\tilde{\boldsymbol{\epsilon}}_\theta(\mathbf{x}_t, \mathbf{c}) = \boldsymbol{\epsilon}_\theta(\mathbf{x}_t, \emptyset) + w \cdot \left[\boldsymbol{\epsilon}_\theta(\mathbf{x}_t, \mathbf{c}) - \boldsymbol{\epsilon}_\theta(\mathbf{x}_t, \emptyset)\right]

Le coefficient w contrôle le compromis entre fidélité à la condition \mathbf{c} et diversité — un w élevé produit des images très fidèles à la condition mais moins variées. Cette technique est au cœur de Stable Diffusion et DALL-E.

6.6 De la Compétition à la Reconstruction

Ce chapitre raconte deux grandes manières de générer : faire progresser un faussaire grâce à un critique (GAN), ou apprendre à nettoyer du bruit jusqu’à faire apparaître une image (diffusion).

Les deux approches ne s’opposent pas totalement : les GANs montrent la puissance de la compétition, tandis que la diffusion montre la puissance d’une reconstruction patiente et guidée.

🔍 Lecture technique

La trajectoire technologique de ce chapitre illustre une transition fondamentale dans le paradigme de la génération : du duel stratégique des GANs à la reconstruction rigoureuse des DDPM. Ces deux approches ne sont pas mutuellement exclusives — elles sont complémentaires, chacune révélant un aspect différent du problème de la modélisation de p_0.

6.6.1 Diffusion et Transformers

Les modèles récents mélangent souvent diffusion et Transformers : la diffusion sait générer progressivement, et les Transformers savent relier des éléments éloignés entre eux.

🔍 Détails techniques

Les modèles de diffusion modernes abandonnent progressivement le U-Net au profit des Diffusion Transformers (DiT) (Peebles et Xie, 2023). Un DiT remplace les couches convolutionnelles du U-Net par des blocs d’attention, permettant de modéliser des dépendances à longue portée entre des régions éloignées de l’image. Cette évolution combine les avantages théoriques de la diffusion (optimalité minimax, couverture totale) avec la puissance de modélisation globale des Transformers (Chen, Zhang, and Zhang 2026; “Diffusion Transformer Vs GAN: Which Generates Better Images? - Newline,” n.d.).

Les Latent Diffusion Models (dont Stable Diffusion) ajoutent une couche d’efficacité en faisant opérer le processus de diffusion non pas dans l’espace des pixels (D \times D \times 3) mais dans l’espace latent d’un VAE (d_z \ll D^2). Cette séparation des préoccupations — compression sémantique (VAE, chapitre 5) et modélisation générative (diffusion) — est la clé de la scalabilité des modèles texte-to-image modernes.

6.6.2 Génération Vidéo

La vidéo est plus difficile que l’image parce qu’il faut rester cohérent dans le temps. Un personnage ne doit pas changer de visage d’une frame à l’autre, et les mouvements doivent rester plausibles.

🔍 Pourquoi la vidéo est difficile

Si les modèles de diffusion dominent aujourd’hui la synthèse d’images, le défi se déplace vers la génération vidéo et audio. La vidéo impose une contrainte de cohérence temporelle absolue absente dans la génération d’images statiques (Weng 2024a, 2024b) :

• Un objet qui disparaît derrière un autre doit réapparaître cohérent.
• Les mouvements physiques doivent respecter la dynamique du monde réel (gravité, inertie).
• L’identité des personnages doit être préservée entre les frames.

Ces contraintes nécessitent que le modèle encode une véritable “connaissance du monde” (world knowledge) — une représentation implicite des lois physiques et de la causalité. Sora (OpenAI, 2024) est la première démonstration à grande échelle d’un tel encodage temporel, via un DiT opérant sur des video patches 3D.

6.6.3 Points Clés à Retenir

🔑 Synthèse du Chapitre 6

• Goodfellow et al. (2014) : Introduction du cadre de la théorie des jeux pour la synthèse — duel Générateur / Discriminateur vers l’Équilibre de Nash.
• WGAN (Arjovsky 2017) : Remplacement du verdict trop brutal par une distance plus progressive, ce qui stabilise mieux le duel.
• Ho et al. (2020) : Standardisation des DDPM : apprendre à prédire le bruit ajouté pour pouvoir l’enlever.
• Kwon et al. (2026) : Explication théorique du succès de la diffusion : les images ont une structure locale que les U-Net exploitent très bien.
• Mécanisme central : On ne cherche plus forcément la formule exacte des données ; on apprend une direction utile pour revenir du bruit vers une donnée plausible.
• Trajectoire : GANs → DDPM → LDM → DiT → génération vidéo cohérente. Chaque étape répond à une limite de la précédente.

Arjovsky, Martin, and Léon Bottou. 2017. “Towards Principled Methods for Training Generative Adversarial Networks - arXiv.” arXiv:1701.04862. https://arxiv.org/abs/1701.04862.

Brownlee, Jason. 2019. “A Gentle Introduction to Generative Adversarial Network Loss Functions - MachineLearningMastery.com.” https://machinelearningmastery.com/generative-adversarial-network-loss-functions/.

Chen, Zhenyuan, Zechuan Zhang, and Feng Zhang. 2026. “From u-Nets to DiTs: The Architectural Evolution of Text-to-Image Diffusion Models (2021–2025) | ICLR Blogposts 2026.” https://iclr-blogposts.github.io/2026/blog/2026/diffusion-architecture-evolution/.

Cosgrove, Christian. 2018. “Spectral Normalization Explained - Christian Cosgrove.” https://christiancosgrove.com/blog/2018/01/04/spectral-normalization-explained.html.

Davies Meyer. 2026. “Spectral Normalization Explained: Definition, Examples & Use Cases (2026) | Davies Meyer.” https://ai-solutions.daviesmeyer.com/en/glossary/spectral-normalization.

“Denoising Diffusion Probabilistic Models in Six Simple Steps - arXiv.” 2024. https://arxiv.org/pdf/2402.04384.

“DIFFUSION MODELS.” n.d. https://cse.buffalo.edu/~kaiyiji/cse705/DM2.pdf.

“Diffusion Transformer Vs GAN: Which Generates Better Images? - Newline.” n.d. https://www.newline.co/@Dipen/diffusion-transformer-vs-gan-which-generates-better-images--41012490.

“Generative Adversarial Networks | CAIS++.” n.d. https://caisplusplus.usc.edu/curriculum/neural-network-flavors/generative-adversarial-networks.

Goodfellow, Ian J., Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. 2014a. “Generative Adversarial Nets.” https://courses.cs.washington.edu/courses/cse599i/20au/resources/L10_gans.pdf.

———. 2014b. “Generative Adversarial Nets - NIPS.” https://papers.neurips.cc/paper/5423-generative-adversarial-nets.pdf.

Google for Developers. n.d. “Common Problems | Machine Learning.” https://developers.google.com/machine-learning/gan/problems.

Gulrajani, Ishaan, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. 2017. “Improved Training of Wasserstein GANs - Advances in Neural Information Processing Systems.” https://proceedings.neurips.cc/paper_files/paper/2017/file/892c3b1c6dccd52936e27cbd0ff683d6-Paper.pdf.

Ho, Jonathan, Ajay Jain, and Pieter Abbeel. 2020. “Denoising Diffusion Probabilistic Models.” https://hojonathanho.github.io/diffusion/.

Jackson, Jacob. n.d. “Gradients of GAN Objectives | Jacob Jackson.” https://jacobjackson.com/gan-gradients/.

Kwon, Hyeok Kyu, Dongha Kim, and Ilsang Ohn. 2026. “Nonparametric Estimation of a Factorizable Density Using Diffusion Models - Journal of Machine Learning Research.” Journal of Machine Learning Research 27. https://www.jmlr.org/papers/volume27/25-0121/25-0121.pdf.

Milvus. n.d.a. “How Do You Design the Neural Network for the Reverse Diffusion Step? - Milvus.” https://milvus.io/ai-quick-reference/how-do-you-design-the-neural-network-for-the-reverse-diffusion-step.

———. n.d.b. “How Do You Implement and Compare DDPM and DDIM Sampling? - Milvus.” https://milvus.io/ai-quick-reference/how-do-you-implement-and-compare-ddpm-and-ddim-sampling.

Moghaddam, Monireh Mohebbi, Bahar Boroomand, Mohammad Jalali, Arman Zareian, Alireza Daeijavad, Mohammad Hossein Manshaei, and Marwan Krunz. 2023. “Games of GANs: Game-Theoretical Models for Generative Adversarial Networks.” Artificial Intelligence Review. https://doi.org/10.1007/s10462-023-10395-6.

PatSnap Eureka. 2025. “Game Theory in GANs: Nash Equilibrium and Mode Collapse - PatSnap Eureka.” https://eureka.patsnap.com/article/game-theory-in-gans-nash-equilibrium-and-mode-collapse.

“[PDF] Spectral Normalization for Generative Adversarial Networks - Semantic Scholar.” n.d. https://www.semanticscholar.org/paper/Spectral-Normalization-for-Generative-Adversarial-Miyato-Kataoka/84de7d27e2f6160f634a483e8548c499a2cda7fa.

Radford, Alec, Luke Metz, and Soumith Chintala. 2015. “Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks - arXiv.” arXiv:1511.06434. https://arxiv.org/abs/1511.06434.

Raha, Ritwik. n.d. “DDPM Explained for Dummies! - Ritwik’s Blog.” https://blog.ritwikraha.dev/ddpm-explained-for-dummies.

Singh, Rohan, and Fabian Bongratz. 2024. “9: Denoising Diffusion Probabilistic Models - ML-Neuro - BayernCollab.” https://collab.dvb.bayern/spaces/TUMmlneuro/pages/651271086/9+Denoising+Diffusion+Probabilistic+Models.

Tarricone, Lorenzo. 2026. “A Timeline of Sampling Methods of Diffusion Models | Oxford Protein Informatics Group.” https://www.blopig.com/blog/2026/05/a-timeline-of-sampling-methods-of-diffusion-models/.

Weng, Lilian. 2021. “What Are Diffusion Models? | Lil’log.” https://lilianweng.github.io/posts/2021-07-11-diffusion-models/.

———. 2024a. “Diffusion Models for Video Generation | Lil’log.” https://lilianweng.github.io/posts/2024-04-12-diffusion-video/.

———. 2024b. “Video-Generation | Lil’log.” https://lilianweng.github.io/tags/video-generation/.

———. 2025. “Generative-Model | Lil’log.” https://lilianweng.github.io/tags/generative-model/.

Wikipedia contributors. 2026a. “Generative Adversarial Network - Wikipedia.” https://en.wikipedia.org/wiki/Generative_adversarial_network.

———. 2026b. “Wasserstein GAN - Wikipedia.” https://en.wikipedia.org/wiki/Wasserstein_GAN.