⬡ Hub
Skip to content

advanced_gan_image_generation

Advanced - Generative Adversarial Network (GAN) for Image Generation

Description

This project provides an implementation of a basic Generative Adversarial Network (GAN) using TensorFlow and Keras. The goal is to train a model that can generate new, synthetic images of handwritten digits that are visually similar to the images in the MNIST dataset.

A GAN consists of two competing neural networks: - The Generator: Takes a random noise vector as input and attempts to generate a realistic image. - The Discriminator: Takes an image (either real from the dataset or fake from the generator) and tries to classify it as real or fake.

Through this adversarial training process, the generator becomes progressively better at creating convincing images.

Functionality

  1. Data Loading: The script loads the MNIST dataset of handwritten digits, which is used as the "real" data for training the discriminator.
  2. Model Definition:
    • A Generator model is defined, which uses Conv2DTranspose (deconvolution) layers to upsample a random noise vector into a 28x28 grayscale image.
    • A Discriminator model is defined, which uses standard Conv2D layers to take a 28x28 image and output a single value indicating whether it thinks the image is real or fake.
  3. Custom Training Loop: The project uses a custom training loop with tf.GradientTape to manage the unique training dynamics of a GAN:
    • The discriminator is trained to correctly identify real and fake images.
    • The generator is trained to produce images that fool the discriminator.
  4. Image Generation and Saving: Throughout the training process, the script periodically generates a set of sample images and saves them to a directory named generated_gan_images. This allows you to visually track the generator's improvement over time.

Architecture

  • TensorFlow & Keras: The entire project is built using the TensorFlow deep learning framework and its high-level Keras API.
  • Generator Network: A deep convolutional network composed of Dense, BatchNormalization, LeakyReLU, and Conv2DTranspose layers to transform a 100-dimensional noise vector into an image.
  • Discriminator Network: A convolutional neural network (CNN) with Conv2D, LeakyReLU, and Dropout layers designed for image classification (real vs. fake).
  • tf.GradientTape: This is used to create a custom training loop, which is necessary for GANs as they have two models with different loss functions that need to be trained in alternating steps.
  • Optimizers: The Adam optimizer is used for both the generator and discriminator networks.
  • matplotlib: Used to visualize and save the generated images.

How to Run

Prerequisites

Make sure you have Python installed, along with the required libraries. You can install them using pip:

pip install tensorflow numpy matplotlib

Execution

To run the project, navigate to the project directory and execute the following command:

python advanced_gan_image_generation.py

The script will begin the training process, printing the loss for the generator and discriminator at each epoch. It will also create a directory named generated_gan_images in the same folder and save image grids (e.g., gan_image_at_epoch_0001.png) that show the generator's progress.

Concepts Covered

  • Generative Adversarial Networks (GANs): The core architecture and adversarial training philosophy.
  • Generative Models: Models that can create new data samples.
  • Deep Convolutional GAN (DCGAN): The specific architecture used in this project.
  • Custom Training Loops: How to write a training loop from scratch in TensorFlow for more complex training scenarios.
  • Loss Functions for GANs: Using binary cross-entropy to create the competing loss functions for the generator and discriminator.
  • Image Synthesis: The process of generating novel images from a learned data distribution.

Files and Subdirectories