[GAN] GAN을 이용한 시계열 데이터 생성

magoker.tistory.com/108

[데이터분석] GAN으로 수치 데이터 생성하기

위 주소에서 제공되는 GAN을 이용해서 수치데이터를 생성하는 것은 있었으나 시계열 데이터를 생성해주는 자료는 없길래 코드를 수정해서 한번시도를 해보았습니다.

 

먼저 제가가지고 있는 시계열 데이터는 폭발물에 관한 시계열 데이터이고 어느 시계열 데이터이든 증식이 가능합니다.

 

 

먼저 사용패키지는 

 

- pandas

- numpy

- matplotlib

- jupyter notebook

- sklearn

- keras

 

가 사용되었습니다.

 

코드환경은 아나콘다에서 주피터 노트북을 실행해서 작성되었습니다.

 

패키지 import

import pandas as pd
import numpy as np
from sklearn import utils
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from numpy import zeros
from numpy import ones
from numpy import hstack
from numpy.random import rand
from numpy.random import randn
from keras.models import Sequential
from keras.layers import Dense
from keras.utils.vis_utils import plot_model
from matplotlib import pyplot
import matplotlib.pyplot as plt

 

data import (csv파일)를 해주고 데이터가 정상적으로 산출되는지 확인합니다.

 

real_sp = pd.read_excel("TNT_many_TSC.csv")
print(real_sp)

#real data import
real_df = real_sp[['TNT']]
real_df2 = real_sp[['TNT']]
real_df2 = real_df[2000:4000]
#real_df2 = real_df2[:2000]
print(len(real_df2))
real_df = real_df[:2000]
print(len(real_df))

여기서 한번의 주기만큼의 데이터를 변수에 저장 시켜주시길 바랍니다

 

데이터가 정상적으로 들어갔으면 GAN 모델을 선언해줍니다.

# define the standalone discriminator model
def define_discriminator(n_inputs=1):
	model = Sequential()
	model.add(Dense(100, activation='relu', kernel_initializer='he_uniform', 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 standalone generator model
def define_generator(latent_dim, n_outputs=1):
	model = Sequential()
	model.add(Dense(100, activation='relu', kernel_initializer='he_uniform', input_dim=latent_dim))
	model.add(Dense(n_outputs, activation='linear'))
	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

GAN모델이 선언이 완료 되셨으면 이제 진짜데이터와 가짜데이터를 함수에 집어 넣어줍니다.

 

# generate n real samples with class labels
def generate_real_samples(n):
    x1 = real_df[:n]
    #x1 = np.array(real_df[:(n+1)])
    x1 = np.array(x1)
    #X = x1
    X = x1.reshape(n,1)
    y = ones((n, 1)) 
    return X, y

def make_randomnum(x_input_):
    #make rand data (import tsc data)
    x_input=[]
    #for i in range(0,2000):
        #x_input_=np.append(x_input_,np.random.randint(1,3401))
    x2 = np.array(real_df2)
    #이 줄에서 시계열 데이터값을 지정해서 넣어줍니다.
    x_input_=np.append(x_input_,np.random.randint(x2))
    x_input = np.array(x_input_)
    return x_input
# generate points in latent space as input for the generator
def generate_latent_points(latent_dim, n):
    # generate points in the latent space
    x_input_=[]
    x_input_=make_randomnum(x_input_)
    #print(x_input_)
    x_input_ = x_input_.reshape(2000, latent_dim)
    return x_input_

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

이제 GAN에 관련된 함수를 모두 선언해주셨으니 훈련이 잘되는지 확인할 수 있는 Summarize 함수와 훈련 함수를 선언해줍니다.

 

# evaluate the discriminator and plot real and fake points
def summarize_performance(epoch, generator, discriminator, latent_dim, n=2000):
	# 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, x_fake_value = 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
	plt.plot(x_real)
	plt.plot(x_fake)
	plt.show()

x_output=[]
def train(g_model, d_model, gan_model, latent_dim, n_epochs=2000, n_batch=2000, n_eval=500):
    half_batch=2000
    for i in range(n_epochs):
        x_real, y_real = generate_real_samples(half_batch)
        x_fake, y_fake, x_fake_value = generate_fake_samples(g_model, latent_dim, half_batch)
        #x_output=[]
        d_model.train_on_batch(x_real, y_real)
        d_model.train_on_batch(x_fake, y_fake)
        x_gan=generate_latent_points(latent_dim, n_batch)
        y_gan=ones((n_batch, 1))
        gan_model.train_on_batch(x_gan, y_gan)
        if (i+1)%n_eval==0:
            summarize_performance(i, g_model, d_model, latent_dim)
            x_output=x_fake_value
            print(x_output)
            x_output=np.array(x_output)
            save_data=pd.DataFrame(x_output)
            save_data.to_csv('save.csv', encoding='utf-8', index=False)

 

최종적으로 이제 메인코드에서 훈련을 진행하시면 됩니다.

# size of the latent space
latent_dim = 1
# 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)

 

 

- 훈련 결과

 

500번 1000번 학습 시

1500번 2000번 학습시

학습을 진행시킬때마다 다른모양으로 최대한 비슷한 값들이 나온것을 알 수 있습니다.