Minor fixes for object detection.

214018767  by Zhichao Lu:

    Add original_image_spatial_shape tensor in input dictionary to store shape of the original input image

--
213914693  by lzc:

    Internal change.

--
213872175  by Zhichao Lu:

    This CL adds a Keras-based mobilenet_v2 feature extractor for object detection models.

    As part of this CL, we use the Keras mobilenet_v2 application's keyword argument layer injection API to allow the generated network to support the object detection hyperparameters.

--
213848499  by Zhichao Lu:

    Replace tf.image.resize_nearest_neighbor with tf.image.resize_images. tf.image.resize_nearest_neighbor only supports 4-D tensors but masks is a 3-D tensor.

--
213758622  by lzc:

    Internal change.

--

PiperOrigin-RevId: 214018767

research/object_detection/models/ssd_feature_extractor_test.py

@@ -21,18 +21,40 @@ import itertools
 import numpy as np
 import tensorflow as tf
 
+from google.protobuf import text_format
+from object_detection.builders import hyperparams_builder
+from object_detection.protos import hyperparams_pb2
 from object_detection.utils import test_case
 
 
 class SsdFeatureExtractorTestBase(test_case.TestCase):
 
+  def _build_conv_hyperparams(self):
+    conv_hyperparams = hyperparams_pb2.Hyperparams()
+    conv_hyperparams_text_proto = """
+      activation: RELU_6
+      regularizer {
+        l2_regularizer {
+        }
+      }
+      initializer {
+        truncated_normal_initializer {
+        }
+      }
+      batch_norm {
+        scale: false
+      }
+    """
+    text_format.Merge(conv_hyperparams_text_proto, conv_hyperparams)
+    return hyperparams_builder.KerasLayerHyperparams(conv_hyperparams)
+
   def conv_hyperparams_fn(self):
     with tf.contrib.slim.arg_scope([]) as sc:
       return sc
 
   @abstractmethod
   def _create_feature_extractor(self, depth_multiplier, pad_to_multiple,
-                                use_explicit_padding=False):
+                                use_explicit_padding=False, use_keras=False):
     """Constructs a new feature extractor.
 
     Args:
@@ -42,20 +64,42 @@ class SsdFeatureExtractorTestBase(test_case.TestCase):
       use_explicit_padding: use 'VALID' padding for convolutions, but prepad
         inputs so that the output dimensions are the same as if 'SAME' padding
         were used.
+      use_keras: if True builds a keras-based feature extractor, if False builds
+        a slim-based one.
     Returns:
-      an ssd_meta_arch.SSDFeatureExtractor object.
+      an ssd_meta_arch.SSDFeatureExtractor or an
+      ssd_meta_arch.SSDKerasFeatureExtractor object.
     """
     pass
 
-  def check_extract_features_returns_correct_shape(
-      self, batch_size, image_height, image_width, depth_multiplier,
-      pad_to_multiple, expected_feature_map_shapes, use_explicit_padding=False):
-    def graph_fn(image_tensor):
+  def _extract_features(self, image_tensor, depth_multiplier, pad_to_multiple,
+                        use_explicit_padding=False, use_keras=False):
+    try:
+      feature_extractor = self._create_feature_extractor(depth_multiplier,
+                                                         pad_to_multiple,
+                                                         use_explicit_padding,
+                                                         use_keras=use_keras)
+    # If the unit test does not support a use_keras arg, it raises an error:
+    except TypeError:
       feature_extractor = self._create_feature_extractor(depth_multiplier,
                                                          pad_to_multiple,
                                                          use_explicit_padding)
+    if use_keras:
+      feature_maps = feature_extractor(image_tensor)
+    else:
       feature_maps = feature_extractor.extract_features(image_tensor)
-      return feature_maps
+    return feature_maps
+
+  def check_extract_features_returns_correct_shape(
+      self, batch_size, image_height, image_width, depth_multiplier,
+      pad_to_multiple, expected_feature_map_shapes, use_explicit_padding=False,
+      use_keras=False):
+    def graph_fn(image_tensor):
+      return self._extract_features(image_tensor,
+                                    depth_multiplier,
+                                    pad_to_multiple,
+                                    use_explicit_padding,
+                                    use_keras=use_keras)
 
     image_tensor = np.random.rand(batch_size, image_height, image_width,
                                   3).astype(np.float32)
