Update app.py

app.py

@@ -1,3 +1,128 @@
+# import streamlit as st
+# import numpy as np
+# import matplotlib.pyplot as plt
+
+# from tensorflow.keras.models import Sequential
+# from tensorflow.keras.layers import Dense, Input, Dropout
+# from tensorflow.keras.optimizers import Adam
+# from tensorflow.keras.callbacks import EarlyStopping
+
+# from sklearn.datasets import make_moons, make_circles, make_blobs
+# from sklearn.model_selection import train_test_split
+# from sklearn.preprocessing import StandardScaler
+
+# # Sidebar - Dataset and Hyperparameters
+# st.sidebar.title("🔧 Model Configuration")
+
+# with st.sidebar.expander("🧠 Dataset Settings"):
+#     dataset = st.radio("Choose Dataset", ['Moons', 'Circles', 'Blobs'])
+#     noise = st.slider("Noise Level", 0.0, 0.2, 0.1)
+#     n_samples = st.slider("Number of Samples", 100, 1000, 300, step=50)
+
+# with st.sidebar.expander("⚙️ Hyperparameters"):
+#     activation = st.selectbox("Activation Function", ['relu', 'sigmoid', 'tanh', 'elu'])
+#     lr = st.slider("Learning Rate", 0.001, 0.1, 0.01)
+#     split = st.slider("Train-Test Split", 0.1, 0.9, 0.2)
+#     batch = st.select_slider("Batch Size", options=list(range(8, 129, 8)), value=32)
+#     epochs = st.slider("Epochs", 10, 200, 50)
+#     num_neurons = st.slider("Neurons per Hidden Layer", 1, 100, 16)
+#     hidden_layers = st.slider("Number of Hidden Layers", 1, 5, 2)
+
+# # Model selection radio
+# model_choice = st.radio(
+#     "🛠 Choose Model Variation",
+#     ["Base Model", "EarlyStopping", "Dropout"]
+# )
+
+# dropout_rate = 0.3  # fixed dropout rate
+
+# # Dataset generation
+# if dataset == "Moons":
+#     x, y = make_moons(n_samples=n_samples, noise=noise, random_state=42)
+# elif dataset == "Circles":
+#     x, y = make_circles(n_samples=n_samples, noise=noise, random_state=42)
+# else:
+#     x, y = make_blobs(n_samples=n_samples, centers=2, cluster_std=1.5, random_state=42)
+
+# scaler = StandardScaler()
+# x = scaler.fit_transform(x)
+
+# x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=split, random_state=27)
+
+# # Build model
+# def build_model(use_dropout=False):
+#     model = Sequential()
+#     model.add(Input(shape=(2,)))
+#     for _ in range(hidden_layers):
+#         model.add(Dense(units=num_neurons, activation=activation))
+#         if use_dropout:
+#             model.add(Dropout(dropout_rate))
+#     model.add(Dense(1, activation="sigmoid"))
+#     model.compile(optimizer=Adam(learning_rate=lr), loss='binary_crossentropy', metrics=['accuracy'])
+#     return model
+
+# # Callback
+# callbacks = [EarlyStopping(patience=10, restore_best_weights=True)] if model_choice == "EarlyStopping" else []
+
+# # Choose dropout condition
+# use_dropout = model_choice == "Dropout"
+
+# # Train model
+# model = build_model(use_dropout=use_dropout)
+# history = model.fit(x_train, y_train,
+#                     validation_data=(x_test, y_test),
+#                     batch_size=batch,
+#                     epochs=epochs,
+#                     callbacks=callbacks,
+#                     verbose=0)
+
+# test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
+
+# # Plot decision boundary
+# def plot_decision_boundary(model, title):
+#     x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
+#     y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
+#     xx, yy = np.meshgrid(np.linspace(x_min, x_max, 300),
+#                          np.linspace(y_min, y_max, 300))
+#     grid = np.c_[xx.ravel(), yy.ravel()]
+#     preds = model.predict(grid, verbose=0).reshape(xx.shape)
+
+#     fig, ax = plt.subplots(figsize=(7, 6))
+#     ax.contourf(xx, yy, preds, cmap='RdBu', alpha=0.6)
+#     ax.scatter(x[:, 0], x[:, 1], c=y, cmap='RdBu', edgecolors='k', s=25)
+#     ax.set_title(title)
+#     ax.set_xlabel("Feature 1")
+#     ax.set_ylabel("Feature 2")
+#     return fig
+
+# # Plot training loss
+# def plot_loss_curve(history, title):
+#     fig, ax = plt.subplots(figsize=(7, 4))
+#     ax.plot(history.history['loss'], label='Train Loss')
+#     ax.plot(history.history['val_loss'], label='Val Loss')
+#     ax.set_title(title)
+#     ax.set_xlabel("Epoch")
+#     ax.set_ylabel("Loss")
+#     ax.legend()
+#     return fig
+
+# # Main UI
+# st.title("🧪 Neural Network Regularization Explorer")
+# st.markdown(f"### Currently Selected: **{model_choice}**")
+
+# st.success(f"**Test Accuracy:** {test_acc:.4f}")
+# st.info(f"**Test Loss:** {test_loss:.4f}")
+
+# # Plot dropdown
+# plot_type = st.selectbox("📊 Select Plot to View", ["Decision Boundary", "Loss Curve"])
+
+# if plot_type == "Decision Boundary":
+#     st.pyplot(plot_decision_boundary(model, f"{model_choice} Decision Boundary"))
+# else:
+#     st.pyplot(plot_loss_curve(history, f"{model_choice} Loss Curve"))
+
+
+
 import streamlit as st
 import numpy as np
 import matplotlib.pyplot as plt
