Merge remote-tracking branch 'upstream/master' into add_multilevel_crop_and_resize

research/object_detection/models/ssd_pnasnet_feature_extractor.py

@@ -27,7 +27,10 @@ from object_detection.models import feature_map_generators
 from object_detection.utils import context_manager
 from object_detection.utils import ops
 from object_detection.utils import variables_helper
-from nets.nasnet import pnasnet
+try:
+  from nets.nasnet import pnasnet  # pylint: disable=g-import-not-at-top
+except:  # pylint: disable=bare-except
+  pass
 
 
 def pnasnet_large_arg_scope_for_detection(is_batch_norm_training=False):

research/object_detection/models/ssd_pnasnet_feature_extractor_test.py → research/object_detection/models/ssd_pnasnet_feature_extractor_tf1_test.py

@@ -14,13 +14,16 @@
 # ==============================================================================
 
 """Tests for ssd_pnas_feature_extractor."""
+import unittest
 import numpy as np
 import tensorflow.compat.v1 as tf
 
 from object_detection.models import ssd_feature_extractor_test
 from object_detection.models import ssd_pnasnet_feature_extractor
+from object_detection.utils import tf_version
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class SsdPnasNetFeatureExtractorTest(
     ssd_feature_extractor_test.SsdFeatureExtractorTestBase):
 

research/object_detection/models/ssd_resnet_v1_fpn_feature_extractor_testbase.py

@@ -19,24 +19,20 @@ from __future__ import division
 from __future__ import print_function
 
 import abc
-from absl.testing import parameterized
 import numpy as np
 from six.moves import zip
 import tensorflow.compat.v1 as tf
 
 from object_detection.models import ssd_feature_extractor_test
+from object_detection.utils import test_utils
 
 
-@parameterized.parameters(
-    {'use_keras': False},
-    {'use_keras': True},
-)
 class SSDResnetFPNFeatureExtractorTestBase(
     ssd_feature_extractor_test.SsdFeatureExtractorTestBase):
   """Helper test class for SSD Resnet v1 FPN feature extractors."""
 
   @abc.abstractmethod
-  def _resnet_scope_name(self, use_keras):
+  def _resnet_scope_name(self):
     pass
 
   @abc.abstractmethod
@@ -52,7 +48,7 @@ class SSDResnetFPNFeatureExtractorTestBase(
                                 use_keras=False):
     pass
 
-  def test_extract_features_returns_correct_shapes_256(self, use_keras):
+  def test_extract_features_returns_correct_shapes_256(self):
     image_height = 256
     image_width = 256
     depth_multiplier = 1.0
@@ -62,10 +58,10 @@ class SSDResnetFPNFeatureExtractorTestBase(
                                   (2, 2, 2, 256)]
     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=self.is_tf2())
 
   def test_extract_features_returns_correct_shapes_with_dynamic_inputs(
-      self, use_keras):
+      self):
     image_height = 256
     image_width = 256
     depth_multiplier = 1.0
@@ -75,10 +71,10 @@ class SSDResnetFPNFeatureExtractorTestBase(
                                   (2, 2, 2, 256)]
     self.check_extract_features_returns_correct_shapes_with_dynamic_inputs(
         2, image_height, image_width, depth_multiplier, pad_to_multiple,
-        expected_feature_map_shape, use_keras=use_keras)
+        expected_feature_map_shape, use_keras=self.is_tf2())
 
   def test_extract_features_returns_correct_shapes_with_depth_multiplier(
-      self, use_keras):
+      self):
     image_height = 256
     image_width = 256
     depth_multiplier = 0.5
@@ -91,10 +87,10 @@ class SSDResnetFPNFeatureExtractorTestBase(
                                   (2, 2, 2, expected_num_channels)]
     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)
+        expected_feature_map_shape, use_keras=self.is_tf2())
 
   def test_extract_features_returns_correct_shapes_with_min_depth(
-      self, use_keras):
+      self):
     image_height = 256
     image_width = 256
     depth_multiplier = 1.0
