refactoring part1 - minor perf updates, removed single letter names, moved functions to separate files

app.py

@@ -1,10 +1,15 @@
-import streamlit as st
-import numpy as np
 import matplotlib.pyplot as plt
+import numpy as np
 import seaborn as sns
+import streamlit as st
 
+from app_helper_functions import generate_wave, local_css, user_input_features
 from predict import predict_series
 
+points_granularity = 0.25
+test_len = 8
+
+
 #TODO: Refactor this module
 
 st.set_page_config(page_title='RNN Playground')
@@ -69,46 +74,10 @@ elif choice == 1:
                       """)
 
 else:
-
-    gran = 0.25
-    test_len = 8
+    # Print instructions
     st.sidebar.header('User Input Parameters')
-
-
-    def user_input_features():
-        predefined_sets = {'length': [30, ], 'period': [1.34, ], 'amplitude': [0.64, ], 'growth': [0.04, ],
-            'amplitude_growth': [0.03, ], 'r1_nodes': [20, ], 'r2_nodes': [20, ], 'fc1_nodes': [34, ]}
-
-        data, nn = {}, {}
-        st.sidebar.header('Dataset:')
-        data['length'] = st.sidebar.slider('Training data length', 20, 50, 28)
-        data['period'] = st.sidebar.slider('Period of the wave', 0.75, 2.0, 1.0)
-        data['growth'] = st.sidebar.slider('Values growth', -0.25, 0.25, 0.0)
-        data['amplitude'] = st.sidebar.slider('Amplitude', 0.25, 1.75, 1.0)
-        data['amplitude_growth'] = st.sidebar.slider('Amplitude growth', -0.01, 0.1, 0.0)
-        data['noise'] = st.sidebar.slider('Noise', 0.0, 1.0, 0.0)
-        st.sidebar.header('Model setup')
-        nn['use_lstm'] = st.sidebar.radio('Select the type of Recurrent Neuron to use', ['LSTM', 'GRU']) == 'LSTM'
-        nn['r1_nodes'] = st.sidebar.slider('Number of nodes in the first RNN layer', 1, 30, 13)
-        nn['r2_nodes'] = st.sidebar.slider('Number of nodes in the second RNN layer', 0, 30, 0)
-        nn['fc1_nodes'] = st.sidebar.slider('Number of nodes in the fully connected RNN layer', 0, 40, 10)
-        nn['steps'] = len(np.arange(0, test_len, gran))
-
-        #if st.sidebar.button('Load one of the pretested configurations'):
-            #i = st.sidebar.selectbox('Select:', [-1, 0])
-            #i = int(np.random.rand(len(predefined_sets['length'])))  # Selecting one pretested configuration
-            #data.update({k: predefined_sets[k][i] for k in set(data) & set(predefined_sets)})
-            #nn.update({k: predefined_sets[k][i] for k in set(nn) & set(predefined_sets)})"""
-
-
-        return data, nn
-
-
-    params, setup = user_input_features()
-
-    st.header("""Refactoring & performance updates in progress!
-                 please be back in a few days""")
-
+    params, setup = user_input_features(test_len, points_granularity)
+    st.header("""Refactoring & performance updates in progress!""")
     st.subheader("Instructions:")
     st.write("""
             1. Modify the dataset by using the sliders in the Dataset group on the left on the screen.
@@ -119,24 +88,17 @@ else:
             6. Have fun!
             \n""")
 
+    # Generate and present generated data
     st.subheader("Generated data:")
-    X = np.arange(0, params['length'], gran)
-    X_pred = np.arange(params['length'], params['length'] + test_len, gran)
-
-
-    def generate_wave(x_set):
-        return np.sin(x_set / params['period']) * (1 + params['amplitude_growth'] * x_set) * params[
-            'amplitude'] + x_set * params['growth'] + params['noise']*np.random.randn(len(x_set))
-
-
-    Y = generate_wave(X)
-    Y_pred = generate_wave(X_pred)
+    X = np.arange(0, params['length'], points_granularity)
+    X_pred = np.arange(params['length'], params['length'] + test_len, points_granularity)
 
+    Y = generate_wave(X, params)
+    Y_pred = generate_wave(X_pred, params)
     X_pred, Y_pred = np.append(X[-1], X_pred), np.append(Y[-1], Y_pred)
 
+    # TODO: move plotting to separate funtion
     c1, c2, c3 = '#1e4a76', '#7dc0f7', '#ff7c0a'  # colors
