Exploring Generative Adversarial Networks Using Tensorflow

Introduction

Generative Adversarial Networks (GANs) are a cutting-edge technology in the field of Machine Learning, specifically in deep learning. They have gained noteworthy attention due to their ability to generate high-quality, realistic images, and other types of data. In this blog post, we will dive into the fascinating world of GANs and explore their inner workings, including how to create and train a simple GAN using TensorFlow.

Understanding Generative Adversarial Networks

GANs consist of two main components, a Generator and a Discriminator. These two components play a min-max game, where the Generator's goal is to create realistic data samples that can deceive the Discriminator, while the Discriminator tries to distinguish between the real samples (from the training data) and fake samples generated by the Generator.

In simple terms, the Generator is like a counterfeiter trying to create fake currency notes, and the Discriminator is the inspector trying to determine if the notes are real or fake.

Implementing a Simple GAN using TensorFlow

We will start by implementing a simple GAN using TensorFlow to generate handwritten digits similar to the MNIST dataset. Make sure you have TensorFlow installed before proceeding.

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Dense, LeakyReLU, BatchNormalization, Reshape, Conv2DTranspose
from tensorflow.keras.models import Sequential

Creating the Generator

The Generator model transforms random noise into fake images. We will use a simple fully connected network with leaky ReLU activations.

def create_generator():
    model = Sequential()
    model.add(Dense(7*7*256, input_dim=100))
    model.add(LeakyReLU(0.2))
    model.add(BatchNormalization())
    model.add(Reshape((7, 7, 256)))

    model.add(Conv2DTranspose(64, (3,3), strides=(2,2), padding='same'))
    model.add(LeakyReLU(0.2))
    model.add(BatchNormalization())

    model.add(Conv2DTranspose(1, (3,3), strides=(2,2), padding='same', activation='tanh'))
    return model

Creating the Discriminator

The Discriminator model distinguishes between real and fake images. It is a simple convolutional neural network with leaky ReLU activations.

def create_discriminator():
    model = Sequential()
    model.add(Dense(512, input_dim=28*28))
    model.add(LeakyReLU(0.2))

    model.add(Dense(256))
    model.add(LeakyReLU(0.2))

    model.add(Dense(1, activation='sigmoid'))
    return model

Training the GAN

Training a GAN involves repeatedly updating the Generator and Discriminator till the Generator produces realistic images.

gan_input = tf.keras.Input(shape=(100,))
generated_image = generator(gan_input)
discriminator.trainable = False
gan_output = discriminator(tf.reshape(generated_image, (batch_size, 28*28)))
gan = tf.keras.Model(gan_input, gan_output)

# Compile the Discriminator and the GAN
discriminator.compile(optimizer='adam', loss='binary_crossentropy')
gan.compile(optimizer='adam', loss='binary_crossentropy')

# Load the MNIST data
(real_images, _), (_, _) = tf.keras.datasets.mnist.load_data()
real_images = real_images.astype('float32') / 255.0
real_images = real_images.reshape((real_images.shape[0], real_images.shape[1] * real_images.shape[2]))

# Train the GAN
for epoch in range(epochs):
    for step in range(batch_size, len(real_images), batch_size):
        real_batch = real_images[step-batch_size:step]
        noise = np.random.uniform(-1, 1, (batch_size, 100))
        generated_batch = generator.predict(noise)

        real_labels = np.ones((batch_size, 1))
        fake_labels = np.zeros((batch_size, 1))

        # Train the Discriminator
        d_loss_real = discriminator.train_on_batch(real_batch, real_labels)
        d_loss_fake = discriminator.train_on_batch(generated_batch, fake_labels)

        # Train the Generator
        noise = np.random.uniform(-1, 1, (batch_size, 100))
        g_loss = gan.train_on_batch(noise, real_labels)

      print('Epoch %d, Step %d - D loss: %.4f, G loss: %.4f' % (epoch, step, d_loss, g_loss))

After training the GAN, you would be able to generate realistic handwritten digits using the Generator.

Conclusion

In this blog post, we introduced Generative Adversarial Networks (GANs) and their two essential components, the Generator and Discriminator. We also covered how to create and train a simple GAN using TensorFlow. Though our example was focused on generating handwritten digits, GANs have the potential to revolutionize various industries, from art to healthcare, by creating high-quality, artificial data.