@@ -106,23 +102,24 @@ class SSDResnetFPNFeatureExtractorTestBase(
                                   (2, 4, 4, min_depth),
                                   (2, 2, 2, min_depth)]
 
-    def graph_fn(image_tensor):
+    with test_utils.GraphContextOrNone() as g:
+      image_tensor = tf.random.uniform([2, image_height, image_width, 3])
       feature_extractor = self._create_feature_extractor(
           depth_multiplier, pad_to_multiple, min_depth=min_depth,
-          use_keras=use_keras)
-      if use_keras:
+          use_keras=self.is_tf2())
+
+    def graph_fn():
+      if self.is_tf2():
         return feature_extractor(image_tensor)
       return feature_extractor.extract_features(image_tensor)
 
-    image_tensor = np.random.rand(2, image_height, image_width,
-                                  3).astype(np.float32)
-    feature_maps = self.execute(graph_fn, [image_tensor])
+    feature_maps = self.execute(graph_fn, [], graph=g)
     for feature_map, expected_shape in zip(feature_maps,
                                            expected_feature_map_shape):
       self.assertAllEqual(feature_map.shape, expected_shape)
 
   def test_extract_features_returns_correct_shapes_with_pad_to_multiple(
-      self, use_keras):
+      self):
     image_height = 254
     image_width = 254
     depth_multiplier = 1.0
@@ -133,55 +130,62 @@ class SSDResnetFPNFeatureExtractorTestBase(
 
     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)
+        expected_feature_map_shape, use_keras=self.is_tf2())
 
   def test_extract_features_raises_error_with_invalid_image_size(
-      self, use_keras):
+      self):
     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,
-        use_keras=use_keras)
+        use_keras=self.is_tf2())
 
-  def test_preprocess_returns_correct_value_range(self, use_keras):
+  def test_preprocess_returns_correct_value_range(self):
     image_height = 128
     image_width = 128
     depth_multiplier = 1
     pad_to_multiple = 1
-    test_image = tf.constant(np.random.rand(4, image_height, image_width, 3))
-    feature_extractor = self._create_feature_extractor(depth_multiplier,
-                                                       pad_to_multiple,
-                                                       use_keras=use_keras)
-    preprocessed_image = feature_extractor.preprocess(test_image)
-    with self.test_session() as sess:
-      test_image_out, preprocessed_image_out = sess.run(
-          [test_image, preprocessed_image])
-      self.assertAllClose(preprocessed_image_out,
-                          test_image_out - [[123.68, 116.779, 103.939]])
-
-  def test_variables_only_created_in_scope(self, use_keras):
+    test_image_np = np.random.rand(4, image_height, image_width, 3)
+    with test_utils.GraphContextOrNone() as g:
+      test_image = tf.constant(test_image_np)
+      feature_extractor = self._create_feature_extractor(
+          depth_multiplier, pad_to_multiple, use_keras=self.is_tf2())
+
+    def graph_fn():
+      preprocessed_image = feature_extractor.preprocess(test_image)
+      return preprocessed_image
+
+    preprocessed_image_out = self.execute(graph_fn, [], graph=g)
+    self.assertAllClose(preprocessed_image_out,
+                        test_image_np - [[123.68, 116.779, 103.939]])
+
+  def test_variables_only_created_in_scope(self):
+    if self.is_tf2():
+      self.skipTest('test_variables_only_created_in_scope is only tf1')
     depth_multiplier = 1
     pad_to_multiple = 1
-    scope_name = self._resnet_scope_name(use_keras)
+    scope_name = self._resnet_scope_name()
     self.check_feature_extractor_variables_under_scope(
         depth_multiplier,
         pad_to_multiple,
         scope_name,
-        use_keras=use_keras)
+        use_keras=self.is_tf2())
 
