Update app.py

app.py

@@ -171,201 +171,396 @@
             
         
     
+# import streamlit as st 
+# import numpy as np 
+# import pandas as pd
+# from sklearn.datasets import make_circles, make_moons, make_blobs
+# from sklearn.preprocessing import StandardScaler
+# from sklearn.model_selection import train_test_split
+# from tensorflow.keras.models import Sequential
+# from tensorflow.keras.layers import InputLayer, Dense
+# from tensorflow.keras.optimizers import SGD
+# from tensorflow.keras.regularizers import l1, l2, l1_l2
+# from tensorflow.keras.callbacks import EarlyStopping
+
+# import matplotlib.pyplot as plt 
+# from mlxtend.plotting import plot_decision_regions
+# import graphviz
+
+# # -----------------------------
+# # Streamlit UI
+# # -----------------------------
+# st.title("TensorFlow Playground")
+
+# with st.sidebar:
+#     st.header("Dataset Options")
+#     dataset_mode = st.radio("Choose Dataset Mode", ["Synthetic", "Upload CSV"])
+
+#     if dataset_mode == "Synthetic":
+#         dataset = st.selectbox("Select Dataset", ["Blobs", "Circles", "Moons"])
+#         noise = st.slider("Noise", 0.0, 1.0, 0.1)
+#         test_size = st.slider("Test Size", 0.1, 0.5, 0.2)
+#     else:
+#         uploaded_file = st.file_uploader("Upload your CSV", type=["csv"])
+#         if uploaded_file is not None:
+#             df = pd.read_csv(uploaded_file)
+#             if df.shape[1] < 3:
+#                 st.error("Your dataset must have at least 3 columns (2 features + 1 target).")
+#                 st.stop()
+#             feature_cols = st.multiselect("Select exactly 2 features", df.columns[:-1])
+#             target_col = st.selectbox("Select target column", df.columns)
+#             if len(feature_cols) != 2:
+#                 st.error("Please select exactly 2 features.")
+#                 st.stop()
+#             X = df[feature_cols].values
+#             y = df[target_col].values
+#             test_size = st.slider("Test Size", 0.1, 0.5, 0.2)
+#         else:
+#             st.warning("Upload a CSV file to continue.")
+#             st.stop()
+
+#     st.header("Model Hyperparameters")
+#     hl = st.number_input("Hidden Layers", 1, 10, step=1)
+#     numbers = st.text_input("Neurons for each hidden layer", placeholder="e.g. 8,16,32")
+#     input_func = lambda x: [int(i.strip()) for i in x.split(",") if i.strip() != ""]
+#     nn = input_func(numbers)
+#     n_epochs = st.number_input("Epochs", 1, 10000, step=1, value=50)
+
+#     col1, col2 = st.columns(2)
+#     with col1:
+#         af = st.selectbox("Activation Function", ["sigmoid", "tanh", "relu"], index=2)
+#     with col2:
+#         lr = st.selectbox("Learning Rate", [0.1, 0.01, 0.02, 0.2], index=1)
+
+#     reg = st.selectbox("Regularizer", ["None", "L1", "L2", "ElasticNet"])
+#     if reg != "None":
+#         reg_rate = st.slider("Regularization rate", 0.0, 0.1, 0.01)
+
+#     early_stop_option = st.selectbox("Early Stopping", ["No", "Yes"], index=0)
+#     if early_stop_option == "Yes":
+#         col3, col4 = st.columns(2)
+#         with col3:
+#             min_delta = st.number_input("Minimum Delta", 0.001, 0.9, step=0.01)
+#         with col4:
+#             patience = st.number_input("Patience", 3, 20, step=1)
+
+# # -----------------------------
+# # Train Button
+# # -----------------------------
+# if st.sidebar.button("Train"):
+#     # ---------------- Dataset ----------------
+#     if dataset_mode == "Synthetic":
+#         if dataset == "Circles":
+#             X, y = make_circles(n_samples=1000, noise=noise, random_state=42, factor=0.5)
+#         elif dataset == "Moons":
+#             X, y = make_moons(n_samples=1000, noise=noise, random_state=42)
+#         elif dataset == "Blobs":
+#             X, y = make_blobs(n_samples=1000, centers=2, cluster_std=noise+0.5, random_state=42)
+
+#     # Split dataset
+#     X_train, X_test, y_train, y_test = train_test_split(
+#         X, y, test_size=test_size, random_state=42, stratify=y
+#     )
+
+#     # Standardize
+#     std = StandardScaler()
+#     X_train = std.fit_transform(X_train)
+#     X_test = std.transform(X_test)
+
+#     # ---------------- Regularizer ----------------
+#     if reg == "L1":
+#         reg = l1(reg_rate)
+#     elif reg == "L2":
+#         reg = l2(reg_rate)
+#     elif reg == "ElasticNet":
+#         reg = l1_l2(l1=reg_rate, l2=reg_rate)
+#     else:
+#         reg = None
+
+#     # ---------------- Model ----------------
+#     model = Sequential()
+#     model.add(InputLayer(shape=(2,)))
+#     if hl == len(nn):
+#         for units in nn:
+#             model.add(Dense(units=units, activation=af, kernel_regularizer=reg))
+
+#     model.add(Dense(units=1, activation="sigmoid", kernel_regularizer=reg))
+#     sgd = SGD(learning_rate=lr)
+#     model.compile(loss="binary_crossentropy", optimizer=sgd, metrics=["accuracy"])
+
+#     # ---------------- Callbacks ----------------
+#     callbacks = []
+#     if early_stop_option == "Yes":
+#         es = EarlyStopping(
+#             monitor="val_loss",
+#             min_delta=min_delta,
+#             patience=patience,
+#             verbose=1,
+#             restore_best_weights=True,
+#             start_from_epoch=50,
+#         )
+#         callbacks.append(es)
+
+#     # ---------------- Training ----------------
+#     hist = model.fit(
+#         X_train,
+#         y_train,
+#         epochs=n_epochs,
+#         batch_size=len(X_train),
+#         validation_data=(X_test, y_test),
+#         verbose=0,
+#         callbacks=callbacks,
+#     )
+
+#     # ---------------- Decision Boundary ----------------
+#     st.subheader("Decision Boundary")
+#     fig, ax = plt.subplots()
+#     plot_decision_regions(X_test, y_test, clf=model, legend=2)
+#     plt.xlabel("Feature 1")
+#     plt.ylabel("Feature 2")
+#     st.pyplot(fig)
+
+#     # ---------------- Loss Curves ----------------
+#     st.subheader("Training vs Validation Loss")
+#     fig2, ax2 = plt.subplots()
+#     ax2.plot(hist.history["loss"], label="Train Loss")
+#     ax2.plot(hist.history["val_loss"], label="Validation Loss")
+#     ax2.set_xlabel("Epochs")
+#     ax2.set_ylabel("Loss")
+#     ax2.legend()
+#     st.pyplot(fig2)
+
+#     # ---------------- Accuracy Curves ----------------
+#     st.subheader("Training vs Validation Accuracy")
+#     fig3, ax3 = plt.subplots()
+#     ax3.plot(hist.history["accuracy"], label="Train Accuracy")
+#     ax3.plot(hist.history["val_accuracy"], label="Validation Accuracy")
+#     ax3.set_xlabel("Epochs")
+#     ax3.set_ylabel("Accuracy")
+#     ax3.legend()
+#     st.pyplot(fig3)
+
+#     # ---------------- Graphical NN Architecture ----------------
+#     st.subheader("Neural Network Architecture")
+
+#     def visualize_nn(layers):
+#         dot = graphviz.Digraph()
+#         dot.attr(rankdir="LR")
+
+#         dot.node("Input", "Input Layer\nfeatures=2", shape="box", style="filled", color="lightblue")
+
+#         for i, units in enumerate(layers):
+#             dot.node(f"H{i}", f"Hidden {i+1}\nunits={units}", shape="box", style="filled", color="lightgreen")
+#             if i == 0:
+#                 dot.edge("Input", f"H{i}")
+#             else:
+#                 dot.edge(f"H{i-1}", f"H{i}")
+
+#         dot.node("Output", "Output Layer\nunits=1", shape="box", style="filled", color="lightcoral")
+#         dot.edge(f"H{len(layers)-1}" if layers else "Input", "Output")
+
+#         return dot
+
+#     dot = visualize_nn(nn)
+#     st.graphviz_chart(dot)
+
+
 import streamlit as st 
 import numpy as np 
 import pandas as pd
 from sklearn.datasets import make_circles, make_moons, make_blobs
 from sklearn.preprocessing import StandardScaler
 from sklearn.model_selection import train_test_split
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import InputLayer, Dense
-from tensorflow.keras.optimizers import SGD
-from tensorflow.keras.regularizers import l1, l2, l1_l2
-from tensorflow.keras.callbacks import EarlyStopping
-
+from tensorflow import keras
 import matplotlib.pyplot as plt 
