Update app.py

app.py

@@ -1,27 +1,23 @@
 import streamlit as st
 import pandas as pd
+import plotly.express as px
 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
+import requests
+import json
+import re
 
 # Set page config
 st.set_page_config(page_title="Neural-Vision Enhanced", layout="wide")
 
-# Sidebar Navigation
-with st.sidebar:
-    st.title("🔮 Neural-Vision Enhanced")
-    st.markdown("Your AI-powered model toolbox.")
-    st.markdown("---")
-    app_mode = st.selectbox("Navigation", ["Data Upload", "Model Training", "Validation & Exploration"])
-    data_type = st.selectbox("Data Type", ["Tabular"])
-    st.markdown("---")
-    st.markdown("**Dependencies**: `pycaret`, `pandas`, `streamlit`, `ydata-profiling`")
-    st.markdown("Created by Calvin Allen-Crawford | v2.0 | © 2025")
+# Helper Functions
+def enhance_section_title(title):
+    st.markdown(f"<h2 style='border-bottom: 2px solid #ccc; padding-bottom: 5px;'>{title}</h2>", unsafe_allow_html=True)
 
-# Helper function to get available models
 def get_available_models(problem_type):
     if problem_type == "Classification":
         return list(get_config('available_estimators')['classification'].keys())
@@ -31,6 +27,194 @@ def get_available_models(problem_type):
         return list(get_config('available_estimators')['clustering'].keys())
     return []
 
