Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.
Leer Generatieve Adversariële Netwerken (GANs) | Theoretische Grondslagen
Diepe Generatieve Modellen met Python

Generatieve Adversariële Netwerken (GANs)

Veeg om het menu te tonen

Generative Adversarial Networks (GANs) zijn een klasse van generatieve modellen geïntroduceerd door Ian Goodfellow in 2014. 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 de 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 wordt de discriminator beter in het onderscheiden van echte en nepdata.

Architectuur van een GAN

afbeelding

Een basis GAN-model bestaat uit twee kerncomponenten:

1. Generator (G)

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

2. Discriminator (D)

  • Ontvangt ofwel een echte datasample xpx(x)x \sim p_x(x) of een gegenereerde sample G(z)G(z);
  • Geeft een scalaire waarde tussen 0 en 1, die de kans schat dat de invoer echt is.

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

Minimax-spel van GANs

In het hart van GANs ligt het minimax-spel, een concept uit de speltheorie. In deze opzet:

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

Deze dynamiek definieert een nulsomspel, waarbij de winst van de één het verlies van de ander is. De optimalisatie wordt gedefinieerd als:

minGmaxDV(D,G)=Expx[logD(x)]+Ezpz[log(1D(G(z)))]\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:
LG=Ezpz[logD(G(z))]L_G=-\mathbb{E}_{z \sim p_z}[\log{D(G(z))}]

Dit helpt de generator om sterke gradiënten te ontvangen, zelfs wanneer de discriminator goed presteert.

  • Discriminatorverlies:
LD=Expx[logD(x)]Ezpz[log(1D(G(z)))]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 monsters te produceren die de onzekerheid van de discriminator vergroten en de convergentie tijdens de training verbeteren.

Belangrijke varianten van GAN-architecturen

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

afbeelding

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 data te genereren uit willekeurige ruis, ontvangt de generator zowel ruis zz als een conditie yy (bijvoorbeeld een klassenlabel). De discriminator ontvangt ook yy om te beoordelen of het gegenereerde 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-activaties.

  • Toepassingen: fotorealistische beeldgeneratie, leren van visuele representaties, ongecontroleerd kenmerkleren.

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

Cycle-consistency-verlies waarborgt:

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

waarbij:

  • GABG_{AB} afbeeldingen van domein A naar domein B mapt;
  • GBAG_{BA} van domein B naar domein A mapt.
  • xA,yBx \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, gaat deze door een mapping-netwerk om "stijlvectoren" te produceren die elke laag van de generator beïnvloeden. Dit maakt fijne controle mogelijk over visuele kenmerken zoals haarkleur, gezichtsuitdrukkingen of belichting.

Belangrijke innovaties:

  • Style mixing, maakt het combineren van meerdere latente codes mogelijk;
  • Adaptive Instance Normalization (AdaIN), stuurt feature maps in de generator aan;
  • Progressive growing, training start op lage resolutie en neemt toe in de tijd.

Toepassingen: ultra hoge-resolutie beeldgeneratie (bijvoorbeeld gezichten), visuele attribuutcontrole, kunstgeneratie.

Vergelijking: GANs vs VAEs

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

1. Welke van de volgende beschrijvingen geeft het beste de componenten van een basis-GAN-architectuur weer?

2. Wat is het doel van het minimax-spel in GANs?

3. Welke van de volgende uitspraken is waar over het verschil tussen GANs en VAEs?

question mark

Welke van de volgende beschrijvingen geeft het beste de componenten van een basis-GAN-architectuur weer?

Selecteer het correcte antwoord

question mark

Wat is het doel van het minimax-spel in GANs?

Selecteer het correcte antwoord

question mark

Welke van de volgende uitspraken is waar over het verschil tussen GANs en VAEs?

Selecteer het correcte antwoord

Was alles duidelijk?

Hoe kunnen we het verbeteren?

Bedankt voor je feedback!

Sectie 2. Hoofdstuk 7

Vraag AI

expand

Vraag AI

ChatGPT

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Sectie 2. Hoofdstuk 7
some-alt