Réseaux antagonistes génératifs (GAN) : le faussaire contre le détective

Le jeu du générateur et du discriminateur, un GAN écrit de zéro, la perte non saturante, huit amas sur un cercle et l’effondrement des modes, des chiffres plus nets qu’avec le VAE, mais pas tous, et le chemin des GAN aux modèles de diffusion.

12 minutes Matěj Žalmánek 2026-10-16

Série Bases de l’IA Partie 45 sur 52

1. Carte de l’intelligence artificielle : qu’est-ce qui est quoi et comment tout s’emboîte
2. Brève histoire de l’intelligence artificielle : de Turing aux modèles de langage
3. Données, modèle, entraînement, inférence : les notions de base sur un seul exemple
4. Lire la notation mathématique : symboles, indices, sommes et quantificateurs
5. Ensembles et relations : les briques dont sont faites les définitions en IA
6. Fonctions et applications : pourquoi tout modèle d’IA est une fonction
7. Logique et démonstrations : les règles selon lesquelles on raisonne en IA
8. Graphes et arbres : la structure sur laquelle reposent la recherche et les réseaux de neurones
9. Algèbre linéaire pour l’apprentissage automatique : vecteurs, matrices et pourquoi l’IA multiplie surtout
10. Dérivées, gradient et règle de dérivation en chaîne : comment un modèle sait dans quelle direction apprendre
11. Descente de gradient : comment un modèle apprend
12. Qu’est-ce que la probabilité : du lancer de dé aux axiomes de Kolmogorov
13. Probabilité conditionnelle et théorème de Bayes : comment réviser une estimation quand on apprend du nouveau
14. Variable aléatoire et fonction de répartition : une seule fonction qui dit tout de la loi
15. Fonction de densité et fonction de masse : pourquoi une variable continue a une probabilité nulle en chaque point
16. Espérance, variance et covariance : où se situe une loi, quelle est sa largeur et ce qui varie avec quoi
17. Panorama des lois de probabilité : Bernoulli, binomiale, Poisson, uniforme, normale et exponentielle
18. Loi des grands nombres et théorème central limite : pourquoi les moyennes sont si prévisibles
19. Statistique et estimation de paramètres : maximum de vraisemblance, MAP et intervalles de confiance
20. Théorie de l’information : entropie, entropie croisée et divergence KL — d’où viennent les fonctions de perte
21. Recherche dans l’espace d’états : BFS, DFS, UCS et A* en animations
22. Jeux et adversaires : minimax, élagage alpha-bêta et Monte Carlo tree search
23. Satisfaction de contraintes : backtracking, propagation de contraintes et AC-3 sur un sudoku et une carte des régions tchèques
24. Logique et systèmes à base de connaissances : chaînage avant et arrière, résolution et systèmes experts
25. Planification : STRIPS, monde des blocs, heuristiques par relaxation et planification dans les agents IA
26. Recherche locale et recuit simulé : un voyageur de commerce à travers les chefs-lieux de région tchèques
27. Algorithmes génétiques : population, croisement, mutation et sélection sur un sac à dos de randonnée
28. Stratégies d’évolution et programmation génétique : de la règle du cinquième à la loi de Kepler
29. Optimisation par colonies de fourmis : comment une piste de phéromone trouve un chemin court
30. Optimisation par essaim de particules : inertie, expérience propre et expérience de l’essaim
31. Neuroévolution : faire évoluer les poids et la forme des réseaux de neurones, et l’algorithme NEAT
32. Ensembles flous et fonctions d’appartenance : comment écrire « un peu chaud »
33. Logique floue et probabilité : pourquoi « un peu chaud » ne veut pas dire « probablement chaud »
34. Logique floue : t-normes, implications et règles SI–ALORS
35. Commande floue : Mamdani et Sugeno, du ventilateur au pendule inversé sur un chariot
36. Clustering flou : l’algorithme fuzzy c-means et les points entre les clusters
37. Systèmes neuro-flous (ANFIS) : des règles floues qui apprennent à partir des données
38. Chaînes de Markov : matrice de transition, distribution stationnaire et PageRank
39. Modèles de Markov cachés : l’algorithme de Viterbi et le casino malhonnête
40. Réseaux bayésiens : pourquoi l’herbe est mouillée et ce que cela implique pour l’arroseur
41. Le filtre de Kalman : comment estimer, à partir de mesures imprécises, où se trouve une voiture et à quelle vitesse elle roule
42. Types d’apprentissage automatique : supervisé, non supervisé, semi-supervisé et plus
43. Prompts, contexte et RAG : comment donner au modèle les bonnes informations
44. Autoencodeurs variationnels (VAE) : de nouvelles images à partir d’un espace latent continu
45. Réseaux antagonistes génératifs (GAN) : le faussaire contre le détective
46. Modèles de diffusion : comment une image naît du bruit pur
47. Processus de décision markoviens : états, actions, récompenses et équations de Bellman
48. Q-learning et DQN : apprendre la valeur des actions, du tableau au réseau de neurones
49. Policy gradient et PPO : apprendre directement la politique
50. Comment fonctionne un agent IA : un modèle de langage en boucle avec des outils
51. Programmer avec des agents IA : consigne, tests et vérification
52. Évaluation et sécurité des systèmes d’IA : comment mesurer et comment surveiller

