diff --git a/reconnaissance images/object_detection/data/mscoco_label_map.pbtxt b/reconnaissance images/object_detection/data/mscoco_label_map.pbtxt
new file mode 100644
index 0000000..1f4872b
--- /dev/null
+++ b/reconnaissance images/object_detection/data/mscoco_label_map.pbtxt	
@@ -0,0 +1,400 @@
+item {
+  name: "/m/01g317"
+  id: 1
+  display_name: "person"
+}
+item {
+  name: "/m/0199g"
+  id: 2
+  display_name: "bicycle"
+}
+item {
+  name: "/m/0k4j"
+  id: 3
+  display_name: "car"
+}
+item {
+  name: "/m/04_sv"
+  id: 4
+  display_name: "motorcycle"
+}
+item {
+  name: "/m/05czz6l"
+  id: 5
+  display_name: "airplane"
+}
+item {
+  name: "/m/01bjv"
+  id: 6
+  display_name: "bus"
+}
+item {
+  name: "/m/07jdr"
+  id: 7
+  display_name: "train"
+}
+item {
+  name: "/m/07r04"
+  id: 8
+  display_name: "truck"
+}
+item {
+  name: "/m/019jd"
+  id: 9
+  display_name: "boat"
+}
+item {
+  name: "/m/015qff"
+  id: 10
+  display_name: "traffic light"
+}
+item {
+  name: "/m/01pns0"
+  id: 11
+  display_name: "fire hydrant"
+}
+item {
+  name: "/m/02pv19"
+  id: 13
+  display_name: "stop sign"
+}
+item {
+  name: "/m/015qbp"
+  id: 14
+  display_name: "parking meter"
+}
+item {
+  name: "/m/0cvnqh"
+  id: 15
+  display_name: "bench"
+}
+item {
+  name: "/m/015p6"
+  id: 16
+  display_name: "bird"
+}
+item {
+  name: "/m/01yrx"
+  id: 17
+  display_name: "cat"
+}
+item {
+  name: "/m/0bt9lr"
+  id: 18
+  display_name: "dog"
+}
+item {
+  name: "/m/03k3r"
+  id: 19
+  display_name: "horse"
+}
+item {
+  name: "/m/07bgp"
+  id: 20
+  display_name: "sheep"
+}
+item {
+  name: "/m/01xq0k1"
+  id: 21
+  display_name: "cow"
+}
+item {
+  name: "/m/0bwd_0j"
+  id: 22
+  display_name: "elephant"
+}
+item {
+  name: "/m/01dws"
+  id: 23
+  display_name: "bear"
+}
+item {
+  name: "/m/0898b"
+  id: 24
+  display_name: "zebra"
+}
+item {
+  name: "/m/03bk1"
+  id: 25
+  display_name: "giraffe"
+}
+item {
+  name: "/m/01940j"
+  id: 27
+  display_name: "backpack"
+}
+item {
+  name: "/m/0hnnb"
+  id: 28
+  display_name: "umbrella"
+}
+item {
+  name: "/m/080hkjn"
+  id: 31
+  display_name: "handbag"
+}
+item {
+  name: "/m/01rkbr"
+  id: 32
+  display_name: "tie"
+}
+item {
+  name: "/m/01s55n"
+  id: 33
+  display_name: "suitcase"
+}
+item {
+  name: "/m/02wmf"
+  id: 34
+  display_name: "frisbee"
+}
+item {
+  name: "/m/071p9"
+  id: 35
+  display_name: "skis"
+}
+item {
+  name: "/m/06__v"
+  id: 36
+  display_name: "snowboard"
+}
+item {
+  name: "/m/018xm"
+  id: 37
+  display_name: "sports ball"
+}
+item {
+  name: "/m/02zt3"
+  id: 38
+  display_name: "kite"
+}
+item {
+  name: "/m/03g8mr"
+  id: 39
+  display_name: "baseball bat"
+}
+item {
+  name: "/m/03grzl"
+  id: 40
+  display_name: "baseball glove"
+}
+item {
+  name: "/m/06_fw"
+  id: 41
+  display_name: "skateboard"
+}
+item {
+  name: "/m/019w40"
+  id: 42
+  display_name: "surfboard"
+}
+item {
+  name: "/m/0dv9c"
+  id: 43
+  display_name: "tennis racket"
+}
+item {
+  name: "/m/04dr76w"
+  id: 44
+  display_name: "bottle"
+}
+item {
+  name: "/m/09tvcd"
+  id: 46
+  display_name: "wine glass"
+}
+item {
+  name: "/m/08gqpm"
+  id: 47
+  display_name: "cup"
+}
+item {
+  name: "/m/0dt3t"
+  id: 48
+  display_name: "fork"
+}
+item {
+  name: "/m/04ctx"
+  id: 49
+  display_name: "knife"
+}
+item {
+  name: "/m/0cmx8"
+  id: 50
+  display_name: "spoon"
+}
+item {
+  name: "/m/04kkgm"
+  id: 51
+  display_name: "bowl"
+}
+item {
+  name: "/m/09qck"
+  id: 52
+  display_name: "banana"
+}
+item {
+  name: "/m/014j1m"
+  id: 53
+  display_name: "apple"
+}
+item {
+  name: "/m/0l515"
+  id: 54
+  display_name: "sandwich"
+}
+item {
+  name: "/m/0cyhj_"
+  id: 55
+  display_name: "orange"
+}
+item {
+  name: "/m/0hkxq"
+  id: 56
+  display_name: "broccoli"
+}
+item {
+  name: "/m/0fj52s"
+  id: 57
+  display_name: "carrot"
+}
+item {
+  name: "/m/01b9xk"
+  id: 58
+  display_name: "hot dog"
+}
+item {
+  name: "/m/0663v"
+  id: 59
+  display_name: "pizza"
+}
+item {
+  name: "/m/0jy4k"
+  id: 60
+  display_name: "donut"
+}
+item {
+  name: "/m/0fszt"
+  id: 61
+  display_name: "cake"
+}
+item {
+  name: "/m/01mzpv"
+  id: 62
+  display_name: "chair"
+}
+item {
+  name: "/m/02crq1"
+  id: 63
+  display_name: "couch"
+}
+item {
+  name: "/m/03fp41"
+  id: 64
+  display_name: "potted plant"
+}
+item {
+  name: "/m/03ssj5"
+  id: 65
+  display_name: "bed"
+}
+item {
+  name: "/m/04bcr3"
+  id: 67
+  display_name: "dining table"
+}
+item {
+  name: "/m/09g1w"
+  id: 70
+  display_name: "toilet"
+}
+item {
+  name: "/m/07c52"
+  id: 72
+  display_name: "tv"
+}
+item {
+  name: "/m/01c648"
+  id: 73
+  display_name: "laptop"
+}
+item {
+  name: "/m/020lf"
+  id: 74
+  display_name: "mouse"
+}
+item {
+  name: "/m/0qjjc"
+  id: 75
+  display_name: "remote"
+}
+item {
+  name: "/m/01m2v"
+  id: 76
+  display_name: "keyboard"
+}
+item {
+  name: "/m/050k8"
+  id: 77
+  display_name: "cell phone"
+}
+item {
+  name: "/m/0fx9l"
+  id: 78
+  display_name: "microwave"
+}
+item {
+  name: "/m/029bxz"
+  id: 79
+  display_name: "oven"
+}
+item {
+  name: "/m/01k6s3"
+  id: 80
+  display_name: "toaster"
+}
+item {
+  name: "/m/0130jx"
+  id: 81
+  display_name: "sink"
+}
+item {
+  name: "/m/040b_t"
+  id: 82
+  display_name: "refrigerator"
+}
+item {
+  name: "/m/0bt_c3"
+  id: 84
+  display_name: "book"
+}
+item {
+  name: "/m/01x3z"
+  id: 85
+  display_name: "clock"
+}
+item {
+  name: "/m/02s195"
+  id: 86
+  display_name: "vase"
+}
+item {
+  name: "/m/01lsmm"
+  id: 87
+  display_name: "scissors"
+}
+item {
+  name: "/m/0kmg4"
+  id: 88
+  display_name: "teddy bear"
+}
+item {
+  name: "/m/03wvsk"
+  id: 89
+  display_name: "hair drier"
+}
+item {
+  name: "/m/012xff"
+  id: 90
+  display_name: "toothbrush"
+}
diff --git a/reconnaissance images/object_detection/data/pascal_label_map.pbtxt b/reconnaissance images/object_detection/data/pascal_label_map.pbtxt
new file mode 100644
index 0000000..c9e9e2a
--- /dev/null
+++ b/reconnaissance images/object_detection/data/pascal_label_map.pbtxt	
@@ -0,0 +1,99 @@
+item {
+  id: 1
+  name: 'aeroplane'
+}
+
+item {
+  id: 2
+  name: 'bicycle'
+}
+
+item {
+  id: 3
+  name: 'bird'
+}
+
+item {
+  id: 4
+  name: 'boat'
+}
+
+item {
+  id: 5
+  name: 'bottle'
+}
+
+item {
+  id: 6
+  name: 'bus'
+}
+
+item {
+  id: 7
+  name: 'car'
+}
+
+item {
+  id: 8
+  name: 'cat'
+}
+
+item {
+  id: 9
+  name: 'chair'
+}
+
+item {
+  id: 10
+  name: 'cow'
+}
+
+item {
+  id: 11
+  name: 'diningtable'
+}
+
+item {
+  id: 12
+  name: 'dog'
+}
+
+item {
+  id: 13
+  name: 'horse'
+}
+
+item {
+  id: 14
+  name: 'motorbike'
+}
+
+item {
+  id: 15
+  name: 'person'
+}
+
+item {
+  id: 16
+  name: 'pottedplant'
+}
+
+item {
+  id: 17
+  name: 'sheep'
+}
+
+item {
+  id: 18
+  name: 'sofa'
+}
+
+item {
+  id: 19
+  name: 'train'
+}
+
+item {
+  id: 20
+  name: 'tvmonitor'
+}
diff --git a/reconnaissance images/object_detection/data/pet_label_map.pbtxt b/reconnaissance images/object_detection/data/pet_label_map.pbtxt
new file mode 100644
index 0000000..54d7d35
--- /dev/null
+++ b/reconnaissance images/object_detection/data/pet_label_map.pbtxt	
@@ -0,0 +1,184 @@
+item {
+  id: 1
+  name: 'Abyssinian'
+}
+
+item {
+  id: 2
+  name: 'american_bulldog'
+}
+
+item {
+  id: 3
+  name: 'american_pit_bull_terrier'
+}
+
+item {
+  id: 4
+  name: 'basset_hound'
+}
+
+item {
+  id: 5
+  name: 'beagle'
+}
+
+item {
+  id: 6
+  name: 'Bengal'
+}
+
+item {
+  id: 7
+  name: 'Birman'
+}
+
+item {
+  id: 8
+  name: 'Bombay'
+}
+
+item {
+  id: 9
+  name: 'boxer'
+}
+
+item {
+  id: 10
+  name: 'British_Shorthair'
+}
+
+item {
+  id: 11
+  name: 'chihuahua'
+}
+
+item {
+  id: 12
+  name: 'Egyptian_Mau'
+}
+
+item {
+  id: 13
+  name: 'english_cocker_spaniel'
+}
+
+item {
+  id: 14
+  name: 'english_setter'
+}
+
+item {
+  id: 15
+  name: 'german_shorthaired'
+}
+
+item {
+  id: 16
+  name: 'great_pyrenees'
+}
+
+item {
+  id: 17
+  name: 'havanese'
+}
+
+item {
+  id: 18
+  name: 'japanese_chin'
+}
+
+item {
+  id: 19
+  name: 'keeshond'
+}
+
+item {
+  id: 20
+  name: 'leonberger'
+}
+
+item {
+  id: 21
+  name: 'Maine_Coon'
+}
+
+item {
+  id: 22
+  name: 'miniature_pinscher'
+}
+
+item {
+  id: 23
+  name: 'newfoundland'
+}
+
+item {
+  id: 24
+  name: 'Persian'
+}
+
+item {
+  id: 25
+  name: 'pomeranian'
+}
+
+item {
+  id: 26
+  name: 'pug'
+}
+
+item {
+  id: 27
+  name: 'Ragdoll'
+}
+
+item {
+  id: 28
+  name: 'Russian_Blue'
+}
+
+item {
+  id: 29
+  name: 'saint_bernard'
+}
+
+item {
+  id: 30
+  name: 'samoyed'
+}
+
+item {
+  id: 31
+  name: 'scottish_terrier'
+}
+
+item {
+  id: 32
+  name: 'shiba_inu'
+}
+
+item {
+  id: 33
+  name: 'Siamese'
+}
+
+item {
+  id: 34
+  name: 'Sphynx'
+}
+
+item {
+  id: 35
+  name: 'staffordshire_bull_terrier'
+}
+
+item {
+  id: 36
+  name: 'wheaten_terrier'
+}
+
+item {
+  id: 37
+  name: 'yorkshire_terrier'
+}
diff --git a/reconnaissance images/object_detection/filevideostream.py b/reconnaissance images/object_detection/filevideostream.py
new file mode 100644
index 0000000..6b0f0c0
--- /dev/null
+++ b/reconnaissance images/object_detection/filevideostream.py	
@@ -0,0 +1,64 @@
+# import the necessary packages
+from threading import Thread
+import sys
+import cv2
+
+# import the Queue class from Python 3
+if sys.version_info >= (3, 0):
+	from queue import Queue
+
+# otherwise, import the Queue class for Python 2.7
+else:
+	from Queue import Queue
+
+class FileVideoStream:
+	def __init__(self, path, queueSize=128):
+		# initialize the file video stream along with the boolean
+		# used to indicate if the thread should be stopped or not
+		self.stream = cv2.VideoCapture(path)
+		self.stopped = False
+
+		# initialize the queue used to store frames read from
+		# the video file
+		self.Q = Queue(maxsize=queueSize)
+
+	def start(self):
+		# start a thread to read frames from the file video stream
+		t = Thread(target=self.update, args=())
+		t.daemon = True
+		t.start()
+		return self
+
+	def update(self):
+		# keep looping infinitely
+		while True:
+			# if the thread indicator variable is set, stop the
+			# thread
+			if self.stopped:
+				return
+
+			# otherwise, ensure the queue has room in it
+			if not self.Q.full():
+				# read the next frame from the file
+				(grabbed, frame) = self.stream.read()
+
+				# if the `grabbed` boolean is `False`, then we have
+				# reached the end of the video file
+				if not grabbed:
+					self.stop()
+					return
+
+				# add the frame to the queue
+				self.Q.put(frame)
+
+	def read(self):
+		# return next frame in the queue
+		return self.Q.get()
+
+	def more(self):
+		# return True if there are still frames in the queue
+		return self.Q.qsize() > 0
+
+	def stop(self):
+		# indicate that the thread should be stopped
+		self.stopped = True
\ No newline at end of file
diff --git a/reconnaissance images/object_detection/fps.py b/reconnaissance images/object_detection/fps.py
new file mode 100644
index 0000000..cad5b89
--- /dev/null
+++ b/reconnaissance images/object_detection/fps.py	
@@ -0,0 +1,33 @@
+# import the necessary packages
+import datetime
+
+class FPS:
+	def __init__(self):
+		# store the start time, end time, and total number of frames
+		# that were examined between the start and end intervals
+		self._start = None
+		self._end = None
+		self._numFrames = 0
+
+	def start(self):
+		# start the timer
+		self._start = datetime.datetime.now()
+		return self
+
+	def stop(self):
+		# stop the timer
+		self._end = datetime.datetime.now()
+
+	def update(self):
+		# increment the total number of frames examined during the
+		# start and end intervals
+		self._numFrames += 1
+
+	def elapsed(self):
+		# return the total number of seconds between the start and
+		# end interval
+		return (self._end - self._start).total_seconds()
+
+	def fps(self):
+		# compute the (approximate) frames per second
+		return self._numFrames / self.elapsed()
\ No newline at end of file
diff --git a/reconnaissance images/object_detection/object_detection_tutorial.ipynb b/reconnaissance images/object_detection/object_detection_tutorial.ipynb
new file mode 100644
index 0000000..7788736
--- /dev/null
+++ b/reconnaissance images/object_detection/object_detection_tutorial.ipynb	
@@ -0,0 +1,316 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Object Detection Demo\n",
+    "Welcome to the object detection inference walkthrough!  This notebook will walk you step by step through the process of using a pre-trained model to detect objects in an image. Make sure to follow the [installation instructions](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/installation.md) before you start."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import os\n",
+    "import six.moves.urllib as urllib\n",
+    "import sys\n",
+    "import tarfile\n",
+    "import tensorflow as tf\n",
+    "import zipfile\n",
+    "\n",
+    "from collections import defaultdict\n",
+    "from io import StringIO\n",
+    "from matplotlib import pyplot as plt\n",
+    "from PIL import Image"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Env setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is needed to display the images.\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# This is needed since the notebook is stored in the object_detection folder.\n",
+    "sys.path.append(\"..\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Object detection imports\n",
+    "Here are the imports from the object detection module."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from utils import label_map_util\n",
+    "\n",
+    "from utils import visualization_utils as vis_util"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Model preparation "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Variables\n",
+    "\n",
+    "Any model exported using the `export_inference_graph.py` tool can be loaded here simply by changing `PATH_TO_CKPT` to point to a new .pb file.  \n",
+    "\n",
+    "By default we use an \"SSD with Mobilenet\" model here. See the [detection model zoo](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/detection_model_zoo.md) for a list of other models that can be run out-of-the-box with varying speeds and accuracies."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# What model to download.\n",
+    "MODEL_NAME = 'ssd_mobilenet_v1_coco_11_06_2017'\n",
+    "MODEL_FILE = MODEL_NAME + '.tar.gz'\n",
+    "DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'\n",
+    "\n",
+    "# Path to frozen detection graph. This is the actual model that is used for the object detection.\n",
+    "PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'\n",
+    "\n",
+    "# List of the strings that is used to add correct label for each box.\n",
+    "PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')\n",
+    "\n",
+    "NUM_CLASSES = 90"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Download Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "opener = urllib.request.URLopener()\n",
+    "opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)\n",
+    "tar_file = tarfile.open(MODEL_FILE)\n",
+    "for file in tar_file.getmembers():\n",
+    "  file_name = os.path.basename(file.name)\n",
+    "  if 'frozen_inference_graph.pb' in file_name:\n",
+    "    tar_file.extract(file, os.getcwd())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load a (frozen) Tensorflow model into memory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "detection_graph = tf.Graph()\n",
+    "with detection_graph.as_default():\n",
+    "  od_graph_def = tf.GraphDef()\n",
+    "  with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:\n",
+    "    serialized_graph = fid.read()\n",
+    "    od_graph_def.ParseFromString(serialized_graph)\n",
+    "    tf.import_graph_def(od_graph_def, name='')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading label map\n",
+    "Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`.  Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "label_map = label_map_util.load_labelmap(PATH_TO_LABELS)\n",
+    "categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True)\n",
+    "category_index = label_map_util.create_category_index(categories)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Helper code"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_image_into_numpy_array(image):\n",
+    "  (im_width, im_height) = image.size\n",
+    "  return np.array(image.getdata()).reshape(\n",
+    "      (im_height, im_width, 3)).astype(np.uint8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Detection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# For the sake of simplicity we will use only 2 images:\n",
+    "# image1.jpg\n",
+    "# image2.jpg\n",
+    "# If you want to test the code with your images, just add path to the images to the TEST_IMAGE_PATHS.\n",
+    "PATH_TO_TEST_IMAGES_DIR = 'test_images'\n",
+    "TEST_IMAGE_PATHS = [ os.path.join(PATH_TO_TEST_IMAGES_DIR, 'image{}.jpg'.format(i)) for i in range(1, 3) ]\n",
+    "\n",
+    "# Size, in inches, of the output images.\n",
+    "IMAGE_SIZE = (12, 8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAskAAAHCCAYAAAAdGlSzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nWVsAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x21e90378ac8>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArkAAAHWCAYAAABzFJGmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x21eadeefcc0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "with detection_graph.as_default():\n",
+    "  with tf.Session(graph=detection_graph) as sess:\n",
+    "    # Definite input and output Tensors for detection_graph\n",
+    "    image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')\n",
+    "    # Each box represents a part of the image where a particular object was detected.\n",
+    "    detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')\n",
+    "    # Each score represent how level of confidence for each of the objects.\n",
+    "    # Score is shown on the result image, together with the class label.\n",
+    "    detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')\n",
+    "    detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')\n",
+    "    num_detections = detection_graph.get_tensor_by_name('num_detections:0')\n",
+    "    for image_path in TEST_IMAGE_PATHS:\n",
+    "      image = Image.open(image_path)\n",
+    "      # the array based representation of the image will be used later in order to prepare the\n",
+    "      # result image with boxes and labels on it.\n",
+    "      image_np = load_image_into_numpy_array(image)\n",
+    "      # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n",
+    "      image_np_expanded = np.expand_dims(image_np, axis=0)\n",
+    "      # Actual detection.\n",
+    "      (boxes, scores, classes, num) = sess.run(\n",
+    "          [detection_boxes, detection_scores, detection_classes, num_detections],\n",
+    "          feed_dict={image_tensor: image_np_expanded})\n",
+    "      # Visualization of the results of a detection.\n",
+    "      vis_util.visualize_boxes_and_labels_on_image_array(\n",
+    "          image_np,\n",
+    "          np.squeeze(boxes),\n",
+    "          np.squeeze(classes).astype(np.int32),\n",
+    "          np.squeeze(scores),\n",
+    "          category_index,\n",
+    "          use_normalized_coordinates=True,\n",
+    "          line_thickness=8)\n",
+    "      plt.figure(figsize=IMAGE_SIZE)\n",
+    "      plt.imshow(image_np)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.5.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/reconnaissance images/object_detection/object_detection_tutorial_test2.py b/reconnaissance images/object_detection/object_detection_tutorial_test2.py
new file mode 100644
index 0000000..97b54b5
--- /dev/null
+++ b/reconnaissance images/object_detection/object_detection_tutorial_test2.py	
@@ -0,0 +1,227 @@
+
+# coding: utf-8
+
+# # Object Detection Demo
+# Welcome to the object detection inference walkthrough!  This notebook will walk you step by step through the process of using a pre-trained model to detect objects in an image. Make sure to follow the [installation instructions](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/installation.md) before you start.
+
+# # Imports
+
+# In[2]:
+
+from __future__ import print_function
+
+import numpy as np
+import os
+import six.moves.urllib as urllib
+import sys
+import tarfile
+import tensorflow as tf
+import zipfile
+import urllib.request
+import cv2
+
+from collections import defaultdict
+from io import StringIO
+#from matplotlib import pyplot as plt
+#from PIL import Image
+
+from imutils.video import WebcamVideoStream
+from imutils.video import FPS
+import argparse
+import imutils
+
+
+#cap = cv2.VideoCapture(0)
+
+#cap = cv2.VideoCapture('tcp://192.168.2.1:8081/')
+vs = WebcamVideoStream(src='tcp://192.168.2.1:8081/').start()
+# ## Env setup
+
+# In[3]:
+
+# This is needed since the notebook is stored in the object_detection folder.
+sys.path.append("..")
+
+
+# ## Object detection imports
+# Here are the imports from the object detection module.
+
+# In[4]:
+
+
+from utils import label_map_util
+
+from utils import visualization_utils as vis_util
+
+
+# # Model preparation 
+
+# ## Variables
+# 
+# Any model exported using the `export_inference_graph.py` tool can be loaded here simply by changing `PATH_TO_CKPT` to point to a new .pb file.  
+# 
+# By default we use an "SSD with Mobilenet" model here. See the [detection model zoo](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/detection_model_zoo.md) for a list of other models that can be run out-of-the-box with varying speeds and accuracies.
+
+# In[5]:
+
+
+# What model to download.
+#MODEL_NAME = 'ssd_mobilenet_v1_coco_11_06_2017'
+MODEL_NAME = 'ssd_inception_v2_coco_11_06_2017'
+MODEL_FILE = MODEL_NAME + '.tar.gz'
+DOWNLOAD_BASE = 'C:\\Users\\utilisateur\\Documents\\Ecole\\2I\\L5\\PRT\\Scripts\\tensorflow\\models\\research\\object_detection\\'
+
+# Path to frozen detection graph. This is the actual model that is used for the object detection.
+PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'
+
+# List of the strings that is used to add correct label for each box.
+PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')
+
+NUM_CLASSES = 90
+
+
+# ## Download Model
+
+# In[6]:
+
+#ouvrir en téléchargent le model
+#opener = urllib.request.URLopener()
+#opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)
+#tar_file = tarfile.open(MODEL_FILE)
+
+#ouvrir avec les fichier prétélécharger
+tar_file = tarfile.open(DOWNLOAD_BASE + MODEL_FILE)
+
+for file in tar_file.getmembers():
+  file_name = os.path.basename(file.name)
+  if 'frozen_inference_graph.pb' in file_name:
+    tar_file.extract(file, os.getcwd())
+
+
+# ## Load a (frozen) Tensorflow model into memory.
+
+# In[7]:
+
+
+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='')
+
+
+# ## Loading label map
+# Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`.  Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine
+
+# In[8]:
+
+
+label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
+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)
+
+
+# ## Helper code
+
+# In[9]:
+
+
+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)
+
+
+# # Detection
+
+# In[10]:
+
+
+# For the sake of simplicity we will use only 2 images:
+# image1.jpg
+# image2.jpg
+# If you want to test the code with your images, just add path to the images to the TEST_IMAGE_PATHS.
+PATH_TO_TEST_IMAGES_DIR = 'test_images'
+TEST_IMAGE_PATHS = [ os.path.join(PATH_TO_TEST_IMAGES_DIR, 'image{}.jpg'.format(i)) for i in range(1, 3) ]
+
+# Size, in inches, of the output images.
+IMAGE_SIZE = (12, 8)
+
+
+# In[11]:
+
+
+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')
+    fps = FPS().start()
+    while True:
+		
+      # ret, image_np = cap.read()
+
+      # # 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})
+      # # Visualization of the results of a detection.
+      # 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=8)
+      # cv2.imshow('object detection',cv2.resize(image_np,(800,600)))
+      # if cv2.waitKey(25) & 0xFF == ord('q'):
+        # cv2.destroyAllWindows()
+        # break
+		
+		# grab the frame from the threaded video stream and resize it
+		# to have a maximum width of 400 pixels
+        image_np = vs.read()
+		
+        image_np_expanded = np.expand_dims(image_np, axis=0)
+        (boxes, scores, classes, num) = sess.run(
+		[detection_boxes, detection_scores, detection_classes, num_detections],
+        feed_dict={image_tensor: image_np_expanded})
+	  
+		# check to see if the frame should be displayed to our screen
+		#if args["display"] > 0:
+		#cv2.imshow("Frame", image_np)
+		
+        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=8)
+        cv2.imshow('object detection',cv2.resize(image_np,(800,600)))
+		
+        fps.update()
+		
+        if cv2.waitKey(25) & 0xFF == ord('q'):
+			# stop the timer and display FPS information
+            fps.stop()
+            print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
+            print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
+			 
+			# do a bit of cleanup
+            cv2.destroyAllWindows()
+            vs.stop()
+            break
+			
\ No newline at end of file
diff --git a/reconnaissance images/object_detection/protos/BUILD b/reconnaissance images/object_detection/protos/BUILD
new file mode 100644
index 0000000..7ab70ca
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/BUILD	
@@ -0,0 +1,329 @@
+# Tensorflow Object Detection API: Configuration protos.
+
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+licenses(["notice"])
+
+proto_library(
+    name = "argmax_matcher_proto",
+    srcs = ["argmax_matcher.proto"],
+)
+
+py_proto_library(
+    name = "argmax_matcher_py_pb2",
+    api_version = 2,
+    deps = [":argmax_matcher_proto"],
+)
+
+proto_library(
+    name = "bipartite_matcher_proto",
+    srcs = ["bipartite_matcher.proto"],
+)
+
+py_proto_library(
+    name = "bipartite_matcher_py_pb2",
+    api_version = 2,
+    deps = [":bipartite_matcher_proto"],
+)
+
+proto_library(
+    name = "matcher_proto",
+    srcs = ["matcher.proto"],
+    deps = [
+        ":argmax_matcher_proto",
+        ":bipartite_matcher_proto",
+    ],
+)
+
+py_proto_library(
+    name = "matcher_py_pb2",
+    api_version = 2,
+    deps = [":matcher_proto"],
+)
+
+proto_library(
+    name = "faster_rcnn_box_coder_proto",
+    srcs = ["faster_rcnn_box_coder.proto"],
+)
+
+py_proto_library(
+    name = "faster_rcnn_box_coder_py_pb2",
+    api_version = 2,
+    deps = [":faster_rcnn_box_coder_proto"],
+)
+
+proto_library(
+    name = "mean_stddev_box_coder_proto",
+    srcs = ["mean_stddev_box_coder.proto"],
+)
+
+py_proto_library(
+    name = "mean_stddev_box_coder_py_pb2",
+    api_version = 2,
+    deps = [":mean_stddev_box_coder_proto"],
+)
+
+proto_library(
+    name = "square_box_coder_proto",
+    srcs = ["square_box_coder.proto"],
+)
+
+py_proto_library(
+    name = "square_box_coder_py_pb2",
+    api_version = 2,
+    deps = [":square_box_coder_proto"],
+)
+
+proto_library(
+    name = "box_coder_proto",
+    srcs = ["box_coder.proto"],
+    deps = [
+        ":faster_rcnn_box_coder_proto",
+        ":mean_stddev_box_coder_proto",
+        ":square_box_coder_proto",
+    ],
+)
+
+py_proto_library(
+    name = "box_coder_py_pb2",
+    api_version = 2,
+    deps = [":box_coder_proto"],
+)
+
+proto_library(
+    name = "grid_anchor_generator_proto",
+    srcs = ["grid_anchor_generator.proto"],
+)
+
+py_proto_library(
+    name = "grid_anchor_generator_py_pb2",
+    api_version = 2,
+    deps = [":grid_anchor_generator_proto"],
+)
+
+proto_library(
+    name = "ssd_anchor_generator_proto",
+    srcs = ["ssd_anchor_generator.proto"],
+)
+
+py_proto_library(
+    name = "ssd_anchor_generator_py_pb2",
+    api_version = 2,
+    deps = [":ssd_anchor_generator_proto"],
+)
+
+proto_library(
+    name = "anchor_generator_proto",
+    srcs = ["anchor_generator.proto"],
+    deps = [
+        ":grid_anchor_generator_proto",
+        ":ssd_anchor_generator_proto",
+    ],
+)
+
+py_proto_library(
+    name = "anchor_generator_py_pb2",
+    api_version = 2,
+    deps = [":anchor_generator_proto"],
+)
+
+proto_library(
+    name = "input_reader_proto",
+    srcs = ["input_reader.proto"],
+)
+
+py_proto_library(
+    name = "input_reader_py_pb2",
+    api_version = 2,
+    deps = [":input_reader_proto"],
+)
+
+proto_library(
+    name = "losses_proto",
+    srcs = ["losses.proto"],
+)
+
+py_proto_library(
+    name = "losses_py_pb2",
+    api_version = 2,
+    deps = [":losses_proto"],
+)
+
+proto_library(
+    name = "optimizer_proto",
+    srcs = ["optimizer.proto"],
+)
+
+py_proto_library(
+    name = "optimizer_py_pb2",
+    api_version = 2,
+    deps = [":optimizer_proto"],
+)
+
+proto_library(
+    name = "post_processing_proto",
+    srcs = ["post_processing.proto"],
+)
+
+py_proto_library(
+    name = "post_processing_py_pb2",
+    api_version = 2,
+    deps = [":post_processing_proto"],
+)
+
+proto_library(
+    name = "hyperparams_proto",
+    srcs = ["hyperparams.proto"],
+)
+
+py_proto_library(
+    name = "hyperparams_py_pb2",
+    api_version = 2,
+    deps = [":hyperparams_proto"],
+)
+
+proto_library(
+    name = "box_predictor_proto",
+    srcs = ["box_predictor.proto"],
+    deps = [":hyperparams_proto"],
+)
+
+py_proto_library(
+    name = "box_predictor_py_pb2",
+    api_version = 2,
+    deps = [":box_predictor_proto"],
+)
+
+proto_library(
+    name = "region_similarity_calculator_proto",
+    srcs = ["region_similarity_calculator.proto"],
+    deps = [],
+)
+
+py_proto_library(
+    name = "region_similarity_calculator_py_pb2",
+    api_version = 2,
+    deps = [":region_similarity_calculator_proto"],
+)
+
+proto_library(
+    name = "preprocessor_proto",
+    srcs = ["preprocessor.proto"],
+)
+
+py_proto_library(
+    name = "preprocessor_py_pb2",
+    api_version = 2,
+    deps = [":preprocessor_proto"],
+)
+
+proto_library(
+    name = "train_proto",
+    srcs = ["train.proto"],
+    deps = [
+        ":optimizer_proto",
+        ":preprocessor_proto",
+    ],
+)
+
+py_proto_library(
+    name = "train_py_pb2",
+    api_version = 2,
+    deps = [":train_proto"],
+)
+
+proto_library(
+    name = "eval_proto",
+    srcs = ["eval.proto"],
+)
+
+py_proto_library(
+    name = "eval_py_pb2",
+    api_version = 2,
+    deps = [":eval_proto"],
+)
+
+proto_library(
+    name = "image_resizer_proto",
+    srcs = ["image_resizer.proto"],
+)
+
+py_proto_library(
+    name = "image_resizer_py_pb2",
+    api_version = 2,
+    deps = [":image_resizer_proto"],
+)
+
+proto_library(
+    name = "faster_rcnn_proto",
+    srcs = ["faster_rcnn.proto"],
+    deps = [
+        ":box_predictor_proto",
+        "//object_detection/protos:anchor_generator_proto",
+        "//object_detection/protos:hyperparams_proto",
+        "//object_detection/protos:image_resizer_proto",
+        "//object_detection/protos:losses_proto",
+        "//object_detection/protos:post_processing_proto",
+    ],
+)
+
+proto_library(
+    name = "ssd_proto",
+    srcs = ["ssd.proto"],
+    deps = [
+        ":anchor_generator_proto",
+        ":box_coder_proto",
+        ":box_predictor_proto",
+        ":hyperparams_proto",
+        ":image_resizer_proto",
+        ":losses_proto",
+        ":matcher_proto",
+        ":post_processing_proto",
+        ":region_similarity_calculator_proto",
+    ],
+)
+
+proto_library(
+    name = "model_proto",
+    srcs = ["model.proto"],
+    deps = [
+        ":faster_rcnn_proto",
+        ":ssd_proto",
+    ],
+)
+
+py_proto_library(
+    name = "model_py_pb2",
+    api_version = 2,
+    deps = [":model_proto"],
+)
+
+proto_library(
+    name = "pipeline_proto",
+    srcs = ["pipeline.proto"],
+    deps = [
+        ":eval_proto",
+        ":input_reader_proto",
+        ":model_proto",
+        ":train_proto",
+    ],
+)
+
+py_proto_library(
+    name = "pipeline_py_pb2",
+    api_version = 2,
+    deps = [":pipeline_proto"],
+)
+
+proto_library(
+    name = "string_int_label_map_proto",
+    srcs = ["string_int_label_map.proto"],
+)
+
+py_proto_library(
+    name = "string_int_label_map_py_pb2",
+    api_version = 2,
+    deps = [":string_int_label_map_proto"],
+)
diff --git a/reconnaissance images/object_detection/protos/__init__.py b/reconnaissance images/object_detection/protos/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/reconnaissance images/object_detection/protos/__pycache__/__init__.cpython-35.pyc b/reconnaissance images/object_detection/protos/__pycache__/__init__.cpython-35.pyc
new file mode 100644
index 0000000..e7e0493
Binary files /dev/null and b/reconnaissance images/object_detection/protos/__pycache__/__init__.cpython-35.pyc differ
diff --git a/reconnaissance images/object_detection/protos/__pycache__/__init__.cpython-36.pyc b/reconnaissance images/object_detection/protos/__pycache__/__init__.cpython-36.pyc
new file mode 100644
index 0000000..473ef0f
Binary files /dev/null and b/reconnaissance images/object_detection/protos/__pycache__/__init__.cpython-36.pyc differ
diff --git a/reconnaissance images/object_detection/protos/__pycache__/string_int_label_map_pb2.cpython-35.pyc b/reconnaissance images/object_detection/protos/__pycache__/string_int_label_map_pb2.cpython-35.pyc
new file mode 100644
index 0000000..1c4e3e2
Binary files /dev/null and b/reconnaissance images/object_detection/protos/__pycache__/string_int_label_map_pb2.cpython-35.pyc differ
diff --git a/reconnaissance images/object_detection/protos/__pycache__/string_int_label_map_pb2.cpython-36.pyc b/reconnaissance images/object_detection/protos/__pycache__/string_int_label_map_pb2.cpython-36.pyc
new file mode 100644
index 0000000..1643edb
Binary files /dev/null and b/reconnaissance images/object_detection/protos/__pycache__/string_int_label_map_pb2.cpython-36.pyc differ
diff --git a/reconnaissance images/object_detection/protos/anchor_generator.proto b/reconnaissance images/object_detection/protos/anchor_generator.proto
new file mode 100644
index 0000000..4b7b1d6
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/anchor_generator.proto	
@@ -0,0 +1,15 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+import "object_detection/protos/grid_anchor_generator.proto";
+import "object_detection/protos/ssd_anchor_generator.proto";
+
+// Configuration proto for the anchor generator to use in the object detection
+// pipeline. See core/anchor_generator.py for details.
+message AnchorGenerator {
+  oneof anchor_generator_oneof {
+    GridAnchorGenerator grid_anchor_generator = 1;
+    SsdAnchorGenerator ssd_anchor_generator = 2;
+  }
+}
diff --git a/reconnaissance images/object_detection/protos/anchor_generator_pb2.py b/reconnaissance images/object_detection/protos/anchor_generator_pb2.py
new file mode 100644
index 0000000..54d603d
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/anchor_generator_pb2.py	
@@ -0,0 +1,90 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/anchor_generator.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import grid_anchor_generator_pb2 as object__detection_dot_protos_dot_grid__anchor__generator__pb2
+from object_detection.protos import ssd_anchor_generator_pb2 as object__detection_dot_protos_dot_ssd__anchor__generator__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/anchor_generator.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n.object_detection/protos/anchor_generator.proto\x12\x17object_detection.protos\x1a\x33object_detection/protos/grid_anchor_generator.proto\x1a\x32object_detection/protos/ssd_anchor_generator.proto\"\xc7\x01\n\x0f\x41nchorGenerator\x12M\n\x15grid_anchor_generator\x18\x01 \x01(\x0b\x32,.object_detection.protos.GridAnchorGeneratorH\x00\x12K\n\x14ssd_anchor_generator\x18\x02 \x01(\x0b\x32+.object_detection.protos.SsdAnchorGeneratorH\x00\x42\x18\n\x16\x61nchor_generator_oneof')
+  ,
+  dependencies=[object__detection_dot_protos_dot_grid__anchor__generator__pb2.DESCRIPTOR,object__detection_dot_protos_dot_ssd__anchor__generator__pb2.DESCRIPTOR,])
+
+
+
+
+_ANCHORGENERATOR = _descriptor.Descriptor(
+  name='AnchorGenerator',
+  full_name='object_detection.protos.AnchorGenerator',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='grid_anchor_generator', full_name='object_detection.protos.AnchorGenerator.grid_anchor_generator', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='ssd_anchor_generator', full_name='object_detection.protos.AnchorGenerator.ssd_anchor_generator', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='anchor_generator_oneof', full_name='object_detection.protos.AnchorGenerator.anchor_generator_oneof',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=181,
+  serialized_end=380,
+)
+
+_ANCHORGENERATOR.fields_by_name['grid_anchor_generator'].message_type = object__detection_dot_protos_dot_grid__anchor__generator__pb2._GRIDANCHORGENERATOR
+_ANCHORGENERATOR.fields_by_name['ssd_anchor_generator'].message_type = object__detection_dot_protos_dot_ssd__anchor__generator__pb2._SSDANCHORGENERATOR
+_ANCHORGENERATOR.oneofs_by_name['anchor_generator_oneof'].fields.append(
+  _ANCHORGENERATOR.fields_by_name['grid_anchor_generator'])
+_ANCHORGENERATOR.fields_by_name['grid_anchor_generator'].containing_oneof = _ANCHORGENERATOR.oneofs_by_name['anchor_generator_oneof']
+_ANCHORGENERATOR.oneofs_by_name['anchor_generator_oneof'].fields.append(
+  _ANCHORGENERATOR.fields_by_name['ssd_anchor_generator'])
+_ANCHORGENERATOR.fields_by_name['ssd_anchor_generator'].containing_oneof = _ANCHORGENERATOR.oneofs_by_name['anchor_generator_oneof']
+DESCRIPTOR.message_types_by_name['AnchorGenerator'] = _ANCHORGENERATOR
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+AnchorGenerator = _reflection.GeneratedProtocolMessageType('AnchorGenerator', (_message.Message,), dict(
+  DESCRIPTOR = _ANCHORGENERATOR,
+  __module__ = 'object_detection.protos.anchor_generator_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.AnchorGenerator)
+  ))
+_sym_db.RegisterMessage(AnchorGenerator)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/argmax_matcher.proto b/reconnaissance images/object_detection/protos/argmax_matcher.proto
new file mode 100644
index 0000000..88c5031
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/argmax_matcher.proto	
@@ -0,0 +1,25 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for ArgMaxMatcher. See
+// matchers/argmax_matcher.py for details.
+message ArgMaxMatcher {
+  // Threshold for positive matches.
+  optional float matched_threshold = 1 [default = 0.5];
+
+  // Threshold for negative matches.
+  optional float unmatched_threshold = 2 [default = 0.5];
+
+  // Whether to construct ArgMaxMatcher without thresholds.
+  optional bool ignore_thresholds = 3 [default = false];
+
+  // If True then negative matches are the ones below the unmatched_threshold,
+  // whereas ignored matches are in between the matched and umatched
+  // threshold. If False, then negative matches are in between the matched
+  // and unmatched threshold, and everything lower than unmatched is ignored.
+  optional bool negatives_lower_than_unmatched = 4 [default = true];
+
+  // Whether to ensure each row is matched to at least one column.
+  optional bool force_match_for_each_row = 5 [default = false];
+}
diff --git a/reconnaissance images/object_detection/protos/argmax_matcher_pb2.py b/reconnaissance images/object_detection/protos/argmax_matcher_pb2.py
new file mode 100644
index 0000000..be2dc9e
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/argmax_matcher_pb2.py	
@@ -0,0 +1,97 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/argmax_matcher.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/argmax_matcher.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n,object_detection/protos/argmax_matcher.proto\x12\x17object_detection.protos\"\xca\x01\n\rArgMaxMatcher\x12\x1e\n\x11matched_threshold\x18\x01 \x01(\x02:\x03\x30.5\x12 \n\x13unmatched_threshold\x18\x02 \x01(\x02:\x03\x30.5\x12 \n\x11ignore_thresholds\x18\x03 \x01(\x08:\x05\x66\x61lse\x12,\n\x1enegatives_lower_than_unmatched\x18\x04 \x01(\x08:\x04true\x12\'\n\x18\x66orce_match_for_each_row\x18\x05 \x01(\x08:\x05\x66\x61lse')
+)
+
+
+
+
+_ARGMAXMATCHER = _descriptor.Descriptor(
+  name='ArgMaxMatcher',
+  full_name='object_detection.protos.ArgMaxMatcher',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='matched_threshold', full_name='object_detection.protos.ArgMaxMatcher.matched_threshold', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='unmatched_threshold', full_name='object_detection.protos.ArgMaxMatcher.unmatched_threshold', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='ignore_thresholds', full_name='object_detection.protos.ArgMaxMatcher.ignore_thresholds', index=2,
+      number=3, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='negatives_lower_than_unmatched', full_name='object_detection.protos.ArgMaxMatcher.negatives_lower_than_unmatched', index=3,
+      number=4, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='force_match_for_each_row', full_name='object_detection.protos.ArgMaxMatcher.force_match_for_each_row', index=4,
+      number=5, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=74,
+  serialized_end=276,
+)
+
+DESCRIPTOR.message_types_by_name['ArgMaxMatcher'] = _ARGMAXMATCHER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+ArgMaxMatcher = _reflection.GeneratedProtocolMessageType('ArgMaxMatcher', (_message.Message,), dict(
+  DESCRIPTOR = _ARGMAXMATCHER,
+  __module__ = 'object_detection.protos.argmax_matcher_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ArgMaxMatcher)
+  ))
+_sym_db.RegisterMessage(ArgMaxMatcher)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/bipartite_matcher.proto b/reconnaissance images/object_detection/protos/bipartite_matcher.proto
new file mode 100644
index 0000000..7e5a9e5
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/bipartite_matcher.proto	
@@ -0,0 +1,8 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for bipartite matcher. See
+// matchers/bipartite_matcher.py for details.
+message BipartiteMatcher {
+}
diff --git a/reconnaissance images/object_detection/protos/bipartite_matcher_pb2.py b/reconnaissance images/object_detection/protos/bipartite_matcher_pb2.py
new file mode 100644
index 0000000..dc258ec
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/bipartite_matcher_pb2.py	
@@ -0,0 +1,62 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/bipartite_matcher.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/bipartite_matcher.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n/object_detection/protos/bipartite_matcher.proto\x12\x17object_detection.protos\"\x12\n\x10\x42ipartiteMatcher')
+)
+
+
+
+
+_BIPARTITEMATCHER = _descriptor.Descriptor(
+  name='BipartiteMatcher',
+  full_name='object_detection.protos.BipartiteMatcher',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=76,
+  serialized_end=94,
+)
+
+DESCRIPTOR.message_types_by_name['BipartiteMatcher'] = _BIPARTITEMATCHER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+BipartiteMatcher = _reflection.GeneratedProtocolMessageType('BipartiteMatcher', (_message.Message,), dict(
+  DESCRIPTOR = _BIPARTITEMATCHER,
+  __module__ = 'object_detection.protos.bipartite_matcher_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.BipartiteMatcher)
+  ))
+_sym_db.RegisterMessage(BipartiteMatcher)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/box_coder.proto b/reconnaissance images/object_detection/protos/box_coder.proto
new file mode 100644
index 0000000..6b37e8f
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/box_coder.proto	
@@ -0,0 +1,17 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+import "object_detection/protos/faster_rcnn_box_coder.proto";
+import "object_detection/protos/mean_stddev_box_coder.proto";
+import "object_detection/protos/square_box_coder.proto";
+
+// Configuration proto for the box coder to be used in the object detection
+// pipeline. See core/box_coder.py for details.
+message BoxCoder {
+  oneof box_coder_oneof {
+    FasterRcnnBoxCoder faster_rcnn_box_coder = 1;
+    MeanStddevBoxCoder mean_stddev_box_coder = 2;
+    SquareBoxCoder square_box_coder = 3;
+  }
+}
diff --git a/reconnaissance images/object_detection/protos/box_coder_pb2.py b/reconnaissance images/object_detection/protos/box_coder_pb2.py
new file mode 100644
index 0000000..21e627e
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/box_coder_pb2.py	
@@ -0,0 +1,102 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/box_coder.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import faster_rcnn_box_coder_pb2 as object__detection_dot_protos_dot_faster__rcnn__box__coder__pb2
+from object_detection.protos import mean_stddev_box_coder_pb2 as object__detection_dot_protos_dot_mean__stddev__box__coder__pb2
+from object_detection.protos import square_box_coder_pb2 as object__detection_dot_protos_dot_square__box__coder__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/box_coder.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n\'object_detection/protos/box_coder.proto\x12\x17object_detection.protos\x1a\x33object_detection/protos/faster_rcnn_box_coder.proto\x1a\x33object_detection/protos/mean_stddev_box_coder.proto\x1a.object_detection/protos/square_box_coder.proto\"\xfe\x01\n\x08\x42oxCoder\x12L\n\x15\x66\x61ster_rcnn_box_coder\x18\x01 \x01(\x0b\x32+.object_detection.protos.FasterRcnnBoxCoderH\x00\x12L\n\x15mean_stddev_box_coder\x18\x02 \x01(\x0b\x32+.object_detection.protos.MeanStddevBoxCoderH\x00\x12\x43\n\x10square_box_coder\x18\x03 \x01(\x0b\x32\'.object_detection.protos.SquareBoxCoderH\x00\x42\x11\n\x0f\x62ox_coder_oneof')
+  ,
+  dependencies=[object__detection_dot_protos_dot_faster__rcnn__box__coder__pb2.DESCRIPTOR,object__detection_dot_protos_dot_mean__stddev__box__coder__pb2.DESCRIPTOR,object__detection_dot_protos_dot_square__box__coder__pb2.DESCRIPTOR,])
+
+
+
+
+_BOXCODER = _descriptor.Descriptor(
+  name='BoxCoder',
+  full_name='object_detection.protos.BoxCoder',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='faster_rcnn_box_coder', full_name='object_detection.protos.BoxCoder.faster_rcnn_box_coder', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='mean_stddev_box_coder', full_name='object_detection.protos.BoxCoder.mean_stddev_box_coder', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='square_box_coder', full_name='object_detection.protos.BoxCoder.square_box_coder', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='box_coder_oneof', full_name='object_detection.protos.BoxCoder.box_coder_oneof',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=223,
+  serialized_end=477,
+)
+
+_BOXCODER.fields_by_name['faster_rcnn_box_coder'].message_type = object__detection_dot_protos_dot_faster__rcnn__box__coder__pb2._FASTERRCNNBOXCODER
+_BOXCODER.fields_by_name['mean_stddev_box_coder'].message_type = object__detection_dot_protos_dot_mean__stddev__box__coder__pb2._MEANSTDDEVBOXCODER
+_BOXCODER.fields_by_name['square_box_coder'].message_type = object__detection_dot_protos_dot_square__box__coder__pb2._SQUAREBOXCODER
+_BOXCODER.oneofs_by_name['box_coder_oneof'].fields.append(
+  _BOXCODER.fields_by_name['faster_rcnn_box_coder'])
+_BOXCODER.fields_by_name['faster_rcnn_box_coder'].containing_oneof = _BOXCODER.oneofs_by_name['box_coder_oneof']
+_BOXCODER.oneofs_by_name['box_coder_oneof'].fields.append(
+  _BOXCODER.fields_by_name['mean_stddev_box_coder'])
+_BOXCODER.fields_by_name['mean_stddev_box_coder'].containing_oneof = _BOXCODER.oneofs_by_name['box_coder_oneof']
+_BOXCODER.oneofs_by_name['box_coder_oneof'].fields.append(
+  _BOXCODER.fields_by_name['square_box_coder'])
+_BOXCODER.fields_by_name['square_box_coder'].containing_oneof = _BOXCODER.oneofs_by_name['box_coder_oneof']
+DESCRIPTOR.message_types_by_name['BoxCoder'] = _BOXCODER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+BoxCoder = _reflection.GeneratedProtocolMessageType('BoxCoder', (_message.Message,), dict(
+  DESCRIPTOR = _BOXCODER,
+  __module__ = 'object_detection.protos.box_coder_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.BoxCoder)
+  ))
+_sym_db.RegisterMessage(BoxCoder)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/box_predictor.proto b/reconnaissance images/object_detection/protos/box_predictor.proto
new file mode 100644
index 0000000..96c501c
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/box_predictor.proto	
@@ -0,0 +1,99 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+import "object_detection/protos/hyperparams.proto";
+
+
+// Configuration proto for box predictor. See core/box_predictor.py for details.
+message BoxPredictor {
+  oneof box_predictor_oneof {
+    ConvolutionalBoxPredictor convolutional_box_predictor = 1;
+    MaskRCNNBoxPredictor mask_rcnn_box_predictor = 2;
+    RfcnBoxPredictor rfcn_box_predictor = 3;
+  }
+}
+
+// Configuration proto for Convolutional box predictor.
+message ConvolutionalBoxPredictor {
+  // Hyperparameters for convolution ops used in the box predictor.
+  optional Hyperparams conv_hyperparams = 1;
+
+  // Minumum feature depth prior to predicting box encodings and class
+  // predictions.
+  optional int32 min_depth = 2 [default = 0];
+
+  // Maximum feature depth prior to predicting box encodings and class
+  // predictions. If max_depth is set to 0, no additional feature map will be
+  // inserted before location and class predictions.
+  optional int32 max_depth = 3 [default = 0];
+
+  // Number of the additional conv layers before the predictor.
+  optional int32 num_layers_before_predictor = 4 [default = 0];
+
+  // Whether to use dropout for class prediction.
+  optional bool use_dropout = 5 [default = true];
+
+  // Keep probability for dropout
+  optional float dropout_keep_probability = 6 [default = 0.8];
+
+  // Size of final convolution kernel. If the spatial resolution of the feature
+  // map is smaller than the kernel size, then the kernel size is set to
+  // min(feature_width, feature_height).
+  optional int32 kernel_size = 7 [default = 1];
+
+  // Size of the encoding for boxes.
+  optional int32 box_code_size = 8 [default = 4];
+
+  // Whether to apply sigmoid to the output of class predictions.
+  // TODO: Do we need this since we have a post processing module.?
+  optional bool apply_sigmoid_to_scores = 9 [default = false];
+}
+
+message MaskRCNNBoxPredictor {
+  // Hyperparameters for fully connected ops used in the box predictor.
+  optional Hyperparams fc_hyperparams = 1;
+
+  // Whether to use dropout op prior to the both box and class predictions.
+  optional bool use_dropout = 2 [default= false];
+
+  // Keep probability for dropout. This is only used if use_dropout is true.
+  optional float dropout_keep_probability = 3 [default = 0.5];
+
+  // Size of the encoding for the boxes.
+  optional int32 box_code_size = 4 [default = 4];
+
+  // Hyperparameters for convolution ops used in the box predictor.
+  optional Hyperparams conv_hyperparams = 5;
+
+  // Whether to predict instance masks inside detection boxes.
+  optional bool predict_instance_masks = 6 [default = false];
+
+  // The depth for the first conv2d_transpose op  applied to the
+  // image_features in the mask prediciton branch
+  optional int32 mask_prediction_conv_depth = 7 [default = 256];
+
+  // Whether to predict keypoints inside detection boxes.
+  optional bool predict_keypoints = 8 [default = false];
+}
+
+message RfcnBoxPredictor {
+  // Hyperparameters for convolution ops used in the box predictor.
+  optional Hyperparams conv_hyperparams = 1;
+
+  // Bin sizes for RFCN crops.
+  optional int32 num_spatial_bins_height = 2 [default = 3];
+
+  optional int32 num_spatial_bins_width = 3 [default = 3];
+
+  // Target depth to reduce the input image features to.
+  optional int32 depth = 4 [default=1024];
+
+  // Size of the encoding for the boxes.
+  optional int32 box_code_size = 5 [default = 4];
+
+  // Size to resize the rfcn crops to.
+  optional int32 crop_height = 6 [default= 12];
+
+  optional int32 crop_width = 7 [default=12];
+}
diff --git a/reconnaissance images/object_detection/protos/box_predictor_pb2.py b/reconnaissance images/object_detection/protos/box_predictor_pb2.py
new file mode 100644
index 0000000..e6c3388
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/box_predictor_pb2.py	
@@ -0,0 +1,368 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/box_predictor.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import hyperparams_pb2 as object__detection_dot_protos_dot_hyperparams__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/box_predictor.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n+object_detection/protos/box_predictor.proto\x12\x17object_detection.protos\x1a)object_detection/protos/hyperparams.proto\"\x9b\x02\n\x0c\x42oxPredictor\x12Y\n\x1b\x63onvolutional_box_predictor\x18\x01 \x01(\x0b\x32\x32.object_detection.protos.ConvolutionalBoxPredictorH\x00\x12P\n\x17mask_rcnn_box_predictor\x18\x02 \x01(\x0b\x32-.object_detection.protos.MaskRCNNBoxPredictorH\x00\x12G\n\x12rfcn_box_predictor\x18\x03 \x01(\x0b\x32).object_detection.protos.RfcnBoxPredictorH\x00\x42\x15\n\x13\x62ox_predictor_oneof\"\xcb\x02\n\x19\x43onvolutionalBoxPredictor\x12>\n\x10\x63onv_hyperparams\x18\x01 \x01(\x0b\x32$.object_detection.protos.Hyperparams\x12\x14\n\tmin_depth\x18\x02 \x01(\x05:\x01\x30\x12\x14\n\tmax_depth\x18\x03 \x01(\x05:\x01\x30\x12&\n\x1bnum_layers_before_predictor\x18\x04 \x01(\x05:\x01\x30\x12\x19\n\x0buse_dropout\x18\x05 \x01(\x08:\x04true\x12%\n\x18\x64ropout_keep_probability\x18\x06 \x01(\x02:\x03\x30.8\x12\x16\n\x0bkernel_size\x18\x07 \x01(\x05:\x01\x31\x12\x18\n\rbox_code_size\x18\x08 \x01(\x05:\x01\x34\x12&\n\x17\x61pply_sigmoid_to_scores\x18\t \x01(\x08:\x05\x66\x61lse\"\xe3\x02\n\x14MaskRCNNBoxPredictor\x12<\n\x0e\x66\x63_hyperparams\x18\x01 \x01(\x0b\x32$.object_detection.protos.Hyperparams\x12\x1a\n\x0buse_dropout\x18\x02 \x01(\x08:\x05\x66\x61lse\x12%\n\x18\x64ropout_keep_probability\x18\x03 \x01(\x02:\x03\x30.5\x12\x18\n\rbox_code_size\x18\x04 \x01(\x05:\x01\x34\x12>\n\x10\x63onv_hyperparams\x18\x05 \x01(\x0b\x32$.object_detection.protos.Hyperparams\x12%\n\x16predict_instance_masks\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\'\n\x1amask_prediction_conv_depth\x18\x07 \x01(\x05:\x03\x32\x35\x36\x12 \n\x11predict_keypoints\x18\x08 \x01(\x08:\x05\x66\x61lse\"\xf9\x01\n\x10RfcnBoxPredictor\x12>\n\x10\x63onv_hyperparams\x18\x01 \x01(\x0b\x32$.object_detection.protos.Hyperparams\x12\"\n\x17num_spatial_bins_height\x18\x02 \x01(\x05:\x01\x33\x12!\n\x16num_spatial_bins_width\x18\x03 \x01(\x05:\x01\x33\x12\x13\n\x05\x64\x65pth\x18\x04 \x01(\x05:\x04\x31\x30\x32\x34\x12\x18\n\rbox_code_size\x18\x05 \x01(\x05:\x01\x34\x12\x17\n\x0b\x63rop_height\x18\x06 \x01(\x05:\x02\x31\x32\x12\x16\n\ncrop_width\x18\x07 \x01(\x05:\x02\x31\x32')
+  ,
+  dependencies=[object__detection_dot_protos_dot_hyperparams__pb2.DESCRIPTOR,])
+
+
+
+
+_BOXPREDICTOR = _descriptor.Descriptor(
+  name='BoxPredictor',
+  full_name='object_detection.protos.BoxPredictor',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='convolutional_box_predictor', full_name='object_detection.protos.BoxPredictor.convolutional_box_predictor', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='mask_rcnn_box_predictor', full_name='object_detection.protos.BoxPredictor.mask_rcnn_box_predictor', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='rfcn_box_predictor', full_name='object_detection.protos.BoxPredictor.rfcn_box_predictor', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='box_predictor_oneof', full_name='object_detection.protos.BoxPredictor.box_predictor_oneof',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=116,
+  serialized_end=399,
+)
+
+
+_CONVOLUTIONALBOXPREDICTOR = _descriptor.Descriptor(
+  name='ConvolutionalBoxPredictor',
+  full_name='object_detection.protos.ConvolutionalBoxPredictor',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='conv_hyperparams', full_name='object_detection.protos.ConvolutionalBoxPredictor.conv_hyperparams', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_depth', full_name='object_detection.protos.ConvolutionalBoxPredictor.min_depth', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_depth', full_name='object_detection.protos.ConvolutionalBoxPredictor.max_depth', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_layers_before_predictor', full_name='object_detection.protos.ConvolutionalBoxPredictor.num_layers_before_predictor', index=3,
+      number=4, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='use_dropout', full_name='object_detection.protos.ConvolutionalBoxPredictor.use_dropout', index=4,
+      number=5, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='dropout_keep_probability', full_name='object_detection.protos.ConvolutionalBoxPredictor.dropout_keep_probability', index=5,
+      number=6, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.8),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='kernel_size', full_name='object_detection.protos.ConvolutionalBoxPredictor.kernel_size', index=6,
+      number=7, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=1,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='box_code_size', full_name='object_detection.protos.ConvolutionalBoxPredictor.box_code_size', index=7,
+      number=8, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=4,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='apply_sigmoid_to_scores', full_name='object_detection.protos.ConvolutionalBoxPredictor.apply_sigmoid_to_scores', index=8,
+      number=9, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=402,
+  serialized_end=733,
+)
+
+
+_MASKRCNNBOXPREDICTOR = _descriptor.Descriptor(
+  name='MaskRCNNBoxPredictor',
+  full_name='object_detection.protos.MaskRCNNBoxPredictor',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='fc_hyperparams', full_name='object_detection.protos.MaskRCNNBoxPredictor.fc_hyperparams', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='use_dropout', full_name='object_detection.protos.MaskRCNNBoxPredictor.use_dropout', index=1,
+      number=2, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='dropout_keep_probability', full_name='object_detection.protos.MaskRCNNBoxPredictor.dropout_keep_probability', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='box_code_size', full_name='object_detection.protos.MaskRCNNBoxPredictor.box_code_size', index=3,
+      number=4, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=4,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='conv_hyperparams', full_name='object_detection.protos.MaskRCNNBoxPredictor.conv_hyperparams', index=4,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='predict_instance_masks', full_name='object_detection.protos.MaskRCNNBoxPredictor.predict_instance_masks', index=5,
+      number=6, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='mask_prediction_conv_depth', full_name='object_detection.protos.MaskRCNNBoxPredictor.mask_prediction_conv_depth', index=6,
+      number=7, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=256,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='predict_keypoints', full_name='object_detection.protos.MaskRCNNBoxPredictor.predict_keypoints', index=7,
+      number=8, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=736,
+  serialized_end=1091,
+)
+
+
+_RFCNBOXPREDICTOR = _descriptor.Descriptor(
+  name='RfcnBoxPredictor',
+  full_name='object_detection.protos.RfcnBoxPredictor',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='conv_hyperparams', full_name='object_detection.protos.RfcnBoxPredictor.conv_hyperparams', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_spatial_bins_height', full_name='object_detection.protos.RfcnBoxPredictor.num_spatial_bins_height', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=3,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_spatial_bins_width', full_name='object_detection.protos.RfcnBoxPredictor.num_spatial_bins_width', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=3,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='depth', full_name='object_detection.protos.RfcnBoxPredictor.depth', index=3,
+      number=4, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=1024,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='box_code_size', full_name='object_detection.protos.RfcnBoxPredictor.box_code_size', index=4,
+      number=5, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=4,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='crop_height', full_name='object_detection.protos.RfcnBoxPredictor.crop_height', index=5,
+      number=6, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=12,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='crop_width', full_name='object_detection.protos.RfcnBoxPredictor.crop_width', index=6,
+      number=7, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=12,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1094,
+  serialized_end=1343,
+)
+
+_BOXPREDICTOR.fields_by_name['convolutional_box_predictor'].message_type = _CONVOLUTIONALBOXPREDICTOR
+_BOXPREDICTOR.fields_by_name['mask_rcnn_box_predictor'].message_type = _MASKRCNNBOXPREDICTOR
+_BOXPREDICTOR.fields_by_name['rfcn_box_predictor'].message_type = _RFCNBOXPREDICTOR
+_BOXPREDICTOR.oneofs_by_name['box_predictor_oneof'].fields.append(
+  _BOXPREDICTOR.fields_by_name['convolutional_box_predictor'])
+_BOXPREDICTOR.fields_by_name['convolutional_box_predictor'].containing_oneof = _BOXPREDICTOR.oneofs_by_name['box_predictor_oneof']
+_BOXPREDICTOR.oneofs_by_name['box_predictor_oneof'].fields.append(
+  _BOXPREDICTOR.fields_by_name['mask_rcnn_box_predictor'])
+_BOXPREDICTOR.fields_by_name['mask_rcnn_box_predictor'].containing_oneof = _BOXPREDICTOR.oneofs_by_name['box_predictor_oneof']
+_BOXPREDICTOR.oneofs_by_name['box_predictor_oneof'].fields.append(
+  _BOXPREDICTOR.fields_by_name['rfcn_box_predictor'])
+_BOXPREDICTOR.fields_by_name['rfcn_box_predictor'].containing_oneof = _BOXPREDICTOR.oneofs_by_name['box_predictor_oneof']
+_CONVOLUTIONALBOXPREDICTOR.fields_by_name['conv_hyperparams'].message_type = object__detection_dot_protos_dot_hyperparams__pb2._HYPERPARAMS
+_MASKRCNNBOXPREDICTOR.fields_by_name['fc_hyperparams'].message_type = object__detection_dot_protos_dot_hyperparams__pb2._HYPERPARAMS
+_MASKRCNNBOXPREDICTOR.fields_by_name['conv_hyperparams'].message_type = object__detection_dot_protos_dot_hyperparams__pb2._HYPERPARAMS
+_RFCNBOXPREDICTOR.fields_by_name['conv_hyperparams'].message_type = object__detection_dot_protos_dot_hyperparams__pb2._HYPERPARAMS
+DESCRIPTOR.message_types_by_name['BoxPredictor'] = _BOXPREDICTOR
+DESCRIPTOR.message_types_by_name['ConvolutionalBoxPredictor'] = _CONVOLUTIONALBOXPREDICTOR
+DESCRIPTOR.message_types_by_name['MaskRCNNBoxPredictor'] = _MASKRCNNBOXPREDICTOR
+DESCRIPTOR.message_types_by_name['RfcnBoxPredictor'] = _RFCNBOXPREDICTOR
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+BoxPredictor = _reflection.GeneratedProtocolMessageType('BoxPredictor', (_message.Message,), dict(
+  DESCRIPTOR = _BOXPREDICTOR,
+  __module__ = 'object_detection.protos.box_predictor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.BoxPredictor)
+  ))
+_sym_db.RegisterMessage(BoxPredictor)
+
+ConvolutionalBoxPredictor = _reflection.GeneratedProtocolMessageType('ConvolutionalBoxPredictor', (_message.Message,), dict(
+  DESCRIPTOR = _CONVOLUTIONALBOXPREDICTOR,
+  __module__ = 'object_detection.protos.box_predictor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ConvolutionalBoxPredictor)
+  ))
+_sym_db.RegisterMessage(ConvolutionalBoxPredictor)
+
+MaskRCNNBoxPredictor = _reflection.GeneratedProtocolMessageType('MaskRCNNBoxPredictor', (_message.Message,), dict(
+  DESCRIPTOR = _MASKRCNNBOXPREDICTOR,
+  __module__ = 'object_detection.protos.box_predictor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.MaskRCNNBoxPredictor)
+  ))
+_sym_db.RegisterMessage(MaskRCNNBoxPredictor)
+
+RfcnBoxPredictor = _reflection.GeneratedProtocolMessageType('RfcnBoxPredictor', (_message.Message,), dict(
+  DESCRIPTOR = _RFCNBOXPREDICTOR,
+  __module__ = 'object_detection.protos.box_predictor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RfcnBoxPredictor)
+  ))
+_sym_db.RegisterMessage(RfcnBoxPredictor)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/eval.proto b/reconnaissance images/object_detection/protos/eval.proto
new file mode 100644
index 0000000..081b60d
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/eval.proto	
@@ -0,0 +1,47 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Message for configuring DetectionModel evaluation jobs (eval.py).
+message EvalConfig {
+  // Number of visualization images to generate.
+  optional uint32 num_visualizations = 1 [default=10];
+
+  // Number of examples to process of evaluation.
+  optional uint32 num_examples = 2 [default=5000];
+
+  // How often to run evaluation.
+  optional uint32 eval_interval_secs = 3 [default=300];
+
+  // Maximum number of times to run evaluation. If set to 0, will run forever.
+  optional uint32 max_evals = 4 [default=0];
+
+  // Whether the TensorFlow graph used for evaluation should be saved to disk.
+  optional bool save_graph = 5 [default=false];
+
+  // Path to directory to store visualizations in. If empty, visualization
+  // images are not exported (only shown on Tensorboard).
+  optional string visualization_export_dir = 6 [default=""];
+
+  // BNS name of the TensorFlow master.
+  optional string eval_master = 7 [default=""];
+
+  // Type of metrics to use for evaluation. Currently supports only Pascal VOC
+  // detection metrics.
+  optional string metrics_set = 8 [default="pascal_voc_metrics"];
+
+  // Path to export detections to COCO compatible JSON format.
+  optional string export_path = 9 [default=''];
+
+  // Option to not read groundtruth labels and only export detections to
+  // COCO-compatible JSON file.
+  optional bool ignore_groundtruth = 10 [default=false];
+
+  // Use exponential moving averages of variables for evaluation.
+  // TODO: When this is false make sure the model is constructed
+  // without moving averages in restore_fn.
+  optional bool use_moving_averages = 11 [default=false];
+
+  // Whether to evaluate instance masks.
+  optional bool eval_instance_masks = 12 [default=false];
+}
diff --git a/reconnaissance images/object_detection/protos/eval_pb2.py b/reconnaissance images/object_detection/protos/eval_pb2.py
new file mode 100644
index 0000000..39cc2e4
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/eval_pb2.py	
@@ -0,0 +1,146 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/eval.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/eval.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n\"object_detection/protos/eval.proto\x12\x17object_detection.protos\"\x80\x03\n\nEvalConfig\x12\x1e\n\x12num_visualizations\x18\x01 \x01(\r:\x02\x31\x30\x12\x1a\n\x0cnum_examples\x18\x02 \x01(\r:\x04\x35\x30\x30\x30\x12\x1f\n\x12\x65val_interval_secs\x18\x03 \x01(\r:\x03\x33\x30\x30\x12\x14\n\tmax_evals\x18\x04 \x01(\r:\x01\x30\x12\x19\n\nsave_graph\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\"\n\x18visualization_export_dir\x18\x06 \x01(\t:\x00\x12\x15\n\x0b\x65val_master\x18\x07 \x01(\t:\x00\x12\'\n\x0bmetrics_set\x18\x08 \x01(\t:\x12pascal_voc_metrics\x12\x15\n\x0b\x65xport_path\x18\t \x01(\t:\x00\x12!\n\x12ignore_groundtruth\x18\n \x01(\x08:\x05\x66\x61lse\x12\"\n\x13use_moving_averages\x18\x0b \x01(\x08:\x05\x66\x61lse\x12\"\n\x13\x65val_instance_masks\x18\x0c \x01(\x08:\x05\x66\x61lse')
+)
+
+
+
+
+_EVALCONFIG = _descriptor.Descriptor(
+  name='EvalConfig',
+  full_name='object_detection.protos.EvalConfig',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='num_visualizations', full_name='object_detection.protos.EvalConfig.num_visualizations', index=0,
+      number=1, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=10,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_examples', full_name='object_detection.protos.EvalConfig.num_examples', index=1,
+      number=2, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=5000,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='eval_interval_secs', full_name='object_detection.protos.EvalConfig.eval_interval_secs', index=2,
+      number=3, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=300,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_evals', full_name='object_detection.protos.EvalConfig.max_evals', index=3,
+      number=4, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='save_graph', full_name='object_detection.protos.EvalConfig.save_graph', index=4,
+      number=5, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='visualization_export_dir', full_name='object_detection.protos.EvalConfig.visualization_export_dir', index=5,
+      number=6, type=9, cpp_type=9, label=1,
+      has_default_value=True, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='eval_master', full_name='object_detection.protos.EvalConfig.eval_master', index=6,
+      number=7, type=9, cpp_type=9, label=1,
+      has_default_value=True, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='metrics_set', full_name='object_detection.protos.EvalConfig.metrics_set', index=7,
+      number=8, type=9, cpp_type=9, label=1,
+      has_default_value=True, default_value=_b("pascal_voc_metrics").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='export_path', full_name='object_detection.protos.EvalConfig.export_path', index=8,
+      number=9, type=9, cpp_type=9, label=1,
+      has_default_value=True, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='ignore_groundtruth', full_name='object_detection.protos.EvalConfig.ignore_groundtruth', index=9,
+      number=10, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='use_moving_averages', full_name='object_detection.protos.EvalConfig.use_moving_averages', index=10,
+      number=11, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='eval_instance_masks', full_name='object_detection.protos.EvalConfig.eval_instance_masks', index=11,
+      number=12, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=64,
+  serialized_end=448,
+)
+
+DESCRIPTOR.message_types_by_name['EvalConfig'] = _EVALCONFIG
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+EvalConfig = _reflection.GeneratedProtocolMessageType('EvalConfig', (_message.Message,), dict(
+  DESCRIPTOR = _EVALCONFIG,
+  __module__ = 'object_detection.protos.eval_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.EvalConfig)
+  ))
+_sym_db.RegisterMessage(EvalConfig)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/faster_rcnn.proto b/reconnaissance images/object_detection/protos/faster_rcnn.proto
new file mode 100644
index 0000000..e2fd5d6
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/faster_rcnn.proto	
@@ -0,0 +1,131 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+import "object_detection/protos/anchor_generator.proto";
+import "object_detection/protos/box_predictor.proto";
+import "object_detection/protos/hyperparams.proto";
+import "object_detection/protos/image_resizer.proto";
+import "object_detection/protos/losses.proto";
+import "object_detection/protos/post_processing.proto";
+
+// Configuration for Faster R-CNN models.
+// See meta_architectures/faster_rcnn_meta_arch.py and models/model_builder.py
+//
+// Naming conventions:
+// Faster R-CNN models have two stages: a first stage region proposal network
+// (or RPN) and a second stage box classifier.  We thus use the prefixes
+// `first_stage_` and `second_stage_` to indicate the stage to which each
+// parameter pertains when relevant.
+message FasterRcnn {
+
+  // Whether to construct only the Region Proposal Network (RPN).
+  optional bool first_stage_only = 1 [default=false];
+
+  // Number of classes to predict.
+  optional int32 num_classes = 3;
+
+  // Image resizer for preprocessing the input image.
+  optional ImageResizer image_resizer = 4;
+
+  // Feature extractor config.
+  optional FasterRcnnFeatureExtractor feature_extractor = 5;
+
+
+  // (First stage) region proposal network (RPN) parameters.
+
+  // Anchor generator to compute RPN anchors.
+  optional AnchorGenerator first_stage_anchor_generator = 6;
+
+  // Atrous rate for the convolution op applied to the
+  // `first_stage_features_to_crop` tensor to obtain box predictions.
+  optional int32 first_stage_atrous_rate = 7 [default=1];
+
+  // Hyperparameters for the convolutional RPN box predictor.
+  optional Hyperparams first_stage_box_predictor_conv_hyperparams = 8;
+
+  // Kernel size to use for the convolution op just prior to RPN box
+  // predictions.
+  optional int32 first_stage_box_predictor_kernel_size = 9 [default=3];
+
+  // Output depth for the convolution op just prior to RPN box predictions.
+  optional int32 first_stage_box_predictor_depth = 10 [default=512];
+
+  // The batch size to use for computing the first stage objectness and
+  // location losses.
+  optional int32 first_stage_minibatch_size = 11 [default=256];
+
+  // Fraction of positive examples per image for the RPN.
+  optional float first_stage_positive_balance_fraction = 12 [default=0.5];
+
+  // Non max suppression score threshold applied to first stage RPN proposals.
+  optional float first_stage_nms_score_threshold = 13 [default=0.0];
+
+  // Non max suppression IOU threshold applied to first stage RPN proposals.
+  optional float first_stage_nms_iou_threshold = 14 [default=0.7];
+
+  // Maximum number of RPN proposals retained after first stage postprocessing.
+  optional int32 first_stage_max_proposals = 15 [default=300];
+
+  // First stage RPN localization loss weight.
+  optional float first_stage_localization_loss_weight = 16 [default=1.0];
+
+  // First stage RPN objectness loss weight.
+  optional float first_stage_objectness_loss_weight = 17 [default=1.0];
+
+
+  // Per-region cropping parameters.
+  // Note that if a R-FCN model is constructed the per region cropping
+  // parameters below are ignored.
+
+  // Output size (width and height are set to be the same) of the initial
+  // bilinear interpolation based cropping during ROI pooling.
+  optional int32 initial_crop_size = 18;
+
+  // Kernel size of the max pool op on the cropped feature map during
+  // ROI pooling.
+  optional int32 maxpool_kernel_size = 19;
+
+  // Stride of the max pool op on the cropped feature map during ROI pooling.
+  optional int32 maxpool_stride = 20;
+
+
+  // (Second stage) box classifier parameters
+
+  // Hyperparameters for the second stage box predictor. If box predictor type
+  // is set to rfcn_box_predictor, a R-FCN model is constructed, otherwise a
+  // Faster R-CNN model is constructed.
+  optional BoxPredictor second_stage_box_predictor  = 21;
+
+  // The batch size per image used for computing the classification and refined
+  // location loss of the box classifier.
+  // Note that this field is ignored if `hard_example_miner` is configured.
+  optional int32 second_stage_batch_size = 22 [default=64];
+
+  // Fraction of positive examples to use per image for the box classifier.
+  optional float second_stage_balance_fraction = 23 [default=0.25];
+
+  // Post processing to apply on the second stage box classifier predictions.
+  // Note: the `score_converter` provided to the FasterRCNNMetaArch constructor
+  // is taken from this `second_stage_post_processing` proto.
+  optional PostProcessing second_stage_post_processing = 24;
+
+  // Second stage refined localization loss weight.
+  optional float second_stage_localization_loss_weight = 25 [default=1.0];
+
+  // Second stage classification loss weight
+  optional float second_stage_classification_loss_weight = 26 [default=1.0];
+
+  // If not left to default, applies hard example mining.
+  optional HardExampleMiner hard_example_miner = 27;
+}
+
+
+message FasterRcnnFeatureExtractor {
+  // Type of Faster R-CNN model (e.g., 'faster_rcnn_resnet101';
+  // See models/model_builder.py for expected types).
+  optional string type = 1;
+
+  // Output stride of extracted RPN feature map.
+  optional int32 first_stage_features_stride = 2 [default=16];
+}
diff --git a/reconnaissance images/object_detection/protos/faster_rcnn_box_coder.proto b/reconnaissance images/object_detection/protos/faster_rcnn_box_coder.proto
new file mode 100644
index 0000000..512a20a
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/faster_rcnn_box_coder.proto	
@@ -0,0 +1,17 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for FasterRCNNBoxCoder. See
+// box_coders/faster_rcnn_box_coder.py for details.
+message FasterRcnnBoxCoder {
+  // Scale factor for anchor encoded box center.
+  optional float y_scale = 1 [default = 10.0];
+  optional float x_scale = 2 [default = 10.0];
+
+  // Scale factor for anchor encoded box height.
+  optional float height_scale = 3 [default = 5.0];
+
+  // Scale factor for anchor encoded box width.
+  optional float width_scale = 4 [default = 5.0];
+}
diff --git a/reconnaissance images/object_detection/protos/faster_rcnn_box_coder_pb2.py b/reconnaissance images/object_detection/protos/faster_rcnn_box_coder_pb2.py
new file mode 100644
index 0000000..156e8a8
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/faster_rcnn_box_coder_pb2.py	
@@ -0,0 +1,90 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/faster_rcnn_box_coder.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/faster_rcnn_box_coder.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n3object_detection/protos/faster_rcnn_box_coder.proto\x12\x17object_detection.protos\"o\n\x12\x46\x61sterRcnnBoxCoder\x12\x13\n\x07y_scale\x18\x01 \x01(\x02:\x02\x31\x30\x12\x13\n\x07x_scale\x18\x02 \x01(\x02:\x02\x31\x30\x12\x17\n\x0cheight_scale\x18\x03 \x01(\x02:\x01\x35\x12\x16\n\x0bwidth_scale\x18\x04 \x01(\x02:\x01\x35')
+)
+
+
+
+
+_FASTERRCNNBOXCODER = _descriptor.Descriptor(
+  name='FasterRcnnBoxCoder',
+  full_name='object_detection.protos.FasterRcnnBoxCoder',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='y_scale', full_name='object_detection.protos.FasterRcnnBoxCoder.y_scale', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(10),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='x_scale', full_name='object_detection.protos.FasterRcnnBoxCoder.x_scale', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(10),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='height_scale', full_name='object_detection.protos.FasterRcnnBoxCoder.height_scale', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='width_scale', full_name='object_detection.protos.FasterRcnnBoxCoder.width_scale', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=80,
+  serialized_end=191,
+)
+
+DESCRIPTOR.message_types_by_name['FasterRcnnBoxCoder'] = _FASTERRCNNBOXCODER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+FasterRcnnBoxCoder = _reflection.GeneratedProtocolMessageType('FasterRcnnBoxCoder', (_message.Message,), dict(
+  DESCRIPTOR = _FASTERRCNNBOXCODER,
+  __module__ = 'object_detection.protos.faster_rcnn_box_coder_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.FasterRcnnBoxCoder)
+  ))
+_sym_db.RegisterMessage(FasterRcnnBoxCoder)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/faster_rcnn_pb2.py b/reconnaissance images/object_detection/protos/faster_rcnn_pb2.py
new file mode 100644
index 0000000..da9996f
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/faster_rcnn_pb2.py	
@@ -0,0 +1,304 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/faster_rcnn.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import anchor_generator_pb2 as object__detection_dot_protos_dot_anchor__generator__pb2
+from object_detection.protos import box_predictor_pb2 as object__detection_dot_protos_dot_box__predictor__pb2
+from object_detection.protos import hyperparams_pb2 as object__detection_dot_protos_dot_hyperparams__pb2
+from object_detection.protos import image_resizer_pb2 as object__detection_dot_protos_dot_image__resizer__pb2
+from object_detection.protos import losses_pb2 as object__detection_dot_protos_dot_losses__pb2
+from object_detection.protos import post_processing_pb2 as object__detection_dot_protos_dot_post__processing__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/faster_rcnn.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n)object_detection/protos/faster_rcnn.proto\x12\x17object_detection.protos\x1a.object_detection/protos/anchor_generator.proto\x1a+object_detection/protos/box_predictor.proto\x1a)object_detection/protos/hyperparams.proto\x1a+object_detection/protos/image_resizer.proto\x1a$object_detection/protos/losses.proto\x1a-object_detection/protos/post_processing.proto\"\xa4\n\n\nFasterRcnn\x12\x1f\n\x10\x66irst_stage_only\x18\x01 \x01(\x08:\x05\x66\x61lse\x12\x13\n\x0bnum_classes\x18\x03 \x01(\x05\x12<\n\rimage_resizer\x18\x04 \x01(\x0b\x32%.object_detection.protos.ImageResizer\x12N\n\x11\x66\x65\x61ture_extractor\x18\x05 \x01(\x0b\x32\x33.object_detection.protos.FasterRcnnFeatureExtractor\x12N\n\x1c\x66irst_stage_anchor_generator\x18\x06 \x01(\x0b\x32(.object_detection.protos.AnchorGenerator\x12\"\n\x17\x66irst_stage_atrous_rate\x18\x07 \x01(\x05:\x01\x31\x12X\n*first_stage_box_predictor_conv_hyperparams\x18\x08 \x01(\x0b\x32$.object_detection.protos.Hyperparams\x12\x30\n%first_stage_box_predictor_kernel_size\x18\t \x01(\x05:\x01\x33\x12,\n\x1f\x66irst_stage_box_predictor_depth\x18\n \x01(\x05:\x03\x35\x31\x32\x12\'\n\x1a\x66irst_stage_minibatch_size\x18\x0b \x01(\x05:\x03\x32\x35\x36\x12\x32\n%first_stage_positive_balance_fraction\x18\x0c \x01(\x02:\x03\x30.5\x12*\n\x1f\x66irst_stage_nms_score_threshold\x18\r \x01(\x02:\x01\x30\x12*\n\x1d\x66irst_stage_nms_iou_threshold\x18\x0e \x01(\x02:\x03\x30.7\x12&\n\x19\x66irst_stage_max_proposals\x18\x0f \x01(\x05:\x03\x33\x30\x30\x12/\n$first_stage_localization_loss_weight\x18\x10 \x01(\x02:\x01\x31\x12-\n\"first_stage_objectness_loss_weight\x18\x11 \x01(\x02:\x01\x31\x12\x19\n\x11initial_crop_size\x18\x12 \x01(\x05\x12\x1b\n\x13maxpool_kernel_size\x18\x13 \x01(\x05\x12\x16\n\x0emaxpool_stride\x18\x14 \x01(\x05\x12I\n\x1asecond_stage_box_predictor\x18\x15 \x01(\x0b\x32%.object_detection.protos.BoxPredictor\x12#\n\x17second_stage_batch_size\x18\x16 \x01(\x05:\x02\x36\x34\x12+\n\x1dsecond_stage_balance_fraction\x18\x17 \x01(\x02:\x04\x30.25\x12M\n\x1csecond_stage_post_processing\x18\x18 \x01(\x0b\x32\'.object_detection.protos.PostProcessing\x12\x30\n%second_stage_localization_loss_weight\x18\x19 \x01(\x02:\x01\x31\x12\x32\n\'second_stage_classification_loss_weight\x18\x1a \x01(\x02:\x01\x31\x12\x45\n\x12hard_example_miner\x18\x1b \x01(\x0b\x32).object_detection.protos.HardExampleMiner\"S\n\x1a\x46\x61sterRcnnFeatureExtractor\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\'\n\x1b\x66irst_stage_features_stride\x18\x02 \x01(\x05:\x02\x31\x36')
+  ,
+  dependencies=[object__detection_dot_protos_dot_anchor__generator__pb2.DESCRIPTOR,object__detection_dot_protos_dot_box__predictor__pb2.DESCRIPTOR,object__detection_dot_protos_dot_hyperparams__pb2.DESCRIPTOR,object__detection_dot_protos_dot_image__resizer__pb2.DESCRIPTOR,object__detection_dot_protos_dot_losses__pb2.DESCRIPTOR,object__detection_dot_protos_dot_post__processing__pb2.DESCRIPTOR,])
+
+
+
+
+_FASTERRCNN = _descriptor.Descriptor(
+  name='FasterRcnn',
+  full_name='object_detection.protos.FasterRcnn',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='first_stage_only', full_name='object_detection.protos.FasterRcnn.first_stage_only', index=0,
+      number=1, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_classes', full_name='object_detection.protos.FasterRcnn.num_classes', index=1,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='image_resizer', full_name='object_detection.protos.FasterRcnn.image_resizer', index=2,
+      number=4, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='feature_extractor', full_name='object_detection.protos.FasterRcnn.feature_extractor', index=3,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_anchor_generator', full_name='object_detection.protos.FasterRcnn.first_stage_anchor_generator', index=4,
+      number=6, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_atrous_rate', full_name='object_detection.protos.FasterRcnn.first_stage_atrous_rate', index=5,
+      number=7, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=1,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_box_predictor_conv_hyperparams', full_name='object_detection.protos.FasterRcnn.first_stage_box_predictor_conv_hyperparams', index=6,
+      number=8, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_box_predictor_kernel_size', full_name='object_detection.protos.FasterRcnn.first_stage_box_predictor_kernel_size', index=7,
+      number=9, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=3,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_box_predictor_depth', full_name='object_detection.protos.FasterRcnn.first_stage_box_predictor_depth', index=8,
+      number=10, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=512,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_minibatch_size', full_name='object_detection.protos.FasterRcnn.first_stage_minibatch_size', index=9,
+      number=11, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=256,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_positive_balance_fraction', full_name='object_detection.protos.FasterRcnn.first_stage_positive_balance_fraction', index=10,
+      number=12, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_nms_score_threshold', full_name='object_detection.protos.FasterRcnn.first_stage_nms_score_threshold', index=11,
+      number=13, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_nms_iou_threshold', full_name='object_detection.protos.FasterRcnn.first_stage_nms_iou_threshold', index=12,
+      number=14, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.7),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_max_proposals', full_name='object_detection.protos.FasterRcnn.first_stage_max_proposals', index=13,
+      number=15, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=300,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_localization_loss_weight', full_name='object_detection.protos.FasterRcnn.first_stage_localization_loss_weight', index=14,
+      number=16, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_objectness_loss_weight', full_name='object_detection.protos.FasterRcnn.first_stage_objectness_loss_weight', index=15,
+      number=17, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='initial_crop_size', full_name='object_detection.protos.FasterRcnn.initial_crop_size', index=16,
+      number=18, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='maxpool_kernel_size', full_name='object_detection.protos.FasterRcnn.maxpool_kernel_size', index=17,
+      number=19, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='maxpool_stride', full_name='object_detection.protos.FasterRcnn.maxpool_stride', index=18,
+      number=20, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='second_stage_box_predictor', full_name='object_detection.protos.FasterRcnn.second_stage_box_predictor', index=19,
+      number=21, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='second_stage_batch_size', full_name='object_detection.protos.FasterRcnn.second_stage_batch_size', index=20,
+      number=22, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=64,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='second_stage_balance_fraction', full_name='object_detection.protos.FasterRcnn.second_stage_balance_fraction', index=21,
+      number=23, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.25),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='second_stage_post_processing', full_name='object_detection.protos.FasterRcnn.second_stage_post_processing', index=22,
+      number=24, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='second_stage_localization_loss_weight', full_name='object_detection.protos.FasterRcnn.second_stage_localization_loss_weight', index=23,
+      number=25, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='second_stage_classification_loss_weight', full_name='object_detection.protos.FasterRcnn.second_stage_classification_loss_weight', index=24,
+      number=26, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='hard_example_miner', full_name='object_detection.protos.FasterRcnn.hard_example_miner', index=25,
+      number=27, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=337,
+  serialized_end=1653,
+)
+
+
+_FASTERRCNNFEATUREEXTRACTOR = _descriptor.Descriptor(
+  name='FasterRcnnFeatureExtractor',
+  full_name='object_detection.protos.FasterRcnnFeatureExtractor',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='type', full_name='object_detection.protos.FasterRcnnFeatureExtractor.type', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='first_stage_features_stride', full_name='object_detection.protos.FasterRcnnFeatureExtractor.first_stage_features_stride', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=16,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1655,
+  serialized_end=1738,
+)
+
+_FASTERRCNN.fields_by_name['image_resizer'].message_type = object__detection_dot_protos_dot_image__resizer__pb2._IMAGERESIZER
+_FASTERRCNN.fields_by_name['feature_extractor'].message_type = _FASTERRCNNFEATUREEXTRACTOR
+_FASTERRCNN.fields_by_name['first_stage_anchor_generator'].message_type = object__detection_dot_protos_dot_anchor__generator__pb2._ANCHORGENERATOR
+_FASTERRCNN.fields_by_name['first_stage_box_predictor_conv_hyperparams'].message_type = object__detection_dot_protos_dot_hyperparams__pb2._HYPERPARAMS
+_FASTERRCNN.fields_by_name['second_stage_box_predictor'].message_type = object__detection_dot_protos_dot_box__predictor__pb2._BOXPREDICTOR
+_FASTERRCNN.fields_by_name['second_stage_post_processing'].message_type = object__detection_dot_protos_dot_post__processing__pb2._POSTPROCESSING
+_FASTERRCNN.fields_by_name['hard_example_miner'].message_type = object__detection_dot_protos_dot_losses__pb2._HARDEXAMPLEMINER
+DESCRIPTOR.message_types_by_name['FasterRcnn'] = _FASTERRCNN
+DESCRIPTOR.message_types_by_name['FasterRcnnFeatureExtractor'] = _FASTERRCNNFEATUREEXTRACTOR
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+FasterRcnn = _reflection.GeneratedProtocolMessageType('FasterRcnn', (_message.Message,), dict(
+  DESCRIPTOR = _FASTERRCNN,
+  __module__ = 'object_detection.protos.faster_rcnn_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.FasterRcnn)
+  ))
+_sym_db.RegisterMessage(FasterRcnn)
+
+FasterRcnnFeatureExtractor = _reflection.GeneratedProtocolMessageType('FasterRcnnFeatureExtractor', (_message.Message,), dict(
+  DESCRIPTOR = _FASTERRCNNFEATUREEXTRACTOR,
+  __module__ = 'object_detection.protos.faster_rcnn_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.FasterRcnnFeatureExtractor)
+  ))
+_sym_db.RegisterMessage(FasterRcnnFeatureExtractor)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/grid_anchor_generator.proto b/reconnaissance images/object_detection/protos/grid_anchor_generator.proto
new file mode 100644
index 0000000..85168f8
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/grid_anchor_generator.proto	
@@ -0,0 +1,34 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for GridAnchorGenerator. See
+// anchor_generators/grid_anchor_generator.py for details.
+message GridAnchorGenerator {
+   // Anchor height in pixels.
+  optional int32 height = 1 [default = 256];
+
+  // Anchor width in pixels.
+  optional int32 width = 2 [default = 256];
+
+  // Anchor stride in height dimension in pixels.
+  optional int32 height_stride = 3 [default = 16];
+
+  // Anchor stride in width dimension in pixels.
+  optional int32 width_stride = 4 [default = 16];
+
+  // Anchor height offset in pixels.
+  optional int32 height_offset = 5 [default = 0];
+
+  // Anchor width offset in pixels.
+  optional int32 width_offset = 6 [default = 0];
+
+  // At any given location, len(scales) * len(aspect_ratios) anchors are
+  // generated with all possible combinations of scales and aspect ratios.
+
+  // List of scales for the anchors.
+  repeated float scales = 7;
+
+  // List of aspect ratios for the anchors.
+  repeated float aspect_ratios = 8;
+}
diff --git a/reconnaissance images/object_detection/protos/grid_anchor_generator_pb2.py b/reconnaissance images/object_detection/protos/grid_anchor_generator_pb2.py
new file mode 100644
index 0000000..4c8d7f8
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/grid_anchor_generator_pb2.py	
@@ -0,0 +1,118 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/grid_anchor_generator.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/grid_anchor_generator.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n3object_detection/protos/grid_anchor_generator.proto\x12\x17object_detection.protos\"\xcd\x01\n\x13GridAnchorGenerator\x12\x13\n\x06height\x18\x01 \x01(\x05:\x03\x32\x35\x36\x12\x12\n\x05width\x18\x02 \x01(\x05:\x03\x32\x35\x36\x12\x19\n\rheight_stride\x18\x03 \x01(\x05:\x02\x31\x36\x12\x18\n\x0cwidth_stride\x18\x04 \x01(\x05:\x02\x31\x36\x12\x18\n\rheight_offset\x18\x05 \x01(\x05:\x01\x30\x12\x17\n\x0cwidth_offset\x18\x06 \x01(\x05:\x01\x30\x12\x0e\n\x06scales\x18\x07 \x03(\x02\x12\x15\n\raspect_ratios\x18\x08 \x03(\x02')
+)
+
+
+
+
+_GRIDANCHORGENERATOR = _descriptor.Descriptor(
+  name='GridAnchorGenerator',
+  full_name='object_detection.protos.GridAnchorGenerator',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='height', full_name='object_detection.protos.GridAnchorGenerator.height', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=256,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='width', full_name='object_detection.protos.GridAnchorGenerator.width', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=256,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='height_stride', full_name='object_detection.protos.GridAnchorGenerator.height_stride', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=16,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='width_stride', full_name='object_detection.protos.GridAnchorGenerator.width_stride', index=3,
+      number=4, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=16,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='height_offset', full_name='object_detection.protos.GridAnchorGenerator.height_offset', index=4,
+      number=5, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='width_offset', full_name='object_detection.protos.GridAnchorGenerator.width_offset', index=5,
+      number=6, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='scales', full_name='object_detection.protos.GridAnchorGenerator.scales', index=6,
+      number=7, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='aspect_ratios', full_name='object_detection.protos.GridAnchorGenerator.aspect_ratios', index=7,
+      number=8, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=81,
+  serialized_end=286,
+)
+
+DESCRIPTOR.message_types_by_name['GridAnchorGenerator'] = _GRIDANCHORGENERATOR
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+GridAnchorGenerator = _reflection.GeneratedProtocolMessageType('GridAnchorGenerator', (_message.Message,), dict(
+  DESCRIPTOR = _GRIDANCHORGENERATOR,
+  __module__ = 'object_detection.protos.grid_anchor_generator_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.GridAnchorGenerator)
+  ))
+_sym_db.RegisterMessage(GridAnchorGenerator)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/hyperparams.proto b/reconnaissance images/object_detection/protos/hyperparams.proto
new file mode 100644
index 0000000..b8b9972
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/hyperparams.proto	
@@ -0,0 +1,103 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for the convolution op hyperparameters to use in the
+// object detection pipeline.
+message Hyperparams {
+
+  // Operations affected by hyperparameters.
+  enum Op {
+    // Convolution, Separable Convolution, Convolution transpose.
+    CONV = 1;
+
+    // Fully connected
+    FC = 2;
+  }
+  optional Op op = 1 [default = CONV];
+
+  // Regularizer for the weights of the convolution op.
+  optional Regularizer regularizer = 2;
+
+  // Initializer for the weights of the convolution op.
+  optional Initializer initializer = 3;
+
+  // Type of activation to apply after convolution.
+  enum Activation {
+    // Use None (no activation)
+    NONE = 0;
+
+    // Use tf.nn.relu
+    RELU = 1;
+
+    // Use tf.nn.relu6
+    RELU_6 = 2;
+  }
+  optional Activation activation = 4 [default = RELU];
+
+  // BatchNorm hyperparameters. If this parameter is NOT set then BatchNorm is
+  // not applied!
+  optional BatchNorm batch_norm = 5;
+}
+
+// Proto with one-of field for regularizers.
+message Regularizer {
+  oneof regularizer_oneof {
+    L1Regularizer l1_regularizer = 1;
+    L2Regularizer l2_regularizer = 2;
+  }
+}
+
+// Configuration proto for L1 Regularizer.
+// See https://www.tensorflow.org/api_docs/python/tf/contrib/layers/l1_regularizer
+message L1Regularizer {
+  optional float weight = 1 [default = 1.0];
+}
+
+// Configuration proto for L2 Regularizer.
+// See https://www.tensorflow.org/api_docs/python/tf/contrib/layers/l2_regularizer
+message L2Regularizer {
+  optional float weight = 1 [default = 1.0];
+}
+
+// Proto with one-of field for initializers.
+message Initializer {
+  oneof initializer_oneof {
+    TruncatedNormalInitializer truncated_normal_initializer = 1;
+    VarianceScalingInitializer variance_scaling_initializer = 2;
+  }
+}
+
+// Configuration proto for truncated normal initializer. See
+// https://www.tensorflow.org/api_docs/python/tf/truncated_normal_initializer
+message TruncatedNormalInitializer {
+  optional float mean = 1 [default = 0.0];
+  optional float stddev = 2 [default = 1.0];
+}
+
+// Configuration proto for variance scaling initializer. See
+// https://www.tensorflow.org/api_docs/python/tf/contrib/layers/
+// variance_scaling_initializer
+message VarianceScalingInitializer {
+  optional float factor = 1 [default = 2.0];
+  optional bool uniform = 2 [default = false];
+  enum Mode {
+    FAN_IN = 0;
+    FAN_OUT = 1;
+    FAN_AVG = 2;
+  }
+  optional Mode mode = 3 [default = FAN_IN];
+}
+
+// Configuration proto for batch norm to apply after convolution op. See
+// https://www.tensorflow.org/api_docs/python/tf/contrib/layers/batch_norm
+message BatchNorm {
+  optional float decay = 1 [default = 0.999];
+  optional bool center = 2 [default = true];
+  optional bool scale = 3 [default = false];
+  optional float epsilon = 4 [default = 0.001];
+  // Whether to train the batch norm variables. If this is set to false during
+  // training, the current value of the batch_norm variables are used for
+  // forward pass but they are never updated.
+  optional bool train = 5 [default = true];
+}
diff --git a/reconnaissance images/object_detection/protos/hyperparams_pb2.py b/reconnaissance images/object_detection/protos/hyperparams_pb2.py
new file mode 100644
index 0000000..88db05e
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/hyperparams_pb2.py	
@@ -0,0 +1,541 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/hyperparams.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/hyperparams.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n)object_detection/protos/hyperparams.proto\x12\x17object_detection.protos\"\x87\x03\n\x0bHyperparams\x12\x39\n\x02op\x18\x01 \x01(\x0e\x32\'.object_detection.protos.Hyperparams.Op:\x04\x43ONV\x12\x39\n\x0bregularizer\x18\x02 \x01(\x0b\x32$.object_detection.protos.Regularizer\x12\x39\n\x0binitializer\x18\x03 \x01(\x0b\x32$.object_detection.protos.Initializer\x12I\n\nactivation\x18\x04 \x01(\x0e\x32/.object_detection.protos.Hyperparams.Activation:\x04RELU\x12\x36\n\nbatch_norm\x18\x05 \x01(\x0b\x32\".object_detection.protos.BatchNorm\"\x16\n\x02Op\x12\x08\n\x04\x43ONV\x10\x01\x12\x06\n\x02\x46\x43\x10\x02\",\n\nActivation\x12\x08\n\x04NONE\x10\x00\x12\x08\n\x04RELU\x10\x01\x12\n\n\x06RELU_6\x10\x02\"\xa6\x01\n\x0bRegularizer\x12@\n\x0el1_regularizer\x18\x01 \x01(\x0b\x32&.object_detection.protos.L1RegularizerH\x00\x12@\n\x0el2_regularizer\x18\x02 \x01(\x0b\x32&.object_detection.protos.L2RegularizerH\x00\x42\x13\n\x11regularizer_oneof\"\"\n\rL1Regularizer\x12\x11\n\x06weight\x18\x01 \x01(\x02:\x01\x31\"\"\n\rL2Regularizer\x12\x11\n\x06weight\x18\x01 \x01(\x02:\x01\x31\"\xdc\x01\n\x0bInitializer\x12[\n\x1ctruncated_normal_initializer\x18\x01 \x01(\x0b\x32\x33.object_detection.protos.TruncatedNormalInitializerH\x00\x12[\n\x1cvariance_scaling_initializer\x18\x02 \x01(\x0b\x32\x33.object_detection.protos.VarianceScalingInitializerH\x00\x42\x13\n\x11initializer_oneof\"@\n\x1aTruncatedNormalInitializer\x12\x0f\n\x04mean\x18\x01 \x01(\x02:\x01\x30\x12\x11\n\x06stddev\x18\x02 \x01(\x02:\x01\x31\"\xc5\x01\n\x1aVarianceScalingInitializer\x12\x11\n\x06\x66\x61\x63tor\x18\x01 \x01(\x02:\x01\x32\x12\x16\n\x07uniform\x18\x02 \x01(\x08:\x05\x66\x61lse\x12N\n\x04mode\x18\x03 \x01(\x0e\x32\x38.object_detection.protos.VarianceScalingInitializer.Mode:\x06\x46\x41N_IN\",\n\x04Mode\x12\n\n\x06\x46\x41N_IN\x10\x00\x12\x0b\n\x07\x46\x41N_OUT\x10\x01\x12\x0b\n\x07\x46\x41N_AVG\x10\x02\"z\n\tBatchNorm\x12\x14\n\x05\x64\x65\x63\x61y\x18\x01 \x01(\x02:\x05\x30.999\x12\x14\n\x06\x63\x65nter\x18\x02 \x01(\x08:\x04true\x12\x14\n\x05scale\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x16\n\x07\x65psilon\x18\x04 \x01(\x02:\x05\x30.001\x12\x13\n\x05train\x18\x05 \x01(\x08:\x04true')
+)
+
+
+
+_HYPERPARAMS_OP = _descriptor.EnumDescriptor(
+  name='Op',
+  full_name='object_detection.protos.Hyperparams.Op',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='CONV', index=0, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='FC', index=1, number=2,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=394,
+  serialized_end=416,
+)
+_sym_db.RegisterEnumDescriptor(_HYPERPARAMS_OP)
+
+_HYPERPARAMS_ACTIVATION = _descriptor.EnumDescriptor(
+  name='Activation',
+  full_name='object_detection.protos.Hyperparams.Activation',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='NONE', index=0, number=0,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='RELU', index=1, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='RELU_6', index=2, number=2,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=418,
+  serialized_end=462,
+)
+_sym_db.RegisterEnumDescriptor(_HYPERPARAMS_ACTIVATION)
+
+_VARIANCESCALINGINITIALIZER_MODE = _descriptor.EnumDescriptor(
+  name='Mode',
+  full_name='object_detection.protos.VarianceScalingInitializer.Mode',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='FAN_IN', index=0, number=0,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='FAN_OUT', index=1, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='FAN_AVG', index=2, number=2,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=1148,
+  serialized_end=1192,
+)
+_sym_db.RegisterEnumDescriptor(_VARIANCESCALINGINITIALIZER_MODE)
+
+
+_HYPERPARAMS = _descriptor.Descriptor(
+  name='Hyperparams',
+  full_name='object_detection.protos.Hyperparams',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='op', full_name='object_detection.protos.Hyperparams.op', index=0,
+      number=1, type=14, cpp_type=8, label=1,
+      has_default_value=True, default_value=1,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='regularizer', full_name='object_detection.protos.Hyperparams.regularizer', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='initializer', full_name='object_detection.protos.Hyperparams.initializer', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='activation', full_name='object_detection.protos.Hyperparams.activation', index=3,
+      number=4, type=14, cpp_type=8, label=1,
+      has_default_value=True, default_value=1,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='batch_norm', full_name='object_detection.protos.Hyperparams.batch_norm', index=4,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _HYPERPARAMS_OP,
+    _HYPERPARAMS_ACTIVATION,
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=71,
+  serialized_end=462,
+)
+
+
+_REGULARIZER = _descriptor.Descriptor(
+  name='Regularizer',
+  full_name='object_detection.protos.Regularizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='l1_regularizer', full_name='object_detection.protos.Regularizer.l1_regularizer', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='l2_regularizer', full_name='object_detection.protos.Regularizer.l2_regularizer', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='regularizer_oneof', full_name='object_detection.protos.Regularizer.regularizer_oneof',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=465,
+  serialized_end=631,
+)
+
+
+_L1REGULARIZER = _descriptor.Descriptor(
+  name='L1Regularizer',
+  full_name='object_detection.protos.L1Regularizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='weight', full_name='object_detection.protos.L1Regularizer.weight', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=633,
+  serialized_end=667,
+)
+
+
+_L2REGULARIZER = _descriptor.Descriptor(
+  name='L2Regularizer',
+  full_name='object_detection.protos.L2Regularizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='weight', full_name='object_detection.protos.L2Regularizer.weight', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=669,
+  serialized_end=703,
+)
+
+
+_INITIALIZER = _descriptor.Descriptor(
+  name='Initializer',
+  full_name='object_detection.protos.Initializer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='truncated_normal_initializer', full_name='object_detection.protos.Initializer.truncated_normal_initializer', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='variance_scaling_initializer', full_name='object_detection.protos.Initializer.variance_scaling_initializer', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='initializer_oneof', full_name='object_detection.protos.Initializer.initializer_oneof',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=706,
+  serialized_end=926,
+)
+
+
+_TRUNCATEDNORMALINITIALIZER = _descriptor.Descriptor(
+  name='TruncatedNormalInitializer',
+  full_name='object_detection.protos.TruncatedNormalInitializer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='mean', full_name='object_detection.protos.TruncatedNormalInitializer.mean', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='stddev', full_name='object_detection.protos.TruncatedNormalInitializer.stddev', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=928,
+  serialized_end=992,
+)
+
+
+_VARIANCESCALINGINITIALIZER = _descriptor.Descriptor(
+  name='VarianceScalingInitializer',
+  full_name='object_detection.protos.VarianceScalingInitializer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='factor', full_name='object_detection.protos.VarianceScalingInitializer.factor', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(2),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='uniform', full_name='object_detection.protos.VarianceScalingInitializer.uniform', index=1,
+      number=2, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='mode', full_name='object_detection.protos.VarianceScalingInitializer.mode', index=2,
+      number=3, type=14, cpp_type=8, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _VARIANCESCALINGINITIALIZER_MODE,
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=995,
+  serialized_end=1192,
+)
+
+
+_BATCHNORM = _descriptor.Descriptor(
+  name='BatchNorm',
+  full_name='object_detection.protos.BatchNorm',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='decay', full_name='object_detection.protos.BatchNorm.decay', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.999),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='center', full_name='object_detection.protos.BatchNorm.center', index=1,
+      number=2, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='scale', full_name='object_detection.protos.BatchNorm.scale', index=2,
+      number=3, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='epsilon', full_name='object_detection.protos.BatchNorm.epsilon', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.001),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='train', full_name='object_detection.protos.BatchNorm.train', index=4,
+      number=5, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1194,
+  serialized_end=1316,
+)
+
+_HYPERPARAMS.fields_by_name['op'].enum_type = _HYPERPARAMS_OP
+_HYPERPARAMS.fields_by_name['regularizer'].message_type = _REGULARIZER
+_HYPERPARAMS.fields_by_name['initializer'].message_type = _INITIALIZER
+_HYPERPARAMS.fields_by_name['activation'].enum_type = _HYPERPARAMS_ACTIVATION
+_HYPERPARAMS.fields_by_name['batch_norm'].message_type = _BATCHNORM
+_HYPERPARAMS_OP.containing_type = _HYPERPARAMS
+_HYPERPARAMS_ACTIVATION.containing_type = _HYPERPARAMS
+_REGULARIZER.fields_by_name['l1_regularizer'].message_type = _L1REGULARIZER
+_REGULARIZER.fields_by_name['l2_regularizer'].message_type = _L2REGULARIZER
+_REGULARIZER.oneofs_by_name['regularizer_oneof'].fields.append(
+  _REGULARIZER.fields_by_name['l1_regularizer'])
+_REGULARIZER.fields_by_name['l1_regularizer'].containing_oneof = _REGULARIZER.oneofs_by_name['regularizer_oneof']
+_REGULARIZER.oneofs_by_name['regularizer_oneof'].fields.append(
+  _REGULARIZER.fields_by_name['l2_regularizer'])
+_REGULARIZER.fields_by_name['l2_regularizer'].containing_oneof = _REGULARIZER.oneofs_by_name['regularizer_oneof']
+_INITIALIZER.fields_by_name['truncated_normal_initializer'].message_type = _TRUNCATEDNORMALINITIALIZER
+_INITIALIZER.fields_by_name['variance_scaling_initializer'].message_type = _VARIANCESCALINGINITIALIZER
+_INITIALIZER.oneofs_by_name['initializer_oneof'].fields.append(
+  _INITIALIZER.fields_by_name['truncated_normal_initializer'])
+_INITIALIZER.fields_by_name['truncated_normal_initializer'].containing_oneof = _INITIALIZER.oneofs_by_name['initializer_oneof']
+_INITIALIZER.oneofs_by_name['initializer_oneof'].fields.append(
+  _INITIALIZER.fields_by_name['variance_scaling_initializer'])
+_INITIALIZER.fields_by_name['variance_scaling_initializer'].containing_oneof = _INITIALIZER.oneofs_by_name['initializer_oneof']
+_VARIANCESCALINGINITIALIZER.fields_by_name['mode'].enum_type = _VARIANCESCALINGINITIALIZER_MODE
+_VARIANCESCALINGINITIALIZER_MODE.containing_type = _VARIANCESCALINGINITIALIZER
+DESCRIPTOR.message_types_by_name['Hyperparams'] = _HYPERPARAMS
+DESCRIPTOR.message_types_by_name['Regularizer'] = _REGULARIZER
+DESCRIPTOR.message_types_by_name['L1Regularizer'] = _L1REGULARIZER
+DESCRIPTOR.message_types_by_name['L2Regularizer'] = _L2REGULARIZER
+DESCRIPTOR.message_types_by_name['Initializer'] = _INITIALIZER
+DESCRIPTOR.message_types_by_name['TruncatedNormalInitializer'] = _TRUNCATEDNORMALINITIALIZER
+DESCRIPTOR.message_types_by_name['VarianceScalingInitializer'] = _VARIANCESCALINGINITIALIZER
+DESCRIPTOR.message_types_by_name['BatchNorm'] = _BATCHNORM
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Hyperparams = _reflection.GeneratedProtocolMessageType('Hyperparams', (_message.Message,), dict(
+  DESCRIPTOR = _HYPERPARAMS,
+  __module__ = 'object_detection.protos.hyperparams_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.Hyperparams)
+  ))
+_sym_db.RegisterMessage(Hyperparams)
+
+Regularizer = _reflection.GeneratedProtocolMessageType('Regularizer', (_message.Message,), dict(
+  DESCRIPTOR = _REGULARIZER,
+  __module__ = 'object_detection.protos.hyperparams_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.Regularizer)
+  ))
+_sym_db.RegisterMessage(Regularizer)
+
+L1Regularizer = _reflection.GeneratedProtocolMessageType('L1Regularizer', (_message.Message,), dict(
+  DESCRIPTOR = _L1REGULARIZER,
+  __module__ = 'object_detection.protos.hyperparams_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.L1Regularizer)
+  ))
+_sym_db.RegisterMessage(L1Regularizer)
+
+L2Regularizer = _reflection.GeneratedProtocolMessageType('L2Regularizer', (_message.Message,), dict(
+  DESCRIPTOR = _L2REGULARIZER,
+  __module__ = 'object_detection.protos.hyperparams_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.L2Regularizer)
+  ))
+_sym_db.RegisterMessage(L2Regularizer)
+
+Initializer = _reflection.GeneratedProtocolMessageType('Initializer', (_message.Message,), dict(
+  DESCRIPTOR = _INITIALIZER,
+  __module__ = 'object_detection.protos.hyperparams_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.Initializer)
+  ))
+_sym_db.RegisterMessage(Initializer)
+
+TruncatedNormalInitializer = _reflection.GeneratedProtocolMessageType('TruncatedNormalInitializer', (_message.Message,), dict(
+  DESCRIPTOR = _TRUNCATEDNORMALINITIALIZER,
+  __module__ = 'object_detection.protos.hyperparams_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.TruncatedNormalInitializer)
+  ))
+_sym_db.RegisterMessage(TruncatedNormalInitializer)
+
+VarianceScalingInitializer = _reflection.GeneratedProtocolMessageType('VarianceScalingInitializer', (_message.Message,), dict(
+  DESCRIPTOR = _VARIANCESCALINGINITIALIZER,
+  __module__ = 'object_detection.protos.hyperparams_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.VarianceScalingInitializer)
+  ))
+_sym_db.RegisterMessage(VarianceScalingInitializer)
+
+BatchNorm = _reflection.GeneratedProtocolMessageType('BatchNorm', (_message.Message,), dict(
+  DESCRIPTOR = _BATCHNORM,
+  __module__ = 'object_detection.protos.hyperparams_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.BatchNorm)
+  ))
+_sym_db.RegisterMessage(BatchNorm)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/image_resizer.proto b/reconnaissance images/object_detection/protos/image_resizer.proto
new file mode 100644
index 0000000..4618add
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/image_resizer.proto	
@@ -0,0 +1,32 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for image resizing operations.
+// See builders/image_resizer_builder.py for details.
+message ImageResizer {
+  oneof image_resizer_oneof {
+    KeepAspectRatioResizer keep_aspect_ratio_resizer = 1;
+    FixedShapeResizer fixed_shape_resizer = 2;
+  }
+}
+
+
+// Configuration proto for image resizer that keeps aspect ratio.
+message KeepAspectRatioResizer {
+  // Desired size of the smaller image dimension in pixels.
+  optional int32 min_dimension = 1 [default = 600];
+
+  // Desired size of the larger image dimension in pixels.
+  optional int32 max_dimension = 2 [default = 1024];
+}
+
+
+// Configuration proto for image resizer that resizes to a fixed shape.
+message FixedShapeResizer {
+  // Desired height of image in pixels.
+  optional int32 height = 1 [default = 300];
+
+  // Desired width of image in pixels.
+  optional int32 width = 2 [default = 300];
+}
diff --git a/reconnaissance images/object_detection/protos/image_resizer_pb2.py b/reconnaissance images/object_detection/protos/image_resizer_pb2.py
new file mode 100644
index 0000000..d6d50ba
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/image_resizer_pb2.py	
@@ -0,0 +1,179 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/image_resizer.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/image_resizer.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n+object_detection/protos/image_resizer.proto\x12\x17object_detection.protos\"\xc6\x01\n\x0cImageResizer\x12T\n\x19keep_aspect_ratio_resizer\x18\x01 \x01(\x0b\x32/.object_detection.protos.KeepAspectRatioResizerH\x00\x12I\n\x13\x66ixed_shape_resizer\x18\x02 \x01(\x0b\x32*.object_detection.protos.FixedShapeResizerH\x00\x42\x15\n\x13image_resizer_oneof\"Q\n\x16KeepAspectRatioResizer\x12\x1a\n\rmin_dimension\x18\x01 \x01(\x05:\x03\x36\x30\x30\x12\x1b\n\rmax_dimension\x18\x02 \x01(\x05:\x04\x31\x30\x32\x34\"<\n\x11\x46ixedShapeResizer\x12\x13\n\x06height\x18\x01 \x01(\x05:\x03\x33\x30\x30\x12\x12\n\x05width\x18\x02 \x01(\x05:\x03\x33\x30\x30')
+)
+
+
+
+
+_IMAGERESIZER = _descriptor.Descriptor(
+  name='ImageResizer',
+  full_name='object_detection.protos.ImageResizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='keep_aspect_ratio_resizer', full_name='object_detection.protos.ImageResizer.keep_aspect_ratio_resizer', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='fixed_shape_resizer', full_name='object_detection.protos.ImageResizer.fixed_shape_resizer', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='image_resizer_oneof', full_name='object_detection.protos.ImageResizer.image_resizer_oneof',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=73,
+  serialized_end=271,
+)
+
+
+_KEEPASPECTRATIORESIZER = _descriptor.Descriptor(
+  name='KeepAspectRatioResizer',
+  full_name='object_detection.protos.KeepAspectRatioResizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_dimension', full_name='object_detection.protos.KeepAspectRatioResizer.min_dimension', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=600,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_dimension', full_name='object_detection.protos.KeepAspectRatioResizer.max_dimension', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=1024,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=273,
+  serialized_end=354,
+)
+
+
+_FIXEDSHAPERESIZER = _descriptor.Descriptor(
+  name='FixedShapeResizer',
+  full_name='object_detection.protos.FixedShapeResizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='height', full_name='object_detection.protos.FixedShapeResizer.height', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=300,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='width', full_name='object_detection.protos.FixedShapeResizer.width', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=300,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=356,
+  serialized_end=416,
+)
+
+_IMAGERESIZER.fields_by_name['keep_aspect_ratio_resizer'].message_type = _KEEPASPECTRATIORESIZER
+_IMAGERESIZER.fields_by_name['fixed_shape_resizer'].message_type = _FIXEDSHAPERESIZER
+_IMAGERESIZER.oneofs_by_name['image_resizer_oneof'].fields.append(
+  _IMAGERESIZER.fields_by_name['keep_aspect_ratio_resizer'])
+_IMAGERESIZER.fields_by_name['keep_aspect_ratio_resizer'].containing_oneof = _IMAGERESIZER.oneofs_by_name['image_resizer_oneof']
+_IMAGERESIZER.oneofs_by_name['image_resizer_oneof'].fields.append(
+  _IMAGERESIZER.fields_by_name['fixed_shape_resizer'])
+_IMAGERESIZER.fields_by_name['fixed_shape_resizer'].containing_oneof = _IMAGERESIZER.oneofs_by_name['image_resizer_oneof']
+DESCRIPTOR.message_types_by_name['ImageResizer'] = _IMAGERESIZER
+DESCRIPTOR.message_types_by_name['KeepAspectRatioResizer'] = _KEEPASPECTRATIORESIZER
+DESCRIPTOR.message_types_by_name['FixedShapeResizer'] = _FIXEDSHAPERESIZER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+ImageResizer = _reflection.GeneratedProtocolMessageType('ImageResizer', (_message.Message,), dict(
+  DESCRIPTOR = _IMAGERESIZER,
+  __module__ = 'object_detection.protos.image_resizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ImageResizer)
+  ))
+_sym_db.RegisterMessage(ImageResizer)
+
+KeepAspectRatioResizer = _reflection.GeneratedProtocolMessageType('KeepAspectRatioResizer', (_message.Message,), dict(
+  DESCRIPTOR = _KEEPASPECTRATIORESIZER,
+  __module__ = 'object_detection.protos.image_resizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.KeepAspectRatioResizer)
+  ))
+_sym_db.RegisterMessage(KeepAspectRatioResizer)
+
+FixedShapeResizer = _reflection.GeneratedProtocolMessageType('FixedShapeResizer', (_message.Message,), dict(
+  DESCRIPTOR = _FIXEDSHAPERESIZER,
+  __module__ = 'object_detection.protos.image_resizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.FixedShapeResizer)
+  ))
+_sym_db.RegisterMessage(FixedShapeResizer)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/input_reader.proto b/reconnaissance images/object_detection/protos/input_reader.proto
new file mode 100644
index 0000000..8956b00
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/input_reader.proto	
@@ -0,0 +1,60 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for defining input readers that generate Object Detection
+// Examples from input sources. Input readers are expected to generate a
+// dictionary of tensors, with the following fields populated:
+//
+// 'image': an [image_height, image_width, channels] image tensor that detection
+//    will be run on.
+// 'groundtruth_classes': a [num_boxes] int32 tensor storing the class
+//    labels of detected boxes in the image.
+// 'groundtruth_boxes': a [num_boxes, 4] float tensor storing the coordinates of
+//    detected boxes in the image.
+// 'groundtruth_instance_masks': (Optional), a [num_boxes, image_height,
+//    image_width] float tensor storing binary mask of the objects in boxes.
+
+message InputReader {
+  // Path to StringIntLabelMap pbtxt file specifying the mapping from string
+  // labels to integer ids.
+  optional string label_map_path = 1 [default=""];
+
+  // Whether data should be processed in the order they are read in, or
+  // shuffled randomly.
+  optional bool shuffle = 2 [default=true];
+
+  // Maximum number of records to keep in reader queue.
+  optional uint32 queue_capacity = 3 [default=2000];
+
+  // Minimum number of records to keep in reader queue. A large value is needed
+  // to generate a good random shuffle.
+  optional uint32 min_after_dequeue = 4 [default=1000];
+
+  // The number of times a data source is read. If set to zero, the data source
+  // will be reused indefinitely.
+  optional uint32 num_epochs = 5 [default=0];
+
+  // Number of reader instances to create.
+  optional uint32 num_readers = 6 [default=8];
+
+  // Whether to load groundtruth instance masks.
+  optional bool load_instance_masks = 7 [default = false];
+
+  oneof input_reader {
+    TFRecordInputReader tf_record_input_reader = 8;
+    ExternalInputReader external_input_reader = 9;
+  }
+}
+
+// An input reader that reads TF Example protos from local TFRecord files.
+message TFRecordInputReader {
+  // Path to TFRecordFile.
+  optional string input_path = 1 [default=""];
+}
+
+// An externally defined input reader. Users may define an extension to this
+// proto to interface their own input readers.
+message ExternalInputReader {
+  extensions 1 to 999;
+}
diff --git a/reconnaissance images/object_detection/protos/input_reader_pb2.py b/reconnaissance images/object_detection/protos/input_reader_pb2.py
new file mode 100644
index 0000000..595da08
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/input_reader_pb2.py	
@@ -0,0 +1,207 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/input_reader.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/input_reader.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n*object_detection/protos/input_reader.proto\x12\x17object_detection.protos\"\xff\x02\n\x0bInputReader\x12\x18\n\x0elabel_map_path\x18\x01 \x01(\t:\x00\x12\x15\n\x07shuffle\x18\x02 \x01(\x08:\x04true\x12\x1c\n\x0equeue_capacity\x18\x03 \x01(\r:\x04\x32\x30\x30\x30\x12\x1f\n\x11min_after_dequeue\x18\x04 \x01(\r:\x04\x31\x30\x30\x30\x12\x15\n\nnum_epochs\x18\x05 \x01(\r:\x01\x30\x12\x16\n\x0bnum_readers\x18\x06 \x01(\r:\x01\x38\x12\"\n\x13load_instance_masks\x18\x07 \x01(\x08:\x05\x66\x61lse\x12N\n\x16tf_record_input_reader\x18\x08 \x01(\x0b\x32,.object_detection.protos.TFRecordInputReaderH\x00\x12M\n\x15\x65xternal_input_reader\x18\t \x01(\x0b\x32,.object_detection.protos.ExternalInputReaderH\x00\x42\x0e\n\x0cinput_reader\"+\n\x13TFRecordInputReader\x12\x14\n\ninput_path\x18\x01 \x01(\t:\x00\"\x1c\n\x13\x45xternalInputReader*\x05\x08\x01\x10\xe8\x07')
+)
+
+
+
+
+_INPUTREADER = _descriptor.Descriptor(
+  name='InputReader',
+  full_name='object_detection.protos.InputReader',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='label_map_path', full_name='object_detection.protos.InputReader.label_map_path', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=True, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='shuffle', full_name='object_detection.protos.InputReader.shuffle', index=1,
+      number=2, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='queue_capacity', full_name='object_detection.protos.InputReader.queue_capacity', index=2,
+      number=3, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=2000,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_after_dequeue', full_name='object_detection.protos.InputReader.min_after_dequeue', index=3,
+      number=4, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=1000,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_epochs', full_name='object_detection.protos.InputReader.num_epochs', index=4,
+      number=5, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_readers', full_name='object_detection.protos.InputReader.num_readers', index=5,
+      number=6, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=8,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='load_instance_masks', full_name='object_detection.protos.InputReader.load_instance_masks', index=6,
+      number=7, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='tf_record_input_reader', full_name='object_detection.protos.InputReader.tf_record_input_reader', index=7,
+      number=8, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='external_input_reader', full_name='object_detection.protos.InputReader.external_input_reader', index=8,
+      number=9, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='input_reader', full_name='object_detection.protos.InputReader.input_reader',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=72,
+  serialized_end=455,
+)
+
+
+_TFRECORDINPUTREADER = _descriptor.Descriptor(
+  name='TFRecordInputReader',
+  full_name='object_detection.protos.TFRecordInputReader',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='input_path', full_name='object_detection.protos.TFRecordInputReader.input_path', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=True, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=457,
+  serialized_end=500,
+)
+
+
+_EXTERNALINPUTREADER = _descriptor.Descriptor(
+  name='ExternalInputReader',
+  full_name='object_detection.protos.ExternalInputReader',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=True,
+  syntax='proto2',
+  extension_ranges=[(1, 1000), ],
+  oneofs=[
+  ],
+  serialized_start=502,
+  serialized_end=530,
+)
+
+_INPUTREADER.fields_by_name['tf_record_input_reader'].message_type = _TFRECORDINPUTREADER
+_INPUTREADER.fields_by_name['external_input_reader'].message_type = _EXTERNALINPUTREADER
+_INPUTREADER.oneofs_by_name['input_reader'].fields.append(
+  _INPUTREADER.fields_by_name['tf_record_input_reader'])
+_INPUTREADER.fields_by_name['tf_record_input_reader'].containing_oneof = _INPUTREADER.oneofs_by_name['input_reader']
+_INPUTREADER.oneofs_by_name['input_reader'].fields.append(
+  _INPUTREADER.fields_by_name['external_input_reader'])
+_INPUTREADER.fields_by_name['external_input_reader'].containing_oneof = _INPUTREADER.oneofs_by_name['input_reader']
+DESCRIPTOR.message_types_by_name['InputReader'] = _INPUTREADER
+DESCRIPTOR.message_types_by_name['TFRecordInputReader'] = _TFRECORDINPUTREADER
+DESCRIPTOR.message_types_by_name['ExternalInputReader'] = _EXTERNALINPUTREADER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+InputReader = _reflection.GeneratedProtocolMessageType('InputReader', (_message.Message,), dict(
+  DESCRIPTOR = _INPUTREADER,
+  __module__ = 'object_detection.protos.input_reader_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.InputReader)
+  ))
+_sym_db.RegisterMessage(InputReader)
+
+TFRecordInputReader = _reflection.GeneratedProtocolMessageType('TFRecordInputReader', (_message.Message,), dict(
+  DESCRIPTOR = _TFRECORDINPUTREADER,
+  __module__ = 'object_detection.protos.input_reader_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.TFRecordInputReader)
+  ))
+_sym_db.RegisterMessage(TFRecordInputReader)
+
+ExternalInputReader = _reflection.GeneratedProtocolMessageType('ExternalInputReader', (_message.Message,), dict(
+  DESCRIPTOR = _EXTERNALINPUTREADER,
+  __module__ = 'object_detection.protos.input_reader_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ExternalInputReader)
+  ))
+_sym_db.RegisterMessage(ExternalInputReader)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/losses.proto b/reconnaissance images/object_detection/protos/losses.proto
new file mode 100644
index 0000000..acd32b1
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/losses.proto	
@@ -0,0 +1,116 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Message for configuring the localization loss, classification loss and hard
+// example miner used for training object detection models. See core/losses.py
+// for details
+message Loss {
+  // Localization loss to use.
+  optional LocalizationLoss localization_loss = 1;
+
+  // Classification loss to use.
+  optional ClassificationLoss classification_loss = 2;
+
+  // If not left to default, applies hard example mining.
+  optional HardExampleMiner hard_example_miner = 3;
+
+  // Classification loss weight.
+  optional float classification_weight = 4 [default=1.0];
+
+  // Localization loss weight.
+  optional float localization_weight = 5 [default=1.0];
+}
+
+// Configuration for bounding box localization loss function.
+message LocalizationLoss {
+  oneof localization_loss {
+    WeightedL2LocalizationLoss weighted_l2 = 1;
+    WeightedSmoothL1LocalizationLoss weighted_smooth_l1 = 2;
+    WeightedIOULocalizationLoss weighted_iou = 3;
+  }
+}
+
+// L2 location loss: 0.5 * ||weight * (a - b)|| ^ 2
+message WeightedL2LocalizationLoss {
+  // Output loss per anchor.
+  optional bool anchorwise_output = 1 [default=false];
+}
+
+// SmoothL1 (Huber) location loss: .5 * x ^ 2 if |x| < 1 else |x| - .5
+message WeightedSmoothL1LocalizationLoss {
+  // Output loss per anchor.
+  optional bool anchorwise_output = 1 [default=false];
+}
+
+// Intersection over union location loss: 1 - IOU
+message WeightedIOULocalizationLoss {
+}
+
+// Configuration for class prediction loss function.
+message ClassificationLoss {
+  oneof classification_loss {
+    WeightedSigmoidClassificationLoss weighted_sigmoid = 1;
+    WeightedSoftmaxClassificationLoss weighted_softmax = 2;
+    BootstrappedSigmoidClassificationLoss bootstrapped_sigmoid = 3;
+  }
+}
+
+// Classification loss using a sigmoid function over class predictions.
+message WeightedSigmoidClassificationLoss {
+  // Output loss per anchor.
+  optional bool anchorwise_output = 1 [default=false];
+}
+
+// Classification loss using a softmax function over class predictions.
+message WeightedSoftmaxClassificationLoss {
+  // Output loss per anchor.
+  optional bool anchorwise_output = 1 [default=false];
+}
+
+// Classification loss using a sigmoid function over the class prediction with
+// the highest prediction score.
+message BootstrappedSigmoidClassificationLoss {
+  // Interpolation weight between 0 and 1.
+  optional float alpha = 1;
+
+  // Whether hard boot strapping should be used or not. If true, will only use
+  // one class favored by model. Othewise, will use all predicted class
+  // probabilities.
+  optional bool hard_bootstrap = 2 [default=false];
+
+  // Output loss per anchor.
+  optional bool anchorwise_output = 3 [default=false];
+}
+
+// Configuation for hard example miner.
+message HardExampleMiner {
+  // Maximum number of hard examples to be selected per image (prior to
+  // enforcing max negative to positive ratio constraint).  If set to 0,
+  // all examples obtained after NMS are considered.
+  optional int32 num_hard_examples = 1 [default=64];
+
+  // Minimum intersection over union for an example to be discarded during NMS.
+  optional float iou_threshold = 2 [default=0.7];
+
+  // Whether to use classification losses ('cls', default), localization losses
+  // ('loc') or both losses ('both'). In the case of 'both', cls_loss_weight and
+  // loc_loss_weight are used to compute weighted sum of the two losses.
+  enum LossType {
+    BOTH = 0;
+    CLASSIFICATION = 1;
+    LOCALIZATION = 2;
+  }
+  optional LossType loss_type = 3 [default=BOTH];
+
+  // Maximum number of negatives to retain for each positive anchor. If
+  // num_negatives_per_positive is 0 no prespecified negative:positive ratio is
+  // enforced.
+  optional int32 max_negatives_per_positive = 4 [default=0];
+
+  // Minimum number of negative anchors to sample for a given image. Setting
+  // this to a positive number samples negatives in an image without any
+  // positive anchors and thus not bias the model towards having at least one
+  // detection per image.
+  optional int32 min_negatives_per_image = 5 [default=0];
+}
diff --git a/reconnaissance images/object_detection/protos/losses_pb2.py b/reconnaissance images/object_detection/protos/losses_pb2.py
new file mode 100644
index 0000000..9791907
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/losses_pb2.py	
@@ -0,0 +1,573 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/losses.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/losses.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n$object_detection/protos/losses.proto\x12\x17object_detection.protos\"\x9f\x02\n\x04Loss\x12\x44\n\x11localization_loss\x18\x01 \x01(\x0b\x32).object_detection.protos.LocalizationLoss\x12H\n\x13\x63lassification_loss\x18\x02 \x01(\x0b\x32+.object_detection.protos.ClassificationLoss\x12\x45\n\x12hard_example_miner\x18\x03 \x01(\x0b\x32).object_detection.protos.HardExampleMiner\x12 \n\x15\x63lassification_weight\x18\x04 \x01(\x02:\x01\x31\x12\x1e\n\x13localization_weight\x18\x05 \x01(\x02:\x01\x31\"\x9a\x02\n\x10LocalizationLoss\x12J\n\x0bweighted_l2\x18\x01 \x01(\x0b\x32\x33.object_detection.protos.WeightedL2LocalizationLossH\x00\x12W\n\x12weighted_smooth_l1\x18\x02 \x01(\x0b\x32\x39.object_detection.protos.WeightedSmoothL1LocalizationLossH\x00\x12L\n\x0cweighted_iou\x18\x03 \x01(\x0b\x32\x34.object_detection.protos.WeightedIOULocalizationLossH\x00\x42\x13\n\x11localization_loss\">\n\x1aWeightedL2LocalizationLoss\x12 \n\x11\x61nchorwise_output\x18\x01 \x01(\x08:\x05\x66\x61lse\"D\n WeightedSmoothL1LocalizationLoss\x12 \n\x11\x61nchorwise_output\x18\x01 \x01(\x08:\x05\x66\x61lse\"\x1d\n\x1bWeightedIOULocalizationLoss\"\xbb\x02\n\x12\x43lassificationLoss\x12V\n\x10weighted_sigmoid\x18\x01 \x01(\x0b\x32:.object_detection.protos.WeightedSigmoidClassificationLossH\x00\x12V\n\x10weighted_softmax\x18\x02 \x01(\x0b\x32:.object_detection.protos.WeightedSoftmaxClassificationLossH\x00\x12^\n\x14\x62ootstrapped_sigmoid\x18\x03 \x01(\x0b\x32>.object_detection.protos.BootstrappedSigmoidClassificationLossH\x00\x42\x15\n\x13\x63lassification_loss\"E\n!WeightedSigmoidClassificationLoss\x12 \n\x11\x61nchorwise_output\x18\x01 \x01(\x08:\x05\x66\x61lse\"E\n!WeightedSoftmaxClassificationLoss\x12 \n\x11\x61nchorwise_output\x18\x01 \x01(\x08:\x05\x66\x61lse\"w\n%BootstrappedSigmoidClassificationLoss\x12\r\n\x05\x61lpha\x18\x01 \x01(\x02\x12\x1d\n\x0ehard_bootstrap\x18\x02 \x01(\x08:\x05\x66\x61lse\x12 \n\x11\x61nchorwise_output\x18\x03 \x01(\x08:\x05\x66\x61lse\"\xa1\x02\n\x10HardExampleMiner\x12\x1d\n\x11num_hard_examples\x18\x01 \x01(\x05:\x02\x36\x34\x12\x1a\n\riou_threshold\x18\x02 \x01(\x02:\x03\x30.7\x12K\n\tloss_type\x18\x03 \x01(\x0e\x32\x32.object_detection.protos.HardExampleMiner.LossType:\x04\x42OTH\x12%\n\x1amax_negatives_per_positive\x18\x04 \x01(\x05:\x01\x30\x12\"\n\x17min_negatives_per_image\x18\x05 \x01(\x05:\x01\x30\":\n\x08LossType\x12\x08\n\x04\x42OTH\x10\x00\x12\x12\n\x0e\x43LASSIFICATION\x10\x01\x12\x10\n\x0cLOCALIZATION\x10\x02')
+)
+
+
+
+_HARDEXAMPLEMINER_LOSSTYPE = _descriptor.EnumDescriptor(
+  name='LossType',
+  full_name='object_detection.protos.HardExampleMiner.LossType',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='BOTH', index=0, number=0,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='CLASSIFICATION', index=1, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='LOCALIZATION', index=2, number=2,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=1618,
+  serialized_end=1676,
+)
+_sym_db.RegisterEnumDescriptor(_HARDEXAMPLEMINER_LOSSTYPE)
+
+
+_LOSS = _descriptor.Descriptor(
+  name='Loss',
+  full_name='object_detection.protos.Loss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='localization_loss', full_name='object_detection.protos.Loss.localization_loss', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='classification_loss', full_name='object_detection.protos.Loss.classification_loss', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='hard_example_miner', full_name='object_detection.protos.Loss.hard_example_miner', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='classification_weight', full_name='object_detection.protos.Loss.classification_weight', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='localization_weight', full_name='object_detection.protos.Loss.localization_weight', index=4,
+      number=5, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=66,
+  serialized_end=353,
+)
+
+
+_LOCALIZATIONLOSS = _descriptor.Descriptor(
+  name='LocalizationLoss',
+  full_name='object_detection.protos.LocalizationLoss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='weighted_l2', full_name='object_detection.protos.LocalizationLoss.weighted_l2', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='weighted_smooth_l1', full_name='object_detection.protos.LocalizationLoss.weighted_smooth_l1', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='weighted_iou', full_name='object_detection.protos.LocalizationLoss.weighted_iou', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='localization_loss', full_name='object_detection.protos.LocalizationLoss.localization_loss',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=356,
+  serialized_end=638,
+)
+
+
+_WEIGHTEDL2LOCALIZATIONLOSS = _descriptor.Descriptor(
+  name='WeightedL2LocalizationLoss',
+  full_name='object_detection.protos.WeightedL2LocalizationLoss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='anchorwise_output', full_name='object_detection.protos.WeightedL2LocalizationLoss.anchorwise_output', index=0,
+      number=1, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=640,
+  serialized_end=702,
+)
+
+
+_WEIGHTEDSMOOTHL1LOCALIZATIONLOSS = _descriptor.Descriptor(
+  name='WeightedSmoothL1LocalizationLoss',
+  full_name='object_detection.protos.WeightedSmoothL1LocalizationLoss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='anchorwise_output', full_name='object_detection.protos.WeightedSmoothL1LocalizationLoss.anchorwise_output', index=0,
+      number=1, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=704,
+  serialized_end=772,
+)
+
+
+_WEIGHTEDIOULOCALIZATIONLOSS = _descriptor.Descriptor(
+  name='WeightedIOULocalizationLoss',
+  full_name='object_detection.protos.WeightedIOULocalizationLoss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=774,
+  serialized_end=803,
+)
+
+
+_CLASSIFICATIONLOSS = _descriptor.Descriptor(
+  name='ClassificationLoss',
+  full_name='object_detection.protos.ClassificationLoss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='weighted_sigmoid', full_name='object_detection.protos.ClassificationLoss.weighted_sigmoid', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='weighted_softmax', full_name='object_detection.protos.ClassificationLoss.weighted_softmax', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='bootstrapped_sigmoid', full_name='object_detection.protos.ClassificationLoss.bootstrapped_sigmoid', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='classification_loss', full_name='object_detection.protos.ClassificationLoss.classification_loss',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=806,
+  serialized_end=1121,
+)
+
+
+_WEIGHTEDSIGMOIDCLASSIFICATIONLOSS = _descriptor.Descriptor(
+  name='WeightedSigmoidClassificationLoss',
+  full_name='object_detection.protos.WeightedSigmoidClassificationLoss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='anchorwise_output', full_name='object_detection.protos.WeightedSigmoidClassificationLoss.anchorwise_output', index=0,
+      number=1, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1123,
+  serialized_end=1192,
+)
+
+
+_WEIGHTEDSOFTMAXCLASSIFICATIONLOSS = _descriptor.Descriptor(
+  name='WeightedSoftmaxClassificationLoss',
+  full_name='object_detection.protos.WeightedSoftmaxClassificationLoss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='anchorwise_output', full_name='object_detection.protos.WeightedSoftmaxClassificationLoss.anchorwise_output', index=0,
+      number=1, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1194,
+  serialized_end=1263,
+)
+
+
+_BOOTSTRAPPEDSIGMOIDCLASSIFICATIONLOSS = _descriptor.Descriptor(
+  name='BootstrappedSigmoidClassificationLoss',
+  full_name='object_detection.protos.BootstrappedSigmoidClassificationLoss',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='alpha', full_name='object_detection.protos.BootstrappedSigmoidClassificationLoss.alpha', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='hard_bootstrap', full_name='object_detection.protos.BootstrappedSigmoidClassificationLoss.hard_bootstrap', index=1,
+      number=2, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='anchorwise_output', full_name='object_detection.protos.BootstrappedSigmoidClassificationLoss.anchorwise_output', index=2,
+      number=3, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1265,
+  serialized_end=1384,
+)
+
+
+_HARDEXAMPLEMINER = _descriptor.Descriptor(
+  name='HardExampleMiner',
+  full_name='object_detection.protos.HardExampleMiner',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='num_hard_examples', full_name='object_detection.protos.HardExampleMiner.num_hard_examples', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=64,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='iou_threshold', full_name='object_detection.protos.HardExampleMiner.iou_threshold', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.7),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='loss_type', full_name='object_detection.protos.HardExampleMiner.loss_type', index=2,
+      number=3, type=14, cpp_type=8, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_negatives_per_positive', full_name='object_detection.protos.HardExampleMiner.max_negatives_per_positive', index=3,
+      number=4, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_negatives_per_image', full_name='object_detection.protos.HardExampleMiner.min_negatives_per_image', index=4,
+      number=5, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _HARDEXAMPLEMINER_LOSSTYPE,
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1387,
+  serialized_end=1676,
+)
+
+_LOSS.fields_by_name['localization_loss'].message_type = _LOCALIZATIONLOSS
+_LOSS.fields_by_name['classification_loss'].message_type = _CLASSIFICATIONLOSS
+_LOSS.fields_by_name['hard_example_miner'].message_type = _HARDEXAMPLEMINER
+_LOCALIZATIONLOSS.fields_by_name['weighted_l2'].message_type = _WEIGHTEDL2LOCALIZATIONLOSS
+_LOCALIZATIONLOSS.fields_by_name['weighted_smooth_l1'].message_type = _WEIGHTEDSMOOTHL1LOCALIZATIONLOSS
+_LOCALIZATIONLOSS.fields_by_name['weighted_iou'].message_type = _WEIGHTEDIOULOCALIZATIONLOSS
+_LOCALIZATIONLOSS.oneofs_by_name['localization_loss'].fields.append(
+  _LOCALIZATIONLOSS.fields_by_name['weighted_l2'])
+_LOCALIZATIONLOSS.fields_by_name['weighted_l2'].containing_oneof = _LOCALIZATIONLOSS.oneofs_by_name['localization_loss']
+_LOCALIZATIONLOSS.oneofs_by_name['localization_loss'].fields.append(
+  _LOCALIZATIONLOSS.fields_by_name['weighted_smooth_l1'])
+_LOCALIZATIONLOSS.fields_by_name['weighted_smooth_l1'].containing_oneof = _LOCALIZATIONLOSS.oneofs_by_name['localization_loss']
+_LOCALIZATIONLOSS.oneofs_by_name['localization_loss'].fields.append(
+  _LOCALIZATIONLOSS.fields_by_name['weighted_iou'])
+_LOCALIZATIONLOSS.fields_by_name['weighted_iou'].containing_oneof = _LOCALIZATIONLOSS.oneofs_by_name['localization_loss']
+_CLASSIFICATIONLOSS.fields_by_name['weighted_sigmoid'].message_type = _WEIGHTEDSIGMOIDCLASSIFICATIONLOSS
+_CLASSIFICATIONLOSS.fields_by_name['weighted_softmax'].message_type = _WEIGHTEDSOFTMAXCLASSIFICATIONLOSS
+_CLASSIFICATIONLOSS.fields_by_name['bootstrapped_sigmoid'].message_type = _BOOTSTRAPPEDSIGMOIDCLASSIFICATIONLOSS
+_CLASSIFICATIONLOSS.oneofs_by_name['classification_loss'].fields.append(
+  _CLASSIFICATIONLOSS.fields_by_name['weighted_sigmoid'])
+_CLASSIFICATIONLOSS.fields_by_name['weighted_sigmoid'].containing_oneof = _CLASSIFICATIONLOSS.oneofs_by_name['classification_loss']
+_CLASSIFICATIONLOSS.oneofs_by_name['classification_loss'].fields.append(
+  _CLASSIFICATIONLOSS.fields_by_name['weighted_softmax'])
+_CLASSIFICATIONLOSS.fields_by_name['weighted_softmax'].containing_oneof = _CLASSIFICATIONLOSS.oneofs_by_name['classification_loss']
+_CLASSIFICATIONLOSS.oneofs_by_name['classification_loss'].fields.append(
+  _CLASSIFICATIONLOSS.fields_by_name['bootstrapped_sigmoid'])
+_CLASSIFICATIONLOSS.fields_by_name['bootstrapped_sigmoid'].containing_oneof = _CLASSIFICATIONLOSS.oneofs_by_name['classification_loss']
+_HARDEXAMPLEMINER.fields_by_name['loss_type'].enum_type = _HARDEXAMPLEMINER_LOSSTYPE
+_HARDEXAMPLEMINER_LOSSTYPE.containing_type = _HARDEXAMPLEMINER
+DESCRIPTOR.message_types_by_name['Loss'] = _LOSS
+DESCRIPTOR.message_types_by_name['LocalizationLoss'] = _LOCALIZATIONLOSS
+DESCRIPTOR.message_types_by_name['WeightedL2LocalizationLoss'] = _WEIGHTEDL2LOCALIZATIONLOSS
+DESCRIPTOR.message_types_by_name['WeightedSmoothL1LocalizationLoss'] = _WEIGHTEDSMOOTHL1LOCALIZATIONLOSS
+DESCRIPTOR.message_types_by_name['WeightedIOULocalizationLoss'] = _WEIGHTEDIOULOCALIZATIONLOSS
+DESCRIPTOR.message_types_by_name['ClassificationLoss'] = _CLASSIFICATIONLOSS
+DESCRIPTOR.message_types_by_name['WeightedSigmoidClassificationLoss'] = _WEIGHTEDSIGMOIDCLASSIFICATIONLOSS
+DESCRIPTOR.message_types_by_name['WeightedSoftmaxClassificationLoss'] = _WEIGHTEDSOFTMAXCLASSIFICATIONLOSS
+DESCRIPTOR.message_types_by_name['BootstrappedSigmoidClassificationLoss'] = _BOOTSTRAPPEDSIGMOIDCLASSIFICATIONLOSS
+DESCRIPTOR.message_types_by_name['HardExampleMiner'] = _HARDEXAMPLEMINER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Loss = _reflection.GeneratedProtocolMessageType('Loss', (_message.Message,), dict(
+  DESCRIPTOR = _LOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.Loss)
+  ))
+_sym_db.RegisterMessage(Loss)
+
+LocalizationLoss = _reflection.GeneratedProtocolMessageType('LocalizationLoss', (_message.Message,), dict(
+  DESCRIPTOR = _LOCALIZATIONLOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.LocalizationLoss)
+  ))
+_sym_db.RegisterMessage(LocalizationLoss)
+
+WeightedL2LocalizationLoss = _reflection.GeneratedProtocolMessageType('WeightedL2LocalizationLoss', (_message.Message,), dict(
+  DESCRIPTOR = _WEIGHTEDL2LOCALIZATIONLOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.WeightedL2LocalizationLoss)
+  ))
+_sym_db.RegisterMessage(WeightedL2LocalizationLoss)
+
+WeightedSmoothL1LocalizationLoss = _reflection.GeneratedProtocolMessageType('WeightedSmoothL1LocalizationLoss', (_message.Message,), dict(
+  DESCRIPTOR = _WEIGHTEDSMOOTHL1LOCALIZATIONLOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.WeightedSmoothL1LocalizationLoss)
+  ))
+_sym_db.RegisterMessage(WeightedSmoothL1LocalizationLoss)
+
+WeightedIOULocalizationLoss = _reflection.GeneratedProtocolMessageType('WeightedIOULocalizationLoss', (_message.Message,), dict(
+  DESCRIPTOR = _WEIGHTEDIOULOCALIZATIONLOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.WeightedIOULocalizationLoss)
+  ))
+_sym_db.RegisterMessage(WeightedIOULocalizationLoss)
+
+ClassificationLoss = _reflection.GeneratedProtocolMessageType('ClassificationLoss', (_message.Message,), dict(
+  DESCRIPTOR = _CLASSIFICATIONLOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ClassificationLoss)
+  ))
+_sym_db.RegisterMessage(ClassificationLoss)
+
+WeightedSigmoidClassificationLoss = _reflection.GeneratedProtocolMessageType('WeightedSigmoidClassificationLoss', (_message.Message,), dict(
+  DESCRIPTOR = _WEIGHTEDSIGMOIDCLASSIFICATIONLOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.WeightedSigmoidClassificationLoss)
+  ))
+_sym_db.RegisterMessage(WeightedSigmoidClassificationLoss)
+
+WeightedSoftmaxClassificationLoss = _reflection.GeneratedProtocolMessageType('WeightedSoftmaxClassificationLoss', (_message.Message,), dict(
+  DESCRIPTOR = _WEIGHTEDSOFTMAXCLASSIFICATIONLOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.WeightedSoftmaxClassificationLoss)
+  ))
+_sym_db.RegisterMessage(WeightedSoftmaxClassificationLoss)
+
+BootstrappedSigmoidClassificationLoss = _reflection.GeneratedProtocolMessageType('BootstrappedSigmoidClassificationLoss', (_message.Message,), dict(
+  DESCRIPTOR = _BOOTSTRAPPEDSIGMOIDCLASSIFICATIONLOSS,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.BootstrappedSigmoidClassificationLoss)
+  ))
+_sym_db.RegisterMessage(BootstrappedSigmoidClassificationLoss)
+
+HardExampleMiner = _reflection.GeneratedProtocolMessageType('HardExampleMiner', (_message.Message,), dict(
+  DESCRIPTOR = _HARDEXAMPLEMINER,
+  __module__ = 'object_detection.protos.losses_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.HardExampleMiner)
+  ))
+_sym_db.RegisterMessage(HardExampleMiner)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/matcher.proto b/reconnaissance images/object_detection/protos/matcher.proto
new file mode 100644
index 0000000..b47de56
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/matcher.proto	
@@ -0,0 +1,15 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+import "object_detection/protos/argmax_matcher.proto";
+import "object_detection/protos/bipartite_matcher.proto";
+
+// Configuration proto for the matcher to be used in the object detection
+// pipeline. See core/matcher.py for details.
+message Matcher {
+  oneof matcher_oneof {
+    ArgMaxMatcher argmax_matcher = 1;
+    BipartiteMatcher bipartite_matcher = 2;
+  }
+}
diff --git a/reconnaissance images/object_detection/protos/matcher_pb2.py b/reconnaissance images/object_detection/protos/matcher_pb2.py
new file mode 100644
index 0000000..8fb5906
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/matcher_pb2.py	
@@ -0,0 +1,90 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/matcher.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import argmax_matcher_pb2 as object__detection_dot_protos_dot_argmax__matcher__pb2
+from object_detection.protos import bipartite_matcher_pb2 as object__detection_dot_protos_dot_bipartite__matcher__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/matcher.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n%object_detection/protos/matcher.proto\x12\x17object_detection.protos\x1a,object_detection/protos/argmax_matcher.proto\x1a/object_detection/protos/bipartite_matcher.proto\"\xa4\x01\n\x07Matcher\x12@\n\x0e\x61rgmax_matcher\x18\x01 \x01(\x0b\x32&.object_detection.protos.ArgMaxMatcherH\x00\x12\x46\n\x11\x62ipartite_matcher\x18\x02 \x01(\x0b\x32).object_detection.protos.BipartiteMatcherH\x00\x42\x0f\n\rmatcher_oneof')
+  ,
+  dependencies=[object__detection_dot_protos_dot_argmax__matcher__pb2.DESCRIPTOR,object__detection_dot_protos_dot_bipartite__matcher__pb2.DESCRIPTOR,])
+
+
+
+
+_MATCHER = _descriptor.Descriptor(
+  name='Matcher',
+  full_name='object_detection.protos.Matcher',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='argmax_matcher', full_name='object_detection.protos.Matcher.argmax_matcher', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='bipartite_matcher', full_name='object_detection.protos.Matcher.bipartite_matcher', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='matcher_oneof', full_name='object_detection.protos.Matcher.matcher_oneof',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=162,
+  serialized_end=326,
+)
+
+_MATCHER.fields_by_name['argmax_matcher'].message_type = object__detection_dot_protos_dot_argmax__matcher__pb2._ARGMAXMATCHER
+_MATCHER.fields_by_name['bipartite_matcher'].message_type = object__detection_dot_protos_dot_bipartite__matcher__pb2._BIPARTITEMATCHER
+_MATCHER.oneofs_by_name['matcher_oneof'].fields.append(
+  _MATCHER.fields_by_name['argmax_matcher'])
+_MATCHER.fields_by_name['argmax_matcher'].containing_oneof = _MATCHER.oneofs_by_name['matcher_oneof']
+_MATCHER.oneofs_by_name['matcher_oneof'].fields.append(
+  _MATCHER.fields_by_name['bipartite_matcher'])
+_MATCHER.fields_by_name['bipartite_matcher'].containing_oneof = _MATCHER.oneofs_by_name['matcher_oneof']
+DESCRIPTOR.message_types_by_name['Matcher'] = _MATCHER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Matcher = _reflection.GeneratedProtocolMessageType('Matcher', (_message.Message,), dict(
+  DESCRIPTOR = _MATCHER,
+  __module__ = 'object_detection.protos.matcher_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.Matcher)
+  ))
+_sym_db.RegisterMessage(Matcher)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/mean_stddev_box_coder.proto b/reconnaissance images/object_detection/protos/mean_stddev_box_coder.proto
new file mode 100644
index 0000000..597c70c
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/mean_stddev_box_coder.proto	
@@ -0,0 +1,8 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for MeanStddevBoxCoder. See
+// box_coders/mean_stddev_box_coder.py for details.
+message MeanStddevBoxCoder {
+}
diff --git a/reconnaissance images/object_detection/protos/mean_stddev_box_coder_pb2.py b/reconnaissance images/object_detection/protos/mean_stddev_box_coder_pb2.py
new file mode 100644
index 0000000..184565d
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/mean_stddev_box_coder_pb2.py	
@@ -0,0 +1,62 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/mean_stddev_box_coder.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/mean_stddev_box_coder.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n3object_detection/protos/mean_stddev_box_coder.proto\x12\x17object_detection.protos\"\x14\n\x12MeanStddevBoxCoder')
+)
+
+
+
+
+_MEANSTDDEVBOXCODER = _descriptor.Descriptor(
+  name='MeanStddevBoxCoder',
+  full_name='object_detection.protos.MeanStddevBoxCoder',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=80,
+  serialized_end=100,
+)
+
+DESCRIPTOR.message_types_by_name['MeanStddevBoxCoder'] = _MEANSTDDEVBOXCODER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+MeanStddevBoxCoder = _reflection.GeneratedProtocolMessageType('MeanStddevBoxCoder', (_message.Message,), dict(
+  DESCRIPTOR = _MEANSTDDEVBOXCODER,
+  __module__ = 'object_detection.protos.mean_stddev_box_coder_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.MeanStddevBoxCoder)
+  ))
+_sym_db.RegisterMessage(MeanStddevBoxCoder)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/model.proto b/reconnaissance images/object_detection/protos/model.proto
new file mode 100644
index 0000000..b699c17
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/model.proto	
@@ -0,0 +1,14 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+import "object_detection/protos/faster_rcnn.proto";
+import "object_detection/protos/ssd.proto";
+
+// Top level configuration for DetectionModels.
+message DetectionModel {
+  oneof model {
+    FasterRcnn faster_rcnn = 1;
+    Ssd ssd = 2;
+  }
+}
diff --git a/reconnaissance images/object_detection/protos/model_pb2.py b/reconnaissance images/object_detection/protos/model_pb2.py
new file mode 100644
index 0000000..da0802c
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/model_pb2.py	
@@ -0,0 +1,90 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/model.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import faster_rcnn_pb2 as object__detection_dot_protos_dot_faster__rcnn__pb2
+from object_detection.protos import ssd_pb2 as object__detection_dot_protos_dot_ssd__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/model.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n#object_detection/protos/model.proto\x12\x17object_detection.protos\x1a)object_detection/protos/faster_rcnn.proto\x1a!object_detection/protos/ssd.proto\"\x82\x01\n\x0e\x44\x65tectionModel\x12:\n\x0b\x66\x61ster_rcnn\x18\x01 \x01(\x0b\x32#.object_detection.protos.FasterRcnnH\x00\x12+\n\x03ssd\x18\x02 \x01(\x0b\x32\x1c.object_detection.protos.SsdH\x00\x42\x07\n\x05model')
+  ,
+  dependencies=[object__detection_dot_protos_dot_faster__rcnn__pb2.DESCRIPTOR,object__detection_dot_protos_dot_ssd__pb2.DESCRIPTOR,])
+
+
+
+
+_DETECTIONMODEL = _descriptor.Descriptor(
+  name='DetectionModel',
+  full_name='object_detection.protos.DetectionModel',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='faster_rcnn', full_name='object_detection.protos.DetectionModel.faster_rcnn', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='ssd', full_name='object_detection.protos.DetectionModel.ssd', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='model', full_name='object_detection.protos.DetectionModel.model',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=143,
+  serialized_end=273,
+)
+
+_DETECTIONMODEL.fields_by_name['faster_rcnn'].message_type = object__detection_dot_protos_dot_faster__rcnn__pb2._FASTERRCNN
+_DETECTIONMODEL.fields_by_name['ssd'].message_type = object__detection_dot_protos_dot_ssd__pb2._SSD
+_DETECTIONMODEL.oneofs_by_name['model'].fields.append(
+  _DETECTIONMODEL.fields_by_name['faster_rcnn'])
+_DETECTIONMODEL.fields_by_name['faster_rcnn'].containing_oneof = _DETECTIONMODEL.oneofs_by_name['model']
+_DETECTIONMODEL.oneofs_by_name['model'].fields.append(
+  _DETECTIONMODEL.fields_by_name['ssd'])
+_DETECTIONMODEL.fields_by_name['ssd'].containing_oneof = _DETECTIONMODEL.oneofs_by_name['model']
+DESCRIPTOR.message_types_by_name['DetectionModel'] = _DETECTIONMODEL
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+DetectionModel = _reflection.GeneratedProtocolMessageType('DetectionModel', (_message.Message,), dict(
+  DESCRIPTOR = _DETECTIONMODEL,
+  __module__ = 'object_detection.protos.model_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.DetectionModel)
+  ))
+_sym_db.RegisterMessage(DetectionModel)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/optimizer.proto b/reconnaissance images/object_detection/protos/optimizer.proto
new file mode 100644
index 0000000..6ea9f19
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/optimizer.proto	
@@ -0,0 +1,73 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Messages for configuring the optimizing strategy for training object
+// detection models.
+
+// Top level optimizer message.
+message Optimizer {
+  oneof optimizer {
+    RMSPropOptimizer rms_prop_optimizer = 1;
+    MomentumOptimizer momentum_optimizer = 2;
+    AdamOptimizer adam_optimizer = 3;
+  }
+  optional bool use_moving_average = 4 [default=true];
+  optional float moving_average_decay = 5 [default=0.9999];
+}
+
+// Configuration message for the RMSPropOptimizer
+// See: https://www.tensorflow.org/api_docs/python/tf/train/RMSPropOptimizer
+message RMSPropOptimizer {
+  optional LearningRate learning_rate = 1;
+  optional float momentum_optimizer_value = 2 [default=0.9];
+  optional float decay = 3 [default=0.9];
+  optional float epsilon = 4 [default=1.0];
+}
+
+// Configuration message for the MomentumOptimizer
+// See: https://www.tensorflow.org/api_docs/python/tf/train/MomentumOptimizer
+message MomentumOptimizer {
+  optional LearningRate learning_rate = 1;
+  optional float momentum_optimizer_value = 2 [default=0.9];
+}
+
+// Configuration message for the AdamOptimizer
+// See: https://www.tensorflow.org/api_docs/python/tf/train/AdamOptimizer
+message AdamOptimizer {
+  optional LearningRate learning_rate = 1;
+}
+
+// Configuration message for optimizer learning rate.
+message LearningRate {
+  oneof learning_rate {
+    ConstantLearningRate constant_learning_rate = 1;
+    ExponentialDecayLearningRate exponential_decay_learning_rate = 2;
+    ManualStepLearningRate manual_step_learning_rate = 3;
+  }
+}
+
+// Configuration message for a constant learning rate.
+message ConstantLearningRate {
+  optional float learning_rate = 1 [default=0.002];
+}
+
+// Configuration message for an exponentially decaying learning rate.
+// See https://www.tensorflow.org/versions/master/api_docs/python/train/ \
+//     decaying_the_learning_rate#exponential_decay
+message ExponentialDecayLearningRate {
+  optional float initial_learning_rate = 1 [default=0.002];
+  optional uint32 decay_steps = 2 [default=4000000];
+  optional float decay_factor = 3 [default=0.95];
+  optional bool staircase = 4 [default=true];
+}
+
+// Configuration message for a manually defined learning rate schedule.
+message ManualStepLearningRate {
+  optional float initial_learning_rate = 1 [default=0.002];
+  message LearningRateSchedule {
+    optional uint32 step = 1;
+    optional float learning_rate = 2 [default=0.002];
+  }
+  repeated LearningRateSchedule schedule = 2;
+}
diff --git a/reconnaissance images/object_detection/protos/optimizer_pb2.py b/reconnaissance images/object_detection/protos/optimizer_pb2.py
new file mode 100644
index 0000000..8e42a3b
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/optimizer_pb2.py	
@@ -0,0 +1,520 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/optimizer.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/optimizer.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n\'object_detection/protos/optimizer.proto\x12\x17object_detection.protos\"\xb5\x02\n\tOptimizer\x12G\n\x12rms_prop_optimizer\x18\x01 \x01(\x0b\x32).object_detection.protos.RMSPropOptimizerH\x00\x12H\n\x12momentum_optimizer\x18\x02 \x01(\x0b\x32*.object_detection.protos.MomentumOptimizerH\x00\x12@\n\x0e\x61\x64\x61m_optimizer\x18\x03 \x01(\x0b\x32&.object_detection.protos.AdamOptimizerH\x00\x12 \n\x12use_moving_average\x18\x04 \x01(\x08:\x04true\x12$\n\x14moving_average_decay\x18\x05 \x01(\x02:\x06\x30.9999B\x0b\n\toptimizer\"\x9f\x01\n\x10RMSPropOptimizer\x12<\n\rlearning_rate\x18\x01 \x01(\x0b\x32%.object_detection.protos.LearningRate\x12%\n\x18momentum_optimizer_value\x18\x02 \x01(\x02:\x03\x30.9\x12\x12\n\x05\x64\x65\x63\x61y\x18\x03 \x01(\x02:\x03\x30.9\x12\x12\n\x07\x65psilon\x18\x04 \x01(\x02:\x01\x31\"x\n\x11MomentumOptimizer\x12<\n\rlearning_rate\x18\x01 \x01(\x0b\x32%.object_detection.protos.LearningRate\x12%\n\x18momentum_optimizer_value\x18\x02 \x01(\x02:\x03\x30.9\"M\n\rAdamOptimizer\x12<\n\rlearning_rate\x18\x01 \x01(\x0b\x32%.object_detection.protos.LearningRate\"\xa8\x02\n\x0cLearningRate\x12O\n\x16\x63onstant_learning_rate\x18\x01 \x01(\x0b\x32-.object_detection.protos.ConstantLearningRateH\x00\x12`\n\x1f\x65xponential_decay_learning_rate\x18\x02 \x01(\x0b\x32\x35.object_detection.protos.ExponentialDecayLearningRateH\x00\x12T\n\x19manual_step_learning_rate\x18\x03 \x01(\x0b\x32/.object_detection.protos.ManualStepLearningRateH\x00\x42\x0f\n\rlearning_rate\"4\n\x14\x43onstantLearningRate\x12\x1c\n\rlearning_rate\x18\x01 \x01(\x02:\x05\x30.002\"\x97\x01\n\x1c\x45xponentialDecayLearningRate\x12$\n\x15initial_learning_rate\x18\x01 \x01(\x02:\x05\x30.002\x12\x1c\n\x0b\x64\x65\x63\x61y_steps\x18\x02 \x01(\r:\x07\x34\x30\x30\x30\x30\x30\x30\x12\x1a\n\x0c\x64\x65\x63\x61y_factor\x18\x03 \x01(\x02:\x04\x30.95\x12\x17\n\tstaircase\x18\x04 \x01(\x08:\x04true\"\xda\x01\n\x16ManualStepLearningRate\x12$\n\x15initial_learning_rate\x18\x01 \x01(\x02:\x05\x30.002\x12V\n\x08schedule\x18\x02 \x03(\x0b\x32\x44.object_detection.protos.ManualStepLearningRate.LearningRateSchedule\x1a\x42\n\x14LearningRateSchedule\x12\x0c\n\x04step\x18\x01 \x01(\r\x12\x1c\n\rlearning_rate\x18\x02 \x01(\x02:\x05\x30.002')
+)
+
+
+
+
+_OPTIMIZER = _descriptor.Descriptor(
+  name='Optimizer',
+  full_name='object_detection.protos.Optimizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='rms_prop_optimizer', full_name='object_detection.protos.Optimizer.rms_prop_optimizer', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='momentum_optimizer', full_name='object_detection.protos.Optimizer.momentum_optimizer', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='adam_optimizer', full_name='object_detection.protos.Optimizer.adam_optimizer', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='use_moving_average', full_name='object_detection.protos.Optimizer.use_moving_average', index=3,
+      number=4, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='moving_average_decay', full_name='object_detection.protos.Optimizer.moving_average_decay', index=4,
+      number=5, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.9999),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='optimizer', full_name='object_detection.protos.Optimizer.optimizer',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=69,
+  serialized_end=378,
+)
+
+
+_RMSPROPOPTIMIZER = _descriptor.Descriptor(
+  name='RMSPropOptimizer',
+  full_name='object_detection.protos.RMSPropOptimizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='learning_rate', full_name='object_detection.protos.RMSPropOptimizer.learning_rate', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='momentum_optimizer_value', full_name='object_detection.protos.RMSPropOptimizer.momentum_optimizer_value', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.9),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='decay', full_name='object_detection.protos.RMSPropOptimizer.decay', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.9),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='epsilon', full_name='object_detection.protos.RMSPropOptimizer.epsilon', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=381,
+  serialized_end=540,
+)
+
+
+_MOMENTUMOPTIMIZER = _descriptor.Descriptor(
+  name='MomentumOptimizer',
+  full_name='object_detection.protos.MomentumOptimizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='learning_rate', full_name='object_detection.protos.MomentumOptimizer.learning_rate', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='momentum_optimizer_value', full_name='object_detection.protos.MomentumOptimizer.momentum_optimizer_value', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.9),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=542,
+  serialized_end=662,
+)
+
+
+_ADAMOPTIMIZER = _descriptor.Descriptor(
+  name='AdamOptimizer',
+  full_name='object_detection.protos.AdamOptimizer',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='learning_rate', full_name='object_detection.protos.AdamOptimizer.learning_rate', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=664,
+  serialized_end=741,
+)
+
+
+_LEARNINGRATE = _descriptor.Descriptor(
+  name='LearningRate',
+  full_name='object_detection.protos.LearningRate',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='constant_learning_rate', full_name='object_detection.protos.LearningRate.constant_learning_rate', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='exponential_decay_learning_rate', full_name='object_detection.protos.LearningRate.exponential_decay_learning_rate', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='manual_step_learning_rate', full_name='object_detection.protos.LearningRate.manual_step_learning_rate', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='learning_rate', full_name='object_detection.protos.LearningRate.learning_rate',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=744,
+  serialized_end=1040,
+)
+
+
+_CONSTANTLEARNINGRATE = _descriptor.Descriptor(
+  name='ConstantLearningRate',
+  full_name='object_detection.protos.ConstantLearningRate',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='learning_rate', full_name='object_detection.protos.ConstantLearningRate.learning_rate', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.002),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1042,
+  serialized_end=1094,
+)
+
+
+_EXPONENTIALDECAYLEARNINGRATE = _descriptor.Descriptor(
+  name='ExponentialDecayLearningRate',
+  full_name='object_detection.protos.ExponentialDecayLearningRate',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='initial_learning_rate', full_name='object_detection.protos.ExponentialDecayLearningRate.initial_learning_rate', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.002),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='decay_steps', full_name='object_detection.protos.ExponentialDecayLearningRate.decay_steps', index=1,
+      number=2, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=4000000,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='decay_factor', full_name='object_detection.protos.ExponentialDecayLearningRate.decay_factor', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.95),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='staircase', full_name='object_detection.protos.ExponentialDecayLearningRate.staircase', index=3,
+      number=4, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1097,
+  serialized_end=1248,
+)
+
+
+_MANUALSTEPLEARNINGRATE_LEARNINGRATESCHEDULE = _descriptor.Descriptor(
+  name='LearningRateSchedule',
+  full_name='object_detection.protos.ManualStepLearningRate.LearningRateSchedule',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='step', full_name='object_detection.protos.ManualStepLearningRate.LearningRateSchedule.step', index=0,
+      number=1, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='learning_rate', full_name='object_detection.protos.ManualStepLearningRate.LearningRateSchedule.learning_rate', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.002),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1403,
+  serialized_end=1469,
+)
+
+_MANUALSTEPLEARNINGRATE = _descriptor.Descriptor(
+  name='ManualStepLearningRate',
+  full_name='object_detection.protos.ManualStepLearningRate',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='initial_learning_rate', full_name='object_detection.protos.ManualStepLearningRate.initial_learning_rate', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.002),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='schedule', full_name='object_detection.protos.ManualStepLearningRate.schedule', index=1,
+      number=2, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[_MANUALSTEPLEARNINGRATE_LEARNINGRATESCHEDULE, ],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1251,
+  serialized_end=1469,
+)
+
+_OPTIMIZER.fields_by_name['rms_prop_optimizer'].message_type = _RMSPROPOPTIMIZER
+_OPTIMIZER.fields_by_name['momentum_optimizer'].message_type = _MOMENTUMOPTIMIZER
+_OPTIMIZER.fields_by_name['adam_optimizer'].message_type = _ADAMOPTIMIZER
+_OPTIMIZER.oneofs_by_name['optimizer'].fields.append(
+  _OPTIMIZER.fields_by_name['rms_prop_optimizer'])
+_OPTIMIZER.fields_by_name['rms_prop_optimizer'].containing_oneof = _OPTIMIZER.oneofs_by_name['optimizer']
+_OPTIMIZER.oneofs_by_name['optimizer'].fields.append(
+  _OPTIMIZER.fields_by_name['momentum_optimizer'])
+_OPTIMIZER.fields_by_name['momentum_optimizer'].containing_oneof = _OPTIMIZER.oneofs_by_name['optimizer']
+_OPTIMIZER.oneofs_by_name['optimizer'].fields.append(
+  _OPTIMIZER.fields_by_name['adam_optimizer'])
+_OPTIMIZER.fields_by_name['adam_optimizer'].containing_oneof = _OPTIMIZER.oneofs_by_name['optimizer']
+_RMSPROPOPTIMIZER.fields_by_name['learning_rate'].message_type = _LEARNINGRATE
+_MOMENTUMOPTIMIZER.fields_by_name['learning_rate'].message_type = _LEARNINGRATE
+_ADAMOPTIMIZER.fields_by_name['learning_rate'].message_type = _LEARNINGRATE
+_LEARNINGRATE.fields_by_name['constant_learning_rate'].message_type = _CONSTANTLEARNINGRATE
+_LEARNINGRATE.fields_by_name['exponential_decay_learning_rate'].message_type = _EXPONENTIALDECAYLEARNINGRATE
+_LEARNINGRATE.fields_by_name['manual_step_learning_rate'].message_type = _MANUALSTEPLEARNINGRATE
+_LEARNINGRATE.oneofs_by_name['learning_rate'].fields.append(
+  _LEARNINGRATE.fields_by_name['constant_learning_rate'])
+_LEARNINGRATE.fields_by_name['constant_learning_rate'].containing_oneof = _LEARNINGRATE.oneofs_by_name['learning_rate']
+_LEARNINGRATE.oneofs_by_name['learning_rate'].fields.append(
+  _LEARNINGRATE.fields_by_name['exponential_decay_learning_rate'])
+_LEARNINGRATE.fields_by_name['exponential_decay_learning_rate'].containing_oneof = _LEARNINGRATE.oneofs_by_name['learning_rate']
+_LEARNINGRATE.oneofs_by_name['learning_rate'].fields.append(
+  _LEARNINGRATE.fields_by_name['manual_step_learning_rate'])
+_LEARNINGRATE.fields_by_name['manual_step_learning_rate'].containing_oneof = _LEARNINGRATE.oneofs_by_name['learning_rate']
+_MANUALSTEPLEARNINGRATE_LEARNINGRATESCHEDULE.containing_type = _MANUALSTEPLEARNINGRATE
+_MANUALSTEPLEARNINGRATE.fields_by_name['schedule'].message_type = _MANUALSTEPLEARNINGRATE_LEARNINGRATESCHEDULE
+DESCRIPTOR.message_types_by_name['Optimizer'] = _OPTIMIZER
+DESCRIPTOR.message_types_by_name['RMSPropOptimizer'] = _RMSPROPOPTIMIZER
+DESCRIPTOR.message_types_by_name['MomentumOptimizer'] = _MOMENTUMOPTIMIZER
+DESCRIPTOR.message_types_by_name['AdamOptimizer'] = _ADAMOPTIMIZER
+DESCRIPTOR.message_types_by_name['LearningRate'] = _LEARNINGRATE
+DESCRIPTOR.message_types_by_name['ConstantLearningRate'] = _CONSTANTLEARNINGRATE
+DESCRIPTOR.message_types_by_name['ExponentialDecayLearningRate'] = _EXPONENTIALDECAYLEARNINGRATE
+DESCRIPTOR.message_types_by_name['ManualStepLearningRate'] = _MANUALSTEPLEARNINGRATE
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Optimizer = _reflection.GeneratedProtocolMessageType('Optimizer', (_message.Message,), dict(
+  DESCRIPTOR = _OPTIMIZER,
+  __module__ = 'object_detection.protos.optimizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.Optimizer)
+  ))
+_sym_db.RegisterMessage(Optimizer)
+
+RMSPropOptimizer = _reflection.GeneratedProtocolMessageType('RMSPropOptimizer', (_message.Message,), dict(
+  DESCRIPTOR = _RMSPROPOPTIMIZER,
+  __module__ = 'object_detection.protos.optimizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RMSPropOptimizer)
+  ))
+_sym_db.RegisterMessage(RMSPropOptimizer)
+
+MomentumOptimizer = _reflection.GeneratedProtocolMessageType('MomentumOptimizer', (_message.Message,), dict(
+  DESCRIPTOR = _MOMENTUMOPTIMIZER,
+  __module__ = 'object_detection.protos.optimizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.MomentumOptimizer)
+  ))
+_sym_db.RegisterMessage(MomentumOptimizer)
+
+AdamOptimizer = _reflection.GeneratedProtocolMessageType('AdamOptimizer', (_message.Message,), dict(
+  DESCRIPTOR = _ADAMOPTIMIZER,
+  __module__ = 'object_detection.protos.optimizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.AdamOptimizer)
+  ))
+_sym_db.RegisterMessage(AdamOptimizer)
+
+LearningRate = _reflection.GeneratedProtocolMessageType('LearningRate', (_message.Message,), dict(
+  DESCRIPTOR = _LEARNINGRATE,
+  __module__ = 'object_detection.protos.optimizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.LearningRate)
+  ))
+_sym_db.RegisterMessage(LearningRate)
+
+ConstantLearningRate = _reflection.GeneratedProtocolMessageType('ConstantLearningRate', (_message.Message,), dict(
+  DESCRIPTOR = _CONSTANTLEARNINGRATE,
+  __module__ = 'object_detection.protos.optimizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ConstantLearningRate)
+  ))
+_sym_db.RegisterMessage(ConstantLearningRate)
+
+ExponentialDecayLearningRate = _reflection.GeneratedProtocolMessageType('ExponentialDecayLearningRate', (_message.Message,), dict(
+  DESCRIPTOR = _EXPONENTIALDECAYLEARNINGRATE,
+  __module__ = 'object_detection.protos.optimizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ExponentialDecayLearningRate)
+  ))
+_sym_db.RegisterMessage(ExponentialDecayLearningRate)
+
+ManualStepLearningRate = _reflection.GeneratedProtocolMessageType('ManualStepLearningRate', (_message.Message,), dict(
+
+  LearningRateSchedule = _reflection.GeneratedProtocolMessageType('LearningRateSchedule', (_message.Message,), dict(
+    DESCRIPTOR = _MANUALSTEPLEARNINGRATE_LEARNINGRATESCHEDULE,
+    __module__ = 'object_detection.protos.optimizer_pb2'
+    # @@protoc_insertion_point(class_scope:object_detection.protos.ManualStepLearningRate.LearningRateSchedule)
+    ))
+  ,
+  DESCRIPTOR = _MANUALSTEPLEARNINGRATE,
+  __module__ = 'object_detection.protos.optimizer_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ManualStepLearningRate)
+  ))
+_sym_db.RegisterMessage(ManualStepLearningRate)
+_sym_db.RegisterMessage(ManualStepLearningRate.LearningRateSchedule)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/pipeline.proto b/reconnaissance images/object_detection/protos/pipeline.proto
new file mode 100644
index 0000000..67f4e54
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/pipeline.proto	
@@ -0,0 +1,18 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+import "object_detection/protos/eval.proto";
+import "object_detection/protos/input_reader.proto";
+import "object_detection/protos/model.proto";
+import "object_detection/protos/train.proto";
+
+// Convenience message for configuring a training and eval pipeline. Allows all
+// of the pipeline parameters to be configured from one file.
+message TrainEvalPipelineConfig {
+  optional DetectionModel model = 1;
+  optional TrainConfig train_config = 2;
+  optional InputReader train_input_reader = 3;
+  optional EvalConfig eval_config = 4;
+  optional InputReader eval_input_reader = 5;
+}
diff --git a/reconnaissance images/object_detection/protos/pipeline_pb2.py b/reconnaissance images/object_detection/protos/pipeline_pb2.py
new file mode 100644
index 0000000..a6dd4c2
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/pipeline_pb2.py	
@@ -0,0 +1,107 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/pipeline.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import eval_pb2 as object__detection_dot_protos_dot_eval__pb2
+from object_detection.protos import input_reader_pb2 as object__detection_dot_protos_dot_input__reader__pb2
+from object_detection.protos import model_pb2 as object__detection_dot_protos_dot_model__pb2
+from object_detection.protos import train_pb2 as object__detection_dot_protos_dot_train__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/pipeline.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n&object_detection/protos/pipeline.proto\x12\x17object_detection.protos\x1a\"object_detection/protos/eval.proto\x1a*object_detection/protos/input_reader.proto\x1a#object_detection/protos/model.proto\x1a#object_detection/protos/train.proto\"\xca\x02\n\x17TrainEvalPipelineConfig\x12\x36\n\x05model\x18\x01 \x01(\x0b\x32\'.object_detection.protos.DetectionModel\x12:\n\x0ctrain_config\x18\x02 \x01(\x0b\x32$.object_detection.protos.TrainConfig\x12@\n\x12train_input_reader\x18\x03 \x01(\x0b\x32$.object_detection.protos.InputReader\x12\x38\n\x0b\x65val_config\x18\x04 \x01(\x0b\x32#.object_detection.protos.EvalConfig\x12?\n\x11\x65val_input_reader\x18\x05 \x01(\x0b\x32$.object_detection.protos.InputReader')
+  ,
+  dependencies=[object__detection_dot_protos_dot_eval__pb2.DESCRIPTOR,object__detection_dot_protos_dot_input__reader__pb2.DESCRIPTOR,object__detection_dot_protos_dot_model__pb2.DESCRIPTOR,object__detection_dot_protos_dot_train__pb2.DESCRIPTOR,])
+
+
+
+
+_TRAINEVALPIPELINECONFIG = _descriptor.Descriptor(
+  name='TrainEvalPipelineConfig',
+  full_name='object_detection.protos.TrainEvalPipelineConfig',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='model', full_name='object_detection.protos.TrainEvalPipelineConfig.model', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='train_config', full_name='object_detection.protos.TrainEvalPipelineConfig.train_config', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='train_input_reader', full_name='object_detection.protos.TrainEvalPipelineConfig.train_input_reader', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='eval_config', full_name='object_detection.protos.TrainEvalPipelineConfig.eval_config', index=3,
+      number=4, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='eval_input_reader', full_name='object_detection.protos.TrainEvalPipelineConfig.eval_input_reader', index=4,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=222,
+  serialized_end=552,
+)
+
+_TRAINEVALPIPELINECONFIG.fields_by_name['model'].message_type = object__detection_dot_protos_dot_model__pb2._DETECTIONMODEL
+_TRAINEVALPIPELINECONFIG.fields_by_name['train_config'].message_type = object__detection_dot_protos_dot_train__pb2._TRAINCONFIG
+_TRAINEVALPIPELINECONFIG.fields_by_name['train_input_reader'].message_type = object__detection_dot_protos_dot_input__reader__pb2._INPUTREADER
+_TRAINEVALPIPELINECONFIG.fields_by_name['eval_config'].message_type = object__detection_dot_protos_dot_eval__pb2._EVALCONFIG
+_TRAINEVALPIPELINECONFIG.fields_by_name['eval_input_reader'].message_type = object__detection_dot_protos_dot_input__reader__pb2._INPUTREADER
+DESCRIPTOR.message_types_by_name['TrainEvalPipelineConfig'] = _TRAINEVALPIPELINECONFIG
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+TrainEvalPipelineConfig = _reflection.GeneratedProtocolMessageType('TrainEvalPipelineConfig', (_message.Message,), dict(
+  DESCRIPTOR = _TRAINEVALPIPELINECONFIG,
+  __module__ = 'object_detection.protos.pipeline_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.TrainEvalPipelineConfig)
+  ))
+_sym_db.RegisterMessage(TrainEvalPipelineConfig)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/post_processing.proto b/reconnaissance images/object_detection/protos/post_processing.proto
new file mode 100644
index 0000000..736ac57
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/post_processing.proto	
@@ -0,0 +1,42 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for non-max-suppression operation on a batch of
+// detections.
+message BatchNonMaxSuppression {
+  // Scalar threshold for score (low scoring boxes are removed).
+  optional float score_threshold = 1 [default = 0.0];
+
+  // Scalar threshold for IOU (boxes that have high IOU overlap
+  // with previously selected boxes are removed).
+  optional float iou_threshold = 2 [default = 0.6];
+
+  // Maximum number of detections to retain per class.
+  optional int32 max_detections_per_class = 3 [default = 100];
+
+  // Maximum number of detections to retain across all classes.
+  optional int32 max_total_detections = 5 [default = 100];
+}
+
+// Configuration proto for post-processing predicted boxes and
+// scores.
+message PostProcessing {
+  // Non max suppression parameters.
+  optional BatchNonMaxSuppression batch_non_max_suppression = 1;
+
+  // Enum to specify how to convert the detection scores.
+  enum ScoreConverter {
+    // Input scores equals output scores.
+    IDENTITY = 0;
+
+    // Applies a sigmoid on input scores.
+    SIGMOID = 1;
+
+    // Applies a softmax on input scores
+    SOFTMAX = 2;
+  }
+
+  // Score converter to use.
+  optional ScoreConverter score_converter = 2 [default = IDENTITY];
+}
diff --git a/reconnaissance images/object_detection/protos/post_processing_pb2.py b/reconnaissance images/object_detection/protos/post_processing_pb2.py
new file mode 100644
index 0000000..e4dcdd8
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/post_processing_pb2.py	
@@ -0,0 +1,166 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/post_processing.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/post_processing.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n-object_detection/protos/post_processing.proto\x12\x17object_detection.protos\"\x9a\x01\n\x16\x42\x61tchNonMaxSuppression\x12\x1a\n\x0fscore_threshold\x18\x01 \x01(\x02:\x01\x30\x12\x1a\n\riou_threshold\x18\x02 \x01(\x02:\x03\x30.6\x12%\n\x18max_detections_per_class\x18\x03 \x01(\x05:\x03\x31\x30\x30\x12!\n\x14max_total_detections\x18\x05 \x01(\x05:\x03\x31\x30\x30\"\xf9\x01\n\x0ePostProcessing\x12R\n\x19\x62\x61tch_non_max_suppression\x18\x01 \x01(\x0b\x32/.object_detection.protos.BatchNonMaxSuppression\x12Y\n\x0fscore_converter\x18\x02 \x01(\x0e\x32\x36.object_detection.protos.PostProcessing.ScoreConverter:\x08IDENTITY\"8\n\x0eScoreConverter\x12\x0c\n\x08IDENTITY\x10\x00\x12\x0b\n\x07SIGMOID\x10\x01\x12\x0b\n\x07SOFTMAX\x10\x02')
+)
+
+
+
+_POSTPROCESSING_SCORECONVERTER = _descriptor.EnumDescriptor(
+  name='ScoreConverter',
+  full_name='object_detection.protos.PostProcessing.ScoreConverter',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='IDENTITY', index=0, number=0,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='SIGMOID', index=1, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='SOFTMAX', index=2, number=2,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=425,
+  serialized_end=481,
+)
+_sym_db.RegisterEnumDescriptor(_POSTPROCESSING_SCORECONVERTER)
+
+
+_BATCHNONMAXSUPPRESSION = _descriptor.Descriptor(
+  name='BatchNonMaxSuppression',
+  full_name='object_detection.protos.BatchNonMaxSuppression',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='score_threshold', full_name='object_detection.protos.BatchNonMaxSuppression.score_threshold', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='iou_threshold', full_name='object_detection.protos.BatchNonMaxSuppression.iou_threshold', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.6),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_detections_per_class', full_name='object_detection.protos.BatchNonMaxSuppression.max_detections_per_class', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=100,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_total_detections', full_name='object_detection.protos.BatchNonMaxSuppression.max_total_detections', index=3,
+      number=5, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=100,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=75,
+  serialized_end=229,
+)
+
+
+_POSTPROCESSING = _descriptor.Descriptor(
+  name='PostProcessing',
+  full_name='object_detection.protos.PostProcessing',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='batch_non_max_suppression', full_name='object_detection.protos.PostProcessing.batch_non_max_suppression', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='score_converter', full_name='object_detection.protos.PostProcessing.score_converter', index=1,
+      number=2, type=14, cpp_type=8, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _POSTPROCESSING_SCORECONVERTER,
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=232,
+  serialized_end=481,
+)
+
+_POSTPROCESSING.fields_by_name['batch_non_max_suppression'].message_type = _BATCHNONMAXSUPPRESSION
+_POSTPROCESSING.fields_by_name['score_converter'].enum_type = _POSTPROCESSING_SCORECONVERTER
+_POSTPROCESSING_SCORECONVERTER.containing_type = _POSTPROCESSING
+DESCRIPTOR.message_types_by_name['BatchNonMaxSuppression'] = _BATCHNONMAXSUPPRESSION
+DESCRIPTOR.message_types_by_name['PostProcessing'] = _POSTPROCESSING
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+BatchNonMaxSuppression = _reflection.GeneratedProtocolMessageType('BatchNonMaxSuppression', (_message.Message,), dict(
+  DESCRIPTOR = _BATCHNONMAXSUPPRESSION,
+  __module__ = 'object_detection.protos.post_processing_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.BatchNonMaxSuppression)
+  ))
+_sym_db.RegisterMessage(BatchNonMaxSuppression)
+
+PostProcessing = _reflection.GeneratedProtocolMessageType('PostProcessing', (_message.Message,), dict(
+  DESCRIPTOR = _POSTPROCESSING,
+  __module__ = 'object_detection.protos.post_processing_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.PostProcessing)
+  ))
+_sym_db.RegisterMessage(PostProcessing)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/preprocessor.proto b/reconnaissance images/object_detection/protos/preprocessor.proto
new file mode 100644
index 0000000..0cb338c
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/preprocessor.proto	
@@ -0,0 +1,326 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Message for defining a preprocessing operation on input data.
+// See: //object_detection/core/preprocessor.py
+message PreprocessingStep {
+  oneof preprocessing_step {
+    NormalizeImage normalize_image = 1;
+    RandomHorizontalFlip random_horizontal_flip = 2;
+    RandomPixelValueScale random_pixel_value_scale = 3;
+    RandomImageScale random_image_scale = 4;
+    RandomRGBtoGray random_rgb_to_gray = 5;
+    RandomAdjustBrightness random_adjust_brightness = 6;
+    RandomAdjustContrast random_adjust_contrast = 7;
+    RandomAdjustHue random_adjust_hue = 8;
+    RandomAdjustSaturation random_adjust_saturation = 9;
+    RandomDistortColor random_distort_color = 10;
+    RandomJitterBoxes random_jitter_boxes = 11;
+    RandomCropImage random_crop_image = 12;
+    RandomPadImage random_pad_image = 13;
+    RandomCropPadImage random_crop_pad_image = 14;
+    RandomCropToAspectRatio random_crop_to_aspect_ratio = 15;
+    RandomBlackPatches random_black_patches = 16;
+    RandomResizeMethod random_resize_method = 17;
+    ScaleBoxesToPixelCoordinates scale_boxes_to_pixel_coordinates = 18;
+    ResizeImage resize_image = 19;
+    SubtractChannelMean subtract_channel_mean = 20;
+    SSDRandomCrop ssd_random_crop = 21;
+    SSDRandomCropPad ssd_random_crop_pad = 22;
+    SSDRandomCropFixedAspectRatio ssd_random_crop_fixed_aspect_ratio = 23;
+  }
+}
+
+// Normalizes pixel values in an image.
+// For every channel in the image, moves the pixel values from the range
+// [original_minval, original_maxval] to [target_minval, target_maxval].
+message NormalizeImage {
+  optional float original_minval = 1;
+  optional float original_maxval = 2;
+  optional float target_minval = 3 [default=0];
+  optional float target_maxval = 4 [default=1];
+}
+
+// Randomly horizontally mirrors the image and detections 50% of the time.
+message RandomHorizontalFlip {
+}
+
+// Randomly scales the values of all pixels in the image by some constant value
+// between [minval, maxval], then clip the value to a range between [0, 1.0].
+message RandomPixelValueScale {
+  optional float minval = 1 [default=0.9];
+  optional float maxval = 2 [default=1.1];
+}
+
+// Randomly enlarges or shrinks image (keeping aspect ratio).
+message RandomImageScale {
+  optional float min_scale_ratio = 1 [default=0.5];
+  optional float max_scale_ratio = 2 [default=2.0];
+}
+
+// Randomly convert entire image to grey scale.
+message RandomRGBtoGray {
+  optional float probability = 1 [default=0.1];
+}
+
+// Randomly changes image brightness by up to max_delta. Image outputs will be
+// saturated between 0 and 1.
+message RandomAdjustBrightness {
+  optional float max_delta=1 [default=0.2];
+}
+
+// Randomly scales contract by a value between [min_delta, max_delta].
+message RandomAdjustContrast {
+  optional float min_delta = 1 [default=0.8];
+  optional float max_delta = 2 [default=1.25];
+}
+
+// Randomly alters hue by a value of up to max_delta.
+message RandomAdjustHue {
+  optional float max_delta = 1 [default=0.02];
+}
+
+// Randomly changes saturation by a value between [min_delta, max_delta].
+message RandomAdjustSaturation {
+  optional float min_delta = 1 [default=0.8];
+  optional float max_delta = 2 [default=1.25];
+}
+
+// Performs a random color distortion. color_orderings should either be 0 or 1.
+message RandomDistortColor {
+  optional int32 color_ordering = 1;
+}
+
+// Randomly jitters corners of boxes in the image determined by ratio.
+// ie. If a box is [100, 200] and ratio is 0.02, the corners can move by [1, 4].
+message RandomJitterBoxes {
+  optional float ratio = 1 [default=0.05];
+}
+
+// Randomly crops the image and bounding boxes.
+message RandomCropImage {
+  // Cropped image must cover at least one box by this fraction.
+  optional float min_object_covered = 1 [default=1.0];
+
+  // Aspect ratio bounds of cropped image.
+  optional float min_aspect_ratio = 2 [default=0.75];
+  optional float max_aspect_ratio = 3 [default=1.33];
+
+  // Allowed area ratio of cropped image to original image.
+  optional float min_area = 4 [default=0.1];
+  optional float max_area = 5 [default=1.0];
+
+  // Minimum overlap threshold of cropped boxes to keep in new image. If the
+  // ratio between a cropped bounding box and the original is less than this
+  // value, it is removed from the new image.
+  optional float overlap_thresh = 6 [default=0.3];
+
+  // Probability of keeping the original image.
+  optional float random_coef = 7 [default=0.0];
+}
+
+// Randomly adds padding to the image.
+message RandomPadImage {
+  // Minimum dimensions for padded image. If unset, will use original image
+  // dimension as a lower bound.
+  optional float min_image_height = 1;
+  optional float min_image_width = 2;
+
+  // Maximum dimensions for padded image. If unset, will use double the original
+  // image dimension as a lower bound.
+  optional float max_image_height = 3;
+  optional float max_image_width = 4;
+
+  // Color of the padding. If unset, will pad using average color of the input
+  // image.
+  repeated float pad_color = 5;
+}
+
+// Randomly crops an image followed by a random pad.
+message RandomCropPadImage {
+  // Cropping operation must cover at least one box by this fraction.
+  optional float min_object_covered = 1 [default=1.0];
+
+  // Aspect ratio bounds of image after cropping operation.
+  optional float min_aspect_ratio = 2 [default=0.75];
+  optional float max_aspect_ratio = 3 [default=1.33];
+
+  // Allowed area ratio of image after cropping operation.
+  optional float min_area = 4 [default=0.1];
+  optional float max_area = 5 [default=1.0];
+
+  // Minimum overlap threshold of cropped boxes to keep in new image. If the
+  // ratio between a cropped bounding box and the original is less than this
+  // value, it is removed from the new image.
+  optional float overlap_thresh = 6 [default=0.3];
+
+  // Probability of keeping the original image during the crop operation.
+  optional float random_coef = 7 [default=0.0];
+
+  // Maximum dimensions for padded image. If unset, will use double the original
+  // image dimension as a lower bound. Both of the following fields should be
+  // length 2.
+  repeated float min_padded_size_ratio = 8;
+  repeated float max_padded_size_ratio = 9;
+
+  // Color of the padding. If unset, will pad using average color of the input
+  // image.
+  repeated float pad_color = 10;
+}
+
+// Randomly crops an iamge to a given aspect ratio.
+message RandomCropToAspectRatio {
+  // Aspect ratio.
+  optional float aspect_ratio = 1 [default=1.0];
+
+  // Minimum overlap threshold of cropped boxes to keep in new image. If the
+  // ratio between a cropped bounding box and the original is less than this
+  // value, it is removed from the new image.
+  optional float overlap_thresh = 2 [default=0.3];
+}
+
+// Randomly adds black square patches to an image.
+message RandomBlackPatches {
+  // The maximum number of black patches to add.
+  optional int32 max_black_patches = 1 [default=10];
+
+  // The probability of a black patch being added to an image.
+  optional float probability = 2 [default=0.5];
+
+  // Ratio between the dimension of the black patch to the minimum dimension of
+  // the image (patch_width = patch_height = min(image_height, image_width)).
+  optional float size_to_image_ratio = 3 [default=0.1];
+}
+
+// Randomly resizes the image up to [target_height, target_width].
+message RandomResizeMethod {
+  optional float target_height = 1;
+  optional float target_width = 2;
+}
+
+// Scales boxes from normalized coordinates to pixel coordinates.
+message ScaleBoxesToPixelCoordinates {
+}
+
+// Resizes images to [new_height, new_width].
+message ResizeImage {
+  optional int32 new_height = 1;
+  optional int32 new_width = 2;
+  enum Method {
+    AREA=1;
+    BICUBIC=2;
+    BILINEAR=3;
+    NEAREST_NEIGHBOR=4;
+  }
+  optional Method method = 3 [default=BILINEAR];
+}
+
+// Normalizes an image by subtracting a mean from each channel.
+message SubtractChannelMean {
+  // The mean to subtract from each channel. Should be of same dimension of
+  // channels in the input image.
+  repeated float means = 1;
+}
+
+message SSDRandomCropOperation {
+  // Cropped image must cover at least this fraction of one original bounding
+  // box.
+  optional float min_object_covered = 1;
+
+  // The aspect ratio of the cropped image must be within the range of
+  // [min_aspect_ratio, max_aspect_ratio].
+  optional float min_aspect_ratio = 2;
+  optional float max_aspect_ratio = 3;
+
+  // The area of the cropped image must be within the range of
+  // [min_area, max_area].
+  optional float min_area = 4;
+  optional float max_area = 5;
+
+  // Cropped box area ratio must be above this threhold to be kept.
+  optional float overlap_thresh = 6;
+
+  // Probability a crop operation is skipped.
+  optional float random_coef = 7;
+}
+
+// Randomly crops a image according to:
+//     Liu et al., SSD: Single shot multibox detector.
+// This preprocessing step defines multiple SSDRandomCropOperations. Only one
+// operation (chosen at random) is actually performed on an image.
+message SSDRandomCrop {
+  repeated SSDRandomCropOperation operations = 1;
+}
+
+message SSDRandomCropPadOperation {
+  // Cropped image must cover at least this fraction of one original bounding
+  // box.
+  optional float min_object_covered = 1;
+
+  // The aspect ratio of the cropped image must be within the range of
+  // [min_aspect_ratio, max_aspect_ratio].
+  optional float min_aspect_ratio = 2;
+  optional float max_aspect_ratio = 3;
+
+  // The area of the cropped image must be within the range of
+  // [min_area, max_area].
+  optional float min_area = 4;
+  optional float max_area = 5;
+
+  // Cropped box area ratio must be above this threhold to be kept.
+  optional float overlap_thresh = 6;
+
+  // Probability a crop operation is skipped.
+  optional float random_coef = 7;
+
+  // Min ratio of padded image height and width to the input image's height and
+  // width. Two entries per operation.
+  repeated float min_padded_size_ratio = 8;
+
+  // Max ratio of padded image height and width to the input image's height and
+  // width. Two entries per operation.
+  repeated float max_padded_size_ratio = 9;
+
+  // Padding color.
+  optional float pad_color_r = 10;
+  optional float pad_color_g = 11;
+  optional float pad_color_b = 12;
+}
+
+// Randomly crops and pads an image according to:
+//     Liu et al., SSD: Single shot multibox detector.
+// This preprocessing step defines multiple SSDRandomCropPadOperations. Only one
+// operation (chosen at random) is actually performed on an image.
+message SSDRandomCropPad {
+  repeated SSDRandomCropPadOperation operations = 1;
+}
+
+message SSDRandomCropFixedAspectRatioOperation {
+  // Cropped image must cover at least this fraction of one original bounding
+  // box.
+  optional float min_object_covered = 1;
+
+  // The area of the cropped image must be within the range of
+  // [min_area, max_area].
+  optional float min_area = 4;
+  optional float max_area = 5;
+
+  // Cropped box area ratio must be above this threhold to be kept.
+  optional float overlap_thresh = 6;
+
+  // Probability a crop operation is skipped.
+  optional float random_coef = 7;
+}
+
+// Randomly crops a image to a fixed aspect ratio according to:
+//     Liu et al., SSD: Single shot multibox detector.
+// Multiple SSDRandomCropFixedAspectRatioOperations are defined by this
+// preprocessing step. Only one operation (chosen at random) is actually
+// performed on an image.
+message SSDRandomCropFixedAspectRatio {
+  repeated SSDRandomCropFixedAspectRatioOperation operations = 1;
+
+  // Aspect ratio to crop to. This value is used for all crop operations.
+  optional float aspect_ratio = 2 [default=1.0];
+}
diff --git a/reconnaissance images/object_detection/protos/preprocessor_pb2.py b/reconnaissance images/object_detection/protos/preprocessor_pb2.py
new file mode 100644
index 0000000..7afc89d
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/preprocessor_pb2.py	
@@ -0,0 +1,1732 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/preprocessor.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/preprocessor.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n*object_detection/protos/preprocessor.proto\x12\x17object_detection.protos\"\xad\x0e\n\x11PreprocessingStep\x12\x42\n\x0fnormalize_image\x18\x01 \x01(\x0b\x32\'.object_detection.protos.NormalizeImageH\x00\x12O\n\x16random_horizontal_flip\x18\x02 \x01(\x0b\x32-.object_detection.protos.RandomHorizontalFlipH\x00\x12R\n\x18random_pixel_value_scale\x18\x03 \x01(\x0b\x32..object_detection.protos.RandomPixelValueScaleH\x00\x12G\n\x12random_image_scale\x18\x04 \x01(\x0b\x32).object_detection.protos.RandomImageScaleH\x00\x12\x46\n\x12random_rgb_to_gray\x18\x05 \x01(\x0b\x32(.object_detection.protos.RandomRGBtoGrayH\x00\x12S\n\x18random_adjust_brightness\x18\x06 \x01(\x0b\x32/.object_detection.protos.RandomAdjustBrightnessH\x00\x12O\n\x16random_adjust_contrast\x18\x07 \x01(\x0b\x32-.object_detection.protos.RandomAdjustContrastH\x00\x12\x45\n\x11random_adjust_hue\x18\x08 \x01(\x0b\x32(.object_detection.protos.RandomAdjustHueH\x00\x12S\n\x18random_adjust_saturation\x18\t \x01(\x0b\x32/.object_detection.protos.RandomAdjustSaturationH\x00\x12K\n\x14random_distort_color\x18\n \x01(\x0b\x32+.object_detection.protos.RandomDistortColorH\x00\x12I\n\x13random_jitter_boxes\x18\x0b \x01(\x0b\x32*.object_detection.protos.RandomJitterBoxesH\x00\x12\x45\n\x11random_crop_image\x18\x0c \x01(\x0b\x32(.object_detection.protos.RandomCropImageH\x00\x12\x43\n\x10random_pad_image\x18\r \x01(\x0b\x32\'.object_detection.protos.RandomPadImageH\x00\x12L\n\x15random_crop_pad_image\x18\x0e \x01(\x0b\x32+.object_detection.protos.RandomCropPadImageH\x00\x12W\n\x1brandom_crop_to_aspect_ratio\x18\x0f \x01(\x0b\x32\x30.object_detection.protos.RandomCropToAspectRatioH\x00\x12K\n\x14random_black_patches\x18\x10 \x01(\x0b\x32+.object_detection.protos.RandomBlackPatchesH\x00\x12K\n\x14random_resize_method\x18\x11 \x01(\x0b\x32+.object_detection.protos.RandomResizeMethodH\x00\x12\x61\n scale_boxes_to_pixel_coordinates\x18\x12 \x01(\x0b\x32\x35.object_detection.protos.ScaleBoxesToPixelCoordinatesH\x00\x12<\n\x0cresize_image\x18\x13 \x01(\x0b\x32$.object_detection.protos.ResizeImageH\x00\x12M\n\x15subtract_channel_mean\x18\x14 \x01(\x0b\x32,.object_detection.protos.SubtractChannelMeanH\x00\x12\x41\n\x0fssd_random_crop\x18\x15 \x01(\x0b\x32&.object_detection.protos.SSDRandomCropH\x00\x12H\n\x13ssd_random_crop_pad\x18\x16 \x01(\x0b\x32).object_detection.protos.SSDRandomCropPadH\x00\x12\x64\n\"ssd_random_crop_fixed_aspect_ratio\x18\x17 \x01(\x0b\x32\x36.object_detection.protos.SSDRandomCropFixedAspectRatioH\x00\x42\x14\n\x12preprocessing_step\"v\n\x0eNormalizeImage\x12\x17\n\x0foriginal_minval\x18\x01 \x01(\x02\x12\x17\n\x0foriginal_maxval\x18\x02 \x01(\x02\x12\x18\n\rtarget_minval\x18\x03 \x01(\x02:\x01\x30\x12\x18\n\rtarget_maxval\x18\x04 \x01(\x02:\x01\x31\"\x16\n\x14RandomHorizontalFlip\"A\n\x15RandomPixelValueScale\x12\x13\n\x06minval\x18\x01 \x01(\x02:\x03\x30.9\x12\x13\n\x06maxval\x18\x02 \x01(\x02:\x03\x31.1\"L\n\x10RandomImageScale\x12\x1c\n\x0fmin_scale_ratio\x18\x01 \x01(\x02:\x03\x30.5\x12\x1a\n\x0fmax_scale_ratio\x18\x02 \x01(\x02:\x01\x32\"+\n\x0fRandomRGBtoGray\x12\x18\n\x0bprobability\x18\x01 \x01(\x02:\x03\x30.1\"0\n\x16RandomAdjustBrightness\x12\x16\n\tmax_delta\x18\x01 \x01(\x02:\x03\x30.2\"G\n\x14RandomAdjustContrast\x12\x16\n\tmin_delta\x18\x01 \x01(\x02:\x03\x30.8\x12\x17\n\tmax_delta\x18\x02 \x01(\x02:\x04\x31.25\"*\n\x0fRandomAdjustHue\x12\x17\n\tmax_delta\x18\x01 \x01(\x02:\x04\x30.02\"I\n\x16RandomAdjustSaturation\x12\x16\n\tmin_delta\x18\x01 \x01(\x02:\x03\x30.8\x12\x17\n\tmax_delta\x18\x02 \x01(\x02:\x04\x31.25\",\n\x12RandomDistortColor\x12\x16\n\x0e\x63olor_ordering\x18\x01 \x01(\x05\"(\n\x11RandomJitterBoxes\x12\x13\n\x05ratio\x18\x01 \x01(\x02:\x04\x30.05\"\xd1\x01\n\x0fRandomCropImage\x12\x1d\n\x12min_object_covered\x18\x01 \x01(\x02:\x01\x31\x12\x1e\n\x10min_aspect_ratio\x18\x02 \x01(\x02:\x04\x30.75\x12\x1e\n\x10max_aspect_ratio\x18\x03 \x01(\x02:\x04\x31.33\x12\x15\n\x08min_area\x18\x04 \x01(\x02:\x03\x30.1\x12\x13\n\x08max_area\x18\x05 \x01(\x02:\x01\x31\x12\x1b\n\x0eoverlap_thresh\x18\x06 \x01(\x02:\x03\x30.3\x12\x16\n\x0brandom_coef\x18\x07 \x01(\x02:\x01\x30\"\x89\x01\n\x0eRandomPadImage\x12\x18\n\x10min_image_height\x18\x01 \x01(\x02\x12\x17\n\x0fmin_image_width\x18\x02 \x01(\x02\x12\x18\n\x10max_image_height\x18\x03 \x01(\x02\x12\x17\n\x0fmax_image_width\x18\x04 \x01(\x02\x12\x11\n\tpad_color\x18\x05 \x03(\x02\"\xa5\x02\n\x12RandomCropPadImage\x12\x1d\n\x12min_object_covered\x18\x01 \x01(\x02:\x01\x31\x12\x1e\n\x10min_aspect_ratio\x18\x02 \x01(\x02:\x04\x30.75\x12\x1e\n\x10max_aspect_ratio\x18\x03 \x01(\x02:\x04\x31.33\x12\x15\n\x08min_area\x18\x04 \x01(\x02:\x03\x30.1\x12\x13\n\x08max_area\x18\x05 \x01(\x02:\x01\x31\x12\x1b\n\x0eoverlap_thresh\x18\x06 \x01(\x02:\x03\x30.3\x12\x16\n\x0brandom_coef\x18\x07 \x01(\x02:\x01\x30\x12\x1d\n\x15min_padded_size_ratio\x18\x08 \x03(\x02\x12\x1d\n\x15max_padded_size_ratio\x18\t \x03(\x02\x12\x11\n\tpad_color\x18\n \x03(\x02\"O\n\x17RandomCropToAspectRatio\x12\x17\n\x0c\x61spect_ratio\x18\x01 \x01(\x02:\x01\x31\x12\x1b\n\x0eoverlap_thresh\x18\x02 \x01(\x02:\x03\x30.3\"o\n\x12RandomBlackPatches\x12\x1d\n\x11max_black_patches\x18\x01 \x01(\x05:\x02\x31\x30\x12\x18\n\x0bprobability\x18\x02 \x01(\x02:\x03\x30.5\x12 \n\x13size_to_image_ratio\x18\x03 \x01(\x02:\x03\x30.1\"A\n\x12RandomResizeMethod\x12\x15\n\rtarget_height\x18\x01 \x01(\x02\x12\x14\n\x0ctarget_width\x18\x02 \x01(\x02\"\x1e\n\x1cScaleBoxesToPixelCoordinates\"\xc0\x01\n\x0bResizeImage\x12\x12\n\nnew_height\x18\x01 \x01(\x05\x12\x11\n\tnew_width\x18\x02 \x01(\x05\x12\x45\n\x06method\x18\x03 \x01(\x0e\x32+.object_detection.protos.ResizeImage.Method:\x08\x42ILINEAR\"C\n\x06Method\x12\x08\n\x04\x41REA\x10\x01\x12\x0b\n\x07\x42ICUBIC\x10\x02\x12\x0c\n\x08\x42ILINEAR\x10\x03\x12\x14\n\x10NEAREST_NEIGHBOR\x10\x04\"$\n\x13SubtractChannelMean\x12\r\n\x05means\x18\x01 \x03(\x02\"\xb9\x01\n\x16SSDRandomCropOperation\x12\x1a\n\x12min_object_covered\x18\x01 \x01(\x02\x12\x18\n\x10min_aspect_ratio\x18\x02 \x01(\x02\x12\x18\n\x10max_aspect_ratio\x18\x03 \x01(\x02\x12\x10\n\x08min_area\x18\x04 \x01(\x02\x12\x10\n\x08max_area\x18\x05 \x01(\x02\x12\x16\n\x0eoverlap_thresh\x18\x06 \x01(\x02\x12\x13\n\x0brandom_coef\x18\x07 \x01(\x02\"T\n\rSSDRandomCrop\x12\x43\n\noperations\x18\x01 \x03(\x0b\x32/.object_detection.protos.SSDRandomCropOperation\"\xb9\x02\n\x19SSDRandomCropPadOperation\x12\x1a\n\x12min_object_covered\x18\x01 \x01(\x02\x12\x18\n\x10min_aspect_ratio\x18\x02 \x01(\x02\x12\x18\n\x10max_aspect_ratio\x18\x03 \x01(\x02\x12\x10\n\x08min_area\x18\x04 \x01(\x02\x12\x10\n\x08max_area\x18\x05 \x01(\x02\x12\x16\n\x0eoverlap_thresh\x18\x06 \x01(\x02\x12\x13\n\x0brandom_coef\x18\x07 \x01(\x02\x12\x1d\n\x15min_padded_size_ratio\x18\x08 \x03(\x02\x12\x1d\n\x15max_padded_size_ratio\x18\t \x03(\x02\x12\x13\n\x0bpad_color_r\x18\n \x01(\x02\x12\x13\n\x0bpad_color_g\x18\x0b \x01(\x02\x12\x13\n\x0bpad_color_b\x18\x0c \x01(\x02\"Z\n\x10SSDRandomCropPad\x12\x46\n\noperations\x18\x01 \x03(\x0b\x32\x32.object_detection.protos.SSDRandomCropPadOperation\"\x95\x01\n&SSDRandomCropFixedAspectRatioOperation\x12\x1a\n\x12min_object_covered\x18\x01 \x01(\x02\x12\x10\n\x08min_area\x18\x04 \x01(\x02\x12\x10\n\x08max_area\x18\x05 \x01(\x02\x12\x16\n\x0eoverlap_thresh\x18\x06 \x01(\x02\x12\x13\n\x0brandom_coef\x18\x07 \x01(\x02\"\x8d\x01\n\x1dSSDRandomCropFixedAspectRatio\x12S\n\noperations\x18\x01 \x03(\x0b\x32?.object_detection.protos.SSDRandomCropFixedAspectRatioOperation\x12\x17\n\x0c\x61spect_ratio\x18\x02 \x01(\x02:\x01\x31')
+)
+
+
+
+_RESIZEIMAGE_METHOD = _descriptor.EnumDescriptor(
+  name='Method',
+  full_name='object_detection.protos.ResizeImage.Method',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='AREA', index=0, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='BICUBIC', index=1, number=2,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='BILINEAR', index=2, number=3,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='NEAREST_NEIGHBOR', index=3, number=4,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=3642,
+  serialized_end=3709,
+)
+_sym_db.RegisterEnumDescriptor(_RESIZEIMAGE_METHOD)
+
+
+_PREPROCESSINGSTEP = _descriptor.Descriptor(
+  name='PreprocessingStep',
+  full_name='object_detection.protos.PreprocessingStep',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='normalize_image', full_name='object_detection.protos.PreprocessingStep.normalize_image', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_horizontal_flip', full_name='object_detection.protos.PreprocessingStep.random_horizontal_flip', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_pixel_value_scale', full_name='object_detection.protos.PreprocessingStep.random_pixel_value_scale', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_image_scale', full_name='object_detection.protos.PreprocessingStep.random_image_scale', index=3,
+      number=4, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_rgb_to_gray', full_name='object_detection.protos.PreprocessingStep.random_rgb_to_gray', index=4,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_adjust_brightness', full_name='object_detection.protos.PreprocessingStep.random_adjust_brightness', index=5,
+      number=6, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_adjust_contrast', full_name='object_detection.protos.PreprocessingStep.random_adjust_contrast', index=6,
+      number=7, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_adjust_hue', full_name='object_detection.protos.PreprocessingStep.random_adjust_hue', index=7,
+      number=8, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_adjust_saturation', full_name='object_detection.protos.PreprocessingStep.random_adjust_saturation', index=8,
+      number=9, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_distort_color', full_name='object_detection.protos.PreprocessingStep.random_distort_color', index=9,
+      number=10, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_jitter_boxes', full_name='object_detection.protos.PreprocessingStep.random_jitter_boxes', index=10,
+      number=11, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_crop_image', full_name='object_detection.protos.PreprocessingStep.random_crop_image', index=11,
+      number=12, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_pad_image', full_name='object_detection.protos.PreprocessingStep.random_pad_image', index=12,
+      number=13, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_crop_pad_image', full_name='object_detection.protos.PreprocessingStep.random_crop_pad_image', index=13,
+      number=14, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_crop_to_aspect_ratio', full_name='object_detection.protos.PreprocessingStep.random_crop_to_aspect_ratio', index=14,
+      number=15, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_black_patches', full_name='object_detection.protos.PreprocessingStep.random_black_patches', index=15,
+      number=16, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_resize_method', full_name='object_detection.protos.PreprocessingStep.random_resize_method', index=16,
+      number=17, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='scale_boxes_to_pixel_coordinates', full_name='object_detection.protos.PreprocessingStep.scale_boxes_to_pixel_coordinates', index=17,
+      number=18, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='resize_image', full_name='object_detection.protos.PreprocessingStep.resize_image', index=18,
+      number=19, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='subtract_channel_mean', full_name='object_detection.protos.PreprocessingStep.subtract_channel_mean', index=19,
+      number=20, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='ssd_random_crop', full_name='object_detection.protos.PreprocessingStep.ssd_random_crop', index=20,
+      number=21, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='ssd_random_crop_pad', full_name='object_detection.protos.PreprocessingStep.ssd_random_crop_pad', index=21,
+      number=22, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='ssd_random_crop_fixed_aspect_ratio', full_name='object_detection.protos.PreprocessingStep.ssd_random_crop_fixed_aspect_ratio', index=22,
+      number=23, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='preprocessing_step', full_name='object_detection.protos.PreprocessingStep.preprocessing_step',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=72,
+  serialized_end=1909,
+)
+
+
+_NORMALIZEIMAGE = _descriptor.Descriptor(
+  name='NormalizeImage',
+  full_name='object_detection.protos.NormalizeImage',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='original_minval', full_name='object_detection.protos.NormalizeImage.original_minval', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='original_maxval', full_name='object_detection.protos.NormalizeImage.original_maxval', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='target_minval', full_name='object_detection.protos.NormalizeImage.target_minval', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='target_maxval', full_name='object_detection.protos.NormalizeImage.target_maxval', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1911,
+  serialized_end=2029,
+)
+
+
+_RANDOMHORIZONTALFLIP = _descriptor.Descriptor(
+  name='RandomHorizontalFlip',
+  full_name='object_detection.protos.RandomHorizontalFlip',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2031,
+  serialized_end=2053,
+)
+
+
+_RANDOMPIXELVALUESCALE = _descriptor.Descriptor(
+  name='RandomPixelValueScale',
+  full_name='object_detection.protos.RandomPixelValueScale',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='minval', full_name='object_detection.protos.RandomPixelValueScale.minval', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.9),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='maxval', full_name='object_detection.protos.RandomPixelValueScale.maxval', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1.1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2055,
+  serialized_end=2120,
+)
+
+
+_RANDOMIMAGESCALE = _descriptor.Descriptor(
+  name='RandomImageScale',
+  full_name='object_detection.protos.RandomImageScale',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_scale_ratio', full_name='object_detection.protos.RandomImageScale.min_scale_ratio', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_scale_ratio', full_name='object_detection.protos.RandomImageScale.max_scale_ratio', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(2),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2122,
+  serialized_end=2198,
+)
+
+
+_RANDOMRGBTOGRAY = _descriptor.Descriptor(
+  name='RandomRGBtoGray',
+  full_name='object_detection.protos.RandomRGBtoGray',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='probability', full_name='object_detection.protos.RandomRGBtoGray.probability', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2200,
+  serialized_end=2243,
+)
+
+
+_RANDOMADJUSTBRIGHTNESS = _descriptor.Descriptor(
+  name='RandomAdjustBrightness',
+  full_name='object_detection.protos.RandomAdjustBrightness',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='max_delta', full_name='object_detection.protos.RandomAdjustBrightness.max_delta', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.2),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2245,
+  serialized_end=2293,
+)
+
+
+_RANDOMADJUSTCONTRAST = _descriptor.Descriptor(
+  name='RandomAdjustContrast',
+  full_name='object_detection.protos.RandomAdjustContrast',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_delta', full_name='object_detection.protos.RandomAdjustContrast.min_delta', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.8),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_delta', full_name='object_detection.protos.RandomAdjustContrast.max_delta', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1.25),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2295,
+  serialized_end=2366,
+)
+
+
+_RANDOMADJUSTHUE = _descriptor.Descriptor(
+  name='RandomAdjustHue',
+  full_name='object_detection.protos.RandomAdjustHue',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='max_delta', full_name='object_detection.protos.RandomAdjustHue.max_delta', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.02),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2368,
+  serialized_end=2410,
+)
+
+
+_RANDOMADJUSTSATURATION = _descriptor.Descriptor(
+  name='RandomAdjustSaturation',
+  full_name='object_detection.protos.RandomAdjustSaturation',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_delta', full_name='object_detection.protos.RandomAdjustSaturation.min_delta', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.8),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_delta', full_name='object_detection.protos.RandomAdjustSaturation.max_delta', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1.25),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2412,
+  serialized_end=2485,
+)
+
+
+_RANDOMDISTORTCOLOR = _descriptor.Descriptor(
+  name='RandomDistortColor',
+  full_name='object_detection.protos.RandomDistortColor',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='color_ordering', full_name='object_detection.protos.RandomDistortColor.color_ordering', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2487,
+  serialized_end=2531,
+)
+
+
+_RANDOMJITTERBOXES = _descriptor.Descriptor(
+  name='RandomJitterBoxes',
+  full_name='object_detection.protos.RandomJitterBoxes',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='ratio', full_name='object_detection.protos.RandomJitterBoxes.ratio', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.05),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2533,
+  serialized_end=2573,
+)
+
+
+_RANDOMCROPIMAGE = _descriptor.Descriptor(
+  name='RandomCropImage',
+  full_name='object_detection.protos.RandomCropImage',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_object_covered', full_name='object_detection.protos.RandomCropImage.min_object_covered', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_aspect_ratio', full_name='object_detection.protos.RandomCropImage.min_aspect_ratio', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.75),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_aspect_ratio', full_name='object_detection.protos.RandomCropImage.max_aspect_ratio', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1.33),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_area', full_name='object_detection.protos.RandomCropImage.min_area', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_area', full_name='object_detection.protos.RandomCropImage.max_area', index=4,
+      number=5, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='overlap_thresh', full_name='object_detection.protos.RandomCropImage.overlap_thresh', index=5,
+      number=6, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.3),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_coef', full_name='object_detection.protos.RandomCropImage.random_coef', index=6,
+      number=7, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2576,
+  serialized_end=2785,
+)
+
+
+_RANDOMPADIMAGE = _descriptor.Descriptor(
+  name='RandomPadImage',
+  full_name='object_detection.protos.RandomPadImage',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_image_height', full_name='object_detection.protos.RandomPadImage.min_image_height', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_image_width', full_name='object_detection.protos.RandomPadImage.min_image_width', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_image_height', full_name='object_detection.protos.RandomPadImage.max_image_height', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_image_width', full_name='object_detection.protos.RandomPadImage.max_image_width', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='pad_color', full_name='object_detection.protos.RandomPadImage.pad_color', index=4,
+      number=5, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2788,
+  serialized_end=2925,
+)
+
+
+_RANDOMCROPPADIMAGE = _descriptor.Descriptor(
+  name='RandomCropPadImage',
+  full_name='object_detection.protos.RandomCropPadImage',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_object_covered', full_name='object_detection.protos.RandomCropPadImage.min_object_covered', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_aspect_ratio', full_name='object_detection.protos.RandomCropPadImage.min_aspect_ratio', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.75),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_aspect_ratio', full_name='object_detection.protos.RandomCropPadImage.max_aspect_ratio', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1.33),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_area', full_name='object_detection.protos.RandomCropPadImage.min_area', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_area', full_name='object_detection.protos.RandomCropPadImage.max_area', index=4,
+      number=5, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='overlap_thresh', full_name='object_detection.protos.RandomCropPadImage.overlap_thresh', index=5,
+      number=6, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.3),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_coef', full_name='object_detection.protos.RandomCropPadImage.random_coef', index=6,
+      number=7, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_padded_size_ratio', full_name='object_detection.protos.RandomCropPadImage.min_padded_size_ratio', index=7,
+      number=8, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_padded_size_ratio', full_name='object_detection.protos.RandomCropPadImage.max_padded_size_ratio', index=8,
+      number=9, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='pad_color', full_name='object_detection.protos.RandomCropPadImage.pad_color', index=9,
+      number=10, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=2928,
+  serialized_end=3221,
+)
+
+
+_RANDOMCROPTOASPECTRATIO = _descriptor.Descriptor(
+  name='RandomCropToAspectRatio',
+  full_name='object_detection.protos.RandomCropToAspectRatio',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='aspect_ratio', full_name='object_detection.protos.RandomCropToAspectRatio.aspect_ratio', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='overlap_thresh', full_name='object_detection.protos.RandomCropToAspectRatio.overlap_thresh', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.3),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=3223,
+  serialized_end=3302,
+)
+
+
+_RANDOMBLACKPATCHES = _descriptor.Descriptor(
+  name='RandomBlackPatches',
+  full_name='object_detection.protos.RandomBlackPatches',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='max_black_patches', full_name='object_detection.protos.RandomBlackPatches.max_black_patches', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=10,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='probability', full_name='object_detection.protos.RandomBlackPatches.probability', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='size_to_image_ratio', full_name='object_detection.protos.RandomBlackPatches.size_to_image_ratio', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=3304,
+  serialized_end=3415,
+)
+
+
+_RANDOMRESIZEMETHOD = _descriptor.Descriptor(
+  name='RandomResizeMethod',
+  full_name='object_detection.protos.RandomResizeMethod',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='target_height', full_name='object_detection.protos.RandomResizeMethod.target_height', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='target_width', full_name='object_detection.protos.RandomResizeMethod.target_width', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=3417,
+  serialized_end=3482,
+)
+
+
+_SCALEBOXESTOPIXELCOORDINATES = _descriptor.Descriptor(
+  name='ScaleBoxesToPixelCoordinates',
+  full_name='object_detection.protos.ScaleBoxesToPixelCoordinates',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=3484,
+  serialized_end=3514,
+)
+
+
+_RESIZEIMAGE = _descriptor.Descriptor(
+  name='ResizeImage',
+  full_name='object_detection.protos.ResizeImage',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='new_height', full_name='object_detection.protos.ResizeImage.new_height', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='new_width', full_name='object_detection.protos.ResizeImage.new_width', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='method', full_name='object_detection.protos.ResizeImage.method', index=2,
+      number=3, type=14, cpp_type=8, label=1,
+      has_default_value=True, default_value=3,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _RESIZEIMAGE_METHOD,
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=3517,
+  serialized_end=3709,
+)
+
+
+_SUBTRACTCHANNELMEAN = _descriptor.Descriptor(
+  name='SubtractChannelMean',
+  full_name='object_detection.protos.SubtractChannelMean',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='means', full_name='object_detection.protos.SubtractChannelMean.means', index=0,
+      number=1, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=3711,
+  serialized_end=3747,
+)
+
+
+_SSDRANDOMCROPOPERATION = _descriptor.Descriptor(
+  name='SSDRandomCropOperation',
+  full_name='object_detection.protos.SSDRandomCropOperation',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_object_covered', full_name='object_detection.protos.SSDRandomCropOperation.min_object_covered', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_aspect_ratio', full_name='object_detection.protos.SSDRandomCropOperation.min_aspect_ratio', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_aspect_ratio', full_name='object_detection.protos.SSDRandomCropOperation.max_aspect_ratio', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_area', full_name='object_detection.protos.SSDRandomCropOperation.min_area', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_area', full_name='object_detection.protos.SSDRandomCropOperation.max_area', index=4,
+      number=5, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='overlap_thresh', full_name='object_detection.protos.SSDRandomCropOperation.overlap_thresh', index=5,
+      number=6, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_coef', full_name='object_detection.protos.SSDRandomCropOperation.random_coef', index=6,
+      number=7, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=3750,
+  serialized_end=3935,
+)
+
+
+_SSDRANDOMCROP = _descriptor.Descriptor(
+  name='SSDRandomCrop',
+  full_name='object_detection.protos.SSDRandomCrop',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='operations', full_name='object_detection.protos.SSDRandomCrop.operations', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=3937,
+  serialized_end=4021,
+)
+
+
+_SSDRANDOMCROPPADOPERATION = _descriptor.Descriptor(
+  name='SSDRandomCropPadOperation',
+  full_name='object_detection.protos.SSDRandomCropPadOperation',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_object_covered', full_name='object_detection.protos.SSDRandomCropPadOperation.min_object_covered', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_aspect_ratio', full_name='object_detection.protos.SSDRandomCropPadOperation.min_aspect_ratio', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_aspect_ratio', full_name='object_detection.protos.SSDRandomCropPadOperation.max_aspect_ratio', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_area', full_name='object_detection.protos.SSDRandomCropPadOperation.min_area', index=3,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_area', full_name='object_detection.protos.SSDRandomCropPadOperation.max_area', index=4,
+      number=5, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='overlap_thresh', full_name='object_detection.protos.SSDRandomCropPadOperation.overlap_thresh', index=5,
+      number=6, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_coef', full_name='object_detection.protos.SSDRandomCropPadOperation.random_coef', index=6,
+      number=7, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_padded_size_ratio', full_name='object_detection.protos.SSDRandomCropPadOperation.min_padded_size_ratio', index=7,
+      number=8, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_padded_size_ratio', full_name='object_detection.protos.SSDRandomCropPadOperation.max_padded_size_ratio', index=8,
+      number=9, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='pad_color_r', full_name='object_detection.protos.SSDRandomCropPadOperation.pad_color_r', index=9,
+      number=10, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='pad_color_g', full_name='object_detection.protos.SSDRandomCropPadOperation.pad_color_g', index=10,
+      number=11, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='pad_color_b', full_name='object_detection.protos.SSDRandomCropPadOperation.pad_color_b', index=11,
+      number=12, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=4024,
+  serialized_end=4337,
+)
+
+
+_SSDRANDOMCROPPAD = _descriptor.Descriptor(
+  name='SSDRandomCropPad',
+  full_name='object_detection.protos.SSDRandomCropPad',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='operations', full_name='object_detection.protos.SSDRandomCropPad.operations', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=4339,
+  serialized_end=4429,
+)
+
+
+_SSDRANDOMCROPFIXEDASPECTRATIOOPERATION = _descriptor.Descriptor(
+  name='SSDRandomCropFixedAspectRatioOperation',
+  full_name='object_detection.protos.SSDRandomCropFixedAspectRatioOperation',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='min_object_covered', full_name='object_detection.protos.SSDRandomCropFixedAspectRatioOperation.min_object_covered', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_area', full_name='object_detection.protos.SSDRandomCropFixedAspectRatioOperation.min_area', index=1,
+      number=4, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_area', full_name='object_detection.protos.SSDRandomCropFixedAspectRatioOperation.max_area', index=2,
+      number=5, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='overlap_thresh', full_name='object_detection.protos.SSDRandomCropFixedAspectRatioOperation.overlap_thresh', index=3,
+      number=6, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='random_coef', full_name='object_detection.protos.SSDRandomCropFixedAspectRatioOperation.random_coef', index=4,
+      number=7, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=4432,
+  serialized_end=4581,
+)
+
+
+_SSDRANDOMCROPFIXEDASPECTRATIO = _descriptor.Descriptor(
+  name='SSDRandomCropFixedAspectRatio',
+  full_name='object_detection.protos.SSDRandomCropFixedAspectRatio',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='operations', full_name='object_detection.protos.SSDRandomCropFixedAspectRatio.operations', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='aspect_ratio', full_name='object_detection.protos.SSDRandomCropFixedAspectRatio.aspect_ratio', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=4584,
+  serialized_end=4725,
+)
+
+_PREPROCESSINGSTEP.fields_by_name['normalize_image'].message_type = _NORMALIZEIMAGE
+_PREPROCESSINGSTEP.fields_by_name['random_horizontal_flip'].message_type = _RANDOMHORIZONTALFLIP
+_PREPROCESSINGSTEP.fields_by_name['random_pixel_value_scale'].message_type = _RANDOMPIXELVALUESCALE
+_PREPROCESSINGSTEP.fields_by_name['random_image_scale'].message_type = _RANDOMIMAGESCALE
+_PREPROCESSINGSTEP.fields_by_name['random_rgb_to_gray'].message_type = _RANDOMRGBTOGRAY
+_PREPROCESSINGSTEP.fields_by_name['random_adjust_brightness'].message_type = _RANDOMADJUSTBRIGHTNESS
+_PREPROCESSINGSTEP.fields_by_name['random_adjust_contrast'].message_type = _RANDOMADJUSTCONTRAST
+_PREPROCESSINGSTEP.fields_by_name['random_adjust_hue'].message_type = _RANDOMADJUSTHUE
+_PREPROCESSINGSTEP.fields_by_name['random_adjust_saturation'].message_type = _RANDOMADJUSTSATURATION
+_PREPROCESSINGSTEP.fields_by_name['random_distort_color'].message_type = _RANDOMDISTORTCOLOR
+_PREPROCESSINGSTEP.fields_by_name['random_jitter_boxes'].message_type = _RANDOMJITTERBOXES
+_PREPROCESSINGSTEP.fields_by_name['random_crop_image'].message_type = _RANDOMCROPIMAGE
+_PREPROCESSINGSTEP.fields_by_name['random_pad_image'].message_type = _RANDOMPADIMAGE
+_PREPROCESSINGSTEP.fields_by_name['random_crop_pad_image'].message_type = _RANDOMCROPPADIMAGE
+_PREPROCESSINGSTEP.fields_by_name['random_crop_to_aspect_ratio'].message_type = _RANDOMCROPTOASPECTRATIO
+_PREPROCESSINGSTEP.fields_by_name['random_black_patches'].message_type = _RANDOMBLACKPATCHES
+_PREPROCESSINGSTEP.fields_by_name['random_resize_method'].message_type = _RANDOMRESIZEMETHOD
+_PREPROCESSINGSTEP.fields_by_name['scale_boxes_to_pixel_coordinates'].message_type = _SCALEBOXESTOPIXELCOORDINATES
+_PREPROCESSINGSTEP.fields_by_name['resize_image'].message_type = _RESIZEIMAGE
+_PREPROCESSINGSTEP.fields_by_name['subtract_channel_mean'].message_type = _SUBTRACTCHANNELMEAN
+_PREPROCESSINGSTEP.fields_by_name['ssd_random_crop'].message_type = _SSDRANDOMCROP
+_PREPROCESSINGSTEP.fields_by_name['ssd_random_crop_pad'].message_type = _SSDRANDOMCROPPAD
+_PREPROCESSINGSTEP.fields_by_name['ssd_random_crop_fixed_aspect_ratio'].message_type = _SSDRANDOMCROPFIXEDASPECTRATIO
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['normalize_image'])
+_PREPROCESSINGSTEP.fields_by_name['normalize_image'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_horizontal_flip'])
+_PREPROCESSINGSTEP.fields_by_name['random_horizontal_flip'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_pixel_value_scale'])
+_PREPROCESSINGSTEP.fields_by_name['random_pixel_value_scale'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_image_scale'])
+_PREPROCESSINGSTEP.fields_by_name['random_image_scale'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_rgb_to_gray'])
+_PREPROCESSINGSTEP.fields_by_name['random_rgb_to_gray'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_adjust_brightness'])
+_PREPROCESSINGSTEP.fields_by_name['random_adjust_brightness'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_adjust_contrast'])
+_PREPROCESSINGSTEP.fields_by_name['random_adjust_contrast'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_adjust_hue'])
+_PREPROCESSINGSTEP.fields_by_name['random_adjust_hue'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_adjust_saturation'])
+_PREPROCESSINGSTEP.fields_by_name['random_adjust_saturation'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_distort_color'])
+_PREPROCESSINGSTEP.fields_by_name['random_distort_color'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_jitter_boxes'])
+_PREPROCESSINGSTEP.fields_by_name['random_jitter_boxes'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_crop_image'])
+_PREPROCESSINGSTEP.fields_by_name['random_crop_image'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_pad_image'])
+_PREPROCESSINGSTEP.fields_by_name['random_pad_image'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_crop_pad_image'])
+_PREPROCESSINGSTEP.fields_by_name['random_crop_pad_image'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_crop_to_aspect_ratio'])
+_PREPROCESSINGSTEP.fields_by_name['random_crop_to_aspect_ratio'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_black_patches'])
+_PREPROCESSINGSTEP.fields_by_name['random_black_patches'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['random_resize_method'])
+_PREPROCESSINGSTEP.fields_by_name['random_resize_method'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['scale_boxes_to_pixel_coordinates'])
+_PREPROCESSINGSTEP.fields_by_name['scale_boxes_to_pixel_coordinates'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['resize_image'])
+_PREPROCESSINGSTEP.fields_by_name['resize_image'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['subtract_channel_mean'])
+_PREPROCESSINGSTEP.fields_by_name['subtract_channel_mean'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['ssd_random_crop'])
+_PREPROCESSINGSTEP.fields_by_name['ssd_random_crop'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['ssd_random_crop_pad'])
+_PREPROCESSINGSTEP.fields_by_name['ssd_random_crop_pad'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step'].fields.append(
+  _PREPROCESSINGSTEP.fields_by_name['ssd_random_crop_fixed_aspect_ratio'])
+_PREPROCESSINGSTEP.fields_by_name['ssd_random_crop_fixed_aspect_ratio'].containing_oneof = _PREPROCESSINGSTEP.oneofs_by_name['preprocessing_step']
+_RESIZEIMAGE.fields_by_name['method'].enum_type = _RESIZEIMAGE_METHOD
+_RESIZEIMAGE_METHOD.containing_type = _RESIZEIMAGE
+_SSDRANDOMCROP.fields_by_name['operations'].message_type = _SSDRANDOMCROPOPERATION
+_SSDRANDOMCROPPAD.fields_by_name['operations'].message_type = _SSDRANDOMCROPPADOPERATION
+_SSDRANDOMCROPFIXEDASPECTRATIO.fields_by_name['operations'].message_type = _SSDRANDOMCROPFIXEDASPECTRATIOOPERATION
+DESCRIPTOR.message_types_by_name['PreprocessingStep'] = _PREPROCESSINGSTEP
+DESCRIPTOR.message_types_by_name['NormalizeImage'] = _NORMALIZEIMAGE
+DESCRIPTOR.message_types_by_name['RandomHorizontalFlip'] = _RANDOMHORIZONTALFLIP
+DESCRIPTOR.message_types_by_name['RandomPixelValueScale'] = _RANDOMPIXELVALUESCALE
+DESCRIPTOR.message_types_by_name['RandomImageScale'] = _RANDOMIMAGESCALE
+DESCRIPTOR.message_types_by_name['RandomRGBtoGray'] = _RANDOMRGBTOGRAY
+DESCRIPTOR.message_types_by_name['RandomAdjustBrightness'] = _RANDOMADJUSTBRIGHTNESS
+DESCRIPTOR.message_types_by_name['RandomAdjustContrast'] = _RANDOMADJUSTCONTRAST
+DESCRIPTOR.message_types_by_name['RandomAdjustHue'] = _RANDOMADJUSTHUE
+DESCRIPTOR.message_types_by_name['RandomAdjustSaturation'] = _RANDOMADJUSTSATURATION
+DESCRIPTOR.message_types_by_name['RandomDistortColor'] = _RANDOMDISTORTCOLOR
+DESCRIPTOR.message_types_by_name['RandomJitterBoxes'] = _RANDOMJITTERBOXES
+DESCRIPTOR.message_types_by_name['RandomCropImage'] = _RANDOMCROPIMAGE
+DESCRIPTOR.message_types_by_name['RandomPadImage'] = _RANDOMPADIMAGE
+DESCRIPTOR.message_types_by_name['RandomCropPadImage'] = _RANDOMCROPPADIMAGE
+DESCRIPTOR.message_types_by_name['RandomCropToAspectRatio'] = _RANDOMCROPTOASPECTRATIO
+DESCRIPTOR.message_types_by_name['RandomBlackPatches'] = _RANDOMBLACKPATCHES
+DESCRIPTOR.message_types_by_name['RandomResizeMethod'] = _RANDOMRESIZEMETHOD
+DESCRIPTOR.message_types_by_name['ScaleBoxesToPixelCoordinates'] = _SCALEBOXESTOPIXELCOORDINATES
+DESCRIPTOR.message_types_by_name['ResizeImage'] = _RESIZEIMAGE
+DESCRIPTOR.message_types_by_name['SubtractChannelMean'] = _SUBTRACTCHANNELMEAN
+DESCRIPTOR.message_types_by_name['SSDRandomCropOperation'] = _SSDRANDOMCROPOPERATION
+DESCRIPTOR.message_types_by_name['SSDRandomCrop'] = _SSDRANDOMCROP
+DESCRIPTOR.message_types_by_name['SSDRandomCropPadOperation'] = _SSDRANDOMCROPPADOPERATION
+DESCRIPTOR.message_types_by_name['SSDRandomCropPad'] = _SSDRANDOMCROPPAD
+DESCRIPTOR.message_types_by_name['SSDRandomCropFixedAspectRatioOperation'] = _SSDRANDOMCROPFIXEDASPECTRATIOOPERATION
+DESCRIPTOR.message_types_by_name['SSDRandomCropFixedAspectRatio'] = _SSDRANDOMCROPFIXEDASPECTRATIO
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+PreprocessingStep = _reflection.GeneratedProtocolMessageType('PreprocessingStep', (_message.Message,), dict(
+  DESCRIPTOR = _PREPROCESSINGSTEP,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.PreprocessingStep)
+  ))
+_sym_db.RegisterMessage(PreprocessingStep)
+
+NormalizeImage = _reflection.GeneratedProtocolMessageType('NormalizeImage', (_message.Message,), dict(
+  DESCRIPTOR = _NORMALIZEIMAGE,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.NormalizeImage)
+  ))
+_sym_db.RegisterMessage(NormalizeImage)
+
+RandomHorizontalFlip = _reflection.GeneratedProtocolMessageType('RandomHorizontalFlip', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMHORIZONTALFLIP,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomHorizontalFlip)
+  ))
+_sym_db.RegisterMessage(RandomHorizontalFlip)
+
+RandomPixelValueScale = _reflection.GeneratedProtocolMessageType('RandomPixelValueScale', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMPIXELVALUESCALE,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomPixelValueScale)
+  ))
+_sym_db.RegisterMessage(RandomPixelValueScale)
+
+RandomImageScale = _reflection.GeneratedProtocolMessageType('RandomImageScale', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMIMAGESCALE,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomImageScale)
+  ))
+_sym_db.RegisterMessage(RandomImageScale)
+
+RandomRGBtoGray = _reflection.GeneratedProtocolMessageType('RandomRGBtoGray', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMRGBTOGRAY,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomRGBtoGray)
+  ))
+_sym_db.RegisterMessage(RandomRGBtoGray)
+
+RandomAdjustBrightness = _reflection.GeneratedProtocolMessageType('RandomAdjustBrightness', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMADJUSTBRIGHTNESS,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomAdjustBrightness)
+  ))
+_sym_db.RegisterMessage(RandomAdjustBrightness)
+
+RandomAdjustContrast = _reflection.GeneratedProtocolMessageType('RandomAdjustContrast', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMADJUSTCONTRAST,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomAdjustContrast)
+  ))
+_sym_db.RegisterMessage(RandomAdjustContrast)
+
+RandomAdjustHue = _reflection.GeneratedProtocolMessageType('RandomAdjustHue', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMADJUSTHUE,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomAdjustHue)
+  ))
+_sym_db.RegisterMessage(RandomAdjustHue)
+
+RandomAdjustSaturation = _reflection.GeneratedProtocolMessageType('RandomAdjustSaturation', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMADJUSTSATURATION,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomAdjustSaturation)
+  ))
+_sym_db.RegisterMessage(RandomAdjustSaturation)
+
+RandomDistortColor = _reflection.GeneratedProtocolMessageType('RandomDistortColor', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMDISTORTCOLOR,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomDistortColor)
+  ))
+_sym_db.RegisterMessage(RandomDistortColor)
+
+RandomJitterBoxes = _reflection.GeneratedProtocolMessageType('RandomJitterBoxes', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMJITTERBOXES,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomJitterBoxes)
+  ))
+_sym_db.RegisterMessage(RandomJitterBoxes)
+
+RandomCropImage = _reflection.GeneratedProtocolMessageType('RandomCropImage', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMCROPIMAGE,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomCropImage)
+  ))
+_sym_db.RegisterMessage(RandomCropImage)
+
+RandomPadImage = _reflection.GeneratedProtocolMessageType('RandomPadImage', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMPADIMAGE,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomPadImage)
+  ))
+_sym_db.RegisterMessage(RandomPadImage)
+
+RandomCropPadImage = _reflection.GeneratedProtocolMessageType('RandomCropPadImage', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMCROPPADIMAGE,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomCropPadImage)
+  ))
+_sym_db.RegisterMessage(RandomCropPadImage)
+
+RandomCropToAspectRatio = _reflection.GeneratedProtocolMessageType('RandomCropToAspectRatio', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMCROPTOASPECTRATIO,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomCropToAspectRatio)
+  ))
+_sym_db.RegisterMessage(RandomCropToAspectRatio)
+
+RandomBlackPatches = _reflection.GeneratedProtocolMessageType('RandomBlackPatches', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMBLACKPATCHES,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomBlackPatches)
+  ))
+_sym_db.RegisterMessage(RandomBlackPatches)
+
+RandomResizeMethod = _reflection.GeneratedProtocolMessageType('RandomResizeMethod', (_message.Message,), dict(
+  DESCRIPTOR = _RANDOMRESIZEMETHOD,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RandomResizeMethod)
+  ))
+_sym_db.RegisterMessage(RandomResizeMethod)
+
+ScaleBoxesToPixelCoordinates = _reflection.GeneratedProtocolMessageType('ScaleBoxesToPixelCoordinates', (_message.Message,), dict(
+  DESCRIPTOR = _SCALEBOXESTOPIXELCOORDINATES,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ScaleBoxesToPixelCoordinates)
+  ))
+_sym_db.RegisterMessage(ScaleBoxesToPixelCoordinates)
+
+ResizeImage = _reflection.GeneratedProtocolMessageType('ResizeImage', (_message.Message,), dict(
+  DESCRIPTOR = _RESIZEIMAGE,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.ResizeImage)
+  ))
+_sym_db.RegisterMessage(ResizeImage)
+
+SubtractChannelMean = _reflection.GeneratedProtocolMessageType('SubtractChannelMean', (_message.Message,), dict(
+  DESCRIPTOR = _SUBTRACTCHANNELMEAN,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SubtractChannelMean)
+  ))
+_sym_db.RegisterMessage(SubtractChannelMean)
+
+SSDRandomCropOperation = _reflection.GeneratedProtocolMessageType('SSDRandomCropOperation', (_message.Message,), dict(
+  DESCRIPTOR = _SSDRANDOMCROPOPERATION,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropOperation)
+  ))
+_sym_db.RegisterMessage(SSDRandomCropOperation)
+
+SSDRandomCrop = _reflection.GeneratedProtocolMessageType('SSDRandomCrop', (_message.Message,), dict(
+  DESCRIPTOR = _SSDRANDOMCROP,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCrop)
+  ))
+_sym_db.RegisterMessage(SSDRandomCrop)
+
+SSDRandomCropPadOperation = _reflection.GeneratedProtocolMessageType('SSDRandomCropPadOperation', (_message.Message,), dict(
+  DESCRIPTOR = _SSDRANDOMCROPPADOPERATION,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropPadOperation)
+  ))
+_sym_db.RegisterMessage(SSDRandomCropPadOperation)
+
+SSDRandomCropPad = _reflection.GeneratedProtocolMessageType('SSDRandomCropPad', (_message.Message,), dict(
+  DESCRIPTOR = _SSDRANDOMCROPPAD,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropPad)
+  ))
+_sym_db.RegisterMessage(SSDRandomCropPad)
+
+SSDRandomCropFixedAspectRatioOperation = _reflection.GeneratedProtocolMessageType('SSDRandomCropFixedAspectRatioOperation', (_message.Message,), dict(
+  DESCRIPTOR = _SSDRANDOMCROPFIXEDASPECTRATIOOPERATION,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropFixedAspectRatioOperation)
+  ))
+_sym_db.RegisterMessage(SSDRandomCropFixedAspectRatioOperation)
+
+SSDRandomCropFixedAspectRatio = _reflection.GeneratedProtocolMessageType('SSDRandomCropFixedAspectRatio', (_message.Message,), dict(
+  DESCRIPTOR = _SSDRANDOMCROPFIXEDASPECTRATIO,
+  __module__ = 'object_detection.protos.preprocessor_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SSDRandomCropFixedAspectRatio)
+  ))
+_sym_db.RegisterMessage(SSDRandomCropFixedAspectRatio)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/region_similarity_calculator.proto b/reconnaissance images/object_detection/protos/region_similarity_calculator.proto
new file mode 100644
index 0000000..e82424e
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/region_similarity_calculator.proto	
@@ -0,0 +1,25 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for region similarity calculators. See
+// core/region_similarity_calculator.py for details.
+message RegionSimilarityCalculator {
+  oneof region_similarity {
+    NegSqDistSimilarity neg_sq_dist_similarity = 1;
+    IouSimilarity iou_similarity = 2;
+    IoaSimilarity ioa_similarity = 3;
+  }
+}
+
+// Configuration for negative squared distance similarity calculator.
+message NegSqDistSimilarity {
+}
+
+// Configuration for intersection-over-union (IOU) similarity calculator.
+message IouSimilarity {
+}
+
+// Configuration for intersection-over-area (IOA) similarity calculator.
+message IoaSimilarity {
+}
diff --git a/reconnaissance images/object_detection/protos/region_similarity_calculator_pb2.py b/reconnaissance images/object_detection/protos/region_similarity_calculator_pb2.py
new file mode 100644
index 0000000..b83f8ec
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/region_similarity_calculator_pb2.py	
@@ -0,0 +1,194 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/region_similarity_calculator.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/region_similarity_calculator.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n:object_detection/protos/region_similarity_calculator.proto\x12\x17object_detection.protos\"\x85\x02\n\x1aRegionSimilarityCalculator\x12N\n\x16neg_sq_dist_similarity\x18\x01 \x01(\x0b\x32,.object_detection.protos.NegSqDistSimilarityH\x00\x12@\n\x0eiou_similarity\x18\x02 \x01(\x0b\x32&.object_detection.protos.IouSimilarityH\x00\x12@\n\x0eioa_similarity\x18\x03 \x01(\x0b\x32&.object_detection.protos.IoaSimilarityH\x00\x42\x13\n\x11region_similarity\"\x15\n\x13NegSqDistSimilarity\"\x0f\n\rIouSimilarity\"\x0f\n\rIoaSimilarity')
+)
+
+
+
+
+_REGIONSIMILARITYCALCULATOR = _descriptor.Descriptor(
+  name='RegionSimilarityCalculator',
+  full_name='object_detection.protos.RegionSimilarityCalculator',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='neg_sq_dist_similarity', full_name='object_detection.protos.RegionSimilarityCalculator.neg_sq_dist_similarity', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='iou_similarity', full_name='object_detection.protos.RegionSimilarityCalculator.iou_similarity', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='ioa_similarity', full_name='object_detection.protos.RegionSimilarityCalculator.ioa_similarity', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='region_similarity', full_name='object_detection.protos.RegionSimilarityCalculator.region_similarity',
+      index=0, containing_type=None, fields=[]),
+  ],
+  serialized_start=88,
+  serialized_end=349,
+)
+
+
+_NEGSQDISTSIMILARITY = _descriptor.Descriptor(
+  name='NegSqDistSimilarity',
+  full_name='object_detection.protos.NegSqDistSimilarity',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=351,
+  serialized_end=372,
+)
+
+
+_IOUSIMILARITY = _descriptor.Descriptor(
+  name='IouSimilarity',
+  full_name='object_detection.protos.IouSimilarity',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=374,
+  serialized_end=389,
+)
+
+
+_IOASIMILARITY = _descriptor.Descriptor(
+  name='IoaSimilarity',
+  full_name='object_detection.protos.IoaSimilarity',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=391,
+  serialized_end=406,
+)
+
+_REGIONSIMILARITYCALCULATOR.fields_by_name['neg_sq_dist_similarity'].message_type = _NEGSQDISTSIMILARITY
+_REGIONSIMILARITYCALCULATOR.fields_by_name['iou_similarity'].message_type = _IOUSIMILARITY
+_REGIONSIMILARITYCALCULATOR.fields_by_name['ioa_similarity'].message_type = _IOASIMILARITY
+_REGIONSIMILARITYCALCULATOR.oneofs_by_name['region_similarity'].fields.append(
+  _REGIONSIMILARITYCALCULATOR.fields_by_name['neg_sq_dist_similarity'])
+_REGIONSIMILARITYCALCULATOR.fields_by_name['neg_sq_dist_similarity'].containing_oneof = _REGIONSIMILARITYCALCULATOR.oneofs_by_name['region_similarity']
+_REGIONSIMILARITYCALCULATOR.oneofs_by_name['region_similarity'].fields.append(
+  _REGIONSIMILARITYCALCULATOR.fields_by_name['iou_similarity'])
+_REGIONSIMILARITYCALCULATOR.fields_by_name['iou_similarity'].containing_oneof = _REGIONSIMILARITYCALCULATOR.oneofs_by_name['region_similarity']
+_REGIONSIMILARITYCALCULATOR.oneofs_by_name['region_similarity'].fields.append(
+  _REGIONSIMILARITYCALCULATOR.fields_by_name['ioa_similarity'])
+_REGIONSIMILARITYCALCULATOR.fields_by_name['ioa_similarity'].containing_oneof = _REGIONSIMILARITYCALCULATOR.oneofs_by_name['region_similarity']
+DESCRIPTOR.message_types_by_name['RegionSimilarityCalculator'] = _REGIONSIMILARITYCALCULATOR
+DESCRIPTOR.message_types_by_name['NegSqDistSimilarity'] = _NEGSQDISTSIMILARITY
+DESCRIPTOR.message_types_by_name['IouSimilarity'] = _IOUSIMILARITY
+DESCRIPTOR.message_types_by_name['IoaSimilarity'] = _IOASIMILARITY
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+RegionSimilarityCalculator = _reflection.GeneratedProtocolMessageType('RegionSimilarityCalculator', (_message.Message,), dict(
+  DESCRIPTOR = _REGIONSIMILARITYCALCULATOR,
+  __module__ = 'object_detection.protos.region_similarity_calculator_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.RegionSimilarityCalculator)
+  ))
+_sym_db.RegisterMessage(RegionSimilarityCalculator)
+
+NegSqDistSimilarity = _reflection.GeneratedProtocolMessageType('NegSqDistSimilarity', (_message.Message,), dict(
+  DESCRIPTOR = _NEGSQDISTSIMILARITY,
+  __module__ = 'object_detection.protos.region_similarity_calculator_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.NegSqDistSimilarity)
+  ))
+_sym_db.RegisterMessage(NegSqDistSimilarity)
+
+IouSimilarity = _reflection.GeneratedProtocolMessageType('IouSimilarity', (_message.Message,), dict(
+  DESCRIPTOR = _IOUSIMILARITY,
+  __module__ = 'object_detection.protos.region_similarity_calculator_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.IouSimilarity)
+  ))
+_sym_db.RegisterMessage(IouSimilarity)
+
+IoaSimilarity = _reflection.GeneratedProtocolMessageType('IoaSimilarity', (_message.Message,), dict(
+  DESCRIPTOR = _IOASIMILARITY,
+  __module__ = 'object_detection.protos.region_similarity_calculator_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.IoaSimilarity)
+  ))
+_sym_db.RegisterMessage(IoaSimilarity)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/square_box_coder.proto b/reconnaissance images/object_detection/protos/square_box_coder.proto
new file mode 100644
index 0000000..41575eb
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/square_box_coder.proto	
@@ -0,0 +1,14 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for SquareBoxCoder. See
+// box_coders/square_box_coder.py for details.
+message SquareBoxCoder {
+  // Scale factor for anchor encoded box center.
+  optional float y_scale = 1 [default = 10.0];
+  optional float x_scale = 2 [default = 10.0];
+
+  // Scale factor for anchor encoded box length.
+  optional float length_scale = 3 [default = 5.0];
+}
diff --git a/reconnaissance images/object_detection/protos/square_box_coder_pb2.py b/reconnaissance images/object_detection/protos/square_box_coder_pb2.py
new file mode 100644
index 0000000..46aa32c
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/square_box_coder_pb2.py	
@@ -0,0 +1,83 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/square_box_coder.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/square_box_coder.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n.object_detection/protos/square_box_coder.proto\x12\x17object_detection.protos\"S\n\x0eSquareBoxCoder\x12\x13\n\x07y_scale\x18\x01 \x01(\x02:\x02\x31\x30\x12\x13\n\x07x_scale\x18\x02 \x01(\x02:\x02\x31\x30\x12\x17\n\x0clength_scale\x18\x03 \x01(\x02:\x01\x35')
+)
+
+
+
+
+_SQUAREBOXCODER = _descriptor.Descriptor(
+  name='SquareBoxCoder',
+  full_name='object_detection.protos.SquareBoxCoder',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='y_scale', full_name='object_detection.protos.SquareBoxCoder.y_scale', index=0,
+      number=1, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(10),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='x_scale', full_name='object_detection.protos.SquareBoxCoder.x_scale', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(10),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='length_scale', full_name='object_detection.protos.SquareBoxCoder.length_scale', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(5),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=75,
+  serialized_end=158,
+)
+
+DESCRIPTOR.message_types_by_name['SquareBoxCoder'] = _SQUAREBOXCODER
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+SquareBoxCoder = _reflection.GeneratedProtocolMessageType('SquareBoxCoder', (_message.Message,), dict(
+  DESCRIPTOR = _SQUAREBOXCODER,
+  __module__ = 'object_detection.protos.square_box_coder_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SquareBoxCoder)
+  ))
+_sym_db.RegisterMessage(SquareBoxCoder)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/ssd.proto b/reconnaissance images/object_detection/protos/ssd.proto
new file mode 100644
index 0000000..9eb78c6
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/ssd.proto	
@@ -0,0 +1,65 @@
+syntax = "proto2";
+package object_detection.protos;
+
+import "object_detection/protos/anchor_generator.proto";
+import "object_detection/protos/box_coder.proto";
+import "object_detection/protos/box_predictor.proto";
+import "object_detection/protos/hyperparams.proto";
+import "object_detection/protos/image_resizer.proto";
+import "object_detection/protos/matcher.proto";
+import "object_detection/protos/losses.proto";
+import "object_detection/protos/post_processing.proto";
+import "object_detection/protos/region_similarity_calculator.proto";
+
+// Configuration for Single Shot Detection (SSD) models.
+message Ssd {
+
+  // Number of classes to predict.
+  optional int32 num_classes = 1;
+
+  // Image resizer for preprocessing the input image.
+  optional ImageResizer image_resizer = 2;
+
+  // Feature extractor config.
+  optional SsdFeatureExtractor feature_extractor = 3;
+
+  // Box coder to encode the boxes.
+  optional BoxCoder box_coder = 4;
+
+  // Matcher to match groundtruth with anchors.
+  optional Matcher matcher = 5;
+
+  // Region similarity calculator to compute similarity of boxes.
+  optional RegionSimilarityCalculator similarity_calculator = 6;
+
+  // Box predictor to attach to the features.
+  optional BoxPredictor box_predictor = 7;
+
+  // Anchor generator to compute anchors.
+  optional AnchorGenerator anchor_generator = 8;
+
+  // Post processing to apply on the predictions.
+  optional PostProcessing post_processing = 9;
+
+  // Whether to normalize the loss by number of groundtruth boxes that match to
+  // the anchors.
+  optional bool normalize_loss_by_num_matches = 10 [default=true];
+
+  // Loss configuration for training.
+  optional Loss loss = 11;
+}
+
+
+message SsdFeatureExtractor {
+  // Type of ssd feature extractor.
+  optional string type = 1;
+
+  // The factor to alter the depth of the channels in the feature extractor.
+  optional float depth_multiplier = 2 [default=1.0];
+
+  // Minimum number of the channels in the feature extractor.
+  optional int32 min_depth = 3 [default=16];
+
+  // Hyperparameters for the feature extractor.
+  optional Hyperparams conv_hyperparams = 4;
+}
diff --git a/reconnaissance images/object_detection/protos/ssd_anchor_generator.proto b/reconnaissance images/object_detection/protos/ssd_anchor_generator.proto
new file mode 100644
index 0000000..15654ac
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/ssd_anchor_generator.proto	
@@ -0,0 +1,25 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+// Configuration proto for SSD anchor generator described in
+// https://arxiv.org/abs/1512.02325. See
+// anchor_generators/multiple_grid_anchor_generator.py for details.
+message SsdAnchorGenerator {
+  // Number of grid layers to create anchors for.
+  optional int32 num_layers = 1 [default = 6];
+
+  // Scale of anchors corresponding to finest resolution.
+  optional float min_scale = 2 [default = 0.2];
+
+  // Scale of anchors corresponding to coarsest resolution
+  optional float max_scale = 3 [default = 0.95];
+
+  // Aspect ratios for anchors at each grid point.
+  repeated float aspect_ratios = 4;
+
+  // Whether to use the following aspect ratio and scale combination for the
+  // layer with the finest resolution : (scale=0.1, aspect_ratio=1.0),
+  // (scale=min_scale, aspect_ration=2.0), (scale=min_scale, aspect_ratio=0.5).
+  optional bool reduce_boxes_in_lowest_layer = 5 [default = true];
+}
diff --git a/reconnaissance images/object_detection/protos/ssd_anchor_generator_pb2.py b/reconnaissance images/object_detection/protos/ssd_anchor_generator_pb2.py
new file mode 100644
index 0000000..4dcbb7a
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/ssd_anchor_generator_pb2.py	
@@ -0,0 +1,97 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/ssd_anchor_generator.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/ssd_anchor_generator.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n2object_detection/protos/ssd_anchor_generator.proto\x12\x17object_detection.protos\"\x9f\x01\n\x12SsdAnchorGenerator\x12\x15\n\nnum_layers\x18\x01 \x01(\x05:\x01\x36\x12\x16\n\tmin_scale\x18\x02 \x01(\x02:\x03\x30.2\x12\x17\n\tmax_scale\x18\x03 \x01(\x02:\x04\x30.95\x12\x15\n\raspect_ratios\x18\x04 \x03(\x02\x12*\n\x1creduce_boxes_in_lowest_layer\x18\x05 \x01(\x08:\x04true')
+)
+
+
+
+
+_SSDANCHORGENERATOR = _descriptor.Descriptor(
+  name='SsdAnchorGenerator',
+  full_name='object_detection.protos.SsdAnchorGenerator',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='num_layers', full_name='object_detection.protos.SsdAnchorGenerator.num_layers', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=6,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_scale', full_name='object_detection.protos.SsdAnchorGenerator.min_scale', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.2),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_scale', full_name='object_detection.protos.SsdAnchorGenerator.max_scale', index=2,
+      number=3, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0.95),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='aspect_ratios', full_name='object_detection.protos.SsdAnchorGenerator.aspect_ratios', index=3,
+      number=4, type=2, cpp_type=6, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='reduce_boxes_in_lowest_layer', full_name='object_detection.protos.SsdAnchorGenerator.reduce_boxes_in_lowest_layer', index=4,
+      number=5, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=80,
+  serialized_end=239,
+)
+
+DESCRIPTOR.message_types_by_name['SsdAnchorGenerator'] = _SSDANCHORGENERATOR
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+SsdAnchorGenerator = _reflection.GeneratedProtocolMessageType('SsdAnchorGenerator', (_message.Message,), dict(
+  DESCRIPTOR = _SSDANCHORGENERATOR,
+  __module__ = 'object_detection.protos.ssd_anchor_generator_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SsdAnchorGenerator)
+  ))
+_sym_db.RegisterMessage(SsdAnchorGenerator)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/ssd_pb2.py b/reconnaissance images/object_detection/protos/ssd_pb2.py
new file mode 100644
index 0000000..39a67ad
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/ssd_pb2.py	
@@ -0,0 +1,219 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/ssd.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import anchor_generator_pb2 as object__detection_dot_protos_dot_anchor__generator__pb2
+from object_detection.protos import box_coder_pb2 as object__detection_dot_protos_dot_box__coder__pb2
+from object_detection.protos import box_predictor_pb2 as object__detection_dot_protos_dot_box__predictor__pb2
+from object_detection.protos import hyperparams_pb2 as object__detection_dot_protos_dot_hyperparams__pb2
+from object_detection.protos import image_resizer_pb2 as object__detection_dot_protos_dot_image__resizer__pb2
+from object_detection.protos import matcher_pb2 as object__detection_dot_protos_dot_matcher__pb2
+from object_detection.protos import losses_pb2 as object__detection_dot_protos_dot_losses__pb2
+from object_detection.protos import post_processing_pb2 as object__detection_dot_protos_dot_post__processing__pb2
+from object_detection.protos import region_similarity_calculator_pb2 as object__detection_dot_protos_dot_region__similarity__calculator__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/ssd.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n!object_detection/protos/ssd.proto\x12\x17object_detection.protos\x1a.object_detection/protos/anchor_generator.proto\x1a\'object_detection/protos/box_coder.proto\x1a+object_detection/protos/box_predictor.proto\x1a)object_detection/protos/hyperparams.proto\x1a+object_detection/protos/image_resizer.proto\x1a%object_detection/protos/matcher.proto\x1a$object_detection/protos/losses.proto\x1a-object_detection/protos/post_processing.proto\x1a:object_detection/protos/region_similarity_calculator.proto\"\xfc\x04\n\x03Ssd\x12\x13\n\x0bnum_classes\x18\x01 \x01(\x05\x12<\n\rimage_resizer\x18\x02 \x01(\x0b\x32%.object_detection.protos.ImageResizer\x12G\n\x11\x66\x65\x61ture_extractor\x18\x03 \x01(\x0b\x32,.object_detection.protos.SsdFeatureExtractor\x12\x34\n\tbox_coder\x18\x04 \x01(\x0b\x32!.object_detection.protos.BoxCoder\x12\x31\n\x07matcher\x18\x05 \x01(\x0b\x32 .object_detection.protos.Matcher\x12R\n\x15similarity_calculator\x18\x06 \x01(\x0b\x32\x33.object_detection.protos.RegionSimilarityCalculator\x12<\n\rbox_predictor\x18\x07 \x01(\x0b\x32%.object_detection.protos.BoxPredictor\x12\x42\n\x10\x61nchor_generator\x18\x08 \x01(\x0b\x32(.object_detection.protos.AnchorGenerator\x12@\n\x0fpost_processing\x18\t \x01(\x0b\x32\'.object_detection.protos.PostProcessing\x12+\n\x1dnormalize_loss_by_num_matches\x18\n \x01(\x08:\x04true\x12+\n\x04loss\x18\x0b \x01(\x0b\x32\x1d.object_detection.protos.Loss\"\x97\x01\n\x13SsdFeatureExtractor\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x1b\n\x10\x64\x65pth_multiplier\x18\x02 \x01(\x02:\x01\x31\x12\x15\n\tmin_depth\x18\x03 \x01(\x05:\x02\x31\x36\x12>\n\x10\x63onv_hyperparams\x18\x04 \x01(\x0b\x32$.object_detection.protos.Hyperparams')
+  ,
+  dependencies=[object__detection_dot_protos_dot_anchor__generator__pb2.DESCRIPTOR,object__detection_dot_protos_dot_box__coder__pb2.DESCRIPTOR,object__detection_dot_protos_dot_box__predictor__pb2.DESCRIPTOR,object__detection_dot_protos_dot_hyperparams__pb2.DESCRIPTOR,object__detection_dot_protos_dot_image__resizer__pb2.DESCRIPTOR,object__detection_dot_protos_dot_matcher__pb2.DESCRIPTOR,object__detection_dot_protos_dot_losses__pb2.DESCRIPTOR,object__detection_dot_protos_dot_post__processing__pb2.DESCRIPTOR,object__detection_dot_protos_dot_region__similarity__calculator__pb2.DESCRIPTOR,])
+
+
+
+
+_SSD = _descriptor.Descriptor(
+  name='Ssd',
+  full_name='object_detection.protos.Ssd',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='num_classes', full_name='object_detection.protos.Ssd.num_classes', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='image_resizer', full_name='object_detection.protos.Ssd.image_resizer', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='feature_extractor', full_name='object_detection.protos.Ssd.feature_extractor', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='box_coder', full_name='object_detection.protos.Ssd.box_coder', index=3,
+      number=4, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='matcher', full_name='object_detection.protos.Ssd.matcher', index=4,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='similarity_calculator', full_name='object_detection.protos.Ssd.similarity_calculator', index=5,
+      number=6, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='box_predictor', full_name='object_detection.protos.Ssd.box_predictor', index=6,
+      number=7, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='anchor_generator', full_name='object_detection.protos.Ssd.anchor_generator', index=7,
+      number=8, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='post_processing', full_name='object_detection.protos.Ssd.post_processing', index=8,
+      number=9, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='normalize_loss_by_num_matches', full_name='object_detection.protos.Ssd.normalize_loss_by_num_matches', index=9,
+      number=10, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='loss', full_name='object_detection.protos.Ssd.loss', index=10,
+      number=11, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=469,
+  serialized_end=1105,
+)
+
+
+_SSDFEATUREEXTRACTOR = _descriptor.Descriptor(
+  name='SsdFeatureExtractor',
+  full_name='object_detection.protos.SsdFeatureExtractor',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='type', full_name='object_detection.protos.SsdFeatureExtractor.type', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='depth_multiplier', full_name='object_detection.protos.SsdFeatureExtractor.depth_multiplier', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(1),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='min_depth', full_name='object_detection.protos.SsdFeatureExtractor.min_depth', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=16,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='conv_hyperparams', full_name='object_detection.protos.SsdFeatureExtractor.conv_hyperparams', index=3,
+      number=4, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1108,
+  serialized_end=1259,
+)
+
+_SSD.fields_by_name['image_resizer'].message_type = object__detection_dot_protos_dot_image__resizer__pb2._IMAGERESIZER
+_SSD.fields_by_name['feature_extractor'].message_type = _SSDFEATUREEXTRACTOR
+_SSD.fields_by_name['box_coder'].message_type = object__detection_dot_protos_dot_box__coder__pb2._BOXCODER
+_SSD.fields_by_name['matcher'].message_type = object__detection_dot_protos_dot_matcher__pb2._MATCHER
+_SSD.fields_by_name['similarity_calculator'].message_type = object__detection_dot_protos_dot_region__similarity__calculator__pb2._REGIONSIMILARITYCALCULATOR
+_SSD.fields_by_name['box_predictor'].message_type = object__detection_dot_protos_dot_box__predictor__pb2._BOXPREDICTOR
+_SSD.fields_by_name['anchor_generator'].message_type = object__detection_dot_protos_dot_anchor__generator__pb2._ANCHORGENERATOR
+_SSD.fields_by_name['post_processing'].message_type = object__detection_dot_protos_dot_post__processing__pb2._POSTPROCESSING
+_SSD.fields_by_name['loss'].message_type = object__detection_dot_protos_dot_losses__pb2._LOSS
+_SSDFEATUREEXTRACTOR.fields_by_name['conv_hyperparams'].message_type = object__detection_dot_protos_dot_hyperparams__pb2._HYPERPARAMS
+DESCRIPTOR.message_types_by_name['Ssd'] = _SSD
+DESCRIPTOR.message_types_by_name['SsdFeatureExtractor'] = _SSDFEATUREEXTRACTOR
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Ssd = _reflection.GeneratedProtocolMessageType('Ssd', (_message.Message,), dict(
+  DESCRIPTOR = _SSD,
+  __module__ = 'object_detection.protos.ssd_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.Ssd)
+  ))
+_sym_db.RegisterMessage(Ssd)
+
+SsdFeatureExtractor = _reflection.GeneratedProtocolMessageType('SsdFeatureExtractor', (_message.Message,), dict(
+  DESCRIPTOR = _SSDFEATUREEXTRACTOR,
+  __module__ = 'object_detection.protos.ssd_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.SsdFeatureExtractor)
+  ))
+_sym_db.RegisterMessage(SsdFeatureExtractor)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/string_int_label_map.proto b/reconnaissance images/object_detection/protos/string_int_label_map.proto
new file mode 100644
index 0000000..0894183
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/string_int_label_map.proto	
@@ -0,0 +1,24 @@
+// Message to store the mapping from class label strings to class id. Datasets
+// use string labels to represent classes while the object detection framework
+// works with class ids. This message maps them so they can be converted back
+// and forth as needed.
+syntax = "proto2";
+
+package object_detection.protos;
+
+message StringIntLabelMapItem {
+  // String name. The most common practice is to set this to a MID or synsets
+  // id.
+  optional string name = 1;
+
+  // Integer id that maps to the string name above. Label ids should start from
+  // 1.
+  optional int32 id = 2;
+
+  // Human readable string label.
+  optional string display_name = 3;
+};
+
+message StringIntLabelMap {
+  repeated StringIntLabelMapItem item = 1;
+};
diff --git a/reconnaissance images/object_detection/protos/string_int_label_map_pb2.py b/reconnaissance images/object_detection/protos/string_int_label_map_pb2.py
new file mode 100644
index 0000000..1556736
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/string_int_label_map_pb2.py	
@@ -0,0 +1,123 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/string_int_label_map.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/string_int_label_map.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n2object_detection/protos/string_int_label_map.proto\x12\x17object_detection.protos\"G\n\x15StringIntLabelMapItem\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\n\n\x02id\x18\x02 \x01(\x05\x12\x14\n\x0c\x64isplay_name\x18\x03 \x01(\t\"Q\n\x11StringIntLabelMap\x12<\n\x04item\x18\x01 \x03(\x0b\x32..object_detection.protos.StringIntLabelMapItem')
+)
+
+
+
+
+_STRINGINTLABELMAPITEM = _descriptor.Descriptor(
+  name='StringIntLabelMapItem',
+  full_name='object_detection.protos.StringIntLabelMapItem',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='name', full_name='object_detection.protos.StringIntLabelMapItem.name', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='id', full_name='object_detection.protos.StringIntLabelMapItem.id', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='display_name', full_name='object_detection.protos.StringIntLabelMapItem.display_name', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=79,
+  serialized_end=150,
+)
+
+
+_STRINGINTLABELMAP = _descriptor.Descriptor(
+  name='StringIntLabelMap',
+  full_name='object_detection.protos.StringIntLabelMap',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='item', full_name='object_detection.protos.StringIntLabelMap.item', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=152,
+  serialized_end=233,
+)
+
+_STRINGINTLABELMAP.fields_by_name['item'].message_type = _STRINGINTLABELMAPITEM
+DESCRIPTOR.message_types_by_name['StringIntLabelMapItem'] = _STRINGINTLABELMAPITEM
+DESCRIPTOR.message_types_by_name['StringIntLabelMap'] = _STRINGINTLABELMAP
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+StringIntLabelMapItem = _reflection.GeneratedProtocolMessageType('StringIntLabelMapItem', (_message.Message,), dict(
+  DESCRIPTOR = _STRINGINTLABELMAPITEM,
+  __module__ = 'object_detection.protos.string_int_label_map_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.StringIntLabelMapItem)
+  ))
+_sym_db.RegisterMessage(StringIntLabelMapItem)
+
+StringIntLabelMap = _reflection.GeneratedProtocolMessageType('StringIntLabelMap', (_message.Message,), dict(
+  DESCRIPTOR = _STRINGINTLABELMAP,
+  __module__ = 'object_detection.protos.string_int_label_map_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.StringIntLabelMap)
+  ))
+_sym_db.RegisterMessage(StringIntLabelMap)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/protos/train.proto b/reconnaissance images/object_detection/protos/train.proto
new file mode 100644
index 0000000..4f07008
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/train.proto	
@@ -0,0 +1,64 @@
+syntax = "proto2";
+
+package object_detection.protos;
+
+import "object_detection/protos/optimizer.proto";
+import "object_detection/protos/preprocessor.proto";
+
+// Message for configuring DetectionModel training jobs (train.py).
+message TrainConfig {
+  // Input queue batch size.
+  optional uint32 batch_size = 1 [default=32];
+
+  // Data augmentation options.
+  repeated PreprocessingStep data_augmentation_options = 2;
+
+  // Whether to synchronize replicas during training.
+  optional bool sync_replicas = 3 [default=false];
+
+  // How frequently to keep checkpoints.
+  optional uint32 keep_checkpoint_every_n_hours = 4 [default=1000];
+
+  // Optimizer used to train the DetectionModel.
+  optional Optimizer optimizer = 5;
+
+  // If greater than 0, clips gradients by this value.
+  optional float gradient_clipping_by_norm = 6 [default=0.0];
+
+  // Checkpoint to restore variables from. Typically used to load feature
+  // extractor variables trained outside of object detection.
+  optional string fine_tune_checkpoint = 7 [default=""];
+
+  // Specifies if the finetune checkpoint is from an object detection model.
+  // If from an object detection model, the model being trained should have
+  // the same parameters with the exception of the num_classes parameter.
+  // If false, it assumes the checkpoint was a object classification model.
+  optional bool from_detection_checkpoint = 8 [default=false];
+
+  // Number of steps to train the DetectionModel for. If 0, will train the model
+  // indefinitely.
+  optional uint32 num_steps = 9 [default=0];
+
+  // Number of training steps between replica startup.
+  // This flag must be set to 0 if sync_replicas is set to true.
+  optional float startup_delay_steps = 10 [default=15];
+
+  // If greater than 0, multiplies the gradient of bias variables by this
+  // amount.
+  optional float bias_grad_multiplier = 11 [default=0];
+
+  // Variables that should not be updated during training.
+  repeated string freeze_variables = 12;
+
+  // Number of replicas to aggregate before making parameter updates.
+  optional int32 replicas_to_aggregate = 13 [default=1];
+
+  // Maximum number of elements to store within a queue.
+  optional int32 batch_queue_capacity = 14 [default=600];
+
+  // Number of threads to use for batching.
+  optional int32 num_batch_queue_threads = 15 [default=8];
+
+  // Maximum capacity of the queue used to prefetch assembled batches.
+  optional int32 prefetch_queue_capacity = 16 [default=10];
+}
diff --git a/reconnaissance images/object_detection/protos/train_pb2.py b/reconnaissance images/object_detection/protos/train_pb2.py
new file mode 100644
index 0000000..3116b9d
--- /dev/null
+++ b/reconnaissance images/object_detection/protos/train_pb2.py	
@@ -0,0 +1,179 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: object_detection/protos/train.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from object_detection.protos import optimizer_pb2 as object__detection_dot_protos_dot_optimizer__pb2
+from object_detection.protos import preprocessor_pb2 as object__detection_dot_protos_dot_preprocessor__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='object_detection/protos/train.proto',
+  package='object_detection.protos',
+  syntax='proto2',
+  serialized_pb=_b('\n#object_detection/protos/train.proto\x12\x17object_detection.protos\x1a\'object_detection/protos/optimizer.proto\x1a*object_detection/protos/preprocessor.proto\"\xe6\x04\n\x0bTrainConfig\x12\x16\n\nbatch_size\x18\x01 \x01(\r:\x02\x33\x32\x12M\n\x19\x64\x61ta_augmentation_options\x18\x02 \x03(\x0b\x32*.object_detection.protos.PreprocessingStep\x12\x1c\n\rsync_replicas\x18\x03 \x01(\x08:\x05\x66\x61lse\x12+\n\x1dkeep_checkpoint_every_n_hours\x18\x04 \x01(\r:\x04\x31\x30\x30\x30\x12\x35\n\toptimizer\x18\x05 \x01(\x0b\x32\".object_detection.protos.Optimizer\x12$\n\x19gradient_clipping_by_norm\x18\x06 \x01(\x02:\x01\x30\x12\x1e\n\x14\x66ine_tune_checkpoint\x18\x07 \x01(\t:\x00\x12(\n\x19\x66rom_detection_checkpoint\x18\x08 \x01(\x08:\x05\x66\x61lse\x12\x14\n\tnum_steps\x18\t \x01(\r:\x01\x30\x12\x1f\n\x13startup_delay_steps\x18\n \x01(\x02:\x02\x31\x35\x12\x1f\n\x14\x62ias_grad_multiplier\x18\x0b \x01(\x02:\x01\x30\x12\x18\n\x10\x66reeze_variables\x18\x0c \x03(\t\x12 \n\x15replicas_to_aggregate\x18\r \x01(\x05:\x01\x31\x12!\n\x14\x62\x61tch_queue_capacity\x18\x0e \x01(\x05:\x03\x36\x30\x30\x12\"\n\x17num_batch_queue_threads\x18\x0f \x01(\x05:\x01\x38\x12#\n\x17prefetch_queue_capacity\x18\x10 \x01(\x05:\x02\x31\x30')
+  ,
+  dependencies=[object__detection_dot_protos_dot_optimizer__pb2.DESCRIPTOR,object__detection_dot_protos_dot_preprocessor__pb2.DESCRIPTOR,])
+
+
+
+
+_TRAINCONFIG = _descriptor.Descriptor(
+  name='TrainConfig',
+  full_name='object_detection.protos.TrainConfig',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='batch_size', full_name='object_detection.protos.TrainConfig.batch_size', index=0,
+      number=1, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=32,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='data_augmentation_options', full_name='object_detection.protos.TrainConfig.data_augmentation_options', index=1,
+      number=2, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='sync_replicas', full_name='object_detection.protos.TrainConfig.sync_replicas', index=2,
+      number=3, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='keep_checkpoint_every_n_hours', full_name='object_detection.protos.TrainConfig.keep_checkpoint_every_n_hours', index=3,
+      number=4, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=1000,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='optimizer', full_name='object_detection.protos.TrainConfig.optimizer', index=4,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='gradient_clipping_by_norm', full_name='object_detection.protos.TrainConfig.gradient_clipping_by_norm', index=5,
+      number=6, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='fine_tune_checkpoint', full_name='object_detection.protos.TrainConfig.fine_tune_checkpoint', index=6,
+      number=7, type=9, cpp_type=9, label=1,
+      has_default_value=True, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='from_detection_checkpoint', full_name='object_detection.protos.TrainConfig.from_detection_checkpoint', index=7,
+      number=8, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_steps', full_name='object_detection.protos.TrainConfig.num_steps', index=8,
+      number=9, type=13, cpp_type=3, label=1,
+      has_default_value=True, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='startup_delay_steps', full_name='object_detection.protos.TrainConfig.startup_delay_steps', index=9,
+      number=10, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(15),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='bias_grad_multiplier', full_name='object_detection.protos.TrainConfig.bias_grad_multiplier', index=10,
+      number=11, type=2, cpp_type=6, label=1,
+      has_default_value=True, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='freeze_variables', full_name='object_detection.protos.TrainConfig.freeze_variables', index=11,
+      number=12, type=9, cpp_type=9, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='replicas_to_aggregate', full_name='object_detection.protos.TrainConfig.replicas_to_aggregate', index=12,
+      number=13, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=1,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='batch_queue_capacity', full_name='object_detection.protos.TrainConfig.batch_queue_capacity', index=13,
+      number=14, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=600,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_batch_queue_threads', full_name='object_detection.protos.TrainConfig.num_batch_queue_threads', index=14,
+      number=15, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=8,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='prefetch_queue_capacity', full_name='object_detection.protos.TrainConfig.prefetch_queue_capacity', index=15,
+      number=16, type=5, cpp_type=1, label=1,
+      has_default_value=True, default_value=10,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=150,
+  serialized_end=764,
+)
+
+_TRAINCONFIG.fields_by_name['data_augmentation_options'].message_type = object__detection_dot_protos_dot_preprocessor__pb2._PREPROCESSINGSTEP
+_TRAINCONFIG.fields_by_name['optimizer'].message_type = object__detection_dot_protos_dot_optimizer__pb2._OPTIMIZER
+DESCRIPTOR.message_types_by_name['TrainConfig'] = _TRAINCONFIG
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+TrainConfig = _reflection.GeneratedProtocolMessageType('TrainConfig', (_message.Message,), dict(
+  DESCRIPTOR = _TRAINCONFIG,
+  __module__ = 'object_detection.protos.train_pb2'
+  # @@protoc_insertion_point(class_scope:object_detection.protos.TrainConfig)
+  ))
+_sym_db.RegisterMessage(TrainConfig)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/reconnaissance images/object_detection/ssd_mobilenet_v1_coco_11_06_2017/frozen_inference_graph.pb b/reconnaissance images/object_detection/ssd_mobilenet_v1_coco_11_06_2017/frozen_inference_graph.pb
new file mode 100644
index 0000000..7844ff0
Binary files /dev/null and b/reconnaissance images/object_detection/ssd_mobilenet_v1_coco_11_06_2017/frozen_inference_graph.pb differ
diff --git a/reconnaissance images/object_detection/utils/BUILD b/reconnaissance images/object_detection/utils/BUILD
new file mode 100644
index 0000000..86d978f
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/BUILD	
@@ -0,0 +1,288 @@
+# Tensorflow Object Detection API: Utility functions.
+
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+licenses(["notice"])
+
+# Apache 2.0
+
+py_library(
+    name = "category_util",
+    srcs = ["category_util.py"],
+    deps = ["//tensorflow"],
+)
+
+py_library(
+    name = "dataset_util",
+    srcs = ["dataset_util.py"],
+    deps = [
+        "//tensorflow",
+    ],
+)
+
+py_library(
+    name = "label_map_util",
+    srcs = ["label_map_util.py"],
+    deps = [
+        "//third_party/py/google/protobuf",
+        "//tensorflow",
+        "//tensorflow_models/object_detection/protos:string_int_label_map_py_pb2",
+    ],
+)
+
+py_library(
+    name = "learning_schedules",
+    srcs = ["learning_schedules.py"],
+    deps = ["//tensorflow"],
+)
+
+py_library(
+    name = "metrics",
+    srcs = ["metrics.py"],
+    deps = ["//third_party/py/numpy"],
+)
+
+py_library(
+    name = "np_box_list",
+    srcs = ["np_box_list.py"],
+    deps = ["//tensorflow"],
+)
+
+py_library(
+    name = "np_box_list_ops",
+    srcs = ["np_box_list_ops.py"],
+    deps = [
+        ":np_box_list",
+        ":np_box_ops",
+        "//tensorflow",
+    ],
+)
+
+py_library(
+    name = "np_box_ops",
+    srcs = ["np_box_ops.py"],
+    deps = ["//tensorflow"],
+)
+
+py_library(
+    name = "object_detection_evaluation",
+    srcs = ["object_detection_evaluation.py"],
+    deps = [
+        ":metrics",
+        ":per_image_evaluation",
+        "//tensorflow",
+    ],
+)
+
+py_library(
+    name = "ops",
+    srcs = ["ops.py"],
+    deps = [
+        ":static_shape",
+        "//tensorflow",
+        "//tensorflow_models/object_detection/core:box_list",
+        "//tensorflow_models/object_detection/core:box_list_ops",
+        "//tensorflow_models/object_detection/core:standard_fields",
+    ],
+)
+
+py_library(
+    name = "per_image_evaluation",
+    srcs = ["per_image_evaluation.py"],
+    deps = [
+        ":np_box_list",
+        ":np_box_list_ops",
+        "//tensorflow",
+    ],
+)
+
+py_library(
+    name = "shape_utils",
+    srcs = ["shape_utils.py"],
+    deps = ["//tensorflow"],
+)
+
+py_library(
+    name = "static_shape",
+    srcs = ["static_shape.py"],
+    deps = [],
+)
+
+py_library(
+    name = "test_utils",
+    srcs = ["test_utils.py"],
+    deps = [
+        "//tensorflow",
+        "//tensorflow_models/object_detection/core:anchor_generator",
+        "//tensorflow_models/object_detection/core:box_coder",
+        "//tensorflow_models/object_detection/core:box_list",
+        "//tensorflow_models/object_detection/core:box_predictor",
+        "//tensorflow_models/object_detection/core:matcher",
+        "//tensorflow_models/object_detection/utils:shape_utils"
+    ],
+)
+
+py_library(
+    name = "variables_helper",
+    srcs = ["variables_helper.py"],
+    deps = [
+        "//tensorflow",
+    ],
+)
+
+py_library(
+    name = "visualization_utils",
+    srcs = ["visualization_utils.py"],
+    deps = [
+        "//third_party/py/PIL:pil",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "category_util_test",
+    srcs = ["category_util_test.py"],
+    deps = [
+        ":category_util",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "dataset_util_test",
+    srcs = ["dataset_util_test.py"],
+    deps = [
+        ":dataset_util",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "label_map_util_test",
+    srcs = ["label_map_util_test.py"],
+    deps = [
+        ":label_map_util",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "learning_schedules_test",
+    srcs = ["learning_schedules_test.py"],
+    deps = [
+        ":learning_schedules",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "metrics_test",
+    srcs = ["metrics_test.py"],
+    deps = [
+        ":metrics",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "np_box_list_test",
+    srcs = ["np_box_list_test.py"],
+    deps = [
+        ":np_box_list",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "np_box_list_ops_test",
+    srcs = ["np_box_list_ops_test.py"],
+    deps = [
+        ":np_box_list",
+        ":np_box_list_ops",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "np_box_ops_test",
+    srcs = ["np_box_ops_test.py"],
+    deps = [
+        ":np_box_ops",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "object_detection_evaluation_test",
+    srcs = ["object_detection_evaluation_test.py"],
+    deps = [
+        ":object_detection_evaluation",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "ops_test",
+    srcs = ["ops_test.py"],
+    deps = [
+        ":ops",
+        "//tensorflow",
+        "//tensorflow_models/object_detection/core:standard_fields",
+    ],
+)
+
+py_test(
+    name = "per_image_evaluation_test",
+    srcs = ["per_image_evaluation_test.py"],
+    deps = [
+        ":per_image_evaluation",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "shape_utils_test",
+    srcs = ["shape_utils_test.py"],
+    deps = [
+        ":shape_utils",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "static_shape_test",
+    srcs = ["static_shape_test.py"],
+    deps = [
+        ":static_shape",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "test_utils_test",
+    srcs = ["test_utils_test.py"],
+    deps = [
+        ":test_utils",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "variables_helper_test",
+    srcs = ["variables_helper_test.py"],
+    deps = [
+        ":variables_helper",
+        "//tensorflow",
+    ],
+)
+
+py_test(
+    name = "visualization_utils_test",
+    srcs = ["visualization_utils_test.py"],
+    deps = [
+        ":visualization_utils",
+        "//third_party/py/PIL:pil",
+    ],
+)
diff --git a/reconnaissance images/object_detection/utils/__init__.py b/reconnaissance images/object_detection/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/reconnaissance images/object_detection/utils/__pycache__/__init__.cpython-35.pyc b/reconnaissance images/object_detection/utils/__pycache__/__init__.cpython-35.pyc
new file mode 100644
index 0000000..2390712
Binary files /dev/null and b/reconnaissance images/object_detection/utils/__pycache__/__init__.cpython-35.pyc differ
diff --git a/reconnaissance images/object_detection/utils/__pycache__/__init__.cpython-36.pyc b/reconnaissance images/object_detection/utils/__pycache__/__init__.cpython-36.pyc
new file mode 100644
index 0000000..dec6c1b
Binary files /dev/null and b/reconnaissance images/object_detection/utils/__pycache__/__init__.cpython-36.pyc differ
diff --git a/reconnaissance images/object_detection/utils/__pycache__/label_map_util.cpython-35.pyc b/reconnaissance images/object_detection/utils/__pycache__/label_map_util.cpython-35.pyc
new file mode 100644
index 0000000..44bfe69
Binary files /dev/null and b/reconnaissance images/object_detection/utils/__pycache__/label_map_util.cpython-35.pyc differ
diff --git a/reconnaissance images/object_detection/utils/__pycache__/label_map_util.cpython-36.pyc b/reconnaissance images/object_detection/utils/__pycache__/label_map_util.cpython-36.pyc
new file mode 100644
index 0000000..57a1448
Binary files /dev/null and b/reconnaissance images/object_detection/utils/__pycache__/label_map_util.cpython-36.pyc differ
diff --git a/reconnaissance images/object_detection/utils/__pycache__/visualization_utils.cpython-35.pyc b/reconnaissance images/object_detection/utils/__pycache__/visualization_utils.cpython-35.pyc
new file mode 100644
index 0000000..6ea6fac
Binary files /dev/null and b/reconnaissance images/object_detection/utils/__pycache__/visualization_utils.cpython-35.pyc differ
diff --git a/reconnaissance images/object_detection/utils/__pycache__/visualization_utils.cpython-36.pyc b/reconnaissance images/object_detection/utils/__pycache__/visualization_utils.cpython-36.pyc
new file mode 100644
index 0000000..48fc99b
Binary files /dev/null and b/reconnaissance images/object_detection/utils/__pycache__/visualization_utils.cpython-36.pyc differ
diff --git a/reconnaissance images/object_detection/utils/category_util.py b/reconnaissance images/object_detection/utils/category_util.py
new file mode 100644
index 0000000..fdd9c1c
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/category_util.py	
@@ -0,0 +1,72 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Functions for importing/exporting Object Detection categories."""
+import csv
+
+import tensorflow as tf
+
+
+def load_categories_from_csv_file(csv_path):
+  """Loads categories from a csv file.
+
+  The CSV file should have one comma delimited numeric category id and string
+  category name pair per line. For example:
+
+  0,"cat"
+  1,"dog"
+  2,"bird"
+  ...
+
+  Args:
+    csv_path: Path to the csv file to be parsed into categories.
+  Returns:
+    categories: A list of dictionaries representing all possible categories.
+                The categories will contain an integer 'id' field and a string
+                'name' field.
+  Raises:
+    ValueError: If the csv file is incorrectly formatted.
+  """
+  categories = []
+
+  with tf.gfile.Open(csv_path, 'r') as csvfile:
+    reader = csv.reader(csvfile, delimiter=',', quotechar='"')
+    for row in reader:
+      if not row:
+        continue
+
+      if len(row) != 2:
+        raise ValueError('Expected 2 fields per row in csv: %s' % ','.join(row))
+
+      category_id = int(row[0])
+      category_name = row[1]
+      categories.append({'id': category_id, 'name': category_name})
+
+  return categories
+
+
+def save_categories_to_csv_file(categories, csv_path):
+  """Saves categories to a csv file.
+
+  Args:
+    categories: A list of dictionaries representing categories to save to file.
+                Each category must contain an 'id' and 'name' field.
+    csv_path: Path to the csv file to be parsed into categories.
+  """
+  categories.sort(key=lambda x: x['id'])
+  with tf.gfile.Open(csv_path, 'w') as csvfile:
+    writer = csv.writer(csvfile, delimiter=',', quotechar='"')
+    for category in categories:
+      writer.writerow([category['id'], category['name']])
diff --git a/reconnaissance images/object_detection/utils/category_util_test.py b/reconnaissance images/object_detection/utils/category_util_test.py
new file mode 100644
index 0000000..9c99079
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/category_util_test.py	
@@ -0,0 +1,54 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.category_util."""
+import os
+
+import tensorflow as tf
+
+from object_detection.utils import category_util
+
+
+class EvalUtilTest(tf.test.TestCase):
+
+  def test_load_categories_from_csv_file(self):
+    csv_data = """
+        0,"cat"
+        1,"dog"
+        2,"bird"
+    """.strip(' ')
+    csv_path = os.path.join(self.get_temp_dir(), 'test.csv')
+    with tf.gfile.Open(csv_path, 'wb') as f:
+      f.write(csv_data)
+
+    categories = category_util.load_categories_from_csv_file(csv_path)
+    self.assertTrue({'id': 0, 'name': 'cat'} in categories)
+    self.assertTrue({'id': 1, 'name': 'dog'} in categories)
+    self.assertTrue({'id': 2, 'name': 'bird'} in categories)
+
+  def test_save_categories_to_csv_file(self):
+    categories = [
+        {'id': 0, 'name': 'cat'},
+        {'id': 1, 'name': 'dog'},
+        {'id': 2, 'name': 'bird'},
+    ]
+    csv_path = os.path.join(self.get_temp_dir(), 'test.csv')
+    category_util.save_categories_to_csv_file(categories, csv_path)
+    saved_categories = category_util.load_categories_from_csv_file(csv_path)
+    self.assertEqual(saved_categories, categories)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/dataset_util.py b/reconnaissance images/object_detection/utils/dataset_util.py
new file mode 100644
index 0000000..014a911
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/dataset_util.py	
@@ -0,0 +1,86 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Utility functions for creating TFRecord data sets."""
+
+import tensorflow as tf
+
+
+def int64_feature(value):
+  return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
+
+
+def int64_list_feature(value):
+  return tf.train.Feature(int64_list=tf.train.Int64List(value=value))
+
+
+def bytes_feature(value):
+  return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
+
+
+def bytes_list_feature(value):
+  return tf.train.Feature(bytes_list=tf.train.BytesList(value=value))
+
+
+def float_list_feature(value):
+  return tf.train.Feature(float_list=tf.train.FloatList(value=value))
+
+
+def read_examples_list(path):
+  """Read list of training or validation examples.
+
+  The file is assumed to contain a single example per line where the first
+  token in the line is an identifier that allows us to find the image and
+  annotation xml for that example.
+
+  For example, the line:
+  xyz 3
+  would allow us to find files xyz.jpg and xyz.xml (the 3 would be ignored).
+
+  Args:
+    path: absolute path to examples list file.
+
+  Returns:
+    list of example identifiers (strings).
+  """
+  with tf.gfile.GFile(path) as fid:
+    lines = fid.readlines()
+  return [line.strip().split(' ')[0] for line in lines]
+
+
+def recursive_parse_xml_to_dict(xml):
+  """Recursively parses XML contents to python dict.
+
+  We assume that `object` tags are the only ones that can appear
+  multiple times at the same level of a tree.
+
+  Args:
+    xml: xml tree obtained by parsing XML file contents using lxml.etree
+
+  Returns:
+    Python dictionary holding XML contents.
+  """
+  if not xml:
+    return {xml.tag: xml.text}
+  result = {}
+  for child in xml:
+    child_result = recursive_parse_xml_to_dict(child)
+    if child.tag != 'object':
+      result[child.tag] = child_result[child.tag]
+    else:
+      if child.tag not in result:
+        result[child.tag] = []
+      result[child.tag].append(child_result[child.tag])
+  return {xml.tag: result}
diff --git a/reconnaissance images/object_detection/utils/dataset_util_test.py b/reconnaissance images/object_detection/utils/dataset_util_test.py
new file mode 100644
index 0000000..99cfb2c
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/dataset_util_test.py	
@@ -0,0 +1,37 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.dataset_util."""
+
+import os
+import tensorflow as tf
+
+from object_detection.utils import dataset_util
+
+
+class DatasetUtilTest(tf.test.TestCase):
+
+  def test_read_examples_list(self):
+    example_list_data = """example1 1\nexample2 2"""
+    example_list_path = os.path.join(self.get_temp_dir(), 'examples.txt')
+    with tf.gfile.Open(example_list_path, 'wb') as f:
+      f.write(example_list_data)
+
+    examples = dataset_util.read_examples_list(example_list_path)
+    self.assertListEqual(['example1', 'example2'], examples)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/label_map_util.py b/reconnaissance images/object_detection/utils/label_map_util.py
new file mode 100644
index 0000000..3b8857c
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/label_map_util.py	
@@ -0,0 +1,140 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Label map utility functions."""
+
+import logging
+
+import tensorflow as tf
+from google.protobuf import text_format
+from object_detection.protos import string_int_label_map_pb2
+
+
+def _validate_label_map(label_map):
+  """Checks if a label map is valid.
+
+  Args:
+    label_map: StringIntLabelMap to validate.
+
+  Raises:
+    ValueError: if label map is invalid.
+  """
+  for item in label_map.item:
+    if item.id < 1:
+      raise ValueError('Label map ids should be >= 1.')
+
+
+def create_category_index(categories):
+  """Creates dictionary of COCO compatible categories keyed by category id.
+
+  Args:
+    categories: a list of dicts, each of which has the following keys:
+      'id': (required) an integer id uniquely identifying this category.
+      'name': (required) string representing category name
+        e.g., 'cat', 'dog', 'pizza'.
+
+  Returns:
+    category_index: a dict containing the same entries as categories, but keyed
+      by the 'id' field of each category.
+  """
+  category_index = {}
+  for cat in categories:
+    category_index[cat['id']] = cat
+  return category_index
+
+
+def convert_label_map_to_categories(label_map,
+                                    max_num_classes,
+                                    use_display_name=True):
+  """Loads label map proto and returns categories list compatible with eval.
+
+  This function loads a label map and returns a list of dicts, each of which
+  has the following keys:
+    'id': (required) an integer id uniquely identifying this category.
+    'name': (required) string representing category name
+      e.g., 'cat', 'dog', 'pizza'.
+  We only allow class into the list if its id-label_id_offset is
+  between 0 (inclusive) and max_num_classes (exclusive).
+  If there are several items mapping to the same id in the label map,
+  we will only keep the first one in the categories list.
+
+  Args:
+    label_map: a StringIntLabelMapProto or None.  If None, a default categories
+      list is created with max_num_classes categories.
+    max_num_classes: maximum number of (consecutive) label indices to include.
+    use_display_name: (boolean) choose whether to load 'display_name' field
+      as category name.  If False or if the display_name field does not exist,
+      uses 'name' field as category names instead.
+  Returns:
+    categories: a list of dictionaries representing all possible categories.
+  """
+  categories = []
+  list_of_ids_already_added = []
+  if not label_map:
+    label_id_offset = 1
+    for class_id in range(max_num_classes):
+      categories.append({
+          'id': class_id + label_id_offset,
+          'name': 'category_{}'.format(class_id + label_id_offset)
+      })
+    return categories
+  for item in label_map.item:
+    if not 0 < item.id <= max_num_classes:
+      logging.info('Ignore item %d since it falls outside of requested '
+                   'label range.', item.id)
+      continue
+    if use_display_name and item.HasField('display_name'):
+      name = item.display_name
+    else:
+      name = item.name
+    if item.id not in list_of_ids_already_added:
+      list_of_ids_already_added.append(item.id)
+      categories.append({'id': item.id, 'name': name})
+  return categories
+
+
+def load_labelmap(path):
+  """Loads label map proto.
+
+  Args:
+    path: path to StringIntLabelMap proto text file.
+  Returns:
+    a StringIntLabelMapProto
+  """
+  with tf.gfile.GFile(path, 'r') as fid:
+    label_map_string = fid.read()
+    label_map = string_int_label_map_pb2.StringIntLabelMap()
+    try:
+      text_format.Merge(label_map_string, label_map)
+    except text_format.ParseError:
+      label_map.ParseFromString(label_map_string)
+  _validate_label_map(label_map)
+  return label_map
+
+
+def get_label_map_dict(label_map_path):
+  """Reads a label map and returns a dictionary of label names to id.
+
+  Args:
+    label_map_path: path to label_map.
+
+  Returns:
+    A dictionary mapping label names to id.
+  """
+  label_map = load_labelmap(label_map_path)
+  label_map_dict = {}
+  for item in label_map.item:
+    label_map_dict[item.name] = item.id
+  return label_map_dict
diff --git a/reconnaissance images/object_detection/utils/label_map_util_test.py b/reconnaissance images/object_detection/utils/label_map_util_test.py
new file mode 100644
index 0000000..be58052
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/label_map_util_test.py	
@@ -0,0 +1,169 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.label_map_util."""
+
+import os
+import tensorflow as tf
+
+from google.protobuf import text_format
+from object_detection.protos import string_int_label_map_pb2
+from object_detection.utils import label_map_util
+
+
+class LabelMapUtilTest(tf.test.TestCase):
+
+  def _generate_label_map(self, num_classes):
+    label_map_proto = string_int_label_map_pb2.StringIntLabelMap()
+    for i in range(1, num_classes + 1):
+      item = label_map_proto.item.add()
+      item.id = i
+      item.name = 'label_' + str(i)
+      item.display_name = str(i)
+    return label_map_proto
+
+  def test_get_label_map_dict(self):
+    label_map_string = """
+      item {
+        id:2
+        name:'cat'
+      }
+      item {
+        id:1
+        name:'dog'
+      }
+    """
+    label_map_path = os.path.join(self.get_temp_dir(), 'label_map.pbtxt')
+    with tf.gfile.Open(label_map_path, 'wb') as f:
+      f.write(label_map_string)
+
+    label_map_dict = label_map_util.get_label_map_dict(label_map_path)
+    self.assertEqual(label_map_dict['dog'], 1)
+    self.assertEqual(label_map_dict['cat'], 2)
+
+  def test_load_bad_label_map(self):
+    label_map_string = """
+      item {
+        id:0
+        name:'class that should not be indexed at zero'
+      }
+      item {
+        id:2
+        name:'cat'
+      }
+      item {
+        id:1
+        name:'dog'
+      }
+    """
+    label_map_path = os.path.join(self.get_temp_dir(), 'label_map.pbtxt')
+    with tf.gfile.Open(label_map_path, 'wb') as f:
+      f.write(label_map_string)
+
+    with self.assertRaises(ValueError):
+      label_map_util.load_labelmap(label_map_path)
+
+  def test_keep_categories_with_unique_id(self):
+    label_map_proto = string_int_label_map_pb2.StringIntLabelMap()
+    label_map_string = """
+      item {
+        id:2
+        name:'cat'
+      }
+      item {
+        id:1
+        name:'child'
+      }
+      item {
+        id:1
+        name:'person'
+      }
+      item {
+        id:1
+        name:'n00007846'
+      }
+    """
+    text_format.Merge(label_map_string, label_map_proto)
+    categories = label_map_util.convert_label_map_to_categories(
+        label_map_proto, max_num_classes=3)
+    self.assertListEqual([{
+        'id': 2,
+        'name': u'cat'
+    }, {
+        'id': 1,
+        'name': u'child'
+    }], categories)
+
+  def test_convert_label_map_to_categories_no_label_map(self):
+    categories = label_map_util.convert_label_map_to_categories(
+        None, max_num_classes=3)
+    expected_categories_list = [{
+        'name': u'category_1',
+        'id': 1
+    }, {
+        'name': u'category_2',
+        'id': 2
+    }, {
+        'name': u'category_3',
+        'id': 3
+    }]
+    self.assertListEqual(expected_categories_list, categories)
+
+  def test_convert_label_map_to_coco_categories(self):
+    label_map_proto = self._generate_label_map(num_classes=4)
+    categories = label_map_util.convert_label_map_to_categories(
+        label_map_proto, max_num_classes=3)
+    expected_categories_list = [{
+        'name': u'1',
+        'id': 1
+    }, {
+        'name': u'2',
+        'id': 2
+    }, {
+        'name': u'3',
+        'id': 3
+    }]
+    self.assertListEqual(expected_categories_list, categories)
+
+  def test_convert_label_map_to_coco_categories_with_few_classes(self):
+    label_map_proto = self._generate_label_map(num_classes=4)
+    cat_no_offset = label_map_util.convert_label_map_to_categories(
+        label_map_proto, max_num_classes=2)
+    expected_categories_list = [{
+        'name': u'1',
+        'id': 1
+    }, {
+        'name': u'2',
+        'id': 2
+    }]
+    self.assertListEqual(expected_categories_list, cat_no_offset)
+
+  def test_create_category_index(self):
+    categories = [{'name': u'1', 'id': 1}, {'name': u'2', 'id': 2}]
+    category_index = label_map_util.create_category_index(categories)
+    self.assertDictEqual({
+        1: {
+            'name': u'1',
+            'id': 1
+        },
+        2: {
+            'name': u'2',
+            'id': 2
+        }
+    }, category_index)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/learning_schedules.py b/reconnaissance images/object_detection/utils/learning_schedules.py
new file mode 100644
index 0000000..217b47a
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/learning_schedules.py	
@@ -0,0 +1,103 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Library of common learning rate schedules."""
+
+import tensorflow as tf
+
+
+def exponential_decay_with_burnin(global_step,
+                                  learning_rate_base,
+                                  learning_rate_decay_steps,
+                                  learning_rate_decay_factor,
+                                  burnin_learning_rate=0.0,
+                                  burnin_steps=0):
+  """Exponential decay schedule with burn-in period.
+
+  In this schedule, learning rate is fixed at burnin_learning_rate
+  for a fixed period, before transitioning to a regular exponential
+  decay schedule.
+
+  Args:
+    global_step: int tensor representing global step.
+    learning_rate_base: base learning rate.
+    learning_rate_decay_steps: steps to take between decaying the learning rate.
+      Note that this includes the number of burn-in steps.
+    learning_rate_decay_factor: multiplicative factor by which to decay
+      learning rate.
+    burnin_learning_rate: initial learning rate during burn-in period.  If
+      0.0 (which is the default), then the burn-in learning rate is simply
+      set to learning_rate_base.
+    burnin_steps: number of steps to use burnin learning rate.
+
+  Returns:
+    a (scalar) float tensor representing learning rate
+  """
+  if burnin_learning_rate == 0:
+    burnin_learning_rate = learning_rate_base
+  post_burnin_learning_rate = tf.train.exponential_decay(
+      learning_rate_base,
+      global_step,
+      learning_rate_decay_steps,
+      learning_rate_decay_factor,
+      staircase=True)
+  return tf.cond(
+      tf.less(global_step, burnin_steps),
+      lambda: tf.convert_to_tensor(burnin_learning_rate),
+      lambda: post_burnin_learning_rate)
+
+
+def manual_stepping(global_step, boundaries, rates):
+  """Manually stepped learning rate schedule.
+
+  This function provides fine grained control over learning rates.  One must
+  specify a sequence of learning rates as well as a set of integer steps
+  at which the current learning rate must transition to the next.  For example,
+  if boundaries = [5, 10] and rates = [.1, .01, .001], then the learning
+  rate returned by this function is .1 for global_step=0,...,4, .01 for
+  global_step=5...9, and .001 for global_step=10 and onward.
+
+  Args:
+    global_step: int64 (scalar) tensor representing global step.
+    boundaries: a list of global steps at which to switch learning
+      rates.  This list is assumed to consist of increasing positive integers.
+    rates: a list of (float) learning rates corresponding to intervals between
+      the boundaries.  The length of this list must be exactly
+      len(boundaries) + 1.
+
+  Returns:
+    a (scalar) float tensor representing learning rate
+  Raises:
+    ValueError: if one of the following checks fails:
+      1. boundaries is a strictly increasing list of positive integers
+      2. len(rates) == len(boundaries) + 1
+  """
+  if any([b < 0 for b in boundaries]) or any(
+      [not isinstance(b, int) for b in boundaries]):
+    raise ValueError('boundaries must be a list of positive integers')
+  if any([bnext <= b for bnext, b in zip(boundaries[1:], boundaries[:-1])]):
+    raise ValueError('Entries in boundaries must be strictly increasing.')
+  if any([not isinstance(r, float) for r in rates]):
+    raise ValueError('Learning rates must be floats')
+  if len(rates) != len(boundaries) + 1:
+    raise ValueError('Number of provided learning rates must exceed '
+                     'number of boundary points by exactly 1.')
+  step_boundaries = tf.constant(boundaries, tf.int64)
+  learning_rates = tf.constant(rates, tf.float32)
+  unreached_boundaries = tf.reshape(tf.where(
+      tf.greater(step_boundaries, global_step)), [-1])
+  unreached_boundaries = tf.concat([unreached_boundaries, [len(boundaries)]], 0)
+  index = tf.reshape(tf.reduce_min(unreached_boundaries), [1])
+  return tf.reshape(tf.slice(learning_rates, index, [1]), [])
diff --git a/reconnaissance images/object_detection/utils/learning_schedules_test.py b/reconnaissance images/object_detection/utils/learning_schedules_test.py
new file mode 100644
index 0000000..c8e6ce6
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/learning_schedules_test.py	
@@ -0,0 +1,59 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.learning_schedules."""
+import tensorflow as tf
+
+from object_detection.utils import learning_schedules
+
+
+class LearningSchedulesTest(tf.test.TestCase):
+
+  def testExponentialDecayWithBurnin(self):
+    global_step = tf.placeholder(tf.int32, [])
+    learning_rate_base = 1.0
+    learning_rate_decay_steps = 3
+    learning_rate_decay_factor = .1
+    burnin_learning_rate = .5
+    burnin_steps = 2
+    exp_rates = [.5, .5, 1, .1, .1, .1, .01, .01]
+    learning_rate = learning_schedules.exponential_decay_with_burnin(
+        global_step, learning_rate_base, learning_rate_decay_steps,
+        learning_rate_decay_factor, burnin_learning_rate, burnin_steps)
+    with self.test_session() as sess:
+      output_rates = []
+      for input_global_step in range(8):
+        output_rate = sess.run(learning_rate,
+                               feed_dict={global_step: input_global_step})
+        output_rates.append(output_rate)
+      self.assertAllClose(output_rates, exp_rates)
+
+  def testManualStepping(self):
+    global_step = tf.placeholder(tf.int64, [])
+    boundaries = [2, 3, 7]
+    rates = [1.0, 2.0, 3.0, 4.0]
+    exp_rates = [1.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0]
+    learning_rate = learning_schedules.manual_stepping(global_step, boundaries,
+                                                       rates)
+    with self.test_session() as sess:
+      output_rates = []
+      for input_global_step in range(10):
+        output_rate = sess.run(learning_rate,
+                               feed_dict={global_step: input_global_step})
+        output_rates.append(output_rate)
+      self.assertAllClose(output_rates, exp_rates)
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/metrics.py b/reconnaissance images/object_detection/utils/metrics.py
new file mode 100644
index 0000000..cfce1e9
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/metrics.py	
@@ -0,0 +1,145 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Functions for computing metrics like precision, recall, CorLoc and etc."""
+from __future__ import division
+
+import numpy as np
+from six import moves
+
+
+def compute_precision_recall(scores, labels, num_gt):
+  """Compute precision and recall.
+
+  Args:
+    scores: A float numpy array representing detection score
+    labels: A boolean numpy array representing true/false positive labels
+    num_gt: Number of ground truth instances
+
+  Raises:
+    ValueError: if the input is not of the correct format
+
+  Returns:
+    precision: Fraction of positive instances over detected ones. This value is
+      None if no ground truth labels are present.
+    recall: Fraction of detected positive instance over all positive instances.
+      This value is None if no ground truth labels are present.
+
+  """
+  if not isinstance(
+      labels, np.ndarray) or labels.dtype != np.bool or len(labels.shape) != 1:
+    raise ValueError("labels must be single dimension bool numpy array")
+
+  if not isinstance(
+      scores, np.ndarray) or len(scores.shape) != 1:
+    raise ValueError("scores must be single dimension numpy array")
+
+  if num_gt < np.sum(labels):
+    raise ValueError("Number of true positives must be smaller than num_gt.")
+
+  if len(scores) != len(labels):
+    raise ValueError("scores and labels must be of the same size.")
+
+  if num_gt == 0:
+    return None, None
+
+  sorted_indices = np.argsort(scores)
+  sorted_indices = sorted_indices[::-1]
+  labels = labels.astype(int)
+  true_positive_labels = labels[sorted_indices]
+  false_positive_labels = 1 - true_positive_labels
+  cum_true_positives = np.cumsum(true_positive_labels)
+  cum_false_positives = np.cumsum(false_positive_labels)
+  precision = cum_true_positives.astype(float) / (
+      cum_true_positives + cum_false_positives)
+  recall = cum_true_positives.astype(float) / num_gt
+  return precision, recall
+
+
+def compute_average_precision(precision, recall):
+  """Compute Average Precision according to the definition in VOCdevkit.
+
+  Precision is modified to ensure that it does not decrease as recall
+  decrease.
+
+  Args:
+    precision: A float [N, 1] numpy array of precisions
+    recall: A float [N, 1] numpy array of recalls
+
+  Raises:
+    ValueError: if the input is not of the correct format
+
+  Returns:
+    average_precison: The area under the precision recall curve. NaN if
+      precision and recall are None.
+
+  """
+  if precision is None:
+    if recall is not None:
+      raise ValueError("If precision is None, recall must also be None")
+    return np.NAN
+
+  if not isinstance(precision, np.ndarray) or not isinstance(recall,
+                                                             np.ndarray):
+    raise ValueError("precision and recall must be numpy array")
+  if precision.dtype != np.float or recall.dtype != np.float:
+    raise ValueError("input must be float numpy array.")
+  if len(precision) != len(recall):
+    raise ValueError("precision and recall must be of the same size.")
+  if not precision.size:
+    return 0.0
+  if np.amin(precision) < 0 or np.amax(precision) > 1:
+    raise ValueError("Precision must be in the range of [0, 1].")
+  if np.amin(recall) < 0 or np.amax(recall) > 1:
+    raise ValueError("recall must be in the range of [0, 1].")
+  if not all(recall[i] <= recall[i + 1] for i in moves.range(len(recall) - 1)):
+    raise ValueError("recall must be a non-decreasing array")
+
+  recall = np.concatenate([[0], recall, [1]])
+  precision = np.concatenate([[0], precision, [0]])
+
+  # Preprocess precision to be a non-decreasing array
+  for i in range(len(precision) - 2, -1, -1):
+    precision[i] = np.maximum(precision[i], precision[i + 1])
+
+  indices = np.where(recall[1:] != recall[:-1])[0] + 1
+  average_precision = np.sum(
+      (recall[indices] - recall[indices - 1]) * precision[indices])
+  return average_precision
+
+
+def compute_cor_loc(num_gt_imgs_per_class,
+                    num_images_correctly_detected_per_class):
+  """Compute CorLoc according to the definition in the following paper.
+
+  https://www.robots.ox.ac.uk/~vgg/rg/papers/deselaers-eccv10.pdf
+
+  Returns nans if there are no ground truth images for a class.
+
+  Args:
+    num_gt_imgs_per_class: 1D array, representing number of images containing
+        at least one object instance of a particular class
+    num_images_correctly_detected_per_class: 1D array, representing number of
+        images that are correctly detected at least one object instance of a
+        particular class
+
+  Returns:
+    corloc_per_class: A float numpy array represents the corloc score of each
+      class
+  """
+  return np.where(
+      num_gt_imgs_per_class == 0,
+      np.nan,
+      num_images_correctly_detected_per_class / num_gt_imgs_per_class)
diff --git a/reconnaissance images/object_detection/utils/metrics_test.py b/reconnaissance images/object_detection/utils/metrics_test.py
new file mode 100644
index 0000000..a2064bb
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/metrics_test.py	
@@ -0,0 +1,79 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.metrics."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.utils import metrics
+
+
+class MetricsTest(tf.test.TestCase):
+
+  def test_compute_cor_loc(self):
+    num_gt_imgs_per_class = np.array([100, 1, 5, 1, 1], dtype=int)
+    num_images_correctly_detected_per_class = np.array([10, 0, 1, 0, 0],
+                                                       dtype=int)
+    corloc = metrics.compute_cor_loc(num_gt_imgs_per_class,
+                                     num_images_correctly_detected_per_class)
+    expected_corloc = np.array([0.1, 0, 0.2, 0, 0], dtype=float)
+    self.assertTrue(np.allclose(corloc, expected_corloc))
+
+  def test_compute_cor_loc_nans(self):
+    num_gt_imgs_per_class = np.array([100, 0, 0, 1, 1], dtype=int)
+    num_images_correctly_detected_per_class = np.array([10, 0, 1, 0, 0],
+                                                       dtype=int)
+    corloc = metrics.compute_cor_loc(num_gt_imgs_per_class,
+                                     num_images_correctly_detected_per_class)
+    expected_corloc = np.array([0.1, np.nan, np.nan, 0, 0], dtype=float)
+    self.assertAllClose(corloc, expected_corloc)
+
+  def test_compute_precision_recall(self):
+    num_gt = 10
+    scores = np.array([0.4, 0.3, 0.6, 0.2, 0.7, 0.1], dtype=float)
+    labels = np.array([0, 1, 1, 0, 0, 1], dtype=bool)
+    accumulated_tp_count = np.array([0, 1, 1, 2, 2, 3], dtype=float)
+    expected_precision = accumulated_tp_count / np.array([1, 2, 3, 4, 5, 6])
+    expected_recall = accumulated_tp_count / num_gt
+    precision, recall = metrics.compute_precision_recall(scores, labels, num_gt)
+    self.assertAllClose(precision, expected_precision)
+    self.assertAllClose(recall, expected_recall)
+
+  def test_compute_average_precision(self):
+    precision = np.array([0.8, 0.76, 0.9, 0.65, 0.7, 0.5, 0.55, 0], dtype=float)
+    recall = np.array([0.3, 0.3, 0.4, 0.4, 0.45, 0.45, 0.5, 0.5], dtype=float)
+    processed_precision = np.array([0.9, 0.9, 0.9, 0.7, 0.7, 0.55, 0.55, 0],
+                                   dtype=float)
+    recall_interval = np.array([0.3, 0, 0.1, 0, 0.05, 0, 0.05, 0], dtype=float)
+    expected_mean_ap = np.sum(recall_interval * processed_precision)
+    mean_ap = metrics.compute_average_precision(precision, recall)
+    self.assertAlmostEqual(expected_mean_ap, mean_ap)
+
+  def test_compute_precision_recall_and_ap_no_groundtruth(self):
+    num_gt = 0
+    scores = np.array([0.4, 0.3, 0.6, 0.2, 0.7, 0.1], dtype=float)
+    labels = np.array([0, 0, 0, 0, 0, 0], dtype=bool)
+    expected_precision = None
+    expected_recall = None
+    precision, recall = metrics.compute_precision_recall(scores, labels, num_gt)
+    self.assertEquals(precision, expected_precision)
+    self.assertEquals(recall, expected_recall)
+    ap = metrics.compute_average_precision(precision, recall)
+    self.assertTrue(np.isnan(ap))
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/np_box_list.py b/reconnaissance images/object_detection/utils/np_box_list.py
new file mode 100644
index 0000000..13a1fde
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/np_box_list.py	
@@ -0,0 +1,134 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Numpy BoxList classes and functions."""
+
+import numpy as np
+from six import moves
+
+
+class BoxList(object):
+  """Box collection.
+
+  BoxList represents a list of bounding boxes as numpy array, where each
+  bounding box is represented as a row of 4 numbers,
+  [y_min, x_min, y_max, x_max].  It is assumed that all bounding boxes within a
+  given list correspond to a single image.
+
+  Optionally, users can add additional related fields (such as
+  objectness/classification scores).
+  """
+
+  def __init__(self, data):
+    """Constructs box collection.
+
+    Args:
+      data: a numpy array of shape [N, 4] representing box coordinates
+
+    Raises:
+      ValueError: if bbox data is not a numpy array
+      ValueError: if invalid dimensions for bbox data
+    """
+    if not isinstance(data, np.ndarray):
+      raise ValueError('data must be a numpy array.')
+    if len(data.shape) != 2 or data.shape[1] != 4:
+      raise ValueError('Invalid dimensions for box data.')
+    if data.dtype != np.float32 and data.dtype != np.float64:
+      raise ValueError('Invalid data type for box data: float is required.')
+    if not self._is_valid_boxes(data):
+      raise ValueError('Invalid box data. data must be a numpy array of '
+                       'N*[y_min, x_min, y_max, x_max]')
+    self.data = {'boxes': data}
+
+  def num_boxes(self):
+    """Return number of boxes held in collections."""
+    return self.data['boxes'].shape[0]
+
+  def get_extra_fields(self):
+    """Return all non-box fields."""
+    return [k for k in self.data.keys() if k != 'boxes']
+
+  def has_field(self, field):
+    return field in self.data
+
+  def add_field(self, field, field_data):
+    """Add data to a specified field.
+
+    Args:
+      field: a string parameter used to speficy a related field to be accessed.
+      field_data: a numpy array of [N, ...] representing the data associated
+          with the field.
+    Raises:
+      ValueError: if the field is already exist or the dimension of the field
+          data does not matches the number of boxes.
+    """
+    if self.has_field(field):
+      raise ValueError('Field ' + field + 'already exists')
+    if len(field_data.shape) < 1 or field_data.shape[0] != self.num_boxes():
+      raise ValueError('Invalid dimensions for field data')
+    self.data[field] = field_data
+
+  def get(self):
+    """Convenience function for accesssing box coordinates.
+
+    Returns:
+      a numpy array of shape [N, 4] representing box corners
+    """
+    return self.get_field('boxes')
+
+  def get_field(self, field):
+    """Accesses data associated with the specified field in the box collection.
+
+    Args:
+      field: a string parameter used to speficy a related field to be accessed.
+
+    Returns:
+      a numpy 1-d array representing data of an associated field
+
+    Raises:
+      ValueError: if invalid field
+    """
+    if not self.has_field(field):
+      raise ValueError('field {} does not exist'.format(field))
+    return self.data[field]
+
+  def get_coordinates(self):
+    """Get corner coordinates of boxes.
+
+    Returns:
+     a list of 4 1-d numpy arrays [y_min, x_min, y_max, x_max]
+    """
+    box_coordinates = self.get()
+    y_min = box_coordinates[:, 0]
+    x_min = box_coordinates[:, 1]
+    y_max = box_coordinates[:, 2]
+    x_max = box_coordinates[:, 3]
+    return [y_min, x_min, y_max, x_max]
+
+  def _is_valid_boxes(self, data):
+    """Check whether data fullfills the format of N*[ymin, xmin, ymax, xmin].
+
+    Args:
+      data: a numpy array of shape [N, 4] representing box coordinates
+
+    Returns:
+      a boolean indicating whether all ymax of boxes are equal or greater than
+          ymin, and all xmax of boxes are equal or greater than xmin.
+    """
+    if data.shape[0] > 0:
+      for i in moves.range(data.shape[0]):
+        if data[i, 0] > data[i, 2] or data[i, 1] > data[i, 3]:
+          return False
+    return True
diff --git a/reconnaissance images/object_detection/utils/np_box_list_ops.py b/reconnaissance images/object_detection/utils/np_box_list_ops.py
new file mode 100644
index 0000000..cb9fee8
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/np_box_list_ops.py	
@@ -0,0 +1,555 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Bounding Box List operations for Numpy BoxLists.
+
+Example box operations that are supported:
+  * Areas: compute bounding box areas
+  * IOU: pairwise intersection-over-union scores
+"""
+
+import numpy as np
+
+from object_detection.utils import np_box_list
+from object_detection.utils import np_box_ops
+
+
+class SortOrder(object):
+  """Enum class for sort order.
+
+  Attributes:
+    ascend: ascend order.
+    descend: descend order.
+  """
+  ASCEND = 1
+  DESCEND = 2
+
+
+def area(boxlist):
+  """Computes area of boxes.
+
+  Args:
+    boxlist: BoxList holding N boxes
+
+  Returns:
+    a numpy array with shape [N*1] representing box areas
+  """
+  y_min, x_min, y_max, x_max = boxlist.get_coordinates()
+  return (y_max - y_min) * (x_max - x_min)
+
+
+def intersection(boxlist1, boxlist2):
+  """Compute pairwise intersection areas between boxes.
+
+  Args:
+    boxlist1: BoxList holding N boxes
+    boxlist2: BoxList holding M boxes
+
+  Returns:
+    a numpy array with shape [N*M] representing pairwise intersection area
+  """
+  return np_box_ops.intersection(boxlist1.get(), boxlist2.get())
+
+
+def iou(boxlist1, boxlist2):
+  """Computes pairwise intersection-over-union between box collections.
+
+  Args:
+    boxlist1: BoxList holding N boxes
+    boxlist2: BoxList holding M boxes
+
+  Returns:
+    a numpy array with shape [N, M] representing pairwise iou scores.
+  """
+  return np_box_ops.iou(boxlist1.get(), boxlist2.get())
+
+
+def ioa(boxlist1, boxlist2):
+  """Computes pairwise intersection-over-area between box collections.
+
+  Intersection-over-area (ioa) between two boxes box1 and box2 is defined as
+  their intersection area over box2's area. Note that ioa is not symmetric,
+  that is, IOA(box1, box2) != IOA(box2, box1).
+
+  Args:
+    boxlist1: BoxList holding N boxes
+    boxlist2: BoxList holding M boxes
+
+  Returns:
+    a numpy array with shape [N, M] representing pairwise ioa scores.
+  """
+  return np_box_ops.ioa(boxlist1.get(), boxlist2.get())
+
+
+def gather(boxlist, indices, fields=None):
+  """Gather boxes from BoxList according to indices and return new BoxList.
+
+  By default, Gather returns boxes corresponding to the input index list, as
+  well as all additional fields stored in the boxlist (indexing into the
+  first dimension).  However one can optionally only gather from a
+  subset of fields.
+
+  Args:
+    boxlist: BoxList holding N boxes
+    indices: a 1-d numpy array of type int_
+    fields: (optional) list of fields to also gather from.  If None (default),
+        all fields are gathered from.  Pass an empty fields list to only gather
+        the box coordinates.
+
+  Returns:
+    subboxlist: a BoxList corresponding to the subset of the input BoxList
+        specified by indices
+
+  Raises:
+    ValueError: if specified field is not contained in boxlist or if the
+        indices are not of type int_
+  """
+  if indices.size:
+    if np.amax(indices) >= boxlist.num_boxes() or np.amin(indices) < 0:
+      raise ValueError('indices are out of valid range.')
+  subboxlist = np_box_list.BoxList(boxlist.get()[indices, :])
+  if fields is None:
+    fields = boxlist.get_extra_fields()
+  for field in fields:
+    extra_field_data = boxlist.get_field(field)
+    subboxlist.add_field(field, extra_field_data[indices, ...])
+  return subboxlist
+
+
+def sort_by_field(boxlist, field, order=SortOrder.DESCEND):
+  """Sort boxes and associated fields according to a scalar field.
+
+  A common use case is reordering the boxes according to descending scores.
+
+  Args:
+    boxlist: BoxList holding N boxes.
+    field: A BoxList field for sorting and reordering the BoxList.
+    order: (Optional) 'descend' or 'ascend'. Default is descend.
+
+  Returns:
+    sorted_boxlist: A sorted BoxList with the field in the specified order.
+
+  Raises:
+    ValueError: if specified field does not exist or is not of single dimension.
+    ValueError: if the order is not either descend or ascend.
+  """
+  if not boxlist.has_field(field):
+    raise ValueError('Field ' + field + ' does not exist')
+  if len(boxlist.get_field(field).shape) != 1:
+    raise ValueError('Field ' + field + 'should be single dimension.')
+  if order != SortOrder.DESCEND and order != SortOrder.ASCEND:
+    raise ValueError('Invalid sort order')
+
+  field_to_sort = boxlist.get_field(field)
+  sorted_indices = np.argsort(field_to_sort)
+  if order == SortOrder.DESCEND:
+    sorted_indices = sorted_indices[::-1]
+  return gather(boxlist, sorted_indices)
+
+
+def non_max_suppression(boxlist,
+                        max_output_size=10000,
+                        iou_threshold=1.0,
+                        score_threshold=-10.0):
+  """Non maximum suppression.
+
+  This op greedily selects a subset of detection bounding boxes, pruning
+  away boxes that have high IOU (intersection over union) overlap (> thresh)
+  with already selected boxes. In each iteration, the detected bounding box with
+  highest score in the available pool is selected.
+
+  Args:
+    boxlist: BoxList holding N boxes.  Must contain a 'scores' field
+      representing detection scores. All scores belong to the same class.
+    max_output_size: maximum number of retained boxes
+    iou_threshold: intersection over union threshold.
+    score_threshold: minimum score threshold. Remove the boxes with scores
+                     less than this value. Default value is set to -10. A very
+                     low threshold to pass pretty much all the boxes, unless
+                     the user sets a different score threshold.
+
+  Returns:
+    a BoxList holding M boxes where M <= max_output_size
+  Raises:
+    ValueError: if 'scores' field does not exist
+    ValueError: if threshold is not in [0, 1]
+    ValueError: if max_output_size < 0
+  """
+  if not boxlist.has_field('scores'):
+    raise ValueError('Field scores does not exist')
+  if iou_threshold < 0. or iou_threshold > 1.0:
+    raise ValueError('IOU threshold must be in [0, 1]')
+  if max_output_size < 0:
+    raise ValueError('max_output_size must be bigger than 0.')
+
+  boxlist = filter_scores_greater_than(boxlist, score_threshold)
+  if boxlist.num_boxes() == 0:
+    return boxlist
+
+  boxlist = sort_by_field(boxlist, 'scores')
+
+  # Prevent further computation if NMS is disabled.
+  if iou_threshold == 1.0:
+    if boxlist.num_boxes() > max_output_size:
+      selected_indices = np.arange(max_output_size)
+      return gather(boxlist, selected_indices)
+    else:
+      return boxlist
+
+  boxes = boxlist.get()
+  num_boxes = boxlist.num_boxes()
+  # is_index_valid is True only for all remaining valid boxes,
+  is_index_valid = np.full(num_boxes, 1, dtype=bool)
+  selected_indices = []
+  num_output = 0
+  for i in xrange(num_boxes):
+    if num_output < max_output_size:
+      if is_index_valid[i]:
+        num_output += 1
+        selected_indices.append(i)
+        is_index_valid[i] = False
+        valid_indices = np.where(is_index_valid)[0]
+        if valid_indices.size == 0:
+          break
+
+        intersect_over_union = np_box_ops.iou(
+            np.expand_dims(boxes[i, :], axis=0), boxes[valid_indices, :])
+        intersect_over_union = np.squeeze(intersect_over_union, axis=0)
+        is_index_valid[valid_indices] = np.logical_and(
+            is_index_valid[valid_indices],
+            intersect_over_union <= iou_threshold)
+  return gather(boxlist, np.array(selected_indices))
+
+
+def multi_class_non_max_suppression(boxlist, score_thresh, iou_thresh,
+                                    max_output_size):
+  """Multi-class version of non maximum suppression.
+
+  This op greedily selects a subset of detection bounding boxes, pruning
+  away boxes that have high IOU (intersection over union) overlap (> thresh)
+  with already selected boxes.  It operates independently for each class for
+  which scores are provided (via the scores field of the input box_list),
+  pruning boxes with score less than a provided threshold prior to
+  applying NMS.
+
+  Args:
+    boxlist: BoxList holding N boxes.  Must contain a 'scores' field
+      representing detection scores.  This scores field is a tensor that can
+      be 1 dimensional (in the case of a single class) or 2-dimensional, which
+      which case we assume that it takes the shape [num_boxes, num_classes].
+      We further assume that this rank is known statically and that
+      scores.shape[1] is also known (i.e., the number of classes is fixed
+      and known at graph construction time).
+    score_thresh: scalar threshold for score (low scoring boxes are removed).
+    iou_thresh: scalar threshold for IOU (boxes that that high IOU overlap
+      with previously selected boxes are removed).
+    max_output_size: maximum number of retained boxes per class.
+
+  Returns:
+    a BoxList holding M boxes with a rank-1 scores field representing
+      corresponding scores for each box with scores sorted in decreasing order
+      and a rank-1 classes field representing a class label for each box.
+  Raises:
+    ValueError: if iou_thresh is not in [0, 1] or if input boxlist does not have
+      a valid scores field.
+  """
+  if not 0 <= iou_thresh <= 1.0:
+    raise ValueError('thresh must be between 0 and 1')
+  if not isinstance(boxlist, np_box_list.BoxList):
+    raise ValueError('boxlist must be a BoxList')
+  if not boxlist.has_field('scores'):
+    raise ValueError('input boxlist must have \'scores\' field')
+  scores = boxlist.get_field('scores')
+  if len(scores.shape) == 1:
+    scores = np.reshape(scores, [-1, 1])
+  elif len(scores.shape) == 2:
+    if scores.shape[1] is None:
+      raise ValueError('scores field must have statically defined second '
+                       'dimension')
+  else:
+    raise ValueError('scores field must be of rank 1 or 2')
+  num_boxes = boxlist.num_boxes()
+  num_scores = scores.shape[0]
+  num_classes = scores.shape[1]
+
+  if num_boxes != num_scores:
+    raise ValueError('Incorrect scores field length: actual vs expected.')
+
+  selected_boxes_list = []
+  for class_idx in range(num_classes):
+    boxlist_and_class_scores = np_box_list.BoxList(boxlist.get())
+    class_scores = np.reshape(scores[0:num_scores, class_idx], [-1])
+    boxlist_and_class_scores.add_field('scores', class_scores)
+    boxlist_filt = filter_scores_greater_than(boxlist_and_class_scores,
+                                              score_thresh)
+    nms_result = non_max_suppression(boxlist_filt,
+                                     max_output_size=max_output_size,
+                                     iou_threshold=iou_thresh,
+                                     score_threshold=score_thresh)
+    nms_result.add_field(
+        'classes', np.zeros_like(nms_result.get_field('scores')) + class_idx)
+    selected_boxes_list.append(nms_result)
+  selected_boxes = concatenate(selected_boxes_list)
+  sorted_boxes = sort_by_field(selected_boxes, 'scores')
+  return sorted_boxes
+
+
+def scale(boxlist, y_scale, x_scale):
+  """Scale box coordinates in x and y dimensions.
+
+  Args:
+    boxlist: BoxList holding N boxes
+    y_scale: float
+    x_scale: float
+
+  Returns:
+    boxlist: BoxList holding N boxes
+  """
+  y_min, x_min, y_max, x_max = np.array_split(boxlist.get(), 4, axis=1)
+  y_min = y_scale * y_min
+  y_max = y_scale * y_max
+  x_min = x_scale * x_min
+  x_max = x_scale * x_max
+  scaled_boxlist = np_box_list.BoxList(np.hstack([y_min, x_min, y_max, x_max]))
+
+  fields = boxlist.get_extra_fields()
+  for field in fields:
+    extra_field_data = boxlist.get_field(field)
+    scaled_boxlist.add_field(field, extra_field_data)
+
+  return scaled_boxlist
+
+
+def clip_to_window(boxlist, window):
+  """Clip bounding boxes to a window.
+
+  This op clips input bounding boxes (represented by bounding box
+  corners) to a window, optionally filtering out boxes that do not
+  overlap at all with the window.
+
+  Args:
+    boxlist: BoxList holding M_in boxes
+    window: a numpy array of shape [4] representing the
+            [y_min, x_min, y_max, x_max] window to which the op
+            should clip boxes.
+
+  Returns:
+    a BoxList holding M_out boxes where M_out <= M_in
+  """
+  y_min, x_min, y_max, x_max = np.array_split(boxlist.get(), 4, axis=1)
+  win_y_min = window[0]
+  win_x_min = window[1]
+  win_y_max = window[2]
+  win_x_max = window[3]
+  y_min_clipped = np.fmax(np.fmin(y_min, win_y_max), win_y_min)
+  y_max_clipped = np.fmax(np.fmin(y_max, win_y_max), win_y_min)
+  x_min_clipped = np.fmax(np.fmin(x_min, win_x_max), win_x_min)
+  x_max_clipped = np.fmax(np.fmin(x_max, win_x_max), win_x_min)
+  clipped = np_box_list.BoxList(
+      np.hstack([y_min_clipped, x_min_clipped, y_max_clipped, x_max_clipped]))
+  clipped = _copy_extra_fields(clipped, boxlist)
+  areas = area(clipped)
+  nonzero_area_indices = np.reshape(np.nonzero(np.greater(areas, 0.0)),
+                                    [-1]).astype(np.int32)
+  return gather(clipped, nonzero_area_indices)
+
+
+def prune_non_overlapping_boxes(boxlist1, boxlist2, minoverlap=0.0):
+  """Prunes the boxes in boxlist1 that overlap less than thresh with boxlist2.
+
+  For each box in boxlist1, we want its IOA to be more than minoverlap with
+  at least one of the boxes in boxlist2. If it does not, we remove it.
+
+  Args:
+    boxlist1: BoxList holding N boxes.
+    boxlist2: BoxList holding M boxes.
+    minoverlap: Minimum required overlap between boxes, to count them as
+                overlapping.
+
+  Returns:
+    A pruned boxlist with size [N', 4].
+  """
+  intersection_over_area = ioa(boxlist2, boxlist1)  # [M, N] tensor
+  intersection_over_area = np.amax(intersection_over_area, axis=0)  # [N] tensor
+  keep_bool = np.greater_equal(intersection_over_area, np.array(minoverlap))
+  keep_inds = np.nonzero(keep_bool)[0]
+  new_boxlist1 = gather(boxlist1, keep_inds)
+  return new_boxlist1
+
+
+def prune_outside_window(boxlist, window):
+  """Prunes bounding boxes that fall outside a given window.
+
+  This function prunes bounding boxes that even partially fall outside the given
+  window. See also ClipToWindow which only prunes bounding boxes that fall
+  completely outside the window, and clips any bounding boxes that partially
+  overflow.
+
+  Args:
+    boxlist: a BoxList holding M_in boxes.
+    window: a numpy array of size 4, representing [ymin, xmin, ymax, xmax]
+            of the window.
+
+  Returns:
+    pruned_corners: a tensor with shape [M_out, 4] where M_out <= M_in.
+    valid_indices: a tensor with shape [M_out] indexing the valid bounding boxes
+     in the input tensor.
+  """
+
+  y_min, x_min, y_max, x_max = np.array_split(boxlist.get(), 4, axis=1)
+  win_y_min = window[0]
+  win_x_min = window[1]
+  win_y_max = window[2]
+  win_x_max = window[3]
+  coordinate_violations = np.hstack([np.less(y_min, win_y_min),
+                                     np.less(x_min, win_x_min),
+                                     np.greater(y_max, win_y_max),
+                                     np.greater(x_max, win_x_max)])
+  valid_indices = np.reshape(
+      np.where(np.logical_not(np.max(coordinate_violations, axis=1))), [-1])
+  return gather(boxlist, valid_indices), valid_indices
+
+
+def concatenate(boxlists, fields=None):
+  """Concatenate list of BoxLists.
+
+  This op concatenates a list of input BoxLists into a larger BoxList.  It also
+  handles concatenation of BoxList fields as long as the field tensor shapes
+  are equal except for the first dimension.
+
+  Args:
+    boxlists: list of BoxList objects
+    fields: optional list of fields to also concatenate.  By default, all
+      fields from the first BoxList in the list are included in the
+      concatenation.
+
+  Returns:
+    a BoxList with number of boxes equal to
+      sum([boxlist.num_boxes() for boxlist in BoxList])
+  Raises:
+    ValueError: if boxlists is invalid (i.e., is not a list, is empty, or
+      contains non BoxList objects), or if requested fields are not contained in
+      all boxlists
+  """
+  if not isinstance(boxlists, list):
+    raise ValueError('boxlists should be a list')
+  if not boxlists:
+    raise ValueError('boxlists should have nonzero length')
+  for boxlist in boxlists:
+    if not isinstance(boxlist, np_box_list.BoxList):
+      raise ValueError('all elements of boxlists should be BoxList objects')
+  concatenated = np_box_list.BoxList(
+      np.vstack([boxlist.get() for boxlist in boxlists]))
+  if fields is None:
+    fields = boxlists[0].get_extra_fields()
+  for field in fields:
+    first_field_shape = boxlists[0].get_field(field).shape
+    first_field_shape = first_field_shape[1:]
+    for boxlist in boxlists:
+      if not boxlist.has_field(field):
+        raise ValueError('boxlist must contain all requested fields')
+      field_shape = boxlist.get_field(field).shape
+      field_shape = field_shape[1:]
+      if field_shape != first_field_shape:
+        raise ValueError('field %s must have same shape for all boxlists '
+                         'except for the 0th dimension.' % field)
+    concatenated_field = np.concatenate(
+        [boxlist.get_field(field) for boxlist in boxlists], axis=0)
+    concatenated.add_field(field, concatenated_field)
+  return concatenated
+
+
+def filter_scores_greater_than(boxlist, thresh):
+  """Filter to keep only boxes with score exceeding a given threshold.
+
+  This op keeps the collection of boxes whose corresponding scores are
+  greater than the input threshold.
+
+  Args:
+    boxlist: BoxList holding N boxes.  Must contain a 'scores' field
+      representing detection scores.
+    thresh: scalar threshold
+
+  Returns:
+    a BoxList holding M boxes where M <= N
+
+  Raises:
+    ValueError: if boxlist not a BoxList object or if it does not
+      have a scores field
+  """
+  if not isinstance(boxlist, np_box_list.BoxList):
+    raise ValueError('boxlist must be a BoxList')
+  if not boxlist.has_field('scores'):
+    raise ValueError('input boxlist must have \'scores\' field')
+  scores = boxlist.get_field('scores')
+  if len(scores.shape) > 2:
+    raise ValueError('Scores should have rank 1 or 2')
+  if len(scores.shape) == 2 and scores.shape[1] != 1:
+    raise ValueError('Scores should have rank 1 or have shape '
+                     'consistent with [None, 1]')
+  high_score_indices = np.reshape(np.where(np.greater(scores, thresh)),
+                                  [-1]).astype(np.int32)
+  return gather(boxlist, high_score_indices)
+
+
+def change_coordinate_frame(boxlist, window):
+  """Change coordinate frame of the boxlist to be relative to window's frame.
+
+  Given a window of the form [ymin, xmin, ymax, xmax],
+  changes bounding box coordinates from boxlist to be relative to this window
+  (e.g., the min corner maps to (0,0) and the max corner maps to (1,1)).
+
+  An example use case is data augmentation: where we are given groundtruth
+  boxes (boxlist) and would like to randomly crop the image to some
+  window (window). In this case we need to change the coordinate frame of
+  each groundtruth box to be relative to this new window.
+
+  Args:
+    boxlist: A BoxList object holding N boxes.
+    window: a size 4 1-D numpy array.
+
+  Returns:
+    Returns a BoxList object with N boxes.
+  """
+  win_height = window[2] - window[0]
+  win_width = window[3] - window[1]
+  boxlist_new = scale(
+      np_box_list.BoxList(boxlist.get() -
+                          [window[0], window[1], window[0], window[1]]),
+      1.0 / win_height, 1.0 / win_width)
+  _copy_extra_fields(boxlist_new, boxlist)
+
+  return boxlist_new
+
+
+def _copy_extra_fields(boxlist_to_copy_to, boxlist_to_copy_from):
+  """Copies the extra fields of boxlist_to_copy_from to boxlist_to_copy_to.
+
+  Args:
+    boxlist_to_copy_to: BoxList to which extra fields are copied.
+    boxlist_to_copy_from: BoxList from which fields are copied.
+
+  Returns:
+    boxlist_to_copy_to with extra fields.
+  """
+  for field in boxlist_to_copy_from.get_extra_fields():
+    boxlist_to_copy_to.add_field(field, boxlist_to_copy_from.get_field(field))
+  return boxlist_to_copy_to
+
+
+def _update_valid_indices_by_removing_high_iou_boxes(
+    selected_indices, is_index_valid, intersect_over_union, threshold):
+  max_iou = np.max(intersect_over_union[:, selected_indices], axis=1)
+  return np.logical_and(is_index_valid, max_iou <= threshold)
diff --git a/reconnaissance images/object_detection/utils/np_box_list_ops_test.py b/reconnaissance images/object_detection/utils/np_box_list_ops_test.py
new file mode 100644
index 0000000..24a2cc8
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/np_box_list_ops_test.py	
@@ -0,0 +1,414 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.np_box_list_ops."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.utils import np_box_list
+from object_detection.utils import np_box_list_ops
+
+
+class AreaRelatedTest(tf.test.TestCase):
+
+  def setUp(self):
+    boxes1 = np.array([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]],
+                      dtype=float)
+    boxes2 = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                       [0.0, 0.0, 20.0, 20.0]],
+                      dtype=float)
+    self.boxlist1 = np_box_list.BoxList(boxes1)
+    self.boxlist2 = np_box_list.BoxList(boxes2)
+
+  def test_area(self):
+    areas = np_box_list_ops.area(self.boxlist1)
+    expected_areas = np.array([6.0, 5.0], dtype=float)
+    self.assertAllClose(expected_areas, areas)
+
+  def test_intersection(self):
+    intersection = np_box_list_ops.intersection(self.boxlist1, self.boxlist2)
+    expected_intersection = np.array([[2.0, 0.0, 6.0], [1.0, 0.0, 5.0]],
+                                     dtype=float)
+    self.assertAllClose(intersection, expected_intersection)
+
+  def test_iou(self):
+    iou = np_box_list_ops.iou(self.boxlist1, self.boxlist2)
+    expected_iou = np.array([[2.0 / 16.0, 0.0, 6.0 / 400.0],
+                             [1.0 / 16.0, 0.0, 5.0 / 400.0]],
+                            dtype=float)
+    self.assertAllClose(iou, expected_iou)
+
+  def test_ioa(self):
+    boxlist1 = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75]], dtype=
+            np.float32))
+    boxlist2 = np_box_list.BoxList(
+        np.array(
+            [[0.5, 0.25, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0]], dtype=np.float32))
+    ioa21 = np_box_list_ops.ioa(boxlist2, boxlist1)
+    expected_ioa21 = np.array([[0.5, 0.0],
+                               [1.0, 1.0]],
+                              dtype=np.float32)
+    self.assertAllClose(ioa21, expected_ioa21)
+
+  def test_scale(self):
+    boxlist = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75]], dtype=
+            np.float32))
+    boxlist_scaled = np_box_list_ops.scale(boxlist, 2.0, 3.0)
+    expected_boxlist_scaled = np_box_list.BoxList(
+        np.array(
+            [[0.5, 0.75, 1.5, 2.25], [0.0, 0.0, 1.0, 2.25]], dtype=np.float32))
+    self.assertAllClose(expected_boxlist_scaled.get(), boxlist_scaled.get())
+
+  def test_clip_to_window(self):
+    boxlist = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75],
+             [-0.2, -0.3, 0.7, 1.5]],
+            dtype=np.float32))
+    boxlist_clipped = np_box_list_ops.clip_to_window(boxlist,
+                                                     [0.0, 0.0, 1.0, 1.0])
+    expected_boxlist_clipped = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75],
+             [0.0, 0.0, 0.7, 1.0]],
+            dtype=np.float32))
+    self.assertAllClose(expected_boxlist_clipped.get(), boxlist_clipped.get())
+
+  def test_prune_outside_window(self):
+    boxlist = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75],
+             [-0.2, -0.3, 0.7, 1.5]],
+            dtype=np.float32))
+    boxlist_pruned, _ = np_box_list_ops.prune_outside_window(
+        boxlist, [0.0, 0.0, 1.0, 1.0])
+    expected_boxlist_pruned = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75]], dtype=
+            np.float32))
+    self.assertAllClose(expected_boxlist_pruned.get(), boxlist_pruned.get())
+
+  def test_concatenate(self):
+    boxlist1 = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75]], dtype=
+            np.float32))
+    boxlist2 = np_box_list.BoxList(
+        np.array(
+            [[0.5, 0.25, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0]], dtype=np.float32))
+    boxlists = [boxlist1, boxlist2]
+    boxlist_concatenated = np_box_list_ops.concatenate(boxlists)
+    boxlist_concatenated_expected = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75],
+             [0.5, 0.25, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0]],
+            dtype=np.float32))
+    self.assertAllClose(boxlist_concatenated_expected.get(),
+                        boxlist_concatenated.get())
+
+  def test_change_coordinate_frame(self):
+    boxlist = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75]], dtype=
+            np.float32))
+    boxlist_coord = np_box_list_ops.change_coordinate_frame(
+        boxlist, np.array([0, 0, 0.5, 0.5], dtype=np.float32))
+    expected_boxlist_coord = np_box_list.BoxList(
+        np.array([[0.5, 0.5, 1.5, 1.5], [0, 0, 1.0, 1.5]], dtype=np.float32))
+    self.assertAllClose(boxlist_coord.get(), expected_boxlist_coord.get())
+
+  def test_filter_scores_greater_than(self):
+    boxlist = np_box_list.BoxList(
+        np.array(
+            [[0.25, 0.25, 0.75, 0.75], [0.0, 0.0, 0.5, 0.75]], dtype=
+            np.float32))
+    boxlist.add_field('scores', np.array([0.8, 0.2], np.float32))
+    boxlist_greater = np_box_list_ops.filter_scores_greater_than(boxlist, 0.5)
+
+    expected_boxlist_greater = np_box_list.BoxList(
+        np.array([[0.25, 0.25, 0.75, 0.75]], dtype=np.float32))
+
+    self.assertAllClose(boxlist_greater.get(), expected_boxlist_greater.get())
+
+
+class GatherOpsTest(tf.test.TestCase):
+
+  def setUp(self):
+    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                      [0.0, 0.0, 20.0, 20.0]],
+                     dtype=float)
+    self.boxlist = np_box_list.BoxList(boxes)
+    self.boxlist.add_field('scores', np.array([0.5, 0.7, 0.9], dtype=float))
+    self.boxlist.add_field('labels',
+                           np.array([[0, 0, 0, 1, 0], [0, 1, 0, 0, 0],
+                                     [0, 0, 0, 0, 1]],
+                                    dtype=int))
+
+  def test_gather_with_out_of_range_indices(self):
+    indices = np.array([3, 1], dtype=int)
+    boxlist = self.boxlist
+    with self.assertRaises(ValueError):
+      np_box_list_ops.gather(boxlist, indices)
+
+  def test_gather_with_invalid_multidimensional_indices(self):
+    indices = np.array([[0, 1], [1, 2]], dtype=int)
+    boxlist = self.boxlist
+    with self.assertRaises(ValueError):
+      np_box_list_ops.gather(boxlist, indices)
+
+  def test_gather_without_fields_specified(self):
+    indices = np.array([2, 0, 1], dtype=int)
+    boxlist = self.boxlist
+    subboxlist = np_box_list_ops.gather(boxlist, indices)
+
+    expected_scores = np.array([0.9, 0.5, 0.7], dtype=float)
+    self.assertAllClose(expected_scores, subboxlist.get_field('scores'))
+
+    expected_boxes = np.array([[0.0, 0.0, 20.0, 20.0], [3.0, 4.0, 6.0, 8.0],
+                               [14.0, 14.0, 15.0, 15.0]],
+                              dtype=float)
+    self.assertAllClose(expected_boxes, subboxlist.get())
+
+    expected_labels = np.array([[0, 0, 0, 0, 1], [0, 0, 0, 1, 0],
+                                [0, 1, 0, 0, 0]],
+                               dtype=int)
+    self.assertAllClose(expected_labels, subboxlist.get_field('labels'))
+
+  def test_gather_with_invalid_field_specified(self):
+    indices = np.array([2, 0, 1], dtype=int)
+    boxlist = self.boxlist
+
+    with self.assertRaises(ValueError):
+      np_box_list_ops.gather(boxlist, indices, 'labels')
+
+    with self.assertRaises(ValueError):
+      np_box_list_ops.gather(boxlist, indices, ['objectness'])
+
+  def test_gather_with_fields_specified(self):
+    indices = np.array([2, 0, 1], dtype=int)
+    boxlist = self.boxlist
+    subboxlist = np_box_list_ops.gather(boxlist, indices, ['labels'])
+
+    self.assertFalse(subboxlist.has_field('scores'))
+
+    expected_boxes = np.array([[0.0, 0.0, 20.0, 20.0], [3.0, 4.0, 6.0, 8.0],
+                               [14.0, 14.0, 15.0, 15.0]],
+                              dtype=float)
+    self.assertAllClose(expected_boxes, subboxlist.get())
+
+    expected_labels = np.array([[0, 0, 0, 0, 1], [0, 0, 0, 1, 0],
+                                [0, 1, 0, 0, 0]],
+                               dtype=int)
+    self.assertAllClose(expected_labels, subboxlist.get_field('labels'))
+
+
+class SortByFieldTest(tf.test.TestCase):
+
+  def setUp(self):
+    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                      [0.0, 0.0, 20.0, 20.0]],
+                     dtype=float)
+    self.boxlist = np_box_list.BoxList(boxes)
+    self.boxlist.add_field('scores', np.array([0.5, 0.9, 0.4], dtype=float))
+    self.boxlist.add_field('labels',
+                           np.array([[0, 0, 0, 1, 0], [0, 1, 0, 0, 0],
+                                     [0, 0, 0, 0, 1]],
+                                    dtype=int))
+
+  def test_with_invalid_field(self):
+    with self.assertRaises(ValueError):
+      np_box_list_ops.sort_by_field(self.boxlist, 'objectness')
+    with self.assertRaises(ValueError):
+      np_box_list_ops.sort_by_field(self.boxlist, 'labels')
+
+  def test_with_invalid_sorting_order(self):
+    with self.assertRaises(ValueError):
+      np_box_list_ops.sort_by_field(self.boxlist, 'scores', 'Descending')
+
+  def test_with_descending_sorting(self):
+    sorted_boxlist = np_box_list_ops.sort_by_field(self.boxlist, 'scores')
+
+    expected_boxes = np.array([[14.0, 14.0, 15.0, 15.0], [3.0, 4.0, 6.0, 8.0],
+                               [0.0, 0.0, 20.0, 20.0]],
+                              dtype=float)
+    self.assertAllClose(expected_boxes, sorted_boxlist.get())
+
+    expected_scores = np.array([0.9, 0.5, 0.4], dtype=float)
+    self.assertAllClose(expected_scores, sorted_boxlist.get_field('scores'))
+
+  def test_with_ascending_sorting(self):
+    sorted_boxlist = np_box_list_ops.sort_by_field(
+        self.boxlist, 'scores', np_box_list_ops.SortOrder.ASCEND)
+
+    expected_boxes = np.array([[0.0, 0.0, 20.0, 20.0],
+                               [3.0, 4.0, 6.0, 8.0],
+                               [14.0, 14.0, 15.0, 15.0],],
+                              dtype=float)
+    self.assertAllClose(expected_boxes, sorted_boxlist.get())
+
+    expected_scores = np.array([0.4, 0.5, 0.9], dtype=float)
+    self.assertAllClose(expected_scores, sorted_boxlist.get_field('scores'))
+
+
+class NonMaximumSuppressionTest(tf.test.TestCase):
+
+  def setUp(self):
+    self._boxes = np.array([[0, 0, 1, 1],
+                            [0, 0.1, 1, 1.1],
+                            [0, -0.1, 1, 0.9],
+                            [0, 10, 1, 11],
+                            [0, 10.1, 1, 11.1],
+                            [0, 100, 1, 101]],
+                           dtype=float)
+    self._boxlist = np_box_list.BoxList(self._boxes)
+
+  def test_with_no_scores_field(self):
+    boxlist = np_box_list.BoxList(self._boxes)
+    max_output_size = 3
+    iou_threshold = 0.5
+
+    with self.assertRaises(ValueError):
+      np_box_list_ops.non_max_suppression(
+          boxlist, max_output_size, iou_threshold)
+
+  def test_nms_disabled_max_output_size_equals_three(self):
+    boxlist = np_box_list.BoxList(self._boxes)
+    boxlist.add_field('scores',
+                      np.array([.9, .75, .6, .95, .2, .3], dtype=float))
+    max_output_size = 3
+    iou_threshold = 1.  # No NMS
+
+    expected_boxes = np.array([[0, 10, 1, 11], [0, 0, 1, 1], [0, 0.1, 1, 1.1]],
+                              dtype=float)
+    nms_boxlist = np_box_list_ops.non_max_suppression(
+        boxlist, max_output_size, iou_threshold)
+    self.assertAllClose(nms_boxlist.get(), expected_boxes)
+
+  def test_select_from_three_clusters(self):
+    boxlist = np_box_list.BoxList(self._boxes)
+    boxlist.add_field('scores',
+                      np.array([.9, .75, .6, .95, .2, .3], dtype=float))
+    max_output_size = 3
+    iou_threshold = 0.5
+
+    expected_boxes = np.array([[0, 10, 1, 11], [0, 0, 1, 1], [0, 100, 1, 101]],
+                              dtype=float)
+    nms_boxlist = np_box_list_ops.non_max_suppression(
+        boxlist, max_output_size, iou_threshold)
+    self.assertAllClose(nms_boxlist.get(), expected_boxes)
+
+  def test_select_at_most_two_from_three_clusters(self):
+    boxlist = np_box_list.BoxList(self._boxes)
+    boxlist.add_field('scores',
+                      np.array([.9, .75, .6, .95, .5, .3], dtype=float))
+    max_output_size = 2
+    iou_threshold = 0.5
+
+    expected_boxes = np.array([[0, 10, 1, 11], [0, 0, 1, 1]], dtype=float)
+    nms_boxlist = np_box_list_ops.non_max_suppression(
+        boxlist, max_output_size, iou_threshold)
+    self.assertAllClose(nms_boxlist.get(), expected_boxes)
+
+  def test_select_at_most_thirty_from_three_clusters(self):
+    boxlist = np_box_list.BoxList(self._boxes)
+    boxlist.add_field('scores',
+                      np.array([.9, .75, .6, .95, .5, .3], dtype=float))
+    max_output_size = 30
+    iou_threshold = 0.5
+
+    expected_boxes = np.array([[0, 10, 1, 11], [0, 0, 1, 1], [0, 100, 1, 101]],
+                              dtype=float)
+    nms_boxlist = np_box_list_ops.non_max_suppression(
+        boxlist, max_output_size, iou_threshold)
+    self.assertAllClose(nms_boxlist.get(), expected_boxes)
+
+  def test_select_from_ten_indentical_boxes(self):
+    boxes = np.array(10 * [[0, 0, 1, 1]], dtype=float)
+    boxlist = np_box_list.BoxList(boxes)
+    boxlist.add_field('scores', np.array(10 * [0.8]))
+    iou_threshold = .5
+    max_output_size = 3
+    expected_boxes = np.array([[0, 0, 1, 1]], dtype=float)
+    nms_boxlist = np_box_list_ops.non_max_suppression(
+        boxlist, max_output_size, iou_threshold)
+    self.assertAllClose(nms_boxlist.get(), expected_boxes)
+
+  def test_different_iou_threshold(self):
+    boxes = np.array([[0, 0, 20, 100], [0, 0, 20, 80], [200, 200, 210, 300],
+                      [200, 200, 210, 250]],
+                     dtype=float)
+    boxlist = np_box_list.BoxList(boxes)
+    boxlist.add_field('scores', np.array([0.9, 0.8, 0.7, 0.6]))
+    max_output_size = 4
+
+    iou_threshold = .4
+    expected_boxes = np.array([[0, 0, 20, 100],
+                               [200, 200, 210, 300],],
+                              dtype=float)
+    nms_boxlist = np_box_list_ops.non_max_suppression(
+        boxlist, max_output_size, iou_threshold)
+    self.assertAllClose(nms_boxlist.get(), expected_boxes)
+
+    iou_threshold = .5
+    expected_boxes = np.array([[0, 0, 20, 100], [200, 200, 210, 300],
+                               [200, 200, 210, 250]],
+                              dtype=float)
+    nms_boxlist = np_box_list_ops.non_max_suppression(
+        boxlist, max_output_size, iou_threshold)
+    self.assertAllClose(nms_boxlist.get(), expected_boxes)
+
+    iou_threshold = .8
+    expected_boxes = np.array([[0, 0, 20, 100], [0, 0, 20, 80],
+                               [200, 200, 210, 300], [200, 200, 210, 250]],
+                              dtype=float)
+    nms_boxlist = np_box_list_ops.non_max_suppression(
+        boxlist, max_output_size, iou_threshold)
+    self.assertAllClose(nms_boxlist.get(), expected_boxes)
+
+  def test_multiclass_nms(self):
+    boxlist = np_box_list.BoxList(
+        np.array(
+            [[0.2, 0.4, 0.8, 0.8], [0.4, 0.2, 0.8, 0.8], [0.6, 0.0, 1.0, 1.0]],
+            dtype=np.float32))
+    scores = np.array([[-0.2, 0.1, 0.5, -0.4, 0.3],
+                       [0.7, -0.7, 0.6, 0.2, -0.9],
+                       [0.4, 0.34, -0.9, 0.2, 0.31]],
+                      dtype=np.float32)
+    boxlist.add_field('scores', scores)
+    boxlist_clean = np_box_list_ops.multi_class_non_max_suppression(
+        boxlist, score_thresh=0.25, iou_thresh=0.1, max_output_size=3)
+
+    scores_clean = boxlist_clean.get_field('scores')
+    classes_clean = boxlist_clean.get_field('classes')
+    boxes = boxlist_clean.get()
+    expected_scores = np.array([0.7, 0.6, 0.34, 0.31])
+    expected_classes = np.array([0, 2, 1, 4])
+    expected_boxes = np.array([[0.4, 0.2, 0.8, 0.8],
+                               [0.4, 0.2, 0.8, 0.8],
+                               [0.6, 0.0, 1.0, 1.0],
+                               [0.6, 0.0, 1.0, 1.0]],
+                              dtype=np.float32)
+    self.assertAllClose(scores_clean, expected_scores)
+    self.assertAllClose(classes_clean, expected_classes)
+    self.assertAllClose(boxes, expected_boxes)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/np_box_list_test.py b/reconnaissance images/object_detection/utils/np_box_list_test.py
new file mode 100644
index 0000000..bb0ee5d
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/np_box_list_test.py	
@@ -0,0 +1,135 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.np_box_list_test."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.utils import np_box_list
+
+
+class BoxListTest(tf.test.TestCase):
+
+  def test_invalid_box_data(self):
+    with self.assertRaises(ValueError):
+      np_box_list.BoxList([0, 0, 1, 1])
+
+    with self.assertRaises(ValueError):
+      np_box_list.BoxList(np.array([[0, 0, 1, 1]], dtype=int))
+
+    with self.assertRaises(ValueError):
+      np_box_list.BoxList(np.array([0, 1, 1, 3, 4], dtype=float))
+
+    with self.assertRaises(ValueError):
+      np_box_list.BoxList(np.array([[0, 1, 1, 3], [3, 1, 1, 5]], dtype=float))
+
+  def test_has_field_with_existed_field(self):
+    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                      [0.0, 0.0, 20.0, 20.0]],
+                     dtype=float)
+    boxlist = np_box_list.BoxList(boxes)
+    self.assertTrue(boxlist.has_field('boxes'))
+
+  def test_has_field_with_nonexisted_field(self):
+    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                      [0.0, 0.0, 20.0, 20.0]],
+                     dtype=float)
+    boxlist = np_box_list.BoxList(boxes)
+    self.assertFalse(boxlist.has_field('scores'))
+
+  def test_get_field_with_existed_field(self):
+    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                      [0.0, 0.0, 20.0, 20.0]],
+                     dtype=float)
+    boxlist = np_box_list.BoxList(boxes)
+    self.assertTrue(np.allclose(boxlist.get_field('boxes'), boxes))
+
+  def test_get_field_with_nonexited_field(self):
+    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                      [0.0, 0.0, 20.0, 20.0]],
+                     dtype=float)
+    boxlist = np_box_list.BoxList(boxes)
+    with self.assertRaises(ValueError):
+      boxlist.get_field('scores')
+
+
+class AddExtraFieldTest(tf.test.TestCase):
+
+  def setUp(self):
+    boxes = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                      [0.0, 0.0, 20.0, 20.0]],
+                     dtype=float)
+    self.boxlist = np_box_list.BoxList(boxes)
+
+  def test_add_already_existed_field(self):
+    with self.assertRaises(ValueError):
+      self.boxlist.add_field('boxes', np.array([[0, 0, 0, 1, 0]], dtype=float))
+
+  def test_add_invalid_field_data(self):
+    with self.assertRaises(ValueError):
+      self.boxlist.add_field('scores', np.array([0.5, 0.7], dtype=float))
+    with self.assertRaises(ValueError):
+      self.boxlist.add_field('scores',
+                             np.array([0.5, 0.7, 0.9, 0.1], dtype=float))
+
+  def test_add_single_dimensional_field_data(self):
+    boxlist = self.boxlist
+    scores = np.array([0.5, 0.7, 0.9], dtype=float)
+    boxlist.add_field('scores', scores)
+    self.assertTrue(np.allclose(scores, self.boxlist.get_field('scores')))
+
+  def test_add_multi_dimensional_field_data(self):
+    boxlist = self.boxlist
+    labels = np.array([[0, 0, 0, 1, 0], [0, 1, 0, 0, 0], [0, 0, 0, 0, 1]],
+                      dtype=int)
+    boxlist.add_field('labels', labels)
+    self.assertTrue(np.allclose(labels, self.boxlist.get_field('labels')))
+
+  def test_get_extra_fields(self):
+    boxlist = self.boxlist
+    self.assertSameElements(boxlist.get_extra_fields(), [])
+
+    scores = np.array([0.5, 0.7, 0.9], dtype=float)
+    boxlist.add_field('scores', scores)
+    self.assertSameElements(boxlist.get_extra_fields(), ['scores'])
+
+    labels = np.array([[0, 0, 0, 1, 0], [0, 1, 0, 0, 0], [0, 0, 0, 0, 1]],
+                      dtype=int)
+    boxlist.add_field('labels', labels)
+    self.assertSameElements(boxlist.get_extra_fields(), ['scores', 'labels'])
+
+  def test_get_coordinates(self):
+    y_min, x_min, y_max, x_max = self.boxlist.get_coordinates()
+
+    expected_y_min = np.array([3.0, 14.0, 0.0], dtype=float)
+    expected_x_min = np.array([4.0, 14.0, 0.0], dtype=float)
+    expected_y_max = np.array([6.0, 15.0, 20.0], dtype=float)
+    expected_x_max = np.array([8.0, 15.0, 20.0], dtype=float)
+
+    self.assertTrue(np.allclose(y_min, expected_y_min))
+    self.assertTrue(np.allclose(x_min, expected_x_min))
+    self.assertTrue(np.allclose(y_max, expected_y_max))
+    self.assertTrue(np.allclose(x_max, expected_x_max))
+
+  def test_num_boxes(self):
+    boxes = np.array([[0., 0., 100., 100.], [10., 30., 50., 70.]], dtype=float)
+    boxlist = np_box_list.BoxList(boxes)
+    expected_num_boxes = 2
+    self.assertEquals(boxlist.num_boxes(), expected_num_boxes)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/np_box_ops.py b/reconnaissance images/object_detection/utils/np_box_ops.py
new file mode 100644
index 0000000..b4b46a7
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/np_box_ops.py	
@@ -0,0 +1,97 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Operations for [N, 4] numpy arrays representing bounding boxes.
+
+Example box operations that are supported:
+  * Areas: compute bounding box areas
+  * IOU: pairwise intersection-over-union scores
+"""
+import numpy as np
+
+
+def area(boxes):
+  """Computes area of boxes.
+
+  Args:
+    boxes: Numpy array with shape [N, 4] holding N boxes
+
+  Returns:
+    a numpy array with shape [N*1] representing box areas
+  """
+  return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+
+
+def intersection(boxes1, boxes2):
+  """Compute pairwise intersection areas between boxes.
+
+  Args:
+    boxes1: a numpy array with shape [N, 4] holding N boxes
+    boxes2: a numpy array with shape [M, 4] holding M boxes
+
+  Returns:
+    a numpy array with shape [N*M] representing pairwise intersection area
+  """
+  [y_min1, x_min1, y_max1, x_max1] = np.split(boxes1, 4, axis=1)
+  [y_min2, x_min2, y_max2, x_max2] = np.split(boxes2, 4, axis=1)
+
+  all_pairs_min_ymax = np.minimum(y_max1, np.transpose(y_max2))
+  all_pairs_max_ymin = np.maximum(y_min1, np.transpose(y_min2))
+  intersect_heights = np.maximum(
+      np.zeros(all_pairs_max_ymin.shape),
+      all_pairs_min_ymax - all_pairs_max_ymin)
+  all_pairs_min_xmax = np.minimum(x_max1, np.transpose(x_max2))
+  all_pairs_max_xmin = np.maximum(x_min1, np.transpose(x_min2))
+  intersect_widths = np.maximum(
+      np.zeros(all_pairs_max_xmin.shape),
+      all_pairs_min_xmax - all_pairs_max_xmin)
+  return intersect_heights * intersect_widths
+
+
+def iou(boxes1, boxes2):
+  """Computes pairwise intersection-over-union between box collections.
+
+  Args:
+    boxes1: a numpy array with shape [N, 4] holding N boxes.
+    boxes2: a numpy array with shape [M, 4] holding N boxes.
+
+  Returns:
+    a numpy array with shape [N, M] representing pairwise iou scores.
+  """
+  intersect = intersection(boxes1, boxes2)
+  area1 = area(boxes1)
+  area2 = area(boxes2)
+  union = np.expand_dims(area1, axis=1) + np.expand_dims(
+      area2, axis=0) - intersect
+  return intersect / union
+
+
+def ioa(boxes1, boxes2):
+  """Computes pairwise intersection-over-area between box collections.
+
+  Intersection-over-area (ioa) between two boxes box1 and box2 is defined as
+  their intersection area over box2's area. Note that ioa is not symmetric,
+  that is, IOA(box1, box2) != IOA(box2, box1).
+
+  Args:
+    boxes1: a numpy array with shape [N, 4] holding N boxes.
+    boxes2: a numpy array with shape [M, 4] holding N boxes.
+
+  Returns:
+    a numpy array with shape [N, M] representing pairwise ioa scores.
+  """
+  intersect = intersection(boxes1, boxes2)
+  areas = np.expand_dims(area(boxes2), axis=0)
+  return intersect / areas
diff --git a/reconnaissance images/object_detection/utils/np_box_ops_test.py b/reconnaissance images/object_detection/utils/np_box_ops_test.py
new file mode 100644
index 0000000..730f3d2
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/np_box_ops_test.py	
@@ -0,0 +1,68 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.np_box_ops."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.utils import np_box_ops
+
+
+class BoxOpsTests(tf.test.TestCase):
+
+  def setUp(self):
+    boxes1 = np.array([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]],
+                      dtype=float)
+    boxes2 = np.array([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+                       [0.0, 0.0, 20.0, 20.0]],
+                      dtype=float)
+    self.boxes1 = boxes1
+    self.boxes2 = boxes2
+
+  def testArea(self):
+    areas = np_box_ops.area(self.boxes1)
+    expected_areas = np.array([6.0, 5.0], dtype=float)
+    self.assertAllClose(expected_areas, areas)
+
+  def testIntersection(self):
+    intersection = np_box_ops.intersection(self.boxes1, self.boxes2)
+    expected_intersection = np.array([[2.0, 0.0, 6.0], [1.0, 0.0, 5.0]],
+                                     dtype=float)
+    self.assertAllClose(intersection, expected_intersection)
+
+  def testIOU(self):
+    iou = np_box_ops.iou(self.boxes1, self.boxes2)
+    expected_iou = np.array([[2.0 / 16.0, 0.0, 6.0 / 400.0],
+                             [1.0 / 16.0, 0.0, 5.0 / 400.0]],
+                            dtype=float)
+    self.assertAllClose(iou, expected_iou)
+
+  def testIOA(self):
+    boxes1 = np.array([[0.25, 0.25, 0.75, 0.75],
+                       [0.0, 0.0, 0.5, 0.75]],
+                      dtype=np.float32)
+    boxes2 = np.array([[0.5, 0.25, 1.0, 1.0],
+                       [0.0, 0.0, 1.0, 1.0]],
+                      dtype=np.float32)
+    ioa21 = np_box_ops.ioa(boxes2, boxes1)
+    expected_ioa21 = np.array([[0.5, 0.0],
+                               [1.0, 1.0]],
+                              dtype=np.float32)
+    self.assertAllClose(ioa21, expected_ioa21)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/object_detection_evaluation.py b/reconnaissance images/object_detection/utils/object_detection_evaluation.py
new file mode 100644
index 0000000..b2b1484
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/object_detection_evaluation.py	
@@ -0,0 +1,233 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""object_detection_evaluation module.
+
+ObjectDetectionEvaluation is a class which manages ground truth information of a
+object detection dataset, and computes frequently used detection metrics such as
+Precision, Recall, CorLoc of the provided detection results.
+It supports the following operations:
+1) Add ground truth information of images sequentially.
+2) Add detection result of images sequentially.
+3) Evaluate detection metrics on already inserted detection results.
+4) Write evaluation result into a pickle file for future processing or
+   visualization.
+
+Note: This module operates on numpy boxes and box lists.
+"""
+
+import logging
+import numpy as np
+
+from object_detection.utils import metrics
+from object_detection.utils import per_image_evaluation
+
+
+class ObjectDetectionEvaluation(object):
+  """Evaluate Object Detection Result."""
+
+  def __init__(self,
+               num_groundtruth_classes,
+               matching_iou_threshold=0.5,
+               nms_iou_threshold=1.0,
+               nms_max_output_boxes=10000):
+    self.per_image_eval = per_image_evaluation.PerImageEvaluation(
+        num_groundtruth_classes, matching_iou_threshold, nms_iou_threshold,
+        nms_max_output_boxes)
+    self.num_class = num_groundtruth_classes
+
+    self.groundtruth_boxes = {}
+    self.groundtruth_class_labels = {}
+    self.groundtruth_is_difficult_list = {}
+    self.num_gt_instances_per_class = np.zeros(self.num_class, dtype=int)
+    self.num_gt_imgs_per_class = np.zeros(self.num_class, dtype=int)
+
+    self.detection_keys = set()
+    self.scores_per_class = [[] for _ in range(self.num_class)]
+    self.tp_fp_labels_per_class = [[] for _ in range(self.num_class)]
+    self.num_images_correctly_detected_per_class = np.zeros(self.num_class)
+    self.average_precision_per_class = np.empty(self.num_class, dtype=float)
+    self.average_precision_per_class.fill(np.nan)
+    self.precisions_per_class = []
+    self.recalls_per_class = []
+    self.corloc_per_class = np.ones(self.num_class, dtype=float)
+
+  def clear_detections(self):
+    self.detection_keys = {}
+    self.scores_per_class = [[] for _ in range(self.num_class)]
+    self.tp_fp_labels_per_class = [[] for _ in range(self.num_class)]
+    self.num_images_correctly_detected_per_class = np.zeros(self.num_class)
+    self.average_precision_per_class = np.zeros(self.num_class, dtype=float)
+    self.precisions_per_class = []
+    self.recalls_per_class = []
+    self.corloc_per_class = np.ones(self.num_class, dtype=float)
+
+  def add_single_ground_truth_image_info(self,
+                                         image_key,
+                                         groundtruth_boxes,
+                                         groundtruth_class_labels,
+                                         groundtruth_is_difficult_list=None):
+    """Add ground truth info of a single image into the evaluation database.
+
+    Args:
+      image_key: sha256 key of image content
+      groundtruth_boxes: A numpy array of shape [M, 4] representing object box
+          coordinates[y_min, x_min, y_max, x_max]
+      groundtruth_class_labels: A 1-d numpy array of length M representing class
+          labels
+      groundtruth_is_difficult_list: A length M numpy boolean array denoting
+          whether a ground truth box is a difficult instance or not. To support
+          the case that no boxes are difficult, it is by default set as None.
+    """
+    if image_key in self.groundtruth_boxes:
+      logging.warn(
+          'image %s has already been added to the ground truth database.',
+          image_key)
+      return
+
+    self.groundtruth_boxes[image_key] = groundtruth_boxes
+    self.groundtruth_class_labels[image_key] = groundtruth_class_labels
+    if groundtruth_is_difficult_list is None:
+      num_boxes = groundtruth_boxes.shape[0]
+      groundtruth_is_difficult_list = np.zeros(num_boxes, dtype=bool)
+    self.groundtruth_is_difficult_list[
+        image_key] = groundtruth_is_difficult_list.astype(dtype=bool)
+    self._update_ground_truth_statistics(groundtruth_class_labels,
+                                         groundtruth_is_difficult_list)
+
+  def add_single_detected_image_info(self, image_key, detected_boxes,
+                                     detected_scores, detected_class_labels):
+    """Add detected result of a single image into the evaluation database.
+
+    Args:
+      image_key: sha256 key of image content
+      detected_boxes: A numpy array of shape [N, 4] representing detected box
+          coordinates[y_min, x_min, y_max, x_max]
+      detected_scores: A 1-d numpy array of length N representing classification
+          score
+      detected_class_labels: A 1-d numpy array of length N representing class
+          labels
+    Raises:
+      ValueError: if detected_boxes, detected_scores and detected_class_labels
+                  do not have the same length.
+    """
+    if (len(detected_boxes) != len(detected_scores) or
+        len(detected_boxes) != len(detected_class_labels)):
+      raise ValueError('detected_boxes, detected_scores and '
+                       'detected_class_labels should all have same lengths. Got'
+                       '[%d, %d, %d]' % len(detected_boxes),
+                       len(detected_scores), len(detected_class_labels))
+
+    if image_key in self.detection_keys:
+      logging.warn(
+          'image %s has already been added to the detection result database',
+          image_key)
+      return
+
+    self.detection_keys.add(image_key)
+    if image_key in self.groundtruth_boxes:
+      groundtruth_boxes = self.groundtruth_boxes[image_key]
+      groundtruth_class_labels = self.groundtruth_class_labels[image_key]
+      groundtruth_is_difficult_list = self.groundtruth_is_difficult_list[
+          image_key]
+    else:
+      groundtruth_boxes = np.empty(shape=[0, 4], dtype=float)
+      groundtruth_class_labels = np.array([], dtype=int)
+      groundtruth_is_difficult_list = np.array([], dtype=bool)
+    scores, tp_fp_labels, is_class_correctly_detected_in_image = (
+        self.per_image_eval.compute_object_detection_metrics(
+            detected_boxes, detected_scores, detected_class_labels,
+            groundtruth_boxes, groundtruth_class_labels,
+            groundtruth_is_difficult_list))
+    for i in range(self.num_class):
+      self.scores_per_class[i].append(scores[i])
+      self.tp_fp_labels_per_class[i].append(tp_fp_labels[i])
+    (self.num_images_correctly_detected_per_class
+    ) += is_class_correctly_detected_in_image
+
+  def _update_ground_truth_statistics(self, groundtruth_class_labels,
+                                      groundtruth_is_difficult_list):
+    """Update grouth truth statitistics.
+
+    1. Difficult boxes are ignored when counting the number of ground truth
+    instances as done in Pascal VOC devkit.
+    2. Difficult boxes are treated as normal boxes when computing CorLoc related
+    statitistics.
+
+    Args:
+      groundtruth_class_labels: An integer numpy array of length M,
+          representing M class labels of object instances in ground truth
+      groundtruth_is_difficult_list: A boolean numpy array of length M denoting
+          whether a ground truth box is a difficult instance or not
+    """
+    for class_index in range(self.num_class):
+      num_gt_instances = np.sum(groundtruth_class_labels[
+          ~groundtruth_is_difficult_list] == class_index)
+      self.num_gt_instances_per_class[class_index] += num_gt_instances
+      if np.any(groundtruth_class_labels == class_index):
+        self.num_gt_imgs_per_class[class_index] += 1
+
+  def evaluate(self):
+    """Compute evaluation result.
+
+    Returns:
+      average_precision_per_class: float numpy array of average precision for
+          each class.
+      mean_ap: mean average precision of all classes, float scalar
+      precisions_per_class: List of precisions, each precision is a float numpy
+          array
+      recalls_per_class: List of recalls, each recall is a float numpy array
+      corloc_per_class: numpy float array
+      mean_corloc: Mean CorLoc score for each class, float scalar
+    """
+    if (self.num_gt_instances_per_class == 0).any():
+      logging.warn(
+          'The following classes have no ground truth examples: %s',
+          np.squeeze(np.argwhere(self.num_gt_instances_per_class == 0)))
+    for class_index in range(self.num_class):
+      if self.num_gt_instances_per_class[class_index] == 0:
+        continue
+      scores = np.concatenate(self.scores_per_class[class_index])
+      tp_fp_labels = np.concatenate(self.tp_fp_labels_per_class[class_index])
+      precision, recall = metrics.compute_precision_recall(
+          scores, tp_fp_labels, self.num_gt_instances_per_class[class_index])
+      self.precisions_per_class.append(precision)
+      self.recalls_per_class.append(recall)
+      average_precision = metrics.compute_average_precision(precision, recall)
+      self.average_precision_per_class[class_index] = average_precision
+
+    self.corloc_per_class = metrics.compute_cor_loc(
+        self.num_gt_imgs_per_class,
+        self.num_images_correctly_detected_per_class)
+
+    mean_ap = np.nanmean(self.average_precision_per_class)
+    mean_corloc = np.nanmean(self.corloc_per_class)
+    return (self.average_precision_per_class, mean_ap,
+            self.precisions_per_class, self.recalls_per_class,
+            self.corloc_per_class, mean_corloc)
+
+  def get_eval_result(self):
+    return EvalResult(self.average_precision_per_class,
+                      self.precisions_per_class, self.recalls_per_class,
+                      self.corloc_per_class)
+
+
+class EvalResult(object):
+
+  def __init__(self, average_precisions, precisions, recalls, all_corloc):
+    self.precisions = precisions
+    self.recalls = recalls
+    self.all_corloc = all_corloc
+    self.average_precisions = average_precisions
diff --git a/reconnaissance images/object_detection/utils/object_detection_evaluation_test.py b/reconnaissance images/object_detection/utils/object_detection_evaluation_test.py
new file mode 100644
index 0000000..12bfc6b
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/object_detection_evaluation_test.py	
@@ -0,0 +1,125 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.object_detection_evaluation."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.utils import object_detection_evaluation
+
+
+class ObjectDetectionEvaluationTest(tf.test.TestCase):
+
+  def setUp(self):
+    num_groundtruth_classes = 3
+    self.od_eval = object_detection_evaluation.ObjectDetectionEvaluation(
+        num_groundtruth_classes)
+
+    image_key1 = "img1"
+    groundtruth_boxes1 = np.array([[0, 0, 1, 1], [0, 0, 2, 2], [0, 0, 3, 3]],
+                                  dtype=float)
+    groundtruth_class_labels1 = np.array([0, 2, 0], dtype=int)
+    self.od_eval.add_single_ground_truth_image_info(
+        image_key1, groundtruth_boxes1, groundtruth_class_labels1)
+    image_key2 = "img2"
+    groundtruth_boxes2 = np.array([[10, 10, 11, 11], [500, 500, 510, 510],
+                                   [10, 10, 12, 12]], dtype=float)
+    groundtruth_class_labels2 = np.array([0, 0, 2], dtype=int)
+    groundtruth_is_difficult_list2 = np.array([False, True, False], dtype=bool)
+    self.od_eval.add_single_ground_truth_image_info(
+        image_key2, groundtruth_boxes2, groundtruth_class_labels2,
+        groundtruth_is_difficult_list2)
+    image_key3 = "img3"
+    groundtruth_boxes3 = np.array([[0, 0, 1, 1]], dtype=float)
+    groundtruth_class_labels3 = np.array([1], dtype=int)
+    self.od_eval.add_single_ground_truth_image_info(
+        image_key3, groundtruth_boxes3, groundtruth_class_labels3)
+
+    image_key = "img2"
+    detected_boxes = np.array(
+        [[10, 10, 11, 11], [100, 100, 120, 120], [100, 100, 220, 220]],
+        dtype=float)
+    detected_class_labels = np.array([0, 0, 2], dtype=int)
+    detected_scores = np.array([0.7, 0.8, 0.9], dtype=float)
+    self.od_eval.add_single_detected_image_info(
+        image_key, detected_boxes, detected_scores, detected_class_labels)
+
+  def test_add_single_ground_truth_image_info(self):
+    expected_num_gt_instances_per_class = np.array([3, 1, 2], dtype=int)
+    expected_num_gt_imgs_per_class = np.array([2, 1, 2], dtype=int)
+    self.assertTrue(np.array_equal(expected_num_gt_instances_per_class,
+                                   self.od_eval.num_gt_instances_per_class))
+    self.assertTrue(np.array_equal(expected_num_gt_imgs_per_class,
+                                   self.od_eval.num_gt_imgs_per_class))
+    groundtruth_boxes2 = np.array([[10, 10, 11, 11], [500, 500, 510, 510],
+                                   [10, 10, 12, 12]], dtype=float)
+    self.assertTrue(np.allclose(self.od_eval.groundtruth_boxes["img2"],
+                                groundtruth_boxes2))
+    groundtruth_is_difficult_list2 = np.array([False, True, False], dtype=bool)
+    self.assertTrue(np.allclose(
+        self.od_eval.groundtruth_is_difficult_list["img2"],
+        groundtruth_is_difficult_list2))
+    groundtruth_class_labels1 = np.array([0, 2, 0], dtype=int)
+    self.assertTrue(np.array_equal(self.od_eval.groundtruth_class_labels[
+        "img1"], groundtruth_class_labels1))
+
+  def test_add_single_detected_image_info(self):
+    expected_scores_per_class = [[np.array([0.8, 0.7], dtype=float)], [],
+                                 [np.array([0.9], dtype=float)]]
+    expected_tp_fp_labels_per_class = [[np.array([0, 1], dtype=bool)], [],
+                                       [np.array([0], dtype=bool)]]
+    expected_num_images_correctly_detected_per_class = np.array([0, 0, 0],
+                                                                dtype=int)
+    for i in range(self.od_eval.num_class):
+      for j in range(len(expected_scores_per_class[i])):
+        self.assertTrue(np.allclose(expected_scores_per_class[i][j],
+                                    self.od_eval.scores_per_class[i][j]))
+        self.assertTrue(np.array_equal(expected_tp_fp_labels_per_class[i][
+            j], self.od_eval.tp_fp_labels_per_class[i][j]))
+    self.assertTrue(np.array_equal(
+        expected_num_images_correctly_detected_per_class,
+        self.od_eval.num_images_correctly_detected_per_class))
+
+  def test_evaluate(self):
+    (average_precision_per_class, mean_ap, precisions_per_class,
+     recalls_per_class, corloc_per_class,
+     mean_corloc) = self.od_eval.evaluate()
+    expected_precisions_per_class = [np.array([0, 0.5], dtype=float),
+                                     np.array([], dtype=float),
+                                     np.array([0], dtype=float)]
+    expected_recalls_per_class = [
+        np.array([0, 1. / 3.], dtype=float), np.array([], dtype=float),
+        np.array([0], dtype=float)
+    ]
+    expected_average_precision_per_class = np.array([1. / 6., 0, 0],
+                                                    dtype=float)
+    expected_corloc_per_class = np.array([0, np.divide(0, 0), 0], dtype=float)
+    expected_mean_ap = 1. / 18
+    expected_mean_corloc = 0.0
+    for i in range(self.od_eval.num_class):
+      self.assertTrue(np.allclose(expected_precisions_per_class[i],
+                                  precisions_per_class[i]))
+      self.assertTrue(np.allclose(expected_recalls_per_class[i],
+                                  recalls_per_class[i]))
+    self.assertTrue(np.allclose(expected_average_precision_per_class,
+                                average_precision_per_class))
+    self.assertTrue(np.allclose(expected_corloc_per_class, corloc_per_class))
+    self.assertAlmostEqual(expected_mean_ap, mean_ap)
+    self.assertAlmostEqual(expected_mean_corloc, mean_corloc)
+
+
+if __name__ == "__main__":
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/ops.py b/reconnaissance images/object_detection/utils/ops.py
new file mode 100644
index 0000000..290cd33
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/ops.py	
@@ -0,0 +1,651 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""A module for helper tensorflow ops."""
+import math
+import six
+
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.core import standard_fields as fields
+from object_detection.utils import static_shape
+
+
+def expanded_shape(orig_shape, start_dim, num_dims):
+  """Inserts multiple ones into a shape vector.
+
+  Inserts an all-1 vector of length num_dims at position start_dim into a shape.
+  Can be combined with tf.reshape to generalize tf.expand_dims.
+
+  Args:
+    orig_shape: the shape into which the all-1 vector is added (int32 vector)
+    start_dim: insertion position (int scalar)
+    num_dims: length of the inserted all-1 vector (int scalar)
+  Returns:
+    An int32 vector of length tf.size(orig_shape) + num_dims.
+  """
+  with tf.name_scope('ExpandedShape'):
+    start_dim = tf.expand_dims(start_dim, 0)  # scalar to rank-1
+    before = tf.slice(orig_shape, [0], start_dim)
+    add_shape = tf.ones(tf.reshape(num_dims, [1]), dtype=tf.int32)
+    after = tf.slice(orig_shape, start_dim, [-1])
+    new_shape = tf.concat([before, add_shape, after], 0)
+    return new_shape
+
+
+def normalized_to_image_coordinates(normalized_boxes, image_shape,
+                                    parallel_iterations=32):
+  """Converts a batch of boxes from normal to image coordinates.
+
+  Args:
+    normalized_boxes: a float32 tensor of shape [None, num_boxes, 4] in
+      normalized coordinates.
+    image_shape: a float32 tensor of shape [4] containing the image shape.
+    parallel_iterations: parallelism for the map_fn op.
+
+  Returns:
+    absolute_boxes: a float32 tensor of shape [None, num_boxes, 4] containg the
+      boxes in image coordinates.
+  """
+  def _to_absolute_coordinates(normalized_boxes):
+    return box_list_ops.to_absolute_coordinates(
+        box_list.BoxList(normalized_boxes),
+        image_shape[1], image_shape[2], check_range=False).get()
+
+  absolute_boxes = tf.map_fn(
+      _to_absolute_coordinates,
+      elems=(normalized_boxes),
+      dtype=tf.float32,
+      parallel_iterations=parallel_iterations,
+      back_prop=True)
+  return absolute_boxes
+
+
+def meshgrid(x, y):
+  """Tiles the contents of x and y into a pair of grids.
+
+  Multidimensional analog of numpy.meshgrid, giving the same behavior if x and y
+  are vectors. Generally, this will give:
+
+  xgrid(i1, ..., i_m, j_1, ..., j_n) = x(j_1, ..., j_n)
+  ygrid(i1, ..., i_m, j_1, ..., j_n) = y(i_1, ..., i_m)
+
+  Keep in mind that the order of the arguments and outputs is reverse relative
+  to the order of the indices they go into, done for compatibility with numpy.
+  The output tensors have the same shapes.  Specifically:
+
+  xgrid.get_shape() = y.get_shape().concatenate(x.get_shape())
+  ygrid.get_shape() = y.get_shape().concatenate(x.get_shape())
+
+  Args:
+    x: A tensor of arbitrary shape and rank. xgrid will contain these values
+       varying in its last dimensions.
+    y: A tensor of arbitrary shape and rank. ygrid will contain these values
+       varying in its first dimensions.
+  Returns:
+    A tuple of tensors (xgrid, ygrid).
+  """
+  with tf.name_scope('Meshgrid'):
+    x = tf.convert_to_tensor(x)
+    y = tf.convert_to_tensor(y)
+    x_exp_shape = expanded_shape(tf.shape(x), 0, tf.rank(y))
+    y_exp_shape = expanded_shape(tf.shape(y), tf.rank(y), tf.rank(x))
+
+    xgrid = tf.tile(tf.reshape(x, x_exp_shape), y_exp_shape)
+    ygrid = tf.tile(tf.reshape(y, y_exp_shape), x_exp_shape)
+    new_shape = y.get_shape().concatenate(x.get_shape())
+    xgrid.set_shape(new_shape)
+    ygrid.set_shape(new_shape)
+
+    return xgrid, ygrid
+
+
+def pad_to_multiple(tensor, multiple):
+  """Returns the tensor zero padded to the specified multiple.
+
+  Appends 0s to the end of the first and second dimension (height and width) of
+  the tensor until both dimensions are a multiple of the input argument
+  'multiple'. E.g. given an input tensor of shape [1, 3, 5, 1] and an input
+  multiple of 4, PadToMultiple will append 0s so that the resulting tensor will
+  be of shape [1, 4, 8, 1].
+
+  Args:
+    tensor: rank 4 float32 tensor, where
+            tensor -> [batch_size, height, width, channels].
+    multiple: the multiple to pad to.
+
+  Returns:
+    padded_tensor: the tensor zero padded to the specified multiple.
+  """
+  tensor_shape = tensor.get_shape()
+  batch_size = static_shape.get_batch_size(tensor_shape)
+  tensor_height = static_shape.get_height(tensor_shape)
+  tensor_width = static_shape.get_width(tensor_shape)
+  tensor_depth = static_shape.get_depth(tensor_shape)
+
+  if batch_size is None:
+    batch_size = tf.shape(tensor)[0]
+
+  if tensor_height is None:
+    tensor_height = tf.shape(tensor)[1]
+    padded_tensor_height = tf.to_int32(
+        tf.ceil(tf.to_float(tensor_height) / tf.to_float(multiple))) * multiple
+  else:
+    padded_tensor_height = int(
+        math.ceil(float(tensor_height) / multiple) * multiple)
+
+  if tensor_width is None:
+    tensor_width = tf.shape(tensor)[2]
+    padded_tensor_width = tf.to_int32(
+        tf.ceil(tf.to_float(tensor_width) / tf.to_float(multiple))) * multiple
+  else:
+    padded_tensor_width = int(
+        math.ceil(float(tensor_width) / multiple) * multiple)
+
+  if tensor_depth is None:
+    tensor_depth = tf.shape(tensor)[3]
+
+  # Use tf.concat instead of tf.pad to preserve static shape
+  height_pad = tf.zeros([
+      batch_size, padded_tensor_height - tensor_height, tensor_width,
+      tensor_depth
+  ])
+  padded_tensor = tf.concat([tensor, height_pad], 1)
+  width_pad = tf.zeros([
+      batch_size, padded_tensor_height, padded_tensor_width - tensor_width,
+      tensor_depth
+  ])
+  padded_tensor = tf.concat([padded_tensor, width_pad], 2)
+
+  return padded_tensor
+
+
+def padded_one_hot_encoding(indices, depth, left_pad):
+  """Returns a zero padded one-hot tensor.
+
+  This function converts a sparse representation of indices (e.g., [4]) to a
+  zero padded one-hot representation (e.g., [0, 0, 0, 0, 1] with depth = 4 and
+  left_pad = 1). If `indices` is empty, the result will simply be a tensor of
+  shape (0, depth + left_pad). If depth = 0, then this function just returns
+  `None`.
+
+  Args:
+    indices: an integer tensor of shape [num_indices].
+    depth: depth for the one-hot tensor (integer).
+    left_pad: number of zeros to left pad the one-hot tensor with (integer).
+
+  Returns:
+    padded_onehot: a tensor with shape (num_indices, depth + left_pad). Returns
+      `None` if the depth is zero.
+
+  Raises:
+    ValueError: if `indices` does not have rank 1 or if `left_pad` or `depth are
+      either negative or non-integers.
+
+  TODO: add runtime checks for depth and indices.
+  """
+  if depth < 0 or not isinstance(depth, (int, long) if six.PY2 else int):
+    raise ValueError('`depth` must be a non-negative integer.')
+  if left_pad < 0 or not isinstance(left_pad, (int, long) if six.PY2 else int):
+    raise ValueError('`left_pad` must be a non-negative integer.')
+  if depth == 0:
+    return None
+  if len(indices.get_shape().as_list()) != 1:
+    raise ValueError('`indices` must have rank 1')
+
+  def one_hot_and_pad():
+    one_hot = tf.cast(tf.one_hot(tf.cast(indices, tf.int64), depth,
+                                 on_value=1, off_value=0), tf.float32)
+    return tf.pad(one_hot, [[0, 0], [left_pad, 0]], mode='CONSTANT')
+  result = tf.cond(tf.greater(tf.size(indices), 0), one_hot_and_pad,
+                   lambda: tf.zeros((depth + left_pad, 0)))
+  return tf.reshape(result, [-1, depth + left_pad])
+
+
+def dense_to_sparse_boxes(dense_locations, dense_num_boxes, num_classes):
+  """Converts bounding boxes from dense to sparse form.
+
+  Args:
+    dense_locations:  a [max_num_boxes, 4] tensor in which only the first k rows
+      are valid bounding box location coordinates, where k is the sum of
+      elements in dense_num_boxes.
+    dense_num_boxes: a [max_num_classes] tensor indicating the counts of
+       various bounding box classes e.g. [1, 0, 0, 2] means that the first
+       bounding box is of class 0 and the second and third bounding boxes are
+       of class 3. The sum of elements in this tensor is the number of valid
+       bounding boxes.
+    num_classes: number of classes
+
+  Returns:
+    box_locations: a [num_boxes, 4] tensor containing only valid bounding
+       boxes (i.e. the first num_boxes rows of dense_locations)
+    box_classes: a [num_boxes] tensor containing the classes of each bounding
+       box (e.g. dense_num_boxes = [1, 0, 0, 2] => box_classes = [0, 3, 3]
+  """
+
+  num_valid_boxes = tf.reduce_sum(dense_num_boxes)
+  box_locations = tf.slice(dense_locations,
+                           tf.constant([0, 0]), tf.stack([num_valid_boxes, 4]))
+  tiled_classes = [tf.tile([i], tf.expand_dims(dense_num_boxes[i], 0))
+                   for i in range(num_classes)]
+  box_classes = tf.concat(tiled_classes, 0)
+  box_locations.set_shape([None, 4])
+  return box_locations, box_classes
+
+
+def indices_to_dense_vector(indices,
+                            size,
+                            indices_value=1.,
+                            default_value=0,
+                            dtype=tf.float32):
+  """Creates dense vector with indices set to specific value and rest to zeros.
+
+  This function exists because it is unclear if it is safe to use
+    tf.sparse_to_dense(indices, [size], 1, validate_indices=False)
+  with indices which are not ordered.
+  This function accepts a dynamic size (e.g. tf.shape(tensor)[0])
+
+  Args:
+    indices: 1d Tensor with integer indices which are to be set to
+        indices_values.
+    size: scalar with size (integer) of output Tensor.
+    indices_value: values of elements specified by indices in the output vector
+    default_value: values of other elements in the output vector.
+    dtype: data type.
+
+  Returns:
+    dense 1D Tensor of shape [size] with indices set to indices_values and the
+        rest set to default_value.
+  """
+  size = tf.to_int32(size)
+  zeros = tf.ones([size], dtype=dtype) * default_value
+  values = tf.ones_like(indices, dtype=dtype) * indices_value
+
+  return tf.dynamic_stitch([tf.range(size), tf.to_int32(indices)],
+                           [zeros, values])
+
+
+def retain_groundtruth(tensor_dict, valid_indices):
+  """Retains groundtruth by valid indices.
+
+  Args:
+    tensor_dict: a dictionary of following groundtruth tensors -
+      fields.InputDataFields.groundtruth_boxes
+      fields.InputDataFields.groundtruth_classes
+      fields.InputDataFields.groundtruth_is_crowd
+      fields.InputDataFields.groundtruth_area
+      fields.InputDataFields.groundtruth_label_types
+      fields.InputDataFields.groundtruth_difficult
+    valid_indices: a tensor with valid indices for the box-level groundtruth.
+
+  Returns:
+    a dictionary of tensors containing only the groundtruth for valid_indices.
+
+  Raises:
+    ValueError: If the shape of valid_indices is invalid.
+    ValueError: field fields.InputDataFields.groundtruth_boxes is
+      not present in tensor_dict.
+  """
+  input_shape = valid_indices.get_shape().as_list()
+  if not (len(input_shape) == 1 or
+          (len(input_shape) == 2 and input_shape[1] == 1)):
+    raise ValueError('The shape of valid_indices is invalid.')
+  valid_indices = tf.reshape(valid_indices, [-1])
+  valid_dict = {}
+  if fields.InputDataFields.groundtruth_boxes in tensor_dict:
+    # Prevents reshape failure when num_boxes is 0.
+    num_boxes = tf.maximum(tf.shape(
+        tensor_dict[fields.InputDataFields.groundtruth_boxes])[0], 1)
+    for key in tensor_dict:
+      if key in [fields.InputDataFields.groundtruth_boxes,
+                 fields.InputDataFields.groundtruth_classes]:
+        valid_dict[key] = tf.gather(tensor_dict[key], valid_indices)
+      # Input decoder returns empty tensor when these fields are not provided.
+      # Needs to reshape into [num_boxes, -1] for tf.gather() to work.
+      elif key in [fields.InputDataFields.groundtruth_is_crowd,
+                   fields.InputDataFields.groundtruth_area,
+                   fields.InputDataFields.groundtruth_difficult,
+                   fields.InputDataFields.groundtruth_label_types]:
+        valid_dict[key] = tf.reshape(
+            tf.gather(tf.reshape(tensor_dict[key], [num_boxes, -1]),
+                      valid_indices), [-1])
+      # Fields that are not associated with boxes.
+      else:
+        valid_dict[key] = tensor_dict[key]
+  else:
+    raise ValueError('%s not present in input tensor dict.' % (
+        fields.InputDataFields.groundtruth_boxes))
+  return valid_dict
+
+
+def retain_groundtruth_with_positive_classes(tensor_dict):
+  """Retains only groundtruth with positive class ids.
+
+  Args:
+    tensor_dict: a dictionary of following groundtruth tensors -
+      fields.InputDataFields.groundtruth_boxes
+      fields.InputDataFields.groundtruth_classes
+      fields.InputDataFields.groundtruth_is_crowd
+      fields.InputDataFields.groundtruth_area
+      fields.InputDataFields.groundtruth_label_types
+      fields.InputDataFields.groundtruth_difficult
+
+  Returns:
+    a dictionary of tensors containing only the groundtruth with positive
+    classes.
+
+  Raises:
+    ValueError: If groundtruth_classes tensor is not in tensor_dict.
+  """
+  if fields.InputDataFields.groundtruth_classes not in tensor_dict:
+    raise ValueError('`groundtruth classes` not in tensor_dict.')
+  keep_indices = tf.where(tf.greater(
+      tensor_dict[fields.InputDataFields.groundtruth_classes], 0))
+  return retain_groundtruth(tensor_dict, keep_indices)
+
+
+def filter_groundtruth_with_nan_box_coordinates(tensor_dict):
+  """Filters out groundtruth with no bounding boxes.
+
+  Args:
+    tensor_dict: a dictionary of following groundtruth tensors -
+      fields.InputDataFields.groundtruth_boxes
+      fields.InputDataFields.groundtruth_classes
+      fields.InputDataFields.groundtruth_is_crowd
+      fields.InputDataFields.groundtruth_area
+      fields.InputDataFields.groundtruth_label_types
+
+  Returns:
+    a dictionary of tensors containing only the groundtruth that have bounding
+    boxes.
+  """
+  groundtruth_boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+  nan_indicator_vector = tf.greater(tf.reduce_sum(tf.to_int32(
+      tf.is_nan(groundtruth_boxes)), reduction_indices=[1]), 0)
+  valid_indicator_vector = tf.logical_not(nan_indicator_vector)
+  valid_indices = tf.where(valid_indicator_vector)
+
+  return retain_groundtruth(tensor_dict, valid_indices)
+
+
+def normalize_to_target(inputs,
+                        target_norm_value,
+                        dim,
+                        epsilon=1e-7,
+                        trainable=True,
+                        scope='NormalizeToTarget',
+                        summarize=True):
+  """L2 normalizes the inputs across the specified dimension to a target norm.
+
+  This op implements the L2 Normalization layer introduced in
+  Liu, Wei, et al. "SSD: Single Shot MultiBox Detector."
+  and Liu, Wei, Andrew Rabinovich, and Alexander C. Berg.
+  "Parsenet: Looking wider to see better." and is useful for bringing
+  activations from multiple layers in a convnet to a standard scale.
+
+  Note that the rank of `inputs` must be known and the dimension to which
+  normalization is to be applied should be statically defined.
+
+  TODO: Add option to scale by L2 norm of the entire input.
+
+  Args:
+    inputs: A `Tensor` of arbitrary size.
+    target_norm_value: A float value that specifies an initial target norm or
+      a list of floats (whose length must be equal to the depth along the
+      dimension to be normalized) specifying a per-dimension multiplier
+      after normalization.
+    dim: The dimension along which the input is normalized.
+    epsilon: A small value to add to the inputs to avoid dividing by zero.
+    trainable: Whether the norm is trainable or not
+    scope: Optional scope for variable_scope.
+    summarize: Whether or not to add a tensorflow summary for the op.
+
+  Returns:
+    The input tensor normalized to the specified target norm.
+
+  Raises:
+    ValueError: If dim is smaller than the number of dimensions in 'inputs'.
+    ValueError: If target_norm_value is not a float or a list of floats with
+      length equal to the depth along the dimension to be normalized.
+  """
+  with tf.variable_scope(scope, 'NormalizeToTarget', [inputs]):
+    if not inputs.get_shape():
+      raise ValueError('The input rank must be known.')
+    input_shape = inputs.get_shape().as_list()
+    input_rank = len(input_shape)
+    if dim < 0 or dim >= input_rank:
+      raise ValueError(
+          'dim must be non-negative but smaller than the input rank.')
+    if not input_shape[dim]:
+      raise ValueError('input shape should be statically defined along '
+                       'the specified dimension.')
+    depth = input_shape[dim]
+    if not (isinstance(target_norm_value, float) or
+            (isinstance(target_norm_value, list) and
+             len(target_norm_value) == depth) and
+            all([isinstance(val, float) for val in target_norm_value])):
+      raise ValueError('target_norm_value must be a float or a list of floats '
+                       'with length equal to the depth along the dimension to '
+                       'be normalized.')
+    if isinstance(target_norm_value, float):
+      initial_norm = depth * [target_norm_value]
+    else:
+      initial_norm = target_norm_value
+    target_norm = tf.contrib.framework.model_variable(
+        name='weights', dtype=tf.float32,
+        initializer=tf.constant(initial_norm, dtype=tf.float32),
+        trainable=trainable)
+    if summarize:
+      mean = tf.reduce_mean(target_norm)
+      mean = tf.Print(mean, ['NormalizeToTarget:', mean])
+      tf.summary.scalar(tf.get_variable_scope().name, mean)
+    lengths = epsilon + tf.sqrt(tf.reduce_sum(tf.square(inputs), dim, True))
+    mult_shape = input_rank*[1]
+    mult_shape[dim] = depth
+    return tf.reshape(target_norm, mult_shape) * tf.truediv(inputs, lengths)
+
+
+def position_sensitive_crop_regions(image,
+                                    boxes,
+                                    box_ind,
+                                    crop_size,
+                                    num_spatial_bins,
+                                    global_pool,
+                                    extrapolation_value=None):
+  """Position-sensitive crop and pool rectangular regions from a feature grid.
+
+  The output crops are split into `spatial_bins_y` vertical bins
+  and `spatial_bins_x` horizontal bins. For each intersection of a vertical
+  and a horizontal bin the output values are gathered by performing
+  `tf.image.crop_and_resize` (bilinear resampling) on a a separate subset of
+  channels of the image. This reduces `depth` by a factor of
+  `(spatial_bins_y * spatial_bins_x)`.
+
+  When global_pool is True, this function implements a differentiable version
+  of position-sensitive RoI pooling used in
+  [R-FCN detection system](https://arxiv.org/abs/1605.06409).
+
+  When global_pool is False, this function implements a differentiable version
+  of position-sensitive assembling operation used in
+  [instance FCN](https://arxiv.org/abs/1603.08678).
+
+  Args:
+    image: A `Tensor`. Must be one of the following types: `uint8`, `int8`,
+      `int16`, `int32`, `int64`, `half`, `float32`, `float64`.
+      A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+      Both `image_height` and `image_width` need to be positive.
+    boxes: A `Tensor` of type `float32`.
+      A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+      specifies the coordinates of a box in the `box_ind[i]` image and is
+      specified in normalized coordinates `[y1, x1, y2, x2]`. A normalized
+      coordinate value of `y` is mapped to the image coordinate at
+      `y * (image_height - 1)`, so as the `[0, 1]` interval of normalized image
+      height is mapped to `[0, image_height - 1] in image height coordinates.
+      We do allow y1 > y2, in which case the sampled crop is an up-down flipped
+      version of the original image. The width dimension is treated similarly.
+      Normalized coordinates outside the `[0, 1]` range are allowed, in which
+      case we use `extrapolation_value` to extrapolate the input image values.
+    box_ind:  A `Tensor` of type `int32`.
+      A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+      The value of `box_ind[i]` specifies the image that the `i`-th box refers
+      to.
+    crop_size: A list of two integers `[crop_height, crop_width]`. All
+      cropped image patches are resized to this size. The aspect ratio of the
+      image content is not preserved. Both `crop_height` and `crop_width` need
+      to be positive.
+    num_spatial_bins: A list of two integers `[spatial_bins_y, spatial_bins_x]`.
+      Represents the number of position-sensitive bins in y and x directions.
+      Both values should be >= 1. `crop_height` should be divisible by
+      `spatial_bins_y`, and similarly for width.
+      The number of image channels should be divisible by
+      (spatial_bins_y * spatial_bins_x).
+      Suggested value from R-FCN paper: [3, 3].
+    global_pool: A boolean variable.
+      If True, we perform average global pooling on the features assembled from
+        the position-sensitive score maps.
+      If False, we keep the position-pooled features without global pooling
+        over the spatial coordinates.
+      Note that using global_pool=True is equivalent to but more efficient than
+        running the function with global_pool=False and then performing global
+        average pooling.
+    extrapolation_value: An optional `float`. Defaults to `0`.
+      Value used for extrapolation, when applicable.
+  Returns:
+    position_sensitive_features: A 4-D tensor of shape
+      `[num_boxes, K, K, crop_channels]`,
+      where `crop_channels = depth / (spatial_bins_y * spatial_bins_x)`,
+      where K = 1 when global_pool is True (Average-pooled cropped regions),
+      and K = crop_size when global_pool is False.
+  Raises:
+    ValueError: Raised in four situations:
+      `num_spatial_bins` is not >= 1;
+      `num_spatial_bins` does not divide `crop_size`;
+      `(spatial_bins_y*spatial_bins_x)` does not divide `depth`;
+      `bin_crop_size` is not square when global_pool=False due to the
+        constraint in function space_to_depth.
+  """
+  total_bins = 1
+  bin_crop_size = []
+
+  for (num_bins, crop_dim) in zip(num_spatial_bins, crop_size):
+    if num_bins < 1:
+      raise ValueError('num_spatial_bins should be >= 1')
+
+    if crop_dim % num_bins != 0:
+      raise ValueError('crop_size should be divisible by num_spatial_bins')
+
+    total_bins *= num_bins
+    bin_crop_size.append(crop_dim // num_bins)
+
+  if not global_pool and bin_crop_size[0] != bin_crop_size[1]:
+    raise ValueError('Only support square bin crop size for now.')
+
+  ymin, xmin, ymax, xmax = tf.unstack(boxes, axis=1)
+  spatial_bins_y, spatial_bins_x = num_spatial_bins
+
+  # Split each box into spatial_bins_y * spatial_bins_x bins.
+  position_sensitive_boxes = []
+  for bin_y in range(spatial_bins_y):
+    step_y = (ymax - ymin) / spatial_bins_y
+    for bin_x in range(spatial_bins_x):
+      step_x = (xmax - xmin) / spatial_bins_x
+      box_coordinates = [ymin + bin_y * step_y,
+                         xmin + bin_x * step_x,
+                         ymin + (bin_y + 1) * step_y,
+                         xmin + (bin_x + 1) * step_x,
+                        ]
+      position_sensitive_boxes.append(tf.stack(box_coordinates, axis=1))
+
+  image_splits = tf.split(value=image, num_or_size_splits=total_bins, axis=3)
+
+  image_crops = []
+  for (split, box) in zip(image_splits, position_sensitive_boxes):
+    crop = tf.image.crop_and_resize(split, box, box_ind, bin_crop_size,
+                                    extrapolation_value=extrapolation_value)
+    image_crops.append(crop)
+
+  if global_pool:
+    # Average over all bins.
+    position_sensitive_features = tf.add_n(image_crops) / len(image_crops)
+    # Then average over spatial positions within the bins.
+    position_sensitive_features = tf.reduce_mean(
+        position_sensitive_features, [1, 2], keep_dims=True)
+  else:
+    # Reorder height/width to depth channel.
+    block_size = bin_crop_size[0]
+    if block_size >= 2:
+      image_crops = [tf.space_to_depth(
+          crop, block_size=block_size) for crop in image_crops]
+
+    # Pack image_crops so that first dimension is for position-senstive boxes.
+    position_sensitive_features = tf.stack(image_crops, axis=0)
+
+    # Unroll the position-sensitive boxes to spatial positions.
+    position_sensitive_features = tf.squeeze(
+        tf.batch_to_space_nd(position_sensitive_features,
+                             block_shape=[1] + num_spatial_bins,
+                             crops=tf.zeros((3, 2), dtype=tf.int32)),
+        squeeze_dims=[0])
+
+    # Reorder back the depth channel.
+    if block_size >= 2:
+      position_sensitive_features = tf.depth_to_space(
+          position_sensitive_features, block_size=block_size)
+
+  return position_sensitive_features
+
+
+def reframe_box_masks_to_image_masks(box_masks, boxes, image_height,
+                                     image_width):
+  """Transforms the box masks back to full image masks.
+
+  Embeds masks in bounding boxes of larger masks whose shapes correspond to
+  image shape.
+
+  Args:
+    box_masks: A tf.float32 tensor of size [num_masks, mask_height, mask_width].
+    boxes: A tf.float32 tensor of size [num_masks, 4] containing the box
+           corners. Row i contains [ymin, xmin, ymax, xmax] of the box
+           corresponding to mask i. Note that the box corners are in
+           normalized coordinates.
+    image_height: Image height. The output mask will have the same height as
+                  the image height.
+    image_width: Image width. The output mask will have the same width as the
+                 image width.
+
+  Returns:
+    A tf.float32 tensor of size [num_masks, image_height, image_width].
+  """
+  # TODO: Make this a public function.
+  def transform_boxes_relative_to_boxes(boxes, reference_boxes):
+    boxes = tf.reshape(boxes, [-1, 2, 2])
+    min_corner = tf.expand_dims(reference_boxes[:, 0:2], 1)
+    max_corner = tf.expand_dims(reference_boxes[:, 2:4], 1)
+    transformed_boxes = (boxes - min_corner) / (max_corner - min_corner)
+    return tf.reshape(transformed_boxes, [-1, 4])
+
+  box_masks = tf.expand_dims(box_masks, axis=3)
+  num_boxes = tf.shape(box_masks)[0]
+  unit_boxes = tf.concat(
+      [tf.zeros([num_boxes, 2]), tf.ones([num_boxes, 2])], axis=1)
+  reverse_boxes = transform_boxes_relative_to_boxes(unit_boxes, boxes)
+  image_masks = tf.image.crop_and_resize(image=box_masks,
+                                         boxes=reverse_boxes,
+                                         box_ind=tf.range(num_boxes),
+                                         crop_size=[image_height, image_width],
+                                         extrapolation_value=0.0)
+  return tf.squeeze(image_masks, axis=3)
diff --git a/reconnaissance images/object_detection/utils/ops_test.py b/reconnaissance images/object_detection/utils/ops_test.py
new file mode 100644
index 0000000..1765c82
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/ops_test.py	
@@ -0,0 +1,1033 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.ops."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import standard_fields as fields
+from object_detection.utils import ops
+
+
+class NormalizedToImageCoordinatesTest(tf.test.TestCase):
+
+  def test_normalized_to_image_coordinates(self):
+    normalized_boxes = tf.placeholder(tf.float32, shape=(None, 1, 4))
+    normalized_boxes_np = np.array([[[0.0, 0.0, 1.0, 1.0]],
+                                    [[0.5, 0.5, 1.0, 1.0]]])
+    image_shape = tf.convert_to_tensor([1, 4, 4, 3], dtype=tf.int32)
+    absolute_boxes = ops.normalized_to_image_coordinates(normalized_boxes,
+                                                         image_shape,
+                                                         parallel_iterations=2)
+
+    expected_boxes = np.array([[[0, 0, 4, 4]],
+                               [[2, 2, 4, 4]]])
+    with self.test_session() as sess:
+      absolute_boxes = sess.run(absolute_boxes,
+                                feed_dict={normalized_boxes:
+                                           normalized_boxes_np})
+
+    self.assertAllEqual(absolute_boxes, expected_boxes)
+
+
+class MeshgridTest(tf.test.TestCase):
+
+  def test_meshgrid_numpy_comparison(self):
+    """Tests meshgrid op with vectors, for which it should match numpy."""
+    x = np.arange(4)
+    y = np.arange(6)
+    exp_xgrid, exp_ygrid = np.meshgrid(x, y)
+    xgrid, ygrid = ops.meshgrid(x, y)
+    with self.test_session() as sess:
+      xgrid_output, ygrid_output = sess.run([xgrid, ygrid])
+      self.assertAllEqual(xgrid_output, exp_xgrid)
+      self.assertAllEqual(ygrid_output, exp_ygrid)
+
+  def test_meshgrid_multidimensional(self):
+    np.random.seed(18)
+    x = np.random.rand(4, 1, 2).astype(np.float32)
+    y = np.random.rand(2, 3).astype(np.float32)
+
+    xgrid, ygrid = ops.meshgrid(x, y)
+
+    grid_shape = list(y.shape) + list(x.shape)
+    self.assertEqual(xgrid.get_shape().as_list(), grid_shape)
+    self.assertEqual(ygrid.get_shape().as_list(), grid_shape)
+    with self.test_session() as sess:
+      xgrid_output, ygrid_output = sess.run([xgrid, ygrid])
+
+    # Check the shape of the output grids
+    self.assertEqual(xgrid_output.shape, tuple(grid_shape))
+    self.assertEqual(ygrid_output.shape, tuple(grid_shape))
+
+    # Check a few elements
+    test_elements = [((3, 0, 0), (1, 2)),
+                     ((2, 0, 1), (0, 0)),
+                     ((0, 0, 0), (1, 1))]
+    for xind, yind in test_elements:
+      # These are float equality tests, but the meshgrid op should not introduce
+      # rounding.
+      self.assertEqual(xgrid_output[yind + xind], x[xind])
+      self.assertEqual(ygrid_output[yind + xind], y[yind])
+
+
+class OpsTestPadToMultiple(tf.test.TestCase):
+
+  def test_zero_padding(self):
+    tensor = tf.constant([[[[0.], [0.]], [[0.], [0.]]]])
+    padded_tensor = ops.pad_to_multiple(tensor, 1)
+    with self.test_session() as sess:
+      padded_tensor_out = sess.run(padded_tensor)
+    self.assertEqual((1, 2, 2, 1), padded_tensor_out.shape)
+
+  def test_no_padding(self):
+    tensor = tf.constant([[[[0.], [0.]], [[0.], [0.]]]])
+    padded_tensor = ops.pad_to_multiple(tensor, 2)
+    with self.test_session() as sess:
+      padded_tensor_out = sess.run(padded_tensor)
+    self.assertEqual((1, 2, 2, 1), padded_tensor_out.shape)
+
+  def test_padding(self):
+    tensor = tf.constant([[[[0.], [0.]], [[0.], [0.]]]])
+    padded_tensor = ops.pad_to_multiple(tensor, 4)
+    with self.test_session() as sess:
+      padded_tensor_out = sess.run(padded_tensor)
+    self.assertEqual((1, 4, 4, 1), padded_tensor_out.shape)
+
+
+class OpsTestPaddedOneHotEncoding(tf.test.TestCase):
+
+  def test_correct_one_hot_tensor_with_no_pad(self):
+    indices = tf.constant([1, 2, 3, 5])
+    one_hot_tensor = ops.padded_one_hot_encoding(indices, depth=6, left_pad=0)
+    expected_tensor = np.array([[0, 1, 0, 0, 0, 0],
+                                [0, 0, 1, 0, 0, 0],
+                                [0, 0, 0, 1, 0, 0],
+                                [0, 0, 0, 0, 0, 1]], np.float32)
+    with self.test_session() as sess:
+      out_one_hot_tensor = sess.run(one_hot_tensor)
+      self.assertAllClose(out_one_hot_tensor, expected_tensor, rtol=1e-10,
+                          atol=1e-10)
+
+  def test_correct_one_hot_tensor_with_pad_one(self):
+    indices = tf.constant([1, 2, 3, 5])
+    one_hot_tensor = ops.padded_one_hot_encoding(indices, depth=6, left_pad=1)
+    expected_tensor = np.array([[0, 0, 1, 0, 0, 0, 0],
+                                [0, 0, 0, 1, 0, 0, 0],
+                                [0, 0, 0, 0, 1, 0, 0],
+                                [0, 0, 0, 0, 0, 0, 1]], np.float32)
+    with self.test_session() as sess:
+      out_one_hot_tensor = sess.run(one_hot_tensor)
+      self.assertAllClose(out_one_hot_tensor, expected_tensor, rtol=1e-10,
+                          atol=1e-10)
+
+  def test_correct_one_hot_tensor_with_pad_three(self):
+    indices = tf.constant([1, 2, 3, 5])
+    one_hot_tensor = ops.padded_one_hot_encoding(indices, depth=6, left_pad=3)
+    expected_tensor = np.array([[0, 0, 0, 0, 1, 0, 0, 0, 0],
+                                [0, 0, 0, 0, 0, 1, 0, 0, 0],
+                                [0, 0, 0, 0, 0, 0, 1, 0, 0],
+                                [0, 0, 0, 0, 0, 0, 0, 0, 1]], np.float32)
+    with self.test_session() as sess:
+      out_one_hot_tensor = sess.run(one_hot_tensor)
+      self.assertAllClose(out_one_hot_tensor, expected_tensor, rtol=1e-10,
+                          atol=1e-10)
+
+  def test_correct_padded_one_hot_tensor_with_empty_indices(self):
+    depth = 6
+    pad = 2
+    indices = tf.constant([])
+    one_hot_tensor = ops.padded_one_hot_encoding(
+        indices, depth=depth, left_pad=pad)
+    expected_tensor = np.zeros((0, depth + pad))
+    with self.test_session() as sess:
+      out_one_hot_tensor = sess.run(one_hot_tensor)
+      self.assertAllClose(out_one_hot_tensor, expected_tensor, rtol=1e-10,
+                          atol=1e-10)
+
+  def test_return_none_on_zero_depth(self):
+    indices = tf.constant([1, 2, 3, 4, 5])
+    one_hot_tensor = ops.padded_one_hot_encoding(indices, depth=0, left_pad=2)
+    self.assertEqual(one_hot_tensor, None)
+
+  def test_raise_value_error_on_rank_two_input(self):
+    indices = tf.constant(1.0, shape=(2, 3))
+    with self.assertRaises(ValueError):
+      ops.padded_one_hot_encoding(indices, depth=6, left_pad=2)
+
+  def test_raise_value_error_on_negative_pad(self):
+    indices = tf.constant(1.0, shape=(2, 3))
+    with self.assertRaises(ValueError):
+      ops.padded_one_hot_encoding(indices, depth=6, left_pad=-1)
+
+  def test_raise_value_error_on_float_pad(self):
+    indices = tf.constant(1.0, shape=(2, 3))
+    with self.assertRaises(ValueError):
+      ops.padded_one_hot_encoding(indices, depth=6, left_pad=0.1)
+
+  def test_raise_value_error_on_float_depth(self):
+    indices = tf.constant(1.0, shape=(2, 3))
+    with self.assertRaises(ValueError):
+      ops.padded_one_hot_encoding(indices, depth=0.1, left_pad=2)
+
+
+class OpsDenseToSparseBoxesTest(tf.test.TestCase):
+
+  def test_return_all_boxes_when_all_input_boxes_are_valid(self):
+    num_classes = 4
+    num_valid_boxes = 3
+    code_size = 4
+    dense_location_placeholder = tf.placeholder(tf.float32,
+                                                shape=(num_valid_boxes,
+                                                       code_size))
+    dense_num_boxes_placeholder = tf.placeholder(tf.int32, shape=(num_classes))
+    box_locations, box_classes = ops.dense_to_sparse_boxes(
+        dense_location_placeholder, dense_num_boxes_placeholder, num_classes)
+    feed_dict = {dense_location_placeholder: np.random.uniform(
+        size=[num_valid_boxes, code_size]),
+                 dense_num_boxes_placeholder: np.array([1, 0, 0, 2],
+                                                       dtype=np.int32)}
+
+    expected_box_locations = feed_dict[dense_location_placeholder]
+    expected_box_classses = np.array([0, 3, 3])
+    with self.test_session() as sess:
+      box_locations, box_classes = sess.run([box_locations, box_classes],
+                                            feed_dict=feed_dict)
+
+    self.assertAllClose(box_locations, expected_box_locations, rtol=1e-6,
+                        atol=1e-6)
+    self.assertAllEqual(box_classes, expected_box_classses)
+
+  def test_return_only_valid_boxes_when_input_contains_invalid_boxes(self):
+    num_classes = 4
+    num_valid_boxes = 3
+    num_boxes = 10
+    code_size = 4
+
+    dense_location_placeholder = tf.placeholder(tf.float32, shape=(num_boxes,
+                                                                   code_size))
+    dense_num_boxes_placeholder = tf.placeholder(tf.int32, shape=(num_classes))
+    box_locations, box_classes = ops.dense_to_sparse_boxes(
+        dense_location_placeholder, dense_num_boxes_placeholder, num_classes)
+    feed_dict = {dense_location_placeholder: np.random.uniform(
+        size=[num_boxes, code_size]),
+                 dense_num_boxes_placeholder: np.array([1, 0, 0, 2],
+                                                       dtype=np.int32)}
+
+    expected_box_locations = (feed_dict[dense_location_placeholder]
+                              [:num_valid_boxes])
+    expected_box_classses = np.array([0, 3, 3])
+    with self.test_session() as sess:
+      box_locations, box_classes = sess.run([box_locations, box_classes],
+                                            feed_dict=feed_dict)
+
+    self.assertAllClose(box_locations, expected_box_locations, rtol=1e-6,
+                        atol=1e-6)
+    self.assertAllEqual(box_classes, expected_box_classses)
+
+
+class OpsTestIndicesToDenseVector(tf.test.TestCase):
+
+  def test_indices_to_dense_vector(self):
+    size = 10000
+    num_indices = np.random.randint(size)
+    rand_indices = np.random.permutation(np.arange(size))[0:num_indices]
+
+    expected_output = np.zeros(size, dtype=np.float32)
+    expected_output[rand_indices] = 1.
+
+    tf_rand_indices = tf.constant(rand_indices)
+    indicator = ops.indices_to_dense_vector(tf_rand_indices, size)
+
+    with self.test_session() as sess:
+      output = sess.run(indicator)
+      self.assertAllEqual(output, expected_output)
+      self.assertEqual(output.dtype, expected_output.dtype)
+
+  def test_indices_to_dense_vector_size_at_inference(self):
+    size = 5000
+    num_indices = 250
+    all_indices = np.arange(size)
+    rand_indices = np.random.permutation(all_indices)[0:num_indices]
+
+    expected_output = np.zeros(size, dtype=np.float32)
+    expected_output[rand_indices] = 1.
+
+    tf_all_indices = tf.placeholder(tf.int32)
+    tf_rand_indices = tf.constant(rand_indices)
+    indicator = ops.indices_to_dense_vector(tf_rand_indices,
+                                            tf.shape(tf_all_indices)[0])
+    feed_dict = {tf_all_indices: all_indices}
+
+    with self.test_session() as sess:
+      output = sess.run(indicator, feed_dict=feed_dict)
+      self.assertAllEqual(output, expected_output)
+      self.assertEqual(output.dtype, expected_output.dtype)
+
+  def test_indices_to_dense_vector_int(self):
+    size = 500
+    num_indices = 25
+    rand_indices = np.random.permutation(np.arange(size))[0:num_indices]
+
+    expected_output = np.zeros(size, dtype=np.int64)
+    expected_output[rand_indices] = 1
+
+    tf_rand_indices = tf.constant(rand_indices)
+    indicator = ops.indices_to_dense_vector(
+        tf_rand_indices, size, 1, dtype=tf.int64)
+
+    with self.test_session() as sess:
+      output = sess.run(indicator)
+      self.assertAllEqual(output, expected_output)
+      self.assertEqual(output.dtype, expected_output.dtype)
+
+  def test_indices_to_dense_vector_custom_values(self):
+    size = 100
+    num_indices = 10
+    rand_indices = np.random.permutation(np.arange(size))[0:num_indices]
+    indices_value = np.random.rand(1)
+    default_value = np.random.rand(1)
+
+    expected_output = np.float32(np.ones(size) * default_value)
+    expected_output[rand_indices] = indices_value
+
+    tf_rand_indices = tf.constant(rand_indices)
+    indicator = ops.indices_to_dense_vector(
+        tf_rand_indices,
+        size,
+        indices_value=indices_value,
+        default_value=default_value)
+
+    with self.test_session() as sess:
+      output = sess.run(indicator)
+      self.assertAllClose(output, expected_output)
+      self.assertEqual(output.dtype, expected_output.dtype)
+
+  def test_indices_to_dense_vector_all_indices_as_input(self):
+    size = 500
+    num_indices = 500
+    rand_indices = np.random.permutation(np.arange(size))[0:num_indices]
+
+    expected_output = np.ones(size, dtype=np.float32)
+
+    tf_rand_indices = tf.constant(rand_indices)
+    indicator = ops.indices_to_dense_vector(tf_rand_indices, size)
+
+    with self.test_session() as sess:
+      output = sess.run(indicator)
+      self.assertAllEqual(output, expected_output)
+      self.assertEqual(output.dtype, expected_output.dtype)
+
+  def test_indices_to_dense_vector_empty_indices_as_input(self):
+    size = 500
+    rand_indices = []
+
+    expected_output = np.zeros(size, dtype=np.float32)
+
+    tf_rand_indices = tf.constant(rand_indices)
+    indicator = ops.indices_to_dense_vector(tf_rand_indices, size)
+
+    with self.test_session() as sess:
+      output = sess.run(indicator)
+      self.assertAllEqual(output, expected_output)
+      self.assertEqual(output.dtype, expected_output.dtype)
+
+
+class GroundtruthFilterTest(tf.test.TestCase):
+
+  def test_filter_groundtruth(self):
+    input_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+    input_boxes = tf.placeholder(tf.float32, shape=(None, 4))
+    input_classes = tf.placeholder(tf.int32, shape=(None,))
+    input_is_crowd = tf.placeholder(tf.bool, shape=(None,))
+    input_area = tf.placeholder(tf.float32, shape=(None,))
+    input_difficult = tf.placeholder(tf.float32, shape=(None,))
+    input_label_types = tf.placeholder(tf.string, shape=(None,))
+    valid_indices = tf.placeholder(tf.int32, shape=(None,))
+    input_tensors = {
+        fields.InputDataFields.image: input_image,
+        fields.InputDataFields.groundtruth_boxes: input_boxes,
+        fields.InputDataFields.groundtruth_classes: input_classes,
+        fields.InputDataFields.groundtruth_is_crowd: input_is_crowd,
+        fields.InputDataFields.groundtruth_area: input_area,
+        fields.InputDataFields.groundtruth_difficult: input_difficult,
+        fields.InputDataFields.groundtruth_label_types: input_label_types
+    }
+    output_tensors = ops.retain_groundtruth(input_tensors, valid_indices)
+
+    image_tensor = np.random.rand(224, 224, 3)
+    feed_dict = {
+        input_image: image_tensor,
+        input_boxes:
+        np.array([[0.2, 0.4, 0.1, 0.8], [0.2, 0.4, 1.0, 0.8]], dtype=np.float),
+        input_classes:
+        np.array([1, 2], dtype=np.int32),
+        input_is_crowd:
+        np.array([False, True], dtype=np.bool),
+        input_area:
+        np.array([32, 48], dtype=np.float32),
+        input_difficult:
+        np.array([True, False], dtype=np.bool),
+        input_label_types:
+        np.array(['APPROPRIATE', 'INCORRECT'], dtype=np.string_),
+        valid_indices:
+        np.array([0], dtype=np.int32)
+    }
+    expected_tensors = {
+        fields.InputDataFields.image:
+        image_tensor,
+        fields.InputDataFields.groundtruth_boxes:
+        [[0.2, 0.4, 0.1, 0.8]],
+        fields.InputDataFields.groundtruth_classes:
+        [1],
+        fields.InputDataFields.groundtruth_is_crowd:
+        [False],
+        fields.InputDataFields.groundtruth_area:
+        [32],
+        fields.InputDataFields.groundtruth_difficult:
+        [True],
+        fields.InputDataFields.groundtruth_label_types:
+        ['APPROPRIATE']
+    }
+    with self.test_session() as sess:
+      output_tensors = sess.run(output_tensors, feed_dict=feed_dict)
+      for key in [fields.InputDataFields.image,
+                  fields.InputDataFields.groundtruth_boxes,
+                  fields.InputDataFields.groundtruth_area]:
+        self.assertAllClose(expected_tensors[key], output_tensors[key])
+      for key in [fields.InputDataFields.groundtruth_classes,
+                  fields.InputDataFields.groundtruth_is_crowd,
+                  fields.InputDataFields.groundtruth_label_types]:
+        self.assertAllEqual(expected_tensors[key], output_tensors[key])
+
+  def test_filter_with_missing_fields(self):
+    input_boxes = tf.placeholder(tf.float32, shape=(None, 4))
+    input_classes = tf.placeholder(tf.int32, shape=(None,))
+    input_tensors = {
+        fields.InputDataFields.groundtruth_boxes: input_boxes,
+        fields.InputDataFields.groundtruth_classes: input_classes
+    }
+    valid_indices = tf.placeholder(tf.int32, shape=(None,))
+
+    feed_dict = {
+        input_boxes:
+        np.array([[0.2, 0.4, 0.1, 0.8], [0.2, 0.4, 1.0, 0.8]], dtype=np.float),
+        input_classes:
+        np.array([1, 2], dtype=np.int32),
+        valid_indices:
+        np.array([0], dtype=np.int32)
+    }
+    expected_tensors = {
+        fields.InputDataFields.groundtruth_boxes:
+        [[0.2, 0.4, 0.1, 0.8]],
+        fields.InputDataFields.groundtruth_classes:
+        [1]
+    }
+
+    output_tensors = ops.retain_groundtruth(input_tensors, valid_indices)
+    with self.test_session() as sess:
+      output_tensors = sess.run(output_tensors, feed_dict=feed_dict)
+      for key in [fields.InputDataFields.groundtruth_boxes]:
+        self.assertAllClose(expected_tensors[key], output_tensors[key])
+      for key in [fields.InputDataFields.groundtruth_classes]:
+        self.assertAllEqual(expected_tensors[key], output_tensors[key])
+
+  def test_filter_with_empty_fields(self):
+    input_boxes = tf.placeholder(tf.float32, shape=(None, 4))
+    input_classes = tf.placeholder(tf.int32, shape=(None,))
+    input_is_crowd = tf.placeholder(tf.bool, shape=(None,))
+    input_area = tf.placeholder(tf.float32, shape=(None,))
+    input_difficult = tf.placeholder(tf.float32, shape=(None,))
+    valid_indices = tf.placeholder(tf.int32, shape=(None,))
+    input_tensors = {
+        fields.InputDataFields.groundtruth_boxes: input_boxes,
+        fields.InputDataFields.groundtruth_classes: input_classes,
+        fields.InputDataFields.groundtruth_is_crowd: input_is_crowd,
+        fields.InputDataFields.groundtruth_area: input_area,
+        fields.InputDataFields.groundtruth_difficult: input_difficult
+    }
+    output_tensors = ops.retain_groundtruth(input_tensors, valid_indices)
+
+    feed_dict = {
+        input_boxes:
+        np.array([[0.2, 0.4, 0.1, 0.8], [0.2, 0.4, 1.0, 0.8]], dtype=np.float),
+        input_classes:
+        np.array([1, 2], dtype=np.int32),
+        input_is_crowd:
+        np.array([False, True], dtype=np.bool),
+        input_area:
+        np.array([], dtype=np.float32),
+        input_difficult:
+        np.array([], dtype=np.float32),
+        valid_indices:
+        np.array([0], dtype=np.int32)
+    }
+    expected_tensors = {
+        fields.InputDataFields.groundtruth_boxes:
+        [[0.2, 0.4, 0.1, 0.8]],
+        fields.InputDataFields.groundtruth_classes:
+        [1],
+        fields.InputDataFields.groundtruth_is_crowd:
+        [False],
+        fields.InputDataFields.groundtruth_area:
+        [],
+        fields.InputDataFields.groundtruth_difficult:
+        []
+    }
+    with self.test_session() as sess:
+      output_tensors = sess.run(output_tensors, feed_dict=feed_dict)
+      for key in [fields.InputDataFields.groundtruth_boxes,
+                  fields.InputDataFields.groundtruth_area]:
+        self.assertAllClose(expected_tensors[key], output_tensors[key])
+      for key in [fields.InputDataFields.groundtruth_classes,
+                  fields.InputDataFields.groundtruth_is_crowd]:
+        self.assertAllEqual(expected_tensors[key], output_tensors[key])
+
+  def test_filter_with_empty_groundtruth_boxes(self):
+    input_boxes = tf.placeholder(tf.float32, shape=(None, 4))
+    input_classes = tf.placeholder(tf.int32, shape=(None,))
+    input_is_crowd = tf.placeholder(tf.bool, shape=(None,))
+    input_area = tf.placeholder(tf.float32, shape=(None,))
+    input_difficult = tf.placeholder(tf.float32, shape=(None,))
+    valid_indices = tf.placeholder(tf.int32, shape=(None,))
+    input_tensors = {
+        fields.InputDataFields.groundtruth_boxes: input_boxes,
+        fields.InputDataFields.groundtruth_classes: input_classes,
+        fields.InputDataFields.groundtruth_is_crowd: input_is_crowd,
+        fields.InputDataFields.groundtruth_area: input_area,
+        fields.InputDataFields.groundtruth_difficult: input_difficult
+    }
+    output_tensors = ops.retain_groundtruth(input_tensors, valid_indices)
+
+    feed_dict = {
+        input_boxes:
+        np.array([], dtype=np.float).reshape(0, 4),
+        input_classes:
+        np.array([], dtype=np.int32),
+        input_is_crowd:
+        np.array([], dtype=np.bool),
+        input_area:
+        np.array([], dtype=np.float32),
+        input_difficult:
+        np.array([], dtype=np.float32),
+        valid_indices:
+        np.array([], dtype=np.int32)
+    }
+    with self.test_session() as sess:
+      output_tensors = sess.run(output_tensors, feed_dict=feed_dict)
+      for key in input_tensors:
+        if key == fields.InputDataFields.groundtruth_boxes:
+          self.assertAllEqual([0, 4], output_tensors[key].shape)
+        else:
+          self.assertAllEqual([0], output_tensors[key].shape)
+
+
+class RetainGroundTruthWithPositiveClasses(tf.test.TestCase):
+
+  def test_filter_groundtruth_with_positive_classes(self):
+    input_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+    input_boxes = tf.placeholder(tf.float32, shape=(None, 4))
+    input_classes = tf.placeholder(tf.int32, shape=(None,))
+    input_is_crowd = tf.placeholder(tf.bool, shape=(None,))
+    input_area = tf.placeholder(tf.float32, shape=(None,))
+    input_difficult = tf.placeholder(tf.float32, shape=(None,))
+    input_label_types = tf.placeholder(tf.string, shape=(None,))
+    valid_indices = tf.placeholder(tf.int32, shape=(None,))
+    input_tensors = {
+        fields.InputDataFields.image: input_image,
+        fields.InputDataFields.groundtruth_boxes: input_boxes,
+        fields.InputDataFields.groundtruth_classes: input_classes,
+        fields.InputDataFields.groundtruth_is_crowd: input_is_crowd,
+        fields.InputDataFields.groundtruth_area: input_area,
+        fields.InputDataFields.groundtruth_difficult: input_difficult,
+        fields.InputDataFields.groundtruth_label_types: input_label_types
+    }
+    output_tensors = ops.retain_groundtruth_with_positive_classes(input_tensors)
+
+    image_tensor = np.random.rand(224, 224, 3)
+    feed_dict = {
+        input_image: image_tensor,
+        input_boxes:
+        np.array([[0.2, 0.4, 0.1, 0.8], [0.2, 0.4, 1.0, 0.8]], dtype=np.float),
+        input_classes:
+        np.array([1, 0], dtype=np.int32),
+        input_is_crowd:
+        np.array([False, True], dtype=np.bool),
+        input_area:
+        np.array([32, 48], dtype=np.float32),
+        input_difficult:
+        np.array([True, False], dtype=np.bool),
+        input_label_types:
+        np.array(['APPROPRIATE', 'INCORRECT'], dtype=np.string_),
+        valid_indices:
+        np.array([0], dtype=np.int32)
+    }
+    expected_tensors = {
+        fields.InputDataFields.image:
+        image_tensor,
+        fields.InputDataFields.groundtruth_boxes:
+        [[0.2, 0.4, 0.1, 0.8]],
+        fields.InputDataFields.groundtruth_classes:
+        [1],
+        fields.InputDataFields.groundtruth_is_crowd:
+        [False],
+        fields.InputDataFields.groundtruth_area:
+        [32],
+        fields.InputDataFields.groundtruth_difficult:
+        [True],
+        fields.InputDataFields.groundtruth_label_types:
+        ['APPROPRIATE']
+    }
+    with self.test_session() as sess:
+      output_tensors = sess.run(output_tensors, feed_dict=feed_dict)
+      for key in [fields.InputDataFields.image,
+                  fields.InputDataFields.groundtruth_boxes,
+                  fields.InputDataFields.groundtruth_area]:
+        self.assertAllClose(expected_tensors[key], output_tensors[key])
+      for key in [fields.InputDataFields.groundtruth_classes,
+                  fields.InputDataFields.groundtruth_is_crowd,
+                  fields.InputDataFields.groundtruth_label_types]:
+        self.assertAllEqual(expected_tensors[key], output_tensors[key])
+
+
+class GroundtruthFilterWithNanBoxTest(tf.test.TestCase):
+
+  def test_filter_groundtruth_with_nan_box_coordinates(self):
+    input_tensors = {
+        fields.InputDataFields.groundtruth_boxes:
+        [[np.nan, np.nan, np.nan, np.nan], [0.2, 0.4, 0.1, 0.8]],
+        fields.InputDataFields.groundtruth_classes:
+        [1, 2],
+        fields.InputDataFields.groundtruth_is_crowd:
+        [False, True],
+        fields.InputDataFields.groundtruth_area:
+        [100.0, 238.7]
+    }
+
+    expected_tensors = {
+        fields.InputDataFields.groundtruth_boxes:
+        [[0.2, 0.4, 0.1, 0.8]],
+        fields.InputDataFields.groundtruth_classes:
+        [2],
+        fields.InputDataFields.groundtruth_is_crowd:
+        [True],
+        fields.InputDataFields.groundtruth_area:
+        [238.7]
+    }
+
+    output_tensors = ops.filter_groundtruth_with_nan_box_coordinates(
+        input_tensors)
+    with self.test_session() as sess:
+      output_tensors = sess.run(output_tensors)
+      for key in [fields.InputDataFields.groundtruth_boxes,
+                  fields.InputDataFields.groundtruth_area]:
+        self.assertAllClose(expected_tensors[key], output_tensors[key])
+      for key in [fields.InputDataFields.groundtruth_classes,
+                  fields.InputDataFields.groundtruth_is_crowd]:
+        self.assertAllEqual(expected_tensors[key], output_tensors[key])
+
+
+class OpsTestNormalizeToTarget(tf.test.TestCase):
+
+  def test_create_normalize_to_target(self):
+    inputs = tf.random_uniform([5, 10, 12, 3])
+    target_norm_value = 4.0
+    dim = 3
+    with self.test_session():
+      output = ops.normalize_to_target(inputs, target_norm_value, dim)
+      self.assertEqual(output.op.name, 'NormalizeToTarget/mul')
+      var_name = tf.contrib.framework.get_variables()[0].name
+      self.assertEqual(var_name, 'NormalizeToTarget/weights:0')
+
+  def test_invalid_dim(self):
+    inputs = tf.random_uniform([5, 10, 12, 3])
+    target_norm_value = 4.0
+    dim = 10
+    with self.assertRaisesRegexp(
+        ValueError,
+        'dim must be non-negative but smaller than the input rank.'):
+      ops.normalize_to_target(inputs, target_norm_value, dim)
+
+  def test_invalid_target_norm_values(self):
+    inputs = tf.random_uniform([5, 10, 12, 3])
+    target_norm_value = [4.0, 4.0]
+    dim = 3
+    with self.assertRaisesRegexp(
+        ValueError, 'target_norm_value must be a float or a list of floats'):
+      ops.normalize_to_target(inputs, target_norm_value, dim)
+
+  def test_correct_output_shape(self):
+    inputs = tf.random_uniform([5, 10, 12, 3])
+    target_norm_value = 4.0
+    dim = 3
+    with self.test_session():
+      output = ops.normalize_to_target(inputs, target_norm_value, dim)
+      self.assertEqual(output.get_shape().as_list(),
+                       inputs.get_shape().as_list())
+
+  def test_correct_initial_output_values(self):
+    inputs = tf.constant([[[[3, 4], [7, 24]],
+                           [[5, -12], [-1, 0]]]], tf.float32)
+    target_norm_value = 10.0
+    dim = 3
+    expected_output = [[[[30/5.0, 40/5.0], [70/25.0, 240/25.0]],
+                        [[50/13.0, -120/13.0], [-10, 0]]]]
+    with self.test_session() as sess:
+      normalized_inputs = ops.normalize_to_target(inputs, target_norm_value,
+                                                  dim)
+      sess.run(tf.global_variables_initializer())
+      output = normalized_inputs.eval()
+      self.assertAllClose(output, expected_output)
+
+  def test_multiple_target_norm_values(self):
+    inputs = tf.constant([[[[3, 4], [7, 24]],
+                           [[5, -12], [-1, 0]]]], tf.float32)
+    target_norm_value = [10.0, 20.0]
+    dim = 3
+    expected_output = [[[[30/5.0, 80/5.0], [70/25.0, 480/25.0]],
+                        [[50/13.0, -240/13.0], [-10, 0]]]]
+    with self.test_session() as sess:
+      normalized_inputs = ops.normalize_to_target(inputs, target_norm_value,
+                                                  dim)
+      sess.run(tf.global_variables_initializer())
+      output = normalized_inputs.eval()
+      self.assertAllClose(output, expected_output)
+
+
+class OpsTestPositionSensitiveCropRegions(tf.test.TestCase):
+
+  def test_position_sensitive(self):
+    num_spatial_bins = [3, 2]
+    image_shape = [1, 3, 2, 6]
+
+    # First channel is 1's, second channel is 2's, etc.
+    image = tf.constant(range(1, 3 * 2 + 1) * 6, dtype=tf.float32,
+                        shape=image_shape)
+    boxes = tf.random_uniform((2, 4))
+    box_ind = tf.constant([0, 0], dtype=tf.int32)
+
+    # The result for both boxes should be [[1, 2], [3, 4], [5, 6]]
+    # before averaging.
+    expected_output = np.array([3.5, 3.5]).reshape([2, 1, 1, 1])
+
+    for crop_size_mult in range(1, 3):
+      crop_size = [3 * crop_size_mult, 2 * crop_size_mult]
+      ps_crop_and_pool = ops.position_sensitive_crop_regions(
+          image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=True)
+
+      with self.test_session() as sess:
+        output = sess.run(ps_crop_and_pool)
+        self.assertAllClose(output, expected_output)
+
+  def test_position_sensitive_with_equal_channels(self):
+    num_spatial_bins = [2, 2]
+    image_shape = [1, 3, 3, 4]
+    crop_size = [2, 2]
+
+    image = tf.constant(range(1, 3 * 3 + 1), dtype=tf.float32,
+                        shape=[1, 3, 3, 1])
+    tiled_image = tf.tile(image, [1, 1, 1, image_shape[3]])
+    boxes = tf.random_uniform((3, 4))
+    box_ind = tf.constant([0, 0, 0], dtype=tf.int32)
+
+    # All channels are equal so position-sensitive crop and resize should
+    # work as the usual crop and resize for just one channel.
+    crop = tf.image.crop_and_resize(image, boxes, box_ind, crop_size)
+    crop_and_pool = tf.reduce_mean(crop, [1, 2], keep_dims=True)
+
+    ps_crop_and_pool = ops.position_sensitive_crop_regions(
+        tiled_image,
+        boxes,
+        box_ind,
+        crop_size,
+        num_spatial_bins,
+        global_pool=True)
+
+    with self.test_session() as sess:
+      expected_output, output = sess.run((crop_and_pool, ps_crop_and_pool))
+      self.assertAllClose(output, expected_output)
+
+  def test_position_sensitive_with_single_bin(self):
+    num_spatial_bins = [1, 1]
+    image_shape = [2, 3, 3, 4]
+    crop_size = [2, 2]
+
+    image = tf.random_uniform(image_shape)
+    boxes = tf.random_uniform((6, 4))
+    box_ind = tf.constant([0, 0, 0, 1, 1, 1], dtype=tf.int32)
+
+    # When a single bin is used, position-sensitive crop and pool should be
+    # the same as non-position sensitive crop and pool.
+    crop = tf.image.crop_and_resize(image, boxes, box_ind, crop_size)
+    crop_and_pool = tf.reduce_mean(crop, [1, 2], keep_dims=True)
+
+    ps_crop_and_pool = ops.position_sensitive_crop_regions(
+        image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=True)
+
+    with self.test_session() as sess:
+      expected_output, output = sess.run((crop_and_pool, ps_crop_and_pool))
+      self.assertAllClose(output, expected_output)
+
+  def test_raise_value_error_on_num_bins_less_than_one(self):
+    num_spatial_bins = [1, -1]
+    image_shape = [1, 1, 1, 2]
+    crop_size = [2, 2]
+
+    image = tf.constant(1, dtype=tf.float32, shape=image_shape)
+    boxes = tf.constant([[0, 0, 1, 1]], dtype=tf.float32)
+    box_ind = tf.constant([0], dtype=tf.int32)
+
+    with self.assertRaisesRegexp(ValueError, 'num_spatial_bins should be >= 1'):
+      ops.position_sensitive_crop_regions(
+          image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=True)
+
+  def test_raise_value_error_on_non_divisible_crop_size(self):
+    num_spatial_bins = [2, 3]
+    image_shape = [1, 1, 1, 6]
+    crop_size = [3, 2]
+
+    image = tf.constant(1, dtype=tf.float32, shape=image_shape)
+    boxes = tf.constant([[0, 0, 1, 1]], dtype=tf.float32)
+    box_ind = tf.constant([0], dtype=tf.int32)
+
+    with self.assertRaisesRegexp(
+        ValueError, 'crop_size should be divisible by num_spatial_bins'):
+      ops.position_sensitive_crop_regions(
+          image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=True)
+
+  def test_raise_value_error_on_non_divisible_num_channels(self):
+    num_spatial_bins = [2, 2]
+    image_shape = [1, 1, 1, 5]
+    crop_size = [2, 2]
+
+    image = tf.constant(1, dtype=tf.float32, shape=image_shape)
+    boxes = tf.constant([[0, 0, 1, 1]], dtype=tf.float32)
+    box_ind = tf.constant([0], dtype=tf.int32)
+
+    with self.assertRaisesRegexp(
+        ValueError, 'Dimension size must be evenly divisible by 4 but is 5'):
+      ops.position_sensitive_crop_regions(
+          image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=True)
+
+  def test_position_sensitive_with_global_pool_false(self):
+    num_spatial_bins = [3, 2]
+    image_shape = [1, 3, 2, 6]
+    num_boxes = 2
+
+    # First channel is 1's, second channel is 2's, etc.
+    image = tf.constant(range(1, 3 * 2 + 1) * 6, dtype=tf.float32,
+                        shape=image_shape)
+    boxes = tf.random_uniform((num_boxes, 4))
+    box_ind = tf.constant([0, 0], dtype=tf.int32)
+
+    expected_output = []
+
+    # Expected output, when crop_size = [3, 2].
+    expected_output.append(np.expand_dims(
+        np.tile(np.array([[1, 2],
+                          [3, 4],
+                          [5, 6]]), (num_boxes, 1, 1)),
+        axis=-1))
+
+    # Expected output, when crop_size = [6, 4].
+    expected_output.append(np.expand_dims(
+        np.tile(np.array([[1, 1, 2, 2],
+                          [1, 1, 2, 2],
+                          [3, 3, 4, 4],
+                          [3, 3, 4, 4],
+                          [5, 5, 6, 6],
+                          [5, 5, 6, 6]]), (num_boxes, 1, 1)),
+        axis=-1))
+
+    for crop_size_mult in range(1, 3):
+      crop_size = [3 * crop_size_mult, 2 * crop_size_mult]
+      ps_crop = ops.position_sensitive_crop_regions(
+          image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=False)
+      with self.test_session() as sess:
+        output = sess.run(ps_crop)
+
+      self.assertAllEqual(output, expected_output[crop_size_mult - 1])
+
+  def test_position_sensitive_with_global_pool_false_and_known_boxes(self):
+    num_spatial_bins = [2, 2]
+    image_shape = [2, 2, 2, 4]
+    crop_size = [2, 2]
+
+    image = tf.constant(range(1, 2 * 2 * 4  + 1) * 2, dtype=tf.float32,
+                        shape=image_shape)
+
+    # First box contains whole image, and second box contains only first row.
+    boxes = tf.constant(np.array([[0., 0., 1., 1.],
+                                  [0., 0., 0.5, 1.]]), dtype=tf.float32)
+    box_ind = tf.constant([0, 1], dtype=tf.int32)
+
+    expected_output = []
+
+    # Expected output, when the box containing whole image.
+    expected_output.append(
+        np.reshape(np.array([[4, 7],
+                             [10, 13]]),
+                   (1, 2, 2, 1))
+    )
+
+    # Expected output, when the box containing only first row.
+    expected_output.append(
+        np.reshape(np.array([[3, 6],
+                             [7, 10]]),
+                   (1, 2, 2, 1))
+    )
+    expected_output = np.concatenate(expected_output, axis=0)
+
+    ps_crop = ops.position_sensitive_crop_regions(
+        image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=False)
+
+    with self.test_session() as sess:
+      output = sess.run(ps_crop)
+      self.assertAllEqual(output, expected_output)
+
+  def test_position_sensitive_with_global_pool_false_and_single_bin(self):
+    num_spatial_bins = [1, 1]
+    image_shape = [2, 3, 3, 4]
+    crop_size = [1, 1]
+
+    image = tf.random_uniform(image_shape)
+    boxes = tf.random_uniform((6, 4))
+    box_ind = tf.constant([0, 0, 0, 1, 1, 1], dtype=tf.int32)
+
+    # Since single_bin is used and crop_size = [1, 1] (i.e., no crop resize),
+    # the outputs are the same whatever the global_pool value is.
+    ps_crop_and_pool = ops.position_sensitive_crop_regions(
+        image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=True)
+    ps_crop = ops.position_sensitive_crop_regions(
+        image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=False)
+
+    with self.test_session() as sess:
+      pooled_output, unpooled_output = sess.run((ps_crop_and_pool, ps_crop))
+      self.assertAllClose(pooled_output, unpooled_output)
+
+  def test_position_sensitive_with_global_pool_false_and_do_global_pool(self):
+    num_spatial_bins = [3, 2]
+    image_shape = [1, 3, 2, 6]
+    num_boxes = 2
+
+    # First channel is 1's, second channel is 2's, etc.
+    image = tf.constant(range(1, 3 * 2 + 1) * 6, dtype=tf.float32,
+                        shape=image_shape)
+    boxes = tf.random_uniform((num_boxes, 4))
+    box_ind = tf.constant([0, 0], dtype=tf.int32)
+
+    expected_output = []
+
+    # Expected output, when crop_size = [3, 2].
+    expected_output.append(np.mean(
+        np.expand_dims(
+            np.tile(np.array([[1, 2],
+                              [3, 4],
+                              [5, 6]]), (num_boxes, 1, 1)),
+            axis=-1),
+        axis=(1, 2), keepdims=True))
+
+    # Expected output, when crop_size = [6, 4].
+    expected_output.append(np.mean(
+        np.expand_dims(
+            np.tile(np.array([[1, 1, 2, 2],
+                              [1, 1, 2, 2],
+                              [3, 3, 4, 4],
+                              [3, 3, 4, 4],
+                              [5, 5, 6, 6],
+                              [5, 5, 6, 6]]), (num_boxes, 1, 1)),
+            axis=-1),
+        axis=(1, 2), keepdims=True))
+
+    for crop_size_mult in range(1, 3):
+      crop_size = [3 * crop_size_mult, 2 * crop_size_mult]
+
+      # Perform global_pooling after running the function with
+      # global_pool=False.
+      ps_crop = ops.position_sensitive_crop_regions(
+          image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=False)
+      ps_crop_and_pool = tf.reduce_mean(
+          ps_crop, reduction_indices=(1, 2), keep_dims=True)
+
+      with self.test_session() as sess:
+        output = sess.run(ps_crop_and_pool)
+
+      self.assertAllEqual(output, expected_output[crop_size_mult - 1])
+
+  def test_raise_value_error_on_non_square_block_size(self):
+    num_spatial_bins = [3, 2]
+    image_shape = [1, 3, 2, 6]
+    crop_size = [6, 2]
+
+    image = tf.constant(1, dtype=tf.float32, shape=image_shape)
+    boxes = tf.constant([[0, 0, 1, 1]], dtype=tf.float32)
+    box_ind = tf.constant([0], dtype=tf.int32)
+
+    with self.assertRaisesRegexp(
+        ValueError, 'Only support square bin crop size for now.'):
+      ops.position_sensitive_crop_regions(
+          image, boxes, box_ind, crop_size, num_spatial_bins, global_pool=False)
+
+
+class ReframeBoxMasksToImageMasksTest(tf.test.TestCase):
+
+  def testZeroImageOnEmptyMask(self):
+    box_masks = tf.constant([[[0, 0],
+                              [0, 0]]], dtype=tf.float32)
+    boxes = tf.constant([[0.0, 0.0, 1.0, 1.0]], dtype=tf.float32)
+    image_masks = ops.reframe_box_masks_to_image_masks(box_masks, boxes,
+                                                       image_height=4,
+                                                       image_width=4)
+    np_expected_image_masks = np.array([[[0, 0, 0, 0],
+                                         [0, 0, 0, 0],
+                                         [0, 0, 0, 0],
+                                         [0, 0, 0, 0]]], dtype=np.float32)
+    with self.test_session() as sess:
+      np_image_masks = sess.run(image_masks)
+      self.assertAllClose(np_image_masks, np_expected_image_masks)
+
+  def testMaskIsCenteredInImageWhenBoxIsCentered(self):
+    box_masks = tf.constant([[[1, 1],
+                              [1, 1]]], dtype=tf.float32)
+    boxes = tf.constant([[0.25, 0.25, 0.75, 0.75]], dtype=tf.float32)
+    image_masks = ops.reframe_box_masks_to_image_masks(box_masks, boxes,
+                                                       image_height=4,
+                                                       image_width=4)
+    np_expected_image_masks = np.array([[[0, 0, 0, 0],
+                                         [0, 1, 1, 0],
+                                         [0, 1, 1, 0],
+                                         [0, 0, 0, 0]]], dtype=np.float32)
+    with self.test_session() as sess:
+      np_image_masks = sess.run(image_masks)
+      self.assertAllClose(np_image_masks, np_expected_image_masks)
+
+  def testMaskOffCenterRemainsOffCenterInImage(self):
+    box_masks = tf.constant([[[1, 0],
+                              [0, 1]]], dtype=tf.float32)
+    boxes = tf.constant([[0.25, 0.5, 0.75, 1.0]], dtype=tf.float32)
+    image_masks = ops.reframe_box_masks_to_image_masks(box_masks, boxes,
+                                                       image_height=4,
+                                                       image_width=4)
+    np_expected_image_masks = np.array([[[0, 0, 0, 0],
+                                         [0, 0, 0.6111111, 0.16666669],
+                                         [0, 0, 0.3888889, 0.83333337],
+                                         [0, 0, 0, 0]]], dtype=np.float32)
+    with self.test_session() as sess:
+      np_image_masks = sess.run(image_masks)
+      self.assertAllClose(np_image_masks, np_expected_image_masks)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/per_image_evaluation.py b/reconnaissance images/object_detection/utils/per_image_evaluation.py
new file mode 100644
index 0000000..ed39afa
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/per_image_evaluation.py	
@@ -0,0 +1,260 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Evaluate Object Detection result on a single image.
+
+Annotate each detected result as true positives or false positive according to
+a predefined IOU ratio. Non Maximum Supression is used by default. Multi class
+detection is supported by default.
+"""
+import numpy as np
+
+from object_detection.utils import np_box_list
+from object_detection.utils import np_box_list_ops
+
+
+class PerImageEvaluation(object):
+  """Evaluate detection result of a single image."""
+
+  def __init__(self,
+               num_groundtruth_classes,
+               matching_iou_threshold=0.5,
+               nms_iou_threshold=0.3,
+               nms_max_output_boxes=50):
+    """Initialized PerImageEvaluation by evaluation parameters.
+
+    Args:
+      num_groundtruth_classes: Number of ground truth object classes
+      matching_iou_threshold: A ratio of area intersection to union, which is
+          the threshold to consider whether a detection is true positive or not
+      nms_iou_threshold: IOU threshold used in Non Maximum Suppression.
+      nms_max_output_boxes: Number of maximum output boxes in NMS.
+    """
+    self.matching_iou_threshold = matching_iou_threshold
+    self.nms_iou_threshold = nms_iou_threshold
+    self.nms_max_output_boxes = nms_max_output_boxes
+    self.num_groundtruth_classes = num_groundtruth_classes
+
+  def compute_object_detection_metrics(self, detected_boxes, detected_scores,
+                                       detected_class_labels, groundtruth_boxes,
+                                       groundtruth_class_labels,
+                                       groundtruth_is_difficult_lists):
+    """Compute Object Detection related metrics from a single image.
+
+    Args:
+      detected_boxes: A float numpy array of shape [N, 4], representing N
+          regions of detected object regions.
+          Each row is of the format [y_min, x_min, y_max, x_max]
+      detected_scores: A float numpy array of shape [N, 1], representing
+          the confidence scores of the detected N object instances.
+      detected_class_labels: A integer numpy array of shape [N, 1], repreneting
+          the class labels of the detected N object instances.
+      groundtruth_boxes: A float numpy array of shape [M, 4], representing M
+          regions of object instances in ground truth
+      groundtruth_class_labels: An integer numpy array of shape [M, 1],
+          representing M class labels of object instances in ground truth
+      groundtruth_is_difficult_lists: A boolean numpy array of length M denoting
+          whether a ground truth box is a difficult instance or not
+
+    Returns:
+      scores: A list of C float numpy arrays. Each numpy array is of
+          shape [K, 1], representing K scores detected with object class
+          label c
+      tp_fp_labels: A list of C boolean numpy arrays. Each numpy array
+          is of shape [K, 1], representing K True/False positive label of
+          object instances detected with class label c
+      is_class_correctly_detected_in_image: a numpy integer array of
+          shape [C, 1], indicating whether the correponding class has a least
+          one instance being correctly detected in the image
+    """
+    detected_boxes, detected_scores, detected_class_labels = (
+        self._remove_invalid_boxes(detected_boxes, detected_scores,
+                                   detected_class_labels))
+    scores, tp_fp_labels = self._compute_tp_fp(
+        detected_boxes, detected_scores, detected_class_labels,
+        groundtruth_boxes, groundtruth_class_labels,
+        groundtruth_is_difficult_lists)
+    is_class_correctly_detected_in_image = self._compute_cor_loc(
+        detected_boxes, detected_scores, detected_class_labels,
+        groundtruth_boxes, groundtruth_class_labels)
+    return scores, tp_fp_labels, is_class_correctly_detected_in_image
+
+  def _compute_cor_loc(self, detected_boxes, detected_scores,
+                       detected_class_labels, groundtruth_boxes,
+                       groundtruth_class_labels):
+    """Compute CorLoc score for object detection result.
+
+    Args:
+      detected_boxes: A float numpy array of shape [N, 4], representing N
+          regions of detected object regions.
+          Each row is of the format [y_min, x_min, y_max, x_max]
+      detected_scores: A float numpy array of shape [N, 1], representing
+          the confidence scores of the detected N object instances.
+      detected_class_labels: A integer numpy array of shape [N, 1], repreneting
+          the class labels of the detected N object instances.
+      groundtruth_boxes: A float numpy array of shape [M, 4], representing M
+          regions of object instances in ground truth
+      groundtruth_class_labels: An integer numpy array of shape [M, 1],
+          representing M class labels of object instances in ground truth
+    Returns:
+      is_class_correctly_detected_in_image: a numpy integer array of
+          shape [C, 1], indicating whether the correponding class has a least
+          one instance being correctly detected in the image
+    """
+    is_class_correctly_detected_in_image = np.zeros(
+        self.num_groundtruth_classes, dtype=int)
+    for i in range(self.num_groundtruth_classes):
+      gt_boxes_at_ith_class = groundtruth_boxes[
+          groundtruth_class_labels == i, :]
+      detected_boxes_at_ith_class = detected_boxes[
+          detected_class_labels == i, :]
+      detected_scores_at_ith_class = detected_scores[detected_class_labels == i]
+      is_class_correctly_detected_in_image[i] = (
+          self._compute_is_aclass_correctly_detected_in_image(
+              detected_boxes_at_ith_class, detected_scores_at_ith_class,
+              gt_boxes_at_ith_class))
+
+    return is_class_correctly_detected_in_image
+
+  def _compute_is_aclass_correctly_detected_in_image(
+      self, detected_boxes, detected_scores, groundtruth_boxes):
+    """Compute CorLoc score for a single class.
+
+    Args:
+      detected_boxes: A numpy array of shape [N, 4] representing detected box
+          coordinates
+      detected_scores: A 1-d numpy array of length N representing classification
+          score
+      groundtruth_boxes: A numpy array of shape [M, 4] representing ground truth
+          box coordinates
+
+    Returns:
+      is_class_correctly_detected_in_image: An integer 1 or 0 denoting whether a
+          class is correctly detected in the image or not
+    """
+    if detected_boxes.size > 0:
+      if groundtruth_boxes.size > 0:
+        max_score_id = np.argmax(detected_scores)
+        detected_boxlist = np_box_list.BoxList(
+            np.expand_dims(detected_boxes[max_score_id, :], axis=0))
+        gt_boxlist = np_box_list.BoxList(groundtruth_boxes)
+        iou = np_box_list_ops.iou(detected_boxlist, gt_boxlist)
+        if np.max(iou) >= self.matching_iou_threshold:
+          return 1
+    return 0
+
+  def _compute_tp_fp(self, detected_boxes, detected_scores,
+                     detected_class_labels, groundtruth_boxes,
+                     groundtruth_class_labels, groundtruth_is_difficult_lists):
+    """Labels true/false positives of detections of an image across all classes.
+
+    Args:
+      detected_boxes: A float numpy array of shape [N, 4], representing N
+          regions of detected object regions.
+          Each row is of the format [y_min, x_min, y_max, x_max]
+      detected_scores: A float numpy array of shape [N, 1], representing
+          the confidence scores of the detected N object instances.
+      detected_class_labels: A integer numpy array of shape [N, 1], repreneting
+          the class labels of the detected N object instances.
+      groundtruth_boxes: A float numpy array of shape [M, 4], representing M
+          regions of object instances in ground truth
+      groundtruth_class_labels: An integer numpy array of shape [M, 1],
+          representing M class labels of object instances in ground truth
+      groundtruth_is_difficult_lists: A boolean numpy array of length M denoting
+          whether a ground truth box is a difficult instance or not
+
+    Returns:
+      result_scores: A list of float numpy arrays. Each numpy array is of
+          shape [K, 1], representing K scores detected with object class
+          label c
+      result_tp_fp_labels: A list of boolean numpy array. Each numpy array is of
+          shape [K, 1], representing K True/False positive label of object
+          instances detected with class label c
+    """
+    result_scores = []
+    result_tp_fp_labels = []
+    for i in range(self.num_groundtruth_classes):
+      gt_boxes_at_ith_class = groundtruth_boxes[(groundtruth_class_labels == i
+                                                ), :]
+      groundtruth_is_difficult_list_at_ith_class = (
+          groundtruth_is_difficult_lists[groundtruth_class_labels == i])
+      detected_boxes_at_ith_class = detected_boxes[(detected_class_labels == i
+                                                   ), :]
+      detected_scores_at_ith_class = detected_scores[detected_class_labels == i]
+      scores, tp_fp_labels = self._compute_tp_fp_for_single_class(
+          detected_boxes_at_ith_class, detected_scores_at_ith_class,
+          gt_boxes_at_ith_class, groundtruth_is_difficult_list_at_ith_class)
+      result_scores.append(scores)
+      result_tp_fp_labels.append(tp_fp_labels)
+    return result_scores, result_tp_fp_labels
+
+  def _remove_invalid_boxes(self, detected_boxes, detected_scores,
+                            detected_class_labels):
+    valid_indices = np.logical_and(detected_boxes[:, 0] < detected_boxes[:, 2],
+                                   detected_boxes[:, 1] < detected_boxes[:, 3])
+    return (detected_boxes[valid_indices, :], detected_scores[valid_indices],
+            detected_class_labels[valid_indices])
+
+  def _compute_tp_fp_for_single_class(self, detected_boxes, detected_scores,
+                                      groundtruth_boxes,
+                                      groundtruth_is_difficult_list):
+    """Labels boxes detected with the same class from the same image as tp/fp.
+
+    Args:
+      detected_boxes: A numpy array of shape [N, 4] representing detected box
+          coordinates
+      detected_scores: A 1-d numpy array of length N representing classification
+          score
+      groundtruth_boxes: A numpy array of shape [M, 4] representing ground truth
+          box coordinates
+      groundtruth_is_difficult_list: A boolean numpy array of length M denoting
+          whether a ground truth box is a difficult instance or not
+
+    Returns:
+      scores: A numpy array representing the detection scores
+      tp_fp_labels: a boolean numpy array indicating whether a detection is a
+      true positive.
+
+    """
+    if detected_boxes.size == 0:
+      return np.array([], dtype=float), np.array([], dtype=bool)
+    detected_boxlist = np_box_list.BoxList(detected_boxes)
+    detected_boxlist.add_field('scores', detected_scores)
+    detected_boxlist = np_box_list_ops.non_max_suppression(
+        detected_boxlist, self.nms_max_output_boxes, self.nms_iou_threshold)
+
+    scores = detected_boxlist.get_field('scores')
+
+    if groundtruth_boxes.size == 0:
+      return scores, np.zeros(detected_boxlist.num_boxes(), dtype=bool)
+    gt_boxlist = np_box_list.BoxList(groundtruth_boxes)
+
+    iou = np_box_list_ops.iou(detected_boxlist, gt_boxlist)
+    max_overlap_gt_ids = np.argmax(iou, axis=1)
+    is_gt_box_detected = np.zeros(gt_boxlist.num_boxes(), dtype=bool)
+    tp_fp_labels = np.zeros(detected_boxlist.num_boxes(), dtype=bool)
+    is_matched_to_difficult_box = np.zeros(
+        detected_boxlist.num_boxes(), dtype=bool)
+    for i in range(detected_boxlist.num_boxes()):
+      gt_id = max_overlap_gt_ids[i]
+      if iou[i, gt_id] >= self.matching_iou_threshold:
+        if not groundtruth_is_difficult_list[gt_id]:
+          if not is_gt_box_detected[gt_id]:
+            tp_fp_labels[i] = True
+            is_gt_box_detected[gt_id] = True
+        else:
+          is_matched_to_difficult_box[i] = True
+    return scores[~is_matched_to_difficult_box], tp_fp_labels[
+        ~is_matched_to_difficult_box]
diff --git a/reconnaissance images/object_detection/utils/per_image_evaluation_test.py b/reconnaissance images/object_detection/utils/per_image_evaluation_test.py
new file mode 100644
index 0000000..8c449f1
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/per_image_evaluation_test.py	
@@ -0,0 +1,212 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.per_image_evaluation."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.utils import per_image_evaluation
+
+
+class SingleClassTpFpWithDifficultBoxesTest(tf.test.TestCase):
+
+  def setUp(self):
+    num_groundtruth_classes = 1
+    matching_iou_threshold = 0.5
+    nms_iou_threshold = 1.0
+    nms_max_output_boxes = 10000
+    self.eval = per_image_evaluation.PerImageEvaluation(
+        num_groundtruth_classes, matching_iou_threshold, nms_iou_threshold,
+        nms_max_output_boxes)
+
+    self.detected_boxes = np.array([[0, 0, 1, 1], [0, 0, 2, 2], [0, 0, 3, 3]],
+                                   dtype=float)
+    self.detected_scores = np.array([0.6, 0.8, 0.5], dtype=float)
+    self.groundtruth_boxes = np.array([[0, 0, 1, 1], [0, 0, 10, 10]],
+                                      dtype=float)
+
+  def test_match_to_not_difficult_box(self):
+    groundtruth_groundtruth_is_difficult_list = np.array([False, True],
+                                                         dtype=bool)
+    scores, tp_fp_labels = self.eval._compute_tp_fp_for_single_class(
+        self.detected_boxes, self.detected_scores, self.groundtruth_boxes,
+        groundtruth_groundtruth_is_difficult_list)
+    expected_scores = np.array([0.8, 0.6, 0.5], dtype=float)
+    expected_tp_fp_labels = np.array([False, True, False], dtype=bool)
+    self.assertTrue(np.allclose(expected_scores, scores))
+    self.assertTrue(np.allclose(expected_tp_fp_labels, tp_fp_labels))
+
+  def test_match_to_difficult_box(self):
+    groundtruth_groundtruth_is_difficult_list = np.array([True, False],
+                                                         dtype=bool)
+    scores, tp_fp_labels = self.eval._compute_tp_fp_for_single_class(
+        self.detected_boxes, self.detected_scores, self.groundtruth_boxes,
+        groundtruth_groundtruth_is_difficult_list)
+    expected_scores = np.array([0.8, 0.5], dtype=float)
+    expected_tp_fp_labels = np.array([False, False], dtype=bool)
+    self.assertTrue(np.allclose(expected_scores, scores))
+    self.assertTrue(np.allclose(expected_tp_fp_labels, tp_fp_labels))
+
+
+class SingleClassTpFpNoDifficultBoxesTest(tf.test.TestCase):
+
+  def setUp(self):
+    num_groundtruth_classes = 1
+    matching_iou_threshold1 = 0.5
+    matching_iou_threshold2 = 0.1
+    nms_iou_threshold = 1.0
+    nms_max_output_boxes = 10000
+    self.eval1 = per_image_evaluation.PerImageEvaluation(
+        num_groundtruth_classes, matching_iou_threshold1, nms_iou_threshold,
+        nms_max_output_boxes)
+
+    self.eval2 = per_image_evaluation.PerImageEvaluation(
+        num_groundtruth_classes, matching_iou_threshold2, nms_iou_threshold,
+        nms_max_output_boxes)
+
+    self.detected_boxes = np.array([[0, 0, 1, 1], [0, 0, 2, 2], [0, 0, 3, 3]],
+                                   dtype=float)
+    self.detected_scores = np.array([0.6, 0.8, 0.5], dtype=float)
+
+  def test_no_true_positives(self):
+    groundtruth_boxes = np.array([[100, 100, 105, 105]], dtype=float)
+    groundtruth_groundtruth_is_difficult_list = np.zeros(1, dtype=bool)
+    scores, tp_fp_labels = self.eval1._compute_tp_fp_for_single_class(
+        self.detected_boxes, self.detected_scores, groundtruth_boxes,
+        groundtruth_groundtruth_is_difficult_list)
+    expected_scores = np.array([0.8, 0.6, 0.5], dtype=float)
+    expected_tp_fp_labels = np.array([False, False, False], dtype=bool)
+    self.assertTrue(np.allclose(expected_scores, scores))
+    self.assertTrue(np.allclose(expected_tp_fp_labels, tp_fp_labels))
+
+  def test_one_true_positives_with_large_iou_threshold(self):
+    groundtruth_boxes = np.array([[0, 0, 1, 1]], dtype=float)
+    groundtruth_groundtruth_is_difficult_list = np.zeros(1, dtype=bool)
+    scores, tp_fp_labels = self.eval1._compute_tp_fp_for_single_class(
+        self.detected_boxes, self.detected_scores, groundtruth_boxes,
+        groundtruth_groundtruth_is_difficult_list)
+    expected_scores = np.array([0.8, 0.6, 0.5], dtype=float)
+    expected_tp_fp_labels = np.array([False, True, False], dtype=bool)
+    self.assertTrue(np.allclose(expected_scores, scores))
+    self.assertTrue(np.allclose(expected_tp_fp_labels, tp_fp_labels))
+
+  def test_one_true_positives_with_very_small_iou_threshold(self):
+    groundtruth_boxes = np.array([[0, 0, 1, 1]], dtype=float)
+    groundtruth_groundtruth_is_difficult_list = np.zeros(1, dtype=bool)
+    scores, tp_fp_labels = self.eval2._compute_tp_fp_for_single_class(
+        self.detected_boxes, self.detected_scores, groundtruth_boxes,
+        groundtruth_groundtruth_is_difficult_list)
+    expected_scores = np.array([0.8, 0.6, 0.5], dtype=float)
+    expected_tp_fp_labels = np.array([True, False, False], dtype=bool)
+    self.assertTrue(np.allclose(expected_scores, scores))
+    self.assertTrue(np.allclose(expected_tp_fp_labels, tp_fp_labels))
+
+  def test_two_true_positives_with_large_iou_threshold(self):
+    groundtruth_boxes = np.array([[0, 0, 1, 1], [0, 0, 3.5, 3.5]], dtype=float)
+    groundtruth_groundtruth_is_difficult_list = np.zeros(2, dtype=bool)
+    scores, tp_fp_labels = self.eval1._compute_tp_fp_for_single_class(
+        self.detected_boxes, self.detected_scores, groundtruth_boxes,
+        groundtruth_groundtruth_is_difficult_list)
+    expected_scores = np.array([0.8, 0.6, 0.5], dtype=float)
+    expected_tp_fp_labels = np.array([False, True, True], dtype=bool)
+    self.assertTrue(np.allclose(expected_scores, scores))
+    self.assertTrue(np.allclose(expected_tp_fp_labels, tp_fp_labels))
+
+
+class MultiClassesTpFpTest(tf.test.TestCase):
+
+  def test_tp_fp(self):
+    num_groundtruth_classes = 3
+    matching_iou_threshold = 0.5
+    nms_iou_threshold = 1.0
+    nms_max_output_boxes = 10000
+    eval1 = per_image_evaluation.PerImageEvaluation(num_groundtruth_classes,
+                                                    matching_iou_threshold,
+                                                    nms_iou_threshold,
+                                                    nms_max_output_boxes)
+    detected_boxes = np.array([[0, 0, 1, 1], [10, 10, 5, 5], [0, 0, 2, 2],
+                               [5, 10, 10, 5], [10, 5, 5, 10], [0, 0, 3, 3]],
+                              dtype=float)
+    detected_scores = np.array([0.8, 0.1, 0.8, 0.9, 0.7, 0.8], dtype=float)
+    detected_class_labels = np.array([0, 1, 1, 2, 0, 2], dtype=int)
+    groundtruth_boxes = np.array([[0, 0, 1, 1], [0, 0, 3.5, 3.5]], dtype=float)
+    groundtruth_class_labels = np.array([0, 2], dtype=int)
+    groundtruth_groundtruth_is_difficult_list = np.zeros(2, dtype=float)
+    scores, tp_fp_labels, _ = eval1.compute_object_detection_metrics(
+        detected_boxes, detected_scores, detected_class_labels,
+        groundtruth_boxes, groundtruth_class_labels,
+        groundtruth_groundtruth_is_difficult_list)
+    expected_scores = [np.array([0.8], dtype=float)] * 3
+    expected_tp_fp_labels = [np.array([True]), np.array([False]), np.array([True
+                                                                           ])]
+    for i in range(len(expected_scores)):
+      self.assertTrue(np.allclose(expected_scores[i], scores[i]))
+      self.assertTrue(np.array_equal(expected_tp_fp_labels[i], tp_fp_labels[i]))
+
+
+class CorLocTest(tf.test.TestCase):
+
+  def test_compute_corloc_with_normal_iou_threshold(self):
+    num_groundtruth_classes = 3
+    matching_iou_threshold = 0.5
+    nms_iou_threshold = 1.0
+    nms_max_output_boxes = 10000
+    eval1 = per_image_evaluation.PerImageEvaluation(num_groundtruth_classes,
+                                                    matching_iou_threshold,
+                                                    nms_iou_threshold,
+                                                    nms_max_output_boxes)
+    detected_boxes = np.array([[0, 0, 1, 1], [0, 0, 2, 2], [0, 0, 3, 3],
+                               [0, 0, 5, 5]], dtype=float)
+    detected_scores = np.array([0.9, 0.9, 0.1, 0.9], dtype=float)
+    detected_class_labels = np.array([0, 1, 0, 2], dtype=int)
+    groundtruth_boxes = np.array([[0, 0, 1, 1], [0, 0, 3, 3], [0, 0, 6, 6]],
+                                 dtype=float)
+    groundtruth_class_labels = np.array([0, 0, 2], dtype=int)
+
+    is_class_correctly_detected_in_image = eval1._compute_cor_loc(
+        detected_boxes, detected_scores, detected_class_labels,
+        groundtruth_boxes, groundtruth_class_labels)
+    expected_result = np.array([1, 0, 1], dtype=int)
+    self.assertTrue(np.array_equal(expected_result,
+                                   is_class_correctly_detected_in_image))
+
+  def test_compute_corloc_with_very_large_iou_threshold(self):
+    num_groundtruth_classes = 3
+    matching_iou_threshold = 0.9
+    nms_iou_threshold = 1.0
+    nms_max_output_boxes = 10000
+    eval1 = per_image_evaluation.PerImageEvaluation(num_groundtruth_classes,
+                                                    matching_iou_threshold,
+                                                    nms_iou_threshold,
+                                                    nms_max_output_boxes)
+    detected_boxes = np.array([[0, 0, 1, 1], [0, 0, 2, 2], [0, 0, 3, 3],
+                               [0, 0, 5, 5]], dtype=float)
+    detected_scores = np.array([0.9, 0.9, 0.1, 0.9], dtype=float)
+    detected_class_labels = np.array([0, 1, 0, 2], dtype=int)
+    groundtruth_boxes = np.array([[0, 0, 1, 1], [0, 0, 3, 3], [0, 0, 6, 6]],
+                                 dtype=float)
+    groundtruth_class_labels = np.array([0, 0, 2], dtype=int)
+
+    is_class_correctly_detected_in_image = eval1._compute_cor_loc(
+        detected_boxes, detected_scores, detected_class_labels,
+        groundtruth_boxes, groundtruth_class_labels)
+    expected_result = np.array([1, 0, 0], dtype=int)
+    self.assertTrue(np.array_equal(expected_result,
+                                   is_class_correctly_detected_in_image))
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/shape_utils.py b/reconnaissance images/object_detection/utils/shape_utils.py
new file mode 100644
index 0000000..880d367
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/shape_utils.py	
@@ -0,0 +1,136 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Utils used to manipulate tensor shapes."""
+
+import tensorflow as tf
+
+
+def _is_tensor(t):
+  """Returns a boolean indicating whether the input is a tensor.
+
+  Args:
+    t: the input to be tested.
+
+  Returns:
+    a boolean that indicates whether t is a tensor.
+  """
+  return isinstance(t, (tf.Tensor, tf.SparseTensor, tf.Variable))
+
+
+def _set_dim_0(t, d0):
+  """Sets the 0-th dimension of the input tensor.
+
+  Args:
+    t: the input tensor, assuming the rank is at least 1.
+    d0: an integer indicating the 0-th dimension of the input tensor.
+
+  Returns:
+    the tensor t with the 0-th dimension set.
+  """
+  t_shape = t.get_shape().as_list()
+  t_shape[0] = d0
+  t.set_shape(t_shape)
+  return t
+
+
+def pad_tensor(t, length):
+  """Pads the input tensor with 0s along the first dimension up to the length.
+
+  Args:
+    t: the input tensor, assuming the rank is at least 1.
+    length: a tensor of shape [1]  or an integer, indicating the first dimension
+      of the input tensor t after padding, assuming length <= t.shape[0].
+
+  Returns:
+    padded_t: the padded tensor, whose first dimension is length. If the length
+      is an integer, the first dimension of padded_t is set to length
+      statically.
+  """
+  t_rank = tf.rank(t)
+  t_shape = tf.shape(t)
+  t_d0 = t_shape[0]
+  pad_d0 = tf.expand_dims(length - t_d0, 0)
+  pad_shape = tf.cond(
+      tf.greater(t_rank, 1), lambda: tf.concat([pad_d0, t_shape[1:]], 0),
+      lambda: tf.expand_dims(length - t_d0, 0))
+  padded_t = tf.concat([t, tf.zeros(pad_shape, dtype=t.dtype)], 0)
+  if not _is_tensor(length):
+    padded_t = _set_dim_0(padded_t, length)
+  return padded_t
+
+
+def clip_tensor(t, length):
+  """Clips the input tensor along the first dimension up to the length.
+
+  Args:
+    t: the input tensor, assuming the rank is at least 1.
+    length: a tensor of shape [1]  or an integer, indicating the first dimension
+      of the input tensor t after clipping, assuming length <= t.shape[0].
+
+  Returns:
+    clipped_t: the clipped tensor, whose first dimension is length. If the
+      length is an integer, the first dimension of clipped_t is set to length
+      statically.
+  """
+  clipped_t = tf.gather(t, tf.range(length))
+  if not _is_tensor(length):
+    clipped_t = _set_dim_0(clipped_t, length)
+  return clipped_t
+
+
+def pad_or_clip_tensor(t, length):
+  """Pad or clip the input tensor along the first dimension.
+
+  Args:
+    t: the input tensor, assuming the rank is at least 1.
+    length: a tensor of shape [1]  or an integer, indicating the first dimension
+      of the input tensor t after processing.
+
+  Returns:
+    processed_t: the processed tensor, whose first dimension is length. If the
+      length is an integer, the first dimension of the processed tensor is set
+      to length statically.
+  """
+  processed_t = tf.cond(
+      tf.greater(tf.shape(t)[0], length),
+      lambda: clip_tensor(t, length),
+      lambda: pad_tensor(t, length))
+  if not _is_tensor(length):
+    processed_t = _set_dim_0(processed_t, length)
+  return processed_t
+
+
+def combined_static_and_dynamic_shape(tensor):
+  """Returns a list containing static and dynamic values for the dimensions.
+
+  Returns a list of static and dynamic values for shape dimensions. This is
+  useful to preserve static shapes when available in reshape operation.
+
+  Args:
+    tensor: A tensor of any type.
+
+  Returns:
+    A list of size tensor.shape.ndims containing integers or a scalar tensor.
+  """
+  static_shape = tensor.shape.as_list()
+  dynamic_shape = tf.shape(tensor)
+  combined_shape = []
+  for index, dim in enumerate(static_shape):
+    if dim is not None:
+      combined_shape.append(dim)
+    else:
+      combined_shape.append(dynamic_shape[index])
+  return combined_shape
diff --git a/reconnaissance images/object_detection/utils/shape_utils_test.py b/reconnaissance images/object_detection/utils/shape_utils_test.py
new file mode 100644
index 0000000..abeacac
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/shape_utils_test.py	
@@ -0,0 +1,127 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.shape_utils."""
+
+import tensorflow as tf
+
+from object_detection.utils import shape_utils
+
+
+class UtilTest(tf.test.TestCase):
+
+  def test_pad_tensor_using_integer_input(self):
+    t1 = tf.constant([1], dtype=tf.int32)
+    pad_t1 = shape_utils.pad_tensor(t1, 2)
+    t2 = tf.constant([[0.1, 0.2]], dtype=tf.float32)
+    pad_t2 = shape_utils.pad_tensor(t2, 2)
+
+    self.assertEqual(2, pad_t1.get_shape()[0])
+    self.assertEqual(2, pad_t2.get_shape()[0])
+
+    with self.test_session() as sess:
+      pad_t1_result, pad_t2_result = sess.run([pad_t1, pad_t2])
+      self.assertAllEqual([1, 0], pad_t1_result)
+      self.assertAllClose([[0.1, 0.2], [0, 0]], pad_t2_result)
+
+  def test_pad_tensor_using_tensor_input(self):
+    t1 = tf.constant([1], dtype=tf.int32)
+    pad_t1 = shape_utils.pad_tensor(t1, tf.constant(2))
+    t2 = tf.constant([[0.1, 0.2]], dtype=tf.float32)
+    pad_t2 = shape_utils.pad_tensor(t2, tf.constant(2))
+
+    with self.test_session() as sess:
+      pad_t1_result, pad_t2_result = sess.run([pad_t1, pad_t2])
+      self.assertAllEqual([1, 0], pad_t1_result)
+      self.assertAllClose([[0.1, 0.2], [0, 0]], pad_t2_result)
+
+  def test_clip_tensor_using_integer_input(self):
+    t1 = tf.constant([1, 2, 3], dtype=tf.int32)
+    clip_t1 = shape_utils.clip_tensor(t1, 2)
+    t2 = tf.constant([[0.1, 0.2], [0.2, 0.4], [0.5, 0.8]], dtype=tf.float32)
+    clip_t2 = shape_utils.clip_tensor(t2, 2)
+
+    self.assertEqual(2, clip_t1.get_shape()[0])
+    self.assertEqual(2, clip_t2.get_shape()[0])
+
+    with self.test_session() as sess:
+      clip_t1_result, clip_t2_result = sess.run([clip_t1, clip_t2])
+      self.assertAllEqual([1, 2], clip_t1_result)
+      self.assertAllClose([[0.1, 0.2], [0.2, 0.4]], clip_t2_result)
+
+  def test_clip_tensor_using_tensor_input(self):
+    t1 = tf.constant([1, 2, 3], dtype=tf.int32)
+    clip_t1 = shape_utils.clip_tensor(t1, tf.constant(2))
+    t2 = tf.constant([[0.1, 0.2], [0.2, 0.4], [0.5, 0.8]], dtype=tf.float32)
+    clip_t2 = shape_utils.clip_tensor(t2, tf.constant(2))
+
+    with self.test_session() as sess:
+      clip_t1_result, clip_t2_result = sess.run([clip_t1, clip_t2])
+      self.assertAllEqual([1, 2], clip_t1_result)
+      self.assertAllClose([[0.1, 0.2], [0.2, 0.4]], clip_t2_result)
+
+  def test_pad_or_clip_tensor_using_integer_input(self):
+    t1 = tf.constant([1], dtype=tf.int32)
+    tt1 = shape_utils.pad_or_clip_tensor(t1, 2)
+    t2 = tf.constant([[0.1, 0.2]], dtype=tf.float32)
+    tt2 = shape_utils.pad_or_clip_tensor(t2, 2)
+
+    t3 = tf.constant([1, 2, 3], dtype=tf.int32)
+    tt3 = shape_utils.clip_tensor(t3, 2)
+    t4 = tf.constant([[0.1, 0.2], [0.2, 0.4], [0.5, 0.8]], dtype=tf.float32)
+    tt4 = shape_utils.clip_tensor(t4, 2)
+
+    self.assertEqual(2, tt1.get_shape()[0])
+    self.assertEqual(2, tt2.get_shape()[0])
+    self.assertEqual(2, tt3.get_shape()[0])
+    self.assertEqual(2, tt4.get_shape()[0])
+
+    with self.test_session() as sess:
+      tt1_result, tt2_result, tt3_result, tt4_result = sess.run(
+          [tt1, tt2, tt3, tt4])
+      self.assertAllEqual([1, 0], tt1_result)
+      self.assertAllClose([[0.1, 0.2], [0, 0]], tt2_result)
+      self.assertAllEqual([1, 2], tt3_result)
+      self.assertAllClose([[0.1, 0.2], [0.2, 0.4]], tt4_result)
+
+  def test_pad_or_clip_tensor_using_tensor_input(self):
+    t1 = tf.constant([1], dtype=tf.int32)
+    tt1 = shape_utils.pad_or_clip_tensor(t1, tf.constant(2))
+    t2 = tf.constant([[0.1, 0.2]], dtype=tf.float32)
+    tt2 = shape_utils.pad_or_clip_tensor(t2, tf.constant(2))
+
+    t3 = tf.constant([1, 2, 3], dtype=tf.int32)
+    tt3 = shape_utils.clip_tensor(t3, tf.constant(2))
+    t4 = tf.constant([[0.1, 0.2], [0.2, 0.4], [0.5, 0.8]], dtype=tf.float32)
+    tt4 = shape_utils.clip_tensor(t4, tf.constant(2))
+
+    with self.test_session() as sess:
+      tt1_result, tt2_result, tt3_result, tt4_result = sess.run(
+          [tt1, tt2, tt3, tt4])
+      self.assertAllEqual([1, 0], tt1_result)
+      self.assertAllClose([[0.1, 0.2], [0, 0]], tt2_result)
+      self.assertAllEqual([1, 2], tt3_result)
+      self.assertAllClose([[0.1, 0.2], [0.2, 0.4]], tt4_result)
+
+  def test_combines_static_dynamic_shape(self):
+    tensor = tf.placeholder(tf.float32, shape=(None, 2, 3))
+    combined_shape = shape_utils.combined_static_and_dynamic_shape(
+        tensor)
+    self.assertTrue(tf.contrib.framework.is_tensor(combined_shape[0]))
+    self.assertListEqual(combined_shape[1:], [2, 3])
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/static_shape.py b/reconnaissance images/object_detection/utils/static_shape.py
new file mode 100644
index 0000000..8e4e522
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/static_shape.py	
@@ -0,0 +1,71 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Helper functions to access TensorShape values.
+
+The rank 4 tensor_shape must be of the form [batch_size, height, width, depth].
+"""
+
+
+def get_batch_size(tensor_shape):
+  """Returns batch size from the tensor shape.
+
+  Args:
+    tensor_shape: A rank 4 TensorShape.
+
+  Returns:
+    An integer representing the batch size of the tensor.
+  """
+  tensor_shape.assert_has_rank(rank=4)
+  return tensor_shape[0].value
+
+
+def get_height(tensor_shape):
+  """Returns height from the tensor shape.
+
+  Args:
+    tensor_shape: A rank 4 TensorShape.
+
+  Returns:
+    An integer representing the height of the tensor.
+  """
+  tensor_shape.assert_has_rank(rank=4)
+  return tensor_shape[1].value
+
+
+def get_width(tensor_shape):
+  """Returns width from the tensor shape.
+
+  Args:
+    tensor_shape: A rank 4 TensorShape.
+
+  Returns:
+    An integer representing the width of the tensor.
+  """
+  tensor_shape.assert_has_rank(rank=4)
+  return tensor_shape[2].value
+
+
+def get_depth(tensor_shape):
+  """Returns depth from the tensor shape.
+
+  Args:
+    tensor_shape: A rank 4 TensorShape.
+
+  Returns:
+    An integer representing the depth of the tensor.
+  """
+  tensor_shape.assert_has_rank(rank=4)
+  return tensor_shape[3].value
diff --git a/reconnaissance images/object_detection/utils/static_shape_test.py b/reconnaissance images/object_detection/utils/static_shape_test.py
new file mode 100644
index 0000000..99307e9
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/static_shape_test.py	
@@ -0,0 +1,50 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.static_shape."""
+
+import tensorflow as tf
+
+from object_detection.utils import static_shape
+
+
+class StaticShapeTest(tf.test.TestCase):
+
+  def test_return_correct_batchSize(self):
+    tensor_shape = tf.TensorShape(dims=[32, 299, 384, 3])
+    self.assertEqual(32, static_shape.get_batch_size(tensor_shape))
+
+  def test_return_correct_height(self):
+    tensor_shape = tf.TensorShape(dims=[32, 299, 384, 3])
+    self.assertEqual(299, static_shape.get_height(tensor_shape))
+
+  def test_return_correct_width(self):
+    tensor_shape = tf.TensorShape(dims=[32, 299, 384, 3])
+    self.assertEqual(384, static_shape.get_width(tensor_shape))
+
+  def test_return_correct_depth(self):
+    tensor_shape = tf.TensorShape(dims=[32, 299, 384, 3])
+    self.assertEqual(3, static_shape.get_depth(tensor_shape))
+
+  def test_die_on_tensor_shape_with_rank_three(self):
+    tensor_shape = tf.TensorShape(dims=[32, 299, 384])
+    with self.assertRaises(ValueError):
+      static_shape.get_batch_size(tensor_shape)
+      static_shape.get_height(tensor_shape)
+      static_shape.get_width(tensor_shape)
+      static_shape.get_depth(tensor_shape)
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/test_utils.py b/reconnaissance images/object_detection/utils/test_utils.py
new file mode 100644
index 0000000..e6277ea
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/test_utils.py	
@@ -0,0 +1,139 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Contains functions which are convenient for unit testing."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import anchor_generator
+from object_detection.core import box_coder
+from object_detection.core import box_list
+from object_detection.core import box_predictor
+from object_detection.core import matcher
+from object_detection.utils import shape_utils
+
+
+class MockBoxCoder(box_coder.BoxCoder):
+  """Simple `difference` BoxCoder."""
+
+  @property
+  def code_size(self):
+    return 4
+
+  def _encode(self, boxes, anchors):
+    return boxes.get() - anchors.get()
+
+  def _decode(self, rel_codes, anchors):
+    return box_list.BoxList(rel_codes + anchors.get())
+
+
+class MockBoxPredictor(box_predictor.BoxPredictor):
+  """Simple box predictor that ignores inputs and outputs all zeros."""
+
+  def __init__(self, is_training, num_classes):
+    super(MockBoxPredictor, self).__init__(is_training, num_classes)
+
+  def _predict(self, image_features, num_predictions_per_location):
+    combined_feature_shape = shape_utils.combined_static_and_dynamic_shape(
+        image_features)
+    batch_size = combined_feature_shape[0]
+    num_anchors = (combined_feature_shape[1] * combined_feature_shape[2])
+    code_size = 4
+    zero = tf.reduce_sum(0 * image_features)
+    box_encodings = zero + tf.zeros(
+        (batch_size, num_anchors, 1, code_size), dtype=tf.float32)
+    class_predictions_with_background = zero + tf.zeros(
+        (batch_size, num_anchors, self.num_classes + 1), dtype=tf.float32)
+    return {box_predictor.BOX_ENCODINGS: box_encodings,
+            box_predictor.CLASS_PREDICTIONS_WITH_BACKGROUND:
+            class_predictions_with_background}
+
+
+class MockAnchorGenerator(anchor_generator.AnchorGenerator):
+  """Mock anchor generator."""
+
+  def name_scope(self):
+    return 'MockAnchorGenerator'
+
+  def num_anchors_per_location(self):
+    return [1]
+
+  def _generate(self, feature_map_shape_list):
+    num_anchors = sum([shape[0] * shape[1] for shape in feature_map_shape_list])
+    return box_list.BoxList(tf.zeros((num_anchors, 4), dtype=tf.float32))
+
+
+class MockMatcher(matcher.Matcher):
+  """Simple matcher that matches first anchor to first groundtruth box."""
+
+  def _match(self, similarity_matrix):
+    return tf.constant([0, -1, -1, -1], dtype=tf.int32)
+
+
+def create_diagonal_gradient_image(height, width, depth):
+  """Creates pyramid image. Useful for testing.
+
+  For example, pyramid_image(5, 6, 1) looks like:
+  # [[[ 5.  4.  3.  2.  1.  0.]
+  #   [ 6.  5.  4.  3.  2.  1.]
+  #   [ 7.  6.  5.  4.  3.  2.]
+  #   [ 8.  7.  6.  5.  4.  3.]
+  #   [ 9.  8.  7.  6.  5.  4.]]]
+
+  Args:
+    height: height of image
+    width: width of image
+    depth: depth of image
+
+  Returns:
+    pyramid image
+  """
+  row = np.arange(height)
+  col = np.arange(width)[::-1]
+  image_layer = np.expand_dims(row, 1) + col
+  image_layer = np.expand_dims(image_layer, 2)
+
+  image = image_layer
+  for i in range(1, depth):
+    image = np.concatenate((image, image_layer * pow(10, i)), 2)
+
+  return image.astype(np.float32)
+
+
+def create_random_boxes(num_boxes, max_height, max_width):
+  """Creates random bounding boxes of specific maximum height and width.
+
+  Args:
+    num_boxes: number of boxes.
+    max_height: maximum height of boxes.
+    max_width: maximum width of boxes.
+
+  Returns:
+    boxes: numpy array of shape [num_boxes, 4]. Each row is in form
+        [y_min, x_min, y_max, x_max].
+  """
+
+  y_1 = np.random.uniform(size=(1, num_boxes)) * max_height
+  y_2 = np.random.uniform(size=(1, num_boxes)) * max_height
+  x_1 = np.random.uniform(size=(1, num_boxes)) * max_width
+  x_2 = np.random.uniform(size=(1, num_boxes)) * max_width
+
+  boxes = np.zeros(shape=(num_boxes, 4))
+  boxes[:, 0] = np.minimum(y_1, y_2)
+  boxes[:, 1] = np.minimum(x_1, x_2)
+  boxes[:, 2] = np.maximum(y_1, y_2)
+  boxes[:, 3] = np.maximum(x_1, x_2)
+
+  return boxes.astype(np.float32)
diff --git a/reconnaissance images/object_detection/utils/test_utils_test.py b/reconnaissance images/object_detection/utils/test_utils_test.py
new file mode 100644
index 0000000..1a4799c
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/test_utils_test.py	
@@ -0,0 +1,73 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.test_utils."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.utils import test_utils
+
+
+class TestUtilsTest(tf.test.TestCase):
+
+  def test_diagonal_gradient_image(self):
+    """Tests if a good pyramid image is created."""
+    pyramid_image = test_utils.create_diagonal_gradient_image(3, 4, 2)
+
+    # Test which is easy to understand.
+    expected_first_channel = np.array([[3, 2, 1, 0],
+                                       [4, 3, 2, 1],
+                                       [5, 4, 3, 2]], dtype=np.float32)
+    self.assertAllEqual(np.squeeze(pyramid_image[:, :, 0]),
+                        expected_first_channel)
+
+    # Actual test.
+    expected_image = np.array([[[3, 30],
+                                [2, 20],
+                                [1, 10],
+                                [0, 0]],
+                               [[4, 40],
+                                [3, 30],
+                                [2, 20],
+                                [1, 10]],
+                               [[5, 50],
+                                [4, 40],
+                                [3, 30],
+                                [2, 20]]], dtype=np.float32)
+
+    self.assertAllEqual(pyramid_image, expected_image)
+
+  def test_random_boxes(self):
+    """Tests if valid random boxes are created."""
+    num_boxes = 1000
+    max_height = 3
+    max_width = 5
+    boxes = test_utils.create_random_boxes(num_boxes,
+                                           max_height,
+                                           max_width)
+
+    true_column = np.ones(shape=(num_boxes)) == 1
+    self.assertAllEqual(boxes[:, 0] < boxes[:, 2], true_column)
+    self.assertAllEqual(boxes[:, 1] < boxes[:, 3], true_column)
+
+    self.assertTrue(boxes[:, 0].min() >= 0)
+    self.assertTrue(boxes[:, 1].min() >= 0)
+    self.assertTrue(boxes[:, 2].max() <= max_height)
+    self.assertTrue(boxes[:, 3].max() <= max_width)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/variables_helper.py b/reconnaissance images/object_detection/utils/variables_helper.py
new file mode 100644
index 0000000..b27f814
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/variables_helper.py	
@@ -0,0 +1,133 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Helper functions for manipulating collections of variables during training.
+"""
+import logging
+import re
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+
+# TODO: Consider replacing with tf.contrib.filter_variables in
+# tensorflow/contrib/framework/python/ops/variables.py
+def filter_variables(variables, filter_regex_list, invert=False):
+  """Filters out the variables matching the filter_regex.
+
+  Filter out the variables whose name matches the any of the regular
+  expressions in filter_regex_list and returns the remaining variables.
+  Optionally, if invert=True, the complement set is returned.
+
+  Args:
+    variables: a list of tensorflow variables.
+    filter_regex_list: a list of string regular expressions.
+    invert: (boolean).  If True, returns the complement of the filter set; that
+      is, all variables matching filter_regex are kept and all others discarded.
+
+  Returns:
+    a list of filtered variables.
+  """
+  kept_vars = []
+  variables_to_ignore_patterns = filter(None, filter_regex_list)
+  for var in variables:
+    add = True
+    for pattern in variables_to_ignore_patterns:
+      if re.match(pattern, var.op.name):
+        add = False
+        break
+    if add != invert:
+      kept_vars.append(var)
+  return kept_vars
+
+
+def multiply_gradients_matching_regex(grads_and_vars, regex_list, multiplier):
+  """Multiply gradients whose variable names match a regular expression.
+
+  Args:
+    grads_and_vars: A list of gradient to variable pairs (tuples).
+    regex_list: A list of string regular expressions.
+    multiplier: A (float) multiplier to apply to each gradient matching the
+      regular expression.
+
+  Returns:
+    grads_and_vars: A list of gradient to variable pairs (tuples).
+  """
+  variables = [pair[1] for pair in grads_and_vars]
+  matching_vars = filter_variables(variables, regex_list, invert=True)
+  for var in matching_vars:
+    logging.info('Applying multiplier %f to variable [%s]',
+                 multiplier, var.op.name)
+  grad_multipliers = {var: float(multiplier) for var in matching_vars}
+  return slim.learning.multiply_gradients(grads_and_vars,
+                                          grad_multipliers)
+
+
+def freeze_gradients_matching_regex(grads_and_vars, regex_list):
+  """Freeze gradients whose variable names match a regular expression.
+
+  Args:
+    grads_and_vars: A list of gradient to variable pairs (tuples).
+    regex_list: A list of string regular expressions.
+
+  Returns:
+    grads_and_vars: A list of gradient to variable pairs (tuples) that do not
+      contain the variables and gradients matching the regex.
+  """
+  variables = [pair[1] for pair in grads_and_vars]
+  matching_vars = filter_variables(variables, regex_list, invert=True)
+  kept_grads_and_vars = [pair for pair in grads_and_vars
+                         if pair[1] not in matching_vars]
+  for var in matching_vars:
+    logging.info('Freezing variable [%s]', var.op.name)
+  return kept_grads_and_vars
+
+
+def get_variables_available_in_checkpoint(variables, checkpoint_path):
+  """Returns the subset of variables available in the checkpoint.
+
+  Inspects given checkpoint and returns the subset of variables that are
+  available in it.
+
+  TODO: force input and output to be a dictionary.
+
+  Args:
+    variables: a list or dictionary of variables to find in checkpoint.
+    checkpoint_path: path to the checkpoint to restore variables from.
+
+  Returns:
+    A list or dictionary of variables.
+  Raises:
+    ValueError: if `variables` is not a list or dict.
+  """
+  if isinstance(variables, list):
+    variable_names_map = {variable.op.name: variable for variable in variables}
+  elif isinstance(variables, dict):
+    variable_names_map = variables
+  else:
+    raise ValueError('`variables` is expected to be a list or dict.')
+  ckpt_reader = tf.train.NewCheckpointReader(checkpoint_path)
+  ckpt_vars = ckpt_reader.get_variable_to_shape_map().keys()
+  vars_in_ckpt = {}
+  for variable_name, variable in sorted(variable_names_map.items()):
+    if variable_name in ckpt_vars:
+      vars_in_ckpt[variable_name] = variable
+    else:
+      logging.warning('Variable [%s] not available in checkpoint',
+                      variable_name)
+  if isinstance(variables, list):
+    return vars_in_ckpt.values()
+  return vars_in_ckpt
diff --git a/reconnaissance images/object_detection/utils/variables_helper_test.py b/reconnaissance images/object_detection/utils/variables_helper_test.py
new file mode 100644
index 0000000..c04b119
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/variables_helper_test.py	
@@ -0,0 +1,185 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.utils.variables_helper."""
+import os
+
+import tensorflow as tf
+
+from object_detection.utils import variables_helper
+
+
+class FilterVariablesTest(tf.test.TestCase):
+
+  def _create_variables(self):
+    return [tf.Variable(1.0, name='FeatureExtractor/InceptionV3/weights'),
+            tf.Variable(1.0, name='FeatureExtractor/InceptionV3/biases'),
+            tf.Variable(1.0, name='StackProposalGenerator/weights'),
+            tf.Variable(1.0, name='StackProposalGenerator/biases')]
+
+  def test_return_all_variables_when_empty_regex(self):
+    variables = self._create_variables()
+    out_variables = variables_helper.filter_variables(variables, [''])
+    self.assertItemsEqual(out_variables, variables)
+
+  def test_return_variables_which_do_not_match_single_regex(self):
+    variables = self._create_variables()
+    out_variables = variables_helper.filter_variables(variables,
+                                                      ['FeatureExtractor/.*'])
+    self.assertItemsEqual(out_variables, variables[2:])
+
+  def test_return_variables_which_do_not_match_any_regex_in_list(self):
+    variables = self._create_variables()
+    out_variables = variables_helper.filter_variables(variables, [
+        'FeatureExtractor.*biases', 'StackProposalGenerator.*biases'
+    ])
+    self.assertItemsEqual(out_variables, [variables[0], variables[2]])
+
+  def test_return_variables_matching_empty_regex_list(self):
+    variables = self._create_variables()
+    out_variables = variables_helper.filter_variables(
+        variables, [''], invert=True)
+    self.assertItemsEqual(out_variables, [])
+
+  def test_return_variables_matching_some_regex_in_list(self):
+    variables = self._create_variables()
+    out_variables = variables_helper.filter_variables(
+        variables,
+        ['FeatureExtractor.*biases', 'StackProposalGenerator.*biases'],
+        invert=True)
+    self.assertItemsEqual(out_variables, [variables[1], variables[3]])
+
+
+class MultiplyGradientsMatchingRegexTest(tf.test.TestCase):
+
+  def _create_grads_and_vars(self):
+    return [(tf.constant(1.0),
+             tf.Variable(1.0, name='FeatureExtractor/InceptionV3/weights')),
+            (tf.constant(2.0),
+             tf.Variable(2.0, name='FeatureExtractor/InceptionV3/biases')),
+            (tf.constant(3.0),
+             tf.Variable(3.0, name='StackProposalGenerator/weights')),
+            (tf.constant(4.0),
+             tf.Variable(4.0, name='StackProposalGenerator/biases'))]
+
+  def test_multiply_all_feature_extractor_variables(self):
+    grads_and_vars = self._create_grads_and_vars()
+    regex_list = ['FeatureExtractor/.*']
+    multiplier = 0.0
+    grads_and_vars = variables_helper.multiply_gradients_matching_regex(
+        grads_and_vars, regex_list, multiplier)
+    exp_output = [(0.0, 1.0), (0.0, 2.0), (3.0, 3.0), (4.0, 4.0)]
+    init_op = tf.global_variables_initializer()
+    with self.test_session() as sess:
+      sess.run(init_op)
+      output = sess.run(grads_and_vars)
+      self.assertItemsEqual(output, exp_output)
+
+  def test_multiply_all_bias_variables(self):
+    grads_and_vars = self._create_grads_and_vars()
+    regex_list = ['.*/biases']
+    multiplier = 0.0
+    grads_and_vars = variables_helper.multiply_gradients_matching_regex(
+        grads_and_vars, regex_list, multiplier)
+    exp_output = [(1.0, 1.0), (0.0, 2.0), (3.0, 3.0), (0.0, 4.0)]
+    init_op = tf.global_variables_initializer()
+    with self.test_session() as sess:
+      sess.run(init_op)
+      output = sess.run(grads_and_vars)
+      self.assertItemsEqual(output, exp_output)
+
+
+class FreezeGradientsMatchingRegexTest(tf.test.TestCase):
+
+  def _create_grads_and_vars(self):
+    return [(tf.constant(1.0),
+             tf.Variable(1.0, name='FeatureExtractor/InceptionV3/weights')),
+            (tf.constant(2.0),
+             tf.Variable(2.0, name='FeatureExtractor/InceptionV3/biases')),
+            (tf.constant(3.0),
+             tf.Variable(3.0, name='StackProposalGenerator/weights')),
+            (tf.constant(4.0),
+             tf.Variable(4.0, name='StackProposalGenerator/biases'))]
+
+  def test_freeze_all_feature_extractor_variables(self):
+    grads_and_vars = self._create_grads_and_vars()
+    regex_list = ['FeatureExtractor/.*']
+    grads_and_vars = variables_helper.freeze_gradients_matching_regex(
+        grads_and_vars, regex_list)
+    exp_output = [(3.0, 3.0), (4.0, 4.0)]
+    init_op = tf.global_variables_initializer()
+    with self.test_session() as sess:
+      sess.run(init_op)
+      output = sess.run(grads_and_vars)
+      self.assertItemsEqual(output, exp_output)
+
+
+class GetVariablesAvailableInCheckpointTest(tf.test.TestCase):
+
+  def test_return_all_variables_from_checkpoint(self):
+    variables = [
+        tf.Variable(1.0, name='weights'),
+        tf.Variable(1.0, name='biases')
+    ]
+    checkpoint_path = os.path.join(self.get_temp_dir(), 'graph.pb')
+    init_op = tf.global_variables_initializer()
+    saver = tf.train.Saver(variables)
+    with self.test_session() as sess:
+      sess.run(init_op)
+      saver.save(sess, checkpoint_path)
+    out_variables = variables_helper.get_variables_available_in_checkpoint(
+        variables, checkpoint_path)
+    self.assertItemsEqual(out_variables, variables)
+
+  def test_return_variables_available_in_checkpoint(self):
+    checkpoint_path = os.path.join(self.get_temp_dir(), 'graph.pb')
+    graph1_variables = [
+        tf.Variable(1.0, name='weights'),
+    ]
+    init_op = tf.global_variables_initializer()
+    saver = tf.train.Saver(graph1_variables)
+    with self.test_session() as sess:
+      sess.run(init_op)
+      saver.save(sess, checkpoint_path)
+
+    graph2_variables = graph1_variables + [tf.Variable(1.0, name='biases')]
+    out_variables = variables_helper.get_variables_available_in_checkpoint(
+        graph2_variables, checkpoint_path)
+    self.assertItemsEqual(out_variables, graph1_variables)
+
+  def test_return_variables_available_an_checkpoint_with_dict_inputs(self):
+    checkpoint_path = os.path.join(self.get_temp_dir(), 'graph.pb')
+    graph1_variables = [
+        tf.Variable(1.0, name='ckpt_weights'),
+    ]
+    init_op = tf.global_variables_initializer()
+    saver = tf.train.Saver(graph1_variables)
+    with self.test_session() as sess:
+      sess.run(init_op)
+      saver.save(sess, checkpoint_path)
+
+    graph2_variables_dict = {
+        'ckpt_weights': tf.Variable(1.0, name='weights'),
+        'ckpt_biases': tf.Variable(1.0, name='biases')
+    }
+    out_variables = variables_helper.get_variables_available_in_checkpoint(
+        graph2_variables_dict, checkpoint_path)
+    self.assertTrue(isinstance(out_variables, dict))
+    self.assertItemsEqual(out_variables.keys(), ['ckpt_weights'])
+    self.assertTrue(out_variables['ckpt_weights'].op.name == 'weights')
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/reconnaissance images/object_detection/utils/visualization_utils.py b/reconnaissance images/object_detection/utils/visualization_utils.py
new file mode 100644
index 0000000..b55fc5f
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/visualization_utils.py	
@@ -0,0 +1,425 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""A set of functions that are used for visualization.
+
+These functions often receive an image, perform some visualization on the image.
+The functions do not return a value, instead they modify the image itself.
+
+"""
+import collections
+import numpy as np
+import PIL.Image as Image
+import PIL.ImageColor as ImageColor
+import PIL.ImageDraw as ImageDraw
+import PIL.ImageFont as ImageFont
+import six
+import tensorflow as tf
+
+
+_TITLE_LEFT_MARGIN = 10
+_TITLE_TOP_MARGIN = 10
+STANDARD_COLORS = [
+    'AliceBlue', 'Chartreuse', 'Aqua', 'Aquamarine', 'Azure', 'Beige', 'Bisque',
+    'BlanchedAlmond', 'BlueViolet', 'BurlyWood', 'CadetBlue', 'AntiqueWhite',
+    'Chocolate', 'Coral', 'CornflowerBlue', 'Cornsilk', 'Crimson', 'Cyan',
+    'DarkCyan', 'DarkGoldenRod', 'DarkGrey', 'DarkKhaki', 'DarkOrange',
+    'DarkOrchid', 'DarkSalmon', 'DarkSeaGreen', 'DarkTurquoise', 'DarkViolet',
+    'DeepPink', 'DeepSkyBlue', 'DodgerBlue', 'FireBrick', 'FloralWhite',
+    'ForestGreen', 'Fuchsia', 'Gainsboro', 'GhostWhite', 'Gold', 'GoldenRod',
+    'Salmon', 'Tan', 'HoneyDew', 'HotPink', 'IndianRed', 'Ivory', 'Khaki',
+    'Lavender', 'LavenderBlush', 'LawnGreen', 'LemonChiffon', 'LightBlue',
+    'LightCoral', 'LightCyan', 'LightGoldenRodYellow', 'LightGray', 'LightGrey',
+    'LightGreen', 'LightPink', 'LightSalmon', 'LightSeaGreen', 'LightSkyBlue',
+    'LightSlateGray', 'LightSlateGrey', 'LightSteelBlue', 'LightYellow', 'Lime',
+    'LimeGreen', 'Linen', 'Magenta', 'MediumAquaMarine', 'MediumOrchid',
+    'MediumPurple', 'MediumSeaGreen', 'MediumSlateBlue', 'MediumSpringGreen',
+    'MediumTurquoise', 'MediumVioletRed', 'MintCream', 'MistyRose', 'Moccasin',
+    'NavajoWhite', 'OldLace', 'Olive', 'OliveDrab', 'Orange', 'OrangeRed',
+    'Orchid', 'PaleGoldenRod', 'PaleGreen', 'PaleTurquoise', 'PaleVioletRed',
+    'PapayaWhip', 'PeachPuff', 'Peru', 'Pink', 'Plum', 'PowderBlue', 'Purple',
+    'Red', 'RosyBrown', 'RoyalBlue', 'SaddleBrown', 'Green', 'SandyBrown',
+    'SeaGreen', 'SeaShell', 'Sienna', 'Silver', 'SkyBlue', 'SlateBlue',
+    'SlateGray', 'SlateGrey', 'Snow', 'SpringGreen', 'SteelBlue', 'GreenYellow',
+    'Teal', 'Thistle', 'Tomato', 'Turquoise', 'Violet', 'Wheat', 'White',
+    'WhiteSmoke', 'Yellow', 'YellowGreen'
+]
+
+
+def save_image_array_as_png(image, output_path):
+  """Saves an image (represented as a numpy array) to PNG.
+
+  Args:
+    image: a numpy array with shape [height, width, 3].
+    output_path: path to which image should be written.
+  """
+  image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
+  with tf.gfile.Open(output_path, 'w') as fid:
+    image_pil.save(fid, 'PNG')
+
+
+def encode_image_array_as_png_str(image):
+  """Encodes a numpy array into a PNG string.
+
+  Args:
+    image: a numpy array with shape [height, width, 3].
+
+  Returns:
+    PNG encoded image string.
+  """
+  image_pil = Image.fromarray(np.uint8(image))
+  output = six.BytesIO()
+  image_pil.save(output, format='PNG')
+  png_string = output.getvalue()
+  output.close()
+  return png_string
+
+
+def draw_bounding_box_on_image_array(image,
+                                     ymin,
+                                     xmin,
+                                     ymax,
+                                     xmax,
+                                     color='red',
+                                     thickness=4,
+                                     display_str_list=(),
+                                     use_normalized_coordinates=True):
+  """Adds a bounding box to an image (numpy array).
+
+  Args:
+    image: a numpy array with shape [height, width, 3].
+    ymin: ymin of bounding box in normalized coordinates (same below).
+    xmin: xmin of bounding box.
+    ymax: ymax of bounding box.
+    xmax: xmax of bounding box.
+    color: color to draw bounding box. Default is red.
+    thickness: line thickness. Default value is 4.
+    display_str_list: list of strings to display in box
+                      (each to be shown on its own line).
+    use_normalized_coordinates: If True (default), treat coordinates
+      ymin, xmin, ymax, xmax as relative to the image.  Otherwise treat
+      coordinates as absolute.
+  """
+  image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
+  draw_bounding_box_on_image(image_pil, ymin, xmin, ymax, xmax, color,
+                             thickness, display_str_list,
+                             use_normalized_coordinates)
+  np.copyto(image, np.array(image_pil))
+
+
+def draw_bounding_box_on_image(image,
+                               ymin,
+                               xmin,
+                               ymax,
+                               xmax,
+                               color='red',
+                               thickness=4,
+                               display_str_list=(),
+                               use_normalized_coordinates=True):
+  """Adds a bounding box to an image.
+
+  Each string in display_str_list is displayed on a separate line above the
+  bounding box in black text on a rectangle filled with the input 'color'.
+
+  Args:
+    image: a PIL.Image object.
+    ymin: ymin of bounding box.
+    xmin: xmin of bounding box.
+    ymax: ymax of bounding box.
+    xmax: xmax of bounding box.
+    color: color to draw bounding box. Default is red.
+    thickness: line thickness. Default value is 4.
+    display_str_list: list of strings to display in box
+                      (each to be shown on its own line).
+    use_normalized_coordinates: If True (default), treat coordinates
+      ymin, xmin, ymax, xmax as relative to the image.  Otherwise treat
+      coordinates as absolute.
+  """
+  draw = ImageDraw.Draw(image)
+  im_width, im_height = image.size
+  if use_normalized_coordinates:
+    (left, right, top, bottom) = (xmin * im_width, xmax * im_width,
+                                  ymin * im_height, ymax * im_height)
+  else:
+    (left, right, top, bottom) = (xmin, xmax, ymin, ymax)
+  draw.line([(left, top), (left, bottom), (right, bottom),
+             (right, top), (left, top)], width=thickness, fill=color)
+  try:
+    font = ImageFont.truetype('arial.ttf', 24)
+  except IOError:
+    font = ImageFont.load_default()
+
+  text_bottom = top
+  # Reverse list and print from bottom to top.
+  for display_str in display_str_list[::-1]:
+    text_width, text_height = font.getsize(display_str)
+    margin = np.ceil(0.05 * text_height)
+    draw.rectangle(
+        [(left, text_bottom - text_height - 2 * margin), (left + text_width,
+                                                          text_bottom)],
+        fill=color)
+    draw.text(
+        (left + margin, text_bottom - text_height - margin),
+        display_str,
+        fill='black',
+        font=font)
+    text_bottom -= text_height - 2 * margin
+
+
+def draw_bounding_boxes_on_image_array(image,
+                                       boxes,
+                                       color='red',
+                                       thickness=4,
+                                       display_str_list_list=()):
+  """Draws bounding boxes on image (numpy array).
+
+  Args:
+    image: a numpy array object.
+    boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).
+           The coordinates are in normalized format between [0, 1].
+    color: color to draw bounding box. Default is red.
+    thickness: line thickness. Default value is 4.
+    display_str_list_list: list of list of strings.
+                           a list of strings for each bounding box.
+                           The reason to pass a list of strings for a
+                           bounding box is that it might contain
+                           multiple labels.
+
+  Raises:
+    ValueError: if boxes is not a [N, 4] array
+  """
+  image_pil = Image.fromarray(image)
+  draw_bounding_boxes_on_image(image_pil, boxes, color, thickness,
+                               display_str_list_list)
+  np.copyto(image, np.array(image_pil))
+
+
+def draw_bounding_boxes_on_image(image,
+                                 boxes,
+                                 color='red',
+                                 thickness=4,
+                                 display_str_list_list=()):
+  """Draws bounding boxes on image.
+
+  Args:
+    image: a PIL.Image object.
+    boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).
+           The coordinates are in normalized format between [0, 1].
+    color: color to draw bounding box. Default is red.
+    thickness: line thickness. Default value is 4.
+    display_str_list_list: list of list of strings.
+                           a list of strings for each bounding box.
+                           The reason to pass a list of strings for a
+                           bounding box is that it might contain
+                           multiple labels.
+
+  Raises:
+    ValueError: if boxes is not a [N, 4] array
+  """
+  boxes_shape = boxes.shape
+  if not boxes_shape:
+    return
+  if len(boxes_shape) != 2 or boxes_shape[1] != 4:
+    raise ValueError('Input must be of size [N, 4]')
+  for i in range(boxes_shape[0]):
+    display_str_list = ()
+    if display_str_list_list:
+      display_str_list = display_str_list_list[i]
+    draw_bounding_box_on_image(image, boxes[i, 0], boxes[i, 1], boxes[i, 2],
+                               boxes[i, 3], color, thickness, display_str_list)
+
+
+def draw_keypoints_on_image_array(image,
+                                  keypoints,
+                                  color='red',
+                                  radius=2,
+                                  use_normalized_coordinates=True):
+  """Draws keypoints on an image (numpy array).
+
+  Args:
+    image: a numpy array with shape [height, width, 3].
+    keypoints: a numpy array with shape [num_keypoints, 2].
+    color: color to draw the keypoints with. Default is red.
+    radius: keypoint radius. Default value is 2.
+    use_normalized_coordinates: if True (default), treat keypoint values as
+      relative to the image.  Otherwise treat them as absolute.
+  """
+  image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
+  draw_keypoints_on_image(image_pil, keypoints, color, radius,
+                          use_normalized_coordinates)
+  np.copyto(image, np.array(image_pil))
+
+
+def draw_keypoints_on_image(image,
+                            keypoints,
+                            color='red',
+                            radius=2,
+                            use_normalized_coordinates=True):
+  """Draws keypoints on an image.
+
+  Args:
+    image: a PIL.Image object.
+    keypoints: a numpy array with shape [num_keypoints, 2].
+    color: color to draw the keypoints with. Default is red.
+    radius: keypoint radius. Default value is 2.
+    use_normalized_coordinates: if True (default), treat keypoint values as
+      relative to the image.  Otherwise treat them as absolute.
+  """
+  draw = ImageDraw.Draw(image)
+  im_width, im_height = image.size
+  keypoints_x = [k[1] for k in keypoints]
+  keypoints_y = [k[0] for k in keypoints]
+  if use_normalized_coordinates:
+    keypoints_x = tuple([im_width * x for x in keypoints_x])
+    keypoints_y = tuple([im_height * y for y in keypoints_y])
+  for keypoint_x, keypoint_y in zip(keypoints_x, keypoints_y):
+    draw.ellipse([(keypoint_x - radius, keypoint_y - radius),
+                  (keypoint_x + radius, keypoint_y + radius)],
+                 outline=color, fill=color)
+
+
+def draw_mask_on_image_array(image, mask, color='red', alpha=0.7):
+  """Draws mask on an image.
+
+  Args:
+    image: uint8 numpy array with shape (img_height, img_height, 3)
+    mask: a float numpy array of shape (img_height, img_height) with
+      values between 0 and 1
+    color: color to draw the keypoints with. Default is red.
+    alpha: transparency value between 0 and 1. (default: 0.7)
+
+  Raises:
+    ValueError: On incorrect data type for image or masks.
+  """
+  if image.dtype != np.uint8:
+    raise ValueError('`image` not of type np.uint8')
+  if mask.dtype != np.float32:
+    raise ValueError('`mask` not of type np.float32')
+  if np.any(np.logical_or(mask > 1.0, mask < 0.0)):
+    raise ValueError('`mask` elements should be in [0, 1]')
+  rgb = ImageColor.getrgb(color)
+  pil_image = Image.fromarray(image)
+
+  solid_color = np.expand_dims(
+      np.ones_like(mask), axis=2) * np.reshape(list(rgb), [1, 1, 3])
+  pil_solid_color = Image.fromarray(np.uint8(solid_color)).convert('RGBA')
+  pil_mask = Image.fromarray(np.uint8(255.0*alpha*mask)).convert('L')
+  pil_image = Image.composite(pil_solid_color, pil_image, pil_mask)
+  np.copyto(image, np.array(pil_image.convert('RGB')))
+
+
+def visualize_boxes_and_labels_on_image_array(image,
+                                              boxes,
+                                              classes,
+                                              scores,
+                                              category_index,
+                                              instance_masks=None,
+                                              keypoints=None,
+                                              use_normalized_coordinates=False,
+                                              max_boxes_to_draw=20,
+                                              min_score_thresh=.5,
+                                              agnostic_mode=False,
+                                              line_thickness=4):
+  """Overlay labeled boxes on an image with formatted scores and label names.
+
+  This function groups boxes that correspond to the same location
+  and creates a display string for each detection and overlays these
+  on the image.  Note that this function modifies the image array in-place
+  and does not return anything.
+
+  Args:
+    image: uint8 numpy array with shape (img_height, img_width, 3)
+    boxes: a numpy array of shape [N, 4]
+    classes: a numpy array of shape [N]
+    scores: a numpy array of shape [N] or None.  If scores=None, then
+      this function assumes that the boxes to be plotted are groundtruth
+      boxes and plot all boxes as black with no classes or scores.
+    category_index: a dict containing category dictionaries (each holding
+      category index `id` and category name `name`) keyed by category indices.
+    instance_masks: a numpy array of shape [N, image_height, image_width], can
+      be None
+    keypoints: a numpy array of shape [N, num_keypoints, 2], can
+      be None
+    use_normalized_coordinates: whether boxes is to be interpreted as
+      normalized coordinates or not.
+    max_boxes_to_draw: maximum number of boxes to visualize.  If None, draw
+      all boxes.
+    min_score_thresh: minimum score threshold for a box to be visualized
+    agnostic_mode: boolean (default: False) controlling whether to evaluate in
+      class-agnostic mode or not.  This mode will display scores but ignore
+      classes.
+    line_thickness: integer (default: 4) controlling line width of the boxes.
+  """
+  # Create a display string (and color) for every box location, group any boxes
+  # that correspond to the same location.
+  box_to_display_str_map = collections.defaultdict(list)
+  box_to_color_map = collections.defaultdict(str)
+  box_to_instance_masks_map = {}
+  box_to_keypoints_map = collections.defaultdict(list)
+  if not max_boxes_to_draw:
+    max_boxes_to_draw = boxes.shape[0]
+  for i in range(min(max_boxes_to_draw, boxes.shape[0])):
+    if scores is None or scores[i] > min_score_thresh:
+      box = tuple(boxes[i].tolist())
+      if instance_masks is not None:
+        box_to_instance_masks_map[box] = instance_masks[i]
+      if keypoints is not None:
+        box_to_keypoints_map[box].extend(keypoints[i])
+      if scores is None:
+        box_to_color_map[box] = 'black'
+      else:
+        if not agnostic_mode:
+          if classes[i] in category_index.keys():
+            class_name = category_index[classes[i]]['name']
+          else:
+            class_name = 'N/A'
+          display_str = '{}: {}%'.format(
+              class_name,
+              int(100*scores[i]))
+        else:
+          display_str = 'score: {}%'.format(int(100 * scores[i]))
+        box_to_display_str_map[box].append(display_str)
+        if agnostic_mode:
+          box_to_color_map[box] = 'DarkOrange'
+        else:
+          box_to_color_map[box] = STANDARD_COLORS[
+              classes[i] % len(STANDARD_COLORS)]
+
+  # Draw all boxes onto image.
+  for box, color in box_to_color_map.items():
+    ymin, xmin, ymax, xmax = box
+    if instance_masks is not None:
+      draw_mask_on_image_array(
+          image,
+          box_to_instance_masks_map[box],
+          color=color
+      )
+    draw_bounding_box_on_image_array(
+        image,
+        ymin,
+        xmin,
+        ymax,
+        xmax,
+        color=color,
+        thickness=line_thickness,
+        display_str_list=box_to_display_str_map[box],
+        use_normalized_coordinates=use_normalized_coordinates)
+    if keypoints is not None:
+      draw_keypoints_on_image_array(
+          image,
+          box_to_keypoints_map[box],
+          color=color,
+          radius=line_thickness / 2,
+          use_normalized_coordinates=use_normalized_coordinates)
diff --git a/reconnaissance images/object_detection/utils/visualization_utils_test.py b/reconnaissance images/object_detection/utils/visualization_utils_test.py
new file mode 100644
index 0000000..809d5f0
--- /dev/null
+++ b/reconnaissance images/object_detection/utils/visualization_utils_test.py	
@@ -0,0 +1,151 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for image.understanding.object_detection.core.visualization_utils.
+
+Testing with visualization in the following colab:
+https://drive.google.com/a/google.com/file/d/0B5HnKS_hMsNARERpU3MtU3I5RFE/view?usp=sharing
+
+"""
+
+
+import numpy as np
+import PIL.Image as Image
+import tensorflow as tf
+
+from object_detection.utils import visualization_utils
+
+
+class VisualizationUtilsTest(tf.test.TestCase):
+
+  def create_colorful_test_image(self):
+    """This function creates an image that can be used to test vis functions.
+
+    It makes an image composed of four colored rectangles.
+
+    Returns:
+      colorful test numpy array image.
+    """
+    ch255 = np.full([100, 200, 1], 255, dtype=np.uint8)
+    ch128 = np.full([100, 200, 1], 128, dtype=np.uint8)
+    ch0 = np.full([100, 200, 1], 0, dtype=np.uint8)
+    imr = np.concatenate((ch255, ch128, ch128), axis=2)
+    img = np.concatenate((ch255, ch255, ch0), axis=2)
+    imb = np.concatenate((ch255, ch0, ch255), axis=2)
+    imw = np.concatenate((ch128, ch128, ch128), axis=2)
+    imu = np.concatenate((imr, img), axis=1)
+    imd = np.concatenate((imb, imw), axis=1)
+    image = np.concatenate((imu, imd), axis=0)
+    return image
+
+  def test_draw_bounding_box_on_image(self):
+    test_image = self.create_colorful_test_image()
+    test_image = Image.fromarray(test_image)
+    width_original, height_original = test_image.size
+    ymin = 0.25
+    ymax = 0.75
+    xmin = 0.4
+    xmax = 0.6
+
+    visualization_utils.draw_bounding_box_on_image(test_image, ymin, xmin, ymax,
+                                                   xmax)
+    width_final, height_final = test_image.size
+
+    self.assertEqual(width_original, width_final)
+    self.assertEqual(height_original, height_final)
+
+  def test_draw_bounding_box_on_image_array(self):
+    test_image = self.create_colorful_test_image()
+    width_original = test_image.shape[0]
+    height_original = test_image.shape[1]
+    ymin = 0.25
+    ymax = 0.75
+    xmin = 0.4
+    xmax = 0.6
+
+    visualization_utils.draw_bounding_box_on_image_array(
+        test_image, ymin, xmin, ymax, xmax)
+    width_final = test_image.shape[0]
+    height_final = test_image.shape[1]
+
+    self.assertEqual(width_original, width_final)
+    self.assertEqual(height_original, height_final)
+
+  def test_draw_bounding_boxes_on_image(self):
+    test_image = self.create_colorful_test_image()
+    test_image = Image.fromarray(test_image)
+    width_original, height_original = test_image.size
+    boxes = np.array([[0.25, 0.75, 0.4, 0.6],
+                      [0.1, 0.1, 0.9, 0.9]])
+
+    visualization_utils.draw_bounding_boxes_on_image(test_image, boxes)
+    width_final, height_final = test_image.size
+
+    self.assertEqual(width_original, width_final)
+    self.assertEqual(height_original, height_final)
+
+  def test_draw_bounding_boxes_on_image_array(self):
+    test_image = self.create_colorful_test_image()
+    width_original = test_image.shape[0]
+    height_original = test_image.shape[1]
+    boxes = np.array([[0.25, 0.75, 0.4, 0.6],
+                      [0.1, 0.1, 0.9, 0.9]])
+
+    visualization_utils.draw_bounding_boxes_on_image_array(test_image, boxes)
+    width_final = test_image.shape[0]
+    height_final = test_image.shape[1]
+
+    self.assertEqual(width_original, width_final)
+    self.assertEqual(height_original, height_final)
+
+  def test_draw_keypoints_on_image(self):
+    test_image = self.create_colorful_test_image()
+    test_image = Image.fromarray(test_image)
+    width_original, height_original = test_image.size
+    keypoints = [[0.25, 0.75], [0.4, 0.6], [0.1, 0.1], [0.9, 0.9]]
+
+    visualization_utils.draw_keypoints_on_image(test_image, keypoints)
+    width_final, height_final = test_image.size
+
+    self.assertEqual(width_original, width_final)
+    self.assertEqual(height_original, height_final)
+
+  def test_draw_keypoints_on_image_array(self):
+    test_image = self.create_colorful_test_image()
+    width_original = test_image.shape[0]
+    height_original = test_image.shape[1]
+    keypoints = [[0.25, 0.75], [0.4, 0.6], [0.1, 0.1], [0.9, 0.9]]
+
+    visualization_utils.draw_keypoints_on_image_array(test_image, keypoints)
+    width_final = test_image.shape[0]
+    height_final = test_image.shape[1]
+
+    self.assertEqual(width_original, width_final)
+    self.assertEqual(height_original, height_final)
+
+  def test_draw_mask_on_image_array(self):
+    test_image = np.asarray([[[0, 0, 0], [0, 0, 0]],
+                             [[0, 0, 0], [0, 0, 0]]], dtype=np.uint8)
+    mask = np.asarray([[0.0, 1.0],
+                       [1.0, 1.0]], dtype=np.float32)
+    expected_result = np.asarray([[[0, 0, 0], [0, 0, 127]],
+                                  [[0, 0, 127], [0, 0, 127]]], dtype=np.uint8)
+    visualization_utils.draw_mask_on_image_array(test_image, mask,
+                                                 color='Blue', alpha=.5)
+    self.assertAllEqual(test_image, expected_result)
+
+
+if __name__ == '__main__':
+  tf.test.main()