Update Home.py

Home.py

@@ -1,12 +1,12 @@
-# import tensorflow as tf
+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):
     """
-    A Keras Callback that logs the epoch number, learning rate, 
-    and other model details during training.
+    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__()
@@ -17,11 +17,8 @@ class EpochLearningRateLogger(Callback):
         self.regularization_rate = regularization_rate
 
     def on_epoch_begin(self, epoch, logs=None):
-        """
-        Called at the beginning of each epoch.
-        """
-        optimizer = self.model.optimizer  # Access the optimizer directly
-        learning_rate = optimizer.learning_rate.numpy()  # Assuming learning rate is a Tensor/Variable
+        optimizer = self.model.optimizer
+        learning_rate = optimizer.learning_rate.numpy()
 
         print(f"\nEpoch: {epoch + 1}")
         print(f"Learning Rate: {learning_rate}")
@@ -32,113 +29,72 @@ class EpochLearningRateLogger(Callback):
             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):
     """
-    Creates a TensorFlow Keras model based on specified parameters.
-
-    Args:
-        input_shape:  Shape of the input data (e.g., (28, 28, 1) for MNIST).
-        problem_type: "classification" or "regression".
-        activation_function:  Activation function to use (e.g., 'relu', 'sigmoid', 'tanh').
-        regularization_type: 'l1' or 'l2', or None for no regularization.
-        regularization_rate:  The regularization strength (lambda).
-        num_classes:  Number of classes for classification problems. Required if problem_type is "classification".
-                      Ignored for "regression".
-
-    Returns:
-        A compiled Keras model.
+    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()
-    # Input Layer
     model.add(layers.Input(shape=input_shape))
-    model.add(layers.Flatten()) # Flatten image to 1D
+    model.add(layers.Flatten())  # Flatten input (useful for images)
 
-
-    # Hidden layers with regularization
+    # 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)
 
-
-    model.add(layers.Dense(128, activation=activation_function, kernel_regularizer=kernel_regularizer)) # Example Hidden Layer
-    model.add(layers.Dense(64, activation=activation_function, kernel_regularizer=kernel_regularizer))   # Another Example
-
+    # 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')) # Softmax for multi-class classification
+        model.add(layers.Dense(num_classes, activation='softmax'))
         loss_function = losses.CategoricalCrossentropy()
-        metrics_list = ['accuracy']  # Common classification metric
+        metrics_list = ['accuracy']
     elif problem_type == "regression":
-        model.add(layers.Dense(1)) # Linear activation for regression
+        model.add(layers.Dense(1))  # Linear activation for regression
         loss_function = losses.MeanSquaredError()
-        metrics_list = ['mean_absolute_error']  # Common regression metric
+        metrics_list = ['mean_absolute_error']
     else:
         raise ValueError("Invalid problem_type. Must be 'classification' or 'regression'.")
 
-
-    # Optimizer
-    optimizer = optimizers.Adam()  # You can configure the learning rate here if desired.
-
-    model.compile(optimizer=optimizer, loss=loss_function, metrics=metrics_list)
+    # Compile Model
+    model.compile(optimizer=optimizers.Adam(), loss=loss_function, metrics=metrics_list)
     return model
 
-
+# Main Execution
 if __name__ == '__main__':
-    # Example usage:
-    input_shape = (28, 28, 1)  # Example: MNIST image size
+    # Model Parameters
+    input_shape = (28, 28, 1)  # Example: MNIST images
     num_classes = 10  # Example: MNIST has 10 classes
-
-    # Define model parameters
-    problem_type = "classification"  # Or "regression"
+    problem_type = "classification"
     activation_function = 'relu'
-    regularization_type = 'l2'  # 'l1', 'l2', or None
+    regularization_type = 'l2'
     regularization_rate = 0.001
-    learning_rate = 0.001
-
-    # Create the model
-    model = create_model(
-        input_shape=input_shape,
-        problem_type=problem_type,
-        activation_function=activation_function,
-        regularization_type=regularization_type,
-        regularization_rate=regularization_rate,
-        num_classes=num_classes
-    )
 
-    # Print model summary
+    # 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 data (Example: MNIST)
+    # Load and Preprocess MNIST Data
     (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
-    x_train = x_train.astype('float32') / 255.0
-    x_test = x_test.astype('float32') / 255.0
-
-    # Reshape images to include the channel dimension
-    x_train = x_train.reshape((-1, 28, 28, 1))
-    x_test = x_test.reshape((-1, 28, 28, 1))
-
+    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)
 
-
-
-
-    # Create the custom callback
+    # Define Custom Callback
     epoch_lr_logger = EpochLearningRateLogger(
         model=model,
         problem_type=problem_type,
@@ -147,19 +103,13 @@ if __name__ == '__main__':
         regularization_rate=regularization_rate
     )
 
-
-
-    # Train the model
-    epochs = 5
-    batch_size = 32
-
+    # Train Model
     history = model.fit(
-        x_train,
-        y_train,
-        epochs=epochs,
-        batch_size=batch_size,
+        x_train, y_train,
+        epochs=5,
+        batch_size=32,
         validation_data=(x_test, y_test),
-        callbacks=[epoch_lr_logger]  # Pass the callback to the fit method
+        callbacks=[epoch_lr_logger]
     )
 
-    print("\nTraining completed.")
+    print("\nTraining Completed.")