Update Home.py

Home.py

@@ -1,115 +1,191 @@
-import tensorflow as tf
-from tensorflow.keras import layers, regularizers, optimizers, losses, metrics
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.callbacks import Callback
-
-# Custom Callback to Log Epoch Details
-class EpochLearningRateLogger(Callback):
-    """
-    Logs epoch number, learning rate, and model details during training.
-    """
-    def __init__(self, model, problem_type, activation_function, regularization_type=None, regularization_rate=None):
-        super().__init__()
-        self.model = model
-        self.problem_type = problem_type
-        self.activation_function = activation_function
-        self.regularization_type = regularization_type
-        self.regularization_rate = regularization_rate
-
-    def on_epoch_begin(self, epoch, logs=None):
-        optimizer = self.model.optimizer
-        learning_rate = optimizer.learning_rate.numpy()
-
-        print(f"\nEpoch: {epoch + 1}")
-        print(f"Learning Rate: {learning_rate}")
-        print(f"Problem Type: {self.problem_type}")
-        print(f"Activation Function: {self.activation_function}")
-
-        if self.regularization_type:
-            print(f"Regularization Type: {self.regularization_type}")
-            print(f"Regularization Rate: {self.regularization_rate}")
-
-# Function to Create the Model
-def create_model(input_shape, problem_type, activation_function='relu', regularization_type=None, regularization_rate=0.01, num_classes=None):
-    """
-    Builds and compiles a TensorFlow Keras model based on given parameters.
-    """
-    if problem_type == "classification" and num_classes is None:
-        raise ValueError("num_classes must be specified for classification problems.")
-
-    model = Sequential()
-    model.add(layers.Input(shape=input_shape))
-    model.add(layers.Flatten())  # Flatten input (useful for images)
-
-    # Apply Regularization if specified
-    kernel_regularizer = None
-    if regularization_type == 'l1':
-        kernel_regularizer = regularizers.L1(regularization_rate)
-    elif regularization_type == 'l2':
-        kernel_regularizer = regularizers.L2(regularization_rate)
-
-    # Hidden Layers
-    model.add(layers.Dense(128, activation=activation_function, kernel_regularizer=kernel_regularizer))
-    model.add(layers.Dense(64, activation=activation_function, kernel_regularizer=kernel_regularizer))
-
-    # Output Layer
-    if problem_type == "classification":
-        model.add(layers.Dense(num_classes, activation='softmax'))
-        loss_function = losses.CategoricalCrossentropy()
-        metrics_list = ['accuracy']
-    elif problem_type == "regression":
-        model.add(layers.Dense(1))  # Linear activation for regression
-        loss_function = losses.MeanSquaredError()
-        metrics_list = ['mean_absolute_error']
-    else:
-        raise ValueError("Invalid problem_type. Must be 'classification' or 'regression'.")
-
-    # Compile Model
-    model.compile(optimizer=optimizers.Adam(), loss=loss_function, metrics=metrics_list)
-    return model
-
-# Main Execution
-if __name__ == '__main__':
-    # Model Parameters
-    input_shape = (28, 28, 1)  # Example: MNIST images
-    num_classes = 10  # Example: MNIST has 10 classes
-    problem_type = "classification"
-    activation_function = 'relu'
-    regularization_type = 'l2'
-    regularization_rate = 0.001
-
-    # Create and Display Model Summary
-    model = create_model(input_shape, problem_type, activation_function, regularization_type, regularization_rate, num_classes)
-    model.summary()
-
-    # Load and Preprocess MNIST Data
-    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
-    x_train, x_test = x_train.astype('float32') / 255.0, x_test.astype('float32') / 255.0
-
-    # Reshape Images to Include Channel Dimension
-    x_train, x_test = x_train.reshape((-1, 28, 28, 1)), x_test.reshape((-1, 28, 28, 1))
-
-    # One-Hot Encoding for Classification
-    if problem_type == "classification":
-        y_train = tf.keras.utils.to_categorical(y_train, num_classes)
-        y_test = tf.keras.utils.to_categorical(y_test, num_classes)
-
-    # Define Custom Callback
-    epoch_lr_logger = EpochLearningRateLogger(
-        model=model,
-        problem_type=problem_type,
-        activation_function=activation_function,
-        regularization_type=regularization_type,
-        regularization_rate=regularization_rate
+mport streamlit as st
+import numpy as np
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from tensorflow import keras
+from tensorflow.keras import layers, regularizers
+
+def main():
+    st.title("Neural Network Playground (TensorFlow + Streamlit)")
+    st.write("""
+    This demo trains a simple feed-forward neural network on the Iris dataset.  
+    Adjust the hyperparameters below and click *Train* to see how they affect performance.
+    """)
+
+    # -----------------------------
+    # 1. SIDEBAR / HYPERPARAMETERS
+    # -----------------------------
+    st.sidebar.header("Hyperparameters")
+
+    # Learning Rate
+    learning_rate = st.sidebar.slider(
+        "Learning Rate", 
+        min_value=1e-5, 
+        max_value=1.0, 
+        value=0.01, 
+        step=1e-5
     )
 
-    # Train Model
-    history = model.fit(
-        x_train, y_train,
-        epochs=5,
-        batch_size=32,
-        validation_data=(x_test, y_test),
-        callbacks=[epoch_lr_logger]
+    # Regularization type
+    reg_type = st.sidebar.selectbox(
+        "Regularization Type", 
+        ["None", "L1", "L2", "L1L2"]
+    )
+    
+    # Regularization value
+    reg_value = st.sidebar.number_input(
+        "Regularization Value", 
+        value=0.01, 
+        step=0.01, 
+        min_value=0.0
+    )
+
+    # Activation function
+    activation_fn = st.sidebar.selectbox(
+        "Activation Function",
+        ["sigmoid", "tanh", "relu"]
+    )
+
+    # Number of hidden layers
+    num_hidden_layers = st.sidebar.slider(
+        "Number of Hidden Layers", 
+        min_value=0, 
+        max_value=5, 
+        value=1
+    )
+
+    # Neurons per hidden layer
+    neurons_per_layer = st.sidebar.slider(
+        "Neurons per Hidden Layer", 
+        min_value=1, 
+        max_value=128, 
+        value=16
+    )
+
+    # Ratio of training to test
+    test_size = st.sidebar.slider(
+        "Test Set Ratio", 
+        min_value=0.05, 
+        max_value=0.95, 
+        value=0.2, 
+        step=0.05
+    )
+
+    # Batch size & Epochs
+    batch_size = st.sidebar.selectbox(
+        "Batch Size", 
+        [8, 16, 32, 64, 128]
+    )
+    epochs = st.sidebar.slider(
+        "Epochs", 
+        min_value=1, 
+        max_value=200, 
+        value=50
+    )
+
+    # -----------------------------
+    # 2. DATA PREPARATION
+    # -----------------------------
+    iris = load_iris()
+    X = iris.data  # shape (150, 4)
+    y = iris.target.reshape(-1, 1)  # shape (150, 1)
+
+    # One-hot encode target
+    encoder = OneHotEncoder(sparse=False)
+    y_encoded = encoder.fit_transform(y)  # shape (150, 3)
+
+    # Split data
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y_encoded, 
+        test_size=test_size, 
+        random_state=42
     )
 
-    print("\nTraining Completed.")
+    # Scale features
+    scaler = StandardScaler()
+    X_train = scaler.fit_transform(X_train)
+    X_test = scaler.transform(X_test)
+
+    # -----------------------------
+    # 3. BUILD MODEL FUNCTION
+    # -----------------------------
+    def build_model(lr, reg_t, reg_v, activation, n_hidden, n_neurons):
+        # Choose the correct regularizer
+        if reg_t == "None":
+            reg = None
+        elif reg_t == "L1":
+            reg = regularizers.l1(reg_v)
+        elif reg_t == "L2":
+            reg = regularizers.l2(reg_v)
+        else:
+            reg = regularizers.l1_l2(reg_v, reg_v)
+        
+        model = keras.Sequential()
+        # Input layer shape = 4 (for Iris)
+        model.add(layers.Input(shape=(4,)))
+
+        # Add hidden layers
+        for _ in range(n_hidden):
+            model.add(
+                layers.Dense(
+                    n_neurons, 
+                    activation=activation, 
+                    kernel_regularizer=reg
+                )
+            )
+        
+        # Output layer (3 classes for Iris)
+        model.add(layers.Dense(3, activation='softmax'))
+
+        # Compile the model
+        model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=lr),
+            loss='categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        return model
+
+    # -----------------------------
+    # 4. TRAINING
+    # -----------------------------
+    if st.button("Train"):
+        st.write("### Training in progress...")
+        model = build_model(
+            learning_rate, 
+            reg_type, 
+            reg_value, 
+            activation_fn, 
+            num_hidden_layers, 
+            neurons_per_layer
+        )
+
+        history = model.fit(
+            X_train, 
+            y_train, 
+            epochs=epochs, 
+            batch_size=batch_size, 
+            validation_split=0.2,
+            verbose=0
+        )
+
+        # Plot training history
+        st.write("#### Accuracy")
+        st.line_chart({
+            "Train": history.history['accuracy'],
+            "Val": history.history['val_accuracy']
+        })
+
+        st.write("#### Loss")
+        st.line_chart({
+            "Train": history.history['loss'],
+            "Val": history.history['val_loss']
+        })
+
+        # Evaluate on test set
+        loss, acc = model.evaluate(X_test, y_test, verbose=0)
+        st.write(f"#### Test Loss: {loss:.4f}")
+        st.write(f"#### Test Accuracy: {acc:.4f}")
+
+if _name_ == "_main_":
+    main()