The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Creating a GAN for Image Generation

Next ►
►

In this section, we will delve into the creation of a Generative Adversarial Network (GAN) for image generation. GANs are a class of machine learning frameworks designed by Ian Goodfellow and his colleagues in 2014. They consist of two neural networks, the generator and the discriminator, which compete against each other in a game-theoretic scenario.

Key Concepts

  1. Overview of GANs

  • Generator: Creates fake data (images) from random noise.
  • Discriminator: Evaluates the authenticity of the data, distinguishing between real and fake images.
  • Adversarial Process: The generator and discriminator are trained simultaneously. The generator aims to produce realistic images to fool the discriminator, while the discriminator aims to correctly identify real vs. fake images.

  1. GAN Architecture

  • Generator Network: Typically a deep neural network that takes a random noise vector as input and generates an image.
  • Discriminator Network: Another deep neural network that takes an image as input and outputs a probability indicating whether the image is real or fake.

  1. Loss Functions

  • Generator Loss: Measures how well the generator fools the discriminator.
  • Discriminator Loss: Measures how well the discriminator distinguishes between real and fake images.

Practical Example: Creating a GAN for Image Generation

Step 1: Import Libraries

import tensorflow as tf
from tensorflow.keras.layers import Dense, Reshape, Flatten, Conv2D, Conv2DTranspose, LeakyReLU, Dropout
from tensorflow.keras.models import Sequential
import numpy as np
import matplotlib.pyplot as plt

Step 2: Define the Generator

def build_generator():
    model = Sequential()
    model.add(Dense(256, input_dim=100))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(1024))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(28 * 28 * 1, activation='tanh'))
    model.add(Reshape((28, 28, 1)))
    return model

generator = build_generator()
generator.summary()

Step 3: Define the Discriminator

def build_discriminator():
    model = Sequential()
    model.add(Flatten(input_shape=(28, 28, 1)))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))
    model.add(Dense(256))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))
    model.add(Dense(1, activation='sigmoid'))
    return model

discriminator = build_discriminator()
discriminator.summary()

Step 4: Compile the Discriminator

discriminator.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

Step 5: Build and Compile the GAN

def build_gan(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

discriminator.trainable = False
gan = build_gan(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer='adam')

Step 6: Training the GAN

def train_gan(gan, generator, discriminator, epochs, batch_size, noise_dim):
    (X_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
    X_train = X_train / 127.5 - 1.0
    X_train = np.expand_dims(X_train, axis=3)
    
    valid = np.ones((batch_size, 1))
    fake = np.zeros((batch_size, 1))
    
    for epoch in range(epochs):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        real_imgs = X_train[idx]
        
        noise = np.random.normal(0, 1, (batch_size, noise_dim))
        gen_imgs = generator.predict(noise)
        
        d_loss_real = discriminator.train_on_batch(real_imgs, valid)
        d_loss_fake = discriminator.train_on_batch(gen_imgs, fake)
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
        
        noise = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(noise, valid)
        
        print(f"{epoch} [D loss: {d_loss[0]} | D accuracy: {100*d_loss[1]}] [G loss: {g_loss}]")
        
        if epoch % 100 == 0:
            save_imgs(generator, epoch)

def save_imgs(generator, epoch, noise_dim=100, examples=10):
    noise = np.random.normal(0, 1, (examples, noise_dim))
    gen_imgs = generator.predict(noise)
    gen_imgs = 0.5 * gen_imgs + 0.5
    
    fig, axs = plt.subplots(1, examples, figsize=(20, 4))
    for i in range(examples):
        axs[i].imshow(gen_imgs[i, :, :, 0], cmap='gray')
        axs[i].axis('off')
    plt.show()

train_gan(gan, generator, discriminator, epochs=10000, batch_size=64, noise_dim=100)

Practical Exercises

Exercise 1: Modify the Generator

Modify the generator to include additional layers and different activation functions. Observe how these changes affect the quality of generated images.

Solution

def build_generator_v2():
    model = Sequential()
    model.add(Dense(128, input_dim=100))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(256))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(1024))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(28 * 28 * 1, activation='tanh'))
    model.add(Reshape((28, 28, 1)))
    return model

generator_v2 = build_generator_v2()
generator_v2.summary()

Exercise 2: Implement a Different Loss Function

Implement a different loss function for the GAN and compare the results with the original binary cross-entropy loss.

Solution

gan.compile(loss='mean_squared_error', optimizer='adam')
train_gan(gan, generator, discriminator, epochs=10000, batch_size=64, noise_dim=100)

Common Mistakes and Tips

  • Overfitting the Discriminator: Ensure that the discriminator does not become too powerful compared to the generator. This can be mitigated by alternating the training steps or adjusting the learning rates.
  • Mode Collapse: This occurs when the generator produces limited varieties of images. Experiment with different architectures and training techniques to avoid this issue.

Conclusion

In this section, we have covered the basics of creating a GAN for image generation, including defining the generator and discriminator, compiling the GAN, and training it. We also explored practical exercises to deepen your understanding. In the next module, we will discuss ethical considerations and the future of deep learning.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved