mindspore 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0__cp311-cp311-win_amd64.whl

mindspore/ops/function/clip_func.py

@@ -66,18 +66,20 @@ def _cal_total_norm(x, norm_type):
 
 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.
+    The input Tensor is cropped based on norm. The computation is done by concatenating the norms of
+    all the input elementsinto a vector and then computing the norm of that vector.
+    The Tensor gradient value corresponding to the `identifier`.
 
     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`` .
+        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], optional): Norm type. Default: ``2.0``.
+        error_if_nonfinite (bool, optional): 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.
@@ -224,9 +226,7 @@ def clip_by_value(x, clip_value_min=None, clip_value_max=None):
 
 def clamp(input, min=None, max=None):
     r"""
-    Clamps tensor values between the specified minimum value and maximum value.
-
-    Limits the value of :math:`input` to a range, whose lower limit is `min` and upper limit is `max` .
+    Clamp all elements of the input tensor within the range [min, max].
 
     .. math::
 
@@ -239,41 +239,37 @@ def clamp(input, min=None, max=None):
 
     Note:
         - `min` and `max` cannot be None at the same time;
-        - When `min` is None and `max` is not None, the elements in Tensor larger than `max` will become `max`;
-        - When `min` is not None and `max` is None, the elements in Tensor smaller than `min` will become `min`;
+        - If `min` is ``None`` , there is no lower bound.
+        - if `max` is ``None`` , there is no upper bound.
         - If `min` is greater than `max`, the value of all elements in Tensor will be set to `max`;
-        - The data type of `input`, `min` and `max` should support implicit type conversion and cannot be bool type.
 
     Args:
-          input (Tensor): Input data, which type is 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`` .
+          input (Tensor): The input tensor.
+          min (Union(Tensor, float, int), optional): The minimum value. Default ``None`` .
+          max (Union(Tensor, float, int), optional): The maximum value. Default ``None`` .
 
     Returns:
-          Tensor, a clipped Tensor.
-          The data type and shape are the same as input.
-
-    Raises:
-          ValueError: If both `min` and `max` are None.
-          TypeError: If the type of `input` is not in Tensor.
-          TypeError: If the type of `min` is not in None, Tensor, float or int.
-          TypeError: If the type of `max` is not in None, Tensor, float or int.
+          Tensor
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> # 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)
-        >>> 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 1: `min` and `max` are integer
+        >>> input = mindspore.tensor([[1, 25, 5, 7], [4, 11, 6, 21]])
+        >>> mindspore.ops.clamp(input, 5, 20)
+        Tensor(shape=[2, 4], dtype=Int64, value=
+        [[ 5, 20,  5,  7],
+         [ 5, 11,  6, 20]])
+        >>>
+        >>> # case 2: If `min` and `max` are tensors, their shapes need to be broadcastable with input.
+        >>> min = mindspore.tensor([2, 4, 6, 8])
+        >>> max = mindspore.tensor([10, 12, 14, 18])
+        >>> mindspore.ops.clamp(input, min, max)
+        Tensor(shape=[2, 4], dtype=Int64, value=
+        [[ 2, 12,  6,  8],
+         [ 4, 11,  6, 18]])
     """
     if isinstance(min, Tensor) or isinstance(max, Tensor):
         return clamp_tensor(input, min, max)
@@ -411,30 +407,27 @@ def clip_by_global_norm(x, clip_norm=1.0, use_norm=None):
     Clips tensor values by the ratio of the sum of their norms.
 
     Note:
-        - Input `x` should be a tuple or list of tensors. Otherwise, it will raise an error.
         - On the SEMI_AUTO_PARALLEL mode or AUTO_PARALLEL mode, if the input `x` is the gradient,
           the gradient norm values on all devices will be automatically aggregated by allreduce inserted after
           the local square sum of the gradients.
 
     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. Currently only none is supported. Default ``None`` .
 
     Returns:
