hosting RNN Playgroung on hugging face

.gitattributes

@@ -32,3 +32,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.css filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,184 @@
+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
+
+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()))]
+
+
+if choice == 0:
+    st.title("Recurrent Neural Networks playground")
+    st.subheader("The purpose")
+    st.write("""\n
+        The goal of this app is to allow the user to experiment easily with Recurrent Neural Networks. Thanks to that, the app helps to understand: \n
+        - When to use recurrent neural networks
+        - Which scenarios are more straightforward for the RNN to predict and which are more difficult
+        - How the noise interrupts the predictions
+        - Difference between LSTM and GRU nodes
+        - Understanding that the increasing number of nodes doesn't always lead to better performance
+        """)
+
+    st.subheader("Typical use case")
+    st.write("""
+        1. Create a synthetic dataset, with a wide range of many choices of parameters
+        2. Create a Recurrent Neural Networks model by selecting a number of nodes in particular layers of the model
+        3. Automatically train the RNN model and make predictions
+        4. Compare the predicted values with the actual values
+        \n""")
+    st.subheader('The architecture of the model')
+    st.image('info.jpg', use_column_width=True, caption='Hover the cursor over image to see the enlarge button')
+    st.write(""" \n Use the radio buttons on the left to navigate between chapters \n \n \n \n""")
+
+elif choice == 1:
+
+    st.title(""" \n Implementation details""")
+    st.subheader("Front-end")
+    st.write("""\n
+                 The front-end part was made with the use of [the Streamlit library](https://www.streamlit.io/). 
+                 The parameters from the sidebar are used to create a dataset. The dataset is visualised using the Seaborn
+                 library and finally sent (with the parameters specifying the number of neurons in particular layers) to
+                 the back-end part through REST API. \n
+                 The front-end is served on Azure as a Web App. """)
+
+    st.subheader("Back-end")
+    st.subheader("[Since the playground is stored on HuggingFace now - the backend is a module of the frontend]")
+    st.write("""\n
+
+                     The backed-part is responsible for:
+                      - Retrieving the dataset from the front-end through REST API
+                      - Creating an RNN model using parameters passed from the user
+                      - Training the model
+                      - Predicting the values and returning them to the front-end \n
+
+                      The most crucial requirements are:
+                      - The neural networks setup has to be able to accurately predict the further shape of a curve for 
+                         the widest range of parameters selected by the user.
+                      - Time execution of the back-end part must be short. 
+                          - Which means balancing over tradeoff between the time needed for the response and the accuracy of the results
+                      - Cost efficiency
+                          - Since the app is desired to be on-line all the time, the serverless approach has been taken.
+                            That's why the back-end is served on Azure as a serverless Function App.
+
+                      """)
+
+else:
+
+    gran = 0.25
+    test_len = 8
+    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.subheader("Instructions:")
+    st.write("""
+            1. Modify the dataset by using the sliders in the Dataset group on the left on the screen.
+            2. Select the number of nodes in the model by using the sliders in the RNN setup group. 
+            3. Press the "Train and Predict" button to Train and Predict the model - note: many operations performing under the hood - please be patient.
+            4. The predicted values will be shown at the bottom of the page.
+            5. If you are not satisfied with the results - modify the model and try again!
+            6. Have fun!
+            \n""")
+
+    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_pred, Y_pred = np.append(X[-1], X_pred), np.append(Y[-1], Y_pred)
+
+    c1, c2, c3 = '#1e4a76', '#7dc0f7', '#ff7c0a'  # colors
+    # sns.scatterplot(x=X, y=Y, color=c1)
+    # st.pyplot()
+    sns.lineplot(x=X, y=Y, color=c1)
+    sns.lineplot(x=X_pred, y=Y_pred, color=c2, linestyle=':')
+    plt.ylim(min(-2, min(Y), min(Y_pred)), max(2, max(Y), max(Y_pred)))
+    plt.legend(['Train data', 'Test data'], loc=3)
+    plt.xlabel('Sample number')
+    plt.ylabel('Sample value')
+    st.pyplot()
+    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.')
+
+
+    if st.sidebar.button('Train and Predict'):
+        setup['values'] = list(Y)
+        reminder.empty()
+
+        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."""))
+
+        #  myUrl = 'http://localhost:7071/api/predict'
+        myUrl = 'https://rnn-background.azurewebsites.net/api/predict?code=a/X0yioXXY4CFVd9UFTw4MiyStNJ2qh3oae7FdFN7VBFMFhqe/qK7Q=='
+        # request = json.dumps(setup)
+        result = predict_series(data, steps=66, r1_nodes=14, r2_nodes=14, fc1_nodes=20)
+        # _ = [waiter.empty() for waiter in waiters]
+
+        result = np.array(range(5))
+
+        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)
+        plt.legend(['Train data', 'Test data', 'Predicted data'], loc=3)
+        plt.xlabel('Sample number')
+        plt.ylabel('Sample value')
+        st.pyplot()
+
+        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']))

button_style.css

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:388e988962ab53220113c1c3c41f470d8a3bde4e0cd43e0e45b1a51751a7816c
+size 163

predict.py

@@ -0,0 +1,152 @@
+import tensorflow.keras as tf
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+
+verbose = 0
+
+
+def predict_series(values, r1_nodes=5, r2_nodes=0, fc1_nodes=0, steps=20, use_lstm=True, *args, **kwargs):
+    
+    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.append(x)
+        Y.append(train[t + T])
+
+    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))
+    
+    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)
+    else:
+        x = rnn_layer(r1_nodes)(i)
+    if fc1_nodes:
+        x = tf.layers.Dense(fc1_nodes, activation='relu')(x)
+    x = tf.layers.Dense(1)(x)
+    model = tf.models.Model(i, x)
+    
+    
+    """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'
+    )
+
+    callbacks = [tf.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]
+
+
+    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]
+    
+    for i in range(1, len(pred)):
+        pred[i] += pred[i-1]
+    
+
+    result = {'result': list(pred.reshape(-1)), 'epochs': r.epoch[-1] + 1, 'loss': min(r.history['loss']), 'loss_last': r.history['loss'][-1]}
+    return result
+
+
+if __name__ == "__main__":
+    from time import time
+    t1 = time()
+    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')
+    sns.lineplot(x=range(30, 30+len(result['result'])), y=result['result'], color='b')

requirements.txt

@@ -0,0 +1,6 @@
+streamlit==1.17.0
+requests
+numpy
+seaborn
+matplotlib
+tensorflow