@@ -66,15 +110,16 @@ class SsdFeatureExtractorTestBase(test_case.TestCase):
 
   def check_extract_features_returns_correct_shapes_with_dynamic_inputs(
       self, batch_size, image_height, image_width, depth_multiplier,
-      pad_to_multiple, expected_feature_map_shapes, use_explicit_padding=False):
+      pad_to_multiple, expected_feature_map_shapes, use_explicit_padding=False,
+      use_keras=False):
     def graph_fn(image_height, image_width):
-      feature_extractor = self._create_feature_extractor(depth_multiplier,
-                                                         pad_to_multiple,
-                                                         use_explicit_padding)
       image_tensor = tf.random_uniform([batch_size, image_height, image_width,
                                         3], dtype=tf.float32)
-      feature_maps = feature_extractor.extract_features(image_tensor)
-      return feature_maps
+      return self._extract_features(image_tensor,
+                                    depth_multiplier,
+                                    pad_to_multiple,
+                                    use_explicit_padding,
+                                    use_keras=use_keras)
 
     feature_maps = self.execute_cpu(graph_fn, [
         np.array(image_height, dtype=np.int32),
@@ -85,11 +130,13 @@ class SsdFeatureExtractorTestBase(test_case.TestCase):
       self.assertAllEqual(feature_map.shape, expected_shape)
 
   def check_extract_features_raises_error_with_invalid_image_size(
-      self, image_height, image_width, depth_multiplier, pad_to_multiple):
-    feature_extractor = self._create_feature_extractor(depth_multiplier,
-                                                       pad_to_multiple)
+      self, image_height, image_width, depth_multiplier, pad_to_multiple,
+      use_keras=False):
     preprocessed_inputs = tf.placeholder(tf.float32, (4, None, None, 3))
-    feature_maps = feature_extractor.extract_features(preprocessed_inputs)
+    feature_maps = self._extract_features(preprocessed_inputs,
+                                          depth_multiplier,
+                                          pad_to_multiple,
+                                          use_keras=use_keras)
     test_preprocessed_image = np.random.rand(4, image_height, image_width, 3)
     with self.test_session() as sess:
       sess.run(tf.global_variables_initializer())
@@ -98,13 +145,19 @@ class SsdFeatureExtractorTestBase(test_case.TestCase):
                  feed_dict={preprocessed_inputs: test_preprocessed_image})
 
   def check_feature_extractor_variables_under_scope(
-      self, depth_multiplier, pad_to_multiple, scope_name):
+      self, depth_multiplier, pad_to_multiple, scope_name, use_keras=False):
+    variables = self.get_feature_extractor_variables(
+        depth_multiplier, pad_to_multiple, use_keras)
+    for variable in variables:
+      self.assertTrue(variable.name.startswith(scope_name))
+
+  def get_feature_extractor_variables(
+      self, depth_multiplier, pad_to_multiple, use_keras=False):
     g = tf.Graph()
     with g.as_default():
-      feature_extractor = self._create_feature_extractor(
-          depth_multiplier, pad_to_multiple)
       preprocessed_inputs = tf.placeholder(tf.float32, (4, None, None, 3))
-      feature_extractor.extract_features(preprocessed_inputs)
-      variables = g.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
-      for variable in variables:
-        self.assertTrue(variable.name.startswith(scope_name))
+      self._extract_features(preprocessed_inputs,
+                             depth_multiplier,
+                             pad_to_multiple,
+                             use_keras=use_keras)
+      return g.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)

research/object_detection/models/ssd_mobilenet_v2_feature_extractor_test.py

@@ -14,20 +14,27 @@
 # ==============================================================================
 
 """Tests for ssd_mobilenet_v2_feature_extractor."""
+from absl.testing import parameterized
+
 import numpy as np
 import tensorflow as tf
 
 from object_detection.models import ssd_feature_extractor_test
 from object_detection.models import ssd_mobilenet_v2_feature_extractor
+from object_detection.models import ssd_mobilenet_v2_keras_feature_extractor
 
 slim = tf.contrib.slim
 
 
