[AI 스터디] Section 11 : GAN (Generative Adversarial Network)

GAN (적대적 생성 모델) 발전

1. 최초 제안 : (2014) Ian Goodfellow
2. 사용 : Computer 가 이미지, 인간의 목소리, 악기소리 등을 실제와 같이 생성
   → https://www.thispersondoesnotexist.com/ : GAN 산출물의 품질 변화를 볼 수 있는 가상 인물
3. 극찬을 받았던 이유
   : 두 개의 딥 뉴럴 네트워크로 이루어짐 : 생성자 / 판별자 ⇒ 두 네트워크가 서로 적대적으로 생성하는 모델

Probability Basics

1. 이산확률 : 각각이 딱딱 떨어진 값을 가지는 경우 ⇒ ex) 주사위
2. 연속분포확률 : 연속된 숫자의 값을 가지는 경우 ⇒ ex) 이미지 : 64x64x3의 확률 분포
   
   
3. 이미지 특성에 따른 확률 분포
   : 이미지 특성에 따라서 픽셀 값들의 확률 분포가 다 다름
   ⇒ 픽셀 하나하나가 어떤 이미지의 특성과 연관됨
   ⇒ ex) 픽셀마다 피부, 안경 등 다 다르게 구성되어, 우리 눈에 다른 모양의 사진으로 나타남
   
   
4. 이미지 특성에 따른 확률 다변수 확률 분포
   : 가장 높은 확률의 부분에 실제 이미지와 가장 비슷한 이미지가 생성될 것

생성 모델

: 실제 존재하지는 않지만 있을 법한 이미지를 생성할 수 있는 모델

1. 분류모델과의 차이
   • 분류 모델 : 결정 경계를 학습
   • 생성 모델 : 각 클래스의 분포를 학습 ⇒ 결합확률 (joint probability) 을 학습
2. 결합확률
   

   

   ⇒ 무엇을 학습하느냐의 대상에 따라 이미지 퀄리티가 달라짐

   • 픽셀의 분포 자체가 낮은 확률의 분포를 학습 시, 어색한 이미지 생성
   • 높은 확률의 분포를 학습 시, 그럴듯한 이미지를 생성

 

GAN의 목표

: 두개 확률 분포의 차이를 줄여 주는 것

1. 확률분포 : 실제 이미지의 각 픽셀이 어떤 값을 가지고 있을 것인가
   ⇒ 특징 : 인접한 픽셀들 끼리 연관이 되어있음 (ex : 픽셀이 달라진다고 피부색이 노란색이 초록색이 되지 않음)
   
   
2. 확률 모델 : 모델이 생성한 이미지의 확률분포
   ⇒ 확률 데이터 X : 실제 데이터

 

GAN 학습

 

검은 점선 (a) : 원본 데이터 이미지의 분포 (\(p_{data}(x)\)) → 데이터가 유한하므로 점으로 표시
파란 점선 (b) : discriminator distribution
녹색 선 (c) : generator distribution ( \( p_z(z) \) )
  ⇒ x(real), z(fake) 선 : 각각 x, z의 도메인
  ⇒ 위로 뻗은 화살표 : \( x=G(z) \) 의 매핑

1. ( a )
   • a : 실제 데이터가 가장 많이 모인 곳
2. ( b )
   • 초기의 생성자 : 오른쪽으로 쏠려서 비정상적인 사람처럼 보이는 분포로 데이터를 만듬
   • 생성자 : 왼쪽으로 분포가 옮겨짐
3. ( c )
   • 판별자 : 진짜, 가짜를 잘 알아맞춤
   • 생성자가 만들어낸 이미지 분포가 점점 센터로 옮겨감
4. ( d )
   • 실제 데이터와 생성자가 만들어낸 데이터와 일치한 상황 ⇒ 실제 데이터의 분포를 완벽히 학습함
   • 생성자 : 분포를 흉내내, 똑같이 픽셀 값을 만듬
     ⇒ 판별자 : 확률을 0.5로 내보냄 (모르겠다. 라는 의미로 !)

