Réseaux Antagonistes Génératifs (GAN)

L'Essentiel

Ce qu’il faut retenir :

1. Quoi : Une architecture composée de deux réseaux de neurones (Générateur et Discriminateur) qui s’affrontent dans un jeu à somme nulle.
2. Pourquoi : Pour générer des données synthétiques (images, sons, textes) indiscernables des données réelles.
3. Comment : Le Générateur apprend à tromper le Discriminateur, tandis que le Discriminateur apprend à ne pas se faire duper.

Ce que vous saurez dans 3 minutes

Historiquement introduits par Ian Goodfellow en 2014, les GAN (Generative Adversarial Networks) ont marqué la première révolution de l’IA générative visuelle, bien avant l’avènement des modèles de diffusion (comme Midjourney). Bien que plus difficiles à entraîner, ils restent pertinents pour des tâches spécifiques nécessitant une inférence ultra-rapide ou des manipulations précises de style.

---

1. Comprendre

Définition

Définition

Un GAN (Generative Adversarial Network) est un modèle d’apprentissage non supervisé où deux réseaux de neurones entrent en compétition :

• Le Générateur ($G$) tente de créer des fausses données à partir de bruit aléatoire.
• Le Discriminateur ($D$) tente de distinguer les vraies données (du dataset) des fausses (créées par $G$).

L’équilibre atteint à la fin de l’entraînement (Équilibre de Nash) permet au Générateur de produire des contenus hyper-réalistes.

L’Analogie du Faussaire

Pour comprendre les GAN, l’analogie la plus célèbre est celle du Faussaire d’Art et de l’Expert.

1. Le Faussaire (Générateur) essaie de peindre de faux Picasso. Au début, ses toiles sont brouillonnes.
2. L’Expert (Discriminateur) examine les toiles. Il reçoit parfois de vrais Picasso, parfois les faux du Faussaire. Il doit dire “Vrai” ou “Faux”.
3. La Boucle d’Apprentissage :
   • Quand l’Expert repère un faux, il explique pourquoi (ex: “le coup de pinceau est trop grossier”). Le Faussaire apprend et s’améliore.
   • Quand le Faussaire réussit à tromper l’Expert, l’Expert se remet en question et affûte son regard.

Au fil du temps, le Faussaire devient si excellent que l’Expert ne peut plus faire la différence (probabilité de 50/50).

Architecture Conceptuelle (Mermaid)

Voici comment les données circulent dans un GAN standard :

