【Tensorflow+keras】Keras API两种训练GAN网络的方式

r囧r小猫 2022-10-16 15:26 235阅读 0赞

### 目录 ###

*  1 第一种 train\_on\_batch
 *  2 第二种 tf.GradientTape()

# 1 第一种 train\_on\_batch #

（1）简介  
github：[https://github.com/eriklindernoren/Keras-GAN/tree/master/cgan][https_github.com_eriklindernoren_Keras-GAN_tree_master_cgan]  
运行一批样品的单次梯度更新。该方法搭配keras的sequential API使用。  
其他网络结构参考[Keras API三种搭建神经网络的方式及以mnist举例实现][Keras API_mnist]  
（2）举例实现

from __future__ import print_function, division
    from tensorflow.keras.datasets import mnist
    from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Dropout, multiply
    from tensorflow.keras.layers import BatchNormalization, Activation, Embedding, ZeroPadding2D
    from tensorflow.keras.layers import LeakyReLU
    from tensorflow.keras.layers import UpSampling2D, Conv2D
    from tensorflow.keras.models import Sequential, Model
    from tensorflow.keras.optimizers import Adam
    import matplotlib.pyplot as plt
    import numpy as np
    class CGAN():
        def __init__(self):
            # Input shape
            self.img_rows = 28
            self.img_cols = 28
            self.channels = 1
            self.img_shape = (self.img_rows, self.img_cols, self.channels)
            self.num_classes = 10
            self.latent_dim = 100
            optimizer = Adam(0.0002, 0.5)
            # Build and compile the discriminator
            self.discriminator = self.build_discriminator()
            self.discriminator.compile(loss=['binary_crossentropy'],
                optimizer=optimizer,
                metrics=['accuracy'])
            # Build the generator
            self.generator = self.build_generator()
            # The generator takes noise and the target label as input
            # and generates the corresponding digit of that label
            noise = Input(shape=(self.latent_dim,))
            label = Input(shape=(1,))
            img = self.generator([noise, label])
            # For the combined model we will only train the generator
            self.discriminator.trainable = False
            # The discriminator takes generated image as input and determines validity
            # and the label of that image
            valid = self.discriminator([img, label])
            # The combined model (stacked generator and discriminator)
            # Trains generator to fool discriminator
            self.combined = Model([noise, label], valid)
            self.combined.compile(loss=['binary_crossentropy'],
                optimizer=optimizer)
        def build_generator(self):
            model = Sequential()
            model.add(Dense(256, input_dim=self.latent_dim))
            model.add(LeakyReLU(alpha=0.2))
            model.add(BatchNormalization(momentum=0.8))
            model.add(Dense(512))
            model.add(LeakyReLU(alpha=0.2))
            model.add(BatchNormalization(momentum=0.8))
            model.add(Dense(1024))
            model.add(LeakyReLU(alpha=0.2))
            model.add(BatchNormalization(momentum=0.8))
            model.add(Dense(np.prod(self.img_shape), activation='tanh'))
            model.add(Reshape(self.img_shape))
            model.summary()
            noise = Input(shape=(self.latent_dim,))
            label = Input(shape=(1,), dtype='int32')
            label_embedding = Flatten()(Embedding(self.num_classes, self.latent_dim)(label))
            model_input = multiply([noise, label_embedding])
            img = model(model_input)
            return Model([noise, label], img)
        def build_discriminator(self):
            model = Sequential()
            model.add(Dense(512, input_dim=np.prod(self.img_shape)))
            model.add(LeakyReLU(alpha=0.2))
            model.add(Dense(512))
            model.add(LeakyReLU(alpha=0.2))
            model.add(Dropout(0.4))
            model.add(Dense(512))
            model.add(LeakyReLU(alpha=0.2))
            model.add(Dropout(0.4))
            model.add(Dense(1, activation='sigmoid'))
            model.summary()
            img = Input(shape=self.img_shape)
            label = Input(shape=(1,), dtype='int32')
            label_embedding = Flatten()(Embedding(self.num_classes, np.prod(self.img_shape))(label))
            flat_img = Flatten()(img)
            model_input = multiply([flat_img, label_embedding])
            validity = model(model_input)
            return Model([img, label], validity)
        def train(self, epochs, batch_size=128, sample_interval=50):
            # Load the dataset
            (X_train, y_train), (_, _) = mnist.load_data()
            # Configure input
            X_train = (X_train.astype(np.float32) - 127.5) / 127.5
            X_train = np.expand_dims(X_train, axis=3)
            y_train = y_train.reshape(-1, 1)
            # Adversarial ground truths
            valid = np.ones((batch_size, 1))
            fake = np.zeros((batch_size, 1))
            for epoch in range(epochs):
                # ---------------------
                # Train Discriminator
                # ---------------------
                # Select a random half batch of images
                idx = np.random.randint(0, X_train.shape[0], batch_size)
                imgs, labels = X_train[idx], y_train[idx]
                # Sample noise as generator input
                noise = np.random.normal(0, 1, (batch_size, 100))
                # Generate a half batch of new images
                gen_imgs = self.generator.predict([noise, labels])
                # Train the discriminator
                d_loss_real = self.discriminator.train_on_batch([imgs, labels], valid)
                #train_on_batch返回值 为长度为2的列表, d_loss_real[0]为loss， d_loss_real[1]为accuracy
                d_loss_fake = self.discriminator.train_on_batch([gen_imgs, labels], fake)
                d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
                # ---------------------
                # Train Generator
                # ---------------------
                # Condition on labels
                sampled_labels = np.random.randint(0, 10, batch_size).reshape(-1, 1)
                # Train the generator
                g_loss = self.combined.train_on_batch([noise, sampled_labels], valid)
                # Plot the progress
                print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))
                # If at save interval => save generated image samples
                if epoch % sample_interval == 0:
                    self.sample_images(epoch)
        def sample_images(self, epoch):
            r, c = 2, 5
            noise = np.random.normal(0, 1, (r * c, 100))
            sampled_labels = np.arange(0, 10).reshape(-1, 1)
            gen_imgs = self.generator.predict([noise, sampled_labels])
            # Rescale images 0 - 1
            gen_imgs = 0.5 * gen_imgs + 0.5
            fig, axs = plt.subplots(r, c)
            cnt = 0
            for i in range(r):
                for j in range(c):
                    axs[i,j].imshow(gen_imgs[cnt,:,:,0], cmap='gray')
                    axs[i,j].set_title("Digit: %d" % sampled_labels[cnt])
                    axs[i,j].axis('off')
                    cnt += 1
            fig.savefig("images/%d.png" % epoch)
            plt.close()
    if __name__ == '__main__':
        cgan = CGAN()
        cgan.train(epochs=1000, batch_size=32, sample_interval=200)

