Update app.py

app.py

@@ -12,7 +12,7 @@ from tensorflow.keras import layers
 st.title("Neural Network Playground")
 
 # Navigation Bar
-col1, col2, col3, col4, col5, col6 = st.columns(6)
+col1, col2, col3, col4, col5, col6, col7 = st.columns(7)
 
 with col1:
     epochs = st.selectbox("Epochs", [100, 200, 500, 800, 1000, 1500, 2000])
@@ -27,6 +27,8 @@ with col5:
     problem_type = st.selectbox("Problem Type", ["Classification", "Regression"])
 with col6:
     play = st.button("Train Model")
+with col7:
+    epoch_counter = st.empty()
 
 # Dataset Selection & Preprocessing
 st.subheader("Dataset Selection & Preprocessing")
@@ -34,78 +36,69 @@ dataset_type = st.selectbox("Select Dataset", ["Binary Classification", "XOR", "
 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
+data_generated = False
 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)
+        X, y = 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)
+        X, y = 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)
+        X, y = 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)
+        X, y = 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)
     
-    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")
-
-# 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] + hidden_layers + [1]
-    pos = {}
-    
-    for i, size in enumerate(layer_sizes):
-        for j in range(size):
-            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}")
-    
-    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)
-
-draw_nn(hidden_layers)
+    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)
+    data_generated = True
+    st.success("Dataset Generated Successfully")
+    st.subheader("Dataset Preview")
+    st.write("Features:")
+    st.write(X[:5])
+    st.write("Labels:")
+    st.write(y[:5])
 
 # Model Training
-if play:
+if play and data_generated:
     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.InputLayer(input_shape=(X_train.shape[1],)))
+    
+    for i in range(3):  # Defaulting to 3 layers
+        model.add(layers.Dense(10, 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.Dropout(0.2))
+    
     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)
+    model.compile(optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
+                  loss="binary_crossentropy" if problem_type == "Classification" else "mse",
+                  metrics=["accuracy"] if problem_type == "Classification" else [])
+    
+    history = model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0, validation_data=(X_test, y_test))
     st.success("Model Training Complete")
-
-# 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")
+    
+    # Plot Training History
+    st.subheader("Training Progress")
+    fig, ax = plt.subplots(1, 2, figsize=(15, 6))
+    ax[0].plot(history.history['loss'], label='Training Loss')
+    ax[0].plot(history.history['val_loss'], label='Validation Loss')
+    ax[0].set_title("Loss Curve")
+    ax[0].set_xlabel("Epochs")
+    ax[0].set_ylabel("Loss")
+    ax[0].legend()
+    
+    if problem_type == "Classification":
+        ax[1].plot(history.history['accuracy'], label='Training Accuracy')
+        ax[1].plot(history.history['val_accuracy'], label='Validation Accuracy')
+        ax[1].set_title("Accuracy Curve")
+        ax[1].set_xlabel("Epochs")
+        ax[1].set_ylabel("Accuracy")
+        ax[1].legend()
+    
+    st.pyplot(fig)