10. 딥러닝 19-21장

 

1) GAN (Generative Adversarial Networks) 생성적 적대 신경망 : 딥러닝 원리를 이용해 가상의 이미지를 생성하는 모델. 가짜 이미지를 만드는 생성자, 이미지의 진위 여부를 판단하는 판별자로 구성.

- 패딩을 사용해 입출력 크기를  통일
- 배치정규화를 통해 입력값의 범위를 제한하여 안정화, BatchNormalization() 함수 사용
- 생성단의 활성함수는 Relu함수, 판별단 전달 직전 tanh 함수 사용

GAN 모델 생성실습

from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Input, Dense, Reshape,Flatten, Dropout
from tensorflow.keras.layers import BatchNormalization, Activation, LeakyReLU, UpSampling2D, Conv2D
from tensorflow.keras.models import Sequential, Model

import numpy as np
import matplotlib.pyplot as plt

# 생성자 모델
generator = Sequential()
generator.add(Dense(128*7*7, input_dim=100, activation=LeakyReLU(0.2)))
generator.add(BatchNormalization())
generator.add(Reshape((7, 7, 128)))
generator.add(UpSampling2D())
generator.add(Conv2D(64, kernel_size=5, padding='same'))
generator.add(BatchNormalization())
generator.add(Activation(LeakyReLU(0.2)))
generator.add(UpSampling2D())
generator.add(Conv2D(1, kernel_size=5, padding='same', activation='tanh'))

# 판별자 모델을
discriminator = Sequential()
discriminator.add(Conv2D(64, kernel_size=5, strides=2, input_shape=(28,28,1), padding="same"))
discriminator.add(Activation(LeakyReLU(0.2)))
discriminator.add(Dropout(0.3))
discriminator.add(Conv2D(128, kernel_size=5, strides=2, padding="same"))
discriminator.add(Activation(LeakyReLU(0.2)))
discriminator.add(Dropout(0.3))
discriminator.add(Flatten())
discriminator.add(Dense(1, activation='sigmoid'))
discriminator.compile(loss='binary_crossentropy', optimizer='adam')
discriminator.trainable = False

# 생성자와 판별자 모델을 연결 gan 모델 생성
ginput = Input(shape=(100,))
dis_output = discriminator(generator(ginput))
gan = Model(ginput, dis_output)
gan.compile(loss='binary_crossentropy', optimizer='adam')
gan.summary()

# 신경망을 실행시키는 함수 생성
def gan_train(epoch, batch_size, saving_interval):

# MNIST 데이터 로드

    (X_train, _), (_, _) = mnist.load_data()
    X_train = X_train.reshape(X_train.shape[0], 28, 28, 1).astype('float32')

    # 127.5를 뺀 후 127.5로 나누어서 -1~1 사이의 값으로 수정
    X_train = (X_train - 127.5) / 127.5

    true = np.ones((batch_size, 1))
    fake = np.zeros((batch_size, 1))

    for i in range(epoch):
        # 실제 데이터를 판별자에 입력
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        imgs = X_train[idx]
        d_loss_real = discriminator.train_on_batch(imgs, true)

        # 가상 이미지를 판별자에 입력
        noise = np.random.normal(0, 1, (batch_size, 100))
        gen_imgs = generator.predict(noise)
        d_loss_fake = discriminator.train_on_batch(gen_imgs, fake)

        # 판별자와 생성자의 오차를 계산
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
        g_loss = gan.train_on_batch(noise, true)

        print('epoch:%d' % i, ' d_loss:%.4f' % d_loss, ' g_loss:%.4f' % g_loss)

        # 중간 과정을 이미지로 저장하는 부분입니다. 정해진 인터벌만큼 학습되면 그때 만든 이미지를 gan_images 폴더에 저장
        if i % saving_interval == 0:
        # r, c = 5, 5
        noise = np.random.normal(0, 1, (25, 100))
        gen_imgs = generator.predict(noise)

        # Rescale images 0 - 1
        gen_imgs = 0.5 * gen_imgs + 0.5

        fig, axs = plt.subplots(5, 5)
        count = 0
        for j in range(5):
            for k in range(5):
                axs[j, k].imshow(gen_imgs[count, :, :, 0], cmap='gray')
                axs[j, k].axis('off')
                count += 1
        fig.savefig("gan_images/gan_mnist_%d.png" % i)

