초보자를 위한 PyTorch에서 GAN을 쉽게 이해하는 방법

I. GAN(생성적 적대 신경망) 소개 A. GAN의 정의와 주요 구성 요소

GAN은 생성자(generator)와 구별자(discriminator)라는 두 개의 신경망으로 이루어진 기계 학습 모델의 한 유형입니다. 이러한 신경망들은 적대적인 과정(adversarial process)으로 훈련됩니다.
생성자 신경망은 잠재 입력 공간(latent input space)에서 현실적으로 보이는 샘플(예: 이미지, 텍스트, 오디오)을 생성하는 역할을 담당합니다.
구별자 신경망은 데이터셋에서 나온 실제 샘플과 생성자에 의해 생성된 가짜 샘플을 구분하는 데에 훈련됩니다.
두 신경망은 적대적인 방식으로 훈련되며, 생성자는 구별자를 속이려고 하고, 구별자는 실제와 가짜 샘플을 올바르게 분류하려고 합니다.

B. GAN의 간단한 역사와 진화

GAN은 이안 굿펠로우와 동료들이 2014년에 소개한 생성 모델링의 새로운 접근 방식입니다.
소개 이후로 GAN은 큰 발전을 이루었으며, 이미지 생성, 텍스트 생성, 심지어 오디오 합성과 같은 다양한 분야에 적용되었습니다.
GAN의 진화 과정에서 주목할만한 중요한 성과로는 Conditional GAN(cGAN), Deep Convolutional GAN(DCGAN), Wasserstein GAN(WGAN), Progressive Growing of GAN(PGGAN) 등이 있습니다.

II. PyTorch 환경 설정 A. PyTorch 설치하기