-        tuple[Tensor], a clipped Tensor. It has the same data type as `x` and each Tensor in the output tuple is the
-        same as the original input shape.
+        Tuple of tensors
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import Tensor, ops
-        >>> import numpy as np
-        >>> x1 = np.array([[2., 3.], [1., 2.]]).astype(np.float32)
-        >>> x2 = np.array([[1., 4.], [3., 1.]]).astype(np.float32)
-        >>> input_x = (Tensor(x1), Tensor(x2))
-        >>> out = ops.clip_by_global_norm(input_x, 1.0)
+        >>> import mindspore
+        >>> x1 = mindspore.tensor([[2., 3.], [1., 2.]], dtype=mindspore.float32)
+        >>> x2 = mindspore.tensor([[1., 4.], [3., 1.]], dtype=mindspore.float32)
+        >>> input_x = (x1, x2)
+        >>> out = mindspore.ops.clip_by_global_norm(input_x, 1.0)
         >>> print(out)
         (Tensor(shape=[2, 2], dtype=Float32, value=
         [[ 2.98142403e-01,  4.47213590e-01],

mindspore/ops/function/debug_func.py

@@ -23,9 +23,9 @@ from .._primitive_cache import _get_cache_prim
 
 def print_(*input_x):
     """
-    Outputs the inputs to stdout. The outputs are printed to screen by default.
+    Outputs the inputs to stdout.
+    The outputs are printed to screen by default.
     It can also be saved in a file by setting the parameter  `print_file_path` in `context`.
-    Once set, the output will be saved in the file specified by print_file_path.
     :func:`mindspore.parse_print` can be employed to reload the data.
     For more information, please refer to :func:`mindspore.set_context` and :func:`mindspore.parse_print`.
     In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
@@ -33,7 +33,7 @@ def print_(*input_x):
 
     Note:
         In pynative mode, please use python print function.
-        In Ascend platform with graph mode, the bool, int and float would be converted into Tensor to print, and
+        In Ascend platform with graph mode, the bool, int and float would be converted into tensor to print, and
         str remains unchanged.
         This function is used for debugging.
 
@@ -44,18 +44,14 @@ def print_(*input_x):
     Returns:
         Invalid value, should be ignored.
 
-    Raises:
-        TypeError: If `input_x` is not one of the following: Tensor, bool, int, float, str, tuple or list.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> 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)
+        >>> import mindspore
+        >>> x = mindspore.tensor(mindspore.ops.ones([2, 1], mindspore.int32))
+        >>> y = mindspore.tensor(mindspore.ops.ones([2, 2], mindspore.int32))
+        >>> result = mindspore.ops.print_('Print Tensor x and Tensor y:', x, y)
         Print Tensor x and Tensor y:
         Tensor(shape=[2, 1], dtype=Int32, value=
         [[1],
@@ -71,10 +67,10 @@ def print_(*input_x):
 
 def tensordump(file_name, tensor, mode='out'):
     """
-    Save Tensor in numpy's npy format.
+    Save tensor in npy format.
 
     .. warning::
-        - The parameter mode will no longer support the value 'all'.
+        - The parameter `mode` will no longer support the value 'all'.
 
     In Parallel situation, tensordump will dump slice of data at each rank.
     In Ascend platform with graph mode, Your code OpA --> OpB may compiled as OpA --> RedistributionOps --> OpB.
@@ -89,18 +85,18 @@ def tensordump(file_name, tensor, mode='out'):
     So the parameter mode is to handle this situation.
 
     Assuming OpA's output is used as both tensordump's input parameter and OpB's input parameter.
-    Different requirements of saving dump data can be achieved by configuring parameter mode:
+    Different requirements of saving dump data can be achieved by configuring parameter `mode` :
 
-    - If the mode is 'out', the dump data contains only OpA's output slice.
-    - If the mode is 'in', the dump data contains only OpB's input slice.
+    - If the `mode` is 'out', the dump data contains only OpA's output slice.
+    - If the `mode` is 'in', the dump data contains only OpB's input slice.
 
-    For mode 'in', the input slice npy file format is: fileName_dumpMode_dtype_id.npy.
+    For `mode` 'in', the input slice npy file format is: fileName_dumpMode_dtype_id.npy.
 
-    For mode 'out', the output slice npy file format is: filename_dtype_id.npy.
+    For `mode` 'out', the output slice npy file format is: fileName_dtype_id.npy.
 
     - fileName: Value of the parameter file_name
-      (if parameter file_name is a user-specified path, the value of fileName is the last level of the path).
-    - dumpMode: Value of the parameter mode.
+      (if parameter `file_name` is a user-specified path, the value of fileName is the last level of the path).
+    - dumpMode: Value of the parameter `mode`.
     - dtype: The original data type. Data of type bfloat16 stored in the .npy file will be converted to float32.
     - id: An auto increment ID.
 
@@ -108,21 +104,14 @@ def tensordump(file_name, tensor, mode='out'):
         - In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
           can be set to solve operator execution failure when outputting big tensor or outputting tensor intensively.
         - The operator of tensordump doesn't support in control flow.
-        - If current parallel mode is STAND_ALONE, mode should only be 'out'.
-        - Parameter mode will be set to 'out' if user doesn't configure it.
+        - If current parallel mode is STAND_ALONE, `mode` should only be 'out'.
         - This function is used for debugging.
 
     Args:
         file_name (str): The path of the npy file saves.
         tensor (Tensor): The tensor that user want to dump.
         mode (str, optional): Used to control tensordump behavior, available value is one of ['in', 'out'].
-            Default value is ``out``.
-
-    Raises:
-        TypeError: If `file_name` is not str.
-        TypeError: If `tensor` is not Tensor.
-        TypeError: If `mode` is not str.
-        ValueError: If `mode` is not in one of ['in', 'out'].
+            Default ``out`` .
 
     Supported Platforms:
         ``Ascend``
@@ -134,38 +123,41 @@ def tensordump(file_name, tensor, mode='out'):
 
         >>> import os
         >>> import numpy as np
-        >>> import mindspore as ms
-        >>> from mindspore import nn, Tensor, ops, context
-        >>> from mindspore.ops import operations as P
+        >>> import mindspore
+        >>> from mindspore import nn, context
         >>> from mindspore.communication import init, get_rank
+        >>> from mindspore.parallel.auto_parallel import AutoParallel
+        >>> from mindspore.nn.utils import no_init_parameters
         >>> init()
         >>> rank_id = get_rank()
-        >>> dump_path = f'dumps/rank_{rank_id}/mul1_mul2.npy'
+        >>> dump_path = f'rank_{rank_id}_mul1_mul2.npy'
         >>> class Net(nn.Cell):
         ...     def __init__(self, strategy1, strategy2):
         ...         super(Net, self).__init__()
-        ...         self.matmul1 = P.MatMul().shard(strategy1)
-        ...         self.matmul2 = P.MatMul().shard(strategy2)
+        ...         self.matmul1 = mindspore.ops.MatMul().shard(strategy1)
+        ...         self.matmul2 = mindspore.ops.MatMul().shard(strategy2)
         ...
         ...     def construct(self, x, y, b):
         ...         out1 = self.matmul1(x, y)
-        ...         ops.tensordump(dump_path, out1, 'out')
+        ...         mindspore.ops.tensordump(dump_path, out1, 'out')
         ...         out2 = self.matmul2(out1, b)
         ...         return out2
         ...
-        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> mindspore.set_context(mode=mindspore.GRAPH_MODE)
         >>> os.environ["MS_DEV_SAVE_GRAPHS"] = "2"
-        >>> context.set_auto_parallel_context(parallel_mode='semi_auto_parallel', full_batch=True)
         >>> strategy1 = ((1, 2), (2, 1))
         >>> strategy2 = ((1, 2), (2, 1))
-        >>> net = Net(strategy1, strategy2)
-        >>> x = Tensor(0.1 * np.random.randn(64, 64).astype(np.float32))
-        >>> y = Tensor(0.1 * np.random.randn(64, 64).astype(np.float32))
-        >>> b = Tensor(0.1 * np.random.randn(64, 64).astype(np.float32))
-        >>> out = net(x, y, b)
+        >>> with no_init_parameters():
+        >>>     net = Net(strategy1, strategy2)
+        >>> x = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
+        >>> y = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
+        >>> b = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
+        >>> parallel_net = Autoparallel(net, parallel_mode="semi_auto")
+        >>> parallel_net.dataset_strategy(config="full_batch")
+        >>> out = parallel_net(x, y, b)
         >>> print(f"out shape is: {out.shape}")
         >>> # out shape is (64, 64)
-        >>> matmul1_output_slice = np.load('dumps/rank_0/mul1_mul2_float32_0.npy')      # load matmul1's output slice
+        >>> matmul1_output_slice = np.load(f'rank_{rank_id}_mul1_mul2_float32_0.npy')      # load matmul1's output slice
         >>> print(f"matmul1_output_slice is loaded, shape is: {matmul1_output_slice.shape}")
         >>> # matmul1_output_slice is loaded, shape is: (64, 64)
     """

mindspore/ops/function/grad/__init__.py

@@ -27,6 +27,7 @@ from .grad_func import (
     vjp,
     linearize,
     stop_gradient,
+    stop_gradient_,
     get_grad
 )
 

mindspore/ops/function/grad/grad_func.py

@@ -22,12 +22,13 @@ 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.operations.other_ops import stop_gradient_
+from mindspore.ops.operations.other_ops import stop_gradient_op
 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
+from mindspore.ops.auto_generate.gen_ops_prim import inplace_stop_gradient_op
 
 cast = P.Cast()
 dtype = P.DType()
@@ -103,11 +104,13 @@ def grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
 
     Args:
         fn (Union[Cell, Function]): Function to do GradOperation.
-        grad_position (Union[NoneType, int, tuple[int]]): Index to specify which inputs to be differentiated.
-            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`` .
+        grad_position (Union[NoneType, int, tuple[int]]):
+            Index to specify which inputs to be differentiated. Default: ``0`` .
+
+            - 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.
+
         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`` .
@@ -237,36 +240,43 @@ def value_and_grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=
 
     As for gradient, three typical cases are included:
 
-    1. gradient with respect to inputs. In this case, `grad_position` is not None while `weights` is None.
-    2. gradient with respect to weights. In this case, `grad_position` is None while `weights` is not None.
-    3. gradient with respect to inputs and weights. In this case, `grad_position` and `weights` are not None.
+    1. gradient with respect to inputs. In this case, `grad_position` is not None while `weights` is ``None``.
+    2. gradient with respect to weights. In this case, `grad_position` is None while `weights` is not ``None``.
+    3. gradient with respect to inputs and weights. In this case, `grad_position` and `weights` are not ``None``.
 
     Args:
         fn (Union[Cell, Function]): Function to do GradOperation.
-        grad_position (Union[NoneType, int, tuple[int]]): Index to specify which inputs to be differentiated.
-            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`` .
-        weights (Union[ParameterTuple, Parameter, list[Parameter]]): The parameters of the training network that need to
+        grad_position (Union[NoneType, int, tuple[int]], optional): Index to specify which inputs
+            to be differentiated. Default: ``0`` .
+
+            - 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.
+
+        weights (Union[ParameterTuple, Parameter, list[Parameter]], optional):
+            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
+        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`` .
-        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
-            which inputs to be differentiated or the name of parameters of the training network.
+        return_ids(bool, optional): Whether the returned derivation function contains
+            `grad_position` or `weights` information. If ``True``,
+            all gradient values in the returned derivation function will be replaced
+            with: [gradient, grad_position] or [gradient, weights].
             Default: ``False`` .
 
     Returns:
-        Function, returns the gradient function to calculate forward output and gradient for the input function or cell.
+        Function, the derivative function used to compute the gradient of a given function.
         For example, as for `out1, out2 = fn(*args)` , gradient function will return outputs like
-        `((out1, out2), gradient)` . When `has_aux` is set to ``True``, only `out1` contributes to the differentiation.
+        `((out1, out2), gradient)` . When `has_aux` is set to ``True``,
+        only `out1` contributes to the differentiation. If `return_ids` is ``True``,
+        all gradient values in the returned derivation function will be replaced
+        with: [gradient, grad_position] or [gradient, weights].
 
     Raises:
-        ValueError: If both `grad_position` and `weights` are None.
+        ValueError: If both `grad_position` and `weights` are ``None``.
         TypeError: If type of Args does not belong to required ones.
 
     Supported Platforms:
@@ -378,10 +388,10 @@ def get_grad(gradients, identifier):
             :func:`mindspore.grad`.
 
     Returns:
-        The gradient of the tensor on the position or in the parameter that specified by the `identifier`.
+        The Tensor gradient value corresponding to the `identifier`.
 
     Raises:
-        RuntimeError: If gradient is not found.
+        RuntimeError: If gradient value corresponding to the `identifier` is not found.
         TypeError: If type of Args does not belong to required ones.
 
     Supported Platforms:
@@ -457,49 +467,42 @@ def jet(fn, primals, series):
     while the other to 0, which is like the derivative of origin input with respect to itself.
 
     Note:
-        If `primals` is Tensor of int type, it will be converted to Tensor of float type.
+        If `primals` is tensor of int type, it will be converted to Tensor of float type.
 
     Args:
         fn (Union[Cell, function]): Function to do TaylorOperation.
         primals (Union[Tensor, tuple[Tensor]]): The inputs to `fn`.
-        series (Union[Tensor, tuple[Tensor]]): If tuple, the length and type of series should be the same as inputs.
-            For each Tensor, the length of first dimension `i` represents the `1` to `i+1`-th order of derivative of
-            output with respect to the inputs will be figured out.
+        series (Union[Tensor, tuple[Tensor]]): The original 1st to nth order derivatives of the input.
+            The index `i` of the zeroth dimension of the tensor corresponds to the `i+1` -th order derivative of the
+            output with respect to the input.
 
     Returns:
-        Tuple, tuple of out_primals and out_series.
+        Tuple(out_primals, out_series)
 
         - **out_primals** (Union[Tensor, list[Tensor]]) - The output of `fn(primals)`.
-        - **out_series** (Union[Tensor, list[Tensor]]) - The `1` to `i+1`-th order of derivative of output with respect
+        - **out_series** (Union[Tensor, list[Tensor]]) - The `1` to `i+1` -th order of derivative of output with respect
           to the inputs.
 
-    Raises:
-        TypeError: If `primals` is not a tensor or tuple of tensors.
-        TypeError: If type of `primals` is not the same as type of `series`.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> import mindspore.nn as nn
-        >>> import mindspore as ms
-        >>> from mindspore import ops
-        >>> from mindspore import Tensor
-        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> import mindspore
+        >>> from mindspore import nn
+        >>> mindspore.set_context(mode=mindspore.GRAPH_MODE)
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super().__init__()
-        ...         self.sin = ops.Sin()
-        ...         self.exp = ops.Exp()
+        ...         self.sin = mindspore.ops.Sin()
+        ...         self.exp = mindspore.ops.Exp()
         ...     def construct(self, x):
         ...         out1 = self.sin(x)
         ...         out2 = self.exp(out1)
         ...         return out2
-        >>> primals = Tensor(np.array([[1, 2], [3, 4]]).astype(np.float32))
-        >>> series = Tensor(np.array([[[1, 1], [1, 1]], [[0, 0], [0, 0]], [[0, 0], [0, 0]]]).astype(np.float32))
+        >>> primals = mindspore.tensor([[1, 2], [3, 4]], mindspore.float32)
+        >>> series = mindspore.tensor([[[1, 1], [1, 1]], [[0, 0], [0, 0]], [[0, 0], [0, 0]]], mindspore.float32)
         >>> net = Net()
-        >>> out_primals, out_series = ops.jet(net, primals, series)
+        >>> out_primals, out_series = mindspore.ops.jet(net, primals, series)
         >>> print(out_primals, out_series)
         [[2.319777  2.4825778]
          [1.1515628 0.4691642]] [[[ 1.2533808  -1.0331168 ]
@@ -567,49 +570,41 @@ def derivative(fn, primals, order):
     input first order derivative is set to 1, while the other to 0.
 
     Note:
-        If `primals` is Tensor of int type, it will be converted to Tensor of float type.
+        If `primals` is tensor of int type, it will be converted to tensor of float type.
 
     Args:
         fn (Union[Cell, function]): Function to do TaylorOperation.
         primals (Union[Tensor, tuple[Tensor]]): The inputs to `fn`.
-        order (int): For each Tensor, the `order`-th order of derivative of output with respect to the inputs will be
-            figured out.
+        order (int): The order of differentiation.
 
     Returns:
-        Tuple, tuple of out_primals and out_series.
+        Tuple(out_primals, out_series)
 
         - **out_primals** (Union[Tensor, list[Tensor]]) - The output of `fn(primals)`.
         - **out_series** (Union[Tensor, list[Tensor]]) - The `order`-th order of derivative of output with respect
           to the inputs.
 
-    Raises:
-        TypeError: If `primals` is not a tensor or tuple of tensors.
-        TypeError: If `order` is not int.
-        ValueError: If `order` is less than 1.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> import mindspore.nn as nn
-        >>> from mindspore import ops
-        >>> from mindspore import Tensor
-        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> import mindspore
+        >>> from mindspore import nn
+        >>> mindspore.set_context(mode=mindspore.GRAPH_MODE)
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super().__init__()
-        ...         self.sin = ops.Sin()
-        ...         self.exp = ops.Exp()
+        ...         self.sin = mindspore.ops.Sin()
+        ...         self.exp = mindspore.ops.Exp()
         ...     def construct(self, x):
         ...         out1 = self.sin(x)
         ...         out2 = self.exp(out1)
         ...         return out2
-        >>> primals = Tensor(np.array([[1, 2], [3, 4]]).astype(np.float32))
+        >>>
+        >>> primals = mindspore.tensor([[1, 2], [3, 4]], mindspore.float32)
         >>> order = 3
         >>> net = Net()
-        >>> out_primals, out_series = ops.derivative(net, primals, order)
+        >>> out_primals, out_series = mindspore.ops.derivative(net, primals, order)
         >>> print(out_primals, out_series)
         [[2.319777  2.4825778]
          [1.1515628 0.4691642]] [[-4.0515366   3.6724353 ]
@@ -677,7 +672,7 @@ def jvp(fn, inputs, v, has_aux=False):
         - **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)` .
         - **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
+        - **aux_value** (Union[Tensor, tuple[Tensor]], optional) - Only 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.
 
@@ -841,7 +836,7 @@ def linearize(fn, inputs):
     """
     linearize_inner = _LinearizeInner()
 
-    @jit(hash_args=fn)
+    @jit
     def _wrap_container(*arg):
         args = arg[1:-1]
         vectors = arg[-1]
@@ -882,10 +877,12 @@ def vjp(fn, *inputs, weights=None, has_aux=False):
         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
+        weights (Union[ParameterTuple, Parameter, list[Parameter]], optional):
+            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
+        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``.
 
@@ -1388,6 +1385,41 @@ def stop_gradient(value):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
+    Examples:
+        >>> import mindspore
+        >>> def f1(x):
+        ...     return x ** 2
+        >>> x = 3.0
+        >>> f1(x)
+        9.0
+        >>> mindspore.ops.grad(f1)(mindspore.tensor(x))
+        Tensor(shape=[], dtype=Float32, value= 6)
+        >>>
+        >>> # The same function with stop_gradient, return a zero gradient because x is effectively treated as a constant.
+        >>> def f2(x):
+        ...     return mindspore.ops.stop_gradient(x) ** 2
+        >>> f2(x)
+        9.0
+        >>> mindspore.ops.grad(f2)(mindspore.tensor(x))
+        Tensor(shape=[], dtype=Float32, value= 0)
+    """
+    return stop_gradient_op(value)
+
+
+def stop_gradient_(input):
+    """
+    StopGradient inplace
+
+    Args:
+        input (Tensor): input tensor
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        RuntimeError: If `input` is a view tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
     Examples:
         >>> from mindspore import ops
         >>> from mindspore import Tensor
@@ -1395,7 +1427,7 @@ def stop_gradient(value):
         >>> def net(x, y):
         ...     out1 = ops.MatMul()(x, y)
         ...     out2 = ops.MatMul()(x, y)
-        ...     out2 = ops.stop_gradient(out2)
+        ...     ops.stop_gradient_(out2)
         ...     return out1, out2
         ...
         >>> x = Tensor([[0.5, 0.6, 0.4], [1.2, 1.3, 1.1]], dtype=mstype.float32)
@@ -1406,7 +1438,7 @@ def stop_gradient(value):
         [[1.4100001 1.6       6.5999994]
          [1.4100001 1.6       6.5999994]]
     """
-    return stop_gradient_(value)
+    inplace_stop_gradient_op(input)
 
 
 __all__ = [
@@ -1420,6 +1452,7 @@ __all__ = [
     'vjp',
     'linearize',
     'stop_gradient',
+    'stop_gradient_',
     'get_grad'
 ]
 __all__.sort()