\n Generative Adversarial Networks (GANs) are an innovative deep learning model proposed by Ian Goodfellow in 2014, where two neural networks learn in opposition to each other. GANs are widely used in various fields such as image generation, text generation, and video generation. In this post, we will explain the basic concepts and implementation methods of GANs step by step using PyTorch.\n <\/p>\n
\n GAN consists of two neural networks: the Generator and the Discriminator. The role of the Generator is to create data that looks real, and the Discriminator’s role is to determine whether the given data is real or fake data produced by the Generator. These two networks learn simultaneously; the Generator evolves to create increasingly sophisticated data to fool the Discriminator, while the Discriminator evolves to identify fake data more accurately.\n <\/p>\n
\n The structure of GAN can be described simply as follows:\n <\/p>\n
\n The learning process of GAN proceeds as follows:\n <\/p>\n
\n Now, let’s implement a simple GAN using PyTorch. Here, we will work on creating a GAN that generates images in numerical form using the MNIST dataset.\n <\/p>\n
\n First, we install and import the necessary libraries. We will use PyTorch and torchvision to load the dataset and build the model.\n <\/p>\n
\n \n !pip install torch torchvision matplotlib\n <\/code>\n <\/pre>\n2.2 Preparing the Dataset<\/h3>\n
\n We will load the MNIST dataset and perform data preprocessing. This will scale the image data between 0 and 1 and divide it into batches.\n <\/p>\n
\n \n import torch\n from torchvision import datasets, transforms\n from torch.utils.data import DataLoader\n\n # Load and preprocess the data\n transform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.5,), (0.5,))\n ])\n\n dataset = datasets.MNIST(root='.\/data', train=True, download=True, transform=transform)\n dataloader = DataLoader(dataset, batch_size=64, shuffle=True)\n <\/code>\n <\/pre>\n2.3 Defining the Generator and Discriminator<\/h3>\n
\n Next, we will define the two key components of GAN: the Generator and the Discriminator. Here, the Generator takes random noise as input to generate images, and the Discriminator takes images as input to determine whether they are real or fake.\n <\/p>\n
\n \n import torch.nn as nn\n\n class 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),\n nn.Tanh()\n )\n\n def forward(self, z):\n return self.model(z).view(-1, 1, 28, 28)\n\n class 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()\n )\n\n def forward(self, img):\n return self.model(img)\n <\/code>\n <\/pre>\n2.4 Initializing the Model and Setting Loss Function, Optimizer<\/h3>\n
\n We will initialize the Generator and Discriminator and specify the loss function and optimizers. We will use CrossEntropyLoss and the Adam optimizer.\n <\/p>\n
\n \n generator = Generator()\n discriminator = Discriminator()\n\n ad = torch.optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n ag = torch.optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n\n criterion = nn.BCELoss()\n <\/code>\n <\/pre>\n2.5 Training the GAN<\/h3>\n
\n Now, let’s train the GAN. During each epoch, we train the Generator and Discriminator, and we can see the generated images.\n <\/p>\n
\n \n import matplotlib.pyplot as plt\n import numpy as np\n\n def train_gan(generator, discriminator, criterion, ag, ad, dataloader, epochs=50):\n for epoch in range(epochs):\n for real_imgs, _ in dataloader:\n batch_size = real_imgs.size(0)\n\n # Generate real images and labels\n real_labels = torch.ones(batch_size, 1)\n noise = torch.randn(batch_size, 100)\n fake_imgs = generator(noise)\n fake_labels = torch.zeros(batch_size, 1)\n\n # Train the Discriminator\n discriminator.zero_grad()\n real_loss = criterion(discriminator(real_imgs), real_labels)\n fake_loss = criterion(discriminator(fake_imgs.detach()), fake_labels)\n d_loss = real_loss + fake_loss\n d_loss.backward()\n ad.step()\n\n # Train the Generator\n generator.zero_grad()\n g_loss = criterion(discriminator(fake_imgs), real_labels)\n g_loss.backward()\n ag.step()\n\n print(f'Epoch [{epoch + 1}\/{epochs}], D Loss: {d_loss.item():.4f}, G Loss: {g_loss.item():.4f}')\n\n # Save generated images\n if (epoch + 1) % 10 == 0:\n save_generated_images(generator, epoch + 1)\n\n def save_generated_images(generator, epoch):\n noise = torch.randn(64, 100)\n generated_imgs = generator(noise)\n generated_imgs = generated_imgs.detach().numpy()\n generated_imgs = (generated_imgs + 1) \/ 2 # Rescale to [0, 1]\n\n fig, axs = plt.subplots(8, 8, figsize=(8, 8))\n for i, ax in enumerate(axs.flat):\n ax.imshow(generated_imgs[i][0], cmap='gray')\n ax.axis('off')\n plt.savefig(f'generated_images_epoch_{epoch}.png')\n plt.close()\n\n train_gan(generator, discriminator, criterion, ag, ad, dataloader, epochs=50)\n <\/code>\n <\/pre>\n2.6 Checking the Results<\/h3>\n
\n After training is completed, check the generated images. As GANs undergo iterative training, they become capable of generating data images that increasingly resemble real ones. Ultimately, the performance of GANs is evaluated by the quality of the generated images. If the training goes well, the generated images will have unfamiliar yet beautiful forms.\n <\/p>\n
3. Conclusion<\/h2>\n
\n In this post, we explained how to implement GANs using PyTorch. I hope you were able to experience creating your own GAN along with the basic concepts of GANs and actual code. GANs are powerful tools, but building a robust model requires diverse and in-depth research. We invite you into the world of GANs that create beautiful and creative results!\n <\/p>\n
4. References<\/h2>\n\n- Ian Goodfellow et al. “Generative Adversarial Networks”. NIPS 2014.<\/li>\n
- PyTorch Documentation: https:\/\/pytorch.org\/docs\/stable\/index.html<\/a><\/li>\n
- GANs in Action book<\/li>\n<\/ul>\n
<\/body><\/p>\n","protected":false},"excerpt":{"rendered":"