Update app.py

app.py

@@ -1,130 +1,344 @@
-import gradio as gr
-import groq
-import os
-import tempfile
-import uuid
-from dotenv import load_dotenv
-from langchain_community.document_loaders import PyPDFLoader
+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, 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.vectorstores import FAISS
 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
 
-# Configuration
+# Load environment variables
 load_dotenv()
-client = groq.Client(api_key=os.getenv("GROQ_API_KEY"))
+
+# 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")
-FAISS_INDEX_DIR = "faiss_indexes"
-os.makedirs(FAISS_INDEX_DIR, exist_ok=True)
-
-def process_pdf(file_bytes):
-    """Process PDF and create vector store"""
-    try:
-        # Generate unique session ID
-        session_id = str(uuid.uuid4())
-        
-        # Save PDF temporarily
-        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
-            f.write(file_bytes)
-            pdf_path = f.name
-        
-        # Load and split PDF
-        loader = PyPDFLoader(pdf_path)
-        pages = loader.load()
-        text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=1000, chunk_overlap=200
-        )
-        texts = text_splitter.split_documents(pages)
-        
-        # Create and save vector store
-        vectorstore = FAISS.from_documents(texts, embeddings)
-        vectorstore.save_local(os.path.join(FAISS_INDEX_DIR, session_id))
-        
-        return session_id, "PDF processed successfully!"
+
+# Set page config
+st.set_page_config(page_title="Neural-Vision Enhanced", layout="wide")
+
+# Custom CSS matching previous theme
+st.markdown("""
+    <style>
+    :root {
+        --primary-blue: #3B82F6;
+        --dark-blue: #1E40AF;
+        --light-blue: #DBEAFE;
+        --medium-grey: #6B7280;
+        --light-grey: #F3F4F6;
+        --white: #FFFFFF;
+        --border-grey: #E5E7EB;
+    }
+    .stApp {
+        background-color: var(--light-grey);
+        font-family: 'Inter', sans-serif;
+        max-width: 1200px;
+        margin: 0 auto;
+    }
+    .header {
+        background-color: var(--white);
+        border-bottom: 2px solid var(--border-grey);
+        padding: 15px;
+        border-radius: 12px 12px 0 0;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        text-align: center;
+    }
+    .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;
+    }
+    .sidebar .sidebar-content {
+        background-color: var(--white);
+        border-radius: 12px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        padding: 15px;
+    }
+    .chat-container {
+        background-color: var(--white);
+        border-radius: 12px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        padding: 15px;
+        margin-top: 20px;
+    }
+    .user-message {
+        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: 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;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# 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
+
+# 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]):
+            text += f"Mean={df[col].mean():.2f}, Min={df[col].min()}, Max={df[col].max()}"
+        else:
+            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):
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as temp_file:
+        temp_file.write(df_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)
+    vector_store = FAISS.from_documents(texts, embeddings)
+    os.unlink(temp_path)
+    return vector_store
+
+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 = "\n\nDataset Context:\n" + "\n".join([f"- {doc.page_content}" for doc in docs])
     
-    except Exception as e:
-        return None, f"Error processing PDF: {str(e)}"
-    finally:
-        if 'pdf_path' in locals() and os.path.exists(pdf_path):
-            os.remove(pdf_path)
-
-def get_response(message, session_id, history):
-    """Generate response using Groq and RAG"""
-    if not message:
-        return history
+    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])
     
-    try:
-        # Load vector store if available
-        context = ""
-        if session_id:
-            vectorstore = FAISS.load_local(
-                os.path.join(FAISS_INDEX_DIR, session_id),
-                embeddings,
-                allow_dangerous_deserialization=True
-            )
-            docs = vectorstore.similarity_search(message, k=3)
-            context = "\n".join([d.page_content for d in docs])
-        
-        # Create system prompt
-        system_prompt = f"""You are a helpful PDF analysis assistant. 
-        Use this context when relevant:
-        {context}
-        """
+    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
+
+# 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
+
+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
+
+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
+
+def plot_clusters(X, labels):
+    fig = px.scatter(X, x=X.columns[0], y=X.columns[1], color=labels, title="Cluster Visualization")
+    return fig
+
+# 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 = {}
         
-        # Get Groq response
-        response = client.chat.completions.create(
-            model="llama3-70b-8192",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": message},
-                *history
-            ],
-            temperature=0.7,
-            max_tokens=1024
-        ).choices[0].message.content
+        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())
         
-        return history + [{"role": "assistant", "content": response}]
+        if st.button("Generate Full EDA Report"):
+            with st.spinner("Generating comprehensive analysis..."):
+                profile = ProfileReport(df, explorative=True)
+                st_profile_report(profile)
+
+def model_training_page():
+    st.header("🧠 Neural Network Training Studio")
     
-    except Exception as e:
-        return history + [{"role": "assistant", "content": f"Error: {str(e)}"}]
+    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!")
 
-# Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    session_id = gr.State()
+def visualization_page():
+    st.header("🔍 Neural Network Evaluation Center")
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("## PDF Analysis with Groq")
-            pdf_input = gr.File(label="Upload PDF", type="binary")
-            upload_btn = gr.Button("Process PDF", variant="primary")
-            status = gr.Markdown("Status: Waiting for PDF upload")
-        
-        with gr.Column(scale=2):
-            pdf_viewer = gr.PDF(label="PDF Preview")
-            chatbot = gr.Chatbot()
-            msg = gr.Textbox(placeholder="Ask about the PDF...", show_label=False)
-            clear_btn = gr.Button("Clear Chat")
+    if 'best_model' not in st.session_state:
+        st.warning("Train a model first!")
+        return
     
-    # Event handlers
-    upload_btn.click(
-        lambda file: process_pdf(file.read()) if file else (None, "No PDF uploaded"),
-        inputs=pdf_input,
-        outputs=[session_id, status]
-    ).then(
-        lambda file: file.name if file else None,
-        inputs=pdf_input,
-        outputs=pdf_viewer
-    )
+    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))
     
-    msg.submit(
-        get_response,
-        inputs=[msg, session_id, chatbot],
-        outputs=chatbot
-    ).then(lambda: "", None, msg)
+    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)")
     
-    clear_btn.click(
-        lambda: ([], None, "Status: Chat cleared"),
-        outputs=[chatbot, session_id, status]
-    )
+    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__":
-    demo.launch(share=True)
+ai_assistant()