[PYTHON] GAN: DCGAN Part2-Training Modèle DCGAN

Cible

Il s'agit d'une continuation de DCGAN utilisant le Microsoft Cognitive Toolkit (CNTK).

Dans la partie 2, la formation DCGAN par CNTK sera effectuée à l'aide des données d'image préparées dans la partie 1. On suppose que CNTK et NVIDIA GPU CUDA sont installés.

introduction

Dans GAN: DCGAN Part1 - Scraping Web images, j'ai préparé l'image du visage de mon artiste préféré à partir de Bing Image Search.

Dans la partie 2, nous créerons et formerons un modèle de génération de visage à l'aide du Deep Convolutional Generative Adversarial Network (DCGAN).

Deep Convolutional Generative Adversarial Network Le DCGAN [1] implémenté cette fois se compose de deux réseaux de neurones comme le montre la figure ci-dessous. Où $ x $ représente un jeu de données d'image réel et $ z $ représente une variable latente.

La structure du réseau du générateur et du discriminateur a été définie comme suit.

Generator Le générateur utilise la convolution de translocation avec la taille du noyau 5 et la foulée 2.

Immédiatement après la couche de convolution de translocation, exécutez la normalisation par lots [2], puis appliquez la fonction d'activation ReLU. Par conséquent, le terme de polarisation n'est pas adopté dans la couche de convolution de translocation.

La convolution de translocation de la couche finale emploie un terme de biais et applique la fonction d'activation tanh sans utiliser la normalisation par lots.

La distribution antérieure de la variable latente $ z $ est la distribution normale standard $ \ mathcal {N} (0.0, 1.0) $.

Discriminator Discriminator utilise une convolution de taille de noyau 3 et de pas 2.

Exécutez la normalisation par lots immédiatement après la couche de convolution, puis appliquez la fonction d'activation Leaky ReLU [3]. Par conséquent, le terme de polarisation n'est pas adopté dans la couche de pliage. Le paramètre Leaky ReLU a été défini sur 0,2. Cependant, la normalisation par lots n'est pas utilisée pour la convolution de la première couche.

La convolution de couche finale emploie un terme de polarisation et applique la fonction d'activation sigmoïde sans utiliser la normalisation par lots.

Paramètres en formation

La valeur initiale des paramètres de la couche convolution / convolution de translocation a été fixée à la distribution normale [1] avec une variance de 0,02.

La fonction de perte implémentée cette fois est illustrée dans l'équation suivante. [4]

