Understanding Generative Adversarial Networks (GANs)

An Intuitive Explanation for the Intricate Architecture of Generative Adversarial Networks.

In the evolving realm of Artificial Intelligence, Generative Adversarial Networks (GANs) have emerged as a revolutionary technology, acting as a game between two dynamic entities with contrasting objectives. This article unfolds the conceptual analogy of two friends immersed in an intriguing game of art creation and discernment, symbolizing the core components of GANs: the Generator, aspiring to master the art of painting, and the Discriminator, striving to perfect the skill of distinguishing authentic paintings from fabricated ones. By conceptualizing the mechanics of GANs through this illustrative analogy, we aim to provide an intuitive understanding of the intricate interplay between the Generator and the Discriminator, elucidating how their continual interaction and learning processes lead to the refinement of their respective skills.

The Game Analogy

Imagine you have two friends playing a game: one is trying to create paintings (we’ll call this friend the “Generator”), and the other is guessing whether the paintings are real or created by the Generator (we’ll call this friend the “Discriminator”). After each round, both friends are informed whether the Discriminator’s guesses were correct or not. This feedback is crucial as it helps the Generator improve its painting skills and the Discriminator refine its ability to distinguish between real and fake paintings. In the beginning, the Generator isn’t adept at painting, and the Discriminator is somewhat proficient at identifying real paintings. As they play many rounds of the game, the Generator strives to create paintings so realistic that the Discriminator can’t discern whether they are fake, and the Discriminator becomes more skilled at making accurate distinctions. Eventually, the Generator produces highly realistic paintings, and the Discriminator becomes exceptionally skilled at differentiating between real and fake!

Imagine the game they are playing is like the GAN architecture in computer programs. The Generator and the Discriminator are like two parts of the program. The Generator creates, or “generates,” things, trying to make them as realistic as possible. It’s like the friend who’s trying to paint more convincing paintings. It starts with random guesses and refines them using feedback.

The Discriminator, on the other hand, is the part of the program that evaluates, or “discriminates,” whether what the Generator made is real or fake. It’s like the friend who’s guessing which paintings are real. It gets better by looking at more real and fake examples and learning the differences between them.

They work together in a loop: the Generator makes something, the Discriminator evaluates it, and then the Generator uses this feedback to make something even better next time. This continues until the Generator creates something so realistic that even the Discriminator has a tough time figuring out if it’s real or fake. In the world of computer science, this process helps in creating very realistic images, sounds, and other types of data!

Introduction to GAN

A Generative Adversarial Network (GAN) is structured as a system of two neural networks, the Generator and the Discriminator, engaging in a sort of game. Just like our friends, one is creating (Generator), and the other is evaluating (Discriminator).

Much like the friend who creates paintings, the Generator’s role within a GAN is to create data. It begins its journey with little knowledge about the real data distribution and attempts to generate data that resembles real, authentic data as closely as possible. The Generator takes random noise as an input and transforms it, aspiring to produce data indistinguishable from real examples.

The Discriminator, analogous to the friend guessing which painting is real, scrutinizes the data it receives and tries to distinguish between real data and the data generated by the Generator. The Discriminator is trained to improve its ability to discern, enhancing its capability to differentiate between real and generated data.

The learning in GANs is interactive and iterative, much like the rounds played by our friends in the game. In each round or iteration of training, the Generator creates a new piece of data, and the Discriminator evaluates it. They both receive feedback: the Generator learns from the Discriminator about which of its creations are more akin to the real ones, honing its ability to generate more realistic data. The Discriminator, on the other hand, is informed after each round which of its guesses were correct, refining its ability to discern between real and generated data accurately.

This continuous feedback and learning are critical. It enables the Generator to progressively refine its creations, making them increasingly indistinguishable from real data. Simultaneously, the Discriminator becomes more adept at making accurate distinctions, continually improving its ability to identify subtle differences that distinguish real data from the generated ones.

This iterative process of creation, discernment, and adaptation continues until a point of equilibrium is reached, where the Generator’s creations are so convincingly realistic that the Discriminator faces immense difficulty distinguishing them from real data, achieving a harmonious balance between generation and discrimination in the network.

On Unsupervised Learning

GANs operate in an unsupervised learning paradigm because they learn to generate new data by understanding the inherent patterns and distributions of the training data without having access to any labels or explicit instructions. The GAN model as a whole is trying to understand and replicate the underlying data distribution, making it a form of unsupervised learning.

However, the internal learning mechanisms of the Generator and the Discriminator are, in essence, supervised. The Discriminator is provided with real data (considered as positive samples) and generated data (considered as negative samples) and is trained to classify between the two, akin to a binary classification task in supervised learning. It receives labels, albeit generated internally: “real” for real data and “fake” for generated data.

Similarly, the Generator, although it generates data without supervision, is guided by the feedback from the Discriminator to refine its generation process. It learns to modify its outputs based on the Discriminator’s responses, optimizing its generation process to produce data that are more likely to be classified as real by the Discriminator. This feedback loop can be likened to the correction mechanism in supervised learning where a model learns from the error in its predictions.

The dichotomy between unsupervised learning at the macro level and the supervised nature of the learning processes of the constituent components underscores the innovative structure of GANs. This amalgamation of learning paradigms allows GANs to leverage the strengths of both supervised and unsupervised learning, enabling the generation of highly realistic data by capturing and emulating the intricate patterns inherent in the training data.

Example: A Basic GAN

