Update app.py

app.py

@@ -5,7 +5,7 @@ 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.metrics import accuracy_score, r2_score, silhouette_score
 from sklearn.preprocessing import StandardScaler
 from ydata_profiling import ProfileReport
 from streamlit_pandas_profiling import st_profile_report
@@ -14,11 +14,8 @@ from langchain_community.vectorstores import FAISS
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain_huggingface import HuggingFaceEmbeddings
 from langchain_community.document_loaders import TextLoader
-from langchain_community.tools.tavily_search import TavilySearchResults
-import torch
 import os
 import tempfile
-import json
 
 # Initialize clients
 client = Groq(api_key=os.getenv("GROQ_API_KEY"))
@@ -27,141 +24,106 @@ embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-
 # Set page config
 st.set_page_config(page_title="Neural-Vision Enhanced", layout="wide")
 
-# Custom CSS
+# Custom CSS for Responsive Silver-Blue-Gold 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;
-        --success-green: #10B981;
-        --warning-yellow: #F59E0B;
+        --silver: #D8D8D8;
+        --blue: #5C89BC;
+        --gold: #A87E01;
+        --text-color: #333333;
     }
     .stApp {
-        background-color: var(--light-grey);
+        background-color: var(--silver);
         font-family: 'Inter', sans-serif;
         max-width: 1200px;
         margin: 0 auto;
+        padding: 10px;
     }
     .header {
-        background-color: var(--white);
-        border-bottom: 2px solid var(--border-grey);
+        background-color: var(--blue);
+        color: white;
         padding: 15px;
-        border-radius: 12px 12px 0 0;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        border-radius: 5px;
         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;
     }
     .card {
-        background-color: var(--white);
-        border-radius: 12px;
-        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        background-color: white;
+        border-radius: 5px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
         padding: 20px;
         margin-bottom: 20px;
     }
-    .layer-card {
-        background-color: var(--light-blue);
-        border-radius: 8px;
-        padding: 15px;
-        margin-bottom: 10px;
-        border-left: 4px solid var(--primary-blue);
-    }
-    .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);
+        background-color: white;
+        border-radius: 5px;
         padding: 15px;
         margin-top: 20px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
     }
     .user-message {
-        background-color: var(--primary-blue);
-        color: var(--white);
-        border-radius: 18px 18px 4px 18px;
-        padding: 12px 16px;
-        margin-left: auto;
+        background-color: var(--blue);
+        color: white;
+        border-radius: 15px 15px 5px 15px;
+        padding: 10px;
         max-width: 80%;
+        margin-left: auto;
         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;
+        background-color: #F0F0F0;
+        color: var(--text-color);
+        border-radius: 15px 15px 15px 5px;
+        padding: 10px;
         max-width: 80%;
+        margin-right: auto;
         margin-bottom: 10px;
     }
