def main(unused_argv):
tf.logging.set_verbosity(tf.logging.INFO)
# Get dataset-dependent information.
dataset = data_generator.Dataset(
dataset_name=FLAGS.dataset,
split_name=FLAGS.vis_split,
dataset_dir=FLAGS.dataset_dir,
batch_size=FLAGS.vis_batch_size,
crop_size=[int(sz) for sz in FLAGS.vis_crop_size],
min_resize_value=FLAGS.min_resize_value,
max_resize_value=FLAGS.max_resize_value,
resize_factor=FLAGS.resize_factor,
model_variant=FLAGS.model_variant,
is_training=False,
should_shuffle=False,
should_repeat=False)
train_id_to_eval_id = None
if dataset.dataset_name == data_generator.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)
instance_save_dir = os.path.join(FLAGS.vis_logdir,
_INSTANCE_PREDICTION_SAVE_FOLDER)
tf.gfile.MakeDirs(instance_save_dir)
regression_save_dir = os.path.join(FLAGS.vis_logdir,
_OFFSET_PREDICTION_SAVE_FOLDER)
tf.gfile.MakeDirs(regression_save_dir)
panoptic_save_dir = os.path.join(FLAGS.vis_logdir,
_PANOPTIC_PREDICTION_SAVE_FOLDER)
tf.gfile.MakeDirs(panoptic_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)
with tf.Graph().as_default():
samples = dataset.get_one_shot_iterator().get_next()
model_options = common.ModelOptions(
outputs_to_num_classes={
common.OUTPUT_TYPE: dataset.num_of_classes,
common.INSTANCE: 1,
common.OFFSET: 2
},
crop_size=[int(sz) for sz in 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.')
if FLAGS.quantize_delay_step >= 0:
raise ValueError(
'Quantize mode is not supported with 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_semantic = predictions[common.OUTPUT_TYPE]
predictions_instance = predictions[common.INSTANCE]
predictions_regression = predictions[common.OFFSET]
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 resize the predictions back.
original_image = tf.squeeze(samples[common.ORIGINAL_IMAGE])
original_image_shape = tf.shape(original_image)
predictions_semantic = tf.slice(
predictions_semantic, [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_semantic = tf.squeeze(
tf.image.resize_images(
tf.expand_dims(predictions_semantic, 3),
resized_shape,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
align_corners=True), 3)
############################### POST PROCESSING LOGITS FROM INSTANCE CENTER #####################
predictions_instance = tf.slice(
predictions_instance, [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_instance = tf.squeeze(
tf.image.resize_images(
tf.expand_dims(predictions_instance, 3),
resized_shape,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
align_corners=True), 3)
############################### POST PROCESSING LOGITS FROM INSTANCE REGRESSION #####################
predictions_regression = tf.slice(
predictions_regression, [0, 0, 0, 0],
[1, original_image_shape[0], original_image_shape[1], 1])
resized_shape = tf.to_int32([
tf.squeeze(samples[common.HEIGHT]),
tf.squeeze(samples[common.WIDTH]), 2
])
predictions_regression = tf.image.resize_images(
predictions_regression,
resized_shape,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
align_corners=True)
tf.train.get_or_create_global_step()
if FLAGS.quantize_delay_step >= 0:
contrib_quantize.create_eval_graph()
num_iteration = 0
max_num_iteration = FLAGS.max_number_of_iterations
checkpoints_iterator = contrib_training.checkpoints_iterator(
FLAGS.checkpoint_dir, min_interval_secs=FLAGS.eval_interval_secs)
for checkpoint_path in checkpoints_iterator:
num_iteration += 1
tf.logging.info('Starting visualization at ' +
time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime()))
tf.logging.info('Visualizing with model %s', checkpoint_path)
scaffold = tf.train.Scaffold(
init_op=tf.global_variables_initializer())
session_creator = tf.train.ChiefSessionCreator(
scaffold=scaffold,
master=FLAGS.master,
checkpoint_filename_with_path=checkpoint_path)
with tf.train.MonitoredSession(session_creator=session_creator,
hooks=None) as sess:
batch = 0
image_id_offset = 0
while not sess.should_stop():
tf.logging.info('Visualizing batch %d', batch + 1)
_process_batch(
sess=sess,
original_images=samples[common.ORIGINAL_IMAGE],
semantic_predictions=predictions_semantic,
instance_predictions=predictions_instance,
regression_predictions=predictions_regression,
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,
instance_save_dir=instance_save_dir,
regression_save_dir=regression_save_dir,
panoptic_save_dir=panoptic_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
batch += 1
tf.logging.info('Finished visualization at ' +
time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime()))
if max_num_iteration > 0 and num_iteration >= max_num_iteration:
break
def main(unused_argv):
tf.logging.set_verbosity(tf.logging.INFO)
tf.logging.info('Prepare to export model to: %s', FLAGS.export_path)
with tf.Graph().as_default():
image, image_size, resized_image_size = _create_input_tensors()
model_options = common.ModelOptions(
outputs_to_num_classes={common.OUTPUT_TYPE: FLAGS.num_classes,
common.INSTANCE: 1, common.OFFSET: 2},
crop_size=FLAGS.crop_size,
atrous_rates=FLAGS.atrous_rates,
output_stride=FLAGS.output_stride)
if tuple(FLAGS.inference_scales) == (1.0,):
tf.logging.info('Exported model performs single-scale inference.')
predictions = model.predict_labels(
image,
model_options=model_options,
image_pyramid=FLAGS.image_pyramid)
else:
tf.logging.info('Exported model performs multi-scale inference.')
if FLAGS.quantize_delay_step >= 0:
raise ValueError(
'Quantize mode is not supported with multi-scale test.')
predictions = model.predict_labels_multi_scale(
image,
model_options=model_options,
eval_scales=FLAGS.inference_scales,
add_flipped_images=FLAGS.add_flipped_images)
raw_predictions = tf.identity(
tf.cast(predictions[common.OUTPUT_TYPE], tf.float32),
_RAW_OUTPUT_NAME)
raw_probabilities = tf.identity(
predictions[common.OUTPUT_TYPE + model.PROB_SUFFIX],
_RAW_OUTPUT_PROB_NAME)
# Crop the valid regions from the predictions.
semantic_predictions = raw_predictions[
:, :resized_image_size[0], :resized_image_size[1]]
semantic_probabilities = raw_probabilities[
:, :resized_image_size[0], :resized_image_size[1]]
################### INSTANCE CENTER ########################
raw_instance_predictions = tf.identity(
tf.cast(predictions[common.INSTANCE], tf.float32),
_RAW_INSTANCE_CENTER_OUTPUT_NAME)
raw_instance_probabilities = tf.identity(
predictions[common.INSTANCE + model.PROB_SUFFIX],
_RAW_INSTANCE_OUTPUT_PROB_NAME)
# Crop the valid regions from the predictions.
instance_predictions = raw_instance_predictions[
:, :resized_image_size[0], :resized_image_size[1]]
instance_probabilities = raw_instance_probabilities[
:, :resized_image_size[0], :resized_image_size[1]]
####################### INSTANCE OFFSET ########################
raw_offset_predictions = tf.identity(
tf.cast(predictions[common.OFFSET], tf.float32),
_RAW_INSTANCE_OFFSET_OUTPUT_NAME)
raw_offset_probabilities = tf.identity(
predictions[common.OFFSET + model.PROB_SUFFIX],
_RAW_OFFSET_OUTPUT_PROB_NAME)
# Crop the valid regions from the predictions.
offset_predictions = raw_offset_predictions[
:, :resized_image_size[0], :resized_image_size[1], :]
offset_probabilities = raw_offset_probabilities[
:, :resized_image_size[0], :resized_image_size[1], :]
# Resize back the prediction to the original image size.
def _resize_label(label, label_size):
# Expand dimension of label to [1, height, width, 1] for resize operation.
label = tf.expand_dims(label, 3)
resized_label = tf.image.resize_images(
label,
label_size,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
align_corners=True)
return tf.cast(tf.squeeze(resized_label, 3), tf.int32)
# Resize back the prediction to the original image size.
def _resize_label_instance(label, label_size):
# Expand dimension of label to [1, height, width, 1] for resize operation.
#label = tf.expand_dims(label, 3)
resized_label = tf.image.resize_images(
label,
label_size,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
align_corners=True)
return tf.cast(tf.squeeze(resized_label, 3), tf.float32)
def _resize_label_offset(label, label_size):
# Expand dimension of label to [1, height, width, 1] for resize operation.
#label = tf.expand_dims(label, 3)
resized_label = tf.image.resize_images(
label,
label_size,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
align_corners=True)
return tf.cast(resized_label, tf.float32)
############################## SEMANTIC LABEL RESIZE ###################################
print(tf.shape(semantic_predictions))
semantic_predictions = _resize_label(semantic_predictions, image_size)
semantic_predictions = tf.identity(semantic_predictions, name=_OUTPUT_NAME)
semantic_probabilities = tf.image.resize_bilinear(
semantic_probabilities, image_size, align_corners=True,
name=_OUTPUT_PROB_NAME)
############################### INSTANCE CENTER RESIZE ####################################
instance_predictions = _resize_label_instance(instance_predictions, image_size)
instance_predictions = tf.identity(instance_predictions, name=_OUTPUT_NAME_INSTANCE_CENTER)
instance_probabilities = tf.image.resize_bilinear(
instance_probabilities, image_size, align_corners=True,
name=_OUTPUT_INSTANCE_PROB_NAME)
################################ INSTANCE REGRESSION RESIZE ###################################
offset_predictions = _resize_label_offset(offset_predictions, image_size)
offset_predictions = tf.identity(offset_predictions, name=_OUTPUT_NAME_INSTANCE_OFFSET)
instance_probabilities = tf.image.resize_bilinear(
instance_probabilities, image_size, align_corners=True,
name=_OUTPUT_OFFSET_PROB_NAME)
if FLAGS.quantize_delay_step >= 0:
contrib_quantize.create_eval_graph()
saver = tf.train.Saver(tf.all_variables())
dirname = os.path.dirname(FLAGS.export_path)
tf.gfile.MakeDirs(dirname)
graph_def = tf.get_default_graph().as_graph_def(add_shapes=True)
freeze_graph.freeze_graph_with_def_protos(
graph_def,
saver.as_saver_def(),
FLAGS.checkpoint_path,
_OUTPUT_NAME + ',' + _OUTPUT_PROB_NAME +
',' + _OUTPUT_NAME_INSTANCE_CENTER +
',' + _OUTPUT_INSTANCE_PROB_NAME +
',' + _OUTPUT_NAME_INSTANCE_OFFSET +
',' + _OUTPUT_OFFSET_PROB_NAME,
restore_op_name=None,
filename_tensor_name=None,
output_graph=FLAGS.export_path,
clear_devices=True,
initializer_nodes=None)
if FLAGS.save_inference_graph:
tf.train.write_graph(graph_def, dirname, 'inference_graph.pbtxt')