def _CompareMaxPoolingBk(self, input_shape, output_shape, ksize, strides,
                          padding):
   # Generate numbers in a narrow range, so that there are many duplicates
   # in the input.
   tensor_input = np.random.random_integers(0, 3,
                                            input_shape).astype(np.float32)
   tensor_output = np.random.rand(*output_shape).astype(np.float32)
   with self.test_session(use_gpu=True):
     t = tf.constant(tensor_input, shape=input_shape)
     _, argmax_op = tf.nn.max_pool_with_argmax(t, ksize, strides, padding)
     argmax = argmax_op.eval()
     grad_in = tf.constant(tensor_output, shape=output_shape)
     out_op = gen_nn_ops._max_pool_grad_with_argmax(t, grad_in, argmax,
                                                    ksize, strides, padding)
     gpu_val = out_op.eval()
     self.assertShapeEqual(gpu_val, out_op)
   with self.test_session(use_gpu=False):
     t = tf.constant(tensor_input, shape=input_shape)
     out_op = tf.nn.max_pool(t, ksize, strides, padding)
     orig_out = out_op.eval()
     grad_in = tf.constant(tensor_output, shape=output_shape)
     out_op = gen_nn_ops._max_pool_grad(t, orig_out, grad_in, ksize,
                                        strides, padding)
     cpu_val = out_op.eval()
     self.assertShapeEqual(cpu_val, out_op)
   self.assertAllClose(cpu_val, gpu_val, rtol=1e-5, atol=1e-5)

 def _CompareMaxPoolingBk(self, input_shape, output_shape, ksize, strides,
                          padding):
   for dtype in np.float32, np.float16:
     # Generate numbers in a narrow range, so that there are many duplicates
     # in the input.
     tensor_input = np.random.random_integers(0, 3, input_shape).astype(dtype)
     tensor_output = np.random.rand(*output_shape).astype(dtype)
     with self.test_session(use_gpu=True):
       t = constant_op.constant(tensor_input, shape=input_shape)
       _, argmax_op = nn_ops.max_pool_with_argmax(t, ksize, strides, padding)
       argmax = argmax_op.eval()
       grad_in = constant_op.constant(tensor_output, shape=output_shape)
       out_op = gen_nn_ops._max_pool_grad_with_argmax(t, grad_in, argmax,
                                                      ksize, strides, padding)
       gpu_val = out_op.eval()
       self.assertShapeEqual(gpu_val, out_op)
     with self.test_session(use_gpu=False):
       t = constant_op.constant(tensor_input, shape=input_shape)
       out_op = nn_ops.max_pool(t, ksize, strides, padding)
       orig_out = out_op.eval()
       grad_in = constant_op.constant(tensor_output, shape=output_shape)
       out_op = gen_nn_ops._max_pool_grad(t, orig_out, grad_in, ksize, strides,
                                          padding)
       cpu_val = out_op.eval()
       self.assertShapeEqual(cpu_val, out_op)
     if dtype == np.float16:
       # The CPU version accumulates its gradient on fp16, so it's less
       # accurate than the GPU version that does the accumulation on fp32
       self.assertAllClose(cpu_val, gpu_val, rtol=0.01, atol=0.01)
     else:
       self.assertAllClose(cpu_val, gpu_val)

def _MaxPoolGrad(op, grad):
  return gen_nn_ops._max_pool_grad(op.inputs[0], op.outputs[0], grad,
                                   op.get_attr("ksize"),
                                   op.get_attr("strides"),
                                   padding=op.get_attr("padding"),
                                   data_format=op.get_attr("data_format")
                                  )

def _MaxPoolWithArgmaxGrad(op, grad, arg):
  return gen_nn_ops._max_pool_grad(op.inputs[0],
                                   op.outputs[0],
                                   grad,
                                   op.get_attr("ksize"),
                                   op.get_attr("strides"),
                                   padding=op.get_attr("padding"),
                                   data_format='NHWC')

def _MaxPoolGradGrad(op, grad):
    ksize = op.get_attr("ksize")
    strides = op.get_attr("strides")
    padding = op.get_attr("padding")
    data_format = op.get_attr("data_format")
    grads = []
    for i in op.inputs:
        igrad = gen_nn_ops._max_pool_grad(i, op.outputs[0], grad, ksize, strides,
                                          padding=padding,data_format=data_format)
        grads.append(igrad)

    return grads

def _MaxPoolGradGradGrad(op, grad):
  return (array_ops.zeros(shape=array_ops.shape(op.inputs[0]),
                          dtype=op.inputs[0].dtype),
          array_ops.zeros(shape=array_ops.shape(op.inputs[1]),
                          dtype=op.inputs[1].dtype),
          gen_nn_ops._max_pool_grad(op.inputs[0],
                                    op.inputs[1],
                                    grad,
                                    op.get_attr("ksize"),
                                    op.get_attr("strides"),
                                    padding=op.get_attr("padding"),
                                    data_format=op.get_attr("data_format")))

    def _MaxPoolGrad(self, orig_input, orig_output, grad, window_rows, window_cols, row_stride, col_stride, padding):
        """Max Pooling Gradient.

    Args:
      orig_input: A float Tensor. The original input tensor.
      orig_output: A float Tensor. The original output tensor.
      grad: A float Tensor.
        The 4D (batch x rows x cols x depth) output backprop.
      window_rows: integer. Kernel size along rows dimension.
      window_cols: integer. Kernel size along cols dimension.
      row_stride: integer. Stride along rows dimension
      col_stride: integer. Stride along cols dimension
      padding: PoolingOpDef.Padding.  Padding type.

    Returns:
      A Tensor.
    """
        return gen_nn_ops._max_pool_grad(
            orig_input, orig_output, grad, [1, window_rows, window_cols, 1], [1, row_stride, col_stride, 1], padding
        )

 def testDirectUseOverlapping(self):
   for num_batches in [1, 3]:
     for row_window_size in [2, 5]:
       for col_window_size in [2, 4]:
         num_rows = (row_window_size - 1) * 5 + 1
         num_cols = (col_window_size - 1) * 7 + 1
         for num_channels in [1, 2]:
           input_shape = (num_batches, num_rows, num_cols, num_channels)
           with self.test_session() as _:
             input_tensor = constant_op.constant(
                 self._GenerateUniqueRandomInputTensor(input_shape))
             window_size = [1, row_window_size, col_window_size, 1]
             stride_size = [1, row_window_size - 1, col_window_size - 1, 1]
             padding = "VALID"
             output_tensor = nn_ops.max_pool(input_tensor, window_size,
                                             stride_size, padding)
             output_data = output_tensor.eval()
             output_backprop = self._PRNG.randint(100, size=output_data.shape)
             input_backprop_tensor = gen_nn_ops._max_pool_grad(input_tensor,
                                                               output_tensor,
                                                               output_backprop,
                                                               window_size,
                                                               stride_size,
                                                               padding)
             input_backprop = input_backprop_tensor.eval()
             row_seq = list(range(0, num_rows, row_window_size - 1))
             col_seq = list(range(0, num_cols, col_window_size - 1))
             row_seq[-1] += 1
             col_seq[-1] += 1
             fmp_input_backprop_tensor = gen_nn_ops._fractional_max_pool_grad(
                 input_tensor,
                 output_tensor,
                 output_backprop,
                 row_seq,
                 col_seq,
                 overlapping=True)
             fmp_input_backprop = fmp_input_backprop_tensor.eval()
             self.assertShapeEqual(input_backprop, fmp_input_backprop_tensor)
             self.assertAllClose(input_backprop, fmp_input_backprop)