Update app.py

app.py

@@ -3,18 +3,18 @@ import networkx as nx
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
-from sklearn.datasets import make_circles
+from sklearn.datasets import make_blobs, make_circles, make_moons
 from sklearn.preprocessing import StandardScaler
 from mlxtend.plotting import plot_decision_regions
 import tensorflow as tf
 from keras.models import Sequential
 from keras.layers import Input, Dense
 from keras.optimizers import SGD
-from keras.losses import BinaryCrossentropy
+from keras.losses import MeanSquaredError, BinaryCrossentropy
 from keras.regularizers import l2, l1
 from keras.callbacks import Callback
 
-# Set wide layout and apply TensorFlow Playground-inspired CSS
+# Set wide layout and TensorFlow Playground CSS
 st.set_page_config(layout="wide")
 st.markdown("""
     <style>
@@ -65,11 +65,11 @@ st.markdown("""
     </style>
 """, unsafe_allow_html=True)
 
-# Session state initialization (matching URL defaults)
+# Session state initialization
 if "training" not in st.session_state:
     st.session_state.training = False
 if "num_hidden_layers" not in st.session_state:
-    st.session_state.num_hidden_layers = 2  # Default: 4,2
+    st.session_state.num_hidden_layers = 2
 if "hidden_layer_neurons" not in st.session_state:
     st.session_state.hidden_layer_neurons = [4, 2]
 if "prev_params" not in st.session_state:
@@ -83,27 +83,52 @@ def reset_session():
 # Top control bar
 with st.container():
     st.markdown('<div class="control-bar">', unsafe_allow_html=True)
-    col1, col2, col3, col4, col5, col6, col7, col8 = st.columns(8)
+    col1, col2, col3, col4, col5, col6, col7, col8, col9 = st.columns(9)
     with col1:
-        dataset_type = st.selectbox("Dataset", ["Circle", "Gaussian"], index=0, label_visibility="collapsed")
+        problem_type = st.selectbox("Problem", ["Classification", "Regression"], label_visibility="collapsed")
     with col2:
-        learning_rate = st.selectbox("Learning Rate", [0.0001, 0.001, 0.03, 0.1, 0.3, 1], index=2, label_visibility="collapsed")
+        dataset_options = {"Classification": ["Blobs", "Circles", "Spirals", "XOR"], "Regression": ["Sine Wave"]}
+        dataset_type = st.selectbox("Dataset", dataset_options[problem_type], label_visibility="collapsed")
     with col3:
-        activation = st.selectbox("Activation", ["ReLU", "Sigmoid", "Tanh"], index=2, label_visibility="collapsed")
+        learning_rate = st.selectbox("Learning Rate", [0.0001, 0.001, 0.03, 0.1, 0.3, 1], index=2, label_visibility="collapsed")
     with col4:
-        batch_size = st.slider("Batch Size", 1, 30, 10, label_visibility="collapsed")
+        activation = st.selectbox("Activation", ["ReLU", "Sigmoid", "Tanh"], index=2, label_visibility="collapsed")
     with col5:
-        noise_level = st.slider("Noise", 0, 50, 0, step=5, label_visibility="collapsed")
+        batch_size = st.slider("Batch Size", 1, 30, 10, label_visibility="collapsed")
     with col6:
-        reg_type = st.selectbox("Regularization", ["None", "L1", "L2"], index=0, label_visibility="collapsed")
+        noise_level = st.slider("Noise", 0, 50, 0, step=5, label_visibility="collapsed")
     with col7:
-        reg_rate = st.selectbox("Reg Rate", [0.0, 0.001, 0.01, 0.1, 1], index=0, label_visibility="collapsed")
+        reg_type = st.selectbox("Regularization", ["None", "L1", "L2"], index=0, label_visibility="collapsed")
     with col8:
+        reg_rate = st.selectbox("Reg Rate", [0.0, 0.001, 0.01, 0.1, 1], index=0, label_visibility="collapsed")
+    with col9:
         train_ratio = st.slider("Train %", 10, 90, 50, 10, label_visibility="collapsed") / 100
     st.markdown('</div>', unsafe_allow_html=True)
 
-# Dataset generation (Circle as default)
-fv, cv = make_circles(n_samples=800, shuffle=True, noise=noise_level / 250, factor=0.2)
+# Dataset generation
+def generate_xor(n_samples):
+    X = np.random.rand(n_samples, 2) * 2 - 1  # Range [-1, 1]
+    y = np.logical_xor(X[:, 0] > 0, X[:, 1] > 0).astype(int)
+    return X, y
+
+def generate_sine_wave(n_samples, noise):
+    X = np.linspace(-3, 3, n_samples).reshape(-1, 1)
+    y = np.sin(X) + np.random.normal(0, noise / 100, X.shape)
+    return np.hstack([X, X**2]), y.ravel()  # Add X^2 as a second feature
+
+if problem_type == "Classification":
+    if dataset_type == "Blobs":
+        fv, cv = make_blobs(n_samples=800, centers=2, n_features=2, cluster_std=1.5 + noise_level / 50, random_state=42)
+    elif dataset_type == "Circles":
+        fv, cv = make_circles(n_samples=800, noise=noise_level / 250, factor=0.2)
+    elif dataset_type == "Spirals":
+        fv, cv = make_moons(n_samples=800, noise=noise_level / 250)
+    elif dataset_type == "XOR":
+        fv, cv = generate_xor(800)
+else:  # Regression
+    fv, cv = generate_sine_wave(800, noise_level)
+
+# Feature preprocessing
 std = StandardScaler()
 X = std.fit_transform(fv)
 x1, x2 = X[:, 0], X[:, 1]
@@ -114,7 +139,7 @@ features = {
 selected_features = [f for f in features.keys() if st.session_state.get(f, f in ["X1", "X2"])]
 selected_data = np.column_stack([features[f] for f in selected_features])
 
-# Main layout with three panels
+# Main layout
 col_left, col_center, col_right = st.columns([1, 2, 1])
 
 # Left panel: Dataset and Features
@@ -122,7 +147,10 @@ with col_left:
     st.markdown('<div class="panel">', unsafe_allow_html=True)
     st.subheader("Data")
     fig, ax = plt.subplots(figsize=(3, 3))
-    ax.scatter(fv[:, 0], fv[:, 1], c=cv, cmap="coolwarm", edgecolors="k", alpha=0.7)
+    if problem_type == "Classification":
+        ax.scatter(fv[:, 0], fv[:, 1], c=cv, cmap="coolwarm", edgecolors="k", alpha=0.7)
+    else:
+        ax.scatter(fv[:, 0], cv, c="blue", alpha=0.7)
     ax.set_xticks([])
     ax.set_yticks([])
     ax.set_facecolor("#333")
@@ -209,11 +237,13 @@ with col_right:
         reg = l1(reg_rate) if reg_type == "L1" else l2(reg_rate) if reg_type == "L2" else None
         for n in neurons:
             model.add(Dense(n, activation=activation.lower(), kernel_regularizer=reg))
-        model.add(Dense(1, activation="sigmoid"))
-        model.compile(optimizer=SGD(learning_rate=learning_rate), loss=BinaryCrossentropy(), metrics=["accuracy"])
+        output_activation = "sigmoid" if problem_type == "Classification" else "linear"
+        loss = BinaryCrossentropy() if problem_type == "Classification" else MeanSquaredError()
+        model.add(Dense(1, activation=output_activation))
+        model.compile(optimizer=SGD(learning_rate=learning_rate), loss=loss, metrics=["accuracy" if problem_type == "Classification" else "mae"])
         return model
 
-    class LossPlotCallback(tf.keras.callbacks.Callback):
+    class OutputCallback(tf.keras.callbacks.Callback):
         def __init__(self, X, y):
             super().__init__()
             self.X, self.y = X, y
@@ -228,7 +258,12 @@ with col_right:
                 col1, col2 = st.columns(2)
                 with col1:
                     plt.figure(figsize=(3, 3))
-                    plot_decision_regions(self.X, self.y, clf=self.model)
+                    if problem_type == "Classification":
+                        plot_decision_regions(self.X, self.y, clf=self.model)
+                    else:
+                        y_pred = self.model.predict(self.X, verbose=0)
+                        plt.scatter(self.X[:, 0], self.y, c="blue", alpha=0.5)
+                        plt.plot(self.X[:, 0], y_pred, "r-", linewidth=2)
                     plt.gca().set_facecolor("#333")
                     st.pyplot(plt)
                 with col2:
@@ -241,7 +276,7 @@ with col_right:
 
     if st.session_state.training:
         model = create_model(len(selected_features), st.session_state.hidden_layer_neurons)
-        callback = LossPlotCallback(selected_data, cv)
+        callback = OutputCallback(selected_data, cv)
         model.fit(selected_data, cv, epochs=999999, batch_size=batch_size, validation_split=1-train_ratio, callbacks=[callback], verbose=0)
     st.markdown('</div>', unsafe_allow_html=True)