Feature update: introduce mode_type and opt_type

app.py

@@ -8,15 +8,23 @@ from sklearn.metrics import mean_absolute_error, max_error, r2_score, mean_squar
 import matplotlib.pyplot as plt
 import streamlit.components.v1 as components
 import mpld3
+import time
 # ----------------------------------------------------------------------------------------------------------------------  # 
 # Settings:
 st.set_option('deprecation.showPyplotGlobalUse', False)
 
 # ----------------------------------------------------------------------------------------------------------------------  # 
 # Collecting User Input 
-## Preamble 
+## Preamble & Formatting
+
 st.markdown(f'<h1 style="color:#0096FF;font-size:54px;">{"No Code ML"}</h1>', unsafe_allow_html=True)
-st.markdown(f"This tool prepares a machine learning model, using your tabular data, from scratch. The model is then used to make predictions for various combinations of the provided data to try to obtain a combination that achieves the desired target value (if possible).")
+col1, mid, col2 = st.columns([10,1,20])
+with col1:
+    st.image('https://images.pexels.com/photos/2599244/pexels-photo-2599244.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=1')
+with col2:
+    st.markdown("""This tool prepares a machine learning model, using your tabular data, from scratch. The model is then used to make predictions for various combinations of the provided data to try to obtain a combination that achieves the desired target value (if possible). **Please direct any bug reports or inquiries to the <a href="http://cleanenergy.utoronto.ca/">clean energy lab at UofT</a>**""", unsafe_allow_html=True)
+st.markdown("""---""")
+
 st.markdown(f"**To use this tool**, fill out all the requested fields from top to bottom.")
 st.markdown(f"**Note:** If an error is obtained refresh the page and start over.")
 ## Column Name
