Update app.py

app.py

@@ -1,420 +1,318 @@
 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
+import numpy as np
+from pycaret.classification import *
+from pycaret.regression import *
+from pycaret.clustering import *
 from ydata_profiling import ProfileReport
 from streamlit_pandas_profiling import st_profile_report
-import os
+import mlflow
 import requests
 import json
-import re
-import logging
+import os
 
 # Set page config
 st.set_page_config(page_title="Neural-Vision Enhanced", layout="wide")
 
-# 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)
+# MLflow Tracking
+mlflow.set_tracking_uri("http://127.0.0.1:5000")
+mlflow.set_experiment("Neural-Vision Enhanced")
 
-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 []
+# Initialize session state
+if 'metrics' not in st.session_state:
+    st.session_state.metrics = {}
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
 
-def get_context():
-    context = "You are using Neural-Vision Enhanced, an AI-powered data analysis and modeling tool.\n"
+# Enhanced Visualization Functions
+def visualize_classification():
+    col1, col2 = st.columns(2)
+    with col1:
+        plot_model(st.session_state.best_model, plot='confusion_matrix', display_format='streamlit')
+    with col2:
+        plot_model(st.session_state.best_model, plot='auc', display_format='streamlit')
+    
+    col3, col4 = st.columns(2)
+    with col3:
+        plot_model(st.session_state.best_model, plot='feature', display_format='streamlit')
+    with col4:
+        plot_model(st.session_state.best_model, plot='pr', display_format='streamlit')
+
+def visualize_regression():
+    col1, col2 = st.columns(2)
+    with col1:
+        plot_model(st.session_state.best_model, plot='residuals', display_format='streamlit')
+    with col2:
+        plot_model(st.session_state.best_model, plot='error', display_format='streamlit')
+    
+    col3, col4 = st.columns(2)
+    with col3:
+        plot_model(st.session_state.best_model, plot='cooks', display_format='streamlit')
+    with col4:
+        plot_model(st.session_state.best_model, plot='learning', display_format='streamlit')
+
+def visualize_clustering():
+    col1, col2 = st.columns(2)
+    with col1:
+        plot_model(st.session_state.best_model, plot='cluster', display_format='streamlit')
+    with col2:
+        plot_model(st.session_state.best_model, plot='distribution', display_format='streamlit')
+    
+    col3, col4 = st.columns(2)
+    with col3:
+        plot_model(st.session_state.best_model, plot='elbow', display_format='streamlit')
+    with col4:
+        plot_model(st.session_state.best_model, plot='silhouette', display_format='streamlit')
+
+# Enhanced Context Generator
+def get_app_context():
+    context = {
+        "current_state": {
+            "active_page": st.session_state.get('active_page', 'Data Upload'),
+            "dataset_stats": {},
+            "model_metrics": st.session_state.metrics,
+            "problem_type": st.session_state.get('problem_type'),
+            "target": st.session_state.get('target'),
+            "best_model": str(st.session_state.get('best_model', None))
+        },
+        "app_capabilities": [
+            "CSV data upload and statistical analysis",
+            "Automated EDA report generation",
+            "PyCaret-powered model training for classification, regression, and clustering",
+            "Advanced model evaluation visualizations",
+            "ML experiment tracking with MLflow",
+            "AI-powered analysis through DeepSeek integration"
+        ]
+    }
+    
     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
+        df = st.session_state.df
+        context["current_state"]["dataset_stats"] = {
+            "rows": df.shape[0],
+            "columns": df.shape[1],
+            "missing_values": df.isna().sum().sum(),
+            "columns": {col: str(df[col].dtype) for col in df.columns}
+        }
+    
+    return json.dumps(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}"}
+# Chatbot Handler
+def handle_ai_query(prompt):
     try:
         response = requests.post(
-            "https://api.deepseek.com/v1/chat/completions",
-            json=payload,
-            headers=headers,
-            timeout=10  # Increased timeout
+            "http://127.0.0.1:5001/analyze",
+            json={
+                "prompt": prompt,
+                "context": get_app_context(),
+                "metrics": st.session_state.metrics
+            }
         )
-        response.raise_for_status()
-        return response.json()["choices"][0]["message"]["content"]
-    except requests.exceptions.RequestException as e:
-        st.error(f"Error: Could not connect to DeepSeek API. {str(e)}")
-        return "I'm sorry, I couldn't process your request. Please try again later."
-
-# 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"])
+        return response.json().get("analysis", "Error in analysis")
+    except Exception as e:
+        return f"Analysis error: {str(e)}"
+
+# Main App Components
+def data_upload_page():
+    st.title("📤 Data Upload & Analysis")
+    uploaded_file = st.file_uploader("Upload Dataset", type=["csv"])
     
