Create app.py

app.py

@@ -0,0 +1,165 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.datasets import make_classification, make_moons, make_circles
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.optimizers import SGD
+from mlxtend.plotting import plot_decision_regions
+
+# -------------------------------
+# PAGE CONFIGURATION
+# -------------------------------
+st.set_page_config(page_title="🧪 Neural Network Playground", layout="centered")
+st.title("🧬 Neural Network Playground")
+
+# -------------------------------
+# SESSION INITIALIZATION
+# -------------------------------
+def init_session():
+    defaults = {
+        'X': None, 'y': None, 'model': None,
+        'X_train': None, 'y_train': None,
+        'history': None
+    }
+    for key, value in defaults.items():
+        if key not in st.session_state:
+            st.session_state[key] = value
+
+init_session()
+
+# -------------------------------
+# DATA GENERATION FUNCTION
+# -------------------------------
+def generate_data(dataset, samples, noise, factor):
+    if dataset == "make_circles":
+        return make_circles(n_samples=samples, noise=noise, factor=factor, random_state=42)
+    elif dataset == "make_moons":
+        return make_moons(n_samples=samples, noise=noise, random_state=42)
+    else:
+        return make_classification(n_samples=samples, n_features=2, n_informative=2,
+                                   n_redundant=0, n_clusters_per_class=1,
+                                   flip_y=noise, random_state=42)
+
+# -------------------------------
+# MODEL TRAINING FUNCTION
+# -------------------------------
+def train_model(X, y, test_size, learning_rate, batch_size, epochs):
+    X_train, _, y_train, _ = train_test_split(X, y, test_size=test_size, random_state=1)
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+
+    model = Sequential([
+        Dense(8, activation='relu', input_shape=(2,)),
+        Dense(4, activation='relu'),
+        Dense(1, activation='sigmoid')
+    ])
+    model.compile(optimizer=SGD(learning_rate=learning_rate),
+                  loss='binary_crossentropy',
+                  metrics=['accuracy'])
+    
+    history = model.fit(X_train_scaled, y_train,
+                        validation_split=0.2,
+                        epochs=epochs,
+                        batch_size=batch_size,
+                        verbose=0)
+
+    return model, X_train_scaled, y_train, history
+
+# -------------------------------
+# PLOT FUNCTIONS
+# -------------------------------
+def plot_dataset(X, y):
+    df = pd.DataFrame(X, columns=['x1', 'x2'])
+    df['label'] = y
+    fig, ax = plt.subplots()
+    sns.scatterplot(data=df, x='x1', y='x2', hue='label', palette='viridis', ax=ax)
+    st.pyplot(fig)
+
+def plot_decision_boundary(model, X, y):
+    fig, ax = plt.subplots()
+    plot_decision_regions(X, y, clf=model, legend=2, ax=ax)
+    st.pyplot(fig)
+
+def plot_loss_curve(history):
+    fig, ax = plt.subplots()
+    ax.plot(history.history['loss'], label='Training Loss')
+    ax.plot(history.history['val_loss'], label='Validation Loss')
+    ax.set_xlabel("Epochs")
+    ax.set_ylabel("Loss")
+    ax.set_title("Loss Curve")
+    ax.legend()
+    st.pyplot(fig)
+
+# -------------------------------
+# STREAMLIT TABS
+# -------------------------------
+tab1, tab2, tab3 = st.tabs([
+    "🔹 Step 1: Data Generator",
+    "🔹 Step 2: Train Neural Net",
+    "🔹 Step 3: Visualize Results"
+])
+
+# -------------------------------
+# TAB 1: DATA GENERATOR
+# -------------------------------
+with tab1:
+    st.header("🎲 Generate Dataset")
+    col1, col2 = st.columns(2)
+    dataset = col1.selectbox("Dataset Type", ["make_classification", "make_moons", "make_circles"])
+    samples = col2.slider("Samples", 100, 5000, 1000, 100)
+    noise = st.slider("Noise", 0.0, 1.0, 0.2)
+    factor = st.slider("Factor (only for Circles)", 0.1, 1.0, 0.5)
+
+    if st.button("Generate"):
+        X, y = generate_data(dataset, samples, noise, factor)
+        st.session_state.X = X
+        st.session_state.y = y
+        st.success("✅ Data generated!")
+        plot_dataset(X, y)
+
+# -------------------------------
+# TAB 2: TRAINING
+# -------------------------------
+with tab2:
+    st.header("🧠 Train Model")
+
+    if st.session_state.X is None:
+        st.warning("⚠️ Generate data first in Step 1.")
+    else:
+        test_size = st.slider("Test Size (%)", 10, 90, 20) / 100
+        lr = st.selectbox("Learning Rate", [0.0001, 0.001, 0.01, 0.1])
+        batch_size = st.slider("Batch Size", 1, 512, 64)
+        epochs = st.slider("Epochs", 10, 500, 100)
+
+        if st.button("Train Model"):
+            with st.spinner("Training in progress..."):
+                model, X_train, y_train, history = train_model(
+                    st.session_state.X, st.session_state.y,
+                    test_size, lr, batch_size, epochs
+                )
+                st.session_state.model = model
+                st.session_state.X_train = X_train
+                st.session_state.y_train = y_train
+                st.session_state.history = history
+                st.success("✅ Training Complete!")
+
+# -------------------------------
+# TAB 3: VISUALIZATION
+# -------------------------------
+with tab3:
+    st.header("📊 Model Visualization")
+    if st.session_state.model is None:
+        st.warning("⚠️ Train the model in Step 2 to visualize results.")
+    else:
+        st.subheader("🌐 Decision Boundary")
+        plot_decision_boundary(st.session_state.model,
+                               st.session_state.X_train,
+                               st.session_state.y_train)
+
+        st.subheader("📉 Training Loss Curve")
+        plot_loss_curve(st.session_state.history)