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) 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) self.confusionMatrix = self.tf.math.confusion_matrix(labels=self.validation_label, predictions=prediction_result).numpy() 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", zero_division=0) 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() dataFrameScore = self.pd.DataFrame({"accuracy":[self.accuracy], "recall":[self.recall], "precision":[self.precision], "f1Score":[self.f1Score]}) dataFrameScore.to_excel(f"reportScore_{self.modelName}.xlsx") self.__drawHistoryAccuracy() 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)