Update app.py

app.py

@@ -15,13 +15,13 @@ 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 Groq client
+# Initialize clients
 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
@@ -38,6 +38,8 @@ st.markdown("""
         --light-grey: #F3F4F6;
         --white: #FFFFFF;
         --border-grey: #E5E7EB;
+        --success-green: #10B981;
+        --warning-yellow: #F59E0B;
     }
     .stApp {
         background-color: var(--light-grey);
@@ -64,6 +66,20 @@ st.markdown("""
         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);
+        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;
@@ -95,6 +111,53 @@ st.markdown("""
         max-width: 80%;
         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);
+        color: white;
+        border-radius: 6px;
+        padding: 8px 16px;
+        border: none;
+        font-weight: 500;
+        transition: all 0.3s ease;
+    }
+    .stButton>button:hover {
+        background-color: var(--dark-blue);
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+    }
+    .status-bar {
+        height: 10px;
+        width: 100%;
+        background-color: var(--light-grey);
+        border-radius: 5px;
+        margin-top: 10px;
+        overflow: hidden;
+    }
+    .status-progress {
+        height: 100%;
+        background-color: var(--primary-blue);
+        transition: width 0.5s ease;
+    }
+    .feature-desc {
+        font-size: 0.9rem;
+        color: var(--medium-grey);
+        margin-top: 5px;
+    }
     </style>
 """, unsafe_allow_html=True)
 
@@ -105,9 +168,96 @@ 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"  # Options: "prebuilt" or "custom"
+if 'custom_model_type' not in st.session_state:
+    st.session_state.custom_model_type = "classification"  # Options: "classification", "regression", "clustering"
+
+# Prebuilt model templates
+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"
+    },
+    "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"
+    },
+    "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"
+    }
+}
 
 # Helper Functions
 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"
@@ -121,6 +271,7 @@ def convert_df_to_text(df):
     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
@@ -132,7 +283,8 @@ def create_vector_store(df_text):
     os.unlink(temp_path)
     return vector_store
 
-def get_groq_response(prompt, mode, use_web_search=False):
+def get_groq_response(prompt, mode, context_type="model_building", use_web_search=False):
+    """Get response from Groq LLM with different context types"""
     context = ""
     sources = []
 
@@ -145,29 +297,31 @@ def get_groq_response(prompt, mode, use_web_search=False):
     # Tavily web search if toggled
     if use_web_search:
         tavily_api_key = os.environ.get("TAVILY_API_KEY")
-        if not tavily_api_key:
-            return "Please provide a Tavily API key in the sidebar to enable web search."
-        try:
-            # Set the API key for Tavily explicitly
-            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."
-
-    # If no context is available
-    if not context:
-        context = "\n\nNo uploaded data available. I’ll provide a general response based on my knowledge."
+        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."
+        "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["Legal"]) + "\n" + context
+    system_prompt = prompts.get(mode, prompts["Technical"]) + "\n" + context
 
     try:
         response = client.chat.completions.create(
@@ -183,181 +337,43 @@ def get_groq_response(prompt, mode, use_web_search=False):
     except Exception as e:
         return f"Error generating response: {str(e)}"
 
-# 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 = {}
-        
-        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)
-
-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"])
+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":
-        target = st.selectbox("Select Target Variable", df.columns)
-        X = df.drop(columns=[target])
-        y = df[target]
+    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:
-        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!")
-
-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})
+        # 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"
         
-        with st.chat_message("assistant"):
-            st.markdown(f'<div class="bot-message">{response}</div>', unsafe_allow_html=True)
+        # 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
+            )
     
-    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**")
-    tavily_api_key = st.text_input("Tavily API Key", type="password", help="For web search functionality")
-    if tavily_api_key:
-        os.environ["TAVILY_API_KEY"] = tavily_api_key  # Set the API key dynamically
-    st.markdown("---")
-    st.markdown("v5.1 | © 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()
-
-ai_assistant()
+    return model