--- a
+++ b/modules/DL_utils.py
@@ -0,0 +1,603 @@
+# Utility functions for deep learning with Keras
+# Dr. Tirthajyoti Sarkar, Fremont, CA 94536
+# ==============================================
+
+# NOTES
+# Used tf.keras in general except in special functions where older/independent Keras has been used.
+
+import tensorflow as tf
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+class myCallback(tf.keras.callbacks.Callback):
+    """
+  User can pass on the desired accuracy threshold while creating an instance of the class
+  """
+
+    def __init__(self, acc_threshold=0.9, print_msg=True):
+        self.acc_threshold = acc_threshold
+        self.print_msg = print_msg
+
+    def on_epoch_end(self, epoch, logs={}):
+        if logs.get("acc") > self.acc_threshold:
+            if self.print_msg:
+                print(
+                    "\nReached {}% accuracy so cancelling the training!".format(
+                        self.acc_threshold
+                    )
+                )
+            self.model.stop_training = True
+        else:
+            if self.print_msg:
+                print("\nAccuracy not high enough. Starting another epoch...\n")
+
+    def build_classification_model(
+        num_layers=1,
+        architecture=[32],
+        act_func="relu",
+        input_shape=(28, 28),
+        output_class=10,
+    ):
+        """
+  Builds a densely connected neural network model from user input
+  
+  Arguments
+          num_layers: Number of hidden layers
+          architecture: Architecture of the hidden layers (densely connected)
+          act_func: Activation function. Could be 'relu', 'sigmoid', or 'tanh'.
+          input_shape: Dimension of the input vector
+          output_class: Number of classes in the output vector
+  Returns
+          A neural net (Keras) model for classification
+  """
+        layers = [tf.keras.layers.Flatten(input_shape=input_shape)]
+        if act_func == "relu":
+            activation = tf.nn.relu
+        elif act_func == "sigmoid":
+            activation = tf.nn.sigmoid
+        elif act_func == "tanh":
+            activation = tf.nn.tanh
+
+        for i in range(num_layers):
+            layers.append(tf.keras.layers.Dense(architecture[i], activation=tf.nn.relu))
+        layers.append(tf.keras.layers.Dense(output_class, activation=tf.nn.softmax))
+
+        model = tf.keras.models.Sequential(layers)
+        return model
+
+
+def build_regression_model(
+    input_neurons=10, input_dim=1, num_layers=1, architecture=[32], act_func="relu"
+):
+    """
+  Builds a densely connected neural network model from user input
+  
+  Arguments
+          num_layers: Number of hidden layers
+          architecture: Architecture of the hidden layers (densely connected)
+          act_func: Activation function. Could be 'relu', 'sigmoid', or 'tanh'.
+          input_shape: Dimension of the input vector
+  Returns
+          A neural net (Keras) model for regression
+  """
+    if act_func == "relu":
+        activation = tf.nn.relu
+    elif act_func == "sigmoid":
+        activation = tf.nn.sigmoid
+    elif act_func == "tanh":
+        activation = tf.nn.tanh
+
+    layers = [
+        tf.keras.layers.Dense(input_neurons, input_dim=input_dim, activation=activation)
+    ]
+
+    for i in range(num_layers):
+        layers.append(tf.keras.layers.Dense(architecture[i], activation=activation))
+    layers.append(tf.keras.layers.Dense(1))
+
+    model = tf.keras.models.Sequential(layers)
+    return model
+
+
+def compile_train_classification_model(
+    model,
+    x_train,
+    y_train,
+    callbacks=None,
+    learning_rate=0.001,
+    batch_size=1,
+    epochs=10,
+    verbose=0,
+):
+    """
+  Compiles and trains a given Keras model with the given data. 
+  Assumes Adam optimizer for this implementation.
+  Assumes categorical cross-entropy loss.
+  
+  Arguments
+          learning_rate: Learning rate for the optimizer Adam
+          batch_size: Batch size for the mini-batch optimization
+          epochs: Number of epochs to train
+          verbose: Verbosity of the training process
+  
+  Returns
+  A copy of the model
+  """
+
+    model_copy = model
+    model_copy.compile(
+        optimizer=tf.keras.optimizers.Adam(lr=learning_rate),
+        loss="sparse_categorical_crossentropy",
+        metrics=["accuracy"],
+    )
+
+    if callbacks != None:
+        model_copy.fit(
+            x_train,
+            y_train,
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=[callbacks],
+            verbose=verbose,
+        )
+    else:
+        model_copy.fit(
+            x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=verbose
+        )
+    return model_copy
+
+
+def compile_train_regression_model(
+    model,
+    x_train,
+    y_train,
+    callbacks=None,
+    learning_rate=0.001,
+    batch_size=1,
+    epochs=10,
+    verbose=0,
+):
+    """
+  Compiles and trains a given Keras model with the given data for regression. 
+  Assumes Adam optimizer for this implementation.
+  Assumes mean-squared-error loss
+  
+  Arguments
+          learning_rate: Learning rate for the optimizer Adam
+          batch_size: Batch size for the mini-batch operation
+          epochs: Number of epochs to train
+          verbose: Verbosity of the training process
+  
+  Returns
+  A copy of the model
+  """
+
+    model_copy = model
+    model_copy.compile(
+        optimizer=tf.keras.optimizers.Adam(lr=learning_rate),
+        loss="mean_squared_error",
+        metrics=["accuracy"],
+    )
+    if callbacks != None:
+        model_copy.fit(
+            x_train,
+            y_train,
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=[callbacks],
+            verbose=verbose,
+        )
+    else:
+        model_copy.fit(
+            x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=verbose
+        )
+    return model_copy
+
+
+def plot_loss_acc(model, target_acc=0.9, title=None):
+    """
+  Takes a Keras model and plots the loss and accuracy over epochs.
+  The same plot shows loss and accuracy on two axes - left and right (with separate scales)
+  Users can supply a title if desired
+  Arguments:
+            target_acc (optional): The desired/ target acc for the function to show a horizontal bar.
+            title (optional): A Python string object to show as the plot's title
+  """
+    e = (
+        np.array(model.history.epoch) + 1
+    )  # Add one to the list of epochs which is zero-indexed
+    # Check to see if loss metric is in the model history
+    assert (
+        "loss" in model.history.history.keys()
+    ), "No loss metric found in the model history"
+    l = np.array(model.history.history["loss"])
+    # Check to see if loss metric is in the model history
+    assert (
+        "acc" in model.history.history.keys()
+    ), "No accuracy metric found in the model history"
+    a = np.array(model.history.history["acc"])
+
+    fig, ax1 = plt.subplots()
+
+    color = "tab:red"
+    ax1.set_xlabel("Epochs", fontsize=15)
+    ax1.set_ylabel("Loss", color=color, fontsize=15)
+    ax1.plot(e, l, color=color, lw=2)
+    ax1.tick_params(axis="y", labelcolor=color)
+    ax1.grid(True)
+
+    ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis
+
+    color = "tab:blue"
+    ax2.set_ylabel(
+        "Accuracy", color=color, fontsize=15
+    )  # we already handled the x-label with ax1
+    ax2.plot(e, a, color=color, lw=2)
+    ax2.tick_params(axis="y", labelcolor=color)
+
+    fig.tight_layout()  # otherwise the right y-label is slightly clipped
+    if title != None:
+        plt.title(title)
+    plt.hlines(
+        y=target_acc, xmin=1, xmax=e.max(), colors="k", linestyles="dashed", lw=3
+    )
+    plt.show()
+
+
+def plot_train_val_acc(model, target_acc=0.9, title=None):
+    """
+  Takes a Keras model and plots the training and validation set accuracy over epochs.
+  The same plot shows both the accuracies on two axes - left and right (with separate scales)
+  Users can supply a title if desired
+  Arguments:
+            target_acc (optional): The desired/ target acc for the function to show a horizontal bar.
+            title (optional): A Python string object to show as the plot's title
+  """
+    e = (
+        np.array(model.history.epoch) + 1
+    )  # Add one to the list of epochs which is zero-indexed
+    # Check to see if loss metric is in the model history
+    assert (
+        "acc" in model.history.history.keys()
+    ), "No accuracy metric found in the model history"
+    a = np.array(model.history.history["acc"])
+    # Check to see if loss metric is in the model history
+    assert (
+        "val_acc" in model.history.history.keys()
+    ), "No validation accuracy metric found in the model history"
+    va = np.array(model.history.history["val_acc"])
+
+    fig, ax1 = plt.subplots()
+
+    color = "tab:red"
+    ax1.set_xlabel("Epochs", fontsize=15)
+    ax1.set_ylabel("Training accuracy", color=color, fontsize=15)
+    ax1.plot(e, a, color=color, lw=2)
+    ax1.tick_params(axis="y", labelcolor=color)
+    ax1.grid(True)
+
+    ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis
+
+    color = "tab:blue"
+    ax2.set_ylabel(
+        "Validation accuracy", color=color, fontsize=15
+    )  # we already handled the x-label with ax1
+    ax2.plot(e, va, color=color, lw=2)
+    ax2.tick_params(axis="y", labelcolor=color)
+
+    fig.tight_layout()  # otherwise the right y-label is slightly clipped
+    if title != None:
+        plt.title(title)
+
+    plt.hlines(
+        y=target_acc, xmin=1, xmax=e.max(), colors="k", linestyles="dashed", lw=3
+    )
+
+    plt.show()
+
+
+def train_CNN(
+    train_directory,
+    target_size=(256, 256),
+    callbacks=None,
+    classes=None,
+    batch_size=128,
+    num_classes=2,
+    num_epochs=20,
+    verbose=0,
+):
+    """
+    Trains a conv net for a given dataset contained within a training directory.
+    Users can just supply the path of the training directory and get back a fully trained, 5-layer, convolutional network.
+    
+    Arguments:
+            train_directory: The directory where the training images are stored in separate folders.
+                            These folders should be named as per the classes.
+            target_size: Target size for the training images. A tuple e.g. (200,200)
+            classes: A Python list with the classes 
+            batch_size: Batch size for training
+            num_epochs: Number of epochs for training
+            num_classes: Number of output classes to consider
+            verbose: Verbosity level of the training, passed on to the `fit_generator` method
+    Returns:
+            A trained conv net model
+    
+    """
+    from tensorflow.keras.preprocessing.image import ImageDataGenerator
+    import tensorflow as tf
+    from tensorflow.keras.optimizers import RMSprop
+
+    # ImageDataGenerator object instance with scaling
+    train_datagen = ImageDataGenerator(rescale=1 / 255)
+
+    # Flow training images in batches using the generator
+    train_generator = train_datagen.flow_from_directory(
+        train_directory,  # This is the source directory for training images
+        target_size=target_size,  # All images will be resized to 200 x 200
+        batch_size=batch_size,
+        # Specify the classes explicitly
+        classes=classes,
+        # Since we use categorical_crossentropy loss, we need categorical labels
+        class_mode="categorical",
+    )
+
+    input_shape = tuple(list(target_size) + [3])
+
+    # Model architecture
+    model = tf.keras.models.Sequential(
+        [
+            # Note the input shape is the desired size of the image 200x 200 with 3 bytes color
+            # The first convolution
+            tf.keras.layers.Conv2D(
+                16, (3, 3), activation="relu", input_shape=input_shape
+            ),
+            tf.keras.layers.MaxPooling2D(2, 2),
+            # The second convolution
+            tf.keras.layers.Conv2D(32, (3, 3), activation="relu"),
+            tf.keras.layers.MaxPooling2D(2, 2),
+            # The third convolution
+            tf.keras.layers.Conv2D(64, (3, 3), activation="relu"),
+            tf.keras.layers.MaxPooling2D(2, 2),
+            # The fourth convolution
+            tf.keras.layers.Conv2D(64, (3, 3), activation="relu"),
+            tf.keras.layers.MaxPooling2D(2, 2),
+            # The fifth convolution
+            tf.keras.layers.Conv2D(64, (3, 3), activation="relu"),
+            tf.keras.layers.MaxPooling2D(2, 2),
+            # Flatten the results to feed into a dense layer
+            tf.keras.layers.Flatten(),
+            # 512 neuron in the fully-connected layer
+            tf.keras.layers.Dense(512, activation="relu"),
+            # Output neurons for `num_classes` classes with the softmax activation
+            tf.keras.layers.Dense(num_classes, activation="softmax"),
+        ]
+    )
+
+    # Optimizer and compilation
+    model.compile(
+        loss="categorical_crossentropy", optimizer=RMSprop(lr=0.001), metrics=["acc"]
+    )
+
+    # Total sample count
+    total_sample = train_generator.n
+
+    # Training
+    model.fit_generator(
+        train_generator,
+        callbacks=callbacks,
+        steps_per_epoch=int(total_sample / batch_size),
+        epochs=num_epochs,
+        verbose=verbose,
+    )
+
+    return model
+
+
+def train_CNN_keras(
+    train_directory,
+    target_size=(256, 256),
+    classes=None,
+    batch_size=128,
+    num_classes=2,
+    num_epochs=20,
+    verbose=0,
+):
+    """
+    Trains a conv net for a given dataset contained within a training directory.
+    Users can just supply the path of the training directory and get back a fully trained, 5-layer, convolutional network.
+    
+    Arguments:
+            train_directory: The directory where the training images are stored in separate folders.
+                            These folders should be named as per the classes.
+            target_size: Target size for the training images. A tuple e.g. (200,200)
+            classes: A Python list with the classes 
+            batch_size: Batch size for training
+            num_epochs: Number of epochs for training
+            num_classes: Number of output classes to consider
+            verbose: Verbosity level of the training, passed on to the `fit_generator` method
+    Returns:
+            A trained conv net model
+    
+    """
+    from keras.layers import Conv2D, MaxPooling2D
+    from keras.layers import Dense, Dropout, Flatten
+    from keras.models import Sequential
+    from keras.optimizers import RMSprop
+    from keras.preprocessing.image import ImageDataGenerator
+
+    # ImageDataGenerator object instance with scaling
+    train_datagen = ImageDataGenerator(rescale=1 / 255)
+
+    # Flow training images in batches using the generator
+    train_generator = train_datagen.flow_from_directory(
+        train_directory,  # This is the source directory for training images
+        target_size=target_size,  # All images will be resized to 200 x 200
+        batch_size=batch_size,
+        # Specify the classes explicitly
+        classes=classes,
+        # Since we use categorical_crossentropy loss, we need categorical labels
+        class_mode="categorical",
+    )
+
+    input_shape = tuple(list(target_size) + [3])
+
+    # Model architecture
+    model = Sequential(
+        [
+            # Note the input shape is the desired size of the image 200x 200 with 3 bytes color
+            # The first convolution
+            Conv2D(16, (3, 3), activation="relu", input_shape=input_shape),
+            MaxPooling2D(2, 2),
+            # The second convolution
+            Conv2D(32, (3, 3), activation="relu"),
+            MaxPooling2D(2, 2),
+            # The third convolution
+            Conv2D(64, (3, 3), activation="relu"),
+            MaxPooling2D(2, 2),
+            # The fourth convolution
+            Conv2D(64, (3, 3), activation="relu"),
+            MaxPooling2D(2, 2),
+            # The fifth convolution
+            Conv2D(64, (3, 3), activation="relu"),
+            MaxPooling2D(2, 2),
+            # Flatten the results to feed into a dense layer
+            Flatten(),
+            # 512 neuron in the fully-connected layer
+            Dense(512, activation="relu"),
+            # Output neurons for `num_classes` classes with the softmax activation
+            Dense(num_classes, activation="softmax"),
+        ]
+    )
+
+    # Optimizer and compilation
+    model.compile(
+        loss="categorical_crossentropy", optimizer=RMSprop(lr=0.001), metrics=["acc"]
+    )
+
+    # Total sample count
+    total_sample = train_generator.n
+
+    # Training
+    model.fit_generator(
+        train_generator,
+        steps_per_epoch=int(total_sample / batch_size),
+        epochs=num_epochs,
+        verbose=verbose,
+    )
+
+    return model
+
+
+def preprocess_image(img_path, model=None, rescale=255, resize=(256, 256)):
+    """
+    Preprocesses a given image for prediction with a trained model, with rescaling and resizing options
+    
+    Arguments:
+            img_path: The path to the image file
+            rescale: A float or integer indicating required rescaling. 
+                    The image array will be divided (scaled) by this number.
+            resize: A tuple indicating desired target size. 
+                    This should match the input shape as expected by the model
+    Returns:
+            img: A processed image.
+    """
+    from keras.preprocessing.image import img_to_array, load_img
+    import cv2
+    import numpy as np
+
+    assert type(img_path) == str, "Image path must be a string"
+    assert (
+        type(rescale) == int or type(rescale) == float
+    ), "Rescale factor must be either a float or int"
+    assert (
+        type(resize) == tuple and len(resize) == 2
+    ), "Resize target must be a tuple with two elements"
+
+#    img = load_img(img_path)    
+    img = load_img(img_path,grayscale=True)
+    img = img_to_array(img)
+    img = img / float(rescale)
+    img = cv2.resize(img, resize)
+    if model != None:
+        if len(model.input_shape) == 4:
+            img = np.expand_dims(img, axis=0)
+
+    return img
+
+
+def pred_prob_with_model(img_path, model, rescale=255, resize=(256, 256)):
+    """
+    Tests a given image with a trained model, with rescaling and resizing options
+    
+    Arguments:
+            img_path: The path to the image file
+            model: The trained Keras model
+            rescale: A float or integer indicating required rescaling. 
+                    The image array will be divided (scaled) by this number.
+            resize: A tuple indicating desired target size. 
+                    This should match the input shape as expected by the model
+    Returns:
+            pred: A prediction vector (Numpy array).
+                  Could be either classes or probabilities depending on the model.
+    """
+    from keras.preprocessing.image import img_to_array, load_img
+    import cv2
+
+    assert type(img_path) == str, "Image path must be a string"
+    assert (
+        type(rescale) == int or type(rescale) == float
+    ), "Rescale factor must be either a float or int"
+    assert (
+        type(resize) == tuple and len(resize) == 2
+    ), "Resize target must be a tuple with two elements"
+
+    img = load_img(img_path,grayscale=True)
+    img = img_to_array(img)
+    img = img / float(rescale)
+    img = cv2.resize(img, resize)
+    if len(model.input_shape) == 4:
+        img = np.expand_dims(img, axis=0)
+
+    pred = model.predict(img)
+
+    return pred
+
+
+def pred_class_with_model(img_path, model, rescale=255, resize=(256, 256)):
+    """
+    Tests a given image with a trained model, with rescaling and resizing options
+    
+    Arguments:
+            img_path: The path to the image file
+            model: The trained Keras model
+            rescale: A float or integer indicating required rescaling. 
+                    The image array will be divided (scaled) by this number.
+            resize: A tuple indicating desired target size. 
+                    This should match the input shape as expected by the model
+    Returns:
+            pred: A prediction vector (Numpy array).
+                  Could be either classes or probabilities depending on the model.
+    """
+    from keras.preprocessing.image import img_to_array, load_img
+    import cv2
+
+    assert type(img_path) == str, "Image path must be a string"
+    assert (
+        type(rescale) == int or type(rescale) == float
+    ), "Rescale factor must be either a float or int"
+    assert (
+        type(resize) == tuple and len(resize) == 2
+    ), "Resize target must be a tuple with two elements"
+
+    img = load_img(img_path)
+    img = img_to_array(img)
+    img = img / float(rescale)
+    img = cv2.resize(img, resize)
+    if len(model.input_shape) == 4:
+        img = np.expand_dims(img, axis=0)
+
+    pred = model.predict(img)
+    pred_class = pred.argmax(axis=-1)
+
+    return pred_class