def test_generate_batch(self):
generator = KittiGenerator(self.dataset_path, self.depth_base,
self.depth_step)
start_time = time.time()
num_set_same_img = 1
batch = generator.validation_batch(multipatch=False,
num_set_same_img=num_set_same_img)
duration = time.time() - start_time
print("PSV Time for batch with %s patches per image: (%.3f sec)" %
(num_set_same_img, duration))
print("Batch shape is -> %s" % str(batch['target'].shape))
# Calculate batch size in bytes to have an approximation of GPU usage
size = sum([batch['planes'][key].nbytes for key in batch['planes']])
print("Batch size: %s bytes" % size)
# Save batch to files
save_to = "/Users/boyander/MASTER_CVC/DepthEstimation/DepthEstimation/batch_test"
print("saving batch: %s" % save_to)
reprojected_images_plot(batch)
#save_batch_images(batch, save_to)
print("Done saving batch!")
def worker_extraction(params, out_queue):
cv2.setNumThreads(-1)
generator = KittiGenerator(params.kitti_path,
params.base_depth,
params.depth_step)
while True:
try:
batch = generator.next_batch(num_set_same_img=params.patches_per_set)
#print("Done extraction, put in queue.")
out_queue.put(batch)
except Exception as e:
print("Extraction Worker Exception: %s" % e)
traceback.print_exc()
def test_meanzero(self):
input_organizer_zero = InputOrganizer(batch_size=self.batch_size,
meanzero=True)
input_organizer_normal = InputOrganizer(batch_size=self.batch_size,
meanzero=False)
generator = KittiGenerator(self.dataset_path, self.depth_base,
self.depth_step)
batch = generator.next_batch(multipatch=True)
b_zero = input_organizer_zero.get_feed_dict([batch])
b_normal = input_organizer_normal.get_feed_dict([batch])
mean_zero = np.mean(
b_zero[input_organizer_zero.get_target_placeholder().name])
mean_normal = np.mean(
b_normal[input_organizer_normal.get_target_placeholder().name])
print("Mean on target is -> (%s for organizer meanzero)"
" (%s for organizer normal)" % (mean_zero, mean_normal))
sub_zero = np.sum(np.subtract(np.abs(mean_zero), np.abs(mean_zero)))
print("Zero substraction is %s" % (sub_zero))
def run_training(FLAGS):
"""Train MNIST for a number of steps."""
sess = None
try:
# Tell TensorFlow that the model will be built into the default Graph.
with tf.Graph().as_default():
# Generate placeholders for the images from all camera
input_organizer = InputOrganizer(batch_size=FLAGS.batch_size,
meanzero=FLAGS.mean_zero,
num_planes=FLAGS.num_planes)
# Build a Graph that computes predictions from the inference model.
net_out = inference(input_organizer,
num_planes=FLAGS.num_planes,
batch_size=FLAGS.batch_size)
print("Graph built! continuing...")
# Add to the Graph the Ops for loss calculation.
loss = lossF(net_out, input_organizer.get_target_placeholder())
# Add to the Graph the Ops that calculate and apply gradients.
print("Learning rate is: %s" % FLAGS.learning_rate)
train_op = training(loss, FLAGS.learning_rate)
# Add the Op to compare the logits to the labels during evaluation.
#eval_correct = evaluation(net_out, input_organizer.get_target_placeholder())
print("Merging summaries continuing...")
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
print("Initialize variables...")
# Add the variable initializer Op.
init = tf.initialize_all_variables()
print("Create a saver for writing training checkpoints...")
# Create a saver for writing training checkpoints.
saver = tf.train.Saver()
print("Starting session...")
# Create a session for running Ops on the Graph.
#sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
print("Creating SummaryWritter...")
git_hash = get_git_revision_short_hash()
summary_name = datetime.now().strftime("%Y_%B_%d_%H_%M_%S")
summary_name = "%s-%s-%s" % (summary_name, socket.gethostname(),
git_hash)
summary_dir = os.path.join(FLAGS.traindir, summary_name)
#os.mkdir(summary_dir)
# Instantiate a SummaryWriter to output summaries and the Graph.
summary_writer = tf.summary.FileWriter(summary_dir, sess.graph)
print("Started SummaryWriter -> %s" % summary_dir)
# And then after everything is built:
# Run the Op to initialize the variables.
sess.run(init)
# read validation batch
print("Starting multiprocessing queue generator...")
# IMPORTANT: Define generator to be used
# Parameters for kitti dataset
kitti_params = KittiParams(FLAGS.kitti_path, FLAGS.depth_base,
FLAGS.depth_step, FLAGS.patches_per_set)
generator = GeneratorQueued(
kitti_params,
input_organizer,
batch_size=FLAGS.batch_size,
extraction_workers=FLAGS.extraction_workers,
aggregation_workers=FLAGS.aggregation_workers)
print("Reading validation batch...")
validation_gene = KittiGenerator(FLAGS.kitti_path,
FLAGS.depth_base,
FLAGS.depth_step)
validation_batch = input_organizer.get_feed_dict([
validation_gene.validation_batch(
num_set_same_img=FLAGS.batch_size)
])
del validation_gene
print("Done reading validation Batch!!")
print(
"Done! Start training loop, validate and save every (%s steps)..."
% FLAGS.validate_step)
# Start the training loop.
max_steps = FLAGS.max_steps
for step in range(max_steps):
# Get images to process in a batch
start_time1 = time.time()
feed_dict = generator.get_batch()
duration_images = time.time() - start_time1
start_time2 = time.time()
# Run one step of the model. The return values are the activations
# from the `train_op` (which is discarded) and the `loss` Op. To
# inspect the values of your Ops or variables, you may include them
# in the list passed to sess.run() and the value tensors will be
# returned in the tuple from the call.
_, loss_value = sess.run([train_op, loss], feed_dict=feed_dict)
duration_net = time.time() - start_time2
print('=== Step %d ===' % step)
# Write the summaries and print an overview fairly often.
if step % FLAGS.print_step == 0:
# Print status to stdout.
print(
'=== Step %d: loss = %.2f -> images:(%.3f sec), net:(%.3f sec) ==='
% (step, loss_value, duration_images, duration_net))
# Update the events file.
summary_str = sess.run(summary_op, feed_dict=feed_dict)
summary_writer.add_summary(summary_str, step)
summary_writer.flush()
# Save a checkpoint every 100 iterations
# and evaluate the model periodically.
if (step + 1) % FLAGS.validate_step == 0 or (step +
1) == max_steps:
print("(Step: %s) Checkpoint, saving model." % step)
checkpoint_file = os.path.join(summary_dir, 'checkpoint')
saver.save(sess, checkpoint_file, global_step=step)
eval_summary = do_eval(
sess, validation_batch, net_out,
input_organizer.get_target_placeholder())
#summary_writer.add_summary(eval_summary, step)
#summary_writer.flush()
except Exception as e:
print("Exception on TRAIN: %s" % e)
traceback.print_exc()
if sess:
sess.close()