Update docs

Author: lululxvi

deepxde/gradients.py

@@ -97,6 +97,8 @@ def __call__(self, ys, xs, i=0, j=None):
 def jacobian(ys, xs, i=0, j=None):
     """Compute Jacobian matrix J: J[i][j] = dy_i/dx_j, where i=0,...,dim_y-1 and j=0,...,dim_x-1.
 
+    Use this function to compute first-order derivatives instead of ``tf.gradients()``, because
+
     - It is lazy evaluation, i.e., it only computes J[i][j] when needed.
     - It will remember the gradients that have already been computed to avoid duplicate computation.
 
@@ -135,27 +137,29 @@ def __call__(self, y, xs, component=None, i=0, j=0, grad_y=None):
         return self.Hs[key](i, j)
 
 
-def hessian(y, xs, component=None, i=0, j=0, grad_y=None):
+def hessian(ys, xs, component=None, i=0, j=0, grad_y=None):
     """Compute Hessian matrix H: H[i][j] = d^2y/dx_idx_j, where i,j=0,...,dim_x-1.
 
+    Use this function to compute second-order derivatives instead of ``tf.gradients()``, because
+
     - It is lazy evaluation, i.e., it only computes H[i][j] when needed.
     - It will remember the gradients that have already been computed to avoid duplicate computation.
 
     Args:
-        y: Output Tensor of shape (batch_size, 1) or (batch_size, dim_y > 1).
+        ys: Output Tensor of shape (batch_size, dim_y).
         xs: Input Tensor of shape (batch_size, dim_x).
-        component: If `y` has the shape (batch_size, dim_y > 1), then `y[:, component]` is used to compute the
-            Hessian. Do not use if `y` has the shape (batch_size, 1).
+        component: If dim_y > 1, then `ys[:, component]` is used as y to compute the Hessian. If dim_y = 1, `component`
+            must be ``None``.
         i (int):
         j (int):
-        grad_y: The gradient of `y` w.r.t. `xs`. Provide `grad_y` if known to avoid duplicate computation. `grad_y` can
+        grad_y: The gradient of y w.r.t. `xs`. Provide `grad_y` if known to avoid duplicate computation. `grad_y` can
             be computed from ``jacobian``. Even if you do not provide `grad_y`, there is no duplicate computation if
             you use ``jacobian`` to compute first-order derivatives.
 
     Returns:
         H[`i`][`j`].
     """
-    return hessian._fn(y, xs, component=component, i=i, j=j, grad_y=grad_y)
+    return hessian._fn(ys, xs, component=component, i=i, j=j, grad_y=grad_y)
 
 
 hessian._fn = Hessians()