Code cleanup to allow TF V2 behavior but still disable eager execution.

Also resolved some simple warnings.

Author: mingxingtan

efficientdet/aug/autoaugment_test.py

@@ -33,6 +33,6 @@ def test_autoaugment_policy(self):
 
 
 if __name__ == '__main__':
-  tf.disable_v2_behavior()
+  tf.disable_eager_execution()
   tf.test.main()
 

efficientdet/backbone/efficientnet_builder_test.py

@@ -109,5 +109,6 @@ def test_efficientnet_b0_base(self):
 
 
 if __name__ == '__main__':
-  tf.disable_v2_behavior()
+  # Disable eager to allow tf.profile works for #params/#flops.
+  tf.disable_eager_execution()
   tf.test.main()

efficientdet/backbone/efficientnet_lite_builder_test.py

@@ -67,5 +67,6 @@ def test_efficientnet_b4(self):
 
 
 if __name__ == '__main__':
-  tf.disable_v2_behavior()
+  # Disable eager to allow tf.profile works for #params/#flops.
+  tf.disable_eager_execution()
   tf.test.main()

efficientdet/backbone/efficientnet_model.py

@@ -136,7 +136,6 @@ def superpixel_kernel_initializer(shape, dtype='float32', partition_info=None):
 
 def round_filters(filters, global_params, skip=False):
   """Round number of filters based on depth multiplier."""
-  orig_f = filters
   multiplier = global_params.width_coefficient
   divisor = global_params.depth_divisor
   min_depth = global_params.min_depth
@@ -149,7 +148,6 @@ def round_filters(filters, global_params, skip=False):
   # Make sure that round down does not go down by more than 10%.
   if new_filters < 0.9 * filters:
     new_filters += divisor
-  logging.info('round_filter input=%s output=%s', orig_f, new_filters)
   return int(new_filters)
 
 
@@ -342,7 +340,7 @@ def call(self, inputs, training=True, survival_prob=None):
     Returns:
       A output tensor.
     """
-    logging.info('Block input: %s shape: %s', inputs.name, inputs.shape)
+    logging.info('Block %s  input shape: %s', self.name, inputs.shape)
     x = inputs
 
     fused_conv_fn = self._fused_conv
@@ -355,21 +353,20 @@ def call(self, inputs, training=True, survival_prob=None):
       with tf.name_scope('super_pixel'):
         x = self._relu_fn(
             self._bnsp(self._superpixel(x), training=training))
-      logging.info(
-          'Block start with SuperPixel: %s shape: %s', x.name, x.shape)
+      logging.info('Block start with SuperPixel shape: %s', x.shape)
 
     if self._block_args.fused_conv:
       # If use fused mbconv, skip expansion and use regular conv.
       x = self._relu_fn(self._bn1(fused_conv_fn(x), training=training))
-      logging.info('Conv2D: %s shape: %s', x.name, x.shape)
+      logging.info('Conv2D shape: %s', x.shape)
     else:
       # Otherwise, first apply expansion and then apply depthwise conv.
       if self._block_args.expand_ratio != 1:
         x = self._relu_fn(self._bn0(expand_conv_fn(x), training=training))
-        logging.info('Expand: %s shape: %s', x.name, x.shape)
+        logging.info('Expand shape: %s', x.shape)
 
       x = self._relu_fn(self._bn1(depthwise_conv_fn(x), training=training))
-      logging.info('DWConv: %s shape: %s', x.name, x.shape)
+      logging.info('DWConv shape: %s', x.shape)
 
     if self._has_se:
       with tf.name_scope('se'):
@@ -391,7 +388,7 @@ def call(self, inputs, training=True, survival_prob=None):
         if survival_prob:
           x = utils.drop_connect(x, training, survival_prob)
         x = tf.add(x, inputs)
-    logging.info('Project: %s shape: %s', x.name, x.shape)
+    logging.info('Project shape: %s', x.shape)
     return x
 
 
@@ -440,12 +437,12 @@ def call(self, inputs, training=True, survival_prob=None):
     Returns:
       A output tensor.
     """
-    logging.info('Block input: %s shape: %s', inputs.name, inputs.shape)
+    logging.info('Block %s  input shape: %s', self.name, inputs.shape)
     if self._block_args.expand_ratio != 1:
       x = self._relu_fn(self._bn0(self._expand_conv(inputs), training=training))
     else:
       x = inputs
-    logging.info('Expand: %s shape: %s', x.name, x.shape)
+    logging.info('Expand shape: %s', x.shape)
 
     self.endpoints = {'expansion_output': x}
 
