mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/function/clip_func.py

@@ -22,28 +22,95 @@ from mindspore.ops import functional as F
 from mindspore.nn.cell import Cell
 from mindspore.common.tensor import Tensor
 from mindspore.common import dtype as mstype
-from mindspore.ops.primitive import constexpr
+from mindspore.common.api import jit
+from mindspore.ops.primitive import _primexpr
 from mindspore import _checkparam as Validator
-from mindspore.ops._primitive_cache import _get_cache_prim
 
 __all__ = [
     'clip_by_value',
+    'clip_by_norm',
     'clamp',
     'clip',
     'clip_by_global_norm',
 ]
 
 hyper_map = C.HyperMap()
-max_op = _get_cache_prim(P.Maximum)()
-min_op = _get_cache_prim(P.Minimum)()
-cast_op = _get_cache_prim(P.Cast)()
-scalar2tensor_op = _get_cache_prim(P.ScalarToTensor)()
-partial_op = _get_cache_prim(P.Partial)()
+max_op = P.Maximum()
+min_op = P.Minimum()
+cast_op = P.Cast()
+scalar2tensor_op = P.ScalarToTensor()
+partial_op = P.Partial()
 expand_dims = P.ExpandDims().add_prim_attr("grad_scale", True)
 get_square_sum = C.MultitypeFuncGraph("get_square_sum")
 apply_global_norm = C.MultitypeFuncGraph("apply_global_norm")
 
 
+def _old_norm(norm_type, x):
+    """Add norm function"""
+    out = F.pow((F.reduce_sum(F.pow(x, norm_type))), 1. / norm_type).astype(x.dtype)
+    return out
+
+
+@jit
+def _cal_total_norm(x, norm_type):
+    if norm_type == float('inf'):
+        func = lambda data: data.abs().max()
+        total_norm = max(hyper_map(func, x))
+    else:
+        total_norm = _old_norm(norm_type, F.stack(hyper_map(partial_op(_old_norm, norm_type), x)))
+    return total_norm
+
+
+def clip_by_norm(x, max_norm, norm_type=2.0, error_if_nonfinite=False):
+    r"""
+    Clip norm of a set of input Tensors. This norm is the result of calculating the norm of all elements in the input
+    separately, connecting them into a vector, and then calculating the norm.
+
+    Note:
+        The interface is suitable for gradient clipping scenarios, and only supports input of type float.
+
+    Args:
+          x (Union(Tensor, list[Tensor], tuple[Tensor])): Input that wishes to be clipped.
+          max_norm (Union(float, int)): The upper limit of the norm for this group of network parameters.
+          norm_type (Union(float, int)): Norm type. Default: ``2.0``.
+          error_if_nonfinite (bool): If it is ``True``, an exception is thrown if the total norm from the input
+              is nan, inf or -inf. If it is ``False``, no exception will be thrown.Default: ``False`` .
+
+    Returns:
+        Tensors, a list or tuple of Tensors, representing clipped Tensors.
+
+    Raises:
+          RuntimeError: If the total norm from the `x` is nan, inf or -inf.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor([[0.8748, 0.1425, 0.0076], [0.7721, 0.4084, 0.0552], [4.6376, 0.2914, 2.1120]])
+        >>> out = ops.clip_by_norm(x, max_norm=1)
+        >>> print(out)
+        [[0.16650201 0.02712224 0.00144652]
+         [0.14695495 0.07773139 0.0105063 ]
+         [0.8826814  0.0554626  0.40198016]]
+    """
+    is_tensor = False
+    if isinstance(x, Tensor):
+        x = [x]
+        is_tensor = True
+    total_norm = _cal_total_norm(x, norm_type)
+    if error_if_nonfinite and F.logical_or(total_norm.isnan(), total_norm.isinf()):
+        raise RuntimeError(f"For clip_by_norm, the total norm of order {norm_type} from input is non-finite.")
+    clip_coef = max_norm / (total_norm + 1e-6)
+    if clip_coef < 1:
+        ret = hyper_map(partial_op(F.mul, clip_coef), x)
+    else:
+        ret = x
+    if is_tensor:
+        return ret[0]
+    return ret
+
+
 def clip_by_value(x, clip_value_min=None, clip_value_max=None):
     r"""
     Clips tensor values to a specified min and max.
@@ -74,8 +141,8 @@ def clip_by_value(x, clip_value_min=None, clip_value_max=None):
     Args:
           x (Union(Tensor, list[Tensor], tuple[Tensor])): Input data, which type is Tensor or a list or tuple of Tensor.
             Tensors of arbitrary dimensions are supported.
-          clip_value_min (Union(Tensor, float, int)): The minimum value. Default: None.
-          clip_value_max (Union(Tensor, float, int)): The maximum value. Default: None.
+          clip_value_min (Union(Tensor, float, int)): The minimum value. Default: ``None`` .
+          clip_value_max (Union(Tensor, float, int)): The maximum value. Default: ``None`` .
 
     Returns:
           (Union(Tensor, tuple[Tensor], list[Tensor])), a clipped Tensor or a tuple or a list of clipped Tensor.
@@ -115,6 +182,7 @@ def clip_by_value(x, clip_value_min=None, clip_value_max=None):
         [[ 5. 20.  5.  7.]
          [ 5. 11.  6. 20.]]
     """
