Update app.py

app.py

@@ -5,198 +5,123 @@ 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.metrics import accuracy_score, r2_score, silhouette_score, confusion_matrix, classification_report, mean_squared_error
 from sklearn.preprocessing import StandardScaler
 from ydata_profiling import ProfileReport
 from streamlit_pandas_profiling import st_profile_report
 from groq import Groq
 from langchain_community.vectorstores import FAISS
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.embeddings import HuggingFaceEmbeddings
 from langchain_community.document_loaders import TextLoader
+from langchain_community.tools.tavily_search import TavilySearchResults
 import os
+from dotenv import load_dotenv
 import tempfile
 
-# Initialize clients
+# Load environment variables
+load_dotenv()
+
+# Initialize Groq client
 client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+# Initialize embeddings for FAISS
 embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
 # Set page config
 st.set_page_config(page_title="Neural-Vision Enhanced", layout="wide")
 
-# Custom CSS for Responsive Silver-Blue-Gold Theme with Top Nav
+# Custom CSS matching previous theme
 st.markdown("""
     <style>
     :root {
-        --silver: #D8D8D8;
-        --blue: #5C89BC;
-        --gold: #A87E01;
-        --text-color: #333333;
+        --primary-blue: #3B82F6;
+        --dark-blue: #1E40AF;
+        --light-blue: #DBEAFE;
+        --medium-grey: #6B7280;
+        --light-grey: #F3F4F6;
+        --white: #FFFFFF;
+        --border-grey: #E5E7EB;
     }
     .stApp {
-        background-color: var(--silver);
+        background-color: var(--light-grey);
         font-family: 'Inter', sans-serif;
         max-width: 1200px;
         margin: 0 auto;
-        padding: 10px;
     }
     .header {
-        background-color: var(--blue);
-        color: white;
+        background-color: var(--white);
+        border-bottom: 2px solid var(--border-grey);
         padding: 15px;
-        border-radius: 5px;
+        border-radius: 12px 12px 0 0;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
         text-align: center;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
     }
     .header-title {
+        color: var(--dark-blue);
         font-size: 1.8rem;
         font-weight: 700;
         margin: 0;
     }
     .header-subtitle {
+        color: var(--medium-grey);
         font-size: 1rem;
         margin-top: 5px;
     }
-    .nav-bar {
-        background-color: white;
-        border-radius: 5px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    .sidebar .sidebar-content {
+        background-color: var(--white);
+        border-radius: 12px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
         padding: 15px;
-        margin-bottom: 20px;
-        display: flex;
-        justify-content: space-around;
-        align-items: center;
-    }
-    .nav-item {
-        color: var(--blue);
-        font-weight: 500;
-        cursor: pointer;
-        padding: 5px 10px;
-        border-radius: 5px;
-    }
-    .nav-item:hover {
-        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;
+        background-color: var(--white);
+        border-radius: 12px;
+        box-shadow: 0 4px 6px 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%;
+        background-color: var(--primary-blue);
+        color: var(--white);
+        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%;
+        background-color: var(--light-grey);
+        color: var(--medium-grey);
+        border-radius: 18px 18px 18px 4px;
+        padding: 12px 16px;
         margin-right: auto;
+        max-width: 80%;
         margin-bottom: 10px;
     }
-    .stButton > button {
-        background-color: var(--gold);
-        color: white;
-        border-radius: 5px;
-        padding: 8px 16px;
-        border: none;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-    }
-    .stButton > button:hover {
-        background-color: #8C6B01;
-    }
-    @media (max-width: 768px) {
-        .header-title {
-            font-size: 1.4rem;
-        }
-        .header-subtitle {
-            font-size: 0.9rem;
-        }
-        .nav-bar {
-            flex-direction: column;
-            padding: 10px;
-        }
-        .nav-item {
-            margin: 5px 0;
-            width: 100%;
-            text-align: center;
-        }
-        .card, .chat-container {
-            padding: 10px;
-        }
-        .stApp {
-            padding: 5px;
-        }
-    }
-      </style>
-   <footer>
-        <p>Created by Calvin Allen-Crawford</p>
-    </footer>
+    </style>
 """, unsafe_allow_html=True)
 
-# Session State Initialization
+# 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 = []
 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"
-
-# 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"
-    }
-}
 
 # Helper Functions
 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}): "
         if pd.api.types.is_numeric_dtype(df[col]):
