GANs (Generative Adversarial Networks:)

Author(s): Data Science meets Cyber Security

Originally published on Towards AI.

We Saw the Generative AI, Now Let’s See How Actually It Is Generated.!

INTRODUCTION:

GANs, Generative Adversarial networks, let’s first understand what GANs are. So I have already written a blog on Generative AI where we discuss many types of AI, the hype of AI, and why AI is tending nowadays in every sector like Healthcare, Finance, Trading, marketing, and many more. But exactly how this AI is able to generate all those look-alike images, fascinating views with intriguing colors and symphonies that are so sweet to hear, and so much more? GANs are a part of the deep-learning world and were very introduced by Ian Goodfellow and his collaborators in 2014, After that GANs have rapidly captivated many researchers’ eyes which resulted in much research and also helped to redefine the boundaries of creativity and artificial intelligence in the world of AI

1.1 WHAT ARE GANs and HOW DO THEY WORK?

So, have any of you heard of synthetic data? Yes, then fantastic. No concerns if the answer is no. Synthetic data is data that is not genuine but is manufactured by algorithms when actual data is unavailable. You can even think of synthetic data as a fake dataset. But, of course, how is it produced? what is the procedure? Did you say the algorithm? What exactly is the algorithm? The answer would be, GANs, Yes, a component of deep learning models used for generative tasks, create virtually anything phony, from deepfake films to look-alike photos to fake datasets of anything.

GANs are made up of two major neural networks:

1. THE GENERATOR

2. THE DISCRIMINATOR:

GENERATOR:

The Generator network takes random noise as input, considers random as completely random fake data, and then attempts to transform it into data that resembles the original data, or its target distribution. Consider the example of images. When dealing with images dataset, this network tries to produce images that appear precisely like the original dataset that we have given as input, but they are completely generated, i.e. false. So, in essence, this network learns to map noise vectors to data samples by modifying its parameters using backpropagation and gradient descent.

DISCRIMINATOR:

The Discriminator network, on the other hand, functions as a classifier, attempting to differentiate between real data from the original dataset and bogus data generated by the Generator. It learns to give true data with high probability and false data with low probabilities.

GAN training comprises a back-and-forth battle between these two networks. This is how it works:

TRAINING PHASE:

• The Generator generates fake data from random noise.
• The Discriminator assesses and assigns probability to both actual and bogus data.
• The Discriminator’s purpose is to enhance its classification accuracy by learning to discriminate between true and bogus data.
• The Generator’s purpose is to generate data that is compelling enough to “fool” the Discriminator. It modifies its settings to provide data that the Discriminator is more likely to recognize as real.

COMPETITION PHASE:

• The Generator produces fresh fictitious data.
• The Discriminator compares fresh phony data to actual data.
• The Discriminator’s increased classification capacity may now allow it to better distinguish the new phony data.
• The Generator modifies its parameters in order to create more compelling results.

This iterative procedure is repeated until the Generator generates data that is indistinguishable from actual data or a stopping requirement is satisfied.

The success of GANs is dependent on striking a balance between the Generator and the Discriminator, where the Generator grows good at producing realistic data and the Discriminator becomes great at discriminating between genuine and false data. By capturing subtle patterns and distributions from training data, GANs have exhibited outstanding outcomes in a variety of disciplines such as picture production, style transfer, data augmentation, and more.

Here’s the coolest video about all the math behind the GAN architecture, explained so simply and efficiently do watch it if interested: https://youtu.be/Gib_kiXgnvA

Step into the dynamic realm of Generative Adversarial Networks (GANs) and deep neural networks through PROJECT PRO Aside from theoretical explanations, this platform provides an immersive learning experience that includes both comprehension and actual application.

You are not simply a passive student with PROJECT PRO; you become an active participant in the creation and fine-tuning of GANs and deep neural networks. You’ll be led through every stage of development, from conceptualizing model architectures to coding and using actual datasets. Whether you’re interested in picture creation, data augmentation, or other GAN applications, PROJECT PRO has the tools and resources to help you turn your ideas into real-world projects. With this interactive learning platform, you may improve your abilities, explore at your own speed, and bring your creative thoughts to reality.

Visit them now: https://bit.ly/3OlIGoF

2. ADVANTAGES OF GANs:

Now that we’ve learned about the inner workings of Generative Adversarial Networks (GANs), let’s look at the particular benefits they have over other deep neural network approaches. These benefits extend beyond picture production, data augmentation, and image alteration, demonstrating GANs’ unique ability to push the frontiers of artificial intelligence and creative applications.

2.1 HIGH-QUALITY IMAGE GENERATION:

