Update app.py

app.py

@@ -8,7 +8,7 @@ from sklearn.preprocessing import StandardScaler
 from mlxtend.plotting import plot_decision_regions
 import tensorflow as tf
 from keras.models import Sequential
-from keras.layers import Input, Dense
+from keras.layers import InputIY Dense
 from keras.optimizers import SGD
 from keras.losses import MeanSquaredError, BinaryCrossentropy
 from keras.regularizers import l2, l1
@@ -62,6 +62,11 @@ st.markdown("""
         border-radius: 5px;
         margin: 10px 0;
     }
+    .stSelectbox label, .stSlider label {
+        color: white;
+        font-size: 12px;
+        font-weight: bold;
+    }
     </style>
 """, unsafe_allow_html=True)
 
@@ -80,41 +85,41 @@ def reset_session():
     st.session_state.num_hidden_layers = 2
     st.session_state.hidden_layer_neurons = [4, 2]
 
-# Top control bar
+# Top control bar with labeled dropdowns and sliders
 with st.container():
     st.markdown('<div class="control-bar">', unsafe_allow_html=True)
     col1, col2, col3, col4, col5, col6, col7, col8, col9 = st.columns(9)
     with col1:
-        problem_type = st.selectbox("Problem", ["Classification", "Regression"], label_visibility="collapsed")
+        problem_type = st.selectbox("Problem Type", ["Classification", "Regression"])
     with col2:
         dataset_options = {"Classification": ["Blobs", "Circles", "Spirals", "XOR"], "Regression": ["Sine Wave"]}
-        dataset_type = st.selectbox("Dataset", dataset_options[problem_type], label_visibility="collapsed")
+        dataset_type = st.selectbox("Dataset", dataset_options[problem_type])
     with col3:
-        learning_rate = st.selectbox("Learning Rate", [0.0001, 0.001, 0.03, 0.1, 0.3, 1], index=2, label_visibility="collapsed")
+        learning_rate = st.selectbox("Learning Rate", [0.0001, 0.001, 0.03, 0.1, 0.3, 1], index=2)
     with col4:
-        activation = st.selectbox("Activation", ["ReLU", "Sigmoid", "Tanh"], index=2, label_visibility="collapsed")
+        activation = st.selectbox("Activation", ["ReLU", "Sigmoid", "Tanh"], index=2)
     with col5:
-        batch_size = st.slider("Batch Size", 1, 30, 10, label_visibility="collapsed")
+        batch_size = st.slider("Batch Size", 1, 30, 10)
     with col6:
-        noise_level = st.slider("Noise", 0, 50, 0, step=5, label_visibility="collapsed")
+        noise_level = st.slider("Noise", 0, 50, 0, step=5)
     with col7:
-        reg_type = st.selectbox("Regularization", ["None", "L1", "L2"], index=0, label_visibility="collapsed")
+        reg_type = st.selectbox("Regularization", ["None", "L1", "L2"], index=0)
     with col8:
-        reg_rate = st.selectbox("Reg Rate", [0.0, 0.001, 0.01, 0.1, 1], index=0, label_visibility="collapsed")
+        reg_rate = st.selectbox("Reg Rate", [0.0, 0.001, 0.01, 0.1, 1], index=0)
     with col9:
-        train_ratio = st.slider("Train %", 10, 90, 50, 10, label_visibility="collapsed") / 100
+        train_ratio = st.slider("Train %", 10, 90, 50, 10) / 100
     st.markdown('</div>', unsafe_allow_html=True)
 
 # Dataset generation
 def generate_xor(n_samples):
-    X = np.random.rand(n_samples, 2) * 2 - 1  # Range [-1, 1]
+    X = np.random.rand(n_samples, 2) * 2 - 1
     y = np.logical_xor(X[:, 0] > 0, X[:, 1] > 0).astype(int)
     return X, y
 
 def generate_sine_wave(n_samples, noise):
     X = np.linspace(-3, 3, n_samples).reshape(-1, 1)
     y = np.sin(X) + np.random.normal(0, noise / 100, X.shape)
-    return np.hstack([X, X**2]), y.ravel()  # Add X^2 as a second feature
+    return np.hstack([X, X**2]), y.ravel()
 
 if problem_type == "Classification":
     if dataset_type == "Blobs":
@@ -125,7 +130,7 @@ if problem_type == "Classification":
         fv, cv = make_moons(n_samples=800, noise=noise_level / 250)
     elif dataset_type == "XOR":
         fv, cv = generate_xor(800)
-else:  # Regression
+else:
     fv, cv = generate_sine_wave(800, noise_level)
 
 # Feature preprocessing
@@ -165,23 +170,57 @@ with col_center:
     st.markdown('<div class="panel">', unsafe_allow_html=True)
     st.subheader("Network")
 
-    def draw_nn(features, neurons):
+    def draw_nn(features, hidden_neurons):
         G = nx.DiGraph()
-        layers = [features] + [[f"h{i+1}_{j+1}" for j in range(n)] for i, n in enumerate(neurons)] + [["Output"]]
+        
+        # Define layers
+        input_layer = features
+        hidden_layers = [[f"H{i+1}_{j+1}" for j in range(n)] for i, n in enumerate(hidden_neurons)]
+        output_layer = ["Output"]
+        all_layers = [input_layer] + hidden_layers + [output_layer]
+
+        # Add nodes with layer attribute
         node_colors = {}
-        for layer_idx, layer in enumerate(layers):
+        for layer_idx, layer in enumerate(all_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")
+                if layer_idx == 0:
+                    node_colors[node] = "#90EE90"  # Input: Green
+                elif layer_idx == len(all_layers) - 1:
+                    node_colors[node] = "#FFA07A"  # Output: Orange
+                else:
+                    node_colors[node] = "#87CEFA"  # Hidden: Blue
+
+        # Add edges (fully connected)
+        for i in range(len(all_layers) - 1):
+            for node1 in all_layers[i]:
+                for node2 in all_layers[i + 1]:
+                    G.add_edge(node1, node2)
+
+        # Position nodes using multipartite layout
+        pos = nx.multipartite_layout(G, subset_key="layer", align="horizontal")
+        
+        # Adjust positions for better spacing
+        for node in pos:
+            pos[node][1] *= 2  # Increase vertical spacing
+
+        # Draw the network
         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", edgecolors="black",
-                node_size=600, font_size=8, font_color="black", width=0.4)
+        nx.draw(
+            G, pos, 
+            with_labels=True, 
+            node_color=[node_colors[node] for node in G.nodes()], 
+            edge_color="white", 
+            node_size=600, 
+            font_size=8, 
+            font_color="black", 
+            font_weight="bold", 
+            edgecolors="black", 
+            width=0.4, 
+            ax=ax
+        )
+        plt.title("Neural Network Structure", color="white", fontsize=12, pad=10)
         return fig
 
     st.pyplot(draw_nn(selected_features, st.session_state.hidden_layer_neurons))