Object detection changes: (#7208)

257914648  by lzc:

    Internal changes

--
257525973  by Zhichao Lu:

    Fixes bug that silently prevents checkpoints from loading when training w/ eager + functions. Also sets up scripts to run training.

--
257296614  by Zhichao Lu:

    Adding detection_features to model outputs

--
257234565  by Zhichao Lu:

    Fix wrong order of `classes_with_max_scores` in class-agnostic NMS caused by
    sorting in partitioned-NMS.

--
257232002  by ronnyvotel:

    Supporting `filter_nonoverlapping` option in np_box_list_ops.clip_to_window().

--
257198282  by Zhichao Lu:

    Adding the focal loss and l1 loss from the Objects as Points paper.

--
257089535  by Zhichao Lu:

    Create Keras based ssd + resnetv1 + fpn.

--
257087407  by Zhichao Lu:

    Make object_detection/data_decoders Python3-compatible.

--
257004582  by Zhichao Lu:

    Updates _decode_raw_data_into_masks_and_boxes to the latest binary masks-to-string encoding format.

--
257002124  by Zhichao Lu:

    Make object_detection/utils Python3-compatible, except json_utils.

    The patching trick used in json_utils is not going to work in Python 3.

--
256795056  by lzc:

    Add a detection_anchor_indices field to detection outputs.

--
256477542  by Zhichao Lu:

    Make object_detection/core Python3-compatible.

--
256387593  by Zhichao Lu:

    Edit class_id_function_approximations builder to skip class ids not present in label map.

--
256259039  by Zhichao Lu:

    Move NMS to TPU for FasterRCNN.

--
256071360  by rathodv:

    When multiclass_scores is empty, add one-hot encoding of groundtruth_classes as multiclass scores so that data_augmentation ops that expect the presence of multiclass_scores don't have to individually handle this case.

    Also copy input tensor_dict to out_tensor_dict first to avoid inplace modification.

--
256023645  by Zhichao Lu:

    Adds the first WIP iterations of TensorFlow v2 eager + functions style custom training & evaluation loops.

--
255980623  by Zhichao Lu:

    Adds a new data augmentation operation "remap_labels" which remaps a set of labels to a new label.

--
255753259  by Zhichao Lu:

    Announcement of the released evaluation tutorial for Open Images Challenge
    2019.

--
255698776  by lzc:

    Fix rewrite_nn_resize_op function which was broken by tf forward compatibility movement.

--
255623150  by Zhichao Lu:

    Add Keras-based ResnetV1 models.

--
255504992  by Zhichao Lu:

    Fixing the typo in specifying label expansion for ground truth segmentation
    file.

--
255470768  by Zhichao Lu:

    1. Fixing Python bug with parsed arguments.
    2. Adding capability to parse relevant columns from CSV header.
    3. Fixing bug with duplicated labels expansion.

--
255462432  by Zhichao Lu:

    Adds a new data augmentation operation "drop_label_probabilistically" which drops a given label with the given probability. This supports experiments on training in the presence of label noise.

--
255441632  by rathodv:

    Fallback on groundtruth classes when multiclass_scores tensor is empty.

--
255434899  by Zhichao Lu:

    Ensuring evaluation binary can run even with big files by synchronizing
    processing of ground truth and predictions: in this way, ground truth is not stored but immediatly
    used for evaluation. In case gt of object masks, this allows to run
    evaluations on relatively large sets.

--
255337855  by lzc:

    Internal change.

--
255308908  by Zhichao Lu:

    Add comment to clarify usage of calibration parameters proto.

--
255266371  by Zhichao Lu:

    Ensuring correct processing of the case, when no groundtruth masks are provided
    for an image.

--
255236648  by Zhichao Lu:

    Refactor model_builder in faster_rcnn.py to a util_map, so that it's possible to be overwritten.

--
255093285  by Zhichao Lu:

    Updating capability to subsample data during evaluation

--
255081222  by rathodv:

    Convert groundtruth masks to be of type float32 before its used in the loss function.

    When using mixed precision training, masks are represented using bfloat16 tensors in the input pipeline for performance reasons. We need to convert them to float32 before using it in the loss function.

--
254788436  by Zhichao Lu:

    Add forward_compatible to non_max_suppression_with_scores to make it is
    compatible with older tensorflow version.

--
254442362  by Zhichao Lu:

    Add num_layer field to ssd feature extractor proto.

--
253911582  by jonathanhuang:

    Plumbs Soft-NMS options (using the new tf.image.non_max_suppression_with_scores op) into the TF Object Detection API.  It adds a `soft_nms_sigma` field to the postprocessing proto file and plumbs this through to both the multiclass and class_agnostic versions of NMS. Note that there is no effect on behavior of NMS when soft_nms_sigma=0 (which it is set to by default).

    See also "Soft-NMS -- Improving Object Detection With One Line of Code" by Bodla et al (https://arxiv.org/abs/1704.04503)

--
253703949  by Zhichao Lu:

    Internal test fixes.

--
253151266  by Zhichao Lu:

    Fix the op type check for FusedBatchNorm, given that we introduced
    FusedBatchNormV3 in a previous change.

--
252718956  by Zhichao Lu:

    Customize activation function to enable relu6 instead of relu for saliency
    prediction model seastarization

--
252158593  by Zhichao Lu:

    Make object_detection/core Python3-compatible.

--
252150717  by Zhichao Lu:

    Make object_detection/core Python3-compatible.

--
251967048  by Zhichao Lu:

    Make GraphRewriter proto extensible.

--
251950039  by Zhichao Lu:

    Remove experimental_export_device_assignment from TPUEstimator.export_savedmodel(), so as to remove rewrite_for_inference().

    As a replacement, export_savedmodel() V2 API supports device_assignment where user call tpu.rewrite in model_fn and pass in device_assigment there.

--
251890697  by rathodv:

    Updated docstring to include new output nodes.

--
251662894  by Zhichao Lu:

    Add autoaugment augmentation option to objection detection api codebase. This
    is an available option in preprocessor.py.

    The intended usage of autoaugment is to be done along with random flipping and
    cropping for best results.

--
251532908  by Zhichao Lu:

    Add TrainingDataType enum to track whether class-specific or agnostic data was used to fit the calibration function.

    This is useful, since classes with few observations may require a calibration function fit on all classes.

--
251511339  by Zhichao Lu:

    Add multiclass isotonic regression to the calibration builder.

--
251317769  by pengchong:

    Internal Change.

--
250729989  by Zhichao Lu:

    Fixing bug in gt statistics count in case of mask and box annotations.

--
250729627  by Zhichao Lu:

    Label expansion for segmentation.

--
250724905  by Zhichao Lu:

    Fix use_depthwise in fpn and test it with fpnlite on ssd + mobilenet v2.

--
250670379  by Zhichao Lu:

    Internal change

250630364  by lzc:

    Fix detection_model_zoo footnotes

--
250560654  by Zhichao Lu:

    Fix static shape issue in matmul_crop_and_resize.

--
250534857  by Zhichao Lu:

    Edit class agnostic calibration function docstring to more accurately describe the function's outputs.

--
250533277  by Zhichao Lu:

    Edit the multiclass messages to use class ids instead of labels.

--

PiperOrigin-RevId: 257914648

research/object_detection/README.md

@@ -78,7 +78,7 @@ Extras:
   * <a href='g3doc/instance_segmentation.md'>
       Run an instance segmentation model</a><br>
   * <a href='g3doc/challenge_evaluation.md'>
-      Run the evaluation for the Open Images Challenge 2018</a><br>
+      Run the evaluation for the Open Images Challenge 2018/2019</a><br>
   * <a href='g3doc/tpu_compatibility.md'>
       TPU compatible detection pipelines</a><br>
   * <a href='g3doc/running_on_mobile_tensorflowlite.md'>
@@ -101,9 +101,23 @@ reporting an issue.
 
 ## Release information
 
+### July 1st, 2019
+
+We have released an updated set of utils and an updated
+[tutorial](g3doc/challenge_evaluation.md) for all three tracks of the
+[Open Images Challenge 2019](https://storage.googleapis.com/openimages/web/challenge2019.html)!
+
+The Instance Segmentation metric for
+[Open Images V5](https://storage.googleapis.com/openimages/web/index.html)
+and [Challenge 2019](https://storage.googleapis.com/openimages/web/challenge2019.html)
+is part of this release. Check out [the metric description](https://storage.googleapis.com/openimages/web/evaluation.html#instance_segmentation_eval)
+on the Open Images website.
+
+<b>Thanks to contributors</b>: Alina Kuznetsova, Rodrigo Benenson
+
 ### Feb 11, 2019
 
-We have released detection models trained on the [Open Images Dataset V4](https://storage.googleapis.com/openimages/web/challenge.html)
+We have released detection models trained on the Open Images Dataset V4
 in our detection model zoo, including
 
 * Faster R-CNN detector with Inception Resnet V2 feature extractor

research/object_detection/builders/calibration_builder.py

@@ -79,6 +79,27 @@ def _function_approximation_proto_to_tf_tensors(x_y_pairs_message):
   return tf_x, tf_y
 
 
+def _get_class_id_function_dict(calibration_config):
+  """Create a dictionary mapping class id to function approximations.
+
+  Args:
+    calibration_config: calibration_pb2 proto containing
+      id_function_approximations.
+  Returns:
+    Dictionary mapping a class id to a tuple of TF tensors to be used for
+    function approximation.
+  """
+  class_id_function_dict = {}
+  class_id_xy_pairs_map = (
+      calibration_config.class_id_function_approximations.class_id_xy_pairs_map)
+  for class_id in class_id_xy_pairs_map:
+    class_id_function_dict[class_id] = (
+        _function_approximation_proto_to_tf_tensors(
+            class_id_xy_pairs_map[class_id]))
+
+  return class_id_function_dict
+
+
 def build(calibration_config):
   """Returns a function that calibrates Tensorflow model scores.
 
@@ -107,9 +128,9 @@ def build(calibration_config):
     def calibration_fn(class_predictions_with_background):
       """Calibrate predictions via 1-d linear interpolation.
 
-      Predictions scores are linearly interpolated based on class-agnostic
-      function approximations. Note that the 0-indexed background class may
-      also transformed.
+      Predictions scores are linearly interpolated based on a class-agnostic
+      function approximation. Note that the 0-indexed background class is also
+      transformed.
 
       Args:
         class_predictions_with_background: tf.float32 tensor of shape
@@ -118,9 +139,8 @@ def build(calibration_config):
           and the result of calling the `predict` method of a detection model.
 
       Returns:
-        tf.float32 tensor of shape [batch_size, num_anchors, num_classes] if
-        background class is not present (else shape is
-        [batch_size, num_anchors, num_classes + 1]) on the interval [0, 1].
+        tf.float32 tensor of the same shape as the input with values on the
+        interval [0, 1].
       """
       # Flattening Tensors and then reshaping at the end.
       flat_class_predictions_with_background = tf.reshape(
@@ -139,7 +159,61 @@ def build(calibration_config):
           name='calibrate_scores')
       return calibrated_class_predictions_with_background
 
-  # TODO(zbeaver): Add sigmoid calibration and per-class isotonic regression.
+  elif (calibration_config.WhichOneof('calibrator') ==
+        'class_id_function_approximations'):
+
+    def calibration_fn(class_predictions_with_background):
+      """Calibrate predictions per class via 1-d linear interpolation.
+
+      Prediction scores are linearly interpolated with class-specific function
+      approximations. Note that after calibration, an anchor's class scores will
+      not necessarily sum to 1, and score ordering may change, depending on each
+      class' calibration parameters.
+
+      Args:
+        class_predictions_with_background: tf.float32 tensor of shape
+          [batch_size, num_anchors, num_classes + 1] containing scores on the
+          interval [0,1]. This is usually produced by a sigmoid or softmax layer
+          and the result of calling the `predict` method of a detection model.
+
+      Returns:
+        tf.float32 tensor of the same shape as the input with values on the
+        interval [0, 1].
+
+      Raises:
+        KeyError: Calibration parameters are not present for a class.
+      """
+      class_id_function_dict = _get_class_id_function_dict(calibration_config)
+
+      # Tensors are split by class and then recombined at the end to recover
+      # the input's original shape. If a class id does not have calibration
+      # parameters, it is left unchanged.
+      class_tensors = tf.unstack(class_predictions_with_background, axis=-1)
+      calibrated_class_tensors = []
+      for class_id, class_tensor in enumerate(class_tensors):
+        flat_class_tensor = tf.reshape(class_tensor, shape=[-1])
+        if class_id in class_id_function_dict:
+          output_tensor = _tf_linear_interp1d(
+              x_to_interpolate=flat_class_tensor,
+              fn_x=class_id_function_dict[class_id][0],
+              fn_y=class_id_function_dict[class_id][1])
+        else:
+          tf.logging.info(
+              'Calibration parameters for class id `%d` not not found',
+              class_id)
+          output_tensor = flat_class_tensor
+        calibrated_class_tensors.append(output_tensor)
+
+      combined_calibrated_tensor = tf.stack(calibrated_class_tensors, axis=1)
+      input_shape = shape_utils.combined_static_and_dynamic_shape(
+          class_predictions_with_background)
+      calibrated_class_predictions_with_background = tf.reshape(
+          combined_calibrated_tensor,
+          shape=input_shape,
+          name='calibrate_scores')
+      return calibrated_class_predictions_with_background
+
+  # TODO(zbeaver): Add sigmoid calibration.
   else:
     raise ValueError('No calibration builder defined for "Oneof" in '
                      'calibration_config.')

research/object_detection/builders/calibration_builder_test.py

@@ -94,37 +94,34 @@ class CalibrationBuilderTest(tf.test.TestCase):
 
   @staticmethod
   def _add_function_approximation_to_calibration_proto(calibration_proto,
-                                                       x_array,
-                                                       y_array,
-                                                       class_label):
-    """Adds a function approximation to calibration proto for a class label."""
+                                                       x_array, y_array,
+                                                       class_id):
+    """Adds a function approximation to calibration proto for a class id."""
     # Per-class calibration.
-    if class_label:
-      label_function_approximation = (calibration_proto
-                                      .label_function_approximations
-                                      .label_xy_pairs_map[class_label])
+    if class_id is not None:
+      function_approximation = (
+          calibration_proto.class_id_function_approximations
+          .class_id_xy_pairs_map[class_id])
     # Class-agnostic calibration.
     else:
-      label_function_approximation = (calibration_proto
-                                      .function_approximation
-                                      .x_y_pairs)
+      function_approximation = (
+          calibration_proto.function_approximation.x_y_pairs)
+
     for x, y in zip(x_array, y_array):
-      x_y_pair_message = label_function_approximation.x_y_pair.add()
+      x_y_pair_message = function_approximation.x_y_pair.add()
       x_y_pair_message.x = x
       x_y_pair_message.y = y
 
   def test_class_agnostic_function_approximation(self):
-    """Ensures that calibration appropriate values, regardless of class."""
+    """Tests that calibration produces correct class-agnostic values."""
     # Generate fake calibration proto. For this interpolation, any input on
     # [0.0, 0.5] should be divided by 2 and any input on (0.5, 1.0] should have
     # 0.25 subtracted from it.
     class_agnostic_x = np.asarray([0.0, 0.5, 1.0])
     class_agnostic_y = np.asarray([0.0, 0.25, 0.75])
     calibration_config = calibration_pb2.CalibrationConfig()
-    self._add_function_approximation_to_calibration_proto(calibration_config,
-                                                          class_agnostic_x,
-                                                          class_agnostic_y,
-                                                          class_label=None)
+    self._add_function_approximation_to_calibration_proto(
+        calibration_config, class_agnostic_x, class_agnostic_y, class_id=None)
 
     od_graph = tf.Graph()
     with self.test_session(graph=od_graph) as sess:
@@ -144,5 +141,55 @@ class CalibrationBuilderTest(tf.test.TestCase):
                                                [[0.35, 0.45, 0.55],
                                                 [0.65, 0.75, 0.75]]])
 
+  def test_multiclass_function_approximations(self):
+    """Tests that calibration produces correct multiclass values."""
+    # Background class (0-index) maps all predictions to 0.5.
+    class_0_x = np.asarray([0.0, 0.5, 1.0])
+    class_0_y = np.asarray([0.5, 0.5, 0.5])
+    calibration_config = calibration_pb2.CalibrationConfig()
+    self._add_function_approximation_to_calibration_proto(
+        calibration_config, class_0_x, class_0_y, class_id=0)
+
+    # Class id 1 will interpolate using these values.
+    class_1_x = np.asarray([0.0, 0.2, 1.0])
+    class_1_y = np.asarray([0.0, 0.6, 1.0])
+    self._add_function_approximation_to_calibration_proto(
+        calibration_config, class_1_x, class_1_y, class_id=1)
+
+    od_graph = tf.Graph()
+    with self.test_session(graph=od_graph) as sess:
+      calibration_fn = calibration_builder.build(calibration_config)
+      # batch_size = 2, num_classes = 2, num_anchors = 2.
+      class_predictions_with_background = tf.constant(
+          [[[0.1, 0.2], [0.9, 0.1]],
+           [[0.6, 0.4], [0.08, 0.92]]],
+          dtype=tf.float32)
+      calibrated_scores = calibration_fn(class_predictions_with_background)
+      calibrated_scores_np = sess.run(calibrated_scores)
+    self.assertAllClose(calibrated_scores_np, [[[0.5, 0.6], [0.5, 0.3]],
+                                               [[0.5, 0.7], [0.5, 0.96]]])
+
+  def test_skips_class_when_calibration_parameters_not_present(self):
+    """Tests that graph fails when parameters not present for all classes."""
+    # Only adding calibration parameters for class id = 0, even though class id
+    # 1 is present in the data.
+    class_0_x = np.asarray([0.0, 0.5, 1.0])
+    class_0_y = np.asarray([0.5, 0.5, 0.5])
+    calibration_config = calibration_pb2.CalibrationConfig()
+    self._add_function_approximation_to_calibration_proto(
+        calibration_config, class_0_x, class_0_y, class_id=0)
+    od_graph = tf.Graph()
+    with self.test_session(graph=od_graph) as sess:
+      calibration_fn = calibration_builder.build(calibration_config)
+      # batch_size = 2, num_classes = 2, num_anchors = 2.
+      class_predictions_with_background = tf.constant(
+          [[[0.1, 0.2], [0.9, 0.1]],
+           [[0.6, 0.4], [0.08, 0.92]]],
+          dtype=tf.float32)
+      calibrated_scores = calibration_fn(class_predictions_with_background)
+      calibrated_scores_np = sess.run(calibrated_scores)
+    self.assertAllClose(calibrated_scores_np, [[[0.5, 0.2], [0.5, 0.1]],
+                                               [[0.5, 0.4], [0.5, 0.92]]])
+
 if __name__ == '__main__':
   tf.test.main()

research/object_detection/builders/model_builder.py

@@ -206,6 +206,9 @@ def _build_ssd_feature_extractor(feature_extractor_config,
             feature_extractor_config.replace_preprocessor_with_placeholder
     })
 
+  if feature_extractor_config.HasField('num_layers'):
+    kwargs.update({'num_layers': feature_extractor_config.num_layers})
+
   if is_keras_extractor:
     kwargs.update({
         'conv_hyperparams': conv_hyperparams,

research/object_detection/builders/post_processing_builder.py

@@ -78,13 +78,16 @@ def _build_non_max_suppressor(nms_config):
 
   Raises:
     ValueError: On incorrect iou_threshold or on incompatible values of
-      max_total_detections and max_detections_per_class.
+      max_total_detections and max_detections_per_class or on negative
+      soft_nms_sigma.
   """
   if nms_config.iou_threshold < 0 or nms_config.iou_threshold > 1.0:
     raise ValueError('iou_threshold not in [0, 1.0].')
   if nms_config.max_detections_per_class > nms_config.max_total_detections:
     raise ValueError('max_detections_per_class should be no greater than '
                      'max_total_detections.')
+  if nms_config.soft_nms_sigma < 0.0:
+    raise ValueError('soft_nms_sigma should be non-negative.')
   non_max_suppressor_fn = functools.partial(
       post_processing.batch_multiclass_non_max_suppression,
       score_thresh=nms_config.score_threshold,
@@ -93,7 +96,8 @@ def _build_non_max_suppressor(nms_config):
       max_total_size=nms_config.max_total_detections,
       use_static_shapes=nms_config.use_static_shapes,
       use_class_agnostic_nms=nms_config.use_class_agnostic_nms,
-      max_classes_per_detection=nms_config.max_classes_per_detection)
+      max_classes_per_detection=nms_config.max_classes_per_detection,
+      soft_nms_sigma=nms_config.soft_nms_sigma)
   return non_max_suppressor_fn
 
 

research/object_detection/builders/post_processing_builder_test.py

@@ -30,6 +30,7 @@ class PostProcessingBuilderTest(tf.test.TestCase):
         iou_threshold: 0.6
         max_detections_per_class: 100
         max_total_detections: 300
+        soft_nms_sigma: 0.4
       }
     """
     post_processing_config = post_processing_pb2.PostProcessing()
@@ -40,6 +41,7 @@ class PostProcessingBuilderTest(tf.test.TestCase):
     self.assertEqual(non_max_suppressor.keywords['max_total_size'], 300)
     self.assertAlmostEqual(non_max_suppressor.keywords['score_thresh'], 0.7)
     self.assertAlmostEqual(non_max_suppressor.keywords['iou_thresh'], 0.6)
+    self.assertAlmostEqual(non_max_suppressor.keywords['soft_nms_sigma'], 0.4)
 
   def test_build_non_max_suppressor_with_correct_parameters_classagnostic_nms(
       self):

research/object_detection/builders/preprocessor_builder.py

@@ -297,6 +297,26 @@ def build(preprocessor_step_config):
               })
     return (preprocessor.ssd_random_crop, {})
 
+  if step_type == 'autoaugment_image':
+    config = preprocessor_step_config.autoaugment_image
+    return (preprocessor.autoaugment_image, {
+        'policy_name': config.policy_name,
+    })
+
+  if step_type == 'drop_label_probabilistically':
+    config = preprocessor_step_config.drop_label_probabilistically
+    return (preprocessor.drop_label_probabilistically, {
+        'dropped_label': config.label,
+        'drop_probability': config.drop_probability,
+    })
+
+  if step_type == 'remap_labels':
+    config = preprocessor_step_config.remap_labels
+    return (preprocessor.remap_labels, {
+        'original_labels': config.original_labels,
+        'new_label': config.new_label
+    })
+
   if step_type == 'ssd_random_crop_pad':
     config = preprocessor_step_config.ssd_random_crop_pad
     if config.operations:

research/object_detection/builders/preprocessor_builder_test.py

@@ -363,6 +363,51 @@ class PreprocessorBuilderTest(tf.test.TestCase):
                                         'probability': 0.95,
                                         'size_to_image_ratio': 0.12})
 
+  def test_auto_augment_image(self):
+    preprocessor_text_proto = """
+    autoaugment_image {
+      policy_name: 'v0'
+    }
+    """
+    preprocessor_proto = preprocessor_pb2.PreprocessingStep()
+    text_format.Merge(preprocessor_text_proto, preprocessor_proto)
+    function, args = preprocessor_builder.build(preprocessor_proto)
+    self.assertEqual(function, preprocessor.autoaugment_image)
+    self.assert_dictionary_close(args, {'policy_name': 'v0'})
+
+  def test_drop_label_probabilistically(self):
+    preprocessor_text_proto = """
+    drop_label_probabilistically{
+      label: 2
+      drop_probability: 0.5
+    }
+    """
+    preprocessor_proto = preprocessor_pb2.PreprocessingStep()
+    text_format.Merge(preprocessor_text_proto, preprocessor_proto)
+    function, args = preprocessor_builder.build(preprocessor_proto)
+    self.assertEqual(function, preprocessor.drop_label_probabilistically)
+    self.assert_dictionary_close(args, {
+        'dropped_label': 2,
+        'drop_probability': 0.5
+    })
+
+  def test_remap_labels(self):
+    preprocessor_text_proto = """
+    remap_labels{
+      original_labels: 1
+      original_labels: 2
+      new_label: 3
+    }
+    """
+    preprocessor_proto = preprocessor_pb2.PreprocessingStep()
+    text_format.Merge(preprocessor_text_proto, preprocessor_proto)
+    function, args = preprocessor_builder.build(preprocessor_proto)
+    self.assertEqual(function, preprocessor.remap_labels)
+    self.assert_dictionary_close(args, {
+        'original_labels': [1, 2],
+        'new_label': 3
+    })
+
   def test_build_random_resize_method(self):
     preprocessor_text_proto = """
     random_resize_method {

research/object_detection/core/anchor_generator.py

@@ -29,15 +29,20 @@ dynamically at generation time.  The number of anchors to place at each location
 is static --- implementations of AnchorGenerator must always be able return
 the number of anchors that it uses per location for each feature map.
 """
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
 from abc import ABCMeta
 from abc import abstractmethod
 
+import six
+from six.moves import zip
 import tensorflow as tf
 
 
-class AnchorGenerator(object):
+class AnchorGenerator(six.with_metaclass(ABCMeta, object)):
   """Abstract base class for anchor generators."""
-  __metaclass__ = ABCMeta
 
   @abstractmethod
   def name_scope(self):
@@ -147,4 +152,3 @@ class AnchorGenerator(object):
                                * feature_map_shape[1])
       actual_num_anchors += anchors.num_boxes()
     return tf.assert_equal(expected_num_anchors, actual_num_anchors)
-

research/object_detection/core/batch_multiclass_nms_test.py

@@ -13,15 +13,22 @@
 # limitations under the License.
 # ==============================================================================
 """Tests for google3.third_party.tensorflow_models.object_detection.core.batch_multiclass_nms."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from absl.testing import parameterized
 import numpy as np
+from six.moves import range
 import tensorflow as tf
 from object_detection.core import post_processing
 from object_detection.utils import test_case
 
 
-class BatchMulticlassNonMaxSuppressionTest(test_case.TestCase):
+class BatchMulticlassNonMaxSuppressionTest(test_case.TestCase,
+                                           parameterized.TestCase):
 
-  def test_batch_multiclass_nms_with_batch_size_1(self):
+  @parameterized.named_parameters(('', False), ('_use_static_shapes', True))
+  def test_batch_multiclass_nms_with_batch_size_1(self, use_static_shapes):
     boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
                           [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
                           [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
@@ -47,10 +54,15 @@ class BatchMulticlassNonMaxSuppressionTest(test_case.TestCase):
     exp_nms_classes = [[0, 0, 1, 0]]
 
     (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
-     nmsed_additional_fields, num_detections
-    ) = post_processing.batch_multiclass_non_max_suppression(
-        boxes, scores, score_thresh, iou_thresh,
-        max_size_per_class=max_output_size, max_total_size=max_output_size)
+     nmsed_additional_fields,
+     num_detections) = post_processing.batch_multiclass_non_max_suppression(
+         boxes,
+         scores,
+         score_thresh,
+         iou_thresh,
+         max_size_per_class=max_output_size,
+         max_total_size=max_output_size,
+         use_static_shapes=use_static_shapes)
 
     self.assertIsNone(nmsed_masks)
     self.assertIsNone(nmsed_additional_fields)
@@ -64,6 +76,17 @@ class BatchMulticlassNonMaxSuppressionTest(test_case.TestCase):
       self.assertAllClose(nmsed_classes, exp_nms_classes)
       self.assertEqual(num_detections, [4])
 
+  def test_batch_iou_with_negative_data(self):
+    boxes = tf.constant([[[0, -0.01, 0.1, 1.1], [0, 0.2, 0.2, 5.0],
+                          [0, -0.01, 0.1, 1.], [-1, -1, -1, -1]]], tf.float32)
+    iou = post_processing.batch_iou(boxes, boxes)
+    expected_iou = [[[0.99999994, 0.0917431, 0.9099099, -1.],
+                     [0.0917431, 1., 0.08154944, -1.],
+                     [0.9099099, 0.08154944, 1., -1.], [-1., -1., -1., -1.]]]
+    with self.test_session() as sess:
+      iou = sess.run(iou)
+      self.assertAllClose(iou, expected_iou)
+
   def test_batch_multiclass_nms_with_batch_size_2(self):
     boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
                           [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],

research/object_detection/core/batcher.py

@@ -14,8 +14,13 @@
 # ==============================================================================
 
 """Provides functions to batch a dictionary of input tensors."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
 import collections
 
+from six.moves import range
 import tensorflow as tf
 
 from object_detection.core import prefetcher

research/object_detection/core/batcher_test.py

@@ -15,7 +15,12 @@
 
 """Tests for object_detection.core.batcher."""
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
 import numpy as np
+from six.moves import range
 import tensorflow as tf
 
 from object_detection.core import batcher

research/object_detection/core/box_coder.py

@@ -26,10 +26,15 @@ Users of a BoxCoder can call two methods:
 In both cases, the arguments are assumed to be in 1-1 correspondence already;
 it is not the job of a BoxCoder to perform matching.
 """
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
 from abc import ABCMeta
 from abc import abstractmethod
 from abc import abstractproperty
 
+import six
 import tensorflow as tf
 
 from object_detection.utils import shape_utils
@@ -42,9 +47,8 @@ MEAN_STDDEV = 'mean_stddev'
 SQUARE = 'square'
 
 
-class BoxCoder(object):
+class BoxCoder(six.with_metaclass(ABCMeta, object)):
   """Abstract base class for box coder."""
-  __metaclass__ = ABCMeta
 
   @abstractproperty
   def code_size(self):

research/object_detection/core/box_list_ops.py

@@ -23,6 +23,11 @@ Example box operations that are supported:
 Whenever box_list_ops functions output a BoxList, the fields of the incoming
 BoxList are retained unless documented otherwise.
 """
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from six.moves import range
 import tensorflow as tf
 
 from object_detection.core import box_list

research/object_detection/core/class_agnostic_nms_test.py

@@ -13,13 +13,15 @@
 # limitations under the License.
 # ==============================================================================
 """Tests for google3.third_party.tensorflow_models.object_detection.core.class_agnostic_nms."""
+from absl.testing import parameterized
 import tensorflow as tf
 from object_detection.core import post_processing
 from object_detection.core import standard_fields as fields
 from object_detection.utils import test_case
 
 
-class ClassAgnosticNonMaxSuppressionTest(test_case.TestCase):
+class ClassAgnosticNonMaxSuppressionTest(test_case.TestCase,
+                                         parameterized.TestCase):
 
   def test_class_agnostic_nms_select_with_shared_boxes(self):
     boxes = tf.constant(
@@ -53,6 +55,7 @@ class ClassAgnosticNonMaxSuppressionTest(test_case.TestCase):
       self.assertAllClose(nms_scores_output, exp_nms_scores)
       self.assertAllClose(nms_classes_output, exp_nms_classes)
 
+
   def test_class_agnostic_nms_select_with_per_class_boxes(self):
     boxes = tf.constant(
         [[[4, 5, 9, 10], [0, 0, 1, 1]],
@@ -98,7 +101,14 @@ class ClassAgnosticNonMaxSuppressionTest(test_case.TestCase):
       self.assertAllClose(nms_scores_output, exp_nms_scores)
       self.assertAllClose(nms_classes_output, exp_nms_classes)
 
-  def test_batch_classagnostic_nms_with_batch_size_1(self):
+  # Two cases will be tested here: using / not using static shapes.
+  # Named the two test cases for easier control during testing, with a flag of
+  # '--test_filter=ClassAgnosticNonMaxSuppressionTest.test_batch_classagnostic_nms_with_batch_size_1'
+  # or
+  # '--test_filter=ClassAgnosticNonMaxSuppressionTest.test_batch_classagnostic_nms_with_batch_size_1_use_static_shapes'.
+  @parameterized.named_parameters(('', False), ('_use_static_shapes', True))
+  def test_batch_classagnostic_nms_with_batch_size_1(self,
+                                                     use_static_shapes=False):
     boxes = tf.constant(
         [[[[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]],
@@ -126,6 +136,7 @@ class ClassAgnosticNonMaxSuppressionTest(test_case.TestCase):
          max_size_per_class=max_output_size,
          max_total_size=max_output_size,
          use_class_agnostic_nms=use_class_agnostic_nms,
+         use_static_shapes=use_static_shapes,
          max_classes_per_detection=max_classes_per_detection)
 
     self.assertIsNone(nmsed_masks)

research/object_detection/core/data_decoder.py

@@ -18,13 +18,16 @@
 Data decoders decode the input data and return a dictionary of tensors keyed by
 the entries in core.reader.Fields.
 """
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
 from abc import ABCMeta
 from abc import abstractmethod
+import six
 
 
-class DataDecoder(object):
+class DataDecoder(six.with_metaclass(ABCMeta, object)):
   """Interface for data decoders."""
-  __metaclass__ = ABCMeta
 
   @abstractmethod
   def decode(self, data):

research/object_detection/core/data_parser.py

@@ -20,12 +20,16 @@ to numpy arrays (materialized tensors) directly, it is used to read data for
 evaluation/visualization; to parse the data during training, DataDecoder should
 be used.
 """
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
 from abc import ABCMeta
 from abc import abstractmethod
+import six
 
 
-class DataToNumpyParser(object):
-  __metaclass__ = ABCMeta
+class DataToNumpyParser(six.with_metaclass(ABCMeta, object)):
+  """Abstract interface for data parser that produces numpy arrays."""
 
   @abstractmethod
   def parse(self, input_data):

research/object_detection/core/freezable_batch_norm_test.py

@@ -14,7 +14,12 @@
 # ==============================================================================
 
 """Tests for object_detection.core.freezable_batch_norm."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
 import numpy as np
+from six.moves import zip
 import tensorflow as tf
 
 from object_detection.core import freezable_batch_norm

research/object_detection/core/losses.py

@@ -26,7 +26,12 @@ Classification losses:
  * WeightedSoftmaxClassificationAgainstLogitsLoss
  * BootstrappedSigmoidClassificationLoss
 """
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
 import abc
+import six
 import tensorflow as tf
 
 from object_detection.core import box_list
@@ -36,9 +41,8 @@ from object_detection.utils import ops
 slim = tf.contrib.slim
 
 
-class Loss(object):
+class Loss(six.with_metaclass(abc.ABCMeta, object)):
   """Abstract base class for loss functions."""
-  __metaclass__ = abc.ABCMeta
 
   def __call__(self,
                prediction_tensor,
@@ -153,6 +157,7 @@ class WeightedSmoothL1LocalizationLoss(Loss):
     Args:
       delta: delta for smooth L1 loss.
     """
+    super(WeightedSmoothL1LocalizationLoss, self).__init__()
     self._delta = delta
 
   def _compute_loss(self, prediction_tensor, target_tensor, weights):
@@ -257,6 +262,7 @@ class SigmoidFocalClassificationLoss(Loss):
       gamma: exponent of the modulating factor (1 - p_t) ^ gamma.
       alpha: optional alpha weighting factor to balance positives vs negatives.
     """
+    super(SigmoidFocalClassificationLoss, self).__init__()
     self._alpha = alpha
     self._gamma = gamma
 
@@ -316,6 +322,7 @@ class WeightedSoftmaxClassificationLoss(Loss):
                    (default 1.0)
 
     """
+    super(WeightedSoftmaxClassificationLoss, self).__init__()
     self._logit_scale = logit_scale
 
   def _compute_loss(self, prediction_tensor, target_tensor, weights):
@@ -360,6 +367,7 @@ class WeightedSoftmaxClassificationAgainstLogitsLoss(Loss):
                    (default 1.0)
 
     """
+    super(WeightedSoftmaxClassificationAgainstLogitsLoss, self).__init__()
     self._logit_scale = logit_scale
 
   def _scale_and_softmax_logits(self, logits):
@@ -423,6 +431,7 @@ class BootstrappedSigmoidClassificationLoss(Loss):
     Raises:
       ValueError: if bootstrap_type is not either 'hard' or 'soft'
     """
+    super(BootstrappedSigmoidClassificationLoss, self).__init__()
     if bootstrap_type != 'hard' and bootstrap_type != 'soft':
       raise ValueError('Unrecognized bootstrap_type: must be one of '
                        '\'hard\' or \'soft.\'')
@@ -673,3 +682,5 @@ class HardExampleMiner(object):
     num_negatives = tf.size(subsampled_selection_indices) - num_positives
     return (tf.reshape(tf.gather(indices, subsampled_selection_indices), [-1]),
             num_positives, num_negatives)
+
+

research/object_detection/core/losses_test.py

@@ -14,9 +14,14 @@
 # ==============================================================================
 
 """Tests for google3.research.vale.object_detection.losses."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
 import math
 
 import numpy as np
+from six.moves import zip
 import tensorflow as tf
 
 from object_detection.core import box_list