GAN (Generative Adversarial Networks) is an innovative deep learning model proposed by Ian Goodfellow in 2014, operating by having a generator model and a discriminator model compete against each other during training. The basic components of GAN are the generator and the discriminator. The generator tries to create data that is similar to real data, while the discriminator determines whether the given data is real or generated. Through the competition between these two models, the generator increasingly produces data that resembles real data.<\/p>\n
The generator is a neural network that takes a random noise vector as input and generates data similar to real data. This network typically uses either a multilayer perceptron or a convolutional neural network.<\/p>\n
The discriminator is a neural network that judges whether the input data is real or generated. Its ability to effectively distinguish between fake data created by the generator and real data is crucial.<\/p>\n
The loss function of GAN is divided into the loss of the generator and the loss of the discriminator. The goal of the generator is to deceive the discriminator, while the goal of the discriminator is to accurately distinguish the generated data.<\/p>\n
The training process of GAN is iterative and consists of the following steps:<\/p>\n
GAN is used in various fields, including:<\/p>\n
Structured data is organized in a format that can easily be represented in a relational database. On the other hand, unstructured data refers to data without a unique form or structure, such as text, images, and videos. GAN is primarily used for unstructured data but can also be utilized for structured data.<\/p>\n
Below is a simple implementation example of GAN using PyTorch. In this example, we will generate handwritten digits using the MNIST dataset.<\/p>\n
First, install and import the necessary libraries.<\/p>\n
!pip install torch torchvision matplotlib<\/code><\/pre>\n6.2 Preparing the Dataset<\/h3>\n
Load the MNIST dataset and transform it to a tensor.<\/p>\n
import torch\nimport torchvision\nimport torchvision.transforms as transforms\n\ntransform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.5,), (0.5,)),\n])\n\ntrain_dataset = torchvision.datasets.MNIST(root='.\/data', train=True, download=True, transform=transform)\ntrain_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)<\/code><\/pre>\n6.3 Model Definition<\/h3>\n
Define the generator and discriminator models.<\/p>\n
import torch.nn as nn\n\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, 784), # 28x28 images like MNIST\n nn.Tanh(),\n )\n\n def forward(self, x):\n return self.model(x)\n\nclass Discriminator(nn.Module):\n def __init__(self):\n super(Discriminator, self).__init__()\n self.model = nn.Sequential(\n nn.Linear(784, 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, x):\n return self.model(x)<\/code><\/pre>\n6.4 Setting Loss Function and Optimizer<\/h3>\n
Use BCELoss as the loss function and proceed with learning using the Adam optimizer.<\/p>\n
criterion = nn.BCELoss()\ngenerator = Generator()\ndiscriminator = Discriminator()\n\noptimizer_G = torch.optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))\noptimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))<\/code><\/pre>\n6.5 Model Training<\/h3>\n
Perform model training. At the end of each epoch, generated samples can be checked.<\/p>\n
import matplotlib.pyplot as plt\n\nnum_epochs = 100\nfor epoch in range(num_epochs):\n for i, (real_images, _) in enumerate(train_loader):\n batch_size = real_images.size(0)\n \n # Label generation\n real_labels = torch.ones(batch_size, 1)\n fake_labels = torch.zeros(batch_size, 1)\n\n # Discriminator training\n optimizer_D.zero_grad()\n outputs = discriminator(real_images.view(batch_size, -1))\n d_loss_real = criterion(outputs, real_labels)\n d_loss_real.backward()\n\n noise = torch.randn(batch_size, 100)\n fake_images = generator(noise)\n outputs = discriminator(fake_images.detach())\n d_loss_fake = criterion(outputs, fake_labels)\n d_loss_fake.backward()\n optimizer_D.step()\n\n # Generator training\n optimizer_G.zero_grad()\n outputs = discriminator(fake_images)\n g_loss = criterion(outputs, real_labels)\n g_loss.backward()\n optimizer_G.step()\n\n if (epoch+1) % 10 == 0:\n print(f'Epoch [{epoch+1}\/{num_epochs}], d_loss: {d_loss_real.item() + d_loss_fake.item():.4f}, g_loss: {g_loss.item():.4f}')\n # Check generated images\n with torch.no_grad():\n fake_images = generator(noise).view(-1, 1, 28, 28)\n grid = torchvision.utils.make_grid(fake_images, nrow=8, normalize=True)\n plt.imshow(grid.permute(1, 2, 0).numpy(), cmap='gray')\n plt.show()<\/code><\/pre>\n6.6 Checking Results<\/h3>\n
As training progresses, the generator increasingly produces realistic handwritten digits, demonstrating the performance of GAN.<\/p>\n
7. Conclusion<\/h2>\n
This article covered the overview of GAN, its components, training process, and implementation methods using PyTorch. GAN exhibits excellent performance in generating unstructured data and can be applied in various fields. With advancements in technology, the future possibilities are endless.<\/p>\n
8. References<\/h2>\n
1. Ian Goodfellow et al., “Generative Adversarial Networks”, NeurIPS 2014.<\/p>\n
2. PyTorch Documentation – https:\/\/pytorch.org\/docs\/stable\/index.html<\/a><\/p>\n3. torchvision Documentation – https:\/\/pytorch.org\/vision\/stable\/index.html<\/a><\/p>\n<\/body><\/p>\n","protected":false},"excerpt":{"rendered":"