Programme complet de la série 52 sur 83 sujets publiés

L’autoencodeur variationnel de la partie précédente génère honnêtement, mais flou. En 2014, Ian Goodfellow a eu une idée qui ressemble presque à un tour de passe-passe : au lieu de mesurer à quel point un échantillon s’écarte des données, on laisse un autre réseau en juger. Deux réseaux jouent à un jeu — l’un contrefait, l’autre démasque la contrefaçon — et tous deux s’améliorent en chemin. C’est ainsi que sont nés les premiers visages générés par une machine qu’on ne distingue pas de photos. Dans cette partie, nous écrirons les deux réseaux de zéro et verrons pourquoi leur apprentissage est si capricieux.

Fait suite aux parties Autoencodeurs variationnels, Régression logistique (sigmoïde et entropie croisée) et Jeux et adversaires.

1. Le faussaire et le détective

Définition — réseau antagoniste génératif (GAN)

Un GAN (Ian Goodfellow et al., 2014) est formé de deux réseaux. Le générateur G transforme un bruit aléatoire z ~ N(0, I) en un échantillon G(z). Le discriminateur D renvoie la probabilité D(x) que x provienne des données réelles. Ils jouent à un jeu à deux joueurs à somme nulle :

min_G max_D E_{x ~ data}[log D(x)] + E_z[log(1 − D(G(z)))].

Pour un G fixé, le meilleur discriminateur est D*(x) = p_data(x) / (p_data(x) + p_G(x)). À l’équilibre, G génère exactement la distribution des données et D renvoie partout ½.

min_G max_D   E_{x ~ data}[ log D(x) ] + E_{z ~ N(0, I)}[ log(1 − D(G(z))) ]

E_{x ~ data}[log D(x)]

le discriminateur sur les données réelles — maximal (0) quand D donne 1 aux vrais échantillons ; le logarithme punit sans limite une erreur commise avec assurance (D → 0)

E_z[log(1 − D(G(z)))]

le discriminateur sur les contrefaçons — maximal quand il leur donne 0 ; c’est le seul terme où apparaît G, donc le générateur n’apprend que de lui

max_D

le discriminateur augmente la valeur — les deux termes ensemble forment l’opposé de l’entropie croisée binaire, c’est donc l’apprentissage ordinaire d’un classifieur « vrai / contrefaçon »

min_G

le générateur diminue la valeur — il veut que le discriminateur se trompe sur les contrefaçons ; ce qu’un joueur gagne, l’autre le perd (somme nulle)

Théorème — le meilleur discriminateur et ce que minimise le générateur

Pour un G fixé, la valeur du jeu est ∫ [p_data(x) log D(x) + p_G(x) log(1 − D(x))] dx. En chaque point x, on maximise la fonction a log y + b log(1 − y) pour y ∈ (0, 1), où a = p_data(x), b = p_G(x).

Démonstration. La dérivée a/y − b/(1 − y) s’annule pour y = a/(a + b) et la fonction est concave (dérivée seconde −a/y² − b/(1 − y)² < 0), il s’agit donc d’un maximum. D’où D*(x) = p_data(x) / (p_data(x) + p_G(x)). En substituant et en simplifiant (Goodfellow et al., 2014) :

V(D*, G) = −log 4 + 2 · JSD(p_data ‖ p_G),   JSD(p ‖ q) = ½ KL(p ‖ m) + ½ KL(q ‖ m),   m = ½(p + q).

La divergence de Jensen–Shannon est positive ou nulle, et nulle exactement pour p_G = p_data. Face au meilleur discriminateur, le générateur minimise donc la JSD, et le minimum −log 4 ≈ −1,386 est atteint quand il génère exactement les données. ∎

Exemple : là où la densité des données vaut 0,3 et celle des contrefaçons 0,1, on a D* = 0,3 / 0,4 = 0,75 (le point est plutôt vrai) ; là où le générateur en fait trop (données 0,1, contrefaçons 0,3), D* = 0,25. Là où les densités sont égales, D* = ½ et la perte du discriminateur (entropie croisée binaire par échantillon) vaut ln 2 ≈ 0,693.

Le discriminateur est un classifieur ordinaire avec une sigmoïde et une entropie croisée, comme la régression logistique, simplement avec des couches en plus. La magie est dans le générateur : le gradient de sa perte traverse par rétropropagation le discriminateur jusqu’à l’image, et de là les poids du générateur. Le discriminateur lui indique ainsi dans quelle direction déplacer chaque pixel pour paraître plus crédible.

2. Apprentissage : des pas alternés

On apprend à tour de rôle : un pas du discriminateur (un lot de données réelles et un lot de contrefaçons, augmenter D sur les vrais, le diminuer sur les faux), puis un pas du générateur (déplacer les contrefaçons là où D les tient pour vraies). Chez nous, les deux réseaux ont deux couches cachées avec leaky ReLU et apprennent avec Adam.

Définition — perte non saturante du générateur

Au lieu de minimiser log(1 − D(G(z))) du jeu d’origine, le générateur apprend à maximiser log D(G(z)), c’est-à-dire à minimiser −log D(G(z)). Les deux pertes ont le même but, mais un gradient différent : si D = σ(s), alors |∂ log(1 − D)/∂s| = D, tandis que |∂(−log D)/∂s| = 1 − D. Goodfellow et al. l’ont déjà proposée dans le même article.

∂/∂s log(1 − σ(s)) = −D,    ∂/∂s (−log σ(s)) = −(1 − D)

s

logit — la sortie du discriminateur avant la sigmoïde ; on dérive par rapport à lui, car c’est de là que le gradient repart dans le discriminateur et, à travers lui, jusqu’à la contrefaçon

D = σ(s)

probabilité que la contrefaçon soit vraie ; on utilise σ′(s) = σ(s)(1 − σ(s)), d’où des expressions aussi simples

log(1 − σ(s))

la perte d’origine du générateur (à minimiser) — son gradient a pour norme D, donc quand le discriminateur démasque sûrement la contrefaçon (D ≈ 0), il est presque nul : saturation

−log σ(s)

la perte non saturante — son gradient a pour norme 1 − D, il est donc le plus grand justement pour les contrefaçons que le discriminateur a démasquées

Pour être honnête : dans nos petites expériences, la perte d’origine apprenait aussi, parce que le discriminateur n’était pas si sûr de lui au début. Pour les grands réseaux sur des images, où le discriminateur gagne vite, la différence est cruciale. Dans la suite, nous utilisons la perte non saturante.

Comment le gradient arrive jusqu’au générateur, la règle de dérivation en chaîne le montre. La contrefaçon x = G(z) n’est pour le discriminateur qu’une entrée, la rétropropagation n’a donc pas à s’y arrêter :

∂L_G / ∂θ_G = ∂L_G / ∂s · ∂s / ∂x · ∂x / ∂θ_G

∂L_G / ∂s

un seul nombre tiré de la perte, pour la non saturante −(1 − D) — « de combien » la contrefaçon doit s’améliorer

∂s / ∂x

le gradient du discriminateur par rapport à son entrée (2 nombres pour le cercle, 64 pour un chiffre) — « dans quelle direction » déplacer chaque coordonnée pour que la contrefaçon paraisse plus vraie ; les poids du discriminateur ne changent pas à ce pas

∂x / ∂θ_G

la rétropropagation ordinaire à travers le générateur — elle convertit le déplacement voulu de la contrefaçon en une modification des poids du générateur

Définition — perte du discriminateur et softplus

Le discriminateur renvoie un logit s et D = σ(s). Pour un vrai échantillon de logit s_r et une contrefaçon de logit s_f, sa perte est l’entropie croisée binaire

L_D = −log σ(s_r) − log(1 − σ(s_f)) = softplus(−s_r) + softplus(s_f),   softplus(u) = ln(1 + e^u),

car −log σ(s) = ln(1 + e^−s) et 1 − σ(s) = σ(−s). Le programme calcule softplus à partir du logit, pas de D : pour s = 40, σ(s) vaut exactement 1 en virgule flottante et log(1 − D) donnerait −∞, alors que softplus(40) ≈ 40. Gradients : ∂L_D/∂s_r = σ(s_r) − 1, ∂L_D/∂s_f = σ(s_f).

