change app name

streamlit_app.py

@@ -1,174 +0,0 @@
-# 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))