기본적인 GAN 모델 구현 (PyTorch & TensorFlow)

기본적인 GAN 모델 구현 (PyTorch & TensorFlow)

1. 생성적 적대 신경망(GAN)이란?

생성적 적대 신경망(Generative Adversarial Network, GAN)은 2014년 Ian Goodfellow와 동료들에 의해 제안된 신경망 모델입니다. GAN은 생성자(Generator)와 판별자(Discriminator)라는 두 개의 신경망이 서로 경쟁하면서 학습하는 구조를 가집니다.

• 생성자(Generator): 랜덤 노이즈에서 진짜 같은 데이터를 생성하는 역할을 합니다.
• 판별자(Discriminator): 입력 데이터가 실제(real)인지 생성된(fake) 데이터인지 판별하는 역할을 합니다.

두 네트워크가 서로 적대적으로 학습하며 점점 더 사실적인 데이터를 생성하는 방향으로 발전합니다.

2. 기본적인 GAN 모델 구조

GAN의 학습 과정은 다음과 같습니다:

1. 생성자는 랜덤 노이즈를 입력받아 가짜 데이터를 생성합니다.
2. 판별자는 가짜 데이터와 실제 데이터를 입력받아 분류합니다.
3. 판별자의 손실을 최소화하면서도 생성자가 판별자를 속일 수 있도록 학습합니다.
4. 이 과정을 반복하면서 생성자가 점점 더 진짜 같은 데이터를 만들어냅니다.

이제 PyTorch와 TensorFlow를 사용하여 기본적인 GAN 모델을 구현해 보겠습니다.

---

3. PyTorch를 활용한 기본적인 GAN 구현

3.1 필요한 라이브러리 불러오기

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
import torchvision.datasets as datasets
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np

3.2 데이터셋 로드 (MNIST 사용)

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

batch_size = 128

dataset = datasets.MNIST(root="./data", train=True, transform=transform, download=True)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

3.3 생성자(Generator) 구현

class Generator(nn.Module):
    def __init__(self, input_dim):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, 784),
            nn.Tanh()
        )

    def forward(self, x):
        return self.model(x).view(-1, 1, 28, 28)

3.4 판별자(Discriminator) 구현

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(784, 512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.model(x.view(-1, 784))

3.5 학습 루프 구현

def train_GAN(epochs, generator, discriminator, optimizer_G, optimizer_D, loss_function, dataloader, latent_dim):
    for epoch in range(epochs):
        for real_images, _ in dataloader:
            batch_size = real_images.shape[0]
            real_images = real_images.view(batch_size, -1)

            # 랜덤 노이즈 생성
            noise = torch.randn(batch_size, latent_dim)
            fake_images = generator(noise)

            # 판별자 학습
            real_labels = torch.ones(batch_size, 1)
            fake_labels = torch.zeros(batch_size, 1)

            real_loss = loss_function(discriminator(real_images), real_labels)
            fake_loss = loss_function(discriminator(fake_images.detach()), fake_labels)
            d_loss = real_loss + fake_loss

            optimizer_D.zero_grad()
            d_loss.backward()
            optimizer_D.step()

            # 생성자 학습
            g_loss = loss_function(discriminator(fake_images), real_labels)

            optimizer_G.zero_grad()
            g_loss.backward()
            optimizer_G.step()

        print(f"Epoch [{epoch+1}/{epochs}] - D Loss: {d_loss.item():.4f} - G Loss: {g_loss.item():.4f}")

3.6 모델 학습 실행

latent_dim = 100
generator = Generator(latent_dim)
discriminator = Discriminator()

loss_function = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=0.0002)
optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002)

train_GAN(epochs=50, generator=generator, discriminator=discriminator, optimizer_G=optimizer_G, optimizer_D=optimizer_D, loss_function=loss_function, dataloader=dataloader, latent_dim=latent_dim)

---

4. TensorFlow를 활용한 기본적인 GAN 구현

TensorFlow 및 Keras를 사용한 GAN 구현은 PyTorch와 유사한 방식으로 진행됩니다. 주요 단계는 다음과 같습니다.

1. 데이터셋 로드
2. 생성자(Generator) 및 판별자(Discriminator) 구현
3. 학습 과정 구현

4.1 TensorFlow GAN 모델 코드

import tensorflow as tf
from tensorflow.keras import layers

latent_dim = 100

def build_generator():
    model = tf.keras.Sequential([
        layers.Dense(256, activation="relu", input_dim=latent_dim),
        layers.Dense(512, activation="relu"),
        layers.Dense(1024, activation="relu"),
        layers.Dense(28*28, activation="tanh"),
        layers.Reshape((28, 28, 1))
    ])
    return model

def build_discriminator():
    model = tf.keras.Sequential([
        layers.Flatten(input_shape=(28, 28, 1)),
        layers.Dense(512, activation="leaky_relu"),
        layers.Dense(256, activation="leaky_relu"),
        layers.Dense(1, activation="sigmoid")
    ])
    return model

이후 학습 과정을 정의하고 실행하면 GAN 모델이 점진적으로 발전하는 모습을 확인할 수 있습니다.

---

5. 마무리

본 포스팅에서는 PyTorch와 TensorFlow를 활용하여 기본적인 GAN 모델을 구현하는 방법을 소개했습니다. GAN을 활용하면 다양한 생성 모델을 개발할 수 있으며, 향후 심화된 아키텍처(GAN 변형 모델)도 탐색해볼 수 있습니다.