\n GAN (Generative Adversarial Network) is a type of generative model where two neural networks interact to generate new data. GANs are primarily used in various fields such as image generation, text generation, and music generation. In this article, we will implement GAN using the PyTorch library and detail the process of generating artwork that can be used in art exhibitions.\n <\/p>\n
\n GAN consists of two models, the Generator and the Discriminator. The Generator creates data based on random input, while the Discriminator distinguishes whether the given data is real or generated. The learning process of GAN is as follows.\n <\/p>\n
\n This process results in the Discriminator becoming increasingly sophisticated, ensuring that the Generator cannot produce overly simplistic fake images.\n <\/p>\n
\n Before implementing GAN, you first need to install PyTorch. You can do this using the following command.\n <\/p>\n
\n \n pip install torch torchvision\n <\/code>\n <\/pre>\n3. Preparing Data<\/h2>\n
\n To generate images of artworks, a dataset is required. In this practice, we will use the CIFAR-10 dataset. This dataset consists of images from 10 classes and can be used to build a dataset related to pictorial arts. It can be easily used with built-in functions in PyTorch.\n <\/p>\n
3.1 CIFAR-10 Dataset<\/h3>\n\n \n import torchvision.transforms as transforms\n import torchvision.datasets as datasets\n from torch.utils.data import DataLoader\n\n # Data Preprocessing\n transform = transforms.Compose([\n transforms.Resize(64),\n transforms.CenterCrop(64),\n transforms.ToTensor(),\n transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),\n ])\n\n # Load CIFAR-10 dataset\n dataset = datasets.CIFAR10(root='.\/data', train=True, download=True, transform=transform)\n dataloader = DataLoader(dataset, batch_size=128, shuffle=True, num_workers=2)\n <\/code>\n <\/pre>\n4. Implementing the GAN Model<\/h2>\n
\n The GAN model requires two neural networks to define the Generator and the Discriminator. The Generator generates images based on random noise, while the Discriminator determines the authenticity of the images.\n <\/p>\n
4.1 Generator Model<\/h3>\n\n \n import torch\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, 3*64*64),\n nn.Tanh(),\n )\n\n def forward(self, z):\n z = self.model(z)\n return z.view(-1, 3, 64, 64)\n <\/code>\n <\/pre>\n4.2 Discriminator Model<\/h3>\n\n \n class Discriminator(nn.Module):\n def __init__(self):\n super(Discriminator, self).__init__()\n self.model = nn.Sequential(\n nn.Linear(3*64*64, 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 img = img.view(-1, 3*64*64)\n return self.model(img)\n <\/code>\n <\/pre>\n5. Setting Loss Function and Optimizers<\/h2>\n
\n For training the GAN, you need to set the loss function and optimizers. Typically, Binary Cross Entropy Loss is used, and Adam optimization can be employed.\n <\/p>\n
\n \n import torch.optim as optim\n\n generator = Generator()\n discriminator = Discriminator()\n\n criterion = nn.BCELoss()\n optimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))\n <\/code>\n <\/pre>\n6. Training the GAN<\/h2>\n
\n The training process of GAN involves alternating learning between the Generator and Discriminator. The code below represents the main loop for training the GAN.\n <\/p>\n
\n \n import numpy as np\n import matplotlib.pyplot as plt\n\n def train_gan(num_epochs):\n for epoch in range(num_epochs):\n for i, (imgs, _) in enumerate(dataloader):\n # Real image labels: 1\n real_labels = torch.ones(imgs.size(0), 1)\n # Fake image labels: 0\n fake_labels = torch.zeros(imgs.size(0), 1)\n\n # Discriminator training\n optimizer_D.zero_grad()\n outputs = discriminator(imgs)\n d_loss_real = criterion(outputs, real_labels)\n d_loss_real.backward()\n\n z = torch.randn(imgs.size(0), 100)\n fake_images = generator(z)\n outputs = discriminator(fake_images.detach())\n d_loss_fake = criterion(outputs, fake_labels)\n d_loss_fake.backward()\n\n optimizer_D.step()\n d_loss = d_loss_real + d_loss_fake\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 (i % 100 == 0):\n print(f'Epoch [{epoch}\/{num_epochs}], Step [{i}\/{len(dataloader)}], d_loss: {d_loss.item()}, g_loss: {g_loss.item()}')\n\n train_gan(num_epochs=20)\n <\/code>\n <\/pre>\n7. Visualizing Results<\/h2>\n
\n After training the model, you can visualize the generated images. The code below shows the process of saving and visualizing the generated images.\n <\/p>\n
\n \n def plot_generated_images(num_images):\n z = torch.randn(num_images, 100)\n generated_images = generator(z).detach().numpy()\n generated_images = (generated_images + 1) \/ 2 # (-1, 1) -> (0, 1)\n \n fig, axes = plt.subplots(1, num_images, figsize=(15, 5))\n for i in range(num_images):\n axes[i].imshow(generated_images[i].transpose(1, 2, 0))\n axes[i].axis('off')\n plt.show()\n\n plot_generated_images(10)\n <\/code>\n <\/pre>\n8. Conclusion<\/h2>\n
\n In this article, we explored the basic concepts and implementation process of GAN deep learning using PyTorch. GAN can generate new images, such as artworks, which can be utilized in events like art exhibitions. We expect that GAN technology will continue to evolve, providing various creative possibilities.\n <\/p>\n
9. Additional Resources<\/h2>\n
\n Below are additional resources on GAN and related topics.\n <\/p>\n