tf-models-nightly 2.17.0.dev20240312__py2.py3-none-any.whl → 2.17.0.dev20240314__py2.py3-none-any.whl

official/vision/ops/preprocess_ops_test.py

@@ -50,11 +50,13 @@ class InputUtilsTest(parameterized.TestCase, tf.test.TestCase):
     padding_shape = input_shape[:]
     padding_shape[0] = max(output_size - input_shape[0], 0)
     expected_outputs = np.concatenate(
-        [np.ones(clip_shape), np.zeros(padding_shape)], axis=0)
+        [np.ones(clip_shape), np.zeros(padding_shape)], axis=0
+    )
 
     data = tf.ones(input_shape)
     output_data = preprocess_ops.clip_or_pad_to_fixed_size(
-        data, output_size, constant_values=0)
+        data, output_size, constant_values=0
+    )
     output_data = output_data.numpy()
     self.assertAllClose(output_size, output_data.shape[0])
     self.assertAllClose(expected_outputs, output_data)
@@ -102,60 +104,81 @@ class InputUtilsTest(parameterized.TestCase, tf.test.TestCase):
       (100, 256, 128, 256, 32, 1.0, 1.0, 128, 256),
       (200, 512, 200, 128, 32, 0.25, 0.25, 224, 128),
   )
-  def test_resize_and_crop_image_rectangluar_case(self, input_height,
-                                                  input_width, desired_height,
-                                                  desired_width, stride,
-                                                  scale_y, scale_x,
-                                                  output_height, output_width):
-    image = tf.convert_to_tensor(
-        np.random.rand(input_height, input_width, 3))
+  def test_resize_and_crop_image_rectangluar_case(
+      self,
+      input_height,
+      input_width,
+      desired_height,
+      desired_width,
+      stride,
+      scale_y,
+      scale_x,
+      output_height,
+      output_width,
+  ):
+    image = tf.convert_to_tensor(np.random.rand(input_height, input_width, 3))
 
     desired_size = (desired_height, desired_width)
     resized_image, image_info = preprocess_ops.resize_and_crop_image(
         image,
         desired_size=desired_size,
-        padded_size=preprocess_ops.compute_padded_size(desired_size, stride))
+        padded_size=preprocess_ops.compute_padded_size(desired_size, stride),
+    )
     resized_image_shape = tf.shape(resized_image)
 
     self.assertAllEqual(
-        [output_height, output_width, 3],
-        resized_image_shape.numpy())
+        [output_height, output_width, 3], resized_image_shape.numpy()
+    )
     self.assertNDArrayNear(
-        [[input_height, input_width],
-         [desired_height, desired_width],
-         [scale_y, scale_x],
-         [0.0, 0.0]],
+        [
+            [input_height, input_width],
+            [desired_height, desired_width],
+            [scale_y, scale_x],
+            [0.0, 0.0],
+        ],
         image_info.numpy(),
-        1e-5)
+        1e-5,
+    )
 
   @parameterized.parameters(
       (100, 200, 220, 220, 32, 1.1, 1.1, 224, 224),
       (512, 512, 1024, 1024, 32, 2.0, 2.0, 1024, 1024),
   )