-    # sns.scatterplot(x=X, y=Y, color=c1)
-    # st.pyplot()
     fig, ax = plt.subplots()
     sns.lineplot(x=X, y=Y, color=c1)
     sns.lineplot(x=X_pred, y=Y_pred, color=c2, linestyle=':')
@@ -146,38 +108,34 @@ else:
     plt.ylabel('Sample value')
     st.pyplot(fig)
     st.write("The plot presents generated train and test data. Use the sliders on the left to modify the curve.")
-
-
-    def local_css(file_name):
-        with open(file_name) as f:
-            st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
     local_css("button_style.css")
-
     st.subheader('Predicted data:')
     reminder = st.text('Press the train and predict button on the sidebar once you are ready with the selections.')
 
-
+    # Calc and post-calc flow
     if st.sidebar.button('Train and Predict'):
         setup['values'] = list(Y)
         reminder.empty()
 
+        # Waiters - contains what should be shown pior to receiving results - it's removed afterwards
         waiters = list()
         waiters.append(st.text('Please wait till the train and predict process is finished.'))
         waiters.append(st.image('wait.gif'))
         waiters.append(st.text("""The process should take around 20-60 seconds."""))
-
         result = predict_series(**setup)
-
         _ = [waiter.empty() for waiter in waiters]
+
+        # Plot results
         fig, ax = plt.subplots()
         sns.lineplot(x=X_pred, y=Y_pred, color=c2, linestyle=':')
         sns.lineplot(x=X, y=Y, color=c1)
-        sns.lineplot(np.append(X[-1], np.arange(0, test_len, gran) + max(X) + gran), np.append(Y[-1], result['result']), color=c3)
+        sns.lineplot(np.append(X[-1], np.arange(0, test_len, points_granularity) + max(X) + points_granularity), np.append(Y[-1], result['result']), color=c3)
         plt.legend(['Train data', 'Test data', 'Predicted data'], loc=3)
         plt.xlabel('Sample number')
         plt.ylabel('Sample value')
         st.pyplot(fig)
 
+        # Print statistics
         st.write("The prediction isn't good enough? Try to change settings in the model setup or increase the dataset length.")
         st.write('Training took {} epochs, Mean Squared Error: {:.2e}'.format(result['epochs'], result['loss']))
         #st.write('Training took {} epochs, Mean Squared Error {}, last loss {}'.format(result['epochs'], result['loss'], result['loss_last']))

app_helper_functions.py

@@ -0,0 +1,29 @@
+import numpy as np
+import streamlit as st
+
+def user_input_features(test_len, points_granularity):
+    data, nn = {}, {}
+    st.sidebar.header('Dataset:')
+    data['length'] = st.sidebar.slider('Training data length', 20, 50, 28)
+    data['period'] = st.sidebar.slider('Period of the wave', 0.75, 2.0, 1.0)
+    data['growth'] = st.sidebar.slider('Values growth', -0.25, 0.25, 0.0)
+    data['amplitude'] = st.sidebar.slider('Amplitude', 0.25, 1.75, 1.0)
+    data['amplitude_growth'] = st.sidebar.slider('Amplitude growth', -0.01, 0.1, 0.0)
+    data['noise'] = st.sidebar.slider('Noise', 0.0, 1.0, 0.0)
+    st.sidebar.header('Model setup')
+    nn['use_lstm'] = st.sidebar.radio('Select the type of Recurrent Neuron to use', ['LSTM', 'GRU']) == 'LSTM'
+    nn['r1_nodes'] = st.sidebar.slider('Number of nodes in the first RNN layer', 1, 30, 13)
+    nn['r2_nodes'] = st.sidebar.slider('Number of nodes in the second RNN layer', 0, 30, 0)
+    nn['fc1_nodes'] = st.sidebar.slider('Number of nodes in the fully connected RNN layer', 0, 40, 10)
+    nn['steps'] = len(np.arange(0, test_len, points_granularity))
+
+    return data, nn
+
+
+def generate_wave(x_set, params):
+    return np.sin(x_set / params['period']) * (1 + params['amplitude_growth'] * x_set) * params[
+        'amplitude'] + x_set * params['growth'] + params['noise']*np.random.randn(len(x_set))
+
+def local_css(file_name):
+    with open(file_name) as f:
+        st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)

predict.py

@@ -1,98 +1,82 @@
-import tensorflow.keras as tf
 import numpy as np
 from sklearn.preprocessing import StandardScaler
+from tensorflow import keras
 
 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):