for t in range(kroku):
    # 1. pas du discriminateur : vrais → 1, contrefaçons → 0
    gD = 0
    for _ in range(davka):
        x = nahodny_vzorek(data)
        gD += D.zpet(D(x), dL_ds=sigmoid(D(x)) - 1)
        f = G(sum())                           # contrefaçon, G n’apprend pas ici
        gD += D.zpet(D(f), dL_ds=sigmoid(D(f)))
    adam_D(gD / davka)
    # 2. pas du générateur : le gradient traverse D jusqu’à la contrefaçon
    gG = 0
    for _ in range(davka):
        x = G(sum())
        dL_ds = sigmoid(D(x)) - 1              # non saturante −log σ(s)
        dL_dx = D.zpet_do_vstupu(dL_ds)        # poids de D inchangés
        gG += G.zpet(dL_dx)
    adam_G(gG / davka)                         # Adam avec β₁ = 0,5 comme pour DCGAN

3. Huit amas sur un cercle

Une expérience classique : les données sont des points tirés de huit petits amas normaux (σ = 0,05) disposés sur un cercle de rayon 2. Le générateur reçoit un bruit bidimensionnel et renvoie un point du plan. Nous mesurons la qualité (la part des échantillons à moins de 3σ d’un des centres) et la couverture (dans combien d’amas tombent au moins 2 % des échantillons).

Définition — données, qualité et couverture

Les centres des amas sont c_j = (r cos(2πj/8), r sin(2πj/8)) pour j = 0, …, 7 avec r = 2 ; un point de données est c_j avec un j aléatoire plus un bruit N(0, σ²I), σ = 0,05. Pour des échantillons x₁, …, x_n du générateur :

qualité = (1/n) · #{i : min_j ‖x_i − c_j‖ < 3σ},   couverture = #{j : n_j ≥ 0,02 · n},

où n_j est le nombre d’échantillons à moins de 3σ du centre c_j. En chiffres : 3σ = 0,15, deux centres voisins sont distants de 2r sin(π/8) ≈ 1,53, soit plus de dix fois plus. Les instantanés comptent n = 400 échantillons, un amas compte donc comme couvert à partir de 8 échantillons.

Même un générateur parfait n’a pas une qualité de 100 % : la distance d’un point au centre d’une loi normale bidimensionnelle suit une loi de Rayleigh, et la part qui tombe à moins de 3σ vaut 1 − e^−9/2 ≈ 0,989, soit environ 98,9 %.

Après 500 pas, le générateur produit un nuage flou (qualité 6 %), après 2 000 pas, les points se resserrent en 6 amas, et à la fin (pas 8 000) il couvre les 8 avec une qualité de 73 %. Le générateur n’a jamais vu un seul point réel — il a tout appris du gradient du discriminateur.

4. Effondrement des modes

Définition — effondrement des modes (mode collapse)

Le générateur ne produit qu’une partie de la distribution des données — quelques modes (amas, types d’images) — et omet les autres. La perte ne le punit pas directement : le discriminateur juge chaque échantillon séparément, et une bonne contrefaçon d’un seul type le convainc autant qu’une collection variée. En cas d’effondrement complet, le générateur produit presque la même chose pour tout z.

Théorème — face à un discriminateur fixé, un seul point est optimal

Pour un D fixé, la perte du générateur est L_G = E_z[−log D(G(z))] ≥ −log D(x*), où x* est le point où D est maximal. L’égalité est atteinte pour un générateur qui envoie chaque z en x*.

Démonstration. Pour tout z, D(G(z)) ≤ D(x*), et comme −log est décroissante, −log D(G(z)) ≥ −log D(x*) ; l’espérance conserve l’inégalité. ∎

La perte est une moyenne sur les échantillons individuels et rien en elle ne récompense la diversité. Face à un adversaire fixé, l’effondrement complet est donc optimal ; seul l’empêche le fait que le discriminateur réagit et se met à soupçonner x*. Si le générateur saute plus vite que le discriminateur n’oublie, le jeu tourne en rond. C’est pourquoi aident les modifications qui donnent au discriminateur une vue sur le lot entier (minibatch discrimination, Tim Salimans et al., 2016) ou une autre distance entre distributions (Wasserstein, plus bas).

Même réseau, mêmes données, mêmes réglages — seule la graine aléatoire change :

Une seule des quatre exécutions a couvert les huit amas. L’exécution avec la graine 3 s’est arrêtée à 5 et n’a plus bougé depuis le pas 5 000. C’est typique des GAN : l’apprentissage n’a pas une perte unique qui diminuerait, mais un jeu à deux joueurs, et le résultat dépend du hasard plus que nous ne le voudrions.

5. Chiffres : plus nets, mais pas tous