+@parameterized.parameters(
+    {'use_keras': False},
+    {'use_keras': True},
+)
 class SsdMobilenetV2FeatureExtractorTest(
     ssd_feature_extractor_test.SsdFeatureExtractorTestBase):
 
   def _create_feature_extractor(self, depth_multiplier, pad_to_multiple,
-                                use_explicit_padding=False):
+                                use_explicit_padding=False, use_keras=False):
     """Constructs a new feature extractor.
 
     Args:
@@ -37,19 +44,47 @@ class SsdMobilenetV2FeatureExtractorTest(
       use_explicit_padding: use 'VALID' padding for convolutions, but prepad
         inputs so that the output dimensions are the same as if 'SAME' padding
         were used.
+      use_keras: if True builds a keras-based feature extractor, if False builds
+        a slim-based one.
     Returns:
       an ssd_meta_arch.SSDFeatureExtractor object.
     """
     min_depth = 32
-    return ssd_mobilenet_v2_feature_extractor.SSDMobileNetV2FeatureExtractor(
-        False,
-        depth_multiplier,
-        min_depth,
-        pad_to_multiple,
-        self.conv_hyperparams_fn,
-        use_explicit_padding=use_explicit_padding)
-
-  def test_extract_features_returns_correct_shapes_128(self):
+    if use_keras:
+      return (ssd_mobilenet_v2_keras_feature_extractor.
+              SSDMobileNetV2KerasFeatureExtractor(
+                  is_training=False,
+                  depth_multiplier=depth_multiplier,
+                  min_depth=min_depth,
+                  pad_to_multiple=pad_to_multiple,
+                  conv_hyperparams=self._build_conv_hyperparams(),
+                  freeze_batchnorm=False,
+                  inplace_batchnorm_update=False,
+                  use_explicit_padding=use_explicit_padding,
+                  name='MobilenetV2'))
+    else:
+      return ssd_mobilenet_v2_feature_extractor.SSDMobileNetV2FeatureExtractor(
+          False,
+          depth_multiplier,
+          min_depth,
+          pad_to_multiple,
+          self.conv_hyperparams_fn,
+          use_explicit_padding=use_explicit_padding)
+
+  def test_extract_features_returns_correct_shapes_128(self, use_keras):
+    image_height = 128
+    image_width = 128
+    depth_multiplier = 1.0
+    pad_to_multiple = 1
+    expected_feature_map_shape = [(2, 8, 8, 576), (2, 4, 4, 1280),
+                                  (2, 2, 2, 512), (2, 1, 1, 256),
+                                  (2, 1, 1, 256), (2, 1, 1, 128)]
+    self.check_extract_features_returns_correct_shape(
+        2, image_height, image_width, depth_multiplier, pad_to_multiple,
+        expected_feature_map_shape, use_keras=use_keras)
+
+  def test_extract_features_returns_correct_shapes_128_explicit_padding(
+      self, use_keras):
     image_height = 128
     image_width = 128
     depth_multiplier = 1.0
@@ -59,9 +94,11 @@ class SsdMobilenetV2FeatureExtractorTest(
                                   (2, 1, 1, 256), (2, 1, 1, 128)]
     self.check_extract_features_returns_correct_shape(
         2, image_height, image_width, depth_multiplier, pad_to_multiple,
-        expected_feature_map_shape)
+        expected_feature_map_shape, use_explicit_padding=True,
+        use_keras=use_keras)
 
-  def test_extract_features_returns_correct_shapes_with_dynamic_inputs(self):
+  def test_extract_features_returns_correct_shapes_with_dynamic_inputs(
+      self, use_keras):
     image_height = 128
     image_width = 128
     depth_multiplier = 1.0
@@ -71,9 +108,9 @@ class SsdMobilenetV2FeatureExtractorTest(
                                   (2, 1, 1, 256), (2, 1, 1, 128)]
     self.check_extract_features_returns_correct_shapes_with_dynamic_inputs(
         2, image_height, image_width, depth_multiplier, pad_to_multiple,
-        expected_feature_map_shape)
+        expected_feature_map_shape, use_keras=use_keras)
 
-  def test_extract_features_returns_correct_shapes_299(self):
+  def test_extract_features_returns_correct_shapes_299(self, use_keras):
     image_height = 299
     image_width = 299
     depth_multiplier = 1.0
