removed unnecessary code

app.py

@@ -2,13 +2,12 @@ import streamlit as st
 import numpy as np
 import matplotlib.pyplot as plt
 import seaborn as sns
-import requests
-import json
 
 from predict import predict_series
 
+#TODO: Refactor this module
+
 st.set_page_config(page_title='RNN Playground')
-#st.set_option('deprecation.showPyplotGlobalUse', False)
 
 pages = {'Intro': 0, 'Implementation details': 1, 'The model': 2}
 choice = pages[st.sidebar.radio("Select the chapter: ", tuple(pages.keys()))]

predict.py

@@ -4,6 +4,7 @@ from sklearn.preprocessing import StandardScaler
 
 verbose = 0
 
+# TODO: Refactor this module
 
 def predict_series(values, r1_nodes=5, r2_nodes=0, fc1_nodes=0, steps=20, use_lstm=True, *args, **kwargs):
     
@@ -25,56 +26,11 @@ def predict_series(values, r1_nodes=5, r2_nodes=0, fc1_nodes=0, steps=20, use_ls
     X = np.array(X).reshape(-1, T, 1)
     Y = np.array(Y)
 
-    nb_stats = 0
-    """
-    X_temp = np.zeros(X.size + nb_stats * len(X)).reshape(-1, T + nb_stats)
-
-    step_size = 1 / (len(X) + steps)
-
-
-    def update_stats(row):
-        new_stat = row[T:]
-        new_stat[0] += step_size  # number of sample
-
-        minimum = min(row[:T])  # minimum value, and when it occurred
-        if minimum < row[T + 1]:
-            new_stat[1], new_stat[2] = minimum, new_stat[0]
-
-        maximum = max(row[:T])  # maximum value, and when it occurred
-        if maximum > row[T + 3]:
-            new_stat[3], new_stat[4] = maximum, new_stat[0]
-        
-        new_stat[5] = (row[T + 5] * row[T] + row[T - 1]) / (new_stat[0])  # rolling average
-
-        difference10 = row[T - 1] - row[T - 11]  # the biggest difference within 10 items
-        if difference10 > row[T + 6]:
-            new_stat[6], new_stat[7] = difference10, new_stat[0]
-        if difference10 < row[T + 8]:
-            new_stat[8], new_stat[9] = difference10, new_stat[0]
-
-        abs_difference10 = abs(difference10)  # the biggest absolute difference within 10 items
-        if abs_difference10 > row[T + 10]:
-            new_stat[10], new_stat[11] = abs_difference10, new_stat[0]
-        if abs_difference10 < row[T + 12]:
-            new_stat[12], new_stat[13] = abs_difference10, new_stat[0]
-        
-        return new_stat
-
-    X_temp[0] = X[0]  #np.append(X[0])#, [0, np.inf, 0, -np.inf, 0])  #, 0, -np.inf, 0, +np.inf, 0, 0, 0, np.inf, 0])
-    for i in range(1, len(X)):
-        X_temp[i] = np.append(X[i][:T], X_temp[i - 1][T:])
-        X_temp[i][T:] = update_stats(X_temp[i])
-    """
-    #X = X_temp[1:].reshape(-1, T + nb_stats, 1)
-    #Y = Y[1:]
-
-    i = tf.layers.Input(shape=(T + nb_stats, 1))
-    
+    i = tf.layers.Input(shape=(T, 1))
     if use_lstm:
         rnn_layer = tf.layers.LSTM
     else:
         rnn_layer = tf.layers.GRU
-
     if r2_nodes:
         x = rnn_layer(r1_nodes, return_sequences=True)(i)
         x = rnn_layer(r2_nodes)(x)
@@ -85,16 +41,13 @@ def predict_series(values, r1_nodes=5, r2_nodes=0, fc1_nodes=0, steps=20, use_ls
     x = tf.layers.Dense(1)(x)
     model = tf.models.Model(i, x)
     
-    
+    # TODO: optimize execution time
     """lr_schedule = tf.optimizers.schedules.ExponentialDecay(
         initial_learning_rate=0.2,
         decay_steps=10,
         decay_rate=0.8)
     optimizer = tf.optimizers.Ftrl(learning_rate=0.001, learning_rate_power=-0.1)"""
-    #for i in range(0, 500, 10):
-        #print('{}: {}'.format(i, lr_schedule(i)))
-    
-    
+
     model.compile(
         loss='mse', #tf.losses.LogCosh(),
         optimizer=tf.optimizers.Adamax(lr=0.1) #LogCosh()'sgd'
@@ -116,16 +69,10 @@ def predict_series(values, r1_nodes=5, r2_nodes=0, fc1_nodes=0, steps=20, use_ls
     for _ in range(steps):
         p = model.predict(last_x.reshape(1, -1, 1))[0, 0]
         pred = np.append(pred, p)
-        #last_x[:T] = np.roll(last_x[:T], -1)
-        #last_x[T - 1] = p
-        #last_x[T:] = update_stats(last_x)
         last_x = np.roll(last_x, -1)
         last_x[-1] = p
 
     pred = sc.inverse_transform(pred.reshape(-1, 1))
-    # pred = np.array(pred).astype('float64')
-    # pred = list(pred)
-    # logging.info(pred)
     
     pred.reshape(-1)
     pred[0] = train_last_value + pred[0]