이미지 생성 모델 개요

학습 목표

목표	내용
생성 모델의 기본 개념	데이터 분포 (P(x)), 잠재 분포 (p(z)) 등을 이해
GAN(Generative Adversarial Network)	생성자·판별자의 대립 구조와 손실 함수
VAE(Variational Autoencoder)	인코더·디코더, ELBO, 재구성·KL 손실
Diffusion	노이즈 추가·제거 과정을 통해 이미지 생성
실무 예시	이미지 생성, 잡음 제거, 텍스트‑투‑이미지 등

1. 생성 모델의 개념과 분류

1.1. 확률 모델과 데이터셋

• (P(x)) : 실제 데이터의 확률분포
• (p(z)) : 잠재 변수의 사전분포(보통 표준 정규분포 (\mathcal{N}(0,I)))
• Explicit : 분포를 명시적으로 지정하는 모델 (예: VAE, Normalizing Flow)
• Implicit : 분포를 직접 지정하지 않고 샘플만 생성하는 모델 (예: GAN, Diffusion)

1.2. 주요 생성 모델

모델	분류	주요 특징
GAN	Implicit	생성자(Generator)와 판별자(Discriminator)의 대립 훈련
VAE	Explicit	인코더‑디코더 구조, ELBO 최적화
Diffusion	Implicit	다단계 노이즈 추가와 제거 과정

2. Generative Adversarial Network (GAN)

2.1. 핵심 아이디어

• Generator (G) : 난수 벡터 (z \sim p_z(z)) 를 받아 가짜 이미지 (x_g = G(z)) 를 생성
• Discriminator (D) : 실제 이미지 (x_{\text{real}}) 와 가짜 이미지 (x_g) 를 받아 진짜/가짜 확률 (D(x)) 를 출력
• GAN의 목표는 D 를 “정확히” 만들면서 동시에 G 가 실제 데이터에 가깝게 만들도록 훈련

2.2. 손실 함수

• Discriminator Loss
  [
  LD = -\,\mathbb{E}{x \sim p{\text{data}}}[\log D(x)]
  \;-\;\mathbb{E}{z \sim p_z}[\log(1 - D(G(z)))]
  ]
• Generator Loss (원래 버전)
  [
  LG = -\,\mathbb{E}{z \sim p_z}[\log D(G(z))]
  ]
• Wasserstein GAN 등은 다른 거리(예: Earth–Mover Distance)를 사용해 안정성을 개선

2.3. 단계별 훈련 과정

1. 실제 샘플 (x_{\text{real}}) 과 노이즈 벡터 (z) 를 불러오기
2. Discriminator 를 한 번 업데이트
3. Generator 를 한 번 업데이트
4. 반복

for _ in range(num_steps):
    # Real batch
    x_real = real_batch

    # Fake batch
    z      = torch.randn(batch_size, z_dim)
    x_fake = G(z)

    # Discriminator loss
    d_real = D(x_real).view(-1)
    d_fake = D(x_fake.detach()).view(-1)
    d_loss = -torch.mean(torch.log(d_real) + torch.log(1 - d_fake))

    D.zero_grad()
    d_loss.backward()
    d_opt.step()

    # Generator loss
    g_loss = -torch.mean(torch.log(D(x_fake).view(-1)))

    G.zero_grad()
    g_loss.backward()
    g_opt.step()

2.4. 실무 예시

• DCGAN : ConvNet 기반 기본 구조, MNIST, CIFAR‑10 등에 자주 사용
• StyleGAN / StyleGAN2 : 스타일 벡터와 Adaptive Instance Normalization 으로 고해상도 인물 이미지 생성
• Conditional GAN (cGAN) : (x) 에 대한 라벨 (y) 를 입력으로 받아 조건부 생성

2.5. 주의사항

문제	해결 방법
Mode Collapse	Spectral Normalization, Gradient Penalty
불안정한 수렴	Wasserstein GAN, Batch Normalization
학습 단계 조절	학습률 스케줄링, 클립 등

3. Variational Autoencoder (VAE)

3.1. 구조

• Encoder (q_\phi(z|x)) : 입력 (x) 를 잠재 공간 (\mathbf{z}) 으로 매핑 (평균 (\mu) 와 분산 (\sigma^2) 를 출력)
• Decoder (p_\theta(x|z)) : 잠재 벡터 (\mathbf{z}) 를 받아 원본을 재구성

3.2. ELBO (Evidence Lower Bound)

최대화 목표
[
\log p_\theta(x) \;\ge\;

\underbrace{\mathbb{E}{q\phi(z|x)}[\log p_\theta(x|z)]}_{\text{Reconstruction}}

\underbrace{D{\text{KL}}!\bigl(q\phi(z|x)\,|\,p(z)\bigr)}_{\text{KL loss}}
]
역전파용 손실
[

\mathcal{L}_{\text{VAE}}

-\mathbb{E}{q\phi(z|x)}[\log p_\theta(x|z)]

• D{\text{KL}}!\bigl(q\phi(z|x)\,|\,p(z)\bigr)
  ]

3.3. 재parameterization Trick

[
z = \mu + \sigma \odot \epsilon,
\qquad \epsilon \sim \mathcal{N}(0,I)
]
이로 인해 (z) 에 대한 미분이 가능해짐.

3.4. 코드 예시 (PyTorch)