-    # 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")
-    uploaded_file = st.file_uploader("Upload CSV Dataset", type=["csv"])
     if uploaded_file:
         df = pd.read_csv(uploaded_file)
-        st.session_state['df'] = df
-        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")
+        st.session_state.df = df
+        st.session_state.metrics = {}
+        
+        st.subheader("Dataset Health Check")
         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..."):
+        col1.metric("Total Samples", df.shape[0])
+        col2.metric("Features", df.shape[1])
+        col3.metric("Missing Values", df.isna().sum().sum())
+        
+        if st.button("Generate Full EDA Report"):
+            with st.spinner("Generating comprehensive analysis..."):
                 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")
+def model_training_page():
+    st.title("🧠 Model Training Studio")
+    
     if 'df' not in st.session_state:
-        st.warning("Please upload a dataset first.")
-        st.stop()
-
-    df = st.session_state['df']
-    problem_type = st.selectbox("Problem Type", ["Classification", "Regression", "Clustering"])
-    target = st.selectbox("Select Target Column", df.columns) if problem_type != "Clustering" else None
-
-    if st.button("Setup PyCaret"):
-        with st.spinner("Setting up PyCaret..."):
+        st.warning("Upload data first!")
+        return
+    
+    df = st.session_state.df
+    problem_type = st.selectbox("Select Problem Type", 
+                              ["Classification", "Regression", "Clustering"])
+    
+    if problem_type != "Clustering":
+        target = st.selectbox("Select Target Variable", df.columns)
+        st.session_state.target = target
+    
+    if st.button("Initialize Training Environment"):
+        with st.spinner("Configuring PyCaret..."):
             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
+                classification_setup(df, target=target, session_id=42)
             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)
-                st.session_state['problem_type'] = "Clustering"
-                st.session_state['setup_complete'] = True
-            st.success("PyCaret setup complete! You can now train models.")
-
-    if st.session_state.get('setup_complete', False):
-        st.subheader("Train Models")
-        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)
-
-        with st.expander("AI Suggestions"):
-            st.write(suggest_model())
+                regression_setup(df, target=target, session_id=42)
+            else:
+                clustering_setup(df, session_id=42)
+            st.session_state.problem_type = problem_type
+            st.success("Environment ready for modeling!")
 
-        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:
-                            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:
-                            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)
+    if 'problem_type' in st.session_state:
+        st.subheader("Model Training Dashboard")
+        if st.session_state.problem_type in ["Classification", "Regression"]:
+            compare_models = st.checkbox("Compare Multiple Models", True)
+            n_models = st.slider("Number of Models", 1, 15, 5) if compare_models else 1
+            
+            if st.button("Start Training"):
+                with st.spinner("Training in progress..."):
+                    if compare_models:
+                        models = compare_models(n_select=n_models)
+                        st.session_state.best_model = models[0]
                     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 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:
-                                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}")
+                        st.session_state.best_model = create_model()
+                    
+                    # Capture metrics
+                    results = pull()
+                    st.session_state.metrics = results.to_dict()
+                    st.success(f"Best Model: {st.session_state.best_model}")
+                    
+                    # Log to MLflow
+                    with mlflow.start_run():
+                        mlflow.log_metrics(results.iloc[0].to_dict())
+                        mlflow.sklearn.log_model(st.session_state.best_model, "model")
+
+def visualization_page():
+    st.title("🔍 Model Evaluation Center")
+    
+    if 'best_model' not in st.session_state:
+        st.warning("Train a model first!")
+        return
+    
+    st.subheader("Performance Analysis")
+    
+    if st.session_state.problem_type == "Classification":
+        visualize_classification()
+    elif st.session_state.problem_type == "Regression":
+        visualize_regression()
+    else:
+        visualize_clustering()
+    
+    st.subheader("Metric Analysis")
+    st.dataframe(pd.DataFrame.from_dict(st.session_state.metrics))
+    
+    if st.button("Request AI Analysis"):
+        analysis = handle_ai_query("Analyze these model metrics")
+        st.markdown(f"**AI Analysis:**\n\n{analysis}")
 