Generative vs. Discriminative Algorithms

1. Discriminative Algorithm
   : 인풋 데이터의 피처를 기준으로 레이블 예측 (ex. Spam 분류)
   → 일반적인 분류 모델이다.
   → p(y | X) → “the probability of y given X
   
   
2. Generative Algorithm
   : 주어진 레이블을 기준으로 feature 예측 (feature extraction (x) → feature filling(o))
   → p(X | y) → “the probability of features given y”

GAN process (과정)

1. Training of Discriminator
   • Generator : 난수를 발생시켜 random image (fake image) 생성
   • Generator가 생성한 가짜 이미지(0)와 actual dataset 의 진짜 이미지(1)를 각 레이블을 부여해, discriminator 에게 공급
   • Discriminator : 진짜 image는 1, 가짜 image는 0를 출력하도록 이진 분류 훈련
   • Binary Classification Problem 으로 discriminator 교육
2. Training of Generator
   ( generator의 목적 : discriminator를 속이기)
   
   • Discriminator 출력의 crossentropy 값을 1 과 비교해, 차이분을 손실로 인식하여 역전파로 보정
     ⇒ 만든 가짜 이미지를 0으로 예측시, backpropagation으로 손실을 줄이기 위해 가중치 조정
     ⇒ 손실이 점점 줄어들면, 가짜와 진짜를 구분하지 못하고 1을 출력하게 될 것
     
     

GAN 목적함수 (object function)

: 두 개의 네트워크를 동시에 훈련 → 하나는 고정 하고 훈련하게 됨

 

x : real data로 부터 표본 추출

z : N(0,1)로 부터 표본추출 (노이즈)

D(x) : 감별자가 x가 진짜라고 예측한 확률

G(z) : z로부터 생성자가 생성한 가짜 이미지

D(G(z)) : 감별자가 가짜를 진짜라고 예측한 확률

Ex : 모든 real data instances 에 대한 기대값

Ez : 생성자로의 random 입력의 기대값