-    .model-card {
-        border: 1px solid var(--border-grey);
-        border-radius: 8px;
-        padding: 15px;
-        margin-bottom: 15px;
-        transition: all 0.3s ease;
-        cursor: pointer;
-    }
-    .model-card:hover {
-        box-shadow: 0 4px 12px rgba(0,0,0,0.1);
-        border-color: var(--primary-blue);
-    }
-    .selected-model {
-        border-color: var(--primary-blue);
-        background-color: var(--light-blue);
-    }
-    .stButton>button {
-        background-color: var(--primary-blue);
+    .stButton > button {
+        background-color: var(--gold);
         color: white;
-        border-radius: 6px;
+        border-radius: 5px;
         padding: 8px 16px;
         border: none;
-        font-weight: 500;
-        transition: all 0.3s ease;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
     }
-    .stButton>button:hover {
-        background-color: var(--dark-blue);
-        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+    .stButton > button:hover {
+        background-color: #8C6B01;
     }
-    .status-bar {
-        height: 10px;
-        width: 100%;
-        background-color: var(--light-grey);
+    .sidebar .sidebar-content {
+        background-color: white;
         border-radius: 5px;
-        margin-top: 10px;
-        overflow: hidden;
-    }
-    .status-progress {
-        height: 100%;
-        background-color: var(--primary-blue);
-        transition: width 0.5s ease;
+        padding: 15px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
     }
-    .feature-desc {
-        font-size: 0.9rem;
-        color: var(--medium-grey);
-        margin-top: 5px;
+    @media (max-width: 768px) {
+        .header-title {
+            font-size: 1.4rem;
+        }
+        .header-subtitle {
+            font-size: 0.9rem;
+        }
+        .card, .chat-container {
+            padding: 10px;
+        }
+        .stApp {
+            padding: 5px;
+        }
     }
     </style>
 """, unsafe_allow_html=True)
 
-# Initialize session state
+# Session State Initialization
 if 'metrics' not in st.session_state:
     st.session_state.metrics = {}
 if 'chat_history' not in st.session_state:
@@ -175,205 +137,145 @@ if 'prebuilt_selection' not in st.session_state:
 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"  # Options: "prebuilt" or "custom"
+    st.session_state.model_builder_mode = "prebuilt"
 if 'custom_model_type' not in st.session_state:
-    st.session_state.custom_model_type = "classification"  # Options: "classification", "regression", "clustering"
+    st.session_state.custom_model_type = "classification"
 
-# Prebuilt model templates
+# Prebuilt Models
 PREBUILT_MODELS = {
     "Legal Document Classifier": {
-        "description": "Neural network optimized for legal document classification with special features for contract analysis.",
-        "architecture": {
-            "type": "classification",
-            "hidden_layers": [(128, "relu"), (64, "relu")],
-            "dropout": 0.3,
-            "optimizer": "adam",
-            "learning_rate": 0.001
-        },
-        "domain": "Legal",
-        "use_case": "Document classification"
+        "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": "Deep learning model designed to detect anomalies in financial transactions with high accuracy.",
-        "architecture": {
-            "type": "classification",
-            "hidden_layers": [(256, "relu"), (128, "relu"), (64, "relu")],
-            "dropout": 0.4,
-            "optimizer": "adam",
-            "learning_rate": 0.0005
-        },
-        "domain": "Financial",
-        "use_case": "Fraud detection"
-    },
-    "Academic Paper Topic Classifier": {
-        "description": "Neural model for categorizing academic papers by subject area.",
-        "architecture": {
-            "type": "classification",
-            "hidden_layers": [(100, "relu"), (50, "tanh")],
-            "dropout": 0.2,
-            "optimizer": "adam",
-            "learning_rate": 0.001
-        },
-        "domain": "Academic",
-        "use_case": "Topic classification"
-    },
-    "Customer Churn Predictor": {
-        "description": "Regression model that predicts likelihood of customer churn based on engagement metrics.",
-        "architecture": {
-            "type": "regression",
-            "hidden_layers": [(64, "relu"), (32, "relu")],
-            "dropout": 0.2,
-            "optimizer": "adam",
-            "learning_rate": 0.001
-        },
-        "domain": "Business",
-        "use_case": "Churn prediction"
-    },
-    "Medical Diagnosis Assistant": {
-        "description": "Classification model for preliminary medical diagnosis based on patient symptoms and metrics.",
-        "architecture": {
-            "type": "classification",
-            "hidden_layers": [(128, "relu"), (64, "relu"), (32, "relu")],
-            "dropout": 0.3,
-            "optimizer": "adam",
-            "learning_rate": 0.0005
-        },
-        "domain": "Healthcare",
-        "use_case": "Diagnosis assistance"
+        "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": "Clustering model for advanced customer segmentation based on behavioral patterns.",
-        "architecture": {
-            "type": "clustering",
-            "n_clusters": 5,
-            "algorithm": "kmeans",
-            "init": "k-means++",
-            "n_init": 10
-        },
-        "domain": "Marketing",
-        "use_case": "Customer segmentation"
+        "description": "Advanced customer segmentation.",
+        "architecture": {"type": "clustering", "n_clusters": 5, "algorithm": "kmeans", "init": "k-means++", "n_init": 10},
+        "domain": "Marketing"
     }
 }
 
-# Helper Functions
+# Helper Functions (unchanged from previous)
 def convert_df_to_text(df):
-    """Convert dataframe to text format for RAG system"""
     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"
+        text += f"- {col} ({df[col].dtype}): Mean={df[col].mean():.2f if pd.api.types.is_numeric_dtype(df[col]) else 'N/A'}\n"
     return text
 
 def create_vector_store(df_text):
-    """Create FAISS vector store from dataframe 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)
+    texts = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100).split_documents(documents)
     vector_store = FAISS.from_documents(texts, embeddings)
     os.unlink(temp_path)
     return vector_store
 
-def get_groq_response(prompt, mode, context_type="model_building", use_web_search=False):
-    """Get response from Groq LLM with different context types"""
+def get_groq_response(prompt, mode):
     context = ""
-    sources = []
-
-    # RAG context from uploaded data
     if st.session_state.vector_store:
         docs = st.session_state.vector_store.similarity_search(prompt, k=3)
-        context += "\n\nUploaded Dataset Context:\n" + "\n".join([f"- {doc.page_content}" for doc in docs])
-        sources.append("Uploaded Data")
-
-    # Tavily web search if toggled
-    if use_web_search:
-        tavily_api_key = os.environ.get("TAVILY_API_KEY")
-        if tavily_api_key:
-            try:
-                tavily = TavilySearchResults(max_results=3, api_key=tavily_api_key)
-                web_results = tavily.invoke(prompt)
-                context += "\n\nWeb Search Results (Tavily):\n" + "\n".join([f"- {res['content'][:200]}..." for res in web_results])
-                sources.append("Tavily Web Search")
-            except Exception as e:
-                return f"Error with Tavily web search: {str(e)}. Ensure your API key is valid."
-        else:
-            context += "\n\nWeb search requested but no Tavily API key provided."
-
-    # Model building context
-    if context_type == "model_building":
-        context += "\n\nYou are advising on neural network architecture and implementation. Provide specific layer recommendations, parameters, and explain your reasoning. Be specific with activation functions, layer sizes, and learning approaches."
-    
-    # Domain-specific prompt
-    prompts = {
-        "Legal": "You are an expert in legal data analysis, providing insights and predictions based on available data and web information if enabled.",
-        "Financial": "You are an expert in financial data analysis, providing insights and predictions based on available data and web information if enabled.",
-        "Academic": "You are an expert in academic data analysis, providing insights and predictions based on available data and web information if enabled.",
-        "Technical": "You are an expert in technical data analysis, providing insights and predictions based on available data and web information if enabled.",
-        "Healthcare": "You are an expert in healthcare data analysis, providing medical insights based on available data and web information if enabled.",
-        "Marketing": "You are an expert in marketing data analysis, providing customer insights based on available data and web information if enabled."
-    }
-    system_prompt = prompts.get(mode, prompts["Technical"]) + "\n" + context
-
+        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": system_prompt},
+                {"role": "system", "content": f"You are an expert in {mode} data analysis.\n{context}"},
                 {"role": "user", "content": prompt}
-            ],
-            temperature=0.7,
-            max_tokens=1024
+            ]
         ).choices[0].message.content