@@ -83,9 +120,10 @@ class SsdMobilenetV2FeatureExtractorTest(
                                   (2, 2, 2, 256), (2, 1, 1, 128)]
     self.check_extract_features_returns_correct_shape(
         2, image_height, image_width, depth_multiplier, pad_to_multiple,
-        expected_feature_map_shape)
+        expected_feature_map_shape, use_keras=use_keras)
 
-  def test_extract_features_returns_correct_shapes_enforcing_min_depth(self):
+  def test_extract_features_returns_correct_shapes_enforcing_min_depth(
+      self, use_keras):
     image_height = 299
     image_width = 299
     depth_multiplier = 0.5**12
@@ -95,9 +133,10 @@ class SsdMobilenetV2FeatureExtractorTest(
                                   (2, 2, 2, 32), (2, 1, 1, 32)]
     self.check_extract_features_returns_correct_shape(
         2, image_height, image_width, depth_multiplier, pad_to_multiple,
-        expected_feature_map_shape)
+        expected_feature_map_shape, use_keras=use_keras)
 
-  def test_extract_features_returns_correct_shapes_with_pad_to_multiple(self):
+  def test_extract_features_returns_correct_shapes_with_pad_to_multiple(
+      self, use_keras):
     image_height = 299
     image_width = 299
     depth_multiplier = 1.0
@@ -107,35 +146,45 @@ class SsdMobilenetV2FeatureExtractorTest(
                                   (2, 2, 2, 256), (2, 1, 1, 128)]
     self.check_extract_features_returns_correct_shape(
         2, image_height, image_width, depth_multiplier, pad_to_multiple,
-        expected_feature_map_shape)
+        expected_feature_map_shape, use_keras=use_keras)
 
-  def test_extract_features_raises_error_with_invalid_image_size(self):
+  def test_extract_features_raises_error_with_invalid_image_size(
+      self, use_keras):
     image_height = 32
     image_width = 32
     depth_multiplier = 1.0
     pad_to_multiple = 1
     self.check_extract_features_raises_error_with_invalid_image_size(
-        image_height, image_width, depth_multiplier, pad_to_multiple)
+        image_height, image_width, depth_multiplier, pad_to_multiple,
+        use_keras=use_keras)
 
-  def test_preprocess_returns_correct_value_range(self):
+  def test_preprocess_returns_correct_value_range(self, use_keras):
     image_height = 128
     image_width = 128
     depth_multiplier = 1
     pad_to_multiple = 1
     test_image = np.random.rand(4, image_height, image_width, 3)
     feature_extractor = self._create_feature_extractor(depth_multiplier,
-                                                       pad_to_multiple)
+                                                       pad_to_multiple,
+                                                       use_keras=use_keras)
     preprocessed_image = feature_extractor.preprocess(test_image)
     self.assertTrue(np.all(np.less_equal(np.abs(preprocessed_image), 1.0)))
 
-  def test_variables_only_created_in_scope(self):
+  def test_variables_only_created_in_scope(self, use_keras):
     depth_multiplier = 1
     pad_to_multiple = 1
     scope_name = 'MobilenetV2'
     self.check_feature_extractor_variables_under_scope(
-        depth_multiplier, pad_to_multiple, scope_name)
+        depth_multiplier, pad_to_multiple, scope_name, use_keras=use_keras)
+
+  def test_variable_count(self, use_keras):
+    depth_multiplier = 1
+    pad_to_multiple = 1
+    variables = self.get_feature_extractor_variables(
+        depth_multiplier, pad_to_multiple, use_keras=use_keras)
+    self.assertEqual(len(variables), 292)
 
-  def test_has_fused_batchnorm(self):
+  def test_has_fused_batchnorm(self, use_keras):
     image_height = 40
     image_width = 40
     depth_multiplier = 1
@@ -143,9 +192,13 @@ class SsdMobilenetV2FeatureExtractorTest(
     image_placeholder = tf.placeholder(tf.float32,
                                        [1, image_height, image_width, 3])
     feature_extractor = self._create_feature_extractor(depth_multiplier,
-                                                       pad_to_multiple)
+                                                       pad_to_multiple,
+                                                       use_keras=use_keras)
     preprocessed_image = feature_extractor.preprocess(image_placeholder)
-    _ = feature_extractor.extract_features(preprocessed_image)
+    if use_keras:
+      _ = feature_extractor(preprocessed_image)
+    else:
+      _ = feature_extractor.extract_features(preprocessed_image)
     self.assertTrue(any(op.type == 'FusedBatchNorm'
                         for op in tf.get_default_graph().get_operations()))
 

