가장 쉬운 GAN (generative adversarial network) 예제 by 바죠

가장 쉬운 GAN (generative adversarial network) 예제

실존하는 것과 매우 유사하지만 실존하지 않는 데이터를 만들어 내고싶을 때 사용하는 인공지능 알고리듬이다. 
인공신경망을 활용한다. 인공신경망이 학습을 통해서 유사하지만 서로 다른 물건을 만들어낸다. 정확하게는 두 가지의 인공신경망들이 신경전을 펼치는 특징이 있다. 인공 신경망 두 개가 서로를 못 잡아 먹어서 안달이 난 경우이다. 
결국, GAN이라는 방법에서 '적대적'이라는 말까지 직접 동원하게 된것이다.
가짜지만 진짜같은 사람 사진을 예로 들 수 있겠다. 아마도 이것이 가장 유명한 응용의 예일 것이다. 
하지만, 보다 더 많은 응용들이 가능하다.

GAN은 데이터를 만들어내는 인공신경망과 데이터의 진위를 판단하는 인공신경망으로 구성되어 있다.
각각의 인공신경망은 서로 경쟁한다.
하나는 진짜같은 가짜를 더 잘 만드는데 집중한다. 생산하는 데 집중한다. 
또 다른 하나는 진짜인지 가짜인지를 더 잘 판단하는데 집중한다. 판별하는 데 집중한다.
이들 두 인공신경망의 경쟁은 진짜같은 가짜를 만들어 낼 때 끝이 날 수 있다. 무승부가 가능할 수 있다.

진짜 데이터를 가지고 있기 때문에 이것이 진짜라는 것을 학습할 수 있다.
가짜 데이터를 만들 수 있기 때문에 이것을 가짜라고 학습할 수 있다.

GAN, VAE 모두 새로운 해를 생성할 수 있는 생성적 모델이다. 
좋은 representation을 찾고, 새로운 해를 제시할 수 있는 것은, 마치, 유전 알고리듬에서 변이, 교차를 통해서 새로운 해를 얻어내는 것에 비유된다. 하지만, 유전 알고리듬이 확보할 수 있는 해들의 다양성과 GAN/VAE가 생성할 수 있는 해들의 다양성은 면밀히 따져 보아야 한다. 

아래의 컴퓨터 프로그램은 생성적 대립망(GAN) 모델을 아마도 가장 쉽게 이해할 수 있게 해주는 것이다. 
다른 예제보다 상대적으로 빠를 실행속도 또한 GAN 알고리듬을 이해하는데 도움이 된다.

분류모델과 생성모델의 차이는 아래의 그림에서 표시했다. 
분류모델은 특정한 경계를 선택하고 특정한 경계에 포함되는지 포함되지 않는지를 판단하는 것이다. 
즉, 데이터를 분류해내는 모델이다.
반면, 생성모델은 특정한 공간에서 학습한 데이터와 유사한 데이터를 생성해내는 모델이다.

생성모델:  RNN(recurrent neural network), VAE, GAN, LSTM

https://machinelearningmastery.com/gentle-introduction-generative-long-short-term-memory-networks/
아래 그림에서 붉은색 sin 함수를 모양을 형성할 수 있는 데이터(alpha, beta)를 생각해 볼 수 있다.
이것은 2차원 데이터에 대한 예제이다. 이들 데이터는 sin 함수 관계를 만족하고 있다고 가정한다.
다시 말해서, 우리는 "beta=sin(alpha)" 를 만족하는 데이터들을 가지고 있다.

\[  \beta = sin(\alpha)  \]

사실 많은 경우, 우리가 알고 있는 특정 이론에 따르면, 데이터는 특정한 관계를 만족할 수 있다.
이러한 것들이 많을 수록 좋을 것이다.
여기서 관심을 가지는 것은 특정한 형식을 만족한다는 것에만 집중하고 있다.
실제 데이터 원본을 직접적으로 취급하지 않고 있다.
물론, 직접적으로 취급해도 될 것이다.
이 경우 상당한 컴퓨팅 파워가 소모 될수도 있다.

생성 모형을 이용하는 우리의 목표는 이들 데이터와 아주 유사한 가짜 데이터를 만들어내는 것이다.
물론, 인공신경망을 학습시켜서 우리가 이것을 이루고자 한다. 
기존의 데이터를 반드시 제공해야만 한다. 이들 데이터로부터 시작한다. 

