Update app.py

app.py

@@ -726,122 +726,108 @@ elif app_mode == "Advanced EDA":
             st.error(f"An error occurred while generating the plot: {e}")
 
 elif app_mode == "Model Training":
-    st.title("🧠 Model Training & Evaluation")
+    st.title("🚂 Model Training")
 
     if st.session_state.cleaned_data is not None:
         df = st.session_state.cleaned_data.copy()
 
         # Target Variable Selection
-        target_column = st.selectbox("Select Target Variable", df.columns, help="Choose the column you want to predict.")
+        target_column = st.selectbox("Select Target Variable", df.columns, help="Choose the column to predict.")
 
         # Problem Type Selection
-        problem_type = st.radio("Select Problem Type", ["Regression", "Classification"], help="Choose the type of machine learning problem.")
+        problem_type = st.radio("Select Problem Type", ["Regression", "Classification"], help="Choose the type of problem.")
 
-        # Feature Selection (optional)
-        use_all_features = st.checkbox("Use All Features", value=True, help="Select to use all features for training. Deselect to manually choose features.")
-        if use_all_features:
-            feature_columns = df.drop(columns=[target_column]).columns.tolist()
-        else:
-            feature_columns = st.multiselect("Select Feature Columns", df.drop(columns=[target_column]).columns, help="Choose the features you want to use for prediction.")
+        # Feature Selection
+        feature_columns = st.multiselect("Select Feature Columns", df.drop(columns=[target_column]).columns, help="Choose features for training.")
 
         # Model Selection
-        model_type = st.selectbox("Select Model", [
-            "Linear Regression", "Decision Tree", "Random Forest", "Gradient Boosting", "Support Vector Machine", "Logistic Regression", "Random Forest Classifier"
-        ], help="Choose the machine learning model to use.")
+        model_name = st.selectbox("Select Model", [
+            "Linear Regression", "Logistic Regression", "Decision Tree",
+            "Random Forest", "Gradient Boosting", "SVM"
+        ], help="Choose a model.")
 
-        # Hyperparameter Tuning
-        with st.expander("Hyperparameter Tuning", expanded=False):
-            if model_type == "Decision Tree":
-                max_depth = st.slider("Max Depth", 2, 30, 5, help="Maximum depth of the decision tree.")
-            elif model_type in ["Random Forest", "Gradient Boosting", "Random Forest Classifier"]:
-                n_estimators = st.slider("Number of Estimators", 50, 200, 100, help="Number of trees in the forest.")
-            elif model_type == "Support Vector Machine":
-                C = st.slider("C", 0.1, 10.0, 1.0, help="Regularization parameter.")
+        # Hyperparameter Tuning (Example - Add more as needed)
+        if model_name == "Random Forest":
+            n_estimators = st.slider("Number of Estimators", 10, 200, 100, help="Number of trees in the forest.")
+            max_depth = st.slider("Max Depth", 3, 20, 10, help="Maximum depth of the tree.")
 
         # Train-Test Split
-        test_size = st.slider("Test Size", 0.1, 0.5, 0.2, help="Proportion of the data to use for testing.")
+        test_size = st.slider("Test Size", 0.1, 0.5, 0.2, help="Proportion of the dataset to include in the test split.")
 
-        # Model Training Button
         if st.button("Train Model"):
             with st.spinner("Training model..."):
