def confMat(sess): sess.run(tf.global_variables_initializer()) ckpt = tf.train.get_checkpoint_state( os.path.dirname('Graphs_and_Results/')) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) datafeeder = Prep() data, label = datafeeder.nextBatchTest_ConfMat() matrix = np.zeros([10, 10]) prediction_ = sess.run(prediction, feed_dict={ x: data, truth: label, hold_prob: 1 }) for l in range(len(prediction_)): k = np.argmax(prediction_[l]) m = np.argmax(label[l]) matrix[k][m] += 1 test = open("Graphs_and_Results/confusion.csv", "w") logger = csv.writer(test, lineterminator="\n") for iterate in matrix: logger.writerow(iterate) print([ 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck' ]) print(matrix)
def Conf_mat(): optimizer = tf.keras.optimizers.Adam(learning_rate=0.001) loss_function = tf.keras.losses.CategoricalCrossentropy(from_logits=True) inputs = tf.keras.Input(shape=[32, 32, 3]) x = Convolve([4, 4, 3, 32])(inputs) x = Convolve([4, 4, 32, 64])(x) x = Convolve([4, 4, 64, 128])(x) x = Flatten([-1, 4 * 4 * 128])(x) x = FC([4 * 4 * 128, 1024])(x) x = FC([1024, 10])(x) outputs = Softmax([])(x) model = tf.keras.Model(inputs=inputs, outputs=outputs) print(model.summary()) model.compile(optimizer=optimizer, loss=loss_function, metrics=['accuracy']) model.load_weights("Graphs_and_Results/best_weights.h5") datafeeder = Prep() data, label = datafeeder.nextBatchTest() acc = model.evaluate(data, label, batch_size=100) print(acc)
def Test(): print("Making model") model = Model() model.build_model_from_pickle("Graphs_and_Results/dual/" + version + "/SAVED_WEIGHTS.pkl") datafeeder = Prep(TEST_AMOUNT, VALID_AMOUNT, SELECTION_LIST) datafeeder.load_train_to_RAM() data, label = datafeeder.GetTest_dom() predictions, l2loss = model.call(data) assert len(label) == len( predictions), "something is wrong with the loaded model or labels" conf = np.zeros(shape=[len(label[0]), len(predictions[0])]) for i in range(len(predictions)): k = np.argmax(predictions[i]) l = np.argmax(label[i]) conf[k][l] += 1 test = open("Graphs_and_Results/dual/" + version + "/confusion.csv", "w") logger = csv.writer(test, lineterminator="\n") test_ = open("Graphs_and_Results/dual/" + version + "/results.csv", "w") logger_ = csv.writer(test_, lineterminator="\n") logger_.writerow([accuracy(predictions, label)]) for iterate in conf: logger.writerow(iterate) right, wrong = record_error(data, label, predictions) try: os.mkdir("Graphs_and_Results/dual/" + version + "/wrong/") os.mkdir("Graphs_and_Results/dual/" + version + "/right/") except: shutil.rmtree("Graphs_and_Results/dual/" + version + "/wrong/") shutil.rmtree("Graphs_and_Results/dual/" + version + "/right/") os.mkdir("Graphs_and_Results/dual/" + version + "/wrong/") os.mkdir("Graphs_and_Results/dual/" + version + "/right/") for i in range(len(wrong)): print("Saving wrong image {}".format(i)) carrier = np.reshape(wrong[i], [100, 100]) util.save_image( 255 * carrier, "Graphs_and_Results/dual/" + version + "/wrong/" + str(i) + ".jpg", "L") for i in range(len(right)): print("Saving right image {}".format(i)) carrier = np.reshape(right[i], [100, 100]) util.save_image( 255 * carrier, "Graphs_and_Results/dual/" + version + "/right/" + str(i) + ".jpg", "L") print("This is the test set accuracy: {}".format( accuracy(predictions, label)))
def Big_Train(): print("Is there a GPU available: "), print(tf.test.is_gpu_available()) print("*****************Training*****************") datafeeder = Prep(TEST_AMOUNT, VALID_AMOUNT, [version]) optimizer = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE_INIT) loss_function = tf.keras.losses.CategoricalCrossentropy() print("loading dataset") datafeeder.load_train_to_RAM() # loads the training data to RAM summary_writer = tf.summary.create_file_writer(logdir=base_directory) print("starting training") print("Making model") model = Model() model.build_model() tf.summary.trace_on(graph=True, profiler=True) for epoch in range(1001): data, label = datafeeder.nextBatchTrain_dom(150) data = data[0] with tf.GradientTape() as tape: predictions, l2_loss = model.call(data) #this is the big call pred_loss = loss_function(label, predictions) #this is the loss function pred_loss = pred_loss + L2WEIGHT * l2_loss #this implements lasso regularization if epoch == 0: #creates graph with summary_writer.as_default(): tf.summary.trace_export(name="Graph", step=0, profiler_outdir=base_directory) if epoch % 50 == 0: #takes care of validation accuracy valid_accuracy = Validation(model, datafeeder) with summary_writer.as_default(): logger.log_valid(valid_accuracy, epoch) with summary_writer.as_default( ): #this is the big player logger and printout logger.log_train(epoch, predictions, label, pred_loss, l2_loss, big_list) gradients = tape.gradient(pred_loss, big_list) optimizer.apply_gradients(zip(gradients, big_list)) Test_live(model, datafeeder)
def Test(): print("Making model") model = Model() model.build_model_from_pickle(base_directory + "SAVED_WEIGHTS.pkl") datafeeder = Prep(TEST_AMOUNT, VALID_AMOUNT, [version]) datafeeder.load_train_to_RAM() data, label = datafeeder.GetTest_dom() data = data[0] # this is because we now have multiple images in the pickle predictions, l2loss = model.call(data) print("This is the test set accuracy: {}".format( accuracy(predictions, label)))
def Test(): print("Making model") model = Model() model.build_model_from_pickle("Graphs_and_Results/basic/" + version + "/" + "SAVED_WEIGHTS.pkl") datafeeder = Prep(TEST_AMOUNT, VALID_AMOUNT, [version]) datafeeder.load_train_to_RAM() data, label = datafeeder.GetTest_dom() data = data[0] # this is because we now have multiple images in the pickle predictions, l2loss = model.call(data) assert len(label) == len( predictions), "something is wrong with the loaded model or labels" right, wrong, wrong_list = record_error(data, label, predictions) print("This is the test set accuracy: {}".format( accuracy(predictions, label))) try: os.mkdir("Graphs_and_Results/basic/" + version + "/wrong/") os.mkdir("Graphs_and_Results/basic/" + version + "/right/") os.mkdir("Graphs_and_Results/wrongs/") except: shutil.rmtree("Graphs_and_Results/basic/" + version + "/wrong/") shutil.rmtree("Graphs_and_Results/basic/" + version + "/right/") os.mkdir("Graphs_and_Results/basic/" + version + "/wrong/") os.mkdir("Graphs_and_Results/basic/" + version + "/right/") wrong_logger = csv.writer(open( "Graphs_and_Results/wrongs/" + version + "SimpleCNN.csv", "w"), lineterminator="\n") for element in wrong_list: wrong_logger.writerow([element]) for i in range(len(wrong)): print("Saving wrong image {}".format(i)) carrier = np.reshape(wrong[i], [100, 100]) util.save_image( 255 * carrier, "Graphs_and_Results/basic/" + version + "/wrong/" + str(i) + ".jpg", "L") for i in range(len(right)): print("Saving right image {}".format(i)) carrier = np.reshape(right[i], [100, 100]) util.save_image( 255 * carrier, "Graphs_and_Results/basic/" + version + "/right/" + str(i) + ".jpg", "L")
def Big_Train(sess): sess.run(tf.global_variables_initializer()) writer = tf.compat.v1.summary.FileWriter( "Graphs_and_Results/", sess.graph) # this will write summary tensorboard datafeeder = Prep() display, _ = datafeeder.nextBatchTrain(10) tf.compat.v1.summary.image("10 training data examples", display, max_outputs=10) for i in range(501): data, label = datafeeder.nextBatchTrain(100) prediction_, loss_, summary, _ = sess.run( [prediction, loss, summary_op, train], feed_dict={ x: data, truth: label, hold_prob: 1 }) print("Epoch: {}. Loss: {}".format(i, loss_)) if i % 10 == 0: writer.add_summary(summary, global_step=i) if i % 100 == 0 and i > 0: saver.save(sess, "Graphs_and_Results/CNN_test", global_step=i) data, label = datafeeder.nextBatchTest() correct = 0 prediction_ = sess.run(prediction, feed_dict={ x: data, truth: label, hold_prob: 1 }) for l in range(len(label)): if (np.argmax(prediction_[l]) == np.argmax(label[l])): correct += 1 print("This is the accuracy: {}".format(correct / len(prediction_)))
def Big_Train(): datafeeder = Prep() optimizer = tf.keras.optimizers.Adam(learning_rate=0.001) loss_function = tf.keras.losses.CategoricalCrossentropy(from_logits=True) inputs = tf.keras.Input(shape=[32, 32, 3]) x = Convolve([4, 4, 3, 32])(inputs) x = Convolve([4, 4, 32, 64])(x) x = Convolve([4, 4, 64, 128])(x) x = Flatten([-1, 4 * 4 * 128])(x) x = FC([4 * 4 * 128, 1024])(x) x = FC([1024, 10])(x) outputs = Softmax([])(x) model = tf.keras.Model(inputs=inputs, outputs=outputs) print(model.summary()) model.compile(optimizer=optimizer, loss=loss_function, metrics=['accuracy']) data, label = datafeeder.nextBatchTrain_all() tensorboard = tf.keras.callbacks.TensorBoard(log_dir='Graphs_and_Results', histogram_freq=1, write_graph=True, write_grads=True, update_freq='batch') cp = tf.keras.callbacks.ModelCheckpoint("Graphs_and_Results/current.ckpt", verbose=1, save_weights_only=True, period=1) model.fit(data, label, batch_size=100, epochs=5, callbacks=[tensorboard, cp]) model.save_weights("Graphs_and_Results/best_weights.h5")
def Big_Train(): try: os.mkdir("Graphs_and_Results/dual/" + version) except: print("dual/{} has already been created".format(version)) status = tf.test.is_gpu_available() print("Is there a GPU available: {}".format(status)) print("*****************Training*****************") datafeeder = Prep(TEST_AMOUNT, VALID_AMOUNT, SELECTION_LIST) optimizer = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE_INIT) loss_function = tf.keras.losses.CategoricalCrossentropy() print("loading dataset") datafeeder.load_train_to_RAM() # loads the training data to RAM summary_writer = tf.summary.create_file_writer( logdir="Graphs_and_Results/dual/" + version + "/") print("starting training") print("Making model") model = Model() model.build_model() train_logger = csv.writer(open( "Graphs_and_Results/dual/" + version + "/xentropyloss.csv", "w"), lineterminator="\n") acc_logger = csv.writer(open( "Graphs_and_Results/dual/" + version + "/accuracy.csv", "w"), lineterminator="\n") l2_logger = csv.writer(open( "Graphs_and_Results/dual/" + version + "/l2.csv", "w"), lineterminator="\n") valid_logger = csv.writer(open( "Graphs_and_Results/dual/" + version + "/valid.csv", "w"), lineterminator="\n") tf.summary.trace_on( graph=True, profiler=False) #set profiler to true if you want compute history for epoch in range(1001): data, label = datafeeder.nextBatchTrain_dom(150) with tf.GradientTape() as tape: predictions, l2_loss = model.call(data) #this is the big call pred_loss_ = loss_function(label, predictions) #this is the loss function pred_loss = pred_loss_ + L2WEIGHT * l2_loss if epoch == 0: #creates graph with summary_writer.as_default(): tf.summary.trace_export( name="Graph", step=0, profiler_outdir="Graphs_and_Results/dual/" + version + "/") train_logger.writerow([np.asarray(pred_loss)]) acc_logger.writerow([accuracy(predictions, label)]) l2_logger.writerow([np.asarray(l2_loss)]) print("***********************") print("Finished epoch", epoch) print("Accuracy: {}".format(accuracy(predictions, label))) print("Loss: {}".format(np.asarray(pred_loss))) print("L2 Loss: {}".format(np.asarray(l2_loss))) print("***********************") if epoch % 20 == 0: with summary_writer.as_default(): tf.summary.scalar(name="XEntropyLoss", data=pred_loss_, step=epoch) tf.summary.scalar(name="L2Loss", data=l2_loss, step=epoch) tf.summary.scalar(name="Accuracy", data=accuracy(predictions, label), step=epoch) for var in big_list: name = str(var.name) tf.summary.histogram(name=name, data=var, step=epoch) tf.summary.flush() if epoch % 50 == 0: valid_accuracy = Validation(model, datafeeder) with summary_writer.as_default(): tf.summary.scalar(name="Validation_accuracy", data=valid_accuracy, step=epoch) valid_logger.writerow([valid_accuracy]) if epoch % 100 == 0 and epoch > 1: print("\n##############SAVING MODE##############\n") try: #because for some reason, the pickle files are incremental os.remove("Graphs_and_Results/dual/" + version + "/SAVED_WEIGHTS.pkl") except: print( "the saved weights were not removed because they were not there!" ) dbfile = open( "Graphs_and_Results/dual/" + version + "/SAVED_WEIGHTS.pkl", "ab") pickle.dump(big_list, dbfile) gradients = tape.gradient(pred_loss, big_list) optimizer.apply_gradients(zip(gradients, big_list)) right, wrong = Test_live(model, datafeeder) try: os.mkdir("Graphs_and_Results/dual/" + version + "/wrong/") os.mkdir("Graphs_and_Results/dual/" + version + "/right/") except: shutil.rmtree("Graphs_and_Results/dual/" + version + "/wrong/") shutil.rmtree("Graphs_and_Results/dual/" + version + "/right/") os.mkdir("Graphs_and_Results/dual/" + version + "/wrong/") os.mkdir("Graphs_and_Results/dual/" + version + "/right/") for i in range(len(wrong)): print("Saving wrong image {}".format(i)) carrier = np.reshape(wrong[i], [100, 100]) util.save_image( 255 * carrier, "Graphs_and_Results/dual/" + version + "/wrong/" + str(i) + ".jpg", "L") for i in range(len(right)): print("Saving right image {}".format(i)) carrier = np.reshape(right[i], [100, 100]) util.save_image( 255 * carrier, "Graphs_and_Results/dual/" + version + "/right/" + str(i) + ".jpg", "L")
def Big_Train(): try: os.mkdir("Graphs_and_Results/basic/" + version + "/") except: pass print("Is there a GPU available: "), print(tf.test.is_gpu_available()) print("*****************Training*****************") datafeeder = Prep(TEST_AMOUNT, VALID_AMOUNT, [version]) optimizer = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE_INIT) loss_function = tf.keras.losses.CategoricalCrossentropy() print("loading dataset") datafeeder.load_train_to_RAM() # loads the training data to RAM summary_writer = tf.summary.create_file_writer( logdir="Graphs_and_Results/basic/" + version + "/") print("starting training") print("Making model") model = Model() model.build_model() tf.summary.trace_on(graph=True, profiler=True) train_logger = csv.writer(open( "Graphs_and_Results/basic/" + version + "/xentropyloss.csv", "w"), lineterminator="\n") acc_logger = csv.writer(open( "Graphs_and_Results/basic/" + version + "/accuracy.csv", "w"), lineterminator="\n") l2_logger = csv.writer(open( "Graphs_and_Results/basic/" + version + "/l2.csv", "w"), lineterminator="\n") valid_logger = csv.writer(open( "Graphs_and_Results/basic/" + version + "/valid.csv", "w"), lineterminator="\n") for epoch in range(1001): data, label = datafeeder.nextBatchTrain_dom(150) data = data[0] with tf.GradientTape() as tape: predictions, l2_loss = model.call(data) #this is the big call pred_loss = loss_function(label, predictions) #this is the loss function pred_loss = pred_loss + L2WEIGHT * l2_loss #this implements lasso regularization train_logger.writerow([np.asarray(pred_loss)]) acc_logger.writerow([accuracy(predictions, label)]) l2_logger.writerow([np.asarray(l2_loss)]) if epoch == 0: #creates graph with summary_writer.as_default(): tf.summary.trace_export( name="Graph", step=0, profiler_outdir="Graphs_and_Results/basic/" + version + "/") if epoch % 20 == 0 and epoch > 1: print("***********************") print("Finished epoch", epoch) print("Accuracy: {}".format(accuracy(predictions, label))) print("Loss: {}".format(np.asarray(pred_loss))) print("***********************") with summary_writer.as_default(): tf.summary.scalar(name="Loss", data=pred_loss, step=epoch) tf.summary.scalar(name="Accuracy", data=accuracy(predictions, label), step=epoch) for var in big_list: name = str(var.name) tf.summary.histogram(name="Variable_" + name, data=var, step=epoch) tf.summary.flush() if epoch % 50 == 0: valid_accuracy = Validation(model, datafeeder) with summary_writer.as_default(): tf.summary.scalar(name="Validation_accuracy", data=valid_accuracy, step=epoch) valid_logger.writerow([valid_accuracy]) if epoch % 100 == 0 and epoch > 1: print("\n##############SAVING MODE##############\n") try: os.remove("Graphs_and_Results/basic/" + version + "/" + "SAVED_WEIGHTS.pkl") except: print( "the saved weights were not removed, because they were not there!" ) dbfile = open( "Graphs_and_Results/basic/" + version + "/" + "SAVED_WEIGHTS.pkl", "ab") pickle.dump(big_list, dbfile) gradients = tape.gradient(pred_loss, big_list) optimizer.apply_gradients(zip(gradients, big_list)) Test_live(model, datafeeder)