-        return response + f"\n\n**Sources:** {', '.join(sources) if sources else 'General Knowledge'}"
+        return response
     except Exception as e:
-        return f"Error generating response: {str(e)}"
+        return f"Error: {str(e)}"
 
 def build_model_from_config(config, X, y=None):
-    """Build a model from configuration dictionary"""
     problem_type = config.get("type", "classification")
-    
     if problem_type == "clustering":
-        model = KMeans(
-            n_clusters=config.get("n_clusters", 3),
-            init=config.get("init", "k-means++"),
-            n_init=config.get("n_init", 10),
-            random_state=42
-        )
-    else:
-        # Extract hidden layer sizes and activations
-        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"
-        
-        # Create appropriate model based on problem type
-        if problem_type == "classification":
-            model = MLPClassifier(
-                hidden_layer_sizes=layer_sizes,
-                activation=activation,
-                solver=config.get("optimizer", "adam"),
-                alpha=config.get("regularization", 0.0001),
-                learning_rate_init=config.get("learning_rate", 0.001),
-                max_iter=config.get("max_iter", 500),
-                random_state=42
-            )
-        else:  # regression
-            model = MLPRegressor(
-                hidden_layer_sizes=layer_sizes,
-                activation=activation,
-                solver=config.get("optimizer", "adam"),
-                alpha=config.get("regularization", 0.0001),
-                learning_rate_init=config.get("learning_rate", 0.001),
-                max_iter=config.get("max_iter", 500),
-                random_state=42
-            )
-    
-    return model
+        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)
+
+    with st.sidebar:
+        st.markdown('<div class="card"><h3>Data Input</h3></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!")
+
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        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)
+
+    with col2:
+        st.markdown('<div class="chat-container"><h3>Chat with Grok</h3></div>', unsafe_allow_html=True)
+        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)
+
+    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)
+
+if __name__ == "__main__":
+    main()