@@ -464,7 +461,7 @@ def call(self, inputs, training=True, survival_prob=None):
         if survival_prob:
           x = utils.drop_connect(x, training, survival_prob)
         x = tf.add(x, inputs)
-    logging.info('Project: %s shape: %s', x.name, x.shape)
+    logging.info('Project shape: %s', x.shape)
     return x
 
 

efficientdet/backbone/efficientnet_model_test.py

@@ -252,5 +252,4 @@ def test_reduction_endpoint_with_single_block_without_sp(self):
     self.assertNotIn('reduction_2', model.endpoints)
 
 if __name__ == '__main__':
-  tf.disable_v2_behavior()
   tf.test.main()

efficientdet/dataloader.py

@@ -71,26 +71,26 @@ def set_training_random_scale_factors(self, scale_min, scale_max):
     """Set the parameters for multiscale training."""
     # Select a random scale factor.
     random_scale_factor = tf.random_uniform([], scale_min, scale_max)
-    scaled_size_y = tf.to_int32(random_scale_factor * self._output_size[0])
-    scaled_size_x = tf.to_int32(random_scale_factor * self._output_size[1])
+    scaled_y = tf.cast(random_scale_factor * self._output_size[0], tf.int32)
+    scaled_x = tf.cast(random_scale_factor * self._output_size[1], tf.int32)
 
     # Recompute the accurate scale_factor using rounded scaled image size.
-    height = tf.shape(self._image)[0]
-    width = tf.shape(self._image)[1]
-    image_scale_y = tf.to_float(scaled_size_y) / tf.to_float(height)
-    image_scale_x = tf.to_float(scaled_size_x) / tf.to_float(width)
+    height = tf.cast(tf.shape(self._image)[0], tf.float32)
+    width = tf.cast(tf.shape(self._image)[1], tf.float32)
+    image_scale_y = tf.cast(scaled_y, tf.float32) / height
+    image_scale_x = tf.cast(scaled_x, tf.float32) / width
     image_scale = tf.minimum(image_scale_x, image_scale_y)
 
     # Select non-zero random offset (x, y) if scaled image is larger than
     # self._output_size.
-    scaled_height = tf.to_int32(tf.to_float(height) * image_scale)
-    scaled_width = tf.to_int32(tf.to_float(width) * image_scale)
-    offset_y = tf.to_float(scaled_height - self._output_size[0])
-    offset_x = tf.to_float(scaled_width - self._output_size[1])
+    scaled_height = tf.cast(height * image_scale, tf.int32)
+    scaled_width = tf.cast(width * image_scale, tf.int32)
+    offset_y = tf.cast(scaled_height - self._output_size[0], tf.float32)
+    offset_x = tf.cast(scaled_width - self._output_size[1], tf.float32)
     offset_y = tf.maximum(0.0, offset_y) * tf.random_uniform([], 0, 1)
     offset_x = tf.maximum(0.0, offset_x) * tf.random_uniform([], 0, 1)
-    offset_y = tf.to_int32(offset_y)
-    offset_x = tf.to_int32(offset_x)
+    offset_y = tf.cast(offset_y, tf.int32)
+    offset_x = tf.cast(offset_x, tf.int32)
     self._image_scale = image_scale
     self._scaled_height = scaled_height
     self._scaled_width = scaled_width
@@ -100,13 +100,13 @@ def set_training_random_scale_factors(self, scale_min, scale_max):
   def set_scale_factors_to_output_size(self):
     """Set the parameters to resize input image to self._output_size."""
     # Compute the scale_factor using rounded scaled image size.
-    height = tf.shape(self._image)[0]
-    width = tf.shape(self._image)[1]
-    image_scale_y = tf.to_float(self._output_size[0]) / tf.to_float(height)
-    image_scale_x = tf.to_float(self._output_size[1]) / tf.to_float(width)
+    height = tf.cast(tf.shape(self._image)[0], tf.float32)
+    width = tf.cast(tf.shape(self._image)[1], tf.float32)
+    image_scale_y = tf.cast(self._output_size[0], tf.float32) / height
+    image_scale_x = tf.cast(self._output_size[1], tf.float32) / width
     image_scale = tf.minimum(image_scale_x, image_scale_y)
-    scaled_height = tf.to_int32(tf.to_float(height) * image_scale)
-    scaled_width = tf.to_int32(tf.to_float(width) * image_scale)
+    scaled_height = tf.cast(height * image_scale, tf.int32)
+    scaled_width = tf.cast(width * image_scale, tf.int32)
     self._image_scale = image_scale
     self._scaled_height = scaled_height
     self._scaled_width = scaled_width
