Create app.py

app.py

@@ -0,0 +1,71 @@
+import streamlit as st
+
+# UI Inputs
+dataset = st.selectbox("Choose a Dataset", ["moons", "circles", "blobs"])
+learning_rate = st.number_input("Learning Rate", value=0.01, format="%.4f")
+activation = st.selectbox("Activation Function", ["relu", "sigmoid", "tanh"])
+split_ratio = st.slider("Train-Test Split Ratio", 0.5, 0.9, 0.7)
+batch_size = st.number_input("Batch Size", value=32, step=16)
+
+if st.button("Train Model"):
+    # Call your training and plotting function
+    train_and_visualize(dataset, learning_rate, activation, split_ratio, batch_size)
+
+from sklearn.datasets import make_moons, make_circles, make_blobs
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+import tensorflow as tf
+from tensorflow.keras import models, layers
+import matplotlib.pyplot as plt
+import numpy as np
+
+def generate_data(dataset, test_size):
+    if dataset == "moons":
+        X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
+    elif dataset == "circles":
+        X, y = make_circles(n_samples=1000, noise=0.2, factor=0.5, random_state=42)
+    else:
+        X, y = make_blobs(n_samples=1000, centers=2, cluster_std=1.5, random_state=42)
+    
+    X = StandardScaler().fit_transform(X)
+    return train_test_split(X, y, test_size=1-test_size, random_state=42)
+
+def build_model(activation, learning_rate):
+    model = models.Sequential([
+        layers.Dense(10, input_shape=(2,), activation=activation),
+        layers.Dense(10, activation=activation),
+        layers.Dense(1, activation="sigmoid")
+    ])
+    optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
+    model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])
+    return model
+
+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, 200),
+                         np.linspace(y_min, y_max, 200))
+    preds = model.predict(np.c_[xx.ravel(), yy.ravel()])
+    preds = preds.reshape(xx.shape)
+
+    plt.contourf(xx, yy, preds, alpha=0.5)
+    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdBu)
+    plt.title("Decision Boundary")
+    st.pyplot(plt.gcf())
+    plt.clf()
+
+def plot_loss(history):
+    plt.plot(history.history['loss'], label='Train Loss')
+    plt.plot(history.history['val_loss'], label='Test Loss')
+    plt.legend()
+    plt.title("Training vs Testing Error")
+    st.pyplot(plt.gcf())
+    plt.clf()
+
+def train_and_visualize(dataset, lr, act, split, batch):
+    X_train, X_test, y_train, y_test = generate_data(dataset, split)
+    model = build_model(act, lr)
+    history = model.fit(X_train, y_train, epochs=50, batch_size=batch,
+                        validation_data=(X_test, y_test), verbose=0)
+    plot_decision_boundary(model, np.vstack((X_train, X_test)), np.hstack((y_train, y_test)))
+    plot_loss(history)