class NeuralNet: def __init__(self, split=[70,20,10], filename="model"): if not os.path.exists(MODEL_PATH): os.makedirs(MODEL_PATH) if not os.path.exists(TRAINED_PATH): os.makedirs(TRAINED_PATH) if not os.path.exists(PERF_PATH): os.makedirs(PERF_PATH) self.viz = Visualize() self.dataset = Dataset() self.dataset.LoadData("Field_Serra*.csv", "list_t*.csv", split) self.filename = filename def _processX(self, X, count): new_X = [] for _ in range(count): new_X.append(X[:,_].reshape(100,205)) return np.array(new_X) def _get_data(self, data_type): x, y, size = self.dataset.MiniBatch(data_type) x = self._processX(x, size) x = x.reshape((size, 100, 205, 1)) y = y.reshape((size,)) return x,y def _get_specific_records(self, lst:list): x, y, size = self.dataset.CustomBatch(lst) x = self._processX(x, size) x = x.reshape((size, 100, 205, 1)) y = y.reshape((size,)) return x,y def _accuracy(self, lst_X: list(), lst_Y: list()): assert(len(lst_X) == len(lst_Y)) accuracy = [self.model.evaluate(x, y) for x,y in zip(lst_X, lst_Y)] return accuracy def _prediction(self, lst_X: list, lst_Y: list): assert(len(lst_X) == len(lst_Y)) y_predic = [self.model.predict(x).reshape(y.shape[0],) for x,y in zip(lst_X, lst_Y)] return y_predic def _check_predictions(self, X, Y): y_p = self.model.predict(X) y_p = y_p.reshape(y_p.shape[0],) corr, _ = pearsonr(Y, y_p.reshape(y_p.shape[0],)) print("Pearson Score: %.3f"%corr) diff = y_p - Y ct_p = 0 ct_n = 0 ct_0 = 0 for a in diff: if a > 0: ct_p+=1 elif a < 0: ct_n+=1 else: ct_0+=1 return ct_p, ct_n, ct_0, corr def _write_to_file(self, rows): f = open(PERF_PATH + self.filename + ".csv", "a") cc = csv.writer(f) cc.writerows(rows) f.close() print("Performance data written to CSV") def _write_to_file2(self, rows): f = open(PERF_PATH + self.filename + "_Custom.csv", "a") cc = csv.writer(f) cc.writerows(rows) f.close() print("Custom Performance data written to CSV") def BuildModel(self, loss_type='mean_squared_error', dropout=0.0): self.model = Sequential() self.model.add(Conv2D(16, kernel_size=7, padding='same', strides=(2,2), activation='relu', input_shape=(100,205,1))) #self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(strides=2)) # self.model.add(Conv2D(32, kernel_size=7, padding='same', activation='relu')) # #self.model.add(BatchNormalization()) # self.model.add(MaxPooling2D(strides=2)) self.model.add(Conv2D(64, kernel_size=7, padding='same', activation='relu')) #self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(strides=2)) self.model.add(Conv2D(128, kernel_size=7, padding='same', activation='relu')) # #self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(strides=2)) self.model.add(Conv2D(256, kernel_size=5, padding='same', activation='relu')) #self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(strides=2)) self.model.add(Flatten()) self.model.add(Dense(256, activation='relu')) self.model.add(Dropout(dropout)) self.model.add(Dense(256, activation='relu')) self.model.add(Dropout(dropout)) self.model.add(Dense(512, activation='relu')) self.model.add(Dense(1, activation='relu')) #self.model.compile(loss='mean_squared_error', optimizer='adam') #self.model.compile(loss='mean_absolute_percentage_error', optimizer='adam') self.model.compile(loss=loss_type, optimizer='adam') self.model.summary() plot_model(self.model, to_file="model.png") def TrainModel(self, epochs, batch_size=10, max_iteration = 20): x_train, y_train = self._get_data('train') x_val, y_val = self._get_data('val') x_test, y_test = self._get_data('test') checkpoint = ModelCheckpoint(MODEL_PATH + self.filename + ".hdf5", monitor='loss', verbose=1, save_best_only=True, mode='auto', period=5) old_predic = 0 ctr = 0 eps = int(epochs / max_iteration) self._write_to_file([["Train","Validation", "Test"]]) for itr in range(max_iteration): print("Running Iteration ", itr) self.model.fit(x_train, y_train, epochs=eps, batch_size=batch_size, verbose=0, validation_data=(x_val, y_val), callbacks=checkpoint) print("\n\nEvaluating Models") accuracy = self._accuracy([x_train, x_val, x_test], [y_train, y_val, y_test]) print("Accuracy: Train->%.2f | Val->%.2f | Test->%.2f\n"%(accuracy[0], accuracy[1], accuracy[2])) print("\n\nPredictions") prediction = self._prediction([x_train, x_val, x_test], [y_train, y_val, y_test]) predic1 = self._check_predictions(x_train, y_train) predic2 = self._check_predictions(x_val, y_val) predic3 = self._check_predictions(x_test, y_test) self._write_to_file([accuracy, [predic1, predic2, predic3]]) ## Early Stopping if old_predic < predic2[3]: old_predic = predic2[3] ctr=0 self.save() else: if ctr == 3: print("Breaking Early!", old_predic, predic2[3]) break ctr += 1 ## Store all records data to file self._write_to_file([["Index", "Actual","Predicted"]]) self._write_to_file(np.transpose([ np.array(self.dataset.Val_seq + self.dataset.Test_seq), np.array(y_val.tolist()+y_test.tolist()), np.array(prediction[1].tolist() + prediction[2].tolist())])) return [predic1, predic2, predic3] def save(self): self.model.save(TRAINED_PATH + filename + ".hdf5") print("Saved Model!") def visualize(self, data_indexs: list, save=False): vl = VisualizeLayers() for index in data_indexs: datas,_ = self._get_specific_records([index]) if not os.path.exists(LAYER_IMG + str(index)): os.makedirs(LAYER_IMG + str(index)) vl.visualize(self.model, datas, save_image=save, path=LAYER_IMG + str(index)) def predict(self, data_indexs: list): X,Y = self._get_specific_records(data_indexs) y_p = self.model.predict(X) y_p = y_p.reshape(y_p.shape[0],) self._write_to_file2([["Index", "Actual","Predicted"]]) self._write_to_file2(np.transpose([np.array(data_indexs), Y, y_p])) print([np.array(data_indexs), Y, y_p])
class NeuralNet: def __init__(self, split=[70,20,10], filename="model"): if not os.path.exists(MODEL_PATH): os.makedirs(MODEL_PATH) if not os.path.exists(TRAINED_PATH): os.makedirs(TRAINED_PATH) if not os.path.exists(PERF_PATH): os.makedirs(PERF_PATH) if not os.path.exists(LAYER_IMG): os.makedirs(LAYER_IMG) self.viz = Visualize() self.dataset = Dataset() self.utility = Utility(filename) self.dataset.LoadData("Field_Serra*.csv", "list_t*.csv", split) self.filename = filename def _processX(self, X, count): new_X = [] for _ in range(count): new_X.append(np.flip(X[:,_].reshape(100,205),axis=0)) return np.array(new_X) def _get_data(self, data_type): x, y, size = self.dataset.MiniBatch(data_type) x = self._processX(x, size) x = x.reshape((size, 100, 205, 1)) y = y.reshape((size,)) return x,y def _get_specific_records(self, lst:list): x, y, size = self.dataset.CustomBatch(lst) x = self._processX(x, size) x = x.reshape((size, 100, 205, 1)) y = y.reshape((size,)) return x,y def _accuracy(self, lst_X: list(), lst_Y: list()): assert(len(lst_X) == len(lst_Y)) accuracy = [self.model.evaluate(x, y) for x,y in zip(lst_X, lst_Y)] return accuracy def _prediction(self, lst_X: list, lst_Y: list): assert(len(lst_X) == len(lst_Y)) # y_p = self.model.predict(lst_X) # y_p = y_p.reshape(y_p.shape[0],) y_predic = [self.model.predict(x).reshape(y.shape[0],) for x,y in zip(lst_X, lst_Y)] return y_predic def _check_predictions(self, X, Y): y_p = self.model.predict(X) y_p = y_p.reshape(y_p.shape[0],) corr, _ = pearsonr(Y, y_p.reshape(y_p.shape[0],)) print("Pearson Score: %.3f"%corr) diff = y_p - Y ct_p = 0 ct_n = 0 ct_0 = 0 for a in diff: if a > 0: ct_p+=1 elif a < 0: ct_n+=1 else: ct_0+=1 return ct_p, ct_n, ct_0, corr def _write_to_file(self, rows): f = open(PERF_PATH + self.filename + ".csv", "a") cc = csv.writer(f) cc.writerows(rows) f.close() print("Performance data written to CSV") def BuildModel(self, layers: list, loss_type='mean_squared_error', dropout=0.0): self.model = Sequential() for layer in layers: self.model.add(layer) self.model.compile(loss=loss_type, optimizer='adam')#, metrics=['accuracy']) self.model.summary() plot_model(self.model, to_file=self.filename + "_model.png") def TrainModel(self, epochs, batch_size=10): x_train, y_train = self._get_data('train') x_val, y_val = self._get_data('val') x_test, y_test = self._get_data('test') #checkpoint = ModelCheckpoint(MODEL_PATH + self.filename + ".hdf5", monitor='val_accuracy', verbose=1, save_best_only=True, mode='auto', period=10) checkpoint = ModelCheckpoint(MODEL_PATH + self.filename + ".hdf5", monitor='loss', verbose=1, save_best_only=True, mode='auto', period=10) self._write_to_file([["Train","Validation", "Test"]]) #history = self.model.fit(x_train, y_train, steps_per_epoch=int(x_train.shape[0]/epochs), epochs=epochs, batch_size=batch_size, verbose=0, validation_data=(x_val, y_val), callbacks=checkpoint) self.model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0, validation_data=(x_val, y_val), callbacks=checkpoint) print("\n\nEvaluating Models") accuracy = self._accuracy([x_train, x_val, x_test], [y_train, y_val, y_test]) print(accuracy) print("\n\nPredictions") prediction = self._prediction([x_train, x_val, x_test], [y_train, y_val, y_test]) predic1 = self._check_predictions(x_train, y_train) predic2 = self._check_predictions(x_val, y_val) predic3 = self._check_predictions(x_test, y_test) self.X = x_test # acc = history.history['accuracy'] # val_acc = history.history['val_accuracy'] # loss = history.history['loss'] # val_loss = history.history['val_loss'] # tot_epochs = range(1, len(acc) + 1) #self.utility.display_accuracy(tot_epochs, acc, val_acc) #self.utility.display_loss(tot_epochs, loss, val_loss) #self.utility.show_layers(self.model, x_test) self._write_to_file([accuracy, [predic1, predic2, predic3]]) self._write_to_file([["Index", "Actual","Predicted"]]) # self._write_to_file(np.transpose([np.array(y_val.tolist()+y_test.tolist()), # prediction[1].tolist() + prediction[2].tolist()])) self._write_to_file(np.transpose([ np.array(self.dataset.Val_seq + self.dataset.Test_seq), np.array(y_val.tolist()+y_test.tolist()), np.array(prediction[1].tolist() + prediction[2].tolist())])) return [predic1, predic2, predic3] def save(self): self.model.save(TRAINED_PATH + self.filename + ".hdf5") print("Saved Model!") def load(self): self.model.load_weights(MODEL_PATH + self.filename + ".hdf5") def visualize(self, data_indexs: list, save=False): vl = VisualizeLayers() for index in data_indexs: datas,_ = self._get_specific_records([index]) if not os.path.exists(LAYER_IMG + str(index)): os.makedirs(LAYER_IMG + str(index)) vl.visualize(self.model, datas, save_image=save, path=LAYER_IMG + str(index)) def predict(self, data_indexs: list): X,Y = self._get_specific_records(data_indexs) y_p = self.model.predict(X) print(self._prediction(X, Y))