파이토치를 활용한 GAN 딥러닝, 생성 모델링이란

딥러닝의 발전은 다양한 분야에 많은 영향을 미치고 있으며, 특히 생성 모델링(Generative Modeling)은 데이터 생성의 새로운 지평을 열고 있습니다. 생성적 적대 신경망(Generative Adversarial Networks, GAN)은 이러한 생성 모델링 중에서 가장 유명한 모델 중 하나로, 원시 데이터에서 새로운 데이터를 생성하는 능력이 뛰어납니다. 본 글에서는 GAN의 주요 개념, 파이토치(PyTorch)를 활용한 구현 방법 및 이를 통한 실습 예제를 자세히 설명하고자 합니다.

1. GAN의 기초

GAN은 두 개의 신경망으로 구성되어 있으며, 이들은 생성자(Generator)와 판별자(Discriminator)라는 역할을 수행합니다. 이 두 신경망은 적대적 관계에 있으며, 동시에 학습합니다.

1.1 생성자(Generator)

생성자는 무작위 노이즈(input noise)로부터 진짜와 같은 데이터를 생성하는 역할을 합니다. 이는 데이터의 분포를 학습하여 새로운 데이터를 생성하는 것이며, 목표는 판별자를 속이는 것입니다.

1.2 판별자(Discriminator)

판별자는 입력 데이터가 진짜인지, 생성자에 의해 만들어진 것인지를 판단하는 역할을 합니다. 이 또한 신경망으로 구현되며, 판별자의 목표는 가능한 한 정확하게 진짜와 가짜를 구분하는 것입니다.

1.3 적대적 학습 과정

GAN의 학습 과정은 다음과 같은 단계로 이루어집니다:

생성자는 무작위 노이즈로부터 데이터를 생성합니다.
판별자는 진짜 데이터와 생성자가 만든 가짜 데이터를 입력 받아 이를 구분하려 합니다.
생성자는 판별자가 가짜 데이터를 진짜로 잘못 판단하도록 최적화됩니다.
판별자는 가짜 데이터를 정확히 구분하기 위해 최적화됩니다.

이러한 과정은 여러 번 반복되며, 점차적으로 생성자는 더 우수한 데이터를 생성하게 되고, 판별자는 더 정교한 판단을 하게 됩니다.

2. GAN의 구조

GAN은 다음과 같은 구조를 가집니다.

입력 노이즈: 일반적으로 정규분포를 따르는 잡음 벡터가 입력됩니다.
생성자 네트워크: 입력 노이즈를 받아들이고, 이를 통해 가짜 샘플을 생성합니다.
판별자 네트워크: 생성된 가짜 샘플과 실제 샘플을 받아들여, 진짜인지 가짜인지 판별합니다.

3. 파이토치를 활용한 GAN 구현

이제 파이토치를 사용하여 GAN을 구현해보겠습니다. 파이토치는 딥러닝 모델을 구축하고 학습하는 데 매우 유용한 라이브러리입니다.

3.1 필수 라이브러리 설치


!pip install torch torchvision matplotlib

3.2 생성자 및 판별자 네트워크 정의

먼저 생성자와 판별자 네트워크를 정의합니다. 이들은 각각 속성에 따라 설계됩니다.


import torch
import torch.nn as nn

# 생성자 정의
class Generator(nn.Module):
    def __init__(self, input_size, output_size):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_size, 128),
            nn.ReLU(),
            nn.Linear(128, 256),
            nn.ReLU(),
            nn.Linear(256, output_size),
            nn.Tanh()  # 출력값을 -1과 1 사이로 제한
        )
    
    def forward(self, z):
        return self.model(z)

# 판별자 정의
class Discriminator(nn.Module):
    def __init__(self, input_size):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_size, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 1),
            nn.Sigmoid()  # 출력값을 0과 1 사이로 제한
        )
    
    def forward(self, x):
        return self.model(x)

