Modified regressor model

app.py

@@ -1,16 +1,12 @@
 from classification import ClassificationModels
 from regression import RegressionModels 
 from resume import Resume
-'''
+
 from sklearn.impute import SimpleImputer
 from sklearn.pipeline import Pipeline
 from sklearn.compose import ColumnTransformer
 from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
 
-'''
-
-
-
 import pandas as pd
 import warnings
 import streamlit as st
@@ -312,16 +308,6 @@ def classification():
                     #spectra_df1 = spectra_df1.drop(columns=['Disease'])
                     st.write(spectra_df1.head(5))
                     st.divider()
-
-                    model_dict ={
-                                "Naive Bayes Classifier":'GaussianNB()',
-                                "Logistic Regression":'LogisticRegression()',
-                                "Decision Tree":'DecisionTreeClassifier()',
-                                "Random Forests":'RandomForestClassifier()',
-                                "SVM":'SVC()',
-                                "KNN":'KNeighborsClassifier()',
-                                "K- Means Clustering":'KMeans()'
-                                }
                     
                     X= spectra_df1
                     if max_key == "Naive Bayes Classifier":
@@ -453,15 +439,58 @@ def regressor():
                         models.split_data()
 
                         # Train and evaluate selected models
+                        best_model = None
+                        best_metric = float('inf')  # Initialize with a high value for MSE (lower is better)
                         for model_name in selected_models:
-                            st.subheader(f"Model: {model_name}")
+                            # st.subheader(f"Model: {model_name}")
                             models.fit(model_name)
                             y_pred = models.train(model_name)
                             mse, r2 = models.evaluate(model_name)
-                            st.write(f"MSE: {mse}")
-                            st.write(f"R-squared: {r2}")
+                            # st.write(f"MSE: {mse}")
+                            # st.write(f"R-squared: {r2}")
+                            
+                            # Update best model based on MSE
+                            if r2 < best_metric:
+                                best_model = model_name
+                                best_metric = r2
+
+
+                        # Perform testing based on the best model
+                        if best_model:
+                            st.subheader(f"Best Model: {best_model}")
+                            test_mse, test_r2 = models.evaluate(best_model)
+                            st.write(f"Test MSE: {test_mse}")
+                            st.write(f"Test R-squared: {test_r2}")
+                            # You can also visualize the predictions vs. true values, residual plots, etc. here
+                        else:
+                            st.write("No best model selected.")                                
+
+
+
+    with test:
+        st.title("Regression / Test")       
+        spectra_1 = st.file_uploader("Upload file test the model", type={"csv", "txt"})
+        if spectra_1 is not None:
+            spectra_df1 = pd.read_csv(spectra_1)
+            st.write(spectra_df1.head(5))
+            st.divider()
+            st.write("models",models)
+            # models = RegressionModels()
+            if best_model:
+                # st.subheader(f"Best Model: {best_model}")
+                st.write("best model", best_model)
+                y_pred= models.predict(model_name = best_model,X = spectra_df1)
+                # st.write(f"Test MSE: {test_mse}")
+                st.write(f"Y pred is : {max(y_pred)}")
+                # You can also visualize the predictions vs. true values, residual plots, etc. here
+            else:
+                st.write("No best model selected.")
+
+
 
 
+        
+
 def NLP():
     Gemini_Chat,Gemini_Vision,Gemini_PDF, Bert, = st.tabs(['Gemini-Chat','Gemini-Vision',"Gemini-PDF Chat",'ChatBot'])
 

regression.py

@@ -10,6 +10,125 @@ from sklearn.svm import SVR
 from xgboost import XGBRegressor
 from lightgbm import LGBMRegressor
 from sklearn.metrics import mean_squared_error, r2_score
