first commit

requirements.txt

@@ -0,0 +1,4 @@
+matplotlib==3.5.3
+mpld3==0.5.9
+pycaret==2.3.10
+streamlit==1.16.0

streamlit_app.py

@@ -0,0 +1,174 @@
+# Module Imports
+import pandas as pd
+import numpy as np
+import streamlit as st
+from pycaret import regression as reg
+from pycaret import classification as clf
+from sklearn.metrics import mean_absolute_error, max_error, r2_score, mean_squared_error
+import matplotlib.pyplot as plt
+import streamlit.components.v1 as components
+import mpld3
+# ----------------------------------------------------------------------------------------------------------------------  # 
+# Collecting User Input 
+## Preamble 
+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).")
+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
+st.markdown(f'<h3 style="color:#000000;font-size:20px;">{"1) Provide name of the column you want to predict with model."}</h3>', unsafe_allow_html=True)
+target_col = st.text_input("Enter the exact name of the column with your target variable. This field is case sensitive. (i.e., capital letters must match.)")
+## 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."))
+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")
+
+# ----------------------------------------------------------------------------------------------------------------------  # 
+if uploaded_file:
+    # Read CSV File and Provide Preview of Data and Statistical Summary:
+    data = pd.read_csv(uploaded_file)
+    
+    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()
+
+    st.subheader("Data preview:")
+    st.write(data.head())
+    st.subheader("Statistical Summary of the Provided Data:")
+    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)
+
+# ----------------------------------------------------------------------------------------------------------------------  # 
+    # 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')
+            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')        
+        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')
+            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")
+        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)
+
+        # Tune the hyperparameters for the best algorithm: 
+        st.subheader("Tuning the Model")
+        with st.spinner(text="Tuning the algorithm..."):
+            tuned_mod = reg.tune_model(best_mod, optimize = 'RMSE', n_iter=25)
+
+        # Finalize the model (Train on the entire train dataset):
+        with st.spinner("Finalizing the model..."):
+            final_mod = reg.finalize_model(tuned_mod)
+
+        st.success('Model successfully trained! Here are your results:')
+        st.write('Best algorithm: ', best_mod_name)
+        st.write('Best hyperparameters: ', final_mod.get_params())
+
+        # Print a SHAP Analysis Summary Plot:
+        st.subheader("SHAP Analysis Summary Plot")        
+        st.pyplot(reg.interpret_model(final_mod))
+
+        if len(data) > 20:
+            # Predict on the test set if it was created:
+            st.subheader("Evaluating model on the test/hold out data:")
+            predictions = reg.predict_model(final_mod, data=test_data)
+            st.success('Here are your results:')
+            st.write(predictions)
+            st.caption('"Label" is the value predicted by the model.')
+
+            # Accuracy of predictions:
+            MAE_val = mean_absolute_error(predictions[target_col], predictions['Label'])
+            RMSE_err = mean_squared_error(predictions[target_col], predictions['Label'], squared=False)
+            Max_err = max_error(predictions[target_col], predictions['Label'])
+            r2_val = r2_score(predictions[target_col], predictions['Label'])
+            err_dict = {'Mean Absolute Error': MAE_val, 'Root Mean Squared Error': RMSE_err, 'Maximum Error': Max_err}
+            df_err = pd.DataFrame(err_dict, index=[0])
+            st.write(df_err)
+
+            # Create an true vs. predicted plot 
+            fig = plt.figure(figsize=(8,8))
+            plt.grid(b=None)
+            plt.scatter(x=predictions[target_col], y=predictions['Label'])
+            plt.xlabel("True Value", fontsize=18)
+            plt.ylabel("Predicted Value", fontsize=18)
+            fig_html = mpld3.fig_to_html(fig)
+            components.html(fig_html, height=1000)
+
+# ----------------------------------------------------------------------------------------------------------------------  #         
+        # 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')
+
+# ----------------------------------------------------------------------------------------------------------------------  # 
+    # Build Classifier Model
+    # if mod_type == "classifier":
+    #     # Setup Classifier Problem
+    #     s = clf.setup(train_data, target = target_col, log_experiment=True, normalize=True, silent= True, experiment_name = 'QD_ML')
+
+    #     # Compare Model Performance:
+    #     st.subheader("Algorithm Selection")
+    #     with st.spinner(text="Finding the best algorithm for your model..."):
+    #         best_mod = clf.compare_models()
+    #         regression_results = clf.pull()
+
+    #     st.balloons()
+    #     st.success('Model successfully trained! Here are your results:')
+    #     st.write(regression_results)
+
+    #     # Print a SHAP Analysis Summary Plot:
+    #     st.subheader("SHAP Analysis Summary Plot")        
+    #     st.pyplot(clf.interpret_model(best_mod))