Update app.py

app.py

@@ -1,8 +1,8 @@
 import streamlit as st
 import pandas as pd
-from pycaret.classification import setup as classification_setup, compare_models as compare_classification_models, evaluate_model as evaluate_classification_model, save_model as save_classification_model, plot_model as plot_classification_model
-from pycaret.regression import setup as regression_setup, compare_models as compare_regression_models, evaluate_model as evaluate_regression_model, save_model as save_regression_model, plot_model as plot_regression_model
-from pycaret.clustering import setup as clustering_setup, evaluate_model as evaluate_clustering_model, save_model as save_clustering_model, plot_model as plot_clustering_model
+from pycaret.classification import setup as classification_setup, compare_models as compare_classification_models, evaluate_model as evaluate_classification_model, save_model as save_classification_model, plot_model as plot_classification_model, tune_model as tune_classification_model, get_config
+from pycaret.regression import setup as regression_setup, compare_models as compare_regression_models, evaluate_model as evaluate_regression_model, save_model as save_regression_model, plot_model as plot_regression_model, tune_model as tune_regression_model, get_config
+from pycaret.clustering import setup as clustering_setup, evaluate_model as evaluate_clustering_model, save_model as save_clustering_model, plot_model as plot_clustering_model, create_model as create_clustering_model, get_config
 from ydata_profiling import ProfileReport
 from streamlit_pandas_profiling import st_profile_report
 import os
@@ -21,6 +21,16 @@ with st.sidebar:
     st.markdown("**Dependencies**: `pycaret`, `pandas`, `streamlit`, `ydata-profiling`")
     st.markdown("Created by Calvin Allen-Crawford | v2.0 | © 2025")
 
+# Helper function to get available models
+def get_available_models(problem_type):
+    if problem_type == "Classification":
+        return list(get_config('available_estimators')['classification'].keys())
+    elif problem_type == "Regression":
+        return list(get_config('available_estimators')['regression'].keys())
+    elif problem_type == "Clustering":
+        return list(get_config('available_estimators')['clustering'].keys())
+    return []
+
 # Main App Sections
 if app_mode == "Data Upload":
     st.title("📤 Data Upload")
@@ -38,7 +48,6 @@ if app_mode == "Data Upload":
         with col2: st.metric("Columns", df.shape[1])
         with col3: st.metric("Missing Values", df.isna().sum().sum())
 
-        # Generate and display ydata-profiling report
         st.write("---")
         st.subheader("Exploratory Data Analysis (EDA)")
         if st.button("Generate EDA Report"):
@@ -74,32 +83,79 @@ elif app_mode == "Model Training":
 
     if st.session_state.get('setup_complete', False):
         st.subheader("Train Models")
-        if st.button("Compare Models"):
-            with st.spinner("Comparing models..."):
-                if st.session_state['problem_type'] == "Classification":
-                    best_model = compare_classification_models()
-                elif st.session_state['problem_type'] == "Regression":
-                    best_model = compare_regression_models()
-                elif st.session_state['problem_type'] == "Clustering":
-                    st.info("Model comparison is not available for clustering. Please proceed with evaluation or create a model manually.")
-                    best_model = None
-                else:
-                    best_model = None
-                if best_model is not None:
+        with st.expander("Advanced Options", expanded=False):
+            if problem_type in ["Classification", "Regression"]:
+                available_models = get_available_models(problem_type)
+                selected_models = st.multiselect("Select Models to Compare (leave empty for all)", available_models, default=None)
+                folds = st.number_input("Number of Cross-Validation Folds", min_value=2, max_value=20, value=10, step=1)
+                if problem_type == "Classification":
+                    sort_metric = st.selectbox("Sort Metric", ["Accuracy", "AUC", "Recall", "Precision", "F1"], index=0)
+                else:  # Regression
+                    sort_metric = st.selectbox("Sort Metric", ["R2", "MAE", "MSE", "RMSE"], index=0)
+            elif problem_type == "Clustering":
+                available_models = get_available_models(problem_type)
+                selected_model = st.selectbox("Select Clustering Algorithm", available_models)
+                if selected_model == "kmeans":
+                    num_clusters = st.number_input("Number of Clusters", min_value=2, max_value=20, value=4, step=1)
+                elif selected_model == "dbscan":
+                    eps = st.number_input("Epsilon (eps)", min_value=0.1, max_value=10.0, value=0.5, step=0.1)
+                    min_samples = st.number_input("Minimum Samples", min_value=2, max_value=20, value=5, step=1)
+                elif selected_model == "hclust":
+                    num_clusters = st.number_input("Number of Clusters", min_value=2, max_value=20, value=4, step=1)
+
+        if problem_type in ["Classification", "Regression"]:
+            if st.button("Compare Models"):
+                with st.spinner("Comparing models..."):
+                    if selected_models:
+                        if problem_type == "Classification":
+                            best_model = compare_classification_models(include=selected_models, fold=folds, sort=sort_metric)
+                        else:  # Regression
+                            best_model = compare_regression_models(include=selected_models, fold=folds, sort=sort_metric)
+                    else:
+                        if problem_type == "Classification":
+                            best_model = compare_classification_models(fold=folds, sort=sort_metric)
+                        else:  # Regression
+                            best_model = compare_regression_models(fold=folds, sort=sort_metric)
                     st.session_state['best_model'] = best_model
                     st.success(f"Best Model: {best_model}")
 
