Update app.py

app.py

@@ -1,156 +1,390 @@
 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
-import graphviz
-import time
-import tensorflow as tf
-from tensorflow import keras
-from tensorflow.keras import layers, Sequential
-from tensorflow.keras.regularizers import l2
+
+from IPython.display import clear_output
+import io
+
+import sklearn
 from sklearn.model_selection import train_test_split
-from sklearn.datasets import make_moons, make_circles, make_classification, make_blobs
+from sklearn.metrics import log_loss
+from sklearn.datasets import make_classification, make_circles
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+
+import mlxtend
 from mlxtend.plotting import plot_decision_regions
-from sklearn.base import BaseEstimator, ClassifierMixin
 
-# Set Streamlit page title
-st.set_page_config(page_title="Neural Network Trainer", layout="wide")
+import keras
+import tensorflow as tf
+from keras.optimizers import SGD
+from keras.models import Sequential
+from keras.layers import Input, Dense
+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
+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
+if "hidden_layer_neurons" not in st.session_state:
+    st.session_state.hidden_layer_neurons = []
+if "prev_params" not in st.session_state:
+    st.session_state.prev_params = {}
+
+def reset_session():
+    st.session_state.clear()
+
+
+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]
+noise_level = min_noise + (noise_level_slider / 50) * (0.2 - min_noise)
 
-# ================= Session State for Training Controls =================
-if "epoch" not in st.session_state:
-    st.session_state.epoch = 0
-if "running" not in st.session_state:
-    st.session_state.running = False
-if "train_loss_history" not in st.session_state:
-    st.session_state.train_loss_history = []
-if "test_loss_history" not in st.session_state:
-    st.session_state.test_loss_history = []
+# 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
+}
 
-# ================= TRAINING CONTROL PANEL (Top) =================
-st.markdown("### Training Controls")
-col1, col2, col3, col4, col5, col6, col7, col8, col9 = st.columns(9)
+# 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
+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,
+    )
+else:
+    fv, cv = make_circles(
+        n_samples=800,
+        shuffle=True,
+        noise=noise_level,
+        factor=0.2
+    )
+
+# Functions for modifying hidden layers
+def add_layer():
+    if st.session_state.num_hidden_layers < 6:
+        st.session_state.num_hidden_layers += 1
+        st.session_state.hidden_layer_neurons.append(1)
+
+def remove_layer():
+    if st.session_state.num_hidden_layers > 0:
+        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])
 
 with col1:
-    if st.button("↩️ Reset"):
-        st.session_state.epoch = 0
-        st.session_state.running = False
-        st.session_state.train_loss_history = []
-        st.session_state.test_loss_history = []
+    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
+
+    # 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
+}
+
 with col2:
-    if st.button("▶️ Train"):
-        st.session_state.running = True
+    # Visualize dataset
+    st.subheader("Dataset Preview")
+    fig, ax = plt.subplots(figsize=(3, 3))
+    scatter = 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:
-    if st.button("⏸️ Pause"):
-        st.session_state.running = False
-with col4:
-    activation = st.selectbox("Activation", ["ReLU", "Sigmoid", "Tanh"], index=2)
-with col5:
-    problem_type = st.selectbox("Problem Type", ["Classification", "Regression"])
-with col6:
-    learning_rate = st.selectbox("Learning Rate", [0.0001, 0.001, 0.01, 0.03, 0.1])
-with col7:
-    num_epochs = st.slider("Epochs", 1, 100, 10)
-with col8:
-    batch_size = st.slider("Batch Size", 1, 100, 10)
-with col9:
-    dataset_option = st.selectbox("Select Dataset", ["Moons", "Circles", "Blobs", "Classification"])
-    noise = st.slider("Noise Level", 0.0, 0.5, 0.2)
-
-# ================= MAIN LAYOUT =================
-col_features, col_hidden, col_plot = st.columns([2, 2, 3])
-
-# ========== FEATURES PANEL (Left) ========== #
-with col_features:
-    st.header("FEATURES")
-    st.write("Select input features:")
-    x1 = st.checkbox("X₁", value=True)
-    x2 = st.checkbox("X₂", value=True)
-
-# ========== HIDDEN LAYERS PANEL (Middle) ========== #
-with col_hidden:
-    st.header("HIDDEN LAYERS")
-    hidden_layers = st.slider("Number of Hidden Layers", 1, 7, 2)
-    neurons = [st.slider(f"Neurons in Layer {i+1}", 1, 20, 4) for i in range(hidden_layers)]
-
-# ================= DATASET GENERATION =================
-def generate_data():
-    if dataset_option == "Moons":
-        X, y = make_moons(n_samples=1000, noise=noise)
-    elif dataset_option == "Circles":
-        X, y = make_circles(n_samples=1000, noise=noise)
-    elif dataset_option == "Blobs":
-        X, y = make_blobs(n_samples=1000, centers=2, cluster_std=noise)
-    else:
-        X, y = make_classification(n_samples=1000, n_features=2, n_classes=2, n_clusters_per_class=1, n_redundant=0, flip_y=noise)
-    return X, y
-
-X, y = generate_data()
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-
-# ========== TRAINING ANN ========== #
-def build_ann():
+    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)
+    
+    st.write("**Adjust Neurons in Each Layer:**")
+    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,))
+        with col2:
+            st.markdown(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")
+
+    return fig
+
+def create_ann_model(input_dim, hidden_layers, neurons_per_layer):
     model = Sequential()
-    model.add(layers.Input(shape=(X.shape[1],)))
-    for units in neurons:
-        model.add(layers.Dense(units=units, activation='tanh'))
-    model.add(layers.Dense(units=1, activation='sigmoid', kernel_regularizer=l2(0.1)))
-    model.compile(optimizer=keras.optimizers.Adam(learning_rate), loss="binary_crossentropy" if problem_type == "Classification" else "mse")
+    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
+    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']
+    )
     return model
 