# 2000번 반복되고(+1을 하는 것에 주의) 각 배치 크기는 32, 200번일때 저장
gan_train(2001, 32, 200)

2) 오토인코더 :  가상의 이미지를 생성하는 1)과 다르게 입력 데이터를 기반으로 특징을 추출한 이미지를 생성하는 모델.

오토인코더 실습

from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, 
UpSampling2D, Flatten, Reshape

import matplotlib.pyplot as plt
import numpy as np

# MNIST 데이터셋 참고로드
(X_train, _), (X_test, _) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1).astype('float32') / 255
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1).astype('float32') / 255

# 생성자 모델
autoencoder = Sequential()

# 인코딩. 맥스풀링 사용, 풀링사이즈 2, 패딩조정
autoencoder.add(Conv2D(16, kernel_size=3, padding='same', input_shape=(28, 28,1), activation='relu'))
autoencoder.add(MaxPooling2D(pool_size=2, padding='same'))
autoencoder.add(Conv2D(8, kernel_size=3, activation='relu', padding='same'))                       
autoencoder.add(MaxPooling2D(pool_size=2, padding='same'))
autoencoder.add(Conv2D(8, kernel_size=3, strides=2, padding='same', activation='relu'))

# 디코딩. 활성화 함수 및 패딩, 커널 사이즈 
autoencoder.add(Conv2D(8, kernel_size=3, padding='same', activation='relu'))
autoencoder.add(UpSampling2D())
autoencoder.add(Conv2D(8, kernel_size=3, padding='same', activation='relu'))
autoencoder.add(UpSampling2D())
autoencoder.add(Conv2D(16, kernel_size=3, activation='relu'))
autoencoder.add(UpSampling2D())
autoencoder.add(Conv2D(1, kernel_size=3, padding='same', activation='sigmoid'))

# 컴파일 및 학습
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
autoencoder.fit(X_train, X_train, epochs=50, batch_size=128, validation_data=(X_test, X_test))

# 결과 random_test 변수 저장, 출력
random_test = np.random.randint(X_test.shape[0], size=5)

# 테스트할 이미지를 랜덤으로 호출
ae_imgs = autoencoder.predict(X_test) 
# 앞서 만든 오토인코더 모델에 넣습니다.

plt.figure(figsize=(7,2)) # 출력 이미지의 크기 고정

for i, image_idx in enumerate(random_test):
    ax = plt.subplot(2, 7, i+1)
    plt.imshow(X_test[image_idx].reshape(28, 28))
    ax.axis('off')
    ax = plt.subplot(2, 7, 7+i+1)
    plt.imshow(ae_imgs[image_idx].reshape(28, 28))
    ax.axis('off')
plt.show()

* GAN 이 존재하지 않는 가상의 이미지를 만든다면 오토인코더는 입력된 데이터의 특징을 기반으로 한 이미지를 만드므로 실재에 존재하게 유사한 이미지를 출력한다.

---

딥러닝의 학습 종류
1) 전이 학습(Transger Learning) : 사전에 준비된 자료를 통해 학습한 결과의 가중치 값을 가지고 사용. 
ex. 컴퓨터 비전, 자연어 처리

2) 지도 학습(Supervised Learning) : 교사학습. 학습 시 시스템이 출령해야 할 목표출력을 함께 제공 -> 분류 및 회귀
ex.  MNIST 데이터 셋을 활용한 분류, 당뇨병 예측, 폐암 수술 환자 생존율 예측 등

3) 비지도 학습(Unsupervised Learning) : 비교사학습. 학습 시 목표 출력 값 제공하지 않음 -> 군집화
ex. GAN, 오토인코더를 사용한 이미지 생성 및 판별(정답 예측이 아닌 입력 데이터의 특성을 찾아 이용, 생성)

* 지도와 비지도 학습을 석은 준지도학습 등이 존재하기도 함

---

딥러닝 결과를 설명하는 방법
1) CAM(Class Activation Map) 
2) Gradient CAM

CAM	Gradient CAM
CNN 에서 데이터 입력 -> 콘볼루션 레이어, 풀링 레이어 통과 -> 손실되는 과정을 한번 더 보완(플래튼 단계 직전에 중간 맵을 별도로 모아 그 맵의 평균값을 뽑아 한번 더 학습 -> 가중치에 필요한 값을 제외한 불필요한 값은 소멸, 자연적으로 필요한 값만 획윽.)	CAM과 같지만 평균값 대신 기울기를 이용