@@ -11,75 +136,51 @@ from sklearn.datasets import make_moons, make_circles, make_blobs
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
 
-# Sidebar - Dataset and Hyperparameters
-st.sidebar.title("🔧 Model Configuration")
+# Caching utility
+@st.cache_resource
+def train_models(params):
+    models_data = {}
 
-with st.sidebar.expander("🧠 Dataset Settings"):
-    dataset = st.radio("Choose Dataset", ['Moons', 'Circles', 'Blobs'])
-    noise = st.slider("Noise Level", 0.0, 0.2, 0.1)
-    n_samples = st.slider("Number of Samples", 100, 1000, 300, step=50)
+    def build_model(use_dropout=False):
+        model = Sequential()
+        model.add(Input(shape=(2,)))
+        for _ in range(params['hidden_layers']):
+            model.add(Dense(params['num_neurons'], activation=params['activation']))
+            if use_dropout:
+                model.add(Dropout(params['dropout_rate']))
+        model.add(Dense(1, activation="sigmoid"))
+        model.compile(optimizer=Adam(learning_rate=params['lr']),
+                      loss='binary_crossentropy', metrics=['accuracy'])
+        return model
 
-with st.sidebar.expander("⚙️ Hyperparameters"):
-    activation = st.selectbox("Activation Function", ['relu', 'sigmoid', 'tanh', 'elu'])
-    lr = st.slider("Learning Rate", 0.001, 0.1, 0.01)
-    split = st.slider("Train-Test Split", 0.1, 0.9, 0.2)
-    batch = st.select_slider("Batch Size", options=list(range(8, 129, 8)), value=32)
-    epochs = st.slider("Epochs", 10, 200, 50)
-    num_neurons = st.slider("Neurons per Hidden Layer", 1, 100, 16)
-    hidden_layers = st.slider("Number of Hidden Layers", 1, 5, 2)
+    callbacks = [EarlyStopping(patience=10, restore_best_weights=True)]
 
-# Model selection radio
-model_choice = st.radio(
-    "🛠 Choose Model Variation",
-    ["Base Model", "EarlyStopping", "Dropout"]
-)
+    for mode in ['Base Model', 'EarlyStopping', 'Dropout']:
+        use_dropout = (mode == 'Dropout')
+        use_callbacks = callbacks if mode == 'EarlyStopping' else []
 
-dropout_rate = 0.3  # fixed dropout rate
+        model = build_model(use_dropout)
+        history = model.fit(params['x_train'], params['y_train'],
+                            validation_data=(params['x_test'], params['y_test']),
+                            batch_size=params['batch'],
+                            epochs=params['epochs'],
+                            callbacks=use_callbacks,
+                            verbose=0)
 
-# Dataset generation
-if dataset == "Moons":
-    x, y = make_moons(n_samples=n_samples, noise=noise, random_state=42)
-elif dataset == "Circles":
-    x, y = make_circles(n_samples=n_samples, noise=noise, random_state=42)
-else:
-    x, y = make_blobs(n_samples=n_samples, centers=2, cluster_std=1.5, random_state=42)
+        test_loss, test_acc = model.evaluate(params['x_test'], params['y_test'], verbose=0)
+        models_data[mode] = {
+            'model': model,
+            'history': history,
+            'test_loss': test_loss,
+            'test_acc': test_acc,
+            'decision_fig': plot_decision_boundary(model, params['x'], params['y']),
+            'loss_fig': plot_loss_curve(history)
+        }
 
-scaler = StandardScaler()
-x = scaler.fit_transform(x)
+    return models_data
 