+        elif problem_type == "Clustering":
+            if st.button("Create Model"):
+                with st.spinner("Creating model..."):
+                    if selected_model == "kmeans":
+                        best_model = create_clustering_model("kmeans", num_clusters=num_clusters)
+                    elif selected_model == "dbscan":
+                        best_model = create_clustering_model("dbscan", eps=eps, min_samples=min_samples)
+                    elif selected_model == "hclust":
+                        best_model = create_clustering_model("hclust", num_clusters=num_clusters)
+                    else:
+                        best_model = create_clustering_model(selected_model)
+                    st.session_state['best_model'] = best_model
+                    st.success(f"Model Created: {selected_model}")
+
         if 'best_model' in st.session_state and st.session_state['best_model'] is not None:
-            st.subheader("Model Evaluation")
-            if st.button("Evaluate Model"):
-                with st.spinner("Evaluating model..."):
-                    if st.session_state['problem_type'] == "Classification":
-                        evaluate_classification_model(st.session_state['best_model'])
-                    elif st.session_state['problem_type'] == "Regression":
-                        evaluate_regression_model(st.session_state['best_model'])
-                    elif st.session_state['problem_type'] == "Clustering":
-                        evaluate_clustering_model(st.session_state['best_model'])
-                    st.success("Model evaluation complete!")
+            st.subheader("Model Evaluation and Tuning")
+            col1, col2 = st.columns(2)
+            with col1:
+                if st.button("Evaluate Model"):
+                    with st.spinner("Evaluating model..."):
+                        if st.session_state['problem_type'] == "Classification":
+                            evaluate_classification_model(st.session_state['best_model'])
+                        elif st.session_state['problem_type'] == "Regression":
+                            evaluate_regression_model(st.session_state['best_model'])
+                        elif st.session_state['problem_type'] == "Clustering":
+                            evaluate_clustering_model(st.session_state['best_model'])
+                        st.success("Model evaluation complete!")
+            with col2:
+                if problem_type in ["Classification", "Regression"]:
+                    if st.button("Tune Model"):
+                        with st.spinner("Tuning model..."):
+                            if problem_type == "Classification":
+                                tuned_model = tune_classification_model(st.session_state['best_model'], fold=folds, optimize=sort_metric)
+                            else:  # Regression
+                                tuned_model = tune_regression_model(st.session_state['best_model'], fold=folds, optimize=sort_metric)
+                            st.session_state['best_model'] = tuned_model
+                            st.success(f"Tuned Model: {tuned_model}")
 
             if st.button("Save Model"):
                 if st.session_state['problem_type'] == "Classification":
@@ -115,7 +171,7 @@ elif app_mode == "Model Training":
 elif app_mode == "Validation & Exploration":
     st.title("🔍 Validation & Exploration")
     if 'best_model' not in st.session_state or st.session_state['best_model'] is None:
-        st.warning("Please train a model first. Note: Clustering does not support automatic model comparison.")
+        st.warning("Please train a model first.")
         st.stop()
 
     st.subheader("Model Performance")