Let’s build a very basic GAN using Python to understand its fundamental structure and working mechanism.

Defining the Discriminator Network

The discriminator is a model that takes a two-dimensional input and produces a one-dimensional output. It accepts a sample either from genuine data or from the generator and then outputs the likelihood that this sample originates from the actual training dataset.

In PyTorch, the neural network models are represented by classes that inherit from nn.Module:

class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(2, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(64, 1),
            nn.Sigmoid(),
        )

    def forward(self, x):
        output = self.model(x)
        return output

Within this model, there are four layers that process input data. The data flows from an initial 2-dimensional input to 256 nodes, then to 128 nodes, and then to 64 nodes. After each of these transformations, there’s an activation function (ReLU) to introduce non-linearity and a dropout for regularization. Finally, the data is compressed to a 1-dimensional output with a sigmoid activation, producing a value between 0 and 1. The forward method dictates how input data (x) is passed through this network to produce an output.

Once declaring the discriminator class, we should instantiate a Discriminator object:

discriminator = Discriminator()

Defining the Generator Network

In generative adversarial networks, the generator is responsible for taking samples from a hidden or latent space and producing data that appears similar to the training set. This latent space, often referred to as hidden space, is essentially a compact representation of the data, often in a lower-dimensional form, where each point can be thought of as a unique code that the generator can decode into more complex data. Specifically, for this generator, it accepts a two-dimensional input from this space, given random points (z₁, z₂), and it then outputs two-dimensional points (x̃₁, x̃₂) that aim to mimic those in the training data.

To achieve this, we will design a Generator class, akin to how the discriminator was constructed. This class will inherit from nn.Module, detailing the neural network’s blueprint. Once that’s set, you’ll instantiate a Generator object to bring it to life.

class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(2, 16),
            nn.ReLU(),
            nn.Linear(16, 32),
            nn.ReLU(),
            nn.Linear(32, 2),
        )

    def forward(self, x):
        output = self.model(x)
        return output

This Generator has two hidden layers, the first with 16 neurons and the second with 32 neurons, both utilizing ReLU activation. The final output layer has 2 neurons with a linear activation, producing a two-element vector. This output can take on any value from negative infinity to positive infinity, symbolizing the coordinates (x̃₁, x̃₂).

Again, upon declaring the generator class, we should instantiate a Generator object:

generator = Generator()

Training the Two Models

The following pseudocode describes the fundamental loop of training a Generative Adversarial Network (GAN).

Initialize Generator and Discriminator

For each epoch:

      #Train the Discriminator
      Get real data samples
      Generate fake data samples using Generator
      Combine real and fake samples
      Train Discriminator to distinguish real from fake

      #Train the Generator
      Generate fake data samples using Generator
      Train Generator to fool the Discriminator into thinking fake samples are real

End For

Within this loop, two main entities, the Generator and the Discriminator, interact in a competitive manner. For each training cycle or epoch, the Discriminator is first taught to differentiate between genuine data and data fabricated by the Generator. After that, the Generator’s role comes into play, where it attempts to create data that can successfully deceive the Discriminator, making it believe the fabricated data is real. This iterative process of training, with both entities trying to outdo the other, continues over many epochs until the network converges, ideally with the Generator producing highly realistic data.

This is a possible implementation of the training process:

for epoch in range(num_epochs):

    for n, (real_samples, _) in enumerate(train_loader):

        # Data for training the discriminator
        real_samples_labels = torch.ones((batch_size, 1))
        latent_space_samples = torch.randn((batch_size, 2))
        generated_samples = generator(latent_space_samples)
        generated_samples_labels = torch.zeros((batch_size, 1))
        all_samples = torch.cat((real_samples, generated_samples))
        all_samples_labels = torch.cat(
            (real_samples_labels, generated_samples_labels)
        )

        # Training the discriminator
        discriminator.zero_grad()
        output_discriminator = discriminator(all_samples)
        loss_discriminator = loss_function(
            output_discriminator, all_samples_labels)
        loss_discriminator.backward()
        optimizer_discriminator.step()

        # Data for training the generator
        latent_space_samples = torch.randn((batch_size, 2))

        # Training the generator
        generator.zero_grad()
        generated_samples = generator(latent_space_samples)
        output_discriminator_generated = discriminator(generated_samples)
        loss_generator = loss_function(
            output_discriminator_generated, real_samples_labels
        )
        loss_generator.backward()
        optimizer_generator.step()

PyTorch offers a range of strategies for updating model weights through its torch.optim module. For training both the discriminator and generator models, you’ll be employing the Adam algorithm. To set up the optimizers with torch.optim, execute the given lines of code.

optimizer_discriminator = torch.optim.Adam(discriminator.parameters(), lr=lr)
optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)

The binary cross-entropy function is an appropriate loss function for the discriminator’s training due to its binary classification nature. It’s equally fitting for training the generator, given that the generator’s output is evaluated by the discriminator, which then produces a binary-based result.

loss_function = nn.BCELoss()

Conclusion

In this article, we’ve delved deep into the mechanics and philosophy behind GANs. This unique machine learning structure, which plays a continual game between two neural networks — the data-crafting Generator and the authenticity-assessing Discriminator — has significantly revolutionized the way we generate and evaluate synthetic data. Through this article, the complex intricacies of GANs were demystified, providing readers with a clearer, more intuitive grasp of its design and functionality. As we stand on the brink of numerous AI-driven innovations, understanding the essence of GANs becomes paramount for both enthusiasts and professionals in the field.