CLN: use code_format.sh to format all files

Author: facaiy

tensorflow_addons/custom_ops/BUILD

@@ -7,7 +7,7 @@ py_library(
     srcs = ["__init__.py"],
     srcs_version = "PY2AND3",
     deps = [
-            "//tensorflow_addons/custom_ops/image:images_ops_py",
-            "//tensorflow_addons/custom_ops/text:text_py",
-        ]
+        "//tensorflow_addons/custom_ops/image:images_ops_py",
+        "//tensorflow_addons/custom_ops/text:text_py",
+    ],
 )

tensorflow_addons/custom_ops/image/BUILD

@@ -2,23 +2,25 @@ licenses(["notice"])  # Apache 2.0
 
 package(default_visibility = ["//visibility:public"])
 
-
 cc_binary(
     name = "python/_image_ops.so",
     srcs = [
         "cc/kernels/image_projective_transform_op.cc",
         "cc/kernels/image_projective_transform_op.h",
         "cc/ops/image_ops.cc",
     ],
+    copts = [
+        "-pthread",
+        "-std=c++11",
+        "-D_GLIBCXX_USE_CXX11_ABI=0",
+    ],
     linkshared = 1,
     deps = [
         "@local_config_tf//:libtensorflow_framework",
         "@local_config_tf//:tf_header_lib",
     ],
-    copts = ["-pthread", "-std=c++11", "-D_GLIBCXX_USE_CXX11_ABI=0"]
 )
 
