Update app.py

app.py

@@ -1,86 +1,273 @@
+# import streamlit as st 
+# import numpy as np 
+# 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 import keras
+# import matplotlib.pyplot as plt 
+# import seaborn as sns 
+# from keras.models import Sequential
+# from keras.layers import InputLayer,Dense,Dropout 
+# from keras.losses import MeanAbsoluteError,MeanSquaredError
+# from keras.optimizers import SGD
+# from keras.regularizers import l1,l1,l1_l2
+
+# from mlxtend.plotting import plot_decision_regions
+# import graphviz
+
+# st.title("TensorFlow Playground")
+
+# with st.sidebar:
+#     st.header("Choose Dataset")
+#     dataset = st.selectbox("Select Dataset",["Blobs","Circles","Moons"])
+#     # on = st.toggle("Upload Dataset(.csv file)")
+#     # if on:
+#     #     st.write("**Note:** Only 2 features are allowed.")
+#     #      up_file = st.file_uploader("Upload Dataset (.csv or .xlsx)", type=["csv"])
+        
+#     noise = st.slider("Noise",0.0,1.0,0.1)
+#     test_size = st.slider("Test Size",0.1,0.5,0.05)
+
+#     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)
+#     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)
+#     with col2:
+#         lr = st.selectbox("Learning Rate",[0.1,0.01,0.02,0.2])
+
+#     # col3,col4 = st.column(2)
+
+#     # with col3:
+#     reg = st.selectbox("Regularizer", ["None", "L1", "L2","ElasticNet"])
+#     if reg != "None":
+#         reg_rate = st.slider("Regularization rate", 0.0, 0.1, 0.01)
+#     # with col4:
+#     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.1)
+            
+#         with col4:
+#             patience = st.number_input("Patience",3,20,step=1)
+
+#     btn=st.sidebar.button("Train")
+            
+    
+    
+    
+# if btn:
+#     if dataset:
+#         if dataset=="Circles":
+#             x,y=make_circles(n_samples=1000,noise=noise,random_state=42,factor=0.1)
+#         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)
+
+#     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)
+
+
+#     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 = Sequential()
+#     model.add(InputLayer(shape=(2,)))
+#     if hl == len(nn):
+#         for i in range(0,len(nn)):
+#             model.add(Dense(units=nn[i],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"])
+#     train_size=round(x_train.shape[0]-x_train.shape[0]*0.2)
+
+#     callbacks = []
+#     if es == "Yes":
+#         es = EarlyStopping(
+#             monitor="val_loss",
+#             #min_delta= min_delta if min_delta else 0.001,
+#             min_delta = min_delta,
+#             patience=patience,
+#             verbose=1,
+#             restore_best_weights=True,
+#             start_from_epoch=50
+#         )
+#         callbacks.append(es)
+    
+#     hist=model.fit(x_train,y_train,epochs=epochs,batch_size=train_size,validation_data=(x_test, y_test),verbose=False)
+
+#     # # --- Neural Network Diagram ---
+#     # st.subheader("Neural Network Architecture")
+#     # stringlist = []
+#     # model.summary(print_fn=lambda x: stringlist.append(x))
+#     # summary_str = "\n".join(stringlist)
+#     # st.text(summary_str)
+
+#     # ---------------- 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)
+
+
+#     # --- Plotting Decision region ---
+#     st.subheader("Decision Region")
+#     fig1, ax1 = plt.subplots(figsize=(6, 5))
+#     plot_decision_regions(X=x_train, y=y_train.astype(np.int_), clf=model, ax=ax1)
+#     #plot_decision_regions(X=x_test, y=y_test.astype(np.int_), clf=model, ax=ax1)
+#     ax1.set_title("Decision Regions", fontsize=12, weight="bold")
+#     st.pyplot(fig1)
+
+#      # --- Plot 2: Training vs Validation Loss ---
+#     st.subheader("Training vs Validation Loss")
+#     fig2, ax2 = plt.subplots(figsize=(6, 5))
+#     ax2.plot(hist.history["loss"], label="Training Loss", linewidth=2)
+#     ax2.plot(hist.history["val_loss"], label="Validation Loss", linewidth=2, linestyle="--")
+#     ax2.set_xlabel("Epochs")
+#     ax2.set_ylabel("Loss")
+#     ax2.legend()
+#     ax2.grid(alpha=0.3)
+#     st.pyplot(fig2)
+            
+        
+    
 import streamlit as st 
 import numpy as np 
-from sklearn.datasets import make_circles,make_moons,make_blobs
+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 import keras
-import matplotlib.pyplot as plt 
-import seaborn as sns 
-from keras.models import Sequential
-from keras.layers import InputLayer,Dense,Dropout 
-from keras.losses import MeanAbsoluteError,MeanSquaredError
-from keras.optimizers import SGD
-from keras.regularizers import l1,l1,l1_l2
+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("Choose Dataset")
-    dataset = st.selectbox("Select Dataset",["Blobs","Circles","Moons"])
-    # on = st.toggle("Upload Dataset(.csv file)")
-    # if on:
-    #     st.write("**Note:** Only 2 features are allowed.")
-    #      up_file = st.file_uploader("Upload Dataset (.csv or .xlsx)", type=["csv"])
-        
-    noise = st.slider("Noise",0.0,1.0,0.1)
-    test_size = st.slider("Test Size",0.1,0.5,0.05)
+    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")
+    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)
-    epochs=st.number_input("Epochs",1,10000,step=1,value=10)
-    
+    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)
+        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])
-
-    # col3,col4 = st.column(2)
+        lr = st.selectbox("Learning Rate", [0.1, 0.01, 0.02, 0.2], index=1)
 
-    # with col3:
-    reg = st.selectbox("Regularizer", ["None", "L1", "L2","ElasticNet"])
+    reg = st.selectbox("Regularizer", ["None", "L1", "L2", "ElasticNet"])
     if reg != "None":
         reg_rate = st.slider("Regularization rate", 0.0, 0.1, 0.01)
-    # with col4:
-    es = st.selectbox("Early Stopping",["No","Yes"],index=0)
-    if es == "Yes":
+
+    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.1)
-            
+            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)
+            patience = st.number_input("Patience", 3, 20, step=1)
 
-    btn=st.sidebar.button("Train")
-            
-    
-    
-    
-if btn:
-    if dataset:
-        if dataset=="Circles":
-            x,y=make_circles(n_samples=1000,noise=noise,random_state=42,factor=0.1)
-        elif dataset=="moons":
-            x,y=make_moons(n_samples=1000,noise=noise,random_state=42)
+# -----------------------------
+# 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, random_state=42)
+            X, y = make_blobs(n_samples=1000, centers=2, cluster_std=noise+0.5, random_state=42)
 
-    x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=test_size,random_state=42,stratify=y)
+    # 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)
-
+    X_train = std.fit_transform(X_train)
+    X_test = std.transform(X_test)
 
+    # ---------------- Regularizer ----------------
     if reg == "L1":
         reg = l1(reg_rate)
     elif reg == "L2":
@@ -88,42 +275,70 @@ if btn:
     elif reg == "ElasticNet":
         reg = l1_l2(l1=reg_rate, l2=reg_rate)
     else:
-        reg=None
-
-
+        reg = None
 
+    # ---------------- Model ----------------
     model = Sequential()
     model.add(InputLayer(shape=(2,)))
     if hl == len(nn):
-        for i in range(0,len(nn)):
-            model.add(Dense(units=nn[i],activation=af,kernel_regularizer=reg))
+        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"])
-    train_size=round(x_train.shape[0]-x_train.shape[0]*0.2)
+    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 es == "Yes":
+    if early_stop_option == "Yes":
         es = EarlyStopping(
             monitor="val_loss",
-            #min_delta= min_delta if min_delta else 0.001,
-            min_delta = min_delta,
+            min_delta=min_delta,
             patience=patience,
             verbose=1,
             restore_best_weights=True,
-            start_from_epoch=50
+            start_from_epoch=50,
         )
         callbacks.append(es)
-    
-    hist=model.fit(x_train,y_train,epochs=epochs,batch_size=train_size,validation_data=(x_test, y_test),verbose=False)
 
-    # # --- Neural Network Diagram ---
-    # st.subheader("Neural Network Architecture")
-    # stringlist = []
-    # model.summary(print_fn=lambda x: stringlist.append(x))
-    # summary_str = "\n".join(stringlist)
-    # st.text(summary_str)
+    # ---------------- 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")
@@ -149,29 +364,6 @@ if btn:
     dot = visualize_nn(nn)
     st.graphviz_chart(dot)
 
-
-    # --- Plotting Decision region ---
-    st.subheader("Decision Region")
-    fig1, ax1 = plt.subplots(figsize=(6, 5))
-    plot_decision_regions(X=x_train, y=y_train.astype(np.int_), clf=model, ax=ax1)
-    #plot_decision_regions(X=x_test, y=y_test.astype(np.int_), clf=model, ax=ax1)
-    ax1.set_title("Decision Regions", fontsize=12, weight="bold")
-    st.pyplot(fig1)
-
-     # --- Plot 2: Training vs Validation Loss ---
-    st.subheader("Training vs Validation Loss")
-    fig2, ax2 = plt.subplots(figsize=(6, 5))
-    ax2.plot(hist.history["loss"], label="Training Loss", linewidth=2)
-    ax2.plot(hist.history["val_loss"], label="Validation Loss", linewidth=2, linestyle="--")
-    ax2.set_xlabel("Epochs")
-    ax2.set_ylabel("Loss")
-    ax2.legend()
-    ax2.grid(alpha=0.3)
-    st.pyplot(fig2)
-            
-        
-    
-