Passons aux mêmes chiffres 8 × 8 que pour le VAE. Générateur : bruit à huit dimensions → 64 → 64 → 64 pixels avec une sigmoïde ; discriminateur en miroir. 6 000 pas, deux exécutions avec des graines différentes. Nous mesurons la qualité comme dans la partie précédente — par la distance d’un échantillon au chiffre d’entraînement le plus proche.

Les échantillons du GAN sont plus nets : distance 0,049 et 0,042 contre 0,054 pour le VAE (chiffres réels 0,017). Le GAN ne punit pas le flou par un moyennage comme la perte de reconstruction du VAE — une image floue, le discriminateur la reconnaît facilement. Mais combien de chaque chiffre le générateur produit-il ?

Dans les données, chaque chiffre est aussi fréquent. L’exécution avec la graine 2 produit pourtant surtout des six (69 sur 200), des huit et des trois, et presque pas de 0, 1, 2, 4, 7 (au plus 3 échantillons). L’exécution avec la graine 1 est plus variée, mais là aussi les chiffres 0, 4, 9 ont moins de la moitié de leur part (au plus 6 échantillons au lieu de 20). C’est le même effondrement des modes que pour le cercle, simplement sur des images : le GAN gagne en netteté, le VAE en couverture.

6. Des GAN à la diffusion

• DCGAN (Alec Radford et al., 2015) a montré comment construire des GAN convolutifs qu’on peut entraîner de façon fiable sur des photos.
• Wasserstein GAN (Martin Arjovsky et al., 2017) a remplacé le classifieur par un « critique » qui mesure la distance entre distributions ; l’apprentissage est plus stable et moins sujet à l’effondrement des modes.
• StyleGAN (Tero Karras et al., Nvidia, 2018–2020) génère des visages photoréalistes en résolution 1024 × 1024 — le site bien connu « this person does not exist ».
• Vers 2021, les GAN ont été dépassés par les modèles de diffusion (Prafulla Dhariwal et Alex Nichol : « Diffusion Models Beat GANs on Image Synthesis »). Ils sont plus lents, mais apprennent de façon stable et couvrent toute la distribution. L’idée du discriminateur survit pourtant — comme perte auxiliaire qui donne de la netteté aux images, par exemple dans les codeurs d’image ou de son.

Pourquoi Wasserstein aide se voit sur l’exemple le plus simple (une version simplifiée de l’exemple de l’article d’Arjovsky et al., 2017) : les données sont un seul point 0, le générateur produit un seul point θ. Tant que θ ≠ 0, les distributions ne se recouvrent pas et JSD = ln 2 ≈ 0,693, quelle que soit la distance de θ — le gradient par rapport à θ est nul et le générateur ne sait pas où aller. La distance de Wasserstein vaut |θ|, elle indique donc la direction même de très loin.

W(p_data, p_G) = sup_{‖f‖L ≤ 1} ( E_{x ~ data}[f(x)] − E_z[f(G(z))] )

sup_{‖f‖L ≤ 1}

le critique f — un réseau qui, au lieu d’une probabilité, renvoie un nombre quelconque ; la condition « 1-lipschitzienne » (|f(a) − f(b)| ≤ ‖a − b‖) l’empêche de distinguer deux points proches de façon arbitrairement tranchée, sinon la différence pourrait croître à l’infini

E_data[f(x)]

la note moyenne des données réelles — le critique la veut la plus grande possible

E_z[f(G(z))]

la note moyenne des contrefaçons — le critique la veut la plus petite possible, le générateur la plus grande ; la différence est continue en les paramètres du générateur, le gradient ne disparaît donc pas même quand les distributions ne se recouvrent pas

7. Résumé

• GAN = un générateur et un discriminateur en jeu ; le générateur n’apprend que du gradient que lui envoie le discriminateur.
• La perte non saturante −log D(G(z)) donne au générateur un signal fort même au début, quand le discriminateur gagne.
• Sur les huit amas, une seule des quatre exécutions les a tous couverts (7, 8, 5, 6) ; le résultat dépend beaucoup du hasard.
• Sur les chiffres, les échantillons sont plus nets que pour le VAE (0,042 contre 0,054), mais certains chiffres manquent — effondrement des modes.
• Aujourd’hui, ce sont surtout les modèles de diffusion qui génèrent les images ; le discriminateur est resté comme auxiliaire pour la netteté.

Envie de mettre la main à la pâte ? Demandez à un agent IA d’entraîner un petit GAN sur huit amas sur un cercle et de le lancer cinq fois avec des graines différentes. Puis qu’il essaie un Wasserstein GAN avec le même réseau et compare combien d’amas il couvre à chaque fois.

Vous voyez les choses autrement ? Écrivez à support@coden-app.com.