즉, 학습으로부터 아주 유사한 데이터를 위조해서 만들어 내는 것이다. 
beta=sin(alpha) 관계를 만족하는 새로운 데이터를 생성하는 것이다.

\[  \beta = sin(\alpha)  \]

기존의 잘 알려진 데이터는 학습에서만 사용된다. 이들 데이터 이외의 가짜 데이터를 만들고 비교해 보고자 한다. 
물론, 이들과 기존의 데이터는 한 장의 그림에 동시에 나타낼 수 있을 것이다. 직접 비교해 볼 수 있을 것이다. ]

컴퓨터 계산으로 만들어낸 데이터는 파란색으로 표시한다. 원본 데이터는 붉은색으로 표시한다.  

프로그램에서 진짜(real)는 1, 가짜(fake)는 0 으로 취급하고 있다.
데이터를 생성하고 나면 즉시 0인지 1인지를 판단할 수 있게 프로그램을 할 것이다.

따라서 실질적인 데이터의 흐름은 아래와 같다.
latent variables (z_input)  generator  discriminator  1(real) or 0(fake) 

이러한 데이터의 흐름에서 매개변수들이 훈련되게 된다.


GAN 알고리듬이 만들어 낸 가짜지만 진짜같은 사진: 


---------------------------------------------------------------------------------------------------------------------
가장 쉬운 생성적 적대 모델, GAN : http://incredible.egloos.com/7473304
가장 쉬운 오토인코더 : http://incredible.egloos.com/7473318
가장 쉬운 디노이징 :  http://incredible.egloos.com/7479749
---------------------------------------------------------------------------------------------------------------------


GAN을 활용한 물리 문제에 대한 응용:
특정한 양자상태를 학습을 통해서 양산할 수 있다. 그럴듯한 물리학적 상태들을 만들어 낼 수 있다. 
통상 양자상태를 직접적으로 만들어 내는 것은 상당한 계산시간을 필요로 한다.
학습하는 시간이 그리 오래 걸리지 않을 경우에는 이러한 학습을 통한 양자상태 생성이 큰 의미를 가질 수 있다.
다양한 분자구조들 학습하고 새로운 분자들을 만들어 낼 수 있다. 인물 사진들을 학습하고 새로운 인물을 만들어 낼 수 있다.

이론적 약점:
hyper-parameter 선택에 민감하다.
수렴하지 않는 예제가 많다.
GAN 훈련이 수렴해야한다는 증명은 세상 어디에도 존재하지 않는다.
model collapse: 동일한 생성물을 계속해서 만들어 내는 경우가 발생한다. 


생성망은 실제 자료와 같은 자료를 만들기 위해 노력하고, 판별망은 실제 자료와 생성자료를 구분하기 위해 노력하여 최종적으로 생성망이 실제 자료와 같은 자료를 만드는 것이 GAN의 목표다.

일반적으로 잠재공간의 차원크기가 충분히 커야 실제 자료의 특징을 잘 표현한다.
100차원의 잠재공간을 사용한다. 매개변수의 수와 수렴속도 그리고 계산시간으로 이어지는 중요한 문제이기 때문에 잠재공간의 적절한 차원크기를 추정하는 것은 GAN의 최적화에 필요한 과제이다.

GAN의 약점:

1
 생성망은 최적 상태인 내쉬 균형점 (Nash equilibrium)에 도달하기 위해 각각의 가치함수를 구해 학습이 진행되지만 실제로는 수렴이 보장되지 않는다.
2
생성망이 다양한 실제 자료를 폭 넓게 생성하지 못하고 일부 자료만을 생성하게되는 모드붕괴 (mode collapse) 현상이다. 
이는 생성자료가 판별망을 속일 수는 있겠지만 실제 자료의 분포와 다른 분포를 나타낸다. 
3
처음부터 판별망의 성능이 매우 우수하다면 실제 자료와 생성자 료를 완벽하게 구별하여 판별망이 가지는 손실이 0이 되기 때문에 생성망의 학습이 더 이상 이루어지지 않게 된다. 
반면 판별망의 성능이 약하면 생성망에 정확한 피드백을 줄 수 없어 생성망이 제대로 학습할 수 없게 된다.

다양한 파생 GAN:
LSGAN
GAN_NS
WGAN_GP


---------------------------------------------------------------------------------------------------------------------