-  def test_resize_and_crop_image_square_case(self, input_height, input_width,
-                                             desired_height, desired_width,
-                                             stride, scale_y, scale_x,
-                                             output_height, output_width):
-    image = tf.convert_to_tensor(
-        np.random.rand(input_height, input_width, 3))
+  def test_resize_and_crop_image_square_case(
+      self,
+      input_height,
+      input_width,
+      desired_height,
+      desired_width,
+      stride,
+      scale_y,
+      scale_x,
+      output_height,
+      output_width,
+  ):
+    image = tf.convert_to_tensor(np.random.rand(input_height, input_width, 3))
 
     desired_size = (desired_height, desired_width)
     resized_image, image_info = preprocess_ops.resize_and_crop_image(
         image,
         desired_size=desired_size,
-        padded_size=preprocess_ops.compute_padded_size(desired_size, stride))
+        padded_size=preprocess_ops.compute_padded_size(desired_size, stride),
+    )
     resized_image_shape = tf.shape(resized_image)
 
     self.assertAllEqual(
-        [output_height, output_width, 3],
-        resized_image_shape.numpy())
+        [output_height, output_width, 3], resized_image_shape.numpy()
+    )
     self.assertNDArrayNear(
-        [[input_height, input_width],
-         [desired_height, desired_width],
-         [scale_y, scale_x],
-         [0.0, 0.0]],
+        [
+            [input_height, input_width],
+            [desired_height, desired_width],
+            [scale_y, scale_x],
+            [0.0, 0.0],
+        ],
         image_info.numpy(),
-        1e-5)
+        1e-5,
+    )
 
   @parameterized.parameters((1,), (2,))
   def test_resize_and_crop_image_tensor_desired_size(self, aug_scale_max):
@@ -166,7 +189,8 @@ class InputUtilsTest(parameterized.TestCase, tf.test.TestCase):
         image,
         desired_size=desired_size,
         padded_size=preprocess_ops.compute_padded_size(desired_size, 32),
-        aug_scale_max=aug_scale_max)
+        aug_scale_max=aug_scale_max,
+    )
     resized_image_shape = tf.shape(resized_image)
 
     self.assertAllEqual([224, 224, 3], resized_image_shape.numpy())
@@ -184,85 +208,108 @@ class InputUtilsTest(parameterized.TestCase, tf.test.TestCase):
       (100, 200, 80, 100, 32, 0.5, 0.5, 50, 100, 96, 128),
       (200, 100, 80, 100, 32, 0.5, 0.5, 100, 50, 128, 96),
   )
-  def test_resize_and_crop_image_v2(self, input_height, input_width, short_side,
-                                    long_side, stride, scale_y, scale_x,
-                                    desired_height, desired_width,
-                                    output_height, output_width):
-    image = tf.convert_to_tensor(
-        np.random.rand(input_height, input_width, 3))
+  def test_resize_and_crop_image_v2(
+      self,
+      input_height,
+      input_width,
+      short_side,
+      long_side,
+      stride,
+      scale_y,
+      scale_x,
+      desired_height,
+      desired_width,
+      output_height,
+      output_width,
+  ):
+    image = tf.convert_to_tensor(np.random.rand(input_height, input_width, 3))
     image_shape = tf.shape(image)[0:2]
 
     desired_size = tf.where(
         tf.greater(image_shape[0], image_shape[1]),
         tf.constant([long_side, short_side], dtype=tf.int32),
-        tf.constant([short_side, long_side], dtype=tf.int32))
+        tf.constant([short_side, long_side], dtype=tf.int32),
+    )
     resized_image, image_info = preprocess_ops.resize_and_crop_image_v2(
         image,
         short_side=short_side,
         long_side=long_side,
-        padded_size=preprocess_ops.compute_padded_size(desired_size, stride))
+        padded_size=preprocess_ops.compute_padded_size(desired_size, stride),
+    )
     resized_image_shape = tf.shape(resized_image)
 
     self.assertAllEqual(
-        [output_height, output_width, 3],
-        resized_image_shape.numpy())
+        [output_height, output_width, 3], resized_image_shape.numpy()
+    )
     self.assertNDArrayNear(
-        [[input_height, input_width],
-         [desired_height, desired_width],
-         [scale_y, scale_x],
-         [0.0, 0.0]],
+        [
+            [input_height, input_width],
+            [desired_height, desired_width],
+            [scale_y, scale_x],
+            [0.0, 0.0],
+        ],
         image_info.numpy(),
-        1e-5)
+        1e-5,
+    )
 
   @parameterized.parameters(
-      (400, 600), (600, 400),
+      (400, 600),
+      (600, 400),
   )
   def test_center_crop_image(self, input_height, input_width):
