GAN : générateur et discriminateur
Théorie des jeux minimax, instabilité de l’entraînement des GAN, effondrement des modes, implémentation d’un DCGAN.
GAN : générateur et discriminateur est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce qu'un GAN ?
Un réseau antagoniste génératif oppose deux réseaux : un Generator qui crée des données fausses et un Discriminator qui détermine si elles sont réelles ou fausses. Ils s'affrontent, et le Generator apprend à produire des échantillons convaincants.
Le jeu antagoniste
Imaginez un faussaire (le générateur) et un détective (le discriminateur). Le faussaire améliore ses faux pour tromper le détective ; le détective affine son regard. Cette compétition pousse les deux à progresser, jusqu'à ce que les faux paraissent réels.
Le Generator
Le générateur transforme un vecteur de bruit aléatoire en une image fausse. Il apprend à transformer des nombres aléatoires dénués de sens en données structurées et réalistes.
class Generator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(100, 256), nn.ReLU(),
nn.Linear(256, 784), nn.Tanh()
)
def forward(self, z):
return self.net(z)Le vecteur de bruit
L'entrée z est échantillonnée selon une loi normale standard. Des vecteurs de bruit différents produisent des images différentes : le bruit est donc la « graine » de la génération. Sa dimension, ici 100, correspond à la taille latente.
z = torch.randn(batch_size, 100)
fake_images = generator(z)Le Discriminator
Le discriminateur reçoit une image et produit une seule probabilité : celle qu'elle soit réelle. Un Sigmoid fournit une valeur dans [0,1], où 1 signifie réel et 0 signifie faux.
class Discriminator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(784, 256), nn.LeakyReLU(0.2),
nn.Linear(256, 1), nn.Sigmoid()
)Entraînement du discriminateur
Entraînez D sur un lot d'images réelles étiquetées 1 et d'images fausses étiquetées 0. Il apprend à augmenter les scores des images réelles et à réduire ceux des images fausses grâce à l'entropie croisée binaire.
d_real = criterion(D(real), ones)
d_fake = criterion(D(fake.detach()), zeros)
d_loss = d_real + d_fake
d_loss.backward()Pourquoi utiliser detach() pour les faux ?
Lors de l'entraînement de D, nous utilisons fake.detach() afin que les gradients ne remontent pas jusqu'au générateur. À cette étape, nous ne mettons à jour que le discriminateur ; le générateur intervient séparément.
Entraînement du générateur
Entraînez maintenant G à tromper D : faites passer les faux dans D et récompensez le générateur lorsque D renvoie réel (étiquette 1). Le générateur progresse en amenant D à croire que ses faux sont réels.
g_loss = criterion(D(fake), ones) # want D to say "real"
g_loss.backward()
g_optimizer.step()Entraînement alterné
Chaque itération alterne les étapes : mettez d'abord D à jour, puis G. Il est essentiel de les maintenir à peu près équilibrés : si D devient trop puissant, G ne reçoit plus de gradient utile ; s'il est trop faible, G ne rencontre aucun véritable défi.
# per step
# 1) update Discriminator
# 2) update GeneratorEffondrement des modes
Un échec classique est l'effondrement des modes : le générateur trouve une ou quelques sorties qui trompent D et ne produit plus qu'elles, en ignorant la variété des données. Le symptôme est que tous les échantillons générés se ressemblent presque parfaitement.
Instabilité de l'entraînement
Les GAN sont notoirement instables : les pertes oscillent, un réseau peut prendre le dessus sur l'autre et la convergence est fragile. Des techniques comme LeakyReLU, des taux d'apprentissage soigneusement choisis et le lissage des étiquettes contribuent à stabiliser l'entraînement.
Vérification rapide
Évaluez votre compréhension des GAN.
Récapitulatif : GAN
Vous avez appris la structure antagoniste : un générateur transforme un vecteur de bruit en données fausses, un discriminateur produit une probabilité réel/faux, et les deux s'entraînent en alternant D puis G. Vous avez également appris à repérer l'effondrement des modes et l'instabilité générale qui rendent l'entraînement des GAN délicat.
Questions Fréquemment Posées
La leçon « GAN : générateur et discriminateur » est-elle gratuite ?
Oui — le texte complet de « GAN : générateur et discriminateur » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « GAN : générateur et discriminateur » ?
Théorie des jeux minimax, instabilité de l’entraînement des GAN, effondrement des modes, implémentation d’un DCGAN. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn AI with Python ?
Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « GAN : générateur et discriminateur » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?
Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Autoencodeurs pour l’apprentissage de représentations
- Autoencodeurs variationnels (VAE)
- GAN : générateur et discriminateur
- GAN conditionnels et transfert de style