research/object_detection/models/ssd_mobilenet_v2_keras_feature_extractor.py

+# Copyright 2018 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.
+# ==============================================================================
+
+"""SSDFeatureExtractor for MobilenetV2 features."""
+
+import tensorflow as tf
+
+from object_detection.meta_architectures import ssd_meta_arch
+from object_detection.models import feature_map_generators
+from object_detection.models.keras_applications import mobilenet_v2
+from object_detection.utils import ops
+from object_detection.utils import shape_utils
+
+
+class SSDMobileNetV2KerasFeatureExtractor(
+    ssd_meta_arch.SSDKerasFeatureExtractor):
+  """SSD Feature Extractor using MobilenetV2 features."""
+
+  def __init__(self,
+               is_training,
+               depth_multiplier,
+               min_depth,
+               pad_to_multiple,
+               conv_hyperparams,
+               freeze_batchnorm,
+               inplace_batchnorm_update,
+               use_explicit_padding=False,
+               use_depthwise=False,
+               override_base_feature_extractor_hyperparams=False,
+               name=None):
+    """MobileNetV2 Feature Extractor for SSD Models.
+
+    Mobilenet v2 (experimental), designed by sandler@. More details can be found
+    in //knowledge/cerebra/brain/compression/mobilenet/mobilenet_experimental.py
+
+    Args:
+      is_training: whether the network is in training mode.
+      depth_multiplier: float depth multiplier for feature extractor (Functions
+        as a width multiplier for the mobilenet_v2 network itself).
+      min_depth: minimum feature extractor depth.
+      pad_to_multiple: the nearest multiple to zero pad the input height and
+        width dimensions to.
+      conv_hyperparams: `hyperparams_builder.KerasLayerHyperparams` object
+        containing convolution hyperparameters for the layers added on top of
+        the base feature extractor.
+      freeze_batchnorm: Whether to freeze batch norm parameters during
+        training or not. When training with a small batch size (e.g. 1), it is
+        desirable to freeze batch norm update and use pretrained batch norm
+        params.
+      inplace_batchnorm_update: Whether to update batch norm moving average
+        values inplace. When this is false train op must add a control
+        dependency on tf.graphkeys.UPDATE_OPS collection in order to update
+        batch norm statistics.
+      use_explicit_padding: Whether to use explicit padding when extracting
+        features. Default is False.
+      use_depthwise: Whether to use depthwise convolutions. Default is False.
+      override_base_feature_extractor_hyperparams: Whether to override
+        hyperparameters of the base feature extractor with the one from
+        `conv_hyperparams_fn`.
+      name: A string name scope to assign to the model. If 'None', Keras
+        will auto-generate one from the class name.
+    """
+    super(SSDMobileNetV2KerasFeatureExtractor, self).__init__(
+        is_training=is_training,
+        depth_multiplier=depth_multiplier,
+        min_depth=min_depth,
+        pad_to_multiple=pad_to_multiple,
+        conv_hyperparams=conv_hyperparams,
+        freeze_batchnorm=freeze_batchnorm,
+        inplace_batchnorm_update=inplace_batchnorm_update,
+        use_explicit_padding=use_explicit_padding,
+        use_depthwise=use_depthwise,
+        override_base_feature_extractor_hyperparams=
+        override_base_feature_extractor_hyperparams,
+        name=name)
+    feature_map_layout = {
+        'from_layer': ['layer_15/expansion_output', 'layer_19', '', '', '', ''],
+        'layer_depth': [-1, -1, 512, 256, 256, 128],
+        'use_depthwise': self._use_depthwise,
+        'use_explicit_padding': self._use_explicit_padding,
+    }
+
+    with tf.name_scope('MobilenetV2'):
+      full_mobilenet_v2 = mobilenet_v2.mobilenet_v2(
+          batchnorm_training=(is_training and not freeze_batchnorm),
+          conv_hyperparams=(conv_hyperparams
+                            if self._override_base_feature_extractor_hyperparams
+                            else None),
+          weights=None,
+          use_explicit_padding=use_explicit_padding,
+          alpha=self._depth_multiplier,
+          min_depth=self._min_depth,
+          include_top=False)
+      conv2d_11_pointwise = full_mobilenet_v2.get_layer(
+          name='block_13_expand_relu').output
+      conv2d_13_pointwise = full_mobilenet_v2.get_layer(name='out_relu').output
+      self.mobilenet_v2 = tf.keras.Model(
+          inputs=full_mobilenet_v2.inputs,
+          outputs=[conv2d_11_pointwise, conv2d_13_pointwise])
+
+      self.feature_map_generator = (
+          feature_map_generators.KerasMultiResolutionFeatureMaps(
+              feature_map_layout=feature_map_layout,
+              depth_multiplier=self._depth_multiplier,
+              min_depth=self._min_depth,
+              insert_1x1_conv=True,
+              is_training=is_training,
+              conv_hyperparams=conv_hyperparams,
+              freeze_batchnorm=freeze_batchnorm,
+              name='FeatureMaps'))
+
+  def preprocess(self, resized_inputs):
+    """SSD preprocessing.
+
+    Maps pixel values to the range [-1, 1].
+
+    Args:
+      resized_inputs: a [batch, height, width, channels] float tensor
+        representing a batch of images.
+
+    Returns:
+      preprocessed_inputs: a [batch, height, width, channels] float tensor
+        representing a batch of images.
+    """
+    return (2.0 / 255.0) * resized_inputs - 1.0
+
+  def _extract_features(self, preprocessed_inputs):
+    """Extract features from preprocessed inputs.
+
+    Args:
+      preprocessed_inputs: a [batch, height, width, channels] float tensor
+        representing a batch of images.
+
+    Returns:
+      feature_maps: a list of tensors where the ith tensor has shape
+        [batch, height_i, width_i, depth_i]
+    """
+    preprocessed_inputs = shape_utils.check_min_image_dim(
+        33, preprocessed_inputs)
+
+    image_features = self.mobilenet_v2(
+        ops.pad_to_multiple(preprocessed_inputs, self._pad_to_multiple))
+
+    feature_maps = self.feature_map_generator({
+        'layer_15/expansion_output': image_features[0],
+        'layer_19': image_features[1]})
+
+    return feature_maps.values()