class VAE(nn.Module):
    def __init__(self, latent_dim):
        super().__init__()
        # Encoder
        self.enc = nn.Sequential(
            nn.Flatten(),
            nn.Linear(784, 400),
            nn.ReLU(True),
            nn.Linear(400, 2*latent_dim)  # μ, logσ²
        )
        # Decoder
        self.dec = nn.Sequential(
            nn.Linear(latent_dim, 400),
            nn.ReLU(True),
            nn.Linear(400, 784),
            nn.Sigmoid()
        )

    def encode(self, x):
        h = self.enc(x)
        mu, logvar = h.chunk(2, dim=1)
        return mu, logvar

    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5*logvar)
        eps = torch.randn_like(std)
        return mu + eps*std

    def decode(self, z):
        return self.dec(z)

    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        recon = self.decode(z)
        return recon, mu, logvar

3.5. 손실 함수

def loss_function(recon_x, x, mu, logvar):
    BCE  = F.binary_cross_entropy(recon_x, x, reduction='sum')
    KLD  = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    return BCE + KLD

3.6. 활용

• Latent 변환 : (\mathbf{z}) 를 변형해 이미지를 서서히 바꾸는 interpolation
• 잡음 감소 : 노이즈가 섞인 이미지를 (p_\theta(x|z)) 로 재구성
• 서로 다른 레이블 생성 : Conditional VAE 를 이용해 라벨을 주고 생성

4. Diffusion 모델

4.1. 아이디어

• Forward process (노이즈 추가)
  [
  xt = \sqrt{1-\beta_t}\,x{t-1} + \sqrt{\beta_t}\,\epsilon,\qquad
  \epsilon \sim \mathcal{N}(0,I)
  ]
• Reverse process (노이즈 제거)
  학습된 denoiser (\epsilon\theta(x_t,t)) 를 통해
  [
  x{t-1} = \frac{1}{\sqrt{1-\betat}}
  \bigl(x_t - \frac{\beta_t}{\sqrt{1-\alpha_t}}\epsilon\theta(x_t,t)\bigr)
  + \sigma_t z
  ]
  여기서 (\sigma_t) 는 작은 잡음이다.

4.2. 스케줄 및 파라미터

• (\beta_t) : 단계별 노이즈 양
• (\alphat = \prod{s=1}^{t}(1-\beta_s))
• (\bar{\alpha}t = \prod{s=1}^{t}(1-\beta_s))

4.3. 손실 (Denoising Score Matching)

[

\mathcal{L}_{\text{diff}}

\mathbb{E}{t,\,x_0,\,\epsilon}
\bigl[
\lambda_t \,|\epsilon - \epsilon\theta(x_t, t)|^2
\bigr]
]

4.4. 샘플링 예시

def p_sample(model, x, t):
    beta_t = betas[t]
    sqrt_one_minus_alpha = sqrt_one_minus_alphas[t]
    eps_theta = model(x, t)          # denoiser output
    mean = (x - eps_theta*beta_t / sqrt_one_minus_alpha) / torch.sqrt(1 - beta_t)

    if t>0:
        var = beta_t
        noise = torch.randn_like(mean)
        return mean + torch.sqrt(var + 1e-6)*noise
    else:
        return mean

• 테스트: (x_T \sim \mathcal{N}(0,I)) 로 시작해 (t=T \to 0) 로 역전파해 이미지 생성.

5. 실무 활용 예시

분야	모델	활용 내용
이미지 생성	GAN	실사 사진, 스타일 변환, 예술 작품 생성
잡음 제거 / 보상	VAE, Diffusion	의료 영상(CT, MRI) 노이즈 감소, 디지털 아트 리프레시
강화학습	VAE latent space	정책 최적화에 사용할 잠재 공간 으로 state‑encoding
텍스트→이미지	Diffusion (예: Stable Diffusion)	자연어 기술을 기반으로 고해상도 이미지 생성

6. 핵심 용어 정리

용어	설명
Generator (G)	노이즈 → 가짜 이미지 생성
Discriminator (D)	실제 vs 가짜 판별
ELBO	확률적 대체, VAE의 최적화 목표
KL Divergence	두 분포 차이량
Diffusion Step	노이즈 추가/제거 단계
Mode Collapse	GAN이 한 종류의 이미지만 생성
Latent Space	잠재 변수 (\mathbf{z}) 의 공간
Spectral Normalization	가중치 정규화로 훈련 안정화
Reparameterization Trick	미분 가능한 noise sampling
Implicit Density	분포를 명시하지 않으면서 샘플만 생성
Explicit Density	분포를 수식으로 정의

7. 추가 학습 권장 사항

• 책
  • “Generative Adversarial Networks” – Ian Goodfellow 대본
  • “The Hundred‑Page Machine Learning Book” – Kevin P. Murphy
• 논문
  • Goodfellow, I. et al., Generative Adversarial Nets, 2014
  • Kingma & Welling, Auto-Encoding Variational Bayes, 2013
  • Ho, J. et al., Denoising Diffusion Probabilistic Models, 2020
• 강의
  • DeepLearning.AI “Generative Adversarial Networks” 특강
  • FastAI “Diffusion Models” 워크숍
• 프레임워크
  • PyTorch Lightning, HuggingFace Diffusers
• 연구실 / 실습
  • Kaggle “CelebA” GAN 튜토리얼
  • OpenAI “DALL·E” 모델 공식 리포지토리

본 노트는 초보자도 이해할 수 있는 수준으로 프로세스를 요약하고, 수학 공식은 단계별로 해설했습니다.
필요한 경우 원문 PDF와 타이핑 자료를 참고해 보충할 수 있도록 구성했습니다.