Update app.py

app.py

@@ -1,30 +1,35 @@
 import streamlit as st
 import pandas as pd
-import plotly.express as px
 import numpy as np
-from sklearn.model_selection import train_test_split
-from sklearn.neural_network import MLPClassifier, MLPRegressor
-from sklearn.cluster import KMeans
-from sklearn.metrics import accuracy_score, r2_score, silhouette_score
-from sklearn.preprocessing import StandardScaler
+import plotly.express as px
+import plotly.graph_objects as go
 from ydata_profiling import ProfileReport
 from streamlit_pandas_profiling import st_profile_report
+import os
+from dotenv import load_dotenv
 from groq import Groq
 from langchain_community.vectorstores import FAISS
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_huggingface import HuggingFaceEmbeddings
 from langchain_community.document_loaders import TextLoader
-import os
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+import re
+from scipy import stats
+from sklearn.preprocessing import StandardScaler, LabelEncoder, OneHotEncoder
 import tempfile
 
-# Initialize clients
+# Set page config as the first Streamlit command
+st.set_page_config(page_title="Data-Vision Pro", layout="wide")
+
+# Load environment variables
+load_dotenv()
+
+# Initialize Groq client
 client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
-# Set page config
-st.set_page_config(page_title="Neural-Vision Enhanced", layout="wide")
+# Initialize HuggingFace embeddings for FAISS
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
-# Custom CSS for Responsive Silver-Blue-Gold Theme with Top Nav
+# Custom CSS with Silver, Blue, and Gold Theme + Top Nav
 st.markdown("""
     <style>
     :root {
@@ -36,7 +41,7 @@ st.markdown("""
     .stApp {
         background-color: var(--silver);
         font-family: 'Inter', sans-serif;
-        max-width: 1200px;
+        max-width: 900px;
         margin: 0 auto;
         padding: 10px;
     }
@@ -45,16 +50,16 @@ st.markdown("""
         color: white;
         padding: 15px;
         border-radius: 5px;
-        text-align: center;
         box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        text-align: center;
     }
     .header-title {
-        font-size: 1.8rem;
+        font-size: 1.5rem;
         font-weight: 700;
         margin: 0;
     }
     .header-subtitle {
-        font-size: 1rem;
+        font-size: 0.9rem;
         margin-top: 5px;
     }
     .nav-bar {
@@ -78,38 +83,51 @@ st.markdown("""
         background-color: var(--gold);
         color: white;
     }
-    .card {
-        background-color: white;
-        border-radius: 5px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        padding: 20px;
-        margin-bottom: 20px;
-    }
     .chat-container {
         background-color: white;
         border-radius: 5px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
         padding: 15px;
         margin-top: 20px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
     }
     .user-message {
         background-color: var(--blue);
         color: white;
-        border-radius: 15px 15px 5px 15px;
-        padding: 10px;
-        max-width: 80%;
+        border-radius: 18px 18px 4px 18px;
+        padding: 12px 16px;
         margin-left: auto;
+        max-width: 80%;
         margin-bottom: 10px;
     }
     .bot-message {
         background-color: #F0F0F0;
         color: var(--text-color);
-        border-radius: 15px 15px 15px 5px;
-        padding: 10px;
-        max-width: 80%;
+        border-radius: 18px 18px 18px 4px;
+        padding: 12px 16px;
         margin-right: auto;
+        max-width: 80%;
         margin-bottom: 10px;
     }
+    .footer {
+        text-align: center;
+        margin-top: 20px;
+        color: var(--text-color);
+        font-size: 0.8rem;
+    }
+    .tech-badge {
+        display: inline-block;
+        background-color: #E6ECEF;
+        color: var(--blue);
+        padding: 4px 8px;
+        border-radius: 12px;
+        font-size: 0.7rem;
+        margin: 0 4px;
+    }
+    h2 {
+        color: var(--blue);
+        border-bottom: 2px solid var(--gold);
+        padding-bottom: 5px;
+    }
     .stButton > button {
         background-color: var(--gold);
         color: white;
@@ -123,10 +141,10 @@ st.markdown("""
     }
     @media (max-width: 768px) {
         .header-title {
-            font-size: 1.4rem;
+            font-size: 1.2rem;
         }
         .header-subtitle {
-            font-size: 0.9rem;
+            font-size: 0.8rem;
         }
         .nav-bar {
             flex-direction: column;
@@ -137,62 +155,43 @@ st.markdown("""
             width: 100%;
             text-align: center;
         }
-        .card, .chat-container {
+        .chat-container {
             padding: 10px;
         }
         .stApp {
             padding: 5px;
         }
+        h2 {
+            font-size: 1.2rem;
+        }
     }
-# Footer
-    <footer style='text-align: center; padding: 10px; background-color: var(--blue); color: white; border-radius: 5px; margin-top: 20px;'>
-        <p>Created by Calvin Allen-Crawford</p>
-    </footer>
+    </style>
 """, unsafe_allow_html=True)
 
-# Session State Initialization
-if 'metrics' not in st.session_state:
-    st.session_state.metrics = {}
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-if 'vector_store' not in st.session_state:
-    st.session_state.vector_store = None
-if 'custom_layers' not in st.session_state:
-    st.session_state.custom_layers = []
-if 'prebuilt_selection' not in st.session_state:
-    st.session_state.prebuilt_selection = None
-if 'model_config' not in st.session_state:
-    st.session_state.model_config = {}
-if 'model_builder_mode' not in st.session_state:
-    st.session_state.model_builder_mode = "prebuilt"
-if 'custom_model_type' not in st.session_state:
-    st.session_state.custom_model_type = "classification"
+# Helper Functions
+def enhance_section_title(title):
+    st.markdown(f"<h2 style='border-bottom: 2px solid var(--gold); padding-bottom: 5px; color: var(--blue);'>{title}</h2>", unsafe_allow_html=True)
 
-# Prebuilt Models
-PREBUILT_MODELS = {
-    "Legal Document Classifier": {
-        "description": "Optimized for legal document classification.",
-        "architecture": {"type": "classification", "hidden_layers": [(128, "relu"), (64, "relu")], "dropout": 0.3, "optimizer": "adam", "learning_rate": 0.001},
-        "domain": "Legal"
-    },
-    "Financial Fraud Detector": {
-        "description": "Detects anomalies in financial transactions.",
-        "architecture": {"type": "classification", "hidden_layers": [(256, "relu"), (128, "relu"), (64, "relu")], "dropout": 0.4, "optimizer": "adam", "learning_rate": 0.0005},
-        "domain": "Financial"
-    },
-    "Customer Segmentation Engine": {
-        "description": "Advanced customer segmentation.",
-        "architecture": {"type": "clustering", "n_clusters": 5, "algorithm": "kmeans", "init": "k-means++", "n_init": 10},
-        "domain": "Marketing"
-    }
-}
+def update_cleaned_data(df):
+    st.session_state.cleaned_data = df
+    if 'data_versions' not in st.session_state:
+        st.session_state.data_versions = [st.session_state.raw_data.copy()]
+    st.session_state.data_versions.append(df.copy())
+    st.session_state.dataset_text = convert_df_to_text(df)
+    st.success("✅ Action completed successfully!")
+    st.rerun()
 
-# Helper Functions (unchanged)
 def convert_df_to_text(df):
     text = f"Dataset Summary: {df.shape[0]} rows, {df.shape[1]} columns\n"
     text += f"Missing Values: {df.isna().sum().sum()}\n"
+    text += "Columns:\n"
     for col in df.columns:
-        text += f"- {col} ({df[col].dtype}): Mean={df[col].mean():.2f if pd.api.types.is_numeric_dtype(df[col]) else 'N/A'}\n"
+        if pd.api.types.is_numeric_dtype(df[col]):
+            mean_value = f"{df[col].mean():.2f}"
+        else:
+            mean_value = "N/A"
+        text += f"- {col} ({df[col].dtype}): Mean={mean_value}, Min={df[col].min()}, Max={df[col].max()}" if pd.api.types.is_numeric_dtype(df[col]) else f"- {col} ({df[col].dtype}): Unique={df[col].nunique()}, Top={df[col].mode()[0] if not df[col].mode().empty else 'N/A'}"
+        text += f", Missing={df[col].isna().sum()}\n"
     return text
 
 def create_vector_store(df_text):
@@ -201,122 +200,35 @@ def create_vector_store(df_text):
         temp_path = temp_file.name
     loader = TextLoader(temp_path)
     documents = loader.load()
-    texts = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100).split_documents(documents)
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
+    texts = text_splitter.split_documents(documents)
     vector_store = FAISS.from_documents(texts, embeddings)
     os.unlink(temp_path)
     return vector_store
 
-def get_groq_response(prompt, mode):
-    context = ""
-    if st.session_state.vector_store:
-        docs = st.session_state.vector_store.similarity_search(prompt, k=3)
-        context += "\nDataset Context:\n" + "\n".join([f"- {doc.page_content}" for doc in docs])
-    try:
-        response = client.chat.completions.create(
-            model="llama3-70b-8192",
-            messages=[
-                {"role": "system", "content": f"You are an expert in {mode} data analysis.\n{context}"},
-                {"role": "user", "content": prompt}
-            ]
-        ).choices[0].message.content
-        return response
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def build_model_from_config(config, X, y=None):
-    problem_type = config.get("type", "classification")
-    if problem_type == "clustering":
-        return KMeans(n_clusters=config.get("n_clusters", 3), init=config.get("init", "k-means++"), n_init=config.get("n_init", 10), random_state=42)
-    hidden_layers = config.get("hidden_layers", [(100, "relu")])
-    layer_sizes = [size for size, _ in hidden_layers]
-    activation = hidden_layers[0][1] if hidden_layers else "relu"
-    if problem_type == "classification":
-        return MLPClassifier(hidden_layer_sizes=layer_sizes, activation=activation, solver=config.get("optimizer", "adam"), learning_rate_init=config.get("learning_rate", 0.001), random_state=42)
-    return MLPRegressor(hidden_layer_sizes=layer_sizes, activation=activation, solver=config.get("optimizer", "adam"), learning_rate_init=config.get("learning_rate", 0.001), random_state=42)
-
-# Main Application
-def main():
-    st.markdown('<div class="header"><h1 class="header-title">Neural-Vision Enhanced</h1><p class="header-subtitle">Build & Train Neural Networks</p></div>', unsafe_allow_html=True)
-
-    # Top Navigation Bar
-    st.markdown('<div class="nav-bar">', unsafe_allow_html=True)
-    col1, col2, col3 = st.columns([1, 2, 1])
-    with col1:
-        st.markdown('<div class="nav-item">Data Input</div>', unsafe_allow_html=True)
-        uploaded_file = st.file_uploader("Upload CSV Dataset", type=["csv"])
-        if uploaded_file:
-            df = pd.read_csv(uploaded_file)
-            st.session_state.vector_store = create_vector_store(convert_df_to_text(df))
-            st.success("Dataset uploaded!")
-    with col2:
-        st.markdown('<div class="nav-item">Navigation</div>', unsafe_allow_html=True)
-        nav_option = st.selectbox("Navigate", ["Model Builder", "Chat", "Train Model"], label_visibility="collapsed")
-    with col3:
-        st.markdown('<div class="nav-item">Info</div>', unsafe_allow_html=True)
-        st.write("Built with Streamlit & Groq")
-    st.markdown('</div>', unsafe_allow_html=True)
-
-    # Main Content
-    if nav_option == "Model Builder":
-        st.markdown('<div class="card"><h2>Model Builder</h2></div>', unsafe_allow_html=True)
-        mode = st.selectbox("Domain", ["Legal", "Financial", "Marketing"])
-        model_builder_mode = st.radio("Mode", ["Prebuilt", "Custom"])
-        st.session_state.model_builder_mode = "prebuilt" if model_builder_mode == "Prebuilt" else "custom"
-
-        if st.session_state.model_builder_mode == "prebuilt":
-            for name, details in PREBUILT_MODELS.items():
-                if st.button(f"{name}: {details['description']}", key=name):
-                    st.session_state.prebuilt_selection = name
-                    st.session_state.model_config = details["architecture"]
-            if st.session_state.prebuilt_selection:
-                st.json(st.session_state.model_config)
-        else:
-            st.session_state.custom_model_type = st.selectbox("Type", ["classification", "regression", "clustering"])
-            if st.session_state.custom_model_type != "clustering":
-                layer_count = st.number_input("Layers", min_value=1, value=1)
-                st.session_state.custom_layers = []
-                for i in range(int(layer_count)):
-                    size = st.number_input(f"Layer {i+1} Size", min_value=1, value=100, key=f"size_{i}")
-                    activation = st.selectbox(f"Layer {i+1} Activation", ["relu", "tanh"], key=f"act_{i}")
-                    st.session_state.custom_layers.append((size, activation))
-                optimizer = st.selectbox("Optimizer", ["adam", "sgd"])
-                st.session_state.model_config = {"type": st.session_state.custom_model_type, "hidden_layers": st.session_state.custom_layers, "optimizer": optimizer, "learning_rate": 0.001}
-            else:
-                st.session_state.model_config = {"type": "clustering", "n_clusters": st.number_input("Clusters", min_value=2, value=3)}
-            if st.button("Finalize"): st.json(st.session_state.model_config)
-
-    elif nav_option == "Chat":
-        st.markdown('<div class="chat-container"><h3>Chat with Grok</h3></div>', unsafe_allow_html=True)
-        mode = st.selectbox("Domain", ["Legal", "Financial", "Marketing"])
-        prompt = st.text_input("Ask a question:")
-        if prompt:
-            response = get_groq_response(prompt, mode)
-            st.session_state.chat_history.append({"role": "user", "content": prompt})
-            st.session_state.chat_history.append({"role": "bot", "content": response})
-        for msg in st.session_state.chat_history:
-            st.markdown(f'<div class={"user-message" if msg["role"] == "user" else "bot-message"}>{msg["content"]}</div>', unsafe_allow_html=True)
-
-    elif nav_option == "Train Model":
-        if uploaded_file and st.session_state.model_config:
-            st.markdown('<div class="card"><h2>Train Model</h2></div>', unsafe_allow_html=True)
-            df = pd.read_csv(uploaded_file)
-            X = df.drop(columns=[df.columns[-1]]) if st.session_state.model_config["type"] != "clustering" else df
-            y = df[df.columns[-1]] if st.session_state.model_config["type"] != "clustering" else None
-            if st.button("Train"):
-                scaler = StandardScaler()
-                X_scaled = scaler.fit_transform(X)
-                model = build_model_from_config(st.session_state.model_config, X_scaled, y)
-                if st.session_state.model_config["type"] != "clustering":
-                    X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
-                    model.fit(X_train, y_train)
-                    y_pred = model.predict(X_test)
-                    st.session_state.metrics = {"accuracy" if st.session_state.model_config["type"] == "classification" else "r2_score": accuracy_score(y_test, y_pred) if st.session_state.model_config["type"] == "classification" else r2_score(y_test, y_pred)}
-                else:
-                    model.fit(X_scaled)
-                    st.session_state.metrics = {"silhouette_score": silhouette_score(X_scaled, model.labels_)}
-                st.json(st.session_state.metrics)
-        else:
-            st.warning("Upload a dataset and configure a model first!")
-
-if __name__ == "__main__":
-    main()
+def update_vector_store_with_plot(plot_text, existing_vector_store):
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as temp_file:
+        temp_file.write(plot_text)
+        temp_path = temp_file.name
+    loader = TextLoader(temp_path)
+    documents = loader.load()
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
+    texts = text_splitter.split_documents(documents)
+    if existing_vector_store:
+        existing_vector_store.add_documents(texts)
+    else:
+        existing_vector_store = FAISS.from_documents(texts, embeddings)
+    os.unlink(temp_path)
+    return existing_vector_store
+
+def extract_plot_data(plot_info, df):
+    plot_type = plot_info["type"]
+    x_col = plot_info["x"]
+    y_col = plot_info["y"] if "y" in plot_info else None
+    data = pd.read_json(plot_info["data"])
+    plot_text = f"Plot Type: {plot_type}\n"
+    plot_text += f"X-Axis: {x_col}\n"
+    if y_col:
+        plot_text += f"Y-Axis: {y_col}\n"
+    if plot_type == "Scatter Plot" and y_col:
+        correlation = data[x