def main(flags): # set gpu os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' os.environ['CUDA_VISIBLE_DEVICES'] = flags.GPU # environment settings np.random.seed(flags.random_seed) tf.set_random_seed(flags.random_seed) # data prepare step Data = rsrClassData(flags.rsr_data_dir) (collect_files_test, meta_test) = Data.getCollectionByName(flags.test_data_dir) # image reader coord = tf.train.Coordinator() # define place holder X = tf.placeholder(tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X') y = tf.placeholder(tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y') mode = tf.placeholder(tf.bool, name='mode') # initialize model model = unet.UnetModel({'X':X, 'Y':y}, trainable=mode, model_name=flags.model_name, input_size=flags.input_size) model.create_graph('X', flags.num_classes) model.make_update_ops('X', 'Y') # set ckdir model.make_ckdir(flags.ckdir) # set up graph and initialize config = tf.ConfigProto() # run training start_time = time.time() with tf.Session(config=config) as sess: init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1) if os.path.exists(model.ckdir) and tf.train.get_checkpoint_state(model.ckdir): latest_check_point = tf.train.latest_checkpoint(model.ckdir) saver.restore(sess, latest_check_point) threads = tf.train.start_queue_runners(coord=coord, sess=sess) try: for (image_name, label_name) in collect_files_test: if flags.city_name in image_name: city_name = re.findall('[a-z\-]*(?=[0-9]+\.)', image_name)[0] tile_id = re.findall('[0-9]+(?=\.tif)', image_name)[0] # load reader iterator_test = image_reader.image_label_iterator( os.path.join(flags.rsr_data_dir, image_name), batch_size=flags.batch_size, tile_dim=meta_test['dim_image'][:2], patch_size=flags.input_size, overlap=0) # run result = model.test('X', sess, iterator_test) pred_label_img = sis_utils.get_output_label(result, meta_test['dim_image'], flags.input_size, meta_test['colormap']) # evaluate truth_label_img = scipy.misc.imread(os.path.join(flags.rsr_data_dir, label_name)) iou = sis_utils.iou_metric(truth_label_img, pred_label_img) print('{}_{}: iou={:.2f}'.format(city_name, tile_id, iou*100)) finally: coord.request_stop() coord.join(threads) duration = time.time() - start_time print('duration {:.2f} minutes'.format(duration/60))
def test_unet(rsr_data_dir, test_data_dir, input_size, model_name, num_classes, ckdir, city, batch_size, ds_name='inria', GPU='0', random_seed=1234): import re import scipy.misc import tensorflow as tf from network import unet from dataReader import image_reader from rsrClassData import rsrClassData def name_has_city(city_list, name): for city in city_list: if city in name: return True return False city = city.split(',') # set gpu os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' os.environ['CUDA_VISIBLE_DEVICES'] = GPU tf.reset_default_graph() # environment settings np.random.seed(random_seed) tf.set_random_seed(random_seed) # data prepare step Data = rsrClassData(rsr_data_dir) (collect_files_test, meta_test) = Data.getCollectionByName(test_data_dir) # image reader coord = tf.train.Coordinator() # define place holder X = tf.placeholder(tf.float32, shape=[None, input_size[0], input_size[1], 3], name='X') y = tf.placeholder(tf.int32, shape=[None, input_size[0], input_size[1], 1], name='y') mode = tf.placeholder(tf.bool, name='mode') # initialize model model = unet.UnetModel({ 'X': X, 'Y': y }, trainable=mode, model_name=model_name, input_size=input_size) model.create_graph('X', num_classes) model.make_update_ops('X', 'Y') # set ckdir model.make_ckdir(ckdir) # set up graph and initialize config = tf.ConfigProto() result_dict = {} # run training with tf.Session(config=config) as sess: init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1) if os.path.exists(model.ckdir) and tf.train.get_checkpoint_state( model.ckdir): latest_check_point = tf.train.latest_checkpoint(model.ckdir) saver.restore(sess, latest_check_point) print('loaded model from {}'.format(latest_check_point)) threads = tf.train.start_queue_runners(coord=coord, sess=sess) for (image_name, label_name) in collect_files_test: #if city in image_name: if name_has_city(city, image_name): if ds_name == 'inria': city_name = re.findall('[a-z\-]*(?=[0-9]+\.)', image_name)[0] tile_id = re.findall('[0-9]+(?=\.tif)', image_name)[0] else: city_name = os.path.basename(image_name)[:3] tile_id = os.path.basename(image_name)[9:12] # load reader iterator_test = image_reader.image_label_iterator( os.path.join(rsr_data_dir, image_name), batch_size=batch_size, tile_dim=meta_test['dim_image'][:2], patch_size=input_size, overlap=0) # run result = model.test('X', sess, iterator_test) pred_label_img = get_output_label(result, meta_test['dim_image'], input_size, meta_test['colormap']) # evaluate truth_label_img = scipy.misc.imread( os.path.join(rsr_data_dir, label_name)) iou = iou_metric(truth_label_img, pred_label_img) result_dict['{}{}'.format(city_name, tile_id)] = iou coord.request_stop() coord.join(threads) return result_dict
def main(flags): # set gpu os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' os.environ['CUDA_VISIBLE_DEVICES'] = flags.GPU # environment settings np.random.seed(flags.random_seed) tf.set_random_seed(flags.random_seed) # data prepare step Data = rsrClassData(flags.rsr_data_dir) (collect_files_train, meta_train) = Data.getCollectionByName(flags.train_data_dir) pe_train = patch_extractor.PatchExtractorInria( flags.rsr_data_dir, collect_files_train, patch_size=flags.input_size, tile_dim=meta_train['dim_image'][:2], appendix=flags.train_patch_appendix) train_data_dir = pe_train.extract(flags.patch_dir) (collect_files_valid, meta_valid) = Data.getCollectionByName(flags.valid_data_dir) pe_valid = patch_extractor.PatchExtractorInria( flags.rsr_data_dir, collect_files_valid, patch_size=flags.input_size, tile_dim=meta_train['dim_image'][:2], appendix=flags.valid_patch_appendix) valid_data_dir = pe_valid.extract(flags.patch_dir) # image reader coord = tf.train.Coordinator() # load reader with tf.name_scope('image_loader'): reader_train = image_reader.ImageLabelReader( train_data_dir, flags.input_size, coord, city_list=flags.city_name, tile_list=flags.train_tile_names) reader_valid = image_reader.ImageLabelReader( valid_data_dir, flags.input_size, coord, city_list=flags.city_name, tile_list=flags.valid_tile_names) X_batch_op, y_batch_op = reader_train.dequeue(flags.batch_size) X_batch_op_valid, y_batch_op_valid = reader_valid.dequeue( flags.batch_size * 2) reader_train_op = [X_batch_op, y_batch_op] reader_valid_op = [X_batch_op_valid, y_batch_op_valid] # define place holder X = tf.placeholder( tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X') y = tf.placeholder( tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y') mode = tf.placeholder(tf.bool, name='mode') # initialize model model = unet.UnetModel({ 'X': X, 'Y': y }, trainable=mode, model_name=flags.model_name, input_size=flags.input_size) model.create_graph('X', flags.num_classes) model.make_loss('Y') model.make_learning_rate( flags.learning_rate, tf.cast(flags.n_train / flags.batch_size * flags.decay_step, tf.int32), flags.decay_rate) model.make_update_ops('X', 'Y') model.make_optimizer(model.learning_rate) # set ckdir model.make_ckdir(flags.ckdir) # make summary model.make_summary() # set up graph and initialize config = tf.ConfigProto() # run training start_time = time.time() with tf.Session(config=config) as sess: init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1) if os.path.exists(model.ckdir) and tf.train.get_checkpoint_state( model.ckdir): latest_check_point = tf.train.latest_checkpoint(model.ckdir) saver.restore(sess, latest_check_point) threads = tf.train.start_queue_runners(coord=coord, sess=sess) try: train_summary_writer = tf.summary.FileWriter( model.ckdir, sess.graph) model.train('X', 'Y', flags.epochs, flags.n_train, flags.batch_size, sess, train_summary_writer, train_reader=reader_train_op, valid_reader=reader_valid_op, image_summary=sis_utils.image_summary) finally: coord.request_stop() coord.join(threads) saver.save(sess, '{}/model.ckpt'.format(model.ckdir), global_step=model.global_step) duration = time.time() - start_time print('duration {:.2f} hours'.format(duration / 60 / 60))
def main(flags): # set gpu os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' os.environ['CUDA_VISIBLE_DEVICES'] = flags.GPU # environment settings np.random.seed(flags.random_seed) tf.set_random_seed(flags.random_seed) # data prepare step Data = rsrClassData(flags.rsr_data_dir) (collect_files_test, meta_test) = Data.getCollectionByName(flags.test_data_dir) # image reader coord = tf.train.Coordinator() # define place holder X = tf.placeholder( tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X') y = tf.placeholder( tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y') mode = tf.placeholder(tf.bool, name='mode') # initialize model model = unet.UnetModel({ 'X': X, 'Y': y }, trainable=mode, model_name=flags.model_name, input_size=flags.input_size) model.create_graph('X', flags.num_classes) model.make_update_ops('X', 'Y') # set ckdir model.make_ckdir(flags.ckdir) # set up graph and initialize config = tf.ConfigProto() # run training start_time = time.time() with tf.Session(config=config) as sess: init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1) if os.path.exists(model.ckdir) and tf.train.get_checkpoint_state( model.ckdir): print('loading model from {}'.format(model.ckdir)) latest_check_point = tf.train.latest_checkpoint(model.ckdir) saver.restore(sess, latest_check_point) threads = tf.train.start_queue_runners(coord=coord, sess=sess) tile_cnt = 0 error_map = np.zeros(flags.input_size) fig = plt.figure(figsize=(20.0, 12.0)) try: for (image_name, label_name) in collect_files_test: if flags.city_name in image_name: tile_cnt += 1 city_name = re.findall('[a-z\-]*(?=[0-9]+\.)', image_name)[0] tile_id = re.findall('[0-9]+(?=\.tif)', image_name)[0] print('Evaluating {}_{}.tif'.format(city_name, tile_id)) # load reader iterator_test = image_reader.image_label_iterator( os.path.join(flags.rsr_data_dir, image_name), batch_size=flags.batch_size, tile_dim=meta_test['dim_image'][:2], patch_size=flags.input_size, overlap=0) # run result = model.test('X', sess, iterator_test) # evaluate label_img = scipy.misc.imread( os.path.join(flags.rsr_data_dir, label_name)) error_map += evaluate_on_patch(result, label_img, meta_test['dim_image'][:2], flags.input_size) plt.subplot(230 + tile_cnt) plt.imshow(error_map / np.max(error_map), cmap='hot') plt.colorbar() plt.title('Error Map {}_{}'.format(city_name, tile_id)) plt.suptitle('Patch Size = {}'.format(flags.input_size)) dist, error = error_vs_dist(error_map) plt.subplot(236) plt.plot(dist, error, 'r.') plt.title('Error VS Dist ({})'.format(city_name)) plt.xlabel('Dist to center of patch') plt.ylabel('#Errors') save_dir = sis_utils.make_task_img_folder(IMG_SAVE_DIR) plt.savefig(os.path.join( save_dir, 'M-{}_PS-{}'.format(flags.model_name, flags.input_size[0])), bbox_inches='tight') plt.show() finally: coord.request_stop() coord.join(threads) duration = time.time() - start_time print('duration {:.2f} minutes'.format(duration / 60))
def main(flags): # set gpu os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' os.environ['CUDA_VISIBLE_DEVICES'] = flags.GPU # environment settings np.random.seed(flags.random_seed) tf.set_random_seed(flags.random_seed) for city in ['bellingham', 'bloomington', 'innsbruck', 'sfo', 'tyrol-e']: if not os.path.exists('./temp'): os.makedirs('./temp') flags.city_name = city for m_name in MODEL_NAME: tf.reset_default_graph() # data prepare step Data = rsrClassData(flags.rsr_data_dir) (collect_files_test, meta_test) = Data.getCollectionByName(flags.test_data_dir) # image reader coord = tf.train.Coordinator() # define place holder X = tf.placeholder( tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X') y = tf.placeholder( tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y') mode = tf.placeholder(tf.bool, name='mode') # initialize model model = unet.UnetModel({ 'X': X, 'Y': y }, trainable=mode, model_name=m_name, input_size=flags.input_size) model.create_graph('X', flags.num_classes) model.make_update_ops('X', 'Y') # set ckdir model.make_ckdir(flags.ckdir) # set up graph and initialize config = tf.ConfigProto() # run training start_time = time.time() with tf.Session(config=config) as sess: init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1) if os.path.exists( model.ckdir) and tf.train.get_checkpoint_state( model.ckdir): print('loading model from {}'.format(model.ckdir)) latest_check_point = tf.train.latest_checkpoint( model.ckdir) saver.restore(sess, latest_check_point) threads = tf.train.start_queue_runners(coord=coord, sess=sess) for (image_name, ) in collect_files_test: if flags.city_name in image_name: city_name = re.findall('[a-z\-]*(?=[0-9]+\.)', image_name)[0] tile_id = re.findall('[0-9]+(?=\.tif)', image_name)[0] print('Evaluating {}_{} at patch size: {}'.format( city_name, tile_id, flags.input_size)) # load reader iterator_test = image_reader.image_label_iterator( os.path.join(flags.rsr_data_dir, image_name), batch_size=flags.batch_size, tile_dim=meta_test['dim_image'][:2], patch_size=flags.input_size, overlap=0) # run result = model.test('X', sess, iterator_test) raw_pred = patch_extractor.un_patchify( result, meta_test['dim_image'], flags.input_size) file_name = '{}_{}_{}.npy'.format( m_name, city_name, tile_id) np.save(os.path.join('./temp', file_name), raw_pred) coord.request_stop() coord.join(threads) duration = time.time() - start_time print('duration {:.2f} minutes'.format(duration / 60)) for tile_num in range(36): output = np.zeros((5000, 5000, 2)) for m_name in MODEL_NAME: raw_pred = np.load( os.path.join( './temp', '{}_{}_{}.npy'.format(m_name, flags.city_name, tile_num + 1))) output += raw_pred # combine results labels_pred = sis_utils.get_pred_labels(output) output_pred = sis_utils.make_output_file(labels_pred, meta_test['colormap']) scipy.misc.imsave( os.path.join(FIG_SAVE_DIR, '{}{}.tif'.format(flags.city_name, tile_num + 1)), output_pred) shutil.rmtree('./temp')