GAN Papers
GAN Paper List
- “Generative Adversarial Nets” (2014) by Ian Goodfellow et al.
- GAN을 처음으로 소개하고 GAN의 기본 개념과 구조를 제시한 논문입니다.
- “Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks” (2016) by Alec Radford et al.
- DCGAN (Deep Convolutional GAN)을 소개하며 이미지 생성을 위한 CNN 기반의 GAN 구조를 제안한 논문입니다.
- “Conditional Generative Adversarial Nets” (2014) by Mehdi Mirza et al.
- 조건부 GAN (Conditional GAN)의 아이디어를 소개한 논문으로, 특정 조건에 따라 이미지를 생성하는 방법을 제시합니다.
- “Improved Techniques for Training GANs” (2016) by Tim Salimans et al.
- GAN 훈련의 안정성과 성능을 향상시키는 여러 기술과 트릭을 다룬 논문입니다.
- “Progressive Growing of GANs for Improved Quality, Stability, and Variation” (2017) by Tero Karras et al.
- Progressive GAN (PGAN)을 소개하며, 고해상도 이미지 생성에서 안정성과 품질을 향상시키는 방법을 다룹니다.
- “A Style-Based Generator Architecture for Generative Adversarial Networks” (2019) by Tero Karras et al.
- StyleGAN과 StyleGAN2를 소개하는 논문으로, 이미지 생성에서 스타일과 다양성을 다루는 방법을 제시합니다.
- NVIDIA
- 고품질 1024x1024 이미지 생성, 얼굴 이미지 생성 분야에서 높은 품질의 가짜 얼굴 이미지를 생성
- 스타일 전이 가능
- 응용: 가상현실, 게임 개발, 캐릭터 디자인, 연예인 얼굴 생성
- “BigGAN: Large Scale GAN Training for High Fidelity Natural Image Synthesis” (2018) by Andrew Brock et al.
- 대규모 GAN 훈련에 관한 논문으로, 고해상도 이미지의 생성을 위한 대규모 모델인 BigGAN을 다룹니다.
- “CycleGAN: Unpaired Image-to-Image Translation Using Cycle-Consistent Adversarial Networks” (2017) by Jun-Yan Zhu et al.
- 이미지 간의 비지도 학습을 통한 이미지 번역에 관한 논문으로, CycleGAN을 소개합니다.
- “StarGAN: Unified Generative Adversarial Networks for Multi-Domain Image-to-Image Translation” (2018) by Yunjey Choi et al.
- 다중 도메인 이미지 번역을 위한 StarGAN 모델을 다루는 논문입니다.
- “TransGAN: Two Transformers Can Make One Strong GAN” (2021) by Yifan Jiang et al.
- GAN과 Transformer 아키텍처를 결합한 TransGAN을 제안하는 최근 논문 중 하나입니다.
- Super-Resolution GAN (SRGAN)
- 저해상도 이미지를 고해상도 이미지로 변환
- 저해상도-고해상도 쌍을 학습
- 이미지 업스케일링, 영화 및 비디오 복원, 의료 이미지 분석 등
코드
- TensorFlow나 PyTorch와 같은 딥 러닝 프레임워크의 공식 문서 및 GAN 튜토리얼을 참고
import tensorflow as tf
from tensorflow.keras import layers
# 생성자 모델 정의
def build_generator(latent_dim):
model = tf.keras.Sequential()
model.add(layers.Dense(128, input_dim=latent_dim))
model.add(layers.LeakyReLU(alpha=0.01))
model.add(layers.Dense(784, activation='sigmoid'))
model.add(layers.Reshape((28, 28)))
return model
# 판별자 모델 정의
def build_discriminator(input_shape):
model = tf.keras.Sequential()
model.add(layers.Flatten(input_shape=input_shape))
model.add(layers.Dense(128))
model.add(layers.LeakyReLU(alpha=0.01))
model.add(layers.Dense(1, activation='sigmoid'))
return model
# 생성자와 판별자 모델 생성
latent_dim = 100
generator = build_generator(latent_dim)
discriminator = build_discriminator((28, 28))
# GAN 모델 구성
discriminator.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
discriminator.trainable = False
gan_input = tf.keras.Input(shape=(latent_dim,))
x = generator(gan_input)
gan_output = discriminator(x)
gan = tf.keras.Model(gan_input, gan_output)
gan.compile(loss='binary_crossentropy', optimizer='adam')
# GAN 훈련 루프
for epoch in range(epochs):
for _ in range(batch_count):
noise = np.random.normal(0, 1, (batch_size, latent_dim))
generated_images = generator.predict(noise)
real_images = # 실제 데이터 미니배치 가져오기
# 판별자 훈련
d_loss_real = discriminator.train_on_batch(real_images, np.ones((batch_size, 1)))
d_loss_fake = discriminator.train_on_batch(generated_images, np.zeros((batch_size, 1)))
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# 생성자 훈련
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))
# 결과 시각화 및 저장
if (epoch + 1) % save_interval == 0:
save_generated_images(epoch, generator)
Super Resolution GAN
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torchvision.models.vgg import vgg19
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder
from torch.autograd import Variable
import numpy as np
import matplotlib.pyplot as plt
import cv2
# 데이터 준비: 저해상도 이미지 로드 또는 생성
# Generator 모델 정의
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
# Generator 아키텍처 예시
self.model = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=9, padding=4),
nn.PReLU(),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
nn.PReLU(),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
nn.PReLU(),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
nn.PReLU(),
nn.Conv2d(64, 3, kernel_size=9, padding=4),
nn.Tanh()
)
def forward(self, x):
return self.model(x)
# Discriminator 모델 정의
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
# Discriminator 아키텍처 예시
self.model = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.LeakyReLU(0.2),
nn.Conv2d(64, 64, kernel_size=3, stride=2, padding=1),
nn.BatchNorm2d(64),
nn.LeakyReLU(0.2),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2),
nn.Conv2d(128, 128, kernel_size=3, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2),
nn.AdaptiveAvgPool2d(1),
nn.Conv2d(128, 1, kernel_size=1)
)
def forward(self, x):
return self.model(x)
# Generator와 Discriminator 모델 생성
generator = Generator()
discriminator = Discriminator()
# 손실 함수 및 최적화 기준 정의
criterion = nn.MSELoss() # MSE 손실 함수 사용
optimizer_g = optim.Adam(generator.parameters(), lr=0.0002)
optimizer_d = optim.Adam(discriminator.parameters(), lr=0.0002)
# 이미지 업샘플링 함수 정의
def upscale_image(image):
# 사용할 업샘플링 알고리즘 선택 (예: Bicubic Interpolation)
interpolation = cv2.INTER_CUBIC
# 이미지 크기를 원하는 크기로 조정
desired_size = (image.shape[1] * 2, image.shape[0] * 2)
upscaled_image = cv2.resize(image, desired_size, interpolation=interpolation)
return upscaled_image
# 테스트 이미지 로드 또는 생성
# 여기에서는 테스트 이미지를 로드하는 대신 무작위 노이즈 이미지를 생성하여 사용합니다.
test_image = np.random.rand(100, 100, 3) * 255.0
# 이미지 업샘플링 적용
super_resolution_image = upscale_image(test_image)
# 결과 이미지 출력
plt.subplot(1, 2, 1)
plt.imshow(test_image.astype(np.uint8))
plt.title("저해상도 이미지")
plt.subplot(1, 2, 2)
plt.imshow(super_resolution_image.astype(np.uint8))
plt.title("고해상도 이미지")
plt.show()