
import os
import numpy as np
from tqdm import tqdm
import tensorflow as tf


import tensorflow.keras
import tensorflow.keras.backend as K
from tensorflow.keras.layers import Conv2D, Activation, Dropout, Flatten, Dense, BatchNormalization, Reshape, UpSampling2D, Input
from tensorflow.keras.optimizers import RMSprop
from tensorflow.keras.preprocessing.image import array_to_img
from tensorflow.keras.models import Model, Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.layers import LeakyReLU, ReLU
from tensorflow.keras.datasets import mnist
from tensorflow.keras.optimizers import Adam
from tensorflow.keras import initializers

import warnings ; warnings.filterwarnings('ignore')


# 훈련데이터입니다. 

x_train = np.load('full_numpy_bitmap_angel.npy')
print(len(x_train))
print(x_train[0].shape)

149736
(784,)


# 데이터를 읽어들이고, reshape하고, 255로 normalization하고! 이것은 discriminator의 입력입니다. 
file_data = 'full_numpy_bitmap_angel.npy'
x_train = np.load(file_data)
x_train = np.reshape(x_train, (len(x_train), 28 * 28))#, 1))
x_train = x_train / 255

# train 데이터를 batch_size 로 나눕니다.
batch_size = 64  # 학습할 batch 크기
batch_count = x_train.shape[0] // batch_size  # 전체 batch 개수
random_dim = int(28*28/2)  # Generator에 넣어줄 noise vector 크기


# Optimizer를 설정합니다. 
def get_optimizer():
    return RMSprop(lr=0.00005) # Adam(lr=0.0001)도 괜찮지 않을까 합니다. 

# Discriminator는 아무래도 이미지 판별에 능한 CNN이 좋겠죠?
def get_discriminator(optimizer):
    
    disc_input = Input(shape=(28, 28, 1))  # 28, 28, 1 차원으로 데이터가 있음 

    x = Conv2D(filters=64, kernel_size=5, strides=2, padding='same')(disc_input)
    x = Activation('relu')(x)
    x = Dropout(rate=0.1)(x)

    x = Conv2D(filters=256, kernel_size=5, strides=1, padding='same')(x)
    x = Activation('relu')(x)
    x = Dropout(rate=0.1)(x)

    x = Flatten()(x)
    disc_output = Dense(units=1, activation='sigmoid', kernel_initializer='he_normal')(x)

    discriminator = Model(disc_input, disc_output)   # compile은 하지 않음 

    return discriminator

# Generator 만들기 DCGAN이 아닌 새로운 시도로 그냥 Fully Connectecd로 만들어 보았습니다. 
def get_generator(optimizer):
    generator = Sequential()
    generator.add(Dense(28*28, input_dim=random_dim, kernel_initializer=initializers.RandomNormal(stddev=0.02)))
    generator.add(BatchNormalization(momentum=0.99))
    generator.add(LeakyReLU(0.3))

    # 0.2 → 0.3
    generator.add(Dense(28*28*2))
    generator.add(BatchNormalization(momentum=0.99))
    generator.add(LeakyReLU(0.3))

    generator.add(Dense(28*28*5))
    generator.add(BatchNormalization(momentum=0.99))
    generator.add(LeakyReLU(0.3))

    generator.add(Dense(28*28*5))
    generator.add(BatchNormalization(momentum=0.99))
    generator.add(LeakyReLU(0.3))
    
    generator.add(Dense(28*28*2))
    generator.add(BatchNormalization(momentum=0.99))
    generator.add(LeakyReLU(0.3))
    
    generator.add(Dense(784, activation='sigmoid'))
    
    gen_dense_size = (28, 28, 1)
    generator.add(Reshape(gen_dense_size))
    return generator


# Discriminator와 Generator를 엮어서 GAN network를 만들어 봅시다. 

def get_gan_network(discriminator, random_dim, generator, optimizer):
    # Generator와 Discriminator를 동시에 물려서 학습할 때는 Discriminator를 trainable을 False로 설정합니다.
    discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)
    discriminator.trainable = False  

    # GAN 입력 (노이즈)설정했구요,
    gan_input = Input(shape=(random_dim,))

    # Generator의 결과는 이미지 입니다. 
    x = generator(gan_input)

    # Discriminator의 결과는 이미지가 진짜인지 가짜인지에 대한 확률입니다.
    # Discriminator의 입력으로는 Generator의 출력입니다. 
    gan_output = discriminator(x)

    gan = Model(inputs=gan_input, outputs=gan_output)
    gan.compile(loss='binary_crossentropy', optimizer=optimizer)
    return gan


# GAN 네트워크를 만들어 봅시다. 
optimizer = get_optimizer() 

# Discriminator와 Generator를 만들고!
discriminator = get_discriminator(optimizer) 
generator = get_generator(optimizer)

# 두개를 붙여서 만들어 봅시다. 
gan_model = get_gan_network(discriminator, random_dim, generator, adam)


def train_discriminator(x_train, batch_size):
    # 진짜와 가까를 0과 1로 labeling해 주고,
    valid = np.full((batch_size, 1), 1)
    fake = np.zeros((batch_size, 1))
    
    # discriminator를 먼저 진짜로 학습 
    idx = np.random.randint(0, len(x_train), batch_size)
    true_imgs = x_train[idx]
    true_data = true_imgs.reshape(batch_size, 28, 28, 1)
    discriminator.train_on_batch(true_data, valid)
    noise = np.random.normal(0, 1, (batch_size, random_dim)) # 784  100 input
    gen_imgs = generator.predict(noise)
    
    # discriminator를 noise로 image를 만든 후에 가짜로 학습 
    discriminator.train_on_batch(gen_imgs, fake) #, verbose=1)
    
def train_generator(batch_size):
    # generator는 GAN 전체 네트워크에 넣어서 학습 
    # Discriminator가 뭔가로 판단한 것과 Label 1의 차이 loss를 genenerator에 back propagation
    # 점점 generator의 결과물의 discriminator의 출력이 1에 가까워 지도록 학습한다는 의미임.
    valid = np.ones((batch_size, 1))
    noise = np.random.normal(0, 1, (batch_size, random_dim))#28*28)) # 100? 
    gan_model.train_on_batch(noise, valid)


# 얏호! 3000 epoch만큼 학습 시작! 두근두근 

for epoch in tqdm(range(3000), position=0, leave=True):
    train_discriminator(x_train, batch_count)
    train_generator(batch_count)

100%|██████████| 6000/6000 [58:14<00:00,  1.72it/s]


# 원래 훈련 데이터가 어땠는지 랜덤으로 한번 보고요, 
import matplotlib.pyplot as plt
print(x_train.shape)
idx = np.random.randint(0, len(x_train), 1)
print(idx)
img = x_train[idx].reshape(28,28,1) 
original=array_to_img(img)
plt.imshow(original, cmap='gray')

(149736, 784)
[134579]


# Generator가 어떻게 만드는지 한번 보고요.
random_noise=np.random.normal(0, 1, (1, random_dim))
gen_result=generator.predict(random_noise)
gen_result[29].shape
gen_img=array_to_img(gen_result[29].reshape(28,28,1))
plt.imshow(gen_img, cmap='gray', interpolation='nearest')

티스토리툴바