def treina_modelo(model, x_train, y_train, existe=False): if existe == False: model.add(LSTM(input_dim=1, output_dim=50, return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(50, return_sequences=False)) model.add(Dropout(0.2)) model.add(Dense(20, activation='relu')) model.add(Dense(output_dim=1)) model.add(Activation('linear')) start = time.time() model.compile(loss='mse', optimizer='adam', metrics=['accuracy']) print("Compilation time: ", time.time() - start) # # Para quando não melhorar es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=5) callbacks_list = [es] # Treinando o modelo model.fit(x_train, y_train, batch_size=512, epochs=10, validation_split=0.05, callbacks=callbacks_list, verbose=1) model.save('meu_modelo.h5') #Step 4 - Plot the predictions! predictions = lstm.predict_sequences_multiple(model, x_test, 50, 50) lstm.plot_results_multiple(predictions, y_test, 50)
def predict(currency, current_price, historical_data): X_train, y_train, X_test, y_test = lstm.load_data( prepare_data(historical_data), 50, True) model = Sequential() model.add(LSTM(input_dim=1, output_dim=50, return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(100, return_sequences=False)) model.add(Dropout(0.2)) model.add(Dense(output_dim=1)) model.add(Activation('linear')) start = time.time() model.compile(loss='mse', optimizer='rmsprop') print('compilation time : ', time.time() - start) model.fit(X_train, y_train, batch_size=512, nb_epoch=1, validation_split=0.05) predictions = lstm.predict_sequences_multiple(model, X_test, 50, 50) #lstm.plot_results_multiple(predictions, y_test, 50) p = predictions[len(predictions) - 1] pi = p[len(p) - 1] prediction = 'down' if pi >= 0: prediction = 'up' return prediction, str(int(round(abs(pi * 100))))
def predict(): #Step 1 Load Data X_train, y_train, X_test, y_test = lstm.load_data('aapl.csv', 50, True) #Step 2 Build Model model = Sequential() model.add(LSTM(input_dim=1, output_dim=2, return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(100, return_sequences=False)) model.add(Dropout(0.2)) model.add(Dense(output_dim=1)) model.add(Activation('linear')) start = time.time() model.compile(loss='mse', optimizer='rmsprop') print 'compilation time : ', time.time() - start #Step 3 Train the model model.fit(X_train, y_train, batch_size=512, nb_epoch=1, validation_split=0.05) #Step 4 - Plot the predictions! predictions = lstm.predict_sequences_multiple(model, X_test, 50, 50) lstm.plot_results_multiple(predictions, y_test, 50)
def main(): global_start_time = time.time() epochs = 1 seq_len = 50 print('> Loading data... ') X_train, y_train, X_test, y_test = lstm.load_data('lux500.csv', seq_len, True) print('> Data Loaded. Compiling...') model = lstm.build_model([1, 50, 100, 1]) model.fit(X_train, y_train, batch_size=512, nb_epoch=epochs, validation_split=0.05) model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) model.save_weights("model.h5") print('Model saved to disk') predictions = lstm.predict_sequences_multiple(model, X_test, seq_len, 50) #predicted = lstm.predict_sequence_full(model, X_test, seq_len) #predicted = lstm.predict_point_by_point(model, X_test) print('Training duration (s) : ', time.time() - global_start_time) data = plot_results_multiple(predictions, y_test, 50) #print(data) return data
def test(): X_train, y_train, X_test, y_test = lstm.load_data('lux500.csv', 50,True) json_file = open("model.json") loaded_model = json_file.read() json_file.close() model = model_from_json(loaded_model) model.load_weights("model.h5") pred = lstm.predict_sequences_multiple(model, X_test, 50, 50) return run.plot_results_multiple(pred, y_test, 50)
def predict(X, forecast, model, horizon, scaler): predictions, predicted_frames = lstm.predict_sequences_multiple( model, X, forecast, horizon) try: predicted_load = lstm.inverse_transform1(predicted_frames, scaler) # true_load = lstm.inverse_transform(dataset[2], dataset[3], scaler) # rmse = sqrt(mean_squared_error(true_load, predicted_load)) # mape = np.mean(np.abs((true_load - predicted_load) / true_load)) * 100 except Exception as e: print(e) # rmse=100.0 # mape=100.0 return predictions, predicted_load
def run_test(filename): X_train, y_train, X_test, y_test, d_X_test, d_y_test = lstm.load_data( filename, seq_len, True) predictions = lstm.predict_sequences_multiple(model, X_test, d_X_test, seq_len, 60, denormalise=True) actual_pos = d_y_test print(filename) for i, prediction in enumerate(predictions): distances = 0 for j, predic in enumerate(prediction): distances += np.linalg.norm(np.array(predic) - actual_pos[i][j])**2 distance = np.sqrt(distances) print(distance)
def main(): outdir = './data' if not os.path.exists(outdir): os.mkdir(outdir) aapl = pdr.get_data_yahoo('AAPL', start=datetime.datetime(2006, 10, 1), end=datetime.datetime(2019, 1, 1)) aapl.to_csv('data/aapl_ohlc.csv') df = pd.read_csv('data/aapl_ohlc.csv', index_col='Date', header=0, parse_dates=True) close = df['Close'] window_size = 30 predict_len = 15 batch_size = 80 epochs = 1 x_train, y_train, x_test, y_test = lstm.load_data(close, window_size, True) #date_price = df['Close'] #date_price = np.array(date_price).astype('float32') #train, test = split_train_test(date_price, 0.8) #x_train, y_train = create_dataset(train, 1) #x_test, y_test = create_dataset(test, 1) #x_train = np.reshape(x_train, (x_train.shape[0], 1, x_train.shape[1])) #x_test = np.reshape(x_test, (x_test.shape[0], 1, x_test.shape[1])) model = Sequential() model.add(LSTM(input_dim=1, output_dim=50, return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(100, return_sequences=False)) model.add(Dropout(0.2)) model.add(Dense(output_dim=1)) model.add(Activation('linear')) start = time.time() model.compile(loss='mse', optimizer='rmsprop') print('compilation time:', time.time() - start) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.05) predictions = lstm.predict_sequences_multiple(model, x_test, window_size, predict_len) lstm.plot_results_multiple(predictions, y_test, predict_len)
def callback(): global_start_time = time.time() epochs = 1 seq_len = 50 a = pdr.get_data_yahoo(e.get(), '1980-12-01') a.to_csv('a.csv', header=False, index=False, columns=['Close']) t.delete("1.0", END) t.insert(END, '> Loading data... \n') X_train, y_train, X_test, y_test = lstm.load_data( 'a.csv', seq_len, True) t.insert(END, '> Data Loaded. Compiling... \n') model = lstm.build_model([1, 50, 100, 1]) model.fit( X_train, y_train, batch_size=512, nb_epoch=epochs, validation_split=0.05, ) predictions = lstm.predict_sequences_multiple(model, X_test, seq_len, 50) #predicted = lstm.predict_sequence_full(model, X_test, seq_len) predicted = lstm.predict_point_by_point(model, X_test) score = model.evaluate(X_test, y_test, batch_size=30, verbose=0) t.insert(END, '\n > LSTM test accuracy :' + str(score)) t.insert( END, '\n > Training duration (s) :' + str(time.time() - global_start_time)) plot_results(predicted, y_test)
# ============================================================================= # #Step 3 Train the model # ============================================================================= model.fit( X_train, y_train, batch_size=512, nb_epoch=1, validation_split=0.05) # ============================================================================= # #Step 4 - Plot the predictions! # ============================================================================= predictions = lstm.predict_sequences_multiple(model, X_test, 50, 50) lstm.plot_results_multiple(predictions, y_test, 50) # we will train our model with the function then we can test it to see what it predicts # for the next 50 steps at several points in our graph # and visualize it using that with mapplotlit # it seems that for a lot of the price movement espacially the big ones # there is quite a correlation between our models prediction and the actual data # so it's time to some money!! # but will our model be able to correcly predict the closing price one hundred percent of time? # the answer is no # it's an analystical tool to help us make educated guesses about the direction of the market, # that's slightly better than random # so to break it down, conclusions: # 1. rnn can model sequential data because the hidden state is affected by the input and # the previous hidden state
def predict(): global_start_time = time.time() epochs = 10 seq_len = 10 num_predict = 5 print('> Loading data... ') # X_train, y_train, X_test, Y_test = lstm.load_data('sp500_2.csv', seq_len, True) # X_train_, y_train_, X_test_, Y_test_ = lstm.load_data('sp500_2.csv', seq_len, False) X_train, y_train, X_test, Y_test = lstm.load_data('ibermansa.csv', seq_len, True) X_train_, y_train_, X_test_, Y_test_ = lstm.load_data( 'ibermansa.csv', seq_len, False) print('> Data Loaded. Compiling...') model = lstm.build_model([1, seq_len, 100, 1]) model.fit(X_train, y_train, batch_size=100, nb_epoch=epochs, validation_split=0.40) predictions2, full_predicted = lstm.predict_sequences_multiple( model, X_test, seq_len, num_predict) # predictions = lstm.predict_sequence_full(model, X_test, seq_len) predictions = lstm.predict_point_by_point(model, X_test, Y_test, batch_size=100) # sequence_length = seq_len + 1 # result = [] # for index in range(len(predictions) - sequence_length): # result.append(predictions[index: index + sequence_length]) # result = lstm.unnormalise_windows(result) # predictions = np.array(result) # result = [] # for index in range(len(Y_test) - sequence_length): # result.append(Y_test[index: index + sequence_length]) # result = lstm.unnormalise_windows(result) # Y_test = np.array(result) # Y_test = Y_test+Y_test_.astype(np.float) # Y_test = Y_test.astype(np.float)[:296] # aux = predictions[:]+Y_test_ # print(aux) # mape = mean_absolute_percentage_error(Y_test[-42:-1], np.array(predictions2)[:,0]) # mse = mean_squared_error(Y_test[-42:-1],np.array(predictions2)[:,0]) # mae = mean_absolute_percentage_error(Y_test[-42:-1],np.array(predictions2)[:,0]) mape = mean_absolute_percentage_error(Y_test[-2050:-1], full_predicted[0:-1]) mse = mean_squared_error(Y_test[-2050:-1], full_predicted[0:-1]) mae = mean_absolute_percentage_error(Y_test[-2050:-1], full_predicted[0:-1]) # msle = mean_squared_logarithmic_error(Y_test, predictions) # print(mape) init_op = tf.initialize_all_variables() # def weighted_mape_tf(Y_test,predictions): #tot = tf.reduce_sum(Y_test) #tot = tf.clip_by_value(tot, clip_value_min=1,clip_value_max=1000) #wmape = tf.realdiv(tf.reduce_sum(tf.abs(tf.subtract(Y_test,predictions))),tot)*100#/tot #return(wmape) # mape = weighted_mape_tf(Y_test,predictions) # run the graph with tf.Session() as sess: sess.run(init_op) print('mape -> {} '.format(sess.run(mape))) print('mse -> {}'.format(sess.run(mse))) print('mae -> {} '.format(sess.run(mae))) # print ('msle -> {} %'.format(sess.run(msle))) print('Training duration (s) : ', time.time() - global_start_time) print(predictions) im1 = plot_results(predictions, Y_test) im2 = plot_results(np.array(Y_test_) + np.array(predictions), Y_test_) im3 = plot_results_multiple(predictions2, Y_test, num_predict) im4 = plot_results( np.array(Y_test_)[-118:-1] + np.array(full_predicted)[-118:-1], Y_test_) return im1, im2, im3, im4
model.compile(loss = 'mse', optimizer = 'rmsprop') print("compilation time: ", time.time() - start) start = time.time() model2.compile(loss = 'mse', optimizer = 'rmsprop') print("compilation time: ", time.time() - start) start = time.time() model3.compile(loss = 'mse', optimizer = 'rmsprop') print("compilation time: ", time.time() - start) model.fit(X_train, y_train, batch_size = 512, nb_epoch = 7, validation_split = 0.05) model2.fit(X_train, y_train, batch_size = 512, nb_epoch = 7, validation_split = 0.05) model3.fit(X_train, y_train, batch_size = 512, nb_epoch = 7, validation_split = 0.05) score1 = model.evaluate(X_test, y_test) print("\n Mean Squared Error: ", score1) score2 = model2.evaluate(X_test, y_test) print("\n Mean Squared Error: ",score2) score3 = model3.evaluate(X_test, y_test) print("\n Mean Squared Error: ",score3) predictions1 = lstm.predict_sequences_multiple(model,X_test, 50,50) lstm.plot_results_multiple(predictions1,y_test, 50) predictions2 = lstm.predict_sequences_multiple(model2,X_test, 50,50) lstm.plot_results_multiple(predictions2,y_test, 50) predictions3 = lstm.predict_sequences_multiple(model3,X_test, 50,50) lstm.plot_results_multiple(predictions3,y_test, 50)
def predict(batch_size, nb_epoch, timestep, hidden_state, layers=[1], save=False, predict_multiple=False, prediction_len=1, predict_full=False): # Load Data normalise = True X_train, y_train, X_test, y_test, y_test_restorer = lstm.load_data( './input/sp500.csv', timestep, normalise) print "X_train length" + str(len(X_train)) print "X_test length" + str(len(X_test)) # Build Model if (len(layers) == 3): model = lstm.build_model_single_layer_LSTM(layers) elif (len(layers) == 4): model = lstm.build_model_double_layer_LSTM(layers) elif (len(layers) == 5): model = lstm.build_model_triple_layer_LSTM(layers) else: model = lstm.build_model_single_layer_LSTM([1, hidden_state, 1]) model.compile(loss='mse', optimizer='rmsprop') # Train the model model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, validation_split=0.05) model.save('./data/modelMetaData.h5') # Predict test data with trained model predictions = lstm.predict_point_by_point(model, X_test) if predict_multiple: predictions_multiple = lstm.predict_sequences_multiple( model, X_test, window_size=timestep, prediction_len=prediction_len) if predict_full: predictions_full = lstm.predict_sequence_full(model, X_test, window_size=timestep) if normalise: # restore the normalised data and predictions to the original value= for i in range(len(y_test)): y_test[i] = (y_test[i] + 1) * float(y_test_restorer[i]) predictions[i] = (predictions[i] + 1) * float(y_test_restorer[i]) if predict_multiple: col = len(predictions_multiple[0]) tmp = np.asarray(predictions_multiple).reshape(1, -1) for i in range(len(tmp)): tmp[i] = (tmp[i] + 1) * float(y_test_restorer[i]) predictions_multiple = tmp.reshape(-1, col).tolist() if predict_full: for i in range(len(predictions_full)): predictions_full[i] = (predictions_full[i] + 1) * float( y_test_restorer[i]) # save predictions and the test data for further experiments if save: np.save('./data/y_test', y_test) np.save('./data/predictions', predictions) if predict_multiple: np.save('./data/predictions_multi', predictions_multiple) if predict_full: np.save('./data/predictions_full', predictions_full) return y_test, predictions
#print ('compilation time : ', time.time() - start) #Step 3 Train the model model.fit( X_train, y_train, batch_size=512, nb_epoch=1, validation_split=0.05) X_test = X_test[:30] y_test = y_test[:30] # Step 4 - Plot the predictions! prediction_len = 3 predictions = lstm.predict_sequences_multiple(model, X_test, 30, prediction_len) lstm.plot_results_multiple(predictions, y_test, prediction_len) #hilo_pred = [] #for prediction in predictions: # if prediction[0] > prediction[-1]: # hilo_pred.append(0) # else: # hilo_pred.append(1) # # #hilo_real = [] #for i in range(0, 147, prediction_len): # if y_test[i] > y_test[i + prediction_len]: # hilo_real.append(0) # else:
plt.legend() plt.show() #Main Run Thread if __name__=='__main__': global_start_time = time.time() epochs = 1 seq_len = 50 print('> Loading data... ') X_train, y_train, X_test, y_test = lstm.load_data('data/sp500.csv', seq_len, True) print('> Data Loaded. Compiling...', X_train.shape, y_train.shape) model = lstm.build_model([1, 50, 100, 1]) model.fit( X_train, y_train, batch_size=512, nb_epoch=epochs, validation_split=0.05) predictions = lstm.predict_sequences_multiple(model, X_test, seq_len, 50) #predicted = lstm.predict_sequence_full(model, X_test, seq_len) #predicted = lstm.predict_point_by_point(model, X_test) print('Training duration (s) : ', time.time() - global_start_time) plot_results_multiple(predictions, y_test, 50)
#Main Run Thread if __name__ == '__main__': global_start_time = time.time() epochs = 1 window_size = 50 prediction_len = 50 batch_size = 5000 validation_split = 0.005 print('> Loading data... ') X_train, y_train, X_test, y_test = lstm.load_data( 'dice_amplified/20_mil_dos_mixed.csv', window_size, True) print('> Data Loaded. Compiling...') model = lstm.build_model([1, 50, 100, 1]) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=epochs, validation_split=validation_split) predictions = lstm.predict_sequences_multiple(model, X_test, window_size, prediction_len) #predicted = lstm.predict_sequence_full(model, X_test, window_size) #predicted = lstm.predict_point_by_point(model, X_test) print('Training duration (s) : ', time.time() - global_start_time) plot_results_multiple(predictions, y_test, 50)
#predict trend predictions_trend = [] y_test_trend = [] for x in range(1, len(predictions)): if y_test[x] > y_test[x - 1]: y_test_trend.append(1) else: y_test_trend.append(-1) for x in range(1, len(y_test)): if predictions[x] > predictions[x - 1]: predictions_trend.append(1) else: predictions_trend.append(-1) name = "pic_features_" + str(z + 1) + "_trends" plot_results(predictions_trend, y_test_trend, name) a = predict_sequence_full(model, X_test, 20) for i in range(len(a)): a[i] = float(X_testn[i][0][features - 1]) * (a[i] + 1) plot_results(a, y_testn, name) predictions = lstm.predict_sequences_multiple(model, X_test, seq_len, 10) for i in range(len(predictions)): for j in range(len(predictions[i])): predictions[i][j] = int( X_testn[i * len(predictions[i]) + j][0][0]) * (predictions[i][j] + 1) print(i) plot_results_multiple(predictions, y_testn, 10)
model.add(Dropout(0.2)) model.add(LSTM(64, return_sequences=False)) model.add(Dense(output_dim=1)) model.add(Activation('linear')) start = time.time() model.compile(loss='mse', optimizer='rmsprop') print('Compilation time:', time.time() - start) #Set hyperparameter model.fit(X_train, y_train, batch_size=512, nb_epoch=100, validation_split=0.1) #Make prediction predictions = lstm.predict_sequences_multiple(model, X_test, seqence_length, seqence_length) lstm.plot_results_multiple(predictions, y_test, seqence_length) #Save Model model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 model.save_weights("model.h5") p = model.predict(X_test) #Show result plt2.plot(p, color='red', label='prediction') plt2.plot(y_test, color='blue', label='actural') plt2.legend(loc='upper left')