GANs’ capacity to create high-quality pictures that closely resemble genuine photographs is one of its amazing capabilities. The Generator network creates visuals with amazing realism by learning the intricate patterns and structures of a dataset. This has enormous potential in disciplines like art, design, and entertainment, allowing for the production of lifelike pictures that push the limits of imagination.

2.2 DATA AUGMENTATION AND SYNTHESIS:

By creating synthetic data, GANs serve a critical role in improving the efficiency of machine learning models. This method, known as data augmentation, entails the creation of additional instances that increase the variety of the training dataset. GANs thrive in this area by delivering data that accurately represents the original distribution. This is especially useful when data is scarce since it aids in model generalization and performance.

2.3 STYLE TRANSFER AND IMAGE-TO-IMAGE TRANSLATION

GANs have the unique capacity to change the style or content of pictures, which leads to applications such as style transfer and image-to-image translation. GANs may transfer the creative style of one picture to another while keeping its content in style transfer. GANs help translate pictures from one domain to another in image-to-image translation, such as translating satellite images into maps or black-and-white photos into color images. This adaptability provides up opportunities for creative expression and practical solutions in a variety of sectors.

GANs’ strength rests in their capacity to address these difficulties with creativity and elegance, making them a driving force in creating the future of artificial intelligence and creative technologies.

REAL-WORLD USE CASES OF GANs:

After we’ve mastered the fundamentals of GANs, let’s look into the many real-world applications where their abilities shine. GANs have created intriguing pieces in art and design, such as “Portrait of Edmond de Belamy,” which was auctioned off as AI-generated art. GANs are used by well-known fashion brands like Nike to create distinctive designs, while in healthcare, GANs generate synthetic medical pictures, enhancing diagnostic AI training in real time.

NVIDIA replicates several driving scenarios in the field of autonomous vehicles, hastening self-driving car improvements. GANs are being used by architects to visualize interior designs, while GAN-generated immersive environments are being used to enhance video games. GAN-powered personalized fashion suggestions enhance the retail experience, while image restoration, medication discovery, and other sectors are being redefined. GANs are the catalysts that turn vision into reality in art, technology, and other fields.

LET’S PLAY WITH GAN A LITTLE: (CODE TO GENERATE IMAGES)

This GAN model code demonstrates how to build, train, and visualize the results of a Generative Adversarial Network (GAN) using TensorFlow and Keras. Let’s go through the key components of the code step by step:

Step1: Preparing and Downloading the Dataset:

To begin, the code downloads and extracts the CelebA dataset. The collection is made up of celebrity face photos. The photos have been imported and are being preprocessed. They have been normalized to the range [-1, 1].

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import matplotlib.pyplot as plt
import os
import gdown
from zipfile import ZipFile

os.makedirs("celeba_gan")

url = "https://drive.google.com/uc?id=1O7m1010EJjLE5QxLZiM9Fpjs7Oj6e684"
output = "celeba_gan/data.zip"
gdown.download(url, output, quiet=True)

with ZipFile("celeba_gan/data.zip", "r") as zipobj:
 zipobj.extractall("celeba_gan")

dataset = keras.utils.image_dataset_from_directory(
 "celeba_gan", label_mode=None, image_size=(64, 64), batch_size=32
)
dataset = dataset.map(lambda x: x / 255.0)

for x in dataset:
 plt.axis("off")
 plt.imshow((x.numpy() * 255).astype("int32")[0])
 break

Step2: Discriminator Model Definition:

A sequence of convolutional layers with LeakyReLU activations is used to create the discriminator model. The discriminator attempts to determine if an input picture is genuine or fabricated (manufactured).

discriminator = keras.Sequential(
 [
 keras.Input(shape=(64, 64, 3)),
 layers.Conv2D(64, kernel_size=4, strides=2, padding="same"),
 layers.LeakyReLU(alpha=0.2),
 layers.Conv2D(128, kernel_size=4, strides=2, padding="same"),
 layers.LeakyReLU(alpha=0.2),
 layers.Conv2D(128, kernel_size=4, strides=2, padding="same"),
 layers.LeakyReLU(alpha=0.2),
 layers.Flatten(),
 layers.Dropout(0.2),
 layers.Dense(1, activation="sigmoid"),
 ],
 name="discriminator",
)
discriminator.summary()

Step3: Creating a Generator Model:

To produce pictures, the generator model accepts random latent vectors as input and gradually upsamples them. It begins with a dense layer and then transforms the output to a 4D tensor.

Convolutional transpose layers are used to upsample the data and produce a picture that mimics the dataset’s genuine images.