research/object_detection/object_detection_tutorial.ipynb

@@ -293,8 +293,6 @@
       "source": [
         "def load_image_into_numpy_array(image):\n",
         "  (im_width, im_height) = image.size\n",
-        "  if image.format == 'PNG':\n",
-        "      image = image.convert('RGB')\n",
         "  return np.array(image.getdata()).reshape(\n",
         "      (im_height, im_width, 3)).astype(np.uint8)"
       ]

research/object_detection/predictors/convolutional_keras_box_predictor_test.py

@@ -190,69 +190,6 @@ class ConvolutionalKerasBoxPredictorTest(test_case.TestCase):
     self.assertEqual(expected_variable_set, actual_variable_set)
 
   # TODO(kaftan): Remove conditional after CMLE moves to TF 1.10
-  # BEGIN GOOGLE-INTERNAL
-  def test_use_depthwise_convolution(self):
-    image_features = tf.placeholder(dtype=tf.float32, shape=[4, None, None, 64])
-    conv_box_predictor = (
-        box_predictor_builder.build_convolutional_keras_box_predictor(
-            is_training=False,
-            num_classes=0,
-            conv_hyperparams=self._build_conv_hyperparams(),
-            freeze_batchnorm=False,
-            inplace_batchnorm_update=False,
-            num_predictions_per_location_list=[5],
-            min_depth=0,
-            max_depth=32,
-            num_layers_before_predictor=1,
-            use_dropout=True,
-            dropout_keep_prob=0.8,
-            kernel_size=1,
-            box_code_size=4,
-            use_depthwise=True
-        ))
-    box_predictions = conv_box_predictor([image_features])
-    box_encodings = tf.concat(
-        box_predictions[box_predictor.BOX_ENCODINGS], axis=1)
-    objectness_predictions = tf.concat(
-        box_predictions[box_predictor.CLASS_PREDICTIONS_WITH_BACKGROUND],
-        axis=1)
-    init_op = tf.global_variables_initializer()
-
-    resolution = 32
-    expected_num_anchors = resolution*resolution*5
-    with self.test_session() as sess:
-      sess.run(init_op)
-      (box_encodings_shape,
-       objectness_predictions_shape) = sess.run(
-           [tf.shape(box_encodings), tf.shape(objectness_predictions)],
-           feed_dict={image_features:
-                      np.random.rand(4, resolution, resolution, 64)})
-      actual_variable_set = set(
-          [var.op.name for var in tf.trainable_variables()])
-    self.assertAllEqual(box_encodings_shape, [4, expected_num_anchors, 1, 4])
-    self.assertAllEqual(objectness_predictions_shape,
-                        [4, expected_num_anchors, 1])
-    expected_variable_set = set([
-        'BoxPredictor/PreHeadConvolutions_0/Conv2d_0_1x1_32/bias',
-        'BoxPredictor/PreHeadConvolutions_0/Conv2d_0_1x1_32/kernel',
-
-        'BoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor_depthwise/'
-        'bias',
-
-        'BoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor_depthwise/'
-        'depthwise_kernel',
-
-        'BoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor/bias',
-        'BoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor/kernel',
-        'BoxPredictor/ConvolutionalClassHead_0/ClassPredictor_depthwise/bias',
-
-        'BoxPredictor/ConvolutionalClassHead_0/ClassPredictor_depthwise/'
-        'depthwise_kernel',
-
-        'BoxPredictor/ConvolutionalClassHead_0/ClassPredictor/bias',
-        'BoxPredictor/ConvolutionalClassHead_0/ClassPredictor/kernel'])
-    self.assertEqual(expected_variable_set, actual_variable_set)
-  # END GOOGLE-INTERNAL
 
 if __name__ == '__main__':
   tf.test.main()

