tf records generation from labels.npz

examples/utils/building_od.pbtxt

@@ -0,0 +1,4 @@
+item {
+  id: 1
+  name: 'building'
+}

examples/utils/ssd_inception_v2_coco.config

@@ -0,0 +1,191 @@
+# SSD with Inception v2 configuration for MSCOCO Dataset.
+# Users should configure the fine_tune_checkpoint field in the train config as
+# well as the label_map_path and input_path fields in the train_input_reader and
+# eval_input_reader. Search for "PATH_TO_BE_CONFIGURED" to find the fields that
+# should be configured.
+
+model {
+  ssd {
+    num_classes: 90
+    box_coder {
+      faster_rcnn_box_coder {
+        y_scale: 10.0
+        x_scale: 10.0
+        height_scale: 5.0
+        width_scale: 5.0
+      }
+    }
+    matcher {
+      argmax_matcher {
+        matched_threshold: 0.5
+        unmatched_threshold: 0.5
+        ignore_thresholds: false
+        negatives_lower_than_unmatched: true
+        force_match_for_each_row: true
+      }
+    }
+    similarity_calculator {
+      iou_similarity {
+      }
+    }
+    anchor_generator {
+      ssd_anchor_generator {
+        num_layers: 6
+        min_scale: 0.2
+        max_scale: 0.95
+        aspect_ratios: 1.0
+        aspect_ratios: 2.0
+        aspect_ratios: 0.5
+        aspect_ratios: 3.0
+        aspect_ratios: 0.3333
+        reduce_boxes_in_lowest_layer: true
+      }
+    }
+    image_resizer {
+      fixed_shape_resizer {
+        height: 300
+        width: 300
+      }
+    }
+    box_predictor {
+      convolutional_box_predictor {
+        min_depth: 0
+        max_depth: 0
+        num_layers_before_predictor: 0
+        use_dropout: false
+        dropout_keep_probability: 0.8
+        kernel_size: 3
+        box_code_size: 4
+        apply_sigmoid_to_scores: false
+        conv_hyperparams {
+          activation: RELU_6,
+          regularizer {
+            l2_regularizer {
+              weight: 0.00004
+            }
+          }
+          initializer {
+            truncated_normal_initializer {
+              stddev: 0.03
+              mean: 0.0
+            }
+          }
+        }
+      }
+    }
+    feature_extractor {
+      type: 'ssd_inception_v2'
+      min_depth: 16
+      depth_multiplier: 1.0
+      conv_hyperparams {
+        activation: RELU_6,
+        regularizer {
+          l2_regularizer {
+            weight: 0.00004
+          }
+        }
+        initializer {
+          truncated_normal_initializer {
+            stddev: 0.03
+            mean: 0.0
+          }
+        }
+        batch_norm {
+          train: true,
+          scale: true,
+          center: true,
+          decay: 0.9997,
+          epsilon: 0.001,
+        }
+      }
+    }
+    loss {
+      classification_loss {
+        weighted_sigmoid {
+          anchorwise_output: true
+        }
+      }
+      localization_loss {
+        weighted_smooth_l1 {
+          anchorwise_output: true
+        }
+      }
+      hard_example_miner {
+        num_hard_examples: 3000
+        iou_threshold: 0.99
+        loss_type: CLASSIFICATION
+        max_negatives_per_positive: 3
+        min_negatives_per_image: 0
+      }
+      classification_weight: 1.0
+      localization_weight: 1.0
+    }
+    normalize_loss_by_num_matches: true
+    post_processing {
+      batch_non_max_suppression {
+        score_threshold: 1e-8
+        iou_threshold: 0.6
+        max_detections_per_class: 100
+        max_total_detections: 100
+      }
+      score_converter: SIGMOID
+    }
+  }
+}
+
+train_config: {
+  batch_size: 24
+  optimizer {
+    rms_prop_optimizer: {
+      learning_rate: {
+        exponential_decay_learning_rate {
+          initial_learning_rate: 0.004
+          decay_steps: 800720
+          decay_factor: 0.95
+        }
+      }
+      momentum_optimizer_value: 0.9
+      decay: 0.9
+      epsilon: 1.0
+    }
+  }
+  fine_tune_checkpoint: "ssd_inception_v2_coco_2017_11_17/model.ckpt"
+  from_detection_checkpoint: true
+  # Note: The below line limits the training process to 200K steps, which we
+  # empirically found to be sufficient enough to train the pets dataset. This
+  # effectively bypasses the learning rate schedule (the learning rate will
+  # never decay). Remove the below line to train indefinitely.
+  num_steps: 200000
+  data_augmentation_options {
+    random_horizontal_flip {
+    }
+  }
+  data_augmentation_options {
+    ssd_random_crop {
+    }
+  }
+}
+
+train_input_reader: {
+  tf_record_input_reader {
+    input_path: "data/train_buildings.record"
+  }
+  label_map_path: "data/building_od.pbtxt"
+}
+
+eval_config: {
+  num_examples: 8000
+  # Note: The below line limits the evaluation process to 10 evaluations.
+  # Remove the below line to evaluate indefinitely.
+  max_evals: 10
+}
+
+eval_input_reader: {
+  tf_record_input_reader {
+    input_path: "data/test_buildings.record"
+  }
+  label_map_path: "data/building_od.pbtxt"
+  shuffle: false
+  num_readers: 1
+  num_epochs: 1
+}

