Added Mltoolit to Modules and integrated with app.py

Modules/MLtoolkit.py

@@ -0,0 +1,215 @@
+import numpy as np
+import pandas as pd
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC, SVR
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.naive_bayes import GaussianNB
+from sklearn.linear_model import LinearRegression, LogisticRegression
+from sklearn.metrics import mean_squared_error, accuracy_score, mean_absolute_error
+from sklearn.decomposition import PCA
+import matplotlib.pyplot as plt
+import seaborn as sns
+import streamlit as st
+from sklearn.preprocessing import LabelEncoder
+
+
+class MLToolkit:
+    def __init__(self, data):
+        self.data = data
+        self.algorithm = None
+        self.algorithm_type = None
+        st.subheader("MLtoolkit")
+
+    def select_algorithm(self):
+        self.algorithm = st.selectbox("Select Supervised Learning Algorithm", ("KNN", "SVM", "Decision Tree", "Naive Bayes", "Random Forest", "Linear Regression", "Logistic Regression"))
+
+        if self.algorithm != 'Linear Regression' and self.algorithm != 'Logistic Regression' and self.algorithm != "Naive Bayes":
+            self.algorithm_type = st.selectbox("Select Algorithm Type", ("Classifier", "Regressor"))
+        else:
+            st.write(f"In {self.algorithm} Classifier and Regressor dosen't exist separately")
+            if self.algorithm == "Linear Regression":
+                self.algorithm_type = "Regressor"
+                st.write("{} only does Regression".format(self.algorithm))
+            else:
+                self.algorithm_type = "Classifier"
+                st.write(f"{self.algorithm} only does Classification")
+        return self.algorithm, self.algorithm_type
+
+    def one_hot_encode_categorical(df, threshold=0.05):
+        categorical_columns = df.select_dtypes(include=['object', 'category']).columns
+
+        unique_ratio = df[categorical_columns].nunique() / len(df)
+
+        selected_categorical_columns = unique_ratio[unique_ratio < threshold].index
+
+        df_encoded = pd.get_dummies(df, columns=selected_categorical_columns)
+
+        return df_encoded
+
+    def select_features_and_target(self):
+        st.write("### Select Features and Target Variable")
+        
+        # Display available columns based on the algorithm
+        st.write("#### Available Columns:")
+        
+        if self.algorithm in ["Linear Regression", "Logistic Regression"]:
+            numerical_columns = self.data.select_dtypes(include=[np.number]).columns
+            selected_features = st.multiselect("Select Numerical Features (X)", numerical_columns)
+        else:
+            selected_features = st.multiselect("Select Features (X)", self.data.columns)
+        
+        if self.algorithm == "Naive Bayes":
+            target_variable = st.selectbox("Select Target Variable (y)", self.data.columns)
+        elif self.algorithm == "Linear Regression":
+            numerical_columns = self.data.select_dtypes(include=[np.number]).columns
+            target_variable = st.selectbox("Select Target Variable (y)", numerical_columns)
+        else:
+            target_variable = st.selectbox("Select Target Variable (y)", self.data.columns)
+        
+        # Ensure at least one feature and one target variable is selected
+        if len(selected_features) < 1 or target_variable is None:
+            st.error("Please select at least one feature (X) and a target variable (y).")
+            return None, None
+        
+        return self.data[selected_features], self.data[target_variable]
+    
+    def add_parameter_classifier_general(self):
+
+        params = dict()
+
+        if self.algorithm == 'SVM':
+
+            c_regular = st.slider('C (Regularization)', 0.01, 10.0)
+            kernel_custom = st.selectbox('Kernel', ('linear', 'poly ', 'rbf', 'sigmoid'))
+            params['C'] = c_regular
+            params['kernel'] = kernel_custom
+
+        elif self.algorithm == 'KNN':
+
+            k_n = st.slider('Number of Neighbors (K)', 1, 20,key="k_n_slider")
+            params['K'] = k_n
+            weights_custom = st.selectbox('Weights', ('uniform', 'distance'))
+            params['weights'] = weights_custom
+
+        elif self.algorithm == 'Naive Bayes':
+            st.info("This is a simple Algorithm. It doesn't have Parameters for Hyper-tuning.")
+
+        elif self.algorithm == 'Decision Tree':
+
+            max_depth = st.slider('Max Depth', 2, 17)
+            criterion = st.selectbox('Criterion', ('gini', 'entropy'))
+            splitter = st.selectbox("Splitter", ("best", "random"))
+            params['max_depth'] = max_depth
+            params['criterion'] = criterion
+            params['splitter'] = splitter
+
+            try:
+                random = st.text_input("Enter Random State")
+                params['random_state'] = int(random)
+            except:
+                params['random_state'] = 4567
+
+        elif self.algorithm == 'Random Forest':
+
+            max_depth = st.slider('Max Depth', 2, 17)
+            n_estimators = st.slider('Number of Estimators', 1, 90)
+            criterion = st.selectbox('Criterion', ('gini', 'entropy', 'log_loss'))
+            params['max_depth'] = max_depth
+            params['n_estimators'] = n_estimators
+            params['criterion'] = criterion
+
+
+            try:
+                random = st.text_input("Enter Random State")
+                params['random_state'] = int(random)
+            except:
+                params['random_state'] = 4567
+
+        else:
+
+            c_regular = st.slider('C (Regularization)', 0.01, 10.0)
+            params['C'] = c_regular
+            fit_intercept = st.selectbox("Fit Intercept", ('True', 'False'))
+            params['fit_intercept'] = bool(fit_intercept)
+            penalty = st.selectbox("Penalty", ('l2', None))
+            params['penalty'] = penalty
+            n_jobs = st.selectbox("Number of Jobs", (None, -1))
+            params['n_jobs'] = n_jobs
+
+        return params
+
+    def add_parameter_regressor(self):
+        params = dict()
+        if self.algorithm == 'Decision Tree':
+            max_depth = st.slider('Max Depth', 2, 17)
+            criterion = st.selectbox('Criterion', ('absolute_error', 'squared_error', 'poisson', 'friedman_mse'))
+            splitter = st.selectbox("Splitter", ("best", "random"))
+            params['max_depth'] = max_depth
+            params['criterion'] = criterion
+            params['splitter'] = splitter
+            try:
+                random = st.text_input("Enter Random State")
+                params['random_state'] = int(random)
+            except:
+                params['random_state'] = 4567
+        elif self.algorithm == 'Linear Regression':
+            fit_intercept = st.selectbox("Fit Intercept", ('True', 'False'))
+            params['fit_intercept'] = bool(fit_intercept)
+            n_jobs = st.selectbox("Number of Jobs", (None, -1))
+            params['n_jobs'] = n_jobs
+        else:
+            max_depth = st.slider('Max Depth', 2, 17)
+            n_estimators = st.slider('Number of Estimators', 1, 90)
+            criterion = st.selectbox('Criterion', ('absolute_error', 'squared_error', 'poisson', 'friedman_mse'))
+            params['max_depth'] = max_depth
+            params['n_estimators'] = n_estimators
+            params['criterion'] = criterion
+            try:
+                random = st.text_input("Enter Random State")
+                params['random_state'] = int(random)
+            except:
+                params['random_state'] = 4567
+        return params
+
+
+    def model_classifier(self, params):
+        if self.algorithm == 'KNN':
+            return KNeighborsClassifier(n_neighbors=params['K'], weights=params['weights'])
+        elif self.algorithm == 'SVM':
+            return SVC(C=params['C'], kernel=params['kernel'])
+        elif self.algorithm == 'Decision Tree':
+            return DecisionTreeClassifier(
+                criterion=params['criterion'], splitter=params['splitter'],
+                random_state=params['random_state'])
+        elif self.algorithm == 'Naive Bayes':
+            return GaussianNB()
+        elif self.algorithm == 'Random Forest':
+            return RandomForestClassifier(n_estimators=params['n_estimators'],
+                                        max_depth=params['max_depth'],
+                                        criterion=params['criterion'],
+                                        random_state=params['random_state'])
+        elif self.algorithm == 'Linear Regression':
+            return LinearRegression(fit_intercept=params['fit_intercept'], n_jobs=params['n_jobs'])
+        else:
+            return LogisticRegression(fit_intercept=params['fit_intercept'],
+                                    penalty=params['penalty'], C=params['C'], n_jobs=params['n_jobs'])
+
+    def model_regressor(self, params):
+        if self.algorithm == 'KNN':
+            return KNeighborsRegressor(n_neighbors=params['K'], weights=params['weights'])
+        elif self.algorithm == 'SVM':
+            return SVR(C=params['C'], kernel=params['kernel'])
+        elif self.algorithm == 'Decision Tree':
+            return DecisionTreeRegressor(
+                criterion=params['criterion'], splitter=params['splitter'],
+                random_state=params['random_state'])
+        elif self.algorithm == 'Random Forest':
+            return RandomForestRegressor(n_estimators=params['n_estimators'],
+                                        max_depth=params['max_depth'],
+                                        criterion=params['criterion'],
+                                        random_state=params['random_state'])
+        else:
+            return LinearRegression(fit_intercept=params['fit_intercept'], n_jobs=params['n_jobs'])

