[api-polish] Renaming api's (#1267)

arnavrneo · web-flow · commit 28e98c996ef3 · 2023-01-28T09:21:47.000-07:00
* API polish

* Update

* Update

* Update

* Typo fix

* Updated

* Update global_random_scaling_test.py

* Updated

* Update

* Update
diff --git a/keras_cv/layers/preprocessing_3d/frustum_random_dropping_points.py b/keras_cv/layers/preprocessing_3d/frustum_random_dropping_points.py
@@ -54,14 +54,16 @@ def __init__(self, r_distance, theta_width, phi_width, drop_rate=None, **kwargs)
         super().__init__(**kwargs)
 
         if r_distance < 0:
-            raise ValueError("r_distance must be >=0.")
+            raise ValueError(f"r_distance must be >=0, but got r_distance={r_distance}")
         if theta_width < 0:
-            raise ValueError("theta_width must be >=0.")
+            raise ValueError(
+                f"theta_width must be >=0, but got theta_width={theta_width}"
+            )
         if phi_width < 0:
-            raise ValueError("phi_width must be >=0.")
+            raise ValueError(f"phi_width must be >=0, but got phi_width={phi_width}")
         drop_rate = drop_rate if drop_rate else 0.0
         if drop_rate > 1:
-            raise ValueError("drop_rate must be <=1.")
+            raise ValueError(f"drop_rate must be <=1, but got drop_rate={drop_rate}")
 
         self._r_distance = r_distance
         self._theta_width = theta_width
diff --git a/keras_cv/layers/preprocessing_3d/global_random_scaling.py b/keras_cv/layers/preprocessing_3d/global_random_scaling.py
@@ -44,116 +44,110 @@ class GlobalRandomScaling(base_augmentation_layer_3d.BaseAugmentationLayer3D):
       A dictionary of Tensors with the same shape as input Tensors.
 
     Arguments:
