def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) # Get dataset-dependent information. dataset = segmentation_dataset.get_dataset( FLAGS.dataset, FLAGS.vis_split, dataset_dir=FLAGS.dataset_dir) train_id_to_eval_id = None if dataset.name == segmentation_dataset.get_cityscapes_dataset_name(): tf.logging.info('Cityscapes requires converting train_id to eval_id.') train_id_to_eval_id = _CITYSCAPES_TRAIN_ID_TO_EVAL_ID # Prepare for visualization. tf.gfile.MakeDirs(FLAGS.vis_logdir) save_dir = os.path.join(FLAGS.vis_logdir, _SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(save_dir) raw_save_dir = os.path.join( FLAGS.vis_logdir, _RAW_SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(raw_save_dir) tf.logging.info('Visualizing on %s set', FLAGS.vis_split) g = tf.Graph() with g.as_default(): samples = input_generator.get(dataset, FLAGS.vis_crop_size, FLAGS.vis_batch_size, min_resize_value=FLAGS.min_resize_value, max_resize_value=FLAGS.max_resize_value, resize_factor=FLAGS.resize_factor, dataset_split=FLAGS.vis_split, is_training=False, model_variant=FLAGS.model_variant) model_options = common.ModelOptions( outputs_to_num_classes={common.OUTPUT_TYPE: dataset.num_classes}, crop_size=FLAGS.vis_crop_size, atrous_rates=FLAGS.atrous_rates, output_stride=FLAGS.output_stride) if tuple(FLAGS.eval_scales) == (1.0,): tf.logging.info('Performing single-scale test.') predictions = model.predict_labels( samples[common.IMAGE], model_options=model_options, image_pyramid=FLAGS.image_pyramid) else: tf.logging.info('Performing multi-scale test.') predictions = model.predict_labels_multi_scale( samples[common.IMAGE], model_options=model_options, eval_scales=FLAGS.eval_scales, add_flipped_images=FLAGS.add_flipped_images) predictions = predictions[common.OUTPUT_TYPE] if FLAGS.min_resize_value and FLAGS.max_resize_value: # Only support batch_size = 1, since we assume the dimensions of original # image after tf.squeeze is [height, width, 3]. assert FLAGS.vis_batch_size == 1 # Reverse the resizing and padding operations performed in preprocessing. # First, we slice the valid regions (i.e., remove padded region) and then # we reisze the predictions back. original_image = tf.squeeze(samples[common.ORIGINAL_IMAGE]) original_image_shape = tf.shape(original_image) predictions = tf.slice( predictions, [0, 0, 0], [1, original_image_shape[0], original_image_shape[1]]) resized_shape = tf.to_int32([tf.squeeze(samples[common.HEIGHT]), tf.squeeze(samples[common.WIDTH])]) predictions = tf.squeeze( tf.image.resize_images(tf.expand_dims(predictions, 3), resized_shape, method=tf.image.ResizeMethod.NEAREST_NEIGHBOR, align_corners=True), 3) tf.train.get_or_create_global_step() saver = tf.train.Saver(slim.get_variables_to_restore()) sv = tf.train.Supervisor(graph=g, logdir=FLAGS.vis_logdir, init_op=tf.global_variables_initializer(), summary_op=None, summary_writer=None, global_step=None, saver=saver) num_batches = int(math.ceil( dataset.num_samples / float(FLAGS.vis_batch_size))) last_checkpoint = None # Loop to visualize the results when new checkpoint is created. num_iters = 0 while (FLAGS.max_number_of_iterations <= 0 or num_iters < FLAGS.max_number_of_iterations): num_iters += 1 last_checkpoint = slim.evaluation.wait_for_new_checkpoint( FLAGS.checkpoint_dir, last_checkpoint) start = time.time() tf.logging.info( 'Starting visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) tf.logging.info('Visualizing with model %s', last_checkpoint) with sv.managed_session(FLAGS.master, start_standard_services=False) as sess: sv.start_queue_runners(sess) sv.saver.restore(sess, last_checkpoint) image_id_offset = 0 for batch in range(num_batches): tf.logging.info('Visualizing batch %d / %d', batch + 1, num_batches) _process_batch(sess=sess, original_images=samples[common.ORIGINAL_IMAGE], semantic_predictions=predictions, image_names=samples[common.IMAGE_NAME], image_heights=samples[common.HEIGHT], image_widths=samples[common.WIDTH], image_id_offset=image_id_offset, save_dir=save_dir, raw_save_dir=raw_save_dir, train_id_to_eval_id=train_id_to_eval_id) image_id_offset += FLAGS.vis_batch_size tf.logging.info( 'Finished visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) time_to_next_eval = start + FLAGS.eval_interval_secs - time.time() if time_to_next_eval > 0: time.sleep(time_to_next_eval)
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) # Get dataset-dependent information. dataset = segmentation_dataset.get_dataset(FLAGS.dataset, FLAGS.vis_split, dataset_dir=FLAGS.dataset_dir) train_id_to_eval_id = None if dataset.name == segmentation_dataset.get_cityscapes_dataset_name(): tf.logging.info('Cityscapes requires converting train_id to eval_id.') train_id_to_eval_id = _CITYSCAPES_TRAIN_ID_TO_EVAL_ID # Prepare for visualization. tf.gfile.MakeDirs(FLAGS.vis_logdir) save_dir = os.path.join(FLAGS.vis_logdir, _SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(save_dir) raw_save_dir = os.path.join(FLAGS.vis_logdir, _RAW_SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(raw_save_dir) tf.logging.info('Visualizing on %s set', FLAGS.vis_split) g = tf.Graph() with g.as_default(): samples = input_generator.get(dataset, FLAGS.vis_crop_size, FLAGS.vis_batch_size, min_resize_value=FLAGS.min_resize_value, max_resize_value=FLAGS.max_resize_value, resize_factor=FLAGS.resize_factor, dataset_split=FLAGS.vis_split, is_training=False, model_variant=FLAGS.model_variant) model_options = common.ModelOptions( outputs_to_num_classes={common.OUTPUT_TYPE: dataset.num_classes}, crop_size=FLAGS.vis_crop_size, atrous_rates=FLAGS.atrous_rates, output_stride=FLAGS.output_stride) if tuple(FLAGS.eval_scales) == (1.0, ): tf.logging.info('Performing single-scale test.') predictions = model.predict_labels( samples[common.IMAGE], model_options=model_options, image_pyramid=FLAGS.image_pyramid) else: tf.logging.info('Performing multi-scale test.') predictions = model.predict_labels_multi_scale( samples[common.IMAGE], model_options=model_options, eval_scales=FLAGS.eval_scales, add_flipped_images=FLAGS.add_flipped_images) predictions = predictions[common.OUTPUT_TYPE] if FLAGS.min_resize_value and FLAGS.max_resize_value: # Only support batch_size = 1, since we assume the dimensions of original # image after tf.squeeze is [height, width, 3]. assert FLAGS.vis_batch_size == 1 # Reverse the resizing and padding operations performed in preprocessing. # First, we slice the valid regions (i.e., remove padded region) and then # we reisze the predictions back. original_image = tf.squeeze(samples[common.ORIGINAL_IMAGE]) original_image_shape = tf.shape(original_image) predictions = tf.slice( predictions, [0, 0, 0], [1, original_image_shape[0], original_image_shape[1]]) resized_shape = tf.to_int32([ tf.squeeze(samples[common.HEIGHT]), tf.squeeze(samples[common.WIDTH]) ]) predictions = tf.squeeze( tf.image.resize_images( tf.expand_dims(predictions, 3), resized_shape, method=tf.image.ResizeMethod.NEAREST_NEIGHBOR, align_corners=True), 3) if FLAGS.is_quant: tf.contrib.quantize.experimental_create_eval_graph( weight_bits=FLAGS.weight_bits, activation_bits=FLAGS.activation_bits) tf.train.get_or_create_global_step() saver = tf.train.Saver(slim.get_variables_to_restore()) sv = tf.train.Supervisor(graph=g, logdir=FLAGS.vis_logdir, init_op=tf.global_variables_initializer(), summary_op=None, summary_writer=None, global_step=None, saver=saver) num_batches = int( math.ceil(dataset.num_samples / float(FLAGS.vis_batch_size))) last_checkpoint = None # Loop to visualize the results when new checkpoint is created. num_iters = 0 while (FLAGS.max_number_of_iterations <= 0 or num_iters < FLAGS.max_number_of_iterations): num_iters += 1 last_checkpoint = slim.evaluation.wait_for_new_checkpoint( FLAGS.checkpoint_dir, last_checkpoint) start = time.time() tf.logging.info('Starting visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) tf.logging.info('Visualizing with model %s', last_checkpoint) with sv.managed_session(FLAGS.master, start_standard_services=False) as sess: sv.start_queue_runners(sess) sv.saver.restore(sess, last_checkpoint) image_id_offset = 0 for batch in range(num_batches): tf.logging.info('Visualizing batch %d / %d', batch + 1, num_batches) _process_batch( sess=sess, original_images=samples[common.ORIGINAL_IMAGE], semantic_predictions=predictions, image_names=samples[common.IMAGE_NAME], image_heights=samples[common.HEIGHT], image_widths=samples[common.WIDTH], image_id_offset=image_id_offset, save_dir=save_dir, raw_save_dir=raw_save_dir, train_id_to_eval_id=train_id_to_eval_id) image_id_offset += FLAGS.vis_batch_size tf.logging.info('Finished visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) time_to_next_eval = start + FLAGS.eval_interval_secs - time.time() if time_to_next_eval > 0: time.sleep(time_to_next_eval)
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) # Get dataset-dependent information. dataset = segmentation_dataset.get_dataset( FLAGS.dataset, FLAGS.vis_split, dataset_dir=FLAGS.dataset_dir, use_input_hints=FLAGS.input_hints, hint_types=FLAGS.hint_types) train_id_to_eval_id = None if dataset.name == segmentation_dataset.get_cityscapes_dataset_name( ) and FLAGS.convert_to_eval_id: tf.logging.info('Cityscapes requires converting train_id to eval_id.') train_id_to_eval_id = _CITYSCAPES_TRAIN_ID_TO_EVAL_ID # Prepare for visualization. tf.gfile.MakeDirs(FLAGS.vis_logdir) save_dir = os.path.join(FLAGS.vis_logdir, _SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(save_dir) raw_save_dir = os.path.join(FLAGS.vis_logdir, _RAW_SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(raw_save_dir) logit_save_dir = os.path.join(FLAGS.vis_logdir, 'logits') tf.gfile.MakeDirs(logit_save_dir) uncertainty_save_dir = os.path.join(FLAGS.vis_logdir, 'uncertainties') tf.gfile.MakeDirs(uncertainty_save_dir) tf.logging.info('Visualizing on %s set', FLAGS.vis_split) g = tf.Graph() with g.as_default(): # Running samples_orig will grab a new batch samples_orig = input_generator.get( dataset, FLAGS.vis_crop_size, FLAGS.vis_batch_size, min_resize_value=FLAGS.min_resize_value, max_resize_value=FLAGS.max_resize_value, resize_factor=FLAGS.resize_factor, dataset_split=FLAGS.vis_split, is_training=False, model_variant=FLAGS.model_variant) # samples_placeholders will represent a batch of data for the network. The values will be filled # by samples_orig. Decoupled so that same batch can be run through network multiple times. # See _process_batch. samples_placeholders = {} for k, v in samples_orig.items(): samples_placeholders[k] = tf.placeholder( dtype=v.dtype, shape=v.shape, name='samples_{}'.format(k)) # Since original code was written with 'samples' variable, leave original code alone and initialize samples dictionary here # The reason we don't use samples = samples_placeholders is because samples is overwritten several times # and we need to keep samples_placeholders in its original state in order to fill it with values from samples_orig. samples = {k: v for k, v in samples_placeholders.items()} model_options = common.ModelOptions( outputs_to_num_classes={common.OUTPUT_TYPE: dataset.num_classes}, crop_size=FLAGS.vis_crop_size, atrous_rates=FLAGS.atrous_rates, output_stride=FLAGS.output_stride) if FLAGS.input_hints: # or if common.HINT in samples.keys(): if 'dynamic_class_partial_boundary_hint' in FLAGS.hint_types: assert len( FLAGS.hint_types ) == 1, 'When using dynamic partial boundary class hints, do not use other hint types!' print("----") print( "eval.py: Partial boundary hints with grid {}x{}.".format( FLAGS.dynamic_class_partial_boundary_hint_B, FLAGS.dynamic_class_partial_boundary_hint_B)) print("eval.py: Drawing blocks with p {}.".format( FLAGS.dynamic_class_partial_boundary_hint_p)) if FLAGS.dynamic_class_partial_boundary_full_block: print( "eval.py: Keeping entire block instead of masking boundaries." .format(FLAGS.boundary_threshold)) else: print( "eval.py: Masking with boundary threshold {}.".format( FLAGS.boundary_threshold)) print("----") if FLAGS.dynamic_class_partial_boundary_full_block: boundary_mask = tf.cast( tf.ones_like(samples[common.LABEL]), tf.uint8) else: boundary_mask = tf.cast( tf.less(samples[common.BOUNDARY_DMAP], FLAGS.boundary_threshold), tf.uint8) class_hints, hinted = tf.py_func( func=train_utils.generate_class_partial_boundaries_helper( B=FLAGS.dynamic_class_partial_boundary_hint_B, p=FLAGS.dynamic_class_partial_boundary_hint_p), inp=[samples[common.LABEL], boundary_mask], Tout=[tf.uint8, tf.bool]) samples[common.HINT] = class_hints samples[common.HINT].set_shape( samples[common.LABEL].get_shape().as_list()) # Now preprocess this. Set the flag so that the rest of the work will be done as usual. FLAGS.hint_types = ['class_hint'] ### if 'dynamic_class_hint' in FLAGS.hint_types: assert len( FLAGS.hint_types ) == 1, 'When using dynamic class hints, do not use other hint types!' print("----") print( "WARNING: Do not use dynamic class hints when simulating crowdsourced points as the points should not change between runs." ) print("vis.py: Drawing hints with geo mean {}.".format( FLAGS.dynamic_class_hint_geo_mean)) print("vis.py: Masking with boundary threshold {}.".format( FLAGS.boundary_threshold)) print("----") boundary_mask = tf.cast( tf.less(samples[common.BOUNDARY_DMAP], FLAGS.boundary_threshold), tf.uint8) class_hints, hinted = tf.py_func( func=train_utils.generate_class_clicks_helper( geo_mean=FLAGS.dynamic_class_hint_geo_mean), inp=[samples[common.LABEL], boundary_mask], Tout=[tf.uint8, tf.bool]) samples[common.HINT] = class_hints samples[common.HINT].set_shape( samples[common.LABEL].get_shape().as_list()) # Now preprocess this. Set the flag so that the rest of the work will be done as usual. FLAGS.hint_types = ['class_hint'] # If using class hints, preprocess into num_class binary mask channels if 'class_hint' in FLAGS.hint_types: assert len( FLAGS.hint_types ) == 1, 'When using class hints, do not use other hint types!' num_classes = dataset.num_classes print('vis.py: num classes is {}'.format(num_classes)) class_hint_channels_list = [] for label in range(num_classes): # Multiply by 255 is to bring into same range as image pixels..., # and so feature_extractor mean subtraction will reduce it back to 0,1 range class_hint_channel = tf.to_float( tf.equal(samples[common.HINT], label)) * 255 class_hint_channels_list.append(class_hint_channel) class_hint_channels = tf.concat(class_hint_channels_list, axis=-1) samples[common.HINT] = class_hint_channels # Get hints and concat to image as input into network samples[common.HINT] = tf.identity(samples[common.HINT], name=common.HINT) model_inputs = tf.concat( [samples[common.IMAGE], tf.to_float(samples[common.HINT])], axis=-1) else: # Just image is input into network model_inputs = samples[common.IMAGE] outputs_to_scales_to_logits = None logits = None predictions = None fixed_features = None extra_to_run = {} if tuple(FLAGS.eval_scales) == (1.0, ): tf.logging.info('Performing single-scale test.') if FLAGS.compute_uncertainty and FLAGS.force_dropout_only_branch: fixed_features = model._get_features_after_decoder( images=model_inputs, model_options=model_options, reuse=None, is_training=False, fine_tune_batch_norm=False, force_dropout=True, force_dropout_only_branch=FLAGS.force_dropout_only_branch, keep_prob=FLAGS.keep_prob) samples_placeholders['fixed_features'] = tf.placeholder( dtype=fixed_features.dtype, shape=fixed_features.shape) logits_from_fixed_features = model._get_branch_logits( samples_placeholders['fixed_features'], model_options.outputs_to_num_classes[common.OUTPUT_TYPE], model_options.atrous_rates, aspp_with_batch_norm=model_options.aspp_with_batch_norm, kernel_size=model_options.logits_kernel_size, reuse=None, scope_suffix=common.OUTPUT_TYPE, keep_prob=FLAGS.keep_prob, force_dropout=True) logits_from_fixed_features = tf.image.resize_bilinear( logits_from_fixed_features, size=tf.shape(samples[common.IMAGE])[1:3], align_corners=True) softmax_from_fixed_features = tf.nn.softmax( logits_from_fixed_features) samples_placeholders['accumulated_softmax'] = tf.placeholder( dtype=softmax_from_fixed_features.dtype, shape=FLAGS.vis_placeholder_size) #shape=[1, 1025, 2049, 19]) #shape=[1, 513, 513, 23]) samples_placeholders[ 'accumulated_softmax_sq'] = tf.placeholder( dtype=softmax_from_fixed_features.dtype, shape=FLAGS.vis_placeholder_size) #shape=[1, 1025, 2049, 19]) #shape=[1, 513, 513, 23]) accumulated_softmax = samples_placeholders[ 'accumulated_softmax'] + softmax_from_fixed_features accumulated_softmax_sq = samples_placeholders[ 'accumulated_softmax_sq'] + tf.square( softmax_from_fixed_features) extra_to_run['accumulated_softmax'] = accumulated_softmax extra_to_run['accumulated_softmax_sq'] = accumulated_softmax_sq elif FLAGS.save_logits or FLAGS.compute_uncertainty: predictions, outputs_to_scales_to_logits = model.predict_labels( # samples[common.IMAGE], model_inputs, model_options=model_options, image_pyramid=FLAGS.image_pyramid, also_return_logits=True, force_dropout=(FLAGS.compute_uncertainty or FLAGS.force_dropout), force_dropout_only_branch=FLAGS.force_dropout_only_branch, keep_prob=FLAGS.keep_prob) assert tuple(FLAGS.eval_scales) == (1.0, ) assert len(outputs_to_scales_to_logits) == 1 for output in sorted(outputs_to_scales_to_logits): scales_to_logits = outputs_to_scales_to_logits[output] logits = scales_to_logits[model._MERGED_LOGITS_SCOPE] if FLAGS.compute_uncertainty: assert not FLAGS.save_logits # We need full size logits to compute final predition and uncertainty. logits = tf.image.resize_bilinear( logits, size=tf.shape(model_inputs)[1:3], align_corners=True) softmax_logits = tf.nn.softmax(logits) samples_placeholders[ 'accumulated_softmax'] = tf.placeholder( dtype=softmax_logits.dtype, shape=FLAGS.vis_placeholder_size) #shape=[1, 1025, 2049, 19]) #shape=[1, 513, 513, 23]) samples_placeholders[ 'accumulated_softmax_sq'] = tf.placeholder( dtype=softmax_logits.dtype, shape=FLAGS.vis_placeholder_size) #shape=[1, 1025, 2049, 19]) #shape=[1, 513, 513, 23]) accumulated_softmax = samples_placeholders[ 'accumulated_softmax'] + softmax_logits accumulated_softmax_sq = samples_placeholders[ 'accumulated_softmax_sq'] + tf.square(softmax_logits) extra_to_run['accumulated_softmax'] = accumulated_softmax extra_to_run[ 'accumulated_softmax_sq'] = accumulated_softmax_sq else: predictions = model.predict_labels( # samples[common.IMAGE], model_inputs, model_options=model_options, image_pyramid=FLAGS.image_pyramid) else: tf.logging.info('Performing multi-scale test.') predictions = model.predict_labels_multi_scale( # samples[common.IMAGE], model_inputs, model_options=model_options, eval_scales=FLAGS.eval_scales, add_flipped_images=FLAGS.add_flipped_images) if FLAGS.save_logits: raise NotImplementedError("Multiscale logits aren't saved") if predictions is not None: predictions = predictions[common.OUTPUT_TYPE] if FLAGS.min_resize_value and FLAGS.max_resize_value: if FLAGS.input_hints: #raise Exception("***Unclear if this will work with hints. Look over the code.") print( "***Unclear if this will work with hints. Look over the code." ) # Only support batch_size = 1, since we assume the dimensions of original # image after tf.squeeze is [height, width, 3]. assert FLAGS.vis_batch_size == 1 # Reverse the resizing and padding operations performed in preprocessing. # First, we slice the valid regions (i.e., remove padded region) and then # we reisze the predictions back. original_image = tf.squeeze(samples[common.ORIGINAL_IMAGE]) original_image_shape = tf.shape(original_image) predictions = tf.slice( predictions, [0, 0, 0], [1, original_image_shape[0], original_image_shape[1]]) resized_shape = tf.to_int32([ tf.squeeze(samples[common.HEIGHT]), tf.squeeze(samples[common.WIDTH]) ]) predictions = tf.squeeze( tf.image.resize_images( tf.expand_dims(predictions, 3), resized_shape, method=tf.image.ResizeMethod.NEAREST_NEIGHBOR, align_corners=True), 3) tf.train.get_or_create_global_step() saver = tf.train.Saver(slim.get_variables_to_restore()) sv = tf.train.Supervisor(graph=g, logdir=FLAGS.vis_logdir, init_op=tf.global_variables_initializer(), summary_op=None, summary_writer=None, global_step=None, saver=saver) if FLAGS.vis_num_batches <= 0: num_batches = int( math.ceil(dataset.num_samples / float(FLAGS.vis_batch_size))) else: num_batches = FLAGS.vis_num_batches if FLAGS.shuffle: shuffled_idxs = range(dataset.num_samples) np.random.seed(FLAGS.shuffle_seed) np.random.shuffle(shuffled_idxs) else: shuffled_idxs = range(dataset.num_samples) idxs_to_keep = shuffled_idxs[FLAGS.start_idx:FLAGS.start_idx + FLAGS.vis_num_batches] if FLAGS.also_vis_first_N > 0: idxs_to_keep.extend(shuffled_idxs[0:FLAGS.also_vis_first_N]) print(sorted(idxs_to_keep)[:10]) print("There are {} indices to keep.".format(len(idxs_to_keep))) num_batches = int( math.ceil(dataset.num_samples / float(FLAGS.vis_batch_size))) last_checkpoint = None # Loop to visualize the results when new checkpoint is created. num_iters = 0 while (FLAGS.max_number_of_iterations <= 0 or num_iters < FLAGS.max_number_of_iterations): num_iters += 1 last_checkpoint = slim.evaluation.wait_for_new_checkpoint( FLAGS.checkpoint_dir, last_checkpoint) start = time.time() tf.logging.info('Starting visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) tf.logging.info('Visualizing with model %s', last_checkpoint) with sv.managed_session(FLAGS.master, start_standard_services=False) as sess: sv.start_queue_runners(sess) sv.saver.restore(sess, last_checkpoint) image_id_offset = 0 for batch in range(num_batches): if batch in idxs_to_keep: tf.logging.info('Visualizing batch %d / %d', batch + 1, num_batches) _process_batch( sess=sess, original_images=samples[common.ORIGINAL_IMAGE], semantic_predictions=predictions, image_names=samples[common.IMAGE_NAME], image_heights=samples[common.HEIGHT], image_widths=samples[common.WIDTH], image_id_offset=image_id_offset, save_dir=save_dir, raw_save_dir=raw_save_dir, save_logits=FLAGS.save_logits, logits=logits, fixed_features=fixed_features, extra_to_run=extra_to_run, logit_save_dir=logit_save_dir, uncertainty_save_dir=uncertainty_save_dir, train_id_to_eval_id=train_id_to_eval_id, samples_orig=samples_orig, samples_placeholders=samples_placeholders, compute_uncertainty=FLAGS.compute_uncertainty, num_forward_passes=FLAGS. compute_uncertainty_iterations) else: # Run batch generator to skip this batch sess.run([samples_orig]) image_id_offset += FLAGS.vis_batch_size tf.logging.info('Finished visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) time_to_next_eval = start + FLAGS.eval_interval_secs - time.time() if time_to_next_eval > 0 and num_iters < FLAGS.max_number_of_iterations: time.sleep(time_to_next_eval)
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) # Get dataset-dependent information. dataset = segmentation_dataset.get_dataset( FLAGS.dataset, FLAGS.vis_split, dataset_dir=FLAGS.dataset_dir) train_id_to_eval_id = None if dataset.name == segmentation_dataset.get_cityscapes_dataset_name(): tf.logging.info('Cityscapes requires converting train_id to eval_id.') train_id_to_eval_id = _CITYSCAPES_TRAIN_ID_TO_EVAL_ID global filename_list global perf_all filename_list = open(os.path.join(FLAGS.dataset_dir, '../ReOrg/filename-val.txt'), encoding='utf-8').readlines() filename_list = [x.strip() for x in filename_list] perf_all = np.empty((len(filename_list), 3)) # Prepare for visualization. tf.gfile.MakeDirs(FLAGS.vis_logdir) save_dir = os.path.join(FLAGS.vis_logdir, _SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(save_dir) raw_save_dir = os.path.join( FLAGS.vis_logdir, _RAW_SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(raw_save_dir) tf.logging.info('Visualizing on %s set', FLAGS.vis_split) g = tf.Graph() with g.as_default(): samples = input_generator.get(dataset, FLAGS.vis_crop_size, FLAGS.vis_batch_size, min_resize_value=FLAGS.min_resize_value, max_resize_value=FLAGS.max_resize_value, resize_factor=FLAGS.resize_factor, dataset_split=FLAGS.vis_split, is_training=False, model_variant=FLAGS.model_variant) model_options = common.ModelOptions( outputs_to_num_classes={common.OUTPUT_TYPE: dataset.num_classes}, crop_size=FLAGS.vis_crop_size, atrous_rates=FLAGS.atrous_rates, output_stride=FLAGS.output_stride) if tuple(FLAGS.eval_scales) == (1.0,): tf.logging.info('Performing single-scale test.') predictions = model.predict_labels( samples[common.IMAGE], model_options=model_options, image_pyramid=FLAGS.image_pyramid) else: tf.logging.info('Performing multi-scale test.') predictions = model.predict_labels_multi_scale( samples[common.IMAGE], model_options=model_options, eval_scales=FLAGS.eval_scales, add_flipped_images=FLAGS.add_flipped_images) predictions = predictions[common.OUTPUT_TYPE] pred_compute = tf.reshape(predictions, shape=[-1]) label_compute = tf.reshape(samples[common.LABEL], shape=[-1]) weights = tf.to_float(tf.not_equal(label_compute, dataset.ignore_label)) # Set ignore_label regions to label 0, because metrics.mean_iou requires # range of labels = [0, dataset.num_classes). Note the ignore_label regions # are not evaluated since the corresponding regions contain weights = 0. label_compute = tf.where( tf.equal(label_compute, dataset.ignore_label), tf.zeros_like(label_compute), label_compute) m_iou, m_accu = compute_m_iou_accu( pred_compute, label_compute, dataset.num_classes, weights=weights) # m_iou = compute_miou( # pred_compute, label_compute, dataset.num_classes, weights=weights) # m_accu = compute_maccu( # pred_compute, label_compute, dataset.num_classes, weights=weights) accu = compute_accu( pred_compute, label_compute, weights=weights) if FLAGS.min_resize_value and FLAGS.max_resize_value: # Only support batch_size = 1, since we assume the dimensions of original # image after tf.squeeze is [height, width, 3]. assert FLAGS.vis_batch_size == 1 # Reverse the resizing and padding operations performed in preprocessing. # First, we slice the valid regions (i.e., remove padded region) and then # we reisze the predictions back. original_image = tf.squeeze(samples[common.ORIGINAL_IMAGE]) original_image_shape = tf.shape(original_image) predictions = tf.slice( predictions, [0, 0, 0], [1, original_image_shape[0], original_image_shape[1]]) resized_shape = tf.to_int32([tf.squeeze(samples[common.HEIGHT]), tf.squeeze(samples[common.WIDTH])]) predictions = tf.squeeze( tf.image.resize_images(tf.expand_dims(predictions, 3), resized_shape, method=tf.image.ResizeMethod.NEAREST_NEIGHBOR, align_corners=True), 3) tf.train.get_or_create_global_step() saver = tf.train.Saver(slim.get_variables_to_restore()) sv = tf.train.Supervisor(graph=g, logdir=FLAGS.vis_logdir, init_op=tf.global_variables_initializer(), summary_op=None, summary_writer=None, global_step=None, saver=saver) num_batches = int(math.ceil( dataset.num_samples / float(FLAGS.vis_batch_size))) last_checkpoint = FLAGS.checkpoint_dir start = time.time() tf.logging.info( 'Starting visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) tf.logging.info('Visualizing with model %s', last_checkpoint) with sv.managed_session(FLAGS.master, start_standard_services=False) as sess: sv.start_queue_runners(sess) sv.saver.restore(sess, last_checkpoint) image_id_offset = 1 for batch in range(num_batches): tf.logging.info('Visualizing batch %d / %d', batch + 1, num_batches) _process_batch(sess=sess, original_images=samples[common.ORIGINAL_IMAGE], labels=samples[common.LABEL], semantic_predictions=predictions, image_names=samples[common.IMAGE_NAME], image_heights=samples[common.HEIGHT], image_widths=samples[common.WIDTH], perf_metrics=[m_iou, m_accu, accu], image_id_offset=image_id_offset, save_dir=save_dir, raw_save_dir=raw_save_dir, train_id_to_eval_id=train_id_to_eval_id) image_id_offset += FLAGS.vis_batch_size np.savetxt(os.path.join(FLAGS.vis_logdir, 'per-image-metrics.txt'), perf_all) tf.logging.info( 'Finished visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime()))
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) # Get dataset-dependent information. dataset = segmentation_dataset.get_dataset(FLAGS.dataset, FLAGS.vis_split, dataset_dir=FLAGS.dataset_dir) train_id_to_eval_id = None if dataset.name == segmentation_dataset.get_cityscapes_dataset_name(): tf.logging.info('Cityscapes requires converting train_id to eval_id.') train_id_to_eval_id = _CITYSCAPES_TRAIN_ID_TO_EVAL_ID # Prepare for visualization. tf.gfile.MakeDirs(FLAGS.vis_logdir) save_dir = os.path.join(FLAGS.vis_logdir, _SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(save_dir) raw_save_dir = os.path.join(FLAGS.vis_logdir, _RAW_SEMANTIC_PREDICTION_SAVE_FOLDER) tf.gfile.MakeDirs(raw_save_dir) tf.logging.info('Visualizing on %s set', FLAGS.vis_split) g = tf.Graph() with g.as_default(): image, label, image_name, height, width = input_generator.get_( dataset, FLAGS.vis_crop_size, FLAGS.vis_batch_size, min_resize_value=FLAGS.min_resize_value, max_resize_value=FLAGS.max_resize_value, resize_factor=FLAGS.resize_factor, dataset_split=FLAGS.vis_split, is_training=False, model_variant="mobilenet_v2") model_options = common.ModelOptions( outputs_to_num_classes={common.OUTPUT_TYPE: dataset.num_classes}, crop_size=FLAGS.vis_crop_size, atrous_rates=FLAGS.atrous_rates, output_stride=FLAGS.output_stride) mask = tf.squeeze(label) # original_images=tf.squeeze(samples[common.ORIGINAL_IMAGE]) # images=tf.squeeze(samples[common.IMAGE]) if FLAGS.min_resize_value and FLAGS.max_resize_value: # Only support batch_size = 1, since we assume the dimensions of original # image after tf.squeeze is [height, width, 3]. assert FLAGS.vis_batch_size == 1 tf.train.get_or_create_global_step() saver = tf.train.Saver(slim.get_variables_to_restore()) sv = tf.train.Supervisor(graph=g, logdir=FLAGS.vis_logdir, init_op=tf.global_variables_initializer(), summary_op=None, summary_writer=None, global_step=None, saver=saver) num_batches = int( math.ceil(dataset.num_samples / float(FLAGS.vis_batch_size))) # Loop to visualize the results when new checkpoint is created. num_iters = 0 while (FLAGS.max_number_of_iterations <= 0 or num_iters < FLAGS.max_number_of_iterations): num_iters += 1 start = time.time() tf.logging.info('Starting visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) with sv.managed_session(FLAGS.master, start_standard_services=False) as sess: sv.start_queue_runners(sess) image_id_offset = 0 for batch in range(num_batches): tf.logging.info('Visualizing batch %d / %d', batch + 1, num_batches) _process_batch(sess=sess, resize_images=image, image_names=image_name, mask=mask, image_heights=height, image_widths=width, image_id_offset=image_id_offset, save_dir=save_dir, raw_save_dir=raw_save_dir, train_id_to_eval_id=train_id_to_eval_id) image_id_offset += FLAGS.vis_batch_size tf.logging.info('Finished visualization at ' + time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime())) time_to_next_eval = start + FLAGS.eval_interval_secs - time.time() if time_to_next_eval > 0: time.sleep(time_to_next_eval)