Découvrez Wasserstein GAN avec le modèle Keras et l'optimisation TensorFlow

introduction


Récemment, le système de génération profonde, appelé GAN, est chaud. J'essaye aussi diverses choses et je joue. Quant à la bibliothèque, Keras est intuitive et facile à comprendre.

Soit dit en passant, DCGAN et Wasserstein GAN ordinaires peuvent être mis en œuvre et appris rapidement même avec Keras, mais quand il s'agit de ceux qui ont apporté des améliorations mineures telles que l'optimisation des erreurs, «Comment écrivez-vous cela dans Keras? ,,? »Je pense que cela peut arriver. Je l'ai fait avec l'implémentation de Gradient Penalty proposée dans Amélioration de la formation des GAN Wasserstein. Je vais omettre l'explication de Gradient Penalty, mais pour cela, je pense qu'il serait bon que le modèle soit défini dans Keras et que l'apprentissage se fasse dans TensorFlow. Je pensais que, j'avais réussi à bien apprendre cela avec Wasserstein GAN normal, alors j'aimerais écrire un article. Je suis heureux que vous puissiez l'utiliser comme référence. Placez le code sur ici.

Requirements

Construction de modèles (Keras)


Generator et Discriminator sont écrits par Keras. C'est facile. (Voir model.py) Generator utilise Deconvolution (taille de filtre 4 * 4, pas 2 * 2) pour convertir une entrée aléatoire en une image. Le discriminateur émet la valeur de la fonction à partir de l'image d'entrée par Convolution (taille de filtre 4 * 4, foulée 2 * 2). Je l'ai écrit dans le modèle d'API fonctionnelle de Keras, mais il ne devrait y avoir aucun problème avec le modèle séquentiel (méthode d'écriture qui se connecte à model.add).

Apprentissage (TensorFlow)


Dans Wasserstein GAN, Discriminator gère la sortie des valeurs de fonction plutôt que de déterminer l'authenticité de l'image d'entrée.

\max_{D} \min_{G} \mathbb{E}_{x\sim p(x)}D(x) - \mathbb{E}_{z \sim p(z)}D(G(z))

Cela rend l'apprentissage par gradient plus stable que le GAN d'origine, ce qui minimise la divergence Jensen-Shannon, mais consultez l'article original (https://arxiv.org/abs/1701.07875) et d'autres commentaires pour plus de détails. S'il te plait donne moi.

D'ailleurs, normalement, dans le cas de Keras, spécifiez la fonction de perte préparée ou celle définie par vous-même et model.compile, mais dans cet article, cette optimisation est effectuée par TensorFlow.

main.py


class WassersteinGAN:

    def __init__(self, ...):

        self.image_size = 64
        self.gen = generator # model.Générateur défini dans py
        self.disc = discriminator # model.Discriminateur défini dans py
        
        #L'image d'entrée et le nombre aléatoire d'entrée sont définis par un espace réservé.
        self.x = tf.placeholder(tf.float32, (None, self.image_size, self.image_size, 3), name = 'x') #Image réelle
        self.z = tf.placeholder(tf.float32, (None, 100), name = 'z') #Entrer un nombre aléatoire
        self.x_ = self.gen(self.z) #Fausse image<-Entrer un nombre aléatoire
        
        self.d = self.disc(self.x) #Sortie avec image réelle en entrée
        self.d_ = self.disc(self.x_) #Sortie avec une fausse image en entrée

        self.d_loss = -(tf.reduce_mean(self.d) - tf.reduce_mean(self.d_)) #Fonction objective du discriminateur
        self.g_loss = -tf.reduce_mean(self.d_) #Fonction objectif du générateur

        #Définissez l'optimiseur. Le taux d'apprentissage de Generator est réglé un peu plus petit.
        self.d_opt = tf.train.RMSPropOptimizer(learning_rate = 5e-5)\
                     .minimize(self.d_loss, var_list = self.disc.trainable_weights)
        self.g_opt = tf.train.RMSPropOptimizer(learning_rate = 1e-5)\
                     .minimize(self.g_loss, var_list = self.gen.trainable_weights)

        #Définissez la session de TensorFlow.
        self.sess = tf.Session()
        K.set_session(self.sess) #← Il semble nécessaire lorsqu'il est utilisé en combinaison avec Keras

    def train(self, ...):

Sous ces paramètres, nous allons réellement diffuser les données et apprendre.

