Upload 4 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ann.jpeg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,58 @@
+import streamlit as st
+import base64
+
+# Set page config
+st.set_page_config(page_title="🧠 Neural Network Playground", layout="wide")
+
+# Background image function
+def set_background(image_path):
+    with open(image_path, "rb") as image_file:
+        encoded = base64.b64encode(image_file.read()).decode()
+
+    st.markdown(
+        f"""
+        <style>
+        .stApp {{
+            background-image: url("data:image/png;base64,{encoded}");
+            background-size: cover;
+            background-repeat: no-repeat;
+            background-position: center;
+            background-attachment: fixed;
+        }}
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+
+# Set background image
+set_background(r"ann.jpeg")
+
+
+# --- Project README/Intro Section ---
+
+st.markdown("""
+# 🧠 Interactive Neural Network Playground
+A Python app that lets users explore how neural networks learn by adjusting hyperparameters and visualizing the results.
+---
+### 🚀 What It Does
+- Lets you choose:
+    - **Dataset**: moons, circles, blobs, classification  
+    - **Learning rate**  
+    - **Activation**: ReLU, Sigmoid, Tanh  
+    - **Train-test split ratio**  
+    - **Batch size**
+    - **Epochs**:  
+    - **Hidden Layes**  
+    - **Number of Neurons**
+    
+    
+- Builds & trains a TensorFlow/Keras neural network on synthetic data.
+- Visualizes:
+    - 🌈 **Decision boundaries** (how the model classifies the space)
+    - 📈 **Training vs testing error** across epochs
+---
+### 🎯 Why It’s Useful
+✅ Understand hyperparameter effects  
+✅ See overfitting vs underfitting visually  
+✅ Learn neural network behavior interactively
+""")

pages/Tensorflow.py

@@ -0,0 +1,96 @@
+import streamlit as st
+import tensorflow as tf
+from tensorflow.keras.layers import Input, Dense
+from tensorflow.keras.models import Sequential
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.datasets import make_moons, make_circles, make_blobs, make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from mlxtend.plotting import plot_decision_regions
+import numpy as np
+
+st.title("Tensorflow Playground")
+
+data_sets = {
+    "make_classification": make_classification,
+    "make_moons": make_moons,
+    "make_circles": make_circles,
+    "make_blobs": make_blobs
+}
+
+learning_rate = st.sidebar.slider('Learning Rate', min_value=0.0001, max_value=0.1, value=0.001, step=0.0001, format="%.4f")
+noise = st.sidebar.slider('Noise Level', min_value=0.0, max_value=1.0, value=0.1, step=0.01, format="%.2f")
+epochs = st.sidebar.slider("Epochs", 1, 100, 10)
+num_hidden_layers = st.sidebar.slider('Number of Hidden Layers', min_value=1, max_value=10, value=2, step=1)
+neurons_per_layer = st.sidebar.slider("Neurons per Layer", 1, 512, 32)
+activation_function = st.sidebar.radio("Select the activation function", ["relu", "sigmoid", "tanh"])
+batch_size = st.sidebar.slider('Batch Size', min_value=8, max_value=512, value=32, step=8)
+test_size = st.sidebar.slider('test_size:', min_value=0.1, max_value=0.9, value=0.3, step=0.05)
+
+data_choice = st.sidebar.radio("Select the dataset", list(data_sets.keys()))
+
+if data_choice == "make_classification":
+    X, y = make_classification(n_samples=2000, n_features=2, n_redundant=0, n_clusters_per_class=1, random_state=27)
+elif data_choice == "make_blobs":
+    X, y = make_blobs(n_samples=2000, n_features=2, random_state=27)
+else:
+    X, y = data_sets[data_choice](n_samples=2000, noise=noise, random_state=27)
+
+if st.button("Start"):
+    st.subheader("📍 Input Data")
+    fig, ax = plt.subplots(figsize=(8, 6))
+    sns.scatterplot(x=X[:, 0], y=X[:, 1], hue=y, palette='Set2', ax=ax)
+    st.pyplot(fig)
+
+if st.button("Train Model"):
+    model = Sequential()
+    model.add(Input(shape=(2,)))
+    for i in range(num_hidden_layers):
+        model.add(Dense(units=neurons_per_layer, activation=activation_function))
+    model.add(Dense(units=1, activation="sigmoid"))
+
+    optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
+    model.compile(optimizer=optimizer, loss="binary_crossentropy", metrics=["accuracy"])
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=27)
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    history = model.fit(X_train_scaled, y_train, epochs=epochs, batch_size=batch_size, validation_split=0.2, verbose=0)
+
+    st.write(f"🧮 Final Training Loss: **{history.history['loss'][-1]:.4f}**")
+    st.write(f"✅ Final Validation Loss: **{history.history['val_loss'][-1]:.4f}**")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("#### Training vs Validation Loss Plot")
+        fig1, ax1 = plt.subplots(figsize=(8, 6))
+        ax1.plot(history.history["loss"], label="Training Loss", color="green")
+        ax1.plot(history.history["val_loss"], label="Validation Loss", color="red")
+        ax1.set_xlabel("Epoch", fontsize=14, fontweight='bold')
+        ax1.set_ylabel("Loss", fontsize=14, fontweight='bold')
+        ax1.legend()
+        st.pyplot(fig1)
+
+    with col2:
+        st.markdown("#### Decision Boundary Plot")
+
+        class KerasClassifierWrapper:
+            def __init__(self, model, scaler):
+                self.model = model
+                self.scaler = scaler
+
+            def predict(self, X):
+                X_scaled = self.scaler.transform(X)
+                preds = self.model.predict(X_scaled)
+                return np.where(preds > 0.5, 1, 0).flatten()
+
+        keras_clf = KerasClassifierWrapper(model, scaler)
+
+        fig2, ax2 = plt.subplots(figsize=(8, 6))
+        plot_decision_regions(X=X_train, y=y_train, clf=keras_clf, ax=ax2)
+        st.pyplot(fig2)