-x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=split, random_state=27)
-
-# Build model
-def build_model(use_dropout=False):
-    model = Sequential()
-    model.add(Input(shape=(2,)))
-    for _ in range(hidden_layers):
-        model.add(Dense(units=num_neurons, activation=activation))
-        if use_dropout:
-            model.add(Dropout(dropout_rate))
-    model.add(Dense(1, activation="sigmoid"))
-    model.compile(optimizer=Adam(learning_rate=lr), loss='binary_crossentropy', metrics=['accuracy'])
-    return model
-
-# Callback
-callbacks = [EarlyStopping(patience=10, restore_best_weights=True)] if model_choice == "EarlyStopping" else []
-
-# Choose dropout condition
-use_dropout = model_choice == "Dropout"
-
-# Train model
-model = build_model(use_dropout=use_dropout)
-history = model.fit(x_train, y_train,
-                    validation_data=(x_test, y_test),
-                    batch_size=batch,
-                    epochs=epochs,
-                    callbacks=callbacks,
-                    verbose=0)
-
-test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
-
-# Plot decision boundary
-def plot_decision_boundary(model, title):
+# Plotting functions
+def plot_decision_boundary(model, x, y):
     x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1
     y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1
     xx, yy = np.meshgrid(np.linspace(x_min, x_max, 300),
@@ -87,36 +188,84 @@ def plot_decision_boundary(model, title):
     grid = np.c_[xx.ravel(), yy.ravel()]
     preds = model.predict(grid, verbose=0).reshape(xx.shape)
 
-    fig, ax = plt.subplots(figsize=(7, 6))
+    fig, ax = plt.subplots(figsize=(7, 5))
     ax.contourf(xx, yy, preds, cmap='RdBu', alpha=0.6)
     ax.scatter(x[:, 0], x[:, 1], c=y, cmap='RdBu', edgecolors='k', s=25)
-    ax.set_title(title)
+    ax.set_title("Decision Boundary")
     ax.set_xlabel("Feature 1")
     ax.set_ylabel("Feature 2")
     return fig
 
-# Plot training loss
-def plot_loss_curve(history, title):
+def plot_loss_curve(history):
     fig, ax = plt.subplots(figsize=(7, 4))
     ax.plot(history.history['loss'], label='Train Loss')
     ax.plot(history.history['val_loss'], label='Val Loss')
-    ax.set_title(title)
+    ax.set_title("Loss Curve")
     ax.set_xlabel("Epoch")
     ax.set_ylabel("Loss")
     ax.legend()
     return fig
 
-# Main UI
-st.title("🧪 Neural Network Regularization Explorer")
-st.markdown(f"### Currently Selected: **{model_choice}**")
+# UI: Sidebar Parameters
+st.sidebar.title("Model Controls")
+
+dataset = st.sidebar.selectbox("Dataset", ["Moons", "Circles", "Blobs"])
+noise = st.sidebar.slider("Noise Level", 0.0, 0.2, 0.1)
+n_samples = st.sidebar.slider("Number of Samples", 100, 1000, 300, step=50)
+
+activation = st.sidebar.selectbox("Activation", ['relu', 'sigmoid', 'tanh', 'elu'])
+lr = st.sidebar.slider("Learning Rate", 0.001, 0.1, 0.01)
+split = st.sidebar.slider("Train-Test Split", 0.1, 0.9, 0.2)
+batch = st.sidebar.select_slider("Batch Size", list(range(8, 129, 8)), value=32)
+epochs = st.sidebar.slider("Epochs", 10, 200, 50)
+num_neurons = st.sidebar.slider("Neurons per Hidden Layer", 1, 100, 16)
+hidden_layers = st.sidebar.slider("Hidden Layers", 1, 5, 2)
+dropout_rate = 0.3
+
+# Data Preparation
+if dataset == "Moons":
+    x, y = make_moons(n_samples=n_samples, noise=noise, random_state=42)
+elif dataset == "Circles":
+    x, y = make_circles(n_samples=n_samples, noise=noise, random_state=42)
+else:
+    x, y = make_blobs(n_samples=n_samples, centers=2, cluster_std=1.5, random_state=42)
+
+scaler = StandardScaler()
+x = scaler.fit_transform(x)
+x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=split, random_state=27)
+
+params = {
+    'x': x,
+    'y': y,
+    'x_train': x_train,
+    'x_test': x_test,
+    'y_train': y_train,
+    'y_test': y_test,
+    'activation': activation,
+    'lr': lr,
+    'batch': batch,
+    'epochs': epochs,
+    'num_neurons': num_neurons,
+    'hidden_layers': hidden_layers,
+    'dropout_rate': dropout_rate,
+}
+
+# Train all models ONCE
+with st.spinner("Training models, please wait..."):
+    model_results = train_models(params)
+
+# UI: Select which model and plot to show
+st.title("⚡ Neural Net Regularization Visualizer")
+model_choice = st.radio("Choose Model", ["Base Model", "EarlyStopping", "Dropout"])
+plot_choice = st.selectbox("Select Plot", ["Decision Boundary", "Loss Curve"])
 
-st.success(f"**Test Accuracy:** {test_acc:.4f}")
-st.info(f"**Test Loss:** {test_loss:.4f}")
+# Display results
+selected = model_results[model_choice]
 
-# Plot dropdown
-plot_type = st.selectbox("📊 Select Plot to View", ["Decision Boundary", "Loss Curve"])
+st.subheader(f"Test Accuracy: {selected['test_acc']:.4f}")
+st.caption(f"Test Loss: {selected['test_loss']:.4f}")
 
-if plot_type == "Decision Boundary":
-    st.pyplot(plot_decision_boundary(model, f"{model_choice} Decision Boundary"))
+if plot_choice == "Decision Boundary":
+    st.pyplot(selected['decision_fig'])
 else:
-    st.pyplot(plot_loss_curve(history, f"{model_choice} Loss Curve"))
+    st.pyplot(selected['loss_fig'])