-
 py_library(
     name = "images_ops_py",
     srcs = ([
@@ -27,23 +29,21 @@ py_library(
         "python/transform.py",
     ]),
     data = [
-        ":python/_image_ops.so"
+        ":python/_image_ops.so",
     ],
     srcs_version = "PY2AND3",
 )
 
-
 # TODO: use cuda_py_test later.
 py_test(
     name = "transform_ops_test",
     size = "small",
     srcs = [
-        "python/transform_test.py"
+        "python/transform_test.py",
     ],
     main = "python/transform_test.py",
+    srcs_version = "PY2AND3",
     deps = [
         ":images_ops_py",
     ],
-    srcs_version = "PY2AND3",
 )
-

tensorflow_addons/custom_ops/image/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Image manipulation ops"""
+"""Image manipulation ops."""
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function

tensorflow_addons/custom_ops/image/cc/kernels/image_projective_transform_op.cc

@@ -19,11 +19,11 @@ limitations under the License.
 #define EIGEN_USE_GPU
 #endif  // GOOGLE_CUDA
 
+#include "tensorflow_addons/custom_ops/image/cc/kernels/image_projective_transform_op.h"
 #include "tensorflow/core/framework/op_kernel.h"
 #include "tensorflow/core/framework/register_types.h"
 #include "tensorflow/core/framework/types.h"
 #include "tensorflow/core/platform/types.h"
-#include "tensorflow_addons/custom_ops/image/cc/kernels/image_projective_transform_op.h"
 
 namespace tensorflow {
 
@@ -73,12 +73,11 @@ class ImageProjectiveTransform : public OpKernel {
     const Tensor& transform_t = ctx->input(1);
     OP_REQUIRES(ctx, images_t.shape().dims() == 4,
                 errors::InvalidArgument("Input images must have rank 4"));
-    OP_REQUIRES(ctx,
-                (TensorShapeUtils::IsMatrix(transform_t.shape()) &&
-                 (transform_t.dim_size(0) == images_t.dim_size(0) ||
-                  transform_t.dim_size(0) == 1) &&
-                 transform_t.dim_size(1) ==
-                     ProjectiveGenerator<Device, T>::kNumParameters),
+    OP_REQUIRES(ctx, (TensorShapeUtils::IsMatrix(transform_t.shape()) &&
+                      (transform_t.dim_size(0) == images_t.dim_size(0) ||
+                       transform_t.dim_size(0) == 1) &&
+                      transform_t.dim_size(1) ==
+                          ProjectiveGenerator<Device, T>::kNumParameters),
                 errors::InvalidArgument(
                     "Input transform should be num_images x 8 or 1 x 8"));
 
@@ -106,9 +105,8 @@ class ImageProjectiveTransform : public OpKernel {
 
     Tensor* output_t;
     OP_REQUIRES_OK(ctx, ctx->allocate_output(
-                            0,
-                            TensorShape({images_t.dim_size(0), out_height,
-                                         out_width, images_t.dim_size(3)}),
+                            0, TensorShape({images_t.dim_size(0), out_height,
+                                            out_width, images_t.dim_size(3)}),
                             &output_t));
     auto output = output_t->tensor<T, 4>();
     auto images = images_t.tensor<T, 4>();

tensorflow_addons/custom_ops/image/cc/kernels/image_projective_transform_op.h

@@ -45,9 +45,9 @@ class ProjectiveGenerator {
   static const int kNumParameters = 8;
 
   EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
-  ProjectiveGenerator(typename TTypes<T, 4>::ConstTensor input,
-                      typename TTypes<float>::ConstMatrix transforms,
-                      const Interpolation interpolation)
+      ProjectiveGenerator(typename TTypes<T, 4>::ConstTensor input,
+                          typename TTypes<float>::ConstMatrix transforms,
+                          const Interpolation interpolation)
       : input_(input), transforms_(transforms), interpolation_(interpolation) {}
 
   EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T

tensorflow_addons/custom_ops/image/cc/kernels/image_projective_transform_op_gpu.cu.cc

@@ -17,10 +17,10 @@ limitations under the License.
 
 #define EIGEN_USE_GPU
 
+#include "tensorflow_addons/custom_ops/image/cc/kernels/image_projective_transform_op.h"
 #include "tensorflow/core/framework/register_types.h"
 #include "tensorflow/core/framework/types.h"
 #include "tensorflow/core/platform/types.h"
-#include "tensorflow_addons/custom_ops/image/cc/kernels/image_projective_transform_op.h"
 
 namespace tensorflow {
 

tensorflow_addons/custom_ops/image/python/transform.py

@@ -25,8 +25,10 @@
 _image_ops_so = tf.load_op_library(
     resource_loader.get_path_to_datafile("_image_ops.so"))
 
-_IMAGE_DTYPES = set([tf.dtypes.uint8, tf.dtypes.int32, tf.dtypes.int64,
-                     tf.dtypes.float16, tf.dtypes.float32, tf.dtypes.float64])
+_IMAGE_DTYPES = set([
+    tf.dtypes.uint8, tf.dtypes.int32, tf.dtypes.int64, tf.dtypes.float16,
+    tf.dtypes.float32, tf.dtypes.float64
+])
 
 ops.RegisterShape("ImageProjectiveTransform")(common_shapes.call_cpp_shape_fn)
 
@@ -66,13 +68,11 @@ def transform(images,
     Raises:
       TypeError: If `image` is an invalid type.
       ValueError: If output shape is not 1-D int32 Tensor.
-
     """
     with ops.name_scope(name, "transform"):
         image_or_images = ops.convert_to_tensor(images, name="images")
-        transform_or_transforms = ops.convert_to_tensor(transforms,
-                                                        name="transforms",
-                                                        dtype=tf.dtypes.float32)
+        transform_or_transforms = ops.convert_to_tensor(
+            transforms, name="transforms", dtype=tf.dtypes.float32)
         if image_or_images.dtype.base_dtype not in _IMAGE_DTYPES:
             raise TypeError("Invalid dtype %s." % image_or_images.dtype)
         elif image_or_images.get_shape().ndims is None:
@@ -89,9 +89,8 @@ def transform(images,
         if output_shape is None:
             output_shape = tf.shape(images)[1:3]
 
-        output_shape = ops.convert_to_tensor(output_shape,
-                                             tf.dtypes.int32,
-                                             name="output_shape")
+        output_shape = ops.convert_to_tensor(
+            output_shape, tf.dtypes.int32, name="output_shape")
 
         if not output_shape.get_shape().is_compatible_with([2]):
             raise ValueError(
@@ -134,15 +133,13 @@ def compose_transforms(*transforms):
       A composed transform tensor. When passed to `transform` op,
           equivalent to applying each of the given transforms to the image in
           order.
-
     """
     assert transforms, "transforms cannot be empty"
     with ops.name_scope("compose_transforms"):
         composed = flat_transforms_to_matrices(transforms[0])
         for tr in transforms[1:]:
             # Multiply batches of matrices.
-            composed = tf.matmul(composed,
-                                 flat_transforms_to_matrices(tr))
+            composed = tf.matmul(composed, flat_transforms_to_matrices(tr))
         return matrices_to_flat_transforms(composed)
 
 
@@ -163,22 +160,18 @@ def flat_transforms_to_matrices(transforms):
 
     Raises:
       ValueError: If `transforms` have an invalid shape.
-
     """
     with ops.name_scope("flat_transforms_to_matrices"):
         transforms = ops.convert_to_tensor(transforms, name="transforms")
         if transforms.shape.ndims not in (1, 2):
-            raise ValueError("Transforms should be 1D or 2D, got: %s" %
-                             transforms)
+            raise ValueError(
+                "Transforms should be 1D or 2D, got: %s" % transforms)
         # Make the transform(s) 2D in case the input is a single transform.
-        transforms = tf.reshape(transforms,
-                                tf.constant([-1, 8]))
+        transforms = tf.reshape(transforms, tf.constant([-1, 8]))
         num_transforms = tf.shape(transforms)[0]
         # Add a column of ones for the implicit last entry in the matrix.
         return tf.reshape(
-            tf.concat(
-                [transforms, tf.ones([num_transforms, 1])],
-                axis=1),
+            tf.concat([transforms, tf.ones([num_transforms, 1])], axis=1),
             tf.constant([-1, 3, 3]))
 
 
@@ -200,17 +193,15 @@ def matrices_to_flat_transforms(transform_matrices):
 
     Raises:
       ValueError: If `transform_matrices` have an invalid shape.
-
     """
     with ops.name_scope("matrices_to_flat_transforms"):
-        transform_matrices = ops.convert_to_tensor(transform_matrices,
-                                                   name="transform_matrices")
+        transform_matrices = ops.convert_to_tensor(
+            transform_matrices, name="transform_matrices")
         if transform_matrices.shape.ndims not in (2, 3):
-            raise ValueError("Matrices should be 2D or 3D, got: %s" %
-                             transform_matrices)
+            raise ValueError(
+                "Matrices should be 2D or 3D, got: %s" % transform_matrices)
         # Flatten each matrix.
-        transforms = tf.reshape(transform_matrices,
-                                tf.constant([-1, 9]))
+        transforms = tf.reshape(transform_matrices, tf.constant([-1, 9]))
         # Divide each matrix by the last entry (normally 1).
         transforms /= transforms[:, 8:9]
         return transforms[:, :8]
@@ -232,33 +223,35 @@ def angles_to_projective_transforms(angles,
     Returns:
       A tensor of shape (num_images, 8). Projective transforms which can be given
         to `transform` op.
-
     """
     with ops.name_scope(name, "angles_to_projective_transforms"):
-        angle_or_angles = ops.convert_to_tensor(angles,
-                                                name="angles",
-                                                dtype=tf.dtypes.float32)
+        angle_or_angles = ops.convert_to_tensor(
+            angles, name="angles", dtype=tf.dtypes.float32)
         if len(angle_or_angles.get_shape()) == 0:
             angles = angle_or_angles[None]
         elif len(angle_or_angles.get_shape()) == 1:
             angles = angle_or_angles
         else:
             raise TypeError("Angles should have rank 0 or 1.")
-        x_offset = ((image_width - 1) -
-                    (tf.math.cos(angles) * (image_width - 1) -
-                     tf.math.sin(angles) * (image_height - 1))) / 2.0
-        y_offset = ((image_height - 1) -
-                    (tf.math.sin(angles) * (image_width - 1) +
-                     tf.math.cos(angles) * (image_height - 1))) / 2.0
+        x_offset = (
+            (image_width - 1) -
+            (tf.math.cos(angles) * (image_width - 1) - tf.math.sin(angles) *
+             (image_height - 1))) / 2.0
+        y_offset = (
+            (image_height - 1) -
+            (tf.math.sin(angles) * (image_width - 1) + tf.math.cos(angles) *
+             (image_height - 1))) / 2.0
         num_angles = tf.shape(angles)[0]
         return tf.concat(
-            values=[tf.math.cos(angles)[:, None],
-                    -tf.math.sin(angles)[:, None],
-                    x_offset[:, None],
-                    tf.math.sin(angles)[:, None],
-                    tf.math.cos(angles)[:, None],
-                    y_offset[:, None],
-                    tf.zeros((num_angles, 2), tf.dtypes.float32),],
+            values=[
+                tf.math.cos(angles)[:, None],
+                -tf.math.sin(angles)[:, None],
+                x_offset[:, None],
+                tf.math.sin(angles)[:, None],
+                tf.math.cos(angles)[:, None],
+                y_offset[:, None],
+                tf.zeros((num_angles, 2), tf.dtypes.float32),
+            ],
             axis=1)
 
 
@@ -270,9 +263,8 @@ def _image_projective_transform_grad(op, grad):
     interpolation = op.get_attr("interpolation")
 
     image_or_images = ops.convert_to_tensor(images, name="images")
-    transform_or_transforms = ops.convert_to_tensor(transforms,
-                                                    name="transforms",
-                                                    dtype=tf.dtypes.float32)
+    transform_or_transforms = ops.convert_to_tensor(
+        transforms, name="transforms", dtype=tf.dtypes.float32)
 
     if image_or_images.dtype.base_dtype not in _IMAGE_DTYPES:
         raise TypeError("Invalid dtype %s." % image_or_images.dtype)