Upload 3 files

geneticAlgorithm.py

@@ -0,0 +1,118 @@
+import tensorflow as tf
+import pygad
+import numpy
+from imageMulticlassClassification import ImageMulticlassClassification
+
+def fitness_func(solution, solution_idx):
+    try:
+        print("solution_idx :",solution_idx)
+        print("solution :",solution)
+        neuronDense1 = [16, 32, 64, 128, 256, 512, 1024, 2048]
+        neuronDense2 = [16, 32, 64, 128, 256, 512, 1024, 2048]
+        Dropout1 = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
+        Dropout2 = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
+        Batchs = [16, 32, 64, 128, 256, 512, 1024, 2048]
+        Activations = ["relu", "sigmoid", "softplus", "softsign", "tanh", "selu", "gelu", "linear"]
+        Optimizers = ["Adam", "RMSprop", "SGD", "Adadelta", "Adagrad", "Adamax", "Ftrl", "Nadam"]
+        LossFunction = ["SparseCategoricalCrossentropy", "CategoricalCrossentropy", "BinaryCrossentropy", "MeanAbsoluteError", "MeanSquaredError", "SquaredHinge", "CategoricalHinge", "CosineSimilarity"]
+        usedNeuronDense1 = neuronDense1[solution[0]]
+        print("==================================")
+        print(f"usedNeuronDense1 : {usedNeuronDense1}")
+        usedNeuronDense2 = neuronDense2[solution[1]]
+        print(f"usedNeuronDense2 : {usedNeuronDense2}")
+        usedDropout1 = Dropout1[solution[2]]
+        print(f"usedDropout1 : {usedDropout1}")
+        usedDropout2 = Dropout2[solution[3]]
+        print(f"usedDropout2 : {usedDropout2}")
+        usedBatchs = Batchs[solution[4]]
+        print(f"usedBatchs : {usedBatchs}")
+        usedActivations = Activations[solution[5]]
+        print(f"usedActivations : {usedActivations}")
+        usedOptimizers = Optimizers[solution[6]]
+        print(f"usedOptimizers : {usedOptimizers}")
+        usedLossFunction = LossFunction[solution[7]]
+        print(f"usedLossFunction : {usedLossFunction}")
+        print("==================================")
+
+        imgWidth=50
+        imgHeight=50
+        batchSize=usedBatchs
+        IMC = ImageMulticlassClassification(imgWidth,imgHeight,batchSize)
+        IMC.data_MakeDataset(datasetUrl="https://huggingface.co/datasets/S1223/HandGestureDataset/resolve/main/HandGestureDataset.tgz",datasetDirectoryName="HandGestureDataset", ratioValidation=0.20)
+        IMC.data_PreprocessingDataset()
+        customModel = tf.keras.Sequential()
+        customModel.add(tf.keras.layers.Conv2D(16, (3, 3), input_shape=(imgWidth, imgHeight, 3), activation=usedActivations))
+        customModel.add(tf.keras.layers.Conv2D(16, (3, 3), activation=usedActivations))
+        customModel.add(tf.keras.layers.Dropout(usedDropout1))
+        customModel.add(tf.keras.layers.MaxPooling2D((2, 2)))
+        customModel.add(tf.keras.layers.Flatten())
+        customModel.add(tf.keras.layers.BatchNormalization())
+        customModel.add(tf.keras.layers.Dense(usedNeuronDense1, activation=usedActivations))
+        customModel.add(tf.keras.layers.Dense(usedNeuronDense2, activation=usedActivations))
+        customModel.add(tf.keras.layers.Dropout(usedDropout2))
+        customModel.add(tf.keras.layers.Dense(10, activation="softmax"))
+        IMC.model_make(customModel) 
+        modelName = ""
+        for x in solution:
+            modelName += f"{str(x)}_"
+        IMC.training_model(epochs=50, modelName=modelName, optimizer=usedOptimizers, lossFunction=usedLossFunction)
+        IMC.evaluation(labelName=["0","1","2","3","4","5","6","7","8","9"])
+        output = float(IMC.history.history["val_accuracy"][-1])
+        # output = numpy.max(solution)
+        # print(output)
+        # print(type(output))
+        print("fitness :",output)
+        fitness = output
+        return fitness
+    except Exception as e:
+        print(str(e))
+        return 0.00001
+
+function_inputs = [1,2,3,4,5,6,7,8]
+desired_output = 5
+
+fitness_function = fitness_func
+
+num_generations = 1
+num_parents_mating = 4
+
+sol_per_pop = 10
+num_genes = len(function_inputs)
+
+init_range_low = 0
+init_range_high = 8
+
+parent_selection_type = "rws"
+keep_parents = 1
+
+crossover_type = "single_point"
+
+mutation_type = "swap"
+mutation_percent_genes = 'default'
+
+ga_instance = pygad.GA(num_generations=num_generations,
+                       num_parents_mating=num_parents_mating,
+                       fitness_func=fitness_function,
+                       sol_per_pop=sol_per_pop,
+                       num_genes=num_genes,
+                       init_range_low=init_range_low,
+                       init_range_high=init_range_high,
+                       parent_selection_type=parent_selection_type,
+                       keep_parents=keep_parents,
+                       crossover_type=crossover_type,
+                       mutation_type=mutation_type,
+                       mutation_percent_genes=mutation_percent_genes,
+                       gene_type=[int, int, int, int, int, int, int, int],
+                       allow_duplicate_genes=False, 
+                       save_best_solutions=False, 
+                       save_solutions=False)
+print("Initial Population")
+print(ga_instance.initial_population)
+print(ga_instance.run())
+solution, solution_fitness, solution_idx = ga_instance.best_solution()
+print("Parameters of the best solution : {solution}".format(solution=solution))
+print("Fitness value of the best solution = {solution_fitness}".format(solution_fitness=solution_fitness))
+
+# from whatsapp import FWA
+# fwa = FWA(APIkey="b2d95af932eedb4de92b3496f338aa5f97b36ae0", NoSender="6285157853522", host="http://wa.fianjulio.web.id:81")
+# print(fwa.sendTextMessage(phoneNumber="082136815488", message="Training selesai"))