-    image = tf.convert_to_tensor(
-        np.random.rand(input_height, input_width, 3))
+    image = tf.convert_to_tensor(np.random.rand(input_height, input_width, 3))
     cropped_image = preprocess_ops.center_crop_image(image)
     cropped_image_shape = tf.shape(cropped_image)
     self.assertAllEqual([350, 350, 3], cropped_image_shape.numpy())
 
   @parameterized.parameters(
-      (400, 600), (600, 400),
+      (400, 600),
+      (600, 400),
   )
   def test_center_crop_image_v2(self, input_height, input_width):
     image_bytes = tf.constant(
         _encode_image(
             np.uint8(np.random.rand(input_height, input_width, 3) * 255),
-            fmt='JPEG'),
-        dtype=tf.string)
+            fmt='JPEG',
+        ),
+        dtype=tf.string,
+    )
     cropped_image = preprocess_ops.center_crop_image_v2(
-        image_bytes, tf.constant([input_height, input_width, 3], tf.int32))
+        image_bytes, tf.constant([input_height, input_width, 3], tf.int32)
+    )
     cropped_image_shape = tf.shape(cropped_image)
     self.assertAllEqual([350, 350, 3], cropped_image_shape.numpy())
 
   @parameterized.parameters(
-      (400, 600), (600, 400),
+      (400, 600),
+      (600, 400),
   )
   def test_random_crop_image(self, input_height, input_width):
-    image = tf.convert_to_tensor(
-        np.random.rand(input_height, input_width, 3))
+    image = tf.convert_to_tensor(np.random.rand(input_height, input_width, 3))
     _ = preprocess_ops.random_crop_image(image)
 
   @parameterized.parameters(
-      (400, 600), (600, 400),
+      (400, 600),
+      (600, 400),
   )
   def test_random_crop_image_v2(self, input_height, input_width):
     image_bytes = tf.constant(
         _encode_image(
             np.uint8(np.random.rand(input_height, input_width, 3) * 255),
-            fmt='JPEG'),
-        dtype=tf.string)
+            fmt='JPEG',
+        ),
+        dtype=tf.string,
+    )
     _ = preprocess_ops.random_crop_image_v2(
-        image_bytes, tf.constant([input_height, input_width, 3], tf.int32))
+        image_bytes, tf.constant([input_height, input_width, 3], tf.int32)
+    )
 
   @parameterized.parameters((400, 600, 0), (400, 600, 0.4), (600, 400, 1.4))
   def testColorJitter(self, input_height, input_width, color_jitter):
     image = tf.convert_to_tensor(np.random.rand(input_height, input_width, 3))
-    jittered_image = preprocess_ops.color_jitter(image, color_jitter,
-                                                 color_jitter, color_jitter)
+    jittered_image = preprocess_ops.color_jitter(
+        image, color_jitter, color_jitter, color_jitter
+    )
     assert jittered_image.shape == image.shape
 
   @parameterized.parameters((400, 600, 0), (400, 600, 0.4), (600, 400, 1))
