In recent years, deep learning has made innovative advancements in various fields such as image generation, transformation, and segmentation. Among them, GAN (Generative Adversarial Network) has opened new possibilities for image generation. GAN consists of two networks, the Generator and the Discriminator, which compete against each other to improve performance. In this post, we will explore an overview of GAN and detail how to set up the environment to implement GAN using the PyTorch framework.<\/p>\n
GAN is a model proposed by Ian Goodfellow in 2014, where two neural networks interact to be trained. The generator creates data that resembles real data, while the discriminator determines whether the generated data is real or not. These two networks continuously enhance each other.<\/p>\n
GAN consists of the following two components:<\/p>\n
The goal of GAN can be expressed as a Minimax game. The generator has the following objective:<\/p>\n
G^{*} = arg \\min_{G} \\max_{D} V(D, G) = E_{x \\sim pdata(x)}[\\log D(x)] + E_{z \\sim pz(z)}[\\log(1 - D(G(z)))]<\/code><\/pre>\nHere, G represents the generator, D represents the discriminator, pdata<\/sub>(x) is the distribution of real data, and pz<\/sub>(z) is the noise distribution used by the generator.<\/p>\n2. Setting Up the PyTorch Environment<\/h2>\n
PyTorch is an open-source machine learning library that provides various tools for tensor operations, automatic differentiation, and easily building deep learning models. The following outlines how to install PyTorch and set up the necessary libraries for implementing GAN.<\/p>\n
2.1 Installing PyTorch<\/h3>\n
PyTorch supports CUDA, allowing it to operate efficiently on NVIDIA GPUs. You can install it using the following command:<\/p>\n
pip install torch torchvision torchaudio<\/code><\/pre>\nIf you are using CUDA, please check the official PyTorch website for the installation commands that match your environment.<\/p>\n
2.2 Installing Additional Libraries<\/h3>\n
You will also need to install additional libraries required for image processing. Install them using the command below:<\/p>\n
pip install matplotlib numpy<\/code><\/pre>\n2.3 Setting Up the Basic Directory Structure<\/h3>\n
Create the project directory with the following structure:<\/p>\n
\n gan_project\/\n \u251c\u2500\u2500 dataset\/\n \u251c\u2500\u2500 models\/\n \u251c\u2500\u2500 results\/\n \u2514\u2500\u2500 train.py\n <\/code><\/pre>\nEach directory serves the purpose of storing datasets, models, and results. The train.py<\/code> file contains the script for training and evaluating GAN.<\/p>\n3. Code Examples Needed to Implement GAN<\/h2>\n
Now, let’s write the basic code to implement GAN. This code defines the generator and discriminator and includes the process of training GAN.<\/p>\n
3.1 Defining the Model<\/h3>\n
First, we define the generator and discriminator networks. The code below demonstrates an example of building the generator and discriminator using a simple CNN (Convolutional Neural Network):<\/p>\n
import torch\nimport torch.nn as nn\n\n# Generator model\nclass Generator(nn.Module):\n def __init__(self):\n super(Generator, self).__init__()\n self.model = nn.Sequential(\n nn.Linear(100, 256),\n nn.ReLU(),\n nn.Linear(256, 512),\n nn.ReLU(),\n nn.Linear(512, 1024),\n nn.ReLU(),\n nn.Linear(1024, 28 * 28), # MNIST image size\n nn.Tanh() # Normalized to [-1, 1]\n )\n \n def forward(self, z):\n return self.model(z).view(-1, 1, 28, 28)\n\n# Discriminator model\nclass Discriminator(nn.Module):\n def __init__(self):\n super(Discriminator, self).__init__()\n self.model = nn.Sequential(\n nn.Flatten(),\n nn.Linear(28 * 28, 512),\n nn.LeakyReLU(0.2),\n nn.Linear(512, 256),\n nn.LeakyReLU(0.2),\n nn.Linear(256, 1),\n nn.Sigmoid() # Normalized to [0, 1]\n )\n \n def forward(self, img):\n return self.model(img)\n <\/code><\/pre>\n3.2 Preparing the Dataset<\/h3>\n
We load and preprocess the MNIST dataset. Using the torchvision library makes it easy to load the dataset.<\/p>\n
from torchvision import datasets, transforms\n\n# Data preprocessing\ntransform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.5,), (0.5,))\n])\n\n# Load MNIST dataset\ndataloader = torch.utils.data.DataLoader(\n datasets.MNIST('dataset\/', download=True, transform=transform),\n batch_size=64,\n shuffle=True\n) \n <\/code><\/pre>\n3.3 GAN Training Code<\/h3>\n
Now, let’s create a loop that can train the generator and discriminator.<\/p>\n
import torch.optim as optim\n\n# Initialize models\ngenerator = Generator()\ndiscriminator = Discriminator()\n\n# Loss function and optimizer\ncriterion = nn.BCELoss()\noptimizer_g = optim.Adam(generator.parameters(), lr=0.0002)\noptimizer_d = optim.Adam(discriminator.parameters(), lr=0.0002)\n\nnum_epochs = 50\nfor epoch in range(num_epochs):\n for i, (imgs, _) in enumerate(dataloader):\n batch_size = imgs.size(0)\n imgs = imgs.view(batch_size, -1)\n\n # Generate real and fake labels\n real_labels = torch.ones(batch_size, 1)\n fake_labels = torch.zeros(batch_size, 1)\n\n # Train the discriminator\n optimizer_d.zero_grad()\n \n outputs = discriminator(imgs)\n d_loss_real = criterion(outputs, real_labels)\n d_loss_real.backward()\n \n z = torch.randn(batch_size, 100)\n fake_images = generator(z)\n outputs = discriminator(fake_images)\n d_loss_fake = criterion(outputs, fake_labels)\n d_loss_fake.backward()\n \n optimizer_d.step()\n\n # Train the generator\n optimizer_g.zero_grad()\n z = torch.randn(batch_size, 100)\n fake_images = generator(z)\n outputs = discriminator(fake_images)\n g_loss = criterion(outputs, real_labels)\n g_loss.backward()\n \n optimizer_g.step()\n\n if i % 100 == 0:\n print(f\"[Epoch {epoch}\/{num_epochs}] [Batch {i}\/{len(dataloader)}] \"\n f\"[D loss: {d_loss_real.item() + d_loss_fake.item()}] \"\n f\"[G loss: {g_loss.item()}]\")\n <\/code><\/pre>\n4. Visualizing Results<\/h2>\n
After training is complete, it is also important to visualize the generated images. You can output the generated images using matplotlib.<\/p>\n
import matplotlib.pyplot as plt\n\ndef generate_and_plot_images(generator, n_samples=25):\n z = torch.randn(n_samples, 100)\n generated_images = generator(z).detach().numpy()\n\n plt.figure(figsize=(5, 5))\n for i in range(n_samples):\n plt.subplot(5, 5, i + 1)\n plt.imshow(generated_images[i][0], cmap='gray')\n plt.axis('off')\n plt.show()\n\ngenerate_and_plot_images(generator)\n <\/code><\/pre>\n5. Conclusion<\/h2>\n
In this post, we explained the principles and basic structure of GAN, as well as provided the setup and code examples needed to implement GAN using PyTorch. GAN is a very powerful generative model with various applications. We encourage you to try various projects utilizing GAN in the future.<\/p>\n
References<\/h2>\n