-  def test_variable_count(self, use_keras):
+  def test_variable_count(self):
+    if self.is_tf2():
+      self.skipTest('test_variable_count is only tf1')
     depth_multiplier = 1
     pad_to_multiple = 1
     variables = self.get_feature_extractor_variables(
         depth_multiplier,
         pad_to_multiple,
-        use_keras=use_keras)
+        use_keras=self.is_tf2())
     # The number of expected variables in resnet_v1_50, resnet_v1_101,
     # and resnet_v1_152 is 279, 534, and 789 respectively.
     expected_variables_len = 279
-    scope_name = self._resnet_scope_name(use_keras)
+    scope_name = self._resnet_scope_name()
     if scope_name in ('ResNet101V1_FPN', 'resnet_v1_101'):
       expected_variables_len = 534
     elif scope_name in ('ResNet152V1_FPN', 'resnet_v1_152'):

research/object_detection/models/ssd_resnet_v1_fpn_feature_extractor_test.py → research/object_detection/models/ssd_resnet_v1_fpn_feature_extractor_tf1_test.py

@@ -13,13 +13,15 @@
 # limitations under the License.
 # ==============================================================================
 """Tests for ssd resnet v1 FPN feature extractors."""
+import unittest
 import tensorflow.compat.v1 as tf
 
 from object_detection.models import ssd_resnet_v1_fpn_feature_extractor
 from object_detection.models import ssd_resnet_v1_fpn_feature_extractor_testbase
-from object_detection.models import ssd_resnet_v1_fpn_keras_feature_extractor
+from object_detection.utils import tf_version
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class SSDResnet50V1FeatureExtractorTest(
     ssd_resnet_v1_fpn_feature_extractor_testbase.
     SSDResnetFPNFeatureExtractorTestBase):
@@ -29,31 +31,17 @@ class SSDResnet50V1FeatureExtractorTest(
                                 use_explicit_padding=False, min_depth=32,
                                 use_keras=False):
     is_training = True
-    if use_keras:
-      return (ssd_resnet_v1_fpn_keras_feature_extractor.
-              SSDResNet50V1FpnKerasFeatureExtractor(
-                  is_training=is_training,
-                  depth_multiplier=depth_multiplier,
-                  min_depth=min_depth,
-                  pad_to_multiple=pad_to_multiple,
-                  conv_hyperparams=self._build_conv_hyperparams(
-                      add_batch_norm=False),
-                  freeze_batchnorm=False,
-                  inplace_batchnorm_update=False,
-                  name='ResNet50V1_FPN'))
-    else:
-      return (
-          ssd_resnet_v1_fpn_feature_extractor.SSDResnet50V1FpnFeatureExtractor(
-              is_training, depth_multiplier, min_depth, pad_to_multiple,
-              self.conv_hyperparams_fn,
-              use_explicit_padding=use_explicit_padding))
+    return (
+        ssd_resnet_v1_fpn_feature_extractor.SSDResnet50V1FpnFeatureExtractor(
+            is_training, depth_multiplier, min_depth, pad_to_multiple,
+            self.conv_hyperparams_fn,
+            use_explicit_padding=use_explicit_padding))
 
-  def _resnet_scope_name(self, use_keras=False):
-    if use_keras:
-      return 'ResNet50V1_FPN'
+  def _resnet_scope_name(self):
     return 'resnet_v1_50'
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class SSDResnet101V1FeatureExtractorTest(
     ssd_resnet_v1_fpn_feature_extractor_testbase.
     SSDResnetFPNFeatureExtractorTestBase):
@@ -63,31 +51,17 @@ class SSDResnet101V1FeatureExtractorTest(
                                 use_explicit_padding=False, min_depth=32,
                                 use_keras=False):
     is_training = True