-            mean_value = f"{df[col].mean():.2f}"
+            text += f"Mean={df[col].mean():.2f}, Min={df[col].min()}, Max={df[col].max()}"
         else:
-            mean_value = "N/A"
-        text += f"- {col} ({df[col].dtype}): Mean={mean_value}\n"
+            text += f"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):
@@ -205,122 +130,215 @@ 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):
+def get_groq_response(prompt, mode, use_web_search=False):
     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)}"
+        context = "\n\nDataset Context:\n" + "\n".join([f"- {doc.page_content}" for doc in docs])
+    
+    if use_web_search:
+        tavily = TavilySearchResults(max_results=3)
+        web_results = tavily.invoke(prompt)
+        context += "\n\nWeb Search Results:\n" + "\n".join([f"- {res['content'][:200]}..." for res in web_results])
+    
+    prompts = {
+        "Legal": "You are a neural network expert specializing in legal data analysis.",
+        "Financial": "You are a neural network expert specializing in financial data analysis.",
+        "Academic": "You are a neural network expert specializing in academic data analysis.",
+        "Technical": "You are a neural network expert specializing in technical data analysis."
+    }
+    system_prompt = prompts.get(mode, "You are a neural network development assistant.") + "\n" + context
+    
+    response = client.chat.completions.create(
+        model="llama3-70b-8192",
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0.7,
+        max_tokens=1024
+    )
+    return response.choices[0].message.content
 
-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)
+# Visualization Functions
+def plot_confusion_matrix(y_true, y_pred):
+    cm = confusion_matrix(y_true, y_pred)
+    fig = px.imshow(cm, text_auto=True, color_continuous_scale='Blues', title="Confusion Matrix")
+    return fig
 
-# 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)
+def plot_feature_importance(model, X):
+    if hasattr(model, 'feature_importances_'):
+        importance = model.feature_importances_
+    else:
+        importance = np.abs(model.coef_) if hasattr(model, 'coef_') else np.ones(X.shape[1])
+    fig = px.bar(x=X.columns, y=importance, title="Feature Importance")
+    return fig
 
-    # 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)
+def plot_residuals(y_true, y_pred):
+    residuals = y_true - y_pred
+    fig = px.scatter(x=y_pred, y=residuals, title="Residual Plot", labels={"x": "Predicted", "y": "Residuals"})
+    return fig
 
-    # 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"
+def plot_clusters(X, labels):
+    fig = px.scatter(X, x=X.columns[0], y=X.columns[1], color=labels, title="Cluster Visualization")
+    return fig
 
-        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)
+# Pages
+def data_upload_page():
+    st.header("📤 Data Upload & Analysis")
+    uploaded_file = st.file_uploader("Upload Dataset", type=["csv"])
+    
+    if uploaded_file:
+        df = pd.read_csv(uploaded_file)
+        st.session_state.df = df
+        st.session_state.vector_store = create_vector_store(convert_df_to_text(df))
+        st.session_state.metrics = {}
+        
+        st.subheader("Dataset Health Check")
+        col1, col2, col3 = st.columns(3)
+        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)
 
-    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)
+def model_training_page():
+    st.header("🧠 Neural Network Training Studio")
+    
+    if 'df' not in st.session_state:
+        st.warning("Upload data first!")
+        return
+    
+    df = st.session_state.df
+    problem_type = st.selectbox("Select Problem Type", ["Classification", "Regression", "Clustering"])
+    mode = st.selectbox("Domain Specialization", ["Legal", "Financial", "Academic", "Technical"])
+    
+    if problem_type != "Clustering":
+        target = st.selectbox("Select Target Variable", df.columns)
+        X = df.drop(columns=[target])
+        y = df[target]
+    else:
+        X = df
+        y = None
+    
+    if st.button("Train Neural Network"):
+        with st.spinner("Training in progress..."):
+            X_scaled = StandardScaler().fit_transform(X)
+            X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42) if y is not None else (X_scaled, None, None, None)
+            
+            if problem_type == "Classification":
+                model = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=500, random_state=42)
+                model.fit(X_train, y_train)
+                y_pred = model.predict(X_test)
+                st.session_state.metrics = {
+                    "Accuracy": accuracy_score(y_test, y_pred),
+                    "Classification Report": classification_report(y_test, y_pred, output_dict=True)
+                }
+            elif problem_type == "Regression":
+                model = MLPRegressor(hidden_layer_sizes=(100, 50), max_iter=500, random_state=42)
+                model.fit(X_train, y_train)
+                y_pred = model.predict(X_test)
+                st.session_state.metrics = {
+                    "R2 Score": r2_score(y_test, y_pred),
+                    "Mean Squared Error": mean_squared_error(y_test, y_pred)
+                }
+            else:  # Clustering
+                model = KMeans(n_clusters=3, random_state=42)
+                labels = model.fit_predict(X_scaled)
+                st.session_state.metrics = {
+                    "Silhouette Score": silhouette_score(X_scaled, labels)
+                }
+            
+            st.session_state.best_model = model
+            st.session_state.X_test = X_test
+            st.session_state.y_test = y_test
+            st.session_state.y_pred = y_pred if y is not None else labels
+            st.session_state.problem_type = problem_type
+            st.success(f"Model trained successfully in {mode} mode!")
 
