Generative Adversarial Networks (GANs) are considered one of the most innovative advancements in deep learning. GAN consists of two neural networks: a Generator and a Discriminator. The Generator creates data, while the Discriminator determines whether the data is real or fake. This competitive structure helps to enhance each other’s performance. In this course, we will build a GAN using PyTorch and perform data generation around the theme of ‘The Literary Club for Bad Criminals’ in an interesting way.<\/p>\n
The operation of GAN works as follows:<\/p>\n
Install PyTorch and other necessary libraries. Then you will need to choose the dataset to prepare the data for this process. In this example, we will use the MNIST dataset to generate images of numbers. The MNIST dataset is composed of images of handwritten digits.<\/p>\n
pip install torch torchvision<\/code><\/pre>\n2.2 Loading the Dataset<\/h3>\nimport torch\nfrom torchvision import datasets, transforms\nfrom torch.utils.data import DataLoader\n\n# Load MNIST Dataset\ntransform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.5,), (0.5,))\n])\n\nmnist_dataset = datasets.MNIST(root='.\/data', train=True, download=True, transform=transform)\ndata_loader = DataLoader(dataset=mnist_dataset, batch_size=64, shuffle=True)<\/code><\/pre>\n3. Constructing the GAN Model<\/h2>\n
We define the Generator and Discriminator models to implement the Generative Adversarial Network.<\/p>\n
3.1 Generator Model<\/h3>\nimport 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, 28 * 28), # MNIST image size\n nn.Tanh() # Adjust the pixel value range of generated images to -1 ~ 1\n )\n\n def forward(self, z):\n img = self.model(z)\n img = img.view(img.size(0), 1, 28, 28) # Transform into image shape\n return img<\/code><\/pre>\n3.2 Discriminator Model<\/h3>\nclass Discriminator(nn.Module):\n def __init__(self):\n super(Discriminator, self).__init__()\n self.model = nn.Sequential(\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() # Output value between 0 and 1\n )\n\n def forward(self, img):\n img_flat = img.view(img.size(0), -1) # Flatten the image\n validity = self.model(img_flat)\n return validity<\/code><\/pre>\n4. Training Process of GAN<\/h2>\n
The training process of GAN is carried out as follows:<\/p>\n
\n- Provide real images and generated images to the Discriminator to calculate its loss.<\/li>\n
- Update the Generator to make the generated images closer to the real ones.<\/li>\n
- Repeat this process to help each network improve.<\/li>\n<\/ul>\n
4.1 Defining Loss Function and Optimizers<\/h3>\nimport torch.optim as optim\n\n# Create instances of Generator and Discriminator\ngenerator = Generator()\ndiscriminator = Discriminator()\n\n# Set loss function and optimizer\nadversarial_loss = nn.BCELoss()\noptimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))\noptimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))<\/code><\/pre>\n4.2 Training Loop<\/h3>\nnum_epochs = 200\nfor epoch in range(num_epochs):\n for i, (imgs, _) in enumerate(data_loader):\n # Label for real data: 1\n real_imgs = imgs\n valid = torch.ones(imgs.size(0), 1) # Ground truth for real images\n fake = torch.zeros(imgs.size(0), 1) # Ground truth for fake images\n\n # Train Discriminator\n optimizer_D.zero_grad()\n z = torch.randn(imgs.size(0), 100) # Sample random noise\n generated_imgs = generator(z) # Generated images\n real_loss = adversarial_loss(discriminator(real_imgs), valid)\n fake_loss = adversarial_loss(discriminator(generated_imgs.detach()), fake)\n d_loss = (real_loss + fake_loss) \/ 2\n d_loss.backward()\n optimizer_D.step()\n\n # Train Generator\n optimizer_G.zero_grad()\n g_loss = adversarial_loss(discriminator(generated_imgs), valid)\n g_loss.backward()\n optimizer_G.step()\n\n print(f'Epoch {epoch}\/{num_epochs} | D Loss: {d_loss.item()} | G Loss: {g_loss.item()}')<\/code><\/pre>\n5. Visualizing Results<\/h2>\n
After training is completed, we visualize the generated images to check the results.<\/p>\n
import matplotlib.pyplot as plt\n\n# Visualize generated images\ndef show_generated_images(generator, num_images=16):\n z = torch.randn(num_images, 100) # Sample random noise\n generated_images = generator(z)\n generated_images = generated_images.detach().numpy()\n\n fig, axs = plt.subplots(4, 4, figsize=(10, 10))\n for i in range(4):\n for j in range(4):\n axs[i, j].imshow(generated_images[i * 4 + j, 0], cmap='gray')\n axs[i, j].axis('off')\n plt.show()\n\nshow_generated_images(generator)<\/code><\/pre>\nIn this way, you can build and train a GAN and verify the generated images. The potential applications of GANs are vast, and they can facilitate creative tasks. Now, you can take a step closer to the world of GANs!<\/p>\n
6. Conclusion<\/h2>\n
Generative Adversarial Networks are a very interesting area of deep learning, actively used in many research and development projects. In this course, we explored the basic principles and structures of GAN using PyTorch and covered the process of building and training deep learning models. I hope you gain a deep understanding and interest in GAN through this course and that it greatly helps you in your future deep learning journey.<\/p>\n