-    if use_keras:
-      return (ssd_resnet_v1_fpn_keras_feature_extractor.
-              SSDResNet101V1FpnKerasFeatureExtractor(
-                  is_training=is_training,
-                  depth_multiplier=depth_multiplier,
-                  min_depth=min_depth,
-                  pad_to_multiple=pad_to_multiple,
-                  conv_hyperparams=self._build_conv_hyperparams(
-                      add_batch_norm=False),
-                  freeze_batchnorm=False,
-                  inplace_batchnorm_update=False,
-                  name='ResNet101V1_FPN'))
-    else:
-      return (
-          ssd_resnet_v1_fpn_feature_extractor.SSDResnet101V1FpnFeatureExtractor(
-              is_training, depth_multiplier, min_depth, pad_to_multiple,
-              self.conv_hyperparams_fn,
-              use_explicit_padding=use_explicit_padding))
+    return (
+        ssd_resnet_v1_fpn_feature_extractor.SSDResnet101V1FpnFeatureExtractor(
+            is_training, depth_multiplier, min_depth, pad_to_multiple,
+            self.conv_hyperparams_fn,
+            use_explicit_padding=use_explicit_padding))
 
-  def _resnet_scope_name(self, use_keras):
-    if use_keras:
-      return 'ResNet101V1_FPN'
+  def _resnet_scope_name(self):
     return 'resnet_v1_101'
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class SSDResnet152V1FeatureExtractorTest(
     ssd_resnet_v1_fpn_feature_extractor_testbase.
     SSDResnetFPNFeatureExtractorTestBase):
@@ -97,28 +71,13 @@ class SSDResnet152V1FeatureExtractorTest(
                                 use_explicit_padding=False, min_depth=32,
                                 use_keras=False):
     is_training = True
-    if use_keras:
-      return (ssd_resnet_v1_fpn_keras_feature_extractor.
-              SSDResNet152V1FpnKerasFeatureExtractor(
-                  is_training=is_training,
-                  depth_multiplier=depth_multiplier,
-                  min_depth=min_depth,
-                  pad_to_multiple=pad_to_multiple,
-                  conv_hyperparams=self._build_conv_hyperparams(
-                      add_batch_norm=False),
-                  freeze_batchnorm=False,
-                  inplace_batchnorm_update=False,
-                  name='ResNet152V1_FPN'))
-    else:
-      return (
-          ssd_resnet_v1_fpn_feature_extractor.SSDResnet152V1FpnFeatureExtractor(
-              is_training, depth_multiplier, min_depth, pad_to_multiple,
-              self.conv_hyperparams_fn,
-              use_explicit_padding=use_explicit_padding))
+    return (
+        ssd_resnet_v1_fpn_feature_extractor.SSDResnet152V1FpnFeatureExtractor(
+            is_training, depth_multiplier, min_depth, pad_to_multiple,
+            self.conv_hyperparams_fn,
+            use_explicit_padding=use_explicit_padding))
 
-  def _resnet_scope_name(self, use_keras):
-    if use_keras:
-      return 'ResNet152V1_FPN'
+  def _resnet_scope_name(self):
     return 'resnet_v1_152'
 
 

research/object_detection/models/ssd_resnet_v1_fpn_feature_extractor_tf2_test.py