Dans mon code, une classe pour récupérer les images d'entrée et entrer des nombres aléatoires (misc / dataIO.py, InputSampler ) A été faite, L'échantillonneur qui apparaît dans le code suivant est une instance de ce InputSampler, et la méthode image_sample renvoie un mini-lot d'images réelles, et la méthode noise_sample renvoie un mini-lot de nombres aléatoires d'entrée. La méthode de rechargement est une méthode pour diviser et conserver un grand nombre d'images de données d'entraînement. (Étant donné que le jeu de données d'image de visage fréquemment utilisé CelebA contient plus de 200 000 images, nous avons créé cette spécification pour la commodité de la mémoire.)

De plus, si le modèle implémenté par Keras inclut la normalisation par lots, il est nécessaire de définir K.learning_phase () lors de la circulation des données. Y compris cela, il est décrit dans le code suivant.

main.py


class WassersteinGAN:

    def __init__(self, ...):

    # --Abréviation--

    def train(self, ...):
        
        for e in range(epochs):
            for batch in range(num_batches):

                #Le discriminateur apprend beaucoup
                for _ in range(5):
                    #Coupure de poids pour garantir la continuité Lipsitz
                    d_weights = [np.clip(w, -0.01, 0.01) for w in self.disc.get_weights()]
                    self.disc.set_weights(d_weights)

                    #Mini lot d'images réelles
                    bx = sampler.image_sample(batch_size)
                    #Mini lot de nombres aléatoires d'entrée
                    bz = sampler.noise_sample(batch_size)
                    #Entrée et K pour passer à l'espace réservé.learning_phase()Pour apprendre Discriminator en spécifiant
                    self.sess.run(self.d_opt, feed_dict = {self.x: bx, self.z: bz,
                                                           K.learning_phase(): 1})

                bz = sampler.noise_sample(batch_size, self.z_dim)
                #Entrée et K pour passer à l'espace réservé.learning_phase()Pour apprendre Generator en spécifiant
                self.sess.run(self.g_opt, feed_dict = {self.z: bz,
                                                       K.learning_phase(): 1})

                #Lors de la sortie de la perte
                d_loss, g_loss = self.sess.run([self.d_loss, self.g_loss],
                                               feed_dict = {self.x: bx, self.z: bz,
                                                            K.learning_phase(): 1})
                print('epoch : {}, batch : {}, d_loss : {}, g_loss : {}'\
                      .format(e, batch, d_loss, g_loss))
        

~~ Puisque le modèle est décrit dans Keras, les paramètres peuvent être enregistrés par la formule Keras. Je sauve souvent chaque époque. ~~ ~~ * Si vous essayez d'enregistrer le modèle à la manière Keras dans une session TensorFlow, cela peut ne pas fonctionner. confirmer. ~~ Les paramètres du modèle peuvent être enregistrés avec l'expression Keras model.save_weights () ''. Vous pouvez également charger les paramètres enregistrés avec model.load_weights () ''.

main.py


class WassersteinGAN:

    def __init__(self, ...):

    # --Abréviation--

    def train(self, ...):
        
        for e in range(epochs):
            for batch in range(num_batches):
            
            # --Abréviation--

            #Les paramètres peuvent être enregistrés de la manière Keras
            self.gen.save_weights('path/to/g_{}epoch.h5'.format(e))
            self.disc.save_weights('path/to/d_{}epoch.h5'.format(e))

Cela m'a assez bien appris, mais l'image générée était un peu floue. En général, Wasserstein GAN semble un peu flou que DCGAN, mais je pense qu'il peut être généré magnifiquement en fonction du réglage tel que le taux d'apprentissage.

finalement


De cette façon, j'ai pu créer un modèle avec Keras et m'entraîner avec TensorFlow. Récemment, j'ai le sentiment que de nombreuses méthodes avec une optimisation conçue ont été proposées, j'espère donc qu'elles seront utiles pour le test de suivi. N'hésitez pas à nous contacter si vous avez des suggestions ou des améliorations.

Postscript


J'ai écrit le code pour apprendre avec Keras et tensorflow de la même manière avec un simple CNN. Si vous aimez le GAN, ici est facile à comprendre.

Recommended Posts

Découvrez Wasserstein GAN avec le modèle Keras et l'optimisation TensorFlow
Comparez le TensorFlow brut avec tf.contrib.learn et Keras
J'ai essayé d'implémenter Grad-CAM avec keras et tensorflow
[Comment!] Apprenez et jouez à Super Mario avec Tensorflow !!
Implémentation d'un GAN efficace avec keras
J'ai touché Tensorflow et keras
MNIST (DCNN) avec Keras (backend TensorFlow)
Personnaliser le modèle / la couche / la métrique avec TensorFlow
[TensorFlow 2] Apprendre RNN avec perte CTC
[TensorFlow] [Keras] Construction d'un réseau neuronal avec Keras
Comparez DCGAN et pix2pix avec Keras
Défiez la classification des images avec TensorFlow2 + Keras 9-Apprentissage, sauvegarde et chargement de modèles-
Essayons le projet de génération de musique TensorFlow "Magenta" du réglage de l'environnement de développement à la génération de chansons.
Découvrez Wasserstein GAN avec le modèle Keras et l'optimisation TensorFlow
[Comment!] Apprenez et jouez à Super Mario avec Tensorflow !!
[Note de lecture] Apprentissage automatique pratique avec Scikit-Learn, Keras et TensorFlow Chapitre 1
Automatisation de l'optimisation des paramètres avec Keras avec GridSearch CV
Apprenez les données distribuées avec TensorFlow Y = 2X
Application de l'optimisation bayésienne au modèle Keras DNN
Hamburgers et vélos ImageNet classés par Keras
Utilisez TPU et Keras avec Google Colaboratory
Implémenter un modèle avec état et comportement
Essayez TensorFlow RNN avec un modèle de base
J'ai essayé de déplacer GAN (mnist) avec keras
Chargez le modèle caffe avec Chainer et classez les images
Premiers pas avec la traduction japonaise du modèle séquentiel Keras
Présentation du modèle DCGAN pour Cifar 10 avec keras
Optimisation apprise avec OR-Tools [Planification linéaire: modèle en plusieurs étapes]
Résolution du modèle Lorenz 96 avec Julia et Python
Chargez le fichier de modèle TensorFlow .pb avec readNetFromTensorflow ().
Optimisation de portefeuille avec Python (modèle de distribution moyenne de Markovitz)
Défiez la classification des images par TensorFlow2 + Keras 6-Essayez le prétraitement et la classification des images préparées par vous-même-