Un GAN (réseau antagoniste génératif) fait s'affronter deux réseaux de neurones : un générateur qui fabrique de fausses données et un discriminateur qui apprend à les distinguer des vraies. À force de se corriger l'un l'autre, le générateur produit des données crédibles. Dépassé par la diffusion pour les images, il sert encore aux données synthétiques.
Un faussaire et un expert en art. Le faussaire peint, l'expert juge. Chaque faux démasqué apprend au faussaire ce qui l'a trahi ; chaque faux réussi apprend à l'expert à mieux regarder.
Il reçoit un vecteur de nombres aléatoires et le transforme en une fausse donnée : une image, ou ici une ligne client.
On lui montre des lignes vraies et des lignes fausses. Il apprend à donner à chacune une probabilité d'être vraie.
Le discriminateur s'entraîne à ne plus se faire tromper ; le générateur s'entraîne à le tromper. À l'équilibre, les fausses données ressemblent assez aux vraies pour que le juge hésite.
Ancienneté, appels au support, montant mensuel, incidents des 3 derniers mois. On veut fournir un jeu réaliste à un prestataire ou à une équipe de test sans exposer de vrais clients.
Le générateur produit de nouvelles lignes qui ne correspondent à aucun client. Le code compare les moyennes et les écarts-types des vraies et des fausses données.
Fidélité : mêmes distributions et mêmes corrélations que le réel, et un modèle entraîné sur les fausses données doit bien prédire sur les vraies. Confidentialité : aucune ligne générée ne doit copier presque exactement un vrai client.
Noms donnés pour PyTorch, utilisé dans le code.
Petit et du même ordre pour les deux réseaux, souvent 2e-4 avec Adam. Si l'un apprend beaucoup plus vite que l'autre, l'entraînement déraille.
Dimension du vecteur aléatoire donné au générateur : 16 dans le code. Quelques dizaines suffisent pour des données tabulaires, une centaine pour des images.
Aucune courbe d'erreur ne baisse sagement : on arrête en contrôlant à intervalles réguliers la qualité des données générées.
Pour des tableaux qui mêlent catégories et nombres, des variantes dédiées comme CTGAN (bibliothèque SDV) gèrent l'encodage et les distributions déséquilibrées.
# Clients synthétiques : GAN en Python
import pandas as pd
import torch
from torch import nn
clients = pd.read_csv("clients_churn.csv")
colonnes = ["anciennete", "appels_support", "montant", "incidents_3m"]
vraies = torch.tensor(clients[colonnes].values, dtype=torch.float32)
moy, ecart = vraies.mean(0), vraies.std(0)
vraies = (vraies - moy) / ecart # mise à l'échelle indispensable
torch.manual_seed(42)
generateur = nn.Sequential(nn.Linear(16, 64), nn.ReLU(), nn.Linear(64, 64), nn.ReLU(), nn.Linear(64, 4))
discriminateur = nn.Sequential(nn.Linear(4, 64), nn.LeakyReLU(0.2), nn.Linear(64, 1))
opt_g = torch.optim.Adam(generateur.parameters(), lr=2e-4, betas=(0.5, 0.999))
opt_d = torch.optim.Adam(discriminateur.parameters(), lr=2e-4, betas=(0.5, 0.999))
perte, un, zero = nn.BCEWithLogitsLoss(), torch.ones(128, 1), torch.zeros(128, 1)
for etape in range(5000):
lot = vraies[torch.randint(0, len(vraies), (128,))]
fausses = generateur(torch.randn(128, 16)) # le faussaire part d'un bruit aléatoire
# 1. L'expert apprend à dire 1 pour les vraies lignes, 0 pour les fausses
perte_d = perte(discriminateur(lot), un) + perte(discriminateur(fausses.detach()), zero)
opt_d.zero_grad(); perte_d.backward(); opt_d.step()
# 2. Le faussaire apprend à se faire passer pour vrai
perte_g = perte(discriminateur(fausses), un)
opt_g.zero_grad(); perte_g.backward(); opt_g.step()
synth = generateur(torch.randn(3000, 16)).detach() * ecart + moy # 3 000 clients fictifs
print(pd.DataFrame({"moyenne_reelle": moy.numpy(), "moyenne_synth": synth.mean(0).numpy(),
"ecart_type_reel": ecart.numpy(), "ecart_type_synth": synth.std(0).numpy()}, index=colonnes).round(1))Les GAN se pratiquent en Python (PyTorch, SDV pour les données tabulaires) : pas d'usage courant en R.
Generative Adversarial Network, réseau antagoniste génératif. La méthode a été proposée par Ian Goodfellow et ses coauteurs en 2014. « Antagoniste » désigne le duel entre générateur et discriminateur.
Les modèles de diffusion ont pris l'avantage à partir de 2021 : images plus variées, entraînement plus stable, pilotage par le texte. Les GAN restent plus rapides à la génération, en une seule passe, d'où leur usage en temps réel ou en super-résolution.
Pas automatiquement. Un générateur peut reproduire presque à l'identique des lignes rares du jeu d'origine. Il faut mesurer la distance entre chaque ligne générée et le vrai client le plus proche, et faire valider la démarche par le délégué à la protection des données.
Plus stable à entraîner et doté d'un espace latent organisé, mais produit des résultats plus flous.
Voir la fiche → le successeur pour les imagesGénèrent en débruitant pas à pas : plus lents, mais plus variés et plus faciles à entraîner.
Voir la fiche → plus simple pour la classe rareCrée des exemples par interpolation entre voisins. Souvent suffisant avant de sortir un GAN.
Voir la fiche →Dataistudio forme les équipes au machine learning et à l'IA, sur des cas concrets.
Nous utilisons des cookies de mesure d'audience et de suivi publicitaire pour comprendre la fréquentation du site et l'efficacité de nos annonces. Rien n'est déposé sans votre accord. En savoir plus