1. Discriminator (D(x) classifier)
   

   

   D(x) & 1-D(G(z)) 가 1이 될 수록 \(max_D V(D)\) : 두 개를 다 maximize 해야 함

   
   
   • D(x) : real 이면 1, fake 면 0 을 return 하도록 훈련
     D(x) = 1 에 가까울수록 좋음 ⇒ 좌측 항 ($log(x))$ : 값이 클 수록 좋음
     
     
   • D(G(z)) : G(z) = real 이라고 판단 → 1, fake로 판단 → 0 return
     • 0에 가까울 수록 좋음 ⇒ 우측 항 ($log(1-D(G(z))$) : 값이 클 수록 좋음
     • Loss 측정 : cross-entropy → p log(q) 를 이용
2. Generator
   

   

   1-D(G(z)) 이 0 가 되어야 좋음 ((D(x) 는 G 와 무관하므로 무시)

   D(G(z)) : 1에 가까울 수록 좋음 ⇒ 우측 항 (\(log(1-D(G(z))\)) : 작은 값 일수록 좋음

Mode Collapse

: Generator가 Discriminator를 속이기 쉬운 모드만 생성하게 되는 현상

⇒ ex) 비슷한 글자만 생성해 내는 현상

 

---

실습 : GAN 모델 작성 ( mnist dataset 위조 )

모델 구성 및 주의 사항

1. Discriminator 의 Goal
   : mnist dataset 을 “진짜” 로 인식하고, Generator 에서 공급되는 image 를 fake 로 구분
   → Generator train : Discriminator 를 constant 로 freeze 하여 gradient를 안정적으로 계산할 수 있도록 한다
   
   
2. Generator 의 Goal
   : discriminator 가 “진짜” 로 인식할 fake image 생성 (Gaussian random noise 로 부터 image 생성)
   → Discriminator train : Generator 를 constant 하게 freeze
   
   
3. 필요 요소
   • Learning Rate 조절 필요
     • Discriminator = 너무 강함
       ⇒ 항상 0 과 1 에 근사한 값 나옴
       ⇒ Generator 가 gradient 못 얻음
     • Generator = 너무 smart함
       ⇒ discriminator 의 weakness 를 계속 이용
       ⇒ discriminative가 false negative 를 predict 하도록 함
   • GPU 필요
     • GAN 의 training 은 시간이 오래 걸리기 때문

Utilities

# 가짜 이미지가 어떻게 형성되었는지 출력하는 함수 
def plot_multiple_images(images, n_cols=None):
    '''visualizes fake images'''
    display.clear_output(wait=False)  
    n_cols = n_cols or len(images)
    n_rows = (len(images) - 1) // n_cols + 1

    if images.shape[-1] == 1:
        images = np.squeeze(images, axis=-1)

    plt.figure(figsize=(n_cols, n_rows))
    
    for index, image in enumerate(images):
        plt.subplot(n_rows, n_cols, index + 1)
        plt.imshow(image, cmap="binary")
        plt.axis("off")

데이터 다운 및 준비

# load the train set of the MNIST dataset
(X_train, _), _ = keras.datasets.mnist.load_data()

# normalize pixel values
X_train = X_train.astype(np.float32) / 255

# 훈련하는 동안 모델에 공급할 수 있도록 훈련 이미지의 배치를 생성.
BATCH_SIZE = 128

dataset = tf.data.Dataset.from_tensor_slices(X_train).shuffle(1000)
dataset = dataset.batch(BATCH_SIZE, drop_remainder=True).prefetch(1)
# drop_remainder : 딱 떨어지지 않는 나머지를 drop (60000 / 128 = 나머지가 존재하기 때문)

Generator

: 임의의 노이즈를 받아 가짜 이미지를 만드는 데 사용

⇒ 랜덤 노이즈 형태로 받아서 MNIST 데이터 세트 (예 : 28 x 28)와 동일한 크기의 이미지를 출력

# declare shape of the noise input
# normal distribution을 만들 dimension을 32차원으로 
random_normal_dimensions = 32

# generator model
# SELU : GAN에 적합한 활성화 함수로 ReLU 계열임 => 처음 두 개의 Dense 네트워크에서 사용 
# sigmoid : 최종 Dense 네트워크는 0과 1 사이의 픽셀 값을 생성하기 원해서
generator = keras.models.Sequential([                                 
    keras.layers.Dense(64, activation="selu", input_shape=[random_normal_dimensions]),
    keras.layers.Dense(128, activation="selu"),
    keras.layers.Dense(28 * 28, activation="sigmoid"),
    keras.layers.Reshape([28, 28])  # 데이터 세트의 차원에 맞게 reshape
])

# 훈련되지 않은 generator의 샘플 출력 => random point 그 자체를 출력할 것
# 훈련 후 : MNIST 데이터 세트의 숫자를 닮을것 
# batch size = 16로 노이즈 생성
test_noise = tf.random.normal([16, random_normal_dimensions])

# feed the batch to the untrained generator
test_image = generator(test_noise)

# visualize sample output
plot_multiple_images(test_image, n_cols=4)

Discriminator

: 입력(가짜 또는 실제) 이미지를 가져와 가짜인지 아닌지를 결정

# input shape = 훈련 이미지의 모양
# => flatten => dense network에 공급 => 출력 : 0 (가짜)과 1 (실제) 사이의 값
# build the discriminator model
discriminator = keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28, 28]),
    keras.layers.Dense(128, activation="selu"), # 처음 두 개의 dense network에서 SELU 활성화
    keras.layers.Dense(64, activation="selu"),
    keras.layers.Dense(1, activation="sigmoid") # sigmoid로 final network를 활성화
])

GAN 구축 및 훈련을 위한 준비