+def get_context():
+    context = "You are using Neural-Vision Enhanced, an AI-powered data analysis and modeling tool.\n"
+    if 'df' in st.session_state:
+        df = st.session_state['df']
+        context += f"Current dataset has {df.shape[0]} rows and {df.shape[1]} columns.\n"
+        context += f"Missing values: {df.isna().sum().sum()}\n"
+        context += "Columns:\n"
+        for col in df.columns:
+            context += f"- {col} ({df[col].dtype}): Missing={df[col].isna().sum()}\n"
+    if 'problem_type' in st.session_state:
+        context += f"Selected problem type: {st.session_state['problem_type']}\n"
+        if 'target' in st.session_state and st.session_state['problem_type'] != "Clustering":
+            context += f"Target column: {st.session_state['target']}\n"
+    if 'best_model' in st.session_state:
+        context += f"Best model trained: {st.session_state['best_model']}\n"
+    return context
+
+def deepseek_chat(user_input, app_mode):
+    system_prompt = (
+        "You are an AI assistant in Neural-Vision Enhanced, a data analysis and modeling app. "
+        "The app has three pages:\n"
+        "- **Data Upload**: Upload CSV files, view stats, or generate EDA reports.\n"
+        "- **Model Training**: Train classification, regression, or clustering models using PyCaret.\n"
+        "- **Validation & Exploration**: Evaluate and visualize trained models.\n"
+        f"The user is on the '{app_mode}' page.\n"
+        f"Current context:\n{get_context()}"
+    )
+    payload = {
+        "model": "deepseek-chat",
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_input}
+        ],
+        "max_tokens": 150,
+        "temperature": 0.7
+    }
+    headers = {"Authorization": f"Bearer {api_key}"}
+    try:
+        response = requests.post("https://api.deepseek.com/v1/chat/completions", json=payload, headers=headers, timeout=5)
+        response.raise_for_status()
+        return response.json()["choices"][0]["message"]["content"]
+    except requests.exceptions.RequestException as e:
+        return f"Error: Could not connect to DeepSeek API. {str(e)}"
+
+# LLM Command Functions
+def drop_columns(columns):
+    if 'df' in st.session_state:
+        df = st.session_state['df'].copy()
+        columns_to_drop = [col.strip() for col in columns.split(',')]
+        valid_columns = [col for col in columns_to_drop if col in df.columns]
+        if valid_columns:
+            df.drop(valid_columns, axis=1, inplace=True)
+            st.session_state['df'] = df
+            st.rerun()
+            return f"Dropped columns: {', '.join(valid_columns)}"
+        else:
+            return "No valid columns found to drop."
+    return "No dataset loaded."
+
+def generate_scatter_plot(params):
+    if 'df' in st.session_state:
+        df = st.session_state['df']
+        match = re.search(r"([\w\s]+)\s+vs\s+([\w\s]+)", params)
+        if match and len(match.groups()) >= 2:
+            x_axis, y_axis = match.group(1).strip(), match.group(2).strip()
+            if x_axis in df.columns and y_axis in df.columns:
+                fig = px.scatter(df, x=x_axis, y=y_axis, title=f'Scatter Plot of {x_axis} vs {y_axis}')
+                st.plotly_chart(fig)
+                st.session_state.last_plot = {"type": "Scatter Plot", "x": x_axis, "y": y_axis, "data": df[[x_axis, y_axis]].to_json()}
+                return f"Generated scatter plot of {x_axis} vs {y_axis}"
+    return "Invalid columns or no dataset loaded."
+
+def generate_histogram(params):
+    if 'df' in st.session_state:
+        df = st.session_state['df']
+        x_axis = params.strip()
+        if x_axis in df.columns:
+            fig = px.histogram(df, x=x_axis, title=f'Histogram of {x_axis}')
+            st.plotly_chart(fig)
+            st.session_state.last_plot = {"type": "Histogram", "x": x_axis, "data": df[[x_axis]].to_json()}
+            return f"Generated histogram of {x_axis}"
+    return "Invalid column or no dataset loaded."
+
+def analyze_plot():
+    if "last_plot" not in st.session_state:
+        return "No plot available to analyze."
+    plot_info = st.session_state.last_plot
+    df = pd.read_json(plot_info["data"])
+    plot_type = plot_info["type"]
+    x_col = plot_info["x"]
+    y_col = plot_info["y"] if "y" in plot_info else None
+
+    if plot_type == "Scatter Plot" and y_col:
+        correlation = df[x_col].corr(df[y_col])
+        strength = "strong" if abs(correlation) > 0.7 else "moderate" if abs(correlation) > 0.3 else "weak"
+        direction = "positive" if correlation > 0 else "negative"
+        return f"The scatter plot of {x_col} vs {y_col} shows a {strength} {direction} correlation (Pearson r = {correlation:.2f})."
+    elif plot_type == "Histogram":
+        skewness = df[x_col].skew()
+        skew_desc = "positively skewed" if skewness > 1 else "negatively skewed" if skewness < -1 else "approximately symmetric"
+        return f"The histogram of {x_col} is {skew_desc} (skewness = {skewness:.2f})."
+    return "Inference not available for this plot type."
+
+def suggest_preprocessing():
+    if 'df' in st.session_state:
+        df = st.session_state['df']
+        missing = df.isna().sum().sum()
+        if missing > 0:
+            return f"Your dataset has {missing} missing values. Consider imputation or dropping rows/columns with missing data before training."
+        if df.duplicated().sum() > 0:
+            return f"Your dataset has {df.duplicated().sum()} duplicates. Consider removing them for better model performance."
+        return "Your dataset looks clean. Proceed to model training."
+    return "No dataset loaded yet."
+
+def suggest_model():
+    if 'df' in st.session_state and 'problem_type' in st.session_state:
+        df = st.session_state['df']
+        problem_type = st.session_state['problem_type']
+        if problem_type == "Classification" and 'target' in st.session_state:
+            target = st.session_state['target']
+            if df[target].nunique() == 2:
+                return "For binary classification, try Logistic Regression or Random Forest."
+            return "For multi-class classification, try Gradient Boosting or SVM."
+        elif problem_type == "Regression":
+            return "For regression, try Linear Regression or Gradient Boosting."
+        elif problem_type == "Clustering":
+            return "For clustering, try K-Means or DBSCAN based on your data distribution."
+    return "Setup PyCaret first to get model suggestions."
+
+# Parse Chatbot Commands
+def parse_command(command):
+    command = command.lower().strip()
+    if "drop columns" in command or "drop column" in command:
+        columns = command.replace("drop columns", "").replace("drop column", "").strip()
+        return drop_columns, columns
+    elif "show a scatter plot" in command or "scatter plot of" in command:
+        params = command.replace("show a scatter plot of", "").replace("scatter plot of", "").strip()
+        return generate_scatter_plot, params
+    elif "show a histogram" in command or "histogram of" in command:
+        params = command.replace("show a histogram of", "").replace("histogram of", "").strip()
+        return generate_histogram, params
+    elif "analyze plot" in command:
+        return lambda x: analyze_plot(), None
+    elif "suggest preprocessing" in command:
+        return lambda x: suggest_preprocessing(), None
+    elif "suggest model" in command:
+        return lambda x: suggest_model(), None
+    return None, "Command not recognized. Try 'drop columns X, Y', 'scatter plot of X vs Y', 'suggest preprocessing', or 'analyze plot'."
+
+# Dataset Preview Function
+def display_dataset_preview():
+    if 'df' in st.session_state:
+        st.subheader("Current Dataset Preview")
+        st.dataframe(st.session_state['df'].head(10), use_container_width=True)
+        st.write("---")
+
+# Sidebar Navigation with API Key Input
+with st.sidebar:
+    st.title("🔮 Neural-Vision Enhanced")
+    st.markdown("Your AI-powered model toolbox.")
+    st.markdown("---")
+    app_mode = st.selectbox("Navigation", ["Data Upload", "Model Training", "Validation & Exploration"])
+    data_type = st.selectbox("Data Type", ["Tabular"])
+    
+    # API Key Input Field
+    api_key_input = st.text_input(
+        "Enter DeepSeek API Key (optional)",
+        type="password",
+        help="Enter your DeepSeek API key to override the default. Leave blank to use the app's default key."
+    )
+    
+    st.markdown("---")
+    st.markdown("**Dependencies**: `pycaret`, `pandas`, `streamlit`, `ydata-profiling`, `plotly`, `requests`")
+    st.markdown("Created by Calvin Allen-Crawford | v2.0 | © 2025")
+
+# Determine which API key to use
+if api_key_input:
+    api_key = api_key_input  # Use the user-provided API key from the sidebar
+else:
+    api_key = st.secrets.get("DEEPSEEK_API_KEY", os.getenv("DEEPSEEK_API_KEY"))  # Fall back to secret or environment variable
+
+if not api_key:
+    st.error("DeepSeek API key is required. Please provide it in the sidebar or ensure it’s set in the app’s secrets.")
+    st.stop()
+
+# Display dataset preview at the top of each page
+display_dataset_preview()
+
 # Main App Sections
 if app_mode == "Data Upload":
     st.title("📤 Data Upload")