-    
+def predict_series(values, r1_nodes=10, r2_nodes=0, fc1_nodes=0, steps=20, use_lstm=True, seq_length = 15, *args, **kwargs):
+    # TODO: simplify and optimize creating windows
     train = np.array(values)
-    
     train_last_value = train[-1]
     train = train[1:] - train[:-1]
     sc = StandardScaler()
     train = sc.fit_transform(train.reshape(-1, 1))
 
-    T = 25
-    X = []
-    Y = []
-    for t in range(len(train) - T):
-        x = train[t:t + T]
+    X, Y = [], []
+    for t in range(len(train) - seq_length):
+        x = train[t:t + seq_length]
         X.append(x)
-        Y.append(train[t + T])
-
-    X = np.array(X).reshape(-1, T, 1)
+        Y.append(train[t + seq_length])
+    X = np.array(X).reshape(-1, seq_length, 1)
     Y = np.array(Y)
 
-    i = tf.layers.Input(shape=(T, 1))
+    # TODO: Add SimpleRNN
     if use_lstm:
-        rnn_layer = tf.layers.LSTM
+        rnn_layer = keras.layers.LSTM
     else:
-        rnn_layer = tf.layers.GRU
+        rnn_layer = keras.layers.GRU
+
+    model = keras.Sequential()
+    model.add(rnn_layer(r1_nodes, return_sequences=bool(r2_nodes)))
     if r2_nodes:
-        x = rnn_layer(r1_nodes, return_sequences=True)(i)
-        x = rnn_layer(r2_nodes)(x)
-    else:
-        x = rnn_layer(r1_nodes)(i)
+        model.add(rnn_layer(r2_nodes))
     if fc1_nodes:
-        x = tf.layers.Dense(fc1_nodes, activation='relu')(x)
-    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)"""
+        model.add(keras.layers.Dense(fc1_nodes, activation='relu'))
+    model.add(keras.layers.Dense(1))
 
+    # TODO: optimize execution time
     model.compile(
-        loss='mse', #tf.losses.LogCosh(),
-        optimizer=tf.optimizers.Adamax(lr=0.1) #LogCosh()'sgd'
-    )
-
-    callbacks = [tf.callbacks.EarlyStopping(patience=150, monitor='loss', restore_best_weights=True)]
+        loss='mse',
+        optimizer=keras.optimizers.Adamax(lr=0.2))
 
+    callbacks = [keras.callbacks.EarlyStopping(patience=150, monitor='loss', restore_best_weights=True)]
     r = model.fit(
         X, Y,
         epochs=500,
         callbacks=callbacks,
         verbose=verbose,
-        validation_split=0.0
-    )
-    pred = np.array([])
-    last_x = X[-1]
+        validation_split=0.0)
 
+    predictions = np.array([])
+    last_x = X[-1]
 
     for _ in range(steps):
         p = model.predict(last_x.reshape(1, -1, 1))[0, 0]
-        pred = np.append(pred, p)
+        predictions = np.append(predictions, p)
         last_x = np.roll(last_x, -1)
         last_x[-1] = p
 
-    pred = sc.inverse_transform(pred.reshape(-1, 1))
-    
-    pred.reshape(-1)
-    pred[0] = train_last_value + pred[0]
-    
-    for i in range(1, len(pred)):
-        pred[i] += pred[i-1]
+    predictions = sc.inverse_transform(predictions.reshape(-1, 1))
+    predictions.reshape(-1)
+    predictions[0] = train_last_value + predictions[0]
     
+    for i in range(1, len(predictions)):
+        predictions[i] += predictions[i-1]
 
-    result = {'result': list(pred.reshape(-1)), 'epochs': r.epoch[-1] + 1, 'loss': min(r.history['loss']), 'loss_last': r.history['loss'][-1]}
+    result = {'result': list(predictions.reshape(-1)), 'epochs': r.epoch[-1] + 1, 'loss': min(r.history['loss']), 'loss_last': r.history['loss'][-1]}
     return result
 
 
 if __name__ == "__main__":
+    # Code for debugging/testing
     from time import time
     t1 = time()
-    verbose = 2
+    # verbose = 2
     data = np.sin(np.arange(0.0, 28.0, 0.35)*2)
     result = predict_series(data, steps=66, r1_nodes=14, r2_nodes=14, fc1_nodes=20)
     print('exec time: {:8.3f}'.format(time()-t1))
-    #print(result['result'][:2])
     print(print(result['epochs'], result['loss']))
     import seaborn as sns
     sns.lineplot(x=range(30), y=data[-30:], color='r')