@@ -151,7 +151,7 @@ def resize_and_crop_boxes(self):
     # Adjust box coordinates based on the offset.
     box_offset = tf.stack([self._crop_offset_y, self._crop_offset_x,
                            self._crop_offset_y, self._crop_offset_x,])
-    boxes -= tf.to_float(tf.reshape(box_offset, [1, 4]))
+    boxes -= tf.cast(tf.reshape(box_offset, [1, 4]), tf.float32)
     # Clip the boxes.
     boxes = self.clip_boxes(boxes)
     # Filter out ground truth boxes that are all zeros.

efficientdet/efficientdet_arch_test.py

@@ -38,7 +38,7 @@ def build_model(self,
       inputs_shape = [1, 3, isize[0], isize[1]]
     else:
       inputs_shape = [1, isize[0], isize[1], 3]
-    inputs = tf.placeholder(tf.float32, name='input', shape=inputs_shape)
+    inputs = tf.ones(shape=inputs_shape, name='input', dtype=tf.float32)
     efficientdet_arch.efficientdet(
         inputs,
         model_name=model_name,
@@ -107,7 +107,7 @@ def _model_fn(inputs):
     return utils.build_model_with_precision(precision, _model_fn, features)
 
   def test_float16(self):
-    inputs = tf.placeholder(tf.float32, name='input', shape=[1, 512, 512, 3])
+    inputs = tf.ones(shape=[1, 512, 512, 3], name='input', dtype=tf.float32)
     cls_out, _ = self.build_model(inputs, True, 'mixed_float16')
     for v in tf.global_variables():
       # All variables should be float32.
@@ -117,7 +117,7 @@ def test_float16(self):
       self.assertIs(v.dtype, tf.float16)
 
   def test_bfloat16(self):
-    inputs = tf.placeholder(tf.float32, name='input', shape=[1, 512, 512, 3])
+    inputs = tf.ones(shape=[1, 512, 512, 3], name='input', dtype=tf.float32)
     cls_out, _ = self.build_model(inputs, True, 'mixed_bfloat16')
     for v in tf.global_variables():
       # All variables should be float32.
@@ -126,7 +126,7 @@ def test_bfloat16(self):
       self.assertEqual(v.dtype, tf.bfloat16)
 
   def test_float32(self):
-    inputs = tf.placeholder(tf.float32, name='input', shape=[1, 512, 512, 3])
+    inputs = tf.ones(shape=[1, 512, 512, 3], name='input', dtype=tf.float32)
     cls_out, _ = self.build_model(inputs, True, 'float32')
     for v in tf.global_variables():
       # All variables should be float32.
@@ -189,4 +189,5 @@ def test_bifpn_dynamic_l2l7(self):
 
 
 if __name__ == '__main__':
+  tf.disable_eager_execution()
   tf.test.main()

efficientdet/inference.py

@@ -244,9 +244,10 @@ def det_post_process_combined(params, cls_outputs, box_outputs, scales,
           clip_boxes=False))
   del valid_detections  # to be used in futue.
 
-  image_ids = tf.tile(
-      tf.expand_dims(tf.range(batch_size, dtype=tf.float32), axis=1),
-      [1, max_boxes_to_draw])
+  image_ids = tf.cast(
+      tf.tile(
+          tf.expand_dims(tf.range(batch_size), axis=1), [1, max_boxes_to_draw]),
+      dtype=tf.float32)
   y = nmsed_boxes[..., 0] * scales
   x = nmsed_boxes[..., 1] * scales
   height = nmsed_boxes[..., 2] * scales - y

efficientdet/main.py

@@ -394,5 +394,5 @@ def terminate_eval():
 
 
 if __name__ == '__main__':
-  tf.disable_v2_behavior()
+  tf.disable_eager_execution()
   tf.app.run(main)

efficientdet/model_inspect.py

@@ -160,6 +160,7 @@ def saved_model_inference(self, image_path_pattern, output_dir, **kwargs):
     # Serving time batch size should be fixed.
     batch_size = self.batch_size or 1
     all_files = list(tf.io.gfile.glob(image_path_pattern))
+    print('all_files=', all_files)
     num_batches = len(all_files) // batch_size
 
     for i in range(num_batches):
@@ -465,5 +466,5 @@ def main(_):
 
 if __name__ == '__main__':
   logging.set_verbosity(logging.WARNING)
-  tf.disable_v2_behavior()
+  tf.disable_eager_execution()
   tf.app.run(main)