graph LR
    Noise(Bruit Aléatoire 'z') -->|Input| G[Générateur]
    G -->|Fake Data| D[Discriminateur]
    Real(Données Réelles 'x') -->|Real Data| D
    
    D -->|Probabilité Real/Fake| Loss{Calcul de l'Erreur}
    Loss -->|Backprop (Maximiser Erreur)| G
    Loss -->|Backprop (Minimiser Erreur)| D

    style G fill:#f9f,stroke:#333
    style D fill:#bbf,stroke:#333
    style Loss fill:#fdd,stroke:#333

---

2. Appliquer

Les Mathématiques du Duel

Le GAN repose sur un Jeu Minimax (Minimax Game). L’objectif est de trouver un équilibre pour la fonction de valeur $V(D, G)$ :

\min_G \max_D V(D, G) = \mathbb{E}_{x \sim p_{data}(x)} [\log D(x)] + \mathbb{E}_{z \sim p_{z}(z)} [\log(1 - D(G(z)))]

Décryptage de la formule :

• E[log D(x)] : Le Discriminateur veut maximiser sa capacité à reconnaître les vraies données.
• E[log(1 - D(G(z)))] : Le Discriminateur veut aussi rejeter les faux.
• Le Générateur (G), lui, veut minimiser ce second terme.

Implémentation PyTorch

Voici à quoi ressemble un GAN minimaliste pour générer des chiffres (type MNIST) en PyTorch.

Générateur (Le Faussaire)

import torch
import torch.nn as nn

class Generator(nn.Module):
    def __init__(self, latent_dim=100, img_shape=(1, 28, 28)):
        super(Generator, self).__init__()
        self.img_shape = img_shape

        # De simples couches linéaires pour upsampler le bruit
        self.model = nn.Sequential(
            nn.Linear(latent_dim, 128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(128, 256),
            nn.BatchNorm1d(256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1024),
            nn.BatchNorm1d(1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, int(torch.prod(torch.tensor(img_shape)))),
            nn.Tanh() # Sortie entre -1 et 1 pour les pixels
        )

    def forward(self, z):
        img = self.model(z)
        img = img.view(img.size(0), *self.img_shape)
        return img

Discriminateur (L'Expert)

class Discriminator(nn.Module):
    def __init__(self, img_shape=(1, 28, 28)):
        super(Discriminator, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(int(torch.prod(torch.tensor(img_shape))), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid() # Sortie probabilité [0, 1]
        )

    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.model(img_flat)
        return validity

Cas d’usage : Quand choisir un GAN ?

Bien que les Modèles de Diffusion soient aujourd’hui rois pour la génération “Text-to-Image”, les GAN gardent des avantages critiques.

Critère	GAN	Diffusion Models
Vitesse d’Inférence	⚡ Ultra-Rapide (1 passe)	🐢 Lent (Denoising itératif)
Qualité Haute Résolution	⭐ Excellente (StyleGAN)	⭐ Excellente (SDXL, FLUX)
Diversité	⚠️ Risque de “Mode Collapse”	✅ Très haute diversité
Stabilité	❌ Très instable à entraîner	✅ Converge mieux
Usage Type	Filtres Snapchat, Super-Resolution, Deepfakes vidéo	Midjourney, DALL-E, Création artistique

---

3. Aller plus loin

Le Problème du “Mode Collapse”

C’est la bête noire des chercheurs en GAN. Cela se produit lorsque le Générateur trouve “une recette qui marche” pour tromper le Discriminateur (par exemple, générer toujours la même image de chien parfait) et ne produit plus rien d’autre. Le Discriminateur est coincé, et la diversité s’effondre.

• Solution : Utiliser des variantes comme WGAN (Wasserstein GAN) qui changent la fonction de perte pour empêcher ce comportement.

L’Héritage : StyleGAN et CycleGAN

Deux variantes historiques méritent d’être connues :

1. StyleGAN (NVIDIA) :

   • Il introduit le concept de “style mixing”. On peut séparer les attributs de “coarseness” (pose, forme du visage) des détails fins (couleur des yeux, texture de peau).
   • C’est la techno derrière le site viral ThisPersonDoesNotExist.com.

2. CycleGAN :

   • Permet le “Domain Transfer” sans paires d’images alignées.
   • Exemple célèbre : Transformer des chevaux en zèbres (et inversement) sur une vidéo, ou transformer des peintures de Monet en photos réalistes.

L’Ère Post-GAN

Pourquoi les Modèles de Diffusion ont-ils pris le dessus vers 2021-2022 ? Les GAN sont des systèmes instables. L’équilibre de Nash est un point de selle difficile à atteindre mathématiquement. Les modèles de diffusion, basés sur la thermodynamique et le débruitage progressif, offrent une fonction objectif plus stable (l’ELBO), garantissant une couverture complète de la distribution des données (pas de mode collapse).

Cependant, les GAN reviennent dans des architectures hybrides pour accélérer la génération (ex: GAN Distillation pour rendre Stable Diffusion plus rapide).

---

Questions Fréquentes

Quelle est la différence entre un GAN et un VAE ?

Le VAE (Variational Autoencoder) cherche à compresser l’image dans un espace latent puis à la reconstruire, ce qui produit souvent des images un peu floues. Le GAN, lui, cherche à “halluciner” des détails pour tromper un juge, produisant des images beaucoup plus nettes (sharp), mais parfois moins fidèles à la structure globale.

Est-ce que ChatGPT est un GAN ?

Non. ChatGPT est un modèle de type Transformer (Decoder-Only) entraîné par “Next Token Prediction” (prédire le mot suivant). Il n’y a pas de boucle adversariale Générateur/Discriminateur dans son architecture de base, bien que des techniques comme le RLHF (Reinforcement Learning from Human Feedback) utilisent un “Reward Model” qui ressemble un peu à un juge.

---

Notions Liées (Spider Web)

• Rival Historique : Diffusion Models (La technologie qui a “tué” les GANs pour l’image).
• Composant Clé : Réseau de Neurones (La brique de base).
• Risque : Deepfakes (L’application malveillante phare des GAN).

Ressources Externes

• Papier Fondateur : Generative Adversarial Networks (Goodfellow et al., 2014) - Le papier qui a tout lancé.
• Site Démo : This Person Does Not Exist - La puissance de StyleGAN2 en action.