Leer Generatieve Adversariële Netwerken (GANs)

Veeg om het menu te tonen

Generative Adversarial Networks (GANs) vormen een klasse van generatieve modellen die in 2014 zijn geïntroduceerd door Ian Goodfellow. Ze bestaan uit twee neurale netwerken — de Generator en de Discriminator — die gelijktijdig worden getraind binnen een speltheoretisch kader. De generator probeert data te produceren die lijkt op echte data, terwijl de discriminator probeert echte data van gegenereerde data te onderscheiden.

GANs leren datasamples te genereren uit ruis door het oplossen van een minimax-spel. Tijdens de training wordt de generator beter in het produceren van realistische data, en de discriminator beter in het onderscheiden van echte en nepdata.

Architectuur van een GAN

Een basis GAN-model bestaat uit twee kerncomponenten:

1. Generator (G)

Ontvangt een willekeurige ruisvector $z \sim p_z(z)$ als invoer;
Zet deze om via een neuraal netwerk naar een datasample $G(z)$ die bedoeld is te lijken op data uit de ware distributie.

2. Discriminator (D)

Ontvangt ofwel een echt gegevensmonster $x \sim p_x(x)$ of een gegenereerd monster $G(z)$ ;
Geeft een scalair tussen 0 en 1 als output, waarmee de waarschijnlijkheid wordt geschat dat de invoer echt is.

Deze twee componenten worden gelijktijdig getraind. De generator streeft ernaar realistische monsters te produceren om de discriminator te misleiden, terwijl de discriminator probeert echte en gegenereerde monsters correct te onderscheiden.

Minimax-spel van GANs

De kern van GANs wordt gevormd door het minimax-spel, een concept uit de speltheorie. In deze opzet:

De generator $G$ en discriminator $D$ zijn concurrerende spelers;
$D$ streeft ernaar zijn vermogen te maximaliseren om echt van gegenereerde data te onderscheiden;
$G$ streeft ernaar het vermogen van $D$ om zijn nepdata te detecteren te minimaliseren.

Deze dynamiek definieert een nulsomspel, waarbij de winst van de ene speler het verlies van de andere is. De optimalisatie wordt gedefinieerd als:

\underset{G}{\min} \, \underset{D}{\max} \, V(D, G) = \mathbb{E}_{\mathbf{x} \sim p_{x}}[\log D(\mathbf{x})] + \mathbb{E}_{\mathbf{z} \sim p_z}[\log(1 - D(G(\mathbf{z})))]

De generator probeert de discriminator te misleiden door monsters $G(z)$ te genereren die zo dicht mogelijk bij echte data liggen.

Verliesfuncties

Hoewel het oorspronkelijke GAN-doel een minimax-spel definieert, worden in de praktijk alternatieve verliesfuncties gebruikt om de training te stabiliseren.

Niet-verzadigende generatorverlies:

L_G=-\mathbb{E}_{z \sim p_z}[\log{D(G(z))}]

Dit zorgt ervoor dat de generator sterke gradiënten ontvangt, zelfs wanneer de discriminator goed presteert.

Discriminatorverlies:

L_D = -\mathbb{E}_{x \sim p_x}[\log{D(x)}] - \mathbb{E}_{z \sim p_z}[\log{(1-D(G(z)))}]

Deze verliezen stimuleren de generator om voorbeelden te produceren die de onzekerheid van de discriminator vergroten en verbeteren de convergentie tijdens de training.

Belangrijke varianten van GAN-architecturen

Er zijn verschillende typen GANs ontwikkeld om specifieke beperkingen aan te pakken of de prestaties te verbeteren:

Conditionele GAN (cGAN)

Conditionele GANs breiden het standaard GAN-framework uit door extra informatie (meestal labels) toe te voegen aan zowel de generator als de discriminator. In plaats van alleen gegevens te genereren uit willekeurige ruis, ontvangt de generator zowel ruis $z$ als een conditie $y$ (bijvoorbeeld een klasse-label). De discriminator ontvangt ook $y$ om te beoordelen of het voorbeeld realistisch is onder die conditie.

Toepassingen: klasse-geconditioneerde beeldgeneratie, beeld-naar-beeldvertaling, tekst-naar-beeldgeneratie.

Deep Convolutional GAN (DCGAN)

DCGANs vervangen de volledig verbonden lagen in de oorspronkelijke GANs door convolutionele en getransponeerde convolutionele lagen, waardoor ze effectiever zijn voor het genereren van afbeeldingen. Ze introduceren ook architecturale richtlijnen zoals het verwijderen van volledig verbonden lagen, het gebruik van batchnormalisatie en het toepassen van ReLU/LeakyReLU-activeringen.

Toepassingen: fotorealistische afbeeldingsgeneratie, leren van visuele representaties, ongecontroleerd kenmerkleren.

CycleGAN CycleGANs lossen het probleem van ongepaarde afbeelding-naar-afbeeldingvertaling op. In tegenstelling tot andere modellen die gekoppelde datasets vereisen (bijvoorbeeld dezelfde foto in twee verschillende stijlen), kunnen CycleGANs mappings tussen twee domeinen leren zonder gekoppelde voorbeelden. Ze introduceren twee generatoren en twee discriminatoren, elk verantwoordelijk voor mapping in één richting (bijvoorbeeld foto's naar schilderijen en omgekeerd), en handhaven een cycle-consistency loss om te waarborgen dat vertaling van het ene domein naar het andere en terug het oorspronkelijke beeld oplevert. Dit verlies is essentieel voor het behouden van inhoud en structuur.

Cycle-Consistency Loss waarborgt:

G_{BA}(G_{AB}(x)) \approx x\ \text{en}\ G_{AB}(G_{BA}(y))\approx y

waarbij:

$G_{AB}$ afbeeldingsmappings van domein A naar domein B;
$G_{BA}$ mappings van domein B naar domein A.
$x \in A, y \in B$ .

Toepassingen: foto naar kunstwerk conversie, paard-naar-zebra vertaling, stemconversie tussen sprekers.

StyleGAN

StyleGAN, ontwikkeld door NVIDIA, introduceert stijlgebaseerde controle in de generator. In plaats van een ruisvector direct aan de generator te voeren, wordt deze door een mappingnetwerk geleid om "stijlvectoren" te produceren die elke laag van de generator beïnvloeden. Dit maakt fijne controle over visuele kenmerken mogelijk, zoals haarkleur, gezichtsuitdrukkingen of belichting.

Opmerkelijke innovaties:

Stijlmenging, maakt het combineren van meerdere latente codes mogelijk;
Adaptive Instance Normalization (AdaIN), stuurt feature maps in de generator aan;
Progressief groeien, training start op lage resolutie en neemt in de loop van de tijd toe.

Toepassingen: ultra hoge-resolutie afbeeldingsgeneratie (bijvoorbeeld gezichten), visuele attributencontrole, kunstgeneratie.

Vergelijking: GANs vs VAEs

GANs vormen een krachtige klasse van generatieve modellen die in staat zijn uiterst realistische data te produceren via een adversair trainingsproces. De kern bestaat uit een minimax-spel tussen twee netwerken, waarbij adversariële verliezen worden gebruikt om beide componenten iteratief te verbeteren. Grondige kennis van hun architectuur, verliesfuncties—inclusief varianten zoals cGAN, DCGAN, CycleGAN en StyleGAN—en hun contrast met andere modellen zoals VAEs biedt de noodzakelijke basis voor toepassingen in onder andere beeldgeneratie, videosynthese, data-augmentatie en meer.