# 2 第二种 tf.GradientTape() #

参考：[https://www.tensorflow.org/guide/keras/customizing\_what\_happens\_in\_fit][https_www.tensorflow.org_guide_keras_customizing_what_happens_in_fit]  
（1）搭建网络

from tensorflow.keras import layers
    # Create the discriminator
    discriminator = keras.Sequential(
        [
            keras.Input(shape=(28, 28, 1)),
            layers.Conv2D(64, (3, 3), strides=(2, 2), padding="same"),
            layers.LeakyReLU(alpha=0.2),
            layers.Conv2D(128, (3, 3), strides=(2, 2), padding="same"),
            layers.LeakyReLU(alpha=0.2),
            layers.GlobalMaxPooling2D(),
            layers.Dense(1),
        ],
        name="discriminator",
    )
    # Create the generator
    latent_dim = 128
    generator = keras.Sequential(
        [
            keras.Input(shape=(latent_dim,)),
            # We want to generate 128 coefficients to reshape into a 7x7x128 map
            layers.Dense(7 * 7 * 128),
            layers.LeakyReLU(alpha=0.2),
            layers.Reshape((7, 7, 128)),
            layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
            layers.LeakyReLU(alpha=0.2),
            layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
            layers.LeakyReLU(alpha=0.2),
            layers.Conv2D(1, (7, 7), padding="same", activation="sigmoid"),
        ],
        name="generator",
    )
    #训练网络
    class GAN(keras.Model):
        def __init__(self, discriminator, generator, latent_dim):
            super(GAN, self).__init__()
            self.discriminator = discriminator
            self.generator = generator
            self.latent_dim = latent_dim
        def compile(self, d_optimizer, g_optimizer, loss_fn):
            super(GAN, self).compile()
            self.d_optimizer = d_optimizer
            self.g_optimizer = g_optimizer
            self.loss_fn = loss_fn
        def train_step(self, real_images):
            if isinstance(real_images, tuple):
                real_images = real_images[0]
            # Sample random points in the latent space
            batch_size = tf.shape(real_images)[0]
            random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))
            # Decode them to fake images
            generated_images = self.generator(random_latent_vectors)
            # Combine them with real images
            combined_images = tf.concat([generated_images, real_images], axis=0)
            # Assemble labels discriminating real from fake images
            labels = tf.concat(
                [tf.ones((batch_size, 1)), tf.zeros((batch_size, 1))], axis=0
            )
            # Add random noise to the labels - important trick!
            labels += 0.05 * tf.random.uniform(tf.shape(labels))
            # Train the discriminator
            with tf.GradientTape() as tape:
                predictions = self.discriminator(combined_images)
                d_loss = self.loss_fn(labels, predictions)
            grads = tape.gradient(d_loss, self.discriminator.trainable_weights)
            self.d_optimizer.apply_gradients(
                zip(grads, self.discriminator.trainable_weights)
            )
            # Sample random points in the latent space
            random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))
            # Assemble labels that say "all real images"
            misleading_labels = tf.zeros((batch_size, 1))
            # Train the generator (note that we should *not* update the weights
            # of the discriminator)!
            with tf.GradientTape() as tape:
                predictions = self.discriminator(self.generator(random_latent_vectors))
                g_loss = self.loss_fn(misleading_labels, predictions)
            grads = tape.gradient(g_loss, self.generator.trainable_weights)
            self.g_optimizer.apply_gradients(zip(grads, self.generator.trainable_weights))
            return { "d_loss": d_loss, "g_loss": g_loss}
    #测试网络
    batch_size = 64
    (x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
    all_digits = np.concatenate([x_train, x_test])
    all_digits = all_digits.astype("float32") / 255.0
    all_digits = np.reshape(all_digits, (-1, 28, 28, 1))
    dataset = tf.data.Dataset.from_tensor_slices(all_digits)
    dataset = dataset.shuffle(buffer_size=1024).batch(batch_size)
    gan = GAN(discriminator=discriminator, generator=generator, latent_dim=latent_dim)
    gan.compile(
        d_optimizer=keras.optimizers.Adam(learning_rate=0.0003),
        g_optimizer=keras.optimizers.Adam(learning_rate=0.0003),
        loss_fn=keras.losses.BinaryCrossentropy(from_logits=True),
    )

[https_github.com_eriklindernoren_Keras-GAN_tree_master_cgan]: https://github.com/eriklindernoren/Keras-GAN/tree/master/cgan
[Keras API_mnist]: https://betterbench.blog.csdn.net/article/details/117412524
[https_www.tensorflow.org_guide_keras_customizing_what_happens_in_fit]: https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit