def main(_):
with tf.Graph().as_default():
tf.logging.set_verbosity(tf.logging.INFO)
# Read data from disk
fiber_output, fiber_input, encoder, label = data_loader.read_inputs('train.txt', True)
# Generator_1(inputs=[fiber_output,fiber_input], targets=[encoder,label])
# Generator_2(inputs=[fiber_output,fiber_input], targets=[encoder,label])
# Discriminator(inputs=[fiber_output,fiber_input], targets=[encoder,label])
Generator_all(inputs=[fiber_output,fiber_input], targets=[encoder,label])
def train(args):
"""Train different architectures for a number of epochs."""
with tf.Graph().as_default(), tf.device('/cpu:0'):
# Read data from disk
images1, images2, labels = data_loader.read_inputs(True, args)
epoch_number = tf.get_variable('epoch_number', [],
dtype=tf.int32,
initializer=tf.constant_initializer(0),
trainable=False)
# Decay the learning rate
lr = tf.train.piecewise_constant(epoch_number,
args.LR_steps,
args.LR_values,
name='LearningRate')
# Weight Decay policy
wd = tf.train.piecewise_constant(epoch_number,
args.WD_steps,
args.WD_values,
name='WeightDecay')
is_training = not args.transfer_mode[0] == 1
# Create an optimizer that performs gradient descent.
opt = tf.train.MomentumOptimizer(lr, 0.9)
# Calculate the gradients for each model tower.
tower_grads = []
tower_auxgrads = []
with tf.variable_scope(tf.get_variable_scope()) as scope_sim:
for i in xrange(args.num_gpus):
with tf.device('/gpu:%d' % i):
with tf.name_scope('Tower_%d' % i) as scope:
# Calculate the loss for one tower. This function
# constructs the entire model but shares the variables across
# all towers.#
o1 = arch.get_model(images1, wd, is_training, args)
scope_sim.reuse_variables()
o2 = arch.get_model(images2, wd, is_training, args)
# logits = arch.get_model(images, wd, is_training, args)
# # Top-1 accuracy
# top1acc = tf.reduce_mean(
# tf.cast(tf.nn.in_top_k(logits, labels, 1), tf.float32))
# # Top-5 accuracy
# topnacc = tf.reduce_mean(
# tf.cast(tf.nn.in_top_k(logits, labels, args.top_n), tf.float32))
# Build the portion of the Graph calculating the losses. Note that we will
# assemble the total_loss using a custom function below.
# cross_entropy_mean = loss(logits, labels)
cross_entropy_mean = loss_contrastive(o1, o2, labels)
# Get all the regularization lesses and add them
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
reg_loss = tf.add_n(regularization_losses)
#Add a tensorboard summary
tf.summary.scalar('Regularization Loss', reg_loss)
# Compute the total loss (cross entropy loss + regularization loss)
total_loss = tf.add(cross_entropy_mean, reg_loss)
# Attach a scalar summary for the total loss and top-1 and top-5 accuracies
tf.summary.scalar('Total Loss', total_loss)
# tf.summary.scalar('Top-1 Accuracy', top1acc)
# tf.summary.scalar('Top-n Accuracy', topnacc)
# Reuse variables for the next tower.
tf.get_variable_scope().reuse_variables()
# Retain the summaries from the final tower.
summaries = tf.get_collection(tf.GraphKeys.SUMMARIES,
scope)
# Gather batch normaliziation update operations
batchnorm_updates = tf.get_collection(
tf.GraphKeys.UPDATE_OPS, scope)
# Calculate the gradients for the batch of data on this CIFAR tower.
if args.transfer_mode[0] == 3:
grads = opt.compute_gradients(
total_loss,
var_list=tf.get_collection(
tf.GraphKeys.VARIABLES, scope='output'))
auxgrads = opt.compute_gradients(total_loss)
tower_auxgrads.append(auxgrads)
elif args.transfer_mode[0] == 1:
grads = opt.compute_gradients(
total_loss,
var_list=tf.get_collection(
tf.GraphKeys.VARIABLES, scope='output'))
else:
grads = opt.compute_gradients(total_loss)
# Keep track of the gradients across all towers.
tower_grads.append(grads)
# We must calculate the mean of each gradient. Note that this is the
# synchronization point across all towers.
grads = average_gradients(tower_grads)
auxgrads = average_gradients(tower_auxgrads)
# Add a summary to track the learning rate and weight decay
summaries.append(tf.summary.scalar('learning_rate', lr))
summaries.append(tf.summary.scalar('weight_decay', wd))
# Group all updates to into a single train op.
#with tf.control_dependencies(bn_update_ops):
# Setup the train operation
if args.transfer_mode[0] == 3:
train_op = tf.cond(
tf.less(epoch_number, args.transfer_mode[1]), lambda: tf.group(
opt.apply_gradients(grads), *batchnorm_updates), lambda: tf
.group(opt.apply_gradients(auxgrads), *batchnorm_updates))
elif args.transfer_mode[0] == 1:
train_op = opt.apply_gradients(grads)
else:
train_op = tf.group(opt.apply_gradients(grads),
tf.group(*batchnorm_updates))
# a loader for loading the pretrained model (it does not load the last layer)
if args.retrain_from is not None:
if args.transfer_mode[0] == 0:
pretrained_loader = tf.train.Saver()
else:
pretrained_loader = tf.train.Saver(var_list=exclude())
# Create a saver.
saver = tf.train.Saver(tf.global_variables(),
max_to_keep=args.num_epochs)
# Build the summary operation from the last tower summaries.
summary_op = tf.summary.merge_all()
# Build an initialization operation to run below.
init = tf.global_variables_initializer()
# Logging the runtime information if requested
if args.log_debug_info:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
else:
run_options = None
run_metadata = None
# Creating a session to run the built graph
sess = tf.Session(config=tf.ConfigProto(
allow_soft_placement=True,
log_device_placement=args.log_device_placement))
sess.run(init)
# Continue training from a saved snapshot, load a pre-trained model
if args.retrain_from is not None:
ckpt = tf.train.get_checkpoint_state(args.retrain_from)
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
pretrained_loader.restore(sess, ckpt.model_checkpoint_path)
else:
return
# Start the queue runners.
tf.train.start_queue_runners(sess=sess)
# Setup a summary writer
summary_writer = tf.summary.FileWriter(args.log_dir, sess.graph)
# Set the start epoch number
start_epoch = sess.run(epoch_number + 1)
# The main training loop
for epoch in xrange(start_epoch, start_epoch + args.num_epochs):
# update epoch_number
sess.run(epoch_number.assign(epoch))
# Trainig batches
for step in xrange(args.num_batches):
start_time = time.time()
_, loss_value = sess.run([train_op, cross_entropy_mean],
options=run_options,
run_metadata=run_metadata)
duration = time.time() - start_time
# Check for errors
assert not np.isnan(
loss_value), 'Model diverged with loss = NaN'
# Logging and writing tensorboard summaries
if step % 10 == 0:
num_examples_per_step = args.chunked_batch_size * args.num_gpus
examples_per_sec = num_examples_per_step / duration
sec_per_batch = duration / args.num_gpus
format_str = (
'%s: epoch %d, step %d, loss = %.2f, (%.1f cats/sec; %.3f '
'sec/batch)')
print(format_str %
(datetime.now(), epoch, step, loss_value,
examples_per_sec, sec_per_batch))
sys.stdout.flush()
if step % 100 == 0:
summary_str = sess.run(summary_op)
summary_writer.add_summary(summary_str,
args.num_batches * epoch + step)
if args.log_debug_info:
summary_writer.add_run_metadata(
run_metadata, 'epoch%d step%d' % (epoch, step))
# Save the model checkpoint periodically after each training epoch
checkpoint_path = os.path.join(args.log_dir, args.snapshot_prefix)
saver.save(sess, checkpoint_path, global_step=epoch)
def evaluate(args):
# Building the graph
with tf.Graph().as_default() as g, tf.device('/cpu:0'):
# Get images and labels for CIFAR-10.
if args.save_predictions is None:
images, labels = data_loader.read_inputs(False, args)
else:
images, labels, urls = data_loader.read_inputs(False, args)
# Performing computations on a GPU
with tf.device('/gpu:0'):
# Build a Graph that computes the logits predictions from the
# inference model.
logits = arch.get_model(images, 0.0, False, args)
# Calculate predictions accuracies top-1 and top-n
top_1_op = tf.nn.in_top_k(logits, labels, 1)
top_n_op = tf.nn.in_top_k(logits, labels, args.top_n)
if args.save_predictions is not None:
topn = tf.nn.top_k(tf.nn.softmax(logits), args.top_n)
topnind= topn.indices
topnval= topn.values
saver = tf.train.Saver(tf.global_variables())
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.log_dir, g)
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
ckpt = tf.train.get_checkpoint_state(args.log_dir)
print(ckpt.model_checkpoint_path)
# Load the latest model
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
else:
return
# Start the queue runners.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
true_predictions_count = 0 # Counts the number of correct predictions
true_topn_predictions_count = 0
all_count = 0
step = 0
predictions_format_str = ('%d,%s,%d,%s,%s\n')
batch_format_str = ('Batch Number: %d, Top-1 Hit: %d, Top-'+str(args.top_n)+' Hit: %d, Top-1 Accuracy: %.3f, Top-'+str(args.top_n)+' Accuracy: %.3f')
if args.save_predictions is not None:
out_file = open(args.save_predictions,'w')
while step < args.num_batches and not coord.should_stop():
if args.save_predictions is None:
top1_predictions, topn_predictions = sess.run([top_1_op, top_n_op])
else:
top1_predictions, topn_predictions, urls_values, label_values, topnguesses, topnconf = sess.run([top_1_op, top_n_op, urls, labels, topnind, topnval])
for i in xrange(0,urls_values.shape[0]):
out_file.write(predictions_format_str%(step*args.batch_size+i+1, urls_values[i], label_values[i],
'[' + ', '.join('%d' % item for item in topnguesses[i]) + ']',
'[' + ', '.join('%.4f' % item for item in topnconf[i]) + ']'))
out_file.flush()
true_predictions_count += np.sum(top1_predictions)
true_topn_predictions_count += np.sum(topn_predictions)
all_count+= top1_predictions.shape[0]
print(batch_format_str%(step, true_predictions_count, true_topn_predictions_count, true_predictions_count / all_count, true_topn_predictions_count / all_count))
sys.stdout.flush()
step += 1
if args.save_predictions is not None:
out_file.close()
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
coord.request_stop()
coord.join(threads)
def predict(args):
# Building the graph
with tf.Graph().as_default() as g, tf.device('/cpu:0'):
# Get images and labels.
images, urls = data_loader.read_inputs(False, args, False)
# Performing computations on a GPU
with tf.device('/gpu:0'):
# Build a Graph that computes the logits predictions from the
# inference model.
logits = arch.get_model(images, 0.0, False, args)
# Information about the predictions for saving in a file
# Species Identification
top5_id = tf.nn.top_k(tf.nn.softmax(logits[0]), 5)
top5ind_id = top5_id.indices
top5val_id = top5_id.values
# Count
top3_cn = tf.nn.top_k(tf.nn.softmax(logits[1]), 3)
top3ind_cn = top3_cn.indices
top3val_cn = top3_cn.values
# Additional Attributes (e.g. description)
top1_bh = [None] * 6
top1ind_bh = [None] * 6
top1val_bh = [None] * 6
for i in xrange(0, 6):
top1_bh[i] = tf.nn.top_k(tf.nn.softmax(logits[i + 2]), 1)
top1ind_bh[i] = top1_bh[i].indices
top1val_bh[i] = top1_bh[i].values
# For reading the snapshot files from file
saver = tf.train.Saver(tf.global_variables())
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.log_dir, g)
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
ckpt = tf.train.get_checkpoint_state(args.log_dir)
# Load the latest model
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
else:
return
# Start the queue runners.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
step = 0
# Output file to save predictions and their confidences
out_file = open(args.save_predictions, 'w')
out_file.write('{')
first_row = True
while step < args.num_batches and not coord.should_stop():
urls_values, top5guesses_id, top5conf, top3guesses_cn, top3conf, top1guesses_bh, top1conf = sess.run(
[
urls, top5ind_id, top5val_id, top3ind_cn, top3val_cn,
top1ind_bh, top1val_bh
])
for i in xrange(0, urls_values.shape[0]):
step_result = {
'path':
urls_values[i],
'top_n_pred':
[int(np.asscalar(item)) for item in top5guesses_id[i]],
'top_n_conf': [
round(float(np.asscalar(item)), 4)
for item in top5conf[i]
],
'top_n_pred_count':
[int(np.asscalar(item)) for item in top3guesses_cn[i]],
'top_n_conf_count': [
round(float(np.asscalar(item)), 4)
for item in top3conf[i]
],
'top_pred_standing':
int(np.asscalar(top1guesses_bh[0][i])),
'top_pred_resting':
int(np.asscalar(top1guesses_bh[1][i])),
'top_pred_moving':
int(np.asscalar(top1guesses_bh[2][i])),
'top_pred_eating':
int(np.asscalar(top1guesses_bh[3][i])),
'top_pred_interacting':
int(np.asscalar(top1guesses_bh[4][i])),
'top_pred_young_present':
int(np.asscalar(top1guesses_bh[5][i])),
'top_conf_standing':
round(float(np.asscalar(top1conf[0][i])), 4),
'top_conf_resting':
round(float(np.asscalar(top1conf[1][i])), 4),
'top_conf_moving':
round(float(np.asscalar(top1conf[2][i])), 4),
'top_conf_eating':
round(float(np.asscalar(top1conf[3][i])), 4),
'top_conf_interacting':
round(float(np.asscalar(top1conf[4][i])), 4),
'top_conf_young_present':
round(float(np.asscalar(top1conf[5][i])), 4)
}
if first_row:
out_file.write('"' +
str(int(step * args.batch_size + i +
1)) + '":')
first_row = False
else:
out_file.write(',\n"' +
str(int(step * args.batch_size + i +
1)) + '":')
json.dump(step_result, out_file)
out_file.flush()
print("Finished predicting batch %s / %s" %
(step, args.num_batches))
sys.stdout.flush()
step += 1
out_file.write('}')
out_file.close()
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
coord.request_stop()
coord.join(threads)
def evaluate(args):
# Building the graph
with tf.Graph().as_default() as g, tf.device('/cpu:0'):
# Get images and labels
images1, images2, labels, urls1, urls2 = data_loader.read_inputs(
False, args)
# Performing computations on a GPU
with tf.device('/gpu:0'):
# Build a Graph that computes the logits predictions from the
# inference model.
logits = arch.get_model(images1, 0.0, False, args)
saver = tf.train.Saver(tf.global_variables())
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.log_dir, g)
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
ckpt = tf.train.get_checkpoint_state(args.log_dir)
# Load the latest model
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
else:
return
# Start the queue runners.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
step = 0
predictions_format_str = ('%s,%s\n')
batch_format_str = ('Batch Number: %d')
out_file = open(args.save_predictions, 'w')
while step < args.num_batches and not coord.should_stop():
features, urls_values, label_values = sess.run(
[logits, urls1, labels])
for i in range(0, urls_values.shape[0]):
out_file.write(predictions_format_str %
(urls_values[i].decode("utf-8"), ','.join(
map(str, features[i]))))
out_file.flush()
print(batch_format_str % (step, ))
sys.stdout.flush()
step += 1
out_file.close()
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
coord.request_stop()
coord.join(threads)
def main(_):
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
logdir = 'E:\GitHub\MMFI\log\GG12\\CNN'
evaldir = os.path.join(logdir, 'eval')
if not tf.gfile.Exists(evaldir):
# tf.gfile.DeleteRecursively(evaldir)
tf.gfile.MakeDirs(evaldir)
with tf.name_scope('inputs'):
fiber_output, fiber_input, encoder, label = data_loader.read_inputs('valid.txt', False)
with tf.variable_scope('Generator'):
with tf.variable_scope('G1'):
generated_input = pix2pix_G(fiber_output, is_training=False) \
* circle(FLAGS.input_size,FLAGS.input_size)
with tf.variable_scope('G2'):
generated_data = pix2pix_G(generated_input,is_training=False)\
* circle(FLAGS.input_size,FLAGS.input_size)
with tf.name_scope('Valid_summary'):
reshaped_fiber_input = get_summary_image(fiber_input, FLAGS.grid_size)
reshaped_label = get_summary_image(label, FLAGS.grid_size)
reshaped_generated_input = get_summary_image(generated_input, FLAGS.grid_size)
reshaped_generated_data = get_summary_image(generated_data, FLAGS.grid_size)
tf.summary.image('Input_Fiber', reshaped_fiber_input)
tf.summary.image('Input_Generator', reshaped_generated_input)
tf.summary.image('Data_Real', reshaped_label)
tf.summary.image('Data_Generator', reshaped_generated_data)
with tf.name_scope('Valid_op'):
psnr = tf.reduce_mean(tf.image.psnr(generated_data, label, max_val=1.0))
ssim = tf.reduce_mean(tf.image.ssim(generated_data, label, max_val=1.0))
corr = correlation(generated_data, label)
# inception_score = get_inception_score(generated_data)
tf.summary.scalar('PSNR', psnr)
tf.summary.scalar('SSIM', ssim)
tf.summary.scalar('Relation', corr)
grate = tf.ones([1,FLAGS.grid_size*FLAGS.input_size,10,1],dtype=tf.float32)
reshaped_images = tf.concat((reshaped_generated_input, grate,
reshaped_fiber_input, grate,
reshaped_label, grate,
reshaped_generated_data, grate), 2)
uint8_images = tf.cast(reshaped_images*255, tf.uint8)
image_write_ops = tf.write_file('%s/%s' % (evaldir, 'Generator_is_training_False.png'),
tf.image.encode_png(uint8_images[0]))
status_message = tf.string_join([' PSNR: ', tf.as_string(psnr), ' ',
' SSIM: ', tf.as_string(ssim), ' ',
' Correlation: ', tf.as_string(corr)],
name='status_message')
checkpoint_path = tf.train.latest_checkpoint(logdir)
tf.logging.info('Evaluating %s' % checkpoint_path)
tf.contrib.training.evaluate_once(
checkpoint_path,
hooks=[tf.contrib.training.SummaryAtEndHook(evaldir),
tf.contrib.training.StopAfterNEvalsHook(50),
tf.train.LoggingTensorHook([status_message],every_n_iter=5)],
eval_ops=image_write_ops)
def evaluate(args):
# Building the graph
with tf.Graph().as_default() as g, tf.device('/cpu:0'):
# Get images and labels.
images, labels, urls = data_loader.read_inputs(False, args)
# Performing computations on a GPU
with tf.device('/gpu:0'):
# Build a Graph that computes the logits predictions from the
# inference model.
logits = arch.get_model(images, 0.0, False, args)
# Calculate predictions accuracies top-1 and top-5
top1acc = [None] * len(logits)
for i in xrange(0, len(logits)):
top1acc[i] = tf.reduce_mean(
tf.cast(tf.nn.in_top_k(logits[i], labels[:, i], 1),
tf.float32))
# Top-5 ID accuracy
top5acc_id = tf.reduce_mean(
tf.cast(tf.nn.in_top_k(logits[0], labels[:, 0], 5),
tf.float32))
# Top-3 count accuracy
top3acc_cn = tf.reduce_mean(
tf.cast(tf.nn.in_top_k(logits[1], labels[:, 1], 3),
tf.float32))
# The percent of predictions within +/1 bin
one_bin_off_loss = tf.reduce_mean(
tf.cast(
tf.less_equal(
tf.abs(
tf.cast(tf.argmax(logits[1], axis=1), tf.float64) -
tf.cast(labels[:, 1], tf.float64)), 1),
tf.float32))
# Information about the predictions for saving in a file
# Species Identification
top5_id = tf.nn.top_k(tf.nn.softmax(logits[0]), 5)
top5ind_id = top5_id.indices
top5val_id = top5_id.values
# Count
top3_cn = tf.nn.top_k(tf.nn.softmax(logits[1]), 3)
top3ind_cn = top3_cn.indices
top3val_cn = top3_cn.values
# Additional Attributes (e.g. description)
top1_bh = [None] * 6
top1ind_bh = [None] * 6
top1val_bh = [None] * 6
for i in xrange(0, 6):
top1_bh[i] = tf.nn.top_k(tf.nn.softmax(logits[i + 2]), 1)
top1ind_bh[i] = top1_bh[i].indices
top1val_bh[i] = top1_bh[i].values
# Binarizing the additial attributes predictions
binary_behavior_logits = tf.cast([
top1ind_bh[0], top1ind_bh[1], top1ind_bh[2], top1ind_bh[3],
top1ind_bh[4], top1ind_bh[5]
], tf.int32)
# Cast to Boolean
binary_behavior_predictions = tf.squeeze(
tf.cast(binary_behavior_logits, tf.bool))
# Group labels together
binary_behavior_labels_logits = [
labels[:, 2], labels[:, 3], labels[:, 4], labels[:, 5],
labels[:, 6], labels[:, 7]
]
# Cast labels to Boolean
binary_behavior_labels = tf.cast(binary_behavior_labels_logits,
tf.bool)
# Compute the size of label sets (for each image separately)
y_length = tf.reduce_sum(binary_behavior_labels_logits, axis=0)
# Compute the size of prediction sets (for each image separately)
z_length = tf.reduce_sum(binary_behavior_logits, axis=0)
# Compute the union of the labels set and prediction set
union_length = tf.reduce_sum(tf.cast(
tf.logical_or(binary_behavior_labels,
binary_behavior_predictions), tf.int32),
axis=0)
# Compute the intersection of the labels set and prediction set
intersect_length = tf.reduce_sum(tf.cast(
tf.logical_and(binary_behavior_labels,
binary_behavior_predictions), tf.int32),
axis=0)
# For reading the snapshot files from file
saver = tf.train.Saver(tf.global_variables())
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.log_dir, g)
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
ckpt = tf.train.get_checkpoint_state(args.log_dir)
# Load the latest model
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
else:
return
# Start the queue runners.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
true_predictions_count = [
0
] * 8 # Counts the number of correct top-1 predictions
true_top5_predictions_count = 0 # Counts the number of correct top-5 predictions for species identification
true_top3_predictions_count = 0 # Counts the number of correct top-3 predictions for counting
accv_all = 0 # Counts accuracy of additional attributes
prcv_all = 0 # Counts precision of additional attributes
recv_all = 0 # Counts recall of additional attributes
total_examples = 0 # Counts number of total examples
one_bin_off_val = 0
step = 0
predictions_format_str = ('%d,%s,%s,%s,%s,%s,%s,%s,%s]\n')
batch_format_str = (
'Batch Number: %d, Top-1 Accuracy: %s, Top-5 Accuracy: %.3f, Top-3 Accuracy: %.3f, One bin off Loss: %.3f, Accuracy: %.3f, Precision: %.3f, Recall: %.3f'
)
# Output file to save predictions and their confidences
out_file = open(args.save_predictions, 'w')
while step < args.num_batches and not coord.should_stop():
top1_accuracy, top5_accuracy, top3_accuracy, urls_values, label_values, top5guesses_id, top5conf, top3guesses_cn, top3conf, top1guesses_bh, top1conf, obol_val, yval, zval, uval, ival = sess.run(
[
top1acc, top5acc_id, top3acc_cn, urls, labels,
top5ind_id, top5val_id, top3ind_cn, top3val_cn,
top1ind_bh, top1val_bh, one_bin_off_loss, y_length,
z_length, union_length, intersect_length
])
for i in xrange(0, urls_values.shape[0]):
out_file.write(
predictions_format_str %
(step * args.batch_size + i + 1, urls_values[i],
'[' + ', '.join('%d' % np.asscalar(item)
for item in label_values[i]) + ']',
'[' + ', '.join('%d' % np.asscalar(item)
for item in top5guesses_id[i]) + ']',
'[' + ', '.join('%.3f' % np.asscalar(item)
for item in top5conf[i]) + ']',
'[' + ', '.join('%d' % np.asscalar(item)
for item in top3guesses_cn[i]) + ']',
'[' + ', '.join('%.3f' % np.asscalar(item)
for item in top3conf[i]) + ']',
'[' + ', '.join('%d' % np.asscalar(item) for item in [
top1guesses_bh[0][i], top1guesses_bh[1][i],
top1guesses_bh[2][i], top1guesses_bh[3][i],
top1guesses_bh[4][i], top1guesses_bh[5][i]
]) + ']', '[' +
', '.join('%.3f' % np.asscalar(item) for item in [
top1conf[0][i], top1conf[1][i], top1conf[2][i],
top1conf[3][i], top1conf[4][i], top1conf[5][i]
]) + ']'))
out_file.flush()
total_examples += uval.shape[0]
# Computing Accuracy, Precision, and Recall of additional attributes
for i in xrange(0, uval.shape[0]):
if (uval[i] == 0):
# If both the label set and prediction set are empty, it is a correct prediction
accv_all += 1
else:
accv_all += ival[i] / uval[i]
if (np.asscalar(yval[i]) == 0):
# If the lebal set is empty, then recall is 100%
recv_all += 1
else:
recv_all += np.asscalar(ival[i]) / yval[i]
if (zval[i] == 0):
# if The prediction set is empty then precision is 100%
prcv_all += 1
else:
prcv_all += ival[i] / zval[i]
for i in xrange(0, len(logits)):
true_predictions_count[i] += top1_accuracy[i]
true_top5_predictions_count += top5_accuracy
true_top3_predictions_count += top3_accuracy
one_bin_off_val += obol_val
print(
batch_format_str %
(step, '[' + ', '.join('%.3f' % (item / (step + 1.0))
for item in true_predictions_count)
+ ']', true_top5_predictions_count /
(step + 1.0), true_top3_predictions_count /
(step + 1.0), obol_val /
(step + 1.0), accv_all / total_examples,
prcv_all / total_examples, recv_all / total_examples))
sys.stdout.flush()
step += 1
out_file.close()
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
coord.request_stop()
coord.join(threads)
def predict(args):
# Building the graph
with tf.Graph().as_default() as g, tf.device('/cpu:0'):
# Get images
images, urls = data_loader.read_inputs(False, args, False)
# Performing computations on a GPU
with tf.device('/gpu:0'):
# Build a Graph that computes the logits predictions from the
# inference model.
logits = arch.get_model(images, 0.0, False, args)
# Calculate predictions
topn = tf.nn.top_k(tf.nn.softmax(logits), args.top_n)
topnind = topn.indices
topnval = topn.values
saver = tf.train.Saver(tf.global_variables())
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.log_dir, g)
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
ckpt = tf.train.get_checkpoint_state(args.log_dir)
# Load the latest model
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
else:
print('Checkpoint not found: '+args.log_dir)
return
# Start the queue runners.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
step = 0
out_file = open(args.save_predictions,'w')
out_file.write('{')
first_row = True
while step < args.num_batches and not coord.should_stop():
urls_values, topnguesses, topnconf = sess.run([urls, topnind, topnval])
for i in xrange(0,urls_values.shape[0]):
step_result = {
'path': urls_values[i],
'top_n_pred': [int(item) for item in topnguesses[i]],
'top_n_conf': [round(float(item), 4) for item in topnconf[i]]
}
if first_row:
out_file.write('"' + str(int(step*args.batch_size+i+1)) + '":')
first_row = False
else:
out_file.write(',\n"' + str(int(step*args.batch_size+i+1)) + '":')
json.dump(step_result, out_file)
out_file.flush()
print("Finished predicting batch %s / %s" % (step, args.num_batches))
sys.stdout.flush()
step += 1
out_file.write('}')
out_file.close()
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
coord.request_stop()
coord.join(threads)
def evaluate(args):
# Building the graph
with tf.Graph().as_default() as g, tf.device('/cpu:0'):
# Get images and labels
images, labels, urls = data_loader.read_inputs(False, args)
# Performing computations on a GPU
with tf.device('/gpu:0'):
# Build a Graph that computes the logits predictions from the
# inference model.
logits = arch.get_model(images, 0.0, False, args)
# Calculate predictions accuracies top-1 and top-5
top_1_op = tf.nn.in_top_k(logits, labels, 1)
top_n_op = tf.nn.in_top_k(logits, labels, args.top_n)
topn = tf.nn.top_k(tf.nn.softmax(logits), args.top_n)
topnind = topn.indices
topnval = topn.values
saver = tf.train.Saver(tf.global_variables())
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.log_dir, g)
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
ckpt = tf.train.get_checkpoint_state(args.log_dir)
# Load the latest model
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
else:
print('Checkpoint not found: ' + args.log_dir)
return
# Start the queue runners.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
true_predictions_count = 0 # Counts correct predictions
true_topn_predictions_count = 0 # Counts correct top-n predictions
all_count = 0 #Counts all images
step = 0
#predictions_format_str = ('%d;%s;%d;%s;%s\n')
batch_format_str = (
'Batch Number: %d, Top-1 Hit: %d, Top-5 Hit: %d, Top-1 Accuracy: %.3f, Top-5 Accuracy: %.3f'
)
out_file = open(args.save_predictions, 'w')
out_file.write('{')
# out_file.write('id', 'path', 'true', 'top_n_class', 'top_n_conf')
first_row = True
while step < args.num_batches and not coord.should_stop():
top1_predictions, topn_predictions, urls_values, label_values, topnguesses, topnconf = sess.run(
[top_1_op, top_n_op, urls, labels, topnind, topnval])
for i in xrange(0, urls_values.shape[0]):
step_result = {
'path':
urls_values[i],
'true':
int(label_values[i]),
'top_n_pred': [int(item) for item in topnguesses[i]],
'top_n_conf':
[round(float(item), 3) for item in topnconf[i]]
}
if first_row:
out_file.write('"' +
str(int(step * args.batch_size + i +
1)) + '":')
first_row = False
else:
out_file.write(',\n"' +
str(int(step * args.batch_size + i +
1)) + '":')
json.dump(step_result, out_file)
out_file.flush()
true_predictions_count += np.sum(top1_predictions)
true_topn_predictions_count += np.sum(topn_predictions)
all_count += top1_predictions.shape[0]
print(batch_format_str %
(step, true_predictions_count,
true_topn_predictions_count, true_predictions_count /
all_count, true_topn_predictions_count / all_count))
sys.stdout.flush()
step += 1
out_file.write('}')
out_file.close()
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
coord.request_stop()
coord.join(threads)