research/object_detection/predictors/heads/keras_box_head_test.py

@@ -57,22 +57,6 @@ class ConvolutionalKerasBoxHeadTest(test_case.TestCase):
     self.assertAllEqual([64, 323, 1, 4], box_encodings.get_shape().as_list())
 
   # TODO(kaftan): Remove conditional after CMLE moves to TF 1.10
-  # BEGIN GOOGLE-INTERNAL
-  def test_prediction_size_depthwise_true(self):
-    conv_hyperparams = self._build_conv_hyperparams()
-    box_prediction_head = keras_box_head.ConvolutionalBoxHead(
-        is_training=True,
-        box_code_size=4,
-        kernel_size=3,
-        conv_hyperparams=conv_hyperparams,
-        freeze_batchnorm=False,
-        num_predictions_per_location=1,
-        use_depthwise=True)
-    image_feature = tf.random_uniform(
-        [64, 17, 19, 1024], minval=-10.0, maxval=10.0, dtype=tf.float32)
-    box_encodings = box_prediction_head(image_feature)
-    self.assertAllEqual([64, 323, 1, 4], box_encodings.get_shape().as_list())
-  # END GOOGLE-INTERNAL
 
 if __name__ == '__main__':
   tf.test.main()

research/object_detection/predictors/heads/keras_class_head_test.py

@@ -60,25 +60,6 @@ class ConvolutionalKerasClassPredictorTest(test_case.TestCase):
                         class_predictions.get_shape().as_list())
 
   # TODO(kaftan): Remove conditional after CMLE moves to TF 1.10
-  # BEGIN GOOGLE-INTERNAL
-  def test_prediction_size_depthwise_true(self):
-    conv_hyperparams = self._build_conv_hyperparams()
-    class_prediction_head = keras_class_head.ConvolutionalClassHead(
-        is_training=True,
-        num_classes=20,
-        use_dropout=True,
-        dropout_keep_prob=0.5,
-        kernel_size=3,
-        conv_hyperparams=conv_hyperparams,
-        freeze_batchnorm=False,
-        num_predictions_per_location=1,
-        use_depthwise=True)
-    image_feature = tf.random_uniform(
-        [64, 17, 19, 1024], minval=-10.0, maxval=10.0, dtype=tf.float32)
-    class_predictions = class_prediction_head(image_feature,)
-    self.assertAllEqual([64, 323, 21],
-                        class_predictions.get_shape().as_list())
-  # END GOOGLE-INTERNAL
 
 if __name__ == '__main__':
   tf.test.main()

research/object_detection/predictors/heads/keras_mask_head_test.py

@@ -62,27 +62,6 @@ class ConvolutionalMaskPredictorTest(test_case.TestCase):
                         mask_predictions.get_shape().as_list())
 
   # TODO(kaftan): Remove conditional after CMLE moves to TF 1.10