#      train a GAN on a 1D function, y=sin(x)
from numpy import hstack
from numpy import zeros
from numpy import ones
from numpy import sin,pi
from numpy.random import rand, randn
from keras.models import Sequential
from keras.layers import Dense
from matplotlib import pyplot
from matplotlib.ticker import MultipleLocator, FormatStrFormatter, AutoMinorLocator

#       generate points in latent space as input for the generator
def generate_latent_points(latent_dim, n):
        #     generate points in the latent space
        z_input = randn(latent_dim * n)
        #     reshape into a batch of inputs for the network
        z_input = z_input.reshape(n, latent_dim)
        return z_input

#       define the standalone generator model
def define_generator(latent_dim, n_outputs= 2):
        model = Sequential()
#      model.add(Dense(15, activation='relu', kernel_initializer='he_uniform', input_dim=latent_dim))
        model.add(Dense(15, activation='relu', input_dim=latent_dim))
        model.add(Dense(n_outputs, activation='linear'))
        return model

#       define the standalone discriminator model
def define_discriminator(n_inputs= 2):
        model = Sequential()
#       model.add(Dense(25, activation='relu', kernel_initializer='he_uniform', input_dim=n_inputs))
        model.add(Dense(25, activation='relu', input_dim=n_inputs))
        model.add(Dense(1, activation='sigmoid'))
        #     compile model
        model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
        return model

#       define the combined generator and discriminator model, for updating the generator
def define_gan(generator, discriminator):
        #     make weights in the discriminator not trainable
        discriminator.trainable = False
        #     connect them
        model = Sequential()
        #     add generator
        model.add(generator)
        #     add the discriminator
        model.add(discriminator)
        #     compile model
        model.compile(loss='binary_crossentropy', optimizer='adam')
        return model

#       generate n real samples with class labels
def generate_real_samples(n):
        #     generate inputs in [-0.5, 0.5]*2.*pi
        p = (rand(n) - 0.5)*2.*pi
        #     generate outputs sin(x)
        q = sin(p)
        #     stack arrays
        p = p.reshape(n, 1)
        q = q.reshape(n, 1)
        x = hstack((p, q))
        #     generate class labels
        y = ones((n, 1))
        return x, y

#       use the generator to generate n fake examples, with class labels
def generate_fake_samples(generator, latent_dim, n):
        #     generate points in latent space
        z_input = generate_latent_points(latent_dim, n)
        #     predict outputs
        x = generator.predict(z_input)
        #     create class labels
        y = zeros((n, 1))
        return x, y

#       evaluate the discriminator and plot real and fake points
def summarize_performance(epoch, generator, discriminator, latent_dim, n=100):
        #     prepare real samples
        x_real, y_real = generate_real_samples(n)
        #     evaluate discriminator on real examples
        _, acc_real = discriminator.evaluate(x_real, y_real, verbose=0)
        #     prepare fake examples
        x_fake, y_fake = generate_fake_samples(generator, latent_dim, n)
        #     evaluate discriminator on fake examples
        _, acc_fake = discriminator.evaluate(x_fake, y_fake, verbose=0)
        #     summarize discriminator performance
        print(epoch, acc_real, acc_fake)
        #     scatter plot real and fake data points
        pyplot.figure(figsize=(6,4))
        ax=pyplot.axes()
        ax.set_xlabel(r'$alpha$',fontsize=20)
        ax.set_ylabel(r'$beta$',fontsize=20)
#       ax.legend(fancybox=True, shadow=True, fontsize=15, framealpha=0.8)
        majorLocator= MultipleLocator(1)
        minorLocator= AutoMinorLocator()
        majorFormatter= FormatStrFormatter('%d')
        minorFormatter= FormatStrFormatter('%d')
        ax.xaxis.set_major_locator(majorLocator)
        ax.xaxis.set_major_formatter(majorFormatter)
        ax.xaxis.set_minor_locator(minorLocator)
        majorLocator= MultipleLocator(1)
        minorLocator= AutoMinorLocator()
        majorFormatter= FormatStrFormatter('%d')
        minorFormatter= FormatStrFormatter('%d')
        ax.yaxis.set_major_locator(majorLocator)
        ax.yaxis.set_major_formatter(majorFormatter)
        ax.yaxis.set_minor_locator(minorLocator)
        ax.tick_params(which='major', length=2, color='black')
        ax.tick_params(which='minor', length=4, color='brown')
        ax.set_facecolor("beige")
        pyplot.grid(True)
        pyplot.scatter(x_real[:, 0], x_real[:, 1], color='red', s=5)
        pyplot.scatter(x_fake[:, 0], x_fake[:, 1], color='blue', s=5)
        pyplot.tight_layout()
        str1='sin'+str(epoch)+'.pdf'
        pyplot.savefig(str1,dpi=150)
