Upload 9 files

app.py

@@ -0,0 +1,535 @@
+# import libraries
+import streamlit as st
+import joblib
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split as tts
+import evaluationer,models, null_value_handling
+import auto_optimizer
+from sklearn.experimental import enable_iterative_imputer
+from sklearn.impute import SimpleImputer, IterativeImputer
+# st.set_page_config(layout="wide")
+
+st.set_page_config(
+    page_title="LazyML App",
+    page_icon="🧊",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://www.extremelycoolapp.com/help',
+        'Report a bug': "https://www.extremelycoolapp.com/bug",
+        'About': "# This is a header. This is an *extremely* cool app!"
+    }
+)
+
+import streamlit as st
+
+# Title with Rainbow Transition Effect and Neon Glow
+html_code = """
+<div class="title-container">
+  <h1 class="neon-text">
+    LazyML
+  </h1>
+</div>
+
+<style>
+@keyframes rainbow-text-animation {
+  0% { color: red; }
+  16.67% { color: orange; }
+  33.33% { color: yellow; }
+  50% { color: green; }
+  66.67% { color: blue; }
+  83.33% { color: indigo; }
+  100% { color: violet; }
+}
+
+.title-container {
+  text-align: center;
+  margin: 1em 0;
+  padding-bottom: 10px;
+  border-bottom: 4  px solid #fcdee9; /* Magenta underline */
+}
+
+.neon-text {
+  font-family: Arial, sans-serif;
+  font-size: 4em;
+  margin: 0;
+  animation: rainbow-text-animation 5s infinite linear;
+  text-shadow: 0 0 5px rgba(255, 255, 255, 0.8),
+               0 0 10px rgba(255, 255, 255, 0.7),
+               0 0 20px rgba(255, 255, 255, 0.6),
+               0 0 40px rgba(255, 0, 255, 0.6),
+               0 0 80px rgba(255, 0, 255, 0.6),
+               0 0 90px rgba(255, 0, 255, 0.6),
+               0 0 100px rgba(255, 0, 255, 0.6),
+               0 0 150px rgba(255, 0, 255, 0.6);
+}
+</style>
+"""
+
+st.markdown(html_code, unsafe_allow_html=True)
+
+
+# file uploader 
+csv_upload = st.sidebar.file_uploader("Input CSV File for ML modelling", type=['csv'])
+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)
+
+    # saving the dataframe to a CSV file
+    df.to_csv('csv_upload.csv', index=False)
+    st.write("Train File uploaded successfully. ✅")
+
+    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)
+        submission_id = test[id_col]
+        # st.write("Train File upl",submission_id)
+
+        
+
+
+    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. ✅")
+    
+    display_train_data = st.radio("Display Train Data",["Yes","No"],index = 1)
+    if  display_train_data == "Yes":
+        st.dataframe(df.head())
+
+    if len(test) >0:
+        display_test_data = st.radio("Display Test Data",["Yes","No"],index = 1)
+        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))
+        
+        # Display the selected column
+        st.write('You selected:', selected_column)
+        
+        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": 
+                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.dataframe(y.head())
+
+
+        select_target_trans = st.radio("Target column Transformation",["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":
+                if y.min() <=0:
+                    st.write("Values in target columns are zeroes or negative, please select power transformation")
+                else:    
+                    log_selected_transformation = st.selectbox("Select Logarithmic method",["Natural Log base(e)","Log base 10","Log base (2)"])
+                    if log_selected_transformation == "Natural Log base(e)":
+                        y = np.log(y)
+                        st.write("Log base (e) Transformation Completed ✅")
+                    elif log_selected_transformation == "Log base 10":
+                        y = np.log10(y)
+                        st.write("Log base 10 Transformation Completed ✅")
+                    elif log_selected_transformation == "Log base (2)":
+                        y = np.log2(y)
+                        st.write("Log base 2 Transformation Completed ✅")
+            elif selected_transformation == "Power Transformation":
+                power_selected_transformation = st.selectbox("Select Power Transformation method",["Square Root","Other"])
+                if power_selected_transformation == "Square Root":
+                    y = np.sqrt(y)
+                    st.write("Square root Transformation Completed ✅")
+                elif power_selected_transformation == "Other":
+                    power_value = st.number_input("Enter Power Value",value=3)
+                    y = y**(1/power_value)
+                    st.write(f"power root of {power_value} Transformation Completed ✅")       
+        
+            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":    
+            len_duplicates = len(X[X.duplicated()])
+            if len_duplicates >0:
+                st.write(f"There are {len_duplicates} duplicate values in Train")
+                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")
+        # dropping not important columns
+        if st.radio("Drop Un-Important Column(s)",["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.dataframe(X.head())
+
+        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":
+            ml_cat_ao = st.radio("Select Machine Learning Category",["Regression","Classification"],index =0)
+
+            if ml_cat_ao =="Regression":
+                eva = "reg"
+                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)
+
+            elif ml_cat_ao =="Classification":
+                eva = "class"
+                st.write("Select ML algorithm")
+                class_model_name = st.selectbox("select model",models.Classification_models.index)
+                class_model = models.Classification_models.loc[class_model_name].values[0]
+                auto_optimizer.Auto_optimizer(X,y,eva,class_model)
+           
+
+        else:
+            if X.isnull().sum().sum() >0 :
+                st.write("⚠️⚠️⚠️ There are missing values in Train Data ⚠️⚠️⚠️")
+
+                if st.selectbox("Drop null values or Impute",["Drop Null Values","Impute Null Values"],index = 1) == "Drop Null Values":
+
+                    X = X.dropna()
+                    if len(test) >0:
+                        st.write("⚠️⚠️⚠️ If choosing drop values, test dataset will also drop those values please choose missing value imputation method befittingly.⚠️⚠️⚠️ ")
+                        test = test.dropna()
+
+                clean_num_nvh_df = pd.DataFrame()
+                if X[num_cols].isnull().sum().sum() >0:
+                    st.write("Numerical Columns with Percentage of Null Values: ")
+                    num_cols_nvh = X[num_cols].isnull().sum()[X[num_cols].isnull().sum()>0].index
+                    st.dataframe(round(X[num_cols].isnull().sum()[X[num_cols].isnull().sum()>0]/len(X)*100,2))
+                    dict_1= {}
+                    for nvh_method in null_value_handling.null_value_handling_method_num_cols :
+                        
+                        selected_nvh_num_cols = st.multiselect(f'method:- \"{nvh_method}\" for Numerical columns', num_cols_nvh,)
+                        dict_1[nvh_method] = selected_nvh_num_cols
+
+                        num_cols_nvh = set(num_cols_nvh) - set(selected_nvh_num_cols)
+                        if len(num_cols_nvh) ==0:
+                            break
+                    num_nvh_df = pd.DataFrame(data=dict_1.values(), index=dict_1.keys())
+
+                    clean_num_nvh_df = num_nvh_df.T[num_nvh_df.T.count()[num_nvh_df.T.count()>0].index]
+                    
+                    st.write("Methods for Numerical columns null value handling",clean_num_nvh_df )
+
+                if len(test) >0:
+                    if test[num_cols].isnull().sum().sum() >0:    
+                        test_num_cols_nvh = test[num_cols].isnull().sum()[test[num_cols].isnull().sum()>0].index
+                        st.write("Columns with Null Value in Test",test_num_cols_nvh)
+                        test[num_cols] = IterativeImputer(max_iter = 200,random_state= 42).fit_transform(test[num_cols])
+                
+
+                clean_num_nvh_df_cat = pd.DataFrame()
+                if X[cat_cols].isnull().sum().sum() >0:
+                    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))
+
+                    dict_2= {}
+                    for nvh_method in null_value_handling.null_value_handling_method_cat_cols :
+                        st.write("dsff",nvh_method)
+                        
+                        selected_nvh_num_cols = st.multiselect(f'method:- \"{nvh_method}\" for Numerical columns', cat_cols_nvh,)
+                        dict_2[nvh_method] = selected_nvh_num_cols
+
+                        cat_cols_nvh = set(cat_cols_nvh) - set(selected_nvh_num_cols)
+                        if len(cat_cols_nvh) ==0:
+                            break
+                    num_nvh_df_cat = pd.DataFrame(data=dict_2.values(), index=dict_2.keys())
+                    clean_num_nvh_df_cat = num_nvh_df_cat.T
+                    st.write("Methods for Categorical columns null value handling",[clean_num_nvh_df_cat])  
+
+                if len(test) >0:
+                    if test[cat_cols].isnull().sum().sum() >0:    
+                        test_num_cols_nvh_cat = test[cat_cols].isnull().sum()[test[cat_cols].isnull().sum()>0].index
+                        st.write("sdgs",test_num_cols_nvh_cat)
+                        test[cat_cols] = SimpleImputer(strategy = "most_frequent").fit_transform(test[cat_cols])
+
+                
+                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')
+
+            ord_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:
+                if st.radio("proceed for ordinal encoding",["Yes","No"],index = 1) == "Yes":
+                    ordinal_order_vals = []
+
+                    for column in ord_enc_cols:
+                        unique_vals = X[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))   
+                    # import ordinal encoder
+                    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])
+                    if len(test) >0:
+                        test[ord_enc_cols] = ord.transform(test[ord_enc_cols])
+                    st.write("DataFrame after Ordinal Encoding",X.head())
+                    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
+                    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)
+                    if len(test) >0:
+                        test.loc[:, ohe.get_feature_names_out()] = ohe.transform(test[ohe_enc_cols])
+                        test.drop(columns = ohe_enc_cols,inplace = True)
+
+                    pd.options.mode.chained_assignment = 'warn'
+
+                    st.write("DataFrame after One Hot Encoding",X.head())
+                    st.write("OneHot Encoding Completed ✅")
+            
+            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": 
+                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})":
+                ttsmethod = "Train_Test_split"
+            else:
+                ttsmethod = "KFoldCV"
+            st.write('You selected:', ttsmethod)
+            if ttsmethod == "Train_Test_split":
+                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)
+
+            if ml_cat =="Regression":
+                method_name_selector = st.selectbox("Select Error Evaluation Method",evaluationer.method_df.index,index = 0)
+
+                method = evaluationer.method_df.loc[method_name_selector].values[0]
+                reg_algorithm = []
+                selected_options = []
+
+                for option in models.Regression_models.index:
+                    selected = st.checkbox(option)
+                    if selected:
+                        selected_options.append(option)
+
+                        param = models.Regression_models.loc[option][0].get_params()
+                        Temp_parameter = pd.DataFrame(data=param.values(), index=param.keys())                    
+                        Temp_parameter_transposed = Temp_parameter.T
+                        parameter = pd.DataFrame(data=param.values(), index=param.keys())
+                        def is_boolean(val):
+                            return isinstance(val, bool)
+
+                        # Apply the function to the DataFrame column and create a new column with the resuSlts
+                        bool_cols= parameter[parameter[0].apply(is_boolean)].index
+                        param_transposed = parameter.T
+                        # st.write("hrweurgesj",param_transposed.loc[:, bool_cols])
+                        # st.write("bool_cols",bool_cols)
+                        remaining_cols = set(param_transposed.columns) - set(bool_cols)
+                        remaining_cols = tuple(remaining_cols)
+                        # st.write("rem_Cols",remaining_cols)
+
+                        for col in remaining_cols:    
+                            param_transposed[col] = pd.to_numeric(param_transposed[col],errors="ignore")
+                        cat_cols = param_transposed.select_dtypes(include = ["O"]).T.index.to_list()
+                        num_cols = set(remaining_cols) - set(cat_cols)
+                        cat_cols = set(cat_cols) - set(bool_cols)
+                        num_cols = tuple(num_cols)
+                        # st.write("sdsafdsd",num_cols)
+                        for i in num_cols:
+                            param_transposed[i] = st.number_input(f"input \"{i}\" value \n{option}",value = parameter.T[i].values[0])
+                        for i in cat_cols:
+                            param_transposed[i] = st.text_input(f"input \"{i}\" value \n{option}",value = parameter.T[i].values[0])
+                        for i in bool_cols:
+                            st.write("default value to insert",Temp_parameter_transposed[i].values[0])
+                            param_transposed[i] = st.selectbox(f"input \"{i}\" value \n{option}",[False, True], index=Temp_parameter_transposed[i].values[0])
+                            
+                        inv_param = param_transposed.T
+                        new_param = inv_param.dropna().loc[:,0].to_dict()
+                        # st.write("asad",new_param)
+                        models.Regression_models.loc[option][0].set_params(**new_param)
+                        a =  models.Regression_models.loc[option][0].get_params()
+                        reg_algorithm.append(models.Regression_models.loc[option][0])
+                if st.button("Train Regression Model"):
+                    for algorithm in reg_algorithm:
+                        evaluationer.evaluation(f"{algorithm} baseline",X_train,X_Val,y_train,y_val,algorithm,method,"reg")
+                    st.write("Regression Model Trained Successfully",evaluationer.reg_evaluation_df)
+                if len(test)>0:
+                    if st.radio("Predict",["Yes","No"],index = 1) =="Yes":
+
+                        if len(evaluationer.reg_evaluation_df) >0:
+                            a = st.number_input("select index of best algorithm for test prediction",min_value = 0,max_value =len(evaluationer.reg_evaluation_df) -1, value = len(evaluationer.reg_evaluation_df) -1)
+                            
+                            test_prediction = evaluationer.reg_evaluation_df.loc[a,"model"].predict(test)
+                            if  select_target_trans == "Yes":
+                                if selected_transformation == "Log Transformation":
+                                    if log_selected_transformation == "Natural Log base(e)":
+                                        test_prediction = np.exp(test_prediction)
+                                        st.write("Natural Log base(e) Inverse Transformation Completed ✅")
+                                    elif log_selected_transformation == "Log base 10":
+                                        test_prediction = np.power(10,test_prediction)
+                                        st.write("Log base 10 Inverse Transformation Completed ✅")
+                                    elif log_selected_transformation == "Log base (2)":
+                                        test_prediction = np.power(2,test_prediction)
+                                        st.write("Log base 2 Inverse Transformation Completed ✅")
+                                elif selected_transformation == "Power Transformation":
+                                    if power_selected_transformation == "Square Root":
+                                        test_prediction = np.power(test_prediction,2)
+                                        st.write("Square root Inverse Transformation Completed ✅")
+                                    elif power_selected_transformation == "Other":
+                                        test_prediction = test_prediction**(power_value)
+                                        st.write(f"power root of {power_value} Inverse Transformation Completed ✅")
+                            submission_file = pd.DataFrame(index = [submission_id],data = test_prediction,columns = [selected_column])
+                            st.write("Sample of Prediction File",submission_file.head())
+                            csv_prediction = submission_file.to_csv()
+                            if st.radio("Download Prediction File as CSV File ? ",["Yes","No"],index = 1) == "Yes": 
+                                st.download_button(label="Download Prediction CSV File",data=csv_prediction,file_name='prediction.csv',mime='text/csv')
+
+            
+
+                
+            if ml_cat =="Classification":
+                
+                
+                
+                cla_algorithm = []
+                selected_options = []
+
+                for option in models.Classification_models.index:
+                    selected = st.checkbox(option)
+                    if selected:
+                        selected_options.append(option)
+                        
+                        param = models.Classification_models.loc[option][0].get_params()
+                                
+                        
+                        parameter = pd.DataFrame(data=param.values(), index=param.keys())
+                        Temp_parameter = parameter.copy()
+                        Temp_parameter_transposed = (Temp_parameter.T).copy()    
+                        def is_boolean(val):
+                            return isinstance(val, bool)
+
+                        # Apply the function to the DataFrame column and create a new column with the resuSlts
+                        bool_cols= parameter[parameter[0].apply(is_boolean)].index
+                        param_transposed = parameter.T
+                        st.write("bool_cols",bool_cols)
+                        remaining_cols = set(param_transposed.columns) - set(bool_cols)
+                        remaining_cols = tuple(remaining_cols)
+                        st.write("rem_Cols",remaining_cols)
+
+                        for col in remaining_cols:    
+                            param_transposed[col] = pd.to_numeric(param_transposed[col],errors="ignore")
+                        cat_cols = param_transposed.select_dtypes(include = ["O"]).T.index.to_list()
+                        num_cols = set(remaining_cols) - set(cat_cols)
+                        num_cols = tuple(num_cols)
+                        st.write("sdsafdsd",num_cols)
+                        for i in num_cols:
+                            param_transposed[i] = st.number_input(f"input \"{i}\" value \n{option}",value = parameter.T[i].values[0])
+                        for i in cat_cols:
+                            param_transposed[i] = st.text_input(f"input \"{i}\" value \n{option}",value = parameter.T[i].values[0])
+                        for i in bool_cols:
+                            st.write("default value to insert",Temp_parameter_transposed[i].values[0])
+                            param_transposed[i] = st.selectbox(f"input \"{i}\" value \n{option}",[False,True], index=Temp_parameter_transposed[i].values[0])
+                        inv_param = param_transposed.T
+                        new_param = inv_param.dropna().loc[:,0].to_dict()
+                        st.write("asad",new_param)
+                        models.Classification_models.loc[option][0].set_params(**new_param)
+                        a =  models.Classification_models.loc[option][0].get_params()
+                        cla_algorithm.append(models.Classification_models.loc[option][0])
+                # st.write("sada",reg_algorithm/)
+                if st.button("Train Regression Model"):
+                    method = None
+                    for algorithm in cla_algorithm:
+                        evaluationer.evaluation(f"{algorithm} baseline",X_train,X_Val,y_train,y_val,algorithm,method,eva ="class")
+                    st.write("Regression Model Trained Successfully",evaluationer.classification_evaluation_df)
+
+                if len(test)>0:
+                    if st.radio("Predict",["Yes","No"],index = 1) =="Yes":
+                        if len(evaluationer.classification_evaluation_df) >0:
+                            a = st.number_input("select index of best algorithm for test prediction",min_value = 0,max_value =len(evaluationer.classification_evaluation_df) -1, value = len(evaluationer.classification_evaluation_df) -1)
+                            
+                            test_prediction = evaluationer.classification_evaluation_df.loc[a,"model"].predict(test)    
+                            if  select_target_trans == "Yes":
+                                if selected_transformation == "Log Transformation":
+                                    if log_selected_transformation == "Natural Log base(e)":
+                                        test_prediction = np.exp(test_prediction)
+                                        st.write("Natural Log base(e) Inverse Transformation Completed ✅")
+                                    elif log_selected_transformation == "Log base 10":
+                                        test_prediction = np.power(10,test_prediction)
+                                        st.write("Log base 10 Inverse Transformation Completed ✅")
+                                    elif log_selected_transformation == "Log base (2)":
+                                        test_prediction = np.power(2,test_prediction)
+                                        st.write("Log base 2 Inverse Transformation Completed ✅")
+                                elif selected_transformation == "Power Transformation":
+                                    if power_selected_transformation == "Square Root":
+                                        test_prediction = np.power(test_prediction,2)
+                                        st.write("Square root Inverse Transformation Completed ✅")
+                                    elif power_selected_transformation == "Other":
+                                        test_prediction = test_prediction**(power_value)
+                                        st.write(f"power root of {power_value} Inverse Transformation Completed ✅")
+                          
+                            submission_file = pd.DataFrame(index = [submission_id],data = test_prediction,columns = [selected_column])
+                            st.write("Sample of Prediction File",submission_file.head())
+                            csv_prediction = submission_file.to_csv()
+                            if st.radio("Download Prediction File as CSV File ? ",["Yes","No"],index = 1) == "Yes": 
+                                st.download_button(label="Download Prediction CSV File",data=csv_prediction,file_name='prediction.csv',mime='text/csv')
+
+
+  
+