-class KerasClassifierWrapper(BaseEstimator, ClassifierMixin):
-    def __init__(self, model):
-        self.model = model
-    def fit(self, X, y):
-        self.model.fit(X, y, epochs=num_epochs, batch_size=batch_size, verbose=0)
-        return self
-    def predict(self, X):
-        return (self.model.predict(X) > 0.5).astype(int).flatten()
-
-wrapper_model = None
-if st.session_state.running:
-    model = build_ann()
-    history = model.fit(X_train, y_train, epochs=num_epochs, batch_size=batch_size, validation_data=(X_test, y_test), verbose=0)
-    st.session_state.train_loss_history = history.history["loss"]
-    st.session_state.test_loss_history = history.history["val_loss"]
-    wrapper_model = KerasClassifierWrapper(model)
-
-# ========== LOSS PLOT ========== #
-with col_plot:
-    st.header("Loss Plot")
-    fig, ax = plt.subplots()
-    ax.plot(range(1, len(st.session_state.train_loss_history) + 1), st.session_state.train_loss_history, marker="o", label="Train Loss")
-    ax.plot(range(1, len(st.session_state.test_loss_history) + 1), st.session_state.test_loss_history, marker="s", label="Test Loss")
-    ax.set_title("Epoch vs. Loss")
-    ax.set_xlabel("Epoch")
-    ax.set_ylabel("Loss")
-    ax.legend()
-    st.pyplot(fig)
-
-# =================== DECISION REGION =================== #
-if problem_type == "Classification":
-    fig, ax = plt.subplots()
-    plot_decision_regions(X_train, y_train, clf=wrapper_model, ax=ax)
-    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolor='k')
-    ax.set_title("Decision Region")
-    st.pyplot(fig)
-
-# =================== DRAW NEURAL NETWORK =================== #
-def draw_neural_network():
-    graph = graphviz.Digraph()
-    graph.node("X1", "X₁", shape="circle", style="filled", fillcolor="lightblue")
-    graph.node("X2", "X₂", shape="circle", style="filled", fillcolor="lightblue")
-    prev_layer = ["X1", "X2"]
-    for i, num_neurons in enumerate(neurons):
-        current_layer = [f"H{i+1}{j+1}" for j in range(num_neurons)]
-        for neuron in current_layer:
-            graph.node(neuron, neuron, shape="circle", style="filled", fillcolor="lightyellow")
-        for prev in prev_layer:
-            for curr in current_layer:
-                graph.edge(prev, curr)
-        prev_layer = current_layer
-    graph.node("Output", "Output", shape="circle", style="filled", fillcolor="lightgreen")
-    for neuron in prev_layer:
-        graph.edge(neuron, "Output")
-    return graph
-
-st.graphviz_chart(draw_neural_network())
+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):
+        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
+
+    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']]
+        })
+        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
+            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
+            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))
+
+# 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],
+    )