+import streamlit as st
+
+
+
+
+
+
+class RegressionModels:
+    def __init__(self):
+        self.data = None
+        self.X_train = None
+        self.X_test = None
+        self.y_train = None
+        self.y_test = None
+        self.column_transformer = None  # Initialize as None
+        self.models = {
+            'Linear Regression': LinearRegression(),
+            'Polynomial Regression': LinearRegression(),
+            'Ridge Regression': Ridge(),
+            'Lasso Regression': Lasso(),
+            'ElasticNet Regression': ElasticNet(),
+            'Logistic Regression': LogisticRegression(),
+            'Decision Tree Regression': DecisionTreeRegressor(),
+            'Random Forest Regression': RandomForestRegressor(),
+            'Gradient Boosting Regression': GradientBoostingRegressor(),
+            'Support Vector Regression (SVR)': SVR(),
+            'XGBoost': XGBRegressor(),
+            'LightGBM': LGBMRegressor()
+        }
+        
+    def add_data(self, X, y):
+        self.data = (X, y)
+        
+    def split_data(self, test_size=0.2, random_state=None):
+        if self.data is None:
+            raise ValueError("No data provided. Use add_data method to add data first.")
+        X, y = self.data
+        self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
+        
+    def build_preprocessor(self):
+        if self.column_transformer is not None:
+            return self.column_transformer  # Return the existing fitted ColumnTransformer
+        else:
+            # Separate numerical and categorical columns
+            numeric_features = self.X_train.select_dtypes(include=['int64', 'float64']).columns
+            categorical_features = self.X_train.select_dtypes(include=['object']).columns
+
+            # Define transformers for numerical and categorical data
+            numeric_transformer = Pipeline(steps=[
+                ('imputer', SimpleImputer(strategy='mean')),
+                ('scaler', StandardScaler())
+            ])
+            categorical_transformer = Pipeline(steps=[
+                ('imputer', SimpleImputer(strategy='most_frequent')),
+                ('onehot', OneHotEncoder(handle_unknown='ignore'))
+            ])
+
+            # Combine transformers using ColumnTransformer
+            self.column_transformer = ColumnTransformer(
+                transformers=[
+                    ('num', numeric_transformer, numeric_features),
+                    ('cat', categorical_transformer, categorical_features)
+                ])
+            return self.column_transformer
+        
+    def fit(self, model_name):
+        if self.X_train is None or self.y_train is None:
+            raise ValueError("Data not split. Use split_data method to split data into training and testing sets.")
+        model = self.models[model_name]
+        preprocessor = self.build_preprocessor()
+        model_pipeline = Pipeline(steps=[
+            ('preprocessor', preprocessor),
+            ('model', model)
+        ])
+        model_pipeline.fit(self.X_train, self.y_train)
+        
+    def train(self, model_name):
+        if self.X_train is None or self.y_train is None or self.X_test is None:
+            raise ValueError("Data not split. Use split_data method to split data into training and testing sets.")
+        model = self.models[model_name]
+        preprocessor = self.build_preprocessor()
+        model_pipeline = Pipeline(steps=[
+            ('preprocessor', preprocessor),
+            ('model', model)
+        ])
+        model_pipeline.fit(self.X_train, self.y_train)
+        y_pred = model_pipeline.predict(self.X_test)
+        return y_pred
+        
+    def evaluate(self, model_name):
+        if self.X_test is None or self.y_test is None:
+            raise ValueError("Data not split. Use split_data method to split data into training and testing sets.")
+        model = self.models[model_name]
+        preprocessor = self.build_preprocessor()
+        model_pipeline = Pipeline(steps=[
+            ('preprocessor', preprocessor),
+            ('model', model)
+        ])
+        model_pipeline.fit(self.X_train, self.y_train)
+        y_pred = model_pipeline.predict(self.X_test)
+        mse = mean_squared_error(self.y_test, y_pred)
+        r2 = r2_score(self.y_test, y_pred)
+        return mse, r2
+        
+    def predict(self, model_name, X):
+        model = self.models[model_name]
+        preprocessor = self.build_preprocessor()  # Ensure that the ColumnTransformer is fitted
+        model_pipeline = Pipeline(steps=[
+            ('preprocessor', preprocessor),
+            ('model', model)
+        ])
+        return model_pipeline.predict(X)
+
+
+
+
+
+'''
+
 
 class RegressionModels:
     def __init__(self):
@@ -110,10 +229,13 @@ class RegressionModels:
         model_pipeline = Pipeline(steps=[
             ('preprocessor', preprocessor),
             ('model', model)
-        ])
+                                ])
+        
+        st.write("Model", model)
+        st.write(X.head(4))
         return model_pipeline.predict(X)
 
-
+'''