# Generator, Discriminator 두 모델을 추가해 GAN 구축
gan = keras.models.Sequential([generator, discriminator])

# Configure Training Parameters
# binary_crossentropy로 손실 => 이유 : 라벨이 0 (가짜) 또는 1 (실제)이 될 것
discriminator.compile(loss="binary_crossentropy", optimizer="rmsprop")
discriminator.trainable = False
gan.compile(loss="binary_crossentropy", optimizer="rmsprop")

모델 훈련

• 1 단계 - 가짜 데이터와 실제 데이터를 구분하도록 판별자를 훈련시킵니다.
• 2 단계 - 판별자를 속이는 이미지를 생성하도록 생성자를 훈련합니다.

각 epoch마다 생성자에 의해 생성되는 가짜 이미지를 확인하기 위해 이미지 샘플 갤러리를 표시

def train_gan(gan, dataset, random_normal_dimensions, n_epochs=100):
    """ Defines the two-phase training loop of the GAN
    Args:
      gan -- the GAN model which has the generator and discriminator
      dataset -- the training set of real images
      random_normal_dimensions -- dimensionality of the input to the generator
      n_epochs -- number of epochs
    """

    # get the two sub networks from the GAN model
    generator, discriminator = gan.layers

    # start loop
    for epoch in range(n_epochs):
        print("Epoch {}/{}".format(epoch + 1, n_epochs))       
        for real_images in dataset: # 데이터셋에서 실제 이미지를 읽어들임 
            # 훈련 배치에서 배치 크기 추론
            batch_size = real_images.shape[0]

            # Train the discriminator - PHASE 1
            # noise 생성
            noise = tf.random.normal(shape=[batch_size, random_normal_dimensions])
            
            # 노이즈를 사용하여 가짜 이미지 생성
            fake_images = generator(noise)
            
            # 가짜 이미지와 실제 이미지를 연결하여 list 만들기
            mixed_images = tf.concat([fake_images, real_images], axis=0)
            
            # discriminator를 위한 label 생성 (지도학습을 하기 위함)
            # 0 for the fake images
            # 1 for the real images
            discriminator_labels = tf.constant([[0.]] * batch_size + [[1.]] * batch_size)
            
            # Ensure that the discriminator is trainable
            discriminator.trainable = True
            
            # train_on_batch를 사용하여 mixed_images 와 discriminator_labels로 판별자를 훈련합니다.
            # 0을 0으로 맞추고, 1을 1로 맞춤 => 손실이 없음
            # 잘못 맞추면 backpropagation 될 것
            discriminator.train_on_batch(mixed_images, discriminator_labels)
            # discriminator.fit(mixed_images, discriminator_labels) : fit == train_on_batch
            
            # Train the generator - PHASE 2
            # GAN에 공급할 노이즈 입력 배치 새롭게 생성
            noise = tf.random.normal(shape=[batch_size, random_normal_dimensions])

            # 생성된 모든 이미지에 "real" 레이블 지정
            generator_labels = tf.constant([[1.]] * batch_size)

            # Freeze the discriminator : 훈련된 감별자 고정
            discriminator.trainable = False

            # 레이블이 모두 true로 설정된 노이즈에 대한 GAN 훈련
            # generator의 출력이 discriminator의 입력으로 들어가, 1, 0 중 하나로 판단
            # discriminator가 속아서 1을 출력시, generator_labels과 동일하므로 손실이 0 => 성공!
            gan.train_on_batch(noise, generator_labels) # generator_labels = 1
            # gan.fit(noise, generator_labels)

        #판별자를 훈련하는 데 사용되는 가짜 이미지를 플로팅합니다.
        plot_multiple_images(fake_images, 8)                     
        plt.show() 
        
# 훈련        
train_gan(gan, dataset, random_normal_dimensions, n_epochs=30)  

Mode Collapse : 학습이 진행됨에 따라 모델이 1, 7, 9와 같은 숫자의 하위 집합에 편향되는 경향