def main(argv):
tf.logging.set_verbosity(tf.logging.INFO)
common.print_args()
dataset = generator.Dataset(
dataset_dir=FLAGS.dataset_dir,
dataset_name=FLAGS.dataset_name,
split_name=FLAGS.split_name,
batch_size=FLAGS.batch_size,
crop_size=[int(val) for val in FLAGS.crop_size],
min_resize_value=FLAGS.min_resize_value,
max_resize_value=FLAGS.max_resize_value,
resize_factor=FLAGS.resize_factor,
min_scale_factor=FLAGS.min_scale_factor,
max_scale_factor=FLAGS.max_scale_factor,
scale_factor_step_size=FLAGS.scale_factor_step_size,
is_training=False,
model_variant=FLAGS.model_variant,
should_shuffle=False,
should_repeat=False)
tf.logging.info('Evaluation on %s set on %s', ''.join(FLAGS.split_name), FLAGS.dataset_name)
with tf.Graph().as_default():
samples = dataset.get_one_shot_iterator().get_next()
model = segModel.SegModel(
num_classes=dataset.num_classes,
model_variant=FLAGS.model_variant,
output_stride=FLAGS.output_stride,
backbone_atrous_rates=FLAGS.backbone_atrous_rates,
is_training=False,
ppm_rates=FLAGS.ppm_rates,
ppm_pooling_type=FLAGS.ppm_pooling_type,
atrous_rates=FLAGS.atrous_rates,
module_order=FLAGS.module_order,
decoder_output_stride=FLAGS.decoder_output_stride)
if FLAGS.eval_scales == [1.0]:
tf.logging.info('Evaluate the single scale image.')
predictions, _ = model.predict_labels(images=samples[common.IMAGE],
add_flipped_images=FLAGS.add_flipped_images)
else:
tf.logging.info('Evaluate the multi-scale image.')
predictions, _ = model.predict_labels_for_multiscale(
images=samples[common.IMAGE],
add_flipped_images=FLAGS.add_flipped_images,
eval_scales=FLAGS.eval_scales)
predictions = tf.reshape(predictions, shape=[-1])
labels = tf.reshape(samples[common.LABEL], shape=[-1])
weights = tf.to_float(tf.not_equal(labels, 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.
labels = tf.where(
tf.equal(labels, dataset.ignore_label), tf.zeros_like(labels), labels)
miou, update_op = tf.metrics.mean_iou(
predictions, labels, dataset.num_classes, weights=weights)
miou_text = '{}_miou_f_{}_multiscale_{}'.format(
''.join(FLAGS.split_name),
int(FLAGS.add_flipped_images),
int(len(FLAGS.eval_scales) > 1))
tf.summary.scalar(miou_text, miou)
summary_op = tf.summary.merge_all()
# それぞれのepochごとに行いたい処理
summary_hook = tf.contrib.training.SummaryAtEndHook(
log_dir=FLAGS.eval_logdir, summary_op=summary_op)
hooks = [summary_hook]
num_eval = None
if FLAGS.max_number_of_evaluations > 0:
num_eval = FLAGS.max_number_of_evaluations
tf.contrib.tfprof.model_analyzer.print_model_analysis(
tf.get_default_graph(),
tfprof_options=tf.contrib.tfprof.model_analyzer.
TRAINABLE_VARS_PARAMS_STAT_OPTIONS)
tf.contrib.tfprof.model_analyzer.print_model_analysis(
tf.get_default_graph(),
tfprof_options=tf.contrib.tfprof.model_analyzer.FLOAT_OPS_OPTIONS)
tf.contrib.training.evaluate_repeatedly(
master='',
checkpoint_dir=FLAGS.checkpoint_dir,
eval_ops=[update_op],
max_number_of_evaluations=num_eval,
hooks=hooks,
eval_interval_secs=FLAGS.eval_interval_secs)
def main(unused_args):
tf.logging.set_verbosity(tf.logging.INFO)
tf.logging.info('Prepare to export model to %s', FLAGS.export_path)
common.print_args()
with tf.Graph().as_default():
image, image_size, resized_image_size = _create_input_tensor()
model = segModel.SegModel(
num_classes=generator._DATASETS_INFORMATION[
FLAGS.dataset_name]['num_classes'],
model_variant=FLAGS.model_variant,
output_stride=FLAGS.output_stride,
fine_tune_batch_norm=False,
backbone_atrous_rates=FLAGS.backbone_atrous_rates,
is_training=False,
ppm_rates=FLAGS.ppm_rates,
ppm_pooling_type=FLAGS.ppm_pooling_type,
atrous_rates=FLAGS.atrous_rates,
module_order=FLAGS.module_order,
decoder_output_stride=FLAGS.decoder_output_stride)
if FLAGS.inference_scales == [1.0]:
tf.logging.info('Evaluate the single scale image.')
predictions, probabilities = model.predict_labels(
images=image, add_flipped_images=FLAGS.add_flipped_images)
else:
tf.logging.info('Evaluate the multi-scale image.')
predictions, probabilities = model.predict_labels_for_multiscale(
images=image,
add_flipped_images=FLAGS.add_flipped_images,
eval_scales=FLAGS.inference_scales)
# prediction is a thing after argmax.
raw_predictions = tf.identity(tf.cast(predictions, tf.float32),
_RAW_OUTPUT_NAME)
# probabilities is a thing berore argmax.
raw_probabilities = tf.identity(probabilities, _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]]
# 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)
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)
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,
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')
def main(argv):
tf.logging.set_verbosity(tf.logging.INFO)
common.print_args()
tf.logging.info('Training on %s %s set' %
(','.join(FLAGS.split_name), FLAGS.dataset_name))
graph = tf.Graph()
crop_size = [int(val) for val in FLAGS.crop_size]
# create graph in new thread.
with graph.as_default():
# create dataset generator
dataset = generator.Dataset(
dataset_dir=FLAGS.dataset_dir,
dataset_name=FLAGS.dataset_name,
split_name=FLAGS.split_name,
batch_size=FLAGS.batch_size,
crop_size=[int(val) for val in FLAGS.crop_size],
min_resize_value=FLAGS.min_resize_value,
max_resize_value=FLAGS.max_resize_value,
resize_factor=FLAGS.resize_factor,
min_scale_factor=FLAGS.min_scale_factor,
max_scale_factor=FLAGS.max_scale_factor,
scale_factor_step_size=FLAGS.scale_factor_step_size,
is_training=True,
model_variant=FLAGS.model_variant,
should_shuffle=True,
should_repeat=True)
iterator = dataset.get_one_shot_iterator()
global_step = tf.train.get_or_create_global_step()
# create learning_rate
learning_rate = tf.train.polynomial_decay(
learning_rate=FLAGS.base_learning_rate,
global_step=global_step,
decay_steps=FLAGS.train_steps,
end_learning_rate=0,
power=0.9)
# create optimizer
optimizer = tf.train.MomentumOptimizer(learning_rate, FLAGS.momentum)
# build models
with tf.name_scope('clone') as scope:
with tf.variable_scope(tf.get_variable_scope(), reuse=False):
samples = iterator.get_next()
input = tf.identity(samples[common.IMAGE], name='Input_Image')
labels = tf.identity(samples[common.LABEL],
name='Semantic_Label')
global model
model = segModel.SegModel(
num_classes=dataset.num_classes,
model_variant=FLAGS.model_variant,
output_stride=FLAGS.output_stride,
fine_tune_batch_norm=FLAGS.fine_tune_batch_norm,
weight_decay=FLAGS.weight_decay,
backbone_atrous_rates=FLAGS.backbone_atrous_rates,
is_training=True,
ppm_rates=FLAGS.ppm_rates,
ppm_pooling_type=FLAGS.ppm_pooling_type,
atrous_rates=FLAGS.atrous_rates,
module_order=FLAGS.module_order,
decoder_output_stride=FLAGS.decoder_output_stride)
logits = model.build(images=input)
logits = tf.identity(logits, name='dense_prediction')
logits, labels = resize_logits_or_labels(logits, labels)
add_softmax_cross_entropy_loss(logits,
labels,
dataset.num_classes,
dataset.ignore_label,
loss_weight=1.0)
log_summaries(input, labels, dataset.num_classes, logits,
dataset.ignore_label)
# should_log
losses = tf.losses.get_losses(scope=scope)
total_loss = get_total_loss(losses, global_step, scope)
grads = optimizer.compute_gradients(total_loss)
grad_updates = optimizer.apply_gradients(grads,
global_step=global_step)
# Gather update_ops. These contain, for example,
# the updates for the batch_norm variables created by model_fn.
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
update_ops.append(grad_updates)
update_op = tf.group(*update_ops)
# Print total loss to the terminal.
total_loss = tf.cond(
math_ops.equal(math_ops.mod(global_step, FLAGS.log_steps), 0),
lambda: _print_tensor('total loss :', total_loss),
lambda: total_loss)
with tf.control_dependencies([update_op]):
train_tensor = tf.identity(total_loss, name='train_op')
summary_op = tf.summary.merge_all(scope='clone')
# Soft placement allows placing on CPU ops without GPU implementation.
session_config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
init_fn = None
if FLAGS.tf_initial_checkpoint:
init_fn = get_model_init_fn(
train_logdir=FLAGS.train_logdir,
tf_initial_checkpoint=FLAGS.tf_initial_checkpoint,
ignore_missing_vars=True)
scaffold = tf.train.Scaffold(init_fn=init_fn, summary_op=summary_op)
stop_hook = tf.train.StopAtStepHook(last_step=FLAGS.train_steps)
if FLAGS.save_summaries_secs <= 0:
FLAGS.save_summaries_secs = None
with tf.train.MonitoredTrainingSession(
checkpoint_dir=FLAGS.train_logdir,
hooks=[stop_hook],
# config=session_config,
scaffold=scaffold,
summary_dir=FLAGS.train_logdir,
log_step_count_steps=FLAGS.log_steps,
save_summaries_secs=FLAGS.save_summaries_secs,
save_checkpoint_secs=FLAGS.save_interval_secs) as sess:
iter = 0
while not sess.should_stop():
sess.run([train_tensor])
if iter % FLAGS.log_steps == 0:
sys.stdout.write('\n')
sys.stdout.flush()
iter += 1
def main(argv):
tf.logging.set_verbosity(tf.logging.INFO)
common.print_args()
# Create dataset generator
dataset = generator.Dataset(
dataset_dir=FLAGS.dataset_dir,
dataset_name=FLAGS.dataset_name,
split_name=FLAGS.split_name,
batch_size=1,
crop_size=[int(val) for val in FLAGS.crop_size],
min_resize_value=FLAGS.min_resize_value,
max_resize_value=FLAGS.max_resize_value,
resize_factor=FLAGS.resize_factor,
min_scale_factor=FLAGS.min_scale_factor,
max_scale_factor=FLAGS.max_scale_factor,
scale_factor_step_size=FLAGS.scale_factor_step_size,
is_training=False,
model_variant=FLAGS.model_variant,
should_shuffle=False,
should_repeat=False)
tf.gfile.MakeDirs(FLAGS.vis_logdir)
miou_text = '_flip_{}_multiscale_{}'.format(
int(FLAGS.add_flipped_images), int(len(FLAGS.eval_scales) > 1))
save_dir = os.path.join(FLAGS.vis_logdir,
_SEMANTIC_PREDICTION_DIR + miou_text)
tf.gfile.MakeDirs(save_dir)
tf.logging.info('Visualizing on %s set', ''.join(FLAGS.split_name))
with tf.Graph().as_default():
iterator = dataset.get_one_shot_iterator()
samples = iterator.get_next()
model = segModel.SegModel(
num_classes=dataset.num_classes,
model_variant=FLAGS.model_variant,
output_stride=FLAGS.output_stride,
backbone_atrous_rates=FLAGS.backbone_atrous_rates,
is_training=False,
ppm_rates=FLAGS.ppm_rates,
ppm_pooling_type=FLAGS.ppm_pooling_type,
atrous_rates=FLAGS.atrous_rates,
module_order=FLAGS.module_order,
decoder_output_stride=FLAGS.decoder_output_stride)
if FLAGS.eval_scales == [1.0]:
tf.logging.info('Evaluate the single scale image.')
predictions, _ = model.predict_labels(
images=samples[common.IMAGE],
add_flipped_images=FLAGS.add_flipped_images)
else:
tf.logging.info('Evaluate the multi-scale image.')
predictions, _ = model.predict_labels_for_multiscale(
images=samples[common.IMAGE],
add_flipped_images=FLAGS.add_flipped_images,
eval_scales=FLAGS.eval_scales)
checkpoints_iterator = tf.contrib.training.checkpoints_iterator(
FLAGS.checkpoint_dir, min_interval_secs=FLAGS.eval_interval_secs)
if FLAGS.log_confusion:
# Get the confusion matrix op.
conf_mat_op, conf_mat, batch_conf = create_conf_mat_op(
samples[common.LABEL], predictions, dataset.num_classes,
dataset.ignore_label)
# Initializer for initializing the conf_mat.
init_fn = tf.initialize_variables([conf_mat])
# restore from checkpoint excluding variable "conf_mat".
variables_to_restore = tf.global_variables()[:-1]
else:
# dummy op.
conf_mat_op, conf_mat, batch_conf = None, None, None
init_fn = None
variables_to_restore = tf.global_variables()
num_iteration = 0
max_num_iteration = FLAGS.max_number_of_iterations
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)
restorer = tf.train.Saver(variables_to_restore)
scaffold = tf.train.Scaffold(
init_op=tf.global_variables_initializer(),
saver=restorer,
ready_for_local_init_op=init_fn)
session_creator = tf.train.ChiefSessionCreator(
scaffold=scaffold,
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)
accumulated_conf_mat = _process_batch(
sess=sess,
samples=samples,
predictions=predictions,
image_id_offset=image_id_offset,
save_dir=save_dir,
conf_mat_op=conf_mat_op,
conf_mat=conf_mat,
batch_conf=batch_conf)
image_id_offset += 1
batch += 1
if FLAGS.log_confusion:
summary_conf_mat(accumulated_conf_mat, save_dir)
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(argv):
common.print_args()
tf.logging.set_verbosity(tf.logging.DEBUG)
crop_size = [int(FLAGS.crop_size[0]), int(FLAGS.crop_size[1])]
dataset = generator.Dataset(FLAGS.dataset_dir,
FLAGS.dataset_name,
FLAGS.split_name,
10,
crop_size,
min_resize_value=FLAGS.min_resize_value,
max_resize_value=FLAGS.max_resize_value,
resize_factor=FLAGS.resize_factor,
min_scale_factor=FLAGS.min_scale_factor,
max_scale_factor=FLAGS.max_scale_factor,
scale_factor_step_size=FLAGS.scale_factor_step_size,
is_training=FLAGS.is_training,
model_variant=FLAGS.model_variant,
should_shuffle=False)
iterator = dataset.get_one_shot_iterator()
samples = iterator.get_next()
sess = tf.Session()
print('=' * 10 + 'samples content' + '=' * 10)
for key, val in samples.items():
print('samples[{}]: {}'.format(key, val.shape))
print('=' * 35)
res = sess.run(samples)
print(res.keys())
image = res[common.IMAGE]
ann = res[common.LABEL]
original_height = res[common.IMAGE_HEIGHT]
original_width = res[common.IMAGE_WIDTH]
print(original_height)
print(original_width)
print('image.shape => ', image.shape)
print('ann.shape => ', ann.shape)
figure = plt.figure(figsize=(20, 10))
num_imgs = 2
gridspec_master = GridSpec(nrows=num_imgs, ncols=2)
for i in range(num_imgs):
grid_sub_1 = GridSpecFromSubplotSpec(nrows=1,
ncols=1,
subplot_spec=gridspec_master[i, 0])
axes_1 = figure.add_subplot(grid_sub_1[:, :])
axes_1.set_xticks([])
axes_1.set_yticks([])
axes_1.imshow(image[i].astype(np.uint8))
axes_1.set_title('target')
grid_sub_2 = GridSpecFromSubplotSpec(nrows=1,
ncols=1,
subplot_spec=gridspec_master[i, 1])
axes_2 = figure.add_subplot(grid_sub_2[:, :])
axes_2.set_xticks([])
axes_2.set_yticks([])
label = np.squeeze(ann[i], axis=2)
label[label == 255] = np.max(label[label != 255]) +1
axes_2.imshow(label, cmap='gray')
axes_2.set_title('label')
plt.show()
print(ann.shape)
def main(argv):
tf.logging.set_verbosity(tf.logging.INFO)
common.print_args()
EKF_VIS_DIR = 'EKF_RESULTS'
ekf_vis_dir = os.path.join(FLAGS.ckpt_dir, EKF_VIS_DIR)
if not os.path.exists(ekf_vis_dir):
os.makedirs(ekf_vis_dir)
with tf.Graph().as_default():
dataset = generator.Dataset(
dataset_dir=os.path.join('dataset', 'cityscapes', 'tfrecord'),
dataset_name='cityscapes',
split_name=['val_fine'],
batch_size=1,
crop_size=[HEIGHT, WIDTH],
is_training=False,
model_variant='resnet_v1_101_beta',
min_scale_factor=0.50,
max_scale_factor=2.0,
should_shuffle=False,
should_repeat=False)
ite = dataset.get_one_shot_iterator()
sample = ite.get_next()
images, labels = sample[common.IMAGE], sample[common.LABEL]
module_order = search_model()
model = segModel.SegModel(
num_classes=dataset.num_classes,
model_variant='resnet_v1_101_beta',
output_stride=16,
backbone_atrous_rates=[1, 2, 4],
is_training=False,
ppm_rates=[1, 2, 3, 6],
module_order=module_order,
decoder_output_stride=4)
logits = model.build(images=images)
logits = tf.image.resize_bilinear(logits, tf.shape(images)[1:3], align_corners=True)
# logits = tf.nn.softmax(logits, axis=3)
height_ind = tf.range(HEIGHT, dtype=tf.int32)
width_ind = tf.range(WIDTH, dtype=tf.int32)
height_ind = tf.expand_dims(tf.math.logical_and(tf.math.greater_equal(height_ind, FLAGS.mask_heights[0]),
tf.math.greater_equal(FLAGS.mask_heights[1], height_ind)), 1)
width_ind = tf.expand_dims(tf.math.logical_and(tf.math.greater_equal(width_ind, FLAGS.mask_widths[0]),
tf.math.greater_equal(FLAGS.mask_widths[1], width_ind)), 0)
# height_ind = tf.expand_dims(tf.math.equal(height_ind, HEIGHT//4), 1)
# width_ind = tf.expand_dims(tf.math.equal(width_ind, WIDTH//4), 0)
height_map = []
width_map = []
for w in range(WIDTH):
height_map.append(height_ind)
for h in range(HEIGHT):
width_map.append(width_ind)
height_map = tf.concat(height_map, axis=1)
width_map = tf.concat(width_map, axis=0)
height_map = tf.cast(height_map, tf.float32)
width_map = tf.cast(width_map, tf.float32)
mask = tf.expand_dims(tf.math.multiply(height_map, width_map), axis=2)
m_concat = []
for _ in range(dataset.num_classes):
m_concat.append(mask)
mask = tf.concat(m_concat, axis=2)
masked_logits = tf.multiply(mask, logits)
grad = tf.gradients(masked_logits, [images])
########### SESSION CREATING PROCESS #############
checkpoints_iterator = tf.contrib.training.checkpoints_iterator(
FLAGS.ckpt_dir)
for checkpoint_path in checkpoints_iterator:
restorer = tf.train.Saver()
scaffold = tf.train.Scaffold(init_op=tf.global_variables_initializer(),
saver=restorer,
ready_for_local_init_op=None)
session_creator = tf.train.ChiefSessionCreator(
scaffold=scaffold,
master='',
checkpoint_filename_with_path=checkpoint_path)
with tf.train.MonitoredSession(
session_creator=session_creator, hooks=None) as sess:
grad_list = []
batch_num = 0
while not sess.should_stop():
im, l, g = sess.run([images, logits, grad])
grad_list.append(g[0])
im = im[0]
g = np.abs(g[0][0])
if batch_num == 0:
sum_g = g
else:
sum_g += g
batch_num += 1
g = normalizeImg(g)
im = normalizeImg(im)
img_path = os.path.join(ekf_vis_dir, '{}_img.jpg'.format(batch_num))
grad_path = os.path.join(ekf_vis_dir, '{}_grad.jpg'.format(batch_num))
cv2.imwrite(img_path, cv2.cvtColor(im*255, cv2.COLOR_RGB2BGR))
cv2.imwrite(grad_path, cv2.cvtColor(g*255, cv2.COLOR_RGB2BGR))
print('Processing {} done!'.format(batch_num))
if batch_num % 100 == 0:
print('100 second sleep')
time.sleep(100)
if batch_num >= 20:
break
break
sum_g = sum_g / batch_num
print('max: {:.3f}, min: {:.3f}'.format(np.max(sum_g), np.min(sum_g)))
sum_g = normalizeImg(sum_g)
binary_g = sum_g.copy()
binary_g[sum_g > np.mean(sum_g)] = 255
cv2.imwrite(os.path.join(ekf_vis_dir, 'average_grad.jpg'), cv2.cvtColor(sum_g*255, cv2.COLOR_RGB2BGR))
plt.title('average grad')
plt.imshow(sum_g)
plt.show()
cv2.imwrite(os.path.join(ekf_vis_dir, 'sum_grad_{}.jpg'.format(batch_num)), cv2.cvtColor(binary_g.astype(np.uint8), cv2.COLOR_RGB2BGR))