Update app.py

app.py

@@ -1,3 +1,296 @@
+import streamlit as st
+import tensorflow as tf
+from tensorflow import keras
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from sklearn.model_selection import train_test_split, GridSearchCV
+from sklearn.preprocessing import StandardScaler, LabelEncoder, OneHotEncoder
+from sklearn.decomposition import PCA, TruncatedSVD
+from sklearn.manifold import TSNE
+import umap.umap_ as umap
+import shap
+import joblib
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_curve, auc, mean_squared_error, mean_absolute_error, r2_score, classification_report, silhouette_score
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.cluster import KMeans, DBSCAN
+from sklearn.mixture import GaussianMixture
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.linear_model import LogisticRegression, LinearRegression
+from sklearn.svm import SVC, SVR
+from xgboost import XGBClassifier, XGBRegressor
+import matplotlib.pyplot as plt
+from io import BytesIO
+import time
+from PIL import Image
+import zipfile
+import os
+
+# Set page config
+st.set_page_config(page_title="Neural-Vision Enhanced", layout="wide")
+
+# Helper Functions for Image Processing
+def preprocess_image(image_path, target_size=(224, 224)):
+    """Preprocess an image by resizing and normalizing it."""
+    img = Image.open(image_path).convert("RGB")
+    img = img.resize(target_size)
+    img_array = np.array(img) / 255.0  # Normalize pixel values to [0, 1]
+    return img_array
+
+def load_image_dataset(zip_path, target_size=(224, 224), problem_type="Classification"):
+    """Load and preprocess an image dataset from a zip file."""
+    # Check file size (5GB = 5 * 1024 * 1024 * 1024 bytes)
+    file_size = os.path.getsize(zip_path) if isinstance(zip_path, str) else zip_path.size
+    max_size = 5 * 1024 * 1024 * 1024  # 5GB in bytes
+    if file_size > max_size:
+        raise ValueError(f"Uploaded file size ({file_size / (1024 * 1024):.2f} MB) exceeds the 5GB limit.")
+    
+    # Extract zip file to a temporary directory
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        zip_ref.extractall('temp_images')
+    
+    if problem_type == "Classification":
+        image_paths = []
+        labels = []
+        class_names = sorted(os.listdir('temp_images'))
+        for label, class_name in enumerate(class_names):
+            class_dir = os.path.join('temp_images', class_name)
+            if os.path.isdir(class_dir):
+                for img_name in os.listdir(class_dir):
+                    image_path = os.path.join(class_dir, img_name)
+                    if os.path.isfile(image_path):
+                        image_paths.append(image_path)
+                        labels.append(label)
+        images = [preprocess_image(path, target_size) for path in image_paths]
+        images = np.array(images)
+        labels = np.array(labels)
+        data = (images, labels, class_names)
+    else:  # Compression or Clustering
+        image_dir = 'temp_images'
+        image_paths = [os.path.join(image_dir, img_name) for img_name in os.listdir(image_dir) if os.path.isfile(os.path.join(image_dir, img_name))]
+        images = [preprocess_image(path, target_size) for path in image_paths]
+        images = np.array(images)
+        data = (images, None, None)
+    
+    # Clean up temporary directory
+    for root, dirs, files in os.walk('temp_images', topdown=False):
+        for name in files:
+            os.remove(os.path.join(root, name))
+        for name in dirs:
+            os.rmdir(os.path.join(root, name))
+    os.rmdir('temp_images')
+    
+    return data
+
+# Model Building Functions
+def get_model_config(model_type, problem_type):
+    configs = {
+        "Random Forest": {
+            "Regression": {"model_class": RandomForestRegressor, "params": {"n_estimators": 100, "random_state": 42},
+                           "grid_params": {"n_estimators": [50, 100, 200], "max_depth": [None, 10, 20]}},
+            "Binary Classification": {"model_class": RandomForestClassifier, "params": {"n_estimators": 100, "random_state": 42},
+                                     "grid_params": {"n_estimators": [50, 100, 200], "max_depth": [None, 10, 20]}},
+            "Multi-Class": {"model_class": RandomForestClassifier, "params": {"n_estimators": 100, "random_state": 42},
+                            "grid_params": {"n_estimators": [50, 100, 200], "max_depth": [None, 10, 20]}}
+        },
+        "XGBoost": {
+            "Regression": {"model_class": XGBRegressor, "params": {"n_estimators": 100, "random_state": 42},
+                           "grid_params": {"n_estimators": [50, 100, 200], "max_depth": [3, 5, 7], "learning_rate": [0.01, 0.1, 0.3]}},
+            "Binary Classification": {"model_class": XGBClassifier, "params": {"n_estimators": 100, "random_state": 42, "use_label_encoder": False, "eval_metric": 'logloss'},
+                                     "grid_params": {"n_estimators": [50, 100, 200], "max_depth": [3, 5, 7], "learning_rate": [0.01, 0.1, 0.3]}},
+            "Multi-Class": {"model_class": XGBClassifier, "params": {"n_estimators": 100, "random_state": 42, "use_label_encoder": False, "eval_metric": 'mlogloss'},
+                            "grid_params": {"n_estimators": [50, 100, 200], "max_depth": [3, 5, 7], "learning_rate": [0.01, 0.1, 0.3]}}
+        },
+        "Logistic Regression": {
+            "Binary Classification": {"model_class": LogisticRegression, "params": {"max_iter": 1000, "random_state": 42},
+                                     "grid_params": {"C": [0.1, 1.0, 10.0], "solver": ["lbfgs", "liblinear"]}}
+        },
+        "Linear Regression": {
+            "Regression": {"model_class": LinearRegression, "params": {}, "grid_params": {}}
+        },
+        "SVM": {
+            "Regression": {"model_class": SVR, "params": {"kernel": "rbf"}, "grid_params": {"C": [0.1, 1, 10], "gamma": ["scale", "auto"]}},
+            "Binary Classification": {"model_class": SVC, "params": {"kernel": "rbf", "random_state": 42}, "grid_params": {"C": [0.1, 1, 10], "gamma": ["scale", "auto"]}},
+            "Multi-Class": {"model_class": SVC, "params": {"kernel": "rbf", "random_state": 42}, "grid_params": {"C": [0.1, 1, 10], "gamma": ["scale", "auto"]}}
+        },
+        "K-Means": {
+            "Clustering": {"model_class": KMeans, "params": {"n_clusters": 3, "random_state": 42},
+                           "grid_params": {"n_clusters": [2, 3, 4, 5]}}
+        },
+        "DBSCAN": {
+            "Clustering": {"model_class": DBSCAN, "params": {"eps": 0.5, "min_samples": 5},
+                           "grid_params": {"eps": [0.3, 0.5, 0.7], "min_samples": [3, 5, 10]}}
+        },
+        "Gaussian Mixture": {
+            "Clustering": {"model_class": GaussianMixture, "params": {"n_components": 3, "random_state": 42},
+                           "grid_params": {"n_components": [2, 3, 4, 5]}}
+        }
+    }
+    return configs.get(model_type, {}).get(problem_type, {"model_class": None, "params": {}, "grid_params": {}})
+
+def preprocess_data(X_train, X_test, numerical_features, categorical_features):
+    numeric_transformer = Pipeline(steps=[
+        ('imputer', SimpleImputer(strategy='mean')),
+        ('scaler', StandardScaler())])
+    categorical_transformer = Pipeline(steps=[
+        ('imputer', SimpleImputer(strategy='most_frequent')),
+        ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))])
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ('num', numeric_transformer, numerical_features),
+            ('cat', categorical_transformer, categorical_features)],
+        remainder='drop')
+    X_train_processed = preprocessor.fit_transform(X_train)
+    X_test_processed = preprocessor.transform(X_test)
+    if categorical_features:
+        onehot_encoder = preprocessor.named_transformers_['cat'].named_steps['onehot']
+        categorical_feature_names = onehot_encoder.get_feature_names_out(categorical_features)
+        feature_names = numerical_features + list(categorical_feature_names)
+    else:
+        feature_names = numerical_features
+    return X_train_processed, X_test_processed, feature_names, preprocessor
+
+def build_neural_network(input_shape, output_units, problem_type, layers_config, optimizer_name="Adam", learning_rate=0.001):
+    model = keras.Sequential()
+    model.add(keras.layers.InputLayer(input_shape=input_shape))
+    for layer in layers_config:
+        if layer['type'] == 'dense':
+            model.add(keras.layers.Dense(layer['units'], activation=layer['activation']))
+        elif layer['type'] == 'dropout':
+            model.add(keras.layers.Dropout(layer['rate']))
+        elif layer['type'] == 'conv2d':
+            model.add(keras.layers.Conv2D(layer['filters'], tuple(layer['kernel_size']), activation=layer['activation'], padding='same'))
+        elif layer['type'] == 'maxpooling2d':
+            model.add(keras.layers.MaxPooling2D(pool_size=tuple(layer['pool_size'])))
+        elif layer['type'] == 'flatten':
+            model.add(keras.layers.Flatten())
+    if problem_type == "Regression":
+        model.add(keras.layers.Dense(1))
+        loss_function = "mse"
+        metrics = ["mse"]
+    elif problem_type == "Binary Classification":
+        model.add(keras.layers.Dense(1, activation='sigmoid'))
+        loss_function = "binary_crossentropy"
+        metrics = ["accuracy"]
+    elif problem_type == "Multi-Class" or problem_type == "Image Classification":
+        model.add(keras.layers.Dense(output_units, activation='softmax'))
+        loss_function = "sparse_categorical_crossentropy" if problem_type == "Image Classification" else "categorical_crossentropy"
+        metrics = ["accuracy"]
+    else:
+        raise ValueError("Unsupported problem type")
+    optimizer = {"Adam": keras.optimizers.Adam, "SGD": keras.optimizers.SGD, "RMSprop": keras.optimizers.RMSprop}.get(optimizer_name)(learning_rate=learning_rate)
+    model.compile(optimizer=optimizer, loss=loss_function, metrics=metrics)
+    return model
+
+def build_autoencoder(input_shape, encoding_dim, layers_config, autoencoder_type="Standard", optimizer_name="Adam", learning_rate=0.001):
+    if autoencoder_type == "Variational":
+        inputs = keras.layers.Input(shape=input_shape)
+        x = keras.layers.Flatten()(inputs) if len(input_shape) > 1 else inputs
+        for layer in layers_config:
+            if layer['type'] == 'dense':
+                x = keras.layers.Dense(layer['units'], activation=layer['activation'])(x)
+        z_mean = keras.layers.Dense(encoding_dim, name='z_mean')(x)
+        z_log_var = keras.layers.Dense(encoding_dim, name='z_log_var')(x)
+        
+        def sampling(args):
+            z_mean, z_log_var = args
+            epsilon = keras.backend.random_normal(shape=(keras.backend.shape(z_mean)[0], encoding_dim))
+            return z_mean + keras.backend.exp(0.5 * z_log_var) * epsilon
+        
+        z = keras.layers.Lambda(sampling, name='z')([z_mean, z_log_var])
+        encoder = keras.Model(inputs, [z_mean, z_log_var, z], name='encoder')
+        
+        decoder_input = keras.layers.Input(shape=(encoding_dim,))
+        x = decoder_input
+        for layer in reversed(layers_config):
+            if layer['type'] == 'dense':
+                x = keras.layers.Dense(layer['units'], activation=layer['activation'])(x)
+        x = keras.layers.Dense(np.prod(input_shape), activation='sigmoid')(x)
+        outputs = keras.layers.Reshape(input_shape)(x) if len(input_shape) > 1 else x
+        decoder = keras.Model(decoder_input, outputs, name='decoder')
+        
+        vae_outputs = decoder(encoder(inputs)[2])
+        autoencoder = keras.Model(inputs, vae_outputs, name='vae')
+        
+        reconstruction_loss = keras.losses.binary_crossentropy(keras.backend.flatten(inputs), keras.backend.flatten(vae_outputs))
+        reconstruction_loss *= np.prod(input_shape)
+        kl_loss = 1 + z_log_var - keras.backend.square(z_mean) - keras.backend.exp(z_log_var)
+        kl_loss = keras.backend.sum(kl_loss, axis=-1) * -0.5
+        vae_loss = keras.backend.mean(reconstruction_loss + kl_loss)
+        autoencoder.add_loss(vae_loss)
+    else:  # Standard or Denoising
+        encoder = keras.Sequential([keras.layers.InputLayer(input_shape=input_shape)])
+        for layer in layers_config:
+            if layer['type'] == 'dense':
+                encoder.add(keras.layers.Dense(layer['units'], activation=layer['activation']))
+            elif layer['type'] == 'dropout':
+                encoder.add(keras.layers.Dropout(layer['rate']))
+        encoder.add(keras.layers.Dense(encoding_dim, activation='relu', name='encoded'))
+        
+        decoder = keras.Sequential([keras.layers.InputLayer(input_shape=(encoding_dim,))])
+        for layer in reversed(layers_config):
+            if layer['type'] == 'dense':
+                decoder.add(keras.layers.Dense(layer['units'], activation=layer['activation']))
+        decoder.add(keras.layers.Dense(np.prod(input_shape), activation='sigmoid'))
+        decoder.add(keras.layers.Reshape(input_shape) if len(input_shape) > 1 else keras.layers.Lambda(lambda x: x))
+        
+        autoencoder_input = keras.layers.Input(shape=input_shape)
+        encoded = encoder(autoencoder_input)
+        decoded = decoder(encoded)
+        autoencoder = keras.Model(autoencoder_input, decoded)
+    
+    optimizer = {"Adam": keras.optimizers.Adam, "SGD": keras.optimizers.SGD, "RMSprop": keras.optimizers.RMSprop}.get(optimizer_name)(learning_rate=learning_rate)
+    autoencoder.compile(optimizer=optimizer, loss='mse', metrics=['mse'])
+    return autoencoder, encoder, decoder
+
+class StreamlitCallback(keras.callbacks.Callback):
+    def __init__(self, placeholder):
+        super().__init__()
+        self.placeholder = placeholder
+        self.epoch_data = []
+
+    def on_epoch_end(self, epoch, logs=None):
+        # Append the logs for the current epoch
+        self.epoch_data.append(logs)
+        
+        # Create a DataFrame from the logs
+        df = pd.DataFrame(self.epoch_data)
+        
+        # Create the Plotly figure
+        fig = go.Figure()
+        
+        # Add training loss trace
+        fig.add_trace(go.Scatter(
+            x=df.index, y=df['loss'], mode='lines', name='Training Loss'
+        ))
+        
+        # Add validation loss trace (if available)
+        if 'val_loss' in df.columns:
+            fig.add_trace(go.Scatter(
+                x=df.index, y=df['val_loss'], mode='lines', name='Validation Loss'
+            ))
+        
+        # Add metric trace (e.g., accuracy or MSE)
+        metric_name = 'accuracy' if 'accuracy' in df.columns else 'mse'
+        if metric_name in df.columns:
+            fig.add_trace(go.Scatter(
+                x=df.index, y=df[metric_name], mode='lines', name=metric_name.capitalize()
+            ))
+        
+        # Update the layout
+        fig.update_layout(
+            title="Training Progress",
+            xaxis_title="Epoch",
+            yaxis_title="Value",
+            legend_title="Metrics"
+        )
+        
+        # Update the placeholder with the new figure
+        self.placeholder.plotly_chart(fig, use_container_width=True)
+
 def train_model(model, X_train, y_train, X_test, y_test, epochs, batch_size, problem_type, input_data=None, target_data=None, do_grid_search=False, params=None, grid_params=None, training_placeholder=None):
     """Train the model and optionally display live training progress for Keras models."""
     start_time = time.time()
@@ -37,7 +330,235 @@ def train_model(model, X_train, y_train, X_test, y_test, epochs, batch_size, pro
     training_time = time.time() - start_time
     return history, model, training_time
 
-# In the "Model Training" section, update the training block:
+def evaluate_model(model, X_test, y_test, problem_type, le=None, encoder=None):
+    y_pred = model.predict(X_test)
+    metrics = {}
+    if problem_type == "Regression":
+        metrics['mse'] = mean_squared_error(y_test, y_pred)
+        metrics['mae'] = mean_absolute_error(y_test, y_pred)
+        metrics['rmse'] = np.sqrt(metrics['mse'])
+        metrics['r2'] = r2_score(y_test, y_pred)
+        return metrics, y_pred.flatten()
+    elif problem_type in ["Binary Classification", "Multi-Class", "Image Classification"]:
+        if problem_type == "Image Classification":
+            y_pred_classes = np.argmax(y_pred, axis=1)
+            y_test_classes = y_test
+        else:
+            y_pred_classes = (y_pred > 0.5).astype(int).flatten() if problem_type == "Binary Classification" else np.argmax(y_pred, axis=1)
+            y_test_classes = y_test if problem_type == "Binary Classification" else np.argmax(y_test, axis=1)
+        metrics['accuracy'] = accuracy_score(y_test_classes, y_pred_classes)
+        metrics['precision'] = precision_score(y_test_classes, y_pred_classes, average='weighted', zero_division=0)
+        metrics['recall'] = recall_score(y_test_classes, y_pred_classes, average='weighted', zero_division=0)
+        metrics['f1'] = f1_score(y_test_classes, y_pred_classes, average='weighted', zero_division=0)
+        return metrics, y_pred_classes
+    elif problem_type == "Clustering":
+        labels = model.labels_ if hasattr(model, 'labels_') else model.predict(X_test)
+        metrics["n_clusters"] = len(np.unique(labels))
+        if len(np.unique(labels)) > 1:
+            metrics["silhouette"] = silhouette_score(X_test, labels)
+        return metrics, labels
+    elif problem_type == "Compression":
+        metrics['mse'] = mean_squared_error(X_test, y_pred)
+        metrics['mae'] = mean_absolute_error(X_test, y_pred)
+        metrics['rmse'] = np.sqrt(metrics['mse'])
+        compressed_data = encoder.predict(X_test) if encoder else None
+        return metrics, y_pred, compressed_data
+
+def save_model(model, preprocessor, features, target, problem_type, filename="model.pkl"):
+    model_data = {
+        'model': model,
+        'preprocessor': preprocessor,
+        'features': features,
+        'target': target,
+        'problem_type': problem_type,
+        'timestamp': time.strftime("%Y%m%d_%H%M%S")
+    }
+    if isinstance(model, keras.Model):
+        model.save("temp_model.h5")
+        model_data['model_path'] = "temp_model.h5"
+    joblib.dump(model_data, filename)
+    return filename
+
+def load_model(model_file):
+    model_data = joblib.load(model_file)
+    if 'model_path' in model_data:
+        model_data['model'] = keras.models.load_model(model_data['model_path'])
+    return model_data
+
+# Sidebar Navigation
+with st.sidebar:
+    st.title("🔮 Neural-Vision Enhanced")
+    st.markdown("Your AI-powered model toolbox.")
+    st.markdown("---")
+    app_mode = st.selectbox("Navigation", ["Data Upload", "Model Training", "Validation & Exploration"])
+    data_type = st.selectbox("Data Type", ["Tabular", "Image"])
+    st.markdown("---")
+    st.markdown("**Dependencies**: `tensorflow`, `shap`, `umap-learn`, `joblib`, `scikit-learn`, `plotly`, `xgboost`, `pillow`")
+    st.markdown("Created by Calvin Allen-Crawford | v1.3 | © 2025")
+
+# Main App Sections
+if app_mode == "Data Upload":
+    st.title("📤 Data Upload")
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        if data_type == "Tabular":
+            uploaded_file = st.file_uploader("Upload CSV Dataset", type=["csv"])
+            if uploaded_file:
+                df = pd.read_csv(uploaded_file)
+                st.session_state.df = df
+                st.write("---")
+                st.subheader("Dataset Preview")
+                st.dataframe(df.head(10))
+                st.write("---")
+                st.subheader("Statistics")
+                col1, col2, col3 = st.columns(3)
+                with col1: st.metric("Rows", df.shape[0])
+                with col2: st.metric("Columns", df.shape[1])
+                with col3: st.metric("Missing Values", df.isna().sum().sum())
+        else:  # Image
+            uploaded_file = st.file_uploader("Upload Zip File with Images (Max 5GB)", type=["zip"])
+            if uploaded_file:
+                # Save uploaded file temporarily to check size
+                with open("temp_upload.zip", "wb") as f:
+                    f.write(uploaded_file.getbuffer())
+                try:
+                    problem_type = st.selectbox("Problem Type for Image Data", ["Image Classification", "Compression", "Clustering"])
+                    images, labels, class_names = load_image_dataset("temp_upload.zip", problem_type=problem_type)
+                    st.session_state.images = images
+                    st.session_state.labels = labels
+                    st.session_state.class_names = class_names if problem_type == "Image Classification" else None
+                    st.write(f"Loaded {len(images)} images.")
+                    if problem_type == "Image Classification":
+                        st.write(f"Classes: {class_names}")
+                    st.image(images[:5], caption=["Sample " + str(i+1) for i in range(min(5, len(images)))], width=100)
+                except ValueError as e:
+                    st.error(str(e))
+                finally:
+                    os.remove("temp_upload.zip")
+
+elif app_mode == "Model Training":
+    st.title("🧠 Model Training")
+    if data_type == "Tabular" and 'df' not in st.session_state:
+        st.warning("Please upload a tabular dataset first.")
+        st.stop()
+    elif data_type == "Image" and 'images' not in st.session_state:
+        st.warning("Please upload an image dataset first.")
+        st.stop()
+
+    if data_type == "Tabular":
+        df = st.session_state.df
+        problem_type = st.selectbox("Problem Type", ["Regression", "Binary Classification", "Multi-Class", "Clustering", "Compression"])
+        features = st.multiselect("Select Features", df.columns)
+        target = st.selectbox("Select Target", df.columns) if problem_type not in ["Clustering", "Compression"] else None
+    else:
+        problem_type = st.selectbox("Problem Type", ["Image Classification", "Compression", "Clustering"])
+        features = ["images"]
+        target = "labels" if problem_type == "Image Classification" else None
+
+    if problem_type not in ["Clustering", "Compression"] and data_type == "Tabular" and target:
+        unique_target_values = df[target].nunique()
+        if problem_type == "Binary Classification" and unique_target_values != 2:
+            st.error("Binary Classification requires exactly 2 unique target values.")
+            st.stop()
+        elif problem_type == "Multi-Class" and unique_target_values < 2:
+            st.error("Multi-Class Classification requires at least 2 unique target values.")
+            st.stop()
+        elif problem_type == "Regression" and not pd.api.types.is_numeric_dtype(df[target]):
+            st.error("Regression requires a numerical target variable.")
+            st.stop()
+
+    model_types = {
+        "Regression": ["Neural Network", "Random Forest", "XGBoost", "Linear Regression", "SVM"],
+        "Binary Classification": ["Neural Network", "Random Forest", "XGBoost", "Logistic Regression", "SVM"],
+        "Multi-Class": ["Neural Network", "Random Forest", "XGBoost", "SVM"],
+        "Clustering": ["K-Means", "DBSCAN", "Gaussian Mixture"],
+        "Compression": ["Autoencoder"],
+        "Image Classification": ["Neural Network", "SVM"]
+    }[problem_type]
+    model_type = st.selectbox("Model Type", model_types)
+
+    if model_type == "Neural Network":
+        st.subheader("Neural Network Configuration")
+        optimizer_name = st.selectbox("Optimizer", ["Adam", "SGD", "RMSprop"])
+        layers_config = st.session_state.get('layers_config', [])
+        layer_type = st.selectbox("Layer Type", ["Dense", "Dropout"] if data_type == "Tabular" else ["Conv2D", "MaxPooling2D", "Flatten", "Dense", "Dropout"])
+        if layer_type == "Dense":
+            units = st.number_input("Units", min_value=1, value=64)
+            activation = st.selectbox("Activation", ["relu", "sigmoid", "tanh"])
+            if st.button("Add Layer"):
+                layers_config.append({"type": "dense", "units": units, "activation": activation})
+        elif layer_type == "Dropout":
+            rate = st.number_input("Dropout Rate", 0.0, 1.0, 0.2)
+            if st.button("Add Layer"):
+                layers_config.append({"type": "dropout", "rate": rate})
+        elif layer_type == "Conv2D":
+            filters = st.number_input("Filters", min_value=1, value=32)
+            kernel_size = st.multiselect("Kernel Size", options=[1, 3, 5], default=[3])
+            activation = st.selectbox("Activation", ["relu", "sigmoid", "tanh"])
+            if st.button("Add Layer"):
+                layers_config.append({"type": "conv2d", "filters": filters, "kernel_size": kernel_size, "activation": activation})
+        elif layer_type == "MaxPooling2D":
+            pool_size = st.multiselect("Pool Size", options=[2, 3], default=[2])
+            if st.button("Add Layer"):
+                layers_config.append({"type": "maxpooling2d", "pool_size": pool_size})
+        elif layer_type == "Flatten":
+            if st.button("Add Layer"):
+                layers_config.append({"type": "flatten"})
+        if layers_config:
+            st.write("Current Layers:", layers_config)
+            if st.button("Clear Layers"):
+                layers_config.clear()
+                st.session_state.layers_config = layers_config
+                st.rerun()
+        st.session_state.layers_config = layers_config
+    elif model_type == "Autoencoder":
+        st.subheader("Autoencoder Configuration")
+        encoding_dim = st.number_input("Encoding Dimension", min_value=1, value=32)
+        optimizer_name = st.selectbox("Optimizer", ["Adam", "SGD", "RMSprop"])
+        autoencoder_type = st.selectbox("Autoencoder Type", ["Standard", "Variational", "Denoising"])
+        if autoencoder_type == "Denoising":
+            noise_level = st.slider("Noise Level", 0.0, 1.0, 0.1)
+        layers_config = st.session_state.get('layers_config', [])
+        layer_type = st.selectbox("Layer Type (Encoder)", ["Dense", "Dropout"])
+        if layer_type == "Dense":
+            units = st.number_input("Units", min_value=1, value=64)
+            activation = st.selectbox("Activation", ["relu", "sigmoid", "tanh"])
+            if st.button("Add Layer"):
+                layers_config.append({"type": "dense", "units": units, "activation": activation})
+        elif layer_type == "Dropout":
+            rate = st.number_input("Dropout Rate", 0.0, 1.0, 0.2)
+            if st.button("Add Layer"):
+                layers_config.append({"type": "dropout", "rate": rate})
+        if layers_config:
+            st.write("Current Encoder Layers:", layers_config)
+            if st.button("Clear Layers"):
+                layers_config.clear()
+                st.session_state.layers_config = layers_config
+                st.rerun()
+        st.session_state.layers_config = layers_config
+    else:
+        st.subheader("Model Hyperparameters")
+        config = get_model_config(model_type, problem_type)
+        params = {}
+        for param_name, param_values in config["grid_params"].items():
+            if isinstance(param_values[0], (int, float)) and len(param_values) > 2:
+                slider_value = st.slider(param_name, min_value=float(min(param_values)), max_value=float(max(param_values)), value=float(param_values[1]))
+                if param_name in {'n_estimators', 'n_clusters', 'min_samples', 'n_components', 'max_depth'}:
+                    params[param_name] = int(slider_value)
+                else:
+                    params[param_name] = slider_value
+            else:
+                params[param_name] = st.selectbox(param_name, param_values)
+        do_grid_search = st.checkbox("Use Grid Search for Tuning", value=False)
+
+    col1, col2, col3 = st.columns(3)
+    with col1: epochs = st.number_input("Epochs", min_value=1, value=10) if model_type in ["Neural Network", "Autoencoder"] else 10
+    with col2: batch_size = st.number_input("Batch Size", min_value=1, value=32) if model_type in ["Neural Network", "Autoencoder"] else 32
+    with col3: learning_rate = st.number_input("Learning Rate", min_value=0.0, value=0.001, step=0.0001) if model_type in ["Neural Network", "Autoencoder"] else 0.001
+
+    uploaded_model = st.file_uploader("Upload Pre-trained Model (.h5)", type=["h5"]) if model_type in ["Neural Network", "Autoencoder"] else None
+    base_model = keras.models.load_model(uploaded_model) if uploaded_model else None
+
 if st.button("Train Model"):
     with st.spinner("Preparing data..."):
         if data_type == "Tabular":
@@ -139,4 +660,162 @@ if st.button("Train Model"):
         filename = save_model(model, preprocessor, features, target, problem_type)
         with open(filename, 'rb') as f:
             st.download_button("Download Model", f, file_name=filename)
-        st.success(f"Model trained in {training_time:.2f}s and saved!")
+        st.success(f"Model trained in {training_time:.2f}s and saved!")
+
+elif app_mode == "Validation & Exploration":
+    st.title("🔍 Validation & Exploration")
+    if data_type == "Tabular" and ('model' not in st.session_state or 'df' not in st.session_state):
+        st.warning("Please upload a tabular dataset and train a model first.")
+        st.stop()
+    elif data_type == "Image" and ('model' not in st.session_state or 'images' not in st.session_state):
+        st.warning("Please upload an image dataset and train a model first.")
+        st.stop()
+
+    if data_type == "Tabular":
+        df = st.session_state.df
+        X = df[st.session_state.features]
+        y = df[st.session_state.target] if st.session_state.problem_type not in ["Clustering", "Compression"] else None
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) if st.session_state.problem_type not in ["Clustering", "Compression"] else (X, X.copy(), None, None)
+        numerical_features = X.select_dtypes(include=np.number).columns.tolist()
+        categorical_features = X.select_dtypes(exclude=np.number).columns.tolist()
+        X_train_processed, X_test_processed, feature_names, _ = preprocess_data(X_train, X_test, numerical_features, categorical_features)
+        if st.session_state.problem_type in ["Binary Classification", "Multi-Class"] and y is not None:
+            y_train = st.session_state.le.transform(y_train) if st.session_state.le else y_train
+            y_test = st.session_state.le.transform(y_test) if st.session_state.le else y_test
+            if st.session_state.problem_type == "Multi-Class":
+                y_train = tf.keras.utils.to_categorical(y_train)
+                y_test = tf.keras.utils.to_categorical(y_test)
+    else:
+        X_train, X_test, y_train, y_test = train_test_split(st.session_state.images, st.session_state.labels, test_size=0.2, random_state=42) if st.session_state.problem_type == "Image Classification" else (st.session_state.images, st.session_state.images.copy(), None, None)
+        X_train_processed, X_test_processed = X_train, X_test
+        feature_names = ["image_features"]
+        if st.session_state.problem_type == "Image Classification":
+            le = None
+
+    model = st.session_state.model
+    problem_type = st.session_state.problem_type
+    encoder = st.session_state.get('encoder', None)
+
+    # Validation
+    st.subheader("Model Validation")
+    if problem_type == "Compression":
+        metrics, y_pred, compressed_data = evaluate_model(model, X_test_processed, None, problem_type, None, encoder)
+    else:
+        metrics, y_pred = evaluate_model(model, X_test_processed, y_test, problem_type, st.session_state.le if data_type == "Tabular" else None)
+
+    col1, col2 = st.columns(2)
+    with col1:
+        for metric, value in metrics.items():
+            st.metric(metric, f"{value:.4f}" if isinstance(value, float) else value)
+    with col2:
+        if problem_type == "Regression":
+            fig = px.scatter(x=y_test, y=y_pred, labels={"x": "Actual", "y": "Predicted"}, title="Predicted vs Actual")
+            st.plotly_chart(fig)
+        elif problem_type in ["Binary Classification", "Image Classification"]:
+            if problem_type == "Binary Classification":
+                y_pred_proba = model.predict_proba(X_test_processed)[:, 1] if hasattr(model, 'predict_proba') else y_pred
+                fpr, tpr, _ = roc_curve(y_test, y_pred_proba)
+                roc_auc = auc(fpr, tpr)
+                fig = px.area(x=fpr, y=tpr, title=f"ROC Curve (AUC = {roc_auc:.2f})", labels={"x": "False Positive Rate", "y": "True Positive Rate"})
+                st.plotly_chart(fig)
+            else:
+                cm = np.zeros((len(st.session_state.class_names), len(st.session_state.class_names)))
+                for i, j in zip(y_test, y_pred):
+                    cm[i, j] += 1
+                fig = px.imshow(cm, title="Confusion Matrix", labels={"x": "Predicted", "y": "Actual"})
+                st.plotly_chart(fig)
+                report = classification_report(y_test, y_pred, target_names=st.session_state.class_names, zero_division=0)
+                st.text("Classification Report:\n" + report)
+        elif problem_type == "Multi-Class":
+            y_pred_classes = np.argmax(model.predict(X_test_processed), axis=1)
+            y_test_classes = np.argmax(y_test, axis=1)
+            cm = np.zeros((y_train.shape[1], y_train.shape[1]))
+            for i, j in zip(y_test_classes, y_pred_classes):
+                cm[i, j] += 1
+            fig = px.imshow(cm, title="Confusion Matrix", labels={"x": "Predicted", "y": "Actual"})
+            st.plotly_chart(fig)
+            report = classification_report(y_test_classes, y_pred_classes, target_names=st.session_state.le.classes_ if st.session_state.le else [str(i) for i in range(y_train.shape[1])], zero_division=0)
+            st.text("Classification Report:\n" + report)
+        elif problem_type == "Clustering":
+            labels = y_pred
+            fig = px.scatter(x=X_test_processed[:, 0] if X_test_processed.shape[-1] == 1 else X_test_processed.reshape(X_test_processed.shape[0], -1)[:, 0], 
+                            y=X_test_processed[:, 1] if X_test_processed.shape[-1] == 1 else X_test_processed.reshape(X_test_processed.shape[0], -1)[:, 1], 
+                            color=labels, title="Cluster Visualization")
+            st.plotly_chart(fig)
+        elif problem_type == "Compression":
+            st.image([X_test_processed[0], y_pred[0]], caption=["Original", "Reconstructed"], width=200) if data_type == "Image" else None
+            fig = px.scatter(x=X_test_processed.flatten()[:1000], y=y_pred.flatten()[:1000], labels={"x": "Original", "y": "Reconstructed"}, title="Original vs Reconstructed (First 1000 Values)")
+            st.plotly_chart(fig)
+
+    # Dimensionality Reduction
+    st.subheader("Dimensionality Reduction")
+    methods = ["PCA", "SVD", "t-SNE", "UMAP"]
+    if problem_type == "Compression" and 'encoder' in st.session_state:
+        methods.append("Autoencoder")
+    method = st.selectbox("Method", methods)
+    n_components = st.slider("Components", 2, min(10 if data_type == "Tabular" else X_train_processed.shape[1], 10), 2)
+
+    if method == "Autoencoder" and 'encoder' in st.session_state:
+        X_reduced = st.session_state.encoder.predict(X_train_processed)
+        if X_reduced.shape[1] < n_components:
+            st.warning(f"Autoencoder encoding dimension is {X_reduced.shape[1]}, using that instead of {n_components}.")
+            n_components = X_reduced.shape[1]
+    else:
+        X_flat = X_train_processed if data_type == "Tabular" else X_train_processed.reshape(X_train_processed.shape[0], -1)
+        if method == "PCA":
+            reducer = PCA(n_components=n_components)
+            X_reduced = reducer.fit_transform(X_flat)
+            fig = px.bar(x=range(n_components), y=reducer.explained_variance_ratio_, title="Explained Variance Ratio")
+            st.plotly_chart(fig)
+        elif method == "SVD":
+            reducer = TruncatedSVD(n_components=n_components)
+            X_reduced = reducer.fit_transform(X_flat)
+            fig = px.bar(x=range(n_components), y=reducer.explained_variance_ratio_, title="Explained Variance Ratio")
+            st.plotly_chart(fig)
+        elif method == "t-SNE":
+            with st.spinner("Running t-SNE..."):
+                X_reduced = TSNE(n_components=n_components, random_state=42).fit_transform(X_flat)
+        elif method == "UMAP":
+            with st.spinner("Running UMAP..."):
+                X_reduced = umap.UMAP(n_components=n_components, random_state=42).fit_transform(X_flat)
+
+    if n_components >= 2:
+        if n_components == 2:
+            fig = px.scatter(x=X_reduced[:, 0], y=X_reduced[:, 1], color=y_train if problem_type not in ["Clustering", "Compression"] else y_pred,
+                            title=f"{method} Visualization")
+        elif n_components == 3:
+            fig = px.scatter_3d(x=X_reduced[:, 0], y=X_reduced[:, 1], z=X_reduced[:, 2], color=y_train if problem_type not in ["Clustering", "Compression"] else y_pred,
+                               title=f"{method} Visualization")
+        st.plotly_chart(fig)
+
+    # Interpretability
+    if problem_type not in ["Compression", "Clustering"]:
+        st.subheader("Interpretability")
+        try:
+            X_flat = X_test_processed if data_type == "Tabular" else X_test_processed.reshape(X_test_processed.shape[0], -1)
+            if isinstance(model, keras.Model):
+                explainer = shap.DeepExplainer(model, X_train_processed[:50] if data_type == "Tabular" else X_train_processed[:50])
+                shap_values = explainer.shap_values(X_flat[:50])
+            else:
+                explainer = shap.Explainer(model, X_flat)
+                shap_values = explainer.shap_values(X_flat[:50])
+            if problem_type == "Regression":
+                shap_fig, ax = plt.subplots()
+                shap.summary_plot(shap_values, X_flat[:50], feature_names=feature_names, show=False)
+                st.pyplot(shap_fig)
+            elif problem_type in ["Binary Classification", "Multi-Class", "Image Classification"]:
+                class_names = st.session_state.le.classes_ if st.session_state.le and data_type == "Tabular" else st.session_state.class_names if problem_type == "Image Classification" else [str(i) for i in range(y_train.shape[1])]
+                for i in range(min(len(class_names), len(shap_values))):
+                    shap_fig, ax = plt.subplots()
+                    shap.summary_plot(shap_values[i] if isinstance(shap_values, list) else shap_values, X_flat[:50], feature_names=feature_names, class_names=class_names, show=False)
+                    st.pyplot(shap_fig)
+        except Exception as e:
+            st.error(f"Error generating SHAP plot: {e}")
+
+# Custom CSS
+st.markdown("""
+    <style>
+    .stButton>button {background-color: #4CAF50; color: white;}
+    h1, h2 {color: #1e3a8a;}
+    </style>
+""", unsafe_allow_html=True)