latent_dim = 128

generator = keras.Sequential(
 [
 keras.Input(shape=(latent_dim,)),
 layers.Dense(8 * 8 * 128),
 layers.Reshape((8, 8, 128)),
 layers.Conv2DTranspose(128, kernel_size=4, strides=2, padding="same"),
 layers.LeakyReLU(alpha=0.2),
 layers.Conv2DTranspose(256, kernel_size=4, strides=2, padding="same"),
 layers.LeakyReLU(alpha=0.2),
 layers.Conv2DTranspose(512, kernel_size=4, strides=2, padding="same"),
 layers.LeakyReLU(alpha=0.2),
 layers.Conv2D(3, kernel_size=5, padding="same", activation="sigmoid"),
 ],
 name="generator",
)
generator.summary()

Step4: The GAN Model is defined as follows:

The discriminator and generator are combined in the GAN class.

It includes a train_step method for performing a single training step on both the discriminator and the generator.

The discriminator is trained to tell the difference between actual and phony pictures, while the generator is trained to create images that deceive the discriminator.

During training, random noise is injected into the labels to improve stability.

class GAN(keras.Model):
 def __init__(self, discriminator, generator, latent_dim):
 super().__init__()
 self.discriminator = discriminator
 self.generator = generator
 self.latent_dim = latent_dim

 def compile(self, d_optimizer, g_optimizer, loss_fn):
 super().compile()
 self.d_optimizer = d_optimizer
 self.g_optimizer = g_optimizer
 self.loss_fn = loss_fn
 self.d_loss_metric = keras.metrics.Mean(name="d_loss")
 self.g_loss_metric = keras.metrics.Mean(name="g_loss")

 @property
 def metrics(self):
 return [self.d_loss_metric, self.g_loss_metric]

 def train_step(self, real_images):
 # 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))

 # Update metrics
 self.d_loss_metric.update_state(d_loss)
 self.g_loss_metric.update_state(g_loss)
 return {
 "d_loss": self.d_loss_metric.result(),
 "g_loss": self.g_loss_metric.result(),
 }

Step5: Visualisation Custom Callback:

At the conclusion of each epoch, the GANMonitor class creates and records a small number of created pictures. These graphics illustrate the generator’s development throughout training.

class GANMonitor(keras.callbacks.Callback):
 def __init__(self, num_img=3, latent_dim=128):
 self.num_img = num_img
 self.latent_dim = latent_dim

 def on_epoch_end(self, epoch, logs=None):
 random_latent_vectors = tf.random.normal(shape=(self.num_img, self.latent_dim))
 generated_images = self.model.generator(random_latent_vectors)
 generated_images *= 255
 generated_images.numpy()
 for i in range(self.num_img):
 img = keras.utils.array_to_img(generated_images[i])
 img.save("generated_img_%03d_%d.png" % (epoch, i))

Step6: Compilation and Training:

The GAN model is compiled with binary cross-entropy loss and Adam optimizers for both the discriminator and generator. The gan.fit method is used to train the model. The dataset of celebrity face images is used for training.

The GANMonitor callback is used to save generated images after each epoch.

Step7: Training Loop and Visualization:

During training, the GAN alternates between updating the discriminator and generator.

The discriminator aims to correctly classify real and generated images, while the generator aims to create images that can deceive the discriminator. Generated images are saved after each epoch using the GANMonitor callback.

CODE REFERENCE: https://keras.io/examples/generative/dcgan_overriding_train_step/

Don’t forget to follow us on social media platforms and share your views. Join our community of AI enthusiasts and let’s continue pushing the boundaries of Generative AI together. Together, we can achieve great things!U+1F510U+2764️

Join our LinkedIn group for data science and cyber security! You’ll find the latest material blogs, exclusive content, and fellow enthusiasts.U+1F525

LINK FOR THE GROUP: https://www.linkedin.com/groups/9378874/

FOLLOW US FOR THE SAME FUN TO LEARN DATA SCIENCE BLOGS AND ARTICLES: U+1F499

MAIL-ID: vidhiwaghela60@gmail.com

LINKEDIN: https://www.linkedin.com/company/dsmcs/

INSTAGRAM: https://www.instagram.com/datasciencemeetscybersecurity/?hl=en

GITHUB: https://github.com/Vidhi1290

TWITTER: https://twitter.com/VidhiWaghela

MEDIUM: https://medium.com/@datasciencemeetscybersecurity-

WEBSITE: https://www.datasciencemeetscybersecurity.com/

— TEAM DATA SCIENCE MEETS CYBER SECURITY U+1F499U+2764️

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI