[tensorflow]Seq2Seq regression in python

https://rcj92.tistory.com/18

[tensorflow]Seq2Seq regression in R

 

앞서 말했듯 python과 R을 같이 포스팅하는 것이 좋아보여 같이 포스팅 하고자 한다.

사용하는 패키지는 아래와 같다.

from statsmodels.tsa.seasonal import seasonal_decompose
import pandas as pd
import numpy as np
import tensorflow as tf
import keras
import statsmodels.api as sm
import datetime, dateutil
import matplotlib.pyplot as plt

 

df = sm.datasets.get_rdataset("AirPassengers").data
df=df.set_index('time')
df.index=pd.date_range(
        pd.to_datetime('1949-01-01'),
        pd.to_datetime('1961-01-01'),
        freq='1M'
    )
result = seasonal_decompose(df['value'], model='additive')
df=pd.DataFrame(
    [result.seasonal,result.trend,result.resid]).T
df=df.dropna()

def truncate(x,cols,train_len=24,test_len=10):
    in_=list();out_=list()
    for i in range(x.shape[0]-train_len-test_len):
        in_.append(x[np.newaxis,i:(i+train_len),cols])
        out_.append(x[np.newaxis,
                      (i+train_len):(i+train_len+test_len),
                      cols])
    return np.concatenate(in_,axis=0),\
            np.concatenate(out_,axis=0)

#데이터 분할 및 스케일링
train=df.iloc[:80,:]
test =df.iloc[80:,:]
means=train.apply(np.mean,0)
sds  =train.apply(np.std,0)
train=(train-means)/sds
test=(test-means)/sds
train_in,train_out=truncate(
    np.array(train),train_len=24,test_len=10,cols=range(3))
test_in,test_out=truncate(
    np.array(test),train_len=24,test_len=10,cols=range(3))

아래는 seq2seq 모형에 해당한다.

n_hidden=100
input_train=tf.keras.Input(shape=(train_in.shape[1],train_in.shape[2]))
output_train=tf.keras.Input(shape=(train_out.shape[1],train_out.shape[2]))

encoder_last_h1,encoder_last_h2,encoder_last_c=\
        tf.keras.layers.LSTM(n_hidden,activation='swish',
                    dropout=.2,recurrent_dropout=.2,
                    return_sequences=False,return_state=True)(input_train)
encoder_last_h1=keras.layers.BatchNormalization(momentum=.6)(encoder_last_h1)
encoder_last_c=keras.layers.BatchNormalization(momentum=.6)(encoder_last_c)

decoder = tf.keras.layers.RepeatVector(output_train.shape[1])(encoder_last_h1)
decoder = tf.keras.layers.LSTM(n_hidden,
               activation='swish', 
               dropout=0.2, 
               recurrent_dropout=0.2,
               return_sequences=True,
               return_state=False)(decoder, initial_state=[encoder_last_h1, encoder_last_c])
print(decoder)
out= tf.keras.layers.TimeDistributed(
    tf.keras.layers.Dense(output_train.shape[2]))(decoder)
print(out)


model = tf.keras.Model(inputs = input_train, outputs = out)
opt = tf.keras.optimizers.Adam(lr = 0.01, clipnorm = 1)
model.compile(loss='mean_squared_error', optimizer = opt, metrics = ['mae'])
model.summary()

tf.keras.utils.plot_model(model, to_file='model_plot.png',
                          show_shapes=True, show_layer_names=True)

epc = 500
es = tf.keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', patience = 50)
history = model.fit(train_in, train_out, validation_split=0.2,
                    epochs=epc, verbose =1 , callbacks=[es],
                    batch_size=100)
train_mae = history.history['mae']
valid_mae = history.history['val_mae']
model.save('model_forecasting_seq2seq.h5')

pred=model.predict(test_in)
for i in range(pred.shape[2]):
    pred[:,:,i]=pred[:,:,i]*sds[i]+means[i]
    
plt.plot(df.apply(sum,1)[1:(81+11)])
plt.plot(df.index[81:(80+11)],np.apply_along_axis(sum,2,pred)[0,:])
plt.ylim(0,500)