Update app.py

app.py

@@ -1,110 +1,216 @@
 import streamlit as st
 import numpy as np
-import matplotlib.pyplot as plt
 import tensorflow as tf
-from sklearn.datasets import make_moons, make_circles, make_classification
+from tensorflow import keras
+import matplotlib.pyplot as plt
+import networkx as nx
+from sklearn.datasets import make_circles, make_moons, make_blobs
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
-from tensorflow import keras
-import plotly.graph_objects as go
-import plotly.figure_factory as ff
-
-
-# Sidebar: Neural Network Settings
-st.sidebar.header("Neural Network Settings")
-problem_type = st.sidebar.selectbox("Problem type", ["Classification", "Regression"])
-dataset_choice = st.sidebar.selectbox("Dataset", ["Moons", "Circles", "Linear"])
-train_ratio = st.sidebar.slider("Training Data Ratio", 0.1, 0.9, 0.5, 0.05)
-noise = st.sidebar.slider("Noise Level", 0.0, 0.5, 0.1, 0.01)
-batch_size = st.sidebar.slider("Batch Size", 5, 100, 10, 5)
-hidden_layers = st.sidebar.slider("Hidden Layers", 1, 5, 2)
-neurons_per_layer = st.sidebar.slider("Neurons per Hidden Layer", 2, 10, 4)
-activation_function = st.sidebar.selectbox("Activation Function", ["relu", "sigmoid", "tanh"])
-learning_rate = st.sidebar.slider("Learning Rate", 0.001, 0.1, 0.03, step=0.001)
+from sklearn.utils import shuffle
+
+# Custom CSS
+st.markdown("""
+    <style>
+    .sidebar .css-12oz5g7 {
+        background-color: #f0f2f6;
+        padding: 20px;
+        border-radius: 10px;
+    }
+    .sidebar .css-1xarl3l {
+        font-size: 20px;
+        color: #333333;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+# Sidebar Controls
+st.sidebar.title("🧠 Neural Network Settings")
+
+task_type = st.sidebar.selectbox("Task Type", ["Classification", "Regression"])
+dataset = st.sidebar.selectbox("Choose Dataset", ["Circles", "Exclusive OR", "Gaussian", "Spiral"])
+learning_rate = st.sidebar.slider("Learning Rate", 0.001, 1.0, 0.03, 0.001, format="%.3f")
+hidden_layers = st.sidebar.slider("Number of Hidden Layers", 1, 5, 3)
+
+neuron_counts = []
+for i in range(hidden_layers):
+    neuron_counts.append(st.sidebar.slider(f"Neurons in Hidden Layer {i+1}", 1, 20, 5))
+
+activation = st.sidebar.selectbox("Activation Function", ["relu", "sigmoid", "tanh", "linear"])
+epochs = st.sidebar.slider("Epochs", 1, 200, 100)
+
 regularization = st.sidebar.selectbox("Regularization", ["None", "L1", "L2"])
-reg_rate = st.sidebar.slider("Regularization Rate", 0.0, 0.1, 0.0, step=0.01)
-epochs = st.sidebar.slider("Epochs", 10, 500, 100)
-
-# Generate Dataset
-if dataset_choice == "Moons":
-    X, y = make_moons(n_samples=1000, noise=noise, random_state=42)
-elif dataset_choice == "Circles":
-    X, y = make_circles(n_samples=1000, noise=noise, factor=0.5, random_state=42)
+if regularization != "None":
+    regularization_rate = st.sidebar.slider("Regularization Rate", 0.0, 0.1, 0.01, 0.001, format="%.3f")
 else:
-    X, y = make_classification(n_samples=1000, n_features=2, n_classes=2, n_redundant=0, random_state=42)
+    regularization_rate = 0.0
+
+st.sidebar.markdown("---")
+st.sidebar.markdown(f"🔁 **Epochs:** {epochs} &nbsp;&nbsp; 🚀 **Learning Rate:** {learning_rate:.3f}")
+if regularization != "None":
+    st.sidebar.markdown(f"🧪 **Regularization:** {regularization} @ {regularization_rate}")
+
+# Title
+st.title("🎯 Neural Network Playground")
 
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=1-train_ratio, random_state=42)
+# Dataset Generator
+def generate_dataset(dataset):
+    if dataset == "Circles":
+        X, y = make_circles(n_samples=1000, noise=0.1, factor=0.5, random_state=0)
+    elif dataset == "Exclusive OR":
+        X = np.random.randn(1000, 2) * 2
+        y = np.logical_xor(X[:, 0] > 0, X[:, 1] > 0).astype(np.float32)
+    elif dataset == "Gaussian":
+        X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=0)
+        y = y.astype(np.float32)
+    elif dataset == "Spiral":
+        n = 1000
+        n_class = 2
+        X = np.zeros((n * n_class, 2))
+        y = np.zeros(n * n_class, dtype=np.float32)
+        for j in range(n_class):
+            ix = range(n * j, n * (j + 1))
+            r = np.linspace(0.0, 1, n)
+            t = np.linspace(j * 4, (j + 1) * 4, n) + np.random.randn(n) * 0.2
+            X[ix] = np.c_[r * np.sin(t), r * np.cos(t)]
+            y[ix] = j
+        X, y = shuffle(X, y)
+    return X, y
+
+# Data setup
+X, y = generate_dataset(dataset)
 scaler = StandardScaler()
-X_train = scaler.fit_transform(X_train)
-X_test = scaler.transform(X_test)
-
-# Build Neural Network
-model = keras.Sequential([keras.layers.InputLayer(input_shape=(2,))])
-reg = None
-if regularization == "L1":
-    reg = keras.regularizers.l1(reg_rate)
-elif regularization == "L2":
-    reg = keras.regularizers.l2(reg_rate)
-for _ in range(hidden_layers):
-    model.add(keras.layers.Dense(neurons_per_layer, activation=activation_function, kernel_regularizer=reg))
-model.add(keras.layers.Dense(1, activation="sigmoid"))
-
-optimizer = keras.optimizers.Adam(learning_rate=learning_rate)
-model.compile(optimizer=optimizer, loss="binary_crossentropy", metrics=["accuracy"])
-
-# Train the model
-history = model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0, validation_data=(X_test, y_test))
-
-# Training Progress Visualization
-st.subheader("Training Progress")
-fig, ax = plt.subplots(1, 2, figsize=(12, 4))
-ax[0].plot(history.history['loss'], label="Train Loss")
-ax[0].plot(history.history['val_loss'], label="Validation Loss")
-ax[0].set_title("Loss Curve")
-ax[0].legend()
-ax[1].plot(history.history['accuracy'], label="Train Accuracy")
-ax[1].plot(history.history['val_accuracy'], label="Validation Accuracy")
-ax[1].set_title("Accuracy Curve")
-ax[1].legend()
-st.pyplot(fig)
-
-# Neural Network Visualization
-st.subheader("Neural Network Structure")
-fig = go.Figure()
-layer_x_positions = [0] + [i * 2 for i in range(1, hidden_layers + 1)] + [hidden_layers * 2 + 2]
-layer_names = ["Input Layer"] + [f"Hidden Layer {i+1}" for i in range(hidden_layers)] + ["Output Layer"]
-for i, x in enumerate(layer_x_positions):
-    y_positions = np.linspace(-1, 1, neurons_per_layer if i != 0 and i != len(layer_x_positions) - 1 else 2)
-    fig.add_trace(go.Scatter(
-        x=[x] * len(y_positions), y=y_positions, mode='markers+text',
-        marker=dict(size=20, color='blue'),
-        text=[f"N{j+1}" for j in range(len(y_positions))], textposition="middle right", name=layer_names[i]
-    ))
-for i in range(len(layer_x_positions) - 1):
-    prev_y_positions = np.linspace(-1, 1, neurons_per_layer if i != 0 else 2)
-    next_y_positions = np.linspace(-1, 1, neurons_per_layer if i + 1 != len(layer_x_positions) - 1 else 1)
-    for y1 in prev_y_positions:
-        for y2 in next_y_positions:
-            fig.add_trace(go.Scatter(
-                x=[layer_x_positions[i], layer_x_positions[i + 1]],
-                y=[y1, y2], mode='lines', line=dict(color='gray', width=2), showlegend=False
-            ))
-st.plotly_chart(fig, use_container_width=True)
-
-# Decision Boundary Plot
-def plot_decision_boundary(model, X, y):
-    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
-    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
-    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
-                         np.linspace(y_min, y_max, 100))
+X = scaler.fit_transform(X)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Build model
+model = keras.Sequential()
+for i, count in enumerate(neuron_counts):
+    kwargs = {
+        "units": count,
+        "activation": activation,
+        "input_shape": (2,) if i == 0 else None
+    }
+    if regularization == "L1":
+        kwargs["kernel_regularizer"] = keras.regularizers.l1(regularization_rate)
+    elif regularization == "L2":
+        kwargs["kernel_regularizer"] = keras.regularizers.l2(regularization_rate)
+    model.add(keras.layers.Dense(**{k: v for k, v in kwargs.items() if v is not None}))
+
+if task_type == "Classification":
+    model.add(keras.layers.Dense(1, activation="sigmoid"))
+    loss = "binary_crossentropy"
+    metrics = ["accuracy"]
+else:
+    model.add(keras.layers.Dense(1, activation="linear"))
+    loss = "mse"
+    metrics = ["mae"]
 
+# Compile and train
+model.compile(optimizer=keras.optimizers.Adam(learning_rate), loss=loss, metrics=metrics)
+history = model.fit(X_train, y_train, epochs=epochs, batch_size=32, verbose=0, validation_split=0.2)
+
+# Visualization Functions
+def draw_neural_network(model):
+    G = nx.DiGraph()
+    pos = {}
+    input_nodes = ["X1", "X2"]
+    for i, node in enumerate(input_nodes):
+        G.add_node(node, layer=0)
+        pos[node] = (0, -i)
+
+    hidden_nodes = []
+    for layer_idx, layer in enumerate(model.layers[:-1]):
+        if isinstance(layer, keras.layers.Dense):
+            layer_nodes = [f"H{layer_idx+1}_{i+1}" for i in range(layer.units)]
+            hidden_nodes.append(layer_nodes)
+            for i, node in enumerate(layer_nodes):
+                G.add_node(node, layer=layer_idx + 1)
+                pos[node] = (layer_idx + 1, -i)
+
+    output_node = "Y"
+    G.add_node(output_node, layer=len(hidden_nodes) + 1)
+    pos[output_node] = (len(hidden_nodes) + 1, -0.5)
+
+    for inp in input_nodes:
+        for hid in hidden_nodes[0]:
+            G.add_edge(inp, hid)
+    for i in range(len(hidden_nodes) - 1):
+        for src in hidden_nodes[i]:
+            for dst in hidden_nodes[i + 1]:
+                G.add_edge(src, dst)
+    for node in hidden_nodes[-1]:
+        G.add_edge(node, output_node)
+
+    all_nodes = input_nodes + sum(hidden_nodes, []) + [output_node]
+    colors = ["lightblue"] * len(input_nodes) + ["lightcoral"] * sum(len(layer) for layer in hidden_nodes) + ["lightgreen"]
+
+    fig, ax = plt.subplots(figsize=(10, 8))
+    nx.draw(G, pos, with_labels=True, node_color=colors, edgecolors="black", node_size=1500, font_size=12, ax=ax, width=2, edge_color="gray", arrowsize=20)
+    ax.axis("off")
+    ax.set_title("Neural Network Architecture", fontsize=16)
+    st.pyplot(fig)
+
+def plot_decision_boundary(X, y, model):
+    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, 200), np.linspace(y_min, y_max, 200))
     Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
     Z = (Z > 0.5).astype(int).reshape(xx.shape)
 
-    plt.contourf(xx, yy, Z, alpha=0.3)
-    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors="k")
-    plt.title("Decision Boundary")
+    plt.figure(figsize=(10, 8))
+    plt.contourf(xx, yy, Z, alpha=0.8, cmap="coolwarm")
+    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors="k", cmap="coolwarm", s=100)
+    plt.xlabel("X1", fontsize=14)
+    plt.ylabel("X2", fontsize=14)
+    plt.title("Decision Boundary", fontsize=16)
     st.pyplot(plt)
 
-st.subheader("Decision Boundary")
-plot_decision_boundary(model, X_test, y_test)
+def plot_regression_surface(X, y, model):
+    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, 200), np.linspace(y_min, y_max, 200))
+    Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
+
+    fig = plt.figure(figsize=(10, 8))
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot_surface(xx, yy, Z, alpha=0.7, cmap='viridis')
+    ax.scatter(X[:, 0], X[:, 1], y, c=y, cmap='viridis', s=20)
+    ax.set_xlabel("X1", fontsize=14)
+    ax.set_ylabel("X2", fontsize=14)
+    ax.set_zlabel("Predicted", fontsize=14)
+    ax.set_title("Regression Surface", fontsize=16)
+    st.pyplot(fig)
+
+def plot_learning_curves(history):
+    plt.figure(figsize=(10, 6))
+    if task_type == "Classification":
+        plt.plot(history.history['accuracy'], label='Training Accuracy')
+        plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
+        plt.ylabel('Accuracy', fontsize=14)
+    else:
+        plt.plot(history.history['mae'], label='Training MAE')
+        plt.plot(history.history['val_mae'], label='Validation MAE')
+        plt.ylabel('Mean Absolute Error', fontsize=14)
+    plt.title(f'Model {task_type} Over Epochs', fontsize=16)
+    plt.xlabel('Epoch', fontsize=14)
+    plt.legend(fontsize=12)
+    st.pyplot(plt)
+
+# Visualizations
+st.subheader("Network Architecture")
+draw_neural_network(model)
+
+if task_type == "Classification":
+    st.subheader("Decision Boundary")
+    plot_decision_boundary(X, y, model)
+else:
+    st.subheader("Regression Surface")
+    plot_regression_surface(X, y, model)
+
+st.subheader(f"Learning Curves for {task_type}")
+plot_learning_curves(history)
+
+if st.checkbox("Show Model Summary"):
+    st.subheader("Model Summary")
+    model.summary(print_fn=lambda x: st.text(x))