+# 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 ssd resnet v1 FPN feature extractors."""
+import unittest
+import tensorflow.compat.v1 as tf
+
+from object_detection.models import ssd_resnet_v1_fpn_feature_extractor_testbase
+from object_detection.models import ssd_resnet_v1_fpn_keras_feature_extractor
+from object_detection.utils import tf_version
+
+
+@unittest.skipIf(tf_version.is_tf1(), 'Skipping TF2.X only test.')
+class SSDResnet50V1FeatureExtractorTest(
+    ssd_resnet_v1_fpn_feature_extractor_testbase.
+    SSDResnetFPNFeatureExtractorTestBase):
+  """SSDResnet50v1Fpn feature extractor test."""
+
+  def _create_feature_extractor(self, depth_multiplier, pad_to_multiple,
+                                use_explicit_padding=False, min_depth=32,
+                                use_keras=True):
+    is_training = True
+    return (ssd_resnet_v1_fpn_keras_feature_extractor.
+            SSDResNet50V1FpnKerasFeatureExtractor(
+                is_training=is_training,
+                depth_multiplier=depth_multiplier,
+                min_depth=min_depth,
+                pad_to_multiple=pad_to_multiple,
+                conv_hyperparams=self._build_conv_hyperparams(
+                    add_batch_norm=False),
+                freeze_batchnorm=False,
+                inplace_batchnorm_update=False,
+                name='ResNet50V1_FPN'))
+
+  def _resnet_scope_name(self):
+    return 'ResNet50V1_FPN'
+
+
+@unittest.skipIf(tf_version.is_tf1(), 'Skipping TF2.X only test.')
+class SSDResnet101V1FeatureExtractorTest(
+    ssd_resnet_v1_fpn_feature_extractor_testbase.
+    SSDResnetFPNFeatureExtractorTestBase):
+  """SSDResnet101v1Fpn feature extractor test."""
+
+  def _create_feature_extractor(self, depth_multiplier, pad_to_multiple,
+                                use_explicit_padding=False, min_depth=32,
+                                use_keras=False):
+    is_training = True
+    return (ssd_resnet_v1_fpn_keras_feature_extractor.
+            SSDResNet101V1FpnKerasFeatureExtractor(
+                is_training=is_training,
+                depth_multiplier=depth_multiplier,
+                min_depth=min_depth,
+                pad_to_multiple=pad_to_multiple,
+                conv_hyperparams=self._build_conv_hyperparams(
+                    add_batch_norm=False),
+                freeze_batchnorm=False,
+                inplace_batchnorm_update=False,
+                name='ResNet101V1_FPN'))
+
+  def _resnet_scope_name(self):
+    return 'ResNet101V1_FPN'
+
+
+@unittest.skipIf(tf_version.is_tf1(), 'Skipping TF2.X only test.')
+class SSDResnet152V1FeatureExtractorTest(
+    ssd_resnet_v1_fpn_feature_extractor_testbase.
+    SSDResnetFPNFeatureExtractorTestBase):
+  """SSDResnet152v1Fpn feature extractor test."""
+
+  def _create_feature_extractor(self, depth_multiplier, pad_to_multiple,
+                                use_explicit_padding=False, min_depth=32,
+                                use_keras=False):
+    is_training = True
+    return (ssd_resnet_v1_fpn_keras_feature_extractor.
+            SSDResNet152V1FpnKerasFeatureExtractor(
+                is_training=is_training,
+                depth_multiplier=depth_multiplier,
+                min_depth=min_depth,
+                pad_to_multiple=pad_to_multiple,
+                conv_hyperparams=self._build_conv_hyperparams(
+                    add_batch_norm=False),
+                freeze_batchnorm=False,
+                inplace_batchnorm_update=False,
+                name='ResNet152V1_FPN'))
+
+  def _resnet_scope_name(self):
+    return 'ResNet152V1_FPN'
+
+
+if __name__ == '__main__':
+  tf.test.main()

research/object_detection/models/ssd_resnet_v1_fpn_keras_feature_extractor.py