@@ -25,21 +33,32 @@ target_col = st.text_input("Enter the exact name of the column with your target
 ## Model Type: Regression or Classifier 
 st.markdown(f'<h3 style="color:#000000;font-size:20px;">{"2) Select type of model you would like to build"}</h3>', unsafe_allow_html=True)
 mod_type = st.selectbox("What type of model would you like to train? Pick regression model for continous values and classifier for categorical values.", ('regression', 'classifier'))
-## Desired Target Value 
-st.markdown(f'<h3 style="color:#000000;font-size:20px;">{"3) What is the desired value?"}</h3>', unsafe_allow_html=True)
-if mod_type == 'regression':
-    desired_value = float(st.number_input("Enter the desired value for the target variable."))
+## Mode of Use
+st.markdown(f'<h3 style="color:#000000;font-size:20px;">{"3) Select mode of use"}</h3>', unsafe_allow_html=True)
+mode_type = st.selectbox("What would you like to use the tool for?", ('Benchmarking (finding the best algorithm for your problem)', 'Parameter Search (find combination of parameters to get a desired value)'))
+if mode_type == 'Parameter Search (find combination of parameters to get a desired value)': 
+    ## Desired Target Value 
+    st.markdown(f'<h3 style="color:#000000;font-size:20px;">{"4) Type of parameter search"}</h3>', unsafe_allow_html=True)
+    opt_type = st.selectbox("What do you want to do with the output?", ('Maximize it', 'Minimize it', 'Obtain a desired value'))
+    if mod_type == 'regression':
+        if opt_type == 'Move towards a desired value':
+            desired_value = float(st.number_input("Enter the desired value for the target variable."))
+    else:
+        desired_value = st.text_input("Enter the desired target parameter value. This field is case sensitive. (i.e., capital letters must match.)", key="DV for Classifier")
+    ## Ask for Dataset
+    st.markdown(f'<h3 style="color:#000000;font-size:20px;">{"5) Upload CSV file "}</h3>', unsafe_allow_html=True)
+    uploaded_file = st.file_uploader("Upload a CSV file", type="csv")
 else:
-    desired_value = st.text_input("Enter the desired target parameter value. This field is case sensitive. (i.e., capital letters must match.)", key="DV for Classifier")
-## Ask for Dataset
-st.markdown(f'<h3 style="color:#000000;font-size:20px;">{"4) Upload CSV file "}</h3>', unsafe_allow_html=True)
-uploaded_file = st.file_uploader("Upload a CSV file", type="csv")
+    ## Ask for Dataset
+    st.markdown(f'<h3 style="color:#000000;font-size:20px;">{"4) Upload CSV file "}</h3>', unsafe_allow_html=True)
+    uploaded_file = st.file_uploader("Upload a CSV file", type="csv")
 
 # ----------------------------------------------------------------------------------------------------------------------  # 
 if uploaded_file:
     # Read CSV File and Provide Preview of Data and Statistical Summary:
     data = pd.read_csv(uploaded_file)
-    
+    data_size = len(data)
+
     if target_col not in list(data.columns):
         st.error("ERROR: Provided name of the target column is not in the CSV file. Please make sure you provide the exact match (case sensitive).Please provide the correct label and try again.")
         exit()
@@ -50,40 +69,54 @@ if uploaded_file:
     st.write(data.describe())
 
     # Prepare Train/Test Split:
-    train_frac = 0.8
-    test_frac = 1 - train_frac
-    train_data = data.sample(frac=train_frac, random_state=0)
-    test_data = data.drop(train_data.index)
+    fraction_check = 20_000/data_size      # Cap Training Dataset to 20k to allow tuning to occur in a timely manner
+    if fraction_check < 0.8:
+        train_frac = fraction_check
+        train_data = data.sample(frac=train_frac, random_state=0)
+        test_data = data.drop(train_data.index)
+        if len(test_data) > 5_000:
+            test_data = test_data[0:5000]
+    else:
+        train_frac = 0.8
+        train_data = data.sample(frac=train_frac, random_state=0)
+        test_data = data.drop(train_data.index)
 
-# ----------------------------------------------------------------------------------------------------------------------  # 
     # Figure out Column Data Types 
     object_columns = data.select_dtypes(include="object").columns.tolist()
+
+# ----------------------------------------------------------------------------------------------------------------------  # 
     # Build Regression Model
     if mod_type == "regression":
         # Setup Regressor Problem
         if object_columns:
-            if len(data) > 20:
-                s = reg.setup(train_data, target = target_col, log_experiment=True, normalize=True, categorical_features=object_columns, fold=20, silent= True, experiment_name = 'No_code_ML')
+            if data_size > 20:
+                s = reg.setup(train_data, target = target_col, log_experiment=True, normalize=True, categorical_features=object_columns, fold=5, silent= True, experiment_name = 'No_code_ML')
             else:
-                s = reg.setup(data, target = target_col, log_experiment=True, normalize=True, categorical_features=object_columns, fold=20, silent= True, experiment_name = 'No_code_ML')        
+                s = reg.setup(data, target = target_col, log_experiment=True, normalize=True, categorical_features=object_columns, silent= True, experiment_name = 'No_code_ML')        
         else:        
-            if len(data) > 20:
-                s = reg.setup(train_data, target = target_col, log_experiment=True, normalize=True, silent= True, experiment_name = 'No_code_ML')
+            if data_size > 20:
+                s = reg.setup(train_data, target = target_col, log_experiment=True, normalize=True, silent= True, fold=5, experiment_name = 'No_code_ML')
             else:
                 s = reg.setup(data, target = target_col, log_experiment=True, normalize=True, silent= True, experiment_name = 'No_code_ML')        
 
         # Find the best algorithm to build Model:
         st.subheader("Algorithm Selection")
+        start_algo = time.time()
         with st.spinner(text="Finding the best algorithm for your dataset..."):
             best_mod = reg.compare_models()
             regression_results = reg.pull()
             best_mod_name = regression_results.Model[0]
             st.write(regression_results)
+        end_algo = time.time()
+        st.write('Time taken to select algorithm:', end_algo - start_algo, 'seconds')
 
         # Tune the hyperparameters for the best algorithm: 
         st.subheader("Tuning the Model")
+        start_tune = time.time()
         with st.spinner(text="Tuning the algorithm..."):
-            tuned_mod = reg.tune_model(best_mod, optimize = 'RMSE', n_iter=25)
+            tuned_mod = reg.tune_model(best_mod, optimize = 'RMSE', n_iter=5)
+        end_tune = time.time()
+        st.write('Time taken to select hyperparameters:', end_tune - start_tune, 'seconds')
 
         # Finalize the model (Train on the entire train dataset):
         with st.spinner("Finalizing the model..."):
@@ -125,37 +158,86 @@ if uploaded_file:
 
 # ----------------------------------------------------------------------------------------------------------------------  #         
         # Use Trained Model to Explore Parameter Space
-        st.subheader("Using the Trained Model to Optimize Target Variable:")
-        if object_columns:
-            st.write("Optimization with string data types not currently supported.")
-        else:
-            with st.spinner("Generating Parameter Combinations for Desired Value of the Target Variable"):
-                # Creating Variables for Data Generation Used in the Optimization Segment
-                list_of_cols = list(data.columns[0:-1])
-                # Figuring out Data Distribution of Original Data & Set Upper and Lower Bounds for New Parameters
-                data_spread = data[target_col].std()/5
-                max_list = [data[i].max() for i in list_of_cols]
-                min_list = [data[i].min() for i in list_of_cols]
-                dv_min = desired_value - data_spread
-                dv_max = desired_value + data_spread
-                
-                # Generate DF from New Parameters
-                generated_data = np.array([np.random.randint(low=min_list[i], high=max_list[i], size=10000) for i in range(0,len(max_list))]).T
-                generated_data_df = pd.DataFrame(generated_data)
-                generated_data_df.columns = list_of_cols
-
-                # Make Predictions with Trained Model & Display Top 10 Results Based on Distance from Desired Value
-                generated_predictions = reg.predict_model(final_mod, data = generated_data_df)
-                generated_predictions['distance_to_dv'] = np.abs(predictions['Label'] - desired_value)
-                proposed_values_to_try = generated_predictions[(generated_predictions["Label"] >=dv_min) & (generated_predictions["Label"] <=dv_max)]
-                proposed_values_to_try.sort_values('distance_to_dv', inplace=True)
-                proposed_values_to_try.reset_index(drop=True, inplace=True)
-                final_proposed_parameters = proposed_values_to_try[0:10]
-                if len(final_proposed_parameters) == 0:
-                    st.write("No parameters could be found for the desired value based on current model. Try collecting additional data or provide a different target value.")
-                else:
-                    st.write(final_proposed_parameters)
-                    st.download_button(label="Download the Proposed Parameters to Try", data = final_proposed_parameters.to_csv(index=False), file_name='Final_proposed_parameters.csv')
+        if mode_type == 'Parameter Search (find combination of parameters to get a desired value)':
+            if object_columns:
+                st.write("Optimization with string data types not currently supported.")
+            else:
+                with st.spinner("Generating parameter combinations for search"):
+                    # Creating Variables for Data Generation Used in the Optimization Segment
+                    list_of_cols = list(data.columns[0:-1])
+                    
+                    # Find min and max value for the input features in the training dataset
+                    max_list = [data[i].max() for i in list_of_cols]
+                    min_list = [data[i].min() for i in list_of_cols]
+
+                    # Generate DF from New Parameters
+                    generated_data = np.array([np.random.randint(low=min_list[i], high=max_list[i], size=50_000) for i in range(0,len(max_list))]).T
+                    generated_data_df = pd.DataFrame(generated_data, columns = list_of_cols)
+
+                    # Make Predictions with Trained Model
+                    generated_predictions = reg.predict_model(final_mod, data = generated_data_df)
+
+                if opt_type == 'Obtain a desired value':
+                    st.subheader("Using the trained model to obtain the desired target value:")
+
+                    # Filter results to get the places closed to desired value
+                    ## Determine +/- window for search 
+                    data_spread = data[target_col].std()/3   
+                    dv_min = desired_value - data_spread
+                    dv_max = desired_value + data_spread
+
+                    ## Apply +/- window to determine lower and upper bound to filter DF ('Generated_predictions)
+                    lower_bound = generated_predictions["Label"] >=dv_min
+                    upper_bound = generated_predictions["Label"] <=dv_max
+
+                    ## Filter DF using upper and lower bounds - sort values based on absolute distance to desired value provided by user.
+                    proposed_values_to_try = generated_predictions[lower_bound & upper_bound]
+                    generated_predictions['distance_to_desired_value'] = np.abs(generated_predictions['Label'] - desired_value)
+                    proposed_values_to_try.sort_values('distance_to_desired_value', inplace=True)
+                    proposed_values_to_try.reset_index(drop=True, inplace=True)
+                    
+                    ## Display top 10 rows
+                    final_proposed_parameters = proposed_values_to_try[0:10]
+
+                    if len(final_proposed_parameters) == 0:
+                        st.write("No parameters could be found for the desired value based on current model. Try collecting additional data or provide a different target value.")
+                    else:
+                        st.write(final_proposed_parameters)
+                        st.download_button(label="Download the Proposed Parameters to Try", data = final_proposed_parameters.to_csv(index=False), file_name='Final_proposed_parameters.csv')
+
+                if opt_type == 'Maximize it':
+                    st.subheader("Using the trained model to maximize target value:")
+                    generated_preds = generated_predictions.copy()
+                    
+                    # Sort results in descending order based on predicted values
+                    generated_preds.sort_values('Label', ascending=False, inplace=True)
+                    generated_preds.reset_index(drop=True, inplace=True)
+                    
+                    ## Display top 10 rows
+                    final_proposed_parameters = generated_preds[0:10]
+
+                    if len(final_proposed_parameters) == 0:
+                        st.write("No parameters could be found for the desired value based on current model. Try collecting additional data or provide a different target value.")
+                    else:
+                        st.write(final_proposed_parameters)
+                        st.download_button(label="Download the Proposed Parameters to Try", data = final_proposed_parameters.to_csv(index=False), file_name='Final_proposed_parameters.csv')
+
+                if opt_type == 'Minimize it':
+                    st.subheader("Using the trained model to minimize target value:")
+                    generated_preds = generated_predictions.copy()
+                    
+                    # Sort results in descending order based on predicted values
+                    generated_preds.sort_values('Label', inplace=True)
+                    generated_preds.reset_index(drop=True, inplace=True)
+                    
+                    ## Display top 10 rows
+                    final_proposed_parameters = generated_preds[0:10]
+
+                    if len(final_proposed_parameters) == 0:
+                        st.write("No parameters could be found for the desired value based on current model. Try collecting additional data or provide a different target value.")
+                    else:
+                        st.write(final_proposed_parameters)
+                        st.download_button(label="Download the Proposed Parameters to Try", data = final_proposed_parameters.to_csv(index=False), file_name='Final_proposed_parameters.csv')
 
 # ----------------------------------------------------------------------------------------------------------------------  # 
     # Build Classifier Model