Update app.py

app.py

@@ -11,14 +11,15 @@ from sklearn.datasets import make_moons, make_circles, make_blobs
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
 
-st.sidebar.title("🔧 Model Settings")
+# 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("⚙️ Model Hyperparameters"):
+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)
@@ -27,11 +28,15 @@ with st.sidebar.expander("⚙️ Model Hyperparameters"):
     num_neurons = st.slider("Neurons per Hidden Layer", 1, 100, 16)
     hidden_layers = st.slider("Number of Hidden Layers", 1, 5, 2)
 
-with st.sidebar.expander("🛠 Regularization"):
-    use_earlystop = st.checkbox("Use EarlyStopping", value=True)
-    use_dropout = st.checkbox("Use Dropout", value=True)
-    dropout_rate = st.slider("Dropout Rate", 0.0, 0.5, 0.3) if use_dropout else 0.0
+# 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":
@@ -44,44 +49,36 @@ x = scaler.fit_transform(x)
 
 x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=split, random_state=27)
 
-callbacks = [EarlyStopping(patience=10, restore_best_weights=True)] if use_earlystop else []
-
-def build_model(with_dropout=False):
+# 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 with_dropout:
+        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
 
-base_model = build_model(False)
-dropout_model = build_model(True)
-
-base_hist = base_model.fit(x_train, y_train,
-                           validation_data=(x_test, y_test),
-                           batch_size=batch,
-                           epochs=epochs,
-                           callbacks=[],
-                           verbose=0)
-
-early_model = build_model(False)
-early_hist = early_model.fit(x_train, y_train,
-                             validation_data=(x_test, y_test),
-                             batch_size=batch,
-                             epochs=epochs,
-                             callbacks=callbacks,
-                             verbose=0)
-
-dropout_hist = dropout_model.fit(x_train, y_train,
-                                 validation_data=(x_test, y_test),
-                                 batch_size=batch,
-                                 epochs=epochs,
-                                 callbacks=callbacks,
-                                 verbose=0)
+# 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
@@ -90,7 +87,7 @@ 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()
+    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)
@@ -98,33 +95,28 @@ def plot_decision_boundary(model, title):
     ax.set_ylabel("Feature 2")
     return fig
 
-def plot_loss(history, title):
-    fig, ax = plt.subplots()
+# 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("Epochs")
+    ax.set_xlabel("Epoch")
     ax.set_ylabel("Loss")
     ax.legend()
     return fig
 
-st.title("🧪 Regularization Comparison")
-
-st.markdown("Below are the decision boundaries and loss curves for three configurations:")
+# Main UI
+st.title("🧪 Neural Network Regularization Explorer")
+st.markdown(f"### Currently Selected: **{model_choice}**")
 
-cols = st.columns(3)
+st.success(f"**Test Accuracy:** {test_acc:.4f}")
+st.info(f"**Test Loss:** {test_loss:.4f}")
 
-with cols[0]:
-    st.markdown("### 🔹 Base Model")
-    st.pyplot(plot_decision_boundary(base_model, "Base Model"))
-    st.pyplot(plot_loss(base_hist, "Base Model Loss"))
+# Plot dropdown
+plot_type = st.selectbox("📊 Select Plot to View", ["Decision Boundary", "Loss Curve"])
 
-with cols[1]:
-    st.markdown("### 🟢 With EarlyStopping")
-    st.pyplot(plot_decision_boundary(early_model, "EarlyStopping"))
-    st.pyplot(plot_loss(early_hist, "EarlyStopping Loss"))
-
-with cols[2]:
-    st.markdown("### 🔸 With Dropout")
-    st.pyplot(plot_decision_boundary(dropout_model, "Dropout Model"))
-    st.pyplot(plot_loss(dropout_hist, "Dropout Loss"))
+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"))