imageMulticlassClassification.py

@@ -0,0 +1,536 @@
+class ImageMulticlassClassification:
+    def __init__(self, imgWidth=300, imgHeight=300, batchSize=32):
+        from time import time
+        import tensorflow as tf
+        import matplotlib.pyplot as plt
+        import pathlib
+        import datetime
+        from sklearn.metrics import roc_curve, auc, roc_auc_score
+        import os
+        import keras
+        import numpy as np
+        import pandas as pd
+        import tarfile
+        import sklearn
+
+        self.time = time
+        self.sklearn = sklearn
+        self.tf = tf
+        self.plt = plt
+        self.pathlib = pathlib
+        self.datetime = datetime
+        self.roc_curve = roc_curve
+        self.roc_auc_score = roc_auc_score
+        self.auc = auc
+        self.os = os
+        self.keras = keras
+        self.np = np
+        self.AUTOTUNE = tf.data.AUTOTUNE
+        self.pd = pd
+        self.tarfile = tarfile
+
+        self.imgWidth = imgWidth
+        self.imgHeight = imgHeight
+        self.numGPU = len(self.tf.config.list_physical_devices('GPU'))
+        if self.numGPU > 0:
+            self.batchSize = batchSize * self.numGPU
+        else:
+            self.batchSize = batchSize
+        self.Model = None
+        self.time_callback = None
+        self.history = None
+        self.confusionMatrix = None
+        self.validation_label = None
+        self.trainDataset = None
+        self.validationDataset = None
+        self.accuracy = None
+        self.recall = None
+        self.precision = None
+        self.f1Score = None
+        self.modelName = ""
+
+    
+    def data_MakeDataset(self, datasetUrl=None, datasetPath=None, datasetDirectoryName="Dataset Covid19 Training", ratioValidation=0.2):
+        """
+        Purpose:
+            - Make dataset from parameter
+        
+        Parameter:
+            - datasetUrl: url of dataset
+                - type: string
+                - example: "https://storage.googleapis.com/fdataset/Dataset%20Covid19%20Training.tgz"
+            - datasetPath: path of dataset
+                - type: string
+                - example: "C:/Users/User/Desktop/Dataset Covid19 Training.tgz"
+            - datasetDirectoryName: name of dataset directory
+                - type: string
+                - example: "Dataset Covid19 Training"
+            - ratioValidation: ratio of validation data
+                - type: float
+                - example: 0.2
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success"}
+        """
+        try:
+            if datasetUrl is not None:
+                dataset_url = datasetUrl
+                data_dir = self.tf.keras.utils.get_file(datasetDirectoryName, origin=dataset_url, untar=True)
+                data_dir = self.pathlib.Path(data_dir)
+            elif datasetPath is not None:
+                currentPath = self.os.getcwd()
+                if self.os.path.exists(currentPath + "/" + datasetDirectoryName):
+                    # remove dataset directory with all file inside
+                    self.os.system("rm -rf " + currentPath + "/" + datasetDirectoryName)
+                # extract dataset
+                my_tar = self.tarfile.open(datasetPath)
+                # check if dataset directory exist then delete it
+                my_tar.extractall(currentPath) # specify which folder to extract to
+                my_tar.close()
+                data_dir = self.pathlib.Path(f'{currentPath}/{datasetDirectoryName}/')
+
+            image_count = len(list(data_dir.glob('*/*.jpg')))
+
+            train_ds = self.tf.keras.preprocessing.image_dataset_from_directory(
+            data_dir,
+            seed=123,
+            subset="training",
+            validation_split=ratioValidation,
+            image_size=(self.imgWidth, self.imgHeight),
+            batch_size=self.batchSize)
+
+            val_ds = self.tf.keras.preprocessing.image_dataset_from_directory(
+            data_dir,
+            seed=123,
+            subset="validation",
+            validation_split=ratioValidation,
+            image_size=(self.imgWidth, self.imgHeight),
+            batch_size=self.batchSize)
+
+            self.trainDataset = train_ds.cache().shuffle(1000).prefetch(buffer_size=self.AUTOTUNE)
+            self.validationDataset = val_ds.cache().prefetch(buffer_size=self.AUTOTUNE)
+        
+            return {"success":True, "code":200, "detail":"success"}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+            
+    def data_PreprocessingDataset(self, typeRandomFlip="horizontal_and_vertical", RandomRotation=0.3, RandomZoom=0.2, shuffleTrainDataset=True, augmentTrainDataset=True):
+        """
+        Purpose:
+            - Preprocessing dataset
+        
+        Parameter:
+            - typeRandomFlip: type of random flip
+                - type: string
+                - example: "horizontal_and_vertical"
+                - options: "horizontal", "vertical", "horizontal_and_vertical"
+            - RandomRotation: random rotation
+                - type: float
+                - example: 0.3
+            - RandomZoom: random zoom
+                - type: float
+                - example: 0.2
+            - shuffleTrainDataset: shuffle train dataset
+                - type: bool
+                - example: True
+            - augmentTrainDataset: augment train dataset
+                - type: bool
+                - example: True
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success"}
+        """
+        try:
+            rescale = self.tf.keras.layers.Rescaling(1.0 / 255, input_shape=(self.imgWidth, self.imgHeight, 3))
+
+            data_augmentation = self.tf.keras.Sequential(
+                [
+                    self.tf.keras.layers.RandomFlip(typeRandomFlip, input_shape=(self.imgWidth,self.imgHeight,3)),
+                    self.tf.keras.layers.RandomRotation(RandomRotation),
+                    self.tf.keras.layers.RandomZoom(RandomZoom),
+                ]
+            )
+
+
+            def prepare(ds, shuffle=False, augment=False):
+                # Rescale dataset
+                ds = ds.map(lambda x, y: (rescale(x), y), num_parallel_calls=self.AUTOTUNE)
+
+                if shuffle:
+                    ds = ds.shuffle(1024)
+
+                # Use data augmentation only on the training set
+                if augment:
+                    ds = ds.map(lambda x, y: (data_augmentation(x), y), num_parallel_calls=self.AUTOTUNE,)
+
+                # Use buffered prefecting
+                return ds.prefetch(buffer_size=self.AUTOTUNE)
+
+            self.trainDataset = prepare(self.trainDataset, shuffle=shuffleTrainDataset, augment=augmentTrainDataset)
+            self.validationDataset = prepare(self.validationDataset)
+            
+            return {"success":True, "code":200, "detail":"success"}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+    
+    def data_GetLabelFromDataset(self, dataset):
+        """
+        Purpose:
+            - Get label from dataset
+        
+        Parameter:
+            - dataset: dataset
+                - type: tf.data.Dataset
+                - example: trainDataset
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success", "label":array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
+       0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1,
+       1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0,
+       1, 1, 0, 0, 0, 0, 0, 0], dtype=int32)}
+        """
+        try:
+            label = self.np.concatenate([y for x, y in dataset], axis=0)
+            return {"success":True, "code":200, "detail":"success", "label":label}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+    
+    def model_make(self, model=None):
+        """
+        Purpose:
+            - Make default model
+        
+        Parameter:
+            - model: model
+                - type: tf.keras.Model
+                - example: model
+                - default: None
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success", "model":model}
+        """
+        try:
+            if model is None:
+                model = self.tf.keras.Sequential()
+                base_model = self.tf.keras.applications.DenseNet121(include_top=False, input_shape=(self.imgWidth, self.imgHeight, 3))
+                base_model.trainable=True
+                model.add(base_model)
+                model.add(self.tf.keras.layers.Dropout(0.4))
+                model.add(self.tf.keras.layers.Flatten())
+                model.add(self.tf.keras.layers.Dense(128,activation='relu'))
+                model.add(self.tf.keras.layers.Dropout(0.5))
+                model.add(self.tf.keras.layers.Dense(32,activation='relu'))
+                model.add(self.tf.keras.layers.Dense(1, activation="sigmoid"))
+                self.Model = model
+            else:
+                self.Model = model
+            return {"success":True, "code":200, "detail":"success", "model":self.Model}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+    
+    def training_model(self, epochs=10, lossFunction="binary_crossentropy", optimizer="adam", metrics=["accuracy"], device='/GPU:0', modelName=None):
+        """
+        Purpose:
+            - Training model
+        
+        Parameter:
+            - model: model
+                - type: tf.keras.Model
+                - example: model
+                - default: True
+            - epochs: epochs
+                - type: int
+                - example: 10
+            - lossFunction: loss function
+                - type: string
+                - example: "binary_crossentropy"
+                - options: "binary_crossentropy", "categorical_crossentropy", "sparse_categorical_crossentropy"
+            - optimizer: optimizer
+                - type: string
+                - example: "adam"
+                - options: "adam", "adamax", "nadam", "rmsprop", "sgd", tf.keras.optimizers.RMSprop(learning_rate=1e-4)
+            - metrics: metrics
+                - type: list
+                - example: ["accuracy"]
+            - device: device
+                - type: string
+                - example: "/GPU:0"
+                - options: "/CPU:0", "/GPU:0"
+            - modelName: model name
+                - type: string
+                - example: "model"
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success"}
+        """
+        try:
+            if modelName is not None:
+                self.modelName = modelName
+
+            self.time_callback = TimeHistory()
+            self.Model.compile(
+                loss=lossFunction,
+                optimizer=optimizer,
+                metrics=metrics,
+            )
+
+            print(self.Model.summary())
+
+            with self.tf.device(device):
+                self.history = self.Model.fit(
+                    self.trainDataset, validation_data=self.validationDataset, epochs=epochs, verbose=1, callbacks=[self.time_callback]
+                )
+            # make excel file report.xlsx and save data in column 1 is number of training loss, column 2 is training accuracy, column 3 is validation loss, column 4 is validation accuracy, column 5 is training time
+            dataFrameHistory = self.pd.DataFrame({"training_loss":self.history.history["loss"], "training_accuracy":self.history.history["accuracy"], "validation_loss":self.history.history["val_loss"], "validation_accuracy":self.history.history["val_accuracy"], "training_time":self.time_callback.times})
+            dataFrameHistory.to_excel(f"report_{self.modelName}.xlsx")
+
+            return {"success":True, "code":200, "detail":"success"}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+    
+    def training_model_multiGPU(self, epochs=10, lossFunction="binary_crossentropy", optimizer="adam", metrics=["accuracy"], device='/GPU:0', modelName=None):
+        """
+        Purpose:
+            - Training model with multi GPU support, with mirrored strategy
+        
+        Parameter:
+            - model: model
+                - type: tf.keras.Model
+                - example: model
+                - default: True
+            - epochs: epochs
+                - type: int
+                - example: 10
+            - lossFunction: loss function
+                - type: string
+                - example: "binary_crossentropy"
+                - options: "binary_crossentropy", "categorical_crossentropy", "sparse_categorical_crossentropy"
+            - optimizer: optimizer
+                - type: string
+                - example: "adam"
+                - options: "adam", "adamax", "nadam", "rmsprop", "sgd", tf.keras.optimizers.RMSprop(learning_rate=1e-4)
+            - metrics: metrics
+                - type: list
+                - example: ["accuracy"]
+            - device: device
+                - type: string
+                - example: "/GPU:0"
+                - options: "/CPU:0", "/GPU:0"
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success"}
+        """
+        try:
+            if modelName is not None:
+                self.modelName = modelName
+
+            self.time_callback = TimeHistory()
+
+            print(self.Model.summary())
+            strategy = self.tf.distribute.MirroredStrategy()
+            with strategy.scope():
+                model = self.Model
+            model.compile(loss=lossFunction, optimizer=optimizer, metrics=metrics)
+
+            self.history = model.fit(self.trainDataset, validation_data=self.validationDataset, epochs=epochs, verbose=1, callbacks=[self.time_callback])
+            # make excel file report.xlsx and save data in column 1 is number of training loss, column 2 is training accuracy, column 3 is validation loss, column 4 is validation accuracy, column 5 is training time
+            dataFrameHistory = self.pd.DataFrame({"training_loss":self.history.history["loss"], "training_accuracy":self.history.history["accuracy"], "validation_loss":self.history.history["val_loss"], "validation_accuracy":self.history.history["val_accuracy"], "training_time":self.time_callback.times})
+            dataFrameHistory.to_excel(f"report_{self.modelName}.xlsx")
+
+            return {"success":True, "code":200, "detail":"success"}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+
+    def evaluation(self, labelName=["COVID19", "NORMAL"]):
+        """
+        Purpose:
+            - Evaluation model with confusionMatrix, precision, recall, f1Score, accuracy
+        
+        Parameter:
+            - labelName: label name
+                - type: list
+                - example: ["COVID19", "NORMAL"]
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success", "confusionMatrix":confusionMatrix, "precision":precision, "recall":recall, "f1Score":f1Score, "accuracy":accuracy}
+        """
+        try:
+            self.Model.evaluate(self.validationDataset)
+            # get prediction result as label
+            prediction_result = self.Model.predict(self.validationDataset)
+            prediction_result = self.np.argmax(prediction_result, axis=1)
+            self.validation_label = self.np.concatenate([y for x, y in self.validationDataset], axis=0)
+            # make confusion matrix for multi class using tensorflow
+            self.confusionMatrix = self.tf.math.confusion_matrix(labels=self.validation_label, predictions=prediction_result).numpy()
+            # get accuracy, precision, recall, f1Score for multi class
+            self.accuracy = self.sklearn.metrics.accuracy_score(self.validation_label, prediction_result)
+            self.precision = self.sklearn.metrics.precision_score(self.validation_label, prediction_result, average="macro")
+            self.recall = self.sklearn.metrics.recall_score(self.validation_label, prediction_result, average="macro")
+            self.f1Score = self.sklearn.metrics.f1_score(self.validation_label, prediction_result, average="macro")
+            self.__drawConfusionMatrix(labelName)
+            self.__drawROC()
+            # save accuracy, recall, precision, f1Score in excel file which name is reportScore_.xlsx
+            dataFrameScore = self.pd.DataFrame({"accuracy":[self.accuracy], "recall":[self.recall], "precision":[self.precision], "f1Score":[self.f1Score]})
+            dataFrameScore.to_excel(f"reportScore_{self.modelName}.xlsx")
+            # draw history accuracy with training and validation dataset
+            self.__drawHistoryAccuracy()
+            # draw history loss with training and validation dataset
+            self.__drawHistoryLoss()
+            return {"success":True, "code":200, "detail":"success"}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+    
+    def __drawConfusionMatrix(self, labelName=["COVID19", "NORMAL"]):
+        # draw confusion matrix with numeric value on the center and library matplotlib with label of validation dataset like this sample https://scikit-learn.org/stable/_images/sklearn-metrics-plot_confusion_matrix-1.png
+        labelName.sort()
+        fig, ax = self.plt.subplots()
+        im = ax.imshow(self.confusionMatrix)
+        ax.figure.colorbar(im, ax=ax)
+        ax.set(xticks=self.np.arange(self.confusionMatrix.shape[1]), yticks=self.np.arange(self.confusionMatrix.shape[0]), xticklabels=labelName, yticklabels=labelName, title="Confusion Matrix", ylabel="True label", xlabel="Predicted label")
+        ax.set_xlabel("Predicted")
+        ax.set_ylabel("True")
+        self.plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
+        for i in range(self.confusionMatrix.shape[0]):
+            for j in range(self.confusionMatrix.shape[1]):
+                ax.text(j, i, self.confusionMatrix[i, j], ha="center", va="center", color="w")
+        self.plt.tight_layout()
+        self.plt.savefig(f"confusionMatrix_{self.modelName}.png")
+        self.plt.show()
+        self.plt.close()
+        # save confusion matrix to excel file
+        dataFrameConfusionMatrix = self.pd.DataFrame(self.confusionMatrix)
+        dataFrameConfusionMatrix.to_excel(f"confusionMatrix_{self.modelName}.xlsx")
+    
+    def __drawROC(self):
+        """
+        Purpose:
+            - Draw ROC curve like this sample https://scikit-learn.org/stable/_images/sphx_glr_plot_roc_001.png for multi class
+        """
+        predictResult = self.Model.predict(self.validationDataset)
+        fpr, tpr, thresholds = self.sklearn.metrics.roc_curve(self.validation_label, predictResult[:, 1], pos_label=1)
+        self.auc = self.sklearn.metrics.auc(fpr, tpr)
+        fig, ax = self.plt.subplots()
+        ax.plot(fpr, tpr, label="ROC curve (area = %0.2f)" % self.auc)
+        ax.plot([0, 1], [0, 1], "k--")
+        ax.set_xlim([0.0, 1.0])
+        ax.set_ylim([0.0, 1.05])
+        ax.set_xlabel("False Positive Rate")
+        ax.set_ylabel("True Positive Rate")
+        ax.set_title("Receiver operating characteristic")
+        ax.legend(loc="best")
+        self.plt.savefig(f"ROC_{self.modelName}.png")
+        self.plt.show()
+        self.plt.close()
+        # save ROC curve to excel file
+        dataFrameROC = self.pd.DataFrame({"fpr":fpr, "tpr":tpr, "thresholds":thresholds, "auc":self.auc})
+        dataFrameROC.to_excel(f"ROC_{self.modelName}.xlsx")
+    
+    def __drawHistoryAccuracy(self):
+        """
+        Purpose:
+            - Draw history accuracy with training and validation dataset
+        """
+        fig, ax = self.plt.subplots()
+        ax.plot(self.history.history["accuracy"], label="training dataset")
+        ax.plot(self.history.history["val_accuracy"], label="validation dataset")
+        ax.set_xlabel("Epoch")
+        ax.set_ylabel("Accuracy")
+        ax.set_title("Accuracy")
+        ax.legend(loc="best")
+        self.plt.savefig(f"historyAccuracy_{self.modelName}.png")
+        self.plt.show()
+        self.plt.close()
+    
+    def __drawHistoryLoss(self):
+        """
+        Purpose:
+            - Draw history loss with training and validation dataset
+        """
+        fig, ax = self.plt.subplots()
+        ax.plot(self.history.history["loss"], label="training dataset")
+        ax.plot(self.history.history["val_loss"], label="validation dataset")
+        ax.set_xlabel("Epoch")
+        ax.set_ylabel("Loss")
+        ax.set_title("Loss")
+        ax.legend(loc="best")
+        self.plt.savefig(f"historyLoss_{self.modelName}.png")
+        self.plt.show()
+        self.plt.close()
+
+    def import_data_Dataset(self, trainDataset, validationDataset):
+        """
+        Purpose:
+            - Import dataset
+        
+        Parameter:
+            - trainDataset: dataset
+                - type: tf.data.Dataset
+                - example: trainDataset
+            - validationDataset: dataset
+                - type: tf.data.Dataset
+                - example: validationDataset
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success"}
+        """
+        try:
+            self.trainDataset = trainDataset
+            self.validationDataset = validationDataset
+            return {"success":True, "code":200, "detail":"success"}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+    
+    def saveModelWithWeight(self, fileName):
+        """
+        Purpose:
+            - Save model with weight
+        
+        Parameter:
+            - fileName: file name
+                - type: string
+                - example: "my_model"
+                - options: "my_model", "gs://bucket/my_model"
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success"}
+        """
+        try:
+            self.Model.save(fileName)
+            return {"success":True, "code":200, "detail":"success"}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+    
+    def loadModelWithWeightAndCustomObject(self, fileName, customObject):
+        """
+        Purpose:
+            - Load model with weight and custom object
+        
+        Parameter:
+            - fileName: file name
+                - type: string
+                - example: "my_model"
+                - options: "my_model", "gs://bucket/my_model"
+            - customObject: custom object
+                - type: dict
+                - example: {"MyCustomObject":MyCustomObject}
+        
+        Return:
+            - {"success":True, "code":200, "detail":"success"}
+        """
+        try:
+            self.Model = self.tf.keras.models.load_model(fileName, custom_objects=customObject)
+            return {"success":True, "code":200, "detail":"success"}
+        except Exception as e:
+            return {"success":False, "code":500, "detail":str(e)}
+
+import tensorflow as tf
+from time import time
+class TimeHistory(tf.keras.callbacks.Callback):
+    def on_train_begin(self, logs={}):
+        self.times = []
+
+    def on_epoch_begin(self, batch, logs={}):
+        self.epoch_time_start = time()
+
+    def on_epoch_end(self, batch, logs={}):
+        self.times.append(time() - self.epoch_time_start)

requirements.txt

@@ -0,0 +1,4 @@
+pygad == 2.19.2
+tensorflow
+numpy
+pandas