#       pyplot.show()

#       train the generator and discriminator
def train(g_model, d_model, gan_model, latent_dim, n_epochs=100000, n_batch=128, n_eval=2000):
        #    determine half the size of one batch, for updating the discriminator
        half_batch = int(n_batch / 2)
        #    manually enumerate epochs
        for i in range(n_epochs):
                #     prepare real samples
                x_real, y_real = generate_real_samples(half_batch)
                #     prepare fake examples
                x_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch)
                #     update discriminator
                d_model.train_on_batch(x_real, y_real)
                d_model.train_on_batch(x_fake, y_fake)
                #     prepare points in latent space as input for the generator
                x_gan = generate_latent_points(latent_dim, n_batch)
                #     create inverted labels for the fake samples
                y_gan = ones((n_batch, 1))
                #     update the generator via the discriminator's error
                gan_model.train_on_batch(x_gan, y_gan)
                #     evaluate the model every n_eval epochs
                if (i+1) % n_eval == 0:
                        summarize_performance(i, g_model, d_model, latent_dim)

#     size of the latent space
latent_dim = 10
#     create the discriminator
discriminator = define_discriminator()
#     create the generator
generator = define_generator(latent_dim)
#     create the GAN
gan_model = define_gan(generator, discriminator)
#      train model
train(generator, discriminator, gan_model, latent_dim)


---------------------------------------------------------------------------------------------------------------------

그림을 보는 방법:
gv sin1999.pdf

---------------------------------------------------------------------------------------------------------------------
https://docs.scipy.org/doc/numpy/reference/generated/numpy.hstack.html

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.hstack((a,b))
array([1, 2, 3, 2, 3, 4])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.hstack((a,b))
array([[1, 2],
[2, 3],
[3, 4]])

---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------
MNIST GAN

#       example of training a gan on mnist
from numpy import expand_dims
from numpy import zeros
from numpy import ones
from numpy import vstack
from numpy.random import randn
from numpy.random import randint
from keras.datasets.mnist import load_data
from keras.optimizers import Adam
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Reshape
from keras.layers import Flatten
from keras.layers import Conv2D
from keras.layers import Conv2DTranspose
from keras.layers import LeakyReLU
from keras.layers import Dropout
from matplotlib import pyplot

#       define the standalone discriminator model
def define_discriminator(in_shape=(28,28,1)):
    model = Sequential()
    model.add(Conv2D(64, (3,3), strides=(2, 2), padding='same', input_shape=in_shape))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.4))
    model.add(Conv2D(64, (3,3), strides=(2, 2), padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.4))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
 #      compile model
    opt = Adam(lr=0.0002, beta_1=0.5)
    model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
    return model

#      define the standalone generator model
def define_generator(latent_dim):
    model = Sequential()
 #      foundation for 7x7 image
    n_nodes = 128 * 7 * 7
    model.add(Dense(n_nodes, input_dim=latent_dim))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Reshape((7, 7, 128)))
 #      upsample to 14x14
    model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
    model.add(LeakyReLU(alpha=0.2))
 #       upsample to 28x28
    model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Conv2D(1, (7,7), activation='sigmoid', padding='same'))
    return model

#       define the combined generator and discriminator model, for updating the generator
def define_gan(g_model, d_model):
 #      make weights in the discriminator not trainable
    d_model.trainable = False
 #      connect them
    model = Sequential()
 #      add generator
    model.add(g_model)
 #      add the discriminator
    model.add(d_model)
 #     compile model
    opt = Adam(lr=0.0002, beta_1=0.5)
    model.compile(loss='binary_crossentropy', optimizer=opt)
    return model

#       load and prepare mnist training images
def load_real_samples():
 #      load mnist dataset
    (trainX, _), (_, _) = load_data()
 #       expand to 3d, e.g. add channels dimension
    X = expand_dims(trainX, axis=-1)
 #      convert from unsigned ints to floats
    X = X.astype('float32')
 #      scale from [0,255] to [0,1]
    X = X / 255.0
    return X

#       select real samples
def generate_real_samples(dataset, n_samples):
 #      choose random instances
    ix = randint(0, dataset.shape[0], n_samples)
 #      retrieve selected images
    X = dataset[ix]
 #      generate 'real' class labels (1)
    y = ones((n_samples, 1))
    return X, y