-      scaling_factor_x: A tuple of float scalars or a float scalar sets the minimum and maximum scaling factors for the X axis.
-      scaling_factor_y: A tuple of float scalars or a float scalar sets the minimum and maximum scaling factors for the Y axis.
-      scaling_factor_z: A tuple of float scalars or a float scalar sets the minimum and maximum scaling factors for the Z axis.
+      x_factor: A tuple of float scalars or a float scalar sets the minimum and maximum scaling factors for the X axis.
+      y_factor: A tuple of float scalars or a float scalar sets the minimum and maximum scaling factors for the Y axis.
+      z_factor: A tuple of float scalars or a float scalar sets the minimum and maximum scaling factors for the Z axis.
     """
 
     def __init__(
         self,
-        scaling_factor_x=None,
-        scaling_factor_y=None,
-        scaling_factor_z=None,
-        same_scaling_xyz=False,
+        x_factor=None,
+        y_factor=None,
+        z_factor=None,
+        preserve_aspect_ratio=False,
         **kwargs
     ):
         super().__init__(**kwargs)
-        if not scaling_factor_x:
-            min_scaling_factor_x = 1.0
-            max_scaling_factor_x = 1.0
-        elif type(scaling_factor_x) is float:
-            min_scaling_factor_x = scaling_factor_x
-            max_scaling_factor_x = scaling_factor_x
+        if not x_factor:
+            min_x_factor = 1.0
+            max_x_factor = 1.0
+        elif type(x_factor) is float:
+            min_x_factor = x_factor
+            max_x_factor = x_factor
         else:
-            min_scaling_factor_x = scaling_factor_x[0]
-            max_scaling_factor_x = scaling_factor_x[1]
-        if not scaling_factor_y:
-            min_scaling_factor_y = 1.0
-            max_scaling_factor_y = 1.0
-        elif type(scaling_factor_y) is float:
-            min_scaling_factor_y = scaling_factor_y
-            max_scaling_factor_y = scaling_factor_y
+            min_x_factor = x_factor[0]
+            max_x_factor = x_factor[1]
+        if not y_factor:
+            min_y_factor = 1.0
+            max_y_factor = 1.0
+        elif type(y_factor) is float:
+            min_y_factor = y_factor
+            max_y_factor = y_factor
         else:
-            min_scaling_factor_y = scaling_factor_y[0]
-            max_scaling_factor_y = scaling_factor_y[1]
-        if not scaling_factor_z:
-            min_scaling_factor_z = 1.0
-            max_scaling_factor_z = 1.0
-        elif type(scaling_factor_z) is float:
-            min_scaling_factor_z = scaling_factor_z
-            max_scaling_factor_z = scaling_factor_z
+            min_y_factor = y_factor[0]
+            max_y_factor = y_factor[1]
+        if not z_factor:
+            min_z_factor = 1.0
+            max_z_factor = 1.0
+        elif type(z_factor) is float:
+            min_z_factor = z_factor
+            max_z_factor = z_factor
         else:
-            min_scaling_factor_z = scaling_factor_z[0]
-            max_scaling_factor_z = scaling_factor_z[1]
+            min_z_factor = z_factor[0]
+            max_z_factor = z_factor[1]
 
         if (
-            min_scaling_factor_x < 0
-            or max_scaling_factor_x < 0
-            or min_scaling_factor_y < 0
-            or max_scaling_factor_y < 0
-            or min_scaling_factor_z < 0
-            or max_scaling_factor_z < 0
+            min_x_factor < 0
+            or max_x_factor < 0
+            or min_y_factor < 0
+            or max_y_factor < 0
+            or min_z_factor < 0
+            or max_z_factor < 0
         ):
-            raise ValueError("min_scaling_factor and max_scaling_factor must be >=0.")
+            raise ValueError("min_factor and max_factor must be >=0.")
         if (
-            min_scaling_factor_x > max_scaling_factor_x
-            or min_scaling_factor_y > max_scaling_factor_y
-            or min_scaling_factor_z > max_scaling_factor_z
+            min_x_factor > max_x_factor
+            or min_y_factor > max_y_factor
+            or min_z_factor > max_z_factor
         ):
-            raise ValueError("min_scaling_factor must be less than max_scaling_factor.")
-        if same_scaling_xyz:
-            if (
-                min_scaling_factor_x != min_scaling_factor_y
-                or min_scaling_factor_y != min_scaling_factor_z
-            ):
+            raise ValueError("min_factor must be less than max_factor.")
+        if preserve_aspect_ratio:
+            if min_x_factor != min_y_factor or min_y_factor != min_z_factor:
                 raise ValueError(
-                    "min_scaling_factor must be the same when same_scaling_xyz is true."
+                    "min_factor must be the same when preserve_aspect_ratio is true."
                 )
-            if (
-                max_scaling_factor_x != max_scaling_factor_y
-                or max_scaling_factor_y != max_scaling_factor_z
-            ):
+            if max_x_factor != max_y_factor or max_y_factor != max_z_factor:
                 raise ValueError(
-                    "max_scaling_factor must be the same when same_scaling_xyz is true."
+                    "max_factor must be the same when preserve_aspect_ratio is true."
                 )
 
-        self._min_scaling_factor_x = min_scaling_factor_x
-        self._max_scaling_factor_x = max_scaling_factor_x
-        self._min_scaling_factor_y = min_scaling_factor_y
-        self._max_scaling_factor_y = max_scaling_factor_y
-        self._min_scaling_factor_z = min_scaling_factor_z
-        self._max_scaling_factor_z = max_scaling_factor_z
-        self._same_scaling_xyz = same_scaling_xyz
+        self._min_x_factor = min_x_factor
+        self._max_x_factor = max_x_factor
+        self._min_y_factor = min_y_factor
+        self._max_y_factor = max_y_factor
+        self._min_z_factor = min_z_factor
+        self._max_z_factor = max_z_factor
+        self._preserve_aspect_ratio = preserve_aspect_ratio
 
     def get_config(self):
         return {
-            "scaling_factor_x": (
-                self._min_scaling_factor_x,
-                self._max_scaling_factor_x,
+            "x_factor": (
+                self._min_x_factor,
+                self._max_x_factor,
             ),
-            "scaling_factor_y": (
-                self._min_scaling_factor_y,
-                self._max_scaling_factor_y,
+            "y_factor": (
+                self._min_y_factor,
+                self._max_y_factor,
             ),
-            "scaling_factor_z": (
-                self._min_scaling_factor_z,
-                self._max_scaling_factor_z,
+            "z_factor": (
+                self._min_z_factor,
+                self._max_z_factor,
             ),
-            "same_scaling_xyz": self._same_scaling_xyz,
+            "preserve_aspect_ratio": self._preserve_aspect_ratio,
         }
 
     def get_random_transformation(self, **kwargs):
 
         random_scaling_x = self._random_generator.random_uniform(
-            (), minval=self._min_scaling_factor_x, maxval=self._max_scaling_factor_x
+            (), minval=self._min_x_factor, maxval=self._max_x_factor
         )
         random_scaling_y = self._random_generator.random_uniform(
-            (), minval=self._min_scaling_factor_y, maxval=self._max_scaling_factor_y
+            (), minval=self._min_y_factor, maxval=self._max_y_factor
         )
         random_scaling_z = self._random_generator.random_uniform(
-            (), minval=self._min_scaling_factor_z, maxval=self._max_scaling_factor_z
+            (), minval=self._min_z_factor, maxval=self._max_z_factor
         )
-        if not self._same_scaling_xyz:
+        if not self._preserve_aspect_ratio:
             return {
                 "scale": tf.stack(
                     [random_scaling_x, random_scaling_y, random_scaling_z]
diff --git a/keras_cv/layers/preprocessing_3d/global_random_scaling_test.py b/keras_cv/layers/preprocessing_3d/global_random_scaling_test.py
@@ -24,9 +24,9 @@
 class GlobalScalingTest(tf.test.TestCase):
     def test_augment_point_clouds_and_bounding_boxes(self):
         add_layer = GlobalRandomScaling(
-            scaling_factor_x=(0.5, 1.5),
-            scaling_factor_y=(0.5, 1.5),
-            scaling_factor_z=(0.5, 1.5),
+            x_factor=(0.5, 1.5),
+            y_factor=(0.5, 1.5),
+            z_factor=(0.5, 1.5),
         )
         point_clouds = np.random.random(size=(2, 50, 10)).astype("float32")
         bounding_boxes = np.random.random(size=(2, 10, 7)).astype("float32")
@@ -36,10 +36,10 @@ def test_augment_point_clouds_and_bounding_boxes(self):
 
     def test_augment_point_clouds_and_bounding_boxes_with_same_scaling(self):
         add_layer = GlobalRandomScaling(
-            scaling_factor_x=(0.5, 1.5),
-            scaling_factor_y=(0.5, 1.5),
-            scaling_factor_z=(0.5, 1.5),
-            same_scaling_xyz=True,
+            x_factor=(0.5, 1.5),
+            y_factor=(0.5, 1.5),
+            z_factor=(0.5, 1.5),
+            preserve_aspect_ratio=True,
         )
         point_clouds = np.random.random(size=(2, 50, 10)).astype("float32")
         bounding_boxes = np.random.random(size=(2, 10, 7)).astype("float32")
@@ -49,9 +49,9 @@ def test_augment_point_clouds_and_bounding_boxes_with_same_scaling(self):
 
     def test_not_augment_point_clouds_and_bounding_boxes(self):
         add_layer = GlobalRandomScaling(
-            scaling_factor_x=(1.0, 1.0),
-            scaling_factor_y=(1.0, 1.0),
-            scaling_factor_z=(1.0, 1.0),
+            x_factor=(1.0, 1.0),
+            y_factor=(1.0, 1.0),
+            z_factor=(1.0, 1.0),
         )
         point_clouds = np.random.random(size=(2, 50, 10)).astype("float32")
         bounding_boxes = np.random.random(size=(2, 10, 7)).astype("float32")
@@ -61,9 +61,9 @@ def test_not_augment_point_clouds_and_bounding_boxes(self):
 
     def test_2x_scaling_point_clouds_and_bounding_boxes(self):
         add_layer = GlobalRandomScaling(
-            scaling_factor_x=(2.0, 2.0),
-            scaling_factor_y=(2.0, 2.0),
-            scaling_factor_z=(2.0, 2.0),
+            x_factor=(2.0, 2.0),
+            y_factor=(2.0, 2.0),
+            z_factor=(2.0, 2.0),
         )
         point_clouds = np.array([[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]] * 2] * 2).astype(
             "float32"
@@ -82,9 +82,9 @@ def test_2x_scaling_point_clouds_and_bounding_boxes(self):
 
     def test_augment_batch_point_clouds_and_bounding_boxes(self):
         add_layer = GlobalRandomScaling(
-            scaling_factor_x=(0.5, 1.5),
-            scaling_factor_y=(0.5, 1.5),
-            scaling_factor_z=(0.5, 1.5),
+            x_factor=(0.5, 1.5),
+            y_factor=(0.5, 1.5),
+            z_factor=(0.5, 1.5),
         )
         point_clouds = np.random.random(size=(3, 2, 50, 10)).astype("float32")
         bounding_boxes = np.random.random(size=(3, 2, 10, 7)).astype("float32")
@@ -94,9 +94,9 @@ def test_augment_batch_point_clouds_and_bounding_boxes(self):
 
     def test_not_augment_batch_point_clouds_and_bounding_boxes(self):
         add_layer = GlobalRandomScaling(
-            scaling_factor_x=(1.0, 1.0),
-            scaling_factor_y=(1.0, 1.0),
-            scaling_factor_z=(1.0, 1.0),
+            x_factor=(1.0, 1.0),
+            y_factor=(1.0, 1.0),
+            z_factor=(1.0, 1.0),
         )
         point_clouds = np.random.random(size=(3, 2, 50, 10)).astype("float32")
         bounding_boxes = np.random.random(size=(3, 2, 10, 7)).astype("float32")
diff --git a/keras_cv/layers/serialization_test.py b/keras_cv/layers/serialization_test.py
@@ -361,10 +361,10 @@ class SerializationTest(tf.test.TestCase, parameterized.TestCase):
             "GlobalRandomScaling",
             cv_layers.GlobalRandomScaling,
             {
-                "scaling_factor_x": (0.2, 1.0),
-                "scaling_factor_y": (0.3, 1.1),
-                "scaling_factor_z": (0.4, 1.3),
-                "same_scaling_xyz": False,
+                "x_factor": (0.2, 1.0),
+                "y_factor": (0.3, 1.1),
+                "z_factor": (0.4, 1.3),
+                "preserve_aspect_ratio": False,
             },
         ),
         (
diff --git a/keras_cv/losses/__init__.py b/keras_cv/losses/__init__.py
@@ -15,6 +15,8 @@
 from keras_cv.losses.focal import FocalLoss
 from keras_cv.losses.giou_loss import GIoULoss
 from keras_cv.losses.iou_loss import IoULoss
-from keras_cv.losses.penalty_reduced_focal_loss import BinaryPenaltyReducedFocalXent
+from keras_cv.losses.penalty_reduced_focal_loss import (
+    BinaryPenaltyReducedFocalCrossEntropy,
+)
 from keras_cv.losses.simclr_loss import SimCLRLoss
 from keras_cv.losses.smooth_l1 import SmoothL1Loss
diff --git a/keras_cv/losses/penalty_reduced_focal_loss.py b/keras_cv/losses/penalty_reduced_focal_loss.py
@@ -18,7 +18,7 @@
 # TODO(tanzhenyu): consider inherit from LossFunctionWrapper to
 # get the dimension squeeze.
 @tf.keras.utils.register_keras_serializable(package="keras_cv")
-class BinaryPenaltyReducedFocalXent(tf.keras.losses.Loss):
+class BinaryPenaltyReducedFocalCrossEntropy(tf.keras.losses.Loss):
     """Implements CenterNet modified Focal loss.
 
     Compared with `keras.losses.BinaryFocalCrossentropy`, this loss discounts for negative
@@ -56,7 +56,7 @@ def __init__(
         positive_weight=1.0,
         negative_weight=1.0,
         reduction=tf.keras.losses.Reduction.AUTO,
-        name="binary_penalty_reduced_focal_xent",
+        name="binary_penalty_reduced_focal_cross_entropy",
     ):
         super().__init__(reduction=reduction, name=name)
         self.alpha = alpha
diff --git a/keras_cv/losses/penalty_reduced_focal_loss_test.py b/keras_cv/losses/penalty_reduced_focal_loss_test.py