app.py

@@ -5,10 +5,29 @@ from Modules.data_filter import DataFilter
 from Modules.data_transformer import DataTransformer
 from Modules.data_visualizer import DataVisualizer
 from Modules.data_QA import DataQA
+from Modules.MLtoolkit import MLToolkit
+from sklearn.metrics import mean_squared_error, accuracy_score, mean_absolute_error
+from sklearn.model_selection import train_test_split
 import os
 from streamlit_option_menu import option_menu
 
+#---IMPORT---
+import numpy as np
 import pandas as pd
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC, SVR
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.naive_bayes import GaussianNB
+from sklearn.linear_model import LinearRegression, LogisticRegression
+from sklearn.metrics import mean_squared_error, accuracy_score, mean_absolute_error
+from sklearn.decomposition import PCA
+import matplotlib.pyplot as plt
+import seaborn as sns
+import streamlit as st
+from sklearn.preprocessing import LabelEncoder
 
 def main():
     st.title('Insights 📶')
@@ -23,7 +42,7 @@ def main():
         with st.sidebar:
             selected = option_menu(
                 menu_title="Main Menu",
-                options=["Data Loader", "Exploratory Data Analysis", "Data Cleaning", "Q/A", "Data Party"])
+                options=["Data Loader", "Exploratory Data Analysis", "Data Cleaning", "Q/A", "MLtoolkit", "Data Party"])
 
         # --- DATA LOADER ---
         if selected == "Data Loader":