-            if st.button("Save Model"):
-                if st.session_state['problem_type'] == "Classification":
-                    save_classification_model(st.session_state['best_model'], "best_model")
-                elif st.session_state['problem_type'] == "Regression":
-                    save_regression_model(st.session_state['best_model'], "best_model")
-                elif st.session_state['problem_type'] == "Clustering":
-                    save_clustering_model(st.session_state['best_model'], "best_model")
-                st.success("Model saved as `best_model.pkl`!")
-                with open("best_model.pkl", "rb") as f:
-                    st.download_button("Download Model", f, file_name="best_model.pkl")
+# Chatbot Interface
+def ai_assistant():
+    st.markdown("---")
+    st.subheader("🧠 Neural Insight Assistant")
+    
+    for msg in st.session_state.chat_history:
+        st.chat_message(msg["role"]).write(msg["content"])
+    
+    if prompt := st.chat_input("Ask about models, data, or app usage"):
+        st.session_state.chat_history.append({"role": "user", "content": prompt})
+        st.chat_message("user").write(prompt)
+        
+        response = handle_ai_query(prompt)
+        
+        st.session_state.chat_history.append({"role": "assistant", "content": response})
+        st.chat_message("assistant").write(response)
 
-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.")
-        st.stop()
+# Flask Backend (app_backend.py)
+"""
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import openai
+import os
 
-    st.subheader("Model Performance")
-    if st.session_state['problem_type'] == "Classification":
-        st.write("Classification Report:")
-        plot_classification_model(st.session_state['best_model'], plot="confusion_matrix", display_format="streamlit")
-        plot_classification_model(st.session_state['best_model'], plot="auc", display_format="streamlit")
-    elif st.session_state['problem_type'] == "Regression":
-        st.write("Regression Metrics:")
-        plot_regression_model(st.session_state['best_model'], plot="residuals", display_format="streamlit")
-        plot_regression_model(st.session_state['best_model'], plot="error", display_format="streamlit")
-    elif st.session_state['problem_type'] == "Clustering":
-        st.write("Clustering Results:")
-        plot_clustering_model(st.session_state['best_model'], plot="cluster", display_format="streamlit")
+app = Flask(__name__)
+CORS(app)
+
+openai.api_key = os.getenv("DEEPSEEK_API_KEY")
+openai.api_base = "https://api.deepseek.com/v1"
+
+SYSTEM_PROMPT = '''
+You are Neural Analyst, an AI assistant for the Neural-Vision Enhanced analytics platform. 
+Your capabilities include:
+
+1. Explaining model metrics and evaluation visualizations
+2. Interpreting dataset statistics and EDA reports
+3. Guiding users through app functionality
+4. Providing data science insights
+5. Comparing different model performances
+
+Always consider:
+- Current dataset statistics: {dataset_stats}
+- Active problem type: {problem_type}
+- Model metrics: {metrics}
+- App state: {active_page}
+'''
+
+@app.route('/analyze', methods=['POST'])
+def analyze():
+    data = request.json
+    context = json.loads(data['context'])
+    
+    prompt = f'''
+    User Query: {data['prompt']}
+    
+    Current Context:
+    - Active Page: {context['current_state']['active_page']}
+    - Problem Type: {context['current_state']['problem_type']}
+    - Target Variable: {context['current_state']['target']}
+    - Dataset Shape: {context['current_state']['dataset_stats'].get('rows', 0)} rows, 
+      {context['current_state']['dataset_stats'].get('columns', 0)} columns
+    - Model Metrics: {json.dumps(context['current_state']['model_metrics'])}
+    '''
+    
+    response = openai.ChatCompletion.create(
+        model="deepseek-chat",
+        messages=[{
+            "role": "system",
+            "content": SYSTEM_PROMPT.format(**context['current_state'])
+        }, {
+            "role": "user",
+            "content": prompt
+        }],
+        temperature=0.3,
+        max_tokens=500
+    )
+    
+    return jsonify({"analysis": response.choices[0].message.content})
 
-# 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 = []
+if __name__ == '__main__':
+    app.run(port=5001)
+"""
 
-for message in st.session_state.chat_history:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
+# App Layout
+with st.sidebar:
+    st.title("🔮 Neural-Vision Enhanced")
+    page = st.selectbox("Navigation", [
+        "Data Upload & Analysis",
+        "Model Training Studio", 
+        "Model Evaluation Center"
+    ])
+    st.session_state.active_page = page
+    st.markdown("---")
+    st.markdown("**DeepSeek API Key**")
+    os.environ["DEEPSEEK_API_KEY"] = st.text_input(
+        "Enter API Key:", type="password",
+        help="Required for AI analysis features"
+    )
+    st.markdown("---")
+    st.markdown("v4.0 | © 2025 Neural-Vision")
 
-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)
+# Page Routing
+if "Data Upload & Analysis" in page:
+    data_upload_page()
+elif "Model Training Studio" in page:
+    model_training_page()
+else:
+    visualization_page()
 
-# Custom CSS
-st.markdown("""
-    <style>
-    .stButton>button {background-color: #4CAF50; color: white;}
-    h1, h2 {color: #1e3a8a;}
-    </style>
-""", unsafe_allow_html=True)
+ai_assistant()