Upload 12 files

.streamlit/config.toml

@@ -0,0 +1,7 @@
+
+[theme]
+primaryColor="#F63366"
+backgroundColor="#002148"
+secondaryBackgroundColor="#576c86"
+textColor="white"
+font="serif"

app.py

@@ -8,6 +8,7 @@ import evaluationer,models, null_value_handling
 import auto_optimizer
 from sklearn.experimental import enable_iterative_imputer
 from sklearn.impute import SimpleImputer, IterativeImputer
+import eda
 # st.set_page_config(layout="wide")
 
 st.set_page_config(
@@ -21,7 +22,23 @@ st.set_page_config(
  }
 )
 
-import streamlit as st
+
+
+# Set the background image
+background_image = """
+<style>
+[data-testid="stAppViewContainer"] > .main {
+ background-image: url("https://w.wallhaven.cc/full/jx/wallhaven-jx7w25.png");
+ background-size: 100vw 100vh; # This sets the size to cover 100% of the viewport width and height
+ background-position: center; 
+ background-repeat: no-repeat;
+}
+</style>
+"""
+
+st.markdown(background_image, unsafe_allow_html=True)
+
+
 
 # Title with Rainbow Transition Effect and Neon Glow
 html_code = """
@@ -67,23 +84,74 @@ html_code = """
 """
 
 st.markdown(html_code, unsafe_allow_html=True)
+st.divider()
+
+st.markdown(
+ """
+ <style>
+ .success-message {
+ font-family: Arial, sans-serif;
+ font-size: 24px;
+ color: green;
+ text-align: left;
+ }
+ .unsuccess-message {
+ font-family: Arial, sans-serif;
+ font-size: 24px;
+ color: red;
+ text-align: left;
+ }
+ .prompt-message {
+ font-family: Arial, sans-serif;
+ font-size: 24px;
+ color: #333;
+ text-align: center;
+ }
+ .success-message2 {
+ font-family: Arial, sans-serif;
+ font-size: 18px;
+ color: white;
+ text-align: left;
+ }
+ .message-box {
+ text-align: center;
+ background-color: white;
+ padding: 5px;
+ border-radius: 10px;
+ box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+ font-size: 24px;
+ color: #333;
+ }
+ </style>
+ """,
+ unsafe_allow_html=True
+)
 
 
+# st.markdown('<p class="success-message">Train File uploaded successfully. ✅</p>', unsafe_allow_html=True)
 # file uploader 
 csv_upload = st.sidebar.file_uploader("Input CSV File for ML modelling", type=['csv'])
+
+sep = st.sidebar.text_input("Input Seperator")
+if (len(sep) ==0):
+ sep = ","
 csv_upload2 = st.sidebar.file_uploader("Input CSV File of Test Data Prediction",type = ["csv"])
+
 test = pd.DataFrame()
 if csv_upload is not None:
  # read the uploaded file into dataframe
- df = pd.read_csv(csv_upload)
+ df = pd.read_csv(csv_upload,sep = sep)
 
  # saving the dataframe to a CSV file
  df.to_csv('csv_upload.csv', index=False)
- st.write("Train File uploaded successfully. ✅")
-
+ st.markdown('<p class="success-message">Train File uploaded successfully. ✅</p>', unsafe_allow_html=True)
+ 
  if csv_upload2 is not None:
- test = pd.read_csv(csv_upload2)
- id_col = st.selectbox("select column for submission i.e, ID",test.columns)
+ test = pd.read_csv(csv_upload2,sep = sep)
+ st.markdown('<p class="success-message">Test File uploaded successfully. ✅</p>', unsafe_allow_html=True)
+ st.divider()
+ id_col = st.selectbox("Select Column for Submission i.e, ID",test.columns)
+ st.divider()
  submission_id = test[id_col]
  # st.write("Train File upl",submission_id)
 
@@ -93,8 +161,10 @@ if csv_upload is not None:
  if len(test) >0:
  # saving the test dataframe to a CSV file
  test.to_csv('csv_upload_test.csv', index=False)
- st.write("Test File uploaded successfully. ✅")
+ 
  
+ st.markdown('<p class="message-box">Display Data</p>', unsafe_allow_html=True)
+ st.write("")
  display_train_data = st.radio("Display Train Data",["Yes","No"],index = 1)
  if display_train_data == "Yes":
  st.dataframe(df.head())
@@ -104,29 +174,40 @@ if csv_upload is not None:
  if display_test_data == "Yes":
  st.dataframe(test.head())
 
- 
- if st.radio("Select Supervision Category",["Supervised","Un-Supervised"],index =0) == "Supervised":
- 
- selected_column = st.selectbox('Select Target column', df.columns, index=(len(df.columns)-1))
+ st.divider()
+ st.markdown('<div class="message-box success">Select Supervision Category</div>', unsafe_allow_html=True)
+ if st.radio("",["Supervised","Un-Supervised"],index =0) == "Supervised":
+ st.divider()
+
+ st.write('<p class="success-message2">Select Target column</p>', unsafe_allow_html=True)
+ selected_column = st.selectbox('', df.columns, index=(len(df.columns)-1))
  
  # Display the selected column
  st.write('You selected:', selected_column)
- 
+ st.divider()
+
+ st.markdown('<div class="message-box success ">Perform EDA</div>', unsafe_allow_html=True)
+ st.write("")
+ if st.checkbox("Proceed to perform EDA"):
+ eda.eda_analysis(df)
+ st.write('<p class="success-message">EDA Performed proceed for Pre-processing</p>', unsafe_allow_html=True)
+ st.divider()
  y = df[selected_column]
  
  if y.dtype == "O":
- st.write("⚠️⚠️⚠️ Target Column is Object Type ⚠️⚠️⚠️")
- if st.radio("Proceed for Label Encoding ",["Yes","No"],index = 1) == "Yes": 
+ st.markdown('<p class="unsuccess-message">⚠️⚠️⚠️ Target Column is Object Type ⚠️⚠️⚠️</p>', unsafe_allow_html=True)
+ 
+ if st.checkbox("Proceed for Label Encoding "): 
  from sklearn.preprocessing import LabelEncoder
  le = LabelEncoder()
  y= pd.Series(le.fit_transform(y))
- st.write("Label Encoding Completed ✅")
- 
- if st.radio("Display Target Column",["Yes","No"],index =1) == "Yes":
+ st.markdown('<p class="success-message">Label Encoding Completed ✅</p>', unsafe_allow_html=True)
+ if st.checkbox("Display Target Column"):
  st.dataframe(y.head())
 
-
- select_target_trans = st.radio("Target column Transformation",["Yes","No"],index = 1)
+ st.divider()
+ st.markdown('<div class="message-box success">Target column Transformation</div>', unsafe_allow_html=True)
+ select_target_trans = st.radio("",["Yes","No"],index = 1)
  if select_target_trans == "Yes":
  selected_transformation = st.selectbox("Select Transformation method",["Log Transformation","Power Transformation"])
  if selected_transformation == "Log Transformation":
@@ -155,36 +236,52 @@ if csv_upload is not None:
  
  if st.radio("Display Target Column after Transformation",["Yes","No"],index =1) == "Yes":
  st.dataframe(y.head())
-# inverse of transformation
+
+
 
  X = df.drop(columns = selected_column)
 
  if st.radio("Display X-Train Data",["Yes","No"],index =1) == "Yes":
  st.dataframe(X.head())
- if st.radio("Check for duplicate Values",["Yes","No"],index = 1) == "Yes": 
+ st.divider()
+
+ # st.checkbox() 
+ st.markdown('<div class="message-box success">Check for duplicate Values</div>', unsafe_allow_html=True)
+ if st.radio(" ",["Yes","No"],index = 1) == "Yes": 
  len_duplicates = len(X[X.duplicated()])
  if len_duplicates >0:
  st.write(f"There are {len_duplicates} duplicate values in Train")
+ if st.checkbox("Show Duplicate values"):
+ st.dataframe(X[X.duplicated()])
  if st.selectbox("Drop Duplicate values",["Yes","No"],index = 1) == "Yes":
  X = X.drop_duplicates()
  st.write("Duplicate values removed ✅")
  else:
  st.write("There are no duplicate values in Train")
+ st.divider() 
  # dropping not important columns
- if st.radio("Drop Un-Important Column(s)",["Yes","No"],index = 1) == "Yes":
+ st.markdown('<div class="message-box success">Drop Unimportant Columns</div>', unsafe_allow_html=True)
+ if st.radio(" ",["Yes","No"],index = 1) == "Yes":
  selected_drop_column = st.multiselect('Select columns to be dropped', X.columns)
  X = X.drop(columns = selected_drop_column)
  if len(test) >0:
  test = test.drop(columns = selected_drop_column)
- st.write("Un-Important column(s) Delected ✅")
+ st.write("Un-Important column(s) Deleted ✅")
  st.dataframe(X.head())
 
+ st.divider()
  num_cols = X.select_dtypes(exclude = "O").columns 
  cat_cols = X.select_dtypes(include = "O").columns
  st.write("Numerical Columns in Train Data: ", tuple(num_cols))
  st.write("Categorical Columns in Train Data: ", tuple(cat_cols))
-
- if st.radio("Select method for ML modelling", ["Manual","Auto Optimized"],index = 0) == "Auto Optimized":
+ if st.sidebar.button("Clear Evaluation DataFrame"):
+ evaluationer.reg_evaluation_df = evaluationer.reg_evaluation_df.drop(index =evaluationer.reg_evaluation_df.index)
+ evaluationer.classification_evaluation_df = evaluationer.classification_evaluation_df.drop(index =evaluationer.reg_evaluation_df.index)
+ st.divider() 
+ # markdown
+ st.markdown('<div class="message-box success">Select method for ML modelling</div>', unsafe_allow_html = True)
+ if st.radio(" ", ["Manual","Auto Optimized"],index = 0) == "Auto Optimized":
+ st.divider()
  ml_cat_ao = st.radio("Select Machine Learning Category",["Regression","Classification"],index =0)
 
  if ml_cat_ao =="Regression":
@@ -192,7 +289,7 @@ if csv_upload is not None:
  st.write("Select ML algorithm")
  reg_model_name = st.selectbox("select model",models.Regression_models.index) 
  reg_model = models.Regression_models.loc[reg_model_name].values[0]
- auto_optimizer.Auto_optimizer(X,y,eva,reg_model)
+ auto_optimizer.Auto_optimizer(X,y,eva,reg_model,reg_model_name)
 
  elif ml_cat_ao =="Classification":
  eva = "class"
@@ -201,10 +298,12 @@ if csv_upload is not None:
  class_model = models.Classification_models.loc[class_model_name].values[0]
  auto_optimizer.Auto_optimizer(X,y,eva,class_model)
  
-
+ 
  else:
+ st.divider()
  if X.isnull().sum().sum() >0 :
- st.write("⚠️⚠️⚠️ There are missing values in Train Data ⚠️⚠️⚠️")
+ 
+ st.markdown('<p class="unsuccess-message">⚠️⚠️⚠️ There are missing values in Train Data ⚠️⚠️⚠️</p>', unsafe_allow_html=True)
 
  if st.selectbox("Drop null values or Impute",["Drop Null Values","Impute Null Values"],index = 1) == "Drop Null Values":
 
@@ -241,7 +340,9 @@ if csv_upload is not None:
  
 
  clean_num_nvh_df_cat = pd.DataFrame()
+ 
  if X[cat_cols].isnull().sum().sum() >0:
+ st.divider()
  st.write("Categorical Columns with Percentage of Null Values: ")
  cat_cols_nvh = X[cat_cols].isnull().sum()[X[cat_cols].isnull().sum()>0].index
  st.dataframe(round(X[cat_cols].isnull().sum()[X[cat_cols].isnull().sum()>0]/len(X)*100,2))
@@ -270,33 +371,41 @@ if csv_upload is not None:
  null_value_handling.null_handling(X,clean_num_nvh_df,clean_num_nvh_df_cat)
  st.write("X Data after Null value handling", X.head())
 
- new_df = pd.concat([X,y[X.index]],axis = 1)
- 
- csv = new_df.to_csv(index = False)
- if st.radio("Download Null Value Handled DataFrame as CSV File ? ",["Yes","No"],index = 1) == "Yes": 
- st.download_button(label="Download Null Value Handled CSV File",data=csv,file_name='NVH_DataFrame.csv',mime='text/csv')
-
+ new_df = pd.concat([X,y[X.index]],axis = 1)
+ 
+ csv = new_df.to_csv(index = False)
+ 
+ st.markdown('<p class="success-message">Null Values Handled Successfully. ✅</p>', unsafe_allow_html=True)
+ if st.checkbox("Download Null Value Handled DataFrame as CSV File ? "): 
+ st.download_button(label="Download Null Value Handled CSV File",data=csv,file_name='NVH_DataFrame.csv',mime='text/csv')
+ st.divider()
  ord_enc_cols = []
 
  if len(cat_cols) == 0:
  st.write("No Categorical Columns in Train")
  else:
- st.write("Select Columns for Ordinal Encoding")
+ st.markdown('<div class="message-box success">Features Encoding</div>', unsafe_allow_html=True)
+ st.markdown('<p class="unsuccess-message">There are Object type Features in Train Data ⚠️</p>', unsafe_allow_html=True)
+ st.markdown('<p class="success-message2">Select Columns for Ordinal Encoding</p>', unsafe_allow_html=True)
+ 
  for column in cat_cols:
 
  selected = st.checkbox(column)
  if selected:
  st.write(f"No. of Unique value in {column} column are", X[column].nunique())
  ord_enc_cols.append(column)
+ st.divider()
  ohe_enc_cols = set(cat_cols) -set(ord_enc_cols)
  ohe_enc_cols = list(ohe_enc_cols)
  if len(ord_enc_cols)>0:
  st.write("ordinal encoded columns" ,tuple(ord_enc_cols))
  if len(ohe_enc_cols)>0:
  st.write("one hot encoded columns" ,tuple(ohe_enc_cols))
-
+ st.divider()
+ st.markdown('<div class="message-box success">Proceed for Encoding</div>', unsafe_allow_html=True)
  if len(ord_enc_cols)>0:
- if st.radio("proceed for ordinal encoding",["Yes","No"],index = 1) == "Yes":
+ 
+ if st.checkbox("Proceed for Ordinal Encoding"):
  ordinal_order_vals = []
 
  for column in ord_enc_cols:
@@ -317,7 +426,7 @@ if csv_upload is not None:
  st.write("Ordinal Encoding Completed ✅")
 
  if len(ohe_enc_cols)>0:
- if st.radio("proceed for OnehotEncoding ",["Yes","No"],index = 1) == "Yes": # import one hot encoder
+ if st.checkbox("Proceed for OneHotEncoding "): # import one hot encoder
  from sklearn.preprocessing import OneHotEncoder
  ohe = OneHotEncoder(sparse_output = False,handle_unknown = "ignore")
  pd.options.mode.chained_assignment = None
@@ -331,39 +440,43 @@ if csv_upload is not None:
 
  st.write("DataFrame after One Hot Encoding",X.head())
  st.write("OneHot Encoding Completed ✅")
- 
+ st.divider()
  new_df = pd.concat([X,y],axis = 1)
  
  csv = new_df.to_csv(index = False)
- if st.radio("Download Encoded DataFrame as CSV File ? ",["Yes","No"],index = 1) == "Yes": 
+ if st.checkbox("Download Encoded DataFrame as CSV File ? "): 
  st.download_button(label="Download Ordinal Encoded CSV File",data=csv,file_name='Encoded_DataFrame.csv',mime='text/csv')
 
- 
- random_state = st.number_input("Enter Random_state",max_value=100,min_value=1,value=42) 
- test_size = st.number_input("Enter test_size",max_value=0.99, min_value = 0.01,value =0.2) 
- if st.radio("select Train Validation Split Method",
- [f"Train_Test_split, Default (Random_state = {random_state},Test_size = {test_size})",
- "KFoldCV, Default (CV = 5)"], index = 0)== f"Train_Test_split, Default (Random_state = {random_state},Test_size = {test_size})":
+ st.divider()
+ st.markdown('<div class="message-box success">Modelling</div>', unsafe_allow_html=True)
+ st.write("")
+ st.markdown('<p class="success-message">Select Train Validation Split Method</p>', unsafe_allow_html=True)
+ if st.radio("",["Train_Test_split","KFoldCV, Default (CV = 5)"], index = 0)== "Train_Test_split":
  ttsmethod = "Train_Test_split"
  else:
  ttsmethod = "KFoldCV"
  st.write('You selected:', ttsmethod)
  if ttsmethod == "Train_Test_split":
+ random_state = st.number_input("Enter Random_state",max_value=100,min_value=1,value=42) 
+ test_size = st.number_input("Enter test_size",max_value=0.99, min_value = 0.01,value =0.2) 
  X_train,X_Val,y_train,y_val = tts(X,y[X.index],random_state = random_state,test_size = test_size)
- st.write('X-Training Data shape:', (X_train.info()))
  
  st.write('X-Training Data shape:', X_train.shape)
  st.write('X-Validation Data shape:', X_Val.shape)
-
- ml_cat = st.radio("Select Machine Learning Category",["Regression","Classification"],index =0)
-
+ st.divider()
+ st.markdown('<p class="success-message2">Select Machine Learning Category</p>', unsafe_allow_html=True)
+ ml_cat = st.radio("___",options=["Regression","Classification"],index =0)
+ st.divider()
  if ml_cat =="Regression":
- method_name_selector = st.selectbox("Select Error Evaluation Method",evaluationer.method_df.index,index = 0)
+ st.markdown('<p class="success-message2">Select Error Evaluation Method</p>', unsafe_allow_html=True)
+ method_name_selector = st.selectbox(" ",evaluationer.method_df.index,index = 0)
+
+ st.divider()
 
  method = evaluationer.method_df.loc[method_name_selector].values[0]
  reg_algorithm = []
  selected_options = []
-
+ st.markdown('<div class="message-box success">Select ML Model(s)</div>', unsafe_allow_html=True)
  for option in models.Regression_models.index:
  selected = st.checkbox(option)
  if selected:
@@ -450,7 +563,7 @@ if csv_upload is not None:
  
  cla_algorithm = []
  selected_options = []
-
+ st.markdown('<div class="message-box success">Select ML Model(s)</div>', unsafe_allow_html=True)
  for option in models.Classification_models.index:
  selected = st.checkbox(option)
  if selected:

auto_optimizer.py

@@ -1,317 +1,361 @@
-import pandas as pd
-import numpy as np
-import streamlit as st
-from sklearn.impute import KNNImputer,SimpleImputer,IterativeImputer
-import best_tts, evaluationer,models
-from sklearn.experimental import enable_iterative_imputer
-from sklearn.model_selection import train_test_split as tts
-from collections import Counter
-#root_mean_squared_error
-from sklearn.metrics import root_mean_squared_error
-import seaborn as sns
-import matplotlib.pyplot as plt
-import outliers,best_tts
-import feature_selections
-def Auto_optimizer(X,y,eva,model,test= None):
- evaluationer.reg_evaluation_df =evaluationer.reg_evaluation_df.drop(index =evaluationer.reg_evaluation_df.index)
- num_cols = X.select_dtypes(exclude = "O").columns
- cat_cols = X.select_dtypes(include = "O").columns
- st.write("Num_cols",tuple(num_cols))
- st.write("cat_cols",tuple(cat_cols))
-
-# check for Duplicate and drop duplicated in X
- 
- if len(X.isnull().sum()[(X.isnull().sum()/len(X)*100) >40]) >0:
- X = X.drop(columns = X.isnull().sum()[(X.isnull().sum()/len(X)*100) >40].index)
- st.write("Columns with more than 40% null values removed")
- # st.write("csx",X)
-
- len_null = X.isnull().sum().sum() 
-
- st.write(f"There are {len_null} null values in Train")
-
- knn_imputed_num_X = X.copy()
- si_mean_imputed_num_X = X.copy()
- # st.write("sf",si_mean_imputed_num_X)
- si_median_imputed_num_X = X.copy()
- si_most_frequent_imputed_num_X = X.copy()
- iter_imputed_num_X = X.copy()
- knn_imputed_X_cat_dropped = knn_imputed_num_X.copy()
- si_mean_imputed_X_cat_dropped = si_mean_imputed_num_X.copy()
- si_median_imputed_X_cat_dropped = si_median_imputed_num_X.copy()
- si_most_frequent_imputed_X_cat_dropped = si_most_frequent_imputed_num_X.copy()
- iter_imputed_X_cat_dropped = iter_imputed_num_X.copy()
- if len_null >0:
- 
- if X[num_cols].isnull().sum().sum() >0:
-
- knn_imputer = KNNImputer(n_neighbors = 5) 
- knn_imputed_num_X[num_cols] = knn_imputer.fit_transform(knn_imputed_num_X[num_cols])
- si_imputer = SimpleImputer(strategy = "mean")
- si_mean_imputed_num_X[num_cols] = si_imputer.fit_transform(si_mean_imputed_num_X[num_cols])
- si_imputer = SimpleImputer(strategy = "median")
- si_median_imputed_num_X[num_cols] = si_imputer.fit_transform(si_median_imputed_num_X[num_cols])
- si_imputer = SimpleImputer(strategy = "most_frequent")
- si_most_frequent_imputed_num_X[num_cols] = si_imputer.fit_transform(si_most_frequent_imputed_num_X[num_cols])
- iter_imputer = IterativeImputer(max_iter = 200,random_state= 42)
- iter_imputed_num_X[num_cols] = iter_imputer.fit_transform(iter_imputed_num_X[num_cols])
- knn_imputed_X_cat_dropped = knn_imputed_num_X.copy()
- si_mean_imputed_X_cat_dropped = si_mean_imputed_num_X.copy()
- si_median_imputed_X_cat_dropped = si_median_imputed_num_X.copy()
- si_most_frequent_imputed_X_cat_dropped = si_most_frequent_imputed_num_X.copy()
- iter_imputed_X_cat_dropped = iter_imputed_num_X.copy()
-
- if X[cat_cols].isnull().sum().sum() >0:
- # treating missing values in categorical columns
- # st.write("si_mean_imputed_num_X",si_mean_imputed_num_X)
- si_imputer = SimpleImputer(strategy = "most_frequent")
- 
- knn_imputed_num_X[cat_cols] = si_imputer.fit_transform(knn_imputed_num_X[cat_cols])
- si_imputer = SimpleImputer(strategy = "most_frequent")
- si_mean_imputed_num_X.loc[:,cat_cols] = si_imputer.fit_transform(si_mean_imputed_num_X.loc[:,cat_cols])
- # st.write("si_mean_imputed_num_X",si_mean_imputed_num_X)
- si_median_imputed_num_X[cat_cols] = si_imputer.fit_transform(si_median_imputed_num_X[cat_cols])
- si_most_frequent_imputed_num_X[cat_cols] = si_imputer.fit_transform(si_most_frequent_imputed_num_X[cat_cols])
- iter_imputed_num_X[cat_cols] = si_imputer.fit_transform(iter_imputed_num_X[cat_cols])
-
- knn_imputed_X_cat_dropped = knn_imputed_X_cat_dropped.dropna()
- si_mean_imputed_X_cat_dropped =si_mean_imputed_X_cat_dropped.dropna()
- si_median_imputed_X_cat_dropped =si_median_imputed_X_cat_dropped.dropna()
- si_most_frequent_imputed_X_cat_dropped =si_most_frequent_imputed_X_cat_dropped.dropna()
- iter_imputed_X_cat_dropped =iter_imputed_X_cat_dropped.dropna()
- st.write("sdds",knn_imputed_num_X)
- st.write("sddssd",knn_imputed_X_cat_dropped)
- 
- miss_val_dropped_X = X.dropna()
- 
- # list of dataframes
- 
- list_X_after_missing_values= [knn_imputed_num_X,
- si_mean_imputed_num_X,
- si_median_imputed_num_X,
- si_most_frequent_imputed_num_X,
- iter_imputed_num_X,
- knn_imputed_X_cat_dropped,
- si_mean_imputed_X_cat_dropped,
- si_median_imputed_X_cat_dropped,
- si_most_frequent_imputed_X_cat_dropped,
- iter_imputed_X_cat_dropped,
- miss_val_dropped_X]
- list_X_after_missing_values_names= ["knn_imputed_num_X",
- "si_mean_imputed_num_X",
- "si_median_imputed_num_X",
- "si_most_frequent_imputed_num_X",
- "iter_imputed_num_X",
- "knn_imputed_X_cat_dropped",
- "si_mean_imputed_X_cat_dropped",
- "si_median_imputed_X_cat_dropped",
- "si_most_frequent_imputed_X_cat_dropped",
- "iter_imputed_X_cat_dropped",
- "miss_val_dropped_X"]
- # st.write("si_most_frequent_imputed_num_X",si_most_frequent_imputed_num_X,) 
- ord_enc_cols = []
- ohe_enc_cols = []
-
- if len(cat_cols) == 0:
- st.write("No Categorical Columns in Train")
- else:
- st.write("Select Columns for Ordinal Encoding")
- for column in cat_cols:
- selected = st.checkbox(column)
- if selected:
- st.write(f"No. of Unique value in {column} column are", X[column].nunique())
- ord_enc_cols.append(column)
- ohe_enc_cols = set(cat_cols) -set(ord_enc_cols)
- ohe_enc_cols = list(ohe_enc_cols)
- 
- if len(ord_enc_cols)>0:
- st.write("ordinal encoded columns" ,tuple(ord_enc_cols))
- if len(ohe_enc_cols)>0:
- st.write("one hot encoded columns" ,tuple(ohe_enc_cols))
- 
- if len(ord_enc_cols)>0:
- 
- ordinal_order_vals = []
-
- for column in ord_enc_cols:
- unique_vals = X.dropna()[column].unique()
- # st.write(f"No. of Unique value in {column} column are", len(unique_vals))
- 
- ordered_unique_vals = st.multiselect("Select values in order for Ordinal Encoding",unique_vals,unique_vals)
- ordinal_order_vals.append(ordered_unique_vals)
- 
- st.write("order of values for Ordinal Encoding",tuple(ordinal_order_vals)) 
-
- if len_null > 0: 
-
- for df_name, df in enumerate(list_X_after_missing_values):
- # st.write(f"{list_X_after_missing_values_names[df_name]}",df)
- from sklearn.preprocessing import OrdinalEncoder
- ord = OrdinalEncoder(categories=ordinal_order_vals,handle_unknown= "use_encoded_value",unknown_value = -1 )
- df[ord_enc_cols] = ord.fit_transform(df[ord_enc_cols])
- # st.write(f"{list_X_after_missing_values_names[df_name]}",df)
- else : 
- from sklearn.preprocessing import OrdinalEncoder
- ord = OrdinalEncoder(categories=ordinal_order_vals,handle_unknown= "use_encoded_value",unknown_value = -1 )
- X[ord_enc_cols] = ord.fit_transform(X[ord_enc_cols])
-
- st.write("Ordinal Encoding Completed ✅")
-
- if len(ohe_enc_cols)>0:
- if len_null > 0:
- for df_name, df in enumerate(list_X_after_missing_values):
- from sklearn.preprocessing import OneHotEncoder
- ohe = OneHotEncoder(sparse_output = False,handle_unknown = "ignore")
- pd.options.mode.chained_assignment = None
- df.loc[:, ohe.get_feature_names_out()] = ohe.fit_transform(df[ohe_enc_cols])
- df.drop(columns = ohe_enc_cols,inplace = True)
- pd.options.mode.chained_assignment = 'warn'
- else:
- from sklearn.preprocessing import OneHotEncoder
- ohe = OneHotEncoder(sparse_output = False,handle_unknown = "ignore")
- pd.options.mode.chained_assignment = None
- X.loc[:, ohe.get_feature_names_out()] = ohe.fit_transform(X[ohe_enc_cols])
- X.drop(columns = ohe_enc_cols,inplace = True)
- pd.options.mode.chained_assignment = 'warn'
- st.write("OneHot Encoding Completed ✅")
-
-
- if len(ohe_enc_cols)>0:
- if len_null > 0:
- for name,df in enumerate(list_X_after_missing_values):
- X_train,X_test,y_train,y_test = tts(df,y[df.index],test_size =.2 ,random_state = 42)
- # best_tts.best_tts(df,y,model,eva)
- evaluationer.evaluation(f"{list_X_after_missing_values_names[name]}",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
- else:
- X_train,X_test,y_train,y_test = tts(X,y[X.index],test_size =.2 ,random_state = 42)
- # best_tts.best_tts(X,y,model,eva)
- 
- evaluationer.evaluation(f"baseline_model",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
-
- if len_null >0:
- for name,df in enumerate(list_X_after_missing_values):
- X_train,X_test,y_train,y_test = tts(df,y[df.index],test_size =.2 ,random_state = 42)
- st.write(f"this is test{list_X_after_missing_values_names[name]}",X_train.isnull().sum().sum())
- evaluationer.evaluation(f"{list_X_after_missing_values_names[name]}",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
-
- if eva == "class":
- counter = Counter(y)
- total = sum(counter.values())
- balance_ratio = {cls: count / total for cls, count in counter.items()}
- num_classes = len(balance_ratio)
- ideal_ratio = 1 / num_classes
- a = all(abs(ratio - ideal_ratio) <= 0.1 * ideal_ratio for ratio in balance_ratio.values())
- if a == True:
- st.write("Balanced Dataset ✅")
- st.write("Using accuracy for Evaluation")
- value = "test_acc"
- else:
- st.write("Unbalanced Dataset ❌")
- st.write("Using F1 score for Evaluation")
- value = "test_f1"
- st.write("SFdfs",evaluationer.classification_evaluation_df)
- evaluationer.classification_evaluation_df.sort_values(by = value,inplace= True)
- name = str(evaluationer.classification_evaluation_df.iloc[-1,0])
- st.write("df name",evaluationer.classification_evaluation_df.iloc[-1,0])
- if len_null >0:
- b = list_X_after_missing_values_names.index(name)
- st.write("Sdffsf",b)
- st.write("df",list_X_after_missing_values[b])
- X = list_X_after_missing_values[b]
- if eva == "reg":
- st.write("Using R2 score for Evaluation",evaluationer.reg_evaluation_df)
- value = "test_r2"
- evaluationer.reg_evaluation_df.sort_values(by = value,inplace= True)
- st.write("adfsdf",evaluationer.reg_evaluation_df.iloc[-1,0])
- name = str(evaluationer.reg_evaluation_df.iloc[-1,0])
- st.write("Sdffsf",name)
- if len_null >0:
- b = list_X_after_missing_values_names.index(name)
- st.write("Sdffsf",b)
- st.write("df",list_X_after_missing_values[b])
- X = list_X_after_missing_values[b]
- 
-
- # Create a figure and axes
- num_plots = len(num_cols)
- cols = 2 # Number of columns in the subplot grid
- rows = (num_plots + cols - 1) // cols # Calculate the number of rows needed
-
- fig, axes = plt.subplots(rows, cols, figsize=(15, 5 * rows))
-
- # Flatten the axes array for easy iteration, and remove any excess subplots
- axes = axes.flatten()
- for ax in axes[num_plots:]:
- fig.delaxes(ax)
-
- for i, col in enumerate(num_cols):
- sns.histplot(X[col], ax=axes[i],kde = True,color=sns.color_palette('Oranges', as_cmap=True)(0.7))
- axes[i].set_title(col)
-
- # Adjust layout
- plt.tight_layout()
-
- # Show the plot in Streamlit
- st.pyplot(fig)
-
- # Create a figure and axes
- num_plots = len(num_cols)
- cols = 3 # Number of columns in the subplot grid
- rows = (num_plots + cols - 1) // cols # Calculate the number of rows needed
-
- fig, axes = plt.subplots(rows, cols, figsize=(15, 5 * rows))
-
- # Flatten the axes array for easy iteration, and remove any excess subplots
- axes = axes.flatten()
- for ax in axes[num_plots:]:
- fig.delaxes(ax)
-
- for i, col in enumerate(num_cols):
- sns.boxplot(y=X[col], ax=axes[i],palette="magma")
- axes[i].set_title(col)
-
- # Adjust layout
- plt.tight_layout()
-
- # Show the plot in Streamlit
- st.pyplot(fig)
- 
- outlier_cols = st.multiselect("De-Select columns for Detecting Outliers", num_cols,default= list(num_cols))
-
- st.write("Checking for Outliers")
- outliers_df_X,outlier_indexes = outliers.detect_outliers(X,list(outlier_cols))
- st.write("Outliers in Dataframe Summary",outliers_df_X)
- st.write("Columns for Outliers handling",tuple(outliers_df_X["columns name"]))
-
- select_outlier_cols = st.multiselect("Select columns for Outlier Handling",tuple(outliers_df_X["columns name"]),default =tuple(outliers_df_X["columns name"]))
- resultant,outlier_handled_df,outlier_handled_df_name= outliers.outlier_handling(X,y,model,outlier_indexes = outlier_indexes,outlier_cols = select_outlier_cols ,method = root_mean_squared_error,test_size = 0.2, random_state = 42,eva = "reg")
- st.write("outlier handling with methods",resultant)
- st.write("Best method with outlier handling",resultant.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0])
- try :
- st.write("Best X Data Index No.",outlier_handled_df_name.index(resultant.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0]))
- 
- st.write("Best X DataFrame after outlier handling ",outlier_handled_df[outlier_handled_df_name.index(resultant.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0])])
- X = outlier_handled_df[outlier_handled_df_name.index(resultant.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0])]
- except :
- "evaluation of baseline model is better continuing with baseline model"
- 
- # result_df ,X_train_b,X_test_b,y_train_b,y_test_b = best_tts.best_tts(X,y,model,eva)
- X_train,X_test,y_train,y_test = tts(X,y[X.index],random_state = 42,test_size = 0.2)
- st.write("result_df",X)
- st.write("fsdfs",X_train)
- result_df_1 = feature_selections.feature_selection(X_train,X_test,y_train,y_test,model,alpha = 0.05)
- st.write("sdchsvdgj",result_df_1)
-
- 
-
-
- 
-
-
-
-
-
-
-
-
-
+import pandas as pd
+import numpy as np
+import streamlit as st
+from sklearn.impute import KNNImputer,SimpleImputer,IterativeImputer
+import best_tts, evaluationer,models
+from sklearn.experimental import enable_iterative_imputer
+from sklearn.model_selection import train_test_split as tts
+from collections import Counter
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.metrics import root_mean_squared_error
+import seaborn as sns
+from sklearn.decomposition import PCA
+import grid_search_cv
+import matplotlib.pyplot as plt
+import outliers,best_tts
+import feature_selections
+def Auto_optimizer(X,y,eva,model,model_name,test= None):
+ if st.button("Train Regression Model"):
+ num_cols = X.select_dtypes(exclude = "O").columns
+ cat_cols = X.select_dtypes(include = "O").columns
+ st.write("Num_cols",tuple(num_cols))
+ st.write("cat_cols",tuple(cat_cols))
+ 
+ # check for Duplicate and drop duplicated in X
+ 
+ if len(X.isnull().sum()[(X.isnull().sum()/len(X)*100) >40]) >0:
+ X = X.drop(columns = X.isnull().sum()[(X.isnull().sum()/len(X)*100) >40].index)
+ st.write("Columns with more than 40% null values removed")
+ # st.write("csx",X)
+
+ len_null = X.isnull().sum().sum() 
+
+ st.write(f"There are {len_null} null values in Train")
+
+ knn_imputed_num_X = X.copy()
+ si_mean_imputed_num_X = X.copy()
+ # st.write("sf",si_mean_imputed_num_X)
+ si_median_imputed_num_X = X.copy()
+ si_most_frequent_imputed_num_X = X.copy()
+ iter_imputed_num_X = X.copy()
+ knn_imputed_X_cat_dropped = knn_imputed_num_X.copy()
+ si_mean_imputed_X_cat_dropped = si_mean_imputed_num_X.copy()
+ si_median_imputed_X_cat_dropped = si_median_imputed_num_X.copy()
+ si_most_frequent_imputed_X_cat_dropped = si_most_frequent_imputed_num_X.copy()
+ iter_imputed_X_cat_dropped = iter_imputed_num_X.copy()
+ if len_null >0:
+ 
+ if X[num_cols].isnull().sum().sum() >0:
+
+ knn_imputer = KNNImputer(n_neighbors = 5) 
+ knn_imputed_num_X[num_cols] = knn_imputer.fit_transform(knn_imputed_num_X[num_cols])
+ si_imputer = SimpleImputer(strategy = "mean")
+ si_mean_imputed_num_X[num_cols] = si_imputer.fit_transform(si_mean_imputed_num_X[num_cols])
+ si_imputer = SimpleImputer(strategy = "median")
+ si_median_imputed_num_X[num_cols] = si_imputer.fit_transform(si_median_imputed_num_X[num_cols])
+ si_imputer = SimpleImputer(strategy = "most_frequent")
+ si_most_frequent_imputed_num_X[num_cols] = si_imputer.fit_transform(si_most_frequent_imputed_num_X[num_cols])
+ iter_imputer = IterativeImputer(max_iter = 200,random_state= 42)
+ iter_imputed_num_X[num_cols] = iter_imputer.fit_transform(iter_imputed_num_X[num_cols])
+ knn_imputed_X_cat_dropped = knn_imputed_num_X.copy()
+ si_mean_imputed_X_cat_dropped = si_mean_imputed_num_X.copy()
+ si_median_imputed_X_cat_dropped = si_median_imputed_num_X.copy()
+ si_most_frequent_imputed_X_cat_dropped = si_most_frequent_imputed_num_X.copy()
+ iter_imputed_X_cat_dropped = iter_imputed_num_X.copy()
+
+ if X[cat_cols].isnull().sum().sum() >0:
+ # treating missing values in categorical columns
+ # st.write("si_mean_imputed_num_X",si_mean_imputed_num_X)
+ si_imputer = SimpleImputer(strategy = "most_frequent")
+ 
+ knn_imputed_num_X[cat_cols] = si_imputer.fit_transform(knn_imputed_num_X[cat_cols])
+ si_imputer = SimpleImputer(strategy = "most_frequent")
+ si_mean_imputed_num_X.loc[:,cat_cols] = si_imputer.fit_transform(si_mean_imputed_num_X.loc[:,cat_cols])
+ # st.write("si_mean_imputed_num_X",si_mean_imputed_num_X)
+ si_median_imputed_num_X[cat_cols] = si_imputer.fit_transform(si_median_imputed_num_X[cat_cols])
+ si_most_frequent_imputed_num_X[cat_cols] = si_imputer.fit_transform(si_most_frequent_imputed_num_X[cat_cols])
+ iter_imputed_num_X[cat_cols] = si_imputer.fit_transform(iter_imputed_num_X[cat_cols])
+
+ knn_imputed_X_cat_dropped = knn_imputed_X_cat_dropped.dropna()
+ si_mean_imputed_X_cat_dropped =si_mean_imputed_X_cat_dropped.dropna()
+ si_median_imputed_X_cat_dropped =si_median_imputed_X_cat_dropped.dropna()
+ si_most_frequent_imputed_X_cat_dropped =si_most_frequent_imputed_X_cat_dropped.dropna()
+ iter_imputed_X_cat_dropped =iter_imputed_X_cat_dropped.dropna()
+ 
+ 
+ miss_val_dropped_X = X.dropna()
+ 
+ # list of dataframes
+ 
+ list_X_after_missing_values= [knn_imputed_num_X,
+ si_mean_imputed_num_X,
+ si_median_imputed_num_X,
+ si_most_frequent_imputed_num_X,
+ iter_imputed_num_X,
+ knn_imputed_X_cat_dropped,
+ si_mean_imputed_X_cat_dropped,
+ si_median_imputed_X_cat_dropped,
+ si_most_frequent_imputed_X_cat_dropped,
+ iter_imputed_X_cat_dropped,
+ miss_val_dropped_X]
+ list_X_after_missing_values_names= ["knn_imputed_num_X",
+ "si_mean_imputed_num_X",
+ "si_median_imputed_num_X",
+ "si_most_frequent_imputed_num_X",
+ "iter_imputed_num_X",
+ "knn_imputed_X_cat_dropped",
+ "si_mean_imputed_X_cat_dropped",
+ "si_median_imputed_X_cat_dropped",
+ "si_most_frequent_imputed_X_cat_dropped",
+ "iter_imputed_X_cat_dropped",
+ "miss_val_dropped_X"]
+ # st.write("si_most_frequent_imputed_num_X",si_most_frequent_imputed_num_X,) 
+ ord_enc_cols = []
+ ohe_enc_cols = []
+
+ if len(cat_cols) == 0:
+ st.write("No Categorical Columns in Train")
+ else:
+ st.write("Select Columns for Ordinal Encoding")
+ for column in cat_cols:
+ selected = st.checkbox(column)
+ if selected:
+ st.write(f"No. of Unique value in {column} column are", X[column].nunique())
+ ord_enc_cols.append(column)
+ ohe_enc_cols = set(cat_cols) -set(ord_enc_cols)
+ ohe_enc_cols = list(ohe_enc_cols)
+ 
+ if len(ord_enc_cols)>0:
+ st.write("ordinal encoded columns" ,tuple(ord_enc_cols))
+ if len(ohe_enc_cols)>0:
+ st.write("one hot encoded columns" ,tuple(ohe_enc_cols))
+ 
+ if len(ord_enc_cols)>0:
+ 
+ ordinal_order_vals = []
+
+ for column in ord_enc_cols:
+ unique_vals = X.dropna()[column].unique()
+ # st.write(f"No. of Unique value in {column} column are", len(unique_vals))
+ 
+ ordered_unique_vals = st.multiselect("Select values in order for Ordinal Encoding",unique_vals,unique_vals)
+ ordinal_order_vals.append(ordered_unique_vals)
+ 
+ st.write("order of values for Ordinal Encoding",tuple(ordinal_order_vals)) 
+
+ if len_null > 0: 
+
+ for df_name, df in enumerate(list_X_after_missing_values):
+ # st.write(f"{list_X_after_missing_values_names[df_name]}",df)
+ from sklearn.preprocessing import OrdinalEncoder
+ ord = OrdinalEncoder(categories=ordinal_order_vals,handle_unknown= "use_encoded_value",unknown_value = -1 )
+ df[ord_enc_cols] = ord.fit_transform(df[ord_enc_cols])
+ # st.write(f"{list_X_after_missing_values_names[df_name]}",df)
+ else : 
+ from sklearn.preprocessing import OrdinalEncoder
+ ord = OrdinalEncoder(categories=ordinal_order_vals,handle_unknown= "use_encoded_value",unknown_value = -1 )
+ X[ord_enc_cols] = ord.fit_transform(X[ord_enc_cols])
+
+ st.write("Ordinal Encoding Completed ✅")
+
+ if len(ohe_enc_cols)>0:
+ if len_null > 0:
+ for df_name, df in enumerate(list_X_after_missing_values):
+ from sklearn.preprocessing import OneHotEncoder
+ ohe = OneHotEncoder(sparse_output = False,handle_unknown = "ignore")
+ pd.options.mode.chained_assignment = None
+ df.loc[:, ohe.get_feature_names_out()] = ohe.fit_transform(df[ohe_enc_cols])
+ df.drop(columns = ohe_enc_cols,inplace = True)
+ pd.options.mode.chained_assignment = 'warn'
+ else:
+ from sklearn.preprocessing import OneHotEncoder
+ ohe = OneHotEncoder(sparse_output = False,handle_unknown = "ignore")
+ pd.options.mode.chained_assignment = None
+ X.loc[:, ohe.get_feature_names_out()] = ohe.fit_transform(X[ohe_enc_cols])
+ X.drop(columns = ohe_enc_cols,inplace = True)
+ pd.options.mode.chained_assignment = 'warn'
+ st.write("OneHot Encoding Completed ✅")
+
+
+ if len(ohe_enc_cols)>0:
+ if len_null > 0:
+ for name,df in enumerate(list_X_after_missing_values):
+ X_train,X_test,y_train,y_test = tts(df,y[df.index],test_size =.2 ,random_state = 42)
+ # best_tts.best_tts(df,y,model,eva)
+ evaluationer.evaluation(f"{list_X_after_missing_values_names[name]}",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
+ else:
+ X_train,X_test,y_train,y_test = tts(X,y[X.index],test_size =.2 ,random_state = 42)
+ # best_tts.best_tts(X,y,model,eva)
+ 
+ evaluationer.evaluation(f"baseline_model",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
+
+ if len_null >0:
+ for name,df in enumerate(list_X_after_missing_values):
+ X_train,X_test,y_train,y_test = tts(df,y[df.index],test_size =.2 ,random_state = 42)
+ 
+ evaluationer.evaluation(f"{list_X_after_missing_values_names[name]}",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
+
+ if eva == "class":
+ counter = Counter(y)
+ total = sum(counter.values())
+ balance_ratio = {cls: count / total for cls, count in counter.items()}
+ num_classes = len(balance_ratio)
+ ideal_ratio = 1 / num_classes
+ a = all(abs(ratio - ideal_ratio) <= 0.1 * ideal_ratio for ratio in balance_ratio.values())
+ if a == True:
+ st.write("Balanced Dataset ✅")
+ st.write("Using accuracy for Evaluation")
+ value = "test_acc"
+ else:
+ st.write("Unbalanced Dataset ❌")
+ st.write("Using F1 score for Evaluation")
+ value = "test_f1"
+ 
+ evaluationer.classification_evaluation_df.sort_values(by = value,inplace= True)
+ name = str(evaluationer.classification_evaluation_df.iloc[-1,0])
+ st.write("df name",evaluationer.classification_evaluation_df.iloc[-1,0])
+ if len_null >0:
+ b = list_X_after_missing_values_names.index(name)
+ 
+ st.write("df",list_X_after_missing_values[b])
+ X = list_X_after_missing_values[b]
+ if eva == "reg":
+ st.write("Using R2 score for Evaluation",evaluationer.reg_evaluation_df)
+ value = "test_r2"
+ evaluationer.reg_evaluation_df.sort_values(by = value,inplace= True)
+ 
+ name = str(evaluationer.reg_evaluation_df.iloc[-1,0])
+ 
+ if len_null >0:
+ b = list_X_after_missing_values_names.index(name)
+ 
+ st.write("df",list_X_after_missing_values[b])
+ X = list_X_after_missing_values[b]
+ 
+
+ # Create a figure and axes
+ num_plots = len(num_cols)
+ cols = 2 # Number of columns in the subplot grid
+ rows = (num_plots + cols - 1) // cols # Calculate the number of rows needed
+
+ fig, axes = plt.subplots(rows, cols, figsize=(15, 5 * rows))
+
+ # Flatten the axes array for easy iteration, and remove any excess subplots
+ axes = axes.flatten()
+ for ax in axes[num_plots:]:
+ fig.delaxes(ax)
+
+ for i, col in enumerate(num_cols):
+ sns.histplot(X[col], ax=axes[i],kde = True,color=sns.color_palette('Oranges', as_cmap=True)(0.7))
+ axes[i].set_title(col)
+
+ # Adjust layout
+ plt.tight_layout()
+
+ # Show the plot in Streamlit
+ st.pyplot(fig)
+
+ # Create a figure and axes
+ num_plots = len(num_cols)
+ cols = 3 # Number of columns in the subplot grid
+ rows = (num_plots + cols - 1) // cols # Calculate the number of rows needed
+
+ fig, axes = plt.subplots(rows, cols, figsize=(15, 5 * rows))
+
+ # Flatten the axes array for easy iteration, and remove any excess subplots
+ axes = axes.flatten()
+ for ax in axes[num_plots:]:
+ fig.delaxes(ax)
+
+ for i, col in enumerate(num_cols):
+ sns.boxplot(y=X[col], ax=axes[i],palette="magma")
+ axes[i].set_title(col)
+
+ # Adjust layout
+ plt.tight_layout()
+
+ # Show the plot in Streamlit
+ st.pyplot(fig)
+ 
+ outlier_cols = st.multiselect("De-Select columns for Detecting Outliers", num_cols,default= list(num_cols))
+
+ st.write("Checking for Outliers")
+ outliers_df_X,outlier_indexes = outliers.detect_outliers(X,list(outlier_cols))
+ st.write("Outliers in Dataframe Summary",outliers_df_X)
+ st.write("Columns for Outliers handling",tuple(outliers_df_X["columns name"]))
+
+ select_outlier_cols = st.multiselect("Select columns for Outlier Handling",tuple(outliers_df_X["columns name"]),default =tuple(outliers_df_X["columns name"]))
+ resultant,outlier_handled_df,outlier_handled_df_name= outliers.outlier_handling(X,y,model,outlier_indexes = outlier_indexes,outlier_cols = select_outlier_cols ,method = root_mean_squared_error,test_size = 0.2, random_state = 42,eva = "reg")
+ st.write("outlier handling with methods",resultant)
+ st.write("Best method with outlier handling",resultant.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0])
+ try :
+ st.write("Best X Data Index No.",outlier_handled_df_name.index(resultant.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0]))
+ 
+ st.write("Best X DataFrame after outlier handling ",outlier_handled_df[outlier_handled_df_name.index(resultant.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0])])
+ X = outlier_handled_df[outlier_handled_df_name.index(resultant.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0])]
+ except :
+ "evaluation of baseline model is better continuing with baseline model"
+ 
+ 
+ X_train,X_test,y_train,y_test = tts(X,y[X.index],random_state = 42,test_size = 0.2)
+ st.write("result_df",X)
+ 
+ 
+
+ try:
+ result_df_1 , feature_col, feature_col_name = feature_selections.feature_selection(X_train,X_test,y_train,y_test,model,alpha = 0.05)
+ X = X.drop(columns = feature_col[feature_col_name.index(result_df_1.sort_values(by = "test_r2").tail(1).iloc[:,0].values[0])])
+ except:
+ "evaluation by feature selection is not better than previous"
+
+ try:
+ result,X_train_b,X_test_b,y_train_b,y_test_b = best_tts.best_tts(X,y,model,eva)
+ st.write("result_df",result)
+ except:
+ X_train,X_test,y_train,y_test = tts(X,y[X.index],test_size =0.2,random_state = 42)
+
+
+ 
+
+ st.write("cheking with polynomial features")
+ poly = PolynomialFeatures(degree=(2))
+ X_train_poly = poly.fit_transform(X_train)
+ X_test_poly = poly.transform(X_test)
+ result_df_2 = evaluationer.evaluation("polynomial features degree 2",X_train_poly,X_test_poly,y_train,y_test,model,root_mean_squared_error,eva)
+ st.write("after polynomial features degree 2",evaluationer.reg_evaluation_df)
+ poly1 = PolynomialFeatures(degree=(3))
+ X_train_poly1 = poly.fit_transform(X_train)
+ X_test_poly1 = poly.transform(X_test)
+ evaluationer.evaluation("polynomial features degree 3",X_train_poly1,X_test_poly1,y_train,y_test,model,root_mean_squared_error,eva)
+ st.write("after polynomial features degree 3",evaluationer.reg_evaluation_df)
+
+ pca = PCA(n_components=0.95)
+ X_train_pca = pca.fit_transform(X_train)
+ X_test_pca = pca.transform(X_test)
+ evaluationer.evaluation("PCA",X_train_pca,X_test_pca,y_train,y_test,model,root_mean_squared_error,eva)
+ st.write("After PCA",evaluationer.reg_evaluation_df)
+
+ grid_search_cv.perform_grid_search(model,model_name,X_train,X_test,y_train,y_test,eva)
+ st.write("best param",evaluationer.reg_evaluation_df)
+ st.sidebar.button("click to clear evaluation metrics",evaluationer.reg_evaluation_df.drop(index = evaluationer.reg_evaluation_df.index))
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+

best_tts.py

@@ -10,9 +10,9 @@ def best_tts(X,y,model,eva):
  if eva == "reg":
  
  test_r2_,test_r2_ts,test_r2_rs = 0,0,0
- for k in range(10,25):
+ for k in range(10,25,3):
  i = k/100
- for j in range(1,100):
+ for j in range(1,100,10):
  X_train,X_test,y_train,y_test = tts(X,y[X.index],test_size = i, random_state = j,)
  
  model = model

eda.py

@@ -0,0 +1,325 @@
+import numpy as np
+import pandas as pd
+import streamlit as st
+import matplotlib.pyplot as plt
+import seaborn as sns
+import streamlit as st
+import streamlit.components.v1 as components
+import plotly.express as px
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+import streamlit as st
+import pandas as pd
+import datashader as ds
+import datashader.transfer_functions as tf
+from colorcet import fire
+import plotly.express as px
+# function to analysing EDA
+def eda_analysis(df):
+
+ target_col = st.sidebar.selectbox("Select Target Column", df.columns,index = len(df.columns)-1)
+ y = df[target_col]
+ X = df.drop(columns = target_col)
+ num_cols = X.select_dtypes(exclude= "O").columns.tolist()
+ cat_cols = X.select_dtypes(include= "O").columns.tolist()
+ st.write("num_cols",tuple(num_cols))
+ st.write("cat_cols",tuple(cat_cols))
+ st.divider()
+
+ results = []
+ for column in X[num_cols].columns:
+ skewness = X[column].skew()
+ kurtosis = X[column].kurtosis()
+ 
+ skewness_html = f'<span style="color: {"red" if abs(skewness) > .5 else "white"}">{skewness:.2f}</span>'
+ kurtosis_html = f'<span style="color: {"red" if abs(kurtosis) > 3 else "white"}">{kurtosis:.2f}</span>'
+ 
+ results.append({
+ 'Column': column,
+ 'Skewness': skewness,
+ 'Kurtosis': kurtosis,
+ 'Skewness_': skewness_html,
+ 'Kurtosis_': kurtosis_html
+ })
+
+ result_df = pd.DataFrame(results)
+
+ # Display the data types of Skewness and Kurtosis columns
+ # st.write("Data types of Skewness and Kurtosis columns:", result_df[["Skewness", "Kurtosis"]].dtypes)
+
+ if st.toggle("Show Skewness and Kurtosis of DataFrame columns"):
+ st.write("Columns with Skewness and Kurtosis:")
+ if st.checkbox("Filter Skewed columns"):
+ filtered_df = result_df[abs(result_df["Skewness"]) > 0.5]
+ st.write(filtered_df[['Column', 'Skewness_', 'Kurtosis_']].to_html(escape=False), unsafe_allow_html=True)
+ else:
+ st.write(result_df[['Column', 'Skewness_', 'Kurtosis_']].to_html(escape=False), unsafe_allow_html=True)
+
+ st.divider()
+ st.write("Plotting Numerical Columns for Visual EDA")
+
+ # Create two columns
+ column1, column2 = st.columns(2)
+
+ # Checkbox for plotting distribution in the first column
+ with column1:
+ plot_distribution = st.checkbox("Plot Distribution of Target Column")
+
+ # Show the second checkbox in the second column only if the first checkbox is clicked
+ if plot_distribution:
+ with column2:
+ show_kde = st.checkbox("Show KDE Plot")
+ kde = show_kde
+ else:
+ kde = False
+
+ # Plot the histogram if the first checkbox is checked
+ if plot_distribution:
+ fig, ax = plt.subplots()
+ sns.histplot(y, ax=ax, kde=kde)
+
+ # Show the plot in the Streamlit app
+ st.pyplot(fig)
+ 
+ column3, column4 = st.columns(2)
+ with column3:
+ plot_distribution_nc =st.checkbox("Plot Distribution of Input Numerical columns")
+ if plot_distribution_nc:
+ with column4:
+ show_kde_1 = st.checkbox("Show KDE Plot for Numerical Columns")
+ kde_1 = show_kde_1
+ if plot_distribution_nc:
+ for column in num_cols:
+ fig, ax = plt.subplots()
+ sns.histplot(df[column], ax=ax, kde=kde_1)
+ st.write(f"Distribution of {column}:")
+ st.pyplot(fig)
+ st.divider()
+ # plot count plot for categorical columns
+ st.write("Plotting Categorical Columns for Visual EDA")
+ if st.checkbox("Plot Distribution of Input Categorical columns") :
+ for column in cat_cols:
+ fig, ax = plt.subplots()
+ fig = px.histogram(df.fillna('Null'), x=column, color=target_col)
+ st.write(fig)
+ 
+ st.divider()
+ # plot correlation matrics using plotly
+ st.write("Plotting Correlation Matrix for Numerical Columns")
+
+ column5, column6 = st.columns(2)
+ with column5:
+ plot_distribution =st.checkbox("Plot Correlation Matrix")
+ if plot_distribution:
+ with column6:
+ show_value = st.checkbox("Correlation values > 0.5")
+ if show_value:
+ # Compute correlation matrix
+ corr_matrix = df[num_cols].corr()
+
+ # Plot correlation matrix heatmap
+ fig = px.imshow(corr_matrix[abs(corr_matrix)>0.5], color_continuous_scale='RdBu')
+
+ # Add annotations for values greater than 0.5
+ for i in range(corr_matrix.shape[0]):
+ for j in range(corr_matrix.shape[1]):
+ correlation_value = corr_matrix.iloc[i, j]
+ if abs(correlation_value) > 0.5: # Filter values greater than 0.5
+ fig.add_annotation(
+ x=i, y=j,
+ text=str(round(correlation_value, 2)),
+ showarrow=False
+ )
+
+ # Update layout
+ fig.update_layout(
+ xaxis=dict(side="top"),
+ width=600,
+ height=600,
+ margin=dict(l=20, r=20, t=40, b=20)
+ )
+
+ # Display the heatmap
+ st.write(fig)
+ if plot_distribution and not show_value:
+
+ 
+ corr_matrix = df[num_cols].corr()
+ fig = px.imshow(corr_matrix, color_continuous_scale='RdBu')
+ for i in range(corr_matrix.shape[0]):
+ for j in range(corr_matrix.shape[1]):
+ fig.add_annotation(
+ x=i, y=j,
+ text=str(round(corr_matrix.iloc[i, j], 2)),
+ showarrow=False
+ )
+
+ # Update the layout to ensure annotations are displayed properly
+ fig.update_layout(
+ xaxis=dict(side="top"),
+ width=600,
+ height=600,
+ margin=dict(l=20, r=20, t=40, b=20)
+ )
+
+ st.write(fig)
+ st.divider()
+ outlier_cols = st.multiselect("Select Continous numerical columns for Outlier Plot",num_cols)
+
+ # plot px.boxplot for outlier cols
+ if st.toggle("Toggle for Violin Plot"):
+ if st.checkbox("Plot BoxPlot for Outlier Cols"):
+ if st.toggle("Split by Target"):
+ for col in outlier_cols:
+ fig = px.violin(df, x=col,color=y)
+ st.write(fig)
+ st.divider()
+ else:
+ for col in outlier_cols:
+ fig = px.violin(df, x=col)
+ st.write(fig)
+ st.divider()
+ if st.checkbox("check outlier distribution of Target column"):
+ fig = px.violin(y)
+ st.write(fig)
+
+ else:
+ if st.checkbox("Plot BoxPlot for Outlier Cols"):
+ if st.toggle("Split by Target"):
+ for col in outlier_cols:
+ fig = px.box(df, x=col,color=y)
+ st.write(fig)
+ st.divider()
+ else:
+ for col in outlier_cols:
+ fig = px.box(df, x=col)
+ st.write(fig)
+ st.divider()
+ if st.checkbox("check outlier distribution of Target column"):
+ fig = px.box(y)
+ st.write(fig)
+
+
+ # plot scatter plot using px
+ st.divider()
+ 
+ if st.checkbox("Plot Scatter Plot"):
+ column7, column8,column9 = st.columns(3)
+ with column7:
+ 
+ 
+ # Select y-axis column
+ y_col = st.selectbox("Select y axis column", df.columns)
+ 
+ # Filter categorical columns for the x-axis selection
+ categorical_columns = df.columns
+ with column8: 
+ # Allow user to select the x-axis column from categorical columns
+ x_col = st.selectbox("Select x axis column", categorical_columns)
+ with column9:
+ hue_col = st.selectbox("Select Hue column",categorical_columns) 
+ # Plot scatter plot using Plotly
+ fig = px.scatter(df, x=x_col, y=y_col, color=hue_col)
+ st.write(fig)
+ 
+ # barchart and line chart
+ st.divider()
+ if st.checkbox("Plot Bar Chart"):
+ column10, column11 = st.columns(2)
+ with column10:
+ # Select y-axis column
+ y_col = st.selectbox("Select y axis column", df.columns)
+ 
+ # Filter categorical columns for the x-axis selection
+ categorical_columns = df.columns
+ with column11:
+ # Allow user to select the x-axis column from categorical columns
+ x_col = st.selectbox("Select x axis column", categorical_columns)
+ fig = px.bar(df, x=x_col, y=y_col,color = x_col)
+ st.write(fig)
+ st.divider()
+ if st.checkbox("Plot Line Chart"):
+ column12, column13,colx = st.columns(3)
+ with column12:
+ # Select y-axis column
+ y_col = st.selectbox("Select y axis column", df.columns)
+ 
+ # Filter categorical columns for the x-axis selection
+ categorical_columns = df.columns
+ with column13:
+ # Allow user to select the x-axis column from categorical columns
+ x_col = st.selectbox("Select x axis column", categorical_columns)
+ with colx:
+ hue_col1 = st.selectbox("Select Line split column",categorical_columns)
+ fig = px.line(df.sort_values(by = y_col), x=x_col, y=y_col,color = hue_col1)
+ st.write(fig)
+ st.divider()
+ # plot pie chart
+ if st.checkbox("Plot Pie Chart "):
+ column14, column15 = st.columns(2)
+ with column14:
+ # Select y-axis column
+ y_col = st.selectbox("Select values columns", df.columns)
+ 
+ # Filter categorical columns for the x-axis selection
+ categorical_columns = df.columns
+ with column15:
+ # Allow user to select the x-axis column from categorical columns
+ x_col = st.selectbox("Select names column", categorical_columns)
+ fig = px.pie(df, values=y_col, names=x_col)
+ st.write(fig)
+ 
+ st.divider()
+ # check if there are latitude and longitude columns
+ if st.checkbox("Plot on Map"):
+ lat_col = st.selectbox("Select Latitute Column",df.columns)
+ long_col = st.selectbox("Select Longitude Column",df.columns)
+ color = st.selectbox
+
+ # # Create the datashader canvas and aggregate points
+ # cvs = ds.Canvas(plot_width=1000, plot_height=1000)
+ # agg = cvs.points(df, x=long_col, y=lat_col)
+
+ # # Get the coordinates for the mapbox layer
+ # coords_lat, coords_lon = agg.coords[lat_col].values, agg.coords[long_col].values
+ # coordinates = [
+ # [coords_lon[0], coords_lat[0]],
+ # [coords_lon[-1], coords_lat[0]],
+ # [coords_lon[-1], coords_lat[-1]],
+ # [coords_lon[0], coords_lat[-1]]
+ # ]
+
+ # # Generate the datashader image
+ # img = tf.shade(agg, cmap=fire)[::-1].to_pil()
+
+ # # Create the Plotly figure with a mapbox layer
+ # fig = px.scatter_mapbox(df[:1], lat=lat_col, lon=long_col, zoom=10) # Adjust zoom level as needed
+ # fig.update_layout(mapbox_style="carto-darkmatter",
+ # mapbox_layers=[
+ # {
+ # "sourcetype": "image",
+ # "source": img,
+ # "coordinates": coordinates
+ # }
+ # ])
+
+ # # Display the figure in Streamlit
+ # st.plotly_chart(fig)
+
+ # Create a scatter mapbox plot with vibrant colors and custom marker sizes
+ if st.button("Proceed to plot map"):
+ fig = px.scatter_mapbox(df, lat=lat_col, lon=long_col, 
+ 
+ size_max=15, # Max marker size
+ mapbox_style="open-street-map", # Using a different map style for vibrancy
+ zoom=1,
+ title='Latitude and Longitude Plotting')
+
+ # Customize the layout for more vibrant appearance
+ fig.update_layout(mapbox_accesstoken='your_mapbox_access_token') 
+ st.write(fig)
+
+ 
+
+
+

feature_selections.py

@@ -8,12 +8,10 @@ import pandas as pd
 import numpy as np
 import evaluationer
 import streamlit as st
-# import root_mean_squared_error
+
+
 from sklearn.metrics import root_mean_squared_error
 def feature_selection(X_train, X_test,y_train,y_test,model_reg,alpha = 0.05):
- 
- st.write("dvsdv",y_train)
- st.write("dvfssdv",X_train)
 
  model = sm.OLS(y_train, sm.add_constant(X_train))
  model_fit = model.fit()
@@ -100,5 +98,7 @@ def feature_selection(X_train, X_test,y_train,y_test,model_reg,alpha = 0.05):
  feature_cols_name = ["pval_cols","coef_cols","pval_and_coef_cols","mi_cols","corr_u_cols","corr_l_cols","vif_cols","lasso_cols"]
  st.write("feature_cols", vif_cols)
  for i,j in enumerate(feature_cols):
- evaluationer.evaluation(f"{feature_cols_name[i]} dropped" ,X_train.drop(columns = j),X_test.drop(columns = j),y_train,y_test,model_reg,method = root_mean_squared_error,eva = "reg")
- return evaluationer.reg_evaluation_df
+ evaluationer.evaluation(f"{feature_cols_name[i]}" ,X_train.drop(columns = j),X_test.drop(columns = j),y_train,y_test,model_reg,method = root_mean_squared_error,eva = "reg")
+ return evaluationer.reg_evaluation_df,feature_cols,feature_cols_name
+
+ 

grid_search_cv.py

@@ -0,0 +1,284 @@
+from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge, Lasso, ElasticNet
+from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor, GradientBoostingRegressor, HistGradientBoostingRegressor
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.svm import SVR
+from xgboost import XGBRegressor, XGBRFRegressor
+from sklearn.neural_network import MLPRegressor
+from lightgbm import LGBMRegressor
+from sklearn.naive_bayes import GaussianNB
+from sklearn.model_selection import GridSearchCV
+from sklearn.datasets import make_regression
+from sklearn.model_selection import train_test_split
+import streamlit as st
+import evaluationer
+
+from sklearn.metrics import root_mean_squared_error
+
+from sklearn.linear_model import LogisticRegression, SGDClassifier, RidgeClassifier
+from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, HistGradientBoostingClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.svm import SVC
+from xgboost import XGBClassifier, XGBRFClassifier
+from sklearn.neural_network import MLPClassifier
+from lightgbm import LGBMClassifier
+from sklearn.naive_bayes import MultinomialNB, CategoricalNB
+
+param_grids_class = {
+ "Logistic Regression": {
+ 'penalty': ['l1', 'l2', 'elasticnet', 'none'],
+ 'C': [0.01, 0.1, 1, 10],
+ 'solver': ['lbfgs', 'liblinear', 'saga']
+ },
+ 
+ "SGD Classifier": {
+ 'loss': ['hinge', 'log', 'modified_huber', 'squared_hinge'],
+ 'penalty': ['l2', 'l1', 'elasticnet'],
+ 'alpha': [0.0001, 0.001, 0.01],
+ 'max_iter': [1000, 5000, 10000]
+ },
+ 
+ "Ridge Classifier": {
+ 'alpha': [0.1, 1, 10, 100]
+ },
+ 
+ "Random Forest Classifier": {
+ 'n_estimators': [100, 200, 300],
+ 'max_depth': [None, 10, 20, 30],
+ 'min_samples_split': [2, 5, 10],
+ 'min_samples_leaf': [1, 2, 4]
+ },
+ 
+ "AdaBoost Classifier": {
+ 'n_estimators': [50, 100, 200],
+ 'learning_rate': [0.01, 0.1, 1]
+ },
+ 
+ "Gradient Boosting Classifier": {
+ 'n_estimators': [100, 200, 300],
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [3, 5, 7]
+ },
+ 
+ "Hist Gradient Boosting Classifier": {
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [None, 10, 20],
+ 'min_samples_leaf': [20, 50, 100]
+ },
+ 
+ "K Neighbors Classifier": {
+ 'n_neighbors': [3, 5, 7],
+ 'weights': ['uniform', 'distance'],
+ 'metric': ['euclidean', 'manhattan']
+ },
+ 
+ "Decision Tree Classifier": {
+ 'max_depth': [None, 10, 20, 30],
+ 'min_samples_split': [2, 5, 10],
+ 'min_samples_leaf': [1, 2, 4]
+ },
+ 
+ "SVC": {
+ 'C': [0.1, 1, 10],
+ 'kernel': ['linear', 'poly', 'rbf'],
+ 'degree': [3, 4, 5],
+ 'gamma': ['scale', 'auto']
+ },
+ 
+ "XGB Classifier": {
+ 'n_estimators': [100, 200, 300],
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [3, 5, 7]
+ },
+ 
+ "XGBRF Classifier": {
+ 'n_estimators': [100, 200, 300],
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [3, 5, 7]
+ },
+ 
+ "MLP Classifier": {
+ 'hidden_layer_sizes': [(50,), (100,), (50, 50)],
+ 'activation': ['tanh', 'relu'],
+ 'solver': ['adam', 'sgd'],
+ 'alpha': [0.0001, 0.001, 0.01],
+ 'learning_rate': ['constant', 'adaptive']
+ },
+ 
+ "LGBM Classifier": {
+ 'n_estimators': [100, 200, 300],
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [-1, 10, 20]
+ },
+ 
+ "Multinomial Naive Bayes": {
+ 'alpha': [0.1, 0.5, 1.0]
+ },
+ 
+ "Categorical Naive Bayes": {
+ 'alpha': [0.1, 0.5, 1.0]
+ }
+}
+
+param_grids_reg = {
+ "Linear Regression": {},
+ 
+ "SGD Regressor": {
+ 'loss': ['squared_loss', 'huber'],
+ 'penalty': ['l2', 'l1', 'elasticnet'],
+ 'alpha': [0.0001, 0.001, 0.01],
+ 'max_iter': [1000, 5000, 10000]
+ },
+ 
+ "Ridge Regressor": {
+ 'alpha': [0.1, 1, 10, 100],
+ 'solver': ['auto', 'svd', 'cholesky', 'lsqr']
+ },
+ 
+ "Lasso Regressor": {
+ 'alpha': [0.1, 1, 10, 100]
+ },
+ 
+ "ElasticNet Regressor": {
+ 'alpha': [0.1, 1, 10, 100],
+ 'l1_ratio': [0.1, 0.5, 0.9]
+ },
+ 
+ "Random Forest Regressor": {
+ 'n_estimators': [100, 200, 300],
+ 'max_depth': [None, 10, 20, 30],
+ 'min_samples_split': [2, 5, 10],
+ 'min_samples_leaf': [1, 2, 4]
+ },
+ 
+ "AdaBoost Regressor": {
+ 'n_estimators': [50, 100, 200],
+ 'learning_rate': [0.01, 0.1, 1]
+ },
+ 
+ "Gradient Boosting Regressor": {
+ 'n_estimators': [100, 200, 300],
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [3, 5, 7]
+ },
+ 
+ "Hist Gradient Boosting Regressor": {
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [None, 10, 20],
+ 'min_samples_leaf': [20, 50, 100]
+ },
+ 
+ "K Neighbors Regressor": {
+ 'n_neighbors': [3, 5, 7],
+ 'weights': ['uniform', 'distance'],
+ 'metric': ['euclidean', 'manhattan']
+ },
+ 
+ "Decision Tree Regressor": {
+ 'max_depth': [None, 10, 20, 30],
+ 'min_samples_split': [2, 5, 10],
+ 'min_samples_leaf': [1, 2, 4]
+ },
+ 
+ "SVR": {
+ 'C': [0.1, 1, 10],
+ 'kernel': ['linear', 'poly', 'rbf'],
+ 'degree': [3, 4, 5],
+ 'gamma': ['scale', 'auto']
+ },
+ 
+ "XGB Regressor": {
+ 'n_estimators': [100, 200, 300],
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [3, 5, 7]
+ },
+ 
+ "XGBRF Regressor": {
+ 'n_estimators': [100, 200, 300],
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [3, 5, 7]
+ },
+ 
+ "MLP Regressor": {
+ 'hidden_layer_sizes': [(50,), (100,), (50, 50)],
+ 'activation': ['tanh', 'relu'],
+ 'solver': ['adam', 'sgd'],
+ 'alpha': [0.0001, 0.001, 0.01],
+ 'learning_rate': ['constant', 'adaptive']
+ },
+ 
+ "LGBM Regressor": {
+ 'n_estimators': [100, 200, 300],
+ 'learning_rate': [0.01, 0.1, 0.2],
+ 'max_depth': [-1, 10, 20]
+ },
+ 
+ "Gaussian Naive Bayes": {
+ 'var_smoothing': [1e-9, 1e-8, 1e-7]
+ }
+}
+
+# Define the regressors
+regressors = {
+ "Linear Regression": LinearRegression(),
+ "SGD Regressor": SGDRegressor(),
+ "Ridge Regressor": Ridge(),
+ "Lasso Regressor": Lasso(),
+ "ElasticNet Regressor": ElasticNet(),
+ "Random Forest Regressor": RandomForestRegressor(),
+ "AdaBoost Regressor": AdaBoostRegressor(),
+ "Gradient Boosting Regressor": GradientBoostingRegressor(),
+ "Hist Gradient Boosting Regressor": HistGradientBoostingRegressor(),
+ "K Neighbors Regressor": KNeighborsRegressor(),
+ "Decision Tree Regressor": DecisionTreeRegressor(),
+ "SVR": SVR(),
+ "XGB Regressor": XGBRegressor(),
+ "XGBRF Regressor": XGBRFRegressor(),
+ "MLP Regressor": MLPRegressor(),
+ "LGBM Regressor": LGBMRegressor(),
+ "Gaussian Naive Bayes": GaussianNB()
+}
+
+classifiers = {
+ "Logistic Regression": LogisticRegression(),
+ "SGD Classifier": SGDClassifier(),
+ "Ridge Classifier": RidgeClassifier(),
+ "Random Forest Classifier": RandomForestClassifier(),
+ "AdaBoost Classifier": AdaBoostClassifier(),
+ "Gradient Boosting Classifier": GradientBoostingClassifier(),
+ "Hist Gradient Boosting Classifier": HistGradientBoostingClassifier(),
+ "K Neighbors Classifier": KNeighborsClassifier(),
+ "Decision Tree Classifier": DecisionTreeClassifier(),
+ "SVC": SVC(),
+ "XGB Classifier": XGBClassifier(),
+ "XGBRF Classifier": XGBRFClassifier(),
+ "MLP Classifier": MLPClassifier(),
+ "LGBM Classifier": LGBMClassifier(),
+ "Multinomial Naive Bayes": MultinomialNB(),
+ "Categorical Naive Bayes": CategoricalNB()
+}
+def perform_grid_search(model,model_name,X_train,X_test,y_train,y_test,eva):
+ if eva == "reg":
+ regressor = regressors[model_name]
+ 
+ param_grid_reg = param_grids_reg[model_name]
+
+ grid_search = GridSearchCV(estimator=regressor, param_grid=param_grid_reg, cv=5, scoring='neg_mean_squared_error')
+ grid_search.fit(X_train,y_train)
+ st.write(f"Best Parameters for {model_name}: {grid_search.best_params_}")
+ st.write(f"Best Score for {model_name}: {grid_search.best_score_}")
+ best_model = grid_search.best_estimator_
+ y_pred = best_model.predict(X_test)
+ evaluationer.evaluation("best hyperparams",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
+ elif eva == "class":
+ classifier = classifiers[model_name]
+ param_grid_class = param_grids_class[model_name]
+
+ grid_search = GridSearchCV(estimator=classifier, param_grid=param_grid_class, cv=5, scoring='accuracy')
+ grid_search.fit(X_train,y_train)
+ st.write(f"Best Parameters for {model_name}: {grid_search.best_params_}")
+ st.write(f"Best Score for {model_name}: {grid_search.best_score_}")
+ best_model = grid_search.best_estimator_
+ y_pred = best_model.predict(X_test)
+ evaluationer.evaluation("best hyperparams",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)

models.py

@@ -23,6 +23,8 @@ from sklearn.neural_network import MLPRegressor
 from lightgbm import LGBMRegressor
 from sklearn.naive_bayes import GaussianNB
 
+
+
 # dictionary where keys are name of algorithm and values are algorithm for classifier
 algos_class = {
  "Logistic Regression": LogisticRegression(),

requirements.txt

@@ -1,10 +1,11 @@
+
 streamlit==1.34.0
 joblib==1.4.2
 numpy==1.26.4
 pandas==2.2.2
 scikit-learn==1.4.2
-seaborn==0.13.2
+datashader==0.16.2
+colorcet==3.1.0
+plotly==5.22.0
 matplotlib==3.9.0
-xgboost==2.0.3
-lightgbm==4.3.0
-statsmodels==0.14.2
+seaborn==0.13.2