auto_optimizer.py

@@ -0,0 +1,317 @@
+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):
+    pass
+    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)
+
+    
+
+
+    
+
+
+
+
+
+
+
+
+

best_tts.py

@@ -0,0 +1,110 @@
+from sklearn.model_selection import train_test_split as tts
+from sklearn.metrics import r2_score,f1_score,accuracy_score, root_mean_squared_error
+import evaluationer 
+import pandas as pd
+import numpy as np
+
+def best_tts(X,y,model,eva):
+    # def best_tts(X,y,test_size_range = range(10,25),random_state_range =range(1,100), stratify=None,shuffle=True,model = LinearRegression(),method = root_mean_squared_error,eva = "reg"):
+   
+    if eva == "reg":
+        
+        test_r2_,test_r2_ts,test_r2_rs = 0,0,0
+        for k in range(10,25):
+            i = k/100
+            for j in range(1,100):
+                X_train,X_test,y_train,y_test = tts(X,y[X.index],test_size = i, random_state = j,)
+                
+                model = model
+                model.fit(X_train,y_train) # model fitting
+                y_pred_train = model.predict(X_train) # model prediction for train
+                y_pred_test = model.predict(X_test) # model prediction for test
+    
+                train_r2 = r2_score(y_train, y_pred_train) # evaluating r2 score for train
+                
+                
+                test_r2 = r2_score(y_test, y_pred_test)  # evaluating r2 score for test
+                if test_r2_ < test_r2:
+                    test_r2_ = test_r2
+                    test_r2_ts = i
+                    test_r2_rs = j
+    
+                n_r_train, n_c_train = X_train.shape # getting no of rows and columns of train data
+                n_r_test,  n_c_test = X_test.shape # getting no of rows and columns of test data
+    
+                adj_r2_train = 1 - ((1 - train_r2)*(n_r_train - 1)/ (n_r_train - n_c_train - 1))  # evaluating adjusted r2 score for train
+                
+                    
+                adj_r2_test = 1 - ((1 - test_r2)*(n_r_test - 1)/ (n_r_test - n_c_test - 1)) # evaluating adjusted r2 score for test
+                
+                    
+                train_evaluation = root_mean_squared_error(y_train, y_pred_train) # evaluating train error
+                
+                    
+                test_evaluation = root_mean_squared_error(y_test, y_pred_test) # evaluating test error
+                
+        X_train,X_test,y_train,y_test = tts(X,y[X.index],test_size = test_r2_ts, random_state = test_r2_rs)           
+        evaluationer.evaluation("best_tts",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
+        return evaluationer.reg_evaluation_df,X_train,X_test,y_train,y_test
+
+    
+    
+    elif eva == "class":        
+        global  test_accuracies_,test_accuracies_ts,test_accuracies_rs
+        test_accuracies_,test_accuracies_ts,test_accuracies_rs = 0,0,0
+        
+        for k in range(10,25):
+            i = k/100
+            for j in range(1,100):
+                X_train,X_test,y_train,y_test = tts(X,y[X.index],test_size = i, random_state = j)
+                model = model
+                model.fit(X_train,y_train) # model fitting
+                y_pred_train = model.predict(X_train) # model prediction for train
+                y_pred_test = model.predict(X_test) # model prediction for test
+                # y_pred_proba_train= model.predict_proba(X_train)
+                # y_pred_proba_test= model.predict_proba(X_test)
+                
+                
+                unique_classes = np.unique(y_train)
+            
+                # Determine the average method
+                if len(unique_classes) == 2:
+                    # Binary classification
+                    # print("Using 'binary' average for binary classification.")
+                    average_method = 'binary'
+                elif len(unique_classes)!=2:
+                    # Determine the distribution of the target column
+                    class_counts = np.bincount(y_train)
+                    
+                    # Check if the dataset is imbalanced
+                    imbalance_ratio = max(class_counts) / min(class_counts)
+                    
+                    if imbalance_ratio > 1.5:
+                        # Imbalanced dataset
+                        # print("Using 'weighted' average due to imbalanced dataset.")
+                        average_method = 'weighted'
+                    else:
+                        # Balanced dataset
+                        # print("Using 'macro' average due to balanced dataset.")
+                        average_method = 'macro'
+                        # F1 scores
+                train_f1_scores = (f1_score(y_train, y_pred_train,average=average_method))
+               
+                    
+                test_f1_scores = (f1_score(y_test, y_pred_test,average=average_method))    
+                
+                # Accuracies
+                train_accuracies = (accuracy_score(y_train, y_pred_train))
+                
+                test_accuracies = (accuracy_score(y_test, y_pred_test))
+                if test_accuracies_ <test_accuracies:
+                    test_accuracies_,test_accuracies_ts,test_accuracies_rs =test_accuracies, i,j
+        X_train,X_test,y_train,y_test = tts(X,y[X.index],test_size = test_accuracies_ts, random_state = test_accuracies_rs)   
+        print(f"test_size = {test_accuracies_ts}, random_state = {test_accuracies_rs}")  
+
+        evaluationer.evaluation("best_tts",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
+        
+
+        return evaluationer.classification_evaluation_df,X_train,X_test,y_train,y_test
+            
+             

evaluationer.py

@@ -0,0 +1,151 @@
+# importing libraries
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import root_mean_squared_error,r2_score,mean_squared_error,root_mean_squared_log_error,mean_absolute_error,mean_squared_log_error
+from sklearn.metrics import f1_score, accuracy_score, precision_score,recall_score, average_precision_score
+# creating a class for evaluation
+    
+reg_evaluation_df = pd.DataFrame({"evaluation_df_method" :[],
+                                "model": [],# model displays regression model
+                                "method": [],# method display evaluation metrics used
+                                "train_r2": [],# train r2 shows train R2 score
+                                "test_r2": [],# test r2 shows test R2 Score
+                                "adjusted_r2_train": [],# adjusted_r2_train shows adjusted r2 score for train
+                                "adjusted_r2_test": [],# adjusted_r2_test shows adjusted r2 score for test
+                                "train_evaluation": [],# train_evaluation shows train evaluation score by used method
+                                "test_evaluation" : []# test_evaluation shows test evaluation score by used method
+                            })
+
+classification_evaluation_df = pd.DataFrame({"evaluation_df_method" :[],
+                        'model': [],
+                        'train_f1': [],
+                        'test_f1': [],
+                        'train_acc': [],
+                        'test_acc': [],
+                        'precision_train': [],
+                        'precision_test': [],
+                        'recall_train': [],
+                        'recall_test': []
+                    })
+
+# function for evaluating dataframe
+def evaluation(evaluation_df_method,X_train,X_test,y_train,y_test,model,method,eva):# input parameters from train_test_split , model and method for evaluation.
+    global y_pred_train,y_pred_test,y_pred_proba_train,y_pred_proba_test
+    model = model
+    model.fit(X_train,y_train) # model fitting
+    y_pred_train = model.predict(X_train) # model prediction for train
+    y_pred_test = model.predict(X_test) # model prediction for test
+
+    if eva == "reg":
+        
+        train_r2 = r2_score(y_train, y_pred_train) # evaluating r2 score for train
+        test_r2 = r2_score(y_test, y_pred_test)  # evaluating r2 score for test
+        
+        n_r_train, n_c_train = X_train.shape # getting no of rows and columns of train data
+        n_r_test,  n_c_test = X_test.shape # getting no of rows and columns of test data
+        
+        adj_r2_train = 1 - ((1 - train_r2)*(n_r_train - 1)/ (n_r_train - n_c_train - 1))  # evaluating adjusted r2 score for train
+        adj_r2_test = 1 - ((1 - test_r2)*(n_r_test - 1)/ (n_r_test - n_c_test - 1)) # evaluating adjusted r2 score for test
+    
+        train_evaluation = method(y_train, y_pred_train) # evaluating train error
+        test_evaluation = method(y_test, y_pred_test) # evaluating test error
+        
+        if method == root_mean_squared_error:
+            a = "root_mean_squared_error"
+        elif method ==root_mean_squared_log_error:
+            a = "root_mean_squared_log_error"
+        elif method == mean_absolute_error:
+            a = "mean_absolute_error"
+        elif method == mean_squared_error:
+            a = "mean_squared_error"
+        elif method == mean_squared_log_error:
+            a = "mean_squared_log_error"    
+        
+        # declaring global dataframes
+        global reg_evaluation_df,temp_df
+        
+        # creating temporary dataframe for concating in later into main evaluation dataframe
+        temp_df = pd.DataFrame({"evaluation_df_method" :[evaluation_df_method],
+                                    "model": [model],
+                                    "method": [a],
+                                    "train_r2": [train_r2],
+                                    "test_r2": [test_r2],
+                                    "adjusted_r2_train": [adj_r2_train],
+                                    "adjusted_r2_test": [adj_r2_test],
+                                    "train_evaluation": [train_evaluation],
+                                    "test_evaluation" : [test_evaluation]
+                                    })
+        reg_evaluation_df = pd.concat([reg_evaluation_df,temp_df]).reset_index(drop = True)
+        
+
+
+        
+        # return reg_evaluation_df # returning evaluation_df
+
+    elif eva == "class":
+                
+        # y_pred_proba_train= model.predict_proba(X_train)
+        # y_pred_proba_test= model.predict_proba(X_test)
+
+        unique_classes = np.unique(y_train)
+    
+        # Determine the average method
+        if len(unique_classes) == 2:
+            # Binary classification
+            print("Using 'binary' average for binary classification.")
+            average_method = 'binary'
+        elif len(unique_classes)!=2:
+            # Determine the distribution of the target column
+            class_counts = np.bincount(y_train)
+            
+            # Check if the dataset is imbalanced
+            imbalance_ratio = max(class_counts) / min(class_counts)
+            
+            if imbalance_ratio > 1.5:
+                # Imbalanced dataset
+                print("Using 'weighted' average due to imbalanced dataset.")
+                average_method = 'weighted'
+            else:
+                # Balanced dataset
+                print("Using 'macro' average due to balanced dataset.")
+                average_method = 'macro'
+            
+        # F1 scores
+        train_f1_scores = (f1_score(y_train, y_pred_train,average=average_method))
+        test_f1_scores = (f1_score(y_test, y_pred_test,average=average_method))    
+    
+        # Accuracies
+        train_accuracies = (accuracy_score(y_train, y_pred_train))
+        test_accuracies = (accuracy_score(y_test, y_pred_test))
+    
+        # Precisions
+        train_precisions = (precision_score(y_train, y_pred_train,average=average_method))
+        test_precisions = (precision_score(y_test, y_pred_test,average=average_method))
+    
+        # Recalls
+        train_recalls = (recall_score(y_train, y_pred_train,average=average_method))
+        test_recalls = (recall_score(y_test, y_pred_test,average=average_method))
+        
+        # declaring global dataframes
+        global classification_evaluation_df,temp_df1
+        
+        # creating temporary dataframe for concating in later into main evaluation dataframe
+        temp_df1 = pd.DataFrame({"evaluation_df_method" :[evaluation_df_method],
+            'model': [model],
+            'train_f1': [train_f1_scores],
+            'test_f1': [test_f1_scores],
+            'train_acc': [train_accuracies],
+            'test_acc': [test_accuracies],
+            'precision_train': [train_precisions],
+            'precision_test': [test_precisions],
+            'recall_train': [train_recalls],
+            'recall_test': [test_recalls]
+        })
+        classification_evaluation_df = pd.concat([classification_evaluation_df, temp_df1]).reset_index(drop = True)
+        
+        return classification_evaluation_df # returning evaluation_df
+
+global method_df
+method_df = pd.DataFrame(data = [root_mean_squared_error, root_mean_squared_log_error,mean_absolute_error,mean_squared_error,mean_squared_log_error],
+                         index = ["root_mean_squared_error", "root_mean_squared_log_error","mean_absolute_error","mean_squared_error","mean_squared_log_error"])

feature_selections.py

@@ -0,0 +1,104 @@
+from sklearn.feature_selection import mutual_info_regression
+from statsmodels.stats.outliers_influence import variance_inflation_factor
+from sklearn.linear_model import Lasso
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import roc_curve, auc
+import statsmodels.api as sm
+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()
+    pval_cols = model_fit.pvalues[model_fit.pvalues > 0.05].index.tolist()
+    coef_cols = model_fit.params[abs(model_fit.params) < 0.001].index.tolist()
+    pval_and_coef_cols = list(set(coef_cols) | set(pval_cols))
+
+    mi_scores = mutual_info_regression(X_train, y_train)
+    mi = pd.DataFrame()
+
+    mi["col_name"] = X_train.columns
+    mi["mi_score"] = mi_scores
+
+    mi_cols = mi[mi.mi_score ==0].col_name.values.tolist()
+
+    corr = X_train.corr()
+    
+    corru= pd.DataFrame(np.triu(corr),columns = corr.columns , index = corr.index)
+    corr_u_cols = corru[corru[(corru > 0.5 )& (corru <1)].any()].index.tolist()
+    
+    corrl= pd.DataFrame(np.tril(corr),columns = corr.columns , index = corr.index)
+    corr_l_cols = corrl[corrl[(corrl > 0.5 )& (corrl <1)].any()].index.tolist()
+    
+    X_new_vif = sm.add_constant(X_train)
+    # Calculating VIF
+    vif = pd.DataFrame()
+    vif["variables"] = X_new_vif.columns
+    vif["VIF"] = [variance_inflation_factor(X_new_vif.values, i) for i in range(X_new_vif.shape[1])]
+    st.write("gdfgdsdsdfad",vif)
+    if len(vif[vif["variables"] == "const"]) == 1:
+        vif = vif.drop(index = (vif[vif["variables"] == "const"].index[0]))
+    st.write("gdfgdsad",vif)
+    # drop const in vif cols
+    # vif_cols = X_new_vif.drop(columns = "const")
+    vif_cols = vif[vif.VIF >10].variables.tolist()
+
+
+    # lasso
+    if alpha == "best":
+        
+        lasso_len = []
+        alpha_i = []
+        for i in range(1,1000,5):
+            j = i/10000
+
+            model_lasso = Lasso(alpha=j)
+            model_lasso.fit(X_train, y_train)
+            col_df = pd.DataFrame({
+                "col_name": X_train.columns,
+                "lasso_coef": model_lasso.coef_
+            })
+            a = len(col_df[col_df.lasso_coef ==0])
+            lasso_len.append(a)
+            alpha_i.append(j)
+        for i in zip(lasso_len,alpha_i):
+            print(i)
+        input_alpha = float(input("enter alpha"))
+        model_lasso = Lasso(alpha=input_alpha)
+        model_lasso.fit(X_train, y_train)
+        col_df = pd.DataFrame({
+            "col_name": X_train.columns,
+            "lasso_coef": model_lasso.coef_
+        })
+
+        lasso_cols =col_df[col_df.lasso_coef ==0].col_name.tolist()
+    else:
+        model_lasso = Lasso(alpha=alpha)
+        model_lasso.fit(X_train, y_train)
+        col_df = pd.DataFrame({
+            "col_name": X_train.columns,
+            "lasso_coef": model_lasso.coef_
+        })
+
+        lasso_cols =col_df[col_df.lasso_coef ==0].col_name.tolist()
+        
+    feature_cols = [pval_cols,coef_cols,pval_and_coef_cols,mi_cols,corr_u_cols,corr_l_cols,vif_cols,lasso_cols]
+    
+    for col in feature_cols:
+        
+        try:
+            st.write(f"{col}",X_train.drop(columns = col))
+        except:
+            st.write(f"error IN col")
+    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

models.py

@@ -0,0 +1,70 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+# import algorithms for classification 
+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
+# import algorithms for regression
+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
+
+# dictionary where keys are name of algorithm and values are algorithm for classifier
+algos_class = {
+    "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()}
+
+# dictionary where keys are name of algorithm and values are algorithm for regression
+algos_reg = {
+    "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()}
+
+# dataframe where index are name of algorithm as "algorithm name" , column  is algorithm as "algorithm"
+
+Classification_models = pd.DataFrame(data=algos_class.values(), index=algos_class.keys())
+
+Regression_models = pd.DataFrame(data=algos_reg.values(), index=algos_reg.keys())
+

null_value_handling.py

@@ -0,0 +1,49 @@
+import pandas as pd
+import streamlit as st
+# import simple imputer, iter imputer , knn inputer
+from sklearn.model_selection import train_test_split as tts
+from sklearn.experimental import enable_iterative_imputer
+from sklearn.impute import SimpleImputer, IterativeImputer, KNNImputer
+import evaluationer
+# import label, ohe,ordinal encoder
+from sklearn.preprocessing import LabelEncoder, OneHotEncoder, OrdinalEncoder
+
+# creating a function for null_handling with different methods for null value imputing, categorical columns encoding and evaluation
+
+null_value_handling_method_num_cols = ["KNN Imputed","SI Mean Imputed","SI Median Imputed","SI Most Frequent Imputed","Iter Imputed"]
+null_value_handling_method_cat_cols = ["SI Most Frequent Imputed (categorical)"]
+
+# dict for null value handling method num cols 
+
+dict1 = {"KNN Imputed" :KNNImputer(n_neighbors = 5),"SI Mean Imputed":SimpleImputer(strategy = "mean"),"SI Median Imputed":SimpleImputer(strategy = "median"),
+         "SI Most Frequent Imputed":SimpleImputer(strategy = "most_frequent"),"Iter Imputed":IterativeImputer(max_iter = 200,random_state= 42)}
+
+dict2 = {"SI Most Frequent Imputed (categorical)":SimpleImputer(strategy = "most_frequent")}
+
+# creating dataframe from dict1 and dict2
+num_nvh_method_df = pd.DataFrame(data=dict1.values(), index=dict1.keys())
+cat_nvh_method_df = pd.DataFrame(data=dict2.values(), index=dict2.keys())
+
+num_imputed_dict = {"KNN Imputed":[],"SI Mean Imputed":[],"SI Median Imputed":[],"SI Most Frequent Imputed":[],"Iter Imputed":[]}
+
+cat_imputed_dict = {"SI Most Frequent Imputed (categorical)":[],"Iter Imputed":[]}
+
+num_imputed_df = pd.DataFrame(data = num_imputed_dict.values(),index = num_imputed_dict.keys())
+
+cat_imputed_df = pd.DataFrame(data = cat_imputed_dict.values(),index = cat_imputed_dict.keys())
+
+final_df = []
+def null_handling(X,clean_num_nvh_df,clean_num_nvh_df_cat):
+    num_nvh_method = clean_num_nvh_df.columns #KNN Imputed","SI Mean Imputed","SI Media
+    cat_nvh_method = clean_num_nvh_df_cat.columns
+    for method in num_nvh_method:
+        X[clean_num_nvh_df[method].dropna().values] = num_nvh_method_df.loc[method].values[0].fit_transform(X[clean_num_nvh_df[method].dropna().values])
+    
+    for method in cat_nvh_method:
+        X[clean_num_nvh_df_cat[method].dropna().values] = cat_nvh_method_df.loc[method].values[0].fit_transform(X[clean_num_nvh_df_cat[method].dropna().values])
+
+    final_df = X
+
+    return final_df
+
+

outliers.py

@@ -0,0 +1,233 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy.stats.mstats import winsorize
+from sklearn.preprocessing import StandardScaler,MinMaxScaler
+from sklearn.metrics import root_mean_squared_error
+from scipy.stats import yeojohnson
+import evaluationer
+from sklearn.model_selection import train_test_split as tts
+def detect_outliers(df,num_cols):
+    global outlier_df,zscore_cols,outlier_indexes,iqr_cols
+    outlier_df = pd.DataFrame({"method" :[],"columns name":[],"upper limit":[],
+                           "lower limit":[],"no of Rows":[],"percentage outlier":[]})
+    if type(num_cols) == list:
+        if len(num_cols)!=0:
+            num_cols = num_cols
+        else:
+            num_cols = df.select_dtypes(exclude = "object").columns.tolist()
+    else:
+        if num_cols.tolist() != None:
+            num_cols = num_cols
+        else:
+            num_cols = df.select_dtypes(exclude = "object").columns.tolist()
+    zscore_cols = []
+    iqr_cols = []
+    outlier_indexes =[]
+    for col in num_cols:
+        skewness = df[col].skew()
+        if -0.5 <= skewness <= 0.5:
+            method = "zscore"
+            zscore_cols.append(col)
+
+        else:
+            method = "iqr"
+            iqr_cols.append(col)
+    if len(zscore_cols) >0:
+        for col in zscore_cols:
+            mean = df[col].mean()
+            std = df[col].std()
+            ul = mean + (3*std)
+            ll = mean - (3*std)
+            mask = (df[col] < ll) | (df[col] > ul)
+            temp = df[mask]
+
+            Zscore_index = temp.index.tolist()
+            outlier_indexes.extend(Zscore_index)
+
+            if len(temp)>0:
+
+                temp_df = pd.DataFrame({"method" : ["ZScore"],
+                "columns name" : [col],
+                "upper limit" : [round(ul,2)],
+                "lower limit" :[ round(ll,2)],
+                "no of Rows" : [len(temp)],
+                "percentage outlier" : [round(len(temp)*100/len(df),2)]})
+                
+                outlier_df = pd.concat([outlier_df,temp_df]).reset_index(drop = True)
+
+    else:
+        print("No columns for Zscore method")
+       
+    
+    if len(iqr_cols) >0:
+        for col in iqr_cols:
+            q3 = df[col].quantile(.75)
+            q1 = df[col].quantile(.25)
+            IQR = q3 -q1
+            ul = q3 + 1.5*IQR
+            ll = q1 - 1.5*IQR
+            mask = (df[col] < ll) | (df[col] > ul)
+            temp = df[mask]
+
+            IQR_index = temp.index.tolist()
+            outlier_indexes.extend(IQR_index)
+
+            if len(temp)>0:
+                list(outlier_indexes).append(list(IQR_index))
+
+                temp_df1 = pd.DataFrame({"method" : ["IQR"],
+                "columns name" : [col],
+                "upper limit" : [round(ul,2)],
+                "lower limit" : [round(ll,2)],
+                "no of Rows": [len(temp)],
+                "percentage outlier" : [round((len(temp)*100/len(df)),2)]
+                                    })
+          
+                outlier_df = pd.concat([outlier_df,temp_df1]).reset_index(drop = True)
+            
+    else:
+        print("No columns for IQR method")
+
+       
+    outlier_indexes = list(set(outlier_indexes))
+    
+    return outlier_df,outlier_indexes
+
+
+def outlier_handling(df,y,model,outlier_indexes = [],outlier_cols = None ,method = root_mean_squared_error,test_size = 0.2, random_state = 42,eva = "reg"):
+    num_col = df.select_dtypes(exclude = "O").columns
+    
+    global outliers_dropped_df,log_transformed_df,sqrt_transformed_df,yeo_johnson_transformed_df,rank_transformed_df
+    global std_scaler_df,winsorize_transformed_df,inverse_log_transformed_winsorize_df,inverse_sqrt_transformed_winsorize_df,minmaxscaler_df
+    if eva == "reg":
+        if len(outlier_indexes) ==0:
+            print("no outlier indexes passed")
+            outliers_dropped_df = df.copy()
+        else:
+            outliers_dropped_df = df.drop(index =outlier_indexes)
+        
+        if outlier_cols != None:
+                    
+            if df[outlier_cols][df[outlier_cols] <0].sum().sum() == 0:
+                log_transformed_df = df.copy()
+                log_transformed_df[outlier_cols] = np.log(log_transformed_df[outlier_cols] + 1e-5)
+                sqrt_transformed_df = df.copy()
+                sqrt_transformed_df[outlier_cols] = np.sqrt(sqrt_transformed_df[outlier_cols] + 1e-5)
+                inverse_log_transformed_winsorize_df = log_transformed_df.copy()
+                inverse_sqrt_transformed_winsorize_df = sqrt_transformed_df.copy()
+                for column in outlier_cols:
+                    inverse_log_transformed_winsorize_df[column] =  np.exp(winsorize(inverse_log_transformed_winsorize_df[column], limits=[0.05, 0.05]))
+                    inverse_sqrt_transformed_winsorize_df[column] =  (winsorize(inverse_sqrt_transformed_winsorize_df[column], limits=[0.05, 0.05]))**2
+            else:
+                print("df have values less than zero")
+            std_scaler_df = df.copy()
+            std_scaler_df[outlier_cols] = StandardScaler().fit_transform(std_scaler_df[outlier_cols])
+            
+            minmaxscaler_df = df.copy()
+            minmaxscaler_df[outlier_cols] = MinMaxScaler().fit_transform(minmaxscaler_df[outlier_cols])
+     
+            yeo_johnson_transformed_df = df.copy()
+            for column in outlier_cols:
+                try:
+                    yeo_johnson_transformed_df[column], lambda_ = yeojohnson(yeo_johnson_transformed_df[column])
+    
+                except :
+                    yeo_johnson_transformed_df[column] = yeo_johnson_transformed_df[column]
+    
+                    print(f"Yeo-Johnson transformation failed for column '{column}'. Original data used.")
+                # yeo_johnson_transformed_df[column], lambda_ = yeojohnson(yeo_johnson_transformed_df[column])
+            rank_transformed_df = df.copy()
+            rank_transformed_df[outlier_cols] = rank_transformed_df[outlier_cols].rank()
+            winsorize_transformed_df = df.copy()
+            for column in outlier_cols:
+                winsorize_transformed_df[column] = winsorize(winsorize_transformed_df[column], limits=[0.05, 0.05])
+                
+                
+            
+        else:
+            
+            
+            if df[num_col][df[num_col] <0].sum().sum() == 0:
+                log_transformed_df = df.copy()
+                log_transformed_df[num_col] = np.log(log_transformed_df[num_col] + 1e-5)
+                sqrt_transformed_df = df.copy()
+                sqrt_transformed_df[num_col] = np.sqrt(sqrt_transformed_df[num_col] + 1e-5)
+                inverse_log_transformed_winsorize_df = log_transformed_df.copy()
+                inverse_sqrt_transformed_winsorize_df = sqrt_transformed_df.copy()
+                for column in num_col:
+                    inverse_log_transformed_winsorize_df[column] =  np.exp(winsorize(inverse_log_transformed_winsorize_df[column], limits=[0.05, 0.05]))
+                    inverse_sqrt_transformed_winsorize_df[column] =  (winsorize(inverse_sqrt_transformed_winsorize_df[column], limits=[0.05, 0.05]))**2
+            else:
+                
+                print("df have values less than zero")
+                
+            std_scaler_df = df.copy()
+            std_scaler_df[outlier_cols] = StandardScaler().fit_transform(std_scaler_df[outlier_cols])
+            
+            minmaxscaler_df = df.copy()
+            minmaxscaler_df[outlier_cols] = MinMaxScaler().fit_transform(minmaxscaler_df[outlier_cols])
+            
+            yeo_johnson_transformed_df = df.copy()
+            for column in num_col:
+                try:
+                    yeo_johnson_transformed_df[column], lambda_ = yeojohnson(yeo_johnson_transformed_df[column])
+    
+                except :
+                    yeo_johnson_transformed_df[column] = yeo_johnson_transformed_df[column]
+    
+                    print(f"Yeo-Johnson transformation failed for column '{column}'. Original data used.")
+                # yeo_johnson_transformed_df[column], lambda_ = yeojohnson(yeo_johnson_transformed_df[column])
+            rank_transformed_df = df.copy()
+            rank_transformed_df[num_col] = rank_transformed_df[num_col].rank()
+            winsorize_transformed_df = df.copy()
+            for column in num_col:
+                winsorize_transformed_df[column] = winsorize(winsorize_transformed_df[column], limits=[0.05, 0.05])
+                 
+        if (df[num_col][df[num_col] <0].sum().sum() == 0):        
+            outlier_handled_df = [std_scaler_df,minmaxscaler_df,outliers_dropped_df,log_transformed_df,sqrt_transformed_df,yeo_johnson_transformed_df,
+                                  rank_transformed_df,winsorize_transformed_df,inverse_log_transformed_winsorize_df,inverse_sqrt_transformed_winsorize_df]
+        
+            outlier_handled_df_name = ["std_scaler_df","minmaxscaler_df","outliers_dropped_df", "log_transformed_df","sqrt_transformed_df", "yeo_johnson_transformed_df","rank_transformed_df","winsorize_transformed_df",
+                                       "inverse_log_transformed_winsorize_df", "inverse_sqrt_transformed_winsorize_df"]
+        elif df[outlier_cols][df[outlier_cols] <0].sum().sum() == 0:
+            outlier_handled_df = [std_scaler_df,minmaxscaler_df,outliers_dropped_df,log_transformed_df,sqrt_transformed_df,yeo_johnson_transformed_df,
+                                  rank_transformed_df,winsorize_transformed_df,inverse_log_transformed_winsorize_df,inverse_sqrt_transformed_winsorize_df]
+        
+            outlier_handled_df_name = ["std_scaler_df","minmaxscaler_df","outliers_dropped_df","log_transformed_df", "sqrt_transformed_df","yeo_johnson_transformed_df","rank_transformed_df",
+                                       "winsorize_transformed_df","inverse_log_transformed_winsorize_df","inverse_sqrt_transformed_winsorize_df"]
+        
+        else:
+            outlier_handled_df = [std_scaler_df,minmaxscaler_df,outliers_dropped_df,yeo_johnson_transformed_df,rank_transformed_df,winsorize_transformed_df]
+        
+            outlier_handled_df_name = ["std_scaler_df","minmaxscaler_df","outliers_dropped_df","yeo_johnson_transformed_df","rank_transformed_df","winsorize_transformed_df"]
+     
+        for j,i in enumerate(outlier_handled_df):
+            X_train, X_test, y_train, y_test = tts(i,y[i.index],test_size = test_size, random_state = random_state)
+            evaluationer.evaluation(f"{outlier_handled_df_name[j]}",X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva)
+            
+                
+        return evaluationer.reg_evaluation_df , outlier_handled_df,outlier_handled_df_name
+    elif eva =="class":
+                   
+        std_scaler_df = df.copy()
+        
+        std_scaler_df.loc[:,:] = StandardScaler().fit_transform(std_scaler_df.loc[:,:])
+       
+        minmaxscaler_df = df.copy()
+        minmaxscaler_df.loc[:,:] = MinMaxScaler().fit_transform(minmaxscaler_df.loc[:,:])
+
+        rank_transformed_df = df.copy()
+        rank_transformed_df = rank_transformed_df.rank()
+
+        outlier_handled_df = [std_scaler_df,minmaxscaler_df,rank_transformed_df]
+        outlier_handled_df_name = ["std_scaler_df","minmaxscaler_df","rank_transformed_df"]
+
+        for j,i in enumerate(outlier_handled_df):
+           
+            X_train, X_test, y_train, y_test = tts(i,y[i.index],test_size = test_size, random_state = random_state)
+            evaluationer.evaluation(f"{outlier_handled_df_name[j]}", X_train,X_test,y_train,y_test,model,root_mean_squared_error,eva = "class")
+        return evaluationer.classification_evaluation_df, outlier_handled_df,outlier_handled_df_name
+# returning evaluating dataframe
+        

requirements.txt

@@ -0,0 +1,10 @@
+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
+matplotlib==3.9.0
+xgboost==2.0.3
+lightgbm==4.3.0
+statsmodels==0.14.2