3.3 데이터 준비

MNIST 데이터셋을 사용하여 생성 모델을 학습할 것입니다. MNIST는 손으로 쓴 숫자 이미지 데이터셋으로, 0부터 9까지의 숫자가 포함되어 있습니다.


from torchvision import datasets, transforms

# 데이터셋 다운로드 및 변환
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))  # 정규화
])

mnist = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(mnist, batch_size=64, shuffle=True)

3.4 손실 함수 및 최적화 기법 정의

GAN은 생성자와 판별자가 서로 경합하는 구조이므로 각각의 손실 함수를 정의합니다. 우리는 이진 크로스 엔트로피 손실을 사용할 것입니다.


# 손실 함수 및 최적화 기법 설정
criterion = nn.BCELoss()
lr = 0.0002
beta1 = 0.5

generator = Generator(input_size=100, output_size=784).cuda()
discriminator = Discriminator(input_size=784).cuda()

optimizer_G = torch.optim.Adam(generator.parameters(), lr=lr, betas=(beta1, 0.999))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=lr, betas=(beta1, 0.999))

3.5 GAN 학습 과정 구현

이제 GAN의 학습 과정을 구현하겠습니다. 각 배치마다 생성자 및 판별자를 업데이트하는 방법을 포함합니다.


num_epochs = 50

for epoch in range(num_epochs):
    for i, (imgs, _) in enumerate(dataloader):
        # 진짜 이미지를 위한 레이블 (1)
        real_imgs = imgs.view(imgs.size(0), -1).cuda()
        real_labels = torch.ones((imgs.size(0), 1)).cuda()

        # 가짜 이미지를 위한 레이블 (0)
        noise = torch.randn((imgs.size(0), 100)).cuda()
        fake_imgs = generator(noise)
        fake_labels = torch.zeros((imgs.size(0), 1)).cuda()

        # 판별자 업데이트
        optimizer_D.zero_grad()
        outputs = discriminator(real_imgs)
        d_loss_real = criterion(outputs, real_labels)
        d_loss_real.backward()

        outputs = discriminator(fake_imgs.detach())
        d_loss_fake = criterion(outputs, fake_labels)
        d_loss_fake.backward()

        optimizer_D.step()
        
        # 생성자 업데이트
        optimizer_G.zero_grad()
        outputs = discriminator(fake_imgs)
        g_loss = criterion(outputs, real_labels)
        g_loss.backward()
        optimizer_G.step()

    print(f'Epoch [{epoch+1}/{num_epochs}], d_loss: {d_loss_real.item() + d_loss_fake.item()}, g_loss: {g_loss.item()}')

3.6 생성된 이미지 시각화

학습이 끝난 후에 생성자에 의해 생성된 이미지를 시각화해보겠습니다.


import matplotlib.pyplot as plt

# 이미지 생성
noise = torch.randn(16, 100).cuda()
fake_imgs = generator(noise).view(-1, 1, 28, 28).cpu().data

# 이미지 시각화
plt.figure(figsize=(10, 10))
for i in range(16):
    plt.subplot(4, 4, i+1)
    plt.imshow(fake_imgs[i].squeeze(), cmap='gray')
    plt.axis('off')
plt.show()

4. 결론

본 포스트에서는 GAN의 이론적 배경과 더불어 파이토치를 활용한 기본적인 GAN 모델의 구현 과정을 살펴보았습니다. GAN은 생성 모델링 분야에서 많은 혁신을 가져왔으며, 앞으로의 발전이 기대됩니다. 본 예제를 통해 GAN의 기본 원리와 파이토치에서의 구현 방법을 이해하는 데 도움이 되었기를 바랍니다.

GAN의 발전은 우리가 데이터 생성 및 처리하는 방식을 변화시킬 것입니다. 앞으로도 GAN과 같은 생성적 모델의 연구가 더욱 활발히 이루어지길 기대합니다.