examples/utils/tf_od_predict.py

@@ -0,0 +1,113 @@
+"""
+This is adapted from Tensorflow (https://github.com/tensorflow/models/tree/master/research/object_detection);
+Save this code under the directory `models/research/object_detection/`
+
+To use, run:
+python tf_od_predict.py --model_name=building_od_ssd \
+                         --path_to_label=data/building_od.pbtxt \
+                         --test_image_path=test_images
+"""
+
+import os
+from os import makedirs, path as op
+import sys
+import glob
+import six.moves.urllib as urllib
+import tensorflow as tf
+import tarfile
+
+from io import StringIO
+import zipfile
+import numpy as np
+from collections import defaultdict
+from matplotlib import pyplot as plt
+from PIL import ImageDraw, Image
+
+sys.path.append("..")
+
+from utils import label_map_util
+from utils import visualization_utils as vis_util
+
+flags = tf.app.flags
+flags.DEFINE_string('model_name', '', 'Path to frozen detection graph')
+flags.DEFINE_string('path_to_label', '', 'Path to label file')
+flags.DEFINE_string('test_image_path', '', 'Path to test imgs and output diractory')
+FLAGS = flags.FLAGS
+
+def load_image_into_numpy_array(image):
+    (im_width, im_height) = image.size
+    return np.array(image.getdata()).reshape((im_height, im_width, 3)).astype(np.uint8)
+
+def tf_od_pred():
+    with detection_graph.as_default():
+        with tf.Session(graph=detection_graph) as sess:
+            # Definite input and output Tensors for detection_graph
+            image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
+            # Each box represents a part of the image where a particular object was detected.
+            detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
+            # Each score represent how level of confidence for each of the objects.
+            # Score is shown on the result image, together with the class label.
+            detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
+            detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
+            num_detections = detection_graph.get_tensor_by_name('num_detections:0')
+    for image_path in test_imgs:
+        image = Image.open(image_path)
+        image_np = load_image_into_numpy_array(image)
+        # the array based representation of the image will be used later in order to prepare the
+        # result image with boxes and labels on it.
+        # Expand dimensions since the model expects images to have shape: [1, None, None, 3]
+        image_np_expanded = np.expand_dims(image_np, axis=0)
+        # Actual detection.
+        (boxes, scores, classes, num) = sess.run(
+          [detection_boxes, detection_scores, detection_classes, num_detections],
+          feed_dict={image_tensor: image_np_expanded})
+         # draw_bounding_box_on_image(image, boxes, )
+         # Visualization of the results of a detection.
+        vis_image = vis_util.visualize_boxes_and_labels_on_image_array(
+                 image_np,
+                 np.squeeze(boxes),
+                 np.squeeze(classes).astype(np.int32),
+                 np.squeeze(scores),
+                 category_index,
+                 use_normalized_coordinates=True,
+                 line_thickness=1)
+        print("{} boxes in {} image tile!".format(len(boxes), image_path))
+        image_pil = Image.fromarray(np.uint8(vis_image)).convert('RGB')
+        with tf.gfile.Open(image_path, 'w') as fid:
+             image_pil.save(fid, 'PNG')
+
+
+
+if __name__ =='__main__':
+    # load your own trained model inference graph. This inference graph was generated from
+    # export_inference_graph.py under model directory, see `models/research/object_detection/`
+    model_name = op.join(os.getcwd(), FLAGS.model_name)
+    # Path to frozen detection graph.
+    path_to_ckpt = op.join(model_name,  'frozen_inference_graph.pb')
+    # Path to the label file
+    path_to_label = op.join(os.getcwd(), FLAGS.path_to_label)
+    #only train on buildings
+    num_classes = 1
+    #Directory to test images path
+    test_image_path = op.join(os.getcwd(), FLAGS.test_image_path)
+    test_imgs = glob.glob(test_image_path + "/*.jpg")
+
+    ############
+    #Load the frozen tensorflow model
+    #############
+
+    detection_graph = tf.Graph()
+    with detection_graph.as_default():
+        od_graph_def = tf.GraphDef()
+        with tf.gfile.GFile(path_to_ckpt, 'rb') as fid:
+            serialized_graph = fid.read()
+            od_graph_def.ParseFromString(serialized_graph)
+            tf.import_graph_def(od_graph_def, name='')
+
+    ############
+    #Load the label file
+    #############
+    label_map = label_map_util.load_labelmap(path_to_label)
+    categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=num_classes, use_display_name=True)
+    category_index = label_map_util.create_category_index(categories)
+    tf_od_pred()