#      generate points in latent space as input for the generator
def generate_latent_points(latent_dim, n_samples):
 #     generate points in the latent space
    x_input = randn(latent_dim * n_samples)
 #     reshape into a batch of inputs for the network
    x_input = x_input.reshape(n_samples, latent_dim)
    return x_input

#      use the generator to generate n fake examples, with class labels
def generate_fake_samples(g_model, latent_dim, n_samples):
 #     generate points in latent space
    x_input = generate_latent_points(latent_dim, n_samples)
 #     predict outputs
    X = g_model.predict(x_input)
 #     create 'fake' class labels (0)
    y = zeros((n_samples, 1))
    return X, y

#      create and save a plot of generated images (reversed grayscale)
def save_plot(examples, epoch, n=10):
 #      plot images
    for i in range(n * n):
  #      define subplot
        pyplot.subplot(n, n, 1 + i)
  #      turn off axis
        pyplot.axis('off')
  #      plot raw pixel data
        pyplot.imshow(examples[i, :, :, 0], cmap='gray_r')
 #      save plot to file
    filename = 'generated_plot_e%03d.png' % (epoch+1)
    pyplot.savefig(filename)
    pyplot.close()

#       evaluate the discriminator, plot generated images, save generator model
def summarize_performance(epoch, g_model, d_model, dataset, latent_dim, n_samples=100):
 #      prepare real samples
    X_real, y_real = generate_real_samples(dataset, n_samples)
 #      evaluate discriminator on real examples
    _, acc_real = d_model.evaluate(X_real, y_real, verbose=0)
 #      prepare fake examples
    x_fake, y_fake = generate_fake_samples(g_model, latent_dim, n_samples)
 #       evaluate discriminator on fake examples
    _, acc_fake = d_model.evaluate(x_fake, y_fake, verbose=0)
 #      summarize discriminator performance
    print('>Accuracy real: %.0f%%, fake: %.0f%%' % (acc_real*100, acc_fake*100))
 #     save plot
    save_plot(x_fake, epoch)
 #      save the generator model tile file
    filename = 'generator_model_%03d.h5' % (epoch + 1)
    g_model.save(filename)

#      train the generator and discriminator
def train(g_model, d_model, gan_model, dataset, latent_dim, n_epochs=100, n_batch=256):
    bat_per_epo = int(dataset.shape[0] / n_batch)
    half_batch = int(n_batch / 2)
 #      manually enumerate epochs
    for i in range(n_epochs):
  #      enumerate batches over the training set
        for j in range(bat_per_epo):
   #      get randomly selected 'real' samples
         X_real, y_real = generate_real_samples(dataset, half_batch)
   #      generate 'fake' examples
         X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch)
   #      create training set for the discriminator
         X, y = vstack((X_real, X_fake)), vstack((y_real, y_fake))
   #      update discriminator model weights
         d_loss, _ = d_model.train_on_batch(X, y)
   #      prepare points in latent space as input for the generator
         X_gan = generate_latent_points(latent_dim, n_batch)
   #      create inverted labels for the fake samples
         y_gan = ones((n_batch, 1))
   #      update the generator via the discriminator's error
         g_loss = gan_model.train_on_batch(X_gan, y_gan)
   #      summarize loss on this batch
         print('>%d, %d/%d, d=%.3f, g=%.3f' % (i+1, j+1, bat_per_epo, d_loss, g_loss))
  #      evaluate the model performance, sometimes
        if (i+1) % 10 == 0:
            summarize_performance(i, g_model, d_model, dataset, latent_dim)

#      size of the latent space
latent_dim = 100
#      create the discriminator
d_model = define_discriminator()
#       create the generator
g_model = define_generator(latent_dim)
#      create the gan
gan_model = define_gan(g_model, d_model)
#      load image data
dataset = load_real_samples()
#      train model
train(g_model, d_model, gan_model, dataset, latent_dim)