@@ -246,17 +246,6 @@ class SSDResNetV1FpnKerasFeatureExtractor(
       feature_maps.append(last_feature_map)
     return feature_maps
 
-  def restore_from_classification_checkpoint_fn(self, feature_extractor_scope):
-    """Returns a map for restoring from an (object-based) checkpoint.
-
-    Args:
-      feature_extractor_scope: A scope name for the feature extractor (unused).
-
-    Returns:
-      A dict mapping keys to Keras models
-    """
-    return {'feature_extractor': self.classification_backbone}
-
 
 class SSDResNet50V1FpnKerasFeatureExtractor(
     SSDResNetV1FpnKerasFeatureExtractor):

research/object_detection/models/ssd_resnet_v1_ppn_feature_extractor_test.py → research/object_detection/models/ssd_resnet_v1_ppn_feature_extractor_tf1_test.py

@@ -13,12 +13,15 @@
 # limitations under the License.
 # ==============================================================================
 """Tests for ssd resnet v1 feature extractors."""
+import unittest
 import tensorflow.compat.v1 as tf
 
 from object_detection.models import ssd_resnet_v1_ppn_feature_extractor
 from object_detection.models import ssd_resnet_v1_ppn_feature_extractor_testbase
+from object_detection.utils import tf_version
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class SSDResnet50V1PpnFeatureExtractorTest(
     ssd_resnet_v1_ppn_feature_extractor_testbase.
     SSDResnetPpnFeatureExtractorTestBase):
@@ -40,6 +43,7 @@ class SSDResnet50V1PpnFeatureExtractorTest(
     return 'resnet_v1_50'
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class SSDResnet101V1PpnFeatureExtractorTest(
     ssd_resnet_v1_ppn_feature_extractor_testbase.
     SSDResnetPpnFeatureExtractorTestBase):
@@ -62,6 +66,7 @@ class SSDResnet101V1PpnFeatureExtractorTest(
     return 'resnet_v1_101'
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class SSDResnet152V1PpnFeatureExtractorTest(
     ssd_resnet_v1_ppn_feature_extractor_testbase.
     SSDResnetPpnFeatureExtractorTestBase):

research/object_detection/predictors/convolutional_box_predictor_test.py → research/object_detection/predictors/convolutional_box_predictor_tf1_test.py

@@ -19,7 +19,7 @@
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
-
+import unittest
 from absl.testing import parameterized
 import numpy as np
 from six.moves import range
@@ -35,8 +35,10 @@ from object_detection.predictors.heads import class_head
 from object_detection.predictors.heads import mask_head
 from object_detection.protos import hyperparams_pb2
 from object_detection.utils import test_case
+from object_detection.utils import tf_version
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class ConvolutionalBoxPredictorTest(test_case.TestCase):
 
   def _build_arg_scope_with_conv_hyperparams(self):
@@ -281,6 +283,7 @@ class ConvolutionalBoxPredictorTest(test_case.TestCase):
     self.assertEqual(bad_dangling_ops, [])
 
 
+@unittest.skipIf(tf_version.is_tf2(), 'Skipping TF1.X only test.')
 class WeightSharedConvolutionalBoxPredictorTest(test_case.TestCase):
 
   def _build_arg_scope_with_conv_hyperparams(self):

research/object_detection/predictors/convolutional_keras_box_predictor.py

@@ -314,7 +314,8 @@ class WeightSharedConvolutionalBoxPredictor(box_predictor.KerasBoxPredictor):
       self, inserted_layer_counter, target_channel):
     projection_layers = []
     if inserted_layer_counter >= 0:
-      use_bias = False if self._apply_batch_norm else True
+      use_bias = False if (self._apply_batch_norm and not
+                           self._conv_hyperparams.force_use_bias()) else True
       projection_layers.append(keras.Conv2D(
           target_channel, [1, 1], strides=1, padding='SAME',
           name='ProjectionLayer/conv2d_{}'.format(inserted_layer_counter),
@@ -331,7 +332,8 @@ class WeightSharedConvolutionalBoxPredictor(box_predictor.KerasBoxPredictor):
     conv_layers = []
     batch_norm_layers = []
     activation_layers = []
-    use_bias = False if self._apply_batch_norm else True
+    use_bias = False if (self._apply_batch_norm and not
+                         self._conv_hyperparams.force_use_bias()) else True
     for additional_conv_layer_idx in range(self._num_layers_before_predictor):
       layer_name = '{}/conv2d_{}'.format(
           tower_name_scope, additional_conv_layer_idx)
@@ -363,7 +365,9 @@ class WeightSharedConvolutionalBoxPredictor(box_predictor.KerasBoxPredictor):
             training=(self._is_training and not self._freeze_batchnorm),
             name='{}/conv2d_{}/BatchNorm/feature_{}'.format(
                 tower_name_scope, additional_conv_layer_idx, feature_index)))
-      activation_layers.append(tf.keras.layers.Lambda(tf.nn.relu6))
+      activation_layers.append(self._conv_hyperparams.build_activation_layer(
+          name='{}/conv2d_{}/activation_{}'.format(
+              tower_name_scope, additional_conv_layer_idx, feature_index)))
 
     # Set conv layers as the shared conv layers for different feature maps with
     # the same tower_name_scope.