PyTorch는 유연하고 효율적인 딥러닝 모델(생성적 적대 신경망 포함)을 만들고 훈련하기 위한 인기 있는 오픈 소스 라이브러리입니다.
PyTorch를 설치하려면 PyTorch 웹사이트(https://pytorch.org/get-started/locally/)에서 (opens in a new tab) 제공하는 공식 설치 가이드를 따르면 됩니다.
설치 과정은 운영 체제, Python 버전 및 CUDA(GPU를 사용하는 경우) 버전에 따라 다를 수 있습니다.

B. 필요한 라이브러리와 모듈 임포트하기

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

III. GAN 아키텍처 이해하기 A. 생성자 신경망

입력 및 출력 구조
- 생성자 신경망은 잠재 입력 벡터(예: 랜덤 노이즈 벡터)를 입력으로 받고 생성된 샘플(예: 이미지)을 출력합니다.
- 입력 잠재 벡터의 크기와 출력 샘플의 크기는 특정 문제와 원하는 출력에 따라 달라집니다.
신경망 레이어와 활성화 함수
- 생성자 신경망은 특정 문제 영역에 따라 완전 연결 레이어 또는 합성곱 레이어의 시리즈로 구성됩니다.
- 주로 ReLU, Leaky ReLU 또는 tanh 같은 활성화 함수가 생성자 신경망에서 사용됩니다.
생성자의 최적화
- 생성자 신경망은 구별자 신경망을 속일 수 있는 샘플을 생성하도록 훈련됩니다.
- 생성자의 손실 함수는 생성된 샘플을 실제로 클래스화한 구별자의 확률을 최대화하기 위해 설계되었습니다.

B. 구별자 신경망

입력 및 출력 구조
- 구별자 신경망은 데이터셋에서 나온 실제 샘플 또는 생성자에 의해 생성된 샘플을 입력으로 받고, 샘플이 실제인지의 확률을 출력합니다.
- 구별자의 입력 크기는 샘플의 크기(예: 이미지 크기)에 따라 달라지며, 출력은 0과 1 사이의 스칼라 값입니다.
신경망 레이어와 활성화 함수
- 구별자 신경망은 특정 문제 영역에 따라 합성곱 레이어 또는 완전 연결 레이어의 시리즈로 구성됩니다.
- 주로 Leaky ReLU 또는 sigmoid와 같은 활성화 함수가 구별자 신경망에서 사용됩니다.
구별자의 최적화
- 구별자 신경망은 실제 데이터셋에서 나온 샘플을 실제로, 생성된 샘플을 가짜로 올바르게 분류하도록 훈련됩니다.
- 구별자의 손실 함수는 실제와 가짜 샘플을 올바르게 분류하는 확률을 최대화하기 위해 설계되었습니다.

C. 적대적인 훈련 과정

생성자와 구별자의 손실 함수
- 생성자의 손실 함수는 생성된 샘플을 실제로 클래스화한 구별자의 확률을 최대화하기 위해 설계되었습니다.
- 구별자의 손실 함수는 실제와 가짜 샘플을 올바르게 분류하는 확률을 최대화하기 위해 설계되었습니다.
생성자와 구별자의 교대적인 최적화
- 훈련 과정은 생성자와 구별자 신경망의 교대적인 업데이트를 포함합니다.
- 먼저, 구별자를 훈련하여 실제와 가짜 샘플을 올바르게 분류할 수 있도록 합니다.
- 그런 다음, 생성자를 훈련하여 구별자를 속일 수 있는 샘플을 생성할 수 있도록 합니다.
- 이 적대적인 훈련 과정은 생성자와 구별자가 균형에 도달할 때까지 계속됩니다.

IV. PyTorch에서 간단한 GAN 구현하기 A. 생성자와 구별자 모델 정의하기

생성자 신경망 구성하기

class Generator(nn.Module):
    def __init__(self, latent_dim, img_shape):
        super(Generator, self).__init__()
        self.latent_dim = latent_dim
        self.img_shape = img_shape
 
        self.model = nn.Sequential(
            nn.Linear(self.latent_dim, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, np.prod(self.img_shape)),
            nn.Tanh()
        )
 
    def forward(self, z):
        img = self.model(z)
        img = img.view(img.size(0), *self.img_shape)
        return img

구별자 신경망 구성하기

class Discriminator(nn.Module):
    def __init__(self, img_shape):
        super(Discriminator, self).__init__()
        self.img_shape = img_shape
 
        self.model = nn.Sequential(
            nn.Linear(np.prod(self.img_shape), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
 
    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.model(img_flat)
        return validity

B. 훈련 루프 설정하기

생성자와 구별자 초기화하기

latent_dim = 100
img_shape = (1, 28, 28)  # MNIST 데이터셋 예시
 
generator = Generator(latent_dim, img_shape)
discriminator = Discriminator(img_shape)

손실 함수 정의하기

adversarial_loss = nn.BCELoss()
 
def generator_loss(fake_output):
    return adversarial_loss(fake_output, torch.ones_like(fake_output))
 
def discriminator_loss(real_output, fake_output):
    real_loss = adversarial_loss(real_output, torch.ones_like(real_output))
    fake_loss = adversarial_loss(fake_output, torch.zeros_like(fake_output))
    return (real_loss + fake_loss) / 2

생성자와 구별자의 최적화 교대적인 최적화

num_epochs = 200
batch_size = 64
 
# Optimizers
generator_optimizer = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
discriminator_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))
 
for epoch in range(num_epochs):
    # 구별자 훈련
    discriminator.zero_grad()
    real_samples = next(iter(dataloader))[0]
    real_output = discriminator(real_samples)
    fake_noise = torch.randn(batch_size, latent_dim)
    fake_samples = generator(fake_noise)
    fake_output = discriminator(fake_samples.detach())
    d_loss = discriminator_loss(real_output, fake_output)
    d_loss.backward()
    discriminator_optimizer.step()
 
    # 생성자 훈련
    generator.zero_grad()
    fake_noise = torch.randn(batch_size, latent_dim)
    fake_samples = generator(fake_noise)
    fake_output = discriminator(fake_samples)
    g_loss = generator_loss(fake_output)
    g_loss.backward()
    generator_optimizer.step()

C. 훈련 진행 상황 모니터링하기

생성된 샘플 시각화하기

# 생성된 샘플 생성 및 플롯
fake_noise = torch.randn(64, latent_dim)
fake_samples = generator(fake_noise)
plt.figure(figsize=(8, 8))
plt.axis("off")
plt.imshow(np.transpose(vutils.make_grid(fake_samples.detach()[:64], padding=2, normalize=True), (1, 2, 0)))
plt.show()

GAN의 성능 평가하기
- GAN의 성능을 평가하는 것은 어려울 수 있으며, 모든 샘플의 측면을 모두 포착하는 단일 지표는 없습니다.
- Inception Score(IS)와 Fréchet Inception Distance(FID)와 같은 널리 사용되는 측정 항목은 생성된 샘플의 품질과 다양성을 측정합니다.

V. 조건부 GAN(cGAN) A. cGAN의 동기 및 응용- 조건부 GAN (cGAN)은 특정 입력 정보에 조건을 걸어 샘플을 생성할 수 있는 표준 GAN 프레임워크의 확장입니다. 이러한 입력 정보는 클래스 레이블, 텍스트 설명 또는 기타 보조 데이터와 같을 수 있습니다.

cGAN은 특정 속성이나 특징을 가진 샘플을 생성하고자 하는 응용 프로그램에서 유용할 수 있습니다. 예를 들어 특정 객체 클래스의 이미지를 생성하거나 텍스트에서 이미지로의 변환을 생성하는 경우 등이 있습니다.

B. 조건부 생성을 위한 GAN 아키텍처 수정

생성자와 판별자에 레이블 정보 통합
- cGAN에서 생성자와 판별자 네트워크는 추가 입력으로 조건 정보(예: 클래스 레이블, 텍스트 설명)를 사용하도록 수정됩니다.
- 이는 생성자의 잠재 입력과 조건 입력을 연결하고 판별자의 실제/가짜 샘플과 함께 연결하여 수행할 수 있습니다.
cGAN의 손실 함수 정의
- cGAN에서 생성자와 판별자의 손실 함수는 표준 GAN과 유사하지만 조건 정보도 고려합니다.
- 예를 들어 판별자 손실은 제공된 레이블 정보에 따라 실제 샘플과 가짜 샘플을 올바르게 분류하도록 목표로 합니다.

C. PyTorch에서 cGAN 구현

cGAN 모델 정의

class ConditionalGenerator(nn.Module):
    def __init__(self, latent_dim, num_classes, img_shape):
        super(ConditionalGenerator, self).__init__()
        self.latent_dim = latent_dim
        self.num_classes = num_classes
        self.img_shape = img_shape
 
        self.model = nn.Sequential(
            nn.Linear(self.latent_dim + self.num_classes, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, np.prod(self.img_shape)),
            nn.Tanh()
        )
 
    def forward(self, z, labels)이 자습서에서는 옵티마이저, 손실 함수, 평가 메트릭, 정규화 기법, 모델 저장 및 불러오기와 같은 딥러닝 모델의 핵심 구성 요소에 대해 배웠습니다. 이러한 개념을 이해하고 자신만의 딥러닝 프로젝트에 적용하면 다양한 문제를 해결할 수 있는 높은 성능의 모델을 구축하고 훈련할 수 있습니다.

기억하세요, 딥러닝은 계속해서 발전하는 분야이며 항상 배울 것이 많습니다. 최신 동향을 지속적으로 탐색하고 실험하며 딥러닝 분야의 최신 기술에 대해 최신 정보를 유지하십시오. 향후 딥러닝 도전에 행운을 빕니다!

LLaMA2 빠르고 쉽게 Fine-tuning하는 방법 딥러닝을 위한 GPU 빠르게 선택하는 방법