log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir) callback_list = [tensorboard_callback] # Set up the verbose=1 (or verbose=1) for visible (or invisible) epochs. model.fit(train_generator, epochs=EPOCHS, steps_per_epoch=train_num // BATCH_SIZE, validation_data=valid_generator, validation_steps=valid_num // BATCH_SIZE, callbacks=callback_list, verbose=1) # The system saves the whole model into the direcotry: /home/mike/Documents/AlexNet-tf2/content. The # model of my_model.h5 has the quite big size of 748.6 MB. model.save(model_dir) # To view the diagrams, users need to upload the Python script into Jupyter Notebook and run the # the script or directly upload and run the original ipython script. class_names = ['bike', 'ship'] x_valid, label_batch = next(iter(valid_generator)) prediction_values = model.predict_classes(x_valid) # The plot will be realized in the Jupyter Notebook after running the script in either Python or # ipython. fig = plt.figure(figsize=(10, 6)) fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05) # Plot the images: each image is 227x227 pixels for i in range(8): ax = fig.add_subplot(2, 4, i + 1, xticks=[], yticks=[])
base_path = "dataset" train_h5_file = "food_c101_n10099_r64x64x3.h5" test_h5_file = "food_test_c101_n1000_r64x64x3.h5" X_train, y_train, X_test, y_test = read_from_h5(base_path, train_h5_file, test_h5_file) from keras.callbacks import ModelCheckpoint checkpoint = ModelCheckpoint('best_model.h5', monitor='val_loss', save_best_only=True, mode='auto') steps_per_epoch = int(len(y_train) / BATCH_SIZE) # 300 validation_steps = int(len(y_test) / BATCH_SIZE) # 90 # Training model_info = model.fit(X_train, y_train, validation_data=(X_test, y_test), batch_size=BATCH_SIZE, shuffle="batch", epochs=NUM_EPOCH, verbose=1) model.save("food_classification.h5") # plot model history after each epoch from visulization import plot_model_history plot_model_history(model_info)
sess.run(tf.global_variables_initializer()) for i in range(EPOCHS): print('Calculating accuracies...') train_accuracy = alexnet.evaluate(sess, X_train, Y_train, BATCH_SIZE) test_accuracy = alexnet.evaluate(sess, X_test, Y_test, BATCH_SIZE) print('Train Accuracy = {:.3f}'.format(train_accuracy)) print('Test Accuracy = {:.3f}'.format(test_accuracy)) print() print('Training epoch', i + 1, '...') alexnet.train_epoch(sess, X_train, Y_train, BATCH_SIZE, file_writer, summary_operation, i) print() final_train_accuracy = alexnet.evaluate(sess, X_train, Y_train, BATCH_SIZE) final_test_accuracy = alexnet.evaluate(sess, X_test, Y_test, BATCH_SIZE) print('Final Train Accuracy = {:.3f}'.format(final_train_accuracy)) print('Final Test Accuracy = {:.3f}'.format(final_test_accuracy)) print() alexnet.save(sess, './model/alexnet') print('Model saved.') print() print('Training done successfully.')
def run_imagenet_test(): """ Runs the a test that trains a CNN to classify ImageNet data. Returns: A tuple containing the total elapsed time, and the average number of training iterations per second. """ batch_size = 128 # How many batches to have loaded into VRAM at once. load_batches = 5 # Learning rate hyperparameters. learning_rate = 0.00001 decay_steps = 10000 decay_rate = 1 momentum = 0.9 weight_decay = 0.0005 rho = 0.9 epsilon = 1e-6 # Where we save the network. save_file = "/home/theano/training_data/alexnet.pkl" synsets_save_file = "/home/theano/training_data/synsets.pkl" # Where we load the synsets to use from. synset_list = "/job_files/ilsvrc16_synsets.txt" # Where to load and save datasets. dataset_path = "/home/theano/training_data/ilsvrc16_dataset" # Where to cache image data. cache_path = "/home/theano/training_data/cache" # Where to save downloaded synset info. synset_dir = "/home/theano/training_data/synsets" data = data_loader.ImagenetLoader(batch_size, load_batches, cache_path, dataset_path, synset_dir, synset_list) if os.path.exists(synsets_save_file): data.load(synsets_save_file) train = data.get_train_set() test = data.get_test_set() cpu_labels = data.get_non_shared_test_set() if os.path.exists(save_file): # Load from the file. print "Theano: Loading network from file..." network = AlexNet.load(save_file, train, test, batch_size, learning_rate=learning_rate) else: # Build new network. network = AlexNet(train, test, batch_size, patch_separation=batch_size * load_batches) network.use_sgd_trainer(learning_rate, momentum=momentum, weight_decay=weight_decay, decay_rate=decay_rate, decay_steps=decay_steps) #network.use_rmsprop_trainer(learning_rate, rho, epsilon, # decay_rate=decay_rate, # decay_steps=decay_steps) print "Theano: Starting ImageNet test..." accuracy = 0 start_time = time.time() iterations = 0 train_batch_index = 0 test_batch_index = 0 while iterations < 150000: logger.debug("Train index, size: %d, %d" % (train_batch_index, data.get_train_batch_size())) logger.debug("Test index, size: %d, %d" % (test_batch_index, data.get_test_batch_size())) # Swap in new data if we need to. if (train_batch_index + 1) * batch_size > data.get_train_batch_size(): train_batch_index = 0 logger.info("Getting train set.") train = data.get_train_set() logger.info("Got train set.") # Swap in new data if we need to. test_set_one_patch = data.get_test_batch_size() / 10 if (test_batch_index + 1) * batch_size > test_set_one_patch: test_batch_index = 0 logger.info("Getting test set.") test = data.get_test_set() cpu_labels = data.get_non_shared_test_set()[:] logger.info("Got test set.") if iterations % 100 == 0: # cpu_labels contains labels for every batch currently loaded in VRAM, # without duplicates for additional patches. label_index = test_batch_index * batch_size top_one, top_five = network.test(test_batch_index, cpu_labels[label_index:label_index + \ batch_size]) logger.info("Step %d, testing top 1: %f, testing top 5: %f" % \ (iterations, top_one, top_five)) test_batch_index += 1 cost, rate, step = network.train(train_batch_index) logger.info("Training cost: %f, learning rate: %f, step: %d" % \ (cost, rate, step)) if iterations % 100 == 0: print "Saving network..." network.save(save_file) # Save synset data as well. data.save(synsets_save_file) iterations += 1 train_batch_index += 1 elapsed = time.time() - start_time speed = iterations / elapsed print("Theano: Ran %d training iterations. (%f iter/s)" % \ (iterations, speed)) print("Theano: Imagenet test completed in %f seconds." % (elapsed)) data.exit_gracefully() return (elapsed, speed)