@@ -38,22 +222,24 @@ if app_mode == "Data Upload":
     if uploaded_file:
         df = pd.read_csv(uploaded_file)
         st.session_state['df'] = df
-        st.write("---")
-        st.subheader("Dataset Preview")
-        st.dataframe(df.head(10))
+        st.session_state.pop('problem_type', None)
+        st.session_state.pop('setup_complete', None)
+        st.session_state.pop('best_model', None)
+        st.session_state.pop('target', None)
         st.write("---")
         st.subheader("Statistics")
         col1, col2, col3 = st.columns(3)
         with col1: st.metric("Rows", df.shape[0])
         with col2: st.metric("Columns", df.shape[1])
         with col3: st.metric("Missing Values", df.isna().sum().sum())
-
         st.write("---")
         st.subheader("Exploratory Data Analysis (EDA)")
         if st.button("Generate EDA Report"):
             with st.spinner("Generating EDA Report..."):
                 profile = ProfileReport(df, explorative=True)
                 st_profile_report(profile)
+        with st.expander("AI Suggestions"):
+            st.write(suggest_preprocessing())
 
 elif app_mode == "Model Training":
     st.title("🧠 Model Training")
@@ -70,10 +256,12 @@ elif app_mode == "Model Training":
             if problem_type == "Classification":
                 classification_setup(data=df, target=target, session_id=123, verbose=False)
                 st.session_state['problem_type'] = "Classification"
+                st.session_state['target'] = target
                 st.session_state['setup_complete'] = True
             elif problem_type == "Regression":
                 regression_setup(data=df, target=target, session_id=123, verbose=False)
                 st.session_state['problem_type'] = "Regression"
+                st.session_state['target'] = target
                 st.session_state['setup_complete'] = True
             elif problem_type == "Clustering":
                 clustering_setup(data=df, session_id=123, verbose=False)
@@ -103,18 +291,21 @@ elif app_mode == "Model Training":
                 elif selected_model == "hclust":
                     num_clusters = st.number_input("Number of Clusters", min_value=2, max_value=20, value=4, step=1)
 
+        with st.expander("AI Suggestions"):
+            st.write(suggest_model())
+
         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
+                        else:
                             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
+                        else:
                             best_model = compare_regression_models(fold=folds, sort=sort_metric)
                     st.session_state['best_model'] = best_model
                     st.success(f"Best Model: {best_model}")
@@ -152,7 +343,7 @@ elif app_mode == "Model Training":
                         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
+                            else:
                                 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}")
@@ -187,6 +378,32 @@ elif app_mode == "Validation & Exploration":
         st.write("Clustering Results:")
         plot_clustering_model(st.session_state['best_model'], plot="cluster", display_format="streamlit")
 
+# Chatbot Section
+st.markdown("---")
+st.subheader("💬 AI Chatbot Assistant (DeepSeek Powered)")
+st.info("Ask me to adjust data, explore it, or get suggestions! Try: 'drop columns X, Y', 'scatter plot of X vs Y', 'suggest preprocessing', or 'analyze plot'")
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+for message in st.session_state.chat_history:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+user_input = st.chat_input("Ask me anything about the app or your data...")
+if user_input:
+    st.session_state.chat_history.append({"role": "user", "content": user_input})
+    with st.chat_message("user"):
+        st.markdown(user_input)
+    with st.spinner("Processing..."):
+        func, param = parse_command(user_input)
+        if func:
+            response = func(param) if param else func(None)
+        else:
+            response = deepseek_chat(user_input, app_mode)
+        st.session_state.chat_history.append({"role": "assistant", "content": response})
+    with st.chat_message("assistant"):
+        st.markdown(response)
+
 # Custom CSS
 st.markdown("""
     <style>