def __init__(self): """ Initializes the class. """ self.Helpers = Helpers("Model") self.Data = Data() self.Helpers.logger.info("Model class initialized.")
class Trainer(): """ Trainer Class Trains the Natural Language Understanding Engine. """ def __init__(self): """ Initializes the class. """ self.Helpers = Helpers("Train") self.intentMap = {} self.words = [] self.classes = [] self.dataCorpus = [] self.Model = Model() self.Data = Data() self.Helpers.logger.info("Trainer class initialized.") def setupData(self): """ Prepares the data. """ self.trainingData = self.Data.loadTrainingData() self.words, self.classes, self.dataCorpus, self.intentMap = self.Data.prepareData( self.trainingData) self.x, self.y = self.Data.finaliseData(self.classes, self.dataCorpus, self.words) self.Helpers.logger.info("NLU Training Data Ready") def setupEntities(self): """ Prepares the entities. """ if self.Helpers.confs["NLU"]["Entities"] == "Mitie": self.entityController = Entities() self.entityController.trainEntities( self.Helpers.confs["NLU"]["Mitie"]["ModelLocation"], self.trainingData) self.Helpers.logger.info("NLU Trainer Entities Ready") def trainModel(self): """ Trains the model. """ while True: self.Helpers.logger.info("Ready To Begin Training ? (Yes/No)") userInput = input(">") if userInput == 'Yes': break if userInput == 'No': exit() self.setupData() self.setupEntities() self.Model.trainDNN(self.x, self.y, self.words, self.classes, self.intentMap) self.Helpers.logger.info("NLU Model Trained")
def do_data(self): """ Creates/sorts dataset. """ self.Data = Data() self.Data.do_im_process() self.Helpers.logger.info("Data preperation complete.")
class ManualAugmentation(): def __init__(self): ############################################################### # # Sets up all default requirements and placeholders # needed for the Acute Myeloid Leukemia Classifier. # ############################################################### self.Data = Data() def processDataset(self): ############################################################### # # Make sure you have your equal amounts of positive and negative # samples in the Model/Data directories. # # Only run this function once! it will continually make copies # of all images in the Settings->TrainDir directory specified # in Required/confs.json # ############################################################### self.Data.processDataset()
def __init__(self): ############################################################### # # Sets up all default requirements and placeholders # needed for the Acute Myeloid Leukemia Classifier. # ############################################################### self.Data = Data()
def data(self): """ Initializes the data. """ self.Data = Data() self.trainingData = self.Data.loadTrainingData() self.trainedData = self.Data.loadTrainedData() self.trainedWords = self.trainedData["words"] self.trainedClasses = self.trainedData["classes"] self.x = self.trainedData["x"] self.y = self.trainedData["y"] self.intentMap = self.trainedData["intentMap"][0]
class Data(): """ Trainer Data Class Sorts the ALL Detection System 2019 NCS1 Classifier training data. """ def __init__(self): """ Initializes the Data Class """ self.Helpers = Helpers("Data") self.confs = self.Helpers.confs self.DataProcess = DataProcess() self.labelsToName = {} self.Helpers.logger.info("Data class initialization complete.") def sortData(self): """ Sorts the training data """ humanStart, clockStart = self.Helpers.timerStart() self.Helpers.logger.info("Loading & preparing training data.") dataPaths, classes = self.DataProcess.processFilesAndClasses() classId = [int(i) for i in classes] classNamesToIds = dict(zip(classes, classId)) # Divide the training datasets into train and test numValidation = int(self.confs["Classifier"]["ValidationSize"] * len(dataPaths)) self.Helpers.logger.info("Number of classes: " + str(classes)) self.Helpers.logger.info("Validation data size: " + str(numValidation)) random.seed(self.confs["Classifier"]["RandomSeed"]) random.shuffle(dataPaths) trainingFiles = dataPaths[numValidation:] validationFiles = dataPaths[:numValidation] # Convert the training and validation sets self.DataProcess.convertToTFRecord('train', trainingFiles, classNamesToIds) self.DataProcess.convertToTFRecord('validation', validationFiles, classNamesToIds) # Write the labels to file labelsToClassNames = dict(zip(classId, classes)) self.DataProcess.writeLabels(labelsToClassNames) self.Helpers.logger.info( "Loading & preparing training data completed.") def cropTestData(self): """ Crops the testing data """ self.DataProcess.cropTestDataset() self.Helpers.logger.info("Testing data resized.")
class COVID19DN(): """ COVID19DN Class Core COVID-19 Tensorflow DenseNet Classifier wrapper class using Tensroflow 2. """ def __init__(self): """ Initializes the class. """ self.Helpers = Helpers("Core") self.Model = Model() self.Helpers.logger.info( "COVID19DN Tensorflow initialization complete.") def do_data(self): """ Sorts the training data. """ self.Data = Data() self.Data.process_data( self.Data.paths_n_labels()) def do_train(self): """ Creates & trains the model. """ self.Model.do_model(self.Data) self.Model.do_train() self.Model.do_evaluate() def do_load_model(self): """ Loads the model """ self.Model.load_model_and_weights() def do_classify(self): """ Loads model and classifies test data """ self.do_load_model() self.Model.test_classifier() def do_server(self): """ Loads the API server """ self.do_load_model() self.Server = Server(self.Model) self.Server.start() def do_http_classify(self): """ Loads model and classifies test data """ self.Model.test_http_classifier()
def do_data(self): """ Creates/sorts dataset. """ self.Data = Data(self.optimizer, self.do_augmentation) self.Data.data_and_labels_sort() if self.do_augmentation == False: self.Data.data_and_labels_prepare() else: self.Data.data_and_labels_augmentation_prepare() self.Data.shuffle() self.Data.get_split()
def __init__(self): self.Helpers = Helpers() self._confs = self.Helpers.loadConfigs() self.LogFile = self.Helpers.setLogFile(self._confs["aiCore"]["Logs"] + "Train/") self.intentMap = {} self.words = [] self.classes = [] self.dataCorpus = [] self.Model = Model() self.Data = Data()
def __init__(self): """ Initializes the Training class. """ self.Helpers = Helpers() self.LogFile = self.Helpers.setLogFile( self.Helpers.confs["System"]["Logs"] + "Train/") self.intentMap = {} self.words = [] self.classes = [] self.dataCorpus = [] self.Model = Model() self.Data = Data()
def __init__(self): """ Initializes the class. """ self.Helpers = Helpers("Train") self.intentMap = {} self.words = [] self.classes = [] self.dataCorpus = [] self.Model = Model() self.Data = Data() self.Helpers.logger.info("Trainer class initialized.")
def __init__(self): ############################################################### # # Sets up all default requirements # # - Helpers: Useful global functions # - Data: Data functions # ############################################################### self.Helpers = Helpers() self.confs = self.Helpers.loadConfigs() self.Data = Data()
def genAmazonData(): dataset = Dataset() arq = open('Datasets/AmazonDatasetTest.txt', 'r', encoding='utf-8') i = 0 while True: try: line = arq.readline() if line == "": break print(i) i = i + 1 # Reading labels and data label = int(line[9]) label = 0 if label == 1 else 1 text = line[11:len(line) - 1] # Tokenizing and lemmatizing text = to_process(text) data = Data(doc=text, label=label) dataset.add(data) except EOFError: break with open('amazon_dataset', 'wb') as fp: pickle.dump(dataset, fp) return dataset
def genRottenData(): dataset = Dataset() src = ['.neg', '.pos'] i = 0 j = 0 for a in src: arq = open('Datasets/rotten/rt-polarity' + a, 'r') while True: print(j) j = j + 1 try: # Reading labels and data text = arq.readline() label = i if text == "": break # Tokenizing and lemmatizing text = to_process(text) data = Data(doc=text, label=label) dataset.add(data) except EOFError: break i = i + 1 with open('Datasets/rotten_dataset', 'wb') as fp: pickle.dump(dataset, fp) return dataset
class IdcQnn(): """ IdcQnn IdcQnn is a wrapper class that creates the Invasive Ductal Carcinoma Tensorflow QNN (Quantum Neural Network). """ def __init__(self): """ Initializes the class. """ self.Helpers = Helpers("Core") self.QModel = QModel() self.Helpers.logger.info("IdcQnn QNN initialization complete.") def do_data(self): """ Sorts the training data """ self.Data = Data() self.Data.get_paths_n_labels() self.Data.process_data() def do_train(self): """ Creates & trains the QNN. CREDIT: https://www.tensorflow.org/quantum/tutorials/mnist CREDIT: https://arxiv.org/pdf/1802.06002.pdf """ self.QMNIST = QMNIST() # "Quantumize" the training data X_train_bin, X_test_bin = self.QMNIST.encode_data_as_binary( self.Data.X_train, self.Data.X_test) X_train_circ, X_test_circ = self.QMNIST.do_circuit_conversion( X_train_bin, X_test_bin) x_train_tfcirc, x_test_tfcirc = self.QMNIST.convert_to_tensors( X_train_circ, X_test_circ) # Create the Quantum Neural Network model_circuit, model_readout = self.QModel.create_quantum_model() self.QModel.create_keras_model(model_circuit, model_readout) # Train the Quantum Neural Network self.QModel.train_model(x_train_tfcirc, x_test_tfcirc, self.Data.y_train, self.Data.y_test) self.QModel.do_evaluate(x_train_tfcirc, x_test_tfcirc, self.Data.y_test)
class Data(): ############################################################### # # Core Data class wrapper. # ############################################################### def __init__(self): ############################################################### # # Sets up all default requirements and placeholders # needed for this class. # ############################################################### self.Helpers = Helpers() self.confs = self.Helpers.loadConfs() self.logFile = self.Helpers.setLogFile(self.confs["Settings"]["Logs"]["DataLogDir"]) self.DataProcess = DataProcess() self.labelsToName = {} self.Helpers.logMessage(self.logFile, "init", "INFO", "Init complete") def sortData(self): ############################################################### # # Sorts the data # ############################################################### humanStart, clockStart = self.Helpers.timerStart() self.Helpers.logMessage(self.logFile, "sortData", "INFO", "Loading & preparing training data") dataPaths, classes = self.DataProcess.processFilesAndClasses() classId = [ int(i) for i in classes] classNamesToIds = dict(zip(classes, classId)) # Divide the training datasets into train and test numValidation = int(self.confs["Classifier"]["ValidationSize"] * len(dataPaths)) self.Helpers.logMessage(self.logFile, "sortData", "Validation Size", str(numValidation)) self.Helpers.logMessage(self.logFile, "sortData", "Class Size", str(len(classes))) random.seed(self.confs["Classifier"]["RandomSeed"]) random.shuffle(dataPaths) trainingFiles = dataPaths[numValidation:] validationFiles = dataPaths[:numValidation] # Convert the training and validation sets self.DataProcess.convertToTFRecord('train', trainingFiles, classNamesToIds) self.DataProcess.convertToTFRecord('validation', validationFiles, classNamesToIds) # Write the labels to file labelsToClassNames = dict(zip(classId, classes)) self.DataProcess.writeLabels(labelsToClassNames) self.Helpers.logMessage(self.logFile, "sortData", "COMPLETE", "Completed sorting data!")
def __init__(self): """ Initializes the Movidius NCS1 Classifier Data Class """ self.Helpers = Helpers("Data") self.confs = self.Helpers.confs self.DataProcess = DataProcess() self.labelsToName = {} self.Helpers.logger.info("Data class initialization complete.")
class Augmentation(): """ ALL Detection System 2019 Manual Data Augmentation Class Manual data augmentation wrapper class for the ALL Detection System 2019 Data Augmentation project. """ def __init__(self): """ Initializes the Augmentation class. """ self.Data = Data() def processDataset(self): """ Processes the AML/ALL Detection System Dataset. Make sure you have your equal amounts of positive and negative samples in the Model/Data directories. Only run this function once! it will continually make copies of all images in the Settings->TrainDir directory specified in Required/confs.json """ self.Data.processDataset()
def initNLU(self): """ Initializes a Chatbot sesiion. Initiates the NLU setting up the data, NLU / entities models and required modules such as context and extensions. """ self.Data = Data() self.trainingData = self.Data.loadTrainingData() self.trainedData = self.Data.loadTrainedData() self.Model = Model() self.Context = Context() self.Extensions = Extensions() self.restoreData() self.restoreNER() self.restoreNLU() self.initiateSession() self.setThresholds()
def divide(self, num_docs): pos = 0 neg = 0 result = Dataset() for i in range(len(self.labels)): text = self.docs[i] label = self.labels[i] if label == 1 and pos < num_docs / 2: data = Data(doc=text, label=label) result.add(data) pos = pos + 1 elif label == 0 and neg < num_docs / 2: data = Data(doc=text, label=label) result.add(data) neg = neg + 1 return result
class QMNISTCOVID19(): """ QMNISTCOVID19 QMNISTCOVID19 is a wrapper class that creates the COVID-19 Tensorflow QNN (Quantum Neural Network). """ def __init__(self): """ Initializes the class. """ self.Helpers = Helpers("Core") self.Helpers.logger.info("QMNISTCOVID19 QNN initialization complete.") def do_data(self): """ Sorts the training data """ self.Data = Data() self.Data.get_paths_n_labels() self.Data.process_data() def do_train(self): """ Creates & trains the QNN. """ self.QMNIST = QMNIST() X_train_bin, X_test_bin = self.QMNIST.encode_as_binary( self.Data.X_train, self.Data.X_test) X_train_circ, X__test_circ = self.QMNIST.do_circuit_conversion( X_train_bin, X_test_bin) x_train_tfcirc, x_test_tfcirc = self.QMNIST.convert_to_tensors( X_train_circ, X__test_circ) def do_load_model(self): """ Loads the trained model """ print("TODO") def do_classify(self): """ Classifies the test data """ print("TODO")
def __init__(self): ############################################################### # # Sets up all default requirements and placeholders # needed for this class. # ############################################################### self.Helpers = Helpers() self.confs = self.Helpers.loadConfs() self.logFile = self.Helpers.setLogFile(self.confs["Settings"]["Logs"]["DataLogDir"]) self.DataProcess = DataProcess() self.labelsToName = {} self.Helpers.logMessage(self.logFile, "init", "INFO", "Init complete")
def __init__(self): """ Initializes the Model class. """ self.Helpers = Helpers() self.Data = Data()
class Model(): """ ALL Detection System 2019 Model Class Model class for the ALL Detection System 2019 Chatbot. """ def __init__(self): """ Initializes the Model class. """ self.Helpers = Helpers() self.Data = Data() def createDNNLayers(self, x, y): """ Sets up the DNN layers """ net = tflearn.input_data(shape=[None, len(x[0])]) for i in range(self.Helpers.confs["NLU"]['FcLayers']): net = tflearn.fully_connected(net, self.Helpers.confs["NLU"]['FcUnits']) net = tflearn.fully_connected( net, len(y[0]), activation=str(self.Helpers.confs["NLU"]['Activation'])) if self.Helpers.confs["NLU"]['Regression']: net = tflearn.regression(net) return net def trainDNN(self, x, y, words, classes, intentMap): """ Trains the DNN """ tf.reset_default_graph() tmodel = tflearn.DNN( self.createDNNLayers(x, y), tensorboard_dir=self.Helpers.confs["NLU"]['TFLearn']['Logs'], tensorboard_verbose=self.Helpers.confs["NLU"]['TFLearn'] ['LogsLevel']) tmodel.fit(x, y, n_epoch=self.Helpers.confs["NLU"]['Epochs'], batch_size=self.Helpers.confs["NLU"]['BatchSize'], show_metric=self.Helpers.confs["NLU"]['ShowMetric']) self.saveModelData( self.Helpers.confs["NLU"]['TFLearn']['Data'], { 'words': words, 'classes': classes, 'x': x, 'y': y, 'intentMap': [intentMap] }, tmodel) def saveModelData(self, path, data, tmodel): """ Saves the model data """ tmodel.save(self.Helpers.confs["NLU"]['TFLearn']['Path']) with open(path, "w") as outfile: json.dump(data, outfile) def buildDNN(self, x, y): """ Loads the DNN model """ tf.reset_default_graph() tmodel = tflearn.DNN(self.createDNNLayers(x, y)) tmodel.load(self.Helpers.confs["NLU"]['TFLearn']['Path']) return tmodel def predict(self, tmodel, parsedSentence, trainedWords, trainedClasses): """ Makes a prediction """ predictions = [[index, confidence] for index, confidence in enumerate( tmodel.predict( [self.Data.makeBagOfWords(parsedSentence, trainedWords)])[0])] predictions.sort(key=lambda x: x[1], reverse=True) classification = [] for prediction in predictions: classification.append( (trainedClasses[prediction[0]], prediction[1])) return classification
class Engine(): """ Engine Class Core functions for the NLU Engine. """ def __init__(self, isAudio): """ Initializes the class. """ self.Helpers = Helpers("Engine") self.ner = None self.user = {} #self.bluetoothCon() self.data() self.entities() #self.iotJumpWayCon() self.model() self.session() self.thresholds() if isAudio: self.speech() self.Helpers.logger.info("Engine class initialized.") def bluetoothCon(self): """ Initializes the Bluetooth connection. """ self.Bluetooth = BluetoothConnect() self.Bluetooth.connect() def data(self): """ Initializes the data. """ self.Data = Data() self.trainingData = self.Data.loadTrainingData() self.trainedData = self.Data.loadTrainedData() self.trainedWords = self.trainedData["words"] self.trainedClasses = self.trainedData["classes"] self.x = self.trainedData["x"] self.y = self.trainedData["y"] self.intentMap = self.trainedData["intentMap"][0] def doExtension(self, extension, entities, exEntities, extensionResponses): """ Executes an extension. """ classParts = extension.split(".") classFolder = classParts[0] className = classParts[1] theEntities = None if exEntities != False: theEntities = entities module = __import__(classParts[0] + "." + classParts[1], globals(), locals(), [className]) extensionClass = getattr(module, className)() response = getattr(extensionClass, classParts[2])(extensionResponses, theEntities) return response def entities(self): """ Initializes the entities. """ self.entityController = Entities() self.ner = self.entityController.restoreNER() def entitiesCheck(self, entityHolder, theIntent, clearEntities): """ Checks entities. """ if not len(entityHolder) and len(theIntent["entities"]): response, entities = self.entityController.replaceResponseEntities( random.choice(theIntent["fallbacks"]), entityHolder) extension, extensionResponses, exEntities = self.Extensions.setExtension( theIntent) elif clearEntities: entities = [] response = random.choice(theIntent["responses"]) extension, extensionResponses, exEntities = self.Extensions.setExtension( theIntent) else: response, entities = self.entityController.replaceResponseEntities( random.choice(theIntent["responses"]), entityHolder) extension, extensionResponses, exEntities = self.Extensions.setExtension( theIntent) return response, entities, extension, extensionResponses, exEntities def fallbackCheck(self, fallback, theIntent, entityHolder): """ Checks if fallback. """ if fallback and fallback in theIntent and len(theIntent["fallbacks"]): response, entities = self.entityController.replaceResponseEntities( random.choice(theIntent["fallbacks"]), entityHolder) extension, extensionResponses, exEntities = None, [], None else: response, entities = self.entityController.replaceResponseEntities( random.choice(theIntent["responses"]), entityHolder) extension, extensionResponses, exEntities = self.Extensions.setExtension( theIntent) return response, entities, extension, extensionResponses, exEntities def model(self): """ Initializes the model. """ self.Model = Model() self.Context = Context() self.Extensions = Extensions() self.tmodel = self.Model.buildDNN(self.x, self.y) def session(self): """ Initializes a NLU sesiion. Initiates empty guest user session, GeniSys will ask the user verify their GeniSys user by speaking or typing if it does not know who it is speaking to. """ self.userID = 0 if not self.userID in self.user: self.user[self.userID] = {} self.user[self.userID]["history"] = {} def respond(self, status, sentence, intent, confidence, response, cIn, cOut, cCurrent, extension, entities): """ Forms the response. """ return { "Response": status, "ResponseData": [{ "Received": sentence, "Intent": intent, "Confidence": confidence, "Response": response, "Context": [{ "In": cIn, "Out": cOut, "Current": cCurrent }], "Extension": extension, "Entities": entities }] } def speech(self): """ Initializes the TTS feature. """ self.TTS = TTS() def thresholds(self): """ Sets thresholds Sets the threshold for the NLU engine, this can be changed using arguments to commandline programs or paramters for API calls. """ self.threshold = self.Helpers.confs["NLU"]["Threshold"] self.entityThrshld = self.Helpers.confs["NLU"]["Mitie"]["Threshold"]
class Model(): """ Model Class Model functions for the OneAPI Acute Lymphoblastic Leukemia Classifier CNN. """ def __init__(self): """ Initializes the class. """ self.Helpers = Helpers("Model", False) os.environ["KMP_BLOCKTIME"] = "1" os.environ["KMP_SETTINGS"] = "1" os.environ["KMP_AFFINITY"] = "granularity=fine,verbose,compact,1,0" os.environ["OMP_NUM_THREADS"] = str( self.Helpers.confs["cnn"]["system"]["cores"]) tf.config.threading.set_inter_op_parallelism_threads(1) tf.config.threading.set_intra_op_parallelism_threads( self.Helpers.confs["cnn"]["system"]["cores"]) self.testing_dir = self.Helpers.confs["cnn"]["data"]["test"] self.valid = self.Helpers.confs["cnn"]["data"]["valid_types"] self.seed = self.Helpers.confs["cnn"]["data"]["seed"] self.weights_file = self.Helpers.confs["cnn"]["model"]["weights"] self.model_json = self.Helpers.confs["cnn"]["model"]["model"] random.seed(self.seed) seed(self.seed) tf.random.set_seed(self.seed) self.Helpers.logger.info("Class initialization complete.") def do_data(self): """ Creates/sorts dataset. """ self.Data = Data() self.Data.do_im_process() self.Helpers.logger.info("Data preperation complete.") def do_network(self): """ Builds the network. Replicates the networked outlined in the Acute Leukemia Classification Using Convolution Neural Network In Clinical Decision Support System paper using Tensorflow 2.0. https://airccj.org/CSCP/vol7/csit77505.pdf """ self.val_steps = self.Helpers.confs["cnn"]["train"]["val_steps"] self.batch_size = self.Helpers.confs["cnn"]["train"]["batch"] self.epochs = self.Helpers.confs["cnn"]["train"]["epochs"] self.tf_model = tf.keras.models.Sequential([ tf.keras.layers.ZeroPadding2D( padding=(2, 2), input_shape=self.Data.X_train.shape[1:]), tf.keras.layers.Conv2D( 30, (5, 5), strides=1, padding="valid", activation='relu'), tf.keras.layers.ZeroPadding2D(padding=(2, 2)), tf.keras.layers.Conv2D( 30, (5, 5), strides=1, padding="valid", activation='relu'), tf.keras.layers.MaxPooling2D( pool_size=(2, 2), strides=2, padding='valid'), tf.keras.layers.Flatten(), tf.keras.layers.Dense(2), tf.keras.layers.Activation('softmax') ], "ALLoneAPI_CNN") self.tf_model.summary() self.Helpers.logger.info("Network initialization complete.") def do_train(self): """ Trains the network. """ self.Helpers.logger.info("Using Adam Optimizer.") optimizer = tf.keras.optimizers.Adam( lr=self.Helpers.confs["cnn"]["train"]["learning_rate_adam"], decay=self.Helpers.confs["cnn"]["train"]["decay_adam"]) self.tf_model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=[ tf.keras.metrics.BinaryAccuracy(name='acc'), tf.keras.metrics.Precision(name='precision'), tf.keras.metrics.Recall(name='recall'), tf.keras.metrics.AUC(name='auc') ]) self.history = self.tf_model.fit(self.Data.X_train, self.Data.y_train, validation_data=(self.Data.X_test, self.Data.y_test), validation_steps=self.val_steps, epochs=self.epochs) print(self.history) print("") self.freeze_model() self.save_model_as_json() self.save_weights() def do_evaluate(self): """ Evaluates the model """ self.do_predictions() metrics = self.tf_model.evaluate(self.Data.X_test, self.Data.y_test, verbose=0) for name, value in zip(self.tf_model.metrics_names, metrics): self.Helpers.logger.info("Metrics: " + name + " " + str(value)) print() self.visualize_metrics() self.confusion_matrix() self.figures_of_merit() def do_predictions(self): """ Makes predictions on the train & test sets. """ self.train_preds = self.tf_model.predict(self.Data.X_train) self.test_preds = self.tf_model.predict(self.Data.X_test) self.Helpers.logger.info("Training predictions: " + str(self.train_preds)) self.Helpers.logger.info("Testing predictions: " + str(self.test_preds)) print("") def visualize_metrics(self): """ Visualize the metrics. """ plt.plot(self.history.history['acc']) plt.plot(self.history.history['val_acc']) plt.title('Model Accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.ylim((0, 1)) plt.legend(['Train', 'Validate'], loc='upper left') plt.savefig('Model/Plots/Accuracy.png') plt.show() plt.clf() plt.plot(self.history.history['loss']) plt.plot(self.history.history['val_loss']) plt.title('Model Loss') plt.ylabel('loss') plt.xlabel('Epoch') plt.legend(['Train', 'Validate'], loc='upper left') plt.savefig('Model/Plots/Loss.png') plt.show() plt.clf() plt.plot(self.history.history['auc']) plt.plot(self.history.history['val_auc']) plt.title('Model AUC') plt.ylabel('AUC') plt.xlabel('Epoch') plt.legend(['Train', 'Validate'], loc='upper left') plt.savefig('Model/Plots/AUC.png') plt.show() plt.clf() plt.plot(self.history.history['precision']) plt.plot(self.history.history['val_precision']) plt.title('Model Precision') plt.ylabel('Precision') plt.xlabel('Epoch') plt.legend(['Train', 'Validate'], loc='upper left') plt.savefig('Model/Plots/Precision.png') plt.show() plt.clf() plt.plot(self.history.history['recall']) plt.plot(self.history.history['val_recall']) plt.title('Model Recall') plt.ylabel('Recall') plt.xlabel('Epoch') plt.legend(['Train', 'Validate'], loc='upper left') plt.savefig('Model/Plots/Recall.png') plt.show() plt.clf() def confusion_matrix(self): """ Prints/displays the confusion matrix. """ self.matrix = confusion_matrix(self.Data.y_test.argmax(axis=1), self.test_preds.argmax(axis=1)) self.Helpers.logger.info("Confusion Matrix: " + str(self.matrix)) print("") plt.imshow(self.matrix, cmap=plt.cm.Blues) plt.xlabel("Predicted labels") plt.ylabel("True labels") plt.xticks([], []) plt.yticks([], []) plt.title('Confusion matrix ') plt.colorbar() plt.savefig('Model/Plots/Confusion-Matrix.png') plt.show() plt.clf() def figures_of_merit(self): """ Calculates/prints the figures of merit. https://homes.di.unimi.it/scotti/all/ """ test_len = len(self.Data.X_test) TP = self.matrix[1][1] TN = self.matrix[0][0] FP = self.matrix[0][1] FN = self.matrix[1][0] TPP = (TP * 100) / test_len FPP = (FP * 100) / test_len FNP = (FN * 100) / test_len TNP = (TN * 100) / test_len specificity = TN / (TN + FP) misc = FP + FN miscp = (misc * 100) / test_len self.Helpers.logger.info("True Positives: " + str(TP) + "(" + str(TPP) + "%)") self.Helpers.logger.info("False Positives: " + str(FP) + "(" + str(FPP) + "%)") self.Helpers.logger.info("True Negatives: " + str(TN) + "(" + str(TNP) + "%)") self.Helpers.logger.info("False Negatives: " + str(FN) + "(" + str(FNP) + "%)") self.Helpers.logger.info("Specificity: " + str(specificity)) self.Helpers.logger.info("Misclassification: " + str(misc) + "(" + str(miscp) + "%)") def freeze_model(self): """ Saves the model weights. """ tf.saved_model.save( self.tf_model, self.Helpers.confs["cnn"]["model"]["saved_model_dir"]) fmodel = tf.function(lambda x: self.tf_model(x)) fmodel = fmodel.get_concrete_function(x=tf.TensorSpec( self.tf_model.inputs[0].shape, self.tf_model.inputs[0].dtype)) freeze = convert_variables_to_constants_v2(fmodel) freeze.graph.as_graph_def() layers = [op.name for op in freeze.graph.get_operations()] self.Helpers.logger.info("Frozen model layers") for layer in layers: self.Helpers.logger.info(layer) self.Helpers.logger.info("Frozen model inputs") self.Helpers.logger.info(freeze.inputs) self.Helpers.logger.info("Frozen model outputs") self.Helpers.logger.info(freeze.outputs) tf.io.write_graph( graph_or_graph_def=freeze.graph, logdir=self.Helpers.confs["cnn"]["model"]["freezing_log_dir"], name=self.Helpers.confs["cnn"]["model"]["frozen"], as_text=False) def save_weights(self): """ Saves the model weights. """ self.tf_model.save_weights(self.weights_file) self.Helpers.logger.info("Weights saved " + self.weights_file) def save_model_as_json(self): """ Saves the model to JSON. """ with open(self.model_json, "w") as file: file.write(self.tf_model.to_json()) self.Helpers.logger.info("Model JSON saved " + self.model_json) def load_model_and_weights(self): """ Loads the model and weights. """ with open(self.model_json) as file: m_json = file.read() self.tf_model = tf.keras.models.model_from_json(m_json) self.tf_model.load_weights(self.weights_file) self.Helpers.logger.info("Model loaded ") self.tf_model.summary() def test_classifier(self): """ Tests the trained model. """ files = 0 tp = 0 fp = 0 tn = 0 fn = 0 totaltime = 0 for testFile in os.listdir(self.testing_dir): if os.path.splitext(testFile)[1] in self.valid: files += 1 fileName = self.testing_dir + "/" + testFile start = time.time() img = cv2.imread(fileName).astype(np.float32) self.Helpers.logger.info("Loaded test image " + fileName) img = cv2.resize(img, (self.Helpers.confs["cnn"]["data"]["dim"], self.Helpers.confs["cnn"]["data"]["dim"])) img = self.reshape(img) prediction = self.get_predictions(img) end = time.time() benchmark = end - start totaltime += benchmark msg = "" if prediction == 1 and "_1." in testFile: tp += 1 msg = "Acute Lymphoblastic Leukemia correctly detected (True Positive) in " + str( benchmark) + " seconds." elif prediction == 1 and "_0." in testFile: fp += 1 msg = "Acute Lymphoblastic Leukemia incorrectly detected (False Positive) in " + str( benchmark) + " seconds." elif prediction == 0 and "_0." in testFile: tn += 1 msg = "Acute Lymphoblastic Leukemia correctly not detected (True Negative) in " + str( benchmark) + " seconds." elif prediction == 0 and "_1." in testFile: fn += 1 msg = "Acute Lymphoblastic Leukemia incorrectly not detected (False Negative) in " + str( benchmark) + " seconds." self.Helpers.logger.info(msg) self.Helpers.logger.info("Images Classifier: " + str(files)) self.Helpers.logger.info("True Positives: " + str(tp)) self.Helpers.logger.info("False Positives: " + str(fp)) self.Helpers.logger.info("True Negatives: " + str(tn)) self.Helpers.logger.info("False Negatives: " + str(fn)) self.Helpers.logger.info("Total Time Taken: " + str(totaltime)) def send_request(self, img_path): """ Sends image to the inference API endpoint. """ self.Helpers.logger.info("Sending request for: " + img_path) _, img_encoded = cv2.imencode('.png', cv2.imread(img_path)) response = requests.post(self.addr, data=img_encoded.tostring(), headers=self.headers) response = json.loads(response.text) return response def test_http_classifier(self): """ Tests the trained model via HTTP. """ msg = "" files = 0 tp = 0 fp = 0 tn = 0 fn = 0 self.addr = "http://" + self.Helpers.confs["cnn"]["system"]["server"] + \ ':'+str(self.Helpers.confs["cnn"]["system"]["port"]) + '/Inference' self.headers = {'content-type': 'image/jpeg'} for data in os.listdir(self.testing_dir): if os.path.splitext(data)[1] in self.valid: response = self.send_request(self.testing_dir + "/" + data) msg = "" if response["Diagnosis"] == "Positive" and "_1." in data: tp += 1 msg = "Acute Lymphoblastic Leukemia correctly detected (True Positive)" elif response["Diagnosis"] == "Positive" and "_0." in data: fp += 1 msg = "Acute Lymphoblastic Leukemia incorrectly detected (False Positive)" elif response["Diagnosis"] == "Negative" and "_0." in data: tn += 1 msg = "Acute Lymphoblastic Leukemia correctly not detected (True Negative)" elif response["Diagnosis"] == "Negative" and "_1." in data: fn += 1 msg = "Acute Lymphoblastic Leukemia incorrectly not detected (False Negative)" files += 1 self.Helpers.logger.info(msg) print() time.sleep(7) self.Helpers.logger.info("Images Classifier: " + str(files)) self.Helpers.logger.info("True Positives: " + str(tp)) self.Helpers.logger.info("False Positives: " + str(fp)) self.Helpers.logger.info("True Negatives: " + str(tn)) self.Helpers.logger.info("False Negatives: " + str(fn)) def http_classify(self, req): """ Classifies an image sent via HTTP. """ if len(req.files) != 0: img = np.fromstring(req.files['file'].read(), np.uint8) else: img = np.fromstring(req.data, np.uint8) img = cv2.imdecode(img, cv2.IMREAD_UNCHANGED) img = cv2.resize(img, (self.Helpers.confs["cnn"]["data"]["dim"], self.Helpers.confs["cnn"]["data"]["dim"])) img = self.reshape(img) return self.get_predictions(img) def vr_http_classify(self, img): """ Classifies an image sent via from VR via HTTP. """ img = cv2.resize(img, (self.Helpers.confs["cnn"]["data"]["dim"], self.Helpers.confs["cnn"]["data"]["dim"])) img = self.reshape(img) return self.get_predictions(img) def get_predictions(self, img): """ Gets a prediction for an image. """ predictions = self.tf_model.predict_proba(img) prediction = np.argmax(predictions, axis=-1) return prediction def reshape(self, img): """ Reshapes an image. """ dx, dy, dz = img.shape input_data = img.reshape((-1, dx, dy, dz)) return input_data
class Trainer(): ############################################################### # # Sets up all default requirements and placeholders # needed for the NLU engine to run. # # - Helpers: Useful global functions # - JumpWay/jumpWayClient: iotJumpWay class and connection # - Logging: Logging class # ############################################################### def __init__(self): self.Helpers = Helpers() self._confs = self.Helpers.loadConfigs() self.LogFile = self.Helpers.setLogFile(self._confs["aiCore"]["Logs"] + "Train/") self.intentMap = {} self.words = [] self.classes = [] self.dataCorpus = [] self.Model = Model() self.Data = Data() def setupData(self): self.trainingData = self.Data.loadTrainingData() self.words, self.classes, self.dataCorpus, self.intentMap = self.Data.prepareData( self.trainingData) self.x, self.y = self.Data.finaliseData(self.classes, self.dataCorpus, self.words) self.Helpers.logMessage(self.LogFile, "TRAIN", "INFO", "NLU Training Data Ready") def setupEntities(self): if self._confs["NLU"]["Entities"] == "Mitie": self.entityController = Entities() self.entityController.trainEntities( self._confs["NLU"]["Mitie"]["ModelLocation"], self.trainingData) self.Helpers.logMessage(self.LogFile, "TRAIN", "OK", "NLU Trainer Entities Ready") def trainModel(self): while True: self.Helpers.logMessage(self.LogFile, "TRAIN", "ACTION", "Ready To Begin Training ? (Yes/No)") userInput = input(">") if userInput == 'Yes': break if userInput == 'No': exit() self.setupData() self.setupEntities() humanStart, trainingStart = self.Helpers.timerStart() self.Model.trainDNN(self.x, self.y, self.words, self.classes, self.intentMap) trainingEnd, trainingTime, humanEnd = self.Helpers.timerEnd( trainingStart) self.Helpers.logMessage( self.LogFile, "TRAIN", "OK", "NLU Model Trained At " + humanEnd + " In " + str(trainingEnd) + " Seconds")
def __init__(self): """ Initializes the Augmentation class. """ self.Data = Data()
class AllDS2020(): """ AllDS2020 Wrapper Class Core wrapper class for the Tensorflow 2.0 AllDS2020 classifier. """ def __init__(self): self.Helpers = Helpers("Core") self.optimizer = "Adam" self.mode = "Local" self.do_augmentation = True def do_data(self): """ Creates/sorts dataset. """ self.Data = Data(self.optimizer, self.do_augmentation) self.Data.data_and_labels_sort() if self.do_augmentation == False: self.Data.data_and_labels_prepare() else: self.Data.data_and_labels_augmentation_prepare() self.Data.shuffle() self.Data.get_split() def do_model(self): """ Creates & trains the model. Replicates the networked and data splits outlined in the Acute Leukemia Classification Using Convolution Neural Network In Clinical Decision Support System paper using Tensorflow 2.0. https://airccj.org/CSCP/vol7/csit77505.pdf """ self.Model = Model(self.optimizer, self.do_augmentation) self.Model.build_network(self.Data.X_train, self.Data.X_test, self.Data.y_train, self.Data.y_test) self.Model.compile_and_train() self.Model.save_model_as_json() self.Model.save_weights() def do_evaluate(self): """ Predictions & Evaluation """ self.Model.predictions() self.Model.evaluate_model() def do_metrics(self): """ Predictions & Evaluation """ self.Model.visualize_metrics() self.Model.confusion_matrix() self.Model.figures_of_merit() def do_create_model(self): """ Loads the model """ self.Model = Model(self.optimizer, self.do_augmentation) def do_load_model(self): """ Loads the model """ self.Model.load_model_and_weights() def do_classify(self): """ Loads model and classifies test data """ self.do_create_model() self.do_load_model() self.Model.test_classifier() def do_http_classify(self): """ Loads model and classifies test data """ self.do_create_model() self.Model.test_http_classifier()