-                # Split data
-                X = df[feature_columns]
-                y = df[target_column]
-                X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
-
-                # Preprocessing
-                numeric_transformer = Pipeline(steps=[
-                    ('imputer', SimpleImputer(strategy='median')),
-                    ('scaler', StandardScaler())
-                ])
-                categorical_transformer = Pipeline(steps=[
-                    ('imputer', SimpleImputer(strategy='most_frequent')),
-                    ('onehot', OneHotEncoder(handle_unknown='ignore'))
-                ])
-
-                numeric_features = X_train.select_dtypes(include=['int64', 'float64']).columns
-                categorical_features = X_train.select_dtypes(include=['object']).columns
-
-                preprocessor = ColumnTransformer(
-                    transformers=[
-                        ('num', numeric_transformer, numeric_features),
-                        ('cat', categorical_transformer, categorical_features)
+                try:
+                    X = df[feature_columns]
+                    y = df[target_column]
+                    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
+
+                    # Preprocessing Pipeline
+                    numeric_features = X.select_dtypes(include=np.number).columns
+                    categorical_features = X.select_dtypes(exclude=np.number).columns
+
+                    numeric_transformer = Pipeline(steps=[
+                        ('imputer', SimpleImputer(strategy='median')),
+                        ('scaler', StandardScaler())
                     ])
 
-                # Model Selection and Training
-                if model_type == "Linear Regression":
-                    model = Pipeline(steps=[('preprocessor', preprocessor),
-                                           ('regressor', LinearRegression())])
-                elif model_type == "Decision Tree":
-                    model = Pipeline(steps=[('preprocessor', preprocessor),
-                                           ('regressor', DecisionTreeRegressor(max_depth=max_depth, random_state=42))])
-                elif model_type == "Random Forest":
-                    model = Pipeline(steps=[('preprocessor', preprocessor),
-                                           ('regressor', RandomForestRegressor(n_estimators=n_estimators, random_state=42))])
-                elif model_type == "Gradient Boosting":
-                    model = Pipeline(steps=[('preprocessor', preprocessor),
-                                           ('regressor', GradientBoostingRegressor(n_estimators=n_estimators, random_state=42))])
-                elif model_type == "Support Vector Machine":
-                    model = Pipeline(steps=[('preprocessor', preprocessor),
-                                           ('regressor', SVR(C=C))])
-                elif model_type == "Logistic Regression":
-                    model = Pipeline(steps=[('preprocessor', preprocessor),
-                                           ('classifier', LogisticRegression(random_state=42))])
-                elif model_type == "Random Forest Classifier":
-                    model = Pipeline(steps=[('preprocessor', preprocessor),
-                                           ('classifier', RandomForestClassifier(n_estimators=n_estimators, random_state=42))])
-
-                model.fit(X_train, y_train)
-
-                # Store the trained model and preprocessor in session state
-                st.session_state.model = model
-                st.session_state.preprocessor = preprocessor
-
-                # Make predictions
-                y_pred = model.predict(X_test)
-
-                # Evaluation
-                if problem_type == "Regression":
-                    mse = mean_squared_error(y_test, y_pred)
-                    rmse = np.sqrt(mse)
-                    mae = mean_absolute_error(y_test, y_pred)
-                    r2 = r2_score(y_test, y_pred)
-                    st.write(f"Mean Squared Error: {mse:.4f}")
-                    st.write(f"Root Mean Squared Error: {rmse:.4f}")
-                    st.write(f"Mean Absolute Error: {mae:.4f}")
-                    st.write(f"R-squared: {r2:.4f}")
-                else:
-                    accuracy = accuracy_score(y_test, y_pred)
-                    precision = precision_score(y_test,y_pred)
-                    recall = recall_score(y_test, y_pred)
-                    f1 = f1_score(y_test, y_pred)
-                    roc_auc = roc_auc_score(y_test, model.predict_proba(X_test)[:, 1])
-                    st.write(f"Accuracy: {accuracy:.4f}")
-                    st.write(f"Precision: {precision:.4f}")
-                    st.write(f"Recall: {recall:.4f}")
-                    st.write(f"F1 Score: {f1:.4f}")
-                    st.write(f"ROC AUC: {roc_auc:.4f}")
+                    categorical_transformer = Pipeline(steps=[
+                        ('imputer', SimpleImputer(strategy='most_frequent')),
+                        ('onehot', OneHotEncoder(handle_unknown='ignore'))
+                    ])
+
+                    preprocessor = ColumnTransformer(
+                        transformers=[
+                            ('num', numeric_transformer, numeric_features),
+                            ('cat', categorical_transformer, categorical_features)
+                        ])
+
+                    X_train_processed = preprocessor.fit_transform(X_train)
+                    X_test_processed = preprocessor.transform(X_test)
+
+                    # Model Training
+                    if model_name == "Linear Regression":
+                        model = LinearRegression()
+                    elif model_name == "Logistic Regression":
+                        model = LogisticRegression(max_iter=1000)
+                    elif model_name == "Decision Tree":
+                        if problem_type == "Regression":
+                            model = DecisionTreeRegressor()
+                        else:
+                            model = DecisionTreeClassifier()
+                    elif model_name == "Random Forest":
+                        if problem_type == "Regression":
+                            model = RandomForestRegressor(n_estimators=n_estimators, max_depth=max_depth)
+                        else:
+                            model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth)
+                    elif model_name == "Gradient Boosting":
+                        model = GradientBoostingRegressor() if problem_type == "Regression" else GradientBoostingClassifier()
+                    elif model_name == "SVM":
+                        model = SVR() if problem_type == "Regression" else SVC()
+
+                    model.fit(X_train_processed, y_train)
+
+                    # Store model and preprocessor
+                    st.session_state.model = Pipeline(steps=[('preprocessor', preprocessor), ('model', model)])
+                    st.session_state.preprocessor = preprocessor
+
+                    # Model Evaluation
+                    y_pred = model.predict(X_test_processed)
+                    if problem_type == "Regression":
+                        mse = mean_squared_error(y_test, y_pred)
+                        r2 = r2_score(y_test, y_pred)
+                        st.write(f"Mean Squared Error: {mse:.4f}")
+                        st.write(f"R-squared: {r2:.4f}")
+                    else:
+                        accuracy = accuracy_score(y_test, y_pred)
+                        st.write(f"Accuracy: {accuracy:.4f}")
 
+                    st.success("Model trained successfully!")
+
+                except Exception as e:
+                    st.error(f"An error occurred: {e}")
+    else:
+        st.write("Please upload and clean data first.")
+        
 elif app_mode == "Predictions":
     st.title("🔮 Make Predictions")
 
@@ -869,6 +855,13 @@ elif app_mode == "Predictions":
                 prediction = st.session_state.model.predict(input_df)[0]
                 st.subheader("Prediction Result")
                 st.write(f"The predicted value is: {prediction}")
+
+                # Additional Feedback (Example for Classification)
+                if isinstance(st.session_state.model.steps[-1][1], LogisticRegression):
+                    probabilities = st.session_state.model.predict_proba(input_df)[0]
+                    st.write("Predicted Probabilities:")
+                    st.write(probabilities)
+
             except Exception as e:
                 st.error(f"An error occurred during prediction: {e}")
     else:
@@ -1120,15 +1113,15 @@ elif app_mode == "Neural Network Studio":
                         st.write(f"R-squared: {r2:.4f}")
                     else:
                         accuracy = accuracy_score(y_test, y_pred)
-                        precision = precision_score(y_test, y_pred, average='weighted', zero_division=0) #Added zero_division
-                        recall = recall_score(y_test, y_pred, average='weighted', zero_division=0) #Added zero_division
-                        f1 = f1_score(y_test, y_pred, average='weighted', zero_division=0) #Added zero_division
+                        precision = precision_score(y_test, y_pred, average='weighted', zero_division=0)
+                        recall = recall_score(y_test, y_pred, average='weighted', zero_division=0)
+                        f1 = f1_score(y_test, y_pred, average='weighted', zero_division=0)
                         st.write(f"Accuracy: {accuracy:.4f}")
                         st.write(f"Precision: {precision:.4f}")
                         st.write(f"Recall: {recall:.4f}")
                         st.write(f"F1 Score: {f1:.4f}")
                         st.write("Classification Report:")
-                        st.text(classification_report(y_test, y_pred)) #added classification report
+                        st.text(classification_report(y_test, y_pred))
 
                     st.success("Model trained successfully!")