Update app.py

app.py

@@ -1,91 +1,111 @@
 import streamlit as st
 import numpy as np
 import matplotlib.pyplot as plt
-import tensorflow as tf
-from tensorflow import keras
-from sklearn.datasets import make_circles
+import networkx as nx
+from sklearn.datasets import make_classification, make_moons, make_circles, make_regression
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
-import seaborn as sns
-import networkx as nx
+from tensorflow import keras
+from tensorflow.keras import layers
 
-def generate_data():
-    X, y = make_circles(n_samples=500, factor=0.5, noise=0.05, random_state=42)
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=42)
-    scaler = StandardScaler()
-    X_train = scaler.fit_transform(X_train)
-    X_test = scaler.transform(X_test)
-    return X_train, X_test, y_train, y_test
+# Title Bar
+st.title("Neural Network Playground")
 
-def build_model(layers=[4, 2], activation='tanh', learning_rate=0.03):
-    model = keras.Sequential()
-    model.add(keras.layers.InputLayer(input_shape=(2,)))
-    
-    for units in layers:
-        model.add(keras.layers.Dense(units, activation=activation))
-    
-    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'])
-    return model
+# Navigation Bar
+col1, col2, col3, col4, col5, col6 = st.columns(6)
 
-def plot_decision_boundary(model, X, y):
-    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, 100), np.linspace(y_min, y_max, 100))
-    grid = np.c_[xx.ravel(), yy.ravel()]
-    preds = model.predict(grid).reshape(xx.shape)
+with col1:
+    epochs = st.selectbox("Epochs", [100, 200, 500, 800, 1000, 1500, 2000])
+with col2:
+    learning_rate = st.selectbox("Learning Rate", [0.0001, 0.001, 0.01, 0.1, 0.3, 1, 3, 10])
+with col3:
+    activation = st.selectbox("Activation Function", ["ReLU", "Tanh", "Sigmoid", "Linear"])
+with col4:
+    reg_type = st.selectbox("Regularization Type", ["L1", "L2", "None"])
+    reg_rate = st.slider("Regularization Rate", 0.0, 0.1, 0.01, step=0.01)
+with col5:
+    problem_type = st.selectbox("Problem Type", ["Classification", "Regression"])
+with col6:
+    play = st.button("Train Model")
+
+# Dataset Selection & Preprocessing
+st.subheader("Dataset Selection & Preprocessing")
+dataset_type = st.selectbox("Select Dataset", ["Binary Classification", "XOR", "Binary Spiral", "Binary Circles", "Regression 1", "Regression 2"])
+test_ratio = st.slider("Train-Test Split Ratio", 0.1, 0.5, 0.2, step=0.05)
+batch_size = st.slider("Batch Size", 4, 64, 16, step=2)
+
+data = None
+X_train, X_test, y_train, y_test = None, None, None, None
+if st.button("Generate Dataset"):
+    if dataset_type == "Binary Classification":
+        data = make_classification(n_samples=1000, n_features=2, n_classes=2, random_state=42)
+    elif dataset_type == "XOR":
+        data = make_moons(n_samples=1000, noise=0.2, random_state=42)
+    elif dataset_type == "Binary Spiral":
+        data = make_circles(n_samples=1000, noise=0.2, factor=0.5, random_state=42)
+    elif dataset_type == "Regression 1":
+        data = make_regression(n_samples=1000, n_features=1, noise=5, random_state=42)
+    elif dataset_type == "Regression 2":
+        X = np.linspace(-1, 1, 1000).reshape(-1, 1)
+        y = X ** 3 + 0.1 * np.random.randn(1000, 1).flatten()
+        data = (X, y)
     
-    plt.figure(figsize=(8, 6))
-    plt.contourf(xx, yy, preds, alpha=0.3)
-    plt.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm', edgecolor='k')
-    plt.xlabel('X1')
-    plt.ylabel('X2')
-    plt.title('Decision Boundary')
-    st.pyplot(plt)
+    if data:
+        X, y = data
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_ratio, random_state=42)
+        scaler = StandardScaler()
+        X_train = scaler.fit_transform(X_train)
+        X_test = scaler.transform(X_test)
+        st.success("Dataset Generated Successfully")
 