@@ -56,6 +75,34 @@ def main():
             data_QA = DataQA(data)
             data_QA.ask_csv()
 
+        if selected == "MLtoolkit":
+            ml_toolkit = MLToolkit(data)
+            algorithm, algorithm_type = ml_toolkit.select_algorithm()
+            X, Y = ml_toolkit.select_features_and_target()
+
+            if (algorithm_type == "Regressor") and (algorithm == 'Decision Tree' or algorithm == 'Random Forest' or algorithm_type == "Linear Regression"):
+                params = ml_toolkit.add_parameter_regressor()
+            else:
+                params = ml_toolkit.add_parameter_classifier_general()
+                        
+            if algorithm_type == "Regressor":
+                algo_model = ml_toolkit.model_regressor(params)
+            else:
+                algo_model = ml_toolkit.model_classifier(params)
+
+            x_train, x_test, y_train, y_test = train_test_split(X, Y, train_size=0.8)
+
+            algo_model.fit(x_train, y_train)
+
+            predict = algo_model.predict(x_test)
+
+            if algorithm != 'Linear Regression' and algorithm_type != 'Regressor':
+                st.write("Training Accuracy is:", algo_model.score(x_train, y_train) * 100)
+                st.write("Testing Accuracy is:", accuracy_score(y_test, predict) * 100)
+            else:
+                st.write("Mean Squared error is:", mean_squared_error(y_test, predict))
+                st.write("Mean Absolute error is:", mean_absolute_error(y_test, predict))
+
         # --- DATA PARTY ---
         if selected == "Data Party":
             st.write("To be continued... :)")

test.py

@@ -0,0 +1,61 @@
+import streamlit as st
+from Modules.data_loader import DataLoader
+from Modules.data_analyzer import DataAnalyzer
+from Modules.data_filter import DataFilter
+from Modules.data_transformer import DataTransformer
+from Modules.data_visualizer import DataVisualizer
+from Modules.data_QA import DataQA
+from Modules.MLtoolkit import MLToolkit
+from sklearn.metrics import mean_squared_error, accuracy_score, mean_absolute_error
+from sklearn.model_selection import train_test_split
+import os
+from streamlit_option_menu import option_menu
+
+#---IMPORT---
+import numpy as np
+import pandas as pd
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC, SVR
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.naive_bayes import GaussianNB
+from sklearn.linear_model import LinearRegression, LogisticRegression
+from sklearn.metrics import mean_squared_error, accuracy_score, mean_absolute_error
+from sklearn.decomposition import PCA
+import matplotlib.pyplot as plt
+import seaborn as sns
+import streamlit as st
+from sklearn.preprocessing import LabelEncoder
+
+
+data = pd.read_csv("data.csv")
+
+
+ml_toolkit = MLToolkit(data)
+algorithm, algorithm_type = ml_toolkit.select_algorithm()
+X, Y = ml_toolkit.select_features_and_target()
+
+if (algorithm_type == "Regressor") and (algorithm == 'Decision Tree' or algorithm == 'Random Forest' or algorithm_type == "Linear Regression"):
+    params = ml_toolkit.add_parameter_regressor()
+else:
+    params = ml_toolkit.add_parameter_classifier_general()
+            
+if algorithm_type == "Regressor":
+    algo_model = ml_toolkit.model_regressor(params)
+else:
+    algo_model = ml_toolkit.model_classifier(params)
+
+x_train, x_test, y_train, y_test = train_test_split(X, Y, train_size=0.8)
+
+algo_model.fit(x_train, y_train)
+
+predict = algo_model.predict(x_test)
+
+if algorithm != 'Linear Regression' and algorithm_type != 'Regressor':
+    st.write("Training Accuracy is:", algo_model.score(x_train, y_train) * 100)
+    st.write("Testing Accuracy is:", accuracy_score(y_test, predict) * 100)
+else:
+    st.write("Mean Squared error is:", mean_squared_error(y_test, predict))
+    st.write("Mean Absolute error is:", mean_absolute_error(y_test, predict))