def main(argv=None):
keep_probability = tf.placeholder(tf.float32, name="keep_probabilty")
learning_rate = tf.placeholder(tf.float32, name="learning_rate")
image = tf.placeholder(tf.float32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, 7], name="input_image")
annotation = tf.placeholder(tf.int32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, 1], name="annotation")
pred_annotation_value, pred_annotation, logits = inference(image, keep_probability)
#logits:the last layer of conv net
#labels:the ground truth
at = float(cfgs.at)
a_w = (1- 2*at) * tf.cast(tf.squeeze(annotation, squeeze_dims=[3]), tf.float32) + at
pro = tf.nn.softmax(logits)
loss_weight = tf.pow(1-tf.reduce_sum(pro * tf.one_hot(tf.squeeze(annotation, squeeze_dims=[3]), cfgs.NUM_OF_CLASSESS), 3), cfgs.gamma)
loss = tf.reduce_mean(loss_weight * a_w * tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,
labels=tf.squeeze(annotation, squeeze_dims=[3]),
name="entropy"))
valid_loss = tf.reduce_mean((tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,
labels=tf.squeeze(annotation, squeeze_dims=[3]),
name="valid_entropy")))
tf.summary.scalar("train_loss", loss)
tf.summary.scalar("valid_loss", valid_loss)
tf.summary.scalar("learning_rate", learning_rate)
trainable_var = tf.trainable_variables()
if cfgs.debug:
for var in trainable_var:
utils.add_to_regularization_and_summary(var)
train_op = train(loss, trainable_var, learning_rate)
print("Setting up summary op...")
summary_op = tf.summary.merge_all()
#Check if has the log file
if not os.path.exists(cfgs.logs_dir):
print("The logs path '%s' is not found" % cfgs.logs_dir)
print("Create now..")
os.makedirs(cfgs.logs_dir)
print("%s is created successfully!" % cfgs.logs_dir)
#Create a file to write logs.
#filename='logs'+ cfgs.mode + str(datatime.datatime.now()) + '.txt'
filename="logs_%s%s.txt"%(cfgs.mode,datetime.datetime.now())
path_=os.path.join(cfgs.logs_dir,filename)
with open(path_,'w') as logs_file:
logs_file.write("The logs file is created at %s.\n" % datetime.datetime.now())
logs_file.write("The model is ---%s---.\n" % cfgs.logs_dir)
logs_file.write("The mode is %s\n"% (cfgs.mode))
logs_file.write("The train data batch size is %d and the validation batch size is %d\n."%(cfgs.batch_size,cfgs.v_batch_size))
logs_file.write("The data size is %d and the MAX_ITERATION is %d.\n" % (IMAGE_SIZE, MAX_ITERATION))
logs_file.write("Setting up image reader...")
print("Setting up image reader...")
train_records, valid_records = scene_parsing.my_read_dataset(cfgs.seq_list_path, cfgs.anno_path)
print('number of train_records',len(train_records))
print('number of valid_records',len(valid_records))
with open(path_, 'a') as logs_file:
logs_file.write('number of train_records %d\n' % len(train_records))
logs_file.write('number of valid_records %d\n' % len(valid_records))
path_lr = cfgs.learning_rate_path
with open(path_lr, 'r') as f:
lr_ = float(f.readline().split('\n')[0])
print("Setting up dataset reader")
vis = True if cfgs.mode == 'all_visualize' else False
image_options = {'resize': True, 'resize_size': IMAGE_SIZE, 'visualize': vis, 'annotation':True}
if cfgs.mode == 'train':
train_dataset_reader = dataset.BatchDatset(train_records, image_options)
validation_dataset_reader = dataset.BatchDatset(valid_records, image_options)
#save current train itr from stopping(init = 0)
current_itr_var = tf.Variable(0, dtype=tf.int32, name='current_itr')
sess = tf.Session()
print("Setting up Saver...")
saver = tf.train.Saver()
summary_writer = tf.summary.FileWriter(cfgs.logs_dir, sess.graph)
sess.run(tf.global_variables_initializer())
ckpt = tf.train.get_checkpoint_state(cfgs.logs_dir)
#if not train,restore the model trained before
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print("Model restored...")
num_=0
current_itr = current_itr_var.eval(sess)
print('itr\tmode\tlr_\tacc\tiou_acc\tloss')
time_begin = time.time()
valid_time = 100
for itr in xrange(current_itr, MAX_ITERATION):
with open(path_lr, 'r') as f:
lr_ = float(f.readline().split('\n')[0])
train_images, train_annotations, if_finish, epoch_no= train_dataset_reader.next_batch(cfgs.batch_size)
if if_finish:
print('Epochs%d finished, time comsumed:%.5f' % (epoch_no, time.time()-time_begin))
time_begin = time.time()
feed_dict = {image: train_images, annotation: train_annotations, keep_probability: 0.85, learning_rate: lr_}
sess.run(train_op, feed_dict=feed_dict)
logs_file = open(path_, 'a')
if itr % 10 == 0:
train_loss, summary_str = sess.run([loss, summary_op], feed_dict=feed_dict)
print('%d\t%s\t%g\t%s\t%s\t%.6f' % (itr, 'train',lr_, 'None','None',train_loss))
summary_writer.add_summary(summary_str, itr)
if itr % valid_time == 0:
with open('time_to_valid.txt', 'r') as f:
valid_time = int(f.readline().split('\n')[0])
#Caculate the accurary at the training set.
train_random_images, train_random_annotations = train_dataset_reader.get_random_batch_for_train(cfgs.v_batch_size)
train_loss,train_pred_anno = sess.run([loss,pred_annotation], feed_dict={image:train_random_images,
annotation:train_random_annotations,
keep_probability:1.0})
accu_iou_,accu_pixel_ = accu.caculate_accurary(train_pred_anno, train_random_annotations)
print('%d\t%s\t%g\t%.5f\t%.5f\t%.6f' % (itr, 'train', lr_, accu_pixel_, accu_iou_, train_loss))
#Output the logs.
num_ = num_ + 1
logs_file.write('%d\t%s\t%g\t%.5f\t%.5f\t%.6f\n' % (itr, 'train', lr_, accu_pixel_, accu_iou_, train_loss))
valid_images, valid_annotations, _, _= validation_dataset_reader.next_batch(cfgs.v_batch_size)
#valid_loss = sess.run(loss, feed_dict={image: valid_images, annotation: valid_annotations,
#keep_probability: 1.0})
valid_loss_,pred_anno=sess.run([loss,pred_annotation],feed_dict={image:valid_images,
annotation:valid_annotations,
keep_probability:1.0})
accu_iou,accu_pixel=accu.caculate_accurary(pred_anno,valid_annotations)
print('%d\t%s\t%g\t%.5f\t%.5f\t%.6f' % (itr, 'valid', lr_, accu_pixel, accu_iou, valid_loss_))
#Output the logs.
logs_file.write('%d\t%s\t%g\t%.5f\t%.5f\t%.6f\n' % (itr, 'train', lr_, accu_pixel, accu_iou, valid_loss_))
#record current itr
sess.run(tf.assign(current_itr_var, itr))
saver.save(sess, cfgs.logs_dir + "model.ckpt", itr)
#End the iterator
'''
if itr % 10000 == 0 and itr > 0:
lr_ = lr_/10
print('learning rate change from %g to %g' %(lr_*10, lr_))
logs_file.write('learning rate change from %g to %g\n' %(lr_*10, lr_))'''
logs_file.close()
def main(argv=None):
# define placeholder{keep_probability,image,annotation}
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")
# execute inference then get pred_annotation, logits, and loss
pred_annotation, logits = inference(image, keep_probability)
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")))
tf.summary.scalar("entropy", loss)
trainable_var = tf.trainable_variables()
train_op = train(loss, trainable_var)
print("Setting up summary op...")
summary_op = tf.summary.merge_all()
print("Setting up image reader...")
# Data_zoo/MIT_SceneParsing/
train_records, valid_records = scene_parsing.read_dataset(FLAGS.data_dir)
print(len(train_records))
print(len(valid_records))
print("Setting up dataset reader")
image_options = {'resize': True, 'resize_size': IMAGE_SIZE}
if FLAGS.mode == 'train':
train_dataset_reader = dataset.BatchDatset(train_records,
image_options)
validation_dataset_reader = dataset.BatchDatset(valid_records,
image_options)
sess = tf.Session()
print("Setting up Saver...")
saver = tf.train.Saver()
summary_writer = tf.summary.FileWriter(FLAGS.logs_dir, sess.graph)
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 range(MAX_ITERATION):
train_images, train_annotations = train_dataset_reader.next_batch(
FLAGS.batch_size)
feed_dict = {
image: train_images,
annotation: train_annotations,
keep_probability: 0.85
}
sess.run(train_op, feed_dict=feed_dict)
if itr % 10 == 0:
train_loss, summary_str = sess.run([loss, summary_op],
feed_dict=feed_dict)
print("Step: %d, Train_loss:%g" % (itr, train_loss))
summary_writer.add_summary(summary_str, itr)
if itr % 500 == 0:
valid_images, valid_annotations = validation_dataset_reader.next_batch(
FLAGS.batch_size)
valid_loss = sess.run(loss,
feed_dict={
image: valid_images,
annotation: valid_annotations,
keep_probability: 1.0
})
print("%s ---> Validation_loss: %g" %
(datetime.datetime.now(), valid_loss))
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
})
# single channle
valid_annotations = np.squeeze(valid_annotations, axis=3)
pred = np.squeeze(pred, axis=3)
for itr in range(FLAGS.batch_size):
utils.save_image(valid_images[itr].astype(np.uint8),
FLAGS.logs_dir,
name="inp_" + str(5 + itr))
utils.save_image(valid_annotations[itr].astype(np.uint8),
FLAGS.logs_dir,
name="gt_" + str(5 + itr))
utils.save_image(pred[itr].astype(np.uint8),
FLAGS.logs_dir,
name="pred_" + str(5 + itr))
print("Saved image: %d" % itr)
def get_data_video(self):
with tf.device('/cpu:0'):
self.video_dataset_reader = dataset.BatchDatset(self.valid_records, self.image_options)
def get_data(self):
with tf.device('/cpu:0'):
if self.mode == 'train':
self.train_dataset_reader = dataset.BatchDatset(self.train_records, self.image_options)
self.validation_dataset_reader = dataset.BatchDatset(self.valid_records, self.image_options)
cur_frame = line[cfgs.seq_num + 1].split(' ')[0]
cur_frame_s = cur_frame.split("/")
filename = '%s%s' % (cur_frame_s[len(cur_frame_s) - 3],
os.path.splitext(cur_frame_s[-1])[0])
print(filename)
#anno_frame = os.path.join(anno_folder, filename+'.bmp')
record = {
'current': cur_frame,
'seq': seq_set,
'filename': filename
}
#print(record)
seq_list[directory].append(record)
random.shuffle(seq_list[directory])
no_of_images = len(seq_list[directory])
print('No of %s files %d' % (directory, no_of_images))
return seq_list
if __name__ == '__main__':
training_records, validation_records = my_read_dataset(
cfgs.seq_list_path, cfgs.anno_path)
image_options = {'resize': True, 'resize_size': 224}
train_reader = dataset.BatchDatset(training_records, image_options)
train_reader._read_images()
def main(argv=None):
keep_probability = tf.placeholder(tf.float32, name="keep_probabilty")
image = tf.placeholder(tf.float32,
shape=[None, IMAGE_SIZE, IMAGE_SIZE, 7],
name="input_image")
annotation = tf.placeholder(tf.int32,
shape=[None, IMAGE_SIZE, IMAGE_SIZE, 1],
name="annotation")
pred_annotation_value, pred_annotation, logits, pred_prob = inference(
image, keep_probability)
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)
#logits:the last layer of conv net
#labels:the ground truth
loss = tf.reduce_mean((tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=logits,
labels=tf.squeeze(annotation, squeeze_dims=[3]),
name="entropy")))
tf.summary.scalar("entropy", loss)
trainable_var = tf.trainable_variables()
if cfgs.debug:
for var in trainable_var:
utils.add_to_regularization_and_summary(var)
print("Setting up summary op...")
summary_op = tf.summary.merge_all()
#Create a file to write logs.
#filename='logs'+ cfgs.mode + str(datetime.datetime.now()) + '.txt'
filename = "logs_%s%s.txt" % (cfgs.mode, datetime.datetime.now())
path_ = os.path.join(cfgs.logs_dir, filename)
logs_file = open(path_, 'w')
logs_file.write("The logs file is created at %s\n" %
datetime.datetime.now())
logs_file.write("The mode is %s\n" % (cfgs.mode))
logs_file.write(
"The train data batch size is %d and the validation batch size is %d.\n"
% (cfgs.batch_size, cfgs.v_batch_size))
logs_file.write("The train data is %s.\n" % (cfgs.data_dir))
logs_file.write("The model is ---%s---.\n" % cfgs.logs_dir)
print("Setting up image reader...")
logs_file.write("Setting up image reader...\n")
train_records, valid_records = scene_parsing.my_read_video_dataset(
cfgs.seq_list_path, cfgs.anno_path)
print('number of train_records', len(train_records))
print('number of valid_records', len(valid_records))
logs_file.write('number of train_records %d\n' % len(train_records))
logs_file.write('number of valid_records %d\n' % len(valid_records))
print("Setting up dataset reader")
vis = True if cfgs.mode == 'all_visualize' else False
image_options = {
'resize': True,
'resize_size': IMAGE_SIZE,
'visualize': vis
}
if cfgs.mode == 'train':
train_dataset_reader = dataset.BatchDatset(train_records,
image_options)
validation_dataset_reader = dataset.BatchDatset(valid_records,
image_options)
sess = tf.Session()
print("Setting up Saver...")
saver = tf.train.Saver()
summary_writer = tf.summary.FileWriter(cfgs.logs_dir, sess.graph)
sess.run(tf.global_variables_initializer())
ckpt = tf.train.get_checkpoint_state(cfgs.logs_dir)
#if not train,restore the model trained before
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print("Model restored...")
if cfgs.mode == "accurary":
count = 0
if_con = True
accu_iou_t = 0
accu_pixel_t = 0
while if_con:
count = count + 1
valid_images, valid_annotations, valid_filenames, if_con, start, end = validation_dataset_reader.next_batch_valid(
cfgs.v_batch_size)
valid_loss, pred_anno = sess.run(
[loss, pred_annotation],
feed_dict={
image: valid_images,
annotation: valid_annotations,
keep_probability: 1.0
})
accu_iou, accu_pixel = accu.caculate_accurary(
pred_anno, valid_annotations)
print("Ture %d ---> the data from %d to %d" % (count, start, end))
print("%s ---> Validation_pixel_accuary: %g" %
(datetime.datetime.now(), accu_pixel))
print("%s ---> Validation_iou_accuary: %g" %
(datetime.datetime.now(), accu_iou))
#Output logs.
logs_file.write("Ture %d ---> the data from %d to %d\n" %
(count, start, end))
logs_file.write("%s ---> Validation_pixel_accuary: %g\n" %
(datetime.datetime.now(), accu_pixel))
logs_file.write("%s ---> Validation_iou_accuary: %g\n" %
(datetime.datetime.now(), accu_iou))
accu_iou_t = accu_iou_t + accu_iou
accu_pixel_t = accu_pixel_t + accu_pixel
print("%s ---> Total validation_pixel_accuary: %g" %
(datetime.datetime.now(), accu_pixel_t / count))
print("%s ---> Total validation_iou_accuary: %g" %
(datetime.datetime.now(), accu_iou_t / count))
#Output logs
logs_file.write("%s ---> Total validation_pixel_accurary: %g\n" %
(datetime.datetime.now(), accu_pixel_t / count))
logs_file.write("%s ---> Total validation_iou_accurary: %g\n" %
(datetime.datetime.now(), accu_iou_t / count))
elif cfgs.mode == "all_visualize":
re_save_dir = "%s%s" % (cfgs.result_dir, datetime.datetime.now())
logs_file.write("The result is save at file'%s'.\n" % re_save_dir)
logs_file.write("The number of part visualization is %d.\n" %
cfgs.v_batch_size)
#Check the result path if exists.
if not os.path.exists(re_save_dir):
print("The path '%s' is not found." % re_save_dir)
print("Create now ...")
os.makedirs(re_save_dir)
print("Create '%s' successfully." % re_save_dir)
logs_file.write("Create '%s' successfully.\n" % re_save_dir)
re_save_dir_im = os.path.join(re_save_dir, 'images')
re_save_dir_heat = os.path.join(re_save_dir, 'heatmap')
re_save_dir_ellip = os.path.join(re_save_dir, 'ellip')
re_save_dir_transheat = os.path.join(re_save_dir, 'transheat')
if not os.path.exists(re_save_dir_im):
os.makedirs(re_save_dir_im)
if not os.path.exists(re_save_dir_heat):
os.makedirs(re_save_dir_heat)
if not os.path.exists(re_save_dir_ellip):
os.makedirs(re_save_dir_ellip)
if not os.path.exists(re_save_dir_transheat):
os.makedirs(re_save_dir_transheat)
count = 0
if_con = True
accu_iou_t = 0
accu_pixel_t = 0
while if_con:
count = count + 1
valid_images, valid_filename, valid_cur_images, if_con, start, end = validation_dataset_reader.next_batch_video_valid(
cfgs.v_batch_size)
pred_value, pred, logits_, pred_prob_ = sess.run(
[pred_annotation_value, pred_annotation, logits, pred_prob],
feed_dict={
image: valid_images,
keep_probability: 1.0
})
print("Turn %d :----start from %d ------- to %d" %
(count, start, end))
pred = np.squeeze(pred, axis=3)
pred_value = np.squeeze(pred_value, axis=3)
for itr in range(len(pred)):
filename = valid_filename[itr]['filename']
valid_images_ = pred_visualize(valid_cur_images[itr].copy(),
pred[itr])
utils.save_image(valid_images_.astype(np.uint8),
re_save_dir_im,
name="inp_" + filename)
if cfgs.fit_ellip:
#valid_images_ellip=fit_ellipse_findContours_ori(valid_images[itr].copy(),np.expand_dims(pred[itr],axis=2).astype(np.uint8))
valid_images_ellip = fit_ellipse_findContours(
valid_cur_images[itr].copy(),
np.expand_dims(pred[itr], axis=2).astype(np.uint8))
utils.save_image(valid_images_ellip.astype(np.uint8),
re_save_dir_ellip,
name="ellip_" + filename)
if cfgs.heatmap:
heat_map = density_heatmap(pred_prob_[itr, :, :, 1])
utils.save_image(heat_map.astype(np.uint8),
re_save_dir_heat,
name="heat_" + filename)
if cfgs.trans_heat:
trans_heat_map = translucent_heatmap(
valid_cur_images[itr],
heat_map.astype(np.uint8).copy())
utils.save_image(trans_heat_map,
re_save_dir_transheat,
name="trans_heat_" + filename)
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()
print("Setting up image reader...")
train_records, valid_records = scene_parsing.read_dataset(FLAGS.data_dir)
print(len(train_records))
print(len(valid_records))
print("Setting up dataset reader")
image_options = {'resize': True, 'resize_size': IMAGE_SIZE}
if FLAGS.mode == 'train':
train_dataset_reader = dataset.BatchDatset(train_records, image_options)
validation_dataset_reader = dataset.BatchDatset(valid_records, image_options)
sess = tf.Session()
print("Setting up Saver...")
saver = tf.train.Saver( max_to_keep=10)
summary_writer = tf.summary.FileWriter(FLAGS.logs_dir+'/train', sess.graph)
# tval_summary_writer = tf.summary.FileWriter(FLAGS.logs_dir + '/val', sess.graph)
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...")