@@ -281,42 +328,51 @@ class InputUtilsTest(parameterized.TestCase, tf.test.TestCase):
     left = np.random.randint(0, high=(input_width - boxes_width))
     right = left + boxes_width
     boxes = tf.constant(
-        np.concatenate([top, left, down, right], axis=-1), tf.float32)
+        np.concatenate([top, left, down, right], axis=-1), tf.float32
+    )
     labels = tf.constant(
-        np.random.randint(low=0, high=num_boxes, size=(num_boxes,)), tf.int64)
+        np.random.randint(low=0, high=num_boxes, size=(num_boxes,)), tf.int64
+    )
     _ = preprocess_ops.random_crop(image, boxes, labels)
 
   @parameterized.parameters(
       ((640, 640, 3), (1000, 1000), None, (1000, 1000, 3)),
       ((1280, 640, 3), 320, None, (640, 320, 3)),
       ((640, 1280, 3), 320, None, (320, 640, 3)),
-      ((640, 640, 3), 320, 100, (100, 100, 3)))
+      ((640, 640, 3), 320, 100, (100, 100, 3)),
+  )
   def test_resize_image(self, input_shape, size, max_size, expected_shape):
     resized_img, image_info = preprocess_ops.resize_image(
-        tf.zeros((input_shape)), size, max_size)
+        tf.zeros((input_shape)), size, max_size
+    )
     self.assertAllEqual(tf.shape(resized_img), expected_shape)
     self.assertAllEqual(image_info[0], input_shape[:-1])
     self.assertAllEqual(image_info[1], expected_shape[:-1])
     self.assertAllEqual(
         image_info[2],
-        np.array(expected_shape[:-1]) / np.array(input_shape[:-1]))
+        np.array(expected_shape[:-1]) / np.array(input_shape[:-1]),
+    )
     self.assertAllEqual(image_info[3], [0, 0])
 
   def test_resize_and_crop_masks(self):
     # shape: (2, 1, 4, 3)