-    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!")
+def visualization_page():
+    st.header("🔍 Neural Network 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":
+        st.plotly_chart(plot_confusion_matrix(st.session_state.y_test, st.session_state.y_pred))
+        st.plotly_chart(plot_feature_importance(st.session_state.best_model, pd.DataFrame(st.session_state.X_test, columns=st.session_state.df.columns[:-1])))
+    elif st.session_state.problem_type == "Regression":
+        st.plotly_chart(plot_residuals(st.session_state.y_test, st.session_state.y_pred))
+        st.plotly_chart(plot_feature_importance(st.session_state.best_model, pd.DataFrame(st.session_state.X_test, columns=st.session_state.df.columns[:-1])))
+    else:  # Clustering
+        st.plotly_chart(plot_clusters(pd.DataFrame(st.session_state.X_test, columns=st.session_state.df.columns), st.session_state.y_pred))
+    
+    st.subheader("Metrics")
+    st.write(st.session_state.metrics)
+
+# Chatbot Interface
+def ai_assistant():
+    st.markdown('<div class="chat-container">', unsafe_allow_html=True)
+    st.subheader("🧠 Neural Insight Assistant (RAG + Web Search)")
+    
+    use_web_search = st.checkbox("Enable Tavily Web Search", value=False)
+    mode = st.selectbox("Domain Mode", ["Legal", "Financial", "Academic", "Technical"], key="chat_mode")
+    
+    for msg in st.session_state.chat_history:
+        with st.chat_message(msg["role"]):
+            st.markdown(f'<div class="{msg["role"]}-message">{msg["content"]}</div>', unsafe_allow_html=True)
+    
+    if prompt := st.chat_input("Ask about data, models, or web insights..."):
+        st.session_state.chat_history.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(f'<div class="user-message">{prompt}</div>', unsafe_allow_html=True)
+        
+        with st.spinner("Processing..."):
+            response = get_groq_response(prompt, mode, use_web_search)
+            st.session_state.chat_history.append({"role": "assistant", "content": response})
+        
+        with st.chat_message("assistant"):
+            st.markdown(f'<div class="bot-message">{response}</div>', unsafe_allow_html=True)
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# Main App Layout
+st.markdown("""
+    <div class="header">
+        <h1 class="header-title">Neural-Vision Enhanced</h1>
+        <div class="header-subtitle">Neural Network Development for Domain-Specialized Analysis</div>
+    </div>
+""", unsafe_allow_html=True)
+
+with st.sidebar:
+    st.title("🔮 Neural-Vision Enhanced")
+    page = st.selectbox("Navigation", [
+        "Data Upload & Analysis",
+        "Neural Network Training Studio",
+        "Neural Network Evaluation Center"
+    ])
+    st.session_state.active_page = page
+    st.markdown("---")
+    st.markdown("**Environment Setup**")
+    os.environ["TAVILY_API_KEY"] = st.text_input("Tavily API Key", type="password", help="For web search functionality")
+    st.markdown("---")
+    st.markdown("v5.0 | © 2025 Neural-Vision")
+
+# Page Routing
+if "Data Upload & Analysis" in page:
+    data_upload_page()
+elif "Neural Network Training Studio" in page:
+    model_training_page()
+else:
+    visualization_page()
 
-if __name__ == "__main__":
-    main()
+ai_assistant()