introduction

Récemment, je vois souvent un mécanisme structurel intéressant dans le modèle de génération appelé GAN (Generative Adversarial Networks). La structure dans laquelle le Générateur et le Discriminateur se font concurrence pour améliorer la précision est comme une correspondance entre le créateur (= Générateur) et l'évaluateur (Discriminateur) dans le monde de l'art, un monde comme un faux de galerie. Cela rappelle. Je ressens de la romance dans le mécanisme lui-même. De plus, c'est vraiment étrange car il peut générer avec précision.

Cependant, il semble que le problème avec GAN était qu'il était difficile à apprendre, mais cela BEGAN apprend tout en équilibrant le conflit entre les deux. On dit que ce problème sera résolu en faisant cela. BEGAN était assez simple et facile à comprendre, je l'ai donc implémenté avec Keras.

Partie intéressante de BEGAN

Il semble qu'il existe un mécanisme pour équilibrer tout en héritant de diverses améliorations du GAN, mais je l'ai personnellement trouvé intéressant en raison des fonctionnalités décrites dans l'article (y compris celles que d'autres personnes pensaient auparavant). Dans le cadre,

Discriminator est composé de la fonction de perte d'AutoEncoder La perte de cet encodeur automatiqueWasserstein distance*C'est un concept difficile, mais en réalité c'est similaireMean Absolute Error (En d'autres termes|InputX - AutoEncoder(InputX)| )Est
** La diversité ** peut être exprimée par le paramètre $ \ gamma \ dans [0, 1] $, qui vous permet d'ajuster "à quelle distance de l'échantillon".
Présente une formule permettant d'évaluer la progression de l'apprentissage ** sans vérifier visuellement l'image réelle **

Cependant, la chose la plus intéressante est

Lorsque la fonction de perte de l'AutoEncoder de Discriminator est $ L (x) $, Soit la fonction de perte du discriminateur $ L_ {D} (x) $ et la fonction de perte du générateur $ L_ {G} (x) $.

$ L_ {D} (x) = L (image vraie) --k_ {t} * L (image générée par Generator) $ $ L_ {G} (x) = L (Image générée par Generator) $ $ k_ {t + 1} = k_ {t} + \ lambda_ {k} (\ gamma * L (image vraie) --L (image générée par le générateur)) $

C'est un endroit pour apprendre sous la forme de. Ce $ k_ {t} $ part de 0 et augmente progressivement.

Discriminator est obligé de faire les actions de "travailler dur sur AutoEncode de la vraie image (réduire la perte)" et "ne pas travailler sur AutoEncoder de fausse image (augmenter la perte)" afin de réduire la perte. Dans un premier temps, puisque k = 0, nous optimiserons l'AutoEncoder de l'image vraie, mais nous ferons également des efforts pour augmenter la perte de l'image du générateur à mesure que k augmente progressivement. À la fin, k atteint l'état d'équilibre lorsque $ (\ gamma * L (image vraie) --L (image générée par le générateur)) = 0 $ (à ce moment-là, $ \ gamma $ entre en vigueur. Ne).

Puisque le générateur conçoit toujours l'image générée de sorte que la perte de l'encodeur automatique devienne plus petite, la concurrence deviendra progressivement plus sophistiquée.

Ce mécanisme de type dilemme était très intéressant, et je pensais qu'il était clairement exprimé (enfin, je ne sais pas grand-chose sur les autres GAN ...).

la mise en oeuvre

Code source

https://github.com/mokemokechicken/keras_BEGAN Il est placé dans.

Je pense qu'il convient comme implémentation car il peut générer une image qui ressemble à ça ...

Avec Keras, il est difficile d'effectuer des modèles et un apprentissage aussi inhabituels (il n'y a pas beaucoup d'échantillons), mais une fois que vous comprenez comment l'écrire, ce n'est en fait pas si difficile, et une fois que vous pouvez le faire, il est facile à lire en raison de sa grande modularité. Il présente l'avantage d'être facile à appliquer de diverses manières.

Progression de l'apprentissage

Le tracé des valeurs des différentes pertes pour chaque lot est le suivant. Je m'entraîne avec $ \ gamma = 0,5 $.

La signification de chaque valeur est la suivante.

m_global: une valeur qui indique la progression de l'apprentissage. Il semble que cela devrait converger.
k: valeur qui équilibre le discriminateur et le générateur décrits ci-dessus.
loss_discriminator: L_{D}(x)
loss_generator: L_{G}(x)
loss_real_x: L (image vraie)
loss_gen_x: L (image générée par Generator)

Ce à quoi je pense quand je vois Pat

k semble augmenter une fois puis diminuer.
loss_real_x * gamma = loss_gen_x est correctement convergé
m_global diminue progressivement et est sur le point de converger
En regardant d'autres cas, pensez-vous que vous endurerez un peu plus après cela et que vous finirez lorsque m_global sera presque plat?

Exemple de génération après exécution

exemple d'image

Toute image carrée de 64 x 64 pixels est correcte, mais comme exemple d'image, http://vis-www.cs.umass.edu/lfw/

[new] All images aligned with deep funneling 
(111MB, md5sum 68331da3eb755a505a502b5aacb3c201)

J'ai été autorisé à utiliser. À l'exclusion de l'image en échelle de gris, il y a 13194 échantillons.

Image générée

Quand j'ai arrangé les images générées en fonction de la progression de l'apprentissage, cela ressemblait à ceci.

Epoch 1
Epoch 25
Epoch 50
Epoch 75
Epoch 100
Epoch 125
Epoch 150
Epoch 175
Epoch 200
Epoch 215

En tant que photo de visage, jusqu'à environ l'époque 125 est assez bonne. Après cela, probablement parce que j'ai essayé de capturer l'arrière-plan, le désordre de la partie du visage est incroyable. Si vous voulez vous concentrer sur le visage et le générer, il peut être un peu plus beau si vous utilisez celui avec le fond écrasé et uniquement le visage. Il semble que le nombre de couches de convection du modèle soit lié à la beauté de l'image, et cela peut avoir été un peu court.

Temps d'exécution

C'était environ 680 secondes / époque avec les spécifications de machine suivantes.

Linux
Dataset: All images aligned with deep funneling (13194 samples)
Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz
GeForce GTX 1080

Environment Variables

  KERAS_BACKEND=theano
  THEANO_FLAGS=device=gpu,floatX=float32,lib.cnmem=1.0

à la fin

J'ai l'impression d'avoir enfin appris un peu sur le GAN.

[PYTHON] Implémenter BEGAN (Boundary Equilibrium Generative Adversarial Networks) avec Keras