Python gradient_checker_v2.compute_gradient函数代码示例

  def Test(self):
    if not use_static_shape_ or a_np_.dtype in (np.int32, np.int64, np.float16):
      self.skipTest("Skipping infeasible gradient test.")

    # Transpose and possibly conjugate a_np_ and b_np_ according to the
    # attributes such that tf.matmul(effective_a_np, effective_b_np, **kwargs)
    # results in a valid matrix multiplication and produces the same result as
    # np.matrix(a_np_) * np.matrix(b_np_)
    effective_a_np = _GetTransposedMatrices(a_np_, "a", kwargs_)
    effective_b_np = _GetTransposedMatrices(b_np_, "b", kwargs_)

    epsilon = np.finfo(a_np_.dtype).eps
    delta = epsilon**(1.0 / 3.0)
    tol = 20 * delta
    with self.session(), test_util.use_gpu():
      theoretical, numerical = gradient_checker_v2.compute_gradient(
          lambda x: math_ops.matmul(x, effective_b_np, **kwargs_),
          [effective_a_np],
          delta=delta)
      self.assertAllClose(theoretical, numerical, rtol=tol, atol=tol)

      theoretical, numerical = gradient_checker_v2.compute_gradient(
          lambda x: math_ops.matmul(effective_a_np, x, **kwargs_),
          [effective_b_np],
          delta=delta)
      self.assertAllClose(theoretical, numerical, rtol=tol, atol=tol)

 def testEmptySucceeds(self):
   def f(x):
     return array_ops.identity(x)
   x = constant_op.constant(np.random.random_sample((0, 3)),
                            dtype=dtypes.float32)
   for grad in gradient_checker.compute_gradient(f, [x]):
     self.assertEqual(grad[0].shape, (0, 0))
   error = gradient_checker.max_error(*gradient_checker.compute_gradient(
       f, [x]))
   self.assertEqual(error, 0)

 def testComplexConj(self):
   def f(x):
     return math_ops.conj(x)
   x = constant_op.constant(11 - 13j, dtype=dtypes.complex64)
   analytical, numerical = gradient_checker.compute_gradient(
       f, [x], delta=0.1)
   correct = np.array([[1, 0], [0, -1]])
   self.assertAllEqual(correct, analytical[0])
   self.assertAllClose(correct, numerical[0], rtol=2e-5)
   self.assertLess(
       gradient_checker.max_error(*gradient_checker.compute_gradient(
           f, [x], delta=0.1)), 2e-5)

 def testComplexConj(self):
   def f(x):
     return math_ops.conj(x)
   x_shape = ()
   x_dtype = dtypes.complex64
   x = constant_op.constant(_random_complex(x_shape, x_dtype))
   analytical, numerical = gradient_checker.compute_gradient(
       f, [x])
   correct = np.array([[1, 0], [0, -1]])
   self.assertAllEqual(correct, analytical[0])
   self.assertAllClose(correct, numerical[0], rtol=2e-5)
   x = constant_op.constant(_random_complex(x_shape, x_dtype))
   self.assertLess(
       gradient_checker.max_error(*gradient_checker.compute_gradient(
           f, [x])), 2e-5)

 def testComplexMul(self):
   if not context.executing_eagerly():
     return
   c = constant_op.constant(5 + 7j, dtype=dtypes.complex64)
   def f(x):
     return c * x
   x = constant_op.constant(11 - 13j, dtype=dtypes.complex64)
   analytical, numerical = gradient_checker.compute_gradient(
       f, [x], delta=0.1)
   correct = np.array([[5, 7], [-7, 5]])
   self.assertAllEqual(correct, analytical[0])
   self.assertAllClose(correct, numerical[0], rtol=1e-4)
   self.assertLess(
       gradient_checker.max_error(*gradient_checker.compute_gradient(
           f, [x], delta=0.1)), 2e-4)

 def testEmptyFails(self):
   @custom_gradient.custom_gradient
   def id_bad_grad(x):
     y = array_ops.identity(x)
     def grad_fn(dy):
       # dx = constant_op.constant(np.zeros((1, 4)), dtype=dtypes.float32)
       dx = array_ops.transpose(dy)
       return dx
     return y, grad_fn
   def f(x):
     return id_bad_grad(x)
   x = constant_op.constant(np.random.random_sample((0, 3)),
                            dtype=dtypes.float32)
   bad = r"Empty gradient has wrong shape: expected \(0, 3\), got \(3, 0\)"
   with self.assertRaisesRegexp(ValueError, bad):
     gradient_checker.compute_gradient(f, [x])

  def _gradientTest(self, diags, rhs, dtype=dtypes.float64):

    def reference_matmul(diags, rhs):
      matrix = self._makeTridiagonalMatrix(diags[..., 0, :-1], diags[..., 1, :],
                                           diags[..., 2, 1:])
      return math_ops.matmul(matrix, rhs)

    diags = constant_op.constant(diags, dtype=dtype)
    rhs = constant_op.constant(rhs, dtype=dtype)
    with self.cached_session(use_gpu=True):
      grad_reference, _ = gradient_checker_v2.compute_gradient(
          reference_matmul, [diags, rhs])
      grad_theoretical, grad_numerical = gradient_checker_v2.compute_gradient(
          linalg_impl.tridiagonal_matmul, [diags, rhs])
    self.assertAllClose(grad_theoretical, grad_numerical)
    self.assertAllClose(grad_theoretical, grad_reference)

 def testComplexMul(self):
   c = constant_op.constant(5 + 7j, dtype=dtypes.complex64)
   def f(x):
     return c * x
   x_shape = c.shape
   x_dtype = c.dtype
   x = constant_op.constant(_random_complex(x_shape, x_dtype))
   analytical, numerical = gradient_checker.compute_gradient(
       f, [x])
   correct = np.array([[5, 7], [-7, 5]])
   self.assertAllEqual(correct, analytical[0])
   self.assertAllClose(correct, numerical[0], rtol=1e-4)
   x = constant_op.constant(_random_complex(x_shape, x_dtype))
   self.assertLess(
       gradient_checker.max_error(*gradient_checker.compute_gradient(
           f, [x])), 3e-4)

 def testAddSimple(self):
   size = (2, 3)
   x1 = constant_op.constant(2.0, shape=size, name="x1")
   x2 = constant_op.constant(3.0, shape=size, name="x2")
   error = gradient_checker.max_error(*gradient_checker.compute_gradient(
       lambda x1: math_ops.add(x1, x2), [x1]))
   tf_logging.info("x1 error = %f", error)
   assert error < 1e-4

 def testGradientFloat64(self):
   with self.cached_session():
     x_val = [[-0.9, -0.7, -0.5, -0.3, -0.1], [0.1, 0.3, 0.5, 0.7, 0.9]]
     x = np.asarray(x_val, dtype=np.float64, order="F")
     err = gradient_checker_v2.max_error(
         *gradient_checker_v2.compute_gradient(nn_ops.selu, [x]))
   print("selu (float64) gradient err = ", err)
   self.assertLess(err, 1e-6)

 def testBroadcastingWithGradientChecker(self):
   for dtype in [dtypes.float32, dtypes.float64]:
     with self.cached_session():
       x1 = np.array([-1, 0, 1, 2, 3], dtype=dtype.as_numpy_dtype)
       x2 = np.array([2], dtype=dtype.as_numpy_dtype)
       err = gradient_checker_v2.max_error(
           *gradient_checker_v2.compute_gradient(
               lambda x: math_ops.nextafter(x, x2), [x1]))  # pylint: disable=cell-var-from-loop
       self.assertLess(err, 1e-3)

 def testGradientFloat32(self):
   with self.cached_session():
     x = np.asarray(
         [[-0.9, -0.7, -0.5, -0.3, -0.1], [0.1, 0.3, 0.5, 0.7, 0.9]],
         dtype=np.float32,
         order="F")
     err = gradient_checker_v2.max_error(
         *gradient_checker_v2.compute_gradient(nn_ops.leaky_relu, [x]))
   print("leaky_relu (float32) gradient err = ", err)
   self.assertLess(err, 1e-4)

 def testAddCustomized(self):
   size = (2, 3)
   x1 = constant_op.constant(
       2.0, shape=size, dtype=dtypes.float64, name="x1")
   x2 = np.asarray(np.arange(6, dtype=np.float64).reshape(2, 3))
   # checkint gradients for x2 using a special delta
   error = gradient_checker.max_error(*gradient_checker.compute_gradient(
       lambda x2: math_ops.add(x1, x2),
       [x2], delta=1e-2))
   tf_logging.info("x2 error = %f", error)
   assert error < 1e-10

 def testAddSimple(self):
   # if context.executing_eagerly():
   #   return
   np.random.seed(1)  # Fix seed to avoid flakiness
   size = (2, 3)
   x1 = constant_op.constant(2.0, shape=size, name="x1")
   x2 = constant_op.constant(3.0, shape=size, name="x2")
   error = gradient_checker.max_error(*gradient_checker.compute_gradient(
       lambda x1: math_ops.add(x1, x2), [x1]))
   tf_logging.info("x1 error = %f", error)
   assert error < 1e-4

  def testGradGrad(self):

    def f(x):
      with backprop.GradientTape() as tape:
        tape.watch(x)
        y = math_ops.square(x)
        z = math_ops.square(y)
      return tape.gradient(z, x)

    analytical, numerical = gradient_checker.compute_gradient(f, [2.0])
    self.assertAllEqual([[[48.]]], analytical)
    self.assertAllClose([[[48.]]], numerical, rtol=1e-4)