update

1 files changed, 95 insertions, 3 deletions

diff --git a/cnn.py b/cnn.py
index 8e8eb98..7cb1493 100755
--- a/cnn.py
+++ b/cnn.py
@@ -20,10 +20,19 @@ from keras.models import Sequential
 from keras.layers import Dense, Dropout, Activation, Flatten, Reshape
 from keras.layers import Conv1D, MaxPooling1D, LeakyReLU, PReLU
 from keras.layers import LSTM
+from keras.layers import GRU, CuDNNGRU
 from keras.utils import np_utils
 from keras.callbacks import CSVLogger, ModelCheckpoint
 import tensorflow as tf
 from keras.backend.tensorflow_backend import set_session
+from keras import applications
+from keras.models import Model
+from scipy.ndimage import imread
+import random
+from keras import backend as K
+import keras
+from keras import optimizers
+import matplotlib.pyplot as plt
 
 def SigHandler_SIGINT(signum, frame):
     print()
@@ -164,12 +173,14 @@ def cnn_type_1(symbol_str):
     model.compile(loss='mse', optimizer='adam')
     model.fit(training_datas, training_labels,verbose=1, batch_size=batch_size,validation_data=(validation_datas,validation_labels), epochs = epochs, callbacks=[CSVLogger(output_file_name+'.csv', append=True),ModelCheckpoint(output_file_name+'-{epoch:02d}-{val_loss:.5f}.hdf5', monitor='val_loss', verbose=1,mode='min')])
 
-def lstm_type_cnn_1(symbol_str):
+def lstm_type_cnn_1(symbol_str, kind):
     df, original_df, time_stamps = getData(symbol_str)
     Scaler(df, original_df, time_stamps, symbol_str)
+    """
     os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
     os.environ['CUDA_VISIBLE_DEVICES'] = '1'
     os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
+    """
 
     config = tf.ConfigProto()
     config.gpu_options.allow_growth = True
@@ -196,21 +207,102 @@ def lstm_type_cnn_1(symbol_str):
 
     #build model
     model = Sequential()
-    model.add(LSTM(units=units,activation='tanh', input_shape=(step_size,nb_features),return_sequences=False))
+    if kind == "GRU":
+        model.add(GRU(units=units,activation='tanh', input_shape=(step_size,nb_features),return_sequences=False))
+    elif kind == "LSTM":
+        model.add(LSTM(units=units,activation='tanh', input_shape=(step_size,nb_features),return_sequences=False))
     model.add(Dropout(0.8))
     model.add(Dense(output_size))
     model.add(LeakyReLU())
     model.compile(loss='mse', optimizer='adam')
     model.fit(training_datas, training_labels, batch_size=batch_size,validation_data=(validation_datas,validation_labels), epochs = epochs, callbacks=[CSVLogger(output_file_name+'.csv', append=True),ModelCheckpoint(output_file_name+'-{epoch:02d}-{val_loss:.5f}.hdf5', monitor='val_loss', verbose=1,mode='min')])
 
+def load_cnn_type_1(symbol_str):
+    df, original_df, time_stamps = getData(symbol_str)
+    Scaler(df, original_df, time_stamps, symbol_str)
+    """
+    os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
+    """
+
+    with h5py.File("".join("./cnn/" + symbol_str + "_close.h5"), "r") as hf:
+        datas = hf['inputs'].value
+        labels = hf['outputs'].value
+        input_times = hf['input_times'].value
+        output_times = hf['output_times'].value
+        original_inputs = hf['original_inputs'].value
+        original_outputs = hf['original_outputs'].value
+        original_datas = hf['original_datas'].value
+
+    scaler=MinMaxScaler()
+    #split training validation
+    training_size = int(0.8* datas.shape[0])
+    training_datas = datas[:training_size,:,:]
+    training_labels = labels[:training_size,:,:]
+    validation_datas = datas[training_size:,:,:]
+    validation_labels = labels[training_size:,:,:]
+    validation_original_outputs = original_outputs[training_size:,:,:]
+    validation_original_inputs = original_inputs[training_size:,:,:]
+    validation_input_times = input_times[training_size:,:,:]
+    validation_output_times = output_times[training_size:,:,:]
+
+    ground_true = np.append(validation_original_inputs,validation_original_outputs, axis=1)
+    ground_true_times = np.append(validation_input_times,validation_output_times, axis=1)
+    step_size = datas.shape[1]
+    batch_size= 8
+    nb_features = datas.shape[2]
+
+    model = Sequential()
+
+    # 2 layers
+    model.add(Conv1D(activation='relu', input_shape=(step_size, nb_features), strides=3, filters=8, kernel_size=20))
+    # model.add(LeakyReLU())
+    model.add(Dropout(0.25))
+    model.add(Conv1D( strides=4, filters=nb_features, kernel_size=16))
+    model.load_weights("cnn/" + symbol_str + "_CNN_2_relu-76-0.00056.hdf5")
+    model.compile(loss='mse', optimizer='adam')
+
+    predicted = model.predict(validation_datas)
+    predicted_inverted = []
+
+    for i in range(original_datas.shape[1]):
+        scaler.fit(original_datas[:, i].reshape(-1, 1))
+        predicted_inverted.append(scaler.inverse_transform(predicted[:,:,i]))
+    print(np.array(predicted_inverted).shape)
+    #get only the close data
+    ground_true = ground_true[:,:,0].reshape(-1)
+    ground_true_times = ground_true_times.reshape(-1)
+    ground_true_times = pd.to_datetime(ground_true_times, unit='s')
+    # since we are appending in the first dimension
+    predicted_inverted = np.array(predicted_inverted)[0,:,:].reshape(-1)
+    print(np.array(predicted_inverted).shape)
+    validation_output_times = pd.to_datetime(validation_output_times.reshape(-1), unit='s')
+
+    ground_true_df = pd.DataFrame()
+    ground_true_df['times'] = ground_true_times
+    ground_true_df['value'] = ground_true
+
+    prediction_df = pd.DataFrame()
+    prediction_df['times'] = validation_output_times
+    prediction_df['value'] = predicted_inverted
+
+    prediction_df = prediction_df.loc[(prediction_df["times"].dt.year == 2017 )&(prediction_df["times"].dt.month > 7 ),: ]
+    ground_true_df = ground_true_df.loc[(ground_true_df["times"].dt.year == 2017 )&(ground_true_df["times"].dt.month > 7 ),:]
 
+    plt.figure(figsize=(20,10))
+    plt.plot(ground_true_df.times,ground_true_df.value, label = 'Actual')
+    plt.plot(prediction_df.times,prediction_df.value,'ro', label='Predicted')
+    plt.legend(loc='upper left')
+    plt.show()
 
 # write code here
 def premain(argparser):
     signal.signal(signal.SIGINT, SigHandler_SIGINT)
     #here
     #cnn_type_1("ETH")
-    lstm_type_cnn_1("ETH")
+    #lstm_type_cnn_1("ETH", "GRU")
+    load_cnn_type_1("ETH")
 
 def main():
     argparser = Argparser()