---------------------------------------------------------------------------------------------------------------------
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Reshape
from keras.layers.core import Activation
from keras.layers.normalization import BatchNormalization
from keras.layers.convolutional import UpSampling2D
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.layers.core import Flatten
from keras.optimizers import SGDimport numpy as np
from PIL import Imageimport math
from keras.datasets import mnist
class GAN(object):
    def __init__(self, input_shape=(28,28,1)):
        self.input_shape = input_shape
        self.generator = self.generator_model()
        self.discriminator = self.discriminator_model()
        self.gan = self.build_model(self.generator, self.discriminator)
    def generator_model(self):
            model = Sequential()
            model.add(Dense(input_dim=100, units=1024))
            model.add(Activation('tanh'))
            model.add(Dense(128*7*7))
            model.add(BatchNormalization())
            model.add(Activation('tanh'))
            model.add(Reshape((7, 7, 128), input_shape=(128*7*7,)))
            model.add(UpSampling2D(size=(2, 2)))
            model.add(Conv2D(64, (5, 5), padding='same'))
            model.add(Activation('tanh'))
            model.add(UpSampling2D(size=(2, 2)))
            model.add(Conv2D(1, (5, 5), padding='same'))
            model.add(Activation('tanh'))
            return model
    def discriminator_model(self):
         model = Sequential()
         model.add(Conv2D(64, (5, 5), padding='same', input_shape=self.input_shape))
         model.add(Activation('tanh'))
         model.add(MaxPooling2D(pool_size=(2, 2)))
         model.add(Conv2D(128, (5, 5)))
         model.add(Activation('tanh'))
         model.add(MaxPooling2D(pool_size=(2, 2)))
         model.add(Flatten())
         model.add(Dense(1024))
         model.add(Activation('tanh'))
         model.add(Dense(1))
         model.add(Activation('sigmoid'))
         return model
    def build_model(self, g, d):
        model = Sequential()
        model.add(g)
        d.trainable = False
        model.add(d)
        return model
    def train(self, X_train, Y_train, X_test, Y_test, epochs=100, batch_size=32):
        d_optimizer = SGD(lr=0.0005, momentum=0.9, nesterov=True)
        g_optimizer = SGD(lr=0.0005, momentum=0.9, nesterov=True)
        self.generator.compile(loss='binary_crossentropy', optimizer="SGD")
        self.gan.compile(loss='binary_crossentropy', optimizer=g_optimizer)
        self.discriminator.trainable = True
        self.discriminator.compile(loss='binary_crossentropy', optimizer=d_optimizer)
        for epoch in range(1,epochs):
            print("Epoch {}".format(epoch))
            for index in range(int(X_train.shape[0]/batch_size)):
                rand_vector = np.random.uniform(-1, 1, size=(batch_size, 100))
                image_batch = X_train[index*batch_size:(index+1) * batch_size]
                generated_images = self.generator.predict(rand_vector, verbose=0)
                X = np.concatenate((image_batch, generated_images))
                y = [1] * batch_size + [0] * batch_size
                d_loss = self.discriminator.train_on_batch(X, y)
                rand_vector = np.random.uniform(-1, 1, (batch_size,  100))
                self.discriminator.trainable = False
                g_loss = self.gan.train_on_batch(rand_vector, [1] * batch_size)
                self.discriminator.trainable = True
                print("\rbatch {} d loss: {} g loss: {}".format(index, d_loss, g_loss), end="")
            print()
if __name__ == '__main__':
                   (X_train, y_train), (X_test, y_test) = mnist.load_data()
                   X_train = (X_train.astype(np.float32) - 127.5)/127.5
                   X_train = X_train[:, :, :, None]
                   X_test = X_test[:, :, :, None]
                   dcgan = GAN()
                   dcgan.train(X_train, y_train, X_test, y_test)



핑백

덧글

  • 바죠 2021/02/06 18:57 # 답글

    MNIST 자료는 0부터 9까지의 숫자로 구성된 손글씨 이미지자료로 훈련이미지 60,000개, 시험이미지 10,000개으로 구성되어있다.
    각 이미지는 28×28 크기의 회색조로 이루어져 있다. Fashion-MNIST는 10개의 패션 클래스로
    구성된 자료인데 훈련이미지 60,000개와 시험이미지 10,000개로 구성되어 있다.
    각 이미지는 28×28 크 기의 회색조로 이루어져 있다.
    CIFAR-10 자료는 총 10개의 클래스로 이루어진 이미지자료이다.
    각 이미지 는 32×32 크기의 RGB로 이루어져 있고 훈련이미지 50,000개와 시험이미지 10,000개로 구성되어있다.
    CelebA자료는 유명 인사 얼굴에 관한 이미지자료이다. 10,177명에 대한 202,599장의 이미지가 있다.
    각 이미지는 178×218 크기의 RGB로 이루어져 있으며 40개의 이진형 특성 주석을 가진다.
댓글 입력 영역

최근 포토로그



MathJax