Automated g4 rollback of changelist 166276461

PiperOrigin-RevId: 166305887

Author: tensorflower-gardener

tensorflow/contrib/fused_conv/BUILD

@@ -60,14 +60,12 @@ tf_kernel_library(
     srcs = [
         "kernels/fused_conv2d_bias_activation_op.cc",
         "kernels/fused_conv2d_bias_activation_op.h",
-        "kernels/fused_conv_ops_gpu.h",
     ],
     prefix = "fused_conv2d_bias_activation_op",
     deps = [
         "//tensorflow/core:framework",
         "//tensorflow/core:lib",
         "//tensorflow/core:lib_proto_parsing",
-        "//tensorflow/core:stream_executor",
         "//tensorflow/core/kernels:bounds_check_lib",
         "//tensorflow/core/kernels:conv_2d_hdrs",
         "//tensorflow/core/kernels:conv_ops_gpu_hdrs",
@@ -83,7 +81,6 @@ tf_custom_op_library(
     srcs = [
         "kernels/fused_conv2d_bias_activation_op.cc",
         "kernels/fused_conv2d_bias_activation_op.h",
-        "kernels/fused_conv_ops_gpu.h",
         "ops/fused_conv2d_bias_activation_op.cc",
     ],
     deps = [
@@ -97,8 +94,12 @@ tf_custom_op_library(
 )
 
 tf_gen_op_libs(
-    op_lib_names = ["fused_conv2d_bias_activation_op"],
-    deps = ["//tensorflow/core:lib_proto_parsing"],
+    op_lib_names = [
+        "fused_conv2d_bias_activation_op",
+    ],
+    deps = [
+        "//tensorflow/core:lib_proto_parsing",
+    ],
 )
 
 tf_gen_op_wrapper_py(
@@ -108,7 +109,7 @@ tf_gen_op_wrapper_py(
 
 cuda_py_test(
     name = "fused_conv2d_bias_activation_op_test",
-    size = "large",
+    size = "small",
     srcs = ["python/ops/fused_conv2d_bias_activation_op_test.py"],
     additional_deps = [
         ":fused_conv_py",

tensorflow/contrib/fused_conv/kernels/fused_conv2d_bias_activation_op.cc

@@ -24,7 +24,7 @@ limitations under the License.
 
 #if GOOGLE_CUDA
 #include "third_party/eigen3/unsupported/Eigen/CXX11/Tensor"
-#include "tensorflow/contrib/fused_conv/kernels/fused_conv_ops_gpu.h"
+#include "tensorflow/core/kernels/conv_ops_gpu.h"
 #include "tensorflow/core/platform/stream_executor.h"
 #endif  // GOOGLE_CUDA
 
@@ -33,30 +33,27 @@ namespace tensorflow {
 // Forward declaration.
 class OpKernelContext;
 
-template <typename Device, typename T, typename BiasType, typename ScaleType>
+template <typename Device, typename T>
 class LaunchFusedConv2DBiasActivationOp {
  public:
   void launch(OpKernelContext* ctx, bool cudnn_use_autotune,
-              const Tensor& conv_input, ScaleType conv_input_scale,
-              const Tensor& filter, int32 row_stride, int32 col_stride,
-              const Eigen::PaddingType& padding, const Tensor& side_input,
-              ScaleType side_input_scale, const Tensor& bias,
-              ActivationMode activation_mode, TensorFormat data_format,
-              FilterTensorFormat filter_format, Tensor* output);
+              const Tensor& input, const Tensor& filter, int row_stride,
+              int col_stride, const Tensor& bias,
+              const ActivationMode& activation_mode,
+              const Eigen::PaddingType& padding, TensorFormat data_format,
+              Tensor* output);
 };
 
 #ifdef GOOGLE_CUDA
-template <typename T, typename BiasType, typename ScaleType>
-class LaunchFusedConv2DBiasActivationOp<Eigen::GpuDevice, T, BiasType,
-                                        ScaleType> {
+template <typename T>
+class LaunchFusedConv2DBiasActivationOp<Eigen::GpuDevice, T> {
  public:
   void launch(OpKernelContext* ctx, bool cudnn_use_autotune,
-              const Tensor& conv_input, ScaleType conv_input_scale,
-              const Tensor& filter, int32 row_stride, int32 col_stride,
-              const Eigen::PaddingType& padding, const Tensor& side_input,
-              ScaleType side_input_scale, const Tensor& bias,
-              ActivationMode activation_mode, TensorFormat data_format,
-              FilterTensorFormat filter_format, Tensor* output);
+              const Tensor& input, const Tensor& filter, int32 row_stride,
+              int32 col_stride, const Tensor& bias,
+              const ActivationMode& activation_mode,
+              const Eigen::PaddingType& padding, TensorFormat data_format,
+              Tensor* output);
 };
 #endif  // GOOGLE_CUDA
 

tensorflow/contrib/fused_conv/kernels/fused_conv2d_bias_activation_op.h

@@ -33,73 +33,40 @@ string GetAllActivationModeAttrString() { return "activation_mode: {'Relu'}"; }
 }  // namespace
 
 // --------------------------------------------------------------------------
-
-// TODO(pauldonnelly): Add support for double inputs and scales to this Op,
-// (currently Attr does not support double).
-
 REGISTER_OP("FusedConv2DBiasActivation")
-    .Input("conv_input: T")
+    .Input("input: T")
     .Input("filter: T")
-    .Input("bias: Tbias")
-    .Input("side_input: T")
+    .Input("bias: T")
     .Output("output: T")
-    .Attr("T: {float, half, qint8}")
-    .Attr("Tbias: {float, half}")
-    .Attr("conv_input_scale: float = 1.0")
-    .Attr("side_input_scale: float = 0.0")
+    .Attr("T: {float}")
     .Attr("strides: list(int)")
     .Attr(GetPaddingAttrString())
-    .Attr("data_format: {'NHWC', 'NCHW', 'NCHW_VECT_C'} = 'NHWC'")
-    .Attr("filter_format: {'HWIO', 'OIHW', 'OIHW_VECT_I'} = 'HWIO'")
-    .Attr("activation_mode: {'Relu'} = 'Relu'")
+    .Attr(GetConvnetDataFormatAttrString())
+    .Attr(GetAllActivationModeAttrString())
     .SetShapeFn(shape_inference::FusedConvBiasActivationShape)
     .Doc(R"doc(
-    Computes a fused kernel which implements: 2-D convolution, adds side input,
-    with separate scaling on convolution and side inputs, then adds bias and
-    applies the RELU activation function to the result. Supports both float and
-    qint8 data formats. In the case of qint8, the output is clipped to [0..127].
+    Computes a fused 2-D convolution, adds bias, and applies an activation function
+    on the output given 4-D `input`, 4-D `filter`, 1-D `bias` tensors and an activation mode.
 
-    conv_input: A tensor with format as specified by `data_format` (see below).
-    filter: A tensor with format depending on `data_format` as follows:
-        "NHWC", "NCHW":
-             `float [ filter_height, filter_width, in_channels, out_channels ]`
-        "NCHW_VECT_C":
-             `qint8 [ out_channels, in_channels, filter_height, filter_width ]`
-    bias: 1-D float tensor with size matching the `out_channels` dimension of
-        `filter`.
-        Note: this tensor is still float, even if other inputs are qint8.
-    side_input: A tensor with format as specified by `data_format` (see below).
-        This tensor will be ignored and can be [] if side_input_scale == 0.
-        Otherwise, the size of each dimension must match the `output` tensor.
-    output: A tensor with format as specified by `data_format` (see below).
-        The dimension sizes are determined automatically based on other inputs
-        and attributes.
-    T: The element data type of `conv_input`, `side_input` and `output` tensors.
-        Note: must match with the `data_format`.
-    Tbias: The element data type of `bias`.
-    conv_input_scale: scalar float value to be multiplied by `conv_input`.
-        (conceptually.. in reality it is applied after convolution).
-    side_input_scale: scalar float value to be multiplied by `side_input`.
+    input: A 4-D tensor. The dimension order is interpreted according to the value
+        of `data_format`, see below for details.
+    filter: A 4-D tensor of shape
+        `[filter_height, filter_width, in_channels, out_channels]`
+    bias: 1-D with size of the `out_channels` dimension in filter.
+    output: A 4-D tensor. The dimension order is determined by the value of
+        `data_format`, see below for details.
+    T: The data type for the elements of input, filter, bias, and output Tensors.
     strides: 1-D tensor of length 4.  The stride of the sliding window for each
         dimension of `input`. The dimension order is determined by the value of
         `data_format`, see below for details.
-        Note: the stride for batch and channel dimensions must be 1.
     padding: The type of padding algorithm to use.
-    data_format: A string specifying the data format of `conv_input`,
-        `side_input` and `output` tensors with the following options:
-        "NHWC": `float [ batch, height, width, channels ]`
-        "NCHW": `float [ batch, channels, height, width ]`
-        "NCHW_VECT_C":
-            `qint8 [ batch, channels / 4, height, width, channels % 4 ]`
-        Note: for "NCHW_VECT_C", `channels` must be a multiple of 4.
-    filter_format: A string specifying the data format of `filter`,
-        "HWIO": `float [ kernel_height, kernel_width, input_channels,
-                         output_channels ]`
-        "OIHW_VECT_I":
-            `qint8 [ output_channels, input_channels / 4,
-                     kernel_height, kernel_width, input_channels % 4 ]`
-    activation_mode: The activation applied to the output.
-        Currently must be "Relu".
+    data_format: Specify the data format of the input and output data. With the
+        default format "NHWC", the data is stored in the order of:
+        [batch, height, width, channels].
+        Alternatively, the format could be "NCHW", the data storage order of:
+        [batch, channels, height, width].
+    activation_mode: Specify the activation function to apply to the output tensor
+        of bias add. Currently only supports "Relu".
 )doc");
 
 }  // namespace tensorflow

tensorflow/contrib/fused_conv/kernels/fused_conv_ops_gpu.h

@@ -26,83 +26,62 @@
     resource_loader.get_path_to_datafile("_fused_conv2d_bias_activation_op.so"))
 
 
-# pylint: disable=redefined-builtin
-def fused_conv2d_bias_activation(conv_input,
-                                 filter,
+def fused_conv2d_bias_activation(input_tensor,
+                                 filter_tensor,
                                  bias,
-                                 strides=None,
-                                 padding=None,
-                                 conv_input_scale=1.0,
-                                 side_input_scale=0.0,
-                                 side_input=None,
-                                 activation_mode="Relu",
+                                 strides,
+                                 padding,
+                                 activation_mode,
                                  data_format=None,
-                                 filter_format=None,
                                  name=None):
-  """Fused 2D conv, bias and activation with optional side input.
+  """Computes a fused 2-D convolution, adds bias, and applies relu.
 
-  Computes a fused 2-D convolution scaled by conv_input_scale,
-  adds an optional side input scaled by side_input_scale, adds biases,
-  and applies ReLU. As an equation:
-  output = ReLU(conv_input_scale * Conv(conv_input, filter) +
-                side_input_scale * side_input + bias)
-  Note: In int8 mode, The ReLU will clip the output to the range [0..127].
+      input_tensor: A 4-D tensor. The dimension order is interpreted
+      according to the value of `data_format`, see below for details.
+      filter_tensor: A 4-D tensor of shape
+          `[filter_height, filter_width, in_channels, out_channels]`
+      bias: 1-D with size of the `out_channels` dimension in filter.
+      output: A 4-D tensor. The dimension order is determined by the value of
+          `data_format`, see below for details.
+      T: The data type for the elements of input, filter, bias, and output
+      Tensors.
+      strides: 1-D tensor of length 4.  The stride of the sliding window for
+      each
+          dimension of `input`. The dimension order is determined by the value
+          of
+          `data_format`, see below for details.
+      padding: The type of padding algorithm to use.
+      data_format: Specify the data format of the input and output data. With
+      the
+          default format "NHWC", the data is stored in the order of:
+          [batch, height, width, channels].
+          Alternatively, the format could be "NCHW", the data storage order of:
+          [batch, channels, height, width].
+      activation_mode: Specify the activation function to apply to the output
+      tensor
+          of bias add. Currently only supports "Relu".
 
   Args:
-    conv_input: A `Tensor` of the format specified by `data_format`.
-    filter: A `Tensor` whose format depends on `data_format`:
-        if `data_format` is "NCHW_VECT_C", filter should be "OIHW_VECT_I"
-        otherwise, it should be "HWIO" format.
-    bias: A 1-D `Tensor` of type `float32`, and dimensions equal to the
-        number of output channels.
-    strides: A list of 4 `ints` specifying convolution strides.
-        if `data_format` is "NCHW" or "NCHW_VECT_C", the order should be NCHW.
-        if `data_format` is "NHWC", the order should be NHWC.
+    input_tensor: A `Tensor`. Must be one of the following types: `float32`.
+    filter_tensor: A `Tensor`. Must have the same type as `input`.
+    bias: A `Tensor`. Must have the same type as `input`.
+    strides: A list of `ints`.
     padding: A `string` from: `"SAME", "VALID"`.
-    conv_input_scale: A scalar `float32` that will be multiplied by conv_input.
-        This is optional and defaults to 1. However it should be set to
-        specify the quantization scale when `data_format` is "NCHW_VECT_C".
-    side_input_scale: A scalar `float32` that will be multiplied by side_input.
-        This is optional and defaults to 0.
-    side_input: A `Tensor` of the format specified by `data_format`.
-        This is useful for imlementing ResNet blocks.
-    activation_mode: (optional) currently must be the default "Relu".
-        Note that in qint8 mode, it also clips to 127, so acts like ReluX.
-    data_format: Specifies the data format.
-        Possible values are:
-        "NHWC" float [batch, height, width, channels]
-        "NCHW" float [batch, channels, height, width]
-        "NCHW_VECT_C" qint8 [batch, channels / 4, height, width, channels % 4]
-        Defaults to `"NHWC"`.
-        Performance is worst for `"NHWC"` and best for `"NCHW_VECT_C"`.
-    filter_format: Specifies the filter format.
-        Possible values are:
-        "HWIO" float [kernel_height, kernel_width, input_channels,
-                      output_channels ]
-        "OIHW" float [output_channels, input_channels, kernel_height,
-                      kernel_width ]
-        "OIHW_VECT_I" qint8 [ output_channels, input_channels / 4,
-                              kernel_height, kernel_width, input_channels % 4 ]
-        Defaults to `"HWIO"`.
+    activation_mode: A `string` from: `"Sigmoid", "Relu", "Relu6", "ReluX",
+      "Tanh", "BandPass"`.
+    data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to
+      `"NHWC"`.
     name: A name for the operation (optional).
 
   Returns:
-    A `Tensor` of the format specified by `data_format`.
+    A `Tensor`. Has the same type as `input`.
   """
-  if strides is None:
-    strides = [1, 1, 1, 1]
-  if side_input is None:
-    side_input = []
   return gen_fused_conv2d_bias_activation_op.fused_conv2d_bias_activation(
-      conv_input,
-      filter,
-      bias,
-      padding=padding,
+      input=input_tensor,
+      filter=filter_tensor,
+      bias=bias,
       strides=strides,
-      conv_input_scale=conv_input_scale,
-      side_input_scale=side_input_scale,
-      side_input=side_input,
+      padding=padding,
       activation_mode=activation_mode,
       data_format=data_format,
-      filter_format=filter_format,
       name=name)