+
     def _clip_by_value(clip_min, clip_max, x):
         if not isinstance(x, Tensor):
             raise TypeError("For 'clip_by_value', the type of argument 'x' must be "
@@ -161,7 +229,7 @@ def clamp(input, min=None, max=None):
 
         out_i= \left\{
         \begin{array}{align}
-            max & \text{ if } x_i\ge  max \\
+            max & \text{ if } x_i\ge max \\
             x_i & \text{ if } min \lt x_i \lt max \\
             min & \text{ if } x_i \le min \\
         \end{array}\right.
@@ -176,8 +244,8 @@ def clamp(input, min=None, max=None):
     Args:
           input (Union(Tensor, list[Tensor], tuple[Tensor])): Input data, which type is Tensor or a list or tuple of
             Tensor. Tensors of arbitrary dimensions are supported.
-          min (Union(Tensor, float, int), optional): The minimum value. Default: None.
-          max (Union(Tensor, float, int), optional): The maximum value. Default: None.
+          min (Union(Tensor, float, int), optional): The minimum value. Default: ``None`` .
+          max (Union(Tensor, float, int), optional): The maximum value. Default: ``None`` .
 
     Returns:
           Union(Tensor, tuple[Tensor], list[Tensor]), a clipped Tensor or a tuple or a list of clipped Tensor.
@@ -193,23 +261,23 @@ def clamp(input, min=None, max=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> # case 1: the data type of x is Tensor
+        >>> # case 1: the data type of input is Tensor
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> import numpy as np
         >>> min_value = Tensor(5, mindspore.float32)
         >>> max_value = Tensor(20, mindspore.float32)
-        >>> x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> output = ops.clamp(x, min_value, max_value)
+        >>> input = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
+        >>> output = ops.clamp(input, min_value, max_value)
         >>> print(output)
         [[ 5. 20.  5.  7.]
          [ 5. 11.  6. 20.]]
-        >>> # case 2: the data type of x is list[Tensor]
+        >>> # case 2: the data type of input is list[Tensor]
         >>> min_value = 5
         >>> max_value = 20
-        >>> x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> y = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> output = ops.clamp([x,y], min_value, max_value)
+        >>> input_x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
+        >>> input_y = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
+        >>> output = ops.clamp([input_x,input_y], min_value, max_value)
         >>> for out in output:
         ...     print(out)
         [[ 5. 20.  5.  7.]
@@ -220,14 +288,14 @@ def clamp(input, min=None, max=None):
     return clip_by_value(input, min, max)
 
 
-def clip(x, min=None, max=None):
+def clip(input, min=None, max=None):
     r"""
     Alias for :func:`mindspore.ops.clamp` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
     """
-    return clamp(x, min, max)
+    return clamp(input, min, max)
 
 
 @get_square_sum.register("Tensor")
@@ -251,7 +319,7 @@ class _ClipByGlobalNorm(Cell):
 
     Args:
         clip_norm (Union(float, int)): The clipping ratio. Default: 1.0
-        use_norm (Union(float, None)): The global norm. Default: None
+        use_norm (Union(float, None)): The global norm. Default: ``None``
 
     Inputs:
         - **x** (Union(tuple[Tensor], list[Tensor])) - Input data to clip.
@@ -281,10 +349,9 @@ class _ClipByGlobalNorm(Cell):
         return clip_x
 
 
-@constexpr
+@_primexpr
 def _check_value(clip_norm):
     Validator.check_number("clip_norm", clip_norm, 0.0, Validator.GT, "clip_by_global_norm")
-    return clip_norm
 
 
 def clip_by_global_norm(x, clip_norm=1.0, use_norm=None):
@@ -299,8 +366,8 @@ def clip_by_global_norm(x, clip_norm=1.0, use_norm=None):
 
     Args:
         x (Union(tuple[Tensor], list[Tensor])): Input data to clip.
-        clip_norm (Union(float, int)): The clipping ratio, it should be greater than 0. Default: 1.0
-        use_norm (None): The global norm. Default: None. Currently only none is supported.
+        clip_norm (Union(float, int)): The clipping ratio, it should be greater than 0. Default: ``1.0`` .
+        use_norm (None): The global norm. Default: ``None`` . Currently only none is supported.
 
     Returns:
         tuple[Tensor], a clipped Tensor. It has the same data type as `x` and each Tensor in the output tuple is the
@@ -324,6 +391,6 @@ def clip_by_global_norm(x, clip_norm=1.0, use_norm=None):
          [ 4.47213590e-01,  1.49071202e-01]]))
     """
 
-    clip_norm = _check_value(clip_norm)
+    _check_value(clip_norm)
     clip_val = _ClipByGlobalNorm(clip_norm, use_norm)(x)
     return clip_val

mindspore/ops/function/debug_func.py

@@ -34,7 +34,7 @@ def print_(*input_x):
         This function is used for debugging. When too much data is printed at the same time,
         in order not to affect the main process, the framework may discard some data. If you need to record the
         data completely, you are recommended to use the `Summary` function, and can check
-        `Summary <https://www.mindspore.cn/mindinsight/docs/en/r2.0/summary_record.html>`_.
+        `Summary <https://www.mindspore.cn/mindinsight/docs/en/r2.2/summary_record.html>`_.
 
     Args:
         input_x (Union[Tensor, bool, int, float, str, tuple, list]): The inputs of print_.
@@ -50,6 +50,8 @@ def print_(*input_x):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
         >>> x = Tensor(np.ones([2, 1]).astype(np.int32))
         >>> y = Tensor(np.ones([2, 2]).astype(np.int32))
         >>> result = ops.print_('Print Tensor x and Tensor y:', x, y)

mindspore/ops/function/grad/grad_func.py

@@ -22,15 +22,14 @@ from mindspore.common import Tensor
 from mindspore.common import dtype as mstype
 from mindspore.nn.cell import Cell
 from mindspore.nn.grad.cell_grad import _LinearizeInner
-from mindspore.ops.primitive import constexpr
-from mindspore.ops.function.array_func import ones, expand_dims, size, reshape, broadcast_to, transpose
+from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore.ops.function.array_func import ones, expand_dims, size, reshape, broadcast_to, transpose, zeros
 from mindspore.ops.composite import _Vmap, _Grad, _TaylorOperation, GradOperation
 from mindspore.ops import operations as P
 from mindspore.ops.operations import _inner_ops as inner
 
 cast = P.Cast()
 dtype = P.DType()
-zeros = P.Zeros()
 oneslike = P.OnesLike()
 
 
@@ -108,24 +107,24 @@ def grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
             If int, get the gradient with respect to single input.
             If tuple, get the gradients with respect to selected inputs. `grad_position` begins with 0.
             If None, none derivative of any input will be figured out, and in this case, `weights` is required.
-            Default: 0.
+            Default: ``0`` .
         weights (Union[ParameterTuple, Parameter, list[Parameter]]): The parameters of the training network that need to
             calculate the gradient. `weights` can be got through `weights = net.trainable_params()` .
-            Default: None.
-        has_aux (bool): If True, only the first output of `fn` contributes the gradient of `fn`, while the other outputs
-            will be returned straightly. It means the `fn` must return more than one outputs in this case.
-            Default: False.
+            Default: ``None`` .
+        has_aux (bool): If ``True`` , only the first output of `fn` contributes the gradient of `fn`, while the other
+            outputs will be returned straightly. It means the `fn` must return more than one outputs in this case.
+            Default: ``False`` .
         return_ids(bool): Whether return the tuple made by gradients and the index to specify which inputs
             to be differentiated or the name of parameters of the training network that need to calculate the gradient.
-            If True, the output gradients will be replaced by the tuples made by gradients and the index to specify
+            If ``True`` , the output gradients will be replaced by the tuples made by gradients and the index to specify
             which inputs to be differentiated or the name of parameters of the training network.
-            Default: False.
+            Default: ``False`` .
 
     Returns:
         Function, the gradient function to calculate gradient for the input function or cell.
-        For example, as for `out1, out2 = fn(*args)`, when `has_aux` is set True, gradient function will return outputs
-        like `(gradient, out2)` and `out2` does not contribute to the differentiation, otherwise `gradient`.
-        When return_ids is set to True, The format of the output will be the same with the output of grad when
+        For example, as for `out1, out2 = fn(*args)`, when `has_aux` is set ``True`` , gradient function will return
+        outputs like `(gradient, out2)` and `out2` does not contribute to the differentiation, otherwise `gradient`.
+        When return_ids is set to ``True`` , The format of the output will be the same with the output of grad when
         return_ids is set to false, but every gradient in the output will be replaced by a tuple of position id or
         parameter name and its gradient.
 
@@ -139,9 +138,7 @@ def grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
     Examples:
         >>> import numpy as np
         >>> import mindspore
-        >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore import grad
+        >>> from mindspore import Tensor, ops, nn, grad
         >>>
         >>> # Cell object to be differentiated
         >>> class Net(nn.Cell):
@@ -250,13 +247,13 @@ def value_and_grad(fn, grad_position=0, weights=None, has_aux=False):
             If int, get the gradient with respect to single input.
             If tuple, get the gradients with respect to selected inputs. `grad_position` begins with 0.
             If None, none derivative of any input will be solved, and in this case, `weights` is required.
-            Default: 0.
+            Default: ``0`` .
         weights (Union[ParameterTuple, Parameter, list[Parameter]]): The parameters of the training network that need to
             calculate the gradient. `weights` can be got through `weights = net.trainable_params()` .
-            Default: None.
-        has_aux (bool): If True, only the first output of `fn` contributes the gradient of `fn`, while the other outputs
-            will be returned straightly. It means the `fn` must return more than one outputs in this case.
-            Default: False.
+            Default: ``None`` .
+        has_aux (bool): If ``True`` , only the first output of `fn` contributes the gradient of `fn`, while the other
+            outputs will be returned straightly. It means the `fn` must return more than one outputs in this case.
+            Default: ``False`` .
 
     Returns:
         Function, returns the gradient function to calculate forward output and gradient for the input function or cell.
@@ -385,10 +382,8 @@ def get_grad(gradients, identifier):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
         >>> import mindspore
-        >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor, ops
+        >>> from mindspore import Tensor, nn
         >>> from mindspore import grad, get_grad
         >>>
         >>>  # Cell object to be differentiated
@@ -659,7 +654,8 @@ def _check_jvp_input_v_len(inputs_len, v_len):
 def jvp(fn, inputs, v, has_aux=False):
     """
     Compute the jacobian-vector-product of the given network. `jvp` matches
-    `forward-mode differentiation <https://www.mindspore.cn/docs/en/r2.0/design/auto_gradient.html#forward-mode-ad>`_.
+    `forward-mode differentiation
+    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#forward-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -667,16 +663,17 @@ def jvp(fn, inputs, v, has_aux=False):
         inputs (Union[Tensor, tuple[Tensor], list[Tensor]]): The inputs to `fn` .
         v (Union[Tensor, tuple[Tensor], list[Tensor]]): The vector in jacobian-vector-product. The shape and type of `v`
             should be the same as `inputs` .
-        has_aux (bool): If True, only the first output of `fn` contributes the gradient of `fn`, while the other outputs
-            will be returned straightly. It means the `fn` must return more than one outputs in this case.
-            Default: False.
+        has_aux (bool): If ``True`` , only the first output of `fn` contributes the gradient of `fn`, while the other
+            outputs will be returned straightly. It means the `fn` must return more than one outputs in this case.
+            Default: ``False`` .
 
     Returns:
         - **net_output** (Union[Tensor, tuple[Tensor]]) - The output of `fn(inputs)` . Specially, when `has_aux` is set
-          True, `netout` is the first output of `fn(inputs)` .
+          ``True`` , `netout` is the first output of `fn(inputs)` .
         - **jvp** (Union[Tensor, tuple[Tensor]]) - The result of jacobian-vector-product.
-        - **aux_value** (Union[Tensor, tuple[Tensor]], optional) - When `has_aux` is True, `aux_value` will be returned.
-          It means the second to last outputs of `fn(inputs)` . Specially, `aux_value` does not contribute to gradient.
+        - **aux_value** (Union[Tensor, tuple[Tensor]], optional) - When `has_aux` is ``True`` , `aux_value` will be
+          returned. It means the second to last outputs of `fn(inputs)` . Specially, `aux_value` does not contribute to
+          gradient.
 
     Raises:
         TypeError: `inputs` or `v` does not belong to required types.
@@ -865,18 +862,26 @@ def _check_tensor(inputs):
     return True
 
 
-def vjp(fn, *inputs, has_aux=False):
+_vjp_grad_op = _Grad(get_all=True, sens_param=True, merge_forward=True)
+_vjp_grad_op_with_weight = _Grad(get_all=True, get_by_list=True, sens_param=True, merge_forward=True)
+
+
+def vjp(fn, *inputs, weights=None, has_aux=False):
     """
     Compute the vector-jacobian-product of the given network. `vjp` matches
-    `reverse-mode differentiation <https://www.mindspore.cn/docs/en/r2.0/design/auto_gradient.html#reverse-mode-ad>`_.
+    `reverse-mode differentiation
+    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#reverse-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
             Tensors.
         inputs (Union[Tensor, tuple[Tensor], list[Tensor]]): The inputs to `fn` .
+        weights (Union[ParameterTuple, Parameter, list[Parameter]]): The parameters of the training network that need to
+            calculate the gradient. `weights` can be got through `weights = net.trainable_params()` .
+            Default: ``None`` .
         has_aux (bool): If True, only the first output of `fn` contributes the gradient of `fn`, while the other outputs
             will be returned straightly. It means the `fn` must return more than one outputs in this case.
-            Default: False.
+            Default: ``False``.
 
     Returns:
         Forward outputs and function to calculate vjp.
@@ -949,9 +954,12 @@ def vjp(fn, *inputs, has_aux=False):
             fn_ = aux_fn
         else:
             fn_ = fn
+        sens = v
         if len(v) == 1:
-            return _grad_all(fn_)(*inputs, v[0])
-        return _grad_all(fn_)(*inputs, v)
+            sens = v[0]
+        if weights is None:
+            return _vjp_grad_op(fn_)(*inputs, sens)
+        return _vjp_grad_op_with_weight(fn_, weights)(*inputs, sens)
 
     res = fn(*inputs)
     if has_aux:
@@ -961,10 +969,13 @@ def vjp(fn, *inputs, has_aux=False):
     return res, wrap_container
 
 
-@constexpr
+@_primexpr
 def _jac_generate_target_dimension(x):
     """For given length = len(x), this method generates target dimension tuple (1, 2, 3,..., length, 0)."""
-    target_dimension = tuple(index + 1 for index, _ in enumerate(x[1:])) + (0,)
+    dim = ()
+    for index in range(len(x[1:])):
+        dim += (index + 1,)
+    target_dimension = dim + (0,)
     return target_dimension
 
 
@@ -1009,11 +1020,7 @@ def _jac_postprocess(x, shape, grad_position, mode):
     for i in range(output_num):
         input_grad = ()
         for j in range(input_num):
-            if mode == 'forward':
-                grad_increment = (res[i * input_num + j],)
-            else:
-                grad_increment = (res[j * output_num + i],)
-            input_grad += grad_increment
+            input_grad += (res[i * input_num + j],) if mode == 'forward' else (res[j * output_num + i],)
         jac += (input_grad,)
     return jac
 
@@ -1060,22 +1067,23 @@ _vmap = _Vmap()
 def jacfwd(fn, grad_position=0, has_aux=False):
     """
     Compute Jacobian via forward mode, corresponding to
-    `forward-mode differentiation <https://www.mindspore.cn/docs/en/r2.0/design/auto_gradient.html#forward-mode-ad>`_.
+    `forward-mode differentiation
+    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#forward-mode-ad>`_.
     When number of outputs is much greater than that of inputs, it's better to calculate Jacobian via forward mode than
     reverse mode to get better performance.
 
     Args:
         fn (Union[Cell, Function]): Function to do GradOperation.
         grad_position (Union[int, tuple[int]], optional): If int, get the gradient with respect to single input.
-            If tuple, get the gradients with respect to selected inputs. 'grad_position' begins with 0. Default: 0.
-        has_aux (bool, optional): If True, only the first output of `fn` contributes the gradient of `fn`,
+            If tuple, get the gradients with respect to selected inputs. 'grad_position' begins with 0. Default: ``0`` .
+        has_aux (bool, optional): If ``True`` , only the first output of `fn` contributes the gradient of `fn`,
             while the other outputs will be returned straightly. It means the `fn` must return more than one
-            outputs in this case. Default: False.
+            outputs in this case. Default: ``False`` .
 
     Returns:
         Function, returns the Jacobian function for the input function or cell.
-        For example, as for `out1, out2 = fn(*args)`, when `has_aux` is set True, gradient function will return outputs
-        like `(Jacobian, out2)` and `out2` does not contribute to the differentiation, otherwise `Jacobian` .
+        For example, as for `out1, out2 = fn(*args)`, when `has_aux` is set ``True`` , gradient function will return
+        outputs like `(Jacobian, out2)` and `out2` does not contribute to the differentiation, otherwise `Jacobian` .
 
     Raises:
         TypeError: `grad_position` or `has_aux` does not belong to required types.
@@ -1097,14 +1105,14 @@ def jacfwd(fn, grad_position=0, has_aux=False):
         >>> net = MultipleInputsMultipleOutputsNet()
         >>> jac, aux = jacfwd(net, grad_position=0, has_aux=True)(x, y, z)
         >>> print(jac)
-        [[[[ 2.,  0.]
-           [ 0.,  0.]]
-          [[ 0.,  4.]
-           [ 0.,  0.]]]
-         [[[ 0.,  0.]
-           [ 6.,  0.]]
-          [[ 0.,  0.]
-           [ 0.,  8.]]]]
+        [[[[ 2.  0.]
+           [ 0.  0.]]
+          [[ 0.  4.]
+           [ 0.  0.]]]
+         [[[ 0.  0.]
+           [ 6.  0.]]
+          [[ 0.  0.]
+           [ 0.  8.]]]]
         >>> print(aux)
         [[ 1.  4.]
          [ 9. 16.]]
@@ -1230,22 +1238,23 @@ _grad = _Grad(get_by_position=True, has_aux=False, sens_param=True)
 def jacrev(fn, grad_position=0, has_aux=False):
     """
     Compute Jacobian via reverse mode, corresponding to
-    `reverse-mode differentiation <https://www.mindspore.cn/docs/en/r2.0/design/auto_gradient.html#reverse-mode-ad>`_.
+    `reverse-mode differentiation
+    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#reverse-mode-ad>`_.
     When number of inputs is much greater than that of outputs, it's better to calculate Jacobian via reverse mode than
     forward mode to get better performance.
 
     Args:
         fn (Union[Cell, Function]): Function to do GradOperation.
         grad_position (Union[int, tuple[int]], optional): If int, get the gradient with respect to single input.
-            If tuple, get the gradients with respect to selected inputs. 'grad_position' begins with 0. Default: 0.
-        has_aux (bool, optional): If True, only the first output of `fn` contributes the gradient of `fn`,
+            If tuple, get the gradients with respect to selected inputs. 'grad_position' begins with 0. Default: ``0`` .
+        has_aux (bool, optional): If ``True`` , only the first output of `fn` contributes the gradient of `fn`,
             while the other outputs will be returned straightly. It means the `fn` must return more than
-            one outputs in this case. Default: False.
+            one outputs in this case. Default: ``False`` .
 
     Returns:
         Function, returns the Jacobian function for the input function or cell.
-        For example, as for `out1, out2 = fn(*args)`, when `has_aux` is set True, gradient function will return outputs
-        like `(Jacobian, out2)` and `out2` does not contribute to the differentiation, otherwise `Jacobian` .
+        For example, as for `out1, out2 = fn(*args)`, when `has_aux` is set ``True`` , gradient function will return
+        outputs like `(Jacobian, out2)` and `out2` does not contribute to the differentiation, otherwise `Jacobian` .
 
     Raises:
         TypeError: `grad_position` or `has_aux` does not belong to required types.
@@ -1267,14 +1276,14 @@ def jacrev(fn, grad_position=0, has_aux=False):
         >>> net = MultipleInputsMultipleOutputsNet()
         >>> jac, aux = jacrev(net, grad_position=0, has_aux=True)(x, y, z)
         >>> print(jac)
-        [[[[ 2.,  0.]
-           [ 0.,  0.]]
-          [[ 0.,  4.]
-           [ 0.,  0.]]]
-         [[[ 0.,  0.]
-           [ 6.,  0.]]
-          [[ 0.,  0.]
-           [ 0.,  8.]]]]
+        [[[[ 2.  0.]
+           [ 0.  0.]]
+          [[ 0.  4.]
+           [ 0.  0.]]]
+         [[[ 0.  0.]
+           [ 6.  0.]]
+          [[ 0.  0.]
+           [ 0.  8.]]]]
         >>> print(aux)
         [[ 1.  4.]
          [ 9. 16.]]
@@ -1322,7 +1331,7 @@ def custom_vjp(fn=None):
     Support vjp to custom bprop for function.
 
     Args:
-        fn (function): The `fn` that need to define custom bprop. Default: None.
+        fn (function): The `fn` that need to define custom bprop. Default: ``None``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1361,7 +1370,7 @@ def stop_gradient(value):
     StopGradient is used for eliminating the effect of a value on the gradient, such as truncating
     the gradient propagation from an output of a function.
     For more details, please refer to `Stop Gradient
-    <https://www.mindspore.cn/tutorials/en/r2.0/beginner/autograd.html#stop-gradient>`_.
+    <https://www.mindspore.cn/tutorials/en/r2.2/beginner/autograd.html#stop-gradient>`_.
 
     Args:
         value (Any): The value whose effect on the gradient to be eliminated.