Update app.py

app.py

@@ -1,24 +1,16 @@
 import streamlit as st
 import networkx as nx
-
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
 import seaborn as sns
-
 from IPython.display import clear_output
 import io
-
-import sklearn
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import log_loss
 from sklearn.datasets import make_classification, make_circles
-from sklearn.preprocessing import StandardScaler, LabelEncoder
-
-import mlxtend
+from sklearn.preprocessing import StandardScaler
 from mlxtend.plotting import plot_decision_regions
-
-import keras
 import tensorflow as tf
 from keras.optimizers import SGD
 from keras.models import Sequential
@@ -27,85 +19,110 @@ from keras.losses import BinaryCrossentropy
 from keras.regularizers import l2, l1
 from keras.callbacks import Callback
 
-st.set_page_config(layout='wide')
-
-# Session state for tracking training process
+# Wide layout and dark theme CSS
+st.set_page_config(layout="wide")
+st.markdown("""
+    <style>
+    body {
+        background-color: #252830;
+        color: white;
+    }
+    .stApp {
+        background-color: #252830;
+        color: white;
+    }
+    .stButton>button {
+        background-color: #555;
+        color: white;
+        border-radius: 5px;
+        padding: 5px 10px;
+    }
+    .stSelectbox, .stSlider {
+        background-color: #333;
+        color: white;
+        border-radius: 5px;
+    }
+    .stCheckbox label {
+        color: white;
+        font-weight: bold;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# 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 = 0
+    st.session_state.num_hidden_layers = 2  # Default from URL: 4,2
 if "hidden_layer_neurons" not in st.session_state:
-    st.session_state.hidden_layer_neurons = []
+    st.session_state.hidden_layer_neurons = [4, 2]  # Default from URL
 if "prev_params" not in st.session_state:
     st.session_state.prev_params = {}
 
 def reset_session():
     st.session_state.clear()
+    st.session_state.num_hidden_layers = 2
+    st.session_state.hidden_layer_neurons = [4, 2]
 
+# Header bar with controls
+st.markdown("<h1 style='text-align: center; color: white;'>Neural Network Playground</h1>", unsafe_allow_html=True)
 
-st.title("Neural Network Playground")
-
-# Sidebar for paramters
-st.sidebar.title("Configure & Train Model")
-problem_type = st.sidebar.selectbox("Problem Type", ["Classification", "Regression"])
-dataset_type = st.sidebar.selectbox("Select Dataset Type", ["Circle", "Gaussian"])
-learning_rate = st.sidebar.selectbox("Learning Rate", [0.00001,0.0001,0.001,0.01,0.03,0.1,0.3,1,3,10])
-regularization_type = st.sidebar.selectbox("Regularization", ["None", "L1", "L2"])
-regularization_rate = st.sidebar.selectbox("Regularization Rate", [0.0,0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1, 3, 10])
-activation_function = st.sidebar.selectbox("Activation Function", ["ReLU", "Sigmoid", "Tanh"])
-train_to_test_ratio = st.sidebar.slider("Train-to-Test Ratio (%)", 10, 90, 20, 10) / 100
-noise_level_slider = st.sidebar.slider("Noise Level", 0, 50, step=5)
-batch_size = st.sidebar.slider("Batch Size", 1, 30, 10)
-
-if st.sidebar.button("🔄 Reset Session"):
-    reset_session()
-    st.rerun()
-
-# min noise
-min_noise = 0.09
-
-# Scale the noise level to range [0.02, 0.2]
+# Top controls in columns
+col1, col2, col3, col4, col5 = st.columns([1, 1, 1, 1, 1])
+with col1:
+    dataset_type = st.selectbox("Dataset", ["Circle", "Gaussian"], index=0)  # Circle default
+with col2:
+    learning_rate = st.selectbox("Learning Rate", [0.0001, 0.001, 0.03, 0.1, 0.3, 1], index=2)  # 0.03 default
+with col3:
+    activation_function = st.selectbox("Activation", ["ReLU", "Sigmoid", "Tanh"], index=2)  # Tanh default
+with col4:
+    batch_size = st.slider("Batch Size", 1, 30, 10)  # 10 default
+with col5:
+    noise_level_slider = st.slider("Noise", 0, 50, 0, step=5)  # 0 default
+
+# Additional controls in a second row
+col6, col7, col8, col9 = st.columns([1, 1, 1, 1])
+with col6:
+    regularization_type = st.selectbox("Regularization", ["None", "L1", "L2"], index=0)  # None default
+with col7:
+    regularization_rate = st.selectbox("Reg Rate", [0.0, 0.001, 0.01, 0.1, 1], index=0)  # 0 default
+with col8:
+    train_to_test_ratio = st.slider("Train %", 10, 90, 50, 10) / 100  # 50% default
+with col9:
+    if st.button("Reset"):
+        reset_session()
+
+# Noise scaling
+min_noise = 0.02
 noise_level = min_noise + (noise_level_slider / 50) * (0.2 - min_noise)
+flip_y = noise_level / 50
+class_sep = max(2.0 - 1.5 * flip_y, 0.5)
+cluster_std = min(1.0 + 3.0 * flip_y, 3.0)
 
-# Store current parameter values in a dictionary
-current_params = {
-    "dataset_type": dataset_type,
-    "learning_rate": learning_rate,
-    "regularization_type": regularization_type,
-    "regularization_rate": regularization_rate,
-    "activation_function": activation_function,
-    "train_to_test_ratio": train_to_test_ratio,
-    "batch_size": batch_size,
-    "noise_level": noise_level
-}
-
-# Normalize noise_level to the range [0, 1] for flip_y
-flip_y = noise_level / 50  
-class_sep = max(2.0 - 1.5 * flip_y, 0.5)  # Decreases as noise increases
-cluster_std = min(1.0 + 3.0 * flip_y, 3.0)  # Increases as noise increases
-
-# Generate dataset based on selection
+# Dataset generation
 if dataset_type == "Gaussian":
-    fv, cv = make_classification(
-        n_samples=800,
-        n_features=2,
-        n_informative=2,
-        n_redundant=0,
-        n_repeated=0,
-        n_classes=2,
-        class_sep=class_sep,
-        flip_y=flip_y,
-        n_clusters_per_class=1,
-    )
+    fv, cv = make_classification(n_samples=800, n_features=2, n_informative=2, n_redundant=0, n_classes=2, class_sep=class_sep, flip_y=flip_y, n_clusters_per_class=1)
 else:
-    fv, cv = make_circles(
-        n_samples=800,
-        shuffle=True,
-        noise=noise_level,
-        factor=0.2
-    )
+    fv, cv = make_circles(n_samples=800, shuffle=True, noise=noise_level, factor=0.2)
+
+# Feature selection
+std = StandardScaler()
+X = std.fit_transform(fv)
+x1, x2 = X[:, 0], X[:, 1]
+x1_squared, x2_squared = x1**2, x2**2
+x1_x2 = x1 * x2
+cos_x1, sin_x1 = np.cos(x1), np.sin(x1)
+cos_x2, sin_x2 = np.cos(x2), np.sin(x2)
 
-# Functions for modifying hidden layers
+feature_mapping = {
+    "X1": x1, "X2": x2, "X1*X2": x1_x2, "X1^2": x1_squared, "X2^2": x2_squared,
+    "cos(X1)": cos_x1, "sin(X1)": sin_x1, "cos(X2)": cos_x2, "sin(X2)": sin_x2
+}
+available_features = list(feature_mapping.keys())
+selected_features = [f for f in available_features if st.checkbox(f, value=f in ["X1", "X2"], key=f)]
+selected_data = np.column_stack([feature_mapping[f] for f in selected_features])
+
+# Hidden layer controls
 def add_layer():
     if st.session_state.num_hidden_layers < 6:
         st.session_state.num_hidden_layers += 1
@@ -116,275 +133,104 @@ def remove_layer():
         st.session_state.num_hidden_layers -= 1
         st.session_state.hidden_layer_neurons.pop()
 
-# Functions for modifying neurons in each layer
-def increase_neurons(layer_idx):
-    if st.session_state.hidden_layer_neurons[layer_idx] < 8:
-        st.session_state.hidden_layer_neurons[layer_idx] += 1
-
-def decrease_neurons(layer_idx):
-    if st.session_state.hidden_layer_neurons[layer_idx] > 1:
-        st.session_state.hidden_layer_neurons[layer_idx] -= 1
-
-col1, col2, col3 = st.columns([2, 2, 2])
+def increase_neurons(idx):
+    if st.session_state.hidden_layer_neurons[idx] < 8:
+        st.session_state.hidden_layer_neurons[idx] += 1
 
-with col1:
-    st.subheader("Select Input Features")
-    
-    # Compute new features
-    std = StandardScaler()
-    X = std.fit_transform(fv)
-    x1, x2 = X[:, 0], X[:, 1]
-    x1_squared, x2_squared = x1**2, x2**2  # Squared features
+def decrease_neurons(idx):
+    if st.session_state.hidden_layer_neurons[idx] > 1:
+        st.session_state.hidden_layer_neurons[idx] -= 1
 
-    # Update feature selection
-    available_features = ["X1", "X2", "X1^2", "X2^2"]
-    
-    st.markdown("""
-        <style>
-        div[data-testid="stCheckbox"] {
-            background-color: #252830;
-            border-radius: 8px;
-            padding: 8px;
-            margin-bottom: 5px;
-            color: white;
-        }
-        div[data-testid="stCheckbox"] label {
-            font-size: 16px;
-            font-weight: bold;
-            color: white;
-        }
-        </style>
-        """, unsafe_allow_html=True)
-
-    selected_features = [feature for feature in available_features if st.checkbox(feature, value = st.session_state.get(feature, feature in ["X1", "X2"]), key=feature)]
-    num_inputs = len(selected_features)
-
-# Map feature names to actual values
-feature_mapping = {
-    "X1": x1,
-    "X2": x2,
-    "X1^2": x1_squared,
-    "X2^2": x2_squared
-}
+# Main layout
+col_left, col_center, col_right = st.columns([1, 2, 1])
 
-with col2:
-    # Visualize dataset
-    st.subheader("Dataset Preview")
+with col_left:
+    st.subheader("Dataset")
     fig, ax = plt.subplots(figsize=(3, 3))
-    scatter = ax.scatter(fv[:, 0], fv[:, 1], c=cv, cmap="coolwarm", edgecolors="k", alpha=0.7)
+    ax.scatter(fv[:, 0], fv[:, 1], c=cv, cmap="coolwarm", edgecolors="k", alpha=0.7)
     ax.set_xticks([])
     ax.set_yticks([])
-    ax.set_facecolor("#f0f0f0")
-
-    st.pyplot(fig)  # Display scatter plot
-
-num_outputs = 1
-with col3:
-    st.subheader("Hidden Layers")
-    col1, col2 = st.columns([1, 1])
-    with col1:
-        st.button("➕ Add Layer", on_click=add_layer)
-    with col2:
-        st.button("➖ Remove Layer", on_click=remove_layer)
+    ax.set_facecolor("#333")
+    st.pyplot(fig)
+
+with col_center:
+    st.subheader("Network Architecture")
+    def draw_nn(features, neurons, outputs=1):
+        G = nx.DiGraph()
+        layers = [features] + [[f"hl{i+1}_{j+1}" for j in range(n)] for i, n in enumerate(neurons)] + [["y1"]]
+        node_colors = {}
+        for layer_idx, layer in enumerate(layers):
+            for node in layer:
+                G.add_node(node, layer=layer_idx)
+                node_colors[node] = "#90EE90" if layer_idx == 0 else "#87CEFA" if layer_idx < len(layers) - 1 else "#FFA07A"
+        for i in range(len(layers) - 1):
+            for n1 in layers[i]:
+                for n2 in layers[i + 1]:
+                    G.add_edge(n1, n2)
+        pos = nx.multipartite_layout(G, subset_key="layer")
+        fig, ax = plt.subplots(figsize=(8, 4))
+        ax.set_facecolor("#252830")
+        nx.draw(G, pos, with_labels=True, node_color=[node_colors[n] for n in G.nodes], edge_color="white", node_size=800, font_size=8, ax=ax, width=0.4)
+        return fig
     
-    st.write("**Adjust Neurons in Each Layer:**")
+    st.pyplot(draw_nn(selected_features, st.session_state.hidden_layer_neurons))
+    
+    # Layer controls
     for i in range(st.session_state.num_hidden_layers):
         col1, col2, col3 = st.columns([1, 2, 1])
         with col1:
-            st.button("➖", key=f"dec_neuron_{i}", on_click=decrease_neurons, args=(i,))
+            st.button("-", key=f"dec_{i}", on_click=decrease_neurons, args=(i,))
         with col2:
-            st.markdown(f"**Layer {i+1}: {st.session_state.hidden_layer_neurons[i]} neurons**")
+            st.write(f"Layer {i+1}: {st.session_state.hidden_layer_neurons[i]} neurons")
         with col3:
-            st.button("➕", key=f"inc_neuron_{i}", on_click=increase_neurons, args=(i,))
-
-# Stack selected features for training
-selected_data = np.column_stack([feature_mapping[feature] for feature in selected_features])
-
-
-# Function to draw the neural network visually
-def draw_nn(selected_features, hidden_layer_neurons, num_outputs):
-    G = nx.DiGraph()
-    
-    # Define layers dynamically
-    input_layer = selected_features  # Match node names with feature names
-    hidden_layers = []
-    if st.session_state.num_hidden_layers > 0:
-        hidden_layers = [[f"hl{i+1}_{j+1}" for j in range(hidden_layer_neurons[i])] for i in range(st.session_state.num_hidden_layers)]
-    output_layer = ["y1"]  # Single output neuron
-    
-    layers = [input_layer] + hidden_layers + [output_layer]
-
-    # Add nodes and assign colors
-    node_colors = {}
-    input_color = "lightgreen"
-    hidden_color = "lightblue"
-    output_color = "salmon"
-
-    # Add nodes
-    # for layer_idx, layer in enumerate(layers):
-    #     for node in layer:
-    #         G.add_node(node, layer=layer_idx, edgecolors='black')
-    for layer_idx, layer in enumerate(layers):
-        for node in layer:
-            G.add_node(node, layer=layer_idx, edgecolors='black')
-            if layer_idx == 0:
-                node_colors[node] = input_color  # Input layer
-            elif layer_idx == len(layers) - 1:
-                node_colors[node] = output_color  # Output layer
-            else:
-                node_colors[node] = hidden_color  # Hidden layers
-
-    # Add edges (fully connected between layers)
-    for i in range(len(layers) - 1):
-        for node1 in layers[i]:
-            for node2 in layers[i + 1]:
-                G.add_edge(node1, node2)
-
-    # Graph Layout
-    pos = nx.multipartite_layout(G, subset_key="layer")
-    fig, ax = plt.subplots(figsize=(12, 4))
-    
-    # Style updates for TensorFlow Playground look
-    fig.patch.set_alpha(0)
-    ax.set_facecolor("#252830")  # Dark background
-    ax.patch.set_alpha(1)
-
-    # Get color list
-    color_list = [node_colors[node] for node in G.nodes]
-
-    nx.draw(G, pos, with_labels=True, node_color=color_list, edge_color="white", edgecolors = "black",
-            node_size=800, font_size=7.5, ax=ax, width=0.4, font_color="black", font_weight="bold")
+            st.button("+", key=f"inc_{i}", on_click=increase_neurons, args=(i,))
+    st.button("Add Layer", on_click=add_layer)
+    st.button("Remove Layer", on_click=remove_layer)
 
-    return fig
+with col_right:
+    st.subheader("Output")
+    if st.button("▶️ Start"):
+        st.session_state.training = True
+    if st.button("⏹️ Stop"):
+        st.session_state.training = False
 
+# Model training
 def create_ann_model(input_dim, hidden_layers, neurons_per_layer):
     model = Sequential()
-    model.add(Input(shape=(input_dim,)))  # Input layer
-    
-    reg = None
-    if regularization_type == "L1":
-        reg = l1(regularization_rate)
-    elif regularization_type == "L2":
-        reg = l2(regularization_rate)
-
-    # Add hidden layers
+    model.add(Input(shape=(input_dim,)))
+    reg = l1(regularization_rate) if regularization_type == "L1" else l2(regularization_rate) if regularization_type == "L2" else None
     for neurons in neurons_per_layer:
         model.add(Dense(neurons, activation=activation_function.lower(), kernel_regularizer=reg))
-
-    # Output layer
     model.add(Dense(1, activation='sigmoid'))
-    
-    # Compile the model with explicit learning rate
     optimizer = SGD(learning_rate=learning_rate)
-    model.compile(
-        optimizer=optimizer,
-        loss=BinaryCrossentropy(),
-        metrics=['accuracy']
-    )
+    model.compile(optimizer=optimizer, loss=BinaryCrossentropy(), metrics=['accuracy'])
     return model
 
-def plot_decision_boundary(model, X, y):
-    plt.figure(figsize=(6, 4))
-    plot_decision_regions(X, y, clf=model, legend=2)
-    #plt.title('Decision Boundary')
-    return plt
-
 class LossPlotCallback(tf.keras.callbacks.Callback):
-    def __init__(self, X, y, display_epochs=10):
+    def __init__(self, X, y):
         super().__init__()
         self.loss_df = pd.DataFrame(columns=["Epoch", "Train Loss", "Val Loss"])
-        #self.display_epochs = display_epochs
-        self.X = X
-        self.y = y
-        self.plot_placeholder = st.empty()  # SINGLE container to update dynamically
+        self.X, self.y = X, y
+        self.plot_placeholder = st.empty()
 
     def on_epoch_end(self, epoch, logs=None):
-        # Append new train and validation loss values
-        new_row = pd.DataFrame({
-            "Epoch": [epoch + 1], 
-            "Train Loss": [logs['loss']], 
-            "Val Loss": [logs['val_loss']]
-        })
+        new_row = pd.DataFrame({"Epoch": [epoch + 1], "Train Loss": [logs['loss']], "Val Loss": [logs['val_loss']]})
         self.loss_df = pd.concat([self.loss_df, new_row], ignore_index=True)
-
         with self.plot_placeholder.container():
-            col1, col2 = st.columns([1, 1])
-
-            # Left Column: Decision Surface
+            col1, col2 = st.columns(2)
             with col1:
-                st.write("### Decision Boundary")
-                fig1 = plot_decision_boundary(ann_model, selected_data, cv)
-                st.pyplot(fig1, clear_figure=True)
-
-
-            # Right Column: Loss Plot
+                plt.figure(figsize=(3, 3))
+                plot_decision_regions(self.X, self.y, clf=self.model)
+                st.pyplot(plt)
             with col2:
-                st.write("### Training vs Validation Loss")
-                fig2, ax = plt.subplots(figsize=(6, 4), dpi=100)
-                ax.plot(self.loss_df["Epoch"], self.loss_df["Train Loss"], marker='o', markersize=1, linestyle='-', color='b', label="Train Loss")
-
-                if "Val Loss" in self.loss_df.columns and self.loss_df["Val Loss"].notna().any():
-                    ax.plot(self.loss_df["Epoch"], self.loss_df["Val Loss"], marker='s',markersize=1, linestyle='--', color='r', label="Val Loss")
-
-                ax.set_xlabel("Epochs", fontsize=12, fontweight='bold')
-                ax.set_ylabel("Loss", fontsize=12, fontweight='bold')
-                
-                #ax.set_title("Training vs Validation Loss", fontsize=14, fontweight='bold')
-                
-                ax.legend(fontsize=10)
-                
-                ax.grid(True, linestyle='--', alpha=0.6)
-                ax.spines['top'].set_visible(False)
-                ax.spines['right'].set_visible(False)
-
-                ax.set_xticks(range(1, len(self.loss_df) + 1))
-                st.pyplot(fig2, clear_figure=True)
-    
-
-if current_params != st.session_state.prev_params:
-    st.session_state.training = False  # Stop training when a parameter changes
-st.session_state.prev_params = current_params
-
-# Start/Stop Buttons
-col1, col2 = st.columns([1, 1])
-with col1:
-    if st.button("▶️ Start Training"):
-        st.session_state.training = True
-        st.session_state.model_trained = False 
-
-with col2:
-    if st.button("⏹️ Stop Training"):
-        st.session_state.training = False
-
-# Render the neural network visualization
-st.write("### Logical Structure of the Neural Network")
-st.pyplot(draw_nn(selected_features, st.session_state.hidden_layer_neurons, num_outputs))
+                fig, ax = plt.subplots(figsize=(3, 3))
+                ax.plot(self.loss_df["Epoch"], self.loss_df["Train Loss"], 'b-', label="Train")
+                ax.plot(self.loss_df["Epoch"], self.loss_df["Val Loss"], 'r--', label="Val")
+                ax.legend()
+                ax.set_facecolor("#333")
+                st.pyplot(fig)
 
-# Train Model if Start is clicked
 if st.session_state.training:
-    # Train the model and track loss in a DataFrame
-    ann_model = create_ann_model(
-        len(selected_features), 
-        st.session_state.num_hidden_layers,
-        st.session_state.hidden_layer_neurons
-        )
-
-    st.session_state.model_trained = True
-    
-    loss_plot_callback = LossPlotCallback(X=selected_data, y=cv)
-
-    # Capture model summary
-    model_summary = io.StringIO()
-    ann_model.summary(print_fn=lambda x: model_summary.write(x + "\n"))
-        
-    # Display ANN model summary in Streamlit
-    st.subheader("Artificial Neural Network Model Summary")
-    st.code(model_summary.getvalue(), language="plaintext")
-
-    history = ann_model.fit(
-        selected_data, cv,
-        epochs=999999,
-        validation_split=1-train_to_test_ratio, 
-        batch_size=batch_size,
-        callbacks=[loss_plot_callback],
-    )
+    ann_model = create_ann_model(len(selected_features), st.session_state.num_hidden_layers, st.session_state.hidden_layer_neurons)
+    loss_plot_callback = LossPlotCallback(selected_data, cv)
+    ann_model.fit(selected_data, cv, epochs=999999, validation_split=1-train_to_test_ratio, batch_size=batch_size, callbacks=[loss_plot_callback], verbose=0)