-def plot_network(layers):
+# Neural Network Architecture
+st.subheader("Neural Network Architecture")
+num_layers = st.slider("Number of Hidden Layers", 1, 5, 3)
+hidden_layers = []
+for i in range(num_layers):
+    neurons = st.slider(f"Neurons in Layer {i+1}", 2, 20, 5)
+    hidden_layers.append(neurons)
+
+def draw_nn(hidden_layers):
     G = nx.DiGraph()
-    layer_sizes = [2] + layers + [1]
-    
+    layer_sizes = [2] + hidden_layers + [1]
     pos = {}
-    node_idx = 0
+    
     for i, size in enumerate(layer_sizes):
         for j in range(size):
-            pos[node_idx] = (i, -j)
-            node_idx += 1
-    
-    node_idx = 0
-    for i in range(len(layer_sizes) - 1):
-        for j in range(layer_sizes[i]):
-            for k in range(layer_sizes[i+1]):
-                G.add_edge(node_idx + j, node_idx + layer_sizes[i] + k)
-        node_idx += layer_sizes[i]
+            G.add_node(f"L{i}_N{j}", layer=i, pos=(i, -j))
+            if i > 0:
+                for k in range(layer_sizes[i-1]):
+                    G.add_edge(f"L{i-1}_N{k}", f"L{i}_N{j}")
     
-    plt.figure(figsize=(8, 6))
-    nx.draw(G, pos, with_labels=False, node_size=500, edge_color='gray')
+    pos = nx.get_node_attributes(G, 'pos')
+    plt.figure(figsize=(8, 5))
+    nx.draw(G, pos, with_labels=False, node_size=600, node_color="lightblue", edge_color="gray")
     st.pyplot(plt)
 
-st.title("TensorFlow Playground Replica with Streamlit")
-
-layers = st.sidebar.text_input("Network Shape (comma-separated)", "4,2")
-layers = list(map(int, layers.split(',')))
-activation = st.sidebar.selectbox("Activation Function", ['tanh', 'relu', 'sigmoid'])
-learning_rate = st.sidebar.slider("Learning Rate", 0.001, 0.1, 0.03, step=0.001)
-batch_size = st.sidebar.slider("Batch Size", 5, 50, 10, step=5)
-epochs = st.sidebar.slider("Epochs", 10, 100, 50, step=10)
-
-X_train, X_test, y_train, y_test = generate_data()
-
-model = build_model(layers, activation, learning_rate)
-model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0)
+draw_nn(hidden_layers)
 
-plot_decision_boundary(model, X_test, y_test)
-
-st.write("## Model Performance")
-loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
-st.write(f"Test Accuracy: {accuracy:.4f}")
+# Model Training
+if play:
+    model = keras.Sequential()
+    model.add(layers.InputLayer(input_shape=(2,)))
+    for neurons in hidden_layers:
+        model.add(layers.Dense(neurons, activation=activation.lower(), kernel_regularizer=keras.regularizers.l1(reg_rate) if reg_type == "L1" else (keras.regularizers.l2(reg_rate) if reg_type == "L2" else None)))
+    model.add(layers.Dense(1, activation="sigmoid" if problem_type == "Classification" else "linear"))
+    model.compile(optimizer=keras.optimizers.Adam(learning_rate=learning_rate), loss="binary_crossentropy" if problem_type == "Classification" else "mse")
+    history = model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0)
+    st.success("Model Training Complete")
 
-st.write("## Neural Network Structure")
-plot_network(layers)
+# Decision Region Visualization
+if play:
+    st.subheader("Decision Boundary Visualization")
+    x_min, x_max = X_train[:, 0].min() - 1, X_train[:, 0].max() + 1
+    y_min, y_max = X_train[:, 1].min() - 1, X_train[:, 1].max() + 1
+    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
+    grid = np.c_[xx.ravel(), yy.ravel()]
+    preds = model.predict(grid).reshape(xx.shape)
+    plt.figure(figsize=(8, 5))
+    plt.contourf(xx, yy, preds, cmap="coolwarm", alpha=0.6)
+    plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap="coolwarm", edgecolors="k")
+    st.pyplot(plt)
+    st.success("Decision Region Updated")