-    masks = tf.constant([[[
-        [0, 1, 2],
-        [3, 4, 5],
-        [6, 7, 8],
-        [9, 10, 11],
-    ]], [[
-        [12, 13, 14],
-        [15, 16, 17],
-        [18, 19, 20],
-        [21, 22, 23],
-    ]]])
+    masks = tf.constant([
+        [[
+            [0, 1, 2],
+            [3, 4, 5],
+            [6, 7, 8],
+            [9, 10, 11],
+        ]],
+        [[
+            [12, 13, 14],
+            [15, 16, 17],
+            [18, 19, 20],
+            [21, 22, 23],
+        ]],
+    ])
     output = preprocess_ops.resize_and_crop_masks(
-        masks, image_scale=[2.0, 0.5], output_size=[2, 3], offset=[1, 0])
+        masks, image_scale=[2.0, 0.5], output_size=[2, 3], offset=[1, 0]
+    )
     # shape: (2, 2, 3, 3)
     expected_output = tf.constant([
         [
@@ -351,24 +407,30 @@ class InputUtilsTest(parameterized.TestCase, tf.test.TestCase):
       (512, 512, 1.0, 1024, 1024, 1024, 1024),
   )
   def test_deit3_resize_center_crop(
-      self, input_height, input_width, center_crop_fraction,
-      desired_height, desired_width,
-      output_height, output_width):
+      self,
+      input_height,
+      input_width,
+      center_crop_fraction,
+      desired_height,
+      desired_width,
+      output_height,
+      output_width,
+  ):
     # Make sure that with center_crop_ratio = 1; result has desired resolution.
-    image = tf.convert_to_tensor(
-        np.random.rand(input_height, input_width, 3))
+    image = tf.convert_to_tensor(np.random.rand(input_height, input_width, 3))
 
     desired_size = (desired_height, desired_width)
     center_cropped = preprocess_ops.center_crop_image(
-        image,
-        center_crop_fraction=center_crop_fraction)
+        image, center_crop_fraction=center_crop_fraction
+    )
     resized_image = tf.image.resize(
-        center_cropped, desired_size, method=tf.image.ResizeMethod.BICUBIC)
+        center_cropped, desired_size, method=tf.image.ResizeMethod.BICUBIC
+    )
     resized_image_shape = tf.shape(resized_image)
 
     self.assertAllEqual(
-        [output_height, output_width, 3],
-        resized_image_shape.numpy())
+        [output_height, output_width, 3], resized_image_shape.numpy()
+    )
 
   @parameterized.product(
       prenormalize=[True, False],
@@ -420,6 +482,46 @@ class InputUtilsTest(parameterized.TestCase, tf.test.TestCase):
     self.assertShapeEqual(input_image, aug_image)
     self.assertDTypeEqual(aug_image, np.uint8)
 
+  @parameterized.parameters(0.25, 0.5, 0.75, 1, 1.25, 1.5)
+  def test_resize_and_crop_image_and_masks(self, scale):
+    image = tf.convert_to_tensor(np.random.rand(1024, 2048, 3))
+    label = tf.convert_to_tensor(np.ones((1, 1024, 2048, 1), dtype=np.int32))
+    image, image_info = preprocess_ops.resize_and_crop_image(
+        image, (256, 256), (256, 256), scale, scale, centered_crop=True
+    )
+    image_scale = image_info[2, :]
+    offset = image_info[3, :]
+    label = preprocess_ops.resize_and_crop_masks(
+        label, image_scale, (256, 256), offset, centered_crop=True
+    )
+    self.assertEqual(image.shape[0:2], label.shape[1:3])
+    image_arr = image.numpy()
+    label_arr = np.squeeze(label.numpy())
+
+    scaled_height = round(1024 * 256 * scale / 2048)
+    scaled_width = round(2048 * 256 * scale / 2048)
+    height_offset = max((256 - scaled_height) // 2, 0)
+    width_offset = max((256 - scaled_width) // 2, 0)
+
+    self.assertEqual(
+        label_arr[
+            height_offset : 256 - height_offset,
+            width_offset : 256 - width_offset,
+        ].mean(),
+        1,
+    )
+    self.assertEqual(label_arr[0:height_offset, :].mean(), 0)
+    self.assertEqual(image_arr[0:height_offset, :, :].mean(), 0)
+    self.assertEqual(label_arr[256 - height_offset :, :].mean(), 0)
+    self.assertEqual(image_arr[256 - height_offset :, :, :].mean(), 0)
+    if width_offset > 0:
+      self.assertEqual(label_arr[height_offset, 0:width_offset].mean(), 0)
+      self.assertEqual(label_arr[height_offset, 256 - width_offset :].mean(), 0)
+      self.assertEqual(image_arr[height_offset, 0:width_offset, :].mean(), 0)
+      self.assertEqual(
+          image_arr[height_offset, 256 - width_offset :, :].mean(), 0
+      )
+
 
 if __name__ == '__main__':
   tf.test.main()

official/vision/serving/image_classification.py

@@ -33,12 +33,7 @@ class ClassificationModule(export_base.ExportModule):
         model_config=self.params.task.model,
         l2_regularizer=None)
 
-  def _build_inputs(self, image):
-    """Builds classification model inputs for serving."""
-    # Center crops and resizes image.
-    if isinstance(image, tf.RaggedTensor):
-      image = image.to_tensor()
-    image = tf.cast(image, dtype=tf.float32)
+  def _crop_and_resize(self, image):
     if self.params.task.train_data.aug_crop:
       image = preprocess_ops.center_crop_image(image)
 
@@ -48,6 +43,21 @@ class ClassificationModule(export_base.ExportModule):
     image = tf.reshape(
         image, [self._input_image_size[0], self._input_image_size[1], 3])
 
+    return image
+
+  def _build_inputs(self, image):
+    """Builds classification model inputs for serving."""
+    # Center crops and resizes image.
+    if isinstance(image, tf.RaggedTensor):
+      image = image.to_tensor()
+    image = tf.cast(image, dtype=tf.float32)
+
+    # For these input types, decode_image already performs cropping.
+    if not (
+        self._input_type in ['tf_example', 'image_bytes']
+        and len(self._input_image_size) == 2):
+      image = self._crop_and_resize(image)
+
     # Normalizes image with mean and std pixel values.
     image = preprocess_ops.normalize_image(
         image, offset=preprocess_ops.MEAN_RGB, scale=preprocess_ops.STDDEV_RGB)
@@ -72,14 +82,12 @@ class ClassificationModule(export_base.ExportModule):
           encoded_image_bytes, channels=self._num_channels
       )
       image_tensor.set_shape((None, None, self._num_channels))
-      # Resize image to input_size to support varible image resolutions in a
-      # batch for tf_example and image_bytes input type.
-      image_tensor = tf.image.resize(
-          tf.cast(image_tensor, tf.float32),
-          self._input_image_size,
-          method=tf.image.ResizeMethod.BILINEAR,
-      )
+      # Crop the image inside the same loop as decoding an image
+      # if there could be several images of different sizes in the batch.
+      image_tensor = tf.cast(image_tensor, dtype=tf.float32)
+      image_tensor = self._crop_and_resize(image_tensor)
       image_tensor = tf.cast(image_tensor, tf.uint8)
+      return image_tensor
     else:
       # Convert raw bytes into a tensor and reshape it, if not 2D input.
       image_tensor = tf.io.decode_raw(encoded_image_bytes, out_type=tf.uint8)

official/vision/tasks/semantic_segmentation.py

@@ -114,7 +114,8 @@ class SemanticSegmentationTask(base_task.Task):
         preserve_aspect_ratio=params.preserve_aspect_ratio,
         dtype=params.dtype,
         image_feature=params.image_feature,
-        additional_dense_features=params.additional_dense_features)
+        additional_dense_features=params.additional_dense_features,
+        centered_crop=params.centered_crop)
 
     reader = input_reader_factory.input_reader_generator(
         params,

{tf_models_nightly-2.17.0.dev20240312.dist-info → tf_models_nightly-2.17.0.dev20240314.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tf-models-nightly
-Version: 2.17.0.dev20240312
+Version: 2.17.0.dev20240314
 Summary: TensorFlow Official Models
 Home-page: https://github.com/tensorflow/models
 Author: Google Inc.

{tf_models_nightly-2.17.0.dev20240312.dist-info → tf_models_nightly-2.17.0.dev20240314.dist-info}/RECORD

@@ -965,7 +965,7 @@ official/vision/configs/maskrcnn.py,sha256=yL8kggxXaCTIpSkcozAV2UudO7UqVcEh1_-rM
 official/vision/configs/maskrcnn_test.py,sha256=Wfkbz30h2qxPcpuu6CEpQsf8I_2df6y10-4bRLsWlj8,1733
 official/vision/configs/retinanet.py,sha256=oCKinkh4IyPslmI1pakwi6dVziwjkZ2cIcpSoGRjqnM,17806
 official/vision/configs/retinanet_test.py,sha256=ffS3QufQMLF8FZhKNmi7Yr1RDTnIyZ1XKQ9agr2EyW8,1699
-official/vision/configs/semantic_segmentation.py,sha256=wN9ejI_KTOS4SasCHJTRRdV_3DWW0eiqvVWtArevP8o,30616
+official/vision/configs/semantic_segmentation.py,sha256=4ZAyLWKcFYReyrEWBc5b7wld3mMcuH0RcaRe_4J2RrA,30831
 official/vision/configs/semantic_segmentation_test.py,sha256=va-ZG6CtBKcs0NicZe6WmJvHxPxxih7nB0orNtrRiEA,1867
 official/vision/configs/video_classification.py,sha256=tf2XJhD_7c1Ned3eS93Sc0qrQ8U3M_zVJy09KI-9em8,14513
 official/vision/configs/video_classification_test.py,sha256=I1HSamxRQ3-f4-YHIeUChnT5CtHCxFQdiL0zy6RRUXU,1879
@@ -988,7 +988,7 @@ official/vision/dataloaders/input_reader_factory.py,sha256=WpvSA8qyqAo3wkmme4WqX
 official/vision/dataloaders/maskrcnn_input.py,sha256=iCc08yYD-7mvIPojgBjm_nSvoQACXWCIeZNZN8CfXSs,16822
 official/vision/dataloaders/parser.py,sha256=nMXnhigMa_ascSJ2OK88xi4HdE9xvfL3G4oMrHau-t4,2315
 official/vision/dataloaders/retinanet_input.py,sha256=joxJL4hQVPw-FW5iUc7RsxP60N7iYGRuVFpU3gC5flE,18291
-official/vision/dataloaders/segmentation_input.py,sha256=EV5mVYyDzmNefGtHTUw7tecMGpajTnyrfY7nV_zugnY,11838
+official/vision/dataloaders/segmentation_input.py,sha256=Klg5KAChYZDRvqzZfyIzdPy54rTlWYZp2AotolD3WX8,12934
 official/vision/dataloaders/tf_example_decoder.py,sha256=9yCT6uSLMpmw50w7zdaRR_BXy6vIvliLZntrYAgzD18,8647
 official/vision/dataloaders/tf_example_decoder_test.py,sha256=PHxneXHn5-eIMdmk1uI4IPLa178kTCifa4EF53ik2Jo,12629
 official/vision/dataloaders/tf_example_label_map_decoder.py,sha256=EHu6ZQvYxqjUliOlsN_f4okYt9Hdpydv_lM_dQwrklU,2598
@@ -1115,10 +1115,10 @@ official/vision/ops/iou_similarity_test.py,sha256=x5jlcMqMCUYC5cRgdbR0VlAW67AoXo
 official/vision/ops/mask_ops.py,sha256=cZLpIowzEA57bXPDbVXa6mktZVHvGSH-TQ1CxHjpQXw,10270
 official/vision/ops/mask_ops_test.py,sha256=D3xbbbleJd4HkpWOSDSEy6hNihsRBY93BqPF6JP-dJk,2835
 official/vision/ops/nms.py,sha256=bKYDAtyV5j6PG7g-RGF2ZccCI5V1xVvuajNblCy1TGs,8125
-official/vision/ops/preprocess_ops.py,sha256=DH6CsT74GJEzmfOxtTkwPxH0UoUqCXeAtgKwv8xBl0U,42172
+official/vision/ops/preprocess_ops.py,sha256=tDW9apUocwSzGnKkgSrKGwqbcZpb6-WQ8nGnW1_ds20,42569
 official/vision/ops/preprocess_ops_3d.py,sha256=K2583ynA9Zt9pOBNoWSD8KtQR1fwRYBoylJ9NusIBtI,16110
 official/vision/ops/preprocess_ops_3d_test.py,sha256=1MmygNfRBnQYGszsrKBGqP_GrPlP4_UGuddCbkYcIms,8364
-official/vision/ops/preprocess_ops_test.py,sha256=ane2INCrHUKJiMEERcQm1pKtugrORXnzwSWe7BDZUUw,15471
+official/vision/ops/preprocess_ops_test.py,sha256=FY3EUvQIb82fYqYJPmzkE7pmkhXIQrd7JNLGFPB6SXI,17213
 official/vision/ops/sampling_ops.py,sha256=1jywCA_E4qDUFWsykCLUwZsWtQSR0QREXdJhvP5qCvc,16072
 official/vision/ops/spatial_transform_ops.py,sha256=PVEJGAn0ygtsrid84vD5GgV0jsjyWoNn14RBzreMxM4,38389
 official/vision/ops/target_gather.py,sha256=Ir3X76yXYEVFSYX5h-yfS8SMkY37GYuypBP2C8ykggo,3965
@@ -1140,7 +1140,7 @@ official/vision/serving/export_tfhub_lib.py,sha256=BZC4XSbly0DLDSlWnphjWaD0Q6SOt
 official/vision/serving/export_tflite.py,sha256=OhIVHrcDvB83p4WroheWcTmeYArMV9TJcgUVJWytWIc,5115
 official/vision/serving/export_tflite_lib.py,sha256=2AWkyEsLvMBE19m2WAa0IpyFsHV8sIR4Gvcv5ZQWbmg,7272
 official/vision/serving/export_utils.py,sha256=8mJb1MF_6kk3lbqZOZq2Lwu4A2L1KWxjnWnV_ZpYlVI,4881
-official/vision/serving/image_classification.py,sha256=Pl2TG7Kjq3-DXh-MywjXQ1MvUmQQLWIer6NgA66iAMM,4300
+official/vision/serving/image_classification.py,sha256=wEthg6y-geVsRkAuQ1SKv-fnECMFXYuE1qR1H0yCVBA,4562
 official/vision/serving/image_classification_test.py,sha256=qZmuiQewptSQdY2iQEkx8rHjULybgADuXsQ84SjLCok,6759
 official/vision/serving/semantic_segmentation.py,sha256=1RmEOpYz-HjB-VKa3k9p3gZj3h_3ob5d-3RO9_cXfH0,4160
 official/vision/serving/semantic_segmentation_test.py,sha256=QVx12ciMA6T20d3wuKu8pe6ekEyPj8aNbKbRKxOgRik,5638
@@ -1150,7 +1150,7 @@ official/vision/tasks/__init__.py,sha256=qfhL5xyDrjZez_zjw613TyciLkqtWm-INFeES7G
 official/vision/tasks/image_classification.py,sha256=Oh4tH-SAD0-MmVfglE3pFXI6-LXVJr2C-WwbudnOdSk,16699
 official/vision/tasks/maskrcnn.py,sha256=iC8-OIFyYcQWpdbBODCXEag2R3YUNdQcZsn_wYAd8f0,25569
 official/vision/tasks/retinanet.py,sha256=EFILc2YPDeLqWcH7QtzN2k5sT5KdKQwioh12NKVOIqg,18261
-official/vision/tasks/semantic_segmentation.py,sha256=jpKzMSrhgXXD1y-HqvUtrcktCOEfL99C35uiaZval3U,14243
+official/vision/tasks/semantic_segmentation.py,sha256=hQBxyT1qZ1SQd4xHCWETiVNcQs96mYxPEXzdTMY8zTI,14287
 official/vision/tasks/video_classification.py,sha256=F4RnG_OvnayPDeWb8khEp8lFyM6CRWi_FlUaBOgsQjk,14318
 official/vision/utils/__init__.py,sha256=7oiypy0N82PDw9aSdcJBLVoGTd_oRSUOdvuJhMv4leQ,609
 official/vision/utils/ops_test.py,sha256=GqsKndrbfbpsfR6Bhs4gnMelXMVnO66CN5eNna-Wj7Y,4394
@@ -1203,9 +1203,9 @@ tensorflow_models/__init__.py,sha256=etxw45SHxuwFCRX5qGxGMP83II0JfJulzNl5GSNJvhw
 tensorflow_models/tensorflow_models_test.py,sha256=AxUYUdiQn416UR7jg0h6rmv688esvlKDfpyDCIQkF18,1395
 tensorflow_models/nlp/__init__.py,sha256=4tA5Pf4qaFwT-fIFOpX7x7FHJpnyJT-5UgOeFYTyMlc,807
 tensorflow_models/vision/__init__.py,sha256=zBorY_v5xva1uI-qxhZO3Qh-Dii-Suq6wEYh6hKHDfc,833
-tf_models_nightly-2.17.0.dev20240312.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
-tf_models_nightly-2.17.0.dev20240312.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
-tf_models_nightly-2.17.0.dev20240312.dist-info/METADATA,sha256=2VhigIlzb7NWsWlmWxnmRnw77A-xmVCRuT7ufErh2zs,1432
-tf_models_nightly-2.17.0.dev20240312.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-tf_models_nightly-2.17.0.dev20240312.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
-tf_models_nightly-2.17.0.dev20240312.dist-info/RECORD,,
+tf_models_nightly-2.17.0.dev20240314.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
+tf_models_nightly-2.17.0.dev20240314.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
+tf_models_nightly-2.17.0.dev20240314.dist-info/METADATA,sha256=rG9SC_Q5R5o4KDAZzsZhuLMumj4osPggvZYK-8MIPUM,1432
+tf_models_nightly-2.17.0.dev20240314.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+tf_models_nightly-2.17.0.dev20240314.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
+tf_models_nightly-2.17.0.dev20240314.dist-info/RECORD,,