+from keras.models import Sequential
+from keras.layers import InputLayer, Dense, Dropout 
+from keras.optimizers import SGD
+from keras.regularizers import l1, l2, l1_l2
+from keras.callbacks import EarlyStopping
 from mlxtend.plotting import plot_decision_regions
-import graphviz
-
-# -----------------------------
-# Streamlit UI
-# -----------------------------
-st.title("TensorFlow Playground")
 
+# ========== Custom CSS ==========
+st.markdown("""
+    <style>
+        /* Background */
+        .stApp {
+            background: linear-gradient(to right, #f8f9fa, #eef2f3);
+            font-family: 'Segoe UI', sans-serif;
+        }
+        /* Sidebar */
+        section[data-testid="stSidebar"] {
+            background-color: #2C3E50 !important;
+        }
+        section[data-testid="stSidebar"] h1, 
+        section[data-testid="stSidebar"] h2, 
+        section[data-testid="stSidebar"] h3, 
+        section[data-testid="stSidebar"] label {
+            color: white !important;
+        }
+        /* Title */
+        h1 {
+            text-align: center;
+            color: #2C3E50;
+            font-size: 40px;
+            font-weight: bold;
+            margin-bottom: 20px;
+        }
+        /* Buttons */
+        div.stButton > button {
+            background: #3498DB;
+            color: white;
+            border-radius: 8px;
+            padding: 10px 24px;
+            border: none;
+            font-size: 16px;
+            transition: 0.3s;
+        }
+        div.stButton > button:hover {
+            background: #2980B9;
+        }
+        /* Select & Input */
+        .stSelectbox, .stNumberInput, .stSlider {
+            border-radius: 10px !important;
+        }
+        /* Charts */
+        .css-1v0mbdj, .css-1y0tads {
+            background-color: white;
+            padding: 20px;
+            border-radius: 12px;
+            box-shadow: 0px 4px 15px rgba(0,0,0,0.1);
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+# ========== Title ==========
+st.title("✨ TensorFlow Playground")
+
+# Sidebar
 with st.sidebar:
-    st.header("Dataset Options")
-    dataset_mode = st.radio("Choose Dataset Mode", ["Synthetic", "Upload CSV"])
+    st.header("Choose Dataset")
+    dataset = st.selectbox("Select Dataset", ["Blobs", "Circles", "Moons", "Upload CSV"])
 
-    if dataset_mode == "Synthetic":
-        dataset = st.selectbox("Select Dataset", ["Blobs", "Circles", "Moons"])
-        noise = st.slider("Noise", 0.0, 1.0, 0.1)
-        test_size = st.slider("Test Size", 0.1, 0.5, 0.2)
-    else:
-        uploaded_file = st.file_uploader("Upload your CSV", type=["csv"])
-        if uploaded_file is not None:
-            df = pd.read_csv(uploaded_file)
-            if df.shape[1] < 3:
-                st.error("Your dataset must have at least 3 columns (2 features + 1 target).")
-                st.stop()
-            feature_cols = st.multiselect("Select exactly 2 features", df.columns[:-1])
-            target_col = st.selectbox("Select target column", df.columns)
-            if len(feature_cols) != 2:
-                st.error("Please select exactly 2 features.")
-                st.stop()
-            X = df[feature_cols].values
-            y = df[target_col].values
-            test_size = st.slider("Test Size", 0.1, 0.5, 0.2)
-        else:
-            st.warning("Upload a CSV file to continue.")
-            st.stop()
+    noise = st.slider("Noise", 0.0, 1.0, 0.1)
+    test_size = st.slider("Test Size", 0.1, 0.5, 0.2)
 
     st.header("Model Hyperparameters")
     hl = st.number_input("Hidden Layers", 1, 10, step=1)
     numbers = st.text_input("Neurons for each hidden layer", placeholder="e.g. 8,16,32")
     input_func = lambda x: [int(i.strip()) for i in x.split(",") if i.strip() != ""]
     nn = input_func(numbers)
-    n_epochs = st.number_input("Epochs", 1, 10000, step=1, value=50)
+    epochs = st.number_input("Epochs", 1, 10000, step=1, value=10)
 
     col1, col2 = st.columns(2)
     with col1:
-        af = st.selectbox("Activation Function", ["sigmoid", "tanh", "relu"], index=2)
+        af = st.selectbox("Activation Function", ["Sigmoid", "Tanh", "Relu"], index=2)
     with col2:
-        lr = st.selectbox("Learning Rate", [0.1, 0.01, 0.02, 0.2], index=1)
+        lr = st.selectbox("Learning Rate", [0.1, 0.01, 0.02, 0.2])
 
     reg = st.selectbox("Regularizer", ["None", "L1", "L2", "ElasticNet"])
     if reg != "None":
         reg_rate = st.slider("Regularization rate", 0.0, 0.1, 0.01)
 
-    early_stop_option = st.selectbox("Early Stopping", ["No", "Yes"], index=0)
-    if early_stop_option == "Yes":
+    es = st.selectbox("Early Stopping", ["No", "Yes"], index=0)
+    if es == "Yes":
         col3, col4 = st.columns(2)
         with col3:
-            min_delta = st.number_input("Minimum Delta", 0.001, 0.9, step=0.01)
+            min_delta = st.number_input("Minimum Delta", 0.001, 0.9, step=0.1)
         with col4:
             patience = st.number_input("Patience", 3, 20, step=1)
 
-# -----------------------------
-# Train Button
-# -----------------------------
-if st.sidebar.button("Train"):
-    # ---------------- Dataset ----------------
-    if dataset_mode == "Synthetic":
-        if dataset == "Circles":
-            X, y = make_circles(n_samples=1000, noise=noise, random_state=42, factor=0.5)
-        elif dataset == "Moons":
-            X, y = make_moons(n_samples=1000, noise=noise, random_state=42)
-        elif dataset == "Blobs":
-            X, y = make_blobs(n_samples=1000, centers=2, cluster_std=noise+0.5, random_state=42)
-
-    # Split dataset
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, test_size=test_size, random_state=42, stratify=y
-    )
-
-    # Standardize
-    std = StandardScaler()
-    X_train = std.fit_transform(X_train)
-    X_test = std.transform(X_test)
-
-    # ---------------- Regularizer ----------------
-    if reg == "L1":
-        reg = l1(reg_rate)
-    elif reg == "L2":
-        reg = l2(reg_rate)
-    elif reg == "ElasticNet":
-        reg = l1_l2(l1=reg_rate, l2=reg_rate)
+# Dataset
+if dataset == "Upload CSV":
+    uploaded_file = st.sidebar.file_uploader("Upload your CSV", type=["csv"]) 
+    if uploaded_file is not None:
+        df = pd.read_csv(uploaded_file)
+        if df.shape[1] < 3:
+            st.error("Your dataset must have at least 3 columns (2 features + 1 target).")
+            st.stop()
+        feature_cols = st.sidebar.multiselect("Select exactly 2 features", df.columns[:-1])
+        target_col = st.sidebar.selectbox("Select target column", df.columns)
+        if len(feature_cols) != 2:
+            st.error("Please select exactly 2 features.")
+            st.stop()
+        X = df[feature_cols].values
+        y = df[target_col].values
     else:
-        reg = None
-
-    # ---------------- Model ----------------
-    model = Sequential()
-    model.add(InputLayer(shape=(2,)))
-    if hl == len(nn):
-        for units in nn:
-            model.add(Dense(units=units, activation=af, kernel_regularizer=reg))
-
-    model.add(Dense(units=1, activation="sigmoid", kernel_regularizer=reg))
-    sgd = SGD(learning_rate=lr)
-    model.compile(loss="binary_crossentropy", optimizer=sgd, metrics=["accuracy"])
-
-    # ---------------- Callbacks ----------------
-    callbacks = []
-    if early_stop_option == "Yes":
-        es = EarlyStopping(
-            monitor="val_loss",
-            min_delta=min_delta,
-            patience=patience,
-            verbose=1,
-            restore_best_weights=True,
-            start_from_epoch=50,
-        )
-        callbacks.append(es)
-
-    # ---------------- Training ----------------
-    hist = model.fit(
-        X_train,
-        y_train,
-        epochs=n_epochs,
-        batch_size=len(X_train),
-        validation_data=(X_test, y_test),
-        verbose=0,
-        callbacks=callbacks,
-    )
-
-    # ---------------- Decision Boundary ----------------
+        st.warning("Upload a CSV file to continue.")
+        st.stop()
+else:
+    if dataset == "Circles":
+        X, y = make_circles(n_samples=1000, noise=noise, random_state=42, factor=0.5)
+    elif dataset == "Moons":
+        X, y = make_moons(n_samples=1000, noise=noise, random_state=42)
+    elif dataset == "Blobs":
+        X, y = make_blobs(n_samples=1000, centers=2, cluster_std=noise, random_state=42)
+
+# Train-test split
+x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42, stratify=y)
+std = StandardScaler()
+x_train = std.fit_transform(x_train)
+x_test = std.transform(x_test)
+
+# Regularizer setup
+if reg == "L1":
+    reg = l1(reg_rate)
+elif reg == "L2":
+    reg = l2(reg_rate)
+elif reg == "ElasticNet":
+    reg = l1_l2(l1=reg_rate, l2=reg_rate)
+else:
+    reg = None
+
+# Build model
+model = Sequential()
+model.add(InputLayer(shape=(2,)))
+if hl == len(nn):
+    for i in range(len(nn)):
+        model.add(Dense(units=nn[i], activation=af.lower(), kernel_regularizer=reg))
+model.add(Dense(units=1, activation="sigmoid", kernel_regularizer=reg))
+
+sgd = SGD(learning_rate=lr)
+model.compile(loss="binary_crossentropy", optimizer=sgd, metrics=["accuracy"])
+
+callbacks = []
+if es == "Yes":
+    early_stopping = EarlyStopping(monitor="val_loss", min_delta=min_delta,
+                                   patience=patience, verbose=1,
+                                   restore_best_weights=True)
+    callbacks.append(early_stopping)
+
+if st.sidebar.button("🚀 Train Model"):
+    hist = model.fit(x_train, y_train, epochs=epochs, validation_data=(x_test, y_test),
+                     batch_size=32, verbose=0, callbacks=callbacks)
+
+    # Decision boundary
     st.subheader("Decision Boundary")
     fig, ax = plt.subplots()
-    plot_decision_regions(X_test, y_test, clf=model, legend=2)
-    plt.xlabel("Feature 1")
-    plt.ylabel("Feature 2")
+    plot_decision_regions(X, y, clf=model, legend=2)
     st.pyplot(fig)
 
-    # ---------------- Loss Curves ----------------
+    # Loss plot
     st.subheader("Training vs Validation Loss")
     fig2, ax2 = plt.subplots()
     ax2.plot(hist.history["loss"], label="Train Loss")
     ax2.plot(hist.history["val_loss"], label="Validation Loss")
-    ax2.set_xlabel("Epochs")
-    ax2.set_ylabel("Loss")
     ax2.legend()
     st.pyplot(fig2)
 
-    # ---------------- Accuracy Curves ----------------
-    st.subheader("Training vs Validation Accuracy")
+    # Neural network diagram
+    st.subheader("Neural Network Architecture")
     fig3, ax3 = plt.subplots()
-    ax3.plot(hist.history["accuracy"], label="Train Accuracy")
-    ax3.plot(hist.history["val_accuracy"], label="Validation Accuracy")
-    ax3.set_xlabel("Epochs")
-    ax3.set_ylabel("Accuracy")
-    ax3.legend()
+    layer_sizes = [2] + nn + [1]
+    for i, size in enumerate(layer_sizes):
+        for j in range(size):
+            ax3.scatter(i, j, s=800, color="skyblue", edgecolors="black")
+        if i < len(layer_sizes) - 1:
+            for j in range(size):
+                for k in range(layer_sizes[i + 1]):
+                    ax3.plot([i, i + 1], [j, k], color="gray", alpha=0.3)
+    ax3.axis("off")
     st.pyplot(fig3)
 
-    # ---------------- Graphical NN Architecture ----------------
-    st.subheader("Neural Network Architecture")
-
-    def visualize_nn(layers):
-        dot = graphviz.Digraph()
-        dot.attr(rankdir="LR")
-
-        dot.node("Input", "Input Layer\nfeatures=2", shape="box", style="filled", color="lightblue")
-
-        for i, units in enumerate(layers):
-            dot.node(f"H{i}", f"Hidden {i+1}\nunits={units}", shape="box", style="filled", color="lightgreen")
-            if i == 0:
-                dot.edge("Input", f"H{i}")
-            else:
-                dot.edge(f"H{i-1}", f"H{i}")
-
-        dot.node("Output", "Output Layer\nunits=1", shape="box", style="filled", color="lightcoral")
-        dot.edge(f"H{len(layers)-1}" if layers else "Input", "Output")
-
-        return dot
-
-    dot = visualize_nn(nn)
-    st.graphviz_chart(dot)
-
-    
-