def main(_): data_dir = FLAGS.data_dir mode = FLAGS.mode assert mode in ["train", "val"] print "Generate data for model {}!".format(mode) label_map_dict = dataset_util.get_label_map_dict(FLAGS.label_map_path) image_dir = os.path.join(data_dir, 'JPEGImages') annotations_dir = os.path.join(data_dir, 'Annotations') # Test images are not included in the downloaded data set, so we shall perform # our own split. # random.seed(42) # random.shuffle(examples_list) # num_examples = len(examples_list) # num_train = int(num_examples) # train_examples = examples_list[:num_train] if not os.path.exists(FLAGS.output_dir): os.makedirs(FLAGS.output_dir) if mode == 'train': examples_path = os.path.join(data_dir, 'ImageSets/Main/trainval.txt') examples_list = dataset_util.read_examples_list(examples_path) print '{} training examples.', len(examples_list) train_output_path = os.path.join(FLAGS.output_dir, 'train.record') create_tf_record(train_output_path, label_map_dict, annotations_dir, image_dir, examples_list) elif mode == 'val': examples_path = os.path.join(data_dir, 'ImageSets/Main/val.txt') examples_list = dataset_util.read_examples_list(examples_path) print '{} validation examples.', len(examples_list) val_output_path = os.path.join(FLAGS.output_dir, 'val.record') create_tf_record(val_output_path, label_map_dict, annotations_dir, image_dir, examples_list)
def main(_): if FLAGS.set not in SETS: raise ValueError('set must be in : {}'.format(SETS)) if FLAGS.year not in YEARS: raise ValueError('year must be in : {}'.format(YEARS)) data_dir = FLAGS.data_dir years = ['VOC2012'] if FLAGS.year != 'merged': years = [FLAGS.year] #writer = tf.python_io.TFRecordWriter(FLAGS.output_path) #label_map_dict = label_map_util.get_label_map_dict(FLAGS.label_map_path) for year in years: logging.info('Reading from PASCAL %s dataset.', year) panoptic_path = os.path.join(data_dir, year, 'panoptic_train.txt') #examples_path = os.path.join(data_dir, year, 'ImageSets', 'Main', # 'aeroplane_' + FLAGS.set + '.txt') annotations_dir = os.path.join(data_dir, year, FLAGS.annotations_dir) examples_list = dataset_util.read_examples_list(panoptic_path) #print(len(examples_list), examples_list[:10]) for idx, example in enumerate(examples_list): if idx % 100 == 0: logging.info('On image %d of %d', idx, len(examples_list)) path = os.path.join(annotations_dir, example + '.xml')
def main(_): if FLAGS.set not in SETS: raise ValueError('set must be in : {}'.format(SETS)) data_dir = FLAGS.data_dir label_map_path = os.path.join(data_dir, "labels.pbtxt") examples_path = os.path.join(data_dir, "files.txt") annotations_dir = os.path.join(data_dir, "annotations") label_map_dict = label_map_util.get_label_map_dict(label_map_path) examples_list = dataset_util.read_examples_list(examples_path) writer = tf.python_io.TFRecordWriter(FLAGS.output_path) for idx, example in enumerate(examples_list): if idx % 100 == 0: logging.info('On image %d of %d', idx, len(examples_list)) path = os.path.join(annotations_dir, example + '.xml') with tf.gfile.GFile(path, 'r') as fid: xml_str = fid.read() xml = etree.fromstring(xml_str) data = dataset_util.recursive_parse_xml_to_dict(xml)['annotation'] tf_example = dict_to_tf_example(data, FLAGS.data_dir, label_map_dict, FLAGS.ignore_difficult_instances) writer.write(tf_example.SerializeToString()) writer.close()
def main(_): data_dir = FLAGS.data_dir label_map_dict = label_map_util.get_label_map_dict(FLAGS.label_map_path) logging.info('Reading from dataset.') image_dir = os.path.join(data_dir, 'images') annotations_dir = os.path.join(data_dir, 'annotations') examples_path = os.path.join(annotations_dir, 'trainval.txt') examples_list = dataset_util.read_examples_list(examples_path) # Test images are not included in the downloaded data set, so we shall perform # our own split. random.seed(42) random.shuffle(examples_list) num_examples = len(examples_list) num_train = int(0.7 * num_examples) train_examples = examples_list[:num_train] val_examples = examples_list[num_train:] logging.info('%d training and %d validation examples.', len(train_examples), len(val_examples)) train_output_path = os.path.join(FLAGS.output_dir, 'train.record') val_output_path = os.path.join(FLAGS.output_dir, 'val.record') create_tf_record(train_output_path, label_map_dict, annotations_dir, image_dir, train_examples) create_tf_record(val_output_path, label_map_dict, annotations_dir, image_dir, val_examples)
def main(_): if FLAGS.set not in SETS: raise ValueError('set must be in : {}'.format(SETS)) data_dir = FLAGS.data_dir writer = tf.python_io.TFRecordWriter(FLAGS.output_path) all_boxes = [] all_small_boxes_count = 0 logging.info('Reading from Ferrari dataset.') examples_path = os.path.join(data_dir, 'training_split_files', FLAGS.set + '.txt') annotations_dir = os.path.join(data_dir, 'SSD_Training_Data', FLAGS.annotations_dir) examples_list = dataset_util.read_examples_list(examples_path) for idx, example in enumerate(examples_list): if idx % 100 == 0: logging.info('On image %d of %d', idx, len(examples_list)) path = os.path.join(annotations_dir, example + '.xml') try: path = path.replace('.mp4', '_mp4') with tf.gfile.GFile(path, 'rb') as fid: xml_str = fid.read() except: import ipdb ipdb.set_trace() try: xml = etree.fromstring(xml_str) except: import ipdb ipdb.set_trace() data = dataset_util.recursive_parse_xml_to_dict(xml)['annotation'] tf_example, boxes, small_boxes_count = dict_to_tf_example( data, FLAGS.data_dir, FLAGS.ignore_difficult_instances) writer.write(tf_example.SerializeToString()) all_boxes += boxes all_small_boxes_count += small_boxes_count writer.close() import ipdb ipdb.set_trace() with open('{}_all_boxes.pkl'.format(FLAGS.set), 'wb') as f: pickle.dump(all_boxes, f)
def proccess(set_path, output_path): writer = tf.python_io.TFRecordWriter(output_path) label_map_dict = get_label_map_dict_from_json(label_map_path) examples_path = set_path examples_list = dataset_util.read_examples_list(examples_path) for idx, example in enumerate(examples_list): if idx % 100 == 0: logging.info('On image %d of %d', idx, len(examples_list)) path = os.path.join(annotations_dir, example + '.xml') with tf.gfile.GFile(path, 'r') as fid: xml = ET.parse(fid).getroot() data = dataset_util.recursive_parse_xml_to_dict(xml)['annotation'] tf_example = dict_to_tf_example(path, data, images_dir, label_map_dict, FLAGS.ignore_difficult_instances) writer.write(tf_example.SerializeToString()) writer.close()
def main(_): if FLAGS.year not in YEARS: raise ValueError('year must be in : {}'.format(YEARS)) data_dir = FLAGS.data_dir years = ['VOC2007', 'VOC2012'] if FLAGS.year != 'merged': years = [FLAGS.year] output_dir = FLAGS.output_dir if not os.path.exists(output_dir): os.makedirs(output_dir) for year in years: for split in SETS: filename = os.path.join(output_dir, '{}_{}.tfrecord'.format(year, split)) if os.path.exists(filename): if FLAGS.overwrite or os.path.getsize(filename) == 0: os.remove(filename) else: print('skipped %s.' % filename) continue writer = tf.python_io.TFRecordWriter(filename) print('Reading from PASCAL %s %s dataset.' % (year, split)) examples_path = os.path.join(data_dir, year, 'ImageSets', 'Main', split + '.txt') annotations_dir = os.path.join(data_dir, year, 'Annotations') examples_list = dataset_util.read_examples_list(examples_path) for example in tqdm(examples_list): try: path = os.path.join(annotations_dir, example + '.xml') with tf.gfile.GFile(path, 'r') as fid: xml_str = fid.read() xml = etree.fromstring(xml_str) data = dataset_util.recursive_parse_xml_to_dict( xml)['annotation'] tf_example = dict_to_tf_example( data, FLAGS.data_dir, FLAGS.ignore_difficult_instances) writer.write(tf_example.SerializeToString()) except Exception as e: print(str(e)) writer.close()
def main(year, data_dir, annotations_dir, set, ignore_difficult_instances): if set not in SETS: raise ValueError('set must be in : {}'.format(SETS)) if year not in YEARS: raise ValueError('year must be in : {}'.format(YEARS)) data_dir = data_dir years = ['VOC2007', 'VOC2012'] if year != 'merged': years = [year] writer = tf.python_io.TFRecordWriter(output_path) label_map_dict = label_map_util.get_label_map_dict(label_map_path) for year in years: logging.info('Reading from PASCAL %s dataset.', year) examples_path = os.path.join(data_dir, year, 'ImageSets', 'Main', set + '.txt') # annotations_dir = os.path.join(data_dir, year, annotations_dir) annotations_dir = annotations_dir examples_list = dataset_util.read_examples_list(examples_path) for idx, example in enumerate(examples_list): if idx % 100 == 0: logging.info('On image %d of %d', idx, len(examples_list)) path = os.path.join(annotations_dir, example + '.xml') with tf.gfile.GFile(path, 'r') as fid: xml_str = fid.read() # xml = etree.fromstring(xml_str) xml = etree.fromstring(xml_str.encode('utf-8')) data = dataset_util.recursive_parse_xml_to_dict(xml)['annotation'] tf_example = dict_to_tf_example(year, data, data_dir, label_map_dict, example, ignore_difficult_instances) writer.write(tf_example.SerializeToString()) writer.close()
def main(_): if FLAGS.set not in SETS: raise ValueError('set must be in : {}'.format(SETS)) # if FLAGS.year not in YEARS: # raise ValueError('year must be in : {}'.format(YEARS)) data_dir = FLAGS.data_dir # years = ['VOC2007', 'VOC2012'] # if FLAGS.year != 'merged': # years = [FLAGS.year] writer = tf.python_io.TFRecordWriter(FLAGS.output_path) label_map_dict = get_label_map_dict(FLAGS.label_map_path) for year in range(1): logging.info('Reading from PASCAL-like customized dataset.') examples_path = os.path.join(data_dir, 'ImageSets', 'Main', FLAGS.set + '.txt') annotations_dir = os.path.join(data_dir, FLAGS.annotations_dir) examples_list = dataset_util.read_examples_list(examples_path) for idx, example in enumerate(examples_list): if idx % 100 == 0: logging.info('On image %d of %d', idx, len(examples_list)) path = os.path.join(annotations_dir, example + '.xml') with tf.gfile.GFile(path, 'r') as fid: xml_str = fid.read() xml = etree.fromstring(xml_str) data = dataset_util.recursive_parse_xml_to_dict(xml)['annotation'] tf_example = dict_to_tf_example(data, FLAGS.data_dir, label_map_dict, FLAGS.ignore_difficult_instances) writer.write(tf_example.SerializeToString()) writer.close()
def main(unused_argv): # Using the Winograd non-fused algorithms provides a small performance boost. os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '1' pred_hooks = None if FLAGS.debug: debug_hook = tf_debug.LocalCLIDebugHook() pred_hooks = [debug_hook] model = tf.estimator.Estimator( model_fn=mymodel.network_model_fn, model_dir=FLAGS.model_dir, params={ 'output_stride': FLAGS.output_stride, 'batch_size': 4, # Batch size must be 1 because the images' size may differ 'base_architecture': FLAGS.base_architecture, 'pre_trained_model': None, 'batch_norm_decay': None, 'num_classes': _NUM_CLASSES, }) examples = dataset_util.read_examples_list(FLAGS.infer_data_list) image_files = [ os.path.join(FLAGS.data_dir, filename) + '.png' for filename in examples ] region_files = [ os.path.join(FLAGS.region_data_dir, filename) + '.png' for filename in examples ] predictions = model.predict(input_fn=lambda: preprocessing.eval_input_fn( image_files, region_files), hooks=pred_hooks) output_dir = FLAGS.output_dir if not os.path.exists(output_dir): os.makedirs(output_dir) for pred_dict, image_path in zip(predictions, image_files): image_basename = os.path.splitext(os.path.basename(image_path))[0] output_filename = image_basename + '.png' path_to_output = os.path.join(output_dir, output_filename) print("generating:", path_to_output) mask = pred_dict['decoded_labels'] mask = Image.fromarray(mask) fig, ax = plt.subplots() #mask = mask[:, :, (2, 1, 0)] ax.imshow(mask, aspect='equal') plt.axis('off') # 去除图像周围的白边 # 如果dpi=300,那么图像大小=height*width fig.set_size_inches(321 / 300.0, 321 / 300.0) plt.gca().xaxis.set_major_locator(plt.NullLocator()) plt.gca().yaxis.set_major_locator(plt.NullLocator()) plt.subplots_adjust(top=1, bottom=0, left=0, right=1, hspace=0, wspace=0) plt.margins(0, 0) plt.savefig(path_to_output, dpi=300) """ plt.axis('off')
def main(unused_argv): # Using the Winograd non-fused algorithms provides a small performance boost. os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '1' os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = "3" examples = dataset_util.read_examples_list(FLAGS.evaluation_data_list) image_files = [os.path.join(FLAGS.image_data_dir, filename) + '.png' for filename in examples] region_files = [os.path.join(FLAGS.region_data_dir, filename) + '.png' for filename in examples] label_files = [os.path.join(FLAGS.label_data_dir, filename) + '.png' for filename in examples] features,labels = preprocessing.eval_input_fn(image_files,region_files,label_files) predictions = mymodel.network_model_fn( features, labels, tf.estimator.ModeKeys.EVAL, params={ 'output_stride': FLAGS.output_stride, 'batch_size': 8, # Batch size must be 1 because the images' size may differ 'base_architecture': FLAGS.base_architecture, 'pre_trained_model': None, 'batch_norm_decay': None, 'num_classes': _NUM_CLASSES, 'freeze_batch_norm': True }).predictions # Manually load the latest checkpoint saver = tf.train.Saver() with tf.Session() as sess: ckpt = tf.train.get_checkpoint_state(FLAGS.model_dir) saver.restore(sess, ckpt.model_checkpoint_path) # Loop through the batches and store predictions and labels step = 1 sum_cm = np.zeros((_NUM_CLASSES, _NUM_CLASSES), dtype=np.int32) start = timeit.default_timer() while True: try: preds = sess.run(predictions) sum_cm += preds['confusion_matrix'] if not step % 100: stop = timeit.default_timer() tf.logging.info("current step = {} ({:.3f} sec)".format(step, stop-start)) start = timeit.default_timer() step += 1 except tf.errors.OutOfRangeError: break def compute_mean_iou(total_cm): """Compute the mean intersection-over-union via the confusion matrix.""" sum_over_row = np.sum(total_cm, axis=0).astype(float) sum_over_col = np.sum(total_cm, axis=1).astype(float) cm_diag = np.diagonal(total_cm).astype(float) denominator = sum_over_row + sum_over_col - cm_diag # The mean is only computed over classes that appear in the # label or prediction tensor. If the denominator is 0, we need to # ignore the class. num_valid_entries = np.sum((denominator != 0).astype(float)) # If the value of the denominator is 0, set it to 1 to avoid # zero division. denominator = np.where( denominator > 0, denominator, np.ones_like(denominator)) ious = cm_diag / denominator print('Intersection over Union for each class:') for i, iou in enumerate(ious): print(' class {}: {:.4f}'.format(i, iou)) # If the number of valid entries is 0 (no classes) we return 0. m_iou = np.where( num_valid_entries > 0, np.sum(ious) / num_valid_entries, 0) m_iou = float(m_iou) print('mean Intersection over Union: {:.4f}'.format(float(m_iou))) def compute_accuracy(total_cm): """Compute the accuracy via the confusion matrix.""" denominator = total_cm.sum().astype(float) cm_diag_sum = np.diagonal(total_cm).sum().astype(float) # If the number of valid entries is 0 (no classes) we return 0. accuracy = np.where( denominator > 0, cm_diag_sum / denominator, 0) accuracy = float(accuracy) print('Pixel Accuracy: {:.4f}'.format(float(accuracy))) compute_mean_iou(sum_cm) compute_accuracy(sum_cm)
def main(unused_argv): # Using the Winograd non-fused algorithms provides a small performance boost. os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '1' pred_hooks = None if FLAGS.debug: debug_hook = tf_debug.LocalCLIDebugHook() pred_hooks = [debug_hook] model = tf.estimator.Estimator( model_fn=deeplabv3plus_hed_model.deeplabv3_plus_model_fn, model_dir=FLAGS.model_dir, params={ 'output_stride': FLAGS.output_stride, 'batch_size': 1, # Batch size must be 1 because the images' size may differ 'base_architecture': FLAGS.base_architecture, 'pre_trained_model': None, 'batch_norm_decay': None, 'num_classes': _NUM_CLASSES, }) examples = dataset_util.read_examples_list(FLAGS.infer_data_list) image_files = [ os.path.join(FLAGS.data_dir, filename) for filename in examples ] predictions = model.predict( input_fn=lambda: preprocessing.eval_input_fn(image_files), hooks=pred_hooks) output_dir = FLAGS.output_dir if not os.path.exists(output_dir): os.makedirs(output_dir) for pred_dict, image_path in zip(predictions, image_files): image_basename = os.path.splitext(os.path.basename(image_path))[0] output_filename = image_basename + '.jpg' path_to_output = os.path.join(output_dir, output_filename) print("generating:", path_to_output) mask = pred_dict['decoded_labels'] raw_mask = pred_dict['classes'] cv2.imwrite(os.path.join(output_dir, image_basename + '.png'), raw_mask) side1_mask = pred_dict['side_output1'] cv2.imwrite(os.path.join(output_dir, image_basename + '_side1.png'), side1_mask) side2_mask = pred_dict['side_output2'] cv2.imwrite(os.path.join(output_dir, image_basename + '_side2.png'), side2_mask) side3_mask = pred_dict['side_output3'] cv2.imwrite(os.path.join(output_dir, image_basename + '_side3.png'), side3_mask) side4_mask = pred_dict['side_output4'] cv2.imwrite(os.path.join(output_dir, image_basename + '_side4.png'), side4_mask) side5_mask = pred_dict['side_output5'] cv2.imwrite(os.path.join(output_dir, image_basename + '_side5.png'), side5_mask) side_fuse_mask = pred_dict['side_output_fuse'] cv2.imwrite( os.path.join(output_dir, image_basename + '_side_fuse.png'), side_fuse_mask) #pdb.set_trace() #np.save(os.path.join(output_dir,image_basename+'.npy'),pred_dict['probabilities']) #pdb.set_trace() mask = Image.fromarray(mask) #pdb.set_trace() mask.save(path_to_output)