def _GetVal(use_xla):
      with self.cached_session():
        t0 = array_ops.placeholder(np.float32, shape=input_sizes)
        t1 = constant_op.constant(filter_sizes, shape=[len(filter_sizes)])
        t2 = array_ops.placeholder(np.float32, shape=output_sizes)
        native_t0 = t0
        native_t2 = t2
        strides = [1, stride, stride, 1]

        if use_xla:
          if data_format == "NCHW":
            # Transpose from NWHC input to NCHW
            # Ex. [4, 5, 5, 48] to [4, 48, 5, 5]
            native_t0 = array_ops.transpose(t0, [0, 3, 1, 2])
            native_t2 = array_ops.transpose(t2, [0, 3, 1, 2])
            strides = [1, 1, stride, stride]
          with self.test_scope():
            backprop = nn_ops.depthwise_conv2d_native_backprop_filter(
                native_t0,
                t1,
                native_t2,
                strides=strides,
                padding=padding,
                data_format=data_format)
        else:
          # For CPU, the format NCHW is not supported. Therefore we always use
          # NHWC here.
          backprop = nn_ops.depthwise_conv2d_native_backprop_filter(
              native_t0, t1, native_t2, strides=strides, padding=padding)
        ret = backprop.eval({t0: x0, t2: x2})
        self.assertShapeEqual(ret, backprop)
        return ret

 def _GetVal(use_xla):
   with self.test_session():
     t0 = array_ops.placeholder(np.float32, shape=input_sizes)
     t1 = constant_op.constant(filter_sizes, shape=[len(filter_sizes)])
     t2 = array_ops.placeholder(np.float32, shape=output_sizes)
     if use_xla:
       with self.test_scope():
         backprop = nn_ops.depthwise_conv2d_native_backprop_filter(
             t0, t1, t2, strides=[1, stride, stride, 1], padding=padding)
     else:
       backprop = nn_ops.depthwise_conv2d_native_backprop_filter(
           t0, t1, t2, strides=[1, stride, stride, 1], padding=padding)
     ret = backprop.eval({t0: x0, t2: x2})
     self.assertShapeEqual(ret, backprop)
     return ret

def _DepthwiseConv2dNativeBackpropInputGrad(op, grad):
  """The derivatives for deconvolution.

  Args:
    op: the Deconvolution op.
    grad: the tensor representing the gradient w.r.t. the output

  Returns:
    the gradients w.r.t. the input and the filter
  """
  return [
      None,
      nn_ops.depthwise_conv2d_native_backprop_filter(
          grad,
          array_ops.shape(op.inputs[1]),
          op.inputs[2],
          dilations=op.get_attr("dilations"),
          strides=op.get_attr("strides"),
          padding=op.get_attr("padding"),
          data_format=op.get_attr("data_format")),
      nn_ops.depthwise_conv2d_native(
          grad,
          op.inputs[1],
          dilations=op.get_attr("dilations"),
          strides=op.get_attr("strides"),
          padding=op.get_attr("padding"),
          data_format=op.get_attr("data_format"))
  ]

def _DepthwiseConv2dNativeGrad(op, grad):
  return [
      nn_ops.depthwise_conv2d_native_backprop_input(
          array_ops.shape(op.inputs[0]), op.inputs[1], grad,
          op.get_attr("strides"), op.get_attr("padding")),
      nn_ops.depthwise_conv2d_native_backprop_filter(
          op.inputs[0], array_ops.shape(op.inputs[1]), grad,
          op.get_attr("strides"), op.get_attr("padding"))
  ]

 def _GetVal(use_gpu):
   with self.cached_session(use_gpu=use_gpu):
     t0 = constant_op.constant(x0, shape=input_sizes)
     t1 = constant_op.constant(filter_sizes, shape=[len(filter_sizes)])
     t2 = constant_op.constant(x2, shape=output_sizes)
     backprop = nn_ops.depthwise_conv2d_native_backprop_filter(
         t0, t1, t2, strides=[1, stride, stride, 1], padding=padding)
     ret = self.evaluate(backprop)
     self.assertShapeEqual(ret, backprop)
     return ret