def main(argv=None):
np.random.seed(3796)
image, logits, is_training, keep_probability, sess, annotation, train_op, loss, acc, loss_summary, acc_summary, saver, pred_annotation, train_writer = build_session(argv[1])
print("Setting up image reader...")
train_records, valid_records = reader.read_dataset_potsdam_submission(FLAGS.data_dir)
print(len(train_records))
print(len(valid_records))
print("Setting up dataset reader")
image_options = {'resize': False, 'resize_size': IMAGE_SIZE}
if FLAGS.mode == 'train':
train_dataset_reader = dataset.Batch_manager(train_records, image_options)
if FLAGS.mode == "train":
for itr in xrange(MAX_ITERATION):
train_images, train_annotations = train_dataset_reader.next_batch_potsdam(saver, FLAGS.batch_size, image, logits, keep_probability, sess, is_training, FLAGS.logs_dir)
feed_dict = {image: train_images, annotation: train_annotations, keep_probability: 0.5, is_training: True}
tf.set_random_seed(3796 + itr) # get deterministicly random dropouts
sess.run(train_op, feed_dict=feed_dict)
if itr % 50 == 0:
feed_dict = {image: train_images, annotation: train_annotations, keep_probability: 1.0, is_training: False}
train_loss, train_acc, summary_loss, summary_acc = sess.run([loss, acc, loss_summary, acc_summary], feed_dict=feed_dict)
print("Step: %d, Train_loss: %g, Train_acc: %g" % (itr, train_loss, train_acc))
with open(join(FLAGS.logs_dir, 'iter_train_loss.csv'), 'a') as f:
f.write(str(itr) + ',' + str(train_loss) + '\n')
with open(join(FLAGS.logs_dir, 'iter_train_acc.csv'), 'a') as f:
f.write(str(itr) + ',' + str(train_acc) + '\n')
train_writer.add_summary(summary_loss, itr)
train_writer.add_summary(summary_acc, itr)
elif FLAGS.mode == "visualize":
valid_images, valid_annotations = validation_dataset_reader.get_random_batch(FLAGS.batch_size)
pred = sess.run(pred_annotation, feed_dict={image: valid_images, annotation: valid_annotations,
keep_probability: 1.0, is_training: False})
valid_annotations = np.squeeze(valid_annotations, axis=3)
pred = np.squeeze(pred, axis=3)
for itr in range(FLAGS.batch_size):
print(valid_images[itr].astype(np.uint8).shape)
utils.save_image(valid_images[itr, :, :, :3].astype(np.uint8), FLAGS.logs_dir, name="inp_" + str(itr))
print(valid_annotations[itr].astype(np.uint8).shape)
utils.save_image(valid_annotations[itr].astype(np.uint8), FLAGS.logs_dir, name="gt_" + str(itr))
print(pred[itr].astype(np.uint8).shape)
utils.save_image(pred[itr].astype(np.uint8), FLAGS.logs_dir, name="pred_" + str(itr))
print("Saved image: %d" % itr)
def main(argv=None):
np.random.seed(3796)
image, logits, is_training, keep_probability, sess, annotation, train_op, loss, acc, loss_summary, acc_summary, saver, pred_annotation, train_writer, validation_writer = build_session(argv[1])
print("Setting up image reader...")
train_records, valid_records = reader.read_dataset_test(FLAGS.data_dir)
print(len(train_records))
print(len(valid_records))
print("Setting up dataset reader")
image_options = {'resize': False, 'resize_size': IMAGE_SIZE}
if FLAGS.mode == 'train':
train_dataset_reader = dataset.Batch_manager(train_records, image_options)
validation_dataset_reader = dataset.Batch_manager(valid_records, image_options)
""" os.environ["CUDA_VISIBLE_DEVICES"] = argv[1]
keep_probability = tf.placeholder(tf.float32, name="keep_probabilty")
image = tf.placeholder(tf.float32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, 3], name="input_image")
annotation = tf.placeholder(tf.int32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, 1], name="annotation")
pred_annotation, logits = inference(image, keep_probability)
annotation_64 = tf.cast(annotation, dtype=tf.int64)
# calculate accuracy for batch.
cal_acc = tf.equal(pred_annotation, annotation_64)
cal_acc = tf.cast(cal_acc, dtype=tf.int8)
acc = tf.count_nonzero(cal_acc) / (FLAGS.batch_size * IMAGE_SIZE * IMAGE_SIZE)
tf.summary.image("input_image", image, max_outputs=2)
tf.summary.image("ground_truth", tf.cast(annotation, tf.uint8), max_outputs=2)
tf.summary.image("pred_annotation", tf.cast(pred_annotation, tf.uint8), max_outputs=2)
loss = tf.reduce_mean((tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,
labels=tf.squeeze(annotation,
squeeze_dims=[3]),
name="entropy")))
loss_summary=tf.summary.scalar("entropy", loss)
# summary accuracy in tensorboard
acc_summary=tf.summary.scalar("accuracy", acc)
trainable_var = tf.trainable_variables()
if FLAGS.debug:
for var in trainable_var:
utils.add_to_regularization_and_summary(var)
train_op = train(loss, trainable_var)
print("Setting up summary op...")
summary_op = tf.summary.merge_all()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
print("Setting up Saver...")
saver = tf.train.Saver()
# train_writer = tf.summary.FileWriter(FLAGS.logs_dir + '/train', sess.graph)
# validation_writer = tf.summary.FileWriter(FLAGS.logs_dir + '/validation')
sess.run(tf.global_variables_initializer())
ckpt = tf.train.get_checkpoint_state(FLAGS.logs_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print("Model restored...") """
if FLAGS.mode == "train":
for itr in xrange(MAX_ITERATION):
train_images, train_annotations = train_dataset_reader.next_batch(saver, FLAGS.batch_size, image, logits, keep_probability, sess, is_training, FLAGS.logs_dir)
feed_dict = {image: train_images, annotation: train_annotations, keep_probability: 1.0, is_training: True}
tf.set_random_seed(3796 + itr) # get deterministicly random dropouts
sess.run(train_op, feed_dict=feed_dict)
if itr % 50 == 0:
feed_dict = {image: train_images, annotation: train_annotations, keep_probability: 1.0, is_training: False}
train_loss, train_acc, summary_loss, summary_acc = sess.run([loss, acc, loss_summary, acc_summary], feed_dict=feed_dict)
print("Step: %d, Train_loss: %g, Train_acc: %g" % (itr, train_loss, train_acc))
with open(join(FLAGS.logs_dir, 'iter_train_loss.csv'), 'a') as f:
f.write(str(itr) + ',' + str(train_loss) + '\n')
with open(join(FLAGS.logs_dir, 'iter_train_acc.csv'), 'a') as f:
f.write(str(itr) + ',' + str(train_acc) + '\n')
train_writer.add_summary(summary_loss, itr)
train_writer.add_summary(summary_acc, itr)
if itr % 600 == 0:
valid_images, valid_annotations = validation_dataset_reader.next_batch(saver, FLAGS.batch_size, image, logits, keep_probability, sess, is_training, FLAGS.logs_dir, is_validation=True)
valid_loss, valid_acc, summary_loss, summary_acc = sess.run([loss, acc, loss_summary, acc_summary],
feed_dict={image: valid_images, annotation: valid_annotations,
keep_probability: 1.0, is_training: False})
validation_writer.add_summary(summary_loss, itr)
validation_writer.add_summary(summary_acc, itr)
print("%s ---> Validation_loss: %g , Validation Accuracy: %g" % (datetime.datetime.now(), valid_loss, valid_acc))
with open(join(FLAGS.logs_dir, 'iter_val_loss.csv'), 'a') as f:
f.write(str(itr) + ',' + str(valid_loss) + '\n')
with open(join(FLAGS.logs_dir, 'iter_val_acc.csv'), 'a') as f:
f.write(str(itr) + ',' + str(valid_acc) + '\n')
saver.save(sess, FLAGS.logs_dir + "model.ckpt", itr)
elif FLAGS.mode == "visualize":
valid_images, valid_annotations = validation_dataset_reader.get_random_batch(FLAGS.batch_size)
pred = sess.run(pred_annotation, feed_dict={image: valid_images, annotation: valid_annotations,
keep_probability: 1.0, is_training: False})
valid_annotations = np.squeeze(valid_annotations, axis=3)
pred = np.squeeze(pred, axis=3)
for itr in range(FLAGS.batch_size):
print(valid_images[itr].astype(np.uint8).shape)
utils.save_image(valid_images[itr, :, :, :3].astype(np.uint8), FLAGS.logs_dir, name="inp_" + str(itr))
print(valid_annotations[itr].astype(np.uint8).shape)
utils.save_image(valid_annotations[itr].astype(np.uint8), FLAGS.logs_dir, name="gt_" + str(itr))
print(pred[itr].astype(np.uint8).shape)
utils.save_image(pred[itr].astype(np.uint8), FLAGS.logs_dir, name="pred_" + str(itr))
print("Saved image: %d" % itr)
def main(argv=None):
np.random.seed(3796)
net, image, logits, is_training, keep_probability, sess, annotation, train_op, loss, acc, loss_summary, acc_summary, saver, pred_annotation, train_writer, validation_writer = build_session(argv[1])
print("Setting up image reader...")
""" train_records, valid_records = reader.read_dataset_OCR(FLAGS.data_dir)
print(len(train_records))
print(len(valid_records)) """
files = listdir(join(FLAGS.data_dir, 'annotations'))
training_image = files[:int(len(files) * 0.8)]
validation_image = files[int(len(files) * 0.8):]
print("Setting up dataset reader")
image_options = {'resize': False, 'resize_size': IMAGE_SIZE}
if FLAGS.mode == 'train':
train_dataset_reader = dataset.Batch_manager(training_image, FLAGS.data_dir, image_options)
validation_dataset_reader = dataset.Batch_manager(validation_image, FLAGS.data_dir, image_options)
if FLAGS.mode == "train":
for itr in xrange(MAX_ITERATION):
train_images, train_annotations = train_dataset_reader.next_batch(saver, FLAGS.batch_size, image, logits, keep_probability, sess, is_training, FLAGS.logs_dir)
feed_dict = {image: train_images, annotation: train_annotations, keep_probability: 1.0, is_training: True}
tf.set_random_seed(3796 + itr) # get deterministicly random dropouts
""" print('input_tensor:', sess.run(tf.shape(image), feed_dict=feed_dict))
print('pool1:', sess.run(tf.shape(net['pool1']), feed_dict=feed_dict))
print('pool2:', sess.run(tf.shape(net['pool2']), feed_dict=feed_dict))
print('pool3:', sess.run(tf.shape(net['pool3']), feed_dict=feed_dict))
print('pool4:', sess.run(tf.shape(net['pool4']), feed_dict=feed_dict))
print("\nTRAINING:", itr, '\n') """
sess.run(train_op, feed_dict=feed_dict)
if itr % 50 == 0:
feed_dict = {image: train_images, annotation: train_annotations, keep_probability: 1.0, is_training: False}
train_loss, train_acc, summary_loss, summary_acc = sess.run([loss, acc, loss_summary, acc_summary], feed_dict=feed_dict)
print("Step: %d, Train_loss: %g, Train_acc: %g" % (itr, train_loss, train_acc))
with open(join(FLAGS.logs_dir, 'iter_train_loss.csv'), 'a') as f:
f.write(str(itr) + ',' + str(train_loss) + '\n')
with open(join(FLAGS.logs_dir, 'iter_train_acc.csv'), 'a') as f:
f.write(str(itr) + ',' + str(train_acc) + '\n')
train_writer.add_summary(summary_loss, itr)
train_writer.add_summary(summary_acc, itr)
if itr % 500 == 0:
valid_images, valid_annotations = validation_dataset_reader.next_batch(saver, FLAGS.batch_size, image, logits, keep_probability, sess, is_training, FLAGS.logs_dir, is_validation=True)
valid_loss, valid_acc, summary_loss, summary_acc = sess.run([loss, acc, loss_summary, acc_summary],
feed_dict={image: valid_images, annotation: valid_annotations,
keep_probability: 1.0, is_training: False})
validation_writer.add_summary(summary_loss, itr)
validation_writer.add_summary(summary_acc, itr)
print("%s ---> Validation_loss: %g , Validation Accuracy: %g" % (datetime.datetime.now(), valid_loss, valid_acc))
with open(join(FLAGS.logs_dir, 'iter_val_loss.csv'), 'a') as f:
f.write(str(itr) + ',' + str(valid_loss) + '\n')
with open(join(FLAGS.logs_dir, 'iter_val_acc.csv'), 'a') as f:
f.write(str(itr) + ',' + str(valid_acc) + '\n')
# saver.save(sess, FLAGS.logs_dir + "model.ckpt", itr)
elif FLAGS.mode == "visualize":
valid_images, valid_annotations = validation_dataset_reader.get_random_batch(FLAGS.batch_size)
pred = sess.run(pred_annotation, feed_dict={image: valid_images, annotation: valid_annotations,
keep_probability: 1.0, is_training: False})
valid_annotations = np.squeeze(valid_annotations, axis=3)
pred = np.squeeze(pred, axis=3)
for itr in range(FLAGS.batch_size):
print(valid_images[itr].astype(np.uint8).shape)
utils.save_image(valid_images[itr, :, :, :3].astype(np.uint8), FLAGS.logs_dir, name="inp_" + str(itr))
print(valid_annotations[itr].astype(np.uint8).shape)
utils.save_image(valid_annotations[itr].astype(np.uint8), FLAGS.logs_dir, name="gt_" + str(itr))
print(pred[itr].astype(np.uint8).shape)
utils.save_image(pred[itr].astype(np.uint8), FLAGS.logs_dir, name="pred_" + str(itr))
print("Saved image: %d" % itr)
