파이토치를 활용한 GAN 딥러닝, 컨트롤러 훈련

안녕하세요! 이번 글에서는 파이토치를 활용하여 GAN(Generative Adversarial Networks)을 구현하고, 컨트롤러 훈련에 대해 자세히 알아보겠습니다. GAN은 두 개의 신경망, 즉 생성기(Generator)와 판별기(Discriminator)가 서로 경쟁하는 구조로, 진짜 같은 데이터 생성을 목적으로 합니다.

1. GAN의 기본 구조

GAN의 기본 구조는 다음과 같습니다:

• 생성기(Generator): 랜덤한 노이즈를 입력으로 받아서 가짜 데이터를 생성합니다.
• 판별기(Discriminator): 입력 데이터를 실제 데이터와 가짜 데이터로 분류합니다.

이 두 네트워크는 서로 경쟁하면서 훈련되며, 결과적으로 생성기는 점점 더 사실적인 데이터를 만들고 판별기는 더 정확한 판별을 하게 됩니다.

2. GAN의 훈련 과정

GAN의 훈련 과정은 아래와 같은 단계로 진행됩니다:

1. 임의의 노이즈 벡터를 생성기로 입력하여 가짜 데이터를 생성합니다.
2. 가짜 데이터와 실제 데이터를 판별기에 입력하여 진짜/가짜 확률을 계산합니다.
3. 판별기의 손실을 기반으로 판별기를 훈련합니다.
4. 생성기의 손실을 기반으로 생성기를 훈련합니다.
5. 1~4 단계를 반복합니다.

3. 파이토치로 GAN 구현하기

이제 파이토치를 사용해 GAN을 구현해 보겠습니다. 다음은 기본 GAN 구조의 구현 예제입니다.

파이토치 설치

먼저, 파이토치를 설치해야 합니다. 파이썬이 설치된 환경에서 다음 명령어로 설치할 수 있습니다:

pip install torch torchvision

모델 정의

먼저 생성기와 판별기를 정의하겠습니다.

import torch
import torch.nn as nn
import torch.optim as optim

# 생성기
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(100, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, 1024),
            nn.ReLU(),
            nn.Linear(1024, 28 * 28),
            nn.Tanh()
        )

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

# 판별기
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Flatten(),
            nn.Linear(28 * 28, 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)

훈련 함수 정의

훈련 과정을 정의하는 함수도 필요합니다:

def train_gan(generator, discriminator, data_loader, num_epochs=100, learning_rate=0.0002):
    criterion = nn.BCELoss()
    optimizer_g = optim.Adam(generator.parameters(), lr=learning_rate)
    optimizer_d = optim.Adam(discriminator.parameters(), lr=learning_rate)

    for epoch in range(num_epochs):
        for real_data, _ in data_loader:
            batch_size = real_data.size(0)
            real_labels = torch.ones(batch_size, 1)
            fake_labels = torch.zeros(batch_size, 1)

            # 판별기 훈련
            optimizer_d.zero_grad()
            outputs = discriminator(real_data)
            d_loss_real = criterion(outputs, real_labels)
            d_loss_real.backward()

            noise = torch.randn(batch_size, 100)
            fake_data = generator(noise)
            outputs = discriminator(fake_data.detach())
            d_loss_fake = criterion(outputs, fake_labels)
            d_loss_fake.backward()

            optimizer_d.step()

            # 생성기 훈련
            optimizer_g.zero_grad()
            outputs = discriminator(fake_data)
            g_loss = criterion(outputs, real_labels)
            g_loss.backward()

            optimizer_g.step()

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

데이터셋 준비

MNIST 데이터셋을 사용할 것입니다. 데이터를 로드하는 코드를 작성합니다.

from torchvision import datasets, transforms
from torch.utils.data import DataLoader

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

dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
data_loader = DataLoader(dataset, batch_size=64, shuffle=True)

4. GAN 훈련하기

모델과 데이터 로더가 준비되었으니, GAN을 훈련해보겠습니다.

generator = Generator()
discriminator = Discriminator()

train_gan(generator, discriminator, data_loader, num_epochs=50)

5. 결과 시각화하기

훈련이 완료된 후, 생성한 이미지를 시각화해 보겠습니다.

import matplotlib.pyplot as plt

def show_generated_images(generator, num_images=25):
    noise = torch.randn(num_images, 100)
    generated_images = generator(noise).detach().cpu().numpy()
    
    plt.figure(figsize=(5, 5))
    for i in range(num_images):
        plt.subplot(5, 5, i + 1)
        plt.imshow(generated_images[i][0], cmap='gray')
        plt.axis('off')
    plt.show()

show_generated_images(generator)

6. 컨트롤러 훈련

이제 GAN을 사용하여 컨트롤러 훈련을 진행해 보겠습니다. 컨트롤러 훈련은 주어진 환경에서 특정 목표를 달성하기 위해 최적의 행동을 학습하는 과정입니다. 여기서는 GAN을 이용하여 이 과정을 어떻게 수행할 수 있는지를 알아보겠습니다.

컨트롤러 훈련에 있어 GAN의 활용은 흥미로운 접근 방식입니다. GAN의 생성기는 다양한 시나리오에서의 행동을 생성할 수 있는 역할을 하고, 판별기는 이러한 행동이 얼마나 목표에 부합하는지 평가합니다.

아래는 GAN을 활용하여 간단한 컨트롤러를 훈련하는 예제 코드입니다.

# 컨트롤러 네트워크 정의
class Controller(nn.Module):
    def __init__(self):
        super(Controller, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(100, 256),
            nn.ReLU(),
            nn.Linear(256, 3)  # 예를 들어 행동의 차원 수(3D 행동)
        )

    def forward(self, x):
        return self.model(x)

# 훈련 과정 정의
def train_controller(gan, controller, num_epochs=100):
    optimizer_c = optim.Adam(controller.parameters(), lr=0.001)

    for epoch in range(num_epochs):
        noise = torch.randn(64, 100)
        actions = controller(noise)
        
        # GAN의 생성기로 행동을 생성
        generated_data = gan.generator(noise)
        
        # 행동을 평가하고 손실 계산
        loss = calculate_loss(generated_data, actions)  # 손실함수는 사용자의 정의 필요
        optimizer_c.zero_grad()
        loss.backward()
        optimizer_c.step()

        if epoch % 10 == 0:
            print(f'Epoch [{epoch}/{num_epochs}], Controller Loss: {loss.item()}')

# 컨트롤러 훈련 시작
controller = Controller()
train_controller(generator, controller)

7. 마무리

이번 포스트에서는 파이토치로 GAN을 구현하고, 이를 바탕으로 간단한 컨트롤러를 훈련하는 과정을 살펴보았습니다. GAN은 실제와 유사한 데이터를 생성하는 데 매우 유용하며, 다양한 적용 가능성도 가지고 있습니다. 컨트롤러 훈련을 통해 GAN의 활용 범위를 확장할 수 있음을 보여드렸습니다.

더 나아가 GAN은 이미지 생성 외에도 텍스트, 비디오 생성 등 다양한 분야에서 활용될 수 있으므로, 이 개념을 활용해 나만의 프로젝트에 도전해 보시기 바랍니다!