\max_{D} \mathbb{E}_{x \sim p_r(x)} [\log D(x)] + \mathbb{E}_{z \sim p_z(z)} [\log(1 - D(G(z))]\\
\max_{G} \mathbb{E}_{z \sim p_z(z)} [\log D(G(z))]

Ici, $ D $ et $ G $ représentent respectivement Discriminator et Generator, $ x $ est l'image d'entrée, $ z $ est la variable latente, $ p_r $ est la distribution des données d'image réelles et $ p_z $ est la fausse image. Il représente la distribution antérieure qui produit les données.

Adam [5] a été utilisé comme algorithme d'optimisation pour le générateur et le discriminateur. Le taux d'apprentissage a été réglé sur 1e-4, l'hyperparamètre d'Adam $ β_1 $ a été réglé sur 0,5 et $ β_2 $ a été réglé sur la valeur par défaut de CNTK.

La formation du modèle a effectué 50000 itérations avec une formation en mini-lot de taille mini-lot 16.

la mise en oeuvre

Environnement d'exécution

Matériel

・ Processeur Intel (R) Core (TM) i7-6700K 4,00 GHz ・ GPU NVIDIA GeForce GTX 1060 6 Go

Logiciel

・ Windows 10 Professionnel 1909 ・ CUDA 10.0 ・ CuDNN 7.6 ・ Python 3.6.6 ・ Cntk-gpu 2.7 ・ Opencv-contrib-python 4.1.1.26 ・ Numpy 1.17.3 ・ Pandas 0.25.0

Programme à exécuter

Le programme de formation est disponible sur GitHub.

dcgan_training.py

Commentaire

Voici quelques-unes des techniques de formation GAN les plus utiles présentées dans Comment former un GAN?.

Input Normalization Normaliser l'image d'entrée sur [-1, 1]. Par conséquent, faites la sortie de Generator tanh.

Latent Distribution Faire de la distribution antérieure des variables latentes une distribution normale avec une distribution sphérique au lieu d'une distribution uniforme avec une distribution rectangulaire.

dcgan_training.py

z_data = np.ascontiguousarray(np.random.normal(size=(minibatch_size, z_dim)), dtype="float32")

Network Architecture Puisque j'ai traité d'images cette fois, j'ai adopté DCGAN, qui utilise une couche de pliage.

Définissez la valeur initiale du poids de la couche de convolution sur une distribution normale avec une variance de 0,02.

Pour le sous-échantillonnage, définissez la foulée de la couche moyenne de regroupement ou de convolution sur 2. Pour le suréchantillonnage, définissez la foulée de Pixel Shuffle [7] ou la couche de convolution de translocation sur 2.

La normalisation par lots ne fonctionnait que si le discriminateur et le générateur étaient appliqués avant la fonction d'activation. La normalisation par lots stabilise l'entraînement, mais ne mélange pas de données réelles et fausses.

Dans le programme implémenté, seules les fausses données sont reçues en entrée tout en partageant les paramètres de Discriminator aux endroits suivants.

dcgan_training.py

D_fake = D_real.clone(method="share", substitutions={x_real.output: G_fake.output})

ReLU a un problème appelé Deadly Neuron, qui utilise Leaky ReLU au lieu de ReLU pour éviter la rareté du gradient qui en résulte. Cependant, ELU [6] peut ne pas fonctionner.

Loss Function La fonction de perte du GAN d'origine [4] est la suivante.

\max_{D} \mathbb{E}_{x \sim p_r(x)} [\log D(x)] + \mathbb{E}_{z \sim p_z(z)} [\log(1 - D(G(z))]\\
\min_{G} \mathbb{E}_{z \sim p_z(z)} [\log(1 - D(G(z)))]

Cependant, dans l'équation ci-dessus, la fonction de perte du discriminateur est une entropie croisée, donc si l'apprentissage du discriminateur va trop loin, le gradient du générateur disparaît, de sorte que la fonction de perte du générateur passe du problème de minimisation au problème de maximisation. Faire.

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

Cela dit, si la formation se déroule bien, il ne semble y avoir aucune différence dans les résultats des deux fonctions de perte.

Optimizer Adam est le meilleur choix pour l'algorithme d'optimisation. Cependant, réglez l'élan à une petite valeur d'environ 0,5 et le taux d'apprentissage à une petite valeur d'environ 1e-4.

Je n'ai pas utilisé le taux d'apprentissage cyclique [8] cette fois à cause de l'instabilité de l'entraînement.

Training Il est difficile de contrôler statistiquement la formation du Discriminateur et du Générateur, alors évitez-la autant que possible.

Si vous voulez vraiment le contrôler, formez le Discriminateur plus souvent.

résultat

Fonctions de perte du discriminateur et du générateur

La figure ci-dessous est une visualisation de chaque fonction de perte pendant l'entraînement. L'axe horizontal représente le nombre de répétitions et l'axe vertical représente la valeur de la fonction de perte.

Images générées et transitions pendant la formation

La figure ci-dessous montre l'image du visage générée par le générateur formé. J'ai l'impression qu'il existe de nombreuses images similaires. Cela suggère qu'un effondrement de mode se produit et constitue une mauvaise tendance.

La figure ci-dessous montre la transition de la génération d'image pendant l'entraînement avec animation. Je fais de mon mieux pour générer un visage, mais il est difficile de dire que cela fonctionne.

Évaluation quantitative par score initial

L'évaluation quantitative du GAN est un problème difficile, mais le score initial [9] a été proposé comme l'un des indices d'évaluation.

Le score de démarrage est pour les générateurs formés

-Qualité d'image: Est-il possible de générer une image spécifique? -Diversité d'image: Y a-t-il une variation dans l'image générée (y a-t-il un mode de réduction?)

Mesurer. J'ai utilisé Inception-v3 [10] comme modèle de base pour mesurer le score de lancement. Le résultat est le suivant.

Inception Score 2.61

référence

CNTK 206: Part B - Deep Convolutional GAN with MNIST data How to Implement the Inception Score (IS) for Evaluating GANs

GAN : DCGAN Part1 - Scraping Web images

1. Alec Radford, Luke Metz, and Soumith Chintal. "Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks", arXiv preprint arXiv:1511.06434 (2015).
2. Ioffe Sergey and Christian Szegedy. "Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift", arXiv preprint arXiv:1502.03167 (2015).
3. Andrew L. Maas, Awni Y. Hannun, and Andrew Y. Ng. "Rectifier Nonlinearities Improve Neural Network Acoustic Models", Proc. icml. Vol. 30. No. 1. 2013.
4. Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mira, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. "Generative Adversarial Nets", Advances in neural information processing systems. 2014, pp 2672-2680.
5. Diederik P. Kingma and Jimmy Lei Ba. "Adam: A method for stochastic optimization", arXiv preprint arXiv:1412.6980 (2014).
6. Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. "Fast and accurate deep network learning by exponential linear units (ELUs)." arXiv preprint arXiv:1511.07289 (2015).
7. Wenzhe Shi, Jose Cabellero, Ferenc Huszar, Johannes Totz, Andrew P. Aitken, Rob Bishop, Daniel Rueckert, and Zehan Wang. "Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network", The IEEE Conference on Computer Vision and Pattern Recognition (CVPR). 2016, pp 1874-1883.
8. Leslie N. Smith. "Cyclical Learning Rates for Training Neural Networks", 2017 IEEE Winter Conference on Applications of Computer Vision. 2017, pp 464-472.
9. Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen, "Improved Techniques for Training GANs", Neural Information Processing Systems. 2016. pp 2234-2242.
10. Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. "Rethinking the Inception Architecture for Computer Vision", The IEEE Conference on Computer Vision and Pattern Recognition (CVPR). 2016, pp 2818-2826.