-  # BEGIN GOOGLE-INTERNAL
-  def test_prediction_size_use_depthwise_true(self):
-    conv_hyperparams = self._build_conv_hyperparams()
-    mask_prediction_head = keras_mask_head.ConvolutionalMaskHead(
-        is_training=True,
-        num_classes=20,
-        use_dropout=True,
-        dropout_keep_prob=0.5,
-        kernel_size=3,
-        conv_hyperparams=conv_hyperparams,
-        freeze_batchnorm=False,
-        num_predictions_per_location=1,
-        use_depthwise=True,
-        mask_height=7,
-        mask_width=7)
-    image_feature = tf.random_uniform(
-        [64, 17, 19, 1024], minval=-10.0, maxval=10.0, dtype=tf.float32)
-    mask_predictions = mask_prediction_head(image_feature)
-    self.assertAllEqual([64, 323, 20, 7, 7],
-                        mask_predictions.get_shape().as_list())
-  # END GOOGLE-INTERNAL
 
   def test_class_agnostic_prediction_size_use_depthwise_false(self):
     conv_hyperparams = self._build_conv_hyperparams()
@@ -106,28 +85,6 @@ class ConvolutionalMaskPredictorTest(test_case.TestCase):
                         mask_predictions.get_shape().as_list())
 
   # TODO(kaftan): Remove conditional after CMLE moves to TF 1.10
-  # BEGIN GOOGLE-INTERNAL
-  def test_class_agnostic_prediction_size_use_depthwise_true(self):
-    conv_hyperparams = self._build_conv_hyperparams()
-    mask_prediction_head = keras_mask_head.ConvolutionalMaskHead(
-        is_training=True,
-        num_classes=20,
-        use_dropout=True,
-        dropout_keep_prob=0.5,
-        kernel_size=3,
-        conv_hyperparams=conv_hyperparams,
-        freeze_batchnorm=False,
-        num_predictions_per_location=1,
-        use_depthwise=True,
-        mask_height=7,
-        mask_width=7,
-        masks_are_class_agnostic=True)
-    image_feature = tf.random_uniform(
-        [64, 17, 19, 1024], minval=-10.0, maxval=10.0, dtype=tf.float32)
-    mask_predictions = mask_prediction_head(image_feature)
-    self.assertAllEqual([64, 323, 1, 7, 7],
-                        mask_predictions.get_shape().as_list())
-  # END GOOGLE-INTERNAL
 
 if __name__ == '__main__':
   tf.test.main()

research/object_detection/protos/eval.proto

@@ -4,6 +4,7 @@ package object_detection.protos;
 
 // Message for configuring DetectionModel evaluation jobs (eval.py).
 message EvalConfig {
+  optional uint32 batch_size = 25 [default=1];
   // Number of visualization images to generate.
   optional uint32 num_visualizations = 1 [default=10];
 

research/object_detection/utils/test_case.py

@@ -24,34 +24,6 @@ flags.DEFINE_bool('tpu_test', False, 'Whether to configure test for TPU.')
 FLAGS = flags.FLAGS
 
 
-# BEGIN GOOGLE-INTERNAL
-def hlo_memory_profile(function):
-  """Decorator to set environment variables that produce XLA HLO memory profile.
-
-  Args:
-    function: A function to run with XLA HLO profiling on.
-
-  Returns:
-    A decorated function that dumps the XLA HLO memory profile in test output
-    directory.
-
-  Usage:
-    @test_case.hlo_memory_profile
-    def test_run_my_tf_tpu_op(self):
-      ...
-
-    After running the test, access the memory profile proto from output files
-    and generate visualization using XLA memory visualizer.
-  """
-  def wrapper_func(*args, **kwargs):
-    outputs_dir = os.environ['TEST_UNDECLARED_OUTPUTS_DIR']
-    path_to_function = os.path.join(outputs_dir, 'hlo_memory_profile',
-                                    function.__name__)
-    os.environ['TF_XLA_FLAGS'] = (
-        '--xla_dump_optimized_hlo_proto_to=' + path_to_function)
-    return function(*args, **kwargs)
-  return wrapper_